Subversión y dependencies

Estoy tratando de encontrar una estrategia viable para un siguiente problema.

Tenemos varios proyectos web que dependen de nuestro marco. Todo está almacenado en nuestro SVN y tiene su propio proyecto con toda la estructura de directorys necesaria (troncales, tags, twigs). En un ejemplo, tenemos proyectos webprj01 y webprj02 y tenemos un marco frm01. Todos ellos tienen estructura de proyecto SVN habitual: tronco, tags, twigs.

webprj01 y webprj01 dependen de frm01 y en la vida real frm01 está presente como subdirectory de webprj01 y webprj02. Para lograr esto en SVN, es posible establecer svn: propiedad externa y podemos configurar frm01 para apuntar a / frm01 / trunk dentro de trunk de webprj01 y webprj02.

Para hacer una encoding de la vida real tenemos que tener los tres proyectos extraídos como una copy de trabajo y hacer los cambios a la base de código particular en su propia copy de trabajo. No hay forma de publicar cambios de webprj01 / frm01 al SVN. El cambio debe hacerse en copy de trabajo frm01 y transferirse a través de SVN a copys de trabajo webprj01 / frm01 y webprj02 / frm01.

Esta solución tiene un problema con las dependencies durante la bifurcación. Realizo una twig de producción desde SVN / webprj01 / trunk a /webprj01/branches/release-1.0.0. En dos días, mientras trabajaba en el segundo proyecto webprj02 y frm01, ya no puedo tener un checkout estable como a través de svn: external en branch release-1.0.0. El directory frm01 ya apunta a nuevos cambios de frm01 / trunk.

Descrito es solo una versión simplificada del problema. En nuestras situaciones de la vida real, las dependencies van a veces a cinco niveles de profundidad. Me gustaría poder get un código estable de SVN en cualquier momento. En diferentes palabras Cuando ramifiqué / etiqueté webprj01 como release-1.0.0. Quiero get un código estable para esa label en particular en un año desde la creación.

Es obvio que la estrategia descrita usando svn: externals no hace el trabajo. ¿Cuál sería tu experiencia con esta situación? No es necesario usar un solo pago. Incluso el uso de scripts de compilation u otra solución sería de ayuda aquí. Estoy buscando una solución a largo ploop al problema que no dependería en gran medida de las acciones humanas ya que somos propensos a cometer errores.

En el mundo de Java, no intentaría resolver esto utilizando solo un sistema de control de versiones; en su lugar, usaría una herramienta de administración de dependencies como Maven + un sistema de control de versiones.

En el lugar donde trabajo, tenemos una configuration que parece bastante común:

Cualquier proyecto "framework" vive en su propia estructura de directorys (trunk, tags, branches) como parece que ya tiene. Estos también se administran usando Maven y cada vez que se ingresa algo, se publica una nueva versión del componente (en la mayoría de los casos, un file JAR) en nuestra reposition local de Maven (que reside en un server Nexus).

Cualquier proyecto que necesite utilizar el proyecto "framework" tendrá una dependencia hacia una versión específica del proyecto de framework: Maven automáticamente extrae esta versión del server Nexus cada vez que se construye el proyecto.

Esto nos permite liberar cada proyecto y componente de marco por separado, pero aún así mantener un logging de las dependencies entre ellos. Incluso podemos tener múltiples versiones de los componentes de framework usados ​​por diferentes proyectos sin perder completamente la pista de las dependencies.

Hasta ahora, esto ha funcionado bastante bien para nosotros, solo puedo ver dos inconvenientes:

Lleva un time configurarlo, especialmente si no has usado antes a Maven.

Cuando libera cada proyecto, se produce cierta sobrecarga, ya que también desea liberar cada componente dependiente para evitar tener dependencies con respecto a la versión "troncal" de otros componentes (es decir, la versión "SNAPSHOT" en la terminología de Maven).

Erik tiene razón, un administrador de dependencies te ayudará: tal vez quieras investigar a maven o ant / ivy.

Usar svn: externals como administrador de dependencies de un hombre pobre es un truco y requiere mucha disciplina: es un PITA averiguar qué versión de un marco está incluida, y luego algún comodín va a establecer la reference externa en un proyecto para el tronco del marco y tendrás un momento realmente difícil para descifrar delta entre lanzamientos.

En el pasado he tenido js, ​​css y xsl en común para muchos proyectos empaquetados como files .tgz y publicados en un repository de hiedra por simples scripts ant, luego los proyectos tienen comstackciones ant (y files ivy.xml) que resuelven las dependencies y luego empaqueta todo. Funcionó pero

  • Los chicos de la web front-end lucharon con el control de la fuente, y mucho less con la administración de la dependencia. Fue realmente difícil hacer que "entendieran" lo suficiente como para publicar los cambios en un module común en un repository local y luego build un proyecto que dependiera de él para ver sus cambios.

  • El paso adicional que Erik mencionó, teniendo que liberar múltiples artefactos para tener algo listo para pinchar.

  • El layout legado de Cruddy significó la mayoría de los cambios en los que, en realidad, en el código común, 1 de cada 10 lanzamientos de los desplegables realmente tenían cambios en su código … por lo general, estaba en el código común incluido.

en serio – svn: externos como una gestión de la dependencia va a llegar a ser un dolor de cabeza. Vale la pena la inversión. Habiendo dicho que estos muchachos tenían problemas con la gestión de la dependencia, sería mucho less probable, así que ordera los svn: externos en muchas twigs que estás teniendo ahora.

Si tuviera que hacer eso otra vez, me volvería loco.