| """Utilities for CVS administration.""" | |
| import string | |
| import os | |
| import time | |
| import md5 | |
| import fnmatch | |
| if not hasattr(time, 'timezone'): | |
| time.timezone = 0 | |
| class File: | |
| """Represent a file's status. | |
| Instance variables: | |
| file -- the filename (no slashes), None if uninitialized | |
| lseen -- true if the data for the local file is up to date | |
| eseen -- true if the data from the CVS/Entries entry is up to date | |
| (this implies that the entry must be written back) | |
| rseen -- true if the data for the remote file is up to date | |
| proxy -- RCSProxy instance used to contact the server, or None | |
| Note that lseen and rseen don't necessary mean that a local | |
| or remote file *exists* -- they indicate that we've checked it. | |
| However, eseen means that this instance corresponds to an | |
| entry in the CVS/Entries file. | |
| If lseen is true: | |
| lsum -- checksum of the local file, None if no local file | |
| lctime -- ctime of the local file, None if no local file | |
| lmtime -- mtime of the local file, None if no local file | |
| If eseen is true: | |
| erev -- revision, None if this is a no revision (not '0') | |
| enew -- true if this is an uncommitted added file | |
| edeleted -- true if this is an uncommitted removed file | |
| ectime -- ctime of last local file corresponding to erev | |
| emtime -- mtime of last local file corresponding to erev | |
| extra -- 5th string from CVS/Entries file | |
| If rseen is true: | |
| rrev -- revision of head, None if non-existent | |
| rsum -- checksum of that revision, Non if non-existent | |
| If eseen and rseen are both true: | |
| esum -- checksum of revision erev, None if no revision | |
| Note | |
| """ | |
| def __init__(self, file = None): | |
| if file and '/' in file: | |
| raise ValueError, "no slash allowed in file" | |
| self.file = file | |
| self.lseen = self.eseen = self.rseen = 0 | |
| self.proxy = None | |
| def __cmp__(self, other): | |
| return cmp(self.file, other.file) | |
| def getlocal(self): | |
| try: | |
| self.lmtime, self.lctime = os.stat(self.file)[-2:] | |
| except os.error: | |
| self.lmtime = self.lctime = self.lsum = None | |
| else: | |
| self.lsum = md5.new(open(self.file).read()).digest() | |
| self.lseen = 1 | |
| def getentry(self, line): | |
| words = string.splitfields(line, '/') | |
| if self.file and words[1] != self.file: | |
| raise ValueError, "file name mismatch" | |
| self.file = words[1] | |
| self.erev = words[2] | |
| self.edeleted = 0 | |
| self.enew = 0 | |
| self.ectime = self.emtime = None | |
| if self.erev[:1] == '-': | |
| self.edeleted = 1 | |
| self.erev = self.erev[1:] | |
| if self.erev == '0': | |
| self.erev = None | |
| self.enew = 1 | |
| else: | |
| dates = words[3] | |
| self.ectime = unctime(dates[:24]) | |
| self.emtime = unctime(dates[25:]) | |
| self.extra = words[4] | |
| if self.rseen: | |
| self.getesum() | |
| self.eseen = 1 | |
| def getremote(self, proxy = None): | |
| if proxy: | |
| self.proxy = proxy | |
| try: | |
| self.rrev = self.proxy.head(self.file) | |
| except (os.error, IOError): | |
| self.rrev = None | |
| if self.rrev: | |
| self.rsum = self.proxy.sum(self.file) | |
| else: | |
| self.rsum = None | |
| if self.eseen: | |
| self.getesum() | |
| self.rseen = 1 | |
| def getesum(self): | |
| if self.erev == self.rrev: | |
| self.esum = self.rsum | |
| elif self.erev: | |
| name = (self.file, self.erev) | |
| self.esum = self.proxy.sum(name) | |
| else: | |
| self.esum = None | |
| def putentry(self): | |
| """Return a line suitable for inclusion in CVS/Entries. | |
| The returned line is terminated by a newline. | |
| If no entry should be written for this file, | |
| return "". | |
| """ | |
| if not self.eseen: | |
| return "" | |
| rev = self.erev or '0' | |
| if self.edeleted: | |
| rev = '-' + rev | |
| if self.enew: | |
| dates = 'Initial ' + self.file | |
| else: | |
| dates = gmctime(self.ectime) + ' ' + \ | |
| gmctime(self.emtime) | |
| return "/%s/%s/%s/%s/\n" % ( | |
| self.file, | |
| rev, | |
| dates, | |
| self.extra) | |
| def report(self): | |
| print '-'*50 | |
| def r(key, repr=repr, self=self): | |
| try: | |
| value = repr(getattr(self, key)) | |
| except AttributeError: | |
| value = "?" | |
| print "%-15s:" % key, value | |
| r("file") | |
| if self.lseen: | |
| r("lsum", hexify) | |
| r("lctime", gmctime) | |
| r("lmtime", gmctime) | |
| if self.eseen: | |
| r("erev") | |
| r("enew") | |
| r("edeleted") | |
| r("ectime", gmctime) | |
| r("emtime", gmctime) | |
| if self.rseen: | |
| r("rrev") | |
| r("rsum", hexify) | |
| if self.eseen: | |
| r("esum", hexify) | |
| class CVS: | |
| """Represent the contents of a CVS admin file (and more). | |
| Class variables: | |
| FileClass -- the class to be instantiated for entries | |
| (this should be derived from class File above) | |
| IgnoreList -- shell patterns for local files to be ignored | |
| Instance variables: | |
| entries -- a dictionary containing File instances keyed by | |
| their file name | |
| proxy -- an RCSProxy instance, or None | |
| """ | |
| FileClass = File | |
| IgnoreList = ['.*', '@*', ',*', '*~', '*.o', '*.a', '*.so', '*.pyc'] | |
| def __init__(self): | |
| self.entries = {} | |
| self.proxy = None | |
| def setproxy(self, proxy): | |
| if proxy is self.proxy: | |
| return | |
| self.proxy = proxy | |
| for e in self.entries.values(): | |
| e.rseen = 0 | |
| def getentries(self): | |
| """Read the contents of CVS/Entries""" | |
| self.entries = {} | |
| f = self.cvsopen("Entries") | |
| while 1: | |
| line = f.readline() | |
| if not line: break | |
| e = self.FileClass() | |
| e.getentry(line) | |
| self.entries[e.file] = e | |
| f.close() | |
| def putentries(self): | |
| """Write CVS/Entries back""" | |
| f = self.cvsopen("Entries", 'w') | |
| for e in self.values(): | |
| f.write(e.putentry()) | |
| f.close() | |
| def getlocalfiles(self): | |
| list = self.entries.keys() | |
| addlist = os.listdir(os.curdir) | |
| for name in addlist: | |
| if name in list: | |
| continue | |
| if not self.ignored(name): | |
| list.append(name) | |
| list.sort() | |
| for file in list: | |
| try: | |
| e = self.entries[file] | |
| except KeyError: | |
| e = self.entries[file] = self.FileClass(file) | |
| e.getlocal() | |
| def getremotefiles(self, proxy = None): | |
| if proxy: | |
| self.proxy = proxy | |
| if not self.proxy: | |
| raise RuntimeError, "no RCS proxy" | |
| addlist = self.proxy.listfiles() | |
| for file in addlist: | |
| try: | |
| e = self.entries[file] | |
| except KeyError: | |
| e = self.entries[file] = self.FileClass(file) | |
| e.getremote(self.proxy) | |
| def report(self): | |
| for e in self.values(): | |
| e.report() | |
| print '-'*50 | |
| def keys(self): | |
| keys = self.entries.keys() | |
| keys.sort() | |
| return keys | |
| def values(self): | |
| def value(key, self=self): | |
| return self.entries[key] | |
| return map(value, self.keys()) | |
| def items(self): | |
| def item(key, self=self): | |
| return (key, self.entries[key]) | |
| return map(item, self.keys()) | |
| def cvsexists(self, file): | |
| file = os.path.join("CVS", file) | |
| return os.path.exists(file) | |
| def cvsopen(self, file, mode = 'r'): | |
| file = os.path.join("CVS", file) | |
| if 'r' not in mode: | |
| self.backup(file) | |
| return open(file, mode) | |
| def backup(self, file): | |
| if os.path.isfile(file): | |
| bfile = file + '~' | |
| try: os.unlink(bfile) | |
| except os.error: pass | |
| os.rename(file, bfile) | |
| def ignored(self, file): | |
| if os.path.isdir(file): return True | |
| for pat in self.IgnoreList: | |
| if fnmatch.fnmatch(file, pat): return True | |
| return False | |
| # hexify and unhexify are useful to print MD5 checksums in hex format | |
| hexify_format = '%02x' * 16 | |
| def hexify(sum): | |
| "Return a hex representation of a 16-byte string (e.g. an MD5 digest)" | |
| if sum is None: | |
| return "None" | |
| return hexify_format % tuple(map(ord, sum)) | |
| def unhexify(hexsum): | |
| "Return the original from a hexified string" | |
| if hexsum == "None": | |
| return None | |
| sum = '' | |
| for i in range(0, len(hexsum), 2): | |
| sum = sum + chr(string.atoi(hexsum[i:i+2], 16)) | |
| return sum | |
| unctime_monthmap = {} | |
| def unctime(date): | |
| if date == "None": return None | |
| if not unctime_monthmap: | |
| months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', | |
| 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] | |
| i = 0 | |
| for m in months: | |
| i = i+1 | |
| unctime_monthmap[m] = i | |
| words = string.split(date) # Day Mon DD HH:MM:SS YEAR | |
| year = string.atoi(words[4]) | |
| month = unctime_monthmap[words[1]] | |
| day = string.atoi(words[2]) | |
| [hh, mm, ss] = map(string.atoi, string.splitfields(words[3], ':')) | |
| ss = ss - time.timezone | |
| return time.mktime((year, month, day, hh, mm, ss, 0, 0, 0)) | |
| def gmctime(t): | |
| if t is None: return "None" | |
| return time.asctime(time.gmtime(t)) | |
| def test_unctime(): | |
| now = int(time.time()) | |
| t = time.gmtime(now) | |
| at = time.asctime(t) | |
| print 'GMT', now, at | |
| print 'timezone', time.timezone | |
| print 'local', time.ctime(now) | |
| u = unctime(at) | |
| print 'unctime()', u | |
| gu = time.gmtime(u) | |
| print '->', gu | |
| print time.asctime(gu) | |
| def test(): | |
| x = CVS() | |
| x.getentries() | |
| x.getlocalfiles() | |
| ## x.report() | |
| import rcsclient | |
| proxy = rcsclient.openrcsclient() | |
| x.getremotefiles(proxy) | |
| x.report() | |
| if __name__ == "__main__": | |
| test() |