##// END OF EJS Templates
convert: cleanup svn file copy handling
Patrick Mezard -
r6544:3447c088 default
parent child Browse files
Show More
@@ -1,1118 +1,1120 b''
1 # Subversion 1.4/1.5 Python API backend
1 # Subversion 1.4/1.5 Python API backend
2 #
2 #
3 # Copyright(C) 2007 Daniel Holth et al
3 # Copyright(C) 2007 Daniel Holth et al
4 #
4 #
5 # Configuration options:
5 # Configuration options:
6 #
6 #
7 # convert.svn.trunk
7 # convert.svn.trunk
8 # Relative path to the trunk (default: "trunk")
8 # Relative path to the trunk (default: "trunk")
9 # convert.svn.branches
9 # convert.svn.branches
10 # Relative path to tree of branches (default: "branches")
10 # Relative path to tree of branches (default: "branches")
11 # convert.svn.tags
11 # convert.svn.tags
12 # Relative path to tree of tags (default: "tags")
12 # Relative path to tree of tags (default: "tags")
13 #
13 #
14 # Set these in a hgrc, or on the command line as follows:
14 # Set these in a hgrc, or on the command line as follows:
15 #
15 #
16 # hg convert --config convert.svn.trunk=wackoname [...]
16 # hg convert --config convert.svn.trunk=wackoname [...]
17
17
18 import locale
18 import locale
19 import os
19 import os
20 import re
20 import re
21 import sys
21 import sys
22 import cPickle as pickle
22 import cPickle as pickle
23 import tempfile
23 import tempfile
24
24
25 from mercurial import strutil, util
25 from mercurial import strutil, util
26 from mercurial.i18n import _
26 from mercurial.i18n import _
27
27
28 # Subversion stuff. Works best with very recent Python SVN bindings
28 # Subversion stuff. Works best with very recent Python SVN bindings
29 # e.g. SVN 1.5 or backports. Thanks to the bzr folks for enhancing
29 # e.g. SVN 1.5 or backports. Thanks to the bzr folks for enhancing
30 # these bindings.
30 # these bindings.
31
31
32 from cStringIO import StringIO
32 from cStringIO import StringIO
33
33
34 from common import NoRepo, commit, converter_source, encodeargs, decodeargs
34 from common import NoRepo, commit, converter_source, encodeargs, decodeargs
35 from common import commandline, converter_sink, mapfile
35 from common import commandline, converter_sink, mapfile
36
36
37 try:
37 try:
38 from svn.core import SubversionException, Pool
38 from svn.core import SubversionException, Pool
39 import svn
39 import svn
40 import svn.client
40 import svn.client
41 import svn.core
41 import svn.core
42 import svn.ra
42 import svn.ra
43 import svn.delta
43 import svn.delta
44 import transport
44 import transport
45 except ImportError:
45 except ImportError:
46 pass
46 pass
47
47
48 def geturl(path):
48 def geturl(path):
49 try:
49 try:
50 return svn.client.url_from_path(svn.core.svn_path_canonicalize(path))
50 return svn.client.url_from_path(svn.core.svn_path_canonicalize(path))
51 except SubversionException:
51 except SubversionException:
52 pass
52 pass
53 if os.path.isdir(path):
53 if os.path.isdir(path):
54 path = os.path.normpath(os.path.abspath(path))
54 path = os.path.normpath(os.path.abspath(path))
55 if os.name == 'nt':
55 if os.name == 'nt':
56 path = '/' + util.normpath(path)
56 path = '/' + util.normpath(path)
57 return 'file://%s' % path
57 return 'file://%s' % path
58 return path
58 return path
59
59
60 def optrev(number):
60 def optrev(number):
61 optrev = svn.core.svn_opt_revision_t()
61 optrev = svn.core.svn_opt_revision_t()
62 optrev.kind = svn.core.svn_opt_revision_number
62 optrev.kind = svn.core.svn_opt_revision_number
63 optrev.value.number = number
63 optrev.value.number = number
64 return optrev
64 return optrev
65
65
66 class changedpath(object):
66 class changedpath(object):
67 def __init__(self, p):
67 def __init__(self, p):
68 self.copyfrom_path = p.copyfrom_path
68 self.copyfrom_path = p.copyfrom_path
69 self.copyfrom_rev = p.copyfrom_rev
69 self.copyfrom_rev = p.copyfrom_rev
70 self.action = p.action
70 self.action = p.action
71
71
72 def get_log_child(fp, url, paths, start, end, limit=0, discover_changed_paths=True,
72 def get_log_child(fp, url, paths, start, end, limit=0, discover_changed_paths=True,
73 strict_node_history=False):
73 strict_node_history=False):
74 protocol = -1
74 protocol = -1
75 def receiver(orig_paths, revnum, author, date, message, pool):
75 def receiver(orig_paths, revnum, author, date, message, pool):
76 if orig_paths is not None:
76 if orig_paths is not None:
77 for k, v in orig_paths.iteritems():
77 for k, v in orig_paths.iteritems():
78 orig_paths[k] = changedpath(v)
78 orig_paths[k] = changedpath(v)
79 pickle.dump((orig_paths, revnum, author, date, message),
79 pickle.dump((orig_paths, revnum, author, date, message),
80 fp, protocol)
80 fp, protocol)
81
81
82 try:
82 try:
83 # Use an ra of our own so that our parent can consume
83 # Use an ra of our own so that our parent can consume
84 # our results without confusing the server.
84 # our results without confusing the server.
85 t = transport.SvnRaTransport(url=url)
85 t = transport.SvnRaTransport(url=url)
86 svn.ra.get_log(t.ra, paths, start, end, limit,
86 svn.ra.get_log(t.ra, paths, start, end, limit,
87 discover_changed_paths,
87 discover_changed_paths,
88 strict_node_history,
88 strict_node_history,
89 receiver)
89 receiver)
90 except SubversionException, (inst, num):
90 except SubversionException, (inst, num):
91 pickle.dump(num, fp, protocol)
91 pickle.dump(num, fp, protocol)
92 except IOError:
92 except IOError:
93 # Caller may interrupt the iteration
93 # Caller may interrupt the iteration
94 pickle.dump(None, fp, protocol)
94 pickle.dump(None, fp, protocol)
95 else:
95 else:
96 pickle.dump(None, fp, protocol)
96 pickle.dump(None, fp, protocol)
97 fp.close()
97 fp.close()
98 # With large history, cleanup process goes crazy and suddenly
98 # With large history, cleanup process goes crazy and suddenly
99 # consumes *huge* amount of memory. The output file being closed,
99 # consumes *huge* amount of memory. The output file being closed,
100 # there is no need for clean termination.
100 # there is no need for clean termination.
101 os._exit(0)
101 os._exit(0)
102
102
103 def debugsvnlog(ui, **opts):
103 def debugsvnlog(ui, **opts):
104 """Fetch SVN log in a subprocess and channel them back to parent to
104 """Fetch SVN log in a subprocess and channel them back to parent to
105 avoid memory collection issues.
105 avoid memory collection issues.
106 """
106 """
107 util.set_binary(sys.stdin)
107 util.set_binary(sys.stdin)
108 util.set_binary(sys.stdout)
108 util.set_binary(sys.stdout)
109 args = decodeargs(sys.stdin.read())
109 args = decodeargs(sys.stdin.read())
110 get_log_child(sys.stdout, *args)
110 get_log_child(sys.stdout, *args)
111
111
112 class logstream:
112 class logstream:
113 """Interruptible revision log iterator."""
113 """Interruptible revision log iterator."""
114 def __init__(self, stdout):
114 def __init__(self, stdout):
115 self._stdout = stdout
115 self._stdout = stdout
116
116
117 def __iter__(self):
117 def __iter__(self):
118 while True:
118 while True:
119 entry = pickle.load(self._stdout)
119 entry = pickle.load(self._stdout)
120 try:
120 try:
121 orig_paths, revnum, author, date, message = entry
121 orig_paths, revnum, author, date, message = entry
122 except:
122 except:
123 if entry is None:
123 if entry is None:
124 break
124 break
125 raise SubversionException("child raised exception", entry)
125 raise SubversionException("child raised exception", entry)
126 yield entry
126 yield entry
127
127
128 def close(self):
128 def close(self):
129 if self._stdout:
129 if self._stdout:
130 self._stdout.close()
130 self._stdout.close()
131 self._stdout = None
131 self._stdout = None
132
132
133 def get_log(url, paths, start, end, limit=0, discover_changed_paths=True,
133 def get_log(url, paths, start, end, limit=0, discover_changed_paths=True,
134 strict_node_history=False):
134 strict_node_history=False):
135 args = [url, paths, start, end, limit, discover_changed_paths,
135 args = [url, paths, start, end, limit, discover_changed_paths,
136 strict_node_history]
136 strict_node_history]
137 arg = encodeargs(args)
137 arg = encodeargs(args)
138 hgexe = util.hgexecutable()
138 hgexe = util.hgexecutable()
139 cmd = '%s debugsvnlog' % util.shellquote(hgexe)
139 cmd = '%s debugsvnlog' % util.shellquote(hgexe)
140 stdin, stdout = os.popen2(cmd, 'b')
140 stdin, stdout = os.popen2(cmd, 'b')
141 stdin.write(arg)
141 stdin.write(arg)
142 stdin.close()
142 stdin.close()
143 return logstream(stdout)
143 return logstream(stdout)
144
144
145 # SVN conversion code stolen from bzr-svn and tailor
145 # SVN conversion code stolen from bzr-svn and tailor
146 #
146 #
147 # Subversion looks like a versioned filesystem, branches structures
147 # Subversion looks like a versioned filesystem, branches structures
148 # are defined by conventions and not enforced by the tool. First,
148 # are defined by conventions and not enforced by the tool. First,
149 # we define the potential branches (modules) as "trunk" and "branches"
149 # we define the potential branches (modules) as "trunk" and "branches"
150 # children directories. Revisions are then identified by their
150 # children directories. Revisions are then identified by their
151 # module and revision number (and a repository identifier).
151 # module and revision number (and a repository identifier).
152 #
152 #
153 # The revision graph is really a tree (or a forest). By default, a
153 # The revision graph is really a tree (or a forest). By default, a
154 # revision parent is the previous revision in the same module. If the
154 # revision parent is the previous revision in the same module. If the
155 # module directory is copied/moved from another module then the
155 # module directory is copied/moved from another module then the
156 # revision is the module root and its parent the source revision in
156 # revision is the module root and its parent the source revision in
157 # the parent module. A revision has at most one parent.
157 # the parent module. A revision has at most one parent.
158 #
158 #
159 class svn_source(converter_source):
159 class svn_source(converter_source):
160 def __init__(self, ui, url, rev=None):
160 def __init__(self, ui, url, rev=None):
161 super(svn_source, self).__init__(ui, url, rev=rev)
161 super(svn_source, self).__init__(ui, url, rev=rev)
162
162
163 try:
163 try:
164 SubversionException
164 SubversionException
165 except NameError:
165 except NameError:
166 raise NoRepo('Subversion python bindings could not be loaded')
166 raise NoRepo('Subversion python bindings could not be loaded')
167
167
168 self.encoding = locale.getpreferredencoding()
168 self.encoding = locale.getpreferredencoding()
169 self.lastrevs = {}
169 self.lastrevs = {}
170
170
171 latest = None
171 latest = None
172 try:
172 try:
173 # Support file://path@rev syntax. Useful e.g. to convert
173 # Support file://path@rev syntax. Useful e.g. to convert
174 # deleted branches.
174 # deleted branches.
175 at = url.rfind('@')
175 at = url.rfind('@')
176 if at >= 0:
176 if at >= 0:
177 latest = int(url[at+1:])
177 latest = int(url[at+1:])
178 url = url[:at]
178 url = url[:at]
179 except ValueError, e:
179 except ValueError, e:
180 pass
180 pass
181 self.url = geturl(url)
181 self.url = geturl(url)
182 self.encoding = 'UTF-8' # Subversion is always nominal UTF-8
182 self.encoding = 'UTF-8' # Subversion is always nominal UTF-8
183 try:
183 try:
184 self.transport = transport.SvnRaTransport(url=self.url)
184 self.transport = transport.SvnRaTransport(url=self.url)
185 self.ra = self.transport.ra
185 self.ra = self.transport.ra
186 self.ctx = self.transport.client
186 self.ctx = self.transport.client
187 self.base = svn.ra.get_repos_root(self.ra)
187 self.base = svn.ra.get_repos_root(self.ra)
188 # Module is either empty or a repository path starting with
188 # Module is either empty or a repository path starting with
189 # a slash and not ending with a slash.
189 # a slash and not ending with a slash.
190 self.module = self.url[len(self.base):]
190 self.module = self.url[len(self.base):]
191 self.rootmodule = self.module
191 self.rootmodule = self.module
192 self.commits = {}
192 self.commits = {}
193 self.paths = {}
193 self.paths = {}
194 self.uuid = svn.ra.get_uuid(self.ra).decode(self.encoding)
194 self.uuid = svn.ra.get_uuid(self.ra).decode(self.encoding)
195 except SubversionException, e:
195 except SubversionException, e:
196 ui.print_exc()
196 ui.print_exc()
197 raise NoRepo("%s does not look like a Subversion repo" % self.url)
197 raise NoRepo("%s does not look like a Subversion repo" % self.url)
198
198
199 if rev:
199 if rev:
200 try:
200 try:
201 latest = int(rev)
201 latest = int(rev)
202 except ValueError:
202 except ValueError:
203 raise util.Abort('svn: revision %s is not an integer' % rev)
203 raise util.Abort('svn: revision %s is not an integer' % rev)
204
204
205 self.startrev = self.ui.config('convert', 'svn.startrev', default=0)
205 self.startrev = self.ui.config('convert', 'svn.startrev', default=0)
206 try:
206 try:
207 self.startrev = int(self.startrev)
207 self.startrev = int(self.startrev)
208 if self.startrev < 0:
208 if self.startrev < 0:
209 self.startrev = 0
209 self.startrev = 0
210 except ValueError:
210 except ValueError:
211 raise util.Abort(_('svn: start revision %s is not an integer')
211 raise util.Abort(_('svn: start revision %s is not an integer')
212 % self.startrev)
212 % self.startrev)
213
213
214 try:
214 try:
215 self.get_blacklist()
215 self.get_blacklist()
216 except IOError, e:
216 except IOError, e:
217 pass
217 pass
218
218
219 self.head = self.latest(self.module, latest)
219 self.head = self.latest(self.module, latest)
220 if not self.head:
220 if not self.head:
221 raise util.Abort(_('no revision found in module %s') %
221 raise util.Abort(_('no revision found in module %s') %
222 self.module.encode(self.encoding))
222 self.module.encode(self.encoding))
223 self.last_changed = self.revnum(self.head)
223 self.last_changed = self.revnum(self.head)
224
224
225 self._changescache = None
225 self._changescache = None
226
226
227 if os.path.exists(os.path.join(url, '.svn/entries')):
227 if os.path.exists(os.path.join(url, '.svn/entries')):
228 self.wc = url
228 self.wc = url
229 else:
229 else:
230 self.wc = None
230 self.wc = None
231 self.convertfp = None
231 self.convertfp = None
232
232
233 def setrevmap(self, revmap):
233 def setrevmap(self, revmap):
234 lastrevs = {}
234 lastrevs = {}
235 for revid in revmap.iterkeys():
235 for revid in revmap.iterkeys():
236 uuid, module, revnum = self.revsplit(revid)
236 uuid, module, revnum = self.revsplit(revid)
237 lastrevnum = lastrevs.setdefault(module, revnum)
237 lastrevnum = lastrevs.setdefault(module, revnum)
238 if revnum > lastrevnum:
238 if revnum > lastrevnum:
239 lastrevs[module] = revnum
239 lastrevs[module] = revnum
240 self.lastrevs = lastrevs
240 self.lastrevs = lastrevs
241
241
242 def exists(self, path, optrev):
242 def exists(self, path, optrev):
243 try:
243 try:
244 svn.client.ls(self.url.rstrip('/') + '/' + path,
244 svn.client.ls(self.url.rstrip('/') + '/' + path,
245 optrev, False, self.ctx)
245 optrev, False, self.ctx)
246 return True
246 return True
247 except SubversionException, err:
247 except SubversionException, err:
248 return False
248 return False
249
249
250 def getheads(self):
250 def getheads(self):
251
251
252 def isdir(path, revnum):
252 def isdir(path, revnum):
253 kind = svn.ra.check_path(self.ra, path, revnum)
253 kind = svn.ra.check_path(self.ra, path, revnum)
254 return kind == svn.core.svn_node_dir
254 return kind == svn.core.svn_node_dir
255
255
256 def getcfgpath(name, rev):
256 def getcfgpath(name, rev):
257 cfgpath = self.ui.config('convert', 'svn.' + name)
257 cfgpath = self.ui.config('convert', 'svn.' + name)
258 if cfgpath is not None and cfgpath.strip() == '':
258 if cfgpath is not None and cfgpath.strip() == '':
259 return None
259 return None
260 path = (cfgpath or name).strip('/')
260 path = (cfgpath or name).strip('/')
261 if not self.exists(path, rev):
261 if not self.exists(path, rev):
262 if cfgpath:
262 if cfgpath:
263 raise util.Abort(_('expected %s to be at %r, but not found')
263 raise util.Abort(_('expected %s to be at %r, but not found')
264 % (name, path))
264 % (name, path))
265 return None
265 return None
266 self.ui.note(_('found %s at %r\n') % (name, path))
266 self.ui.note(_('found %s at %r\n') % (name, path))
267 return path
267 return path
268
268
269 rev = optrev(self.last_changed)
269 rev = optrev(self.last_changed)
270 oldmodule = ''
270 oldmodule = ''
271 trunk = getcfgpath('trunk', rev)
271 trunk = getcfgpath('trunk', rev)
272 self.tags = getcfgpath('tags', rev)
272 self.tags = getcfgpath('tags', rev)
273 branches = getcfgpath('branches', rev)
273 branches = getcfgpath('branches', rev)
274
274
275 # If the project has a trunk or branches, we will extract heads
275 # If the project has a trunk or branches, we will extract heads
276 # from them. We keep the project root otherwise.
276 # from them. We keep the project root otherwise.
277 if trunk:
277 if trunk:
278 oldmodule = self.module or ''
278 oldmodule = self.module or ''
279 self.module += '/' + trunk
279 self.module += '/' + trunk
280 self.head = self.latest(self.module, self.last_changed)
280 self.head = self.latest(self.module, self.last_changed)
281 if not self.head:
281 if not self.head:
282 raise util.Abort(_('no revision found in module %s') %
282 raise util.Abort(_('no revision found in module %s') %
283 self.module.encode(self.encoding))
283 self.module.encode(self.encoding))
284
284
285 # First head in the list is the module's head
285 # First head in the list is the module's head
286 self.heads = [self.head]
286 self.heads = [self.head]
287 if self.tags is not None:
287 if self.tags is not None:
288 self.tags = '%s/%s' % (oldmodule , (self.tags or 'tags'))
288 self.tags = '%s/%s' % (oldmodule , (self.tags or 'tags'))
289
289
290 # Check if branches bring a few more heads to the list
290 # Check if branches bring a few more heads to the list
291 if branches:
291 if branches:
292 rpath = self.url.strip('/')
292 rpath = self.url.strip('/')
293 branchnames = svn.client.ls(rpath + '/' + branches, rev, False,
293 branchnames = svn.client.ls(rpath + '/' + branches, rev, False,
294 self.ctx)
294 self.ctx)
295 for branch in branchnames.keys():
295 for branch in branchnames.keys():
296 module = '%s/%s/%s' % (oldmodule, branches, branch)
296 module = '%s/%s/%s' % (oldmodule, branches, branch)
297 if not isdir(module, self.last_changed):
297 if not isdir(module, self.last_changed):
298 continue
298 continue
299 brevid = self.latest(module, self.last_changed)
299 brevid = self.latest(module, self.last_changed)
300 if not brevid:
300 if not brevid:
301 self.ui.note(_('ignoring empty branch %s\n') %
301 self.ui.note(_('ignoring empty branch %s\n') %
302 branch.encode(self.encoding))
302 branch.encode(self.encoding))
303 continue
303 continue
304 self.ui.note('found branch %s at %d\n' %
304 self.ui.note('found branch %s at %d\n' %
305 (branch, self.revnum(brevid)))
305 (branch, self.revnum(brevid)))
306 self.heads.append(brevid)
306 self.heads.append(brevid)
307
307
308 if self.startrev and self.heads:
308 if self.startrev and self.heads:
309 if len(self.heads) > 1:
309 if len(self.heads) > 1:
310 raise util.Abort(_('svn: start revision is not supported with '
310 raise util.Abort(_('svn: start revision is not supported with '
311 'with more than one branch'))
311 'with more than one branch'))
312 revnum = self.revnum(self.heads[0])
312 revnum = self.revnum(self.heads[0])
313 if revnum < self.startrev:
313 if revnum < self.startrev:
314 raise util.Abort(_('svn: no revision found after start revision %d')
314 raise util.Abort(_('svn: no revision found after start revision %d')
315 % self.startrev)
315 % self.startrev)
316
316
317 return self.heads
317 return self.heads
318
318
319 def getfile(self, file, rev):
319 def getfile(self, file, rev):
320 data, mode = self._getfile(file, rev)
320 data, mode = self._getfile(file, rev)
321 self.modecache[(file, rev)] = mode
321 self.modecache[(file, rev)] = mode
322 return data
322 return data
323
323
324 def getmode(self, file, rev):
324 def getmode(self, file, rev):
325 return self.modecache[(file, rev)]
325 return self.modecache[(file, rev)]
326
326
327 def getchanges(self, rev):
327 def getchanges(self, rev):
328 if self._changescache and self._changescache[0] == rev:
328 if self._changescache and self._changescache[0] == rev:
329 return self._changescache[1]
329 return self._changescache[1]
330 self._changescache = None
330 self._changescache = None
331 self.modecache = {}
331 self.modecache = {}
332 (paths, parents) = self.paths[rev]
332 (paths, parents) = self.paths[rev]
333 if parents:
333 if parents:
334 files, copies = self.expandpaths(rev, paths, parents)
334 files, copies = self.expandpaths(rev, paths, parents)
335 else:
335 else:
336 # Perform a full checkout on roots
336 # Perform a full checkout on roots
337 uuid, module, revnum = self.revsplit(rev)
337 uuid, module, revnum = self.revsplit(rev)
338 entries = svn.client.ls(self.base + module, optrev(revnum),
338 entries = svn.client.ls(self.base + module, optrev(revnum),
339 True, self.ctx)
339 True, self.ctx)
340 files = [n for n,e in entries.iteritems()
340 files = [n for n,e in entries.iteritems()
341 if e.kind == svn.core.svn_node_file]
341 if e.kind == svn.core.svn_node_file]
342 copies = {}
342 copies = {}
343
343
344 files.sort()
344 files.sort()
345 files = zip(files, [rev] * len(files))
345 files = zip(files, [rev] * len(files))
346
346
347 # caller caches the result, so free it here to release memory
347 # caller caches the result, so free it here to release memory
348 del self.paths[rev]
348 del self.paths[rev]
349 return (files, copies)
349 return (files, copies)
350
350
351 def getchangedfiles(self, rev, i):
351 def getchangedfiles(self, rev, i):
352 changes = self.getchanges(rev)
352 changes = self.getchanges(rev)
353 self._changescache = (rev, changes)
353 self._changescache = (rev, changes)
354 return [f[0] for f in changes[0]]
354 return [f[0] for f in changes[0]]
355
355
356 def getcommit(self, rev):
356 def getcommit(self, rev):
357 if rev not in self.commits:
357 if rev not in self.commits:
358 uuid, module, revnum = self.revsplit(rev)
358 uuid, module, revnum = self.revsplit(rev)
359 self.module = module
359 self.module = module
360 self.reparent(module)
360 self.reparent(module)
361 # We assume that:
361 # We assume that:
362 # - requests for revisions after "stop" come from the
362 # - requests for revisions after "stop" come from the
363 # revision graph backward traversal. Cache all of them
363 # revision graph backward traversal. Cache all of them
364 # down to stop, they will be used eventually.
364 # down to stop, they will be used eventually.
365 # - requests for revisions before "stop" come to get
365 # - requests for revisions before "stop" come to get
366 # isolated branches parents. Just fetch what is needed.
366 # isolated branches parents. Just fetch what is needed.
367 stop = self.lastrevs.get(module, 0)
367 stop = self.lastrevs.get(module, 0)
368 if revnum < stop:
368 if revnum < stop:
369 stop = revnum + 1
369 stop = revnum + 1
370 self._fetch_revisions(revnum, stop)
370 self._fetch_revisions(revnum, stop)
371 commit = self.commits[rev]
371 commit = self.commits[rev]
372 # caller caches the result, so free it here to release memory
372 # caller caches the result, so free it here to release memory
373 del self.commits[rev]
373 del self.commits[rev]
374 return commit
374 return commit
375
375
376 def gettags(self):
376 def gettags(self):
377 tags = {}
377 tags = {}
378 if self.tags is None:
378 if self.tags is None:
379 return tags
379 return tags
380
380
381 # svn tags are just a convention, project branches left in a
381 # svn tags are just a convention, project branches left in a
382 # 'tags' directory. There is no other relationship than
382 # 'tags' directory. There is no other relationship than
383 # ancestry, which is expensive to discover and makes them hard
383 # ancestry, which is expensive to discover and makes them hard
384 # to update incrementally. Worse, past revisions may be
384 # to update incrementally. Worse, past revisions may be
385 # referenced by tags far away in the future, requiring a deep
385 # referenced by tags far away in the future, requiring a deep
386 # history traversal on every calculation. Current code
386 # history traversal on every calculation. Current code
387 # performs a single backward traversal, tracking moves within
387 # performs a single backward traversal, tracking moves within
388 # the tags directory (tag renaming) and recording a new tag
388 # the tags directory (tag renaming) and recording a new tag
389 # everytime a project is copied from outside the tags
389 # everytime a project is copied from outside the tags
390 # directory. It also lists deleted tags, this behaviour may
390 # directory. It also lists deleted tags, this behaviour may
391 # change in the future.
391 # change in the future.
392 pendings = []
392 pendings = []
393 tagspath = self.tags
393 tagspath = self.tags
394 start = svn.ra.get_latest_revnum(self.ra)
394 start = svn.ra.get_latest_revnum(self.ra)
395 try:
395 try:
396 for entry in get_log(self.url, [self.tags], start, self.startrev):
396 for entry in get_log(self.url, [self.tags], start, self.startrev):
397 origpaths, revnum, author, date, message = entry
397 origpaths, revnum, author, date, message = entry
398 copies = [(e.copyfrom_path, e.copyfrom_rev, p) for p, e
398 copies = [(e.copyfrom_path, e.copyfrom_rev, p) for p, e
399 in origpaths.iteritems() if e.copyfrom_path]
399 in origpaths.iteritems() if e.copyfrom_path]
400 copies.sort()
400 copies.sort()
401 # Apply moves/copies from more specific to general
401 # Apply moves/copies from more specific to general
402 copies.reverse()
402 copies.reverse()
403
403
404 srctagspath = tagspath
404 srctagspath = tagspath
405 if copies and copies[-1][2] == tagspath:
405 if copies and copies[-1][2] == tagspath:
406 # Track tags directory moves
406 # Track tags directory moves
407 srctagspath = copies.pop()[0]
407 srctagspath = copies.pop()[0]
408
408
409 for source, sourcerev, dest in copies:
409 for source, sourcerev, dest in copies:
410 if not dest.startswith(tagspath + '/'):
410 if not dest.startswith(tagspath + '/'):
411 continue
411 continue
412 for tag in pendings:
412 for tag in pendings:
413 if tag[0].startswith(dest):
413 if tag[0].startswith(dest):
414 tagpath = source + tag[0][len(dest):]
414 tagpath = source + tag[0][len(dest):]
415 tag[:2] = [tagpath, sourcerev]
415 tag[:2] = [tagpath, sourcerev]
416 break
416 break
417 else:
417 else:
418 pendings.append([source, sourcerev, dest.split('/')[-1]])
418 pendings.append([source, sourcerev, dest.split('/')[-1]])
419
419
420 # Tell tag renamings from tag creations
420 # Tell tag renamings from tag creations
421 remainings = []
421 remainings = []
422 for source, sourcerev, tagname in pendings:
422 for source, sourcerev, tagname in pendings:
423 if source.startswith(srctagspath):
423 if source.startswith(srctagspath):
424 remainings.append([source, sourcerev, tagname])
424 remainings.append([source, sourcerev, tagname])
425 continue
425 continue
426 # From revision may be fake, get one with changes
426 # From revision may be fake, get one with changes
427 tagid = self.latest(source, sourcerev)
427 tagid = self.latest(source, sourcerev)
428 if tagid:
428 if tagid:
429 tags[tagname] = tagid
429 tags[tagname] = tagid
430 pendings = remainings
430 pendings = remainings
431 tagspath = srctagspath
431 tagspath = srctagspath
432
432
433 except SubversionException, (inst, num):
433 except SubversionException, (inst, num):
434 self.ui.note('no tags found at revision %d\n' % start)
434 self.ui.note('no tags found at revision %d\n' % start)
435 return tags
435 return tags
436
436
437 def converted(self, rev, destrev):
437 def converted(self, rev, destrev):
438 if not self.wc:
438 if not self.wc:
439 return
439 return
440 if self.convertfp is None:
440 if self.convertfp is None:
441 self.convertfp = open(os.path.join(self.wc, '.svn', 'hg-shamap'),
441 self.convertfp = open(os.path.join(self.wc, '.svn', 'hg-shamap'),
442 'a')
442 'a')
443 self.convertfp.write('%s %d\n' % (destrev, self.revnum(rev)))
443 self.convertfp.write('%s %d\n' % (destrev, self.revnum(rev)))
444 self.convertfp.flush()
444 self.convertfp.flush()
445
445
446 # -- helper functions --
446 # -- helper functions --
447
447
448 def revid(self, revnum, module=None):
448 def revid(self, revnum, module=None):
449 if not module:
449 if not module:
450 module = self.module
450 module = self.module
451 return u"svn:%s%s@%s" % (self.uuid, module.decode(self.encoding),
451 return u"svn:%s%s@%s" % (self.uuid, module.decode(self.encoding),
452 revnum)
452 revnum)
453
453
454 def revnum(self, rev):
454 def revnum(self, rev):
455 return int(rev.split('@')[-1])
455 return int(rev.split('@')[-1])
456
456
457 def revsplit(self, rev):
457 def revsplit(self, rev):
458 url, revnum = rev.encode(self.encoding).split('@', 1)
458 url, revnum = rev.encode(self.encoding).split('@', 1)
459 revnum = int(revnum)
459 revnum = int(revnum)
460 parts = url.split('/', 1)
460 parts = url.split('/', 1)
461 uuid = parts.pop(0)[4:]
461 uuid = parts.pop(0)[4:]
462 mod = ''
462 mod = ''
463 if parts:
463 if parts:
464 mod = '/' + parts[0]
464 mod = '/' + parts[0]
465 return uuid, mod, revnum
465 return uuid, mod, revnum
466
466
467 def latest(self, path, stop=0):
467 def latest(self, path, stop=0):
468 """Find the latest revid affecting path, up to stop. It may return
468 """Find the latest revid affecting path, up to stop. It may return
469 a revision in a different module, since a branch may be moved without
469 a revision in a different module, since a branch may be moved without
470 a change being reported. Return None if computed module does not
470 a change being reported. Return None if computed module does not
471 belong to rootmodule subtree.
471 belong to rootmodule subtree.
472 """
472 """
473 if not path.startswith(self.rootmodule):
473 if not path.startswith(self.rootmodule):
474 # Requests on foreign branches may be forbidden at server level
474 # Requests on foreign branches may be forbidden at server level
475 self.ui.debug(_('ignoring foreign branch %r\n') % path)
475 self.ui.debug(_('ignoring foreign branch %r\n') % path)
476 return None
476 return None
477
477
478 if not stop:
478 if not stop:
479 stop = svn.ra.get_latest_revnum(self.ra)
479 stop = svn.ra.get_latest_revnum(self.ra)
480 try:
480 try:
481 self.reparent('')
481 self.reparent('')
482 dirent = svn.ra.stat(self.ra, path.strip('/'), stop)
482 dirent = svn.ra.stat(self.ra, path.strip('/'), stop)
483 self.reparent(self.module)
483 self.reparent(self.module)
484 except SubversionException:
484 except SubversionException:
485 dirent = None
485 dirent = None
486 if not dirent:
486 if not dirent:
487 raise util.Abort('%s not found up to revision %d' % (path, stop))
487 raise util.Abort('%s not found up to revision %d' % (path, stop))
488
488
489 # stat() gives us the previous revision on this line of development, but
489 # stat() gives us the previous revision on this line of development, but
490 # it might be in *another module*. Fetch the log and detect renames down
490 # it might be in *another module*. Fetch the log and detect renames down
491 # to the latest revision.
491 # to the latest revision.
492 stream = get_log(self.url, [path], stop, dirent.created_rev)
492 stream = get_log(self.url, [path], stop, dirent.created_rev)
493 try:
493 try:
494 for entry in stream:
494 for entry in stream:
495 paths, revnum, author, date, message = entry
495 paths, revnum, author, date, message = entry
496 if revnum <= dirent.created_rev:
496 if revnum <= dirent.created_rev:
497 break
497 break
498
498
499 for p in paths:
499 for p in paths:
500 if not path.startswith(p) or not paths[p].copyfrom_path:
500 if not path.startswith(p) or not paths[p].copyfrom_path:
501 continue
501 continue
502 newpath = paths[p].copyfrom_path + path[len(p):]
502 newpath = paths[p].copyfrom_path + path[len(p):]
503 self.ui.debug("branch renamed from %s to %s at %d\n" %
503 self.ui.debug("branch renamed from %s to %s at %d\n" %
504 (path, newpath, revnum))
504 (path, newpath, revnum))
505 path = newpath
505 path = newpath
506 break
506 break
507 finally:
507 finally:
508 stream.close()
508 stream.close()
509
509
510 if not path.startswith(self.rootmodule):
510 if not path.startswith(self.rootmodule):
511 self.ui.debug(_('ignoring foreign branch %r\n') % path)
511 self.ui.debug(_('ignoring foreign branch %r\n') % path)
512 return None
512 return None
513 return self.revid(dirent.created_rev, path)
513 return self.revid(dirent.created_rev, path)
514
514
515 def get_blacklist(self):
515 def get_blacklist(self):
516 """Avoid certain revision numbers.
516 """Avoid certain revision numbers.
517 It is not uncommon for two nearby revisions to cancel each other
517 It is not uncommon for two nearby revisions to cancel each other
518 out, e.g. 'I copied trunk into a subdirectory of itself instead
518 out, e.g. 'I copied trunk into a subdirectory of itself instead
519 of making a branch'. The converted repository is significantly
519 of making a branch'. The converted repository is significantly
520 smaller if we ignore such revisions."""
520 smaller if we ignore such revisions."""
521 self.blacklist = util.set()
521 self.blacklist = util.set()
522 blacklist = self.blacklist
522 blacklist = self.blacklist
523 for line in file("blacklist.txt", "r"):
523 for line in file("blacklist.txt", "r"):
524 if not line.startswith("#"):
524 if not line.startswith("#"):
525 try:
525 try:
526 svn_rev = int(line.strip())
526 svn_rev = int(line.strip())
527 blacklist.add(svn_rev)
527 blacklist.add(svn_rev)
528 except ValueError, e:
528 except ValueError, e:
529 pass # not an integer or a comment
529 pass # not an integer or a comment
530
530
531 def is_blacklisted(self, svn_rev):
531 def is_blacklisted(self, svn_rev):
532 return svn_rev in self.blacklist
532 return svn_rev in self.blacklist
533
533
534 def reparent(self, module):
534 def reparent(self, module):
535 svn_url = self.base + module
535 svn_url = self.base + module
536 self.ui.debug("reparent to %s\n" % svn_url.encode(self.encoding))
536 self.ui.debug("reparent to %s\n" % svn_url.encode(self.encoding))
537 svn.ra.reparent(self.ra, svn_url.encode(self.encoding))
537 svn.ra.reparent(self.ra, svn_url.encode(self.encoding))
538
538
539 def expandpaths(self, rev, paths, parents):
539 def expandpaths(self, rev, paths, parents):
540 entries = []
540 entries = []
541 copyfrom = {} # Map of entrypath, revision for finding source of deleted revisions.
541 copyfrom = {} # Map of entrypath, revision for finding source of deleted revisions.
542 copies = {}
542 copies = {}
543
543
544 new_module, revnum = self.revsplit(rev)[1:]
544 new_module, revnum = self.revsplit(rev)[1:]
545 if new_module != self.module:
545 if new_module != self.module:
546 self.module = new_module
546 self.module = new_module
547 self.reparent(self.module)
547 self.reparent(self.module)
548
548
549 for path, ent in paths:
549 for path, ent in paths:
550 entrypath = self.getrelpath(path)
550 entrypath = self.getrelpath(path)
551 entry = entrypath.decode(self.encoding)
551 entry = entrypath.decode(self.encoding)
552
552
553 kind = svn.ra.check_path(self.ra, entrypath, revnum)
553 kind = svn.ra.check_path(self.ra, entrypath, revnum)
554 if kind == svn.core.svn_node_file:
554 if kind == svn.core.svn_node_file:
555 if ent.copyfrom_path:
556 copyfrom_path = self.getrelpath(ent.copyfrom_path)
557 if copyfrom_path:
558 self.ui.debug("Copied to %s from %s@%s\n" %
559 (entrypath, copyfrom_path,
560 ent.copyfrom_rev))
561 # It's probably important for hg that the source
562 # exists in the revision's parent, not just the
563 # ent.copyfrom_rev
564 fromkind = svn.ra.check_path(self.ra, copyfrom_path, ent.copyfrom_rev)
565 if fromkind != 0:
566 copies[self.recode(entry)] = self.recode(copyfrom_path)
567 entries.append(self.recode(entry))
555 entries.append(self.recode(entry))
556
557 if not ent.copyfrom_path:
558 continue
559 copyfrom_path = self.getrelpath(ent.copyfrom_path)
560 if not copyfrom_path:
561 continue
562 self.ui.debug("copied to %s from %s@%s\n" %
563 (entrypath, copyfrom_path, ent.copyfrom_rev))
564 # It's probably important for hg that the source
565 # exists in the revision's parent, not just the
566 # ent.copyfrom_rev
567 fromkind = svn.ra.check_path(self.ra, copyfrom_path, ent.copyfrom_rev)
568 if fromkind != 0:
569 copies[self.recode(entry)] = self.recode(copyfrom_path)
568 elif kind == 0: # gone, but had better be a deleted *file*
570 elif kind == 0: # gone, but had better be a deleted *file*
569 self.ui.debug("gone from %s\n" % ent.copyfrom_rev)
571 self.ui.debug("gone from %s\n" % ent.copyfrom_rev)
570
572
571 # if a branch is created but entries are removed in the same
573 # if a branch is created but entries are removed in the same
572 # changeset, get the right fromrev
574 # changeset, get the right fromrev
573 # parents cannot be empty here, you cannot remove things from
575 # parents cannot be empty here, you cannot remove things from
574 # a root revision.
576 # a root revision.
575 uuid, old_module, fromrev = self.revsplit(parents[0])
577 uuid, old_module, fromrev = self.revsplit(parents[0])
576
578
577 basepath = old_module + "/" + self.getrelpath(path)
579 basepath = old_module + "/" + self.getrelpath(path)
578 entrypath = basepath
580 entrypath = basepath
579
581
580 def lookup_parts(p):
582 def lookup_parts(p):
581 rc = None
583 rc = None
582 parts = p.split("/")
584 parts = p.split("/")
583 for i in range(len(parts)):
585 for i in range(len(parts)):
584 part = "/".join(parts[:i])
586 part = "/".join(parts[:i])
585 info = part, copyfrom.get(part, None)
587 info = part, copyfrom.get(part, None)
586 if info[1] is not None:
588 if info[1] is not None:
587 self.ui.debug("Found parent directory %s\n" % info[1])
589 self.ui.debug("Found parent directory %s\n" % info[1])
588 rc = info
590 rc = info
589 return rc
591 return rc
590
592
591 self.ui.debug("base, entry %s %s\n" % (basepath, entrypath))
593 self.ui.debug("base, entry %s %s\n" % (basepath, entrypath))
592
594
593 frompath, froment = lookup_parts(entrypath) or (None, revnum - 1)
595 frompath, froment = lookup_parts(entrypath) or (None, revnum - 1)
594
596
595 # need to remove fragment from lookup_parts and replace with copyfrom_path
597 # need to remove fragment from lookup_parts and replace with copyfrom_path
596 if frompath is not None:
598 if frompath is not None:
597 self.ui.debug("munge-o-matic\n")
599 self.ui.debug("munge-o-matic\n")
598 self.ui.debug(entrypath + '\n')
600 self.ui.debug(entrypath + '\n')
599 self.ui.debug(entrypath[len(frompath):] + '\n')
601 self.ui.debug(entrypath[len(frompath):] + '\n')
600 entrypath = froment.copyfrom_path + entrypath[len(frompath):]
602 entrypath = froment.copyfrom_path + entrypath[len(frompath):]
601 fromrev = froment.copyfrom_rev
603 fromrev = froment.copyfrom_rev
602 self.ui.debug("Info: %s %s %s %s\n" % (frompath, froment, ent, entrypath))
604 self.ui.debug("Info: %s %s %s %s\n" % (frompath, froment, ent, entrypath))
603
605
604 # We can avoid the reparent calls if the module has not changed
606 # We can avoid the reparent calls if the module has not changed
605 # but it probably does not worth the pain.
607 # but it probably does not worth the pain.
606 self.reparent('')
608 self.reparent('')
607 fromkind = svn.ra.check_path(self.ra, entrypath.strip('/'), fromrev)
609 fromkind = svn.ra.check_path(self.ra, entrypath.strip('/'), fromrev)
608 self.reparent(self.module)
610 self.reparent(self.module)
609
611
610 if fromkind == svn.core.svn_node_file: # a deleted file
612 if fromkind == svn.core.svn_node_file: # a deleted file
611 entries.append(self.recode(entry))
613 entries.append(self.recode(entry))
612 elif fromkind == svn.core.svn_node_dir:
614 elif fromkind == svn.core.svn_node_dir:
613 # print "Deleted/moved non-file:", revnum, path, ent
615 # print "Deleted/moved non-file:", revnum, path, ent
614 # children = self._find_children(path, revnum - 1)
616 # children = self._find_children(path, revnum - 1)
615 # print "find children %s@%d from %d action %s" % (path, revnum, ent.copyfrom_rev, ent.action)
617 # print "find children %s@%d from %d action %s" % (path, revnum, ent.copyfrom_rev, ent.action)
616 # Sometimes this is tricky. For example: in
618 # Sometimes this is tricky. For example: in
617 # The Subversion Repository revision 6940 a dir
619 # The Subversion Repository revision 6940 a dir
618 # was copied and one of its files was deleted
620 # was copied and one of its files was deleted
619 # from the new location in the same commit. This
621 # from the new location in the same commit. This
620 # code can't deal with that yet.
622 # code can't deal with that yet.
621 if ent.action == 'C':
623 if ent.action == 'C':
622 children = self._find_children(path, fromrev)
624 children = self._find_children(path, fromrev)
623 else:
625 else:
624 oroot = entrypath.strip('/')
626 oroot = entrypath.strip('/')
625 nroot = path.strip('/')
627 nroot = path.strip('/')
626 children = self._find_children(oroot, fromrev)
628 children = self._find_children(oroot, fromrev)
627 children = [s.replace(oroot,nroot) for s in children]
629 children = [s.replace(oroot,nroot) for s in children]
628 # Mark all [files, not directories] as deleted.
630 # Mark all [files, not directories] as deleted.
629 for child in children:
631 for child in children:
630 # Can we move a child directory and its
632 # Can we move a child directory and its
631 # parent in the same commit? (probably can). Could
633 # parent in the same commit? (probably can). Could
632 # cause problems if instead of revnum -1,
634 # cause problems if instead of revnum -1,
633 # we have to look in (copyfrom_path, revnum - 1)
635 # we have to look in (copyfrom_path, revnum - 1)
634 entrypath = self.getrelpath("/" + child, module=old_module)
636 entrypath = self.getrelpath("/" + child, module=old_module)
635 if entrypath:
637 if entrypath:
636 entry = self.recode(entrypath.decode(self.encoding))
638 entry = self.recode(entrypath.decode(self.encoding))
637 if entry in copies:
639 if entry in copies:
638 # deleted file within a copy
640 # deleted file within a copy
639 del copies[entry]
641 del copies[entry]
640 else:
642 else:
641 entries.append(entry)
643 entries.append(entry)
642 else:
644 else:
643 self.ui.debug('unknown path in revision %d: %s\n' % \
645 self.ui.debug('unknown path in revision %d: %s\n' % \
644 (revnum, path))
646 (revnum, path))
645 elif kind == svn.core.svn_node_dir:
647 elif kind == svn.core.svn_node_dir:
646 # Should probably synthesize normal file entries
648 # Should probably synthesize normal file entries
647 # and handle as above to clean up copy/rename handling.
649 # and handle as above to clean up copy/rename handling.
648
650
649 # If the directory just had a prop change,
651 # If the directory just had a prop change,
650 # then we shouldn't need to look for its children.
652 # then we shouldn't need to look for its children.
651 if ent.action == 'M':
653 if ent.action == 'M':
652 continue
654 continue
653
655
654 # Also this could create duplicate entries. Not sure
656 # Also this could create duplicate entries. Not sure
655 # whether this will matter. Maybe should make entries a set.
657 # whether this will matter. Maybe should make entries a set.
656 # print "Changed directory", revnum, path, ent.action, ent.copyfrom_path, ent.copyfrom_rev
658 # print "Changed directory", revnum, path, ent.action, ent.copyfrom_path, ent.copyfrom_rev
657 # This will fail if a directory was copied
659 # This will fail if a directory was copied
658 # from another branch and then some of its files
660 # from another branch and then some of its files
659 # were deleted in the same transaction.
661 # were deleted in the same transaction.
660 children = self._find_children(path, revnum)
662 children = self._find_children(path, revnum)
661 children.sort()
663 children.sort()
662 for child in children:
664 for child in children:
663 # Can we move a child directory and its
665 # Can we move a child directory and its
664 # parent in the same commit? (probably can). Could
666 # parent in the same commit? (probably can). Could
665 # cause problems if instead of revnum -1,
667 # cause problems if instead of revnum -1,
666 # we have to look in (copyfrom_path, revnum - 1)
668 # we have to look in (copyfrom_path, revnum - 1)
667 entrypath = self.getrelpath("/" + child)
669 entrypath = self.getrelpath("/" + child)
668 # print child, self.module, entrypath
670 # print child, self.module, entrypath
669 if entrypath:
671 if entrypath:
670 # Need to filter out directories here...
672 # Need to filter out directories here...
671 kind = svn.ra.check_path(self.ra, entrypath, revnum)
673 kind = svn.ra.check_path(self.ra, entrypath, revnum)
672 if kind != svn.core.svn_node_dir:
674 if kind != svn.core.svn_node_dir:
673 entries.append(self.recode(entrypath))
675 entries.append(self.recode(entrypath))
674
676
675 # Copies here (must copy all from source)
677 # Copies here (must copy all from source)
676 # Probably not a real problem for us if
678 # Probably not a real problem for us if
677 # source does not exist
679 # source does not exist
678 if not ent.copyfrom_path or not parents:
680 if not ent.copyfrom_path or not parents:
679 continue
681 continue
680 # Copy sources not in parent revisions cannot be represented,
682 # Copy sources not in parent revisions cannot be represented,
681 # ignore their origin for now
683 # ignore their origin for now
682 pmodule, prevnum = self.revsplit(parents[0])[1:]
684 pmodule, prevnum = self.revsplit(parents[0])[1:]
683 if ent.copyfrom_rev < prevnum:
685 if ent.copyfrom_rev < prevnum:
684 continue
686 continue
685 copyfrompath = ent.copyfrom_path.decode(self.encoding)
687 copyfrompath = ent.copyfrom_path.decode(self.encoding)
686 copyfrompath = self.getrelpath(copyfrompath, pmodule)
688 copyfrompath = self.getrelpath(copyfrompath, pmodule)
687 if not copyfrompath:
689 if not copyfrompath:
688 continue
690 continue
689 copyfrom[path] = ent
691 copyfrom[path] = ent
690 self.ui.debug("mark %s came from %s:%d\n"
692 self.ui.debug("mark %s came from %s:%d\n"
691 % (path, copyfrompath, ent.copyfrom_rev))
693 % (path, copyfrompath, ent.copyfrom_rev))
692 children = self._find_children(ent.copyfrom_path, ent.copyfrom_rev)
694 children = self._find_children(ent.copyfrom_path, ent.copyfrom_rev)
693 children.sort()
695 children.sort()
694 for child in children:
696 for child in children:
695 entrypath = self.getrelpath("/" + child, pmodule)
697 entrypath = self.getrelpath("/" + child, pmodule)
696 if not entrypath:
698 if not entrypath:
697 continue
699 continue
698 entry = entrypath.decode(self.encoding)
700 entry = entrypath.decode(self.encoding)
699 copytopath = path + entry[len(copyfrompath):]
701 copytopath = path + entry[len(copyfrompath):]
700 copytopath = self.getrelpath(copytopath)
702 copytopath = self.getrelpath(copytopath)
701 copies[self.recode(copytopath)] = self.recode(entry, pmodule)
703 copies[self.recode(copytopath)] = self.recode(entry, pmodule)
702
704
703 return (util.unique(entries), copies)
705 return (util.unique(entries), copies)
704
706
705 def _fetch_revisions(self, from_revnum, to_revnum):
707 def _fetch_revisions(self, from_revnum, to_revnum):
706 if from_revnum < to_revnum:
708 if from_revnum < to_revnum:
707 from_revnum, to_revnum = to_revnum, from_revnum
709 from_revnum, to_revnum = to_revnum, from_revnum
708
710
709 self.child_cset = None
711 self.child_cset = None
710 def parselogentry(orig_paths, revnum, author, date, message):
712 def parselogentry(orig_paths, revnum, author, date, message):
711 """Return the parsed commit object or None, and True if
713 """Return the parsed commit object or None, and True if
712 the revision is a branch root.
714 the revision is a branch root.
713 """
715 """
714 self.ui.debug("parsing revision %d (%d changes)\n" %
716 self.ui.debug("parsing revision %d (%d changes)\n" %
715 (revnum, len(orig_paths)))
717 (revnum, len(orig_paths)))
716
718
717 branched = False
719 branched = False
718 rev = self.revid(revnum)
720 rev = self.revid(revnum)
719 # branch log might return entries for a parent we already have
721 # branch log might return entries for a parent we already have
720
722
721 if (rev in self.commits or revnum < to_revnum):
723 if (rev in self.commits or revnum < to_revnum):
722 return None, branched
724 return None, branched
723
725
724 parents = []
726 parents = []
725 # check whether this revision is the start of a branch or part
727 # check whether this revision is the start of a branch or part
726 # of a branch renaming
728 # of a branch renaming
727 orig_paths = orig_paths.items()
729 orig_paths = orig_paths.items()
728 orig_paths.sort()
730 orig_paths.sort()
729 root_paths = [(p,e) for p,e in orig_paths if self.module.startswith(p)]
731 root_paths = [(p,e) for p,e in orig_paths if self.module.startswith(p)]
730 if root_paths:
732 if root_paths:
731 path, ent = root_paths[-1]
733 path, ent = root_paths[-1]
732 if ent.copyfrom_path:
734 if ent.copyfrom_path:
733 branched = True
735 branched = True
734 newpath = ent.copyfrom_path + self.module[len(path):]
736 newpath = ent.copyfrom_path + self.module[len(path):]
735 # ent.copyfrom_rev may not be the actual last revision
737 # ent.copyfrom_rev may not be the actual last revision
736 previd = self.latest(newpath, ent.copyfrom_rev)
738 previd = self.latest(newpath, ent.copyfrom_rev)
737 if previd is not None:
739 if previd is not None:
738 prevmodule, prevnum = self.revsplit(previd)[1:]
740 prevmodule, prevnum = self.revsplit(previd)[1:]
739 if prevnum >= self.startrev:
741 if prevnum >= self.startrev:
740 parents = [previd]
742 parents = [previd]
741 self.ui.note('found parent of branch %s at %d: %s\n' %
743 self.ui.note('found parent of branch %s at %d: %s\n' %
742 (self.module, prevnum, prevmodule))
744 (self.module, prevnum, prevmodule))
743 else:
745 else:
744 self.ui.debug("No copyfrom path, don't know what to do.\n")
746 self.ui.debug("No copyfrom path, don't know what to do.\n")
745
747
746 paths = []
748 paths = []
747 # filter out unrelated paths
749 # filter out unrelated paths
748 for path, ent in orig_paths:
750 for path, ent in orig_paths:
749 if self.getrelpath(path) is None:
751 if self.getrelpath(path) is None:
750 continue
752 continue
751 paths.append((path, ent))
753 paths.append((path, ent))
752
754
753 # Example SVN datetime. Includes microseconds.
755 # Example SVN datetime. Includes microseconds.
754 # ISO-8601 conformant
756 # ISO-8601 conformant
755 # '2007-01-04T17:35:00.902377Z'
757 # '2007-01-04T17:35:00.902377Z'
756 date = util.parsedate(date[:19] + " UTC", ["%Y-%m-%dT%H:%M:%S"])
758 date = util.parsedate(date[:19] + " UTC", ["%Y-%m-%dT%H:%M:%S"])
757
759
758 log = message and self.recode(message) or ''
760 log = message and self.recode(message) or ''
759 author = author and self.recode(author) or ''
761 author = author and self.recode(author) or ''
760 try:
762 try:
761 branch = self.module.split("/")[-1]
763 branch = self.module.split("/")[-1]
762 if branch == 'trunk':
764 if branch == 'trunk':
763 branch = ''
765 branch = ''
764 except IndexError:
766 except IndexError:
765 branch = None
767 branch = None
766
768
767 cset = commit(author=author,
769 cset = commit(author=author,
768 date=util.datestr(date),
770 date=util.datestr(date),
769 desc=log,
771 desc=log,
770 parents=parents,
772 parents=parents,
771 branch=branch,
773 branch=branch,
772 rev=rev.encode('utf-8'))
774 rev=rev.encode('utf-8'))
773
775
774 self.commits[rev] = cset
776 self.commits[rev] = cset
775 # The parents list is *shared* among self.paths and the
777 # The parents list is *shared* among self.paths and the
776 # commit object. Both will be updated below.
778 # commit object. Both will be updated below.
777 self.paths[rev] = (paths, cset.parents)
779 self.paths[rev] = (paths, cset.parents)
778 if self.child_cset and not self.child_cset.parents:
780 if self.child_cset and not self.child_cset.parents:
779 self.child_cset.parents[:] = [rev]
781 self.child_cset.parents[:] = [rev]
780 self.child_cset = cset
782 self.child_cset = cset
781 return cset, branched
783 return cset, branched
782
784
783 self.ui.note('fetching revision log for "%s" from %d to %d\n' %
785 self.ui.note('fetching revision log for "%s" from %d to %d\n' %
784 (self.module, from_revnum, to_revnum))
786 (self.module, from_revnum, to_revnum))
785
787
786 try:
788 try:
787 firstcset = None
789 firstcset = None
788 lastonbranch = False
790 lastonbranch = False
789 stream = get_log(self.url, [self.module], from_revnum, to_revnum)
791 stream = get_log(self.url, [self.module], from_revnum, to_revnum)
790 try:
792 try:
791 for entry in stream:
793 for entry in stream:
792 paths, revnum, author, date, message = entry
794 paths, revnum, author, date, message = entry
793 if revnum < self.startrev:
795 if revnum < self.startrev:
794 lastonbranch = True
796 lastonbranch = True
795 break
797 break
796 if self.is_blacklisted(revnum):
798 if self.is_blacklisted(revnum):
797 self.ui.note('skipping blacklisted revision %d\n'
799 self.ui.note('skipping blacklisted revision %d\n'
798 % revnum)
800 % revnum)
799 continue
801 continue
800 if paths is None:
802 if paths is None:
801 self.ui.debug('revision %d has no entries\n' % revnum)
803 self.ui.debug('revision %d has no entries\n' % revnum)
802 continue
804 continue
803 cset, lastonbranch = parselogentry(paths, revnum, author,
805 cset, lastonbranch = parselogentry(paths, revnum, author,
804 date, message)
806 date, message)
805 if cset:
807 if cset:
806 firstcset = cset
808 firstcset = cset
807 if lastonbranch:
809 if lastonbranch:
808 break
810 break
809 finally:
811 finally:
810 stream.close()
812 stream.close()
811
813
812 if not lastonbranch and firstcset and not firstcset.parents:
814 if not lastonbranch and firstcset and not firstcset.parents:
813 # The first revision of the sequence (the last fetched one)
815 # The first revision of the sequence (the last fetched one)
814 # has invalid parents if not a branch root. Find the parent
816 # has invalid parents if not a branch root. Find the parent
815 # revision now, if any.
817 # revision now, if any.
816 try:
818 try:
817 firstrevnum = self.revnum(firstcset.rev)
819 firstrevnum = self.revnum(firstcset.rev)
818 if firstrevnum > 1:
820 if firstrevnum > 1:
819 latest = self.latest(self.module, firstrevnum - 1)
821 latest = self.latest(self.module, firstrevnum - 1)
820 if latest:
822 if latest:
821 firstcset.parents.append(latest)
823 firstcset.parents.append(latest)
822 except util.Abort:
824 except util.Abort:
823 pass
825 pass
824 except SubversionException, (inst, num):
826 except SubversionException, (inst, num):
825 if num == svn.core.SVN_ERR_FS_NO_SUCH_REVISION:
827 if num == svn.core.SVN_ERR_FS_NO_SUCH_REVISION:
826 raise util.Abort('svn: branch has no revision %s' % to_revnum)
828 raise util.Abort('svn: branch has no revision %s' % to_revnum)
827 raise
829 raise
828
830
829 def _getfile(self, file, rev):
831 def _getfile(self, file, rev):
830 io = StringIO()
832 io = StringIO()
831 # TODO: ra.get_file transmits the whole file instead of diffs.
833 # TODO: ra.get_file transmits the whole file instead of diffs.
832 mode = ''
834 mode = ''
833 try:
835 try:
834 new_module, revnum = self.revsplit(rev)[1:]
836 new_module, revnum = self.revsplit(rev)[1:]
835 if self.module != new_module:
837 if self.module != new_module:
836 self.module = new_module
838 self.module = new_module
837 self.reparent(self.module)
839 self.reparent(self.module)
838 info = svn.ra.get_file(self.ra, file, revnum, io)
840 info = svn.ra.get_file(self.ra, file, revnum, io)
839 if isinstance(info, list):
841 if isinstance(info, list):
840 info = info[-1]
842 info = info[-1]
841 mode = ("svn:executable" in info) and 'x' or ''
843 mode = ("svn:executable" in info) and 'x' or ''
842 mode = ("svn:special" in info) and 'l' or mode
844 mode = ("svn:special" in info) and 'l' or mode
843 except SubversionException, e:
845 except SubversionException, e:
844 notfound = (svn.core.SVN_ERR_FS_NOT_FOUND,
846 notfound = (svn.core.SVN_ERR_FS_NOT_FOUND,
845 svn.core.SVN_ERR_RA_DAV_PATH_NOT_FOUND)
847 svn.core.SVN_ERR_RA_DAV_PATH_NOT_FOUND)
846 if e.apr_err in notfound: # File not found
848 if e.apr_err in notfound: # File not found
847 raise IOError()
849 raise IOError()
848 raise
850 raise
849 data = io.getvalue()
851 data = io.getvalue()
850 if mode == 'l':
852 if mode == 'l':
851 link_prefix = "link "
853 link_prefix = "link "
852 if data.startswith(link_prefix):
854 if data.startswith(link_prefix):
853 data = data[len(link_prefix):]
855 data = data[len(link_prefix):]
854 return data, mode
856 return data, mode
855
857
856 def _find_children(self, path, revnum):
858 def _find_children(self, path, revnum):
857 path = path.strip('/')
859 path = path.strip('/')
858 pool = Pool()
860 pool = Pool()
859 rpath = '/'.join([self.base, path]).strip('/')
861 rpath = '/'.join([self.base, path]).strip('/')
860 return ['%s/%s' % (path, x) for x in svn.client.ls(rpath, optrev(revnum), True, self.ctx, pool).keys()]
862 return ['%s/%s' % (path, x) for x in svn.client.ls(rpath, optrev(revnum), True, self.ctx, pool).keys()]
861
863
862 def getrelpath(self, path, module=None):
864 def getrelpath(self, path, module=None):
863 if module is None:
865 if module is None:
864 module = self.module
866 module = self.module
865 # Given the repository url of this wc, say
867 # Given the repository url of this wc, say
866 # "http://server/plone/CMFPlone/branches/Plone-2_0-branch"
868 # "http://server/plone/CMFPlone/branches/Plone-2_0-branch"
867 # extract the "entry" portion (a relative path) from what
869 # extract the "entry" portion (a relative path) from what
868 # svn log --xml says, ie
870 # svn log --xml says, ie
869 # "/CMFPlone/branches/Plone-2_0-branch/tests/PloneTestCase.py"
871 # "/CMFPlone/branches/Plone-2_0-branch/tests/PloneTestCase.py"
870 # that is to say "tests/PloneTestCase.py"
872 # that is to say "tests/PloneTestCase.py"
871 if path.startswith(module):
873 if path.startswith(module):
872 relative = path.rstrip('/')[len(module):]
874 relative = path.rstrip('/')[len(module):]
873 if relative.startswith('/'):
875 if relative.startswith('/'):
874 return relative[1:]
876 return relative[1:]
875 elif relative == '':
877 elif relative == '':
876 return relative
878 return relative
877
879
878 # The path is outside our tracked tree...
880 # The path is outside our tracked tree...
879 self.ui.debug('%r is not under %r, ignoring\n' % (path, module))
881 self.ui.debug('%r is not under %r, ignoring\n' % (path, module))
880 return None
882 return None
881
883
882 pre_revprop_change = '''#!/bin/sh
884 pre_revprop_change = '''#!/bin/sh
883
885
884 REPOS="$1"
886 REPOS="$1"
885 REV="$2"
887 REV="$2"
886 USER="$3"
888 USER="$3"
887 PROPNAME="$4"
889 PROPNAME="$4"
888 ACTION="$5"
890 ACTION="$5"
889
891
890 if [ "$ACTION" = "M" -a "$PROPNAME" = "svn:log" ]; then exit 0; fi
892 if [ "$ACTION" = "M" -a "$PROPNAME" = "svn:log" ]; then exit 0; fi
891 if [ "$ACTION" = "A" -a "$PROPNAME" = "hg:convert-branch" ]; then exit 0; fi
893 if [ "$ACTION" = "A" -a "$PROPNAME" = "hg:convert-branch" ]; then exit 0; fi
892 if [ "$ACTION" = "A" -a "$PROPNAME" = "hg:convert-rev" ]; then exit 0; fi
894 if [ "$ACTION" = "A" -a "$PROPNAME" = "hg:convert-rev" ]; then exit 0; fi
893
895
894 echo "Changing prohibited revision property" >&2
896 echo "Changing prohibited revision property" >&2
895 exit 1
897 exit 1
896 '''
898 '''
897
899
898 class svn_sink(converter_sink, commandline):
900 class svn_sink(converter_sink, commandline):
899 commit_re = re.compile(r'Committed revision (\d+).', re.M)
901 commit_re = re.compile(r'Committed revision (\d+).', re.M)
900
902
901 def prerun(self):
903 def prerun(self):
902 if self.wc:
904 if self.wc:
903 os.chdir(self.wc)
905 os.chdir(self.wc)
904
906
905 def postrun(self):
907 def postrun(self):
906 if self.wc:
908 if self.wc:
907 os.chdir(self.cwd)
909 os.chdir(self.cwd)
908
910
909 def join(self, name):
911 def join(self, name):
910 return os.path.join(self.wc, '.svn', name)
912 return os.path.join(self.wc, '.svn', name)
911
913
912 def revmapfile(self):
914 def revmapfile(self):
913 return self.join('hg-shamap')
915 return self.join('hg-shamap')
914
916
915 def authorfile(self):
917 def authorfile(self):
916 return self.join('hg-authormap')
918 return self.join('hg-authormap')
917
919
918 def __init__(self, ui, path):
920 def __init__(self, ui, path):
919 converter_sink.__init__(self, ui, path)
921 converter_sink.__init__(self, ui, path)
920 commandline.__init__(self, ui, 'svn')
922 commandline.__init__(self, ui, 'svn')
921 self.delete = []
923 self.delete = []
922 self.setexec = []
924 self.setexec = []
923 self.delexec = []
925 self.delexec = []
924 self.copies = []
926 self.copies = []
925 self.wc = None
927 self.wc = None
926 self.cwd = os.getcwd()
928 self.cwd = os.getcwd()
927
929
928 path = os.path.realpath(path)
930 path = os.path.realpath(path)
929
931
930 created = False
932 created = False
931 if os.path.isfile(os.path.join(path, '.svn', 'entries')):
933 if os.path.isfile(os.path.join(path, '.svn', 'entries')):
932 self.wc = path
934 self.wc = path
933 self.run0('update')
935 self.run0('update')
934 else:
936 else:
935 wcpath = os.path.join(os.getcwd(), os.path.basename(path) + '-wc')
937 wcpath = os.path.join(os.getcwd(), os.path.basename(path) + '-wc')
936
938
937 if os.path.isdir(os.path.dirname(path)):
939 if os.path.isdir(os.path.dirname(path)):
938 if not os.path.exists(os.path.join(path, 'db', 'fs-type')):
940 if not os.path.exists(os.path.join(path, 'db', 'fs-type')):
939 ui.status(_('initializing svn repo %r\n') %
941 ui.status(_('initializing svn repo %r\n') %
940 os.path.basename(path))
942 os.path.basename(path))
941 commandline(ui, 'svnadmin').run0('create', path)
943 commandline(ui, 'svnadmin').run0('create', path)
942 created = path
944 created = path
943 path = util.normpath(path)
945 path = util.normpath(path)
944 if not path.startswith('/'):
946 if not path.startswith('/'):
945 path = '/' + path
947 path = '/' + path
946 path = 'file://' + path
948 path = 'file://' + path
947
949
948 ui.status(_('initializing svn wc %r\n') % os.path.basename(wcpath))
950 ui.status(_('initializing svn wc %r\n') % os.path.basename(wcpath))
949 self.run0('checkout', path, wcpath)
951 self.run0('checkout', path, wcpath)
950
952
951 self.wc = wcpath
953 self.wc = wcpath
952 self.opener = util.opener(self.wc)
954 self.opener = util.opener(self.wc)
953 self.wopener = util.opener(self.wc)
955 self.wopener = util.opener(self.wc)
954 self.childmap = mapfile(ui, self.join('hg-childmap'))
956 self.childmap = mapfile(ui, self.join('hg-childmap'))
955 self.is_exec = util.checkexec(self.wc) and util.is_exec or None
957 self.is_exec = util.checkexec(self.wc) and util.is_exec or None
956
958
957 if created:
959 if created:
958 hook = os.path.join(created, 'hooks', 'pre-revprop-change')
960 hook = os.path.join(created, 'hooks', 'pre-revprop-change')
959 fp = open(hook, 'w')
961 fp = open(hook, 'w')
960 fp.write(pre_revprop_change)
962 fp.write(pre_revprop_change)
961 fp.close()
963 fp.close()
962 util.set_flags(hook, "x")
964 util.set_flags(hook, "x")
963
965
964 xport = transport.SvnRaTransport(url=geturl(path))
966 xport = transport.SvnRaTransport(url=geturl(path))
965 self.uuid = svn.ra.get_uuid(xport.ra)
967 self.uuid = svn.ra.get_uuid(xport.ra)
966
968
967 def wjoin(self, *names):
969 def wjoin(self, *names):
968 return os.path.join(self.wc, *names)
970 return os.path.join(self.wc, *names)
969
971
970 def putfile(self, filename, flags, data):
972 def putfile(self, filename, flags, data):
971 if 'l' in flags:
973 if 'l' in flags:
972 self.wopener.symlink(data, filename)
974 self.wopener.symlink(data, filename)
973 else:
975 else:
974 try:
976 try:
975 if os.path.islink(self.wjoin(filename)):
977 if os.path.islink(self.wjoin(filename)):
976 os.unlink(filename)
978 os.unlink(filename)
977 except OSError:
979 except OSError:
978 pass
980 pass
979 self.wopener(filename, 'w').write(data)
981 self.wopener(filename, 'w').write(data)
980
982
981 if self.is_exec:
983 if self.is_exec:
982 was_exec = self.is_exec(self.wjoin(filename))
984 was_exec = self.is_exec(self.wjoin(filename))
983 else:
985 else:
984 # On filesystems not supporting execute-bit, there is no way
986 # On filesystems not supporting execute-bit, there is no way
985 # to know if it is set but asking subversion. Setting it
987 # to know if it is set but asking subversion. Setting it
986 # systematically is just as expensive and much simpler.
988 # systematically is just as expensive and much simpler.
987 was_exec = 'x' not in flags
989 was_exec = 'x' not in flags
988
990
989 util.set_flags(self.wjoin(filename), flags)
991 util.set_flags(self.wjoin(filename), flags)
990 if was_exec:
992 if was_exec:
991 if 'x' not in flags:
993 if 'x' not in flags:
992 self.delexec.append(filename)
994 self.delexec.append(filename)
993 else:
995 else:
994 if 'x' in flags:
996 if 'x' in flags:
995 self.setexec.append(filename)
997 self.setexec.append(filename)
996
998
997 def delfile(self, name):
999 def delfile(self, name):
998 self.delete.append(name)
1000 self.delete.append(name)
999
1001
1000 def copyfile(self, source, dest):
1002 def copyfile(self, source, dest):
1001 self.copies.append([source, dest])
1003 self.copies.append([source, dest])
1002
1004
1003 def _copyfile(self, source, dest):
1005 def _copyfile(self, source, dest):
1004 # SVN's copy command pukes if the destination file exists, but
1006 # SVN's copy command pukes if the destination file exists, but
1005 # our copyfile method expects to record a copy that has
1007 # our copyfile method expects to record a copy that has
1006 # already occurred. Cross the semantic gap.
1008 # already occurred. Cross the semantic gap.
1007 wdest = self.wjoin(dest)
1009 wdest = self.wjoin(dest)
1008 exists = os.path.exists(wdest)
1010 exists = os.path.exists(wdest)
1009 if exists:
1011 if exists:
1010 fd, tempname = tempfile.mkstemp(
1012 fd, tempname = tempfile.mkstemp(
1011 prefix='hg-copy-', dir=os.path.dirname(wdest))
1013 prefix='hg-copy-', dir=os.path.dirname(wdest))
1012 os.close(fd)
1014 os.close(fd)
1013 os.unlink(tempname)
1015 os.unlink(tempname)
1014 os.rename(wdest, tempname)
1016 os.rename(wdest, tempname)
1015 try:
1017 try:
1016 self.run0('copy', source, dest)
1018 self.run0('copy', source, dest)
1017 finally:
1019 finally:
1018 if exists:
1020 if exists:
1019 try:
1021 try:
1020 os.unlink(wdest)
1022 os.unlink(wdest)
1021 except OSError:
1023 except OSError:
1022 pass
1024 pass
1023 os.rename(tempname, wdest)
1025 os.rename(tempname, wdest)
1024
1026
1025 def dirs_of(self, files):
1027 def dirs_of(self, files):
1026 dirs = util.set()
1028 dirs = util.set()
1027 for f in files:
1029 for f in files:
1028 if os.path.isdir(self.wjoin(f)):
1030 if os.path.isdir(self.wjoin(f)):
1029 dirs.add(f)
1031 dirs.add(f)
1030 for i in strutil.rfindall(f, '/'):
1032 for i in strutil.rfindall(f, '/'):
1031 dirs.add(f[:i])
1033 dirs.add(f[:i])
1032 return dirs
1034 return dirs
1033
1035
1034 def add_dirs(self, files):
1036 def add_dirs(self, files):
1035 add_dirs = [d for d in self.dirs_of(files)
1037 add_dirs = [d for d in self.dirs_of(files)
1036 if not os.path.exists(self.wjoin(d, '.svn', 'entries'))]
1038 if not os.path.exists(self.wjoin(d, '.svn', 'entries'))]
1037 if add_dirs:
1039 if add_dirs:
1038 add_dirs.sort()
1040 add_dirs.sort()
1039 self.xargs(add_dirs, 'add', non_recursive=True, quiet=True)
1041 self.xargs(add_dirs, 'add', non_recursive=True, quiet=True)
1040 return add_dirs
1042 return add_dirs
1041
1043
1042 def add_files(self, files):
1044 def add_files(self, files):
1043 if files:
1045 if files:
1044 self.xargs(files, 'add', quiet=True)
1046 self.xargs(files, 'add', quiet=True)
1045 return files
1047 return files
1046
1048
1047 def tidy_dirs(self, names):
1049 def tidy_dirs(self, names):
1048 dirs = list(self.dirs_of(names))
1050 dirs = list(self.dirs_of(names))
1049 dirs.sort()
1051 dirs.sort()
1050 dirs.reverse()
1052 dirs.reverse()
1051 deleted = []
1053 deleted = []
1052 for d in dirs:
1054 for d in dirs:
1053 wd = self.wjoin(d)
1055 wd = self.wjoin(d)
1054 if os.listdir(wd) == '.svn':
1056 if os.listdir(wd) == '.svn':
1055 self.run0('delete', d)
1057 self.run0('delete', d)
1056 deleted.append(d)
1058 deleted.append(d)
1057 return deleted
1059 return deleted
1058
1060
1059 def addchild(self, parent, child):
1061 def addchild(self, parent, child):
1060 self.childmap[parent] = child
1062 self.childmap[parent] = child
1061
1063
1062 def revid(self, rev):
1064 def revid(self, rev):
1063 return u"svn:%s@%s" % (self.uuid, rev)
1065 return u"svn:%s@%s" % (self.uuid, rev)
1064
1066
1065 def putcommit(self, files, parents, commit):
1067 def putcommit(self, files, parents, commit):
1066 for parent in parents:
1068 for parent in parents:
1067 try:
1069 try:
1068 return self.revid(self.childmap[parent])
1070 return self.revid(self.childmap[parent])
1069 except KeyError:
1071 except KeyError:
1070 pass
1072 pass
1071 entries = util.set(self.delete)
1073 entries = util.set(self.delete)
1072 files = util.frozenset(files)
1074 files = util.frozenset(files)
1073 entries.update(self.add_dirs(files.difference(entries)))
1075 entries.update(self.add_dirs(files.difference(entries)))
1074 if self.copies:
1076 if self.copies:
1075 for s, d in self.copies:
1077 for s, d in self.copies:
1076 self._copyfile(s, d)
1078 self._copyfile(s, d)
1077 self.copies = []
1079 self.copies = []
1078 if self.delete:
1080 if self.delete:
1079 self.xargs(self.delete, 'delete')
1081 self.xargs(self.delete, 'delete')
1080 self.delete = []
1082 self.delete = []
1081 entries.update(self.add_files(files.difference(entries)))
1083 entries.update(self.add_files(files.difference(entries)))
1082 entries.update(self.tidy_dirs(entries))
1084 entries.update(self.tidy_dirs(entries))
1083 if self.delexec:
1085 if self.delexec:
1084 self.xargs(self.delexec, 'propdel', 'svn:executable')
1086 self.xargs(self.delexec, 'propdel', 'svn:executable')
1085 self.delexec = []
1087 self.delexec = []
1086 if self.setexec:
1088 if self.setexec:
1087 self.xargs(self.setexec, 'propset', 'svn:executable', '*')
1089 self.xargs(self.setexec, 'propset', 'svn:executable', '*')
1088 self.setexec = []
1090 self.setexec = []
1089
1091
1090 fd, messagefile = tempfile.mkstemp(prefix='hg-convert-')
1092 fd, messagefile = tempfile.mkstemp(prefix='hg-convert-')
1091 fp = os.fdopen(fd, 'w')
1093 fp = os.fdopen(fd, 'w')
1092 fp.write(commit.desc)
1094 fp.write(commit.desc)
1093 fp.close()
1095 fp.close()
1094 try:
1096 try:
1095 output = self.run0('commit',
1097 output = self.run0('commit',
1096 username=util.shortuser(commit.author),
1098 username=util.shortuser(commit.author),
1097 file=messagefile,
1099 file=messagefile,
1098 encoding='utf-8')
1100 encoding='utf-8')
1099 try:
1101 try:
1100 rev = self.commit_re.search(output).group(1)
1102 rev = self.commit_re.search(output).group(1)
1101 except AttributeError:
1103 except AttributeError:
1102 self.ui.warn(_('unexpected svn output:\n'))
1104 self.ui.warn(_('unexpected svn output:\n'))
1103 self.ui.warn(output)
1105 self.ui.warn(output)
1104 raise util.Abort(_('unable to cope with svn output'))
1106 raise util.Abort(_('unable to cope with svn output'))
1105 if commit.rev:
1107 if commit.rev:
1106 self.run('propset', 'hg:convert-rev', commit.rev,
1108 self.run('propset', 'hg:convert-rev', commit.rev,
1107 revprop=True, revision=rev)
1109 revprop=True, revision=rev)
1108 if commit.branch and commit.branch != 'default':
1110 if commit.branch and commit.branch != 'default':
1109 self.run('propset', 'hg:convert-branch', commit.branch,
1111 self.run('propset', 'hg:convert-branch', commit.branch,
1110 revprop=True, revision=rev)
1112 revprop=True, revision=rev)
1111 for parent in parents:
1113 for parent in parents:
1112 self.addchild(parent, rev)
1114 self.addchild(parent, rev)
1113 return self.revid(rev)
1115 return self.revid(rev)
1114 finally:
1116 finally:
1115 os.unlink(messagefile)
1117 os.unlink(messagefile)
1116
1118
1117 def puttags(self, tags):
1119 def puttags(self, tags):
1118 self.ui.warn(_('XXX TAGS NOT IMPLEMENTED YET\n'))
1120 self.ui.warn(_('XXX TAGS NOT IMPLEMENTED YET\n'))
General Comments 0
You need to be logged in to leave comments. Login now