Git rebase continuamente falha e requer a intervenção manual de fusão

Question

Estou tendo um problema com rebasing do mestre se a um ramo 'deploy' dentro de um dos meus repositórios.

Meu repo está configurado da seguinte forma:

master - of course, the main branch
deploy - a branch created where files like Capfile, deploy.rb etc are created and configured - these changes will NEVER be merged back into Master

Geralmente meu fluxo de trabalho é:

1. desenvolvimento Do sobre o branch master ... teste, sorriso, cometer.
2. Checkout o ramo deploy
3. Executar git rebase master no ramo deploy - este utilizado para o trabalho sem problemas
4. Push to cap deploy
remoto e, em seguida, executar
5. Relax

O problema que estou tendo agora é que quando eu executar git rebase master no ramo implantá-lo está chegando com um erro de 3-way merge / merge manual necessário (eu não acho que a mensagem de erro é suficiente realmente genérico para post) . Git me diz para executar uma mala, em seguida, uso git rebase --continue ao fim -. Que nunca funciona

O que eu encontrei 'faz' trabalho está sendo executado git rebase master --interactive, limpar a lista de seleção (há 5 ou 'commits' tão repetidas, mas com os números de referência diferentes (mesma mensagem) nesta lista, então eu vou escolher um dos -los) e, em seguida, fazer manualmente a mesclagem. Uma vez eu fiz isso para cada commit, então eu posso continuar o rebase e todos os seus feliz ...

Até a próxima vez que eu preciso para executar uma alteração de base.

Então, alguém sabe o que pode ser feliz? O projeto não é realmente 'segredo' para que em caso de necessidade eu posso postar mensagens, logs, gráficos filiais etc.

Graças

Answer 1

O que soa como ele poderia estar acontecendo é que você mudou a história desses commits "repetidas" cometer tal que eles têm um sha1 diferente. Cada sha1 é único, não só para a cometer, mas a história cometer. Por isso, é impossível (bem, altamente improvável de acontecer durante a vida do universo), ter dois sha1 identicial na mesma história ou ter dois sha1 em duas histórias diferentes mesmo. Se você mudar alguma coisa em sua cometer, como com um rebase alterar ou interativo, então você vai mudar o sha1. Então dois commits que possam olhar o mesmo, são realmente tratados de forma diferente.

Assim, muito provavelmente, você rebased do outro ramo, fez algum tipo de rebase interativo ou alterados os commits, continuaram a cometer mais algum código que modificou essa mesma parte do código, em seguida, na próxima rebase você tem conflitos porque o commits que você tem em sua filial local que diferem do ramo que você está rebasing de são removidos do ramo, o montante é puxado incluindo a cometer você já puxado e mudou o SHA1 e, em seguida, quando os commits são reproduzidos para o ramo que você acabar com um conflito porque o estado do código mudou do que a submissão era esperado porque era original criado a partir de uma história diferente do que você já tem no seu ramo. Uau, isso foi uma frase longa ...

Quando você está "limpando" a lista de seleção ... o que você está fazendo é provável exclusão desses commits repetido antes rebasing, então agora você não está reaplicando as mudanças que já foram aplicados, de modo que não há mais conflitos.

No entanto, se você só queria resolver os conflitos durante o rebase, este seria provavelmente a melhor aposta para que você não acidentalmente excluir um commit que você deseja. Resolver os conflitos fará com que o conjunto de mudanças de que cometem diferente uma aplicável à história que você tem. Depois de empurrar essa resolução de conflitos de mesclagem, você não deve ver as questões novamente, a menos que você modificar commits que já foram empurrados novamente.

Para saber quais arquivos foram os conflitos de mesclagem fazer:

git status

ou

git ls-files -u

Depois de saber quais arquivos foram os conflitos, se você tem uma configuração mergetool você pode fazer:

git mergetool <file>

Se você preferir mesclar manualmente, você pode encontrar os marcadores de mesclagem e linhas fazendo:

grep -Hnr '^=\{7\}\|^<\{7\}\|^>\{7\}' *

no nível superior do seu caminho repo e editar. Quando você editar manualmente, certifique-se de remover os marcadores e fazer a versão final do olhar de arquivo como a forma como você quer que ele ... git não faz nada especial com os marcadores para você. Quando você terminar de editting manualmente, certifique-se de fazer

git add <file>

para adicionar o arquivo para adicioná-lo ao índice e remover o sinalizador não mesclado. Quando você terminar de resolver todos os arquivos unmerged, faça

git rebase --continue

Para completar o rebase.

Answer 2

Para obter git rebase --continue a trabalhar você tem que realmente mesclar os arquivos em conflito (edit-los, escolher as peças que você quer de entre os marcadores de conflito “<<<<<<<”, “=======”, “>>>>>>>”) e, em seguida, git add-los para o índice (o índice é onde eles são registrados como em conflito, adicionando um arquivo limpa seu estado de conflito). Verifique a diff atual com git diff --cached, então git rebase --continue se parece certo.

Antes de tentar a sua rebase (ou depois de abortar a problemática), confira git log -p master..deploy para ver os commits que você está tentando rebase. É um deles que está em conflito com o que você tem em mestre .

Os commits que você está caindo, apagando as suas linhas de ‘pegar’ em git rebase -i pode não ser exatamente o mesmo (apesar de terem o mesmo ‘sujeito’ em sua mensagem de commit). O fato de que você acha que deve haver apenas um deles indica que algo suspeito está acontecendo com o seu deploy ramo. São esses commits ‘duplicado’ na ponta da deploy ou existem outros commits depois deles? Talvez vendo o conteúdo desses commits ‘peixe’ (log -p, acima) vai lhe dar uma pista sobre sua origem.

Answer 3

Você pode definir um atributo no diretório pai de seus arquivos "específicas para implantar" , a fim de sempre selecionar o conteúdo do ramo implantar em caso de fusão.

Para um exemplo de gerente de mesclagem, consulte este SO resposta .

Outras estratégias foram discutidos , mas a chave permanecem: sempre considerar uma fusão como "uma fusão no âmbito do projeto" e não uma fusão baseado em arquivo. Daí os atributos para refinar o merge todo o projeto quando se trata de alguns arquivos "especiais".