| #!/usr/bin/env python |
| # |
| # cvs2svn: ... |
| # |
| |
| import rcsparse |
| import os |
| import sys |
| import sha |
| import re |
| import time |
| import fileinput |
| import string |
| import getopt |
| import statcache |
| import stat |
| |
| from svn import fs, util, delta, repos |
| |
| |
| trunk_rev = re.compile('^[0-9]+\\.[0-9]+$') |
| branch_tag = re.compile('^[0-9.]+\\.0\\.[0-9]+$') |
| vendor_tag = re.compile('^[0-9]+\\.[0-9]+\\.[0-9]+$') |
| |
| DATAFILE = 'cvs2svn-data' |
| REVS_SUFFIX = '.revs' |
| CLEAN_REVS_SUFFIX = '.c-revs' |
| SORTED_REVS_SUFFIX = '.s-revs' |
| TAGS_SUFFIX = '.tags' |
| RESYNC_SUFFIX = '.resync' |
| |
| SVNROOT = 'svnroot' |
| ATTIC = os.sep + 'Attic' |
| |
| COMMIT_THRESHOLD = 5 * 60 # flush a commit if a 5 minute gap occurs |
| |
| OP_DELETE = 'D' |
| OP_CHANGE = 'C' |
| |
| DIGEST_END_IDX = 9 + (sha.digestsize * 2) |
| |
| verbose = 1 |
| |
| |
| class CollectData(rcsparse.Sink): |
| def __init__(self, cvsroot, log_fname_base): |
| self.cvsroot = cvsroot |
| self.revs = open(log_fname_base + '.revs', 'w') |
| self.tags = open(log_fname_base + '.tags', 'w') |
| self.resync = open(log_fname_base + '.resync', 'w') |
| |
| def set_fname(self, fname): |
| "Prepare to receive data for a new file." |
| self.fname = fname |
| |
| # revision -> [timestamp, author, operation, old-timestamp] |
| self.rev_data = { } |
| self.prev = { } |
| self.branch_names = {} |
| self.taglist = {} |
| self.branchlist = {} |
| |
| def set_branch_name(self, revision, name): |
| self.branch_names[revision] = name |
| |
| def get_branch_name(self, revision): |
| brev = revision[:revision.rindex(".")]; |
| if not self.branch_names.has_key(brev): |
| return None |
| return self.branch_names[brev] |
| |
| def add_branch_point(self, revision, branch_name): |
| if not self.branchlist.has_key(revision): |
| self.branchlist[revision] = [] |
| self.branchlist[revision].append(branch_name) |
| |
| def add_cvs_branch(self, revision, branch_name): |
| last_dot = revision.rfind("."); |
| branch_rev = revision[:last_dot]; |
| last2_dot = branch_rev.rfind("."); |
| branch_rev = branch_rev[:last2_dot] + revision[last_dot:]; |
| self.set_branch_name(branch_rev, branch_name) |
| self.add_branch_point(branch_rev[:last2_dot], branch_name) |
| |
| def get_tags(self, revision): |
| if self.taglist.has_key(revision): |
| return self.taglist[revision] |
| else: |
| return [] |
| |
| def get_branches(self, revision): |
| if self.branchlist.has_key(revision): |
| return self.branchlist[revision] |
| else: |
| return [] |
| |
| def define_tag(self, name, revision): |
| self.tags.write('%s %s %s\n' % (name, revision, self.fname)) |
| if branch_tag.match(revision): |
| self.add_cvs_branch(revision, name) |
| elif vendor_tag.match(revision): |
| self.set_branch_name(revision, name) |
| else: |
| if not self.taglist.has_key(revision): |
| self.taglist[revision] = []; |
| self.taglist[revision].append(name) |
| |
| def define_revision(self, revision, timestamp, author, state, |
| branches, next): |
| ### what else? |
| if state == 'dead': |
| op = OP_DELETE |
| else: |
| op = OP_CHANGE |
| |
| # store the rev_data as a list in case we have to jigger the timestamp |
| self.rev_data[revision] = [int(timestamp), author, op, None] |
| |
| # record the previous revision for sanity checking later |
| if trunk_rev.match(revision): |
| self.prev[revision] = next |
| elif next: |
| self.prev[next] = revision |
| for b in branches: |
| self.prev[b] = revision |
| |
| def tree_completed(self): |
| "The revision tree has been parsed. Analyze it for consistency." |
| |
| # Our algorithm depends upon the timestamps on the revisions occuring |
| # monotonically over time. That is, we want to see rev 1.34 occur in |
| # time before rev 1.35. If we inserted 1.35 *first* (due to the time- |
| # sorting), and then tried to insert 1.34, we'd be screwed. |
| |
| # to perform the analysis, we'll simply visit all of the 'previous' |
| # links that we have recorded and validate that the timestamp on the |
| # previous revision is before the specified revision |
| |
| # if we have to resync some nodes, then we restart the scan. just keep |
| # looping as long as we need to restart. |
| while 1: |
| for current, prev in self.prev.items(): |
| if not prev: |
| # no previous revision exists (i.e. the initial revision) |
| continue |
| t_c = self.rev_data[current][0] |
| t_p = self.rev_data[prev][0] |
| if t_p >= t_c: |
| # the previous revision occurred later than the current revision. |
| # shove the previous revision back in time (and any before it that |
| # may need to shift). |
| while t_p >= t_c: |
| self.rev_data[prev][0] = t_c - 1 # new timestamp |
| self.rev_data[prev][3] = t_p # old timestamp |
| |
| print 'RESYNC: %s (%s) : old time="%s" new time="%s"' \ |
| % (relative_name(self.cvsroot, self.fname), |
| prev, time.ctime(t_p), time.ctime(t_c - 1)) |
| |
| current = prev |
| prev = self.prev[current] |
| if not prev: |
| break |
| t_c = t_c - 1 # self.rev_data[current][0] |
| t_p = self.rev_data[prev][0] |
| |
| # break from the for-loop |
| break |
| else: |
| # finished the for-loop (no resyncing was performed) |
| return |
| |
| def set_revision_info(self, revision, log, text): |
| timestamp, author, op, old_ts = self.rev_data[revision] |
| digest = sha.new(log + '\0' + author).hexdigest() |
| if old_ts: |
| # the timestamp on this revision was changed. log it for later |
| # resynchronization of other files's revisions that occurred |
| # for this time and log message. |
| self.resync.write('%08lx %s %08lx\n' % (old_ts, digest, timestamp)) |
| |
| branch_name = self.get_branch_name(revision) |
| |
| write_revs_line(self.revs, timestamp, digest, op, revision, self.fname, |
| branch_name, self.get_tags(revision), self.get_branches(revision)) |
| |
| def branch_path(ctx, branch_name = None): |
| if branch_name: |
| return ctx.branches_base + '/' + branch_name + '/' |
| else: |
| return ctx.trunk_base + '/' |
| |
| def get_tag_path(ctx, tag_name): |
| return ctx.tags_base + '/' + tag_name + '/' |
| |
| def relative_name(cvsroot, fname): |
| l = len(cvsroot) |
| if fname[:l] == cvsroot: |
| if fname[l] == '/': |
| return fname[l+1:] |
| return fname[l:] |
| return l |
| |
| def make_path(fs, root, repos_path, f_pool): |
| ### hmm. need to clarify OS path separators vs FS path separators |
| dirname = os.path.dirname(repos_path) |
| if dirname != '/': |
| # get the components of the path (skipping the leading '/') |
| parts = string.split(dirname[1:], os.sep) |
| for i in range(1, len(parts) + 1): |
| # reassemble the pieces, adding a leading slash |
| parent_dir = '/' + string.join(parts[:i], '/') |
| if fs.check_path(root, parent_dir, f_pool) == util.svn_node_none: |
| print ' making dir:', parent_dir |
| fs.make_dir(root, parent_dir, f_pool) |
| |
| def visit_file(arg, dirname, files): |
| cd, p, stats = arg |
| for fname in files: |
| if fname[-2:] != ',v': |
| continue |
| pathname = os.path.join(dirname, fname) |
| if dirname[-6:] == ATTIC: |
| # drop the 'Attic' portion from the pathname |
| ### we should record this so we can easily insert it back in |
| cd.set_fname(os.path.join(dirname[:-6], fname)) |
| else: |
| cd.set_fname(pathname) |
| if verbose: |
| print pathname |
| p.parse(open(pathname), cd) |
| stats[0] = stats[0] + 1 |
| |
| class RevInfoParser(rcsparse.Sink): |
| def __init__(self): |
| self.authors = { } # revision -> author |
| self.logs = { } # revision -> log message |
| |
| def define_revision(self, revision, timestamp, author, state, |
| branches, next): |
| self.authors[revision] = author |
| |
| def set_revision_info(self, revision, log, text): |
| self.logs[revision] = log |
| |
| def parse_cvs_file(self, rcs_pathname): |
| try: |
| rcsfile = open(rcs_pathname, 'r') |
| except: |
| try: |
| dirname, fname = os.path.split(rcs_pathname) |
| rcs_pathname = os.path.join(dirname, "Attic", fname) |
| rcsfile = open(rcs_pathname, 'r') |
| except: |
| ### should use a better error |
| raise RuntimeError, ('error: %s appeared to be under CVS control, ' |
| 'but the RCS file is inaccessible.' |
| % rcs_pathname) |
| |
| rcsparse.Parser().parse(rcsfile, self) |
| |
| class BuildRevision(rcsparse.Sink): |
| def __init__(self, rev, get_metadata=0): |
| self.rev = rev |
| self.get_metadata = get_metadata |
| self.result = None |
| |
| def define_revision(self, revision, timestamp, author, state, |
| branches, next): |
| for branch in branches: |
| self.prev_delta[branch] = revision |
| if next: |
| self.prev_delta[next] = revision |
| if self.get_metadata and revision == self.rev: |
| self.author = author |
| |
| def tree_completed(self): |
| path = [ ] |
| revision = self.rev |
| while revision: |
| path.append(revision) |
| revision = self.prev_delta.get(revision) |
| path.reverse() |
| self.collect = path |
| |
| def set_revision_info(self, revision, log, text): |
| if not self.collect: |
| # nothing more to do |
| ### would be nice to halt the file parsing... |
| return |
| |
| # NOTE: we assume that the deltas appear in the proper order within |
| # the RCS file, for streaming application. Thus, our max size is the |
| # largest revision of all involved (rather than the revision plus all |
| # diff entries). |
| if revision != self.collect[0]: |
| # not something we are interested in |
| return |
| |
| if self.get_metadata and revision == self.rev: |
| self.log = log |
| |
| if self.result is None: |
| self.result = string.split(text, '\n') |
| else: |
| adjust = 0 |
| diffs = string.split(text, '\n') |
| |
| for command in diffs: |
| if add_lines_remaining > 0: |
| # Insertion lines from a prior "a" command |
| self.result.insert(start_line + adjust, command) |
| add_lines_remaining = add_lines_remaining - 1 |
| adjust = adjust + 1 |
| else: |
| dmatch = self.d_command.match(command) |
| amatch = self.a_command.match(command) |
| if dmatch: |
| # "d" - Delete command |
| start_line = string.atoi(dmatch.group(1)) |
| count = string.atoi(dmatch.group(2)) |
| begin = start_line + adjust - 1 |
| del self.result[begin:begin + count] |
| adjust = adjust - count |
| elif amatch: |
| # "a" - Add command |
| start_line = string.atoi(amatch.group(1)) |
| count = string.atoi(amatch.group(2)) |
| add_lines_remaining = count |
| else: |
| raise RuntimeError, 'Error parsing diff commands' |
| |
| class Commit: |
| def __init__(self): |
| self.files = { } |
| self.changes = [ ] |
| self.deletes = [ ] |
| self.t_min = 1<<30 |
| self.t_max = 0 |
| |
| def has_file(self, fname): |
| return self.files.has_key(fname) |
| |
| def add(self, t, op, file, rev, branch_name, tags, branches): |
| # record the time range of this commit |
| if t < self.t_min: |
| self.t_min = t |
| if t > self.t_max: |
| self.t_max = t |
| |
| if op == OP_CHANGE: |
| self.changes.append((file, rev, branch_name, tags, branches)) |
| else: |
| # OP_DELETE |
| self.deletes.append((file, rev, branch_name, tags, branches)) |
| self.files[file] = 1 |
| |
| def get_metadata(self, pool): |
| # by definition, the author and log message must be the same for all |
| # items that went into this commit. therefore, just grab any item from |
| # our record of changes/deletes. |
| if self.changes: |
| file, rev, br, tags, branches = self.changes[0] |
| else: |
| # there better be one... |
| file, rev, br, tags, branches = self.deletes[0] |
| |
| # now, fetch the author/log from the ,v file |
| rip = RevInfoParser() |
| rip.parse_cvs_file(file) |
| author = rip.authors[rev] |
| log = rip.logs[rev] |
| |
| # format the date properly |
| a_t = util.apr_time_ansi_put(self.t_max)[1] |
| date = util.svn_time_to_cstring(a_t, pool) |
| |
| return author, log, date |
| |
| def commit(self, t_fs, ctx): |
| # commit this transaction |
| print 'committing: %s, over %d seconds' % (time.ctime(self.t_min), |
| self.t_max - self.t_min) |
| |
| if ctx.dry_run: |
| for f, r, br, tags, branches in self.changes: |
| # compute a repository path. ensure we have a leading "/" and drop |
| # the ,v from the file name |
| repos_path = branch_path(ctx, br) + relative_name(ctx.cvsroot, f[:-2]) |
| print ' changing %s : %s' % (r, repos_path) |
| for f, r, br, tags, branches in self.deletes: |
| # compute a repository path. ensure we have a leading "/" and drop |
| # the ,v from the file name |
| repos_path = branch_path(ctx, br) + relative_name(ctx.cvsroot, f[:-2]) |
| print ' deleting %s : %s' % (r, repos_path) |
| print ' (skipped; dry run enabled)' |
| return |
| |
| # create a pool for the entire commit |
| c_pool = util.svn_pool_create(ctx.pool) |
| |
| rev = fs.youngest_rev(t_fs, c_pool) |
| txn = fs.begin_txn(t_fs, rev, c_pool) |
| root = fs.txn_root(txn, c_pool) |
| |
| lastcommit = (None, None) |
| |
| do_copies = [ ] |
| |
| # create a pool for each file; it will be cleared on each iteration |
| f_pool = util.svn_pool_create(c_pool) |
| |
| for f, r, br, tags, branches in self.changes: |
| # compute a repository path. ensure we have a leading "/" and drop |
| # the ,v from the file name |
| rel_name = relative_name(ctx.cvsroot, f[:-2]) |
| repos_path = branch_path(ctx, br) + rel_name |
| #print 'DEBUG:', repos_path |
| |
| print ' changing %s : %s' % (r, repos_path) |
| |
| make_path(fs, root, repos_path, f_pool) |
| |
| if fs.check_path(root, repos_path, f_pool) == util.svn_node_none: |
| created_file = 1 |
| fs.make_file(root, repos_path, f_pool) |
| else: |
| created_file = 0 |
| |
| handler, baton = fs.apply_textdelta(root, repos_path, None, None, f_pool) |
| |
| # figure out the real file path for "co" |
| try: |
| f_st = statcache.stat(f) |
| except os.error: |
| dirname, fname = os.path.split(f) |
| f = os.path.join(dirname, 'Attic', fname) |
| f_st = statcache.stat(f) |
| |
| pipe = os.popen('co -q -p%s \'%s\'' % (r, f), 'r', 102400) |
| |
| # if we just made the file, we can send it in one big hunk, rather |
| # than streaming it in. |
| ### we should watch out for file sizes here; we don't want to yank |
| ### in HUGE files... |
| if created_file: |
| delta.svn_txdelta_send_string(pipe.read(), handler, baton, f_pool) |
| if f_st[0] & stat.S_IXUSR: |
| fs.change_node_prop(root, repos_path, "svn:executable", "", f_pool); |
| else: |
| # open an SVN stream onto the pipe |
| stream2 = util.svn_stream_from_aprfile(pipe, f_pool) |
| |
| # Get the current file contents from the repo, or, if we have |
| # multiple CVS revisions to the same file being done in this |
| # single commit, then get the contents of the previous |
| # revision from co, or else the delta won't be correct because |
| # the contents in the repo won't have changed yet. |
| if repos_path == lastcommit[0]: |
| infile2 = os.popen("co -q -p%s \'%s\'" % (lastcommit[1], f), "r", 102400) |
| stream1 = util.svn_stream_from_aprfile(infile2, f_pool) |
| else: |
| stream1 = fs.file_contents(root, repos_path, f_pool) |
| |
| txstream = delta.svn_txdelta(stream1, stream2, f_pool) |
| delta.svn_txdelta_send_txstream(txstream, handler, baton, f_pool) |
| |
| # shut down the previous-rev pipe, if we opened it |
| infile2 = None |
| |
| # shut down the current-rev pipe |
| pipe.close() |
| |
| # wipe the pool. this will get rid of the pipe streams and the delta |
| # stream, and anything the FS may have done. |
| util.svn_pool_clear(f_pool) |
| |
| # remember what we just did, for the next iteration |
| lastcommit = (repos_path, r) |
| |
| for to_tag in tags: |
| to_tag_path = get_tag_path(ctx, to_tag) + rel_name |
| do_copies.append((repos_path, to_tag_path, 1)) |
| for to_branch in branches: |
| to_branch_path = branch_path(ctx, to_branch) + rel_name |
| do_copies.append((repos_path, to_branch_path, 2)) |
| |
| for f, r, br, tags, branches in self.deletes: |
| # compute a repository path. ensure we have a leading "/" and drop |
| # the ,v from the file name |
| rel_name = relative_name(ctx.cvsroot, f[:-2]) |
| repos_path = branch_path(ctx, br) + rel_name |
| |
| print ' deleting %s : %s' % (r, repos_path) |
| |
| # If the file was initially added on a branch, the first mainline |
| # revision will be marked dead, and thus, attempts to delete it will |
| # fail, since it doesn't really exist. |
| if r != '1.1': |
| ### need to discriminate between OS paths and FS paths |
| fs.delete(root, repos_path, f_pool) |
| |
| for to_branch in branches: |
| to_branch_path = branch_path(ctx, to_branch) + rel_name |
| print "file", f, "created on branch", to_branch, "rev", r, "path", to_branch_path |
| |
| # wipe the pool, in case the delete loads it up |
| util.svn_pool_clear(f_pool) |
| |
| # get the metadata for this commit |
| author, log, date = self.get_metadata(c_pool) |
| |
| # convert locale encoded strings to unicode objects |
| l = unicode(log, ctx.encoding) |
| a = unicode(author, ctx.encoding) |
| |
| # put UTF-8 encoded unicode-"strings" into svn filesystem |
| fs.change_txn_prop(txn, 'svn:author', a.encode('utf8'), c_pool) |
| fs.change_txn_prop(txn, 'svn:log', l.encode('utf8'), c_pool) |
| |
| conflicts, new_rev = fs.commit_txn(txn) |
| |
| # set the time to the proper (past) time |
| fs.change_rev_prop(t_fs, new_rev, 'svn:date', date, c_pool) |
| |
| ### how come conflicts is a newline? |
| if conflicts != '\n': |
| print ' CONFLICTS:', `conflicts` |
| print ' new revision:', new_rev |
| |
| if len(do_copies) > 0: |
| # make a new transaction for the tags |
| rev = fs.youngest_rev(t_fs, c_pool) |
| txn = fs.begin_txn(t_fs, rev, c_pool) |
| root = fs.txn_root(txn, c_pool) |
| |
| for c_from, c_to, c_type in do_copies: |
| print "copying", c_from, "to", c_to |
| |
| t_root = fs.revision_root(t_fs, rev, f_pool); |
| make_path(fs, root, c_to, f_pool) |
| fs.copy(t_root, c_from, root, c_to, f_pool) |
| |
| # clear the pool after each copy |
| util.svn_pool_clear(f_pool) |
| |
| log_msg = "%d copies to tags/branches\n" % (len(do_copies)) |
| fs.change_txn_prop(txn, 'svn:author', "cvs2svn", c_pool) |
| fs.change_txn_prop(txn, 'svn:log', log_msg, c_pool) |
| |
| conflicts, new_rev = fs.commit_txn(txn) |
| if conflicts != '\n': |
| print ' CONFLICTS:', `conflicts` |
| print ' new revision:', new_rev |
| |
| # FIXME: we don't set a date here |
| |
| # done with the commit and file pools |
| util.svn_pool_destroy(c_pool) |
| |
| def read_resync(fname): |
| "Read the .resync file into memory." |
| |
| ### note that we assume that we can hold the entire resync file in |
| ### memory. really large repositories with whacky timestamps could |
| ### bust this assumption. should that ever happen, then it is possible |
| ### to split the resync file into pieces and make multiple passes, |
| ### using each piece. |
| |
| # |
| # A digest maps to a sequence of lists which specify a lower and upper |
| # time bound for matching up the commit. We keep a sequence of these |
| # because a number of checkins with the same log message (e.g. an empty |
| # log message) could need to be remapped. We also make them a list because |
| # we will dynamically expand the lower/upper bound as we find commits |
| # that fall into a particular msg and time range. |
| # |
| # resync == digest -> [ [old_time_lower, old_time_upper, new_time], ... ] |
| # |
| resync = { } |
| |
| for line in fileinput.FileInput(fname): |
| t1 = int(line[:8], 16) |
| digest = line[9:DIGEST_END_IDX] |
| t2 = int(line[DIGEST_END_IDX+1:], 16) |
| t1_l = t1 - COMMIT_THRESHOLD/2 |
| t1_u = t1 + COMMIT_THRESHOLD/2 |
| if resync.has_key(digest): |
| resync[digest].append([t1_l, t1_u, t2]) |
| else: |
| resync[digest] = [ [t1_l, t1_u, t2] ] |
| return resync |
| |
| def parse_revs_line(line): |
| data = line.split(' ', 6) |
| timestamp = int(data[0], 16) |
| id = data[1] |
| op = data[2] |
| rev = data[3] |
| branch_name = data[4] |
| if branch_name == "*": |
| branch_name = None |
| ntags = int(data[5]) |
| tags = data[6].split(' ', ntags + 1) |
| nbranches = int(tags[ntags]) |
| branches = tags[ntags + 1].split(' ', nbranches) |
| fname = branches[nbranches][:-1] # strip \n |
| tags = tags[:ntags] |
| branches = branches[:nbranches] |
| |
| return timestamp, id, op, rev, fname, branch_name, tags, branches |
| |
| def write_revs_line(output, timestamp, digest, op, revision, fname, |
| branch_name, tags, branches): |
| output.write('%08lx %s %s %s ' % (timestamp, digest, op, revision)) |
| if not branch_name: |
| branch_name = "*" |
| output.write('%s ' % branch_name); |
| output.write('%d ' % (len(tags))); |
| for tag in tags: |
| output.write('%s ' % (tag)); |
| output.write('%d ' % (len(branches))); |
| for branch in branches: |
| output.write('%s ' % (branch)); |
| output.write('%s\n' % fname); |
| |
| def pass1(ctx): |
| cd = CollectData(ctx.cvsroot, DATAFILE) |
| p = rcsparse.Parser() |
| stats = [ 0 ] |
| os.path.walk(ctx.cvsroot, visit_file, (cd, p, stats)) |
| if ctx.verbose: |
| print 'processed', stats[0], 'files' |
| |
| def pass2(ctx): |
| "Pass 2: clean up the revision information." |
| |
| # We may have recorded some changes in revisions' timestamp. We need to |
| # scan for any other files which may have had the same log message and |
| # occurred at "the same time" and change their timestamps, too. |
| |
| # read the resync data file |
| resync = read_resync(ctx.log_fname_base + RESYNC_SUFFIX) |
| |
| output = open(ctx.log_fname_base + CLEAN_REVS_SUFFIX, 'w') |
| |
| # process the revisions file, looking for items to clean up |
| for line in fileinput.FileInput(ctx.log_fname_base + REVS_SUFFIX): |
| timestamp, digest, op, rev, fname, branch_name, tags, branches = \ |
| parse_revs_line(line) |
| if not resync.has_key(digest): |
| output.write(line) |
| continue |
| |
| # we have a hit. see if this is "near" any of the resync records we |
| # have recorded for this digest [of the log message]. |
| for record in resync[digest]: |
| if record[0] <= timestamp <= record[1]: |
| # bingo! remap the time on this (record[2] is the new time). |
| write_revs_line(output, record[2], digest, op, rev, fname, |
| branch_name, tags, branches) |
| |
| print 'RESYNC: %s (%s) : old time="%s" new time="%s"' \ |
| % (relative_name(ctx.cvsroot, fname), |
| rev, time.ctime(timestamp), time.ctime(record[2])) |
| |
| # adjust the time range. we want the COMMIT_THRESHOLD from the |
| # bounds of the earlier/latest commit in this group. |
| record[0] = min(record[0], timestamp - COMMIT_THRESHOLD/2) |
| record[1] = max(record[1], timestamp + COMMIT_THRESHOLD/2) |
| |
| # stop looking for hits |
| break |
| else: |
| # the file/rev did not need to have its time changed. |
| output.write(line) |
| |
| def pass3(ctx): |
| # sort the log files |
| os.system('sort %s > %s' % (ctx.log_fname_base + CLEAN_REVS_SUFFIX, |
| ctx.log_fname_base + SORTED_REVS_SUFFIX)) |
| |
| def pass4(ctx): |
| # create the target repository |
| if not ctx.dry_run: |
| if ctx.create_repos: |
| t_repos = repos.svn_repos_create(ctx.target, None, None, None, ctx.pool) |
| else: |
| t_repos = repos.svn_repos_open(ctx.target, ctx.pool) |
| t_fs = repos.svn_repos_fs(t_repos) |
| else: |
| t_fs = t_repos = None |
| |
| # process the logfiles, creating the target |
| commits = { } |
| count = 0 |
| |
| for line in fileinput.FileInput(ctx.log_fname_base + SORTED_REVS_SUFFIX): |
| timestamp, id, op, rev, fname, branch_name, tags, branches = \ |
| parse_revs_line(line) |
| |
| # scan for commits to process |
| process = [ ] |
| for scan_id, scan_c in commits.items(): |
| |
| # ISSUE: the has_file() check below is not optimal. |
| # it does fix the dataloss bug where revisions would get lost |
| # if checked in too quickly, but it can alco break apart the |
| # commits. The correct fix would require tracking the dependencies |
| # between change sets and commiting them in proper order. |
| if scan_c.t_max + COMMIT_THRESHOLD < timestamp or \ |
| scan_c.has_file(fname): |
| process.append((scan_c.t_max, scan_c)) |
| del commits[scan_id] |
| |
| # sort the commits into time-order, then commit 'em |
| process.sort() |
| for t_max, c in process: |
| c.commit(t_fs, ctx) |
| count = count + len(process) |
| |
| # add this item into the set of commits we're assembling |
| if commits.has_key(id): |
| c = commits[id] |
| else: |
| c = commits[id] = Commit() |
| c.add(timestamp, op, fname, rev, branch_name, tags, branches) |
| |
| # if there are any pending commits left, then flush them |
| if commits: |
| process = [ ] |
| for id, c in commits.items(): |
| process.append((c.t_max, c)) |
| process.sort() |
| for t_max, c in process: |
| c.commit(t_fs, ctx) |
| count = count + len(process) |
| |
| if ctx.verbose: |
| print count, 'commits processed.' |
| |
| _passes = [ |
| pass1, |
| pass2, |
| pass3, |
| pass4, |
| ] |
| |
| class _ctx: |
| pass |
| |
| def convert(pool, ctx, start_pass=1): |
| "Convert a CVS repository to an SVN repository." |
| |
| ctx.pool = pool |
| |
| times = [ None ] * len(_passes) |
| for i in range(start_pass - 1, len(_passes)): |
| times[i] = time.time() |
| if verbose: |
| print '----- pass %d -----' % (i + 1) |
| _passes[i](ctx) |
| times.append(time.time()) |
| |
| if verbose: |
| for i in range(start_pass, len(_passes)+1): |
| print 'pass %d: %d seconds' % (i, int(times[i] - times[i-1])) |
| print ' total:', int(times[len(_passes)] - times[start_pass-1]), 'seconds' |
| |
| def usage(ctx): |
| print 'USAGE: %s [-n] [-v] [-s svn-repos-path] [-p pass] cvs-repos-path' \ |
| % os.path.basename(sys.argv[0]) |
| print ' -n dry run. parse CVS repos, but do not construct SVN repos.' |
| print ' -v verbose.' |
| print ' -s PATH path for SVN repos.' |
| print ' -p NUM start at pass NUM of %d.' % len(_passes) |
| print ' --create create a new SVN repository' |
| print ' --trunk=PATH path for trunk (default: %s)' % ctx.trunk_base |
| print ' --branches=PATH path for branches (default: %s)' % ctx.branches_base |
| print ' --tags=PATH path for tags (default: %s)' % ctx.tags_base |
| print ' --encoding=ENC encoding of log messages in CVS repos (default: %s)' % ctx.encoding |
| sys.exit(1) |
| |
| def main(): |
| # prepare the operation context |
| ctx = _ctx() |
| ctx.cvsroot = None |
| ctx.target = SVNROOT |
| ctx.log_fname_base = DATAFILE |
| ctx.verbose = 0 |
| ctx.dry_run = 0 |
| ctx.create_repos = 0 |
| ctx.trunk_base = "/trunk" |
| ctx.tags_base = "/tags" |
| ctx.branches_base = "/branches" |
| ctx.encoding = "ascii" |
| |
| try: |
| opts, args = getopt.getopt(sys.argv[1:], 'p:s:vn', |
| [ "create", "trunk=", "branches=", "tags=", "encoding=" ]) |
| except getopt.GetoptError: |
| usage(ctx) |
| if len(args) != 1: |
| usage(ctx) |
| |
| ctx.cvsroot = args[0] |
| start_pass = 1 |
| |
| for opt, value in opts: |
| if opt == '-p': |
| start_pass = int(value) |
| if start_pass < 1 or start_pass > len(_passes): |
| print 'ERROR: illegal value (%d) for starting pass. ' \ |
| 'must be 1 through %d.' % (start_pass, len(_passes)) |
| sys.exit(1) |
| elif opt == '-v': |
| ctx.verbose = 1 |
| elif opt == '-n': |
| ctx.dry_run = 1 |
| elif opt == '-s': |
| ctx.target = value |
| elif opt == '--create': |
| ctx.create_repos = 1 |
| elif opt == '--trunk': |
| ctx.trunk_base = value |
| elif opt == '--branches': |
| ctx.branches_base = value |
| elif opt == '--tags': |
| ctx.tags_base = value |
| elif opt == '--encoding': |
| ctx.encoding = value |
| |
| util.run_app(convert, ctx, start_pass=start_pass) |
| |
| if __name__ == '__main__': |
| main() |
