Melhores Práticas do Subversion.
Este é um conjunto rápido de diretrizes para fazer o melhor uso do Subversion no seu trabalho de desenvolvimento de software do dia-a-dia.
Use um layout sano do repositório.
Existem várias maneiras de estabelecer seu repositório. Como as filiais e as tags são diretórios comuns, você precisará contabilizá-los na estrutura do repositório.
O projeto Subversion recomenda oficialmente a idéia de uma "raiz do projeto", que representa um ponto de ancoragem para um projeto. Uma "raiz do projeto" contém exatamente três subdiretórios: / tronco, / ramos e / tags. Um repositório pode conter apenas uma raiz do projeto, ou pode conter uma série delas.
Cometer conjuntos de mudanças lógicas.
Quando você comete uma alteração no repositório, verifique se sua alteração reflete um único propósito: a correção de um bug específico, a adição de um novo recurso ou alguma tarefa específica. Seu commit criará um novo número de revisão que pode ser usado para sempre como um "nome" para a mudança. Você pode mencionar este número de revisão em bancos de dados de bugs, ou usá-lo como um argumento para svn merge se desejar desfazer a alteração ou acessá-la para outra ramificação.
Use o rastreador de problemas com sabedoria.
Tente criar tantos links bidirecionais entre os conjuntos de mudanças do Subversion e seu banco de dados de rastreamento de problemas quanto possível:
Se possível, consulte um ID de problema específico em cada mensagem de log de confirmação. Ao anexar informações a um problema (para descrever o progresso ou fechar o problema), nomeie o (s) número (s) de revisão responsável pela mudança.
Fase de fusão manualmente.
Ao cometer o resultado de uma mesclagem, certifique-se de escrever uma mensagem de log descritiva que explica o que foi mesclado, algo como:
Compreenda cópias de trabalho de revisão mista.
Os diretórios e arquivos da sua cópia de trabalho podem estar em diferentes revisões "trabalhando": esta é uma característica deliberada que permite misturar e combinar versões antigas de coisas com novas. Mas há alguns fatos que você deve estar ciente:
Após cada svn commit, sua cópia de trabalho tem revisões misturadas. As coisas que você acabou de cometer estão agora na revisão HEAD, e tudo o resto está em uma revisão mais antiga. Certos compromissos não são permitidos: você não pode comprometer a exclusão de um arquivo ou diretório que não tenha uma revisão de trabalho da HEAD. Você não pode comprometer uma alteração de propriedade em um diretório que não tenha uma revisão de trabalho da HEAD. A atualização do svn trará toda a sua cópia de trabalho para uma revisão de trabalho e é a solução típica dos problemas mencionados no ponto 2.
Seja paciente com arquivos grandes.
Um bom recurso do Subversion é que, por design, não há limite para o tamanho dos arquivos que ele pode manipular. Os arquivos são enviados "de forma corrente" em ambos os sentidos entre o cliente e o servidor do Subversion, usando uma quantidade pequena e constante de memória em cada lado da rede.
Claro, há uma série de questões práticas a serem consideradas. Embora não haja necessidade de se preocupar com arquivos no intervalo de tamanho de kilobytes (por exemplo, arquivos de código-fonte típicos), cometer arquivos maiores pode levar uma tremenda quantidade de tempo e espaço (por exemplo, arquivos que são dezenas ou centenas de megabytes de tamanho grande).
Para começar, lembre-se de que sua cópia de trabalho do Subversion armazena cópias prístinas de todos os arquivos controlados por versão na. svn / base de texto / área. Isso significa que sua cópia de trabalho ocupa pelo menos duas vezes mais espaço em disco que o conjunto de dados original. Além disso, o cliente do Subversion segue um algoritmo (atualmente não ajustável) para cometer arquivos:
Copia o arquivo para. svn / tmp / (pode demorar um pouco e usa temporariamente espaço em disco extra)) Executa uma diferença binária entre o arquivo tmp e a cópia original, ou entre o arquivo tmp e um arquivo vazio se recém adicionado. (pode levar muito tempo para calcular, mesmo que apenas uma pequena quantidade de dados possa ser enviada pela rede) Envia o diff para o servidor e, em seguida, move o arquivo tmp para. svn / base de texto /
Portanto, enquanto não houver limite teórico para o tamanho de seus arquivos, você precisará estar ciente de que arquivos muito grandes podem exigir um pouco de paciente aguardando enquanto seu cliente se afasta. Você pode ter a certeza, no entanto, que ao contrário do CVS, seus arquivos grandes não incapacitarão o servidor ou afetarão outros usuários.
Saiba quando criar filiais.
Esta é uma questão muito debatida, e isso realmente depende da cultura do seu projeto de software. Em vez de prescrever uma política universal, descreveremos três comuns aqui.
O sistema Never-Branch.
(Muitas vezes usado por projetos nascentes que ainda não possuem código executável.)
Os usuários comprometem seu trabalho no dia-a-dia no tronco. Ocasionalmente / tronco "quebra" (não compila ou falha em testes funcionais) quando um usuário começa a cometer uma série de mudanças complicadas.
Prós: política muito fácil de seguir. Novos desenvolvedores têm baixa barreira para a entrada. Ninguém precisa aprender a se ramificar ou se fundir.
Contras: o desenvolvimento caótico, o código pode ser instável a qualquer momento.
Uma nota lateral: esse tipo de desenvolvimento é um pouco menos arriscado no Subversion do que no CVS. Como os compromissos do Subversion são atômicos, não é possível um check-out ou atualização para receber um commit "parcial" enquanto outra pessoa está no processo de cometer.
O sistema Always-Branch.
(Muitas vezes usado por projetos que favorecem a gestão e supervisão pesada).
Cada usuário cria / trabalha em um ramo privado para cada tarefa de codificação. Quando a codificação está completa, alguém (codificador original, par ou gerente) analisa todas as alterações das filiais privadas e as combina com / tronco.
Prós: / tronco é garantido para ser extremamente estável em todos os momentos.
Contras: os codificadores são artificialmente isolados uns dos outros, possivelmente criando mais conflitos de mesclagem do que o necessário. Requer usuários para fazer muita fusão extra.
O sistema Branch-When-Needed.
(Esse é o sistema usado pelo projeto Subversion.) Usuários comprometem seu trabalho no dia-a-dia no tronco. Regra # 1: / tronco deve compilar e passar testes de regressão em todos os momentos. Os engajadores que violam esta regra são publicamente humilhados. Regra # 2: um único commit (changeset) não deve ser tão grande para desencorajar a revisão por pares. Regra # 3: se as regras # 1 e # 2 entrarem em conflito (ou seja, é impossível fazer uma série de pequenos compromissos sem interromper o tronco), então o usuário deve criar um ramo e cometer uma série de conjuntos de mudanças menores lá. Isso permite a revisão por pares sem interromper a estabilidade do tronco.
Prós: / tronco é garantido para ser estável em todos os momentos. O motivo de ramificação / fusão é um pouco raro.
Contras: Adiciona um pouco de carga ao trabalho diário dos usuários: eles devem compilar e testar antes de cada commit.
característica de estratégia de ramificação do Subversion versus lançamento
Obter através da App Store Leia esta publicação em nosso aplicativo!
Estratégia de ramificação para mover ramo de recursos entre as versões.
No meu local de trabalho, usamos um repositório SVN para o código-fonte, que contém a aplicação principal e alguns outros projetos, e para a aplicação principal está estruturado como este:
Assim, nas filiais, temos um recipiente para cada nova versão, e dentro de que existe um ramo "mestre", criado usando a cópia svn do tronco e um ramo para cada recurso agendado para essa versão, criado usando a cópia svn no ramo principal.
Quando um recurso é completo, ele é testado e depois mesclado no mestre para sua versão, e no final, o mestre é incorporado no tronco, que é usado para abrir outro ramo de versão.
No entanto, aconteceu que um recurso não poderia ser completado para a versão em que estava programado e teve que ser adiado.
Então, o que eu fiz foi criar o ramo principal para a nova versão, que crie o ramo para o recurso adiado e tente combinar o ramo antigo da versão anterior com este novo.
No entanto, o cliente SVN se recusou a executar a operação, devido à diferente ascendência dos dois ramos.
Existe uma outra maneira, dada essa configuração, para mover um ramo de recursos de um ramo de versão para outro? Ou deveríamos mudar o layout aqui?
Você terá que fazer uma fusão cruzada. o que é uma dor.
Uma solução melhor pode ser simplesmente criar um novo ramo e refazer as alterações dos recursos. ou seja, copiá-los em frente de um download do ramo antigo e verificá-los em um novo commit.
Você perderia seu histórico de confirmação pelo trabalho realizado até agora, o que é uma dor, mas evite problemas de mesclagem.
característica de estratégia de ramificação do Subversion versus lançamento
Obter através da App Store Leia esta publicação em nosso aplicativo!
Melhor estratégia de ramificação ao fazer integração contínua?
Qual é a melhor estratégia de ramificação a ser usada quando você quer fazer integração contínua?
Release Branching: desenvolva no tronco, mantenha um ramo para cada lançamento. Ramificação de recursos: desenvolva cada recurso em uma ramificação separada, apenas funde uma vez estável.
Faz sentido usar essas duas estratégias juntas? Como em, você se ramifica para cada versão, mas você também se ramifica para grandes recursos? Uma dessas estratégias engrena melhor com a integração contínua? Usar integração contínua ainda faz sentido ao usar um tronco instável?
11 Respostas.
A resposta depende do tamanho da sua equipe e da qualidade do seu controle de origem e da capacidade de mesclar conjuntos de mudanças complexas corretamente. Por exemplo, no controle de fonte de ramo completo, como a fusão CVS ou SVN pode ser difícil e você pode estar melhor com o primeiro modelo, enquanto que se usar um sistema mais complexo como o IBM ClearCase e com um tamanho maior de equipe, você poderia ser melhor com o segundo modelo ou uma combinação dos dois.
Eu, pessoalmente, separaria o modelo de ramal de recursos, onde cada característica principal é desenvolvida em um ramo separado, com subdivisões de tarefas para cada mudança feita pelo desenvolvedor individual. À medida que os recursos se estabilizam, eles são mesclados ao tronco, o que você mantém razoavelmente estável e passa todos os testes de regressão em todos os momentos. À medida que você está perto do final do seu ciclo de lançamento e todos os ramos de recursos se fundem, você se estabiliza e se ramifica de um ramo do sistema de liberação no qual você apenas faz correções de bug de estabilidade e backports necessários, enquanto o tronco é usado para o desenvolvimento da próxima versão e você novamente se ramificam para novos ramos de recursos. E assim por diante.
Desta forma, o tronco contém sempre o código mais recente, mas você consegue mantê-lo razoavelmente estável, criando rótulos estáveis (tags) em grandes mudanças e fusões de recursos, os ramos de recursos são desenvolvimento de ritmo rápido com integração contínua e sub-ramos de tarefas individuais podem ser muitas vezes atualizado do ramo de recursos para manter todos os que trabalham no mesmo recurso em sincronia, enquanto simultaneamente não afetam outras equipes trabalhando em diferentes recursos.
Ao mesmo tempo, você tem através do histórico um conjunto de ramos de lançamento, onde você pode fornecer backports, suporte e correções de erros para seus clientes que, por qualquer motivo, permanecem em versões anteriores do seu produto ou mesmo apenas na versão mais recente lançada. Tal como acontece com o tronco, você não configura a integração contínua nos ramos de lançamento, eles são cuidadosamente integrados ao passar todos os testes de regressão e outros controles de qualidade de liberação.
Se por algum motivo dois recursos são co-dependentes e precisam de mudanças feitas um com o outro, você pode considerar desenvolver ambos no mesmo ramo de recursos ou exigir que os recursos agrupem regularmente partes estáveis do código no tronco e depois atualize as alterações de tronco para trocar código entre ramos do tronco. Ou se você precisar isolar esses dois recursos de outros, você pode criar um ramo comum do qual você ramifica esses ramos de recursos e que você pode usar para trocar código entre os recursos.
O modelo acima não faz muito sentido com equipes com menos de 50 desenvolvedores e sistema de controle de fonte sem ramos esparsos e capacidade de fusão adequada como CVS ou SVN, o que tornaria todo esse modelo um pesadelo para configurar, gerenciar e integrar.
Eu acho o tópico realmente interessante, porque eu confio muito nas filiais no meu trabalho diário.
Lembro-me de Mark Shuttleworth, que propõe um modelo sobre manter o ramo principal puro enquanto vai além do CI convencional. Eu postei sobre isso aqui. Como estou familiarizado com o Cruise Control, também bloguei sobre filiais de tarefas e CI aqui. É um tutorial passo a passo explicando como fazê-lo com SCM de plástico. Finalmente, encontrei alguns dos tópicos sobre CI (e potencialmente falando sobre ramificação) no livro de Duvall sobre a CI também muito interessante.
Espero que você ache os links interessantes.
Eu pessoalmente acho muito mais limpo ter um tronco estável e apresentar ramificações. Dessa forma, os testadores e similares conseguem permanecer em uma única "versão" e atualizar do tronco para testar qualquer recurso que seja codificado.
Além disso, se vários desenvolvedores estiverem trabalhando em recursos diferentes, eles podem ter seus próprios ramos separados, depois fundir no tronco quando terminarem e enviar um recurso para serem testados sem que o testador tenha que alternar para vários ramos para testar diferentes recursos.
Como um bônus adicional, há algum nível de testes de integração que vem automaticamente.
Penso que qualquer uma das estratégias pode ser usada com o desenvolvimento contínuo, desde que você se lembre de um dos princípios fundamentais que cada desenvolvedor comete no tronco / mainline todos os dias.
Eu tenho feito uma leitura deste livro sobre a CI e os autores sugerem que a ramificação por lançamento é a estratégia de ramificação preferida. Eu tenho que concordar. O raciocínio por recurso não faz sentido para mim ao usar o CI.
Vou tentar e explicar por que estou pensando dessa maneira. Digamos que três desenvolvedores tomem um ramo para trabalhar em um recurso. Cada recurso levará vários dias ou semanas para terminar. Para garantir que a equipe esteja se integrando continuamente, eles devem se comprometer com a filial principal pelo menos uma vez por dia. Assim que eles começam a fazer isso, eles perdem o benefício de criar um ramo de recursos. Suas mudanças não são mais separadas de todas as mudanças do outro desenvolvedor. Sendo assim, por que se preocupar em criar filiais de recursos em primeiro lugar?
O uso de ramificação por versão requer muito menos fusão entre os ramos (sempre é uma coisa boa), garante que todas as alterações sejam integradas o mais rápido possível e (se feito corretamente) garante que sua base de código esteja sempre pronta para ser liberada. O lado negativo para se ramificar pelo lançamento é que você deve ter um cuidado consideravelmente mais cuidadoso com as mudanças. Por exemplo. A refatoração ampla deve ser feita de forma incremental e, se você já integrou um novo recurso que não deseja na próxima versão, ele deve estar oculto usando algum tipo de mecanismo de alternância de recursos.
Há mais de uma opinião sobre este assunto. Aqui está uma postagem de blog que é uma ramificação de recursos pro com CI.
Os ramos de lançamento são muito úteis, e até mesmo absolutamente necessários, se você precisar manter várias versões do seu aplicativo.
Os ramos de recursos também são muito convenientes, especialmente se um desenvolvedor precisa trabalhar em uma grande mudança, enquanto outros ainda lançam novas versões.
Então, para mim, usar ambos os mecanismos é uma estratégia muito boa.
Link interessante do Livro do SVN.
Recentemente, gostei desse modelo ao usar o git. Embora sua pergunta seja marcada como "svn", você ainda pode fazer algum uso disso.
A integração contínua pode, em certa medida, acontecer no ramo "desenvolver" (ou seja o que for que você chamar) neste modelo, embora possuir ramos de recursos longos para lançamentos futuros não o tornem tão rígido quanto a considerar cada mudança acontecendo com o código em algum lugar. A questão permanece, se você realmente quer isso. Martin Fowler faz.
A integração contínua não deve ser qualquer tipo de fator na determinação de sua estratégia de ramificação. Sua abordagem de ramificação deve ser selecionada com base em sua equipe, o sistema em desenvolvimento e as ferramentas disponíveis para você.
Tendo dito isto .
não há nenhuma razão para que a CI não possa ser usada em ambas as abordagens que você descreve, essas abordagens funcionam bastante bem em combinação, nenhum dos dois trabalha "melhor" do que o outro CI faz todo o sentido com um tronco instável.
Tudo isso foi respondido na quarta pergunta na página da qual você tirou os diagramas: blogs. collab / subversion / 2007/11 / branching-strat /
Enquanto você entender os princípios, você sempre pode reinventar as melhores práticas. Se você não entender os princípios, as melhores práticas irão levá-lo até antes de desmoronar devido a algum requisito externo conflitante.
Leia o link. Uma vez que você obteve o básico, leia o seguinte artigo pelo venerável Henrik Kniberg. Ele irá ajudá-lo a relacionar o Mainline Model com integração contínua.
Quando iniciamos nossa equipe, herdamos uma estratégia baseada em lançamentos do fornecedor que originalmente desenvolveu o sistema ao qual estávamos prestes a se encarregar. Isso funcionou até o momento em que nossos clientes solicitaram que vários recursos desenvolvidos não fossem incluídos em um lançamento (f. y.i.
250k linhas de código,
2500 arquivos, Scrum com XP SDLC).
Em seguida, começamos a olhar para os ramos baseados em recursos. Isso também funcionou por um tempo - como 2 meses até o momento em que percebemos que nosso processo de teste de regressão levaria mais de 2 semanas, o que combinado com a incerteza do que seria lançado criou uma enorme inconveniência.
O último "prego no caixão" de estratégias SC puras veio quando decidimos que deveríamos ter 1. tronco estável e 2. A produção deveria conter BINÁRIOS testados ST, UAT e Regressão (não apenas fonte - pense CC).
Isso nos leva a conceber uma estratégia que seja um híbrido entre as estratégias SC e baseadas em lançamento.
Então nós temos um baú. Todos os sprints nos ramificamos no ramo de sprint (para pessoas não ágeis - um sprint é apenas um esforço de desenvolvimento com caixa de tempo com saída variável com base na complexidade). Do ramo de sprint criamos os ramos de recursos e o desenvolvimento paralelo é iniciado neles. Uma vez que os recursos estão completos e testados pelo sistema, e recebemos a intenção de implementá-los, eles são incorporados ao ramo de sprint - alguns podem flutuar em vários sprints, geralmente os mais complexos. Uma vez que o sprint está perto do seu fim e as características estão completas. nós "renomeamos" o ramo de sprint para "regressão" (isso permite que o CruiseControl o apanhe sem qualquer reconfiguração) e o teste de regressão / integração começa no EAR construído no cc. Quando tudo estiver pronto, ele vai em produção.
Em suma, os ramos baseados em recursos são usados para desenvolver, teste do sistema e funcionalidade UAT. O ramo de sprint (realmente o ramo de lançamento) é usado para mesclar seletivamente os recursos sob demanda e teste de integração.
Agora, aqui é uma questão para a comunidade - obviamente estamos tendo problemas para realizar uma integração contínua devido ao fato de que o desenvolvimento acontece em muitos ramos e a sobrecarga de reconfiguração do CruiseControl. Alguém pode sugerir e orientar?
Do jeito que eu vejo você quer ter um conjunto limitado de ramos onde você pode se concentrar. Uma vez que você deseja testes, métricas de qualidade de código e muitas coisas interessantes para executar com as compilações, ter muitos relatórios provavelmente irá levá-lo a perder informações.
Quando e o que se ramifica, geralmente depende do tamanho da equipe e do tamanho das características que estão sendo desenvolvidas. Eu não acho que haja uma regra de ouro. Certifique-se de usar uma estratégia onde você possa receber comentários com antecedência / freqüência, e isso inclui ter qualidade envolvida desde o início dos recursos. O bit de qualidade significa que, à medida que você está automatizando à medida que a equipe se desenvolve, se você se ramifica para um grande conjunto de recursos criado por uma equipe, você também deve ter qualidade envolvida na equipe.
ps Onde você obteve as referências da abordagem? - não sente que esses gráficos representam todas as opções.
Atualização 1: expandindo porque eu disse que não é uma regra de ouro. Basicamente, para equipes relativamente pequenas, achei melhor usar uma abordagem que seja uma mistura. Os ramos de recursos são criados se for algo longo e parte da equipe continuará adicionando recursos menores.
Eu acho que as ferramentas que você usa são um grande fator aqui.
Se você estiver usando a subversão, aderindo à opção 1 e soltando as filiais. Se você estiver usando o GIT, a opção 2 funcionará bem para você.
característica de estratégia de ramificação do Subversion versus lançamento
Esta documentação foi escrita para descrever a série 1.7.x do Apacheв "ў Subversion®. Se você estiver executando uma versão diferente do Subversion, você é fortemente encorajado a visitar svnbook / e, em vez disso, consulte a versão desta documentação apropriada para sua versão do Subversion.
Padrões comuns de ramificação.
Há muitos usos diferentes para ramificação e svn mesclar, e esta seção descreve o mais comum.
O controle de versão é usado com mais freqüência para o desenvolvimento de software, então é uma rápida olhada em dois dos padrões de ramificação / fusão mais comuns usados por equipes de programadores. Se você não estiver usando o Subversion para desenvolvimento de software, sinta-se à vontade para ignorar esta seção. Se você é um desenvolvedor de software que usa o controle de versão pela primeira vez, preste muita atenção, pois esses padrões são muitas vezes considerados melhores práticas por pessoas experientes. Esses processos não são específicos do Subversion; eles são aplicáveis a qualquer sistema de controle de versão. Ainda assim, pode ajudar a vê-los descritos nos termos do Subversion.
Ramos de publicação.
A maioria dos programas tem um ciclo de vida típico: código, teste, lançamento, repetição. Existem dois problemas com esse processo. Primeiro, os desenvolvedores precisam continuar escrevendo novos recursos, enquanto as equipes de garantia de qualidade levam tempo para testar versões supostamente estáveis do software. O novo trabalho não pode parar enquanto o software é testado. Em segundo lugar, o time quase sempre precisa suportar versões de software mais antigas e lançadas; Se um bug for descoberto no código mais recente, provavelmente também existe em versões lançadas, e os clientes vão querer obter essa correção de bugs sem ter que esperar por uma nova versão importante.
Aqui é onde o controle de versão pode ajudar. O procedimento típico parece assim:
Os desenvolvedores comprometem todo o trabalho novo no tronco. As mudanças do dia-a-dia estão comprometidas com / tronco: novos recursos, correções de bugs, e assim por diante.
O tronco é copiado para um ramo de "liberação". Quando a equipe pensa que o software está pronto para a liberação (por exemplo, uma versão 1.0), o tronco pode ser copiado para /branches/1.0.
As equipes continuam a trabalhar em paralelo. Uma equipe começa testes rigorosos do ramo de lançamento, enquanto outra equipe continua um novo trabalho (digamos, para a versão 2.0) no / tronco. Se os erros forem descobertos em qualquer local, as correções serão carregadas para frente e para trás, conforme necessário. Em algum momento, no entanto, mesmo esse processo pára. O ramo está "congelado" para o teste final antes de um lançamento.
O ramo é marcado e liberado. Quando o teste estiver completo, /branches/1.0 é copiado para /tags/1.0.0 como um instantâneo de referência. A etiqueta é empacotada e lançada para clientes.
O ramo é mantido ao longo do tempo. Enquanto o trabalho continuar no / tronco para a versão 2.0, as correções de bugs continuam sendo portadas de / tronco para /branches/1.0. Quando suficientes correções de bugs se acumulam, o gerenciamento pode decidir fazer uma versão 1.0.1: /branches/1.0 é copiado para /tags/1.0.1 e a etiqueta é empacotada e liberada.
Todo esse processo se repete à medida que o software amadurece: quando o trabalho 2.0 estiver completo, um novo ramo de liberação 2.0 é criado, testado, etiquetado e eventualmente lançado. Depois de alguns anos, o repositório termina com vários ramos de lançamento no modo "manutenção", e uma série de tags que representam as versões enviadas.
Ramos de recursos.
Um ramo de recursos é o tipo de ramo que tem sido o exemplo dominante neste capítulo (aquele em que você trabalhou enquanto a Sally continua trabalhando no tronco). É um ramo temporário criado para trabalhar em uma mudança complexa sem interferir com a estabilidade do tronco. Ao contrário dos ramos de lançamento (que podem precisar ser suportados para sempre), os ramos de recursos nascem, usados por um tempo, fundidos de volta ao tronco e, em seguida, excluídos. Eles têm um período finito de utilidade.
Novamente, as políticas de projetos variam amplamente sobre exatamente quando é apropriado criar um ramo de recursos. Alguns projetos nunca usam ramos de recursos: os compromissos para / tronco são gratuitos para todos. A vantagem desse sistema é que é simples: "ninguém precisa aprender sobre ramificação ou fusão. A desvantagem é que o código do tronco é muitas vezes instável ou inutilizável. Outros projetos usam ramos para um extremo: nenhuma mudança já foi comprometida com o tronco diretamente. Mesmo as mudanças mais triviais são criadas em um ramo de curta duração, cuidadosamente revisadas e fundidas no tronco. Em seguida, o ramo é excluído. Este sistema garante um tronco excepcionalmente estável e utilizável em todos os momentos, mas ao custo de uma enorme carga de processo.
A maioria dos projetos aborda a abordagem do meio-da-estrada. Eles geralmente insistem em que / compilar tronco e passar testes de regressão em todos os momentos. Um ramo de recursos é necessário apenas quando uma mudança requer um grande número de compromissos desestabilizadores. Uma boa regra geral é fazer esta pergunta: se o desenvolvedor trabalhou por dias isoladamente e depois comprometeu a grande mudança de uma só vez (de modo que o tronco nunca foi desestabilizado), seria uma grande mudança para revisão? Se a resposta a essa pergunta é "sim", a mudança deve ser desenvolvida em um ramo de recursos. À medida que o desenvolvedor compromete mudanças incrementais no ramo, eles podem ser facilmente revisados por colegas.
Finalmente, há a questão de como manter melhor um ramo de recursos em "sincronização" com o tronco à medida que o trabalho avança. Como mencionamos anteriormente, há um grande risco de trabalhar em uma filial por semanas ou meses; as mudanças do tronco podem continuar a derramar, até o ponto em que as duas linhas de desenvolvimento diferem tanto que pode se tornar um pesadelo tentando unir o ramo de volta ao tronco.
Esta situação é melhor evitada através da fusão regular das mudanças no tronco para o ramo. Elimine uma política: uma vez por semana, combine o valor da semana passada de alterações no tronco para o ramo.
Quando você finalmente estiver pronto para mesclar o ramo de características sincronizadas do tronco, comece fazendo uma fusão final das últimas mudanças no tronco para o ramo. Quando isso for feito, as versões mais recentes do ramo e do tronco são absolutamente idênticas, exceto para as mudanças de sua filial. Em seguida, você combina novamente com a opção --reintegrar:
Outra maneira de pensar sobre esse padrão é que sua sincronização semanal do tronco para o ramo é análoga à execução da atualização do svn em uma cópia de trabalho, enquanto a etapa de mesclagem final é análoga à execução do commit do svn a partir de uma cópia de trabalho. Afinal, o que mais é uma cópia de trabalho, mas um ramo privado muito superficial? É um ramo que é capaz de armazenar apenas uma mudança por vez.
Você está lendo o Controle de Versão com Subversion (para Subversion 1.7), de Ben Collins-Sussman, Brian W. Fitzpatrick e C. Michael Pilato.
O recurso abre caminho para a grandeza.
Ou tarefa que se ramifica para lá. Ou liberar ramificações. Você escolhe.
Quase todos os sistemas de controle de versão hoje oferecem suporte a ramos e ndash, linhas de trabalho independentes que decorrem de uma base de código central. Dependendo do seu sistema de controle de versão, o ramo principal pode ser chamado de mestre, mainline, padrão ou tronco. Os desenvolvedores podem criar seus próprios ramos da linha principal do código e trabalhar de forma independente ao lado dele.
Por que se preocupar com a ramificação?
O Branching permite que equipes de desenvolvedores colaborem facilmente dentro de uma base de código central. Quando um desenvolvedor cria um ramo, o sistema de controle de versão cria uma cópia da base de código naquele momento. As mudanças na filial não afetam outros desenvolvedores no time. Isso é uma coisa boa, obviamente, porque os recursos em desenvolvimento podem criar instabilidade, o que seria altamente perturbador se todo o trabalho estava acontecendo na linha principal do código. Mas os ramos não precisam viver em confinamento solitário. Os desenvolvedores podem facilmente reduzir as mudanças de outros desenvolvedores para colaborar em recursos e garantir que seus ramos privados não se divertem muito do mestre.
Os ramos não são bons para o trabalho de recurso. Os ramos podem isolar o time de mudanças arquitetônicas importantes, como atualizações, bibliotecas comuns, etc.
Três estratégias de ramificação para equipes ágeis.
Os modelos de ramificação geralmente diferem entre equipes e são objeto de muito debate na comunidade de software. Um grande tema é a quantidade de trabalho que deve permanecer em um ramo antes de ser incorporado de novo ao mestre.
Liberação de ramificação.
A ramificação de lançamento refere-se à idéia de que uma versão está inteiramente contida em um ramo. Isso significa que, no final do ciclo de desenvolvimento, o gerente de lançamento criará um ramo do mestre (por exemplo, & ldquo; 1.1 ramo de desenvolvimento & rdquo;). Todas as alterações para a versão 1.1 devem ser aplicadas duas vezes: uma vez para o ramo 1.1 e, em seguida, para a linha do código mestre. Trabalhar com dois ramos é trabalho extra para a equipe e é fácil esquecer de fundir os dois ramos. Os ramos de liberação podem ser difíceis de manejar e difíceis de gerenciar, pois muitas pessoas estão trabalhando no mesmo ramo. Nós sentimos a dor de ter que combinar muitas mudanças diferentes em um único ramo. Se você deve fazer um ramo de lançamento, crie o ramo o mais próximo possível da versão real.
A ramificação de lançamento é uma parte importante do suporte de software versionado no mercado. Um único produto pode ter vários ramos de libertação (por exemplo, 1.1, 1.2, 2.0) para suportar o desenvolvimento de sustentação. Tenha em mente que as mudanças em versões anteriores (ou seja, 1.1) podem precisar ser mescladas para ramos de liberação posteriores (ou seja, 1.2, 2.0). Confira nosso webinar abaixo para saber mais sobre como gerenciar os ramos de lançamento com o Git.
Característica ramificação.
Os ramos de recursos geralmente são acoplados com bandeiras de recurso e ndash; & quot; toggles & quot; que permitem ou desativam um recurso dentro do produto. Isso facilita a implantação do código em mestre e controle quando o recurso é ativado, facilitando a implantação do código antes do recurso ser exposto aos usuários finais.
Outro benefício das bandeiras de recursos é que o código pode permanecer dentro da compilação, mas inativo enquanto ele está em desenvolvimento. Se algo estiver errado quando o recurso estiver ativado, um administrador do sistema pode reverter o sinalizador de recurso e voltar para um bom estado conhecido em vez de ter que implantar uma nova compilação.
Ramificação de tarefas.
Na Atlassian, nos concentramos em um fluxo de trabalho de ramificação por tarefa. Toda organização tem uma maneira natural de quebrar o trabalho em tarefas individuais dentro de um rastreador de problemas, como o Jira Software. As questões então se tornam o ponto central de contato da equipe para esse trabalho. A ramificação de tarefas, também conhecida como ramificação de problemas, conecta diretamente esses problemas com o código-fonte. Cada questão é implementada em seu próprio ramo com a chave de problema incluída no nome da filial. É fácil ver qual código implementa qual questão: basta procurar a chave de problema no nome do ramo. Com esse nível de transparência, é mais fácil aplicar mudanças específicas ao mestre ou qualquer ramo de lançamento legado em execução.
Desde centros ágiles em torno de histórias de usuários, os ramos de tarefas parecem bem com o desenvolvimento ágil. Cada história de usuário (ou correção de bugs) vive dentro de seu próprio ramo, facilitando a visão de quais problemas estão em andamento e estão prontos para serem lançados. Para um mergulho profundo em uma ramificação de tarefas (às vezes chamado de ramificação de problemas ou ramificação por questão), pegue algumas pipocas e confira a gravação do webinar abaixo do & ndash, um dos nossos mais populares de todos os tempos.
Agora conheça o gêmeo malvado da ramificação: a fusão.
Todos nós sofremos a dor de tentar integrar vários ramos em uma solução sensata. Tradicionalmente, sistemas de controle de versão centralizados como o Subversion fizeram uma operação muito dolorosa. Mas os sistemas de controle de versões mais recentes, como o Git e o Mercurial, tomam uma abordagem diferente para rastrear versões de arquivos que vivem em diferentes ramos.
Os ramos tendem a ser de curta duração, tornando-os mais fáceis de fundir e mais flexíveis em toda a base do código. Entre a capacidade de mesclar freqüentemente e automaticamente os ramos como parte da integração contínua (CI), e o fato de que os ramos de curta duração simplesmente contêm menos mudanças, "fundir o inferno" becomes is a thing of the past for teams using Git and Mercurial.
That's what makes task branching so awesome!
Validate, validate, validate.
A version control system can only go so far in affecting the outcome of a merge. Automated testing and continuous integration are critical as well. Most CI servers can automatically put new branches under test, drastically reducing the number of "surprises" upon the final merge upstream and helping to keep the main code line stable.
Agile has had a huge impact on me both professionally and personally as I've learned the best experiences are agile, both in code and in life. You'll often find me at the intersection of technology, photography, and motorcycling. Find me on Twitter! @danradigan.
Sign up for more articles.
Obrigado por inscrever-se!
How to do scrum with Jira Software.
A step-by-step guide on how to drive a scrum project, prioritize and organize your backlog into sprints, run the Scrum ceremonies and more, all within Jira Software.
Git branching for agile teams.
Moving to Git opens up a whole new level of agility for software teams. Here's how to design branching schemes for shipping both SaaS and installed products.
Obter através da App Store Leia esta publicação em nosso aplicativo!
Melhor estratégia de ramificação ao fazer integração contínua?
Qual é a melhor estratégia de ramificação a ser usada quando você quer fazer integração contínua?
Release Branching: desenvolva no tronco, mantenha um ramo para cada lançamento. Ramificação de recursos: desenvolva cada recurso em uma ramificação separada, apenas funde uma vez estável.
Faz sentido usar essas duas estratégias juntas? Como em, você se ramifica para cada versão, mas você também se ramifica para grandes recursos? Uma dessas estratégias engrena melhor com a integração contínua? Usar integração contínua ainda faz sentido ao usar um tronco instável?
11 Respostas.
A resposta depende do tamanho da sua equipe e da qualidade do seu controle de origem e da capacidade de mesclar conjuntos de mudanças complexas corretamente. Por exemplo, no controle de fonte de ramo completo, como a fusão CVS ou SVN pode ser difícil e você pode estar melhor com o primeiro modelo, enquanto que se usar um sistema mais complexo como o IBM ClearCase e com um tamanho maior de equipe, você poderia ser melhor com o segundo modelo ou uma combinação dos dois.
Eu, pessoalmente, separaria o modelo de ramal de recursos, onde cada característica principal é desenvolvida em um ramo separado, com subdivisões de tarefas para cada mudança feita pelo desenvolvedor individual. À medida que os recursos se estabilizam, eles são mesclados ao tronco, o que você mantém razoavelmente estável e passa todos os testes de regressão em todos os momentos. À medida que você está perto do final do seu ciclo de lançamento e todos os ramos de recursos se fundem, você se estabiliza e se ramifica de um ramo do sistema de liberação no qual você apenas faz correções de bug de estabilidade e backports necessários, enquanto o tronco é usado para o desenvolvimento da próxima versão e você novamente se ramificam para novos ramos de recursos. E assim por diante.
Desta forma, o tronco contém sempre o código mais recente, mas você consegue mantê-lo razoavelmente estável, criando rótulos estáveis (tags) em grandes mudanças e fusões de recursos, os ramos de recursos são desenvolvimento de ritmo rápido com integração contínua e sub-ramos de tarefas individuais podem ser muitas vezes atualizado do ramo de recursos para manter todos os que trabalham no mesmo recurso em sincronia, enquanto simultaneamente não afetam outras equipes trabalhando em diferentes recursos.
Ao mesmo tempo, você tem através do histórico um conjunto de ramos de lançamento, onde você pode fornecer backports, suporte e correções de erros para seus clientes que, por qualquer motivo, permanecem em versões anteriores do seu produto ou mesmo apenas na versão mais recente lançada. Tal como acontece com o tronco, você não configura a integração contínua nos ramos de lançamento, eles são cuidadosamente integrados ao passar todos os testes de regressão e outros controles de qualidade de liberação.
Se por algum motivo dois recursos são co-dependentes e precisam de mudanças feitas um com o outro, você pode considerar desenvolver ambos no mesmo ramo de recursos ou exigir que os recursos agrupem regularmente partes estáveis do código no tronco e depois atualize as alterações de tronco para trocar código entre ramos do tronco. Ou se você precisar isolar esses dois recursos de outros, você pode criar um ramo comum do qual você ramifica esses ramos de recursos e que você pode usar para trocar código entre os recursos.
O modelo acima não faz muito sentido com equipes com menos de 50 desenvolvedores e sistema de controle de fonte sem ramos esparsos e capacidade de fusão adequada como CVS ou SVN, o que tornaria todo esse modelo um pesadelo para configurar, gerenciar e integrar.
Eu acho o tópico realmente interessante, porque eu confio muito nas filiais no meu trabalho diário.
Lembro-me de Mark Shuttleworth, que propõe um modelo sobre manter o ramo principal puro enquanto vai além do CI convencional. Eu postei sobre isso aqui. Como estou familiarizado com o Cruise Control, também bloguei sobre filiais de tarefas e CI aqui. É um tutorial passo a passo explicando como fazê-lo com SCM de plástico. Finalmente, encontrei alguns dos tópicos sobre CI (e potencialmente falando sobre ramificação) no livro de Duvall sobre a CI também muito interessante.
Espero que você ache os links interessantes.
Eu pessoalmente acho muito mais limpo ter um tronco estável e apresentar ramificações. Dessa forma, os testadores e similares conseguem permanecer em uma única "versão" e atualizar do tronco para testar qualquer recurso que seja codificado.
Além disso, se vários desenvolvedores estiverem trabalhando em recursos diferentes, eles podem ter seus próprios ramos separados, depois fundir no tronco quando terminarem e enviar um recurso para serem testados sem que o testador tenha que alternar para vários ramos para testar diferentes recursos.
Como um bônus adicional, há algum nível de testes de integração que vem automaticamente.
Penso que qualquer uma das estratégias pode ser usada com o desenvolvimento contínuo, desde que você se lembre de um dos princípios fundamentais que cada desenvolvedor comete no tronco / mainline todos os dias.
Eu tenho feito uma leitura deste livro sobre a CI e os autores sugerem que a ramificação por lançamento é a estratégia de ramificação preferida. Eu tenho que concordar. O raciocínio por recurso não faz sentido para mim ao usar o CI.
Vou tentar e explicar por que estou pensando dessa maneira. Digamos que três desenvolvedores tomem um ramo para trabalhar em um recurso. Cada recurso levará vários dias ou semanas para terminar. Para garantir que a equipe esteja se integrando continuamente, eles devem se comprometer com a filial principal pelo menos uma vez por dia. Assim que eles começam a fazer isso, eles perdem o benefício de criar um ramo de recursos. Suas mudanças não são mais separadas de todas as mudanças do outro desenvolvedor. Sendo assim, por que se preocupar em criar filiais de recursos em primeiro lugar?
O uso de ramificação por versão requer muito menos fusão entre os ramos (sempre é uma coisa boa), garante que todas as alterações sejam integradas o mais rápido possível e (se feito corretamente) garante que sua base de código esteja sempre pronta para ser liberada. O lado negativo para se ramificar pelo lançamento é que você deve ter um cuidado consideravelmente mais cuidadoso com as mudanças. Por exemplo. A refatoração ampla deve ser feita de forma incremental e, se você já integrou um novo recurso que não deseja na próxima versão, ele deve estar oculto usando algum tipo de mecanismo de alternância de recursos.
Há mais de uma opinião sobre este assunto. Aqui está uma postagem de blog que é uma ramificação de recursos pro com CI.
Os ramos de lançamento são muito úteis, e até mesmo absolutamente necessários, se você precisar manter várias versões do seu aplicativo.
Os ramos de recursos também são muito convenientes, especialmente se um desenvolvedor precisa trabalhar em uma grande mudança, enquanto outros ainda lançam novas versões.
Então, para mim, usar ambos os mecanismos é uma estratégia muito boa.
Link interessante do Livro do SVN.
Recentemente, gostei desse modelo ao usar o git. Embora sua pergunta seja marcada como "svn", você ainda pode fazer algum uso disso.
A integração contínua pode, em certa medida, acontecer no ramo "desenvolver" (ou seja o que for que você chamar) neste modelo, embora possuir ramos de recursos longos para lançamentos futuros não o tornem tão rígido quanto a considerar cada mudança acontecendo com o código em algum lugar. A questão permanece, se você realmente quer isso. Martin Fowler faz.
A integração contínua não deve ser qualquer tipo de fator na determinação de sua estratégia de ramificação. Sua abordagem de ramificação deve ser selecionada com base em sua equipe, o sistema em desenvolvimento e as ferramentas disponíveis para você.
Tendo dito isto .
não há nenhuma razão para que a CI não possa ser usada em ambas as abordagens que você descreve, essas abordagens funcionam bastante bem em combinação, nenhum dos dois trabalha "melhor" do que o outro CI faz todo o sentido com um tronco instável.
Tudo isso foi respondido na quarta pergunta na página da qual você tirou os diagramas: blogs. collab / subversion / 2007/11 / branching-strat /
Enquanto você entender os princípios, você sempre pode reinventar as melhores práticas. Se você não entender os princípios, as melhores práticas irão levá-lo até antes de desmoronar devido a algum requisito externo conflitante.
Leia o link. Uma vez que você obteve o básico, leia o seguinte artigo pelo venerável Henrik Kniberg. Ele irá ajudá-lo a relacionar o Mainline Model com integração contínua.
Quando iniciamos nossa equipe, herdamos uma estratégia baseada em lançamentos do fornecedor que originalmente desenvolveu o sistema ao qual estávamos prestes a se encarregar. Isso funcionou até o momento em que nossos clientes solicitaram que vários recursos desenvolvidos não fossem incluídos em um lançamento (f. y.i.
250k linhas de código,
2500 arquivos, Scrum com XP SDLC).
Em seguida, começamos a olhar para os ramos baseados em recursos. Isso também funcionou por um tempo - como 2 meses até o momento em que percebemos que nosso processo de teste de regressão levaria mais de 2 semanas, o que combinado com a incerteza do que seria lançado criou uma enorme inconveniência.
O último "prego no caixão" de estratégias SC puras veio quando decidimos que deveríamos ter 1. tronco estável e 2. A produção deveria conter BINÁRIOS testados ST, UAT e Regressão (não apenas fonte - pense CC).
Isso nos leva a conceber uma estratégia que seja um híbrido entre as estratégias SC e baseadas em lançamento.
Então nós temos um baú. Todos os sprints nos ramificamos no ramo de sprint (para pessoas não ágeis - um sprint é apenas um esforço de desenvolvimento com caixa de tempo com saída variável com base na complexidade). Do ramo de sprint criamos os ramos de recursos e o desenvolvimento paralelo é iniciado neles. Uma vez que os recursos estão completos e testados pelo sistema, e recebemos a intenção de implementá-los, eles são incorporados ao ramo de sprint - alguns podem flutuar em vários sprints, geralmente os mais complexos. Uma vez que o sprint está perto do seu fim e as características estão completas. nós "renomeamos" o ramo de sprint para "regressão" (isso permite que o CruiseControl o apanhe sem qualquer reconfiguração) e o teste de regressão / integração começa no EAR construído no cc. Quando tudo estiver pronto, ele vai em produção.
Em suma, os ramos baseados em recursos são usados para desenvolver, teste do sistema e funcionalidade UAT. O ramo de sprint (realmente o ramo de lançamento) é usado para mesclar seletivamente os recursos sob demanda e teste de integração.
Agora, aqui é uma questão para a comunidade - obviamente estamos tendo problemas para realizar uma integração contínua devido ao fato de que o desenvolvimento acontece em muitos ramos e a sobrecarga de reconfiguração do CruiseControl. Alguém pode sugerir e orientar?
Do jeito que eu vejo você quer ter um conjunto limitado de ramos onde você pode se concentrar. Uma vez que você deseja testes, métricas de qualidade de código e muitas coisas interessantes para executar com as compilações, ter muitos relatórios provavelmente irá levá-lo a perder informações.
Quando e o que se ramifica, geralmente depende do tamanho da equipe e do tamanho das características que estão sendo desenvolvidas. Eu não acho que haja uma regra de ouro. Certifique-se de usar uma estratégia onde você possa receber comentários com antecedência / freqüência, e isso inclui ter qualidade envolvida desde o início dos recursos. O bit de qualidade significa que, à medida que você está automatizando à medida que a equipe se desenvolve, se você se ramifica para um grande conjunto de recursos criado por uma equipe, você também deve ter qualidade envolvida na equipe.
ps Onde você obteve as referências da abordagem? - não sente que esses gráficos representam todas as opções.
Atualização 1: expandindo porque eu disse que não é uma regra de ouro. Basicamente, para equipes relativamente pequenas, achei melhor usar uma abordagem que seja uma mistura. Os ramos de recursos são criados se for algo longo e parte da equipe continuará adicionando recursos menores.
Eu acho que as ferramentas que você usa são um grande fator aqui.
Se você estiver usando a subversão, aderindo à opção 1 e soltando as filiais. Se você estiver usando o GIT, a opção 2 funcionará bem para você.
No comments:
Post a Comment