dgit - Online nel cloud

PROGRAMMA:

NOME

dgit - integrazione git con l'archivio Debian

SINOSSI

DGIT [dgit-opt] clonare [dgit-opt] pacchetto [suite] [./dir|/dir]
DGIT [dgit-opt] andare a prendere|tirare [dgit-opt] [suite]
DGIT [dgit-opt] costruire|costruire|sorgente di compilazione [opzioni di costruzione]
DGIT [dgit-opt] spingere [dgit-opt] [suite]
DGIT [dgit-opt] rrush build-host:build-dir [spingere argomenti...]
DGIT [dgit-opt] azione ...

DESCRIZIONE

DGIT ti permette di trattare l'archivio Debian come se fosse un repository git. Vedere DGIT(7)
per informazioni dettagliate sul modello di dati, problemi comuni che potrebbero sorgere con
alcuni tipi di pacco, ecc.

Il normale flusso di lavoro è:
1. DGIT clonare or andare a prendere;
2. effettuare, eseguire test di sviluppo e confermare le modifiche in git come desiderato;
3. crea pacchetti da caricare, usando ad es DGIT costruire
4. eseguire test pre-caricamento del caricamento proposto;
5. DGIT spingere.

OPERAZIONI

DGIT clonare pacchetto [suite] [./dir|/dir]
Consulta l'archivio e dgit-repos per costruire la vista git della cronologia per
pacchetto in suite (sid per impostazione predefinita) in una nuova directory (denominata ./pacchetto per impostazione predefinita);
inoltre, scarica tutti gli archivi tar originali necessari.

La mancia git della suite viene lasciata alla filiale locale cifra/suite pronto per il lavoro, e via
il ramo di tracciamento remoto della cifra corrispondente. Il origine telecomando sarà impostato su
puntare all'albero dgit-repos del pacchetto per la distribuzione a cui suite appartiene.

Per tua comodità, il vcs-git remote verrà configurato dal pacchetto Vcs-Git
campo, se ce n'è uno - ma nota che nel caso generale la storia trovata lì
può essere diverso o addirittura disgiunto dal punto di vista di dgit.

DGIT andare a prendere [suite]
Consulta l'archivio e git-repos per aggiornare la vista git della cronologia per uno specifico
suite (e scarica tutti i tarball di origine necessari) e aggiorna il monitoraggio remoto
ramo telecomandi/dgit/dgit/suite. Se il ramo corrente è cifra/suite quindi digit
recupera le impostazioni predefinite su suite; altrimenti analizza debian/changelog e usa la suite
lì specificato.

DGIT tirare [suite]
Dgit recupera e quindi unisce la nuova testa del ramo di monitoraggio remoto
telecomandi/dgit/dgit/suite nel ramo attuale.

DGIT costruire ...
Esegue dpkg-buildpackage con alcune opzioni adatte. Opzioni e argomenti dopo
build verrà passato a dpkg-buildpackage. Non è necessario utilizzare dgit
costruire quando si usa dgit; va bene utilizzare qualsiasi approccio che garantisca che il
il pacchetto sorgente generato corrisponde al relativo commit git.

La codifica, la firma e il caricamento effettivo dovrebbero essere lasciati a dgit push.

DGIT sorgente di compilazione ...
Crea il pacchetto sorgente e un file di modifiche per un potenziale caricamento solo sorgente,
utilizzando dpkg-source. L'uscita viene lasciata in versione_pacchetto.dsc ed
versione_pacchetto_sorgente.modifiche.

La codifica, la firma e il caricamento effettivo dovrebbero essere lasciati a dgit push.

DGIT cavedano
Pulisce l'albero di lavoro corrente (secondo l'opzione --clean= in vigore).

DGIT Aiuto
Stampa un riepilogo dell'utilizzo.

DGIT costruire ...
Costruisce il pacchetto sorgente, usa costruire per fare una build binaria, e usa
mergechanges per unire i file di modifiche di origine e binari. Opzioni e argomenti
dopo sbuild sarà passato a sbuild. Cambia la corrispondenza dei file
versione_pacchetto_*.i cambiamenti nella directory padre verrà rimosso; l'uscita è
lasciato dentro versione_pacchetto_multi.cambiamenti.

La codifica, la firma e il caricamento effettivo dovrebbero essere lasciati a dgit push.

DGIT gbp-build ...
Esegue pacchetto git-build con alcune opzioni adatte. Opzioni e argomenti dopo gbp-
build verrà passato a git-buildpackage.

La codifica, la firma e il caricamento effettivo dovrebbero essere lasciati a dgit push.

DGIT spingere [suite]
Esegue un "caricamento", spingendo l'HEAD corrente nell'archivio (come pacchetto sorgente) e
a dgit-repos (come git commit). Il pacchetto deve essere già stato creato pronto per
upload, con .dsc e .changes rimasti nella directory principale. È normalmente
meglio fare la compilazione anche con dgit (ad esempio con dgit sbuild): alcuni strumenti di compilazione esistenti
passa opzioni inutili a dpkg-source e altri per impostazione predefinita, il che può comportare il
il pacchetto sorgente compilato non è identico all'albero git.

Più in dettaglio: dgit push verifica che l'HEAD corrente corrisponda al .dsc. Esso
quindi spinge l'HEAD nel ramo dgit-repos della suite, crea un tag git firmato,
modifica il .dsc per contenere il campo dei metadati dgit, esegue debsign per firmare il caricamento
(.dsc e .changes), spinge il tag firmato e infine usa dput per caricare il
.modifiche all'archivio.

dgit push usa sempre il pacchetto, la suite e la versione specificati nel
debian/changelog e .dsc, che devono essere d'accordo. Se la riga di comando specifica a
suite allora anche quella deve corrispondere.

Se dgit push fallisce durante il caricamento, va bene semplicemente riprovare il dput sul
.changes a tuo piacimento.

DGIT rrush build-host:build-dir [spingere argomenti...]
Inserisce il contenuto della directory specificata su una macchina remota. Questo è come
eseguire dgit push su build-host con build-dir come directory corrente; però,
le operazioni di firma vengono eseguite sull'host chiamante. Questo ti permette di fare una spinta
quando il sistema che ha il codice sorgente e gli output della build non ha accesso a
il tasto:

1. Clona su host di compilazione (clone dgit)
2. Modifica il codice sull'host di build (modifica, git commit)
3. Compila il pacchetto sull'host di compilazione (dgit build)
4. Pacchetto di prova sull'host di compilazione o altrove (dpkg -i, test)
5. Carica invocando dgit rpush sull'host con la tua chiave GPG.

Tuttavia, l'host di build deve essere in grado di eseguire ssh sui repository dgit. Se questo non è
già il caso, devi organizzarlo separatamente, ad esempio usando ssh
inoltro dell'agente.

Gli argomenti rimanenti vengono trattati proprio come li gestirebbe dgit push.

build-host e build-dir possono essere passati come argomenti separati; si presume che questo sia
il caso se il primo argomento non contiene: (tranne forse uno in [ ], per supportare
Indirizzo IPv6 letterale).

Avrai bisogno di versioni abbastanza simili di dgit sull'host di build e sull'invocazione
ospite. L'host di build ha bisogno dell'installazione di gnupg, con la tua chiave pubblica nel suo portachiavi
(ma non la tua chiave privata, ovviamente).

DGIT setup-nuovo-albero
Configura l'albero di lavoro corrente nel modo in cui dgit clone lo avrebbe impostato.
come correre DGIT setup-usermail ed setup-mergechangelogs (ma solo ciascuno
cosa se dgit è configurato per farlo automaticamente). Puoi usarli in qualsiasi git
repository, non solo quelli usati con le altre operazioni dgit.

DGIT setup-usermail
Imposta user.name e user.email dell'albero di lavoro dal dgit specifico della distribuzione
configurazione (Digit-distro.distro.nome utente ed .e-mail utente), o DEBFULLNAME o
DEBEMAIL.

DGIT setup-mergechangelogs
Configura un helper git merge per il file debian/log delle modifiche quale usa dpkg-
unisci i log delle modifiche.

DGIT correzione della trapunta
I pacchetti sorgente in formato "3.0 (quilt)" necessitano di modifiche che rappresentino non solo in-tree ma
anche come patch in debian/patch. dgit quilt-fixup controlla se questo è stato
fatto; in caso contrario, dgit creerà le patch appropriate in debian/patch e commit
le modifiche risultanti in git.

Normalmente questo viene fatto automaticamente da dgit build e dgit push.

dgit proverà a trasformare ogni commit rilevante nella tua cronologia git in una nuova trapunta
toppa. dgit non può convertire unioni non banali o certi altri tipi di altro
storia esotica. Se dgit non riesce a trovare una linearizzazione adeguata della tua cronologia, da
di default fallirà, ma puoi chiedergli di generare una singola patch schiacciata
anziché.

DGIT versione
Stampa le informazioni sulla versione ed esce.

DGIT clone-dgit-repos-server destinazione
Cerca di recuperare una copia del codice sorgente per il dgit-repos-server, come in realtà
utilizzato sul server dgit git, come albero git.

VERSIONI

--funzionamento a secco | -n
Eseguire i movimenti, recuperare tutte le informazioni necessarie, ma non aggiornare effettivamente
le uscite. Per push, dgit esegue i controlli richiesti e lascia il nuovo .dsc in
un file temporaneo, ma non firma, tagga, invia o carica.

--corsa umida | -L
Passa attraverso molti altri movimenti: fai tutto ciò che non implica neanche
firmare cose o apportare modifiche sui server pubblici.

-kID chiave
Usa il ID chiave per la firma del tag e il caricamento. L'impostazione predefinita viene dalle distro
ID chiave config (vedi CONFIGURAZIONE, sotto), o in mancanza, l'uploader
linea del trailer in debian/changelog.

--nessun segno
non firma tag o caricamenti (significativo solo con push).

-ppacchetto
Specifica che dovremmo elaborare il pacchetto sorgente pacchetto piuttosto che guardare dentro
debian/control o debian/changelog. Valido solo con dgit fetch e dgit pull.

--clean=git | -wg
L'albero dei sorgenti dovrebbe essere pulito, prima di creare un pacchetto sorgente con uno dei
opzioni di compilazione, usando git cavedano -xdf. Questo cancellerà tutti i file che non lo sono
tracciato da git. Inoltre, -wg fa passare dgit -nc a dpkg-buildpackage, che
impedisce l'esecuzione della destinazione pulita del pacchetto.

--clean=git è utile quando il target clean del pacchetto è problematico; il rovescio della medaglia
è semplicemente che git clean potrebbe eliminare i file che hai dimenticato di aggiungere. --clean=git can
evita anche di aver bisogno delle dipendenze di build.

--clean=git-ff | -wgf
L'albero dei sorgenti dovrebbe essere pulito, prima di creare un pacchetto sorgente con uno dei
opzioni di compilazione, usando git cavedano -xff. È come "git clean -xdf" ma anche
rimuove qualsiasi sottodirectory contenente diversi alberi git (cosa insolita
è probabile che i pacchetti creino).

--clean=verifica | -bagno
Basta controllare che l'albero sia pulito (non contenga file non salvati), prima
creazione di un pacchetto sorgente.

--clean=nessuno | -wn
Non pulire l'albero prima di creare un pacchetto sorgente. Se ci sono file che
non sono in git, o se la build crea tali file, un successivo push dgit lo farà
fallire.

--clean=sorgente-dpkg | -wd
Usa dpkg-buildpackage per eseguire la pulizia, in modo che il pacchetto sorgente venga pulito da
dpkg-source che esegue il clean target del pacchetto. Questa è l'impostazione predefinita. Richiede
le dipendenze di compilazione del pacchetto.

--clean=dpkg-source-d | -wdd
Usa il dpkg-buildpackage -d per eseguire la pulizia, in modo che il pacchetto sorgente venga pulito da
dpkg-source che esegue il clean target del pacchetto. Le dipendenze di build non lo sono
controllato (a causa di -d), che viola la politica, ma potrebbe funzionare nella pratica.

-N | --nuovo
Il pacchetto è o potrebbe essere nuovo in questa suite. Senza questo, dgit si rifiuterà di
spingere. Potrebbe (per Debian, will) non essere in grado di accedere alla cronologia di git per nessuno
pacchetti che sono stati appena spinti e non sono ancora stati pubblicati.

--ignora-sporco
Non lamentarti se l'albero di lavoro non corrisponde al tuo git HEAD. Questo può essere
utile con build, se prevedi di impegnarti in un secondo momento. (dgit push garantirà comunque che
il .dsc che carichi e l'albero git che spingi sono identici, quindi questa opzione non lo farà
fare spinte spezzate.)

--deliberatamente-qualcosa
Dichiara che stai facendo deliberatamente qualcosa. Questo può essere usato per sovrascrivere
le catture di sicurezza, comprese le catture di sicurezza che si riferiscono a politiche specifiche della distribuzione.
I significati di qualcosas intesi nel contesto di Debian sono discussi di seguito:

--deliberatamente-non-avanti-velocemente
Dichiara che stai deliberatamente riavvolgendo la storia. Quando si esegue il push su Debian, utilizzare
questo quando si effettua un caricamento rinnovato di un pacchetto sorgente completamente nuovo il cui
la versione precedente non è stata accettata per il rilascio da NEW a causa di problemi con
diritto d'autore o ridistribuzione.

--includere-deliberatamente-storia-discutibile
Dichiara di aver deliberatamente incluso, nella cronologia git del tuo attuale
push, cronologia che contiene una versione inviata in precedenza di questo pacchetto che
non è stato approvato (o non è stato ancora approvato) da ftpmasters. Quando si spinge a
Debian, usa questa opzione solo dopo aver verificato che: nessuno dei respinti-da-NEW
(o mai accettate) versioni nella cronologia git del tuo push attuale, sono state respinte
da ftpmaster per motivi di copyright o ridistribuzione.

--deliberatamente-fresh-repo
Dichiara che stai deliberatamente riavvolgendo la storia e vuoi buttare via il
repo esistente. Non rilevante quando si esegue il push a Debian, come farà il server Debian
questo automaticamente quando necessario.

--quilt=lineare
Quando si correggono i metadati del formato di origine `3.0 (quilt)', insistere sulla generazione di un lineare
pila di patch. Se tale stack non può essere generato, fallisce. Questa è l'impostazione predefinita per
Debian.

--quilt=automatico
Quando si correggono i metadati del formato di origine `3.0 (quilt)', si preferisce generare un'immagine lineare
stack di patch, ma se ciò non sembra possibile, genera una singola patch schiacciata
per tutte le modifiche apportate in git. Questa non è una buona idea per un NMU in Debian.

--quilt=distruggi
Quando si correggono i metadati del formato di origine `3.0 (quilt)', generare un singolo schiacciato
patch per tutte le modifiche apportate in git. Questa non è una buona idea per un NMU in
Debian.

--quilt=nessuna correzione
Verificare se i metadati del formato di origine "3.0 (quilt)" necessitano di una correzione, ma, in tal caso
fa, fallisce. È quindi necessario correggere i metadati in qualche modo prima di eseguire il push. (NB
che dpkg-source --commit non funzionerà perché l'albero dgit git non ha a
.PC rubrica.)

--quilt=nessun controllo | --nessuna correzione della trapunta
Non controllare se i metadati del formato di origine `3.0 (quilt)' devono essere corretti. Se
usi questa opzione e i metadati hanno effettivamente bisogno di essere aggiustati, dgit push lo farà
fallire.

-D Stampa le informazioni di debug su stderr. La ripetizione dell'opzione produce più output
(attualmente, fino a -DDDD è significativamente diverso).

-cNome=APPREZZIAMO
Specifica un'opzione di configurazione git, da utilizzare per questa esecuzione. dgit stesso è anche
controllato dalle opzioni di configurazione di git.

-vversione|_ | --da-versione=versione|_
Specifica il -vversione opzione da passare a dpkg-genchanges, durante le build. I cambiamenti
(da debian/changelog) poiché questa versione sarà inclusa nelle modifiche compilate
file, e quindi nel caricamento. Se questa opzione non è specificata, dgit interrogherà
l'archivio e utilizzare l'ultima versione caricata nella suite prevista.

specificando _ lo inibisce, in modo che nessuna opzione -v venga passata a dpkg-genchanges
(e di conseguenza, solo l'ultima strofa di debian/changelog sarà usata per
costruire e caricare).

-mindirizzo manutentore
Passato a dpkg-genchanges (alla fine).

--ch:opzione
Specifica una singola opzione aggiuntiva da passare, eventualmente, a dpkg-genchanges.

--ricciolo=Programma | --dput=Programma | ...
Specifica programmi alternativi da usare al posto di arricciare, dput, design, dpkg-source,
dpkg-buildpackage, dpkg-genchanges, costruire, gpg, SSH, DGIT, git, o unisci modifiche.

Per dpkg-buildpackage, dpkg-genchanges, mergechanges e sbuild, questo vale solo
quando il programma viene invocato direttamente da dgit.

Per dgit, specifica il comando da eseguire sull'host remoto quando è necessario dgit rpush
invocare una copia remota di se stesso. (dgit si rinnova anche come EDITOR per
dpkg-source --commit; questo viene fatto usando argv[0] e non è influenzato da --dgit=).

Per ssh, il valore predefinito è preso da DGIT_SSH or GIT_SSH ambiente
variabili, se impostate (vedi sotto). E, per ssh, quando si accede all'archivio e digit-
repository, questa impostazione della riga di comando viene sovrascritta dalle variabili git config cifra-
distro.distro.ssh ed .dgit.default.ssh (che a sua volta può essere sovrascritto con -c).
Inoltre, quando dgit utilizza git per accedere a dgit-repos, solo l'idea di git di cosa ssh deve
utilizzare (ad es. GIT_SSH) è pertinente.

--arricciare:opzione | --dput:opzione | ...
Specifica una singola opzione aggiuntiva a cui passare arricciare, dput, design, dpkg-source,
dpkg-buildpackage, dpkg-genchanges, costruire, SSH, DGIT, o unisci modifiche. Può essere
ripetuto se necessario.

Per dpkg-buildpackage, dpkg-genchanges, mergechanges e sbuild, questo vale solo
quando il programma viene invocato direttamente da dgit. Di solito, per passare opzioni a
dpkg-genchanges, dovresti usare --ch:opzione.

Specificare --git non è efficace per alcune operazioni git di sola lettura di livello inferiore
eseguita da dgit, e anche non quando git viene invocato da un altro programma eseguito da dgit.

Vedi le note sopra relative a ssh e dgit.

NB che --gpg:option non è supportato (perché debsign non lo ha
servizio, struttura). ma vedi -k e la ID chiave impostazione di configurazione della distribuzione.

-ddistro | --distro=distro
Specifica che la suite su cui operare fa parte di distro distro. Questo
sovrascrive il valore predefinito trovato dall'opzione git config cifra-
on.suite.distro. L'unico effetto è che altre variabili di configurazione (usate
per l'accesso all'archivio e dgit-repos) utilizzati sono Digit-distro.distro.*.

Se la tua suite fa parte di una distribuzione che dgit già conosce, puoi usare questo
opzione per far funzionare dgit anche se il tuo dgit non conosce la suite. Per
esempio, specificando -ddebian funzionerà quando la suite è una suite sconosciuta nel
Archivio Debian.

Per definire una nuova distribuzione è necessario definire metodi e URL per il recupero
(e, per dgit push, alterando) una varietà di informazioni sia nell'archivio che in
dgit-repos. Come impostare questo non è ancora documentato.

-Cfile modifiche
Specifica il file .changes che deve essere caricato. Per impostazione predefinita, dgit push guarda
per un singolo file .changes nella directory padre il cui nome file suggerisce che sia per
il pacchetto e la versione corretti - o, se c'è un file _multi.changes, dgit usa
quella.

Se il specificato file modifiche il nome del percorso contiene barre, anche la parte della directory è
usato come valore per --build-prodotti-dir; in caso contrario, è previsto il file delle modifiche
in quella directory (per impostazione predefinita, in ..).

--build-prodotti-dir=elenco
Specifica dove trovare i file compilati da caricare. Per impostazione predefinita, dgit guarda dentro
la directory principale (..).

--pacchetto-esistente=pacchetto
dgit push deve rendere canonico il nome della suite. A volte, dgit non ha modo di chiedere
l'archivio per farlo senza conoscere il nome di un pacchetto esistente. Privo di
--new possiamo semplicemente usare il pacchetto che stiamo cercando di inviare. Ma con --nuovo che sarà
non funziona, quindi indoviniamo dpkg oppure utilizzare il valore di questa opzione. Questa opzione non lo è
necessario con i meccanismi predefiniti per l'accesso all'archivio.

-h|--Aiuto
Stampa un riepilogo dell'utilizzo.

--initiator-tempdir=elenco
dgit rpush usa una directory temporanea sull'host che invoca (firma). Questa opzione
causa l'uso di dgit elenco Invece. Inoltre, la directory specificata sarà
svuotato, rimosso e ricreato prima dell'avvio di dgit, piuttosto che rimosso dopo dgit
finiture. La directory specificata deve essere un percorso assoluto.

--no-rm-in-errore
Non eliminare la directory di destinazione se il clone fallisce.

FLUSSO DI LAVORO - SEMPLICE

È sempre possibile con dgit clonare o recuperare un pacchetto, apportare modifiche in git (usando
git-commit) sul ramo della suite (git cassa cifra/suite) e poi digit push. Puoi usare
qualunque tecnica gitish ti piaccia per costruire i commit da spingere; l'unico requisito
è che quello che spingi è un discendente dello stato dell'archivio, come fornito da dgit in
il ramo del monitoraggio a distanza telecomandi/dgit/dgit/suite.

Se stai usando dgit per fare un NMU (in Debian) e non conosci i manutentori
flussi di lavoro di imballaggio preferiti, dovresti apportare le modifiche come una serie lineare di
(logicamente separato) esegue il commit in cima a ciò che è già nell'archivio.

Se sei fortunato anche gli altri uploader hanno usato dgit e integrato l'altro rilevante
git storia; in caso contrario, puoi prenderlo nel tuo albero e raccogliere le ciliegie ecc. Come desideri.

FLUSSO DI LAVORO - INTEGRAZIONE TRA DGIT E ALTRO GIT STORIA

Se sei il manutentore di un pacchetto che si occupa di caricamenti effettuati senza dgit, lo farai
probabilmente vuoi unire i commit sintetici (fatti da dgit per rappresentare i caricamenti) in
la tua storia git. Normalmente puoi semplicemente unire il ramo dgit nel tuo master, oppure
infatti se fai il tuo lavoro sul ramo dgit local suite cifra/suite puoi semplicemente usare dgit
Tirare.

Tuttavia la prima volta che dgit viene utilizzato genererà un nuovo commit di origine dall'archivio
che non sarà collegato al resto della tua cronologia git. Dovrai unire questo.

Se l'ultimo caricamento è stato effettivamente effettuato con git, di solito dovresti procedere come segue: identifica
il commit che è stato effettivamente utilizzato per compilare il pacchetto. (Spero che tu abbia un tag per
questo.) Controlla il ramo dgit (git cassa cifra/suite) e unisci quell'altro commit
(git unire Debian/versione). Speriamo che questa fusione sia banale perché i due alberi
dovrebbe essere molto simile. La testa del ramo risultante può essere unita al tuo lavoro
rami (git cassa Mastercard && git unire cifra/suite).

Se l'ultimo caricamento non è stato effettuato con git, è necessario un approccio diverso per iniziare a utilizzare
cifra. Per prima cosa, fai DGIT andare a prendere (o clone) per ottenere una rappresentazione della cronologia git di cosa c'è dentro
l'archivio e registrarlo nel telecomandi/dgit/dgit/suite ramo di inseguimento. Poi in qualche modo,
usando la tua altra cronologia git più le differenze appropriate e le scelte di ciliegia dal telecomando dgit
tracking branch, costruisci un git commit il cui albero corrisponda all'albero da usare per il
prossimo caricamento. Se quel commit-to-be-uploaded non è un discendente del dgit remote
filiale di monitoraggio, controlla e dì git unire -s orso telecomandi/dgit/dgit/suite; Che
dice a git che stiamo deliberatamente buttando via qualsiasi differenza tra ciò che è nel
archivio e cosa intendi caricare. Allora corri DGIT spingere per caricare effettivamente il risultato.

CONFIGURAZIONE

dgit può essere configurato tramite il sistema git config. Puoi impostare le chiavi con git-config
(in configurazione globale di sistema o per albero), o fornire -cchiave=APPREZZIAMO sulla cifra
riga di comando.

Le impostazioni che potrebbero essere utili per un utente finale includono:

suite digitale.suite.distro distro
Specifica la distribuzione per una suite. digiti il ​​nome della suite (che appare in
log delle modifiche ecc.) e lo usa per determinare la distribuzione coinvolta. Il
config utilizzato è successivamente quello per la distro.

digit.default.distro distro
La distribuzione predefinita per una suite sconosciuta.

digit.default.*
per ciascuno Digit-distro.distro.*, il valore predefinito utilizzato se non è presente alcuna distribuzione
impostazione specifica.

Digit-distro.distro.modalità pulita
Uno dei valori per la riga di comando --clean= opzione; usato se --clean non lo è
specificato.

Digit-distro.distro.sola lettura auto|a | vero|t|y|1 | falso|f|n|0
Se hai accesso push alla distribuzione. Per Debian va bene usare auto,
che utilizza la modalità di sola lettura se non stai spingendo in questo momento; ma, impostandolo su
false eviterà di fare affidamento sul mirror del server del repository dgit git.

Digit-distro.distro.id chiave
Vedi anche -k.

Digit-distro.distro.specchio URL

Digit-distro.distro.nome utente
Non rilevante per Debian.

Digit-distro.distro.host di caricamento
Potrebbe essere utile se si dispone di un server di coda intermedio.

Digit-distro.distro.nome utente Digit-distro.distro.e-mail utente
Valori da configurare per user.name e user.email nei nuovi alberi git. Altrimenti
specificato, vengono utilizzate le variabili di ambiente DEBFULLNAME e DEBEMAIL,
rispettivamente. Utilizzato solo se .setup-usermail non è disabilitato.

Digit-distro.distro.setup-usermail
Se impostare user.name e user.email nei nuovi alberi git. Vero per impostazione predefinita.
Ignorato per dgit setup-setup-usermail, che lo fa comunque.

Digit-distro.distro.setup-mergechangelogs
Se configurare un driver di unione che utilizza dpkg-mergechangelogs per
debian/changelog. Vero per impostazione predefinita. Ignorato per dgit setup-mergechangelogs, che
lo fa comunque.

Digit-distro.distro.cmd-cmd
Programma da usare al posto di cmd. Funziona come --cmd=... .

Digit-distro.distro.opt-cmd
Opzioni extra a cui passare cmd. Funziona come --cmd:... . Per passare diverse opzioni,
configura più valori in git config (con git config --add). Le opzioni per
digit.default.opts-cmd Digit-distro.distro/premere.opzioni-cmd e sono tutti usati, seguiti
per opzioni dalla riga di comando di dgit.

ACCESSO CONFIGURAZIONE

Ci sono molte altre impostazioni che specificano come i servizi di una particolare distribuzione (archivio
e git) sono forniti. Questi non dovrebbero normalmente essere regolati, ma sono documentati per il
beneficio delle distro che desiderano adottare dgit.

Digit-distro.distro/spingere.*
Se impostato, esclude il corrispondente non / push config quando readonly=falsoo quando
spingendo e sola lettura=auto.

Digit-distro.distro.git-url

Digit-distro.distro.git-url[-suffisso]

Digit-distro.distro.git-proto

Digit-distro.distro.git-percorso

Digit-distro.distro.git-check vero|falso|URL|ssh-cmd

Digit-distro.distro.git-check-suffisso

Digit-distro.distro.devia.devia nuova-distro|/distro-suffisso

Digit-distro.distro.git-creare ssh-cmd|vero

Digit-distro.distro.query-archivio ftpmasterapi: | Madison:distro | finto gatto:/il percorso |
sshpsql:Utente@host:nomedb

Digit-distro.distro.query-archivio-(URL|tasto tls|curl-ca-args)

Digit-distro.distro.madison-distro

Digit-distro.distro.archivio-query-componente-predefinito

Digit-distro.distro.ssh

Digit-distro.distro.sshpsql-nomedb

Digit-distro.distro.(git|sshpsql)-(Utente|host|forza-utente)

Digit-distro.distro.backport-stranezza

AMBIENTE VARIABILI

DGIT_SSH, GIT_SSH
specificare un programma predefinito alternativo (e forse argomenti) da usare al posto di
ssh. DGIT_SSH viene consultato per primo e può contenere argomenti; se ne contiene
gli spazi bianchi verranno passati alla shell. GIT_SSH specifica solo il programma; no
gli argomenti possono essere specificati, quindi dgit lo interpreta allo stesso modo di git. Vedere
anche le opzioni --ssh= e --ssh:.

DEBEMAIL, DEBNOME COMPLETO
git user.email e user.name predefiniti per i nuovi alberi. Vedere DGIT setup-nuovo-albero.

gpg, dpkg-..., design, git, arricciare, dput, LWP::UserAgent
e altri sottoprogrammi e moduli utilizzati da dgit sono influenzati da vari ambienti
variabili. Consultare la documentazione per quei programmi per i dettagli.

Usa dgit online utilizzando i servizi onworks.net