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