Mercurial > traipse_dev

comparison upmana/mercurial/localrepo.py @ 121:496dbf12a6cb alpha

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Traipse Alpha 'OpenRPG' {091030-00} Traipse is a distribution of OpenRPG that is designed to be easy to setup and go. Traipse also makes it easy for developers to work on code without fear of sacrifice. 'Ornery-Orc' continues the trend of 'Grumpy' and adds fixes to the code. 'Ornery-Orc's main goal is to offer more advanced features and enhance the productivity of the user. Update Summary (Cleaning up for Beta): Adds Bookmarks (Alpha) with cool Smiley Star and Plus Symbol images! Changes made to the map for increased portability. SnowDog has changes planned in Core, though. Added an initial push to the BCG. Not much to see, just shows off how it is re-writing Main code. Fix to remote admin commands Minor fix to texted based server, works in /System/ folder Some Core changes to gametree to correctly disply Pretty Print, thanks David! Fix to Splitter Nodes not being created. Added images to Plugin Control panel for Autostart feature Fix to massive amounts of images loading; from Core fix to gsclient so with_statement imports Added 'boot' command to remote admin Prep work in Pass tool for remote admin rankings and different passwords, ei, Server, Admin, Moderator, etc. Remote Admin Commands more organized, more prep work. Added Confirmation window for sent nodes. Minor changes to allow for portability to an OpenSUSE linux OS (hopefully without breaking) {091028} Made changes to gametree to start working with Element Tree, mostly from Core Minor changes to Map to start working with Element Tree, from Core Preliminary changes to map efficiency, from FlexiRPG Miniatures Layer pop up box allows users to turn off Mini labels, from FlexiRPG Changes to main.py to start working with Element Tree {091029} Changes made to server to start working with Element Tree. Changes made to Meta Server Lib. Prepping test work for a multi meta network page. Minor bug fixed with mini to gametree Zoom Mouse plugin added. {091030} Getting ready for Beta. Server needs debugging so Alpha remains bugged. Plugin UI code cleaned. Auto start works with a graphic, pop-up asks to enable or disable plugin. Update Manager now has a partially working Status Bar. Status Bar captures terminal text, so Merc out put is visible. Manifest.xml file, will be renamed, is now much cleaner. Debug Console has a clear button and a Report Bug button. Prep work for a Term2Win class in Debug Console. Known: Current Alpha fails in Windows.
author sirebral
date Fri, 30 Oct 2009 22:21:40 -0500
parents
children
comparison
equal deleted inserted replaced
120:d86e762a994f 121:496dbf12a6cb
1 # localrepo.py - read/write repository class for mercurial
2 #
3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
4 #
5 # This software may be used and distributed according to the terms of the
6 # GNU General Public License version 2, incorporated herein by reference.
7
8 from node import bin, hex, nullid, nullrev, short
9 from i18n import _
10 import repo, changegroup, subrepo
11 import changelog, dirstate, filelog, manifest, context
12 import lock, transaction, store, encoding
13 import util, extensions, hook, error
14 import match as match_
15 import merge as merge_
16 from lock import release
17 import weakref, stat, errno, os, time, inspect
18 propertycache = util.propertycache
19
20 class localrepository(repo.repository):
21 capabilities = set(('lookup', 'changegroupsubset', 'branchmap'))
22 supported = set('revlogv1 store fncache shared'.split())
23
24 def __init__(self, baseui, path=None, create=0):
25 repo.repository.__init__(self)
26 self.root = os.path.realpath(path)
27 self.path = os.path.join(self.root, ".hg")
28 self.origroot = path
29 self.opener = util.opener(self.path)
30 self.wopener = util.opener(self.root)
31 self.baseui = baseui
32 self.ui = baseui.copy()
33
34 try:
35 self.ui.readconfig(self.join("hgrc"), self.root)
36 extensions.loadall(self.ui)
37 except IOError:
38 pass
39
40 if not os.path.isdir(self.path):
41 if create:
42 if not os.path.exists(path):
43 os.mkdir(path)
44 os.mkdir(self.path)
45 requirements = ["revlogv1"]
46 if self.ui.configbool('format', 'usestore', True):
47 os.mkdir(os.path.join(self.path, "store"))
48 requirements.append("store")
49 if self.ui.configbool('format', 'usefncache', True):
50 requirements.append("fncache")
51 # create an invalid changelog
52 self.opener("00changelog.i", "a").write(
53 '\0\0\0\2' # represents revlogv2
54 ' dummy changelog to prevent using the old repo layout'
55 )
56 reqfile = self.opener("requires", "w")
57 for r in requirements:
58 reqfile.write("%s\n" % r)
59 reqfile.close()
60 else:
61 raise error.RepoError(_("repository %s not found") % path)
62 elif create:
63 raise error.RepoError(_("repository %s already exists") % path)
64 else:
65 # find requirements
66 requirements = set()
67 try:
68 requirements = set(self.opener("requires").read().splitlines())
69 except IOError, inst:
70 if inst.errno != errno.ENOENT:
71 raise
72 for r in requirements - self.supported:
73 raise error.RepoError(_("requirement '%s' not supported") % r)
74
75 self.sharedpath = self.path
76 try:
77 s = os.path.realpath(self.opener("sharedpath").read())
78 if not os.path.exists(s):
79 raise error.RepoError(
80 _('.hg/sharedpath points to nonexistent directory %s') % s)
81 self.sharedpath = s
82 except IOError, inst:
83 if inst.errno != errno.ENOENT:
84 raise
85
86 self.store = store.store(requirements, self.sharedpath, util.opener)
87 self.spath = self.store.path
88 self.sopener = self.store.opener
89 self.sjoin = self.store.join
90 self.opener.createmode = self.store.createmode
91
92 self.tagscache = None
93 self._tagstypecache = None
94 self.branchcache = None
95 self._ubranchcache = None # UTF-8 version of branchcache
96 self._branchcachetip = None
97 self.nodetagscache = None
98 self.filterpats = {}
99 self._datafilters = {}
100 self._transref = self._lockref = self._wlockref = None
101
102 @propertycache
103 def changelog(self):
104 c = changelog.changelog(self.sopener)
105 if 'HG_PENDING' in os.environ:
106 p = os.environ['HG_PENDING']
107 if p.startswith(self.root):
108 c.readpending('00changelog.i.a')
109 self.sopener.defversion = c.version
110 return c
111
112 @propertycache
113 def manifest(self):
114 return manifest.manifest(self.sopener)
115
116 @propertycache
117 def dirstate(self):
118 return dirstate.dirstate(self.opener, self.ui, self.root)
119
120 def __getitem__(self, changeid):
121 if changeid is None:
122 return context.workingctx(self)
123 return context.changectx(self, changeid)
124
125 def __nonzero__(self):
126 return True
127
128 def __len__(self):
129 return len(self.changelog)
130
131 def __iter__(self):
132 for i in xrange(len(self)):
133 yield i
134
135 def url(self):
136 return 'file:' + self.root
137
138 def hook(self, name, throw=False, **args):
139 return hook.hook(self.ui, self, name, throw, **args)
140
141 tag_disallowed = ':\r\n'
142
143 def _tag(self, names, node, message, local, user, date, extra={}):
144 if isinstance(names, str):
145 allchars = names
146 names = (names,)
147 else:
148 allchars = ''.join(names)
149 for c in self.tag_disallowed:
150 if c in allchars:
151 raise util.Abort(_('%r cannot be used in a tag name') % c)
152
153 for name in names:
154 self.hook('pretag', throw=True, node=hex(node), tag=name,
155 local=local)
156
157 def writetags(fp, names, munge, prevtags):
158 fp.seek(0, 2)
159 if prevtags and prevtags[-1] != '\n':
160 fp.write('\n')
161 for name in names:
162 m = munge and munge(name) or name
163 if self._tagstypecache and name in self._tagstypecache:
164 old = self.tagscache.get(name, nullid)
165 fp.write('%s %s\n' % (hex(old), m))
166 fp.write('%s %s\n' % (hex(node), m))
167 fp.close()
168
169 prevtags = ''
170 if local:
171 try:
172 fp = self.opener('localtags', 'r+')
173 except IOError:
174 fp = self.opener('localtags', 'a')
175 else:
176 prevtags = fp.read()
177
178 # local tags are stored in the current charset
179 writetags(fp, names, None, prevtags)
180 for name in names:
181 self.hook('tag', node=hex(node), tag=name, local=local)
182 return
183
184 try:
185 fp = self.wfile('.hgtags', 'rb+')
186 except IOError:
187 fp = self.wfile('.hgtags', 'ab')
188 else:
189 prevtags = fp.read()
190
191 # committed tags are stored in UTF-8
192 writetags(fp, names, encoding.fromlocal, prevtags)
193
194 if '.hgtags' not in self.dirstate:
195 self.add(['.hgtags'])
196
197 m = match_.exact(self.root, '', ['.hgtags'])
198 tagnode = self.commit(message, user, date, extra=extra, match=m)
199
200 for name in names:
201 self.hook('tag', node=hex(node), tag=name, local=local)
202
203 return tagnode
204
205 def tag(self, names, node, message, local, user, date):
206 '''tag a revision with one or more symbolic names.
207
208 names is a list of strings or, when adding a single tag, names may be a
209 string.
210
211 if local is True, the tags are stored in a per-repository file.
212 otherwise, they are stored in the .hgtags file, and a new
213 changeset is committed with the change.
214
215 keyword arguments:
216
217 local: whether to store tags in non-version-controlled file
218 (default False)
219
220 message: commit message to use if committing
221
222 user: name of user to use if committing
223
224 date: date tuple to use if committing'''
225
226 for x in self.status()[:5]:
227 if '.hgtags' in x:
228 raise util.Abort(_('working copy of .hgtags is changed '
229 '(please commit .hgtags manually)'))
230
231 self.tags() # instantiate the cache
232 self._tag(names, node, message, local, user, date)
233
234 def tags(self):
235 '''return a mapping of tag to node'''
236 if self.tagscache:
237 return self.tagscache
238
239 globaltags = {}
240 tagtypes = {}
241
242 def readtags(lines, fn, tagtype):
243 filetags = {}
244 count = 0
245
246 def warn(msg):
247 self.ui.warn(_("%s, line %s: %s\n") % (fn, count, msg))
248
249 for l in lines:
250 count += 1
251 if not l:
252 continue
253 s = l.split(" ", 1)
254 if len(s) != 2:
255 warn(_("cannot parse entry"))
256 continue
257 node, key = s
258 key = encoding.tolocal(key.strip()) # stored in UTF-8
259 try:
260 bin_n = bin(node)
261 except TypeError:
262 warn(_("node '%s' is not well formed") % node)
263 continue
264 if bin_n not in self.changelog.nodemap:
265 # silently ignore as pull -r might cause this
266 continue
267
268 h = []
269 if key in filetags:
270 n, h = filetags[key]
271 h.append(n)
272 filetags[key] = (bin_n, h)
273
274 for k, nh in filetags.iteritems():
275 if k not in globaltags:
276 globaltags[k] = nh
277 tagtypes[k] = tagtype
278 continue
279
280 # we prefer the global tag if:
281 # it supercedes us OR
282 # mutual supercedes and it has a higher rank
283 # otherwise we win because we're tip-most
284 an, ah = nh
285 bn, bh = globaltags[k]
286 if (bn != an and an in bh and
287 (bn not in ah or len(bh) > len(ah))):
288 an = bn
289 ah.extend([n for n in bh if n not in ah])
290 globaltags[k] = an, ah
291 tagtypes[k] = tagtype
292
293 seen = set()
294 f = None
295 ctxs = []
296 for node in self.heads():
297 try:
298 fnode = self[node].filenode('.hgtags')
299 except error.LookupError:
300 continue
301 if fnode not in seen:
302 seen.add(fnode)
303 if not f:
304 f = self.filectx('.hgtags', fileid=fnode)
305 else:
306 f = f.filectx(fnode)
307 ctxs.append(f)
308
309 # read the tags file from each head, ending with the tip
310 for f in reversed(ctxs):
311 readtags(f.data().splitlines(), f, "global")
312
313 try:
314 data = encoding.fromlocal(self.opener("localtags").read())
315 # localtags are stored in the local character set
316 # while the internal tag table is stored in UTF-8
317 readtags(data.splitlines(), "localtags", "local")
318 except IOError:
319 pass
320
321 self.tagscache = {}
322 self._tagstypecache = {}
323 for k, nh in globaltags.iteritems():
324 n = nh[0]
325 if n != nullid:
326 self.tagscache[k] = n
327 self._tagstypecache[k] = tagtypes[k]
328 self.tagscache['tip'] = self.changelog.tip()
329 return self.tagscache
330
331 def tagtype(self, tagname):
332 '''
333 return the type of the given tag. result can be:
334
335 'local' : a local tag
336 'global' : a global tag
337 None : tag does not exist
338 '''
339
340 self.tags()
341
342 return self._tagstypecache.get(tagname)
343
344 def tagslist(self):
345 '''return a list of tags ordered by revision'''
346 l = []
347 for t, n in self.tags().iteritems():
348 try:
349 r = self.changelog.rev(n)
350 except:
351 r = -2 # sort to the beginning of the list if unknown
352 l.append((r, t, n))
353 return [(t, n) for r, t, n in sorted(l)]
354
355 def nodetags(self, node):
356 '''return the tags associated with a node'''
357 if not self.nodetagscache:
358 self.nodetagscache = {}
359 for t, n in self.tags().iteritems():
360 self.nodetagscache.setdefault(n, []).append(t)
361 return self.nodetagscache.get(node, [])
362
363 def _branchtags(self, partial, lrev):
364 # TODO: rename this function?
365 tiprev = len(self) - 1
366 if lrev != tiprev:
367 self._updatebranchcache(partial, lrev+1, tiprev+1)
368 self._writebranchcache(partial, self.changelog.tip(), tiprev)
369
370 return partial
371
372 def branchmap(self):
373 tip = self.changelog.tip()
374 if self.branchcache is not None and self._branchcachetip == tip:
375 return self.branchcache
376
377 oldtip = self._branchcachetip
378 self._branchcachetip = tip
379 if self.branchcache is None:
380 self.branchcache = {} # avoid recursion in changectx
381 else:
382 self.branchcache.clear() # keep using the same dict
383 if oldtip is None or oldtip not in self.changelog.nodemap:
384 partial, last, lrev = self._readbranchcache()
385 else:
386 lrev = self.changelog.rev(oldtip)
387 partial = self._ubranchcache
388
389 self._branchtags(partial, lrev)
390 # this private cache holds all heads (not just tips)
391 self._ubranchcache = partial
392
393 # the branch cache is stored on disk as UTF-8, but in the local
394 # charset internally
395 for k, v in partial.iteritems():
396 self.branchcache[encoding.tolocal(k)] = v
397 return self.branchcache
398
399
400 def branchtags(self):
401 '''return a dict where branch names map to the tipmost head of
402 the branch, open heads come before closed'''
403 bt = {}
404 for bn, heads in self.branchmap().iteritems():
405 head = None
406 for i in range(len(heads)-1, -1, -1):
407 h = heads[i]
408 if 'close' not in self.changelog.read(h)[5]:
409 head = h
410 break
411 # no open heads were found
412 if head is None:
413 head = heads[-1]
414 bt[bn] = head
415 return bt
416
417
418 def _readbranchcache(self):
419 partial = {}
420 try:
421 f = self.opener("branchheads.cache")
422 lines = f.read().split('\n')
423 f.close()
424 except (IOError, OSError):
425 return {}, nullid, nullrev
426
427 try:
428 last, lrev = lines.pop(0).split(" ", 1)
429 last, lrev = bin(last), int(lrev)
430 if lrev >= len(self) or self[lrev].node() != last:
431 # invalidate the cache
432 raise ValueError('invalidating branch cache (tip differs)')
433 for l in lines:
434 if not l: continue
435 node, label = l.split(" ", 1)
436 partial.setdefault(label.strip(), []).append(bin(node))
437 except KeyboardInterrupt:
438 raise
439 except Exception, inst:
440 if self.ui.debugflag:
441 self.ui.warn(str(inst), '\n')
442 partial, last, lrev = {}, nullid, nullrev
443 return partial, last, lrev
444
445 def _writebranchcache(self, branches, tip, tiprev):
446 try:
447 f = self.opener("branchheads.cache", "w", atomictemp=True)
448 f.write("%s %s\n" % (hex(tip), tiprev))
449 for label, nodes in branches.iteritems():
450 for node in nodes:
451 f.write("%s %s\n" % (hex(node), label))
452 f.rename()
453 except (IOError, OSError):
454 pass
455
456 def _updatebranchcache(self, partial, start, end):
457 # collect new branch entries
458 newbranches = {}
459 for r in xrange(start, end):
460 c = self[r]
461 newbranches.setdefault(c.branch(), []).append(c.node())
462 # if older branchheads are reachable from new ones, they aren't
463 # really branchheads. Note checking parents is insufficient:
464 # 1 (branch a) -> 2 (branch b) -> 3 (branch a)
465 for branch, newnodes in newbranches.iteritems():
466 bheads = partial.setdefault(branch, [])
467 bheads.extend(newnodes)
468 if len(bheads) < 2:
469 continue
470 newbheads = []
471 # starting from tip means fewer passes over reachable
472 while newnodes:
473 latest = newnodes.pop()
474 if latest not in bheads:
475 continue
476 minbhrev = self[min([self[bh].rev() for bh in bheads])].node()
477 reachable = self.changelog.reachable(latest, minbhrev)
478 bheads = [b for b in bheads if b not in reachable]
479 newbheads.insert(0, latest)
480 bheads.extend(newbheads)
481 partial[branch] = bheads
482
483 def lookup(self, key):
484 if isinstance(key, int):
485 return self.changelog.node(key)
486 elif key == '.':
487 return self.dirstate.parents()[0]
488 elif key == 'null':
489 return nullid
490 elif key == 'tip':
491 return self.changelog.tip()
492 n = self.changelog._match(key)
493 if n:
494 return n
495 if key in self.tags():
496 return self.tags()[key]
497 if key in self.branchtags():
498 return self.branchtags()[key]
499 n = self.changelog._partialmatch(key)
500 if n:
501 return n
502
503 # can't find key, check if it might have come from damaged dirstate
504 if key in self.dirstate.parents():
505 raise error.Abort(_("working directory has unknown parent '%s'!")
506 % short(key))
507 try:
508 if len(key) == 20:
509 key = hex(key)
510 except:
511 pass
512 raise error.RepoError(_("unknown revision '%s'") % key)
513
514 def local(self):
515 return True
516
517 def join(self, f):
518 return os.path.join(self.path, f)
519
520 def wjoin(self, f):
521 return os.path.join(self.root, f)
522
523 def rjoin(self, f):
524 return os.path.join(self.root, util.pconvert(f))
525
526 def file(self, f):
527 if f[0] == '/':
528 f = f[1:]
529 return filelog.filelog(self.sopener, f)
530
531 def changectx(self, changeid):
532 return self[changeid]
533
534 def parents(self, changeid=None):
535 '''get list of changectxs for parents of changeid'''
536 return self[changeid].parents()
537
538 def filectx(self, path, changeid=None, fileid=None):
539 """changeid can be a changeset revision, node, or tag.
540 fileid can be a file revision or node."""
541 return context.filectx(self, path, changeid, fileid)
542
543 def getcwd(self):
544 return self.dirstate.getcwd()
545
546 def pathto(self, f, cwd=None):
547 return self.dirstate.pathto(f, cwd)
548
549 def wfile(self, f, mode='r'):
550 return self.wopener(f, mode)
551
552 def _link(self, f):
553 return os.path.islink(self.wjoin(f))
554
555 def _filter(self, filter, filename, data):
556 if filter not in self.filterpats:
557 l = []
558 for pat, cmd in self.ui.configitems(filter):
559 if cmd == '!':
560 continue
561 mf = match_.match(self.root, '', [pat])
562 fn = None
563 params = cmd
564 for name, filterfn in self._datafilters.iteritems():
565 if cmd.startswith(name):
566 fn = filterfn
567 params = cmd[len(name):].lstrip()
568 break
569 if not fn:
570 fn = lambda s, c, **kwargs: util.filter(s, c)
571 # Wrap old filters not supporting keyword arguments
572 if not inspect.getargspec(fn)[2]:
573 oldfn = fn
574 fn = lambda s, c, **kwargs: oldfn(s, c)
575 l.append((mf, fn, params))
576 self.filterpats[filter] = l
577
578 for mf, fn, cmd in self.filterpats[filter]:
579 if mf(filename):
580 self.ui.debug(_("filtering %s through %s\n") % (filename, cmd))
581 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
582 break
583
584 return data
585
586 def adddatafilter(self, name, filter):
587 self._datafilters[name] = filter
588
589 def wread(self, filename):
590 if self._link(filename):
591 data = os.readlink(self.wjoin(filename))
592 else:
593 data = self.wopener(filename, 'r').read()
594 return self._filter("encode", filename, data)
595
596 def wwrite(self, filename, data, flags):
597 data = self._filter("decode", filename, data)
598 try:
599 os.unlink(self.wjoin(filename))
600 except OSError:
601 pass
602 if 'l' in flags:
603 self.wopener.symlink(data, filename)
604 else:
605 self.wopener(filename, 'w').write(data)
606 if 'x' in flags:
607 util.set_flags(self.wjoin(filename), False, True)
608
609 def wwritedata(self, filename, data):
610 return self._filter("decode", filename, data)
611
612 def transaction(self):
613 tr = self._transref and self._transref() or None
614 if tr and tr.running():
615 return tr.nest()
616
617 # abort here if the journal already exists
618 if os.path.exists(self.sjoin("journal")):
619 raise error.RepoError(_("journal already exists - run hg recover"))
620
621 # save dirstate for rollback
622 try:
623 ds = self.opener("dirstate").read()
624 except IOError:
625 ds = ""
626 self.opener("journal.dirstate", "w").write(ds)
627 self.opener("journal.branch", "w").write(self.dirstate.branch())
628
629 renames = [(self.sjoin("journal"), self.sjoin("undo")),
630 (self.join("journal.dirstate"), self.join("undo.dirstate")),
631 (self.join("journal.branch"), self.join("undo.branch"))]
632 tr = transaction.transaction(self.ui.warn, self.sopener,
633 self.sjoin("journal"),
634 aftertrans(renames),
635 self.store.createmode)
636 self._transref = weakref.ref(tr)
637 return tr
638
639 def recover(self):
640 lock = self.lock()
641 try:
642 if os.path.exists(self.sjoin("journal")):
643 self.ui.status(_("rolling back interrupted transaction\n"))
644 transaction.rollback(self.sopener, self.sjoin("journal"), self.ui.warn)
645 self.invalidate()
646 return True
647 else:
648 self.ui.warn(_("no interrupted transaction available\n"))
649 return False
650 finally:
651 lock.release()
652
653 def rollback(self):
654 wlock = lock = None
655 try:
656 wlock = self.wlock()
657 lock = self.lock()
658 if os.path.exists(self.sjoin("undo")):
659 self.ui.status(_("rolling back last transaction\n"))
660 transaction.rollback(self.sopener, self.sjoin("undo"), self.ui.warn)
661 util.rename(self.join("undo.dirstate"), self.join("dirstate"))
662 try:
663 branch = self.opener("undo.branch").read()
664 self.dirstate.setbranch(branch)
665 except IOError:
666 self.ui.warn(_("Named branch could not be reset, "
667 "current branch still is: %s\n")
668 % encoding.tolocal(self.dirstate.branch()))
669 self.invalidate()
670 self.dirstate.invalidate()
671 else:
672 self.ui.warn(_("no rollback information available\n"))
673 finally:
674 release(lock, wlock)
675
676 def invalidate(self):
677 for a in "changelog manifest".split():
678 if a in self.__dict__:
679 delattr(self, a)
680 self.tagscache = None
681 self._tagstypecache = None
682 self.nodetagscache = None
683 self.branchcache = None
684 self._ubranchcache = None
685 self._branchcachetip = None
686
687 def _lock(self, lockname, wait, releasefn, acquirefn, desc):
688 try:
689 l = lock.lock(lockname, 0, releasefn, desc=desc)
690 except error.LockHeld, inst:
691 if not wait:
692 raise
693 self.ui.warn(_("waiting for lock on %s held by %r\n") %
694 (desc, inst.locker))
695 # default to 600 seconds timeout
696 l = lock.lock(lockname, int(self.ui.config("ui", "timeout", "600")),
697 releasefn, desc=desc)
698 if acquirefn:
699 acquirefn()
700 return l
701
702 def lock(self, wait=True):
703 l = self._lockref and self._lockref()
704 if l is not None and l.held:
705 l.lock()
706 return l
707
708 l = self._lock(self.sjoin("lock"), wait, None, self.invalidate,
709 _('repository %s') % self.origroot)
710 self._lockref = weakref.ref(l)
711 return l
712
713 def wlock(self, wait=True):
714 l = self._wlockref and self._wlockref()
715 if l is not None and l.held:
716 l.lock()
717 return l
718
719 l = self._lock(self.join("wlock"), wait, self.dirstate.write,
720 self.dirstate.invalidate, _('working directory of %s') %
721 self.origroot)
722 self._wlockref = weakref.ref(l)
723 return l
724
725 def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist):
726 """
727 commit an individual file as part of a larger transaction
728 """
729
730 fname = fctx.path()
731 text = fctx.data()
732 flog = self.file(fname)
733 fparent1 = manifest1.get(fname, nullid)
734 fparent2 = fparent2o = manifest2.get(fname, nullid)
735
736 meta = {}
737 copy = fctx.renamed()
738 if copy and copy[0] != fname:
739 # Mark the new revision of this file as a copy of another
740 # file. This copy data will effectively act as a parent
741 # of this new revision. If this is a merge, the first
742 # parent will be the nullid (meaning "look up the copy data")
743 # and the second one will be the other parent. For example:
744 #
745 # 0 --- 1 --- 3 rev1 changes file foo
746 # \ / rev2 renames foo to bar and changes it
747 # \- 2 -/ rev3 should have bar with all changes and
748 # should record that bar descends from
749 # bar in rev2 and foo in rev1
750 #
751 # this allows this merge to succeed:
752 #
753 # 0 --- 1 --- 3 rev4 reverts the content change from rev2
754 # \ / merging rev3 and rev4 should use bar@rev2
755 # \- 2 --- 4 as the merge base
756 #
757
758 cfname = copy[0]
759 crev = manifest1.get(cfname)
760 newfparent = fparent2
761
762 if manifest2: # branch merge
763 if fparent2 == nullid or crev is None: # copied on remote side
764 if cfname in manifest2:
765 crev = manifest2[cfname]
766 newfparent = fparent1
767
768 # find source in nearest ancestor if we've lost track
769 if not crev:
770 self.ui.debug(_(" %s: searching for copy revision for %s\n") %
771 (fname, cfname))
772 for ancestor in self['.'].ancestors():
773 if cfname in ancestor:
774 crev = ancestor[cfname].filenode()
775 break
776
777 self.ui.debug(_(" %s: copy %s:%s\n") % (fname, cfname, hex(crev)))
778 meta["copy"] = cfname
779 meta["copyrev"] = hex(crev)
780 fparent1, fparent2 = nullid, newfparent
781 elif fparent2 != nullid:
782 # is one parent an ancestor of the other?
783 fparentancestor = flog.ancestor(fparent1, fparent2)
784 if fparentancestor == fparent1:
785 fparent1, fparent2 = fparent2, nullid
786 elif fparentancestor == fparent2:
787 fparent2 = nullid
788
789 # is the file changed?
790 if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
791 changelist.append(fname)
792 return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
793
794 # are just the flags changed during merge?
795 if fparent1 != fparent2o and manifest1.flags(fname) != fctx.flags():
796 changelist.append(fname)
797
798 return fparent1
799
800 def commit(self, text="", user=None, date=None, match=None, force=False,
801 editor=False, extra={}):
802 """Add a new revision to current repository.
803
804 Revision information is gathered from the working directory,
805 match can be used to filter the committed files. If editor is
806 supplied, it is called to get a commit message.
807 """
808
809 def fail(f, msg):
810 raise util.Abort('%s: %s' % (f, msg))
811
812 if not match:
813 match = match_.always(self.root, '')
814
815 if not force:
816 vdirs = []
817 match.dir = vdirs.append
818 match.bad = fail
819
820 wlock = self.wlock()
821 try:
822 p1, p2 = self.dirstate.parents()
823 wctx = self[None]
824
825 if (not force and p2 != nullid and match and
826 (match.files() or match.anypats())):
827 raise util.Abort(_('cannot partially commit a merge '
828 '(do not specify files or patterns)'))
829
830 changes = self.status(match=match, clean=force)
831 if force:
832 changes[0].extend(changes[6]) # mq may commit unchanged files
833
834 # check subrepos
835 subs = []
836 for s in wctx.substate:
837 if match(s) and wctx.sub(s).dirty():
838 subs.append(s)
839 if subs and '.hgsubstate' not in changes[0]:
840 changes[0].insert(0, '.hgsubstate')
841
842 # make sure all explicit patterns are matched
843 if not force and match.files():
844 matched = set(changes[0] + changes[1] + changes[2])
845
846 for f in match.files():
847 if f == '.' or f in matched or f in wctx.substate:
848 continue
849 if f in changes[3]: # missing
850 fail(f, _('file not found!'))
851 if f in vdirs: # visited directory
852 d = f + '/'
853 for mf in matched:
854 if mf.startswith(d):
855 break
856 else:
857 fail(f, _("no match under directory!"))
858 elif f not in self.dirstate:
859 fail(f, _("file not tracked!"))
860
861 if (not force and not extra.get("close") and p2 == nullid
862 and not (changes[0] or changes[1] or changes[2])
863 and self[None].branch() == self['.'].branch()):
864 return None
865
866 ms = merge_.mergestate(self)
867 for f in changes[0]:
868 if f in ms and ms[f] == 'u':
869 raise util.Abort(_("unresolved merge conflicts "
870 "(see hg resolve)"))
871
872 cctx = context.workingctx(self, (p1, p2), text, user, date,
873 extra, changes)
874 if editor:
875 cctx._text = editor(self, cctx, subs)
876
877 # commit subs
878 if subs:
879 state = wctx.substate.copy()
880 for s in subs:
881 self.ui.status(_('committing subrepository %s\n') % s)
882 sr = wctx.sub(s).commit(cctx._text, user, date)
883 state[s] = (state[s][0], sr)
884 subrepo.writestate(self, state)
885
886 ret = self.commitctx(cctx, True)
887
888 # update dirstate and mergestate
889 for f in changes[0] + changes[1]:
890 self.dirstate.normal(f)
891 for f in changes[2]:
892 self.dirstate.forget(f)
893 self.dirstate.setparents(ret)
894 ms.reset()
895
896 return ret
897
898 finally:
899 wlock.release()
900
901 def commitctx(self, ctx, error=False):
902 """Add a new revision to current repository.
903
904 Revision information is passed via the context argument.
905 """
906
907 tr = lock = None
908 removed = ctx.removed()
909 p1, p2 = ctx.p1(), ctx.p2()
910 m1 = p1.manifest().copy()
911 m2 = p2.manifest()
912 user = ctx.user()
913
914 xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
915 self.hook("precommit", throw=True, parent1=xp1, parent2=xp2)
916
917 lock = self.lock()
918 try:
919 tr = self.transaction()
920 trp = weakref.proxy(tr)
921
922 # check in files
923 new = {}
924 changed = []
925 linkrev = len(self)
926 for f in sorted(ctx.modified() + ctx.added()):
927 self.ui.note(f + "\n")
928 try:
929 fctx = ctx[f]
930 new[f] = self._filecommit(fctx, m1, m2, linkrev, trp,
931 changed)
932 m1.set(f, fctx.flags())
933 except (OSError, IOError):
934 if error:
935 self.ui.warn(_("trouble committing %s!\n") % f)
936 raise
937 else:
938 removed.append(f)
939
940 # update manifest
941 m1.update(new)
942 removed = [f for f in sorted(removed) if f in m1 or f in m2]
943 drop = [f for f in removed if f in m1]
944 for f in drop:
945 del m1[f]
946 mn = self.manifest.add(m1, trp, linkrev, p1.manifestnode(),
947 p2.manifestnode(), (new, drop))
948
949 # update changelog
950 self.changelog.delayupdate()
951 n = self.changelog.add(mn, changed + removed, ctx.description(),
952 trp, p1.node(), p2.node(),
953 user, ctx.date(), ctx.extra().copy())
954 p = lambda: self.changelog.writepending() and self.root or ""
955 self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
956 parent2=xp2, pending=p)
957 self.changelog.finalize(trp)
958 tr.close()
959
960 if self.branchcache:
961 self.branchtags()
962
963 self.hook("commit", node=hex(n), parent1=xp1, parent2=xp2)
964 return n
965 finally:
966 del tr
967 lock.release()
968
969 def walk(self, match, node=None):
970 '''
971 walk recursively through the directory tree or a given
972 changeset, finding all files matched by the match
973 function
974 '''
975 return self[node].walk(match)
976
977 def status(self, node1='.', node2=None, match=None,
978 ignored=False, clean=False, unknown=False):
979 """return status of files between two nodes or node and working directory
980
981 If node1 is None, use the first dirstate parent instead.
982 If node2 is None, compare node1 with working directory.
983 """
984
985 def mfmatches(ctx):
986 mf = ctx.manifest().copy()
987 for fn in mf.keys():
988 if not match(fn):
989 del mf[fn]
990 return mf
991
992 if isinstance(node1, context.changectx):
993 ctx1 = node1
994 else:
995 ctx1 = self[node1]
996 if isinstance(node2, context.changectx):
997 ctx2 = node2
998 else:
999 ctx2 = self[node2]
1000
1001 working = ctx2.rev() is None
1002 parentworking = working and ctx1 == self['.']
1003 match = match or match_.always(self.root, self.getcwd())
1004 listignored, listclean, listunknown = ignored, clean, unknown
1005
1006 # load earliest manifest first for caching reasons
1007 if not working and ctx2.rev() < ctx1.rev():
1008 ctx2.manifest()
1009
1010 if not parentworking:
1011 def bad(f, msg):
1012 if f not in ctx1:
1013 self.ui.warn('%s: %s\n' % (self.dirstate.pathto(f), msg))
1014 match.bad = bad
1015
1016 if working: # we need to scan the working dir
1017 s = self.dirstate.status(match, listignored, listclean, listunknown)
1018 cmp, modified, added, removed, deleted, unknown, ignored, clean = s
1019
1020 # check for any possibly clean files
1021 if parentworking and cmp:
1022 fixup = []
1023 # do a full compare of any files that might have changed
1024 for f in sorted(cmp):
1025 if (f not in ctx1 or ctx2.flags(f) != ctx1.flags(f)
1026 or ctx1[f].cmp(ctx2[f].data())):
1027 modified.append(f)
1028 else:
1029 fixup.append(f)
1030
1031 if listclean:
1032 clean += fixup
1033
1034 # update dirstate for files that are actually clean
1035 if fixup:
1036 try:
1037 # updating the dirstate is optional
1038 # so we don't wait on the lock
1039 wlock = self.wlock(False)
1040 try:
1041 for f in fixup:
1042 self.dirstate.normal(f)
1043 finally:
1044 wlock.release()
1045 except error.LockError:
1046 pass
1047
1048 if not parentworking:
1049 mf1 = mfmatches(ctx1)
1050 if working:
1051 # we are comparing working dir against non-parent
1052 # generate a pseudo-manifest for the working dir
1053 mf2 = mfmatches(self['.'])
1054 for f in cmp + modified + added:
1055 mf2[f] = None
1056 mf2.set(f, ctx2.flags(f))
1057 for f in removed:
1058 if f in mf2:
1059 del mf2[f]
1060 else:
1061 # we are comparing two revisions
1062 deleted, unknown, ignored = [], [], []
1063 mf2 = mfmatches(ctx2)
1064
1065 modified, added, clean = [], [], []
1066 for fn in mf2:
1067 if fn in mf1:
1068 if (mf1.flags(fn) != mf2.flags(fn) or
1069 (mf1[fn] != mf2[fn] and
1070 (mf2[fn] or ctx1[fn].cmp(ctx2[fn].data())))):
1071 modified.append(fn)
1072 elif listclean:
1073 clean.append(fn)
1074 del mf1[fn]
1075 else:
1076 added.append(fn)
1077 removed = mf1.keys()
1078
1079 r = modified, added, removed, deleted, unknown, ignored, clean
1080 [l.sort() for l in r]
1081 return r
1082
1083 def add(self, list):
1084 wlock = self.wlock()
1085 try:
1086 rejected = []
1087 for f in list:
1088 p = self.wjoin(f)
1089 try:
1090 st = os.lstat(p)
1091 except:
1092 self.ui.warn(_("%s does not exist!\n") % f)
1093 rejected.append(f)
1094 continue
1095 if st.st_size > 10000000:
1096 self.ui.warn(_("%s: files over 10MB may cause memory and"
1097 " performance problems\n"
1098 "(use 'hg revert %s' to unadd the file)\n")
1099 % (f, f))
1100 if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
1101 self.ui.warn(_("%s not added: only files and symlinks "
1102 "supported currently\n") % f)
1103 rejected.append(p)
1104 elif self.dirstate[f] in 'amn':
1105 self.ui.warn(_("%s already tracked!\n") % f)
1106 elif self.dirstate[f] == 'r':
1107 self.dirstate.normallookup(f)
1108 else:
1109 self.dirstate.add(f)
1110 return rejected
1111 finally:
1112 wlock.release()
1113
1114 def forget(self, list):
1115 wlock = self.wlock()
1116 try:
1117 for f in list:
1118 if self.dirstate[f] != 'a':
1119 self.ui.warn(_("%s not added!\n") % f)
1120 else:
1121 self.dirstate.forget(f)
1122 finally:
1123 wlock.release()
1124
1125 def remove(self, list, unlink=False):
1126 if unlink:
1127 for f in list:
1128 try:
1129 util.unlink(self.wjoin(f))
1130 except OSError, inst:
1131 if inst.errno != errno.ENOENT:
1132 raise
1133 wlock = self.wlock()
1134 try:
1135 for f in list:
1136 if unlink and os.path.exists(self.wjoin(f)):
1137 self.ui.warn(_("%s still exists!\n") % f)
1138 elif self.dirstate[f] == 'a':
1139 self.dirstate.forget(f)
1140 elif f not in self.dirstate:
1141 self.ui.warn(_("%s not tracked!\n") % f)
1142 else:
1143 self.dirstate.remove(f)
1144 finally:
1145 wlock.release()
1146
1147 def undelete(self, list):
1148 manifests = [self.manifest.read(self.changelog.read(p)[0])
1149 for p in self.dirstate.parents() if p != nullid]
1150 wlock = self.wlock()
1151 try:
1152 for f in list:
1153 if self.dirstate[f] != 'r':
1154 self.ui.warn(_("%s not removed!\n") % f)
1155 else:
1156 m = f in manifests[0] and manifests[0] or manifests[1]
1157 t = self.file(f).read(m[f])
1158 self.wwrite(f, t, m.flags(f))
1159 self.dirstate.normal(f)
1160 finally:
1161 wlock.release()
1162
1163 def copy(self, source, dest):
1164 p = self.wjoin(dest)
1165 if not (os.path.exists(p) or os.path.islink(p)):
1166 self.ui.warn(_("%s does not exist!\n") % dest)
1167 elif not (os.path.isfile(p) or os.path.islink(p)):
1168 self.ui.warn(_("copy failed: %s is not a file or a "
1169 "symbolic link\n") % dest)
1170 else:
1171 wlock = self.wlock()
1172 try:
1173 if self.dirstate[dest] in '?r':
1174 self.dirstate.add(dest)
1175 self.dirstate.copy(source, dest)
1176 finally:
1177 wlock.release()
1178
1179 def heads(self, start=None):
1180 heads = self.changelog.heads(start)
1181 # sort the output in rev descending order
1182 heads = [(-self.changelog.rev(h), h) for h in heads]
1183 return [n for (r, n) in sorted(heads)]
1184
1185 def branchheads(self, branch=None, start=None, closed=False):
1186 if branch is None:
1187 branch = self[None].branch()
1188 branches = self.branchmap()
1189 if branch not in branches:
1190 return []
1191 bheads = branches[branch]
1192 # the cache returns heads ordered lowest to highest
1193 bheads.reverse()
1194 if start is not None:
1195 # filter out the heads that cannot be reached from startrev
1196 bheads = self.changelog.nodesbetween([start], bheads)[2]
1197 if not closed:
1198 bheads = [h for h in bheads if
1199 ('close' not in self.changelog.read(h)[5])]
1200 return bheads
1201
1202 def branches(self, nodes):
1203 if not nodes:
1204 nodes = [self.changelog.tip()]
1205 b = []
1206 for n in nodes:
1207 t = n
1208 while 1:
1209 p = self.changelog.parents(n)
1210 if p[1] != nullid or p[0] == nullid:
1211 b.append((t, n, p[0], p[1]))
1212 break
1213 n = p[0]
1214 return b
1215
1216 def between(self, pairs):
1217 r = []
1218
1219 for top, bottom in pairs:
1220 n, l, i = top, [], 0
1221 f = 1
1222
1223 while n != bottom and n != nullid:
1224 p = self.changelog.parents(n)[0]
1225 if i == f:
1226 l.append(n)
1227 f = f * 2
1228 n = p
1229 i += 1
1230
1231 r.append(l)
1232
1233 return r
1234
1235 def findincoming(self, remote, base=None, heads=None, force=False):
1236 """Return list of roots of the subsets of missing nodes from remote
1237
1238 If base dict is specified, assume that these nodes and their parents
1239 exist on the remote side and that no child of a node of base exists
1240 in both remote and self.
1241 Furthermore base will be updated to include the nodes that exists
1242 in self and remote but no children exists in self and remote.
1243 If a list of heads is specified, return only nodes which are heads
1244 or ancestors of these heads.
1245
1246 All the ancestors of base are in self and in remote.
1247 All the descendants of the list returned are missing in self.
1248 (and so we know that the rest of the nodes are missing in remote, see
1249 outgoing)
1250 """
1251 return self.findcommonincoming(remote, base, heads, force)[1]
1252
1253 def findcommonincoming(self, remote, base=None, heads=None, force=False):
1254 """Return a tuple (common, missing roots, heads) used to identify
1255 missing nodes from remote.
1256
1257 If base dict is specified, assume that these nodes and their parents
1258 exist on the remote side and that no child of a node of base exists
1259 in both remote and self.
1260 Furthermore base will be updated to include the nodes that exists
1261 in self and remote but no children exists in self and remote.
1262 If a list of heads is specified, return only nodes which are heads
1263 or ancestors of these heads.
1264
1265 All the ancestors of base are in self and in remote.
1266 """
1267 m = self.changelog.nodemap
1268 search = []
1269 fetch = set()
1270 seen = set()
1271 seenbranch = set()
1272 if base is None:
1273 base = {}
1274
1275 if not heads:
1276 heads = remote.heads()
1277
1278 if self.changelog.tip() == nullid:
1279 base[nullid] = 1
1280 if heads != [nullid]:
1281 return [nullid], [nullid], list(heads)
1282 return [nullid], [], []
1283
1284 # assume we're closer to the tip than the root
1285 # and start by examining the heads
1286 self.ui.status(_("searching for changes\n"))
1287
1288 unknown = []
1289 for h in heads:
1290 if h not in m:
1291 unknown.append(h)
1292 else:
1293 base[h] = 1
1294
1295 heads = unknown
1296 if not unknown:
1297 return base.keys(), [], []
1298
1299 req = set(unknown)
1300 reqcnt = 0
1301
1302 # search through remote branches
1303 # a 'branch' here is a linear segment of history, with four parts:
1304 # head, root, first parent, second parent
1305 # (a branch always has two parents (or none) by definition)
1306 unknown = remote.branches(unknown)
1307 while unknown:
1308 r = []
1309 while unknown:
1310 n = unknown.pop(0)
1311 if n[0] in seen:
1312 continue
1313
1314 self.ui.debug(_("examining %s:%s\n")
1315 % (short(n[0]), short(n[1])))
1316 if n[0] == nullid: # found the end of the branch
1317 pass
1318 elif n in seenbranch:
1319 self.ui.debug(_("branch already found\n"))
1320 continue
1321 elif n[1] and n[1] in m: # do we know the base?
1322 self.ui.debug(_("found incomplete branch %s:%s\n")
1323 % (short(n[0]), short(n[1])))
1324 search.append(n[0:2]) # schedule branch range for scanning
1325 seenbranch.add(n)
1326 else:
1327 if n[1] not in seen and n[1] not in fetch:
1328 if n[2] in m and n[3] in m:
1329 self.ui.debug(_("found new changeset %s\n") %
1330 short(n[1]))
1331 fetch.add(n[1]) # earliest unknown
1332 for p in n[2:4]:
1333 if p in m:
1334 base[p] = 1 # latest known
1335
1336 for p in n[2:4]:
1337 if p not in req and p not in m:
1338 r.append(p)
1339 req.add(p)
1340 seen.add(n[0])
1341
1342 if r:
1343 reqcnt += 1
1344 self.ui.debug(_("request %d: %s\n") %
1345 (reqcnt, " ".join(map(short, r))))
1346 for p in xrange(0, len(r), 10):
1347 for b in remote.branches(r[p:p+10]):
1348 self.ui.debug(_("received %s:%s\n") %
1349 (short(b[0]), short(b[1])))
1350 unknown.append(b)
1351
1352 # do binary search on the branches we found
1353 while search:
1354 newsearch = []
1355 reqcnt += 1
1356 for n, l in zip(search, remote.between(search)):
1357 l.append(n[1])
1358 p = n[0]
1359 f = 1
1360 for i in l:
1361 self.ui.debug(_("narrowing %d:%d %s\n") % (f, len(l), short(i)))
1362 if i in m:
1363 if f <= 2:
1364 self.ui.debug(_("found new branch changeset %s\n") %
1365 short(p))
1366 fetch.add(p)
1367 base[i] = 1
1368 else:
1369 self.ui.debug(_("narrowed branch search to %s:%s\n")
1370 % (short(p), short(i)))
1371 newsearch.append((p, i))
1372 break
1373 p, f = i, f * 2
1374 search = newsearch
1375
1376 # sanity check our fetch list
1377 for f in fetch:
1378 if f in m:
1379 raise error.RepoError(_("already have changeset ")
1380 + short(f[:4]))
1381
1382 if base.keys() == [nullid]:
1383 if force:
1384 self.ui.warn(_("warning: repository is unrelated\n"))
1385 else:
1386 raise util.Abort(_("repository is unrelated"))
1387
1388 self.ui.debug(_("found new changesets starting at ") +
1389 " ".join([short(f) for f in fetch]) + "\n")
1390
1391 self.ui.debug(_("%d total queries\n") % reqcnt)
1392
1393 return base.keys(), list(fetch), heads
1394
1395 def findoutgoing(self, remote, base=None, heads=None, force=False):
1396 """Return list of nodes that are roots of subsets not in remote
1397
1398 If base dict is specified, assume that these nodes and their parents
1399 exist on the remote side.
1400 If a list of heads is specified, return only nodes which are heads
1401 or ancestors of these heads, and return a second element which
1402 contains all remote heads which get new children.
1403 """
1404 if base is None:
1405 base = {}
1406 self.findincoming(remote, base, heads, force=force)
1407
1408 self.ui.debug(_("common changesets up to ")
1409 + " ".join(map(short, base.keys())) + "\n")
1410
1411 remain = set(self.changelog.nodemap)
1412
1413 # prune everything remote has from the tree
1414 remain.remove(nullid)
1415 remove = base.keys()
1416 while remove:
1417 n = remove.pop(0)
1418 if n in remain:
1419 remain.remove(n)
1420 for p in self.changelog.parents(n):
1421 remove.append(p)
1422
1423 # find every node whose parents have been pruned
1424 subset = []
1425 # find every remote head that will get new children
1426 updated_heads = set()
1427 for n in remain:
1428 p1, p2 = self.changelog.parents(n)
1429 if p1 not in remain and p2 not in remain:
1430 subset.append(n)
1431 if heads:
1432 if p1 in heads:
1433 updated_heads.add(p1)
1434 if p2 in heads:
1435 updated_heads.add(p2)
1436
1437 # this is the set of all roots we have to push
1438 if heads:
1439 return subset, list(updated_heads)
1440 else:
1441 return subset
1442
1443 def pull(self, remote, heads=None, force=False):
1444 lock = self.lock()
1445 try:
1446 common, fetch, rheads = self.findcommonincoming(remote, heads=heads,
1447 force=force)
1448 if fetch == [nullid]:
1449 self.ui.status(_("requesting all changes\n"))
1450
1451 if not fetch:
1452 self.ui.status(_("no changes found\n"))
1453 return 0
1454
1455 if heads is None and remote.capable('changegroupsubset'):
1456 heads = rheads
1457
1458 if heads is None:
1459 cg = remote.changegroup(fetch, 'pull')
1460 else:
1461 if not remote.capable('changegroupsubset'):
1462 raise util.Abort(_("Partial pull cannot be done because "
1463 "other repository doesn't support "
1464 "changegroupsubset."))
1465 cg = remote.changegroupsubset(fetch, heads, 'pull')
1466 return self.addchangegroup(cg, 'pull', remote.url())
1467 finally:
1468 lock.release()
1469
1470 def push(self, remote, force=False, revs=None):
1471 # there are two ways to push to remote repo:
1472 #
1473 # addchangegroup assumes local user can lock remote
1474 # repo (local filesystem, old ssh servers).
1475 #
1476 # unbundle assumes local user cannot lock remote repo (new ssh
1477 # servers, http servers).
1478
1479 if remote.capable('unbundle'):
1480 return self.push_unbundle(remote, force, revs)
1481 return self.push_addchangegroup(remote, force, revs)
1482
1483 def prepush(self, remote, force, revs):
1484 common = {}
1485 remote_heads = remote.heads()
1486 inc = self.findincoming(remote, common, remote_heads, force=force)
1487
1488 update, updated_heads = self.findoutgoing(remote, common, remote_heads)
1489 if revs is not None:
1490 msng_cl, bases, heads = self.changelog.nodesbetween(update, revs)
1491 else:
1492 bases, heads = update, self.changelog.heads()
1493
1494 def checkbranch(lheads, rheads, updatelh):
1495 '''
1496 check whether there are more local heads than remote heads on
1497 a specific branch.
1498
1499 lheads: local branch heads
1500 rheads: remote branch heads
1501 updatelh: outgoing local branch heads
1502 '''
1503
1504 warn = 0
1505
1506 if not revs and len(lheads) > len(rheads):
1507 warn = 1
1508 else:
1509 updatelheads = [self.changelog.heads(x, lheads)
1510 for x in updatelh]
1511 newheads = set(sum(updatelheads, [])) & set(lheads)
1512
1513 if not newheads:
1514 return True
1515
1516 for r in rheads:
1517 if r in self.changelog.nodemap:
1518 desc = self.changelog.heads(r, heads)
1519 l = [h for h in heads if h in desc]
1520 if not l:
1521 newheads.add(r)
1522 else:
1523 newheads.add(r)
1524 if len(newheads) > len(rheads):
1525 warn = 1
1526
1527 if warn:
1528 if not rheads: # new branch requires --force
1529 self.ui.warn(_("abort: push creates new"
1530 " remote branch '%s'!\n") %
1531 self[updatelh[0]].branch())
1532 else:
1533 self.ui.warn(_("abort: push creates new remote heads!\n"))
1534
1535 self.ui.status(_("(did you forget to merge?"
1536 " use push -f to force)\n"))
1537 return False
1538 return True
1539
1540 if not bases:
1541 self.ui.status(_("no changes found\n"))
1542 return None, 1
1543 elif not force:
1544 # Check for each named branch if we're creating new remote heads.
1545 # To be a remote head after push, node must be either:
1546 # - unknown locally
1547 # - a local outgoing head descended from update
1548 # - a remote head that's known locally and not
1549 # ancestral to an outgoing head
1550 #
1551 # New named branches cannot be created without --force.
1552
1553 if remote_heads != [nullid]:
1554 if remote.capable('branchmap'):
1555 localhds = {}
1556 if not revs:
1557 localhds = self.branchmap()
1558 else:
1559 for n in heads:
1560 branch = self[n].branch()
1561 if branch in localhds:
1562 localhds[branch].append(n)
1563 else:
1564 localhds[branch] = [n]
1565
1566 remotehds = remote.branchmap()
1567
1568 for lh in localhds:
1569 if lh in remotehds:
1570 rheads = remotehds[lh]
1571 else:
1572 rheads = []
1573 lheads = localhds[lh]
1574 updatelh = [upd for upd in update
1575 if self[upd].branch() == lh]
1576 if not updatelh:
1577 continue
1578 if not checkbranch(lheads, rheads, updatelh):
1579 return None, 0
1580 else:
1581 if not checkbranch(heads, remote_heads, update):
1582 return None, 0
1583
1584 if inc:
1585 self.ui.warn(_("note: unsynced remote changes!\n"))
1586
1587
1588 if revs is None:
1589 # use the fast path, no race possible on push
1590 cg = self._changegroup(common.keys(), 'push')
1591 else:
1592 cg = self.changegroupsubset(update, revs, 'push')
1593 return cg, remote_heads
1594
1595 def push_addchangegroup(self, remote, force, revs):
1596 lock = remote.lock()
1597 try:
1598 ret = self.prepush(remote, force, revs)
1599 if ret[0] is not None:
1600 cg, remote_heads = ret
1601 return remote.addchangegroup(cg, 'push', self.url())
1602 return ret[1]
1603 finally:
1604 lock.release()
1605
1606 def push_unbundle(self, remote, force, revs):
1607 # local repo finds heads on server, finds out what revs it
1608 # must push. once revs transferred, if server finds it has
1609 # different heads (someone else won commit/push race), server
1610 # aborts.
1611
1612 ret = self.prepush(remote, force, revs)
1613 if ret[0] is not None:
1614 cg, remote_heads = ret
1615 if force: remote_heads = ['force']
1616 return remote.unbundle(cg, remote_heads, 'push')
1617 return ret[1]
1618
1619 def changegroupinfo(self, nodes, source):
1620 if self.ui.verbose or source == 'bundle':
1621 self.ui.status(_("%d changesets found\n") % len(nodes))
1622 if self.ui.debugflag:
1623 self.ui.debug(_("list of changesets:\n"))
1624 for node in nodes:
1625 self.ui.debug("%s\n" % hex(node))
1626
1627 def changegroupsubset(self, bases, heads, source, extranodes=None):
1628 """This function generates a changegroup consisting of all the nodes
1629 that are descendents of any of the bases, and ancestors of any of
1630 the heads.
1631
1632 It is fairly complex as determining which filenodes and which
1633 manifest nodes need to be included for the changeset to be complete
1634 is non-trivial.
1635
1636 Another wrinkle is doing the reverse, figuring out which changeset in
1637 the changegroup a particular filenode or manifestnode belongs to.
1638
1639 The caller can specify some nodes that must be included in the
1640 changegroup using the extranodes argument. It should be a dict
1641 where the keys are the filenames (or 1 for the manifest), and the
1642 values are lists of (node, linknode) tuples, where node is a wanted
1643 node and linknode is the changelog node that should be transmitted as
1644 the linkrev.
1645 """
1646
1647 if extranodes is None:
1648 # can we go through the fast path ?
1649 heads.sort()
1650 allheads = self.heads()
1651 allheads.sort()
1652 if heads == allheads:
1653 common = []
1654 # parents of bases are known from both sides
1655 for n in bases:
1656 for p in self.changelog.parents(n):
1657 if p != nullid:
1658 common.append(p)
1659 return self._changegroup(common, source)
1660
1661 self.hook('preoutgoing', throw=True, source=source)
1662
1663 # Set up some initial variables
1664 # Make it easy to refer to self.changelog
1665 cl = self.changelog
1666 # msng is short for missing - compute the list of changesets in this
1667 # changegroup.
1668 msng_cl_lst, bases, heads = cl.nodesbetween(bases, heads)
1669 self.changegroupinfo(msng_cl_lst, source)
1670 # Some bases may turn out to be superfluous, and some heads may be
1671 # too. nodesbetween will return the minimal set of bases and heads
1672 # necessary to re-create the changegroup.
1673
1674 # Known heads are the list of heads that it is assumed the recipient
1675 # of this changegroup will know about.
1676 knownheads = set()
1677 # We assume that all parents of bases are known heads.
1678 for n in bases:
1679 knownheads.update(cl.parents(n))
1680 knownheads.discard(nullid)
1681 knownheads = list(knownheads)
1682 if knownheads:
1683 # Now that we know what heads are known, we can compute which
1684 # changesets are known. The recipient must know about all
1685 # changesets required to reach the known heads from the null
1686 # changeset.
1687 has_cl_set, junk, junk = cl.nodesbetween(None, knownheads)
1688 junk = None
1689 # Transform the list into a set.
1690 has_cl_set = set(has_cl_set)
1691 else:
1692 # If there were no known heads, the recipient cannot be assumed to
1693 # know about any changesets.
1694 has_cl_set = set()
1695
1696 # Make it easy to refer to self.manifest
1697 mnfst = self.manifest
1698 # We don't know which manifests are missing yet
1699 msng_mnfst_set = {}
1700 # Nor do we know which filenodes are missing.
1701 msng_filenode_set = {}
1702
1703 junk = mnfst.index[len(mnfst) - 1] # Get around a bug in lazyindex
1704 junk = None
1705
1706 # A changeset always belongs to itself, so the changenode lookup
1707 # function for a changenode is identity.
1708 def identity(x):
1709 return x
1710
1711 # A function generating function. Sets up an environment for the
1712 # inner function.
1713 def cmp_by_rev_func(revlog):
1714 # Compare two nodes by their revision number in the environment's
1715 # revision history. Since the revision number both represents the
1716 # most efficient order to read the nodes in, and represents a
1717 # topological sorting of the nodes, this function is often useful.
1718 def cmp_by_rev(a, b):
1719 return cmp(revlog.rev(a), revlog.rev(b))
1720 return cmp_by_rev
1721
1722 # If we determine that a particular file or manifest node must be a
1723 # node that the recipient of the changegroup will already have, we can
1724 # also assume the recipient will have all the parents. This function
1725 # prunes them from the set of missing nodes.
1726 def prune_parents(revlog, hasset, msngset):
1727 haslst = list(hasset)
1728 haslst.sort(cmp_by_rev_func(revlog))
1729 for node in haslst:
1730 parentlst = [p for p in revlog.parents(node) if p != nullid]
1731 while parentlst:
1732 n = parentlst.pop()
1733 if n not in hasset:
1734 hasset.add(n)
1735 p = [p for p in revlog.parents(n) if p != nullid]
1736 parentlst.extend(p)
1737 for n in hasset:
1738 msngset.pop(n, None)
1739
1740 # This is a function generating function used to set up an environment
1741 # for the inner function to execute in.
1742 def manifest_and_file_collector(changedfileset):
1743 # This is an information gathering function that gathers
1744 # information from each changeset node that goes out as part of
1745 # the changegroup. The information gathered is a list of which
1746 # manifest nodes are potentially required (the recipient may
1747 # already have them) and total list of all files which were
1748 # changed in any changeset in the changegroup.
1749 #
1750 # We also remember the first changenode we saw any manifest
1751 # referenced by so we can later determine which changenode 'owns'
1752 # the manifest.
1753 def collect_manifests_and_files(clnode):
1754 c = cl.read(clnode)
1755 for f in c[3]:
1756 # This is to make sure we only have one instance of each
1757 # filename string for each filename.
1758 changedfileset.setdefault(f, f)
1759 msng_mnfst_set.setdefault(c[0], clnode)
1760 return collect_manifests_and_files
1761
1762 # Figure out which manifest nodes (of the ones we think might be part
1763 # of the changegroup) the recipient must know about and remove them
1764 # from the changegroup.
1765 def prune_manifests():
1766 has_mnfst_set = set()
1767 for n in msng_mnfst_set:
1768 # If a 'missing' manifest thinks it belongs to a changenode
1769 # the recipient is assumed to have, obviously the recipient
1770 # must have that manifest.
1771 linknode = cl.node(mnfst.linkrev(mnfst.rev(n)))
1772 if linknode in has_cl_set:
1773 has_mnfst_set.add(n)
1774 prune_parents(mnfst, has_mnfst_set, msng_mnfst_set)
1775
1776 # Use the information collected in collect_manifests_and_files to say
1777 # which changenode any manifestnode belongs to.
1778 def lookup_manifest_link(mnfstnode):
1779 return msng_mnfst_set[mnfstnode]
1780
1781 # A function generating function that sets up the initial environment
1782 # the inner function.
1783 def filenode_collector(changedfiles):
1784 next_rev = [0]
1785 # This gathers information from each manifestnode included in the
1786 # changegroup about which filenodes the manifest node references
1787 # so we can include those in the changegroup too.
1788 #
1789 # It also remembers which changenode each filenode belongs to. It
1790 # does this by assuming the a filenode belongs to the changenode
1791 # the first manifest that references it belongs to.
1792 def collect_msng_filenodes(mnfstnode):
1793 r = mnfst.rev(mnfstnode)
1794 if r == next_rev[0]:
1795 # If the last rev we looked at was the one just previous,
1796 # we only need to see a diff.
1797 deltamf = mnfst.readdelta(mnfstnode)
1798 # For each line in the delta
1799 for f, fnode in deltamf.iteritems():
1800 f = changedfiles.get(f, None)
1801 # And if the file is in the list of files we care
1802 # about.
1803 if f is not None:
1804 # Get the changenode this manifest belongs to
1805 clnode = msng_mnfst_set[mnfstnode]
1806 # Create the set of filenodes for the file if
1807 # there isn't one already.
1808 ndset = msng_filenode_set.setdefault(f, {})
1809 # And set the filenode's changelog node to the
1810 # manifest's if it hasn't been set already.
1811 ndset.setdefault(fnode, clnode)
1812 else:
1813 # Otherwise we need a full manifest.
1814 m = mnfst.read(mnfstnode)
1815 # For every file in we care about.
1816 for f in changedfiles:
1817 fnode = m.get(f, None)
1818 # If it's in the manifest
1819 if fnode is not None:
1820 # See comments above.
1821 clnode = msng_mnfst_set[mnfstnode]
1822 ndset = msng_filenode_set.setdefault(f, {})
1823 ndset.setdefault(fnode, clnode)
1824 # Remember the revision we hope to see next.
1825 next_rev[0] = r + 1
1826 return collect_msng_filenodes
1827
1828 # We have a list of filenodes we think we need for a file, lets remove
1829 # all those we know the recipient must have.
1830 def prune_filenodes(f, filerevlog):
1831 msngset = msng_filenode_set[f]
1832 hasset = set()
1833 # If a 'missing' filenode thinks it belongs to a changenode we
1834 # assume the recipient must have, then the recipient must have
1835 # that filenode.
1836 for n in msngset:
1837 clnode = cl.node(filerevlog.linkrev(filerevlog.rev(n)))
1838 if clnode in has_cl_set:
1839 hasset.add(n)
1840 prune_parents(filerevlog, hasset, msngset)
1841
1842 # A function generator function that sets up the a context for the
1843 # inner function.
1844 def lookup_filenode_link_func(fname):
1845 msngset = msng_filenode_set[fname]
1846 # Lookup the changenode the filenode belongs to.
1847 def lookup_filenode_link(fnode):
1848 return msngset[fnode]
1849 return lookup_filenode_link
1850
1851 # Add the nodes that were explicitly requested.
1852 def add_extra_nodes(name, nodes):
1853 if not extranodes or name not in extranodes:
1854 return
1855
1856 for node, linknode in extranodes[name]:
1857 if node not in nodes:
1858 nodes[node] = linknode
1859
1860 # Now that we have all theses utility functions to help out and
1861 # logically divide up the task, generate the group.
1862 def gengroup():
1863 # The set of changed files starts empty.
1864 changedfiles = {}
1865 # Create a changenode group generator that will call our functions
1866 # back to lookup the owning changenode and collect information.
1867 group = cl.group(msng_cl_lst, identity,
1868 manifest_and_file_collector(changedfiles))
1869 for chnk in group:
1870 yield chnk
1871
1872 # The list of manifests has been collected by the generator
1873 # calling our functions back.
1874 prune_manifests()
1875 add_extra_nodes(1, msng_mnfst_set)
1876 msng_mnfst_lst = msng_mnfst_set.keys()
1877 # Sort the manifestnodes by revision number.
1878 msng_mnfst_lst.sort(cmp_by_rev_func(mnfst))
1879 # Create a generator for the manifestnodes that calls our lookup
1880 # and data collection functions back.
1881 group = mnfst.group(msng_mnfst_lst, lookup_manifest_link,
1882 filenode_collector(changedfiles))
1883 for chnk in group:
1884 yield chnk
1885
1886 # These are no longer needed, dereference and toss the memory for
1887 # them.
1888 msng_mnfst_lst = None
1889 msng_mnfst_set.clear()
1890
1891 if extranodes:
1892 for fname in extranodes:
1893 if isinstance(fname, int):
1894 continue
1895 msng_filenode_set.setdefault(fname, {})
1896 changedfiles[fname] = 1
1897 # Go through all our files in order sorted by name.
1898 for fname in sorted(changedfiles):
1899 filerevlog = self.file(fname)
1900 if not len(filerevlog):
1901 raise util.Abort(_("empty or missing revlog for %s") % fname)
1902 # Toss out the filenodes that the recipient isn't really
1903 # missing.
1904 if fname in msng_filenode_set:
1905 prune_filenodes(fname, filerevlog)
1906 add_extra_nodes(fname, msng_filenode_set[fname])
1907 msng_filenode_lst = msng_filenode_set[fname].keys()
1908 else:
1909 msng_filenode_lst = []
1910 # If any filenodes are left, generate the group for them,
1911 # otherwise don't bother.
1912 if len(msng_filenode_lst) > 0:
1913 yield changegroup.chunkheader(len(fname))
1914 yield fname
1915 # Sort the filenodes by their revision #
1916 msng_filenode_lst.sort(cmp_by_rev_func(filerevlog))
1917 # Create a group generator and only pass in a changenode
1918 # lookup function as we need to collect no information
1919 # from filenodes.
1920 group = filerevlog.group(msng_filenode_lst,
1921 lookup_filenode_link_func(fname))
1922 for chnk in group:
1923 yield chnk
1924 if fname in msng_filenode_set:
1925 # Don't need this anymore, toss it to free memory.
1926 del msng_filenode_set[fname]
1927 # Signal that no more groups are left.
1928 yield changegroup.closechunk()
1929
1930 if msng_cl_lst:
1931 self.hook('outgoing', node=hex(msng_cl_lst[0]), source=source)
1932
1933 return util.chunkbuffer(gengroup())
1934
1935 def changegroup(self, basenodes, source):
1936 # to avoid a race we use changegroupsubset() (issue1320)
1937 return self.changegroupsubset(basenodes, self.heads(), source)
1938
1939 def _changegroup(self, common, source):
1940 """Generate a changegroup of all nodes that we have that a recipient
1941 doesn't.
1942
1943 This is much easier than the previous function as we can assume that
1944 the recipient has any changenode we aren't sending them.
1945
1946 common is the set of common nodes between remote and self"""
1947
1948 self.hook('preoutgoing', throw=True, source=source)
1949
1950 cl = self.changelog
1951 nodes = cl.findmissing(common)
1952 revset = set([cl.rev(n) for n in nodes])
1953 self.changegroupinfo(nodes, source)
1954
1955 def identity(x):
1956 return x
1957
1958 def gennodelst(log):
1959 for r in log:
1960 if log.linkrev(r) in revset:
1961 yield log.node(r)
1962
1963 def changed_file_collector(changedfileset):
1964 def collect_changed_files(clnode):
1965 c = cl.read(clnode)
1966 changedfileset.update(c[3])
1967 return collect_changed_files
1968
1969 def lookuprevlink_func(revlog):
1970 def lookuprevlink(n):
1971 return cl.node(revlog.linkrev(revlog.rev(n)))
1972 return lookuprevlink
1973
1974 def gengroup():
1975 # construct a list of all changed files
1976 changedfiles = set()
1977
1978 for chnk in cl.group(nodes, identity,
1979 changed_file_collector(changedfiles)):
1980 yield chnk
1981
1982 mnfst = self.manifest
1983 nodeiter = gennodelst(mnfst)
1984 for chnk in mnfst.group(nodeiter, lookuprevlink_func(mnfst)):
1985 yield chnk
1986
1987 for fname in sorted(changedfiles):
1988 filerevlog = self.file(fname)
1989 if not len(filerevlog):
1990 raise util.Abort(_("empty or missing revlog for %s") % fname)
1991 nodeiter = gennodelst(filerevlog)
1992 nodeiter = list(nodeiter)
1993 if nodeiter:
1994 yield changegroup.chunkheader(len(fname))
1995 yield fname
1996 lookup = lookuprevlink_func(filerevlog)
1997 for chnk in filerevlog.group(nodeiter, lookup):
1998 yield chnk
1999
2000 yield changegroup.closechunk()
2001
2002 if nodes:
2003 self.hook('outgoing', node=hex(nodes[0]), source=source)
2004
2005 return util.chunkbuffer(gengroup())
2006
2007 def addchangegroup(self, source, srctype, url, emptyok=False):
2008 """add changegroup to repo.
2009
2010 return values:
2011 - nothing changed or no source: 0
2012 - more heads than before: 1+added heads (2..n)
2013 - less heads than before: -1-removed heads (-2..-n)
2014 - number of heads stays the same: 1
2015 """
2016 def csmap(x):
2017 self.ui.debug(_("add changeset %s\n") % short(x))
2018 return len(cl)
2019
2020 def revmap(x):
2021 return cl.rev(x)
2022
2023 if not source:
2024 return 0
2025
2026 self.hook('prechangegroup', throw=True, source=srctype, url=url)
2027
2028 changesets = files = revisions = 0
2029
2030 # write changelog data to temp files so concurrent readers will not see
2031 # inconsistent view
2032 cl = self.changelog
2033 cl.delayupdate()
2034 oldheads = len(cl.heads())
2035
2036 tr = self.transaction()
2037 try:
2038 trp = weakref.proxy(tr)
2039 # pull off the changeset group
2040 self.ui.status(_("adding changesets\n"))
2041 clstart = len(cl)
2042 chunkiter = changegroup.chunkiter(source)
2043 if cl.addgroup(chunkiter, csmap, trp) is None and not emptyok:
2044 raise util.Abort(_("received changelog group is empty"))
2045 clend = len(cl)
2046 changesets = clend - clstart
2047
2048 # pull off the manifest group
2049 self.ui.status(_("adding manifests\n"))
2050 chunkiter = changegroup.chunkiter(source)
2051 # no need to check for empty manifest group here:
2052 # if the result of the merge of 1 and 2 is the same in 3 and 4,
2053 # no new manifest will be created and the manifest group will
2054 # be empty during the pull
2055 self.manifest.addgroup(chunkiter, revmap, trp)
2056
2057 # process the files
2058 self.ui.status(_("adding file changes\n"))
2059 while 1:
2060 f = changegroup.getchunk(source)
2061 if not f:
2062 break
2063 self.ui.debug(_("adding %s revisions\n") % f)
2064 fl = self.file(f)
2065 o = len(fl)
2066 chunkiter = changegroup.chunkiter(source)
2067 if fl.addgroup(chunkiter, revmap, trp) is None:
2068 raise util.Abort(_("received file revlog group is empty"))
2069 revisions += len(fl) - o
2070 files += 1
2071
2072 newheads = len(cl.heads())
2073 heads = ""
2074 if oldheads and newheads != oldheads:
2075 heads = _(" (%+d heads)") % (newheads - oldheads)
2076
2077 self.ui.status(_("added %d changesets"
2078 " with %d changes to %d files%s\n")
2079 % (changesets, revisions, files, heads))
2080
2081 if changesets > 0:
2082 p = lambda: cl.writepending() and self.root or ""
2083 self.hook('pretxnchangegroup', throw=True,
2084 node=hex(cl.node(clstart)), source=srctype,
2085 url=url, pending=p)
2086
2087 # make changelog see real files again
2088 cl.finalize(trp)
2089
2090 tr.close()
2091 finally:
2092 del tr
2093
2094 if changesets > 0:
2095 # forcefully update the on-disk branch cache
2096 self.ui.debug(_("updating the branch cache\n"))
2097 self.branchtags()
2098 self.hook("changegroup", node=hex(cl.node(clstart)),
2099 source=srctype, url=url)
2100
2101 for i in xrange(clstart, clend):
2102 self.hook("incoming", node=hex(cl.node(i)),
2103 source=srctype, url=url)
2104
2105 # never return 0 here:
2106 if newheads < oldheads:
2107 return newheads - oldheads - 1
2108 else:
2109 return newheads - oldheads + 1
2110
2111
2112 def stream_in(self, remote):
2113 fp = remote.stream_out()
2114 l = fp.readline()
2115 try:
2116 resp = int(l)
2117 except ValueError:
2118 raise error.ResponseError(
2119 _('Unexpected response from remote server:'), l)
2120 if resp == 1:
2121 raise util.Abort(_('operation forbidden by server'))
2122 elif resp == 2:
2123 raise util.Abort(_('locking the remote repository failed'))
2124 elif resp != 0:
2125 raise util.Abort(_('the server sent an unknown error code'))
2126 self.ui.status(_('streaming all changes\n'))
2127 l = fp.readline()
2128 try:
2129 total_files, total_bytes = map(int, l.split(' ', 1))
2130 except (ValueError, TypeError):
2131 raise error.ResponseError(
2132 _('Unexpected response from remote server:'), l)
2133 self.ui.status(_('%d files to transfer, %s of data\n') %
2134 (total_files, util.bytecount(total_bytes)))
2135 start = time.time()
2136 for i in xrange(total_files):
2137 # XXX doesn't support '\n' or '\r' in filenames
2138 l = fp.readline()
2139 try:
2140 name, size = l.split('\0', 1)
2141 size = int(size)
2142 except (ValueError, TypeError):
2143 raise error.ResponseError(
2144 _('Unexpected response from remote server:'), l)
2145 self.ui.debug(_('adding %s (%s)\n') % (name, util.bytecount(size)))
2146 # for backwards compat, name was partially encoded
2147 ofp = self.sopener(store.decodedir(name), 'w')
2148 for chunk in util.filechunkiter(fp, limit=size):
2149 ofp.write(chunk)
2150 ofp.close()
2151 elapsed = time.time() - start
2152 if elapsed <= 0:
2153 elapsed = 0.001
2154 self.ui.status(_('transferred %s in %.1f seconds (%s/sec)\n') %
2155 (util.bytecount(total_bytes), elapsed,
2156 util.bytecount(total_bytes / elapsed)))
2157 self.invalidate()
2158 return len(self.heads()) + 1
2159
2160 def clone(self, remote, heads=[], stream=False):
2161 '''clone remote repository.
2162
2163 keyword arguments:
2164 heads: list of revs to clone (forces use of pull)
2165 stream: use streaming clone if possible'''
2166
2167 # now, all clients that can request uncompressed clones can
2168 # read repo formats supported by all servers that can serve
2169 # them.
2170
2171 # if revlog format changes, client will have to check version
2172 # and format flags on "stream" capability, and use
2173 # uncompressed only if compatible.
2174
2175 if stream and not heads and remote.capable('stream'):
2176 return self.stream_in(remote)
2177 return self.pull(remote, heads)
2178
2179 # used to avoid circular references so destructors work
2180 def aftertrans(files):
2181 renamefiles = [tuple(t) for t in files]
2182 def a():
2183 for src, dest in renamefiles:
2184 util.rename(src, dest)
2185 return a
2186
2187 def instance(ui, path, create):
2188 return localrepository(ui, util.drop_scheme('file', path), create)
2189
2190 def islocal(path):
2191 return True