¿Qué parte de su proyecto debe estar en el control del código fuente?

Un desarrollador compañero comenzó a trabajar en un nuevo proyecto de Drupal, y el administrador del sistema sugirió que solo deberían poner los sitios / subdirectorio predeterminado en el control de código fuente, ya que "hará que las actualizaciones sean fácilmente programables". Dejando a un lado esa afirmación un tanto dudosa, plantea otra pregunta: ¿qué archivos deberían estar bajo control de origen? ¿Y hay una situación en la que se debe excluir una gran parte de los archivos?

Mi opinión es que todo el árbol para el proyecto debería estar bajo control, y esto sería cierto para un proyecto Drupal, rieles o cualquier otra cosa. Esto parece una obviedad: claramente necesita versiones para su marco tanto como para cualquier código personalizado que escriba.

Dicho esto, me encantaría obtener otras opiniones sobre esto. ¿Hay algún argumento para no tener todo bajo control?

Diría que lo mínimo que debe contener el control de código fuente son todos los archivos necesarios para recrear una versión en ejecución del proyecto. Esto incluso incluye archivos DDL para configurar y modificar cualquier esquema de base de datos, y también en la secuencia correcta. Menos, por supuesto, las herramientas necesarias para construir y ejecutar el proyecto, así como cualquier cosa que pueda derivarse / generarse automáticamente de otros archivos en el control de origen (como los archivos JavaDoc generados a partir de los archivos Java en el control de origen).

Es mejor poner casi todo bajo el sol en el control de la fuente.

• Código

• Bibliotecas

• Recursos

• Crear / implementar scripts

• Creación de bases de datos y scripts de actualización

• Cierta documentación

• Archivos de configuración específicos del entorno

Lo único que no se debe poner en control de fuente son los artefactos de construcción para su proyecto.

Yo diría que;

• cualquier archivo necesario para realizar la compilación pasa al control de versiones
• cualquier archivo (que puede ser) generado por la compilación no

Tendería a colocar binarios grandes como paquetes de instalación de herramientas en algún lugar fuera del tronco, pero aún deberían estar bajo el control de la versión.

¡Y no olvide poner también todo el código de la base de datos en Source Control! Esto incluiría las secuencias de comandos de creación originales, las secuencias de comandos para alterar las tablas (que están marcadas por la versión del software que las utiliza, para que pueda recrear cualquier versión de la base de datos para cualquier versión de las aplicaciones) y las secuencias de comandos para completar las tablas de búsqueda.

La experiencia duramente ganada me ha enseñado que casi todo pertenece al control de la fuente. (Mis comentarios aquí están coloreados por una década y media en desarrollo para sistemas integrados / de telecomunicaciones en hardware propietario con herramientas propietarias, y a veces difíciles de encontrar).

Algunas de las respuestas aquí dicen "no ponga binarios en el control de fuente". Eso está mal. Cuando trabajas en un producto con un montón de código de terceros y muchas bibliotecas binarias de proveedores, revisas las bibliotecas binarias . Porque, si no lo hace, en algún momento va a actualizar y se encontrará con problemas: la compilación se rompe porque la máquina de compilación no tiene la última versión; alguien le da al nuevo chico los viejos CD para instalar; el wiki del proyecto tiene instrucciones obsoletas sobre qué versión instalar; Peor aún, si tiene que trabajar en estrecha colaboración con el proveedor para resolver un problema en particular y le envían cinco conjuntos de bibliotecas en una semana, debeser capaz de rastrear qué conjunto de binarios exhibieron qué comportamiento. El sistema de control de fuente es una herramienta que resuelve exactamente ese problema.

Algunas de las respuestas aquí dicen "no pongas la cadena de herramientas en el control de fuente". No diré que está mal, pero es mejor poner la cadena de herramientas en el control de la fuente a menos que tenga un sistema de gestión de configuración (CM) sólido como roca . Nuevamente, considere el problema de actualización como se mencionó anteriormente. Peor aún, trabajé en un proyecto donde había cuatro sabores separados de la cadena de herramientas flotando cuando me contrataron, ¡ todos en uso activo ! Una de las primeras cosas que hice (después de que logré que una compilación funcionara) fue poner la cadena de herramientas bajo control de fuente. (La idea de un sistema CM sólido estaba fuera de toda esperanza).

¿Y qué sucede cuando diferentes proyectos requieren diferentes cadenas de herramientas? Caso en cuestión: después de un par de años, uno de los proyectos recibió una actualización de un proveedor y todos los Makefiles se rompieron. Resulta que confiaban en una versión más nueva de GNU make. Así que todos actualizamos. Whoops, los Makefiles de otro proyecto se rompieron. Lección: confirme ambas versiones de GNU make y ejecute la versión que viene con el pago de su proyecto.

O, si trabajas en un lugar donde todo lo demás está completamente fuera de control, tienes conversaciones como, "Hola, el chico nuevo está empezando hoy, ¿dónde está el CD para el compilador?" "No sé, no los he visto desde que Jack renunció, él era el guardián de los CD". "Uhh, ¿no fue eso antes de subir del segundo piso?" "Tal vez están en una caja o algo así". Y dado que las herramientas tienen tres años, no hay esperanza de obtener ese viejo CD del vendedor.

Todos los scripts de compilación pertenecen al control de código fuente. ¡Todo! Todo el camino hasta las variables de entorno. Su máquina de compilación debería poder ejecutar una compilación de cualquiera de sus proyectos ejecutando un solo script en la raíz del proyecto. ( ./buildes un estándar razonable; ./configure; makees casi tan bueno). El script debe configurar el entorno según sea necesario y luego lanzar cualquier herramienta que construya el producto (make, ant, etc.).

Si crees que es demasiado trabajo, no lo es. En realidad ahorra un montón de trabajo. Confirma los archivos una vez al principio del tiempo y luego cada vez que actualiza. Ningún lobo solitario puede actualizar su propia máquina y cometer un montón de código fuente que depende de la última versión de alguna herramienta, rompiendo la compilación para todos los demás. Cuando contrata nuevos desarrolladores, puede decirles que revisen el proyecto y lo ejecuten ./build. Cuando la versión 1.8 tiene una gran cantidad de ajuste de rendimiento, y modifica el código, los indicadores del compilador y las variables de entorno, debe asegurarse de que los nuevos indicadores del compilador no se apliquen accidentalmente a las versiones del parche de la versión 1.7, porque realmente necesitan el código cambios que van junto con ellos o ves algunas condiciones de carrera peludas.

Lo mejor de todo es que algún día te salvará: imagina que envías la versión 3.0.2 de tu producto un lunes. Hurra, celebra. El martes por la mañana, un cliente VIP llama a la línea directa de soporte, quejándose de este error supercrítico y urgente en la versión 2.2.6 que envió hace 18 meses . Y todavía tiene que admitirlo contractualmente, y se niegan a actualizarse hasta que pueda confirmar con certeza que el error está solucionado en el nuevo código, y que son lo suficientemente grandes como para hacerlo bailar. Hay dos universos paralelos:

• En el universo donde no tiene bibliotecas, cadenas de herramientas y scripts de compilación en el control de código fuente, y no tiene un sistema CM sólido como una roca ... Puede consultar la versión correcta del código, pero proporciona Usted todo tipo de errores cuando intenta construir. Veamos, ¿actualizamos las herramientas en mayo? No, esas fueron las bibliotecas. Ok, regrese a las viejas bibliotecas. Espere, ¿hubo dos actualizaciones? Ah sí, eso se ve un poco mejor. Pero ahora este extraño bloqueo del enlazador parece familiar. Oh, eso es porque las bibliotecas antiguas no funcionaban con la nueva cadena de herramientas, por eso tuvimos que actualizar, ¿verdad? (Le ahorraré la agonía del resto del esfuerzo. Lleva dos semanas y nadie está contento al final, ni usted, ni la gerencia, ni el cliente).

• En el universo donde todo está bajo control de origen, revisa la etiqueta 2.2.6, tiene una compilación de depuración lista en aproximadamente una hora, pasa un día o dos recreando el "error VIP", rastrea la causa, corrígelo la versión actual, y convencer al cliente para actualizar. Estresante, pero no tan malo como ese otro universo donde tu cabello es 3 cm más alto.

Dicho esto, puedes llevarlo demasiado lejos:

• Debe tener una instalación estándar del sistema operativo del que tenga una "copia dorada". Documéntelo, probablemente en un archivo README que esté en control de fuente, para que las generaciones futuras sepan que la versión 2.2.6 y anteriores solo se compilaron en RHEL 5.3 y 2.3.0 y más tarde solo se compilaron en Ubuntu 11.04. Si le resulta más fácil administrar la cadena de herramientas de esta manera, hágalo, solo asegúrese de que sea un sistema confiable.
• La documentación del proyecto es engorrosa de mantener en un sistema de control de fuente. Los documentos del proyecto siempre están por delante del código en sí, y no es raro trabajar en la documentación para la próxima versión mientras se trabaja en el código para la versión actual. Especialmente si todos los documentos de su proyecto son documentos binarios que no puede diferenciar ni fusionar.
• Si tiene un sistema que controla las versiones de todo lo utilizado en la compilación, ¡ úselo ! Solo asegúrese de que sea fácil de sincronizar con todo el equipo, de modo que todos (incluida la máquina de compilación) utilicen el mismo conjunto de herramientas. (Estoy pensando en sistemas como el pbuilder de Debian y el uso responsable de virtualenv de python).

Lo único que no pongo bajo control de origen son los archivos que puede regenerar fácilmente o que son específicos del desarrollador. Esto significa ejecutables y archivos binarios que se componen de su código fuente, documentación que se genera a partir de la lectura / análisis de archivos bajo control de origen y archivos específicos de IDE. Todo lo demás pasa al control de versiones y se gestiona adecuadamente.

El caso de uso para el control de fuente es: ¿Qué pasa si todas nuestras máquinas de desarrollo y todas nuestras máquinas de implementación fueron golpeadas por un meteorito? Desea que la recuperación esté lo más cerca posible del pago y la compilación. (Si eso es demasiado tonto, puede optar por "contratar a un nuevo desarrollador").

En otras palabras, todo lo que no sea SO, aplicaciones y herramientas debe estar en VCS, y en sistemas integrados, donde puede haber una dependencia de una versión binaria de herramienta específica, ¡también he visto las herramientas guardadas en VCS!

El control de fuente incompleto es uno de los riesgos más comunes que veo cuando consulto: hay todo tipo de fricción asociada con traer un nuevo desarrollador o configurar una nueva máquina. Junto con los conceptos de Integración continua y Entrega continua, debe tener una sensación de "Desarrollo continuo": ¿puede una persona de TI configurar una nueva máquina de desarrollo o implementación esencialmente automática, de modo que el desarrollador pueda mirar el código antes de que termine? su primera taza de café?

Cualquier cosa que contribuya al proyecto y para la que desee realizar un seguimiento de los cambios.

Las excepciones pueden incluir grandes blobs binarios, como imágenes, si está utilizando un scm que no maneja muy bien los datos binarios.

Drupal usa git, así que usaré la terminología de git. Usaría subrepos para cada módulo para poder extraer las actualizaciones del módulo de los repositorios oficiales de drupal, sin dejar de preservar la estructura de las implementaciones individuales. De esa forma, obtiene los beneficios de scriptability sin perder los beneficios de tener todo bajo control de fuente.

Todo debe estar bajo control de la fuente, excepto:

• Archivos de configuración, si incluyen opciones de configuración que son diferentes para cada desarrollador y / o cada entorno (desarrollo, prueba, producción)
• Archivos de caché, si está utilizando el almacenamiento en caché del sistema de archivos
• Archivos de registro, si está iniciando sesión en archivos de texto
• Cualquier cosa que le guste a los archivos de caché y archivos de registro es contenido generado
• (Muy) Archivos binarios grandes que es poco probable que cambien (a algunos sistemas de control de versiones no les gustan, pero si está usando hg o git no les importa mucho)

Piénselo así: cada nuevo miembro del equipo debería poder retirar una copia de trabajo del proyecto (menos los elementos de configuración).

Y no olvide poner los cambios en el esquema de la base de datos (volcados simples de SQL de cada cambio de esquema) también bajo control de versiones. Puede incluir documentación de usuario y api, si tiene sentido para el proyecto.

@maple_shaft plantea un problema importante con mi primera declaración con respecto a los archivos de configuración del entorno en los comentarios. Me gustaría aclarar que mi respuesta es a los detalles de la pregunta, que trata sobre Drupal o proyectos genéricos de CMS. En tales escenarios, normalmente tiene una base de datos local y de producción, y una opción de configuración del entorno son las credenciales de estas bases de datos (y credenciales similares). Es aconsejable que NO estén bajo el control de la fuente, ya que eso crearía varios problemas de seguridad.

Sin embargo, en un flujo de trabajo de desarrollo más típico, estoy de acuerdo con maple_shaft en que las opciones de configuración del entorno deben estar bajo control de origen para permitir una compilación y despliegue en un solo paso de cualquier entorno.

Todo lo que genera su compilación automatizada no entra en el control de origen. Cualquier cosa que no requiera modificación durante la compilación se realiza en el control de origen. Es así de simple.

Por ejemplo, lo siguiente no entra en el control de origen:

• código generado
• binarios generados
• cualquier cosa creada por tu construcción
• cualquier cosa creada en tiempo de ejecución por su servicio, proceso, aplicación web

Qué implica el control de fuente:

• cualquier cosa que un humano cree
• cualquier cosa creada por otra persona o grupo (por ejemplo, una biblioteca interna de terceros donde se distribuye el control de origen o los binarios de un proyecto de código abierto).
• scripts y otras fuentes que crean cosas como una base de datos (es decir, cómo volvería a crear la base de datos si todos los DBA se vuelven AWOL).

Estas reglas generales se basan en la noción de que cualquier cosa que esté bajo el control de la fuente podría ser modificada por un humano y podría tomar el valioso tiempo de alguien para entender por qué está allí.

Cualquier cosa que necesite trabajar y que pueda cambiar debe ser versionada de una forma u otra. Pero rara vez es necesario tener dos sistemas independientes que lo controlen.

Cualquier cosa generada de manera confiable generalmente se puede adjuntar a una versión de origen, por lo tanto, no es necesario realizar un seguimiento independiente: fuente generada, archivos binarios que no se pasan de un sistema a otro, etc.

Crear registros y otras cosas que probablemente a nadie le importan (pero nunca se sabe con certeza) generalmente son mejor rastreados por quien lo está generando: jenkins, etc.

Es necesario realizar un seguimiento de los productos de compilación que se pasan de un sistema a otro, pero un repositorio de Maven es una buena manera de hacerlo: no necesita el nivel de control que proporciona un control de origen. Los entregables suelen estar en la misma categoría.

Lo que queda (y en este punto, debería haber poco más que archivos de origen y configuración del servidor de compilación) entra en control de origen.

Mi respuesta es bastante simple: no binarios. Por implicación, casi todo lo demás.

(Sin embargo, definitivamente no son copias de seguridad de la base de datos ni migraciones de esquemas ni datos de usuario).

El control de origen es un mecanismo de seguimiento de cambios. Úselo cuando quiera saber quién cambió qué y cuándo.

El control de la fuente no es gratuito. Agrega complejidad a su flujo de trabajo y requiere capacitación para nuevos colegas. Sopesar los beneficios contra el costo.

Por ejemplo, puede ser difícil controlar las bases de datos. Solíamos tener un sistema donde tenía que guardar manualmente las definiciones en un archivo de texto y luego agregarlas al control de origen. Esto tomó mucho tiempo y no era confiable. Debido a que no era confiable, no podía usarlo para configurar una nueva base de datos o para verificar a qué hora se realizó un cambio. Pero lo mantuvimos durante años, desperdiciando innumerables horas, porque nuestro gerente pensó que "todas las cosas deberían estar bajo el control de la fuente".

El control de la fuente no es mágico. Pruébelo, pero abandónelo si no agrega suficiente valor para compensar el costo.

Cosas que no pondría en el control de la fuente:

• Claves secretas y contraseñas
• El SDK aunque es el mismo directorio y si hago un parche para el SDK, entonces debería hacerlo otro proyecto ya que sería por marco en lugar de por aplicación
• Bibliotecas de terceros como. Restos de migración, copias de seguridad, código compilado, código bajo otra licencia (quizás)

Por lo tanto, no hago un hg addremoveejemplo, ya que hago un nuevo clon de vez en cuando cuando se actualiza el SDK. Eso también me hace hacer una copia de seguridad completa cada vez que se actualiza el SDk y verificar que una nueva versión clonada desde el repositorio esté bien.

Le recomiendo el siguiente libro que aborda sus inquietudes:

Entrega continua: lanzamientos de software confiables a través de la automatización de compilación, prueba e implementación . Específicamente, el Capítulo 2 aborda los elementos que se colocarán en el control de origen, que, como han dicho algunas personas, es prácticamente todo, excepto el contenido generado principalmente como resultado de una compilación.

No estoy de acuerdo con una parte de la respuesta aceptada proporcionada por @FrustratedWithFormsDesigner menos porque defiende no colocar en el control de versiones las herramientas necesarias para construir el proyecto. En algún lugar del control de origen (adyacente al código que se está creando) deben estar los scripts de compilación para compilar el proyecto y los scripts de compilación que se ejecutan solo desde una línea de comandos. Si por herramientas quiere decir, IDEs y editores, no se les debería exigir que construyan el proyecto en absoluto. Estos son buenos para el desarrollo activo / rápido para los desarrolladores y la configuración de este tipo de entorno también puede ser programada o descargada desde otra sección de SCM o desde algún tipo de servidor de administración binario y la configuración de tales IDE debe ser lo más automatizada posible.

Tampoco estoy de acuerdo con lo que dice @Yannis Rizos sobre la colocación de configuraciones para entornos en control de fuente. La razón es que debería poder reconstruir cualquier entorno a voluntad utilizando nada más que scripts y no es manejable sin tener ajustes de configuración en el control de origen. Tampoco hay un historial de cómo han evolucionado las configuraciones para varios entornos sin colocar esta información en el control de la fuente. Ahora, la configuración del entorno de producción puede ser confidencial o las empresas pueden no querer colocarlos en el control de versiones, por lo que una segunda opción es colocarlos en el control de versiones para que tengan un historial y otorgar a este repositorio acceso limitado.

Mantenga todo el código en el control de versiones y todas las configuraciones y datos de usuario. Para ser específico de drupal, debe poner todo en el control de versiones, excepto archivos y configuraciones.php