Provided by: git-ubuntu_1.1-2_all bug

NAME

       git-ubuntu-import - Import Launchpad publishing history to Git

SYNOPSIS

       git  ubuntu import [-o | --lp-owner <owner>] [-l | --lp-user <user>] [--dl-cache <dl_cache>] [--no-fetch]
       [--push] [--no-clean] [-d | --directory  <directory>]  [--active-series-only]  [--skip-applied]  [--skip-
       orig] [--reimport] [--allow-applied-failures] <package>

DESCRIPTION

       Import  a  source package's publication history from Launchpad into a local git(1) repository and push it
       to a remote repository.

       The importer algorithm roughly looks like:

           Fetch the owner repository for <package>.

           For <distribution> in "Debian", "Ubuntu":

               For each <publish> in <distribution> since the most recent patches-unapplied import in the  local
               repository:

                   Import  the  orig  tarballs for <publish> using "gbp import-orig --pristine-tar", unless they
                   have already been imported and the imported tarballs are identical.

                   Find a <changelog parent>: the most recent changelog  entry  with  a  corresponding  patches-
                   unapplied import.

                   Find  an  <upload  parent>: an upload-tag in the repository for the same version as <publish>
                   with git-tree-identical contents as <publish>.

                   Commit the git tree corresponding  to  a  patches-unapplied  extraction  of  <publish>  using
                   <changelog parent> and <upload parent> as parents.

                   If  this  is  the  first  patches-unapplied  import  of  a  given  version,  create  a tag in
                   refs/tags/import/ pointing to the new commit.

                   Update the patches-applied <distribution>/<publish's series>/<publish's pocket> branch to the
                   new commit.

           For <distribution> in "Debian", "Ubuntu":

           For each <publish> in <distribution> since the  most  recent  patches-applied  import  in  the  local
           repository:

               Find  a  <changelog parent>: the most recent changelog entry with a corresponding patches-applied
               import.

               Find an <unapplied parent>: the corresponding patches-unapplied import of <publish>'s version.

               Commit each git tree corresponding to the application of the next quilt patch in <publish>  using
               <changelog  parent>  and  <unapplied  parent>  as  parents.   As each quilt patch is applied, the
               <unapplied parent> becomes the result of the immediately prior patch's application.

               If  this  is  the  first  patches-applied  import  of  a  given  version,   create   a   tag   in
               refs/tags/applied/  pointing  to  the  commit corresponding to the application of the final quilt
               patch.

               Update the patches-applied <distribution>/<publish>'s series/<publish>'s pocket branch to the new
               commit.

OPTIONS

       -o <owner>, --lp-owner <owner>
           The Launchpad owner of the remote repository to fetch  the  current  repository  from  and  push  the
           resulting import to.

       -l <user>, --lp-user <user>
           The Launchpad user to authenticate as for push URLs as well as the default personal remote to create.
           If not specified, this value is obtained from "git config --global gitubuntu.lpuser".  If that config
           value is not set, a prompt is shown to obtain the value.

       --dl-cache <dl_cache>
           The  path  to  use for caching downloads from Launchpad.  By default, downloads are cached inside the
           repository's GIT_DIR.

       --no-fetch
           Do not fetch the <owner>'s repository before importing.

       --push
           Confirm that you want to push the resulting import to the <<owner>'s repository after importing. This
           is not the default since for local purposes operating  outside  the  importer  service  this  is  not
           usually wanted.

       --no-clean
           Do not delete local directory used for the import upon completion.

       -d <directory>, --directory <directory>
           The local directory to perform the import in.  Implies --no-clean.  If not specified, use a temporary
           directory.

       --active-series-only
           Rather  than  importing all publications from Launchpad, only consider those for the currently active
           series.  This can be useful to just get a quick view of the current state in the archive, as  a  full
           import can take a very long time.

       --skip-applied
           Only  perform  the  patches-unapplied portion of the algorithm in DESCRIPTION.  This can be useful to
           just get a quick view of the current state in the archive, as a full import  can  take  a  very  long
           time.

       --skip-orig
           Do  not  attempt  to  import  the  orig tarballs.  This can be useful to just get a quick view of the
           current state in the archive, as a full import can take a very long time.  This option can be  useful
           for git-ubuntu(1) developers when debugging issues with "gbp" or "pristine-tar".

       --reimport
           Reimport  the  given source package from scratch.  The reimport will still incorporate upload tags as
           currently present in  the  remote  repository.   This  option  is  only  intended  for  git-ubuntu(1)
           developers  and  is used when the SHA1s of commits must change due to an implementation change in git
           ubuntu-import.  A typical reimport of a repository (for safety) will look like:

               git ubuntu import --reimport --no-clean <package>

               This will leave a local directory with the resulting reimport.  The  local  directory  should  be
               examined  for  the  reimport's success; in particular, that upload tags are reincorporated in the
               new history.

               git ubuntu import --reimport --no-fetch --directory <tempdir from prior command>

               This will use the local directory, which is current as of the prior reimport, ensure it is  still
               current  (in  case new publishes have occurred) and forcibly git-push the resulting repository to
               <owner>'s remote repository.

       --allow-applied-failures
           Do not treat a patch application as a hard failure when importing the  patches-applied  history.   As
           dpkg-source(1)'s  (or  other  tool's) behavior has evolved over time, it is possible that the version
           used by git ubuntu import is not able to reproduce the patch application of a historical publication.
           By default, such a failure will stop the historical import for the patches-applied branch, to allow a
           git ubuntu developer to investigate.  After investigation, this flag can  be  used  to  indicate  the
           importer is allowed to ignore such a failure.

       <package>
           The name of the source package to import.

EXIT STATUS

       git ubuntu import exits with status 0 if the import completes successfully.  git ubuntu import exits with
       nonzero exit status on errors.

REPORTING BUGS

       Report bugs at https://bugs.launchpad.net/git-ubuntu

SEE ALSO

       quilt(1)

GIT-UBUNTU

       Part of the git-ubuntu(1) suite

Git-Ubuntu 0.2                                     2017-07-19                               GIT-UBUNTU-IMPORT(1)