¿Cómo puedo conciliar HEAD separado con maestro / origen?

Soy nuevo en las complejidades de ramificación de Git. Siempre trabajo en una sola rama y confirmo cambios y luego me desplazo periódicamente a mi origen remoto.

Recientemente, en algún lugar, restablecí algunos archivos para sacarlos de la puesta en escena de la confirmación, y luego hice una rebase -ipara deshacerme de un par de confirmaciones locales recientes. Ahora estoy en un estado que no entiendo del todo.

En mi área de trabajo, git logmuestra exactamente lo que esperaría: estoy en el tren correcto con los compromisos que no quería que se fueran, y los nuevos allí, etc.

Pero simplemente ingresé al repositorio remoto, y lo que hay allí es diferente: un par de los compromisos que maté en el rebase fueron empujados, y los nuevos cometidos localmente no están allí.

Creo que "maestro / origen" está separado de HEAD, pero no estoy 100% claro sobre lo que eso significa, cómo visualizarlo con las herramientas de línea de comandos y cómo solucionarlo.

Primero, aclaremos qué es HEAD y qué significa cuando se separa.

HEAD es el nombre simbólico para el commit actualmente desprotegido. Cuando HEAD no está separado (la situación "normal" ¹ : tiene una rama desprotegida), HEAD señala la "referencia" de una rama y la rama apunta a la confirmación. HEAD está "unido" a una rama. Cuando realiza una nueva confirmación, la rama a la que apunta HEAD se actualiza para que apunte a la nueva confirmación. HEAD sigue automáticamente ya que solo apunta a la rama.

• git symbolic-ref HEADrendimientos refs/heads/master
  La rama llamada "maestro" está desprotegida.
• git rev-parse refs/heads/masterceder 17a02998078923f2d62811326d130de991d1a95a
  Ese compromiso es la punta actual o "cabeza" de la rama maestra.
• git rev-parse HEADtambién rinde 17a02998078923f2d62811326d130de991d1a95a
  Esto es lo que significa ser una "referencia simbólica". Apunta a un objeto a través de alguna otra referencia.
  (Las referencias simbólicas se implementaron originalmente como enlaces simbólicos, pero luego se cambiaron a archivos simples con interpretación adicional para que pudieran usarse en plataformas que no tienen enlaces simbólicos).

Tenemos HEAD→ refs/heads/master→17a02998078923f2d62811326d130de991d1a95a

Cuando HEAD está separado, apunta directamente a un commit, en lugar de señalar indirectamente a uno a través de una rama. Puedes pensar en un HEAD separado como si estuviera en una rama sin nombre.

• git symbolic-ref HEAD falla con fatal: ref HEAD is not a symbolic ref
• git rev-parse HEADcede 17a02998078923f2d62811326d130de991d1a95a
  Dado que no es una referencia simbólica, debe apuntar directamente al compromiso en sí.

Tenemos HEAD→17a02998078923f2d62811326d130de991d1a95a

Lo importante para recordar con un HEAD separado es que si el commit al que apunta no tiene referencia (ninguna otra referencia puede alcanzarlo), entonces se convertirá en "colgante" cuando compruebe algún otro commit. Eventualmente, tales confirmaciones pendientes se podarán a través del proceso de recolección de basura (de forma predeterminada, se conservan durante al menos 2 semanas y pueden mantenerse más tiempo al hacer referencia al reflog de HEAD).

¹ Está perfectamente bien hacer un trabajo "normal" con una CABEZA separada, solo tiene que hacer un seguimiento de lo que está haciendo para evitar tener que sacar el historial eliminado del registro.

Los pasos intermedios de un rebase interactivo se realizan con un HEAD separado (parcialmente para evitar contaminar el reflog de la rama activa). Si finaliza la operación de rebase completa, actualizará su rama original con el resultado acumulativo de la operación de rebase y volverá a conectar HEAD a la rama original. Supongo que nunca completó completamente el proceso de rebase; esto lo dejará con un HEAD separado que apunte al commit que fue procesado más recientemente por la operación de rebase.

Para recuperarse de su situación, debe crear una rama que apunte al compromiso al que apunta su HEAD separado:

git branch temp
git checkout temp

_{(estos dos comandos se pueden abreviar como git checkout -b temp)}

Esto volverá a conectar su CABEZA a la nueva temprama.

A continuación, debe comparar la confirmación actual (y su historial) con la rama normal en la que esperaba trabajar:

git log --graph --decorate --pretty=oneline --abbrev-commit master origin/master temp
git diff master temp
git diff origin/master temp

(Probablemente quiera experimentar con las opciones de registro: agregar -p, dejar de --pretty=…ver todo el mensaje de registro, etc.)

Si su nueva tempsucursal se ve bien, es posible que desee actualizar (por ejemplo) masterpara señalarla:

git branch -f master temp
git checkout master

_{(estos dos comandos se pueden abreviar como git checkout -B master temp)}

Luego puede eliminar la rama temporal:

git branch -d temp

Finalmente, probablemente querrás impulsar la historia restablecida:

git push origin master

Es posible que deba agregar --forceal final de este comando para presionar si la rama remota no se puede "reenviar rápidamente" a la nueva confirmación (es decir, eliminó o reescribió alguna confirmación existente, o de lo contrario reescribió un poco de historial).

Si estaba en medio de una operación de rebase, probablemente debería limpiarlo. Puede verificar si se estaba procesando un cambio de base buscando el directorio .git/rebase-merge/. Puede limpiar manualmente el rebase en progreso simplemente borrando ese directorio (por ejemplo, si ya no recuerda el propósito y el contexto de la operación de rebase activa). Por lo general, lo usaría git rebase --abort, pero eso hace un restablecimiento adicional que probablemente desee evitar (mueve HEAD de nuevo a la rama original y lo restablece a la confirmación original, lo que deshacerá parte del trabajo que hicimos anteriormente).

Solo haz esto:

git checkout master

O, si tiene cambios que desea conservar, haga lo siguiente:

git checkout -b temp
git checkout -B master temp

Me encontré con este problema y cuando leí en la respuesta más votada:

HEAD es el nombre simbólico para el commit actualmente desprotegido.

Pensé: ¡Ah, ja! Si HEADes el nombre simbólico para el commit de pago actual, puedo reconciliarlo masteral cambiarlo a master:

git rebase HEAD master

Este comando:

1. echa un vistazo master
2. identifica las confirmaciones principales de HEADregreso al punto HEADdivergido demaster
3. juega esos commits encima de master

El resultado final es que todos los commits que estaban en HEADpero no masterestán entonces también en master. masterpermanece desprotegido.

Con respecto al control remoto:

un par de los cometidos que maté en el rebase fueron empujados, y los nuevos cometidos localmente no están allí.

El historial remoto ya no puede reenviarse rápidamente utilizando su historial local. Deberá forzar-presionar ( git push -f) para sobrescribir el historial remoto. Si tiene colaboradores, generalmente tiene sentido coordinar esto con ellos para que todos estén en la misma página.

Después de presionar masteral control remoto origin, su rama de seguimiento remoto origin/masterse actualizará para que apunte al mismo compromiso que master.

Mire aquí para obtener una explicación básica de la cabeza separada:

http://git-scm.com/docs/git-checkout

Línea de comando para visualizarlo:

git branch

o

git branch -a

Obtendrá salida como a continuación:

* (no branch)
master
branch1

Los * (no branch)espectáculos que estás en la cabeza separada.

Podría haber llegado a este estado haciendo un git checkout somecommitetc. y le habría advertido lo siguiente:

Estás en estado de 'CABEZA separada'. Puede mirar a su alrededor, realizar cambios experimentales y confirmarlos, y puede descartar cualquier confirmación que realice en este estado sin afectar ninguna rama al realizar otro pago.

Si desea crear una nueva rama para retener las confirmaciones que crea, puede hacerlo (ahora o más adelante) utilizando -b con el comando de pago nuevamente. Ejemplo:

git checkout -b nombre_rango_nuevo

Ahora, para llevarlos al maestro:

Haz un git reflogo incluso solo git logy anota tus compromisos. Ahora git checkout mastery git mergelos commits.

git merge HEAD@{1}

Editar:

Para agregar, use git rebase -ino solo para eliminar / eliminar confirmaciones que no necesita, sino también para editarlas. Solo mencione "editar" en la lista de confirmación y podrá modificar su confirmación y luego emitir un git rebase --continuepara continuar. Esto habría asegurado que nunca llegaras a un HEAD separado.

Obtenga su compromiso separado en su propia rama

Simplemente corre git checkout -b mynewbranch.

Luego ejecute git log, y verá que commit está ahora HEADen esta nueva rama.

si solo tiene una rama maestra y quiere volver a "desarrollar" o una característica, simplemente haga esto:

git checkout origin/develop

Nota: verificando origen / desarrollo .

Estás en estado HEAD separado . Puede mirar a su alrededor, hacer cambios experimentales y confirmarlos, y puede descartar cualquier confirmación que realice en este estado sin afectar ninguna rama al realizar otro pago ...

entonces

git checkout -b develop

Funciona :)

Si desea empujar su CABEZA separada actual (verifique git logantes), intente:

git push origin HEAD:master

para enviar su CABEZA separada a la rama maestra en origen. Si su empuje es rechazado, intente git pull origin masterprimero obtener los cambios desde el origen. Si no le importan los cambios desde el origen y se rechaza, porque realizó un cambio de base intencional y desea reemplazar el origen / maestro con su rama actualmente separada, entonces puede forzarla ( -f). En caso de que haya perdido el acceso a confirmaciones anteriores, siempre puede ejecutar git reflogpara ver el historial de todas las ramas.

Para volver a una rama maestra, mientras mantiene los cambios, pruebe los siguientes comandos:

git rebase HEAD master
git checkout master

Ver: Git: "Actualmente no en ninguna rama". ¿Hay una manera fácil de volver a una sucursal, manteniendo los cambios?

Encontré esta pregunta al buscar You are in 'detached HEAD' state.

Después de analizar lo que había hecho para llegar aquí, en comparación con lo que había hecho en el pasado, descubrí que había cometido un error.

Mi flujo normal es:

git checkout master
git fetch
git checkout my-cool-branch
git pull

Esta vez hice:

git checkout master
git fetch
git checkout origin/my-cool-branch
# You are in 'detached HEAD' state.

El problema es que accidentalmente lo hice:

git checkout origin/my-cool-branch

Más bien que:

git checkout my-cool-branch

La solución (en mi situación) era simplemente ejecutar el comando anterior y luego continuar el flujo:

git checkout my-cool-branch
git pull

Lo siguiente funcionó para mí (usando solo el maestro de rama):

git push origin HEAD:master
git checkout master        
git pull

El primero empuja la CABEZA separada al origen remoto.

El segundo se mueve a la rama maestra.

El tercero recupera la CABEZA que se une al maestro de rama.

Pueden surgir problemas con el primer comando si se rechaza la inserción. Pero esto ya no sería un problema de cabeza separada, sino que se trata del hecho de que la CABEZA separada no es consciente de algunos cambios remotos.

Hoy me encontré con este problema y estoy bastante seguro de que lo resolví haciendo:

git branch temp
git checkout master
git merge temp

Estaba en mi computadora de trabajo cuando descubrí cómo hacer esto, y ahora me encuentro con el mismo problema en mi computadora personal. Entonces tendré que esperar hasta el lunes cuando vuelva a la computadora del trabajo para ver exactamente cómo lo hice.

Si está completamente seguro de que HEAD es el buen estado:

git branch -f master HEAD
git checkout master

Probablemente no puedas empujar al origen, ya que tu maestro ha divergido del origen. Si está seguro de que nadie más está utilizando el repositorio, puede forzar:

git push -f

Más útil si está en una rama de características que nadie más está usando.

Todo lo que tiene que hacer es 'git checkout [nombre-sucursal]' donde [nombre-sucursal] es el nombre de la sucursal original de la que ingresó en un estado de cabeza separada. El (separado de asdfasdf) desaparecerá.

Entonces, por ejemplo, en la rama 'dev' revisa el commit asdfasd14314 ->

'git checkout asdfasd14314'

ahora estás en un estado de cabeza separada

'git branch' enumerará algo como ->

* (detached from asdfasdf)
  dev
  prod
  stage

pero para salir del estado de la cabeza separada y volver a dev ->

'git checkout dev'

y luego 'git branch' listará ->

* dev
  prod
  stage

pero eso es, por supuesto, si no tiene la intención de mantener ningún cambio desde el estado de la cabeza separada, pero me encuentro haciendo esto mucho sin tener la intención de hacer ningún cambio, sino solo mirar una confirmación anterior

Como señaló Chris, tuve la siguiente situación

git symbolic-ref HEAD falla con fatal: ref HEAD is not a symbolic ref

Sin embargo, git rev-parse refs/heads/masterestaba apuntando a una buena confirmación desde donde podría recuperarme (en mi caso, la última confirmación y puedes ver esa confirmación usandogit show [SHA]

Hice muchas cosas desordenadas después de eso, pero lo que parece haber solucionado es simplemente,

git symbolic-ref HEAD refs/heads/master

Y la cabeza se vuelve a unir!

En lugar de hacer git checkout origin/master

solo haz git checkout master

luego git branchconfirmará su sucursal.

Tuve este problema hoy, donde había actualizado un submódulo, pero no estaba en ninguna rama. Ya me había comprometido, por lo que esconder, pagar, desapilar no funcionaría. Terminé escogiendo el compromiso de la cabeza separada. Entonces, inmediatamente después de cometer (cuando el empuje falló), hice:

git checkout master
git cherry-pick 99fe23ab

Mi pensamiento fue: estoy en una cabeza separada, pero quiero estar en el maestro. Suponiendo que mi estado separado no sea muy diferente del maestro, si pudiera aplicar mi confirmación al maestro, estaría configurado. Esto es exactamente lo que hace Cherry-Pick.

Si hiciste algunos commits encima del master y solo quieres "fusionar hacia atrás" masterallí (es decir, quieres masterseñalar HEAD), la línea sería:

git checkout -B master HEAD

1. Eso crea una nueva rama llamada master, incluso si ya existe (que es como moverse mastery eso es lo que queremos).
2. La rama recién creada está configurada para apuntar HEAD, que es donde se encuentra.
3. La nueva sucursal está desprotegida, por lo que está en marcha masterdespués.

Encontré esto especialmente útil en el caso de los repositorios secundarios, que también se encuentran en un estado separado con bastante frecuencia.

Tuve el mismo problema y lo resolví siguiendo los siguientes pasos.

Si necesita conservar sus cambios

1. Primero debe ejecutar el git checkout mastercomando para volver a la rama maestra.
2. Si necesita mantener sus cambios, simplemente ejecute git checkout -b changesy git checkout -B master changes

Si no necesitas tus cambios

1. Para eliminar todos los archivos no rastreados de su rama ejecute git clean -df.

2. Luego debe borrar todos los cambios no organizados dentro de su repositorio. Para hacer eso tienes que corrergit checkout --

3. Finalmente, debe volver a colocar su rama en la rama maestra mediante el git checkout mastercomando.

Para mí fue tan fácil como eliminar la sucursal local nuevamente, ya que no tenía ningún compromiso local que quisiera impulsar:

Así que lo hice:

git branch -d branchname

Y luego revisando la rama nuevamente:

git checkout branchname

Cuando personalmente me encuentro en una situación en la que resulta que hice algunos cambios mientras no estoy master( HEADes decir, está separado justo encima mastery no hay compromisos en el medio), el escondite podría ayudar:

git stash # HEAD has same content as master, but we are still not in master
git checkout master  # switch to master, okay because no changes and master
git stash apply  # apply changes we had between HEAD and master in the first place

En palabras simples, el estado HEAD separado significa que no está desprotegido en HEAD (o punta) de ninguna rama .

Comprender con un ejemplo

Una rama en la mayoría de los casos es una secuencia de confirmaciones múltiples como:

Commit 1: master -> branch_HEAD (123be6a76168aca712aea16076e971c23835f8ca)

Commit 2: master -> 123be6a76168aca712aea16076e971c23835f8ca -> branch_HEAD (100644a76168aca712aea16076e971c23835f8ca)

Como puede ver arriba en caso de secuencia de confirmaciones, su rama apunta a su última confirmación. Entonces, en ese caso, si realiza el pago para comprometerse 123be6a76168aca712aea16076e971c23835f8ca, entonces estaría en estado de cabeza separada ya que HEAD de su sucursal apunta a 100644a76168aca712aea16076e971c23835f8ca y técnicamente está desprotegido en HEAD of no branch. Por lo tanto, estás en el estado HEAD separado.

Explicación teórica

En este Blog , está indicando claramente que un repositorio de Git es un árbol de compromisos, con cada confirmación que apunta a su antepasado con cada puntero de confirmación actualizado y estos punteros a cada rama se almacenan en los subdirectorios .git / refs. Las etiquetas se almacenan en .git / refs / tags y las ramas se almacenan en .git / refs / heads. Si observa cualquiera de los archivos, encontrará que cada etiqueta corresponde a un solo archivo, con un hash de confirmación de 40 caracteres y, según lo explicado anteriormente por @Chris Johnsen y @Yaroslav Nikitenko, puede consultar estas referencias.

Llegué a un estado realmente tonto, dudo que alguien más lo encuentre útil ... pero por si acaso

git ls-remote origin
0d2ab882d0dd5a6db93d7ed77a5a0d7b258a5e1b        HEAD
6f96ad0f97ee832ee16007d865aac9af847c1ef6        refs/heads/HEAD
0d2ab882d0dd5a6db93d7ed77a5a0d7b258a5e1b        refs/heads/master

que eventualmente arreglé con

git push origin :HEAD

Esto me funcionó perfectamente:

1. git stashpara guardar sus modificaciones locales

Si desea descartar los cambios,
git clean -df
git checkout -- .
git clean elimina todos los archivos no rastreados (advertencia: aunque no eliminará los archivos ignorados mencionados directamente en .gitignore, puede eliminar los archivos ignorados que residen en carpetas) y git checkout borra todos los cambios no organizados.

2. git checkout masterpara cambiar a la rama principal (suponiendo que quiera usar master)
3. git pullpara extraer el último commit de la rama master
4. git statuspara verificar que todo se vea genial

On branch master
Your branch is up-to-date with 'origin/master'.

En mi caso, corrí git statusy vi que tenía algunos archivos sin seguimiento en mi directorio de trabajo.

Para que el rebase funcione, solo tuve que limpiarlos (ya que no los necesitaba).

Si está utilizando EGit en Eclipse: suponga que su maestro es su rama de desarrollo principal

• enviar cambios a una rama, normalmente una nueva
• luego tire del control remoto
• luego haga clic derecho en el nodo del proyecto, elija el equipo y luego elija mostrar historial
• luego haga clic derecho en el maestro, elija revisar
• si Eclipse le dice que hay dos maestros, uno local y uno remoto, elija el control remoto

Después de esto, debería poder volver a conectar al origen-maestro.

Yo tuve el mismo problema. Guardo mis cambios git stashy restablezco la rama en local a un commit anterior (pensé que eso causó), luego hice un git pully no estoy despegando esa cabeza ahora. No olvide git stash applytener sus cambios nuevamente.

git checkout checksum  # You could use this to peek previous checkpoints
git status # You will see HEAD detached at checksum
git checkout master # This moves HEAD to master branch