programa ejecutar desde compilar como build-process build-automation build

build process - ejecutar - Mejorando tu proceso de compilación



compilar un programa en c desde terminal (8)

Cuando se trata de un proyecto que nunca ha tenido un proceso de construcción automatizado, es más fácil llevarlo por etapas. No trates de tragar demasiado a la vez, de lo contrario, puede ser abrumador.

  1. Primero obtenga su código compilando con un solo paso usando un programa de compilación automatizado (es decir, nant / msbuild). No voy a debatir cuál es mejor. Encuentre uno que se sienta cómodo para usted y úselo. Haga que los scripts de construcción vivan con el proyecto en control de fuente.
  2. Descubre cómo quieres que se active tu compilación automatizada. Ya sea que se conecte a CruiseControl o ejecute una tarea de compilación nocturna usando Tareas programadas. CruiseControl o TeamCity es probablemente la mejor opción para esto, ya que incluyen muchas herramientas que puede utilizar para facilitar este paso. CruiseControl es gratuito y TeamCity es gratuito hasta cierto punto, donde es posible que tengas que pagarlo según lo grande que sea el proyecto.
  3. De acuerdo, en este punto estarás bastante cómodo con las herramientas. Ahora está listo para agregar más tareas según lo que desee hacer para probar, implementar, etc.

Espero que esto ayude.

O, en realidad, establecer un proceso de construcción cuando no hay mucho de uno en el lugar para empezar.

Actualmente, esa es prácticamente la situación que enfrenta mi grupo. Hacemos desarrollo de aplicaciones web principalmente (pero no desarrollo de escritorio en este momento). Las implementaciones de software son feas e inmanejables incluso con nuestras modestas aplicaciones, y hemos tenido demasiados problemas en los dos años en que he sido parte de este equipo (y compañía). Ya es hora de hacer algo al respecto, y el resultado es que podremos matar dos pájaros Joel Test de un tiro (construcciones diarias y construcciones de un solo paso, ninguno de los cuales existe en forma alguna).

Lo que busco aquí es una idea general sobre el tipo de cosas que necesito hacer o pensar, de personas que han estado en el desarrollo de software por más tiempo que yo y también tienen cerebros más grandes. Estoy seguro de que será la mayoría de las personas que publiquen actualmente en la versión beta.

Herramientas relevantes: Visual Build Source Safe 6.0 (Lo sé, pero no puedo hacer nada sobre si usamos Source Safe o no en este momento. Esa podría ser la próxima batalla en la que peleo).

Tentativamente, tengo un proyecto Visual Build que hace esto:

  1. Obtenga el origen y el lugar en el directorio local, incluidas las DLL necesarias para el proyecto.
  2. Obtenga los archivos de configuración y renómbrelos según sea necesario (los estamos almacenando en un subdirectorio especial que no es parte de la aplicación real, y se nombran de acuerdo con el uso).
  3. Crear usando Visual Studio
  4. Precompila usando la línea de comando, copiando en lo que será un directorio de "compilación"
  5. Copiar a destino
  6. Obtenga los recursos adicionales necesarios, en su mayoría cosas como documentos, imágenes e informes que están asociados con el proyecto (y los coloca en el directorio desde el paso 5). Hay muchas de estas cosas, y no quería incluirlas previamente. Sin embargo, solo copiaré los artículos cambiados, así que tal vez sea irrelevante. No estaba seguro de si realmente quería incluir esto en los pasos anteriores.

Todavía necesito convencer a cerrar sesión de Visual Build para todo esto, pero todavía no estoy en un punto en el que deba hacerlo.

¿Alguien tiene algún consejo o sugerencia para hacer? Actualmente no estamos usando un proyecto de implementación, lo notaré. Eliminaría algunos de los pasos necesarios en esta compilación, supongo (como el intercambio de web.config).

Nuestro proceso de compilación es un conjunto de scripts de Perl de cosecha propia que han evolucionado más de una década, nada sofisticado pero que hace el trabajo bien. Una secuencia de comandos obtiene el último código fuente, otro lo construye, un tercero lo ubica en una ubicación de red. Hacemos el desarrollo de aplicaciones de escritorio, por lo que nuestro proceso de preparación también crea paquetes de instalación para probar y finalmente enviar a los clientes.

Te sugiero que lo desgloses en pasos individuales porque habrá momentos en los que querrás reconstruir pero no llegarás al último, o tal vez solo necesites volver a escenificar. Nuestros scripts también pueden manejar construcciones de diferentes ramas, así que considere eso también con cualquier solución que desarrolle.

Finalmente, tenemos una máquina de creación dedicada que reconstruye las ramas de troncales y mantenimiento todas las noches y envía un correo electrónico con cualquier problema o si se completó con éxito.

Nuestro sistema de compilación es un archivo MAKE (o dos). Ha sido bastante divertido ponerlo en funcionamiento, ya que debe ejecutarse en ambas ventanas (como una tarea de compilación en VS) y en Linux (como una tarea normal de "make bla"). Lo realmente divertido es que la construcción obtiene la lista de archivos real de un archivo .csproj, crea (otro) archivo MAKE de eso y ejecuta eso. En los procesos, el archivo make realmente se llama a sí mismo.

Si ese pensamiento no asusta al lector, entonces (o están locos o) probablemente puedan hacer que + "su traficante de cuerdas favorito" trabaje para ellos.

Pasamos de usar una secuencia de comandos de Perl a MSBuild hace dos años y no hemos mirado hacia atrás. La construcción de soluciones visuales de estudio se puede hacer simplemente especificándolas en el archivo xml principal.

Para algo más complicado (obtener su código fuente, ejecutar pruebas de unidades, crear paquetes de instalación, implementar sitios web), puede crear una nueva clase en .net derivada de Tarea que anule la función Ejecutar y luego hacer referencia a esto desde su archivo xml de compilación. .

Aquí hay una introducción bastante buena: introducción

Solo he trabajado en un par de proyectos .Net (he hecho principalmente Java) pero una cosa que recomendaría es usar una herramienta como NAnt . Tengo un problema real con el acoplamiento de mi compilación al IDE, termina haciendo un gran esfuerzo configurar los servidores de compilación en el camino, ya que tienes que hacer una instalación completa de VS en cualquier caja que quieras construir en el futuro.

Dicho esto, cualquier versión automatizada es mejor que ninguna versión automatizada.

Tengo un conjunto de scripts de Powershell que hacen todo esto por mí.

Script 1: Build: este es simple, principalmente se maneja mediante una llamada a msbuild, y también crea mis scripts de base de datos.

Script 2: Paquete: este toma varios argumentos para empaquetar una versión para varios entornos, como prueba, y subconjuntos del entorno de producción, que consta de muchas máquinas.

Script 3: Implementar: se ejecuta en cada equipo individual desde la carpeta creada por el script del paquete (el script de implementación se copia como parte del empaquetado)

Desde el script de implementación, hago verificaciones de cordura en cosas como el nombre de la máquina para que las cosas no se desplieguen accidentalmente en el lugar equivocado.

Para archivos web.config, uso el

<appSettings file="Local.config">

para tener reemplazos que ya están en las máquinas de producción, y son de solo lectura para que no se vuelvan a escribir accidentalmente. Los archivos Local.config no están registrados, y no tengo que hacer ningún cambio de archivo en tiempo de compilación.

[Editar] El equivalente de appSettings file = para una sección de configuración es configSource = "Local.config"

Una cosa que sugeriría es asegurarse de que su script de compilación (y el proyecto de instalador, si es relevante en su caso) esté en control de fuente. Tiendo a tener un script muy simple que simplemente verifica / gets latest the "main" script y luego lo lanza.

Digo esto porque veo que los equipos solo ejecutan la última versión del script de compilación en el servidor, pero nunca lo ponen en control de fuente o cuando lo hacen solo lo registran aleatoriamente. Si haces que el proceso de compilación para "obtener" desde el control de la fuente te obligará a mantener la última y mejor secuencia de comandos de compilación allí.