Estou tentando escolher um fluxo de trabalho Git que seja mais apropriado para o nosso produto. Aqui estão os parâmetros:
- Fazemos alguns lançamentos importantes por ano, digamos 10 no máximo
- Temos várias versões do nosso produto ativas ao mesmo tempo (algumas pessoas estão na v10.1, outras na v11.2, etc.)
- Precisamos ser capazes de trabalhar em várias versões ao mesmo tempo (para que possamos trabalhar na v12.1, mas, ao chegarmos ao final da versão, começamos a trabalhar na v12.2 ao mesmo tempo)
- Precisamos poder corrigir lançamentos quando forem encontrados erros críticos
Até agora, aqui está a maneira que eu acho que poderia funcionar:
- É utilizado um repositório remoto único
- Criar ramificação 12.1 do mestre
- Crie ramificações de recursos com base em 12.1, confirme-as e junte-as novamente em 12.1, pressione
- Quando precisarmos começar a trabalhar em versões futuras, crie um novo ramo 12.2 com base em 12.1
- A partir de então, ao trabalhar em um recurso para 12.1, crie ramificação a partir de 12.1, confirme as alterações e mescle em 12.1 e 12.2, pressione
- Se estiver trabalhando em um recurso para 12.2, crie uma ramificação a partir da 12.2, confirme as alterações e mescle apenas na 12.2, pressione
- Quando a liberação 12.1 for concluída, mescle-a no mestre e identifique o ramo mestre com o 12.1
- Se um hotfix for necessário, crie um ramo de hotfix a partir do ramo de versão mais antigo que precisa, confirme as alterações e mescle novamente em todos os ramos de lançamento para esse lançamento e para os lançamentos futuros que possam ser afetados; se a ramificação de versão estável mais recente foi afetada, mescle-a no master.
Tenho algumas preocupações:
- Não tenho certeza de que a fusão de hotfixes de ramificações antigas em ramificações novas será um processo tranquilo, especialmente se houver muitas alterações sobrepostas; seria mais inteligente aplicar hotfix manualmente em cada ramificação nos casos em que parece haver conflitos
- Os modelos de fluxo de trabalho que vi parecem não manter muito ativos os ramos de lançamento, uma vez feito, o lançamento é mesclado no mestre, marcado e removido. Meu problema com isso é que não tenho uma boa idéia de como gerenciar o estado do lançamento, se tudo o que tenho são tags no master, parece mais fácil de hotfix em um ramo e, em seguida, tenho um release no qual sempre posso voltar para que possui o hotfix mais recente (posso até marcar os hotfixes no lançamento). Não sei se há uma maneira de voltar ao master e, de alguma forma, ter uma cópia do release com os hotfixes aplicados e atualizar essa tag.
Os comentários são apreciados sobre coisas que posso ter esquecido ou sobre maneiras melhores de realizar as coisas, de acordo com os requisitos que especifiquei.
version-control
git
Rocket04
fonte
fonte
Respostas:
Você parece estar se ramificando em todas as versões principais (12.0.0), tendo possíveis atualizações menores para cada uma (12.1.0) e hot fixes (12.2.1). Corrigir?
Não há nenhuma razão específica para que você não consiga manter as ramificações de lançamento ativas no GitFlow após o lançamento de uma versão, além do fato de que coordenar alterações entre várias ramificações divergentes por um longo tempo é difícil para qualquer modelo. Suponho que o GitFlow também foi modelado mais para produtos que mantêm um único lançamento ao vivo enquanto desenvolvem o próximo.
Gostaria de ficar com o GitFlow e fazer algumas alterações;
Pule o ramo principal. Até agora, eu não tinha nenhum uso prático e perderia sua linearidade da maneira como você trabalha. Mantenha o desenvolvimento no próximo grande lançamento em desenvolvimento. Se você decidir manter o mestre, não coloque tags de lançamento no mestre, coloque-as na última confirmação no ramo de lançamento que produziu o binário que você está enviando.
Não jogue fora os ramos de liberação depois de mesclá-los de volta ao desenvolvimento. Em vez disso, mantenha-os por perto para a próxima versão menor e possíveis correções. Se você parar de apoiar um lançamento, suponho que não há problema em excluí-los. Você pode nomear ramificações de liberação após o componente principal, release / 12, e criar ramificações de sub-release, release / 12.1, release / 12.2. Não tive que me preocupar muito com esse nível de paralelismo, mas é provavelmente o que eu tentaria. Você pode pensar em cada ramo de versão principal como seu próprio ambiente sub-GitFlow neste caso.
Se você precisar trabalhar em paralelo nos recursos de vários lançamentos importantes futuros ao mesmo tempo, talvez seja necessário manter o próximo (13) em desenvolvimento e qualquer coisa para as versões posteriores (14, 15) em ramificações adicionais "develop-N" . Isso parece muito difícil de manter em geral, mas seria possível.
fonte
Parece que uma possível solução para o seu principal problema ( «Precisamos poder trabalhar em vários lançamentos ao mesmo tempo [...]» ) está fazendo uma
git worktree add <path> [<branch>]Veja esta resposta SO para uma introdução detalhada sobre
git worktree.fonte
Você mencionou que está familiarizado com o gitflow. Sugiro adicioná-lo para o seu cenário. Você precisará criar ramificações a partir da ramificação de desenvolvimento para suportar versões mais antigas. Essas versões mais antigas também precisam ter suas próprias ramificações de liberação / mestre e ramificações de hotfix. Você precisará mesclar periodicamente suas ramificações de suporte nas ramificações de suporte mais recentes e na ramificação de desenvolvimento.
À medida que o desenvolvimento das principais versões diverge, isso fica cada vez mais difícil. Não há bala de prata para isso. Às vezes, será mais fácil fazer alterações manualmente. O custo de manutenção das versões mais antigas aumentará e, em algum momento, não valerá mais a pena.
Tudo depende do tipo de alteração que você está fazendo nas versões anteriores. Se apenas corrigir erros, é relativamente fácil de mesclar. Se você tentar adicionar novos recursos, isso será difícil.
fonte