estratégias de gerenciamento de código fonte - ramificação, tagging, bifurcação, etc. - para aplicações web

Question

Esta postagem aqui ( como você gerenciar revisões de banco de dados em um projeto de médio porte com ramos? ) me perguntando a melhor forma de trabalhar em um projeto web usando ramificação e implantação de dev, teste e produção (juntamente com cópias locais).

Não temos "releases" per se: se um recurso é grande o suficiente para ser perceptível, eu empurro-lo ao vivo (. Após o teste requisito / etc), caso contrário, lote alguns para cima e, quando se sente "confortável ", empurrar aqueles ao vivo. O objetivo é o de nunca ter uma implantação mais de uma vez ou duas vezes por mês ou assim porque um site em constante mudança tende a tornar os usuários uma desconfortável pouco.

Aqui está como fazemos isso, e ele se sente espécie de frágil (atualmente usando svn mas considerando uma mudança para git):

1. dois "ramos" - DEV e palco com uma determinada versão da etapa marcada como TRONCO
   • cheques desenvolvedores uma cópia do tronco para cada mudança e cria um ramo para ele
   • desenvolvedor trabalha localmente, o check-in de código frequentemente (tal como a votação: cedo e muitas vezes)
   • Quando desenvolvedor é confortável não é totalmente quebrado, mesclar o ramo com DEV e deploy para o desenvolvimento local.
   • Repita 3-4 conforme necessário até que a mudança é "acabado"
   ramo mudança
   • Mesclar com o estadiamento, deploy para local palco. Fazer teste final esperado.
   • Depois de algum período de tempo, marcar uma determinada revisão do palco como o tronco e tronco impulso ao vivo
   • Merge TRONCO muda de volta para DEV para mantê-lo em sincronia

Agora, algumas dessas etapas tem significativa complexidade mão acenou para longe e na prática são muito difícil de fazer (TRONCO -> DEV sempre quebra). Então eu tenho que imaginar que há uma maneira melhor

Os pensamentos?

Answer 1

Ramificação é útil se você espera que o trabalho não ser concluído a tempo, e você não tem um corpo suficiente de ensaios para tornar o trabalho de integração contínua. I tendem a ver o desenvolvimento branch-louco em lojas onde as tarefas de programação são demasiado grande para completar previsível e assim que a gerência quer esperar até pouco antes de um lançamento para determinar quais as características que deve enviar. Se você estiver fazendo esse tipo de trabalho, então você pode considerar o uso de controle de versão distribuído, onde cada diretório de trabalho é um ramo naturalmente e você terá todo o check-in local e história local que você pode comer sem ferir ninguém. Você pode até mesmo cross-merge com outros desenvolvedores de fora do tronco.

A minha preferência é quando trabalhamos em um tronco instável com ramos de release candidates, que são então marcadas para lançamento, e que, em seguida, tornar-se o fluxo de patches de emergência. Em tal sistema uma, você raramente têm mais de três ramos (último lançamento, candidatos versão atual, tronco instável). Isso funciona se você está fazendo TDD e têm CI no tronco instável. E se você precisar de todas as tarefas deverão ser discriminados para que possa entregar código tão frequentemente como você deseja (normalmente uma tarefa deve ser apenas um ou dois dias, e libertado sem todas as outras tarefas que compõem a sua característica). Assim, os programadores ter trabalho, check-out do tronco, fazer o trabalho, sincronizar e verificar em qualquer momento todos os testes passam. O tronco instável está sempre disponível para ramo como um release candidate (se todos os testes passar) e, portanto, liberação torna-se um não-evento.

No geral, melhores meios:. Menos galhos, tarefas mais curtos, menor tempo de lançamento, mais testes

Answer 2

Um pensamento óbvia seria mais "rebase" (fusões voltar mais vezes de "pai" STAGE ambiente para "criança" ambiente "DEV" para o desenvolvedor de filial), a fim de minimizar o impacto final de TRUNK-> DEV, o que faria ser não mais necessário.

Ou seja, qualquer coisa feita em STAGE, que é obrigado a entrar em produção ao mesmo tempo (tronco) deve ser mescladas de volta o mais cedo possível no DEV e ramo devs privada, caso contrário, essas fusões de adaptação final são sempre uma dor.

MAS, o fluxo de trabalho merge acima é muito inconveniente, gostaria de sugerir um ramo REBASE, com base na mais recente DEV apenas depois de um release (novo tronco). O rebase TRUNK-> DEV se tornaria TRUNK-> REBASE, onde todos os problemas são resolvidos, em seguida, um DEV merge final> REBASE para verificar que qualquer dev atual é compatível com o novo sistema atualizado. A volta merge trivial final REBASE para DEV (e ramos dev privadas) iria completar o processo.
O ponto de um ramo é isolar um esforço de desenvolvimento que não pode ser realizada em conjunto com outros esforços de desenvolvimento em curso. Se TRUNK-> DEV é muito complicado para ir junto com DEVs atuais, ele precisa ser isolado. Daí a 'REBASE' proposição ramo.

Answer 3

Leia este: http://oreilly.com/catalog/practicalperforce/chapter/ ch07.pdf

Answer 4

Nós usamos SVN na loja que eu trabalho em. Enquanto nós fazemos o desenvolvimento C ++, gerenciamento de versão é bastante universal. O seguinte é a nossa abordagem, você pode decidir que, se nada disso, é razoável para a sua abordagem.

Para nós, todo o desenvolvimento ocorre em um galho. Nós ramificar para cada bug e cada recurso. Idealmente, esse ramo é dedicado SOMENTE a 1 recurso, mas às vezes isso não é apenas destinado a ser.

Quando o trabalho é concluído, testado e "pronto" nós mesclar as alterações do tronco. A nossa regra é que em nenhum momento deve o tronco já ter quebrado código nele. Se o código quebrado deve encontrar seu caminho para o tronco, fixando-se prioridade 1.

Lançamentos são feitas quando os recursos são todos feitos e fundiu-se: um ramo para o lançamento é criado como uma tag. A tag permite-nos uma shapshot para recuperar se precisarmos. A filial permite-nos o nosso apoio versão anterior. Corrigir bugs em uma versão liberada é feito indo para ramo que da liberação, ramificando a partir dele. Quando tudo está bem, as mudanças estão de volta resultante da concentração filial da liberação e, se desejado, todo o caminho até o tronco.