mirror of
https://github.com/facebook/sapling.git
synced 2024-10-11 17:27:53 +03:00
15e470ce7f
The default for the time zone offset in a converted changeset has always been 0 (UTC). With this patch, the converted changeset is modified so that the local offset from UTC is specified as the time zone offset. The option is specified as the boolean convert.localtimezone (default False). Example usage: hg convert -s cvs --config convert.localtimezone=True example-cvs example-hg IMPORTANT: the patch only applies to conversions from cvs or svn. The documentation for the option only appears in those two sections in the convert help text.
276 lines
10 KiB
Python
276 lines
10 KiB
Python
# cvs.py: CVS conversion code inspired by hg-cvs-import and git-cvsimport
|
|
#
|
|
# Copyright 2005-2009 Matt Mackall <mpm@selenic.com> and others
|
|
#
|
|
# This software may be used and distributed according to the terms of the
|
|
# GNU General Public License version 2 or any later version.
|
|
|
|
import os, re, socket, errno
|
|
from cStringIO import StringIO
|
|
from mercurial import encoding, util
|
|
from mercurial.i18n import _
|
|
|
|
from common import NoRepo, commit, converter_source, checktool
|
|
from common import makedatetimestamp
|
|
import cvsps
|
|
|
|
class convert_cvs(converter_source):
|
|
def __init__(self, ui, path, rev=None):
|
|
super(convert_cvs, self).__init__(ui, path, rev=rev)
|
|
|
|
cvs = os.path.join(path, "CVS")
|
|
if not os.path.exists(cvs):
|
|
raise NoRepo(_("%s does not look like a CVS checkout") % path)
|
|
|
|
checktool('cvs')
|
|
|
|
self.changeset = None
|
|
self.files = {}
|
|
self.tags = {}
|
|
self.lastbranch = {}
|
|
self.socket = None
|
|
self.cvsroot = open(os.path.join(cvs, "Root")).read()[:-1]
|
|
self.cvsrepo = open(os.path.join(cvs, "Repository")).read()[:-1]
|
|
self.encoding = encoding.encoding
|
|
|
|
self._connect()
|
|
|
|
def _parse(self):
|
|
if self.changeset is not None:
|
|
return
|
|
self.changeset = {}
|
|
|
|
maxrev = 0
|
|
if self.rev:
|
|
# TODO: handle tags
|
|
try:
|
|
# patchset number?
|
|
maxrev = int(self.rev)
|
|
except ValueError:
|
|
raise util.Abort(_('revision %s is not a patchset number')
|
|
% self.rev)
|
|
|
|
d = os.getcwd()
|
|
try:
|
|
os.chdir(self.path)
|
|
id = None
|
|
|
|
cache = 'update'
|
|
if not self.ui.configbool('convert', 'cvsps.cache', True):
|
|
cache = None
|
|
db = cvsps.createlog(self.ui, cache=cache)
|
|
db = cvsps.createchangeset(self.ui, db,
|
|
fuzz=int(self.ui.config('convert', 'cvsps.fuzz', 60)),
|
|
mergeto=self.ui.config('convert', 'cvsps.mergeto', None),
|
|
mergefrom=self.ui.config('convert', 'cvsps.mergefrom', None))
|
|
|
|
for cs in db:
|
|
if maxrev and cs.id > maxrev:
|
|
break
|
|
id = str(cs.id)
|
|
cs.author = self.recode(cs.author)
|
|
self.lastbranch[cs.branch] = id
|
|
cs.comment = self.recode(cs.comment)
|
|
if self.ui.configbool('convert', 'localtimezone'):
|
|
cs.date = makedatetimestamp(cs.date[0])
|
|
date = util.datestr(cs.date, '%Y-%m-%d %H:%M:%S %1%2')
|
|
self.tags.update(dict.fromkeys(cs.tags, id))
|
|
|
|
files = {}
|
|
for f in cs.entries:
|
|
files[f.file] = "%s%s" % ('.'.join([str(x)
|
|
for x in f.revision]),
|
|
['', '(DEAD)'][f.dead])
|
|
|
|
# add current commit to set
|
|
c = commit(author=cs.author, date=date,
|
|
parents=[str(p.id) for p in cs.parents],
|
|
desc=cs.comment, branch=cs.branch or '')
|
|
self.changeset[id] = c
|
|
self.files[id] = files
|
|
|
|
self.heads = self.lastbranch.values()
|
|
finally:
|
|
os.chdir(d)
|
|
|
|
def _connect(self):
|
|
root = self.cvsroot
|
|
conntype = None
|
|
user, host = None, None
|
|
cmd = ['cvs', 'server']
|
|
|
|
self.ui.status(_("connecting to %s\n") % root)
|
|
|
|
if root.startswith(":pserver:"):
|
|
root = root[9:]
|
|
m = re.match(r'(?:(.*?)(?::(.*?))?@)?([^:\/]*)(?::(\d*))?(.*)',
|
|
root)
|
|
if m:
|
|
conntype = "pserver"
|
|
user, passw, serv, port, root = m.groups()
|
|
if not user:
|
|
user = "anonymous"
|
|
if not port:
|
|
port = 2401
|
|
else:
|
|
port = int(port)
|
|
format0 = ":pserver:%s@%s:%s" % (user, serv, root)
|
|
format1 = ":pserver:%s@%s:%d%s" % (user, serv, port, root)
|
|
|
|
if not passw:
|
|
passw = "A"
|
|
cvspass = os.path.expanduser("~/.cvspass")
|
|
try:
|
|
pf = open(cvspass)
|
|
for line in pf.read().splitlines():
|
|
part1, part2 = line.split(' ', 1)
|
|
# /1 :pserver:user@example.com:2401/cvsroot/foo
|
|
# Ah<Z
|
|
if part1 == '/1':
|
|
part1, part2 = part2.split(' ', 1)
|
|
format = format1
|
|
# :pserver:user@example.com:/cvsroot/foo Ah<Z
|
|
else:
|
|
format = format0
|
|
if part1 == format:
|
|
passw = part2
|
|
break
|
|
pf.close()
|
|
except IOError, inst:
|
|
if inst.errno != errno.ENOENT:
|
|
if not getattr(inst, 'filename', None):
|
|
inst.filename = cvspass
|
|
raise
|
|
|
|
sck = socket.socket()
|
|
sck.connect((serv, port))
|
|
sck.send("\n".join(["BEGIN AUTH REQUEST", root, user, passw,
|
|
"END AUTH REQUEST", ""]))
|
|
if sck.recv(128) != "I LOVE YOU\n":
|
|
raise util.Abort(_("CVS pserver authentication failed"))
|
|
|
|
self.writep = self.readp = sck.makefile('r+')
|
|
|
|
if not conntype and root.startswith(":local:"):
|
|
conntype = "local"
|
|
root = root[7:]
|
|
|
|
if not conntype:
|
|
# :ext:user@host/home/user/path/to/cvsroot
|
|
if root.startswith(":ext:"):
|
|
root = root[5:]
|
|
m = re.match(r'(?:([^@:/]+)@)?([^:/]+):?(.*)', root)
|
|
# Do not take Windows path "c:\foo\bar" for a connection strings
|
|
if os.path.isdir(root) or not m:
|
|
conntype = "local"
|
|
else:
|
|
conntype = "rsh"
|
|
user, host, root = m.group(1), m.group(2), m.group(3)
|
|
|
|
if conntype != "pserver":
|
|
if conntype == "rsh":
|
|
rsh = os.environ.get("CVS_RSH") or "ssh"
|
|
if user:
|
|
cmd = [rsh, '-l', user, host] + cmd
|
|
else:
|
|
cmd = [rsh, host] + cmd
|
|
|
|
# popen2 does not support argument lists under Windows
|
|
cmd = [util.shellquote(arg) for arg in cmd]
|
|
cmd = util.quotecommand(' '.join(cmd))
|
|
self.writep, self.readp = util.popen2(cmd)
|
|
|
|
self.realroot = root
|
|
|
|
self.writep.write("Root %s\n" % root)
|
|
self.writep.write("Valid-responses ok error Valid-requests Mode"
|
|
" M Mbinary E Checked-in Created Updated"
|
|
" Merged Removed\n")
|
|
self.writep.write("valid-requests\n")
|
|
self.writep.flush()
|
|
r = self.readp.readline()
|
|
if not r.startswith("Valid-requests"):
|
|
raise util.Abort(_('unexpected response from CVS server '
|
|
'(expected "Valid-requests", but got %r)')
|
|
% r)
|
|
if "UseUnchanged" in r:
|
|
self.writep.write("UseUnchanged\n")
|
|
self.writep.flush()
|
|
r = self.readp.readline()
|
|
|
|
def getheads(self):
|
|
self._parse()
|
|
return self.heads
|
|
|
|
def getfile(self, name, rev):
|
|
|
|
def chunkedread(fp, count):
|
|
# file-objects returned by socket.makefile() do not handle
|
|
# large read() requests very well.
|
|
chunksize = 65536
|
|
output = StringIO()
|
|
while count > 0:
|
|
data = fp.read(min(count, chunksize))
|
|
if not data:
|
|
raise util.Abort(_("%d bytes missing from remote file")
|
|
% count)
|
|
count -= len(data)
|
|
output.write(data)
|
|
return output.getvalue()
|
|
|
|
self._parse()
|
|
if rev.endswith("(DEAD)"):
|
|
raise IOError
|
|
|
|
args = ("-N -P -kk -r %s --" % rev).split()
|
|
args.append(self.cvsrepo + '/' + name)
|
|
for x in args:
|
|
self.writep.write("Argument %s\n" % x)
|
|
self.writep.write("Directory .\n%s\nco\n" % self.realroot)
|
|
self.writep.flush()
|
|
|
|
data = ""
|
|
mode = None
|
|
while True:
|
|
line = self.readp.readline()
|
|
if line.startswith("Created ") or line.startswith("Updated "):
|
|
self.readp.readline() # path
|
|
self.readp.readline() # entries
|
|
mode = self.readp.readline()[:-1]
|
|
count = int(self.readp.readline()[:-1])
|
|
data = chunkedread(self.readp, count)
|
|
elif line.startswith(" "):
|
|
data += line[1:]
|
|
elif line.startswith("M "):
|
|
pass
|
|
elif line.startswith("Mbinary "):
|
|
count = int(self.readp.readline()[:-1])
|
|
data = chunkedread(self.readp, count)
|
|
else:
|
|
if line == "ok\n":
|
|
if mode is None:
|
|
raise util.Abort(_('malformed response from CVS'))
|
|
return (data, "x" in mode and "x" or "")
|
|
elif line.startswith("E "):
|
|
self.ui.warn(_("cvs server: %s\n") % line[2:])
|
|
elif line.startswith("Remove"):
|
|
self.readp.readline()
|
|
else:
|
|
raise util.Abort(_("unknown CVS response: %s") % line)
|
|
|
|
def getchanges(self, rev):
|
|
self._parse()
|
|
return sorted(self.files[rev].iteritems()), {}
|
|
|
|
def getcommit(self, rev):
|
|
self._parse()
|
|
return self.changeset[rev]
|
|
|
|
def gettags(self):
|
|
self._parse()
|
|
return self.tags
|
|
|
|
def getchangedfiles(self, rev, i):
|
|
self._parse()
|
|
return sorted(self.files[rev])
|