¿Cómo usar un sistema de control de fuente?

Entiendo que la mayoría de ustedes me fruncen el ceño por no usar ningún control de fuente. Quiero hacerlo, realmente lo hago, ahora que he pasado un time leyendo las preguntas / respuestas aquí. Soy un progtwigdor aficionado y realmente no hago mucho más que jugar, pero he sido mordido un par de veces sin tener a mano la "máquina del time" …

Todavía tengo que decidir con qué producto iré, pero eso no es relevante para esta pregunta.

Realmente estoy luchando con el flujo de files bajo el control de la fuente, tanto que ni siquiera estoy seguro de cómo plantear la pregunta con sensatez.

Actualmente tengo una jerarquía de directory donde todos mis files PHP viven en un entorno Linux. Los edito allí y puedo presionar Actualizar en mi browser para ver qué pasa.

Según lo entiendo, mis files ahora viven en un lugar diferente. Cuando quiero editar, lo reviso y lo edito. Pero, ¿cuál es mi sustituto para F5? ¿Cómo lo pruebo? ¿Tengo que volver a controlarlo y luego presionar F5? Admito un poco de testing y error en mi trabajo. Sospecho que me voy a cansar de registrarme y salir muy rápido para los pequeños cambios frecuentes que tiendo a hacer. Me falta algo, ¿verdad?

¿Alguien puede guiarme a través de dónde vive todo y cómo lo pruebo en el path, mientras me mantengo fiel al objective de tener a mano una 'máquina del time'?

Eric Sink tiene una gran serie de publicaciones sobre conceptos básicos de control de fuente. Su compañía (Sourcegear) hace una herramienta de control de fuente llamada Vault, pero el modo de hacerlo es generalmente bastante agnóstico al sistema.

  1. No edite su código en producción.
  2. Cree un entorno de desarrollo con los services apropiados (apache w / mod_php).
  3. El directory de la aplicación dentro de su entorno de desarrollo es donde hace su trabajo.
  4. Pon tu aplicación de producción actual allí.
  5. Confirme este directory con la herramienta de control de origen. (ahora tiene un control de fuente poblado con su aplicación)
  6. Realice cambios en su nuevo entorno de desarrollo, presionando F5 cuando desee ver / probar lo que ha cambiado.
  7. Fusionar / Confirmar sus cambios al control de origen.

En realidad, sus files, mientras están almacenados en un repository de origen (palabra grande para otro lugar en su disco duro o disco duro en otro lugar), también pueden existir en su máquina local, justo donde existen ahora.

Por lo tanto, todos los files que no están desprotegidos se marcarán como "de solo lectura" si usa VSS (no está seguro acerca de SVN, CVS, etc.). Por lo tanto, aún puede ejecutar su website presionando "F5" y volverá a cargar los files donde se encuentran actualmente. Si marca uno y lo está editando, NO se convierte en solo lectura, y puede cambiarlo.

De todos modos, el server web que está ejecutando cargará files de solo lectura / escritura con el mismo efecto.

Aún tienes todos los files en tu disco duro, ¡listos para F5!

La diferencia es que puedes "marcar" tus files en el repository. Tu vida diaria no tiene que cambiar en absoluto.

Puede hacer un "pago" en el mismo directory donde trabaja actualmente para que no tenga que cambiar. Básicamente, su directory de trabajo no necesita cambiar.

Esta es una pregunta abiertamente abierta porque cómo usa un SCM depende en gran medida de qué SCM elija. Un SCM distribuido como git funciona de manera muy diferente a uno centralizado como Subversion.

svn es mucho más fácil de digerir para el "nuevo usuario", pero git puede ser un poco más poderoso y mejorar su flujo de trabajo. Subversion también tiene excelentes documentos y soporte de herramientas (como trac), y un libro en línea que debe leer:

http://svnbook.networking-bean.com/

Cubrirá los aspectos básicos de la administración de control de origen que le ayudará de alguna manera sin importar qué SCM elija en última instancia, por lo que recomiendo pasar los primeros capítulos.

edit: Permítanme señalar por qué la gente le está frunciendo el ceño, por cierto: SCM es más que simplemente una "copy de security de su código". Tener "timemachine" no es nada como un SCM. Con un SCM puedes volver atrás en tu historial de cambios y ver qué cambiaste realmente y cuándo es algo que nunca obtendrás con blobs de código. Estoy seguro de que se preguntó en más de una ocasión: "¿cómo llegó este código aquí?" o "Pensé que arreglé ese error" – si lo hizo, es por eso que necesita SCM.

No "tiene" que cambiar su flujo de trabajo de manera drástica. Podrías, y en algunos casos deberías, pero eso no es algo que dicta el control de versiones.

Simplemente usa los files como lo harías normalmente. Solo bajo control de versión, una vez que alcanzas un cierto estado de "terminado" o al less "funcionando" (resolvió un problema en tu rastreador de problemas, finalizó un método determinado, retocó algo, etc.), lo registras.

Si tiene más de un desarrollador trabajando en su base de código, asegúrese de actualizar regularmente, por lo que siempre está trabajando contra una versión reciente (fusionada) del código.

Aquí está el flujo de trabajo general que usaría con un sistema de control de fuente no centralizado como CVS o Subversion: Al principio importa su proyecto actual en el llamado repository, un almacenamiento versionado de todos sus files. Tenga cuidado únicamente de importar files generados manualmente (fuente, files de datos, files make, files de proyecto). Los files generados (files de object, ejecutables, documentation generada) no deben colocarse en el repository.

Luego debe verificar su copy de trabajo. Como su nombre lo indica, aquí es donde hará todas sus ediciones locales, donde comstackrá y hacia dónde dirigirá su server de testing. Básicamente es el reemploop al lugar donde trabajabas antes. Solo necesita hacer estos pasos una vez por proyecto (aunque puede verificar múltiples copys de trabajo, por supuesto).

Este es el ciclo de trabajo básico: al principio, verifica todos los cambios realizados en el repository en su copy de trabajo local. Cuando se trabaja en equipo, esto generará los cambios que otros miembros del equipo hayan realizado desde su último control de salida. Entonces haces tu trabajo. Cuando hayas terminado con un set de tareas, deberías revisar la versión actual nuevamente y resolver posibles conflictos debido a cambios por parte de otros miembros del equipo. (En un equipo disciplinado, esto generalmente no es un problema.) Haga la testing, y cuando todo funcione según lo esperado, comprométase (controle) sus cambios. Luego puede continuar trabajando, y una vez que haya terminado de nuevo, revise, resuelva conflictos y vuelva a registrarse. Tenga en count que solo debe confirmar los cambios que fueron probados y funcionan. La frecuencia con la que se registra es una cuestión de gusto, pero una regla general dice que debe comprometer sus cambios al less una vez al final de su día. Personalmente, hago mis cambios mucho más a menudo que eso, básicamente cada vez que hago un set de cambios relacionados que pasan todas las testings.

Gran pregunta Con el control de fuente, aún puede hacer su process de actualización "F5". Pero después de cada edición (o algunas ediciones menores) desea verificar su código para que tenga una copy de security.

Dependiendo del sistema de control de fuente, no tiene que extraer explícitamente el file cada vez. Solo editando el file lo verificará. He escrito una guía visual para el control de la fuente que mucha gente ha encontrado útil al resumir lo básico.

Recomendaría un sistema de control de versiones distribuidas (mercurial, git, bazaar, darcs) en lugar de un sistema de control de versiones centralizado (cvs, svn). Son mucho más fáciles de configurar y trabajar.

Pruebe mercurial (que es el VCS que usé para entender cómo funciona el control de versiones) y luego, si lo desea, puede incluso cambiar a git.

Hay un buen tutorial introductorio en la página principal de Mercurial: Entendiendo a Mercurial . Eso le presentará los conceptos básicos sobre VCS y cómo funcionan las cosas. Es realmente genial. Después de eso, te sugiero que pases a los tutoriales de Mercurial: la página del tutorial de Mercurial , que te enseñará cómo usar Mercurial. Finalmente, tiene un ebook gratuito que es una gran reference sobre cómo usar Mercurial: Control de Revisión Distribuida con Mercurial

Si te sientes más aventurero y quieres comenzar con Git de inmediato, entonces este ebook gratuito es un gran lugar para comenzar: Git Magic (lectura muy fácil)

Al final , sin importar qué herramienta de VCS elija, lo que terminará haciendo es lo siguiente:

  1. Tenga un repository que no edite manualmente, solo para el VCS
  2. Tenga un directory de trabajo donde realice los cambios como de costumbre.
  3. Cambia lo que quieras, presiona F5 tantas veces como desees. Cuando le gusta lo que ha hecho y piensa que le gustaría save el proyecto tal como está en ese mismo momento (al igual que lo haría cuando está escribiendo, por ejemplo, algo en Word), puede confirmar sus cambios. al repository.
  4. Si alguna vez necesita regresar a cierto estado en su proyecto, ahora tiene el poder para hacerlo.

Y eso es más o less.

Si está utilizando Subversion, revisa sus files una vez . Luego, cada vez que haya hecho grandes cambios (o vaya a almorzar o lo que sea), los compromete con el server. De esta forma, puede mantener su flujo de trabajo anterior presionando F5, pero cada vez que se compromete , guarda una copy de todos los files en su estado actual en su repository SVN.

Depende del sistema de control de fuente que use. Por ejemplo, para subversión y cvs, sus files pueden residir en una location remota, pero siempre verifica su propia copy localmente. Esta copy local (a menudo referida como la working copy ) son solo files regulares en el sistema de files con algunos metadatos para permitirle cargar sus cambios de vuelta al server.

Si está utilizando Subversion aquí hay un buen tutorial .

Dependiendo del sistema de control de la fuente, 'checkout' puede significar cosas diferentes. En el mundo de SVN, solo significa recuperar (podría ser una actualización, podría ser un file nuevo) la última copy del repository. En el mundo de fuente segura, eso generalmente significa actualizar el file existente y bloquearlo. El siguiente text usa el significado SVN:

Usando PHP, lo que quiere hacer es revisar su proyecto / sitio completo en una carpeta de trabajo en un sitio de testing de Apache. Debería configurar el repository para que esto pueda suceder con un único process de pago, incluidas las subcarpetas necesarias. Pagará su proyecto para configurarlo una vez .

Ahora puede hacer los cambios y presionar F5 para actualizar como siempre. Cuando esté satisfecho con un set de cambios para admitir una solución o function en particular, puede comprometerse como una unidad (con los comentarios apropiados, por supuesto). Esto pone la última versión en el repository.

Revisar / comprometer un file a la vez sería una molestia.

Un sistema de control de origen generalmente es un lugar de almacenamiento para sus files y su historial, y generalmente está separado de los files en los que está trabajando actualmente. Depende un poco del tipo de sistema de control de versiones, pero suponga que está utilizando algo parecido a CVS (como la subversión), y que todos sus files vivirán en dos (o más) lugares. Tiene los files en su directory local, la llamada "copy de trabajo" y otra en el repository, que puede ubicarse en otra carpeta local, o en otra máquina, a la que generalmente se accede a través de la networking. Por lo general, después de la primera import de sus files en el repository los revisa en una carpeta de trabajo donde continúa trabajando en ellos. Supongo que esa sería la carpeta donde ahora viven sus files PHP.

Ahora, ¿qué sucede cuando ha comprobado una copy y ha realizado algunos cambios no triviales que desea "save"? Simplemente debe enviar esos cambios en su copy de trabajo al sistema de control de versiones. Ahora tienes un historial de tus cambios. Si en algún momento desea volver a la versión en la que realizó dichos cambios, puede simplemente revertir su copy de trabajo a una revisión anterior (el nombre dado al set de cambios que realiza de inmediato).

Tenga en count que todo esto es muy específico de CVS / SVN, ya que GIT podría funcionar ligeramente diferente. Recomiendo comenzar con la subversión y leer los primeros capítulos del excelente Libro SVN para que comiences.

Todo esto es muy subjetivo dependiendo de la solución de control de fuente que decida usar. Uno que definitivamente querrá examinar es Subversion.

Mencionaste que estás haciendo PHP, pero ¿lo estás haciendo en un entorno Linux o en Windows? No es realmente importante, pero lo que normalmente hacía cuando trabajaba en un entorno PHP era tener una twig de producción y una twig de desarrollo. Esto me permitió configurar un trabajo cron (una tarea progtwigda en Windows) para extraer automáticamente de la sucursal preparada para la producción para el server de producción, mientras me retiro de la twig de desarrollo para mi server de desarrollo.

Una vez que decida sobre una herramienta, realmente debería dedicarle un time a aprender cómo funciona. Los conceptos de input y salida no se aplican a todas las soluciones de control de fuente, por ejemplo. De cualquier manera, le recomiendo que elija uno que permita la ramificación. Este artículo repasa un excelente (en mi opinión) model de control de origen para seguir en un entorno de producción.

Por supuesto, declaro que todo esto no ha "modificado" en años. He estado haciendo desarrollo profesional por un time y mis técnicas pueden ser excesivas para alguien en su position. No quiere decir que haya algo de malo en eso, sin embargo.

Solo quiero agregar que el sistema que creo que fue más fácil de configurar y trabajar fue Mercurial . Si trabajas solo y no en un equipo, solo debes inicializarlo en tu carpeta de trabajo normal y luego continuar desde allí. El flujo normal es editar cualquier file usando su editor favorito y luego a un checkin (commit). No he probado GIT pero supongo que es muy similar. Monotone fue un poco más difícil de empezar. Todos estos son sistemas de control de fuente distribuidos.

Parece que estás preguntando cómo usar el control de código fuente para administrar las versiones.

Aquí hay algunas pautas generales que no son específicas de los sitios web:

  • Use una copy local para desarrollar cambios
  • Comstack (si corresponde) y testing tus cambios antes de registrarte
  • Ejecute comstackciones y testings automatizadas tan a menudo como sea posible (al less diariamente)
  • Actualice sus comstackciones diarias (tenga alguna forma de especificar los bits exactos de código correspondientes a una compilation y testing en particular)
  • Si es posible, use twigs separadas para las versiones principales (o tenga una twig de desarrollo y una de lanzamiento)
  • Cuando sea necesario, estabilice su código base (defina un set de testings tales que pasar todas esas testings significa que tiene la suficiente confianza en la calidad de su producto para liberarlo, luego conduzca hacia 0 fallas de testing, es decir, prohibir cualquier checkins a la twig de publicación aparte de las soluciones para los problemas pendientes)
  • Cuando tenga una compilation que tenga las características que desea y haya pasado todas las testings necesarias, impleméntela.

Si tiene un equipo pequeño, un producto estable, una compilation rápida y testings eficientes y de alta calidad, todo este process podría estar 100% automatizado y podría llevarse a cabo en cuestión de minutos.

Recomiendo Subversion . Configurar un repository y usarlo en realidad es bastante trivial, incluso desde la línea de command. Así es como funcionaría:

si no ha configurado su repo (repository)

1) Asegúrate de que tienes Subversion instalado en tu server

 $ which svn /usr/bin/svn 

que es una herramienta que te dice el path a otra herramienta. si no devuelve nada, esa herramienta no está instalada en su sistema

1b) Si no, obténgalo

 $ apt-get install subversion 

apt-get es una herramienta que instala otras herramientas en tu sistema

Si ese no es el nombre correcto para la subversión en apt, intente esto

 $ apt-cache search subversion 

o esto

 $ apt-cache search svn 

Encuentre el nombre correcto del package e instálelo usando apt-get install nombnetworkingelpackage

2) Crea un nuevo repository en tu server

 $ cd /path/to/directory/of/repositories $ svnadmin create my_repository 

svnadmin create reponame crea un nuevo repository en el presente directory de trabajo ( pwd ) con el nombre de reponame

Ya terminaste de crear tu repository

si tiene un repository existente, o ha terminado de configurarlo

1) Asegúrate de que tienes Subversion instalado en tu máquina local según las instrucciones anteriores

2) Mira el repository a tu máquina local

 $ cd /repos/on/your/local/machine $ svn co svn+ssh://www.myserver.com/path/to/directory/of/repositories/my_repository 

svn co es el command que usas para consultar un repository

3) Crea tu estructura de directory inicial (opcional)

 $ cd /repos/on/your/local/machine $ cd my_repository $ svn mkdir branches $ svn mkdir tags $ svn mkdir trunk $ svn commit -m "Initial structure" 

svn mkdir ejecuta un mkdir normal y crea un directory en el directory de trabajo actual con el nombre que proporcione después de escribir svn mkdir y luego lo agrega al repository.

svn commit -m "" envía sus cambios al repository y lo actualiza. Lo que sea que coloque en las citas después de -m es el comentario de esta confirmación (¡haga que cuente!).

La "copy de trabajo" de su código iría en el directory troncal . twigs se usa para trabajar en proyectos individuales fuera del tronco; cada directory en las twigs es una copy del tronco para un subproyecto diferente. tags se usa más lanzamientos. Sugiero centrarme en trunk por un time y acostumbrarme a Subversion.

trabajando con su repository

1) Agregue código a su repository

 $ cd /repos/on/your/local/machine $ svn add my_new_file.ext $ svn add some/new/directory $ svn add some/directory/* $ svn add some/directory/*.ext 

La penúltima línea agrega todos los files en ese directory. La última línea agrega todos los files con la extensión .ext.

2) Verifica el estado de tu repository

 $ cd /repos/on/your/local/machine $ svn status 

Eso le dirá si hay files nuevos y actualizados, y files con conflictos (diferencias entre su versión local y la versión en el server), etc.

3) Actualiza tu copy local de tu repository

 $ cd /repos/on/your/local/machine $ svn up 

La actualización extrae cualquier cambio nuevo del server que aún no tiene

A svn up le importa en qué directory se encuentra. Si desea actualizar todo el repository, asegúrese de estar en el directory raíz del repository (arriba del enlace)


Eso es todo lo que necesitas saber para comenzar. Para get más información, le recomiendo que consulte el Libro de Subversion .