¿Cuáles son algunos consejos para hacer que mi proyecto se compile en una caja nueva cada vez?

Más veces de las que me gustaría admitir que he tenido personas nuevas en un proyecto, haga un checkout solo para descubrir que faltan varios resources, dll's, settings. Me gustaría tener el hábito de hacer que la compilation de mis proyectos sea fluida, como puede serlo en un nuevo process de pago.

¿Cuáles son algunos consejos o sugerencias sobre cómo estructurar mis proyectos para que no tengan problemas de compilation en un nuevo process de control de versiones?

Empecé a mantener una carpeta de "Recursos" en mis proyectos que contiene todas las references dll necesarias en el control de código fuente. ¿Alguien más puede hacer algunas sugerencias?

Suponiendo que se encuentre en un entorno de Visual Studio, aquí hay algunas cosas que le pueden resultar útiles, YMMV, por supuesto, y tenga en count que usamos Subversion, pero cualquier herramienta VCS debería hacer …

  • Coloque todas las dependencies (o tantas como sea posible) bajo control de versión y haga reference a éstas en sus proyectos. Usamos Subversion externos para administrar esto.
  • No controle la versión de los directorys de salida estándar (bin, obj), es decir, use svn: ignore
  • Del mismo modo, ignore los elementos de usuario de control de versiones (* .user, * .suo)
  • Tampoco utilice los files de configuration de control de versión (App | Web.config); en su lugar, cree un App.default.config y en su proyecto BeforeBuild task copie este file en App.config. Esto le permite get lujo mediante el uso de RegEx y tokens para configurar comstackciones por desarrollador o server de compilation, sino que también le permite eliminar cualquier file App.config existente en las comstackciones de CI para garantizar una construcción prístina en todo momento. Esto también permite a los desarrolladores utilizar configuraciones sin tener que molestar a los demás hasta que estén listos, es decir, actualicen App.default.config.
  • La versión controla todo lo demás 🙂
  • Si necesita binarys de control de versiones (MSI, salida de DLL, etc.) como resultado de su compilation, en su proyecto de destino de AfterBuild (wixproj, etc.) copie el resultado a otro directory que esté bajo control de versión. Un consejo al usar Subversion es que puede agregar / comprometerse a un directory svn: external, que le permite enviar bibliotecas, etc. al proyecto que las reference.

Consejo final: una vez que haya finalizado el process de pago y haya realizado una compilation exitosa, verifique si hay alguna modificación en su copy de trabajo, por ejemplo, TortoiseSVN -> Verifique las modificaciones. Si tiene cambios detectados, es probable que estos files deban ignorarse.

Busque una computadora más vieja que no esté en uso y configúrela para "comstackciones rodadas" automáticas:

  1. Espere hasta que alguien revise un cambio
  2. Actualiza a la última versión de todos los files.
  3. Limpie todos los files de control que no sean de origen ( make clean no sea suficiente: escanee los residuos y elimínelos)
  4. Construir.
  5. Ejecutar testings unitarias
  6. Una vez al día, guarde los binarys de una ejecución exitosa. Llámalo la "construcción oficial" del día.

Si la compilation o las testings fallan, envíe un correo electrónico con el error. Incluya la list de cambios que fueron recogidos en el n. ° 2.

Si realmente, realmente no puede encontrar una máquina, hágalo en una máquina virtual.

Las herramientas como nmaven pueden ayudar con los problemas de dependencia (aunque es posible que tenga que consultar los documentos de Java Mava para get información …)

Las herramientas de continuous integration, como cruisecontrol, comtestingn y crean repetidamente su aplicación después de cada logging, lo que puede alertarle sobre los checkins que rompen la construcción … Además, pueden ejecutar sus testings unitarias y así alertarlo sobre cualquier regresión causada por su logging, también …

¿Alguien más puede hacer algunas sugerencias?

  1. Mantenga los files, que debe comstackr, en un solo lugar (un directory y sus subdirectorys) … la mayoría de los sistemas de control de versiones lo llaman su "directory de trabajo"
  2. Su software de control de versiones tiene un command para enumerar las diferencias entre lo que está en su directory de trabajo y lo que está bajo control de versión … esta "diferencia" incluye files que existen en el directory de trabajo y que no están bajo control de versiones
  3. Ajuste su software de control de versiones para excluir (de la list mostrada en el paso 2.) los files cuyo tipo no desea almacenar … por ejemplo, es posible que desee almacenar solo el código fuente y excluir *.obj etc. … excluir estos types de files significa que cuando ejecuta el paso 2, la list de diferencias no está llena de files que no tiene la intención de almacenar
  4. Considere tener una máquina de compilation, que automáticamente hace check-out-and-builds (y que le envía un correo electrónico si alguna vez la 'compilation está rota')

Debian Linux tiene una herramienta realmente impresionante llamada pbuilder , que crea una image de un sistema recién instalado y luego intenta build su código. Funciona solo con el sistema de package Debian, pero podría robar las ideas, que son realmente buenas.

Automatice su compilation desde un entorno chroot o una máquina virtual que se parece a una installation nueva. Su secuencia de commands de compilation instalará los files DLL y así sucesivamente. O su script de configuration enumerará las dependencies faltantes (todas ellas, no solo la primera).

Son las 1 am y estoy sonando incoherente, pero dos ideas son centrales:

  • Tener una máquina virtual o un directory chroot que pueda imitar a un sistema en blanco. En estos días, una máquina virtual es probablemente la más fácil.

  • Ajusta tu sistema de compilation hasta que verifique y construya automáticamente en tu máquina virtual — o si no se queja de lo que falta.

En ese punto, puede hacer que el process forme parte de una compilation nocturna automatizada, y usted será un feliz campista 🙂

Todos los resources / DLL / configuraciones deben verificarse en el control de versiones junto con el código fuente.

Deben labelrse y tratarse de manera equitativa con el código fuente, lo que le permitirá correlacionar estos resources con el origen y tratar el código fuente / resources / configuration como una sola entidad.

En mi compañía, utilizamos Rational ClearCase. Todo se controla en el control de fuente, con la exception de los files de código fuente generados (por ejemplo, files .cpp y .h generados a partir del comstackdor MIDL). Debido a esto, la mayoría de las comstackciones funcionan sin problemas.

También debe asegurarse de que sus dependencies estén configuradas correctamente, de modo que cuando se cambie un file fuente, todas las bibliotecas dependientes se rebuildán.

Podría elaborar una list de verificación completa que consulte antes de cada check-in, pero eso llevaría mucho time y es propensa a errores (especialmente en múltiples desarrolladores, no todos tienen los rasgos de personalidad para seguir una list de verificación de cerca cada vez).

En su lugar, configure un server simple de Integración Continua – CruiseControl.Net es de código abierto; TeamCity by JetBrains es gratis, que verifica las construcciones cada vez que se realiza un checkin.

De esta manera, lo sabrá con certeza, en lugar de inferir que las cosas funcionan porque se siguió la list de verificación.

SCons es otra herramienta que funciona multiplataforma y ayuda a administrar sus dependencies. Similar a gnu make en el que tiene un "file scons / script" – y el hecho de que utiliza python le da mucha flexibilidad.

http://www.scons.org/

(No tengo nada que ver con SCons, solo lo usamos)