¿Cómo dividir un gran trabajo/proyecto de Jenkins en trabajos más pequeños sin comprometer la funcionalidad?

estamos tratando de mejorar nuestra configuración de Jenkins. Hasta ahora tenemos dos directorios: /plugins y /tests.

Nuestro proyecto es un proyecto de varios módulos de complementos de Eclipse. Los complementos de prueba en la carpeta /tests son proyectos de fragmentos que dependen de sus correspondientes complementos de código productivo en /plugins.

Hasta ahora, solo teníamos un trabajo de Jenkins que verificaba tanto /plugins como /tests, los construía todos y producía los resultados de Surefire, etc.

Ahora estamos pensando en dividir el proyecto en trabajos más pequeños correspondientes a las funciones que ofrecemos. Parece que la forma en que tratamos de hacerlo es subóptima.

Probamos lo siguiente:

  1. Creamos un trabajo para la característica principal. Este trabajo verifica todos los directorios /plugins y /tests y solo crea los complementos de los que se compone la función. Este trabajo tiene un pom.xml separado que define el artefacto principal e informa sobre los módulos contenidos en la función.
  2. Creamos un trabajo separado para las pruebas que deben ejecutarse en los complementos de funciones. Este trabajo usa el espacio de trabajo clonado del trabajo principal. Este trabajo debe ejecutarse después de compilar la característica principal.

De alguna manera creo que esto es menos que óptimo.

  • Por ejemplo, solo el trabajo principal puede actualizar los archivos desprotegidos. Si solo se actualizan las pruebas, no es necesario volver a crear la función principal, pero se hará.
  • Tan pronto como tenga una función que dependa de la función principal, esta función necesitaría usar un clon del espacio de trabajo de la función principal o verificar su propia copia de /plugins y /tests, lo que conduciría a la hinchazón.
  • Usando un espacio de trabajo clonado, no puedo actualizar mis fuentes. Entonces, cuando tengo una función que depende de otra función, solo puedo hacer el trabajo si la función principal está actualizada y construida.

Creo que me estoy perdiendo algunas cosas básicas aquí. ¿Alguien puede ayudar? Definitivamente hay una manera más fácil para esto.

EDITAR: intentaré formular lo que creo que sucedería idealmente si todo funciona:

  • compruebe si los componentes de la función han cambiado (es decir, es posible actualizarlos)
  • si se cambia, construye la característica
    • Cree las características dependientes, si es necesario (es decir, verifique el trabajo correspondiente del ob)
    • Construya la función en sí
    • si la compilación es exitosa, inicie el trabajo de prueba de características
    • déjame ver los resultados del trabajo de prueba en el trabajo destacado

Finalmente, el trabajo del proyecto debe

  • hacer una compilación nocturna
  • echa un vistazo a todas las fuentes de /plugins y /tests
  • construir todo, probar todo, enviar resultados a Sonar

Además, sería genial si la compilación nocturna fuera innecesaria porque las compilaciones y los resultados de las pruebas de las características de los proyectos se combinarían en los resultados del trabajo del proyecto.

¿Es posible algo así?

preguntado el 03 de mayo de 12 a las 14:05

Esta es una buena pregunta para reflexionar en este momento, ya que estoy trabajando para dividir nuestra construcción monolítica en etapas que se pueden ejecutar simultáneamente. -

1 Respuestas

A partir del final de la pregunta. Mantendría un trabajo nocturno separado que hace un check-out limpio (se deshace de cualquier material generado antes del check-out), construye todo desde cero y ejecuta todas las pruebas. Si no está haciendo una compilación limpia, no puede garantizar que lo que está registrado en su repositorio realmente se compile.

  • compruebe si los componentes de la función han cambiado (es decir, es posible actualizarlos)
  • si se cambia, construye la característica
    1. Cree las características dependientes, si es necesario (es decir, verifique el trabajo correspondiente del ob)
    2. Construya la función en sí
    3. si la compilación es exitosa, inicie el trabajo de prueba de características
    4. déjame ver los resultados del trabajo de prueba en el trabajo destacado

[Supongo que por "características dependientes" en 1 te refieres a las cosas que necesita la "característica" en 2.]

Para hacer esto, diría que tienes múltiples trabajos.

  • un trabajo para cada función individual y cada función dependiente que simplemente crea esa función. Los trabajos deben iniciarse mediante cambios de SCM para la característica (dependiente).
  • No mantendría trabajos de prueba separados de trabajos de compilación. Permite la posibilidad de que el código compilado con éxito nunca se pruebe. En cambio, confiaría en el hecho de que cuando falla un paso de compilación en Jenkins, normalmente aborta los pasos de compilación adicionales.

El truco va a estar en cómo enhebras todos estos juntos.

Digamos que tenemos una función y su trabajo de compilación se llama F1 que se basa en 2 características dependientes DF1.1 y DF1.2, cada uno con sus propios trabajos de compilación.

  • Ambos DF1.1 y DF1.2 debe configurarse para desencadenar la compilación de F1.
  • F1 debe configurarse para obtener los artefactos que necesita del último DF1.1 y DF1.2 construye Desafortunadamente, el muy buen complemento "Clone SCM" no será de mucha ayuda aquí, ya que solo se extrae de un trabajo anterior. Tal vez uno de los complementos del editor de artefactos pueda ser útil, o es posible que deba agregar algunos pasos de compilación personalizados para colocar/obtener artefactos.

contestado el 04 de mayo de 12 a las 15:05

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.