Changeset 1195 in tailor

Timestamp:

06/29/06 01:25:02 (7 years ago)

Author:

ydirson@…

Hash name:

20060628232502-130f5-9fddd5dda8c17309c7837d5307fbbe24b112c9de

Message:

[git] add support for "repository" parameter

Files:

• README (modified) (1 diff)
• vcpx/repository/git.py (modified) (10 diffs)

README

@@ -665 +665 @@
             ``subdir`` different from ``.``. [#]_
 
-git
-%%%
+git target
+%%%%%%%%%%
 
 parent-repo : string
-  Relative path to a git directory to use as a parent.  This is useful
-  to import repository branches.  If this parameter is empty, the
-  branch has no parent (default behaviour).
+  Relative path to a git directory to use as a parent.  This is one
+  way to import branches into a git repository, which creates a new
+  git repository borrowing ancestry from the parent-repo.  It is quite
+  a simple way, and thus believed to be quite robust, but spreads
+  branches across several git repositories. If this parameter is
+  not set, and ``repository`` is not set either, the branch has no
+  parent.
+
+  The alternative is to specify a ``repository`` parameter, to contain
+  all git branches.  The .git directory in the working copy for each
+  branch will then only contain the ``.git/index`` file.
+
+branch : string
+  The name of the branch to which to commit.  It is only used in
+  single-repository mode (using ``repository``, see above).  The
+  default is to use the "master" branch.
 
 branchpoint : string

vcpx/repository/git.py

@@ -4 +4 @@
 # :Autore:   Todd Mokros <tmokros@tmokros.net>
 #            Brendan Cully <brendan@kublai.com>
+#            Yann Dirson <ydirson@altern.org>
 # :Licenza:  GNU General Public License
 #
@@ -15 +16 @@
 from vcpx.repository import Repository
 from vcpx.shwrap import ExternalCommand, PIPE
+from vcpx.config import ConfigurationError
 from vcpx.source import UpdatableSourceWorkingDir, GetUpstreamChangesetsFailure
 from vcpx.source import ChangesetApplicationFailure
@@ -30 +32 @@
         self.PARENT_REPO = project.config.get(self.name, 'parent-repo')
         self.BRANCHPOINT = project.config.get(self.name, 'branchpoint', 'HEAD')
-
+        self.BRANCHNAME = project.config.get(self.name, 'branch')
+        if self.BRANCHNAME:
+            self.BRANCHNAME = 'refs/heads/' + self.BRANCHNAME
+
+        if self.repository and self.PARENT_REPO:
+            self.log.critical('Cannot make sense of both "repository" and "parent-repo" parameters')
+            raise ConfigurationError ('Must specify only one of "repository" and "parent-repo"')
+
+        if self.BRANCHNAME and not self.repository:
+            self.log.critical('Cannot make sense of "branch" if "repository" is not set')
+            raise ConfigurationError ('Missing "repository" to make use o "branch"')
+
+        self.env = {}
+
+        if self.repository:
+            self.storagedir = self.repository
+            self.env['GIT_DIR'] = self.storagedir
+            self.env['GIT_INDEX_FILE'] = self.METADIR + '/index'
+        else:
+            self.storagedir = self.METADIR
+
+class GitExternalCommand(ExternalCommand):
+    def __init__(self, repo, command=None, cwd=None):
+        """
+        Initialize an ExternalCommand instance tied to a GitRepository
+        from which it inherits a set of environment variables to use
+        fo each execute().
+        """
+
+        self.repo = repo
+        return ExternalCommand.__init__(self, command, cwd)
+
+    def execute(self, *args, **kwargs):
+        """Execute the command, with controlled environment."""
+
+        if not kwargs.has_key('env'):
+            kwargs['env'] = {}
+
+        kwargs['env'].update(self.repo.env)
+
+        return ExternalCommand.execute(self, *args, **kwargs)
 
 class GitWorkingDir(UpdatableSourceWorkingDir, SynchronizableTargetWorkingDir):
 
     def _tryCommand(self, cmd, exception=Exception, pipe=True):
-        c = ExternalCommand(command = self.repository.command(*cmd), cwd = self.basedir)
+        c = GitExternalCommand(self.repository,
+                               command = self.repository.command(*cmd), cwd = self.basedir)
         if pipe:
             output = c.execute(stdout=PIPE)[0]
@@ -241 +284 @@
         treeid = self._tryCommand(['write-tree'])[0]
 
-        # find the parent commit if any
-        c = ExternalCommand(cwd=self.basedir,
-                         command=self.repository.command('rev-parse', 'HEAD'))
+        # in single-repository mode, only update the relevant branch
+        if self.repository.BRANCHNAME:
+            refname = self.repository.BRANCHNAME
+        else:
+            refname = 'HEAD'
+
+        # find the previous commit on the branch if any
+        c = GitExternalCommand(self.repository, cwd=self.basedir,
+                               command=self.repository.command('rev-parse', refname))
         (out, err) = c.execute(stdout=PIPE, stderr=PIPE)
         if c.exit_status:
@@ -267 +316 @@
         else:
             cmd = self.repository.command('commit-tree', treeid)
-        c = ExternalCommand(cwd=self.basedir, command=cmd)
+        c = GitExternalCommand(self.repository, cwd=self.basedir, command=cmd)
 
         logmessage = encode('\n'.join(logmessage))
@@ -286 +335 @@
         else:
             commitid=out.read().split('\n')[0]
+
             if parent:
-                self._tryCommand(['update-ref', 'HEAD', commitid, parent])
+                self._tryCommand(['update-ref', refname, commitid, parent])
             else:
-                self._tryCommand(['update-ref', 'HEAD', commitid])
+                self._tryCommand(['update-ref', refname, commitid])
 
     def _tag(self, tag):
         # Allow a new tag to overwrite an older one with -f
         cmd = self.repository.command("tag", "-f", tag)
-        c = ExternalCommand(cwd=self.basedir, command=cmd)
+        c = GitExternalCommand(self.repository, cwd=self.basedir, command=cmd)
         c.execute()
 
@@ -350 +400 @@
         """
 
-        from os import renames
+        from os import renames, mkdir
         from os.path import join, exists
 
         if not exists(join(self.basedir, self.repository.METADIR)):
-            if not self.repository.PARENT_REPO:
-                cmd = self.repository.command("init-db")
-                init = ExternalCommand(cwd=self.basedir, command=cmd)
-                init.execute()
-                if init.exit_status:
-                    raise TargetInitializationFailure(
-                        "%s returned status %s" % (str(init), init.exit_status))
-            else:
+            if self.repository.PARENT_REPO:
                 cmd = self.repository.command("clone", "--shared", "-n",
                                               self.repository.PARENT_REPO, 'tmp')
-                clone = ExternalCommand(cwd=self.basedir, command=cmd)
+                clone = GitExternalCommand(self.repository, cwd=self.basedir, command=cmd)
                 clone.execute()
                 if clone.exit_status:
@@ -374 +417 @@
                 
                 cmd = self.repository.command("reset", "--soft", self.repository.BRANCHPOINT)
-                reset = ExternalCommand(cwd=self.basedir, command=cmd)
+                reset = GitExternalCommand(self.repository, cwd=self.basedir, command=cmd)
                 reset.execute()
                 if reset.exit_status:
@@ -380 +423 @@
                         "%s returned status %s" % (str(reset), reset.exit_status))
 
+            elif self.repository.repository and self.repository.BRANCHNAME:
+                # ...and exists(self.repository.storagedir) ?
+
+                # initialization of a new branch in single-repository mode
+                mkdir(join(self.basedir, self.repository.METADIR))
+
+                bp = self._tryCommand(['rev-parse', self.repository.BRANCHPOINT])[0]
+                self._tryCommand(['read-tree', bp])
+                self._tryCommand(['update-ref', self.repository.BRANCHNAME, bp])
+                #self._tryCommand(['checkout-index'])
+
+            else:
+                self._tryCommand(['init-db'])
+                if self.repository.repository:
+                    # in this mode, the db is not stored in working dir, so we
+                    # have to create .git ourselves
+                    mkdir(join(self.basedir, self.repository.METADIR))
 
     def _prepareWorkingDirectory(self, source_repo):
@@ -390 +450 @@
         from vcpx.dualwd import IGNORED_METADIRS
 
-        infodir = join(self.basedir, self.repository.METADIR, 'info')
+        # create info/excludes in storagedir
+        infodir = join(self.basedir, self.repository.storagedir, 'info')
         if not exists(infodir):
             mkdir(infodir)