1dgit(1)                              dgit                              dgit(1)
2
3
4

NAME

6       dgit - git integration with the Debian archive
7

SYNOPSIS

9       dgit [dgit-opts] clone [dgit-opts] package [suite] [./dir|/dir]
10       dgit [dgit-opts] fetch|pull [dgit-opts] [suite]
11       dgit [dgit-opts] build|sbuild|build-source [build-opts]
12       dgit [dgit-opts] pbuilder|cowbuilder [debbuildopts]
13       dgit [dgit-opts] push|push-source [dgit-opts] [suite]
14       dgit [dgit-opts] rpush build-host:build-dir [push args...]
15       dgit [dgit-opts] action ...
16

DESCRIPTION

18       dgit allows you to treat the Debian archive as if it were a git reposi‐
19       tory.  Conversely, it allows Debian to publish the source of its  pack‐
20       ages as git branches, in a format which is directly useable by ordinary
21       people.
22
23       This is the command line reference.  Please read the tutorial(s):
24
25       dgit-user(7)              for users: edit, build and share packages
26       dgit-nmu-simple(7)        for DDs: do a straightforward NMU
27       dgit-maint-native(7)      for maintainers of Debian-native packages
28       dgit-maint-debrebase(7)   for maintainers: a pure-git rebasish workflow
29       dgit-maint-merge(7)       for maintainers: a pure-git merging workflow
30       dgit-maint-gbp(7)         for maintainers already using git-buildpackage
31       dgit-sponsorship(7)       for sponsors and sponsored contributors
32       dgit-downstream-dsc(7)    setting up dgit push for a new distro
33
34       See dgit(7) for detailed information about the data model, common prob‐
35       lems likely to arise with certain kinds of package, etc.
36

OPERATIONS

38       dgit clone package [suite] [./dir|/dir]
39              Consults the archive and dgit-repos to construct the git view of
40              history for package in suite (sid by default) in a new directory
41              (named ./package by default); also, downloads any necessary orig
42              tarballs.
43
44              The suite's git tip is left on the local branch dgit/suite ready
45              for  work, and on the corresponding dgit remote tracking branch.
46              The origin remote will be set up to point to the package's dgit-
47              repos tree for the distro to which suite belongs.
48
49              suite  may  be a combination of several underlying suites in the
50              form mainsuite,subsuite...; see COMBINED SUITES in dgit(7).
51
52              For your convenience, the vcs-git remote will be set up from the
53              package's  Vcs-Git field, if there is one - but note that in the
54              general case the history found there may be different to or even
55              disjoint from dgit's view.  (See also dgit update-vcs-git.)
56
57       dgit fetch [suite]
58              Consults  the  archive  and  git-repos to update the git view of
59              history for a specific suite (and downloads any  necessary  orig
60              tarballs),    and    updates    the   remote   tracking   branch
61              remotes/dgit/dgit/suite.  If the current  branch  is  dgit/suite
62              then   dgit   fetch  defaults  to  suite;  otherwise  it  parses
63              debian/changelog and uses the suite specified there.  suite  may
64              be a combined suite, as for clone.
65
66       dgit pull [suite]
67              Does  dgit  fetch,  and  then  merges the new head of the remote
68              tracking branch remotes/dgit/dgit/suite into the current branch.
69
70       dgit checkout suite
71              Checks out the local branch dgit/suite.
72
73              If the branch does not exist, dgit checkout creates it, and sets
74              it  up  the  same way as dgit clone would.  In that case, if the
75              archive remote tracking branch does  not  exist,  dgit  checkout
76              will do a dgit fetch first.
77
78              NB:  dgit  checkout  will  only do a fetch if it has to.  If you
79              already have the suite branch, and want  to  merge  your  branch
80              with updates from the archive, use dgit pull.
81
82              dgit  checkout  will normally need to access the archive server,
83              to canonicalise the provided suite name.  The  exception  is  if
84              you  specify  the  canonical  name,  and the branch (or tracking
85              branch) already exists.
86
87       dgit build ...
88              Runs dpkg-buildpackage with some suitable options.  Options  and
89              arguments  after  build  will be passed on to dpkg-buildpackage.
90              It is not necessary to use dgit build when using dgit; it is  OK
91              to  use  any  approach  which  ensures that the generated source
92              package corresponds to the relevant git commit.
93
94              Tagging, signing and actually uploading should be left  to  dgit
95              push.
96
97              dgit's build operations access the network, to get the -v option
98              right.  See -v, below.
99
100       dgit build-source ...
101              Builds the source package, and a changes file for a  prospective
102              source-only  upload,  using  dpkg-source.  The output is left in
103              package_version.dsc and package_version_source.changes.
104
105              Tagging, signing and actually uploading should be left  to  dgit
106              push-source, or dgit push.
107
108       dgit clean
109              Cleans  the  current  working  tree  (according  to the --clean=
110              option in force).
111
112       dgit update-vcs-git [suite|.] [--] [git fetch options]
113       dgit update-vcs-git [suite|.] -
114              Sets up, or updates the url of, the vcs-git remote, and  (unless
115              - was specified) runs git fetch on it.
116
117              By  default,  the  Vcs-Git  field of the .dsc from Debian sid is
118              used, as that is probably most up to date.  Another suite may be
119              specified,  or  .   to  indicate  that  the Vcs-Git of the cwd's
120              debian/control should be used instead.
121
122       dgit help
123              Print a usage summary.
124
125       dgit sbuild ...
126              Constructs the source package, uses sbuild to do a binary build,
127              and  uses  mergechanges  to  merge the source and binary changes
128              files.  Options and arguments after sbuild will be passed on  to
129              sbuild.  The output is left in package_version_multi.changes.
130
131              Note  that  by  default  sbuild  does not build arch-independent
132              packages.  You probably want to pass -A, to request those.
133
134              Tagging, signing and actually uploading should be left  to  dgit
135              push.
136
137       dgit pbuilder [debbuildopts]
138              Constructs  the  source  package,  uses  pbuilder to do a binary
139              build, and uses mergechanges to  merge  the  source  and  binary
140              changes   files.    The   output   is   left   in   package_ver‐
141              sion_multi.changes.
142
143              You should ensure that your  dgit  --build-products-dir  setting
144              matches your pbuilder --buildresult.
145
146              The debbuildopts are passed to pbuilder using its --debbuildopts
147              option.  If you want to pass other options to pbuilder, use  the
148              --pbuilder:  dgit  option as described below (remember that dgit
149              options should appear between dgit and pbuilder).
150
151              You should ensure that in your pbuilderrc you do  not  have  the
152              setting SOURCE_ONLY_CHANGES=yes as this may cause trouble.
153
154       dgit cowbuilder [debbuildopts]
155              Like dgit pbuilder, but uses cowbuilder instead of pbuilder.
156
157       dgit gbp-build ...
158              Runs  git-buildpackage  with some suitable options.  Options and
159              arguments after gbp-build will be passed on to git-buildpackage.
160
161              By default this uses --quilt=gbp, so HEAD should be a git-build‐
162              package style branch, not a patches-applied branch.
163
164              Tagging,  signing  and actually uploading should be left to dgit
165              push.
166
167       dgit push [suite]
168              Does an `upload', pushing the current HEAD to the archive (as  a
169              source package) and to dgit-repos (as git commits).  The package
170              must already have been built ready for upload, with the .dsc and
171              .changes  left  in the parent directory.  It is normally best to
172              do the build with dgit too (eg with dgit sbuild): some  existing
173              build  tools  pass  unhelpful  options  to  dpkg-source et al by
174              default, which can result in the built source package not  being
175              identical to the git tree.
176
177              In  more  detail:  dgit push checks that the current HEAD corre‐
178              sponds to the .dsc.  It then pushes  the  HEAD  to  the  suite's
179              dgit-repos  branch,  adjusts  the .changes to include any .origs
180              which the archive lacks and exclude .origs which the archive has
181              (so  -sa  and  -sd  are not needed when building for dgit push),
182              makes a signed git tag, edits the .dsc to contain the dgit meta‐
183              data field, runs debsign to sign the upload (.dsc and .changes),
184              pushes the signed tag, and  finally  uses  dput  to  upload  the
185              .changes to the archive.
186
187              dgit  push  always uses the package, suite and version specified
188              in the debian/changelog and the .dsc, which must agree.  If  the
189              command line specifies a suite then that must match too.
190
191              When used on a git-debrebase branch, dgit calls git-debrebase to
192              prepare the branch for source package upload and push.
193
194       dgit push-source [suite]
195              Without -C, builds a source package and dgit pushes it.   Saying
196              dgit  push-source  is like saying "update the source code in the
197              archive to match my git HEAD, and let the  autobuilders  do  the
198              rest."
199
200              With  -C,  performs  a  dgit push, additionally ensuring that no
201              binary packages are uploaded.
202
203       dgit rpush build-host:build-dir [push args...]
204              Pushes the contents of  the  specified  directory  on  a  remote
205              machine.   This  is  like  running  dgit push on build-host with
206              build-dir as the current directory; however, signing  operations
207              are  done  on  the  invoking host.  This allows you to do a push
208              when the system which has the source code and the build  outputs
209              has no access to the key:
210
211
212              1.   Clone on build host (dgit clone)
213              2.   Edit code on build host (edit, git commit)
214              3.   Build package on build host (dgit build)
215              4.   Test package on build host or elsewhere (dpkg -i, test)
216              5.   Upload by invoking dgit rpush on host with your GPG key.
217
218              However,  the  build-host must be able to ssh to the dgit repos.
219              If this is not already the case,  you  must  organise  it  sepa‐
220              rately, for example by the use of ssh agent forwarding.
221
222              The remaining arguments are treated just as dgit push would han‐
223              dle them.
224
225              build-host and build-dir can be passed  as  separate  arguments;
226              this is assumed to be the case if the first argument contains no
227              : (except perhaps one in [ ], to support IPv6 address literals).
228
229              You will need similar enough versions of dgit on the  build-host
230              and  the invocation host.  The build-host needs gnupg installed,
231              with your public key in its keyring (but not your  private  key,
232              obviously).
233
234       dgit setup-new-tree
235              Configure the current working tree the way that dgit clone would
236              have set it  up.   Like  running  dgit  setup-useremail,  setup-
237              mergechangelogs  and  setup-gitattributes  (but  only  does each
238              thing if dgit is configured to do it  automatically).   You  can
239              use  these  in  any  git repository, not just ones used with the
240              other dgit operations.  Does not  run  update-vcs-git  (as  that
241              requires Debian packaging information).
242
243       dgit setup-useremail
244              Set the working tree's user.name and user.email from the distro-
245              specific dgit  configuration  (dgit-distro.distro.user-name  and
246              .user-email), or DEBFULLNAME or DEBEMAIL.
247
248       dgit setup-mergechangelogs
249              Configures  a  git  merge  helper  for the file debian/changelog
250              which uses dpkg-mergechangelogs.
251
252       dgit setup-gitattributes
253              Set up the working tree's .git/info/attributes  to  disable  all
254              transforming attributes for all files.  This is done by defining
255              a macro attribute, dgit-defuse-attrs, and applying it to *.  For
256              why,  see  GITATTRIBUTES  in dgit(7).  Note that only attributes
257              affecting the working  tree  are  suppressed.   git-archive  may
258              remain exciting.
259
260              If  there is an existing macro attribute line [attr]dgit-defuse-
261              attrs in .git/info/attributes, but it is  insufficient,  because
262              it  was  made  by  an  earlier version of dgit and git has since
263              introduced new transforming attributes, this modifies the  macro
264              to disable the newer transformations.
265
266              (If  there  is already a macro attribute line [attr]dgit-defuse-
267              attrs in .git/info/attributes  which  does  what  dgit  requires
268              (whatever  files  it  effects), this operation does nothing fur‐
269              ther.  This fact can be used to defeat or partially defeat  dgit
270              setup-gitattributes and hence dgit setup-new-tree.)
271
272       dgit quilt-fixup
273              `3.0  (quilt)'  format source packages need changes representing
274              not only in-tree but also as patches  in  debian/patches.   dgit
275              quilt-fixup checks whether this has been done; if not, dgit will
276              make appropriate patches in debian/patches and also  commit  the
277              resulting changes to git.
278
279              This is normally done automatically by dgit build and dgit push.
280
281              dgit  will  try to turn each relevant commit in your git history
282              into a new quilt patch.  dgit cannot convert nontrivial  merges,
283              or  certain  other  kinds of more exotic history.  If dgit can't
284              find a suitable linearisation of your  history,  by  default  it
285              will  fail,  but  you  can  ask it to generate a single squashed
286              patch instead.
287
288              When used with a git-debrebase branch, dgit will ask  git-debre‐
289              base to prepare patches.  However, dgit can make patches in some
290              situations where git-debrebase fails, so dgit quilt-fixup can be
291              useful in its own right.  To always use dgit's own patch genera‐
292              tor instead of  git-debrebase  make-patches,  pass  --git-debre‐
293              base=true to dgit.
294
295              See FORMAT 3.0 (QUILT) in dgit(7).
296
297       dgit import-dsc [sub-options] ../path/to/.dsc [+|..]branch
298              Import  a  Debian-format  source package, specified by its .dsc,
299              into git, the way dgit fetch would do.
300
301              This does about half the work of dgit fetch: it will convert the
302              .dsc into a new, orphan git branch.  Since dgit has no access to
303              a corresponding source package archive or knowledge of the  his‐
304              tory it does not consider whether this version is newer than any
305              previous import or corresponding git branches; and it  therefore
306              does not make a pseudomerge to bind the import into any existing
307              git history.
308
309              Because a .dsc can contain a Dgit  field  naming  a  git  commit
310              (which  you  might  not have), and specifying where to find that
311              commit (and any history rewrite table),  import-dsc  might  need
312              online  access.  If this is a problem (or dgit's efforts to find
313              the commit fail),  consider  --no-chase-dsc-distro  or  --force-
314              import-dsc-with-dgit-field.
315
316              There is only one sub-option:
317
318              --require-valid-signature  causes dgit to insist that the signa‐
319              ture on the .dsc is valid (using  the  same  criteria  as  dpkg-
320              source  -x).   Otherwise, dgit tries to verify the signature but
321              the outcome is reported only as messages to stderr.
322
323              If branch is prefixed with + then if it already exists, it  will
324              be  simply  overwritten,  no  matter  its existing contents.  If
325              branch is prefixed with ..  then if it already exists  and  dgit
326              actually  imports  the  dsc  (rather than simply reading the git
327              commit out of the Dgit field), dgit will make a  pseudomerge  so
328              that  the  result  is necessarily fast forward from the existing
329              branch.  Otherwise, if branch already  exists,  dgit  will  stop
330              with an error message.
331
332              If branch does not start with refs/, refs/heads/ is prepended.
333
334       dgit version
335              Prints version information and exits.
336
337       dgit clone-dgit-repos-server destdir
338              Tries  to  fetch  a  copy of the source code for the dgit-repos-
339              server, as actually being used on the dgit git server, as a  git
340              tree.
341
342       dgit print-dgit-repos-server-source-url
343              Prints  the  url  used by dgit clone-dgit-repos-server.  This is
344              hopefully suitable for use as a git remote url.  It may  not  be
345              useable in a browser.
346
347       dgit print-dpkg-source-ignores
348              Prints  the  -i  and  -I arguments which must be passed to dpkg-
349              souce to cause it to exclude  exactly  the  .git  directory  and
350              nothing else.  The separate arguments are unquoted, separated by
351              spaces, and do not contain spaces.
352
353       dgit print-unapplied-treeish
354              Constructs a tree-ish approximating the patches-unapplied  state
355              of  your  3.0 (quilt) package, and prints the git object name to
356              stdout.  This requires appropriate .orig  tarballs.   This  tree
357              object  is  identical  to your .origs as regards upstream files.
358              The contents of the debian subdirectory is not  interesting  and
359              should  not  be  inspected;  except  that debian/patches will be
360              identical to your HEAD.
361
362              To make this operate  off-line,  the  access  configuration  key
363              which  is  used  to  determine  the  build-products-dir  is  the
364              uncanonicalised version of the suite name from the changelog, or
365              (of course) dgit.default.build-products-dir.  See ACCESS CONFIG‐
366              URATION, below.
367
368              This function is primarily provided  for  the  benefit  of  git-
369              debrebase.
370

OPTIONS

372       --dry-run | -n
373              Go  through the motions, fetching all information needed, but do
374              not actually update the output(s).   For  push,  dgit  does  the
375              required checks and leaves the new .dsc in a temporary file, but
376              does not sign, tag, push or upload.
377
378       --damp-run | -L
379              Go through many more of the motions: do everything that  doesn't
380              involve  either  signing things, or making changes on the public
381              servers.
382
383       -kkeyid
384              Use keyid for signing the tag and the upload.  The default comes
385              from  the  distro's  keyid  config  setting  (see CONFIGURATION,
386              below),  or  failing  that,  the  uploader   trailer   line   in
387              debian/changelog.
388
389       --no-sign
390              does not sign tags or uploads (meaningful only with push).
391
392
393       -ppackage
394              Specifies  that  we should process source package package
395              rather    than    looking    in     debian/control     or
396              debian/changelog.   Valid  with dgit fetch and dgit pull,
397              only.
398
399       --clean=git | -wg
400              Use git clean -xdf to clean the working tree, rather than
401              running the package's rules clean target.
402
403              This  will delete all files which are not tracked by git.
404              (Including any files you forgot to git add.)
405
406              --clean=...  options other than  dpkg-source  are  useful
407              when  the  package's  clean  target is troublesome, or to
408              avoid needing the build-dependencies.
409
410              dgit will only actually clean the tree  if  it  needs  to
411              (because it needs to build the source package or binaries
412              from your working tree).  Otherwise it  will  just  check
413              that   there  are  no  untracked  unignored  files.   See
414              --clean=git[-ff],always, below.
415
416       --clean=git-ff | -wgf
417              Use git clean -xdff to clean the working tree.  Like  git
418              clean  -xdf  but  it also removes any subdirectories con‐
419              taining different git trees (which only unusual  packages
420              are likely to create).
421
422       --clean=git[-ff],always | -wga | -wgfa
423              Like  --clean=git, but always does the clean and not just
424              a check, deleting any untracked un-ignored files.
425
426       --clean=check | --clean=check,ignores | -wc | -wci
427              Merely check that the tree is  clean  (does  not  contain
428              uncommitted  files).  Avoids running rules clean, and can
429              avoid needing the build-dependencies.
430
431              With ,ignores or -wci, untracked files covered by .gitig‐
432              nore  are tolerated, so only files which show up as ?  in
433              git status (ie, ones you maybe forgot  to  git  add)  are
434              treated as a problem.
435
436       --clean=none | -wn
437              Do  not  clean  the  tree,  nor  check  that it is clean.
438              Avoids running rules clean, and  can  avoid  needing  the
439              build-dependencies.   If there are files which are not in
440              git, or if the build creates  such  files,  a  subsequent
441              dgit push will fail.
442
443       --clean=dpkg-source[-d] | -wd | -wdd
444              Use dpkg-buildpackage to do the clean, so that the source
445              package is cleaned by dpkg-source running  the  package's
446              clean target.  --clean=dpkg-source is the default.
447
448              Without  the extra d, requires the package's build depen‐
449              dencies.
450
451              With  ...-d  or  -wdd,  the  build-dependencies  are  not
452              checked  (due  to passing -d to dpkg-buildpackage), which
453              violates policy, but may work in practice.
454
455              The rules clean target will only be run if it is  needed:
456              when  dgit  is  going  to build source or binary packages
457              from your working tree, rather than from your git  branch
458              (for  example  because  of --include-dirty or because the
459              binary package build uses your working tree).
460
461              In all cases, dgit will check that there are (after rules
462              clean,  if  applicable) no untracked un-ignored files, in
463              case these are files you forgot to git add.  (Except that
464              this  check  is not done for a `3.0 (quilt)' package when
465              dgit has to apply patches, dirtily, to the working tree.)
466              If  your package does not have a good .gitignore you will
467              probably need --clean=dpkg-source,no-check aka -wdn.
468
469       --clean=dpkg-source[-d],no-check | -wdn | -wddn
470              Like  --clean=dpkg-source,  but  does  not   care   about
471              untracked un-ignored files.
472
473       --clean=dpkg-source[-d],all-check | -wda | -wdda
474              Like  --clean=dpkg-source,  but  fails  even  on  ignored
475              untracked files.  This could perhaps be  used  to  detect
476              bugs in your rules clean target.
477
478       -N | --new
479              The  package  is  or  may  be new in this suite.  Without
480              this, dgit will refuse to  push.   It  may  (for  Debian,
481              will)  be  unable to access the git history for any pack‐
482              ages which have been newly pushed and have not  yet  been
483              published.
484
485       --include-dirty
486              Do  not  complain if the working tree does not match your
487              git HEAD, and when building,  include  the  changes  from
488              your working tree.  This can be useful with build, if you
489              plan to commit later.  (dgit push will still ensure  that
490              the .dsc you upload and the git tree you push are identi‐
491              cal, so this option won't make broken pushes.)
492
493              Note that this does not prevent dgit from  cleaning  your
494              tree,  so  if the changes in your working tree are in the
495              form of untracked files, those might  still  be  deleted,
496              especially  with  --clean=git.   If  you  want to include
497              untracked files in the build, you can use --clean=none or
498              --clean=dpkg-source[-d]  in  addition to --include-dirty.
499              Note that this combination  can  fail  if  the  untracked
500              files are under debian/patches/.
501
502       --ignore-dirty
503              Deprecated alias for --include-dirty.
504
505       --overwrite[=previous-version]
506              Declare  that  your  HEAD  really  does  contain  all the
507              (wanted)  changes  from  all  versions  listed   in   its
508              changelog;  or,  all  (wanted) changes from previous-ver‐
509              sion.  This promise is needed when your git branch is not
510              a  descendant  of the version in the archive according to
511              the git revision history.
512
513              It is safer not to specify previous-version, and  usually
514              it's  not  needed.  Just say --overwrite, unless you know
515              what you are doing.
516
517              This option is useful if you are the maintainer, and  you
518              have  incorporated NMU changes into your own git workflow
519              in a way that doesn't make your  branch  a  fast  forward
520              from the NMU.
521
522              This  option  is  also usually necessary the first time a
523              package is pushed with dgit push to a  particular  suite.
524              See dgit-maint-*(7).
525
526              If  previous-version  is  not  specified, dgit will check
527              that the version in the  archive  is  mentioned  in  your
528              debian/changelog.   (This will avoid losing changes, even
529              with --overwrite,  unless  someone  committed  to  git  a
530              finalised changelog entry, and then made later changes to
531              that version.)   If  previous-version  is  specified,  it
532              ought to be the version currently in the archive.
533
534              dgit  push --overwrite will, if necessary, make a pseudo-
535              merge (that is, something that looks like the  result  of
536              git  merge  -s ours) to stitch the archive's version into
537              your own git history, so that your push is a fast forward
538              from the archive.
539
540              (In quilt mode gbp, dpm, unpatched or baredebian*, imply‐
541              ing a split between the  dgit  view  and  the  maintainer
542              view,  the  pseudo-merge  will  appear  only  in the dgit
543              view.)
544
545       --delayed=days
546              Upload to a DELAYED queue.
547
548              WARNING: If the maintainer responds  by  cancelling  your
549              upload  from  the  queue,  and does not make an upload of
550              their own, this will not rewind the  git  branch  on  the
551              dgit  git  server.   Other  dgit users will then see your
552              push (with a warning message from dgit) even  though  the
553              maintainer wanted to abolish it.  Such users might unwit‐
554              tingly reintroduce your changes.
555
556              If this situation arises, someone should make a  suitable
557              dgit  push to update the contents of dgit-repos to a ver‐
558              sion without the controversial changes.
559
560       --no-chase-dsc-distro
561              Tells dgit not to look online for additional git  reposi‐
562              tories  containing  information  about  a particular .dsc
563              being imported.  Chasing is the default.
564
565              For most operations (such as fetch and  pull),  disabling
566              chasing  means  dgit  will access only the git server for
567              the distro you are directly working  with,  even  if  the
568              .dsc  was  copied  verbatim  from  another  distro.   For
569              import-dsc, disabling chasing means dgit will  work  com‐
570              pletely offline.
571
572              Disabling  chasing  can be hazardous: if the .dsc names a
573              git commit which has been rewritten by those in charge of
574              the  distro,  this  option  may prevent that rewrite from
575              being effective.  Also, it can mean that  dgit  fails  to
576              find necessary git commits.
577
578       --save-dgit-view=branch|ref
579              Specifies  that when split view is in operation, and dgit
580              calculates (or looks up in its cache) a dgit view  corre‐
581              sponding to your HEAD, the dgit view will be left in ref.
582              The specified  ref  is  unconditionally  overwritten,  so
583              don't specify a branch you want to keep.
584
585              This  option  is effective only with the following opera‐
586              tions: quilt-fixup; push; all builds.   And  it  is  only
587              effective when split view is actually in operation.
588
589              If  ref  does  not  start  with refs/ it is taken to be a
590              branch - i.e. refs/heads/ is prepended.
591
592              --dgit-view-save is a deprecated alias  for  --save-dgit-
593              view.
594
595       --deliberately-something
596              Declare  that you are deliberately doing something.  This
597              can be used to override safety catches, including  safety
598              catches  which  relate  to distro-specific policies.  The
599              use of --deliberately is declared and  published  in  the
600              signed  tags  generated  for you by dgit, so that the ar‐
601              chive software can give effect to your  intent,  and  for
602              the  benefit of humans looking at the history.  The mean‐
603              ings of somethings understood in the  context  of  Debian
604              are discussed below:
605
606       --deliberately-not-fast-forward
607              Declare  that  you  are  deliberately  rewinding history.
608              When pushing to Debian, use this when you  are  making  a
609              renewed  upload  of  an entirely new source package whose
610              previous version was not accepted for  release  from  NEW
611              because of problems with copyright or redistributibility.
612
613              When  split  view is in operation, this also prevents the
614              construction by dgit of a pseudomerge to  make  the  dgit
615              view  fast  forwarding.  Normally only one of --overwrite
616              (which creates a  suitable  pseudomerge)  and  --deliber‐
617              ately-not-fast-forward  (which suppresses the pseudomerge
618              and the fast forward checks) should  be  needed;  --over‐
619              write is usually better.
620
621       --deliberately-include-questionable-history
622              Declare  that  you are deliberately including, in the git
623              history of your current push, history  which  contains  a
624              previously-submitted  version  of  this package which was
625              not approved (or has not yet been approved) by  the  ftp‐
626              masters.   When  pushing  to Debian, only use this option
627              after verifying that: none of the  rejected-from-NEW  (or
628              never-accepted)  versions in the git history of your cur‐
629              rent push, were rejected by ftpmaster  for  copyright  or
630              redistributability reasons.
631
632       --deliberately-fresh-repo
633              Declare  that  you are deliberately rewinding history and
634              want to throw away the existing repo.  Not relevant  when
635              pushing  to  Debian,  as  the  Debian server will do this
636              automatically when necessary.
637
638       --quilt=linear
639              When fixing up  source  format  `3.0  (quilt)'  metadata,
640              insist  on generating a linear patch stack: one new patch
641              for each relevant commit.  If such a stack cannot be gen‐
642              erated, fail.  This is the default for Debian.
643
644              HEAD  should  be  a series of plain commits (not touching
645              debian/patches/), and pseudomerges, with  as  ancestor  a
646              patches-applied branch.
647
648       --quilt=auto
649              When fixing up source format `3.0 (quilt)' metadata, pre‐
650              fer  to  generate  a  linear   patch   stack   (as   with
651              --quilt=linear) but if that doesn't seem possible, try to
652              generate a single squashed patch for all the changes made
653              in  git (as with --quilt=smash).  This is not a good idea
654              for an NMU in Debian.
655
656       --quilt=smash
657              When fixing up source format `3.0 (quilt)' metadata, gen‐
658              erate  a single additional patch for all the changes made
659              in git.  This is not a good idea for an NMU in Debian.
660
661              (If HEAD has any in-tree patches already, they must apply
662              cleanly.  This will be the case for any trees produced by
663              dgit fetch or clone; if you do not  change  the  upstream
664              version  nor  make  changes  in  debian/patches,  it will
665              remain true.)
666
667       --quilt=nofix
668              Check whether source format `3.0 (quilt)' metadata  would
669              need fixing up, but, if it does, fail.  You must then fix
670              the metadata yourself somehow before pushing.   (NB  that
671              dpkg-source  --commit  will not work because the dgit git
672              tree does not have a .pc directory.)
673
674       --quilt=nocheck | --no-quilt-fixup
675              Do not check whether source format `3.0 (quilt)' metadata
676              needs fixing up.  If you use this option and the metadata
677              did in fact need fixing up, dgit push will fail.
678
679       --[quilt=]gbp   |   --[quilt=]dpm    |    --quilt=unapplied    |
680       --[quilt=]baredebian[+git|+tarball]
681              Tell dgit that you are using a nearly-dgit-compatible git
682              branch, aka a maintainer  view,  and  do  not  want  your
683              branch changed by dgit.
684
685              These  quilt  modes  are  known as splitting quilt modes.
686              See --split-view, below.
687
688              --gbp (short for --quilt=gbp) is for use with  git-build‐
689              package.  Your HEAD is expected to be a patches-unapplied
690              git branch, except  that  it  might  contain  changes  to
691              upstream  .gitignore files.  This is the default for dgit
692              gbp-build.
693
694              --dpm (short for --quilt=dpm) is for  use  with  git-dpm.
695              Your HEAD is expected to be a patches-applied git branch,
696              except that it might contain changes to upstream  .gitig‐
697              nore files.
698
699              --quilt=unapplied  specifies that your HEAD is a patches-
700              unapplied git branch (and that any  changes  to  upstream
701              .gitignore   files   are   represented   as   patches  in
702              debian/patches).
703
704              --quilt=baredebian (or its alias  --quilt=baredebian+git)
705              specifies  that  your HEAD contains only a debian/ direc‐
706              tory, with any changes to upstream files  represented  as
707              patches  in  debian/patches.  The upstream source must be
708              available in git, by default, in  a  suitably  named  git
709              tag; see --upstream-commitish.  In this mode, dgit cannot
710              check that all edited upstream files are properly  repre‐
711              sented  as  patches:  dgit relies on debian/patches being
712              correct.
713
714              --quilt=baredebian+tarball  is  like  --quilt=baredebian,
715              but  is  used  when  there is no appropriate upstream git
716              history.  To construct the dgit view,  dgit  will  import
717              your  orig  tarballs'  contents  into git.  In this mode,
718              dgit cannot check that the upstream parts of your  upload
719              correspond  to  what you intend: dgit relies on the right
720              orig tarball(s) existing, and debian/patches  being  cor‐
721              rect.
722
723              With --quilt=gbp|dpm|unapplied|baredebian*, dgit push (or
724              precursors like quilt-fixup and build) will automatically
725              generate  a  conversion of your git branch into the right
726              form.  dgit push will push the dgit-compatible form  (the
727              dgit view) to the dgit git server.  The dgit view will be
728              visible to you in the dgit remote tracking branches,  but
729              your  own  branch  will  not be modified.  dgit push will
730              create a tag debian/version for the maintainer view,  and
731              the  dgit  tag  archive/debian/version for the dgit view.
732              dgit quilt-fixup will merely do some  checks,  and  cache
733              the maintainer view.
734
735              If you have a branch like this it is essential to specify
736              the appropriate --quilt= option!  This is because  it  is
737              not  always  possible  to  tell:  a patches-unapplied git
738              branch of a package with one patch,  for  example,  looks
739              very  like  a  patches-applied  branch where the user has
740              used git revert to undo the patch, expecting to  actually
741              revert  it.   However,  if  you fail to specify the right
742              --quilt option, and  you  aren't  too  lucky,  dgit  will
743              notice the problem and stop, with a useful hint.
744
745       -ddistro | --distro=distro
746              Specifies  that  the  suite  to be operated on is part of
747              distro distro.  This overrides the  default  value  found
748              from  the git config option dgit-suite.suite.distro.  The
749              only effect is that other configuration  variables  (used
750              for  accessing the archive and dgit-repos) used are dgit-
751              distro.distro.*.
752
753              If your suite is part of a distro that dgit already knows
754              about,  you can use this option to make dgit work even if
755              your dgit doesn't know about  the  suite.   For  example,
756              specifying  -ddebian  will  work  when  the  suite  is an
757              unknown suite in the Debian archive.
758
759              To define a new distro it is necessary to define  methods
760              and  URLs  for  fetching (and, for dgit push, altering) a
761              variety of information both in the archive and  in  dgit-
762              repos.  How to set this up is not yet documented.
763
764       --split-view=auto|always|never
765              Controls  whether  dgit operates a split view, separating
766              your own branch (as Debian maintainer) from that shown to
767              users of dgit clone and dgit fetch.
768
769              When  split  view  is  in operation dgit will not make or
770              merge any commits onto your  own  branch.   Specifically,
771              only  the  dgit  view  will  contain dgit's pseudomerges,
772              which bring into the git history  previous  uploads  made
773              with   dgit  push,  and  any  commits  in  debian/patches
774              required to make a correct `3.0 (quilt)' source package.
775
776              auto is the  default,  and  splits  the  view  only  when
777              needed:  i.e.,  when you are working with a `3.0 (quilt)'
778              source package and a splitting quilt mode: --[quilt=]gbp,
779              dpm, unpatched or baredebian*.
780
781              always  splits  the  view regardless of the source format
782              and the quilt mode.
783
784              never will cause dgit to fail if split view is needed.
785
786              When split view is in operation, the dgit view is visible
787              in  your  local  git  clone, but only in refs specific to
788              dgit: notably  remotes/dgit/dgit/suite  and  archive/dis‐
789              tro/version.
790
791              Note  that  split view does not affect dgit fetch, and is
792              not compatible with dgit pull.
793
794       -Cchangesfile
795              Specifies the .changes file which is to be uploaded.   By
796              default dgit push looks for a single .changes file in the
797              parent directory whose filename suggests it  is  for  the
798              right package and version.
799
800              If  the  specified changesfile pathname contains slashes,
801              the directory part is also used as the value for --build-
802              products-dir;  otherwise, the changes file is expected in
803              that directory (by default, in ..).
804
805       --upstream-commitish=upstream
806              For use with --quilt=baredebian only.  Specifies the com‐
807              mit  containing the upstream source.  This commit must be
808              identical to your .orig tarball.  The default is to  look
809              for  one of the git tags U vU upstream/U (in that order),
810              where U is the upstream version.
811
812       --rm-old-changes
813              When doing a build, delete  any  changes  files  matching
814              package_version_*.changes  before starting.  This ensures
815              that dgit push (and dgit sbuild) will be  able  to  unam‐
816              biguously  identify  the  relevant changes files from the
817              most recent build,  even  if  there  have  been  previous
818              builds  with  different tools or options.  The default is
819              not to remove, but --no-rm-old-changes  can  be  used  to
820              override  a  previous  --rm-old-changes  or  the .rm-old-
821              changes configuration setting.
822
823              Note that dgit push-source will  always  find  the  right
824              .changes, regardless of this option.
825
826       --build-products-dir=directory
827              Specifies where to find and create tarballs, binary pack‐
828              ages, source packages, .changes files, and so on.
829
830              By default, dgit uses the parent directory (..).
831
832              Changing this setting may necessitate moving  .orig  tar‐
833              balls to the new directory, so it is probably best to use
834              the dgit.default.build-products-dir configuration setting
835              (see CONFIGURATION, below) which this command line option
836              overrides).
837
838       --no-rm-on-error
839              Do not delete the destination directory if clone fails.
840
841       --dep14tag
842              Generates a DEP-14 tag (eg debian/version) as well  as  a
843              dgit   tag  (eg  archive/debian/version).   This  is  the
844              default.
845
846       --no-dep14tag
847              Do not generate a DEP-14 tag, except when split  view  is
848              in operation.
849
850       --always-dep14tag
851              Obsolete  alias  for --dep14tag, retained for compatibil‐
852              ity.
853
854       -D     Prints debugging information to  stderr.   Repeating  the
855              option  produces  more  output (currently, up to -DDDD is
856              meaningfully different).
857
858       -cname=value
859              Specifies a git configuration option, to be used for this
860              run.  dgit itself is also controlled by git configuration
861              options.
862
863       -vversion|_ | --since-version=version|_
864              Specifies the  -vversion  option  to  pass  to  dpkg-gen‐
865              changes,  during builds.  Changes (from debian/changelog)
866              since this version will be included in the built  changes
867              file,  and  hence  in  the upload.  If this option is not
868              specified, dgit will query the archive and use the latest
869              version uploaded to the intended suite.
870
871              Specifying  _ inhibits this, so that no -v option will be
872              passed to dpkg-genchanges (and as a result, only the last
873              stanza  from  debian/changelog will be used for the build
874              and upload).
875
876       -mmaintaineraddress
877              Passed to dpkg-genchanges (eventually).
878
879       --ch:option
880              Specifies a single additional option to pass, eventually,
881              to dpkg-genchanges.
882
883              Options  which  are safe to pass include -C (and also -si
884              -sa -sd although these should  never  be  necessary  with
885              Debian since dgit automatically calculates whether .origs
886              need to be uploaded.)
887
888              For other options the caveat below applies.
889
890       --curl:option | --dput:option |...
891              Specifies a single additional option  to  pass  to  curl,
892              dput,  debsign, dpkg-source, dpkg-buildpackage, dpkg-gen‐
893              changes, sbuild, pbuilder, cowbuilder,  ssh,  dgit,  git-
894              debrebase,  apt-get,  apt-cache,  gbp-pq,  gbp-build,  or
895              mergechanges.  Can be repeated as necessary.
896
897              Use of this ability should not normally be necessary.  It
898              is  provided  for  working  around bugs, or other unusual
899              situations.  If you use these options,  you  may  violate
900              dgit's assumptions about the behaviour of its subprograms
901              and cause lossage.
902
903              For dpkg-buildpackage, dpkg-genchanges, mergechanges  and
904              sbuild,  the  option  applies  only  when  the program is
905              invoked directly by dgit.  Usually, for  passing  options
906              to dpkg-genchanges, you should use --ch:option.
907
908              Specifying  --git  is  not effective for some lower-level
909              read-only git operations performed by dgit, and also  not
910              when git is invoked by another program run by dgit.
911
912              See notes below regarding ssh and dgit.
913
914              NB  that  --gpg:option  is not supported (because debsign
915              does not have that facility).  But see -k and  the  keyid
916              distro config setting.
917
918       --curl!:option | --dput!:option |...
919              Specifies an option to remove from the command line for a
920              program called by dgit, as for --program:option (and  the
921              same caveats apply).
922
923              Any  options or arguments exactly identical to option are
924              removed.  (It is not an error if there were none.)
925
926              This can only be used to delete options which are  always
927              passed  by  default by dgit, or to undo a previous --pro‐
928              gram:option.  It cannot be  used  to  override  option(s)
929              dynamically decided on by dgit.
930
931       --curl=program | --dput=program |...
932              Specifies  alternative  programs  to use instead of curl,
933              dput, debsign, dpkg-source, dpkg-buildpackage,  dpkg-gen‐
934              changes,  sbuild,  pbuilder,  cowbuilder, gpg, ssh, dgit,
935              git-debrebase,  apt-get,  apt-cache,  git,  gbp-pq,  gbp-
936              build, or mergechanges.
937
938              For  dpkg-buildpackage, dpkg-genchanges, mergechanges and
939              sbuild, this applies only when  the  program  is  invoked
940              directly by dgit.
941
942              For dgit, specifies the command to run on the remote host
943              when dgit rpush needs to invoke a remote copy of  itself.
944              (dgit also reinvokes itself as the EDITOR for dpkg-source
945              --commit; this is done using argv[0], and is not affected
946              by --dgit=).
947
948              gbp-build's  value  is  used instead of gbp build or git-
949              buildpackage.  (The default is the latter unless the for‐
950              mer  exists  on PATH.)  gbp-pq's value is used instead of
951              gbp pq.  In both cases, unusually, the specified value is
952              split  on  whitespace  to  produce a command and possibly
953              some options and/or arguments.
954
955              For pbuilder and cowbuilder, the  defaults  are  sudo  -E
956              pbuilder  and sudo -E cowbuilder respectively.  Like with
957              gbp-build and gbp pq, the specified  value  is  split  on
958              whitespace.
959
960              For  ssh, the default value is taken from the DGIT_SSH or
961              GIT_SSH environment variables, if set (see below).   And,
962              for  ssh, when accessing the archive and dgit-repos, this
963              command line setting is  overridden  by  the  git  config
964              variables  dgit-distro.distro.ssh  and  .dgit.default.ssh
965              (which can in turn be overridden with  -c).   Also,  when
966              dgit  is  using git to access dgit-repos, only git's idea
967              of what ssh to use (eg, GIT_SSH) is relevant.
968
969       --existing-package=package
970              dgit push needs to canonicalise the  suite  name.   Some‐
971              times,  dgit  lacks  a  way to ask the archive to do this
972              without knowing the name of an existing package.  Without
973              --new  we can just use the package we are trying to push.
974              But with --new that will not work, so we  guess  dpkg  or
975              use  the value of this option.  This option is not needed
976              with the default mechanisms for accessing the archive.
977
978       -h|--help
979              Print a usage summary.
980
981       --initiator-tempdir=directory
982              dgit rpush uses a temporary  directory  on  the  invoking
983              (signing) host.  This option causes dgit to use directory
984              instead.  Furthermore, the specified  directory  will  be
985              emptied, removed and recreated before dgit starts, rather
986              than removed after dgit finishes.  The  directory  speci‐
987              fied must be an absolute pathname.
988
989       --force-something
990              Instructs  dgit  to try to proceed despite detecting what
991              it thinks is going to be a fatal problem.  This is proba‐
992              bly  not going to work.  These options are provided as an
993              escape hatch, in case dgit is confused.  (They might also
994              be useful for testing error cases.)
995
996       --force-import-dsc-with-dgit-field
997              Tell  dgit  import-dsc  to treat a .dsc with a Dgit field
998              like one without it.  The result is a fresh import,  dis‐
999              carding  the  git history that the person who pushed that
1000              .dsc was working with.
1001
1002       --force-uploading-binaries
1003              Carry on and upload binaries even though dgit thinks your
1004              distro does not permit that.
1005
1006       --force-uploading-source-only
1007              Carry  on  and do a source-only upload, without any bina‐
1008              ries, even though dgit thinks your distro does not permit
1009              that, or does not permit that in this situation.
1010
1011       --force-unrepresentable
1012              Carry  on even if dgit thinks that your git tree contains
1013              changes (relative to your  .orig  tarballs)  which  dpkg-
1014              source is not able to represent.  Your build or push will
1015              probably fail later.
1016
1017       --force-changes-origs-exactly
1018              Use  the  set  of  .origs  specified  in  your  .changes,
1019              exactly,  without  regard  to  what  is  in  the  archive
1020              already.  The archive may well reject your upload.
1021
1022       --force-unsupported-source-format
1023              Carry on despite dgit not understanding your source pack‐
1024              age format.  dgit will probably mishandle it.
1025
1026       --force-dsc-changes-mismatch
1027              Do  not  check  whether .dsc and .changes match.  The ar‐
1028              chive will probably reject your upload.
1029
1030       --force-import-gitapply-absurd   |   --force-import-gitapply-no-
1031       absurd
1032              Force on or off the use of the absurd git-apply emulation
1033              when running gbp pq import when importing a package  from
1034              a .dsc.  See Debian bug #841867.
1035
1036       --for-push
1037              Override  the  dgit-distro.distro.readonly  configuration
1038              setting, to specify that we have  read/write  access  and
1039              should  use  the  corresponding  git  and  achive  access
1040              approach even if the operation is a read-only one.
1041

CONFIGURATION

1043       dgit can be configured via the git config system.  You  may  set
1044       keys  with  git-config (either in system-global or per-tree con‐
1045       figuration), or provide -ckey=value on the dgit command line.
1046
1047       Settings likely to be useful for an end user include:
1048
1049       dgit.default.build-products-dir
1050              Specifies where to find the built files to  be  uploaded,
1051              when  --build-products-dir is not specified.  The default
1052              is the parent directory (..).
1053
1054       dgit-suite.suite.distro distro
1055              Specifies the distro for a  suite.   dgit  keys  off  the
1056              suite  name  (which appears in changelogs etc.), and uses
1057              that to determine the distro which is involved.  The con‐
1058              fig used is thereafter that for the distro.
1059
1060              suite may be a glob pattern.
1061
1062       dgit.default.distro distro
1063              The default distro for an unknown suite.
1064
1065       dgit.default.default-suite suite
1066              The default suite (eg for clone).
1067
1068       dgit.default.*
1069              for  each dgit-distro.distro.*, the default value used if
1070              there is no distro-specific setting.
1071
1072       dgit-distro.distro.clean-mode
1073              One of the values for the command line  --clean=  option;
1074              used if --clean is not specified.
1075
1076       dgit-distro.distro.clean-mode-newer
1077              Like  .clean-mode, but ignored if the value is unknown to
1078              this version  of  dgit.   Setting  both  .clean-mode  and
1079              .clean-mode-newer  is useful to provide a single git con‐
1080              fig compatible with different dgit versions.
1081
1082       dgit-distro.distro.quilt-mode
1083              One of the values for the command line  --quilt=  option;
1084              used if --quilt is not specified.
1085
1086       dgit-distro.distro.split-view
1087
1088       dgit-distro.distro.rm-old-changes
1089              Boolean,  used  if  neither --rm-old-changes nor --no-rm-
1090              old-changes is specified.  The default is not to remove.
1091
1092       dgit-distro.distro.readonly auto|a | true|t|y|1 | false|f|n|0
1093              Whether you have push access to the distro.  For  Debian,
1094              it is OK to use auto, which uses readonly mode if you are
1095              not pushing right now; but, setting this  to  false  will
1096              avoid  relying  on  the mirror of the dgit git repository
1097              server.
1098
1099       dgit-distro.distro.keyid
1100              See also -k.
1101
1102       dgit-distro.distro.mirror url
1103
1104       dgit-distro.distro.username
1105              Not relevant for Debian.
1106
1107       dgit-distro.distro.upload-host
1108              Might be useful if you have an intermediate queue server.
1109
1110       dgit-distro.distro.user-name dgit-distro.distro.user-email
1111              Values to configure for user.name and user.email  in  new
1112              git  trees.   If not specified, the DEBFULLNAME and DEBE‐
1113              MAIL environment variables are used, respectively.   Only
1114              used if .setup-usermail is not disabled.
1115
1116       dgit-distro.distro.setup-useremail
1117              Whether to set user.name and user.email in new git trees.
1118              True by default.  Ignored for dgit setup-useremail, which
1119              does it anyway.
1120
1121       dgit-distro.distro.setup-mergechangelogs
1122              Whether  to  set  up  a  merge  driver  which  uses dpkg-
1123              mergechangelogs for debian/changelog.  True  by  default.
1124              Ignored  for  dgit  setup-mergechangelogs,  which does it
1125              anyway.
1126
1127       dgit-distro.distro.setup-gitattributes
1128              Whether to  configure  .git/info/attributes  to  suppress
1129              checkin/checkout  file content transformations in new git
1130              trees.  True by default.  Ignored for  dgit  setup-gitat‐
1131              tributes, which does it anyway.
1132
1133       dgit-distro.distro.cmd-cmd
1134              Program to use instead of cmd.  Works like --cmd=... .
1135
1136       dgit-distro.distro.opts-cmd
1137              Extra options to pass to cmd.  Works like --cmd:... .  To
1138              pass several options, configure multiple  values  in  git
1139              config   (with   git  config  --add).   The  options  for
1140              dgit.default.opts-cmd  and  dgit-distro.distro/push.opts-
1141              cmd are all used, followed by options from dgit's command
1142              line.
1143

ACCESS CONFIGURATION

1145       There are many other settings which  specify  how  a  particular
1146       distro's  services (archive and git) are provided.  These should
1147       not normally be adjusted, but are documented for the benefit  of
1148       distros who wish to adopt dgit.
1149
1150       dgit-distro.distro.nominal-distro
1151              Shown in git tags, Dgit fields, and so on.
1152
1153       dgit-distro.distro.alias-canon
1154              Used for all access configuration lookup.
1155
1156       dgit-distro.distro/push.*
1157              If  set,  overrides  corresponding  non /push config when
1158              readonly=false, or when pushing and readonly=auto.
1159
1160       dgit-distro.distro.git-url
1161
1162       dgit-distro.distro.git-url[-suffix]
1163
1164       dgit-distro.distro.git-proto
1165
1166       dgit-distro.distro.git-path
1167
1168       dgit-distro.distro.git-check true|false|url|ssh-cmd
1169
1170       dgit-distro.distro.git-check-suffix
1171
1172       dgit-distro.distro.diverts.divert new-distro|/distro-suffix
1173
1174       dgit-distro.distro.git-create ssh-cmd|true
1175
1176       dgit-distro.distro.archive-query ftpmasterapi: |  madison:distro
1177       | dummycat:/path  | sshpsql:user@host:dbname | aptget:
1178
1179       dgit-distro.distro.archive-query-(url|tls-key|curl-ca-args)
1180
1181       dgit-distro.distro.madison-distro
1182
1183       dgit-distro.distro.archive-query-default-component
1184
1185       dgit-distro.distro.dgit-tag-format
1186
1187       dgit-distro.distro.dep14tag want|no[|always]
1188
1189       dgit-distro.distro.ssh
1190
1191       dgit-distro.distro.sshpsql-dbname
1192
1193       dgit-distro.distro.(git|sshpsql)-(user|host|user-force)
1194
1195       dgit-distro.distro.backports-quirk
1196
1197       dgit-distro.distro.rewrite-map-enable
1198
1199       dgit-distro.distro.source-only-uploads      ok|always|never|not-
1200       wholly-new
1201
1202       dgit.default.old-dsc-distro
1203
1204       dgit.dsc-url-proto-ok.protocol
1205
1206       dgit.dsc-url-proto-ok.bad-syntax
1207
1208       dgit.default.dsc-url-proto-ok
1209
1210       dgit.vcs-git.suites suite[;...]
1211

ENVIRONMENT VARIABLES

1213       DGIT_SSH, GIT_SSH
1214              specify an alternative default program (and perhaps argu‐
1215              ments)  to  use  instead  of  ssh.  DGIT_SSH is consulted
1216              first and may  contain  arguments;  if  it  contains  any
1217              whitespace  will  be passed to the shell.  GIT_SSH speci‐
1218              fies just the program; no arguments can be specified,  so
1219              dgit  interprets  it  the same way as git does.  See also
1220              the --ssh= and --ssh: options.
1221
1222       DEBEMAIL, DEBFULLNAME
1223              Default git user.email and user.name for new trees.   See
1224              dgit setup-new-tree.
1225
1226       gpg, dpkg-..., debsign, git, [lib]curl, dput
1227              and  other  subprograms  and  modules  used  by  dgit are
1228              affected by various environment variables.   Consult  the
1229              documentation for those programs for details.
1230

BUGS

1232       There  should  be  a  `dgit rebase-prep' command or some such to
1233       turn a fast-forwarding branch containing pseudo-merges back into
1234       a  rebasing  patch  stack.   It might have to leave a note for a
1235       future dgit push.
1236
1237       If the dgit push fails halfway through, it  is  not  necessarily
1238       restartable  and idempotent.  It would be good to check that the
1239       proposed signing key is available before starting work.
1240
1241       dgit's build functions, and dgit push, may make changes to  your
1242       current  HEAD.  Sadly this is necessary for packages in the `3.0
1243       (quilt)' source format.  This is ultimately due to what  I  con‐
1244       sider design problems in quilt and dpkg-source.
1245
1246       --dry-run  does  not  always work properly, as not doing some of
1247       the git fetches may result in subsequent actions  being  differ‐
1248       ent.   Doing  a non-dry-run dgit fetch first will help.  --damp-
1249       run is likely to work much better.
1250

SEE ALSO

1252       dgit(7), dgit-*(7), curl(1), dput(1), debsign(1), git-config(1),
1253       git-buildpackage(1), dpkg-buildpackage(1),
1254       https://browse.dgit.debian.org/
1255
1256
1257
1258Debian Project                                                         dgit(1)
Impressum