Configuración del process de compilation para proyectos dependientes y desarrolladores múltiples

Soy bastante nuevo en automatizar los processs de compilation y la continuous integration, y estoy trabajando en la configuration de un process / server de compilation para un pequeño equipo de desarrolladores. Estamos utilizando el server de compilation SVN, CMake y Jenkins. El lenguaje de origen es C ++.

Digamos que tenemos dos proyectos, library (a dll) y executable . enlaces executable a la library , y para build el executable necesita los files .lib y .h de la library . Para ejecutar el executable , necesita el .dll (y posiblemente los files de símbolos de debugging) para la library .

Cuando construyes todo, es bastante simple, obtienes la última fuente del repository y comstack la library luego la executable .

Sin embargo, tenemos múltiples desarrolladores, y cada desarrollador generalmente trabaja en un proyecto a la vez. Nuestros scripts CMake le permiten elegir qué proyectos build, por lo que John puede tener una configuration que solo crea executable , mientras que Bob solo crea la library . Renunciar a esto no es una opción.

Entonces, si Bob realiza cambios en la library y confirma el origen, John necesitará get los files comstackdos .lib y .dll (porque no está comstackndo la library ).

En este momento, los binarys están en el svn. Durante cada compilation, CMake copy src/bin para build/bin como un paso previo a la build/bin , luego se comstackn los proyectos seleccionados (reemplazando el binary apropiado en build/bin ), y finalmente CMake copy build/bin a src/bin .

Esto significa que cuando Bob hace un cambio, él no solo compromete los files fuente, sino también el binary comstackdo, y cuando John actualiza su copy de trabajo obtiene los files binarys correctos, y no tiene que hacer ningún reemploop manual de files.

Esto ha estado funcionando por un time, pero realmente no me gusta por varias razones. ¿Hay alguna forma de hack-ish para configurar algo como esto? (En realidad, hay 4 desarrolladores y aproximadamente 12 proyectos, algunos son bibliotecas que no dependen de nada, otros son bibliotecas que dependen de otras bibliotecas, y algunos son ejecutables que dependen de otras bibliotecas).

Editar : Este es el process en el que estoy pensando:

Utilice un sistema de seguimiento de artefactos como Artifactory o Nexus para almacenar binarys después de la compilation, junto con los files de encabezado utilizados para generar esos binarys.

En CMake, cada proyecto se marca como comstackdo o precomstackdo. Los proyectos comstackdos se generan desde el repository regular. Los files binarys y encabezados de proyectos precomstackdos se descargan de Nexus si están desactualizados, y CMake los enlaces e incluye de forma adecuada. Los encabezados también se guardan con los artefactos para evitar la condición de raza que describí en mi comentario a la respuesta de Dave Bacher.

Lo único que no me gusta es que tendré que hacer un poco de CMake-foo para comprobar si los artefactos están desactualizados y downloadlos, pero supongo que no existe realmente una alternativa ya que aparentemente lo que bash para configurar es tan no estándar.

No me gusta que esté revisando la compilation de un desarrollador como la reference canónica de la que otros buildán. Es frágil y puedes terminar con comstackciones malas que funcionan para una persona en su entorno, pero que fallan para otros. O un caso en el que alguien hace cambios, pero se olvida de registrar los files y, de repente, es el único que puede build parte del proyecto.

Como mínimo, debe configurar a Jenkins como el lugar para build las bibliotecas y los ejecutables, y lograr que los desarrolladores solo consulten la fuente. Jenkins tiene varios complementos (por ejemplo, SVN Publisher ) que se pueden usar para publicar las bibliotecas y los ejecutables una vez que se hayan construido en su entorno de compilation estándar.

En mi experiencia, es muy sencillo instalar Jenkins en una máquina de construcción y configurar construcciones para cada uno de sus proyectos. Eso lo ayuda a comenzar con el primer paso para verificar que cada uno de sus proyectos se desarrolle. Luego, trabaje para conseguir que Jenkins publique su resultado en lugar de confiar en que los desarrolladores publiquen sus comstackciones.

Parece que el sistema que está actualmente en funcionamiento siempre tendrá una condición de carrera entre aquellos que modifican el ejecutable y la biblioteca. En lugar de tratar de centrarse en cómo resolver la condición de carrera para todos los desarrolladores, sugiero que use CI para detectar problemas que pueden ocurrir a partir de las condiciones de carrera.

Como recién está comenzando, lo mantendría simple y me concentraría en crear un trabajo de Jenkins que genere todo cuando se revise algo en el repository. Suponiendo que la biblioteca y el ejecutable se mantienen en el mismo repository SVN, las acciones para el trabajo deberían ser algo como esto:

  1. Mira el repository
  2. Ejecute CMake para build la biblioteca
  3. Haga testings unitarias para la biblioteca (hay algunas, ¿verdad?)
  4. Ejecute CMake para build el file ejecutable contra la biblioteca
  5. Haz alguna testing unitaria para el ejecutable (hay algunos, ¿verdad?)
  6. Notifique a los desarrolladores de los resultados de la construcción.

Si bien parece trivial, los comentarios de los desarrolladores lo harán si están rompiendo las cosas por sus cambios sin tener que obligarlos a recordar actualizar su copy. También ayudará a facilitarles el cambio de paradigma de trabajar con CI.

[Por cierto, el que los desarrolladores pueden encontrar es si están acostumbrados a verificar en SVN un file a la vez. Hacer cambios de file por file iniciará varias comstackciones que solo se llevarán a cabo con éxito cuando el último file esté finalmente registrado. Las revisiones de varios files deben realizarse como acciones atómicas con varios files a la vez. Esta también es una buena práctica de SCM ya que agrupa los cambios en una sola cosa que se puede rastrear y (si es necesario) revertir.]

El cambio de paradigma puede parecer insuperable al principio, pero puede suceder. El proyecto en el que estoy trabajando actualmente comenzó con desarrolladores acostumbrados a un process muy similar al que describió anteriormente. Cuando pasamos a ejecutar CI, hubo cierta resistencia al código de comprobación más de una vez a la semana. 8 meses después, si tengo que hacer algún mantenimiento a las comstackciones de Jenkins, inmediatamente me preguntan por qué Jenkins no está disponible y "¿cómo espero que las personas trabajen si no pueden recuperar los resultados de compilation inmediatamente? "