¿Cuáles son los methods efectivos para administrar la propiedad de los progtwigs en los sistemas de control de fonts?

Utilizando SVN o Git, se me ocurrió la idea de usar la estructura de directorys como un marcador de position de metadatos. Cada equipo tendría un directory en un repository compartido para su código. Cuanto más lo pienso, peor parece la idea. La razón por la que parece una mala idea para mí es que los equipos no son entidades estáticas. Los equipos pueden desaparecer, dividirse, recombinarse e incluso get un nuevo nombre. Sé que estoy buscando el uso de un identificador único y, probablemente, una database externa. Probablemente, incluso estoy enfrentando un repository por equipo para administrar apropiadamente los derechos de acceso. En una situación con 200 o más equipos, ¿es mejor mantener la propiedad en una database externa o hay algunas herramientas y prácticas de las que podría aprender?

Este es mi mejor bash de señalarte en las direcciones correctas. Generalmente hablando:

Organice su código fuente de acuerdo con los componentes de su sistema de la manera habitual. Asegúrese de que cada componente tenga control de acceso configurado independientemente (por ejemplo, en git, esto significa repositorys separados para cada componente, como dijo Makis).

El event handling los derechos de acceso comúnmente se realiza junto con LDAP en estos días. Configure su herramienta para aprovechar el directory LDAP de su organización de la manera habitual. (Para git, esto se hace más comúnmente usando las counts existentes en el sistema, que pueden o no estar respaldadas por LDAP).

Use los mecanismos de control de acceso incorporados de su sistema de control de versiones de la forma habitual para permitir que cada equipo lea o escriba en cada componente según corresponda. Si esta matriz de permissions se vuelve demasiado engorrosa para administrarla manualmente, cree un mecanismo personalizado para controlarla a un nivel superior y / o automatice las actualizaciones a gran escala.

Si no tiene una architecture de componentes, counts de usuario centralizadas o control de acceso para su VCS, abandone este problema hasta que solucione los problemas más importantes.

Así es como lo he visto hacer. Alinee la estructura del directory con las líneas tecnológicas relacionadas. Probablemente esto esté basado en el equipo ahora mismo. Use una database o algo para mapear binarys (o files fuente) a los miembros del equipo. Luego, cuando las cosas se muevan, todo lo que tienes que hacer es actualizar la database.

Si haces que la raíz sea bastante amplia, tendrás less reorganización para hacer más tarde que si la haces pequeña.

Git no tiene derechos de acceso muy bien. Para comenzar a manejarlo, necesitaría usar gitosis y luego escribir algún código en los ganchos de git. Tengo una pregunta con respecto a esto.

Entonces necesitaría, como dijo, una database para manejar la información sobre qué usuario puede acceder a qué repository. Es decir, necesitarías dividir las cosas en repositorys separados en git ya que no puedes proteger files individuales o directorys en git. Escribí una breve nota de blog sobre esto hace algún time. Los superproyectos podrían ayudar en el futuro, pero este concepto aún está en construcción y no está muy bien definido.

En herramientas SCM más elegantes (y costosas) como Rational ClearCase, tiene mejores herramientas para esto. Por ejemplo, puede crear componentes y definir derechos de usuario por componente. Lamentablemente, incluso estas herramientas requieren actualizaciones exhaustivas a mano si las cosas cambian mucho. Pero si los derechos de usuario son todo lo que necesita, sería mucho más rentable escribir sus propias herramientas en lugar de comprar uno de estos monstruos.

Dale a cada equipo su propio repository.

Leyendo tu pregunta He tenido una idea, que puede ser útil para ti (o no, es solo una idea flash que repentinamente ha aparecido en mi mente ;-):

  1. Al igual que con la herramienta 'devtodo' de Linux, puede crear un file en cada directory para los metadatos. (Para devtodo, el file se llama '.todo')
  2. Ese file de metadatos podría ser un file de database nosql , con los miembros del equipo en ese momento.
  3. Ese file de metadatos podría estar en la versión de control.
  4. Ese file de metadatos se podría unir (como la operación de unión a sql) con otros files, es decir, todos los miembros de sus equipos.
  5. Se puede definir un set de scripts o alias de shell para escribir la command-line de nosql más utilizada.

En pocas líneas: relacione los files de database en su git o svn con sus metadatos; y sin serveres de database.

Los metadatos que desea almacenar serían save información sobre los files y los miembros del equipo que trabajaron con los resources. Suponiendo que tiene una semántica madura de event handling resources en su repository, como comentarios de check-in, etc., una estrategia podría ser identificar los metadatos que está viendo e indexarlos usando alguna herramienta de indexing / api. Hay una gran cantidad de información disponible en los metadatos del repository que se puede recuperar e indexar. Si necesita un control más preciso, puede utilizar ganchos precompromisos personalizados para obligar a los miembros del equipo a colocar la información requerida durante el check-in. El repository de metadatos que tendría le daría un buen control para consultar / search usuarios y resources. La indexing puede realizarse mediante un script diario / semanal.

De acuerdo, entonces si he entendido bien tu pregunta, entonces tienes
1. Múltiples progtwigs
2. Múltiples equipos que trabajan en el código fuente
3. Una necesidad de rastrear qué equipos están trabajando en qué código

No especifica si cada vez funciona en un solo progtwig o si varios equipos pueden trabajar conjuntamente en ese progtwig.

No soy un usuario de GIT o SVN, mi experiencia principal es con fuerza, pero intentaré describir algunas de las mejores prácticas que deberían funcionar para cualquier sistema SCM de gran empresa.

  1. Tener una twig de código de línea principal: esta sería su área 'limpia'.
  2. Crea una sucursal de sandbox para cada equipo
  3. Use convenciones claras de nomenclatura

Cada sandbox de equipo tendría derechos de acceso completos a ese sandbox solamente pero no al sandbox de ningún otro equipo.

Entonces, en términos de layout de repository, tenga algo como esto

  • código
    • chutarse
      • progtwig1
      • progtwig2
    • equipo
      • teamA
        • progtwig1
      • equipoB
        • progtwig2

Cada equipo luego ramificará el código de las cosas en las que quieren trabajar en su caja de arena del equipo y podrán registrar lo que quieran. Si ensucian su propia twig, entonces está bien, es su problema resolver entre ellos y ejecutar cómo mejor les parezca.

Una vez que un equipo está contento de que tengan una buena próxima iteración de su código, el líder del equipo solo tiene permiso para promocionar e integrar los cambios hasta la línea principal.

Cualquier SCM decente le mostrará el historial de integración, por lo que para cada cambio promovido en la línea principal, sabrá qué equipo se integró y cuándo.

Si un equipo se disuelve, puedes abandonar la sucursal si lo deseas
Si el nombre de un equipo cambia, cree una nueva sucursal de sanbox para el nuevo equipo y luego integre los cambios del antiguo entorno limitado del equipo al nuevo entorno limitado

En forzosamente puedes hacer algunas cosas funky como reverse integrates, lo que es realmente agradable porque puedes desplegar la línea principal en tu twig, hacer fusiones y luego integrar de nuevo a la línea principal. Mientras nada más haya cambiado en el código, la integración simplemente se convierte en una copy directa. Esto tiene la ventaja de empujar la línea principal 'quebrada' hacia la caja de arena y mantener limpia la línea principal

De todos modos, son algunos de mis pensamientos. La administración de SCM es un área completa en sí misma y estoy seguro de que muchas otras personas tendrán algunas mejores soluciones, pero el enfoque anterior me ha funcionado

Algunos enlaces útiles en esta área compleja 🙂
Modelado del ciclo de vida del software
Prácticas recomendadas de alto nivel en SCM
Introducción a SCM – repositorys
SCM intro – twigs

Si se trata de un proyecto separado, simplemente dele un repository propio.