Digamos que tengo una computadora de escritorio y una computadora portátil, y algunas veces trabajo en la computadora de escritorio y otras veces en la computadora portátil.

¿Cuál es la forma más fácil de mover un repositorio de git hacia adelante y hacia atrás?

Quiero que los repositorios de git sean idénticos, para poder continuar donde lo dejé en la otra computadora.

Me gustaría asegurarme de tener las mismas ramas y etiquetas en ambas computadoras.

Gracias Johan

Nota: sé cómo hacer esto con SubVersion, pero tengo curiosidad por saber cómo funcionaría con git. Si es más fácil, puedo usar una tercera computadora como servidor clásico con el que las dos computadoras pueden sincronizarse.

Nota: Ambas computadoras ejecutan Linux.

Actualización :

Así que probemos la idea de XANI con un repositorio git simple en un servidor y la sintaxis del comando push de KingCrunch. En este ejemplo, hay dos clientes y un servidor.

Entonces, creemos primero la parte del servidor.

ssh user@server
mkdir -p ~/git_test/workspace
cd ~/git_test/workspace
git --bare init

Entonces, desde una de las otras computadoras, trato de obtener una copia del repositorio con clon:

git clone user@server:~/git_test/workspace/
Initialized empty Git repository in /home/user/git_test/repo1/workspace/.git/
warning: You appear to have cloned an empty repository.

Luego vaya a ese repositorio y agregue un archivo:

cd workspace/
echo "test1" > testfile1.txt
git add testfile1.txt
git commit testfile1.txt -m "Added file testfile1.txt"
git push origin master

Ahora el servidor se actualiza con testfile1.txt.

De todos modos, veamos si podemos obtener este archivo de la otra computadora.

mkdir -p ~/git_test/repo2
cd ~/git_test/repo2
git clone user@server:~/git_test/workspace/
cd workspace/
git pull

Y ahora podemos ver el archivo de prueba.

En este punto podemos editarlo con algo más de contenido y actualizar el servidor nuevamente.

echo "test2" >> testfile1.txt
git add testfile1.txt
git commit -m "Test2"
git push origin master

Luego volvemos al primer cliente y hacemos un git pull para ver el archivo actualizado. Y ahora puedo moverme hacia adelante y hacia atrás entre las dos computadoras y agregar una tercera si quiero.

Creo que hay múltiples enfoques. Solo describiré cómo manejo esto

Tengo una netbook como servidor 24 horas al día, 7 días a la semana, que tiene varios repositorios git. Desde / Hacia allí empujo y saco cambios a través de SSH. Para acceder desde el exterior utilizo dyndns.org. Funciona bien, especialmente porque tengo más de dos sistemas, que necesitan acceso a algunos de los repositorios.

Actualización: un pequeño ejemplo. Digamos que mi netbook se llama "netbook". Creo un repositorio allí

$ ssh username@netbook.local
$ cd ~/git
$ mkdir newThing
$ cd newThing
$ git init --bare

En mi escritorio, crearé un clon. Tal vez agregue algunos archivos también

$ git clone username@netbook.local:/home/username/git/newThing
$ git add .
$ git commit -m "Initial"
$ git push origin master

En mis portátiles haré (primero) lo mismo, pero para el acceso remoto (desde fuera de mi LAN), también agregaré la dirección externa.

$ git clone username@netbook.local:/home/username/git/newThing
$ git remote add externalName username@mydyndns.home-ip.org:/home/username/git/newThing
$ git pull externalName master

Es simplemente la forma en que funciona git (/ git workflows). Puede agregar tantos repositorios remotos como desee. No importa si dos o más se refieren a los mismos repositorios "físicos". No necesita un "servidor" local propio, puede utilizar cualquier servidor público al que tenga acceso ssh. Y, por supuesto, no necesita un servidor público en absoluto, si no necesita acceso desde el exterior. El repositorio simple también puede estar en el sistema de escritorio y luego puede crear un repositorio de copia de trabajo dentro del sistema de archivos local.

$ mkdir myRepo; cd myRepo
$ git init --bare
$ cd /path/to/myProject
$ git remote add origin /path/to/myRepo
$ git add .; git commit -m "Initial"; git push origin master

Esta es la forma, cómo manejo esto, y para mí funciona bastante bien (si no perfecto;))

Algo para leer: http://progit.org/ Muy buen libro.-

Clonaría el repositorio de un cuadro a otro, y luego configuraría los dos repositorios para poder hacerlo git fetchdesde el otro cuadro.

Cambiar el nombre del mando a distancia por originel nombre de la otra caja hace que las ramas remotas sean más fáciles de leer.

Tenga en cuenta que con solo usar git fetch(y no git push), esto funciona bien con repositorios no desnudos:

[user@foo repo]$ git fetch -v bar

[user@bar repo]$ git fetch -v foo

La forma más fácil: repositorio central creado con --bare(por lo que no hay archivos extraídos, solo cosas .git) o ​​github

"Distribuido" se verá así:

Preparar:

1. En la computadora portátil: git remote add desktop ssh://user@desktop/home/user/repo/path
2. En el escritorio: git remote add laptop ssh://user@laptop/home/user/repo/path

Sincronización:

git pull laptop/desktop (push no funcionará muy bien en repositorios no desnudos porque git no modificará los archivos extraídos cuando se empuje al repositorio remoto)

O hacer repositorio en pendrive;)

¿Qué tal simplemente usar rsync?

¿No podría simplemente crear un repositorio remoto en GitHub, BitBucket o GitLab? (Las dos últimas empresas ofrecen repositorios privados gratuitos ilimitados). Cuando termine el día en el trabajo, simplemente use git pushpara enviar sus cambios al repositorio remoto. Cuando llegues a casa, hazlo git pullpara transferir los cambios del trabajo a la máquina de tu casa. Asimismo, cuando termines en casa hazlo git pushy luego cuando regreses al trabajo hazlo git pull.

¿Cuál es la forma más sencilla de mover un repositorio de git hacia adelante y hacia atrás [entre 2 computadoras]?

Escenario 1: Trabajo (edito código y archivos) exclusivamente en PC1, pero quiero tener una copia duplicada de los archivos (por ejemplo, para construir toda la base del código) también en PC2.

Sincronice de PC1 a PC2 en <1 minuto a través de un punto de acceso wifi mientras usa <25 MB de datos:

Trabajo en una computadora débil con la que viajo (una computadora portátil), pero construyo una computadora más poderosa ubicada en otro lugar. Uso git todo el tiempo para sincronizar desde mi computadora portátil a la otra computadora usando un script. Solo escribo este comando para ejecutarlo:

sync_git_repo_from_pc1_to_pc2

¡Eso es! Por lo general, toma alrededor de 25 MB de datos y ~ 30 segundos a 1 minuto, incluso cuando se usa un punto de acceso wifi de un teléfono celular y se trabaja en un repositorio que tiene un tamaño de docenas de gigabytes . Estoy conectado a PC2, así que lo hago git log -1en PC2 para verificar que la sincronización funcionó, luego ejecuto el comando de compilación. Funciona perfectamente. Dale un tiro. Consulte los enlaces a continuación para obtener más detalles.

Nota: el repositorio clonado en PC2 estará en una rama de git llamada somename_SYNC. Modifique la secuencia de comandos de forma adecuada si desea que tenga el mismo nombre de rama en lugar de utilizar siempre una "rama SYNC". Es posible modificar la secuencia de comandos para obtener un efecto más parecido al Escenario 2 a continuación si lo desea. Sin embargo, realizar el Escenario 2 manualmente no es difícil, por lo que es posible que desee continuar con el Escenario 2 manualmente. Es el escenario 1 donde el script automatizado es el más beneficioso y ahorra tiempo, ya que permite un flujo de trabajo fácil y rápido de "modificar, sincronizar, construir" donde "modificar" tiene lugar en PC1, "sincronizar" se ejecuta desde PC1 pero también afecta PC2, y la "construcción" se lleva a cabo en PC2.

Enlaces:

1. Instrucciones completas de configuración e instalación aquí:
   Trabaje en un proyecto remoto con Eclipse a través de SSH
2. Léame, documentación y repositorio aquí: https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles/blob/master/useful_scripts/README_git-sync_repo_from_pc1_to_pc2.md .
3. El script exacto en cuestión está aquí:
   https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles/blob/master/useful_scripts/sync_git_repo_from_pc1_to_pc2.sh

Escenario 2: trabajo (edito código y archivos) en varias computadoras y quiero poder editar el mismo repositorio de código desde cualquier computadora del mundo:

Quiero que los repositorios de git sean idénticos, para poder continuar donde lo dejé en la otra computadora. Me gustaría asegurarme de tener las mismas ramas y etiquetas en ambas computadoras.

1. Vaya a https://github.com y cree una cuenta y, opcionalmente (recomendado), configure las claves ssh .

2. Ahora use su interfaz web para crear un nuevo repositorio.

   1. A partir del año 2020 o antes, GitHub también permite repositorios privados gratuitos , por lo que esto funciona bien incluso para proyectos privados de código cerrado.

3. Busque el nuevo repositorio ssh o https clon URL. Ejemplo: git@github.com: ElectricRCAircraftGuy / eRCaGuy_dotfiles.git o https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles.git .

4. Clone el proyecto en PC1. Ex:

    git@github.com:ElectricRCAircraftGuy/eRCaGuy_dotfiles.git
    cd eRCaGuy_dotfiles
   

5. Y repita exactamente el mismo comando de clonación en PC2.

6. Ahora en la PC1, haga algunos cambios, consúltelos y envíelos a su repositorio "remoto" en github:

    # edit some files, then do the following
    git add -A  # stage ("add") all changed files to be committed 
    git commit  # commit them
    git push    # push them to your remote github repo
   

7. Ahora en PC2, introduzca sus cambios:

    # pull all changes from github (which includes the changes
    # you just pushed from PC1) to PC2
    git pull  
   

8. Ahora puede editar archivos en PC2, confirmarlos y enviarlos a github usando los comandos que se muestran solo en los 2 pasos anteriores, y luego desde PC1 puede ejecutar git pullpara extraer esos cambios desde PC2.

9. Siga haciendo este proceso, según sea necesario, trabajando en PC1 O PC2, y comparta fácilmente los archivos y divida su trabajo entre las dos computadoras. Solo recuerde que todos sus cambios deben confirmarse y enviarse a github en una PC antes de poder verificarlos (extraerlos) y continuar trabajando en la otra PC.

10. Si alguna vez te encuentras en una situación en la que los archivos están un poco desincronizados entre las dos PC, quizás tengas que usar algunas ramas adicionales, hacer algunas fusiones, resolver conflictos, etc. Entonces, se vuelve más similar a trabajar con un pequeño equipo en el que todos trabajan en el mismo repositorio. Google es tu amigo. Git es muy, muy poderoso y tiene un comando, un conjunto de comandos o un flujo de trabajo para casi todo.

Bueno, puede empujar y tirar (a través de Git) al servidor que potencialmente podría configurar. O puede almacenar sus repositorios en GitHub y usarlos como puente de sincronización.

Puede crear el repositorio en cualquiera de sus computadoras, probablemente la de escritorio y empujar / tirar de él desde la computadora portátil y desde sí mismo.