Flujo de compilation versus desarrollo de compilation

Estoy intentando dividir algunos trabajos de Jenkins usando el plugin Build Flow para que en lugar de tres trabajos monolíticos, tengamos tres "puntos de partida" que luego usen el DSL para desencadenar trabajos secundarios. Elegí Build Flow sobre el plugin Build Pipeline porque parecía que era mucho más difícil compartir trabajos entre diferentes canalizaciones (es decir, compartir el espacio de trabajo de las múltiples tareas iniciales con un solo trabajo de compilation).

Anteriormente, tenía tres trabajos configurados: Project-PR, Project-DEV y Project-PROD.

Project-PR se crearía cada vez que se realizara una request de extracción en GitHub, y solo ejecutaría un subset más pequeño de nuestras testings unitarias, para que pudiéramos get una verificación rápida de que el RP está bien para fusionarse.

Project-DEV se comstackrá cada vez que una twig de características se fusione en GitHub en la twig de desarrollo principal, además de tener la capacidad de activarse manualmente y proporcionarle una twig diferente para extraer. Correría la suite completa de la unidad, básicamente un control de cordura que todo sigue siendo bueno. Luego comstackría y minimizaría, y pasaría a un entorno de control de calidad para realizar testings, y luego ejecutaría el set completo de testings de integración en ese entorno de control de calidad. Este paso se configuró como una construcción parametrizada, con el parámetro que es el nombre de la twig para extraer, probar y presionar. Impulsaría y configuraría un entorno de control de calidad específico para esa twig, de modo que pudiéramos realizar funciones de control de calidad múltiples sin tener que fusionarnos con el desarrollo (es decir, feature-one.qa.example.com, feature-two.qa.example.com) .

Project-PROD solo se activaría manualmente, y realizaría el set completo de testings de unidad e integración, comstackría y mineríaría el código de front-end (Less, JS y CSS) e insertía el código incorporado en una "twig de publicación" especial. en GitHub que luego se puede implementar, no hemos llegado al punto en que Jenkins esté a cargo de la implementación.

Ahora, lo que quería configurar era dividir las subtareas en sus propios trabajos, de modo que sería fácil configurar nuevos trabajos sin tener que copyr y pegar todos los pasos de compilation (o copyr el trabajo y cambiar todo el trabajo). cosas que necesitan ser únicas). Esto nos permitiría hacer cosas como crear una copy del proyecto-DEV, pero cambiar el último trabajo por uno que se implementa en un entorno de testing configurado en la nube. O cree fácilmente un trabajo que pueda informar los resultados de la testing a una fuente externa, es decir, copie los resultados en una carpeta de networking compartida o algo así. O cualquier cantidad de cosas El objective es básicamente utilizar estos trabajos de subtareas como bloques de construcción para permitirnos crear trabajos más complicados, al mismo time que sea más fácil actualizar cómo funciona una parte de la compilation (por ejemplo, tal vez cambiemos a una tecnología diferente para comstackr, que podría cambiar cómo Jenkins comstackría el código).

Por ejemplo, Project-PR se dividiría en lo siguiente:

Project-PULL -> Project-SetupBuildEnv -> Project-PartialUnitTests (BuildFlow) (Normal Job) (Normal Job) 

SetupBuildEnv simplemente eliminará cualquier requisito de NPM o Composer, y configurará los directorys necesarios para probar y build. PartialUnitTests luego se ejecuta e informa sus resultados nuevamente a la

El Proyecto-DEV podría dividirse así:

 Project-DEV -> Project->SetupBuildEnv -> Project-FullUnitTests -> Project-Compile -> Project-Minify -> Project-DeployQA -> Project-FullIntegrationTests 

De esta forma, las partes del process de compilation que se comparten (en este caso, Project-SetupBuildEnv) pueden compartirse fácilmente entre trabajos, networkinguciendo la duplicación y facilitando la actualización de un paso en el process de compilation sin tener que recordar TODOS los trabajos que usa ese paso.

En este momento, estoy usando el plugin Shanetworking Workspace para que todos los pasos usen el mismo espacio de trabajo. Sin embargo, estoy teniendo un problema con eso: en realidad no está usando un espacio de trabajo. Lo que sucede es que el trabajo Build Flow obtendrá un directory (por ejemplo: / shanetworkingspace / shanetworking_one) y downloadá el código de GitHub allí. Luego activará el DSL, que inicia el trabajo 'SetupBuildEnv'. Pero en lugar de trabajar dentro del mismo directory, obtendrá un directory con un nombre como "/ shanetworkingspace / shanetworking_one @ 2" y ejecutará la tarea de installation de compilation allí. Luego, cuando va al tercer paso (testing unitaria), falla, porque ahora tiene un tercer directory (/ shanetworkingspace / shanetworking_one @ 3), pero ese directory no tenía la configuration ejecutada, por lo que el nodo y el compositor necesarios los modules faltan Lo raro es que parece que el plugin Shanetworking Workspace copy el primer espacio de trabajo compartido a otro directory y aumenta un contador (la parte @N del nombre del directory) y lo transfiere a los otros trabajos para que funcionen.

Entonces, hora de la pregunta:

  1. ¿Hay alguna manera de arreglar el plugin Shanetworking Workspace para que solo esté usando un directory para cada trabajo?
  2. de lo contrario, ¿es posible hacer que el plugin Clone Workspace tome un argumento, por lo que puedo especificar qué espacio de trabajo archivado utilizar en lugar de usar el menu desplegable?
  3. otra posibilidad: ¿usaría el complemento de espacio de trabajo compartido, pero usaría la opción "subdirectory local para repo (opcional)" en las opciones de trabajo de git avanzadas para especificar el directory a usar?
  4. Al fallar todo eso, ¿hay alguna otra forma de configurar una canalización de compilation que pueda compartir trabajos con otras interconexiones que me he perdido?

En mi experiencia, incluso si logras que esto funcione, esta podría no ser una forma escalable de ir a más largo ploop. Hemos encontrado que el complemento del espacio de trabajo compartido es una mala idea para comstackciones largas / complejas (razones similares a las tuyas, pero también: escalar a través de docenas de esclavos se vuelve difícil de repente). Podría decirse que la idea es ligeramente contraria al espíritu de CI escalable moderno.

En cambio, delegaría más en tus herramientas de construcción, ya sean Maven / Gradle, Ant, incluso Grunt, lo que sea. Si desea mantener estas comstackciones realmente modulares, pero no puede permitirse rebuild en cada paso (decidimos que la independencia total valía la pena desperdiciar unos minutos por compilation), entonces tal vez considere la creación de artefactos útiles en etapas key: en su caso, minificado TARs de activos, JAR de biblioteca, o tal vez webjars , o lo que sea, y desplegarlos en un repository (Maven?).

Los últimos pasos de compilation en su canalización pueden extraer rápida, fácil y repetidamente los activos más recientes (o versiones nombradas) de este repository centralizado y continuar con el process de compilation.

Una alternativa (con similitudes) es crear uno o más activos, pero solo promocionarlos después de que se ejecute un número cada vez mayor de testings, lo que se puede hacer en comstackciones separadas coordinadas por su flujo de compilation, utilizando el complemento Promociones comstackdas, etc.