This patch introduces parts of a Python package called "git_remote_cvs"
containing the building blocks of the CVS remote helper.
The CVS remote helper itself is NOT part of this patch.
This patch has been improved by the following contributions:
- David Aguilar: Lots of Python coding style fixes
Cc: David Aguilar <davvid@xxxxxxxxx>
Signed-off-by: Johan Herland <johan@xxxxxxxxxxx>
---
This patch and the next patch belong together in the same commit, but
the 100K limit (?) on the git mailing list forces me to split this
patch in two.
...Johan
git_remote_cvs/changeset.py | 126 +++++
git_remote_cvs/cvs.py | 998 ++++++++++++++++++++++++++++++++++++
git_remote_cvs/cvs_symbol_cache.py | 313 +++++++++++
git_remote_cvs/util.py | 186 +++++++
4 files changed, 1623 insertions(+), 0 deletions(-)
create mode 100644 git_remote_cvs/changeset.py
create mode 100644 git_remote_cvs/cvs.py
create mode 100644 git_remote_cvs/cvs_symbol_cache.py
create mode 100644 git_remote_cvs/util.py
diff --git a/git_remote_cvs/changeset.py b/git_remote_cvs/changeset.py
new file mode 100644
index 0000000..9eea9d2
--- /dev/null
+++ b/git_remote_cvs/changeset.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+
+"""Code for collecting individual CVS revisions into "changesets"
+
+A changeset is a collection of CVSRev objects that belong together in
+the same "commit". This is a somewhat artificial construct on top of
+CVS, which only stores changes at the per-file level. Normally, CVS
+users create several CVS revisions simultaneously by applying the
+"cvs commit" command to several files with related changes. This
+module tries to reconstruct this notion of related revisions.
+
+"""
+
+from git_remote_cvs.util import debug, error, die
+
+
+class Changeset(object):
+
+ """Encapsulate a single changeset/commit."""
+
+ __slots__ = ('revs', 'date', 'author', 'message')
+
+ # The maximum time between the changeset's date, and the date of a
+ # rev to included in that changeset.
+ MaxSecondsBetweenRevs = 8 * 60 * 60 # 8 hours
+
+ @classmethod
+ def from_rev (cls, rev):
+ """Return a Changeset based on the given CVSRev object."""
+ c = cls(rev.date, rev.author, rev.message)
+ result = c.add(rev)
+ assert result
+ return c
+
+ def __init__ (self, date, author, message):
+ """Create a new Changeset with the given metadata."""
+ self.revs = {} # dict: path -> CVSRev object
+ self.date = date # CVSDate object
+ self.author = author
+ self.message = message # Lines of commit message
+
+ def __str__ (self):
+ """Stringify this Changeset object."""
+ msg = self.message[0] # First line only
+ # Limit message to 25 chars
+ if len(msg) > 25:
+ msg = msg[:22] + "..."
+ return ("<Changeset @(%s) by %s (%s) updating %i files>" %
+ (self.date, self.author, msg, len(self.revs)))
+
+ def __iter__ (self):
+ """Return iterator traversing the CVSRevs in this Changeset."""
+ return self.revs.itervalues()
+
+ def __getitem__ (self, path):
+ """Look up a specific CVSRev in this Changeset."""
+ return self.revs[path]
+
+ def within_time_window (self, rev):
+ """Return True iff the rev is within the time window of self."""
+ return abs(rev.date.diff(self.date)) <= self.MaxSecondsBetweenRevs
+
+ def add (self, rev):
+ """Add the given CVSRev to this Changeset.
+
+ The addition will only succeed if the following holds:
+ - rev.author == self.author
+ - rev.message == self.message
+ - rev.path is not in self.revs
+ - rev.date is within MaxSecondsBetweenRevs of self.date
+ If the addition succeeds, True is returned; otherwise False.
+
+ """
+ if rev.author != self.author or \
+ rev.message != self.message or \
+ rev.path in self.revs or \
+ not self.within_time_window(rev):
+ return False
+
+ self.revs[rev.path] = rev
+ return True
+
+
+def build_changesets_from_revs (cvs_revs):
+ """Organize CVSRev objects into a chronological list of Changesets."""
+ # Construct chronological list of CVSRev objects
+ chron_revs = []
+ for path, d in cvs_revs.iteritems():
+ i = 0 # Current index into chronRevs
+ for revnum, cvsrev in sorted(d.iteritems()):
+ assert path == cvsrev.path
+ assert revnum == cvsrev.num
+ while i < len(chron_revs) and cvsrev.date > chron_revs[i].date:
+ i += 1
+ # Insert cvsRev at position i in chronRevs
+ chron_revs.insert(i, cvsrev)
+ i += 1
+
+ changesets = [] # Chronological list of Changeset objects
+ while len(chron_revs):
+ # There are still more revs to be added to Changesets
+ # Create Changeset based on the first rev in chronRevs
+ changeset = Changeset.from_rev(chron_revs.pop(0))
+ # Keep adding revs chronologically until MaxSecondsBetweenRevs
+ rejects = [] # Revs that cannot be added to this changeset
+ while len(chron_revs):
+ rev = chron_revs.pop(0)
+ reject = False
+ # First, if we have one of rev's parents in rejects, we
+ # must also reject rev
+ for r in rejects:
+ if r.path == rev.path:
+ reject = True
+ break
+ # Next, add rev to changeset, reject if add fails
+ if not reject:
+ reject = not changeset.add(rev)
+ if reject:
+ rejects.append(rev)
+ # stop trying when rev is too far in the future
+ if not changeset.within_time_window(rev):
+ break
+ chron_revs = rejects + chron_revs # Reconstruct remaining revs
+ changesets.append(changeset)
+
+ return changesets
diff --git a/git_remote_cvs/cvs.py b/git_remote_cvs/cvs.py
new file mode 100644
index 0000000..f870ae0
--- /dev/null
+++ b/git_remote_cvs/cvs.py
@@ -0,0 +1,998 @@
+#!/usr/bin/env python
+
+"""Functionality for interacting with CVS repositories.
+
+This module provides classes for interrogating a CVS repository via a
+CVS working directory (aka. checkout), or via direct queries using the
+"cvs rlog" command.
+
+Also, classes for encapsulating fundamental CVS concepts (like CVS
+revision/branch numbers) are provided.
+"""
+
+import sys
+import os
+import shutil
+import time
+from calendar import timegm
+import unittest
+
+from git_remote_cvs.util import (debug, error, die, ProgressIndicator,
+ start_command, run_command,
+ file_reader_method, file_writer_method)
+
+
+class CVSNum(object):
+
+ """Encapsulate a single CVS revision/branch number.
+
+ Provides functionality for common operations on CVS numbers.
+
+ A CVS number consists of a list of components separated by periods
+ ('.'), where each component is a decimal number. Inspecting the
+ components from left to right, the odd-numbered (1st, 3rd, 5th,
+ etc.) components represent branches in the CVS history tree, while
+ the even-numbered (2nd, 4th, 6th, etc.) components represent
+ revisions on the branch specified in the previous position.
+ Thus "1.2" denotes the second revision on the first branch
+ (aka. trunk), while "1.2.4.6" denotes the sixth revision of the
+ fourth branch started from revision "1.2".
+
+ Therefore, in general, a CVS number with an even number of
+ components denotes a revision (we call this a "revision number"),
+ while an odd number of components denotes a branch (called a
+ "branch number").
+
+ There are a few complicating peculiarities: If there is an even
+ number of components, and the second-last component is 0, the
+ number is not a revision number, but is rather equivalent to the
+ branch number we get by removing the 0-component. I.e. "1.2.0.4"
+ is equivalent to "1.2.4".
+
+ A branch number (except the trunk: "1") always has a "branch point"
+ revision, i.e. the revision from which the branch was started.
+ This revision is found by removing the last component of the branch
+ number. For example the branch point of "1.2.4" is "1.2".
+
+ Conversely, all revision numbers belong to a corresponding branch,
+ whose branch number is found by removing the last component.
+ Examples: The "1.2.4.6" revision belong to the "1.2.4" branch,
+ while the "1.2" revision belongs to the "1" branch (the "trunk").
+
+ From this we can programatically determine the ancestry of any
+ revision number, by decrementing the last revision component until
+ it equals 1, and then trim off the last two components to get to
+ the branch point, and repeat the process from there until we reach
+ the initial revision (typically "1.1"). For example, recursively
+ enumerating the parent revisions of "1.2.4.6" yields the following
+ revisions:
+ "1.2.4.5", "1.2.4.4", "1.2.4.3", "1.2.4.2", "1.2.4.1", "1.2", "1.1"
+
+ """
+
+ __slots__ = ('c',)
+
+ @staticmethod
+ def decompose (cvsnum):
+ """Split the given CVS number into a list of int components.
+
+ Branch numbers are normalized to the odd-numbered components
+ form (i.e. removing the second last '0' component)
+
+ Examples:
+ '1.2.4.8' -> [1, 2, 4, 8]
+ '1.2.3' -> [1, 2, 3]
+ '1.2.0.5' -> [1, 2, 5]
+
+ """
+ if cvsnum:
+ r = map(int, cvsnum.split('.'))
+ else:
+ r = []
+ if len(r) >= 2 and r[-2] == 0:
+ del r[-2]
+ if r[-1] == 0:
+ raise ValueError(cvsnum)
+ return tuple(r)
+
+ @staticmethod
+ def compose (c):
+ """Join the given list of integer components into a CVS number.
+
+ E.g.: (1, 2, 4, 8) -> '1.2.4.8'
+
+ """
+ if c[-1] == 0:
+ raise ValueError(str(c))
+ return ".".join(map(str, c))
+
+ @classmethod
+ def from_components (cls, args):
+ """Create a CVSNum from the given list of numerical components."""
+ return cls(cls.compose(args))
+
+ @classmethod
+ def disjoint (cls, a, b):
+ """Return True iff the CVS numbers are historically disjoint.
+
+ Two CVS numbers are disjoint if they do not share the same
+ historical line back to the initial revision. In other words:
+ the two numbers are disjoint if the history (i.e. set of parent
+ revisions all the way back to the intial (1.1) revision) of
+ neither number is a superset of the other's history.
+ See test_disjoint() for practical examples:
+
+ """
+ if a.is_branch():
+ a = cls.from_components(a.c + (1,))
+ if b.is_branch():
+ b = cls.from_components(b.c + (1,))
+ if len(a.c) > len(b.c):
+ a, b = b, a # a is now shortest
+ pairs = zip(a.c, b.c)
+ for pa, pb in pairs[:-1]:
+ if pa != pb:
+ return True
+ if len(a) == len(b):
+ return False
+ common_len = len(a)
+ if a.c[common_len - 1] <= b.c[common_len - 1]:
+ return False
+ return True
+
+
+ def __init__ (self, cvsnum):
+ """Create a CVSNum object from the given CVS number string."""
+ self.c = self.decompose(str(cvsnum))
+
+ def __repr__ (self):
+ """Return a string representation of this object."""
+ return self.compose(self.c)
+
+ def __str__ (self):
+ """Return a string representation of this object."""
+ return repr(self)
+
+ def __hash__ (self):
+ """Create a hash value for this CVS number."""
+ return hash(repr(self))
+
+ def __len__ (self):
+ """Return number of components in this CVS number."""
+ return len(self.c)
+
+ def __cmp__ (self, other):
+ """Comparison method for CVS numbers."""
+ try:
+ return cmp(self.c, other.c)
+ except AttributeError:
+ return 1
+
+ def __getitem__ (self, key):
+ """Return the Xth component of this CVS number."""
+ return self.c[key]
+
+ def is_rev (self):
+ """Return True iff this number is a CVS revision number."""
+ return len(self.c) % 2 == 0 and len(self.c) >= 2 and self.c[-2] != 0
+
+ def is_branch (self):
+ """Return True iff this number is a CVS branch number."""
+ return len(self.c) % 2 != 0 or (len(self.c) >= 2 and self.c[-2] == 0)
+
+ def components (self):
+ """Return a list of integer components in this CVS number."""
+ return list(self.c)
+
+ def branch (self):
+ """Return the branch on which the given number lives.
+
+ Revisions: chop the last component to find the branch, e.g.:
+ 1.2.4.6 -> 1.2.4
+ 1.1 -> 1
+ Branches: unchanged
+
+ """
+ if self.is_rev():
+ return self.from_components(self.c[:-1])
+ return self
+
+ def parent (self):
+ """Return the parent/previous revision number to this number.
+
+ For revisions, this is the previous revision, e.g.:
+ 1.2.4.6 -> 1.2.4.5
+ 1.2.4.1 -> 1.2
+ 1.1 -> None
+ 2.1 -> None
+ For branches, this is the branch point, e.g.:
+ 1.2.4 -> 1.2
+ 1 -> None
+ 2 -> None
+
+ """
+ if len(self.c) < 2:
+ return None
+ elif len(self.c) % 2: # Branch number
+ return self.from_components(self.c[:-1])
+ else: # Revision number
+ assert self.c[-1] > 0
+ result = self.components()
+ result[-1] -= 1 # Decrement final component
+ if result[-1] == 0: # We're at the start of the branch
+ del result[-2:] # Make into branch point
+ if not result:
+ return None
+ return self.from_components(result)
+
+ def follows (self, other):
+ """Return True iff self historically follows the given rev.
+
+ This iterates through the parents of self, and returns True iff
+ any of them equals the given rev. Otherwise, it returns False.
+
+ """
+ assert other.is_rev()
+ cur = self
+ while cur:
+ if cur == other:
+ return True
+ cur = cur.parent()
+ return False
+
+ def on_branch (self, branch):
+ """Return True iff this rev is on the given branch.
+
+ The revs considered to be "on" a branch X also includes the
+ branch point of branch X.
+
+ """
+ return branch == self.branch() or branch.parent() == self
+
+
+class TestCVSNum(unittest.TestCase):
+
+ """CVSNum selftests."""
+
+ def test_basic (self):
+ """CVSNum basic selftests."""
+ self.assertEqual(CVSNum("1.2.4"), CVSNum("1.2.0.4"))
+ self.assert_(CVSNum("1.2.4").is_branch())
+ self.assert_(CVSNum("1.2").is_rev())
+ self.assert_(CVSNum("1").is_branch())
+ self.assert_(CVSNum("1.2.4.6").is_rev())
+ self.assertEqual(CVSNum("1.2.4.6").components(), [1, 2, 4, 6])
+ self.assertEqual(CVSNum.from_components([1, 2, 4, 6]),
+ CVSNum("1.2.4.6"))
+ self.assertEqual(str(CVSNum.from_components([1, 2, 4, 6])), "1.2.4.6")
+ self.assertEqual(len(CVSNum("1.2.4.6")), 4)
+ self.assertEqual(CVSNum("1.2.4.6").branch(), CVSNum("1.2.4"))
+ self.assertEqual(CVSNum("1.2.4").branch(), CVSNum("1.2.4"))
+ self.assertEqual(CVSNum("1.1").branch(), CVSNum("1"))
+ self.assertEqual(CVSNum("1").branch(), CVSNum("1"))
+ self.assertEqual(CVSNum("1.2.4.6").parent(), CVSNum("1.2.4.5"))
+ self.assertEqual(CVSNum("1.2.4.1").parent(), CVSNum("1.2"))
+ self.assertEqual(CVSNum("1.2").parent(), CVSNum("1.1"))
+ self.assert_(CVSNum("1.1").parent() is None)
+ self.assert_(CVSNum("2.1").parent() is None)
+ self.assertEqual(CVSNum("1.2.4").parent(), CVSNum("1.2"))
+ self.assert_(CVSNum("1").parent() is None)
+ self.assert_(CVSNum("2").parent() is None)
+
+ def test_follows (self):
+ """CVSNum.follows() selftests."""
+ self.assert_(CVSNum("1.2.4.6").follows(CVSNum("1.1")))
+ self.assert_(CVSNum("1.2.4.6").follows(CVSNum("1.2")))
+ self.assert_(CVSNum("1.2.4.6").follows(CVSNum("1.2.4.1")))
+ self.assert_(CVSNum("1.2.4.6").follows(CVSNum("1.2.4.2")))
+ self.assert_(CVSNum("1.2.4.6").follows(CVSNum("1.2.4.3")))
+ self.assert_(CVSNum("1.2.4.6").follows(CVSNum("1.2.4.4")))
+ self.assert_(CVSNum("1.2.4.6").follows(CVSNum("1.2.4.5")))
+ self.assert_(CVSNum("1.2.4.6").follows(CVSNum("1.2.4.6")))
+ self.assertFalse(CVSNum("1.2.4.6").follows(CVSNum("1.2.4.7")))
+ self.assertFalse(CVSNum("1.2.4.6").follows(CVSNum("1.3")))
+ self.assertFalse(CVSNum("1.1").follows(CVSNum("1.2.4.6")))
+
+ def test_disjoint (self):
+ """CVSNum.disjoint() selftests."""
+ tests = [
+ ("1.2", "1.1", False),
+ ("1.2", "1.2", False),
+ ("1.2", "1.3", False),
+ ("1.2", "1.1.2", True),
+ ("1.2", "1.1.2.3", True),
+ ("1.2.4", "1.1", False),
+ ("1.2.4", "1.2", False),
+ ("1.2.4", "1.3", True),
+ ("1.2.4", "1.2.2", True),
+ ("1.2.4", "1.2.4", False),
+ ("1.2.4", "1.2.6", True),
+ ("1.2.4", "1.2.2.4", True),
+ ("1.2.4", "1.2.4.4", False),
+ ("1.2.4", "1.2.6.4", True),
+ ("1.2.4.6", "1.1", False),
+ ("1.2.4.6", "1.2", False),
+ ("1.2.4.6", "1.3", True),
+ ("1.2.4.6", "1.2.2", True),
+ ("1.2.4.6", "1.2.2.1", True),
+ ("1.2.4.6", "1.2.4", False),
+ ("1.2.4.6", "1.2.4.5", False),
+ ("1.2.4.6", "1.2.4.6", False),
+ ("1.2.4.6", "1.2.4.7", False),
+ ("1.2.4.6.8.10", "1.2.4.5", False),
+ ("1.2.4.6.8.10", "1.2.4.6", False),
+ ("1.2.4.6.8.10", "1.2.4.7", True),
+ ]
+ for a, b, result in tests:
+ self.assertEqual(CVSNum.disjoint(CVSNum(a), CVSNum(b)), result)
+ self.assertEqual(CVSNum.disjoint(CVSNum(b), CVSNum(a)), result)
+
+
+class CVSState(object):
+
+ """Encapsulate a historical state in CVS (a set of paths and nums).
+
+ This class is a container of CVS pathnames and associated CVSNum
+ objects.
+
+ No communication with a CVS working directory or repository is done
+ in this class, hence only basic sanity checks are performed:
+ - A path may only appear once in a CVSState.
+ - When adding a path:num pair, path may not already exist in self
+ - When replacing a path:num pair, path must already exist in self
+ - When removing a path:num pair, both path and num must be given
+
+ IMPORTANT: Objects of this class are hash()able (to support being
+ used as keys in a dict), but they are also mutable. It is
+ therefore up to the caller to make sure that the object is not
+ changed after being stored in a data structure indexed by its hash
+ value.
+
+ """
+
+ __slots__ = ('revs', '_hash')
+
+ def __init__ (self):
+ """Create a new, empty CVSState."""
+ self.revs = {} # dict: path -> CVSNum object
+ self._hash = None
+
+ def __iter__ (self):
+ """Return iterator traversing the (path, CVSNum)s in this CVSState."""
+ return self.revs.iteritems()
+
+ def __cmp__ (self, other):
+ """Comparison method for CVSState objects."""
+ return cmp(self.revs, other.revs)
+
+ def __str__ (self):
+ """Stringify this CVSState by listing the contained revisions."""
+ return "".join(["%s:%s\n" % (p, n) for p, n in sorted(self)])
+
+ def __hash__ (self):
+ """Create a hash value for this CVSState."""
+ if self._hash is None:
+ self._hash = hash(str(self))
+ return self._hash
+
+ def __getitem__ (self, path):
+ """Return the CVSNum associated with the given path in self."""
+ return self.revs[path]
+
+ def get (self, path, default = None):
+ """Return the CVSNum associated with the given path in self."""
+ return self.revs.get(path, default)
+
+ def paths (self):
+ """Return the path names contained within this CVSState."""
+ return self.revs.iterkeys()
+
+ def add (self, path, revnum):
+ """Add the given path:revnum to this CVSState."""
+ assert path not in self.revs
+ self._hash = None
+ self.revs[path] = revnum
+
+ def replace (self, path, revnum):
+ """Replace the revnum associated with the given path."""
+ assert path in self.revs
+ self._hash = None
+ self.revs[path] = revnum
+
+ def remove (self, path, revnum):
+ """Remove the given path:revnum association from this CVSState."""
+ assert path in self.revs and self.revs[path] == revnum
+ self._hash = None
+ del self.revs[path]
+
+ def copy (self):
+ """Create and return a copy of this object."""
+ ret = CVSState()
+ ret.revs = self.revs.copy()
+ ret._hash = self._hash
+ return ret
+
+ def load_data (self, note_data):
+ """Load note data as formatted by self.__str__()."""
+ for line in note_data.split("\n"):
+ line = line.strip()
+ if not line:
+ continue
+ path, num = line.rsplit(':', 1)
+ self.add(path, CVSNum(num))
+ self._hash = hash(note_data)
+
+ def print_members (self, f = sys.stdout, prefix = ""):
+ """Write the members of this CVSState to the given file object."""
+ for path, num in sorted(self):
+ print >> f, "%s%s:%s" % (prefix, path, num)
+
+ @file_reader_method(missing_ok = True)
+ def load (self, f):
+ """Load CVS state from the given file name/object."""
+ if f:
+ self.load_data(f.read())
+
+ @file_writer_method
+ def save (self, f):
+ """Save CVS state to the given file name/object."""
+ assert f
+ print >> f, str(self),
+
+
+class CVSDate(object):
+
+ """Encapsulate a timestamp, as reported by CVS.
+
+ The internal representation of a timestamp is two integers, the
+ first representing the timestamp as #seconds since epoch (UTC),
+ and the second representing the timezone as #minutes offset from
+ UTC.
+
+ Example: "2007-09-05 17:26:28 -0200" is converted to
+ (1189013188, -120)
+
+ """
+
+ __slots__ = ('ts', 'tz')
+
+ def __init__ (self, date_str = None, in_utc = False):
+ """Convert CVS date string into a CVSDate object.
+
+ A CVS timestamp string has one of the following forms:
+ - "YYYY-MM-DD hh:mm:ss SZZZZ"
+ - "YYYY/MM/DD hh:mm:ss" (with timezone assumed to be UTC)
+ The in_utc parameter determines whether the timestamp part of
+ the given string (the "YYYY-MM-DD hh:mm:ss" part) is given in
+ local time or UTC (normally CVS dates are given in local time.
+ If given in local time, the timezone offset is subtracted from
+ the timestamp in order to make the time in UTC format.
+
+ """
+ if date_str is None:
+ self.ts, self.tz = 0, 0
+ return
+ if date_str == "now":
+ self.ts, self.tz = time.time(), 0
+ return
+ date_str = date_str.strip()
+ # Set up self.ts and self.tz
+ if date_str.count(" ") == 2:
+ # Assume format "YYYY-MM-DD hh:mm:ss SZZZZ"
+ t, z = date_str.rsplit(" ", 1)
+ # Convert timestamp to #secs since epoch (UTC)
+ self.ts = timegm(time.strptime(t, "%Y-%m-%d %H:%M:%S"))
+ # Convert timezone into #mins offset from UTC
+ self.tz = int(z[1:3]) * 60 + int(z[3:5])
+ # Incorporate timezone sign
+ if z[0] == '-':
+ self.tz *= -1
+ else:
+ assert date_str.count(" ") == 1
+ # Assume format "YYYY/MM/DD hh:mm:ss"
+ self.ts = timegm(time.strptime(date_str, "%Y/%m/%d %H:%M:%S"))
+ self.tz = 0
+ # Adjust timestamp if not already in UTC
+ if not in_utc:
+ self.ts -= self.tz * 60
+
+ def tz_str (self):
+ """Return timezone part of self in string format."""
+ sign = '+'
+ if self.tz < 0:
+ sign = '-'
+ hours, minutes = divmod(abs(self.tz), 60)
+ return "%s%02d%02d" % (sign, hours, minutes)
+
+ def __str__ (self):
+ """Reconstruct date string from members."""
+ s = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(self.ts))
+ return "%s %s" % (s, self.tz_str())
+
+ def __repr__ (self):
+ """Create a string representation of self."""
+ return "CVSDate('%s')" % (str(self))
+
+ def __hash__ (self):
+ """Create a hash value from self."""
+ return hash((self.ts, self.tz))
+
+ def __nonzero__ (self):
+ """Provide interpretation of self in a boolean context."""
+ return bool(self.ts or self.tz)
+
+ def __cmp__ (self, other):
+ """Comparison method for CVSDate objects."""
+ return cmp(self.ts, other.ts) or cmp(self.tz, other.tz)
+
+ def __eq__ (self, other):
+ """Return True iff self and other is considered equal."""
+ return self.ts == other.ts and self.tz == other.tz
+
+ def diff (self, other):
+ """Return difference between self and other in #seconds.
+
+ Invariant: self == other.add(self.diff(other))
+
+ """
+ return self.ts - other.ts
+
+
+class TestCVSDate(unittest.TestCase):
+
+ """CVSDate selftests."""
+
+ def test_basic (self):
+ """CVSDate basic selftests."""
+ a = CVSDate("2009-05-10 14:34:56 +0200")
+ b = CVSDate("2009/05/10 12:34:56")
+ self.assert_(a)
+ self.assert_(b)
+ self.assertEqual(str(a), "2009-05-10 12:34:56 +0200", str(a))
+ self.assertEqual(str(b), "2009-05-10 12:34:56 +0000", str(b))
+ self.assertNotEqual(a, b)
+ self.assertEqual(a.diff(b), 0)
+ c = CVSDate("2009-05-10 16:34:56 +0200")
+ self.assert_(c)
+ self.assertEqual(str(c), "2009-05-10 14:34:56 +0200", str(c))
+ self.assertNotEqual(c, a)
+ self.assertEqual(c.diff(a), 2 * 60 * 60)
+ self.assertEqual(a.diff(c), -2 * 60 * 60)
+
+
+class CVSRev(object):
+
+ """Encapsulate metadata on a CVS revision."""
+
+ __slots__ = ('path', 'num', 'date', 'author', 'deleted', 'message')
+
+ def __init__ (self, path, num):
+ """Create a CVSRev object for the given path:num revision."""
+ self.path = path
+ self.num = num
+ self.date = None # CVSDate object
+ self.author = ""
+ self.deleted = None # True or False
+ self.message = [] # Lines of commit message
+
+ def __str__ (self):
+ """Return a string listing the metadata in this CVS revision."""
+ return ("<%s:%s on %s by %s%s>" %
+ (self.path, self.num, self.date, self.author,
+ self.deleted and ", deleted" or ""))
+
+ def __cmp__ (self, other):
+ """Comparison method for CVSRev objects."""
+ return cmp(self.path, other.path) or cmp(self.num, other.num)
+
+
+class CVSWorkDir(object):
+
+ """Encapsulate a CVS working directory.
+
+ This class auto-creates a CVS workdir/checkout in the directory
+ given to the constructor, and provides various methods for
+ interacting with this workdir.
+
+ """
+
+ def __init__ (self, workdir, cvs_repo):
+ """Create a new CVSWorkDir.
+
+ The cvs_repo argument must be a (cvs_root, cvs_module) tuple
+
+ """
+ self.d = workdir
+ self.cvs_root, self.cvs_module = cvs_repo
+ parent_dir = os.path.dirname(self.d)
+ if not os.path.isdir(parent_dir):
+ os.makedirs(parent_dir)
+ self._valid = None
+
+ def makepath(self, *args):
+ """Create path relative to working directory."""
+ return os.path.join(self.d, *args)
+
+ def valid (self):
+ """Return True iff this workdir is present and valid."""
+ if self._valid is not None:
+ return self._valid
+ try:
+ f = open(self.makepath("CVS", "Root"), 'r')
+ assert f.read().strip() == self.cvs_root
+ f.close()
+ f = open(self.makepath("CVS", "Repository"), 'r')
+ assert f.read().strip() == self.cvs_module
+ f.close()
+ self._valid = True
+ except (IOError, AssertionError):
+ self._valid = False
+ return self._valid
+
+ def remove (self):
+ """Remove this checkout."""
+ shutil.rmtree(self.d, True)
+ assert not os.path.exists(self.d)
+ self._valid = False
+
+ def checkout (self, revision = "HEAD"):
+ """Create a checkout of the given revision."""
+ self.remove()
+ parent_dir, co_dir = os.path.split(self.d)
+ args = ["cvs", "-f", "-Q", "-d", self.cvs_root, "checkout"]
+ if str(revision) != "HEAD":
+ args.extend(["-r", str(revision)])
+ args.extend(["-d", co_dir, self.cvs_module])
+ exit_code, output, errors = run_command(args, cwd = parent_dir)
+ if exit_code:
+ die("Failed to checkout CVS working directory")
+ assert not errors
+ assert not output, "output = '%s'" % (output)
+ self._valid = None
+ assert self.valid()
+
+ def update (self, revision = "HEAD", paths = None):
+ """Update the given paths to the given revision."""
+ if not self.valid():
+ self.checkout()
+ args = ["cvs", "-f", "-Q", "update", "-kk"]
+ if str(revision) == "HEAD":
+ args.append("-A")
+ else:
+ args.extend(["-r", str(revision)])
+ if paths is not None:
+ args.extend(paths)
+ exit_code, output, errors = run_command(args, cwd = self.d)
+ if exit_code:
+ die("Failed to checkout CVS working directory")
+ assert not errors
+ assert not output, "output = '%s'" % (output)
+
+ def get_revision_data (self, path, revision):
+ """Return the contents of the given CVS path:revision."""
+ if not self.valid():
+ self.checkout()
+ args = ["cvs", "-f", "-Q", "update", "-p", "-kk"]
+ if str(revision) == "HEAD":
+ args.append("-A")
+ else:
+ args.extend(["-r", str(revision)])
+ args.append(path)
+ exit_code, output, errors = run_command(args, cwd = self.d)
+ if exit_code:
+ die("Failed to checkout CVS working directory")
+ assert not errors
+ return output
+
+ def get_modeinfo (self, paths = None):
+ """Return mode information for the given paths.
+
+ Returns a dict of path -> mode number mappings. If paths are
+ not specified, mode information for all files in the current
+ checkout will be returned. No checkout/update will be done.
+
+ """
+ result = {}
+ if paths is not None:
+ for path in paths:
+ fullpath = os.path.join(self.d, path)
+ mode = 644
+ if os.access(fullpath, os.X_OK):
+ mode = 755
+ assert path not in result
+ result[path] = mode
+ else: # Return mode information for all paths
+ for dirpath, dirnames, filenames in os.walk(self.d):
+ # Don't descend into CVS subdirs
+ try:
+ dirnames.remove('CVS')
+ except ValueError:
+ pass
+ assert dirpath.startswith(self.d)
+ directory = dirpath[len(self.d):].lstrip("/")
+ for fname in filenames:
+ path = os.path.join(directory, fname)
+ fullpath = os.path.join(dirpath, fname)
+ mode = 644
+ if os.access(fullpath, os.X_OK):
+ mode = 755
+ assert path not in result
+ result[path] = mode
+ return result
+
+ @classmethod
+ def parse_entries (cls, entries, prefix, directory = ""):
+ """Recursively parse CVS/Entries files.
+
+ Return a dict of CVS paths found by parsing the CVS/Entries
+ files rooted at the given directory.
+
+ See http://ximbiot.com/cvs/manual/feature/cvs_2.html#SEC19 for
+ information on the format of the CVS/Entries file.
+
+ """
+ fname = os.path.join(prefix, directory, "CVS", "Entries")
+ subdirs = []
+ f = open(fname, 'r')
+ for line in f:
+ line = line.strip()
+ if line == "D":
+ continue # There are no subdirectories
+ t, path, revnum, date, options, tag = line.split("/")
+ if t == "D":
+ subdirs.append(path)
+ continue
+ assert line.startswith("/")
+ path = os.path.join(directory, path)
+ revnum = CVSNum(revnum)
+ assert path not in entries
+ entries[path] = (revnum, date, options, tag)
+ f.close()
+ for d in subdirs:
+ d = os.path.join(directory, d)
+ cls.parse_entries(entries, prefix, d)
+
+ def get_state (self):
+ """Return CVSState reflecting current state of this checkout.
+
+ Note that the resulting CVSState will never contain any
+ deleted/dead files. Other CVSStates to be compared to the one
+ returned from here should remove deleted/dead entries first.
+
+ """
+ assert self.valid()
+ entries = {}
+ result = CVSState()
+ self.parse_entries(entries, self.d)
+ for path, info in entries.iteritems():
+ result.add(path, info[0])
+ return result
+
+
+class CVSLogParser(object):
+
+ """Encapsulate the execution of a "cvs rlog" command."""
+
+ def __init__ (self, cvs_repo):
+ """Create a new CVSLogParser.
+
+ The cvs_repo argument must be a (cvs_root, cvs_module) tuple
+
+ """
+ self.cvs_root, self.cvs_module = cvs_repo
+
+ def cleanup_path (self, cvs_path):
+ """Utility method for parsing CVS paths from CVS log."""
+ cvsprefix = "/".join((self.cvs_root[self.cvs_root.index("/"):],
+ self.cvs_module))
+ assert cvs_path.startswith(cvsprefix)
+ assert cvs_path.endswith(",v")
+ # Drop cvsprefix and ,v-extension
+ cvs_path = cvs_path[len(cvsprefix):-2]
+ # Split the remaining path into components
+ path_comps = filter(None, cvs_path.strip().split('/'))
+ # Remove 'Attic' from CVS paths
+ if len(path_comps) >= 2 and path_comps[-2] == "Attic":
+ del path_comps[-2]
+ # Reconstruct resulting "cleaned" path
+ return "/".join(path_comps)
+
+ def __call__ (self, line):
+ """Parse the given line from the CVS log.
+
+ Must be reimplemented by subclass
+
+ """
+ pass
+
+ def finish (self):
+ """This method is invoked after the last line has been parsed.
+
+ May be reimplemented by subclass
+
+ """
+ pass
+
+ def run (self, paths = None, no_symbols = False, revisions = None):
+ """Execute "cvs rlog" with the given arguments.
+
+ self.__call__() is invoked once for each line in the CVS log.
+ self.finish() is invoked exactly once after the CVS log.
+
+ """
+ args = ["cvs", "-f", "-q", "-d", self.cvs_root, "rlog"]
+ if no_symbols:
+ args.append("-N")
+ if revisions:
+ args.append("-r%s" % (revisions))
+ if paths is not None:
+ for p in paths:
+ args.append("%s/%s" % (self.cvs_module, p))
+ else:
+ args.append(self.cvs_module)
+ proc = start_command(args)
+ proc.stdin.close()
+ while True:
+ for line in proc.stdout:
+ self(line.rstrip()) # Call self's line parser
+ if proc.poll() is not None:
+ break
+ assert proc.stdout.read() == ""
+ self.finish() # Notify subclass that parsing is finished
+ exit_code = proc.returncode
+ if exit_code:
+ error("'%s' returned exit code %i, and errors:\n---\n%s---",
+ " ".join(args), exit_code, proc.stderr.read())
+ return exit_code
+
+
+class CVSRevLister(CVSLogParser):
+
+ """Extract CVSRev objects (with revision metadata) from a CVS log."""
+
+ def __init__ (self, cvs_repo, show_progress = False):
+ """Create a new CVSRevLister.
+
+ The cvs_repo argument must be a (cvs_root, cvs_module) tuple
+ show_progress determines whether progress indication is shown.
+
+ """
+ super(CVSRevLister, self).__init__(cvs_repo)
+ self.cur_file = None # Current CVS file being processed
+ self.cur_file_numrevs = 0 # #revs in current CVS file
+ self.cur_rev = None # Current CVSRev under construction
+ self.progress = None
+ if show_progress:
+ self.progress = ProgressIndicator("\t", sys.stderr)
+ # Store found revs in a two-level dict structure:
+ # filename -> revnum -> CVSRev
+ self.revs = {}
+ # Possible states:
+ # - BeforeRevs - waiting for "total revisions:"
+ # - BetweenRevs - waiting for "----------------------------"
+ # - ReadingRev - reading CVS revision details
+ self.state = 'BeforeRevs'
+
+ def __call__ (self, line):
+ """Line parser; this method is invoked for each line in the log."""
+ if self.state == 'BeforeRevs':
+ if line.startswith("RCS file: "):
+ self.cur_file = self.cleanup_path(line[10:])
+ assert self.cur_file not in self.revs
+ self.revs[self.cur_file] = {}
+ elif line.startswith("total revisions: "):
+ assert self.cur_file
+ totalrevs_unused, selectedrevs = line.split(";")
+ self.cur_file_numrevs = int(selectedrevs.split(":")[1].strip())
+ self.state = 'BetweenRevs'
+ elif self.state == 'BetweenRevs':
+ if (line == "----------------------------" or
+ line == "======================================"
+ "======================================="):
+ if self.cur_rev:
+ # Finished current revision
+ f = self.revs[self.cur_file]
+ assert self.cur_rev.num not in f
+ f[self.cur_rev.num] = self.cur_rev
+ self.cur_rev = None
+ if self.progress:
+ self.progress()
+ if line == "----------------------------":
+ self.state = 'ReadingRev'
+ else:
+ # Finalize current CVS file
+ assert len(self.revs[self.cur_file]) == \
+ self.cur_file_numrevs
+ self.cur_file = None
+ self.state = 'BeforeRevs'
+ elif self.cur_rev:
+ # Currently in the middle of a revision.
+ if line.startswith("branches: %s" % (self.cur_rev.num)) and \
+ line.endswith(";"):
+ return # Skip 'branches:' lines
+ # This line is part of the commit message.
+ self.cur_rev.message.append(line)
+ elif self.state == 'ReadingRev':
+ if line.startswith("revision "):
+ self.cur_rev = CVSRev(self.cur_file, CVSNum(line.split()[1]))
+ else:
+ date, author, state, dummy = line.split(";", 3)
+ assert date.startswith("date: ")
+ self.cur_rev.date = CVSDate(date[6:])
+ assert author.strip().startswith("author: ")
+ self.cur_rev.author = author.strip()[8:]
+ assert state.strip().startswith("state: ")
+ state = state.strip()[7:]
+ self.cur_rev.deleted = state == "dead"
+ self.state = 'BetweenRevs'
+
+ def finish (self):
+ """This method is invoked after the last line has been parsed."""
+ assert self.state == 'BeforeRevs'
+ if self.progress:
+ self.progress.finish("Parsed %i revs in %i files" %
+ (self.progress.n, len(self.revs)))
+
+
+def fetch_revs (path, from_rev, to_rev, symbol, cvs_repo):
+ """Fetch CVSRevs for each rev in <path:from_rev, path:symbol].
+
+ Return a dict of CVSRev objects (revnum -> CVSRev), where each
+ CVSRev encapsulates a CVS revision in the range from
+ path:from_rev to path:symbol (inclusive). If symbol currently
+ refers to from_rev (i.e. nothing has happened since the last
+ import), the returned dict will have exactly one entry (from_rev).
+ If there is no valid revision range between from_rev and symbol,
+ the returned dict will be empty. Situations in which an empty dict
+ is returned, include:
+ - symbol is no longer defined on this path
+ - symbol refers to a revision that is disjoint from from_rev
+
+ from_rev may be None, meaning that all revisions from the initial
+ version of path up to the revision currently referenced by symbol
+ should be fetched.
+
+ If the revision currently referenced by symbol is disjoint from
+ from_rev, the returned dict will be empty.
+
+ Note that there is lots of unexpected behaviour in the handling of
+ the 'cvs rlog -r' parameter: Say you have a branch, called
+ 'my_branch', that points to branch number 1.1.2 of a file. Say
+ there are 3 revisions on this branch: 1.1.2.1 -> 1.1.2.3 (in
+ additions to the branch point 1.1). Now, observe the following
+ 'cvs rlog' executions:
+ - cvs rlog -r0:my_branch ... returns 1.1, 1.1.2.1, 1.1.2.2, 1.1.2.3
+ - cvs rlog -r1.1:my_branch ... returns the same revs
+ - cvs rlog -rmy_branch ... returns 1.1.2.1, 1.1.2.2, 1.1.2.3
+ - cvs rlog -rmy_branch: ... returns the same revs
+ - cvs rlog -r:my_branch ... returns the same revs
+ - cvs rlog -r::my_branch ... returns the same revs
+ - cvs rlog -r1.1.2.1: ... returns the same revs
+ Here is where it gets really weird:
+ - cvs rlog -r1.1.2.1:my_branch ... returns 1.1.2.1 only
+ - cvs rlog -r1.1.2.2:my_branch ... returns 1.1.2.1, 1.1.2.2
+ - cvs rlog -r1.1.2.3:my_branch ... returns 1.1.2.1, 1.1.2.2, 1.1.2.3
+
+ In other words the 'cvs rlog -rfrom_rev:symbol' scheme that we
+ normally use will not work in the case where from_rev is _on_ the
+ branch pointed at by the symbol.
+
+ Therefore, we need an extra parameter, to_rev, which we can use to:
+ 1. Detect when this situation is present.
+ 2. Work around by using 'cvs rlog -rfrom_ref:to_rev' instead.
+
+ """
+ if from_rev is None: # Initial import
+ from_rev = "0" # "cvs rlog -r0:X" fetches from initial revision
+ elif to_rev and to_rev.branch() == from_rev.branch():
+ symbol = to_rev # Use to_rev instead of given symbol
+ # Run 'cvs rlog' on range [from_rev, symbol] and parse CVSRev objects
+ parser = CVSRevLister(cvs_repo)
+ parser.run((path,), True, "%s:%s" % (from_rev, symbol))
+ assert len(parser.revs) == 1
+ assert path in parser.revs
+ return parser.revs[path]
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/git_remote_cvs/cvs_symbol_cache.py b/git_remote_cvs/cvs_symbol_cache.py
new file mode 100644
index 0000000..cc8d88b
--- /dev/null
+++ b/git_remote_cvs/cvs_symbol_cache.py
@@ -0,0 +1,313 @@
+#!/usr/bin/env python
+
+"""Implementation of a local CVS symbol cache.
+
+A CVS symbol cache stores a list of CVS symbols and the CVS state
+associated with each of those CVS symbols at some point in time.
+
+Keeping a local cache of CVS symbols is often needed because the
+design of CVS makes it potentially very expensive to query the CVS
+server directly for CVS symbols and associated states.
+
+In these cases, a local CVS symbol cache can provide equivalent
+(although possibly out-of-date) information immediatele.
+
+Synchronization with the current state on the CVS server can be
+done on a symbol-by-symbol basis (by checking out a given symbol
+and extracting the CVS state from the CVS work tree), or by
+synchronizing _all_ CVS symbols in one operation (by executing
+'cvs rlog' and parsing CVS states from its output).
+
+"""
+
+import sys
+import os
+
+from git_remote_cvs.util import debug, error, die, ProgressIndicator
+from git_remote_cvs.cvs import CVSNum, CVSState, CVSLogParser
+
+
+class CVSSymbolStateLister(CVSLogParser):
+
+ """Extract current CVSStates for all CVS symbols from a CVS log."""
+
+ def __init__ (self, cvs_repo, show_progress = False):
+ """Create a new CVSSymbolStateLister.
+
+ The cvs_repo argument must be a (cvs_root, cvs_module) tuple
+ show_progress determines whether a progress indicator should
+ be displayed.
+
+ """
+ super(CVSSymbolStateLister, self).__init__(cvs_repo)
+ self.symbols = {} # CVS symbol name -> CVSState object
+ self.cur_file = None # current CVS file being processed
+ self.cur_file_numrevs = 0 # #revs in current CVS file
+ self.cur_revnum = None # current revision number
+ self.rev2syms = {} # CVSNum -> [CVS symbol names]
+ self.cur_revs = {} # CVSNum -> True/False (deleted)
+ self.head_num = None # CVSNum of the HEAD rev or branch
+
+ # Possible states:
+ # - BeforeSymbols - waiting for "symbolic names:"
+ # - WithinSymbols - reading CVS symbol names
+ # - BeforeRevs - waiting for "total revisions:"
+ # - BetweenRevs - waiting for "----------------------------"
+ # - ReadingRev - reading CVS revision details
+ self.state = 'BeforeSymbols'
+
+ self.progress = None
+ if show_progress:
+ self.progress = ProgressIndicator("\t", sys.stderr)
+
+ def finalize_symbol_states (self):
+ """Adjust CVSStates in self.symbols based on revision data.
+
+ Based on the information found in self.rev2syms and
+ self.cur_revs, remove deleted revisions and turn branch numbers
+ into corresponding revisions in the CVSStates found in
+ self.symbols.
+
+ """
+ # Create a mapping from branch numbers to the last existing
+ # revision number on those branches
+ branch2lastrev = {} # branch number -> revision number
+ for revnum in self.cur_revs.iterkeys():
+ branchnum = revnum.branch()
+ if (branchnum not in branch2lastrev) or \
+ (revnum > branch2lastrev[branchnum]):
+ branch2lastrev[branchnum] = revnum
+
+ for cvsnum, symbols in self.rev2syms.iteritems():
+ if cvsnum.is_branch():
+ # Turn into corresponding revision number
+ revnum = branch2lastrev.get(cvsnum, cvsnum.parent())
+ for s in symbols:
+ state = self.symbols[s]
+ assert state[self.cur_file] == cvsnum
+ state.replace(self.cur_file, revnum)
+ cvsnum = revnum
+ assert cvsnum.is_rev()
+ assert cvsnum in self.cur_revs
+ if self.cur_revs[cvsnum]: # cvsnum is a deleted rev
+ # Remove from CVSStates
+ for s in symbols:
+ state = self.symbols[s]
+ state.remove(self.cur_file, cvsnum)
+
+ self.rev2syms = {}
+ self.cur_revs = {}
+ self.cur_file = None
+
+ def __call__ (self, line):
+ """Line parser; this method is invoked for each line in the log."""
+ if self.state == 'BeforeSymbols':
+ if line.startswith("RCS file: "):
+ self.cur_file = self.cleanup_path(line[10:])
+ if self.progress:
+ self.progress("%5i symbols found - Parsing CVS file #%i: "
+ "%s " % (len(self.symbols), self.progress.n,
+ self.cur_file,))
+ if line.startswith("head: "):
+ self.head_num = CVSNum(line[6:])
+ if line.startswith("branch: "):
+ self.head_num = CVSNum(line[8:])
+ elif line == "symbolic names:":
+ assert self.head_num
+ s = self.symbols.setdefault("HEAD", CVSState())
+ s.add(self.cur_file, self.head_num)
+ r = self.rev2syms.setdefault(self.head_num, [])
+ r.append("HEAD")
+ self.head_num = None
+ self.state = 'WithinSymbols'
+ elif self.state == 'WithinSymbols':
+ if line.startswith("\t"):
+ symbol, cvsnum = line.split(":", 1)
+ symbol = symbol.strip()
+ cvsnum = CVSNum(cvsnum)
+ s = self.symbols.setdefault(symbol, CVSState())
+ s.add(self.cur_file, cvsnum)
+ r = self.rev2syms.setdefault(cvsnum, [])
+ r.append(symbol)
+ else:
+ self.state = 'BeforeRevs'
+ elif self.state == 'BeforeRevs':
+ if line.startswith("total revisions: "):
+ assert self.cur_file
+ totalrevs_unused, selectedrevs = line.split(";")
+ self.cur_file_numrevs = int(selectedrevs.split(":")[1].strip())
+ self.state = 'BetweenRevs'
+ elif self.state == 'BetweenRevs':
+ if (line == "----------------------------" or
+ line == "======================================"
+ "======================================="):
+ if self.cur_revnum:
+ assert self.cur_revnum in self.cur_revs
+ self.cur_revnum = None
+ if line == "----------------------------":
+ self.state = 'ReadingRev'
+ else:
+ # Finalize current CVS file
+ assert len(self.cur_revs) == self.cur_file_numrevs
+ self.finalize_symbol_states()
+ self.state = 'BeforeSymbols'
+ elif self.state == 'ReadingRev':
+ if line.startswith("revision "):
+ self.cur_revnum = CVSNum(line.split()[1])
+ else:
+ date, author, state, dummy = line.split(";", 3)
+ assert date.startswith("date: ")
+ assert author.strip().startswith("author: ")
+ assert state.strip().startswith("state: ")
+ state = state.strip()[7:]
+ assert self.cur_revnum not in self.cur_revs
+ deleted = state == "dead"
+ self.cur_revs[self.cur_revnum] = deleted
+ self.state = 'BetweenRevs'
+
+ def finish (self):
+ """This method is invoked after the last line has been parsed."""
+ assert self.state == 'BeforeSymbols'
+ if self.progress:
+ self.progress.finish("Parsed %i symbols in %i files" %
+ (len(self.symbols), self.progress.n))
+
+
+class CVSSymbolCache(object):
+
+ """Local cache of the current CVSState of CVS symbols.
+
+ Simulates a dictionary of CVS symbol -> CVSState mappings.
+
+ """
+
+ def __init__ (self, symbols_dir):
+ """Create a new CVS symbol cache, located in the given directory."""
+ self.symbols_dir = symbols_dir
+ if not os.path.isdir(self.symbols_dir):
+ os.makedirs(self.symbols_dir)
+
+ def __len__ (self):
+ """Return the number of CVS symbols stored in this cache."""
+ return len(os.listdir(self.symbols_dir))
+
+ def __iter__ (self):
+ """Return an iterator traversing symbol names stored in this cache."""
+ for filename in os.listdir(self.symbols_dir):
+ yield filename
+
+ def __contains__ (self, symbol):
+ """Return True if the given symbol is present in this cache."""
+ return os.access(os.path.join(self.symbols_dir, symbol),
+ os.F_OK | os.R_OK)
+
+ def __getitem__ (self, symbol):
+ """Return the cached CVSState of the given CVS symbol."""
+ try:
+ f = open(os.path.join(self.symbols_dir, symbol), 'r')
+ except IOError:
+ raise KeyError("'%s'" % (symbol))
+ ret = CVSState()
+ ret.load(f)
+ f.close()
+ return ret
+
+ def __setitem__ (self, symbol, cvs_state):
+ """Store the given CVS symbol and CVSState into the cache."""
+ cvs_state.save(os.path.join(self.symbols_dir, symbol))
+
+ def __delitem__ (self, symbol):
+ """Remove the the given CVS symbol from the cache."""
+ os.remove(os.path.join(self.symbols_dir, symbol))
+
+ def get (self, symbol, default = None):
+ """Return the cached CVSState of the given CVS symbol."""
+ try:
+ return self[symbol]
+ except KeyError:
+ return default
+
+ def items (self):
+ """Return list of (CVS symbol, CVSState) tuples saved in this cache."""
+ for filename in self:
+ yield (filename, self[filename])
+
+ def clear (self):
+ """Remove all entries from this CVS symbol cache."""
+ for filename in os.listdir(self.symbols_dir):
+ os.remove(os.path.join(self.symbols_dir, filename))
+
+ def sync_symbol (self, symbol, cvs, progress):
+ """Synchronize the given CVS symbol with the CVS server.
+
+ The given CVS workdir is used for the synchronization.
+ The retrieved CVSState is also returned
+
+ """
+ progress("Retrieving state of CVS symbol '%s'..." % (symbol))
+ cvs.update(symbol)
+ state = cvs.get_state()
+
+ progress("Saving state of '%s' to symbol cache..." % (symbol))
+ self[symbol] = state
+
+ def sync_all_symbols (self, cvs_repo, progress, symbol_filter = None):
+ """Synchronize this entire CVS symbol cache with the CVS server.
+
+ This may be very expensive if the CVS repository is large, or
+ has many symbols. After this method returns, the symbol cache
+ will be in sync with the current state on the server.
+
+ This method returns a dict with the keys 'unchanged',
+ 'changed', 'added', and 'deleted', where each map to a list of
+ CVS symbols. Each CVS symbol appears in exactly one of these
+ lists.
+
+ If symbol_filter is given, it specifies functions that takes
+ one parameter - a CVS symbol name - and returns True if that
+ symbol should be synchronized, and False if that symbol should
+ be skipped. Otherwise all CVS symbols are synchronized.
+
+ """
+ if symbol_filter is None:
+ symbol_filter = lambda symbol: True
+
+ # Run cvs rlog to fetch current CVSState for all CVS symbols
+ progress("Retrieving current state of all CVS symbols from CVS "
+ "server...", lf = True)
+ parser = CVSSymbolStateLister(cvs_repo, True)
+ retcode = parser.run()
+ if retcode:
+ raise EnvironmentError(retcode, "cvs rlog exit code %i" % retcode)
+
+ # Update symbol cache with new states from the CVS server
+ progress("Updating symbol cache with current CVS state...")
+ results = {}
+ result_keys = ("unchanged", "changed", "added", "deleted")
+ for k in result_keys:
+ results[k] = []
+ # Classify existing symbols as unchanged, changed, or deleted
+ for symbol in filter(symbol_filter, self):
+ if symbol not in parser.symbols: # Deleted
+ results["deleted"].append(symbol)
+ del self[symbol]
+ elif self[symbol] != parser.symbols[symbol]: # Changed
+ results["changed"].append(symbol)
+ self[symbol] = parser.symbols[symbol]
+ else: # Unchanged
+ results["unchanged"].append(symbol)
+ progress()
+ # Add symbols that are not in self
+ for symbol, state in parser.symbols.iteritems():
+ if not symbol_filter(symbol):
+ debug("Skipping CVS symbol '%s'...", symbol)
+ elif symbol in self:
+ assert state == self[symbol]
+ else: # Added
+ results["added"].append(symbol)
+ self[symbol] = state
+ progress()
+ progress("Synchronized local symbol cache (%s)" %
+ (", ".join(["%i %s" % (len(results[k]), k)
+ for k in result_keys])), True)
+ return results
diff --git a/git_remote_cvs/util.py b/git_remote_cvs/util.py
new file mode 100644
index 0000000..7d6adb4
--- /dev/null
+++ b/git_remote_cvs/util.py
@@ -0,0 +1,186 @@
+#!/usr/bin/env python
+
+"""Misc. useful functionality used by the rest of this package.
+
+This module provides common functionality used by the other modules in
+this package.
+
+"""
+
+import sys
+import os
+import subprocess
+
+
+# Whether or not to show debug messages
+DEBUG = False
+
+def debug (msg, *args):
+ """Print a debug message to stderr when DEBUG is enabled."""
+ if DEBUG:
+ print >> sys.stderr, msg % args
+
+def error (msg, *args):
+ """Print an error message to stderr."""
+ print >> sys.stderr, "ERROR:", msg % args
+
+def die (msg, *args):
+ """Print as error message to stderr and exit the program."""
+ error(msg, *args)
+ sys.exit(1)
+
+
+class ProgressIndicator(object):
+
+ """Simple progress indicator.
+
+ Displayed as a spinning character by default, but can be customized
+ by passing custom messages that overrides the spinning character.
+
+ """
+
+ States = ("|", "/", "-", "\\")
+
+ def __init__ (self, prefix = "", f = sys.stdout):
+ """Create a new ProgressIndicator, bound to the given file object."""
+ self.n = 0 # Simple progress counter
+ self.f = f # Progress is written to this file object
+ self.prev_len = 0 # Length of previous msg (to be overwritten)
+ self.prefix = prefix # Prefix prepended to each progress message
+ self.prefix_lens = [] # Stack of prefix string lengths
+
+ def pushprefix (self, prefix):
+ """Append the given prefix onto the prefix stack."""
+ self.prefix_lens.append(len(self.prefix))
+ self.prefix += prefix
+
+ def popprefix (self):
+ """Remove the last prefix from the prefix stack."""
+ prev_len = self.prefix_lens.pop()
+ self.prefix = self.prefix[:prev_len]
+
+ def __call__ (self, msg = None, lf = False):
+ """Indicate progress, possibly with a custom message."""
+ if msg is None:
+ msg = self.States[self.n % len(self.States)]
+ msg = self.prefix + msg
+ print >> self.f, "\r%-*s" % (self.prev_len, msg),
+ self.prev_len = len(msg.expandtabs())
+ if lf:
+ print >> self.f
+ self.prev_len = 0
+ self.n += 1
+
+ def finish (self, msg = "done", noprefix = False):
+ """Finalize progress indication with the given message."""
+ if noprefix:
+ self.prefix = ""
+ self(msg, True)
+
+
+def start_command (args, cwd = None, shell = False, add_env = None,
+ stdin = subprocess.PIPE, stdout = subprocess.PIPE,
+ stderr = subprocess.PIPE):
+ """Start the given command, and return a subprocess object.
+
+ This provides a simpler interface to the subprocess module.
+
+ """
+ env = None
+ if add_env is not None:
+ env = os.environ.copy()
+ env.update(add_env)
+ return subprocess.Popen(args, bufsize = 1, stdin = stdin, stdout = stdout,
+ stderr = stderr, cwd = cwd, shell = shell,
+ env = env, universal_newlines = True)
+
+
+def run_command (args, cwd = None, shell = False, add_env = None,
+ flag_error = True):
+ """Run the given command to completion, and return its results.
+
+ This provides a simpler interface to the subprocess module.
+
+ The results are formatted as a 3-tuple: (exit_code, output, errors)
+
+ If flag_error is enabled, Error messages will be produced if the
+ subprocess terminated with a non-zero exit code and/or stderr
+ output.
+
+ The other arguments are passed on to start_command().
+
+ """
+ process = start_command(args, cwd, shell, add_env)
+ (output, errors) = process.communicate()
+ exit_code = process.returncode
+ if flag_error and errors:
+ error("'%s' returned errors:\n---\n%s---", " ".join(args), errors)
+ if flag_error and exit_code:
+ error("'%s' returned exit code %i", " ".join(args), exit_code)
+ return (exit_code, output, errors)
+
+
+def file_reader_method (missing_ok = False):
+ """Decorator for simplifying reading of files.
+
+ If missing_ok is True, a failure to open a file for reading will
+ not raise the usual IOError, but instead the wrapped method will be
+ called with f == None. The method must in this case properly
+ handle f == None.
+
+ """
+ def _wrap (method):
+ """Teach given method to handle both filenames and file objects.
+
+ The given method must take a file object as its second argument
+ (the first argument being 'self', of course). This decorator
+ will take a filename given as the second argument and promote
+ it to a file object.
+
+ """
+ def _wrapped_method (self, filename, *args, **kwargs):
+ if isinstance(filename, file):
+ f = filename
+ else:
+ try:
+ f = open(filename, 'r')
+ except IOError:
+ if missing_ok:
+ f = None
+ else:
+ raise
+ try:
+ return method(self, f, *args, **kwargs)
+ finally:
+ if not isinstance(filename, file) and f:
+ f.close()
+ return _wrapped_method
+ return _wrap
+
+
+def file_writer_method (method):
+ """Decorator for simplifying writing of files.
+
+ Enables the given method to handle both filenames and file objects.
+
+ The given method must take a file object as its second argument
+ (the first argument being 'self', of course). This decorator will
+ take a filename given as the second argument and promote it to a
+ file object.
+
+ """
+ def _new_method (self, filename, *args, **kwargs):
+ if isinstance(filename, file):
+ f = filename
+ else:
+ # Make sure the containing directory exists
+ parent_dir = os.path.dirname(filename)
+ if not os.path.isdir(parent_dir):
+ os.makedirs(parent_dir)
+ f = open(filename, 'w')
+ try:
+ return method(self, f, *args, **kwargs)
+ finally:
+ if not isinstance(filename, file):
+ f.close()
+ return _new_method
--
1.6.4.262.gca66a.dirty
--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html