Desenvolver sequenciamento ao usar o controle de versão distribuído

StackOverflow https://stackoverflow.com/questions/122424

  •  02-07-2019
  •  | 
  •  

Pergunta

Agora, estamos usando Perforce para controle de versão. Ele tem a característica útil de um número de alteração estritamente crescente que podemos usar para se referir a constrói, por exemplo, "você vai ter o bugfix se a sua construção é, pelo menos, 44902".

Eu gostaria de passar a usar um sistema distribuído (provavelmente git) para torná-lo mais fácil de ramo e trabalhar em casa. (Ambos são perfeitamente possível com Perforce, mas o fluxo de trabalho git tem algumas vantagens.) Assim, embora "desenvolvimento tributário" seria distribuído e não se referem a um sequenciamento de revisão comum, nós ainda manter um repositório mestre git que todas as mudanças faria necessidade de alimentação para antes de uma compilação foi criado.

Qual é a melhor maneira de preservar estritamente crescente ids construir? A maneira mais simples que posso pensar é ter algum tipo de gancho post-commit que os incêndios fora sempre que o repo mestre é atualizado, e ele registra (o hash) o novo objeto árvore (ou cometer objeto? Eu sou novo para git) com um banco de dados centralizado que distribui ids. (Eu digo "banco de dados", mas eu provavelmente faria com etiquetas git, e basta olhar para o número seguinte tag disponíveis ou algo assim. Assim, o "banco de dados" seria realmente .git / refs / tags / build-id /. )

Este é viável, mas eu estou querendo saber se existe uma maneira mais fácil, ou já implementadas, ou standard / "melhor prática" de fazer isso.

Foi útil?

Solução

Eu segundo a sugestão de usar git describe. Desde que você tem uma sã política de controle de versão, e você não fizer qualquer coisa louca com seu repositório, git describe será sempre monotônica (pelo menos tão monótona como você pode ser, quando o seu histórico de revisão é um DAG em vez de uma árvore) e único.

Uma pequena demonstração: 

git init
git commit --allow-empty -m'Commit One.'
git tag -a -m'Tag One.' 1.2.3
git describe    # => 1.2.3
git commit --allow-empty -m'Commit Two.'
git describe    # => 1.2.3-1-gaac161d
git commit --allow-empty -m'Commit Three.'
git describe    # => 1.2.3-2-g462715d
git tag -a -m'Tag Two.' 2.0.0
git describe    # => 2.0.0

A saída de git describe consiste nos seguintes componentes:

  1. O último tag acessível a partir da comprometer você está pedindo para descrever
  2. O número de commits entre a comprometer ea tag (se não-zero)
  3. A (abreviado) id do commit (se # 2 é diferente de zero)

# 2 é o que faz a monótona saída, # 3 é o que o torna único. # 2 e # 3 são omitidas, quando a cometer é o tag, tornando git describe também adequado para lançamentos de produção.

Outras dicas

monotonamente crescente número correspondente à corrente commit poderia ser gerado com 

git log --pretty=oneline | wc -l

que retorna um único número. Você pode também acrescentar sha1 atual para esse número, para adicionar singularidade.

Esta abordagem é melhor do que git describe, porque ele não exige que você adicione todas as tags, e ele automaticamente lida com fusões.

Ele poderia ter problemas com rebasing, mas rebasing é uma operação "perigosa" de qualquer maneira. 

    git rev-list BRANCHNAME --count

este é muito menos recursos do que 

    git log --pretty=oneline | wc -l

git tag pode ser suficiente para o que você precisa. Escolha um formato de tag que todos vão concordar em não usar de outra forma.

Nota: quando você marcar localmente, um git push não irá atualizar as tags no servidor. Use git push --tags para isso.

Você deve investigar git describe. Dá uma corda única que descreve o ramo atual (ou qualquer passado cometer id) em termos da mais recente marca anotada, o número de commits desde que tag e um id abreviado cometer da cabeça do ramo.

Provavelmente, você tem um único ramo que você realiza lançamentos de construção controlado off. Neste caso, eu iria marcar uma comprometer cedo com um formato tag conhecido e, em seguida, usar git descrever com a opção --match para descrever o atual chefe em relação a um tag conhecido. Você pode então usar o resultado do git descrever como é ou se você realmente deseja apenas um único número que você pode usar um regex para cortar o número fora do tag.

Assumindo que você nunca retroceder o ramo do número de seguinte commit é sempre identificar um ponto único na história do ramo.

por exemplo. (Usando bash ou semelhante) 

# make an annotated tag to an early build in the repository:
git tag -a build-origin "$some_old_commitid"

# describe the current HEAD against this tag and pull out a build number
expr "$(git describe --match build-origin)" : 'build-origin-\([0-9]*\)-g'

Eu usaria "Labels" Criar uma etiqueta sempre que tiver uma compilação bem-sucedida (ou mesmo sem sucesso), e você será capaz de identificar que construir para sempre. Não é bem a mesma coisa, mas fornece esses números de compilação, enquanto continua a fornecer os benefícios do desenvolvimento distribuído.

Como você provavelmente sabe, git calcula um hash (um número) que identifica exclusivamente um nó da história. Usando estes, embora não sejam estritamente crescente, parece que seria bom o suficiente. (Ainda melhor, eles sempre correspondem à fonte, por isso, se você tem o hash, você tem o mesmo código.) Eles são grandes números, mas na maior parte você pode conviver com 6 ou assim da levando dígitos.

Por exemplo,

Esse bug foi fixado em 064f2ea ...

Com Mercurial você pode usar o seguinte comando: 

# get the parents id, the local revision number and the tags
[yjost@myhost:~/my-repo]$ hg id -nibt
03b6399bc32b+ 23716+ default tip

hg identificar

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top