remove - git tag best practices

¿Cómo se utilizan los DVCS en equipos grandes? (6)

Recientemente comencé a involucrarme con Git en un proyecto personal, y puedo ver cómo un DVCS podría beneficiarnos en el trabajo (que es una gran empresa de software empresarial que actualmente ejecuta Perforce). El trabajo destacado en mi equipo, por ejemplo, consiste principalmente en desarrolladores que crean sus propias sucursales; A veces estos se comparten entre pequeños equipos de desarrolladores. Creo que sería más eficiente en este caso usar un DVCS.

Sin embargo, en el caso más general, me interesaría saber de personas que usan un DVCS en el trabajo, en equipos medianos a grandes.

¿Cómo lidias con las fusiones en N-way? ¿Es esto incluso un escenario común? Mercurial solo admite las combinaciones de N-way al hacer (N-1) fusiones de 2 vías (y read que esta es la solución preferida en otros DVCS), lo que parece un proceso muy laborioso incluso para una N. relativamente pequeña.
¿Utiliza un único repositorio central autorizado, o es realmente P2P?
¿Los desarrolladores a menudo empujan y tiran el código entre ellos, o todo va a través del repositorio central?

Aquí hay un ejemplo (de ninguna manera un "universal")

Tenemos VCS central (ClearCase o SubVersion, dependiendo de los diferentes proyectos), y los estamos utilizando para esfuerzos de desarrollo "oficiales" (desarrollo, parches, arreglos), donde el número de sucursales es limitado y está bien identificado.

Sin embargo, para refactorizar desarrollos que involucran una gran cantidad de estados intermedios, donde nada funciona, y donde muchos desarrolladores necesitan tener su propia rama o sucursales basadas en actividades, algunos repositorios Git se configuran entre ellos, de una manera P2P.
Una vez que el trabajo alcanza algún tipo de estabilidad de 0.1, y las fusiones se reducen, se reimportan en el VCS, donde el trabajo puede continuar de una manera central "ordenada".

Dado que Git en Windows funciona bien (MSysGit), conseguimos que pequeños desarrollos iniciales se realicen rápidamente de esa manera.

Sin embargo, todavía estamos evaluando a Git para un desarrollo de proyectos a gran escala.

El bastante famoso "Tech Talk: Linus Torvalds en git" explica cómo se usa para Linux (casi tan grande como el equipo que puedo imaginar)

Si recuerdo correctamente, su uso se comparó con una cadena de mando militar: cada módulo tiene un mantenedor, que maneja las solicitudes de extracción de los desarrolladores, luego hay algunas personas "más confiables" que se ocupan de extraer datos de los mantenedores del módulo en El repositorio oficial de git de kernel.org.

"Linux: Managing the Kernel Source With ''git''" también lo explica, aunque de nuevo no es una explicación concisa.

Esquema de flujo de whygitisbetterthanx de whygitisbetterthanx :

alt git work-flow con el administrador de integración http://whygitisbetterthanx.com/images/workflow-b.png

Para escalar esto a incluso más desarrolladores, simplemente agregue otra capa de "tenientes de confianza" entre el administrador de integración y los desarrolladores.

Llevo varios años trabajando con el equipo de compiladores de Haskell de Glasgow utilizando Darcs . Recientemente (hace varios meses) comencé a usar git para mi propia copia del repositorio, tanto para el rendimiento como para mejorar mi educación.

¿Cómo lidias con las fusiones en N-way?
No hay fusiones en N. Cada desarrollador origina un flujo de parches, y los flujos se combinan de uno en uno en cada repositorio. Entonces, si los desarrolladores N hacen cambios simultáneamente, se fusionan por pares.
¿Utiliza un único repositorio central autorizado?
Absolutamente. Es la única forma de saber qué es GHC y qué no lo es.
¿Los desarrolladores a menudo empujan y tiran el código entre ellos, o todo va a través del repositorio central?
Creo que depende de los desarrolladores y del VCS que estés usando. En el proyecto de GHC casi todos los tirones y empujes que veo pasan por el repositorio central. Pero hay un portero de peso pesado (autoadministrado) en los envíos al repositorio central, y si un colega tiene una solución de error que necesito ahora , lo sacaré directamente de su repositorio. Con darcs es muy fácil tirar un solo parche (en lugar de todo el estado como en git), y sé que mis compañeros en desarrollo, que tienen más experiencia con darcs, usan esta función mucho más que yo --- y les gusta mucho.
Con git , cuando estoy trabajando estrechamente con otro desarrollador, frecuentemente crearé una nueva sucursal con el propósito de compartirla con otra persona. Esa rama nunca llegará al repositorio central.

Mi equipo en mi empleador anterior usaba Git, y funcionó bien para nosotros. No éramos tan grandes (quizás 16 o más, ¿quizás con 8 comprometedores realmente activos?), Pero tengo respuestas a sus preguntas:

Las fusiones N-Way no son terriblemente comunes. Hicimos algunas convenciones sobre el nombre de las sucursales que nos permitieron escribir scripts que facilitaban el proceso de "ingeniería de lanzamiento" (uso citas de miedo porque no teníamos un ingeniero de lanzamiento), y la gente creaba sucursales privadas, pero rara vez tuvo un problema con la fusión de más de dos sucursales (vea la siguiente).
(y # 3). Teníamos un repositorio central en un servidor de desarrollo por tres razones: (a) La máquina de desarrollo tenía un RAID5 (más tolerante a fallas) y las copias de seguridad nocturnas (las estaciones de trabajo dev no eran todas las noches), (b) las versiones de producción se crearon en el servidor de desarrollo, y (c) tener un repositorio central de secuencias de comandos simplificadas. Como resultado, la fusión N-way simplemente nunca sucedió. Lo más cercano que tuvimos a N-way fue cuando alguien se fusionó lateralmente y luego se fusionó verticalmente.

Git fue realmente una gran cosa para nosotros debido a su alto grado de flexibilidad; sin embargo, tuvimos que establecer algunas convenciones (nombres de sucursales y etiquetas, ubicaciones de repositorios, guiones, etc.) o podría haber sido un poco caótico. Una vez que establecimos las convenciones, la flexibilidad que teníamos era simplemente fantástica.

Actualización: nuestras convenciones básicamente fueron así:

un directorio en nuestro servidor NFS que albergaba todos los repositorios centrales
teníamos varios proyectos que compartían componentes, por lo que los dividimos en bibliotecas, esencialmente, con sus propios repositorios, y los proyectos entregables solo los incluían como submódulos de git.
hubo cadenas de versión y nombres de versiones que se nos impusieron desde arriba, así que solo usamos una variante de esas como nombres de rama
De manera similar, para las etiquetas, siguieron los nombres de versión dictados por el proceso.
los proyectos entregados contenían un archivo de propiedades que leí en los scripts de shell, y eso me permitió escribir un solo script para gestionar el proceso de publicación de todos los proyectos, aunque cada uno tenía ligeras variaciones en el proceso: las variaciones se explicaron en esos archivos de propiedades
Escribí scripts que reconstruirían un paquete entregable desde cualquier etiqueta
el uso de git nos permitió controlar el acceso mediante PAM y / o permisos de usuario normales (ssh, etc.)
Hubo otras convenciones que son más difíciles de incluir en una lista con viñetas, como cuándo deben ocurrir las combinaciones. Realmente, otro chico y yo éramos una especie de "git gurus" de la casa, y ayudamos a todos a descubrir cómo usar las ramas y cuándo fusionarse.
Lograr que las personas se comprometieran en pequeños trozos y no arrojara bombas diferenciales en la rama maestra fue un desafío. Un hombre dejó caer alrededor de dos semanas sólidas de trabajo en un solo compromiso, y finalmente tuvimos que desentrañar todo. Una enorme pérdida de tiempo, y frustrante para todos.
Comentarios informativos y detallados para acompañar.

Hubo otras cosas que aprendes a medida que tu equipo adquiere experiencia y aprende a trabajar entre ellos, pero esto fue suficiente para que empezáramos.

Actualización : cualquiera que siga estas cosas por ahora ya lo sabe, pero Vincent Dreissen ha escrito una versión sólida y bastante exhaustiva (pero no exhaustiva) sobre la ingeniería de ramificaciones y lanzamientos con Git . Recomendaría encarecidamente que utilice su proceso como punto de partida porque, por dos motivos:

muchos equipos lo hacen de esta manera o están usando una variante cercana (incluidos Linux, Git y muchos otros equipos de proyectos OSS), lo que significa que este método ha sido probado y ajustado para que tenga éxito en la mayoría de las circunstancias. Es muy poco probable que enfrente un problema que no se haya resuelto y resuelto dentro de las limitaciones de este modelo.
Debido a lo anterior, casi cualquier ingeniero con experiencia en Git entenderá lo que está sucediendo. No tendrá que escribir documentación detallada sobre la naturaleza fundamental de su proceso de lanzamiento; solo tendrás que documentar cosas específicas solo para tu proyecto o equipo.

Probablemente sea mejor ver cómo funcionan los desarrolladores del kernel de Linux. Tienen un flujo de trabajo bastante complejo en el que se envían cambios desde muchas fuentes, y luego los desarrolladores confiables para cada subsytem (llamados tenientes) retiran los cambios, y cuando están contentos, envíenlos a Linus, quien eventualmente los arrastra a su árbol o los rechaza Por supuesto, es más complejo que eso, pero esa es una descripción general.