Como criar submódulos rasos do git?

É possível ter submódulos rasos? Eu tenho um superprojeto com vários submódulos, cada um com uma longa história, por isso fica desnecessariamente grande arrastando toda essa história.

Tudo o que eu encontrei é esse tópico sem resposta .

Devo apenas hackear o git-submodule para implementar isso?

Novo no próximo git1.8.4 (julho de 2013) :

" git submodule update" pode opcionalmente clonar os repositórios do submódulo superficialmente.

(E o git 2.10 Q3 2016 permite gravar isso com git config -f .gitmodules submodule.<name>.shallow true.
Veja o final desta resposta)

Consulte commit 275cd184d52b5b81cb89e4ec33e540fb2ae61c1f :

Adicione a --depthopção aos comandos add e update do "submodule git", que são passados ​​ao comando clone. Isso é útil quando os submódulos são enormes e você não está realmente interessado em nada além da confirmação mais recente.

Os testes são adicionados e alguns ajustes de indentação foram feitos para estar em conformidade com o restante do arquivo de teste em "a atualização do sub-módulo pode manipular links simbólicos no pwd".

Assinado por: Fredrik Gustafsson <[email protected]>
Aceito por: Jens Lehmann<[email protected]>

Isso significa que isso funciona:

git submodule add --depth 1 -- repository path
git submodule update --depth -- [<path>...]

Com:

--depth::

Esta opção é válida para adde updatecomandos.
Crie um clone 'superficial' com um histórico truncado para o número especificado de revisões.

atwyman acrescenta nos comentários :

Tanto quanto sei, essa opção não é utilizável para submódulos que não acompanham de masterperto. Se você definir a profundidade 1, submodule updatepoderá ter êxito apenas se o submódulo que você deseja for o mais recente mestre. Caso contrário, você recebe " fatal: reference is not a tree" .

Isso é verdade.
Ou seja, até o git 2.8 (março de 2016). Com o 2.8, ele submodule update --depthtem mais uma chance de obter sucesso, mesmo que o SHA1 esteja diretamente acessível a partir de um dos HEADs de repositório remoto.

Veja commit fb43e31 (24 de fevereiro de 2016) por Stefan Beller ( stefanbeller) .
Ajudado por: Junio ​​C Hamano ( gitster) .
^{(Mesclado por Junio ​​C Hamano - gitster- na confirmação 9671a76 , 26 de fevereiro de 2016)}

submódulo: tente mais difícil buscar o sha1 necessário, buscando diretamente o sha1

Ao revisar uma alteração que também atualiza um submódulo no Gerrit, uma prática comum de revisão é baixar e escolher o patch localmente para testá-lo.
No entanto, ao testá-lo localmente, o ' git submodule update' pode falhar ao buscar o submódulo correto sha1, pois o commit correspondente no submódulo ainda não faz parte do histórico do projeto, mas também é apenas uma alteração proposta.

Se $sha1não fez parte da busca padrão, tentamos buscá-la $sha1diretamente . Alguns servidores, no entanto, não oferecem suporte à busca direta pelo sha1, o que leva git-fetchà falha rápida.
Nós podemos falhar aqui, pois o sha1 ainda ausente levaria a uma falha mais tarde na fase de checkout, de qualquer maneira, então falhar aqui é o melhor possível.

MVG aponta nos comentários para confirmar fb43e31 (git 2.9, fev 2016)

Parece-me que o commit fb43e31 solicita o commit ausente pelo ID SHA1, portanto as configurações uploadpack.allowReachableSHA1InWante uploadpack.allowTipSHA1InWantno servidor provavelmente afetarão se isso funciona.
Eu escrevi um post na lista git hoje , apontando como o uso de submódulos rasos poderia funcionar melhor em alguns cenários, a saber, se o commit também é uma tag.
Vamos esperar e ver.

Eu acho que essa é uma razão pela qual fb43e31 fez a busca para um SHA1 específico um fallback após a busca para a ramificação padrão.
No entanto, no caso de “--ththth 1”, acho que faria sentido abortar cedo: se nenhum dos refs listados corresponder ao solicitado, e a solicitação pelo SHA1 não for suportada pelo servidor, então não há sentido em buscando qualquer coisa, pois não seremos capazes de satisfazer o requisito do submódulo de qualquer maneira.

Atualização em agosto de 2016 (3 anos depois)

Com o Git 2.10 (terceiro trimestre de 2016), você poderá fazer

 git config -f .gitmodules submodule.<name>.shallow true

Consulte " Sub-módulo Git sem peso extra " para obter mais informações.

Git 2.13 (Q2 2017) adiciona no commit 8d3047c (19 de abril de 2017) por Sebastian Schuberth ( sschuberth) .
^{(Mesclado por Sebastian Schuberth - sschuberth- no commit 8d3047c , 20 de abril de 2017)}

um clone deste submódulo será executado como um clone superficial (com uma profundidade de histórico de 1)

No entanto, Ciro Santilli acrescenta nos comentários (e detalhes em sua resposta )

shallow = trueem .gitmodulessó afeta a referência monitorado pelo chefe do controle remoto quando usar --recurse-submodules, mesmo se o alvo cometer é apontado por um ramo, e mesmo se você colocar branch = mybranchsobre o .gitmodulesbem.

O Git 2.20 (quarto trimestre de 2018) aprimora o suporte ao submódulo, que foi atualizado para ler no blob HEAD:.gitmodulesquando o .gitmodulesarquivo estiver ausente na árvore de trabalho.

Consulte commit 2b1257e , commit 76e9bdc (25 de outubro de 2018) e commit b5c259f , commit 23dd8f5 , commit b2faad4 , commit 2502ffc , commit 996df4d , commit d1b13df , commit 45f5ef3 , commit bcbc780 (05 out 2018) por Antonio Ospite ( ao2) .
^{(Mesclado por Junio ​​C Hamano - gitster- in commit abb4824 , 13 de novembro de 2018)}

submodule: suporta leitura .gitmodulesquando não está na árvore de trabalho

Quando o .gitmodulesarquivo não estiver disponível na árvore de trabalho, tente usar o conteúdo do índice e da ramificação atual.
Isso abrange o caso em que o arquivo faz parte do repositório, mas, por algum motivo, não é retirado, por exemplo, devido a uma verificação esparsa.

Isso torna possível usar pelo menos os git submodulecomandos ' ' que lêem o gitmodulesarquivo de configuração sem preencher totalmente a árvore de trabalho.

Escrever para .gitmodulesainda exigirá que o arquivo esteja com check-out, portanto, verifique-o antes de ligar config_set_in_gitmodules_file_gently.

Adicione uma verificação semelhante também git-submodule.sh::cmd_add()para antecipar a eventual falha do git submodule addcomando " " quando .gitmodulesnão for gravável com segurança; isso evita que o comando deixe o repositório em um estado falso (por exemplo, o repositório do submódulo foi clonado, mas .gitmodulesnão foi atualizado porque config_set_in_gitmodules_file_gentlyfalhou).

Além disso, como config_from_gitmodules()agora acessa o armazenamento de objetos global, é necessário proteger todos os caminhos de código que chamam a função contra acesso simultâneo ao armazenamento de objetos global.
Atualmente, isso só acontece em builtin/grep.c::grep_submodules(), portanto, chame grep_read_lock()antes de chamar o código que envolve config_from_gitmodules().

NOTA: há um caso raro em que esse novo recurso ainda não funciona corretamente: submódulos aninhados sem .gitmodulesna árvore de trabalho.

Nota: O Git 2.24 (quarto trimestre de 2019) corrige um possível segfault ao clonar um submódulo superficial.

Veja commit ddb3c85 (30 set 2019) por Ali Utku Selen ( auselen) .
^{(Mesclado por Junio ​​C Hamano - gitster- in commit 678a9ca , 09 out 2019)}

O Git 2.25 (primeiro trimestre de 2020) esclarece a git submodule updatedocumentação.

Veja commit f0e58b3 (24 Nov 2019) por Philippe Blain ( phil-blain) .
^{(Incorporado por Junio ​​C Hamano - gitster- in commit ef61045 , 05 dez 2019)}

doc: mencionar que 'atualização do sub-módulo git' busca confirmações ausentes

^{Ajudado por: Junio ​​C Hamano
Ajudado por: Johannes Schindelin
Assinado por: Philippe Blain}

' git submoduleupdate' buscará novas confirmações no submódulo remoto se o SHA-1 registrado no superprojeto não for encontrado . Isso não foi mencionado na documentação.

Aviso: Com o Git 2.25 (primeiro trimestre de 2020), a interação entre " git clone --recurse-submodules" e o armazenamento de objetos alternativos foi mal projetada.

A documentação e o código foram ensinados a fazer recomendações mais claras quando os usuários veem falhas.

Consulte commit 4f3e57e , commit 10c64a0 (02 dez 2019) por Jonathan Tan ( jhowtan) .
^{(Mesclado por Junio ​​C Hamano - gitster- in commit 5dd1d59 , 10 dez 2019)}

submodule--helper: aconselhar sobre erro alternativo fatal

^{Assinado por: Jonathan Tan
Acked-by: Jeff King}

Ao clonar recursivamente um superprojeto com alguns módulos rasos definidos em seu e .gitmodules, em seguida, reclonar com " --reference=<path>", ocorre um erro. Por exemplo:

git clone --recurse-submodules --branch=master -j8 \
  https://android.googlesource.com/platform/superproject \
  master
git clone --recurse-submodules --branch=master -j8 \
  https://android.googlesource.com/platform/superproject \
  --reference master master2

falha com:

fatal: submodule '<snip>' cannot add alternate: reference repository
'<snip>' is shallow

Quando uma alternativa calculada a partir da alternativa do superprojeto não puder ser adicionada, seja neste caso ou em outro, informe sobre a submodule.alternateErrorStrategyconfiguração da opção de configuração " " e o uso de " --reference-if-able" em vez de " --reference" na clonagem.

Isso é detalhado em:

Com o Git 2.25 (primeiro trimestre de 2020), a interação entre o "git clone --recurse-submodules" e o armazenamento de objetos alternativos foi mal projetada.

Doc: explicar submodule.alternateErrorStrategy

^{Assinado por: Jonathan Tan
Acked-by: Jeff King}

A confirmação 31224cbdc7 (" clone: a opção recursiva e de referência aciona as alternativas do submódulo", 17/08/2016, Git v2.11.0-rc0 - fusão listada no lote # 1 ) ensinou o Git a suportar as opções de configuração " submodule.alternateLocation" e " submodule.alternateErrorStrategy" em um superprojeto .

Se " submodule.alternateLocation" estiver configurado para " superproject" em um superprojeto, sempre que um sub-módulo desse superprojeto for clonado, ele calculará o caminho alternativo análogo para esse sub-módulo a partir $GIT_DIR/objects/info/alternatesdo superprojeto e fará referência a ele.

A submodule.alternateErrorStrategyopção " " determina o que acontece se essa alternativa não puder ser referenciada.
No entanto, não está claro que o clone continue como se nenhuma alternativa fosse especificada quando essa opção não estiver configurada para "morrer" (como pode ser visto nos testes em 31224cbdc7 ).
Portanto, documente-o adequadamente.

A documentação do submódulo de configuração agora inclui:

submodule.alternateErrorStrategy::

Especifica como tratar erros com as alternativas para um submódulo conforme calculado via submodule.alternateLocation.
Os valores possíveis são ignore, info, die.
O padrão é die.
Observe que se definido como ignoreou infoe se houver um erro com a alternativa calculada, o clone continuará como se nenhuma alternativa fosse especificada .

Os sub-módulos de suporte do Git 2.9.0 raso clone diretamente, então agora você pode simplesmente chamar:

git clone url://to/source/repository --recursive --shallow-submodules

Seguindo a resposta de Ryan, consegui criar esse script simples que itera todos os submódulos e os clona superficialmente:

#!/bin/bash
git submodule init
for i in $(git submodule | sed -e 's/.* //'); do
    spath=$(git config -f .gitmodules --get submodule.$i.path)
    surl=$(git config -f .gitmodules --get submodule.$i.url)
    git clone --depth 1 $surl $spath
done
git submodule update

Lendo o "fonte" do git-submódulo, parece que ele git submodule addpode lidar com submódulos que já têm seus repositórios presentes. Nesse caso...

$ git clone $remote1 $repo
$ cd $repo
$ git clone --depth 5 $remotesub1 $sub1
$ git submodule add $remotesub1 $sub1
#repeat as necessary...

Você deseja garantir que a confirmação necessária esteja no repositório do submódulo, portanto, defina uma profundidade apropriada.

Editar: você pode se safar de vários clones de submódulos manuais, seguidos por uma única atualização:

$ git clone $remote1 $repo
$ cd $repo
$ git clone --depth 5 $remotesub1 $sub1
#repeat as necessary...
$ git submodule update

Resumo do comportamento incorreto / inesperado / irritante no Git 2.14.1

1. shallow = trueem .gitmodulesafeta apenas git clone --recurse-submodulesse o HEADdeste sub-módulo remoto aponta para o necessário cometer, mesmo se o alvo cometer é apontado por um ramo, e mesmo se você colocar branch = mybranchsobre o .gitmodulesbem.

   Script de teste local . O mesmo comportamento no GitHub 2017-11, onde HEADé controlado pela configuração padrão de repo branch:

   git clone --recurse-submodules https://github.com/cirosantilli/test-shallow-submodule-top-branch-shallow
   cd test-shallow-submodule-top-branch-shallow/mod
   git log
   # Multiple commits, not shallow.
   

2. git clone --recurse-submodules --shallow-submodulesfalhará se a cometer é nem referenciado por um ramo ou etiqueta com uma mensagem: error: Server does not allow request for unadvertised object.

   Script de teste local . Mesmo comportamento no GitHub:

   git clone --recurse-submodules --shallow-submodules https://github.com/cirosantilli/test-shallow-submodule-top-sha
   # error
   

   Também perguntei na lista de endereços: https://marc.info/?l=git&m=151863590026582&w=2 e a resposta foi:

   Em teoria, isso deve ser fácil. :)

   Na prática, nem tanto, infelizmente. Isso ocorre porque a clonagem obterá apenas a última dica de um ramo (geralmente mestre). Não há mecanismo no clone para especificar o sha1 exato que é desejado.

   O protocolo de conexão suporta a solicitação de sha1s exatos, para que isso seja coberto. (Advertência: só funciona se o operador do servidor ativar o uploadpack.allowReachableSHA1InWant que github não possui AFAICT)

   O git-fetch permite buscar sha1 arbitrário, portanto, como uma solução alternativa, você pode executar uma busca após o clone recursivo usando a "atualização do sub-módulo git", que utilizará buscas após o clone inicial.

Teste TODO: allowReachableSHA1InWant.

Os locais canônicos dos seus submódulos são remotos? Se sim, você está bem em cloná-los uma vez? Em outras palavras, você deseja os clones superficiais apenas porque está sofrendo a largura de banda desperdiçada dos (re) clones freqüentes de submódulos?

Se você deseja que clones rasos salvem espaço em disco local, a resposta de Ryan Graham parece ser um bom caminho. Clone manualmente os repositórios para que sejam rasos. Se você acha que seria útil, adapte-o git submodulepara apoiá-lo. Envie um email para a lista perguntando sobre isso (conselhos para implementá-lo, sugestões na interface etc.). Na minha opinião, o pessoal apoia bastante os colaboradores em potencial que desejam sinceramente aprimorar o Git de maneiras construtivas.

Se você concorda em executar um clone completo de cada submódulo (além de buscar mais tarde para mantê-los atualizados), tente usar a --referenceopção de git submodule update(está no Git 1.6.4 e posterior) para se referir aos armazenamentos de objetos locais (por exemplo, faça --mirrorclones dos repositórios canônicos de submódulos e use --referenceem seus submódulos para apontar para esses clones locais). Apenas certifique-se de ler sobre git clone --reference/ git clone --sharedantes de usar --reference. O único problema provável com os espelhos de referência seria se eles acabassem buscando atualizações sem avanço rápido (embora você possa ativar reflogs e expandir suas janelas de expiração para ajudar a reter quaisquer commits abandonados que possam causar um problema). Você não deve ter nenhum problema, desde que

• você não faz nenhum submódulo local confirma ou
• quaisquer confirmações deixadas pendentes por encaminhamentos não rápidos que os repositórios canônicos possam publicar não são ancestrais das confirmações do submódulo local ou
• você é diligente em manter as confirmações do submódulo local refazidas sobre qualquer avanço não rápido que possa ser publicado nos repositórios de submódulos canônicos.

Se você optar por algo assim e houver alguma chance de levar submissões locais do submódulo em suas árvores de trabalho, provavelmente seria uma boa ideia criar um sistema automatizado que garanta que os objetos críticos referenciados pelos submódulos retirados não sejam deixado pendurado nos repositórios espelhados (e, se houver algum, copia-os para os repositórios que precisam deles).

E, como git clonediz a página de manual, não use --referencese você não entender essas implicações.

# Full clone (mirror), done once.
git clone --mirror $sub1_url $path_to_mirrors/$sub1_name.git
git clone --mirror $sub2_url $path_to_mirrors/$sub2_name.git

# Reference the full clones any time you initialize a submodule
git clone $super_url super
cd super
git submodule update --init --reference $path_to_mirrors/$sub1_name.git $sub1_path_in_super
git submodule update --init --reference $path_to_mirrors/$sub2_name.git $sub2_path_in_super

# To avoid extra packs in each of the superprojects' submodules,
#   update the mirror clones before any pull/merge in super-projects.
for p in $path_to_mirrors/*.git; do GIT_DIR="$p" git fetch; done

cd super
git pull             # merges in new versions of submodules
git submodule update # update sub refs, checkout new versions,
                     #   but no download since they reference the updated mirrors

Como alternativa, em vez de --reference, você pode usar os clones de espelho em combinação com a funcionalidade de ligação direta padrão git cloneusando espelhos locais como a fonte para seus submódulos. Nos novos clones de superprojeto git submodule init, edite os URLs do submódulo .git/configpara apontar para os espelhos locais e, em seguida,git submodule update. Você precisaria reclinar todos os submódulos de check-out existentes para obter os hardlinks. Você economizaria largura de banda baixando apenas uma vez nos espelhos e depois localizando-os localmente nos sub-módulos com check-out. A vinculação física pouparia espaço em disco (embora as buscas tendam a se acumular e a duplicar-se em várias instâncias dos armazenamentos de objetos dos sub-módulos de check-out; você pode periodicamente reclinar os sub-módulos de check-out dos espelhos para recuperar a economia de espaço em disco fornecida por ligação direta).

Eu criei uma versão um pouco diferente, para quando ela não está sendo executada no limite, o que nem todos os projetos fazem. As adições de sub-módulo padrão não funcionaram nem o script acima. Então, eu adicionei uma pesquisa de hash para a tag ref e, se ela não tiver uma, ela volta ao clone completo.

#!/bin/bash
git submodule init
git submodule | while read hash name junk; do
    spath=$(git config -f .gitmodules --get submodule.$name.path)
    surl=$(git config -f .gitmodules --get submodule.$name.url)
    sbr=$(git ls-remote --tags $surl | sed -r "/${hash:1}/ s|^.*tags/([^^]+).*\$|\1|p;d")
    if [ -z $sbr ]; then
        git clone $surl $spath
    else
        git clone -b $sbr --depth 1 --single-branch $surl $spath
    fi
done
git submodule update 

Referência a Como clonar repositório git com revisão / conjunto de alterações específicas?

Eu escrevi um script simples que não tem problema quando a referência do sub-módulo está longe do mestre

git submodule foreach --recursive 'git rev-parse HEAD | xargs -I {} git fetch origin {} && git reset --hard FETCH_HEAD'

Esta declaração buscará a versão referenciada do submódulo.

É rápido, mas você não pode confirmar sua edição no submódulo (você deve buscá-lo antes de https://stackoverflow.com/a/17937889/3156509 )

na íntegra:

#!/bin/bash
git submodule init
git submodule foreach --recursive 'git rev-parse HEAD | xargs -I {} git fetch origin {} && git reset --hard FETCH_HEAD'
git submodule update --recursive

O clone raso de um submódulo é perfeito porque eles capturam instantaneamente uma revisão / conjunto de alterações específico. É fácil baixar um zip do site, então tentei um script.

#!/bin/bash
git submodule deinit --all -f
for value in $(git submodule | perl -pe 's/.*(\w{40})\s([^\s]+).*/\1:\2/'); do
  mysha=${value%:*}
  mysub=${value#*:}
  myurl=$(grep -A2 -Pi "path = $mysub" .gitmodules | grep -Pio '(?<=url =).*/[^.]+')
  mydir=$(dirname $mysub)
  wget $myurl/archive/$mysha.zip
  unzip $mysha.zip -d $mydir
  test -d $mysub && rm -rf $mysub
  mv $mydir/*-$mysha $mysub
  rm $mysha.zip
done
git submodule init

git submodule deinit --all -f limpa a árvore do submódulo que permite que o script seja reutilizável.

git submodulerecupera o 40 char sha1 seguido por um caminho que corresponde ao mesmo em .gitmodules. Eu uso o perl para concatenar essas informações, delimitadas por dois pontos, e depois emprego a transformação de variáveis ​​para separar os valores em myshae mysub.

Essas são as chaves críticas porque precisamos do sha1 para baixar e do caminho para correlacionar os urlmódulos .git.

Dada uma entrada típica do sub-módulo:

[submodule "label"]
    path = localpath
    url = https://github.com/repository.git

myurlas teclas path =então parecem 2 linhas depois para obter o valor. Este método pode não funcionar de forma consistente e requer refinamento. O URL grep retira todas as .gitreferências de tipo restantes , correspondendo à última /e qualquer coisa até a ..

mydiré mysubmenos uma final /nameque seria pelo diretório que levava ao nome do submódulo.

A seguir está um wgetcom o formato de url de arquivo zip para download. Isso pode mudar no futuro.

Descompacte o arquivo no mydirqual seria o subdiretório especificado no caminho do sub-módulo. A pasta resultante será o último elemento do url- sha1.

Verifique se o subdiretório especificado no caminho do submódulo existe e remova-o para permitir renomear a pasta extraída.

mv renomeie a pasta extraída que contém nosso sha1 para o caminho correto do sub-módulo.

Exclua o arquivo zip baixado.

Init do submódulo

Isso é mais uma prova de conceito do WIP do que uma solução. Quando funciona, o resultado é um clone superficial de um submódulo em um conjunto de alterações especificado.

Se o repositório voltar a hospedar um submódulo em uma confirmação diferente, execute novamente o script para atualizar.

A única vez que um script como esse seria útil é para a construção local não colaborativa de um projeto de origem.