travis - jenkins tutorial
Recuperar la identificación del trabajo jenkins disparado de forma remota (5)
Estoy activando un Jenkins parametrizado desde fuera de jenkins a través de una solicitud HTTP POST:
He habilitado en la configuración del trabajo que el trabajo se puede desencadenar desde el exterior y realmente puedo desencadenarlo enviando una solicitud a jenkins con un contenido como este:
ENVIAR
http://myJenkins.com/myJob/buildWithParameters?token=MYTOKEN Parámetro: SCREEN_SIZE: 27
Al activar la creación de trabajos, se obtiene una respuesta http CREATED 201 exitosa.
Mi problema es que no sé el ID del trabajo de compilación que se creó. Quiero controlar el estado del trabajo. Para hacer eso necesito saber el id. De lo contrario, si tomo la última versión de ese trabajo, podría tomar el trabajo equivocado.
¿Hay una manera confiable de obtener la identificación del trabajo creado?
Desde Jenkins 1.519, la puesta en cola de una compilación responde con una URL en la Location , indicándole un elemento en la cola de compilación:
$ nc localhost 8666
POST /jenkins/job/morgRemote/buildWithParameters?jenkins_status=1&jenkins_sleep=20&token=morgRemote HTTP/1.1
Host: localhost:8666
HTTP/1.1 201 Created
Location: http://localhost:8666/jenkins/queue/item/39/
Content-Length: 0
Server: Jetty(winstone-2.8)
Ahora si agrega api/json (o api/xml y así sucesivamente) al final de la misma (por lo que en este ejemplo sería http://localhost:8666/jenkins/queue/item/39/api/json ) entonces obtendrá un documento que contendrá ID de compilación para el trabajo dado. Para json, el objeto recuperado tiene un atributo executable , que a su vez tiene atributos number y url . number es el id de compilación para el trabajo dado (35 aquí) y url es la url la página de compilación de jenkins.
{
"actions" : [
{
"parameters" : [
{
"name" : "jenkins_status",
"value" : "1"
},
{
"name" : "jenkins_sleep",
"value" : "20"
}
]
},
{
"causes" : [
{
"shortDescription" : "Started by remote host 127.0.0.1",
"addr" : "127.0.0.1",
"note" : null
}
]
}
],
"blocked" : false,
"buildable" : false,
"id" : 39,
"inQueueSince" : 1423993879845,
"params" : "/njenkins_status=1/njenkins_sleep=20",
"stuck" : false,
"task" : {
"name" : "morgRemote",
"url" : "http://localhost:8666/jenkins/job/morgRemote/",
"color" : "red"
},
"url" : "queue/item/39/",
"why" : null,
"cancelled" : false,
"executable" : {
"number" : 35,
"url" : "http://localhost:8666/jenkins/job/morgRemote/35/"
}
}
ser consciente de 2 cosas:
- los elementos inactivos en la cola de compilación se recolectan como basura después de unos minutos, por lo que debe recuperar la id.
- de forma predeterminada, toma unos segundos entre el elemento que se agrega a la cola hasta que obtiene el ID de compilación. Durante este tiempo,
executableatributosexecutableycanceledywhyno será nulo. Puede cambiar este comportamiento en "Opciones de proyecto avanzadas" de la configuración de su trabajo modificando la configuración de "Período de silencio" o en la configuración global de jenkins.
:
...
"url" : "queue/item/39/",
"why" : "In the quiet period. Expires in 2.4 sec",
"timestamp" : 1423993879845
}
Pude usar la api de Java Jenkins para lograr lo que buscas. https://github.com/jenkinsci/java-client-api
Código de muestra:
JenkinsServer jenkinsServer = new JenkinsServer(newURI("http://yourJenkinsServer:8080/"));
JobWithDetails smokeTestJob = jenkinsServer.getJob("YourJobName");
Map<String,String> jobParams = new HashMap<String,String>();
QueueReference queueReference = smokeTestJob.build(jobParams);
do {
Thread.sleep(2000L);
queueItem = jenkinsServer.getQueueItem(queueReference);
log("Job still in queue"+queueItem.getExecutable());
} while (queueItem.getExecutable() == null);
Build build = jenkinsServer.getBuild(queueItem);
while(build.details().isBuilding()){
log("Job still running");
Thread.sleep(10000L);
}
log("Result="+build.details().getResult());
Quería agregar a la respuesta morgwai usando el encabezado de ubicación.
Acabo de resolver este problema. La clave después del encabezado Ubicación es sondear la entrada de la cola de trabajos hasta que tenga una entrada ''ejecutable'' que proporcione el número de trabajo que se inició.
Doy la respuesta completa a una pregunta similar que vi primero que no respondió completamente al problema:
https://.com/a/48531874/9291603
JSON de la entrada de la cola de trabajos de Jenkins con la entrada ejecutable:
{
"_class": "hudson.model.Queue$LeftItem",
"actions": [
{
"_class": "hudson.model.CauseAction",
"causes": [
{
"_class": "hudson.model.Cause$RemoteCause",
"addr": "10.20.30.60",
"note": null,
"shortDescription": "Started by remote host 10.20.30.60"
}
]
}
],
"blocked": false,
"buildable": false,
"cancelled": false,
"executable": {
"_class": "org.jenkinsci.plugins.workflow.job.WorkflowRun",
"number": 45,
"url": "http://192.168.115.187:8080/job/rf_systest/45/"
},
"id": 95,
"inQueueSince": 1517342648136,
"params": "",
"stuck": false,
"task": {
"_class": "org.jenkinsci.plugins.workflow.job.WorkflowJob",
"color": "blue_anime",
"name": "rf_systest",
"url": "http://192.168.115.187:8080/job/rf_systest/"
},
"url": "queue/item/95/",
"why": null
}
Resulta que las compilaciones tienen el ID de la cola original. Además, puede consultar solo la compilación con su Id. De cola y sondearla hasta que obtenga un resultado porque 404 normalmente debería implicar que está en cola.
Extraiga el ID de la cola del encabezado de la ubicación, por ejemplo, 39
/jenkins/queue/item/39/
Consulte repetidamente una construcción con ese número de cola hasta que obtenga una respuesta
"http://{jenkins}job/{job}/api/xml?tree=builds[number,queueId]&xpath=//build[queueId=/"{queueId}/"]";
<build>
<number>411</number>
<queueId>39</queueId>
</build>
A partir de este resultado, puede extraer el número de compilación con xpath /build/number/text()
(Tenga en cuenta que no pude usar &xpath=//build[queueId={queueId}]/number/text() en la url porque "primitive XPath result sets forbidden; implement jenkins.security.SecureRequester" )
Es igual de cojo que sondear el api de la cola para una compilación "ejecutable". Una ventaja es que el punto final continuará por más tiempo, hasta que se elimine la construcción, en comparación con un tiempo arbitrario (que parece ser alrededor de 5 minutos).
Actualizar:
La otra respuesta fue agregada ~ 8 meses después de la mía. No estaba al tanto del encabezado de ubicación en la respuesta en ese momento. Eso suena como una buena opción para algunos casos. Dicho esto, según las advertencias en la respuesta y los comentarios (especialmente en las versiones parametrizadas ), parece que esta respuesta todavía tiene alguna utilidad para algunos casos.
Respuesta original:
Desafortunadamente, no hacen esto tan sencillo como podría ser. es decir, por ejemplo, devolviendo una respuesta JSON con información como una identificación .
Sin embargo, creo que una solución sólida, aunque ciertamente no trivial, a esa situación sería aprovechar el parámetro de causa en la URL que usa para desencadenar la compilación, y dentro de esa causa, agregue un texto único que luego pueda analizar para determinar que lo desencadenó desde su automatización.
Para unificar aún más el trabajo específico, en caso de que se ejecuten varios al mismo tiempo, incluso desde su automatización, también incluya un ID único de algún tipo (podría ser simplemente un ID de secuencia de su RDBMS o similar) dentro del parámetro causa.
Luego, puede usar la API de JSON para obtener información sobre el trabajo que está activando de forma remota. De nuevo, es algo indirecto, pero factible:
Pulse una URL del formulario:
http://<server>:<port>/job/<jobname>/lastBuild/api/json
Puede agregar ?pretty=true para imprimirlo en el navegador para una mejor legibilidad humana.
Eso te dará el JSON de la última compilación. Contendrá el atributo de causas dentro del atributo de acciones , y allí (en otro atributo anidado llamado shortDescription ) encontrará el parámetro de causa que agregó, si esta fuera una de las compilaciones que activó.
Podría analizar tanto el texto estático especial como su ID generada para ver si coinciden. Si lo hacen, también puede obtener el id Jenkins fuera del JSON (busque buildNumber , que está anidado).
Si esa compilación no es activada por su automatización, o si fue, pero la ID no coincide, puede repetir el proceso para la compilación N - 1 hasta que encuentre lo que está buscando.
Ese JSON sería de la forma:
http://<server>:<port>/job/<jobname>/<buildNumber>/api/json