¿Cómo controlar la versión de las herramientas de compilation y las bibliotecas?

¿Cuáles son las recomendaciones para include su comstackdor, bibliotecas y otras herramientas en su propio sistema de control de origen?

En el pasado, me encontré con problemas en los que, aunque teníamos todo el código fuente, crear una versión anterior del producto era un ejercicio de escabullirnos tratando de get la configuration correcta exacta de Visual Studio, InstallShield y otras herramientas (incluyendo la versión de parche correcta) utilizada para build el producto. En mi próximo proyecto, me gustaría evitar esto verificando estas herramientas de compilation en el control de código fuente y luego comstackr usándolas. Esto también simplificaría las cosas en términos de configurar una nueva máquina de construcción: 1) instalar nuestra herramienta de control de fuente, 2) señalar en la twig derecha, y 3) build: eso es todo.

Las opciones que he considerado incluyen:

  • Copiando el CD de installation ISO al control de fuente: aunque esto proporciona la copy de security que necesitamos si tenemos que volver a una versión anterior, no es una buena opción para el uso "directo" (cada compilation debería comenzar con un paso de installation , que fácilmente podría convertir una construcción de 1 hora en 3 horas).
  • Instalar el software para controlar la fuente. ClearCase asigna su twig a una letra de unidad; podríamos instalar el software en este disco. Esto no tiene en count la parte no incluida en el file de la installation de sus herramientas, como la configuration del logging.
  • Instalar todo el software y configurar el process de compilation dentro de una máquina virtual, almacenar la máquina virtual en control de código fuente y descubrir cómo hacer que la VM haga una compilation al arrancar. Si bien capturamos el estado de la "máquina de creación" con facilidad, obtenemos la sobrecarga de una VM, y no ayuda con "hacer que las mismas herramientas estén disponibles para los desarrolladores".

Parece una idea tan básica de la administración de la configuration, pero no he podido rastrear ningún recurso sobre cómo hacerlo. ¿Cuáles son las sugerencias?

Creo que la VM es tu mejor solución. Siempre usamos máquinas de construcción dedicadas para get consistencia. En el antiguo DLL COM DLL Días infernales, había dependencies en (COMCAT.DLL, cualquier persona) en un software no desarrollado instalado (Office). Sus primeras dos opciones no resuelven nada que haya compartido componentes COM. Si no tiene ningún problema de componentes compartidos, quizás funcionen.

No hay ninguna razón para que los desarrolladores no puedan tomar una copy de la misma VM para poder depurar en un entorno limpio. Sus problemas serían más complejos si hay muchas capas físicas en su architecture, como server de correo, server de database, etc.

Esto es algo muy específico para su entorno. Es por eso que no verás una guía para manejar todas las situaciones. Todas las diferentes tiendas para las que he trabajado han manejado esto de manera diferente. Solo puedo darle mi opinión sobre lo que creo que ha funcionado mejor para mí.

  • Coloque todo lo necesario para comstackr la aplicación en una nueva estación de trabajo bajo control de fuente.
  • Mantenga las aplicaciones grandes fuera del control de la fuente, cosas como IDE, SDK y motores de bases de datos. Mantenga estos en un directory como files ISO.
  • Mantenga un documento de text, con el código fuente, que tenga una list de los files ISO que se necesitarán para comstackr la aplicación.

Definitivamente consideraría los problemas legales / de licencia que rodean la idea. ¿Sería permisible según las diversas licencias de su cadena de herramientas?

¿Ha considerado la creación de fantasmas de una nueva máquina de desarrollo que pueda crear la versión, si no le gusta la idea de una image de máquina virtual? Por supuesto, mantener esa image fantasma ejecutándose como cambios de hardware podría ser más problemático de lo que vale …

Solo una nota sobre la versión de las bibliotecas en su sistema de control de versiones:

  • es una buena solución, pero implica el empaquetado (es decir, networkingucir al mínimo el número de files de esa biblioteca)
  • no resuelve el "aspecto de configuration" (es decir, "¿qué set específico de bibliotecas necesitan mis proyectos '3.2'?").
    No olvide que el set evolucionará con cada nueva versión de su proyecto. UCM y su "línea base compuesta" podrían dar el comienzo de una respuesta para eso.

El aspecto del package (número mínimo de files) es importante porque:

  • no desea acceder a sus bibliotecas a través de la networking (como la vista dinámica), porque los times de compilation son mucho más largos que cuando utiliza los files de la biblioteca a los que se accede localmente.
  • usted quiere tener esa biblioteca en su disco, es decir, vista de instantánea, es decir, download esos files … y es aquí donde puede apreciar el empaquetado de sus bibliotecas: mientras less files tenga que download, mejor será;)

Mi organización tiene un sistema de files de "solo lectura", donde todo se incluye en lanzamientos y versiones. Los enlaces de propuesta (esencialmente enlaces simbólicos) apuntan a la versión que está utilizando su proyecto. Cuando aparece una nueva versión, simplemente se agrega al sistema de files y puede cambiar su enlace simbólico a ella. Hay un historial completo de auditoría de los enlaces simbólicos, y puedes crear nuevos enlaces simbólicos para diferentes versiones.

Este enfoque funciona muy bien en Linux, pero no funciona tan bien para las aplicaciones de Windows que tienden a gustar usar cosas locales en la máquina, como el logging para almacenar cosas como la configuration.

¿Estás utilizando una herramienta de continuous integration (CI) como NAnt para hacer tus comstackciones?

Como ejemplo .Net, puede especificar frameworks específicos para cada compilation.

Quizás la herramienta de CI popular para lo que sea que esté desarrollando tenga opciones que le permitirán evitar almacenar varios IDEs en su sistema de control de versiones.

En muchos casos, puede obligar a su compilation a usar comstackdores y bibliotecas en su control de origen en lugar de confiar en la configuration global de la máquina que no será repetible en el futuro. Por ejemplo, con el comstackdor de C #, puede usar el modificador / nostdlib y hacer manualmente / referencer todas las bibliotecas para apuntar a las versiones registradas en el control de fuente. Y, por supuesto, compruebe también los comstackdores en el control de código fuente.

Siguiendo mi propia pregunta, me encontré con esta publicación a la que se hace reference en la respuesta a otra pregunta. Aunque es más una discusión sobre el tema que un aswer, menciona la idea de VM.

En cuanto a "averiguar cómo build en el arranque": desarrollé el uso de un sistema de creación de granja personalizado creado muy rápidamente por un administrador de sistema y un administrador. Los esclavos de compilation consultan a un taskmaster sobre las requestes de compilation en queue adecuadas. Es muy lindo.

Una request es 'adecuada' para un esclavo si sus requisitos de cadena de herramientas coinciden con las versiones de cadena de herramientas en el esclavo, incluido el sistema operativo, ya que el producto es multiplataforma y una compilation puede include testings automatizadas. Normalmente, este es "el estado actual de la técnica", pero no tiene por qué serlo.

Cuando un esclavo está listo para build, solo comienza a sondear al capataz, diciéndole lo que tiene instalado. No tiene que saber de antemano lo que se espera build. Obtiene una request de compilation, que le dice que verifique ciertas tags desde SVN, luego ejecuta un script desde una de esas tags para llevarlo desde allí. Los desarrolladores no tienen que saber cuántos esclavos de compilation están disponibles, cómo se llaman o si están ocupados, solo cómo agregar una request a la queue de compilation. La queue de creación en sí es una aplicación web bastante simple. Todo muy modular.

Los esclavos no necesitan ser máquinas virtuales, pero por lo general lo son. La cantidad de esclavos (y las máquinas físicas en las que se ejecutan) se puede escalar para satisfacer la demanda. Los esclavos obviamente pueden agregarse al sistema en cualquier momento, o ser destruidos si la cadena de herramientas falla. Ese es en realidad el punto principal de este esquema, en lugar de su problema con el file del estado de la cadena de herramientas, pero creo que es aplicable.

Dependiendo de la frecuencia con la que necesite una cadena de herramientas antigua, es posible que desee que la queue de compilation sea capaz de iniciar máquinas virtuales según sea necesario, ya que de lo contrario, alguien que quiera recrear una compilation anterior también deberá organizar la aparición de un esclavo adecuado. No es que esto sea necesariamente difícil; podría tratarse simplemente de iniciar la VM correcta en la máquina que elijan.