« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 974.1.54
- compare with another revision
- download diff
- download tarball
- view history from revision 974.1.54
- Committer: aaron.bentley at utoronto
- Date: 2005-09-05 01:31:37 UTC
- mto: (1185.3.4)
- mto: This revision was merged to the branch mainline in revision 1178.
- Revision ID: aaron.bentley@utoronto.ca-20050905013137-c8b598b5a90a52a9
Fixed the revno bug in log
- files added:
- bzrlib/mdiff.py
- files removed:
- BRANCH.TODO
- bzrlib/export
- bzrlib/store
- bzrlib/tests/blackbox
- bzrlib/transport
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- files renamed:
- bzr_man.py => bzr-man.py
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/tests/ => bzrlib/selftest/
- bzrlib/tests/blackbox/test_too_much.py => bzrlib/selftest/blackbox.py
- bzrlib/tests/test_plugins.py => bzrlib/selftest/plugins.py
- bzrlib/tests/test_branch.py => bzrlib/selftest/testbranch.py
- bzrlib/tests/test_diff.py => bzrlib/selftest/testdiff.py
- bzrlib/tests/test_fetch.py => bzrlib/selftest/testfetch.py
- bzrlib/tests/test_hashcache.py => bzrlib/selftest/testhashcache.py
- bzrlib/tests/test_inv.py => bzrlib/selftest/testinv.py
- bzrlib/tests/test_log.py => bzrlib/selftest/testlog.py
- bzrlib/tests/test_merge3.py => bzrlib/selftest/testmerge3.py
- bzrlib/tests/test_revision.py => bzrlib/selftest/testrevision.py
- bzrlib/tests/test_revisionnamespaces.py => bzrlib/selftest/testrevisionnamespaces.py
- bzrlib/tests/test_status.py => bzrlib/selftest/teststatus.py
- bzrlib/tests/test_store.py => bzrlib/selftest/teststore.py
- bzrlib/tests/blackbox/test_versioning.py => bzrlib/selftest/versioning.py
- bzrlib/tests/test_whitebox.py => bzrlib/selftest/whitebox.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/ui/__init__.py => bzrlib/ui.py
- bzrlib/upgrade.py => tools/history2weaves.py
- bzrlib/tests/test_weave.py => tools/testweave.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
import shutil
19
18
import sys
20
19
import os
21
import errno
22
from warnings import warn
23
from cStringIO import StringIO
24
25
20
26
21
import bzrlib
27
22
from bzrlib.trace import mutter, note
28
from bzrlib.osutils import (isdir, quotefn,
29
rename, splitpath, sha_file,
30
file_kind, abspath, normpath, pathjoin)
31
import bzrlib.errors as errors
32
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
33
NoSuchRevision, HistoryMissing, NotBranchError,
34
DivergedBranches, LockError, UnlistableStore,
35
UnlistableBranch, NoSuchFile, NotVersionedError,
36
NoWorkingTree)
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
24
splitpath, \
25
sha_file, appendpath, file_kind
26
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
28
import bzrlib.errors
37
29
from bzrlib.textui import show_status
38
from bzrlib.config import TreeConfig
30
from bzrlib.revision import Revision
31
from bzrlib.xml import unpack_xml
39
32
from bzrlib.delta import compare_trees
40
import bzrlib.inventory as inventory
41
from bzrlib.inventory import Inventory
42
from bzrlib.lockable_files import LockableFiles
43
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions)
44
from bzrlib.repository import Repository
45
from bzrlib.store import copy_all
46
import bzrlib.transactions as transactions
47
from bzrlib.transport import Transport, get_transport
48
33
from bzrlib.tree import EmptyTree, RevisionTree
49
34
import bzrlib.ui
50
import bzrlib.xml5
51
52
53
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
54
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
55
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
35
36
37
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
56
39
## TODO: Maybe include checks for common corruption of newlines, etc?
57
40
58
41
59
42
# TODO: Some operations like log might retrieve the same revisions
60
43
# repeatedly to calculate deltas. We could perhaps have a weakref
61
# cache in memory to make this faster. In general anything can be
62
# cached in memory between lock and unlock operations.
63
64
def find_branch(*ignored, **ignored_too):
65
# XXX: leave this here for about one release, then remove it
66
raise NotImplementedError('find_branch() is not supported anymore, '
67
'please use one of the new branch constructors')
68
69
70
def needs_read_lock(unbound):
71
"""Decorate unbound to take out and release a read lock."""
72
def decorated(self, *args, **kwargs):
73
self.lock_read()
74
try:
75
return unbound(self, *args, **kwargs)
76
finally:
77
self.unlock()
78
return decorated
79
80
81
def needs_write_lock(unbound):
82
"""Decorate unbound to take out and release a write lock."""
83
def decorated(self, *args, **kwargs):
84
self.lock_write()
85
try:
86
return unbound(self, *args, **kwargs)
87
finally:
88
self.unlock()
89
return decorated
44
# cache in memory to make this faster.
45
46
# TODO: please move the revision-string syntax stuff out of the branch
47
# object; it's clutter
48
49
50
def find_branch(f, **args):
51
if f and (f.startswith('http://') or f.startswith('https://')):
52
import remotebranch
53
return remotebranch.RemoteBranch(f, **args)
54
else:
55
return Branch(f, **args)
56
57
58
def find_cached_branch(f, cache_root, **args):
59
from remotebranch import RemoteBranch
60
br = find_branch(f, **args)
61
def cacheify(br, store_name):
62
from meta_store import CachedStore
63
cache_path = os.path.join(cache_root, store_name)
64
os.mkdir(cache_path)
65
new_store = CachedStore(getattr(br, store_name), cache_path)
66
setattr(br, store_name, new_store)
67
68
if isinstance(br, RemoteBranch):
69
cacheify(br, 'inventory_store')
70
cacheify(br, 'text_store')
71
cacheify(br, 'revision_store')
72
return br
73
74
75
def _relpath(base, path):
76
"""Return path relative to base, or raise exception.
77
78
The path may be either an absolute path or a path relative to the
79
current working directory.
80
81
Lifted out of Branch.relpath for ease of testing.
82
83
os.path.commonprefix (python2.4) has a bad bug that it works just
84
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
85
avoids that problem."""
86
rp = os.path.abspath(path)
87
88
s = []
89
head = rp
90
while len(head) >= len(base):
91
if head == base:
92
break
93
head, tail = os.path.split(head)
94
if tail:
95
s.insert(0, tail)
96
else:
97
from errors import NotBranchError
98
raise NotBranchError("path %r is not within branch %r" % (rp, base))
99
100
return os.sep.join(s)
101
102
103
def find_branch_root(f=None):
104
"""Find the branch root enclosing f, or pwd.
105
106
f may be a filename or a URL.
107
108
It is not necessary that f exists.
109
110
Basically we keep looking up until we find the control directory or
111
run into the root. If there isn't one, raises NotBranchError.
112
"""
113
if f == None:
114
f = os.getcwd()
115
elif hasattr(os.path, 'realpath'):
116
f = os.path.realpath(f)
117
else:
118
f = os.path.abspath(f)
119
if not os.path.exists(f):
120
raise BzrError('%r does not exist' % f)
121
122
123
orig_f = f
124
125
while True:
126
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
127
return f
128
head, tail = os.path.split(f)
129
if head == f:
130
# reached the root, whatever that may be
131
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
132
f = head
133
134
135
136
# XXX: move into bzrlib.errors; subclass BzrError
137
class DivergedBranches(Exception):
138
def __init__(self, branch1, branch2):
139
self.branch1 = branch1
140
self.branch2 = branch2
141
Exception.__init__(self, "These branches have diverged.")
142
90
143
91
144
######################################################################
92
145
# branch objects
95
148
"""Branch holding a history of revisions.
96
149
97
150
base
98
Base directory/url of the branch.
151
Base directory of the branch.
152
153
_lock_mode
154
None, or 'r' or 'w'
155
156
_lock_count
157
If _lock_mode is true, a positive count of the number of times the
158
lock has been taken.
159
160
_lock
161
Lock object from bzrlib.lock.
99
162
"""
100
163
base = None
101
102
def __init__(self, *ignored, **ignored_too):
103
raise NotImplementedError('The Branch class is abstract')
104
105
@staticmethod
106
def open_downlevel(base):
107
"""Open a branch which may be of an old format.
108
109
Only local branches are supported."""
110
return BzrBranch(get_transport(base), relax_version_check=True)
111
112
@staticmethod
113
def open(base):
114
"""Open an existing branch, rooted at 'base' (url)"""
115
t = get_transport(base)
116
mutter("trying to open %r with transport %r", base, t)
117
return BzrBranch(t)
118
119
@staticmethod
120
def open_containing(url):
121
"""Open an existing branch which contains url.
122
123
This probes for a branch at url, and searches upwards from there.
124
125
Basically we keep looking up until we find the control directory or
126
run into the root. If there isn't one, raises NotBranchError.
127
If there is one, it is returned, along with the unused portion of url.
128
"""
129
t = get_transport(url)
130
while True:
131
try:
132
return BzrBranch(t), t.relpath(url)
133
except NotBranchError, e:
134
mutter('not a branch in: %r %s', t.base, e)
135
new_t = t.clone('..')
136
if new_t.base == t.base:
137
# reached the root, whatever that may be
138
raise NotBranchError(path=url)
139
t = new_t
140
141
@staticmethod
142
def initialize(base):
143
"""Create a new branch, rooted at 'base' (url)"""
144
t = get_transport(unicode(base))
145
return BzrBranch(t, init=True)
146
147
def setup_caching(self, cache_root):
148
"""Subclasses that care about caching should override this, and set
149
up cached stores located under cache_root.
150
"""
151
self.cache_root = cache_root
152
153
def _get_nick(self):
154
cfg = self.tree_config()
155
return cfg.get_option(u"nickname", default=self.base.split('/')[-1])
156
157
def _set_nick(self, nick):
158
cfg = self.tree_config()
159
cfg.set_option(nick, "nickname")
160
assert cfg.get_option("nickname") == nick
161
162
nick = property(_get_nick, _set_nick)
163
164
def push_stores(self, branch_to):
165
"""Copy the content of this branches store to branch_to."""
166
raise NotImplementedError('push_stores is abstract')
164
_lock_mode = None
165
_lock_count = None
166
_lock = None
167
168
# Map some sort of prefix into a namespace
169
# stuff like "revno:10", "revid:", etc.
170
# This should match a prefix with a function which accepts
171
REVISION_NAMESPACES = {}
172
173
def __init__(self, base, init=False, find_root=True):
174
"""Create new branch object at a particular location.
175
176
base -- Base directory for the branch.
177
178
init -- If True, create new control files in a previously
179
unversioned directory. If False, the branch must already
180
be versioned.
181
182
find_root -- If true and init is false, find the root of the
183
existing branch containing base.
184
185
In the test suite, creation of new trees is tested using the
186
`ScratchBranch` class.
187
"""
188
from bzrlib.store import ImmutableStore
189
if init:
190
self.base = os.path.realpath(base)
191
self._make_control()
192
elif find_root:
193
self.base = find_branch_root(base)
194
else:
195
self.base = os.path.realpath(base)
196
if not isdir(self.controlfilename('.')):
197
from errors import NotBranchError
198
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
199
['use "bzr init" to initialize a new working tree',
200
'current bzr can only operate from top-of-tree'])
201
self._check_format()
202
203
self.text_store = ImmutableStore(self.controlfilename('text-store'))
204
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
205
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
206
207
208
def __str__(self):
209
return '%s(%r)' % (self.__class__.__name__, self.base)
210
211
212
__repr__ = __str__
213
214
215
def __del__(self):
216
if self._lock_mode or self._lock:
217
from warnings import warn
218
warn("branch %r was not explicitly unlocked" % self)
219
self._lock.unlock()
220
167
221
168
222
def lock_write(self):
169
raise NotImplementedError('lock_write is abstract')
170
223
if self._lock_mode:
224
if self._lock_mode != 'w':
225
from errors import LockError
226
raise LockError("can't upgrade to a write lock from %r" %
227
self._lock_mode)
228
self._lock_count += 1
229
else:
230
from bzrlib.lock import WriteLock
231
232
self._lock = WriteLock(self.controlfilename('branch-lock'))
233
self._lock_mode = 'w'
234
self._lock_count = 1
235
236
171
237
def lock_read(self):
172
raise NotImplementedError('lock_read is abstract')
238
if self._lock_mode:
239
assert self._lock_mode in ('r', 'w'), \
240
"invalid lock mode %r" % self._lock_mode
241
self._lock_count += 1
242
else:
243
from bzrlib.lock import ReadLock
173
244
245
self._lock = ReadLock(self.controlfilename('branch-lock'))
246
self._lock_mode = 'r'
247
self._lock_count = 1
248
174
249
def unlock(self):
175
raise NotImplementedError('unlock is abstract')
250
if not self._lock_mode:
251
from errors import LockError
252
raise LockError('branch %r is not locked' % (self))
253
254
if self._lock_count > 1:
255
self._lock_count -= 1
256
else:
257
self._lock.unlock()
258
self._lock = None
259
self._lock_mode = self._lock_count = None
176
260
177
261
def abspath(self, name):
178
"""Return absolute filename for something in the branch
262
"""Return absolute filename for something in the branch"""
263
return os.path.join(self.base, name)
264
265
def relpath(self, path):
266
"""Return path relative to this branch of something inside it.
267
268
Raises an error if path is not in this branch."""
269
return _relpath(self.base, path)
270
271
def controlfilename(self, file_or_path):
272
"""Return location relative to branch."""
273
if isinstance(file_or_path, basestring):
274
file_or_path = [file_or_path]
275
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
276
277
278
def controlfile(self, file_or_path, mode='r'):
279
"""Open a control file for this branch.
280
281
There are two classes of file in the control directory: text
282
and binary. binary files are untranslated byte streams. Text
283
control files are stored with Unix newlines and in UTF-8, even
284
if the platform or locale defaults are different.
285
286
Controlfiles should almost never be opened in write mode but
287
rather should be atomically copied and replaced using atomicfile.
288
"""
289
290
fn = self.controlfilename(file_or_path)
291
292
if mode == 'rb' or mode == 'wb':
293
return file(fn, mode)
294
elif mode == 'r' or mode == 'w':
295
# open in binary mode anyhow so there's no newline translation;
296
# codecs uses line buffering by default; don't want that.
297
import codecs
298
return codecs.open(fn, mode + 'b', 'utf-8',
299
buffering=60000)
300
else:
301
raise BzrError("invalid controlfile mode %r" % mode)
302
303
def _make_control(self):
304
from bzrlib.inventory import Inventory
305
from bzrlib.xml import pack_xml
179
306
180
XXX: Robert Collins 20051017 what is this used for? why is it a branch
181
method and not a tree method.
307
os.mkdir(self.controlfilename([]))
308
self.controlfile('README', 'w').write(
309
"This is a Bazaar-NG control directory.\n"
310
"Do not change any files in this directory.\n")
311
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
312
for d in ('text-store', 'inventory-store', 'revision-store'):
313
os.mkdir(self.controlfilename(d))
314
for f in ('revision-history', 'merged-patches',
315
'pending-merged-patches', 'branch-name',
316
'branch-lock',
317
'pending-merges'):
318
self.controlfile(f, 'w').write('')
319
mutter('created control directory in ' + self.base)
320
321
# if we want per-tree root ids then this is the place to set
322
# them; they're not needed for now and so ommitted for
323
# simplicity.
324
pack_xml(Inventory(), self.controlfile('inventory','w'))
325
326
def _check_format(self):
327
"""Check this branch format is supported.
328
329
The current tool only supports the current unstable format.
330
331
In the future, we might need different in-memory Branch
332
classes to support downlevel branches. But not yet.
182
333
"""
183
raise NotImplementedError('abspath is abstract')
334
# This ignores newlines so that we can open branches created
335
# on Windows from Linux and so on. I think it might be better
336
# to always make all internal files in unix format.
337
fmt = self.controlfile('branch-format', 'r').read()
338
fmt.replace('\r\n', '')
339
if fmt != BZR_BRANCH_FORMAT:
340
raise BzrError('sorry, branch format %r not supported' % fmt,
341
['use a different bzr version',
342
'or remove the .bzr directory and "bzr init" again'])
184
343
185
344
def get_root_id(self):
186
345
"""Return the id of this branches root"""
187
raise NotImplementedError('get_root_id is abstract')
188
189
def print_file(self, file, revision_id):
346
inv = self.read_working_inventory()
347
return inv.root.file_id
348
349
def set_root_id(self, file_id):
350
inv = self.read_working_inventory()
351
orig_root_id = inv.root.file_id
352
del inv._byid[inv.root.file_id]
353
inv.root.file_id = file_id
354
inv._byid[inv.root.file_id] = inv.root
355
for fid in inv:
356
entry = inv[fid]
357
if entry.parent_id in (None, orig_root_id):
358
entry.parent_id = inv.root.file_id
359
self._write_inventory(inv)
360
361
def read_working_inventory(self):
362
"""Read the working inventory."""
363
from bzrlib.inventory import Inventory
364
from bzrlib.xml import unpack_xml
365
from time import time
366
before = time()
367
self.lock_read()
368
try:
369
# ElementTree does its own conversion from UTF-8, so open in
370
# binary.
371
inv = unpack_xml(Inventory,
372
self.controlfile('inventory', 'rb'))
373
mutter("loaded inventory of %d items in %f"
374
% (len(inv), time() - before))
375
return inv
376
finally:
377
self.unlock()
378
379
380
def _write_inventory(self, inv):
381
"""Update the working inventory.
382
383
That is to say, the inventory describing changes underway, that
384
will be committed to the next revision.
385
"""
386
from bzrlib.atomicfile import AtomicFile
387
from bzrlib.xml import pack_xml
388
389
self.lock_write()
390
try:
391
f = AtomicFile(self.controlfilename('inventory'), 'wb')
392
try:
393
pack_xml(inv, f)
394
f.commit()
395
finally:
396
f.close()
397
finally:
398
self.unlock()
399
400
mutter('wrote working inventory')
401
402
403
inventory = property(read_working_inventory, _write_inventory, None,
404
"""Inventory for the working copy.""")
405
406
407
def add(self, files, ids=None):
408
"""Make files versioned.
409
410
Note that the command line normally calls smart_add instead,
411
which can automatically recurse.
412
413
This puts the files in the Added state, so that they will be
414
recorded by the next commit.
415
416
files
417
List of paths to add, relative to the base of the tree.
418
419
ids
420
If set, use these instead of automatically generated ids.
421
Must be the same length as the list of files, but may
422
contain None for ids that are to be autogenerated.
423
424
TODO: Perhaps have an option to add the ids even if the files do
425
not (yet) exist.
426
427
TODO: Perhaps yield the ids and paths as they're added.
428
"""
429
# TODO: Re-adding a file that is removed in the working copy
430
# should probably put it back with the previous ID.
431
if isinstance(files, basestring):
432
assert(ids is None or isinstance(ids, basestring))
433
files = [files]
434
if ids is not None:
435
ids = [ids]
436
437
if ids is None:
438
ids = [None] * len(files)
439
else:
440
assert(len(ids) == len(files))
441
442
self.lock_write()
443
try:
444
inv = self.read_working_inventory()
445
for f,file_id in zip(files, ids):
446
if is_control_file(f):
447
raise BzrError("cannot add control file %s" % quotefn(f))
448
449
fp = splitpath(f)
450
451
if len(fp) == 0:
452
raise BzrError("cannot add top-level %r" % f)
453
454
fullpath = os.path.normpath(self.abspath(f))
455
456
try:
457
kind = file_kind(fullpath)
458
except OSError:
459
# maybe something better?
460
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
461
462
if kind != 'file' and kind != 'directory':
463
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
464
465
if file_id is None:
466
file_id = gen_file_id(f)
467
inv.add_path(f, kind=kind, file_id=file_id)
468
469
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
470
471
self._write_inventory(inv)
472
finally:
473
self.unlock()
474
475
476
def print_file(self, file, revno):
190
477
"""Print `file` to stdout."""
191
raise NotImplementedError('print_file is abstract')
478
self.lock_read()
479
try:
480
tree = self.revision_tree(self.lookup_revision(revno))
481
# use inventory as it was in that revision
482
file_id = tree.inventory.path2id(file)
483
if not file_id:
484
raise BzrError("%r is not present in revision %s" % (file, revno))
485
tree.print_file(file_id)
486
finally:
487
self.unlock()
488
489
490
def remove(self, files, verbose=False):
491
"""Mark nominated files for removal from the inventory.
492
493
This does not remove their text. This does not run on
494
495
TODO: Refuse to remove modified files unless --force is given?
496
497
TODO: Do something useful with directories.
498
499
TODO: Should this remove the text or not? Tough call; not
500
removing may be useful and the user can just use use rm, and
501
is the opposite of add. Removing it is consistent with most
502
other tools. Maybe an option.
503
"""
504
## TODO: Normalize names
505
## TODO: Remove nested loops; better scalability
506
if isinstance(files, basestring):
507
files = [files]
508
509
self.lock_write()
510
511
try:
512
tree = self.working_tree()
513
inv = tree.inventory
514
515
# do this before any modifications
516
for f in files:
517
fid = inv.path2id(f)
518
if not fid:
519
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
520
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
521
if verbose:
522
# having remove it, it must be either ignored or unknown
523
if tree.is_ignored(f):
524
new_status = 'I'
525
else:
526
new_status = '?'
527
show_status(new_status, inv[fid].kind, quotefn(f))
528
del inv[fid]
529
530
self._write_inventory(inv)
531
finally:
532
self.unlock()
533
534
535
# FIXME: this doesn't need to be a branch method
536
def set_inventory(self, new_inventory_list):
537
from bzrlib.inventory import Inventory, InventoryEntry
538
inv = Inventory(self.get_root_id())
539
for path, file_id, parent, kind in new_inventory_list:
540
name = os.path.basename(path)
541
if name == "":
542
continue
543
inv.add(InventoryEntry(file_id, name, kind, parent))
544
self._write_inventory(inv)
545
546
547
def unknowns(self):
548
"""Return all unknown files.
549
550
These are files in the working directory that are not versioned or
551
control files or ignored.
552
553
>>> b = ScratchBranch(files=['foo', 'foo~'])
554
>>> list(b.unknowns())
555
['foo']
556
>>> b.add('foo')
557
>>> list(b.unknowns())
558
[]
559
>>> b.remove('foo')
560
>>> list(b.unknowns())
561
['foo']
562
"""
563
return self.working_tree().unknowns()
564
192
565
193
566
def append_revision(self, *revision_ids):
194
raise NotImplementedError('append_revision is abstract')
195
196
def set_revision_history(self, rev_history):
197
raise NotImplementedError('set_revision_history is abstract')
567
from bzrlib.atomicfile import AtomicFile
568
569
for revision_id in revision_ids:
570
mutter("add {%s} to revision-history" % revision_id)
571
572
rev_history = self.revision_history()
573
rev_history.extend(revision_ids)
574
575
f = AtomicFile(self.controlfilename('revision-history'))
576
try:
577
for rev_id in rev_history:
578
print >>f, rev_id
579
f.commit()
580
finally:
581
f.close()
582
583
584
def get_revision_xml(self, revision_id):
585
"""Return XML file object for revision object."""
586
if not revision_id or not isinstance(revision_id, basestring):
587
raise InvalidRevisionId(revision_id)
588
589
self.lock_read()
590
try:
591
try:
592
return self.revision_store[revision_id]
593
except IndexError:
594
raise bzrlib.errors.NoSuchRevision(self, revision_id)
595
finally:
596
self.unlock()
597
598
599
def get_revision(self, revision_id):
600
"""Return the Revision object for a named revision"""
601
xml_file = self.get_revision_xml(revision_id)
602
603
try:
604
r = unpack_xml(Revision, xml_file)
605
except SyntaxError, e:
606
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
607
[revision_id,
608
str(e)])
609
610
assert r.revision_id == revision_id
611
return r
612
613
614
def get_revision_delta(self, revno):
615
"""Return the delta for one revision.
616
617
The delta is relative to its mainline predecessor, or the
618
empty tree for revision 1.
619
"""
620
assert isinstance(revno, int)
621
rh = self.revision_history()
622
if not (1 <= revno <= len(rh)):
623
raise InvalidRevisionNumber(revno)
624
625
# revno is 1-based; list is 0-based
626
627
new_tree = self.revision_tree(rh[revno-1])
628
if revno == 1:
629
old_tree = EmptyTree()
630
else:
631
old_tree = self.revision_tree(rh[revno-2])
632
633
return compare_trees(old_tree, new_tree)
634
635
636
637
def get_revision_sha1(self, revision_id):
638
"""Hash the stored value of a revision, and return it."""
639
# In the future, revision entries will be signed. At that
640
# point, it is probably best *not* to include the signature
641
# in the revision hash. Because that lets you re-sign
642
# the revision, (add signatures/remove signatures) and still
643
# have all hash pointers stay consistent.
644
# But for now, just hash the contents.
645
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
646
647
648
def get_inventory(self, inventory_id):
649
"""Get Inventory object by hash.
650
651
TODO: Perhaps for this and similar methods, take a revision
652
parameter which can be either an integer revno or a
653
string hash."""
654
from bzrlib.inventory import Inventory
655
from bzrlib.xml import unpack_xml
656
657
return unpack_xml(Inventory, self.get_inventory_xml(inventory_id))
658
659
660
def get_inventory_xml(self, inventory_id):
661
"""Get inventory XML as a file object."""
662
return self.inventory_store[inventory_id]
663
664
665
def get_inventory_sha1(self, inventory_id):
666
"""Return the sha1 hash of the inventory entry
667
"""
668
return sha_file(self.get_inventory_xml(inventory_id))
669
670
671
def get_revision_inventory(self, revision_id):
672
"""Return inventory of a past revision."""
673
# bzr 0.0.6 imposes the constraint that the inventory_id
674
# must be the same as its revision, so this is trivial.
675
if revision_id == None:
676
from bzrlib.inventory import Inventory
677
return Inventory(self.get_root_id())
678
else:
679
return self.get_inventory(revision_id)
680
198
681
199
682
def revision_history(self):
200
"""Return sequence of revision hashes on to this branch."""
201
raise NotImplementedError('revision_history is abstract')
683
"""Return sequence of revision hashes on to this branch.
684
685
>>> ScratchBranch().revision_history()
686
[]
687
"""
688
self.lock_read()
689
try:
690
return [l.rstrip('\r\n') for l in
691
self.controlfile('revision-history', 'r').readlines()]
692
finally:
693
self.unlock()
694
695
696
def common_ancestor(self, other, self_revno=None, other_revno=None):
697
"""
698
>>> import commit
699
>>> sb = ScratchBranch(files=['foo', 'foo~'])
700
>>> sb.common_ancestor(sb) == (None, None)
701
True
702
>>> commit.commit(sb, "Committing first revision", verbose=False)
703
>>> sb.common_ancestor(sb)[0]
704
1
705
>>> clone = sb.clone()
706
>>> commit.commit(sb, "Committing second revision", verbose=False)
707
>>> sb.common_ancestor(sb)[0]
708
2
709
>>> sb.common_ancestor(clone)[0]
710
1
711
>>> commit.commit(clone, "Committing divergent second revision",
712
... verbose=False)
713
>>> sb.common_ancestor(clone)[0]
714
1
715
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
716
True
717
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
718
True
719
>>> clone2 = sb.clone()
720
>>> sb.common_ancestor(clone2)[0]
721
2
722
>>> sb.common_ancestor(clone2, self_revno=1)[0]
723
1
724
>>> sb.common_ancestor(clone2, other_revno=1)[0]
725
1
726
"""
727
my_history = self.revision_history()
728
other_history = other.revision_history()
729
if self_revno is None:
730
self_revno = len(my_history)
731
if other_revno is None:
732
other_revno = len(other_history)
733
indices = range(min((self_revno, other_revno)))
734
indices.reverse()
735
for r in indices:
736
if my_history[r] == other_history[r]:
737
return r+1, my_history[r]
738
return None, None
739
202
740
203
741
def revno(self):
204
742
"""Return current revision number for this branch.
208
746
"""
209
747
return len(self.revision_history())
210
748
211
def last_revision(self):
212
"""Return last patch hash, or None if no history."""
749
750
def last_patch(self):
751
"""Return last patch hash, or None if no history.
752
"""
213
753
ph = self.revision_history()
214
754
if ph:
215
755
return ph[-1]
216
756
else:
217
757
return None
218
758
759
219
760
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
220
"""Return a list of new revisions that would perfectly fit.
221
761
"""
222
762
If self and other have not diverged, return a list of the revisions
223
763
present in other, but missing from self.
224
764
242
782
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
243
783
>>> br1.missing_revisions(br2)
244
784
Traceback (most recent call last):
245
DivergedBranches: These branches have diverged. Try merge.
785
DivergedBranches: These branches have diverged.
246
786
"""
247
787
self_history = self.revision_history()
248
788
self_len = len(self_history)
255
795
256
796
if stop_revision is None:
257
797
stop_revision = other_len
258
else:
259
assert isinstance(stop_revision, int)
260
if stop_revision > other_len:
261
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
798
elif stop_revision > other_len:
799
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
800
262
801
return other_history[self_len:stop_revision]
263
802
264
803
265
804
def update_revisions(self, other, stop_revision=None):
266
"""Pull in new perfect-fit revisions."""
267
raise NotImplementedError('update_revisions is abstract')
268
269
def pullable_revisions(self, other, stop_revision):
270
raise NotImplementedError('pullable_revisions is abstract')
805
"""Pull in all new revisions from other branch.
806
"""
807
from bzrlib.fetch import greedy_fetch
808
809
pb = bzrlib.ui.ui_factory.progress_bar()
810
pb.update('comparing histories')
811
812
revision_ids = self.missing_revisions(other, stop_revision)
813
814
if len(revision_ids) > 0:
815
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
816
else:
817
count = 0
818
self.append_revision(*revision_ids)
819
## note("Added %d revisions." % count)
820
pb.clear()
821
822
def install_revisions(self, other, revision_ids, pb):
823
if hasattr(other.revision_store, "prefetch"):
824
other.revision_store.prefetch(revision_ids)
825
if hasattr(other.inventory_store, "prefetch"):
826
inventory_ids = [other.get_revision(r).inventory_id
827
for r in revision_ids]
828
other.inventory_store.prefetch(inventory_ids)
829
830
if pb is None:
831
pb = bzrlib.ui.ui_factory.progress_bar()
832
833
revisions = []
834
needed_texts = set()
835
i = 0
836
837
failures = set()
838
for i, rev_id in enumerate(revision_ids):
839
pb.update('fetching revision', i+1, len(revision_ids))
840
try:
841
rev = other.get_revision(rev_id)
842
except bzrlib.errors.NoSuchRevision:
843
failures.add(rev_id)
844
continue
845
846
revisions.append(rev)
847
inv = other.get_inventory(str(rev.inventory_id))
848
for key, entry in inv.iter_entries():
849
if entry.text_id is None:
850
continue
851
if entry.text_id not in self.text_store:
852
needed_texts.add(entry.text_id)
853
854
pb.clear()
855
856
count, cp_fail = self.text_store.copy_multi(other.text_store,
857
needed_texts)
858
#print "Added %d texts." % count
859
inventory_ids = [ f.inventory_id for f in revisions ]
860
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
861
inventory_ids)
862
#print "Added %d inventories." % count
863
revision_ids = [ f.revision_id for f in revisions]
864
865
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
866
revision_ids,
867
permit_failure=True)
868
assert len(cp_fail) == 0
869
return count, failures
870
871
872
def commit(self, *args, **kw):
873
from bzrlib.commit import commit
874
commit(self, *args, **kw)
271
875
876
877
def lookup_revision(self, revision):
878
"""Return the revision identifier for a given revision information."""
879
revno, info = self._get_revision_info(revision)
880
return info
881
882
272
883
def revision_id_to_revno(self, revision_id):
273
884
"""Given a revision id, return its revno"""
274
if revision_id is None:
275
return 0
276
885
history = self.revision_history()
277
886
try:
278
887
return history.index(revision_id) + 1
279
888
except ValueError:
280
889
raise bzrlib.errors.NoSuchRevision(self, revision_id)
281
890
891
892
def get_revision_info(self, revision):
893
"""Return (revno, revision id) for revision identifier.
894
895
revision can be an integer, in which case it is assumed to be revno (though
896
this will translate negative values into positive ones)
897
revision can also be a string, in which case it is parsed for something like
898
'date:' or 'revid:' etc.
899
"""
900
revno, rev_id = self._get_revision_info(revision)
901
if revno is None:
902
raise bzrlib.errors.NoSuchRevision(self, revision)
903
return revno, rev_id
904
282
905
def get_rev_id(self, revno, history=None):
283
906
"""Find the revision id of the specified revno."""
284
907
if revno == 0:
289
912
raise bzrlib.errors.NoSuchRevision(self, revno)
290
913
return history[revno - 1]
291
914
915
def _get_revision_info(self, revision):
916
"""Return (revno, revision id) for revision specifier.
917
918
revision can be an integer, in which case it is assumed to be revno
919
(though this will translate negative values into positive ones)
920
revision can also be a string, in which case it is parsed for something
921
like 'date:' or 'revid:' etc.
922
923
A revid is always returned. If it is None, the specifier referred to
924
the null revision. If the revid does not occur in the revision
925
history, revno will be None.
926
"""
927
928
if revision is None:
929
return 0, None
930
revno = None
931
try:# Convert to int if possible
932
revision = int(revision)
933
except ValueError:
934
pass
935
revs = self.revision_history()
936
if isinstance(revision, int):
937
if revision < 0:
938
revno = len(revs) + revision + 1
939
else:
940
revno = revision
941
rev_id = self.get_rev_id(revno, revs)
942
elif isinstance(revision, basestring):
943
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
944
if revision.startswith(prefix):
945
result = func(self, revs, revision)
946
if len(result) > 1:
947
revno, rev_id = result
948
else:
949
revno = result[0]
950
rev_id = self.get_rev_id(revno, revs)
951
break
952
else:
953
raise BzrError('No namespace registered for string: %r' %
954
revision)
955
else:
956
raise TypeError('Unhandled revision type %s' % revision)
957
958
if revno is None:
959
if rev_id is None:
960
raise bzrlib.errors.NoSuchRevision(self, revision)
961
return revno, rev_id
962
963
def _namespace_revno(self, revs, revision):
964
"""Lookup a revision by revision number"""
965
assert revision.startswith('revno:')
966
try:
967
return (int(revision[6:]),)
968
except ValueError:
969
return None
970
REVISION_NAMESPACES['revno:'] = _namespace_revno
971
972
def _namespace_revid(self, revs, revision):
973
assert revision.startswith('revid:')
974
rev_id = revision[len('revid:'):]
975
try:
976
return revs.index(rev_id) + 1, rev_id
977
except ValueError:
978
return None, rev_id
979
REVISION_NAMESPACES['revid:'] = _namespace_revid
980
981
def _namespace_last(self, revs, revision):
982
assert revision.startswith('last:')
983
try:
984
offset = int(revision[5:])
985
except ValueError:
986
return (None,)
987
else:
988
if offset <= 0:
989
raise BzrError('You must supply a positive value for --revision last:XXX')
990
return (len(revs) - offset + 1,)
991
REVISION_NAMESPACES['last:'] = _namespace_last
992
993
def _namespace_tag(self, revs, revision):
994
assert revision.startswith('tag:')
995
raise BzrError('tag: namespace registered, but not implemented.')
996
REVISION_NAMESPACES['tag:'] = _namespace_tag
997
998
def _namespace_date(self, revs, revision):
999
assert revision.startswith('date:')
1000
import datetime
1001
# Spec for date revisions:
1002
# date:value
1003
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
1004
# it can also start with a '+/-/='. '+' says match the first
1005
# entry after the given date. '-' is match the first entry before the date
1006
# '=' is match the first entry after, but still on the given date.
1007
#
1008
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
1009
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
1010
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
1011
# May 13th, 2005 at 0:00
1012
#
1013
# So the proper way of saying 'give me all entries for today' is:
1014
# -r {date:+today}:{date:-tomorrow}
1015
# The default is '=' when not supplied
1016
val = revision[5:]
1017
match_style = '='
1018
if val[:1] in ('+', '-', '='):
1019
match_style = val[:1]
1020
val = val[1:]
1021
1022
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
1023
if val.lower() == 'yesterday':
1024
dt = today - datetime.timedelta(days=1)
1025
elif val.lower() == 'today':
1026
dt = today
1027
elif val.lower() == 'tomorrow':
1028
dt = today + datetime.timedelta(days=1)
1029
else:
1030
import re
1031
# This should be done outside the function to avoid recompiling it.
1032
_date_re = re.compile(
1033
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1034
r'(,|T)?\s*'
1035
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1036
)
1037
m = _date_re.match(val)
1038
if not m or (not m.group('date') and not m.group('time')):
1039
raise BzrError('Invalid revision date %r' % revision)
1040
1041
if m.group('date'):
1042
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1043
else:
1044
year, month, day = today.year, today.month, today.day
1045
if m.group('time'):
1046
hour = int(m.group('hour'))
1047
minute = int(m.group('minute'))
1048
if m.group('second'):
1049
second = int(m.group('second'))
1050
else:
1051
second = 0
1052
else:
1053
hour, minute, second = 0,0,0
1054
1055
dt = datetime.datetime(year=year, month=month, day=day,
1056
hour=hour, minute=minute, second=second)
1057
first = dt
1058
last = None
1059
reversed = False
1060
if match_style == '-':
1061
reversed = True
1062
elif match_style == '=':
1063
last = dt + datetime.timedelta(days=1)
1064
1065
if reversed:
1066
for i in range(len(revs)-1, -1, -1):
1067
r = self.get_revision(revs[i])
1068
# TODO: Handle timezone.
1069
dt = datetime.datetime.fromtimestamp(r.timestamp)
1070
if first >= dt and (last is None or dt >= last):
1071
return (i+1,)
1072
else:
1073
for i in range(len(revs)):
1074
r = self.get_revision(revs[i])
1075
# TODO: Handle timezone.
1076
dt = datetime.datetime.fromtimestamp(r.timestamp)
1077
if first <= dt and (last is None or dt <= last):
1078
return (i+1,)
1079
REVISION_NAMESPACES['date:'] = _namespace_date
1080
1081
def revision_tree(self, revision_id):
1082
"""Return Tree for a revision on this branch.
1083
1084
`revision_id` may be None for the null revision, in which case
1085
an `EmptyTree` is returned."""
1086
# TODO: refactor this to use an existing revision object
1087
# so we don't need to read it in twice.
1088
if revision_id == None:
1089
return EmptyTree()
1090
else:
1091
inv = self.get_revision_inventory(revision_id)
1092
return RevisionTree(self.text_store, inv)
1093
1094
292
1095
def working_tree(self):
293
"""Return a `Tree` for the working copy if this is a local branch."""
294
raise NotImplementedError('working_tree is abstract')
1096
"""Return a `Tree` for the working copy."""
1097
from workingtree import WorkingTree
1098
return WorkingTree(self.base, self.read_working_inventory())
295
1099
296
def pull(self, source, overwrite=False):
297
raise NotImplementedError('pull is abstract')
298
1100
299
1101
def basis_tree(self):
300
1102
"""Return `Tree` object for last revision.
301
1103
302
1104
If there are no revisions yet, return an `EmptyTree`.
303
1105
"""
304
return self.repository.revision_tree(self.last_revision())
1106
r = self.last_patch()
1107
if r == None:
1108
return EmptyTree()
1109
else:
1110
return RevisionTree(self.text_store, self.get_revision_inventory(r))
1111
1112
305
1113
306
1114
def rename_one(self, from_rel, to_rel):
307
1115
"""Rename one file.
308
1116
309
1117
This can change the directory or the filename or both.
310
1118
"""
311
raise NotImplementedError('rename_one is abstract')
1119
self.lock_write()
1120
try:
1121
tree = self.working_tree()
1122
inv = tree.inventory
1123
if not tree.has_filename(from_rel):
1124
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1125
if tree.has_filename(to_rel):
1126
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1127
1128
file_id = inv.path2id(from_rel)
1129
if file_id == None:
1130
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1131
1132
if inv.path2id(to_rel):
1133
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1134
1135
to_dir, to_tail = os.path.split(to_rel)
1136
to_dir_id = inv.path2id(to_dir)
1137
if to_dir_id == None and to_dir != '':
1138
raise BzrError("can't determine destination directory id for %r" % to_dir)
1139
1140
mutter("rename_one:")
1141
mutter(" file_id {%s}" % file_id)
1142
mutter(" from_rel %r" % from_rel)
1143
mutter(" to_rel %r" % to_rel)
1144
mutter(" to_dir %r" % to_dir)
1145
mutter(" to_dir_id {%s}" % to_dir_id)
1146
1147
inv.rename(file_id, to_dir_id, to_tail)
1148
1149
from_abs = self.abspath(from_rel)
1150
to_abs = self.abspath(to_rel)
1151
try:
1152
os.rename(from_abs, to_abs)
1153
except OSError, e:
1154
raise BzrError("failed to rename %r to %r: %s"
1155
% (from_abs, to_abs, e[1]),
1156
["rename rolled back"])
1157
1158
self._write_inventory(inv)
1159
finally:
1160
self.unlock()
1161
312
1162
313
1163
def move(self, from_paths, to_name):
314
1164
"""Rename files.
324
1174
This returns a list of (from_path, to_path) pairs for each
325
1175
entry that is moved.
326
1176
"""
327
raise NotImplementedError('move is abstract')
1177
result = []
1178
self.lock_write()
1179
try:
1180
## TODO: Option to move IDs only
1181
assert not isinstance(from_paths, basestring)
1182
tree = self.working_tree()
1183
inv = tree.inventory
1184
to_abs = self.abspath(to_name)
1185
if not isdir(to_abs):
1186
raise BzrError("destination %r is not a directory" % to_abs)
1187
if not tree.has_filename(to_name):
1188
raise BzrError("destination %r not in working directory" % to_abs)
1189
to_dir_id = inv.path2id(to_name)
1190
if to_dir_id == None and to_name != '':
1191
raise BzrError("destination %r is not a versioned directory" % to_name)
1192
to_dir_ie = inv[to_dir_id]
1193
if to_dir_ie.kind not in ('directory', 'root_directory'):
1194
raise BzrError("destination %r is not a directory" % to_abs)
1195
1196
to_idpath = inv.get_idpath(to_dir_id)
1197
1198
for f in from_paths:
1199
if not tree.has_filename(f):
1200
raise BzrError("%r does not exist in working tree" % f)
1201
f_id = inv.path2id(f)
1202
if f_id == None:
1203
raise BzrError("%r is not versioned" % f)
1204
name_tail = splitpath(f)[-1]
1205
dest_path = appendpath(to_name, name_tail)
1206
if tree.has_filename(dest_path):
1207
raise BzrError("destination %r already exists" % dest_path)
1208
if f_id in to_idpath:
1209
raise BzrError("can't move %r to a subdirectory of itself" % f)
1210
1211
# OK, so there's a race here, it's possible that someone will
1212
# create a file in this interval and then the rename might be
1213
# left half-done. But we should have caught most problems.
1214
1215
for f in from_paths:
1216
name_tail = splitpath(f)[-1]
1217
dest_path = appendpath(to_name, name_tail)
1218
result.append((f, dest_path))
1219
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1220
try:
1221
os.rename(self.abspath(f), self.abspath(dest_path))
1222
except OSError, e:
1223
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1224
["rename rolled back"])
1225
1226
self._write_inventory(inv)
1227
finally:
1228
self.unlock()
1229
1230
return result
1231
1232
1233
def revert(self, filenames, old_tree=None, backups=True):
1234
"""Restore selected files to the versions from a previous tree.
1235
1236
backups
1237
If true (default) backups are made of files before
1238
they're renamed.
1239
"""
1240
from bzrlib.errors import NotVersionedError, BzrError
1241
from bzrlib.atomicfile import AtomicFile
1242
from bzrlib.osutils import backup_file
1243
1244
inv = self.read_working_inventory()
1245
if old_tree is None:
1246
old_tree = self.basis_tree()
1247
old_inv = old_tree.inventory
1248
1249
nids = []
1250
for fn in filenames:
1251
file_id = inv.path2id(fn)
1252
if not file_id:
1253
raise NotVersionedError("not a versioned file", fn)
1254
if not old_inv.has_id(file_id):
1255
raise BzrError("file not present in old tree", fn, file_id)
1256
nids.append((fn, file_id))
1257
1258
# TODO: Rename back if it was previously at a different location
1259
1260
# TODO: If given a directory, restore the entire contents from
1261
# the previous version.
1262
1263
# TODO: Make a backup to a temporary file.
1264
1265
# TODO: If the file previously didn't exist, delete it?
1266
for fn, file_id in nids:
1267
backup_file(fn)
1268
1269
f = AtomicFile(fn, 'wb')
1270
try:
1271
f.write(old_tree.get_file(file_id).read())
1272
f.commit()
1273
finally:
1274
f.close()
1275
1276
1277
def pending_merges(self):
1278
"""Return a list of pending merges.
1279
1280
These are revisions that have been merged into the working
1281
directory but not yet committed.
1282
"""
1283
cfn = self.controlfilename('pending-merges')
1284
if not os.path.exists(cfn):
1285
return []
1286
p = []
1287
for l in self.controlfile('pending-merges', 'r').readlines():
1288
p.append(l.rstrip('\n'))
1289
return p
1290
1291
1292
def add_pending_merge(self, revision_id):
1293
from bzrlib.revision import validate_revision_id
1294
1295
validate_revision_id(revision_id)
1296
1297
p = self.pending_merges()
1298
if revision_id in p:
1299
return
1300
p.append(revision_id)
1301
self.set_pending_merges(p)
1302
1303
1304
def set_pending_merges(self, rev_list):
1305
from bzrlib.atomicfile import AtomicFile
1306
self.lock_write()
1307
try:
1308
f = AtomicFile(self.controlfilename('pending-merges'))
1309
try:
1310
for l in rev_list:
1311
print >>f, l
1312
f.commit()
1313
finally:
1314
f.close()
1315
finally:
1316
self.unlock()
1317
328
1318
329
1319
def get_parent(self):
330
1320
"""Return the parent location of the branch.
333
1323
pattern is that the user can override it by specifying a
334
1324
location.
335
1325
"""
336
raise NotImplementedError('get_parent is abstract')
337
338
def get_push_location(self):
339
"""Return the None or the location to push this branch to."""
340
raise NotImplementedError('get_push_location is abstract')
341
342
def set_push_location(self, location):
343
"""Set a new push location for this branch."""
344
raise NotImplementedError('set_push_location is abstract')
1326
import errno
1327
_locs = ['parent', 'pull', 'x-pull']
1328
for l in _locs:
1329
try:
1330
return self.controlfile(l, 'r').read().strip('\n')
1331
except IOError, e:
1332
if e.errno != errno.ENOENT:
1333
raise
1334
return None
1335
345
1336
346
1337
def set_parent(self, url):
347
raise NotImplementedError('set_parent is abstract')
1338
# TODO: Maybe delete old location files?
1339
from bzrlib.atomicfile import AtomicFile
1340
self.lock_write()
1341
try:
1342
f = AtomicFile(self.controlfilename('parent'))
1343
try:
1344
f.write(url + '\n')
1345
f.commit()
1346
finally:
1347
f.close()
1348
finally:
1349
self.unlock()
348
1350
349
1351
def check_revno(self, revno):
350
1352
"""\
362
1364
if revno < 1 or revno > self.revno():
363
1365
raise InvalidRevisionNumber(revno)
364
1366
365
def sign_revision(self, revision_id, gpg_strategy):
366
raise NotImplementedError('sign_revision is abstract')
367
368
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
369
raise NotImplementedError('store_revision_signature is abstract')
370
371
def clone(self, to_location, revision=None, basis_branch=None, to_branch_type=None):
372
"""Copy this branch into the existing directory to_location.
373
374
Returns the newly created branch object.
375
376
revision
377
If not None, only revisions up to this point will be copied.
378
The head of the new branch will be that revision. Must be a
379
revid or None.
380
381
to_location -- The destination directory; must either exist and be
382
empty, or not exist, in which case it is created.
383
384
basis_branch
385
A local branch to copy revisions from, related to this branch.
386
This is used when branching from a remote (slow) branch, and we have
387
a local branch that might contain some relevant revisions.
388
389
to_branch_type
390
Branch type of destination branch
391
"""
392
assert isinstance(to_location, basestring)
393
if not bzrlib.osutils.lexists(to_location):
394
os.mkdir(to_location)
395
if to_branch_type is None:
396
to_branch_type = BzrBranch
397
br_to = to_branch_type.initialize(to_location)
398
mutter("copy branch from %s to %s", self, br_to)
399
if basis_branch is not None:
400
basis_branch.push_stores(br_to)
401
br_to.working_tree().set_root_id(self.get_root_id())
402
if revision is None:
403
revision = self.last_revision()
404
br_to.update_revisions(self, stop_revision=revision)
405
br_to.set_parent(self.base)
406
# circular import protection
407
from bzrlib.merge import build_working_dir
408
build_working_dir(to_location)
409
mutter("copied")
410
return br_to
411
412
class BzrBranch(Branch):
413
"""A branch stored in the actual filesystem.
414
415
Note that it's "local" in the context of the filesystem; it doesn't
416
really matter if it's on an nfs/smb/afs/coda/... share, as long as
417
it's writable, and can be accessed via the normal filesystem API.
418
419
"""
420
# We actually expect this class to be somewhat short-lived; part of its
421
# purpose is to try to isolate what bits of the branch logic are tied to
422
# filesystem access, so that in a later step, we can extricate them to
423
# a separarte ("storage") class.
424
_inventory_weave = None
425
426
# Map some sort of prefix into a namespace
427
# stuff like "revno:10", "revid:", etc.
428
# This should match a prefix with a function which accepts
429
REVISION_NAMESPACES = {}
430
431
def push_stores(self, branch_to):
432
"""See Branch.push_stores."""
433
if (self._branch_format != branch_to._branch_format
434
or self._branch_format != 4):
435
from bzrlib.fetch import greedy_fetch
436
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
437
self, self._branch_format, branch_to, branch_to._branch_format)
438
greedy_fetch(to_branch=branch_to, from_branch=self,
439
revision=self.last_revision())
440
return
441
442
store_pairs = ((self.text_store, branch_to.text_store),
443
(self.inventory_store, branch_to.inventory_store),
444
(self.revision_store, branch_to.revision_store))
445
try:
446
for from_store, to_store in store_pairs:
447
copy_all(from_store, to_store)
448
except UnlistableStore:
449
raise UnlistableBranch(from_store)
450
451
def __init__(self, transport, init=False,
452
relax_version_check=False):
453
"""Create new branch object at a particular location.
454
455
transport -- A Transport object, defining how to access files.
456
457
init -- If True, create new control files in a previously
458
unversioned directory. If False, the branch must already
459
be versioned.
460
461
relax_version_check -- If true, the usual check for the branch
462
version is not applied. This is intended only for
463
upgrade/recovery type use; it's not guaranteed that
464
all operations will work on old format branches.
465
466
In the test suite, creation of new trees is tested using the
467
`ScratchBranch` class.
468
"""
469
assert isinstance(transport, Transport), \
470
"%r is not a Transport" % transport
471
# TODO: jam 20060103 We create a clone of this transport at .bzr/
472
# and then we forget about it, should we keep a handle to it?
473
self._base = transport.base
474
self.control_files = LockableFiles(transport.clone(bzrlib.BZRDIR),
475
'branch-lock')
476
if init:
477
self._make_control()
478
self._check_format(relax_version_check)
479
self.repository = Repository(transport, self._branch_format)
480
481
def __str__(self):
482
return '%s(%r)' % (self.__class__.__name__, self.base)
483
484
__repr__ = __str__
485
486
def __del__(self):
487
# TODO: It might be best to do this somewhere else,
488
# but it is nice for a Branch object to automatically
489
# cache it's information.
490
# Alternatively, we could have the Transport objects cache requests
491
# See the earlier discussion about how major objects (like Branch)
492
# should never expect their __del__ function to run.
493
if hasattr(self, 'cache_root') and self.cache_root is not None:
494
try:
495
shutil.rmtree(self.cache_root)
496
except:
497
pass
498
self.cache_root = None
499
500
def _get_base(self):
501
return self._base
502
503
base = property(_get_base, doc="The URL for the root of this branch.")
504
505
def _finish_transaction(self):
506
"""Exit the current transaction."""
507
return self.control_files._finish_transaction()
508
509
def get_transaction(self):
510
"""Return the current active transaction.
511
512
If no transaction is active, this returns a passthrough object
513
for which all data is immediately flushed and no caching happens.
514
"""
515
# this is an explicit function so that we can do tricky stuff
516
# when the storage in rev_storage is elsewhere.
517
# we probably need to hook the two 'lock a location' and
518
# 'have a transaction' together more delicately, so that
519
# we can have two locks (branch and storage) and one transaction
520
# ... and finishing the transaction unlocks both, but unlocking
521
# does not. - RBC 20051121
522
return self.control_files.get_transaction()
523
524
def _set_transaction(self, transaction):
525
"""Set a new active transaction."""
526
return self.control_files._set_transaction(transaction)
527
528
def abspath(self, name):
529
"""See Branch.abspath."""
530
return self.control_files._transport.abspath(name)
531
532
def _make_control(self):
533
from bzrlib.inventory import Inventory
534
from bzrlib.weavefile import write_weave_v5
535
from bzrlib.weave import Weave
536
537
# Create an empty inventory
538
sio = StringIO()
539
# if we want per-tree root ids then this is the place to set
540
# them; they're not needed for now and so ommitted for
541
# simplicity.
542
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
543
empty_inv = sio.getvalue()
544
sio = StringIO()
545
bzrlib.weavefile.write_weave_v5(Weave(), sio)
546
empty_weave = sio.getvalue()
547
548
dirs = ['', 'revision-store', 'weaves']
549
files = [('README',
550
"This is a Bazaar-NG control directory.\n"
551
"Do not change any files in this directory.\n"),
552
('branch-format', BZR_BRANCH_FORMAT_6),
553
('revision-history', ''),
554
('branch-name', ''),
555
('branch-lock', ''),
556
('pending-merges', ''),
557
('inventory', empty_inv),
558
('inventory.weave', empty_weave),
559
('ancestry.weave', empty_weave)
560
]
561
cfe = self.control_files._escape
562
self.control_files._transport.mkdir_multi([cfe(d) for d in dirs],
563
mode=self.control_files._dir_mode)
564
self.control_files.lock_write()
565
try:
566
for file, content in files:
567
self.control_files.put_utf8(file, content)
568
mutter('created control directory in ' + self.base)
569
finally:
570
self.control_files.unlock()
571
572
def _check_format(self, relax_version_check):
573
"""Check this branch format is supported.
574
575
The format level is stored, as an integer, in
576
self._branch_format for code that needs to check it later.
577
578
In the future, we might need different in-memory Branch
579
classes to support downlevel branches. But not yet.
580
"""
581
try:
582
fmt = self.control_files.controlfile('branch-format', 'r').read()
583
except NoSuchFile:
584
raise NotBranchError(path=self.base)
585
mutter("got branch format %r", fmt)
586
if fmt == BZR_BRANCH_FORMAT_6:
587
self._branch_format = 6
588
elif fmt == BZR_BRANCH_FORMAT_5:
589
self._branch_format = 5
590
elif fmt == BZR_BRANCH_FORMAT_4:
591
self._branch_format = 4
592
593
if (not relax_version_check
594
and self._branch_format not in (5, 6)):
595
raise errors.UnsupportedFormatError(
596
'sorry, branch format %r not supported' % fmt,
597
['use a different bzr version',
598
'or remove the .bzr directory'
599
' and "bzr init" again'])
600
601
@needs_read_lock
602
def get_root_id(self):
603
"""See Branch.get_root_id."""
604
inv = self.repository.get_inventory(self.last_revision())
605
return inv.root.file_id
606
607
def lock_write(self):
608
# TODO: test for failed two phase locks. This is known broken.
609
self.control_files.lock_write()
610
self.repository.lock_write()
611
612
def lock_read(self):
613
# TODO: test for failed two phase locks. This is known broken.
614
self.control_files.lock_read()
615
self.repository.lock_read()
616
617
def unlock(self):
618
# TODO: test for failed two phase locks. This is known broken.
619
self.repository.unlock()
620
self.control_files.unlock()
621
622
@needs_read_lock
623
def print_file(self, file, revision_id):
624
"""See Branch.print_file."""
625
return self.repository.print_file(file, revision_id)
626
627
@needs_write_lock
628
def append_revision(self, *revision_ids):
629
"""See Branch.append_revision."""
630
for revision_id in revision_ids:
631
mutter("add {%s} to revision-history" % revision_id)
632
rev_history = self.revision_history()
633
rev_history.extend(revision_ids)
634
self.set_revision_history(rev_history)
635
636
@needs_write_lock
637
def set_revision_history(self, rev_history):
638
"""See Branch.set_revision_history."""
639
old_revision = self.last_revision()
640
new_revision = rev_history[-1]
641
self.control_files.put_utf8(
642
'revision-history', '\n'.join(rev_history))
643
try:
644
# FIXME: RBC 20051207 this smells wrong, last_revision in the
645
# working tree may be != to last_revision in the branch - so
646
# why is this passing in the branches last_revision ?
647
self.working_tree().set_last_revision(new_revision, old_revision)
648
except NoWorkingTree:
649
mutter('Unable to set_last_revision without a working tree.')
650
651
def get_revision_delta(self, revno):
652
"""Return the delta for one revision.
653
654
The delta is relative to its mainline predecessor, or the
655
empty tree for revision 1.
656
"""
657
assert isinstance(revno, int)
658
rh = self.revision_history()
659
if not (1 <= revno <= len(rh)):
660
raise InvalidRevisionNumber(revno)
661
662
# revno is 1-based; list is 0-based
663
664
new_tree = self.repository.revision_tree(rh[revno-1])
665
if revno == 1:
666
old_tree = EmptyTree()
667
else:
668
old_tree = self.repository.revision_tree(rh[revno-2])
669
return compare_trees(old_tree, new_tree)
670
671
@needs_read_lock
672
def revision_history(self):
673
"""See Branch.revision_history."""
674
# FIXME are transactions bound to control files ? RBC 20051121
675
transaction = self.get_transaction()
676
history = transaction.map.find_revision_history()
677
if history is not None:
678
mutter("cache hit for revision-history in %s", self)
679
return list(history)
680
history = [l.rstrip('\r\n') for l in
681
self.control_files.controlfile('revision-history', 'r').readlines()]
682
transaction.map.add_revision_history(history)
683
# this call is disabled because revision_history is
684
# not really an object yet, and the transaction is for objects.
685
# transaction.register_clean(history, precious=True)
686
return list(history)
687
688
def update_revisions(self, other, stop_revision=None):
689
"""See Branch.update_revisions."""
690
from bzrlib.fetch import greedy_fetch
691
if stop_revision is None:
692
stop_revision = other.last_revision()
693
### Should this be checking is_ancestor instead of revision_history?
694
if (stop_revision is not None and
695
stop_revision in self.revision_history()):
696
return
697
greedy_fetch(to_branch=self, from_branch=other,
698
revision=stop_revision)
699
pullable_revs = self.pullable_revisions(other, stop_revision)
700
if len(pullable_revs) > 0:
701
self.append_revision(*pullable_revs)
702
703
def pullable_revisions(self, other, stop_revision):
704
"""See Branch.pullable_revisions."""
705
other_revno = other.revision_id_to_revno(stop_revision)
706
try:
707
return self.missing_revisions(other, other_revno)
708
except DivergedBranches, e:
709
try:
710
pullable_revs = get_intervening_revisions(self.last_revision(),
711
stop_revision,
712
self.repository)
713
assert self.last_revision() not in pullable_revs
714
return pullable_revs
715
except bzrlib.errors.NotAncestor:
716
if is_ancestor(self.last_revision(), stop_revision, self):
717
return []
718
else:
719
raise e
720
721
def basis_tree(self):
722
"""See Branch.basis_tree."""
723
try:
724
revision_id = self.revision_history()[-1]
725
# FIXME: This is an abstraction violation, the basis tree
726
# here as defined is on the working tree, the method should
727
# be too. The basis tree for a branch can be different than
728
# that for a working tree. RBC 20051207
729
xml = self.working_tree().read_basis_inventory(revision_id)
730
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
731
return RevisionTree(self.repository, inv, revision_id)
732
except (IndexError, NoSuchFile, NoWorkingTree), e:
733
return self.repository.revision_tree(self.last_revision())
734
735
def working_tree(self):
736
"""See Branch.working_tree."""
737
from bzrlib.workingtree import WorkingTree
738
if self.base.find('://') != -1:
739
raise NoWorkingTree(self.base)
740
return WorkingTree(self.base, branch=self)
741
742
@needs_write_lock
743
def pull(self, source, overwrite=False):
744
"""See Branch.pull."""
745
source.lock_read()
746
try:
747
old_count = len(self.revision_history())
748
try:
749
self.update_revisions(source)
750
except DivergedBranches:
751
if not overwrite:
752
raise
753
if overwrite:
754
self.set_revision_history(source.revision_history())
755
new_count = len(self.revision_history())
756
return new_count - old_count
757
finally:
758
source.unlock()
759
760
def get_parent(self):
761
"""See Branch.get_parent."""
762
import errno
763
_locs = ['parent', 'pull', 'x-pull']
764
for l in _locs:
765
try:
766
return self.control_files.controlfile(l, 'r').read().strip('\n')
767
except NoSuchFile:
768
pass
769
return None
770
771
def get_push_location(self):
772
"""See Branch.get_push_location."""
773
config = bzrlib.config.BranchConfig(self)
774
push_loc = config.get_user_option('push_location')
775
return push_loc
776
777
def set_push_location(self, location):
778
"""See Branch.set_push_location."""
779
config = bzrlib.config.LocationConfig(self.base)
780
config.set_user_option('push_location', location)
781
782
@needs_write_lock
783
def set_parent(self, url):
784
"""See Branch.set_parent."""
785
# TODO: Maybe delete old location files?
786
from bzrlib.atomicfile import AtomicFile
787
f = AtomicFile(self.control_files.controlfilename('parent'))
788
try:
789
f.write(url + '\n')
790
f.commit()
791
finally:
792
f.close()
793
794
def tree_config(self):
795
return TreeConfig(self)
796
797
def _get_truncated_history(self, revision_id):
798
history = self.revision_history()
799
if revision_id is None:
800
return history
801
try:
802
idx = history.index(revision_id)
803
except ValueError:
804
raise InvalidRevisionId(revision_id=revision, branch=self)
805
return history[:idx+1]
806
807
@needs_read_lock
808
def _clone_weave(self, to_location, revision=None, basis_branch=None):
809
assert isinstance(to_location, basestring)
810
if basis_branch is not None:
811
note("basis_branch is not supported for fast weave copy yet.")
812
813
history = self._get_truncated_history(revision)
814
if not bzrlib.osutils.lexists(to_location):
815
os.mkdir(to_location)
816
branch_to = Branch.initialize(to_location)
817
mutter("copy branch from %s to %s", self, branch_to)
818
branch_to.working_tree().set_root_id(self.get_root_id())
819
820
self.repository.copy(branch_to.repository)
821
822
# must be done *after* history is copied across
823
# FIXME duplicate code with base .clone().
824
# .. would template method be useful here. RBC 20051207
825
branch_to.set_parent(self.base)
826
branch_to.append_revision(*history)
827
# circular import protection
828
from bzrlib.merge import build_working_dir
829
build_working_dir(to_location)
830
mutter("copied")
831
return branch_to
832
833
def clone(self, to_location, revision=None, basis_branch=None, to_branch_type=None):
834
if to_branch_type is None:
835
to_branch_type = BzrBranch
836
837
if to_branch_type == BzrBranch \
838
and self.repository.weave_store.listable() \
839
and self.repository.revision_store.listable():
840
return self._clone_weave(to_location, revision, basis_branch)
841
842
return Branch.clone(self, to_location, revision, basis_branch, to_branch_type)
843
844
845
class ScratchBranch(BzrBranch):
1367
1368
1369
1370
class ScratchBranch(Branch):
846
1371
"""Special test class: a branch that cleans up after itself.
847
1372
848
1373
>>> b = ScratchBranch()
849
1374
>>> isdir(b.base)
850
1375
True
851
1376
>>> bd = b.base
852
>>> b._transport.__del__()
1377
>>> b.destroy()
853
1378
>>> isdir(bd)
854
1379
False
855
1380
"""
856
857
def __init__(self, files=[], dirs=[], transport=None):
1381
def __init__(self, files=[], dirs=[], base=None):
858
1382
"""Make a test branch.
859
1383
860
1384
This creates a temporary directory and runs init-tree in it.
861
1385
862
1386
If any files are listed, they are created in the working copy.
863
1387
"""
864
if transport is None:
865
transport = bzrlib.transport.local.ScratchTransport()
866
super(ScratchBranch, self).__init__(transport, init=True)
867
else:
868
super(ScratchBranch, self).__init__(transport)
869
870
# BzrBranch creates a clone to .bzr and then forgets about the
871
# original transport. A ScratchTransport() deletes itself and
872
# everything underneath it when it goes away, so we need to
873
# grab a local copy to prevent that from happening
874
self._transport = transport
875
1388
from tempfile import mkdtemp
1389
init = False
1390
if base is None:
1391
base = mkdtemp()
1392
init = True
1393
Branch.__init__(self, base, init=init)
876
1394
for d in dirs:
877
self._transport.mkdir(d)
1395
os.mkdir(self.abspath(d))
878
1396
879
1397
for f in files:
880
self._transport.put(f, 'content of %s' % f)
1398
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1399
881
1400
882
1401
def clone(self):
883
1402
"""
884
1403
>>> orig = ScratchBranch(files=["file1", "file2"])
885
>>> os.listdir(orig.base)
886
[u'.bzr', u'file1', u'file2']
887
1404
>>> clone = orig.clone()
888
>>> if os.name != 'nt':
889
... os.path.samefile(orig.base, clone.base)
890
... else:
891
... orig.base == clone.base
892
...
1405
>>> os.path.samefile(orig.base, clone.base)
893
1406
False
894
>>> os.listdir(clone.base)
895
[u'.bzr', u'file1', u'file2']
1407
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1408
True
896
1409
"""
897
1410
from shutil import copytree
898
from bzrlib.osutils import mkdtemp
1411
from tempfile import mkdtemp
899
1412
base = mkdtemp()
900
1413
os.rmdir(base)
901
1414
copytree(self.base, base, symlinks=True)
902
return ScratchBranch(
903
transport=bzrlib.transport.local.ScratchTransport(base))
1415
return ScratchBranch(base=base)
1416
1417
1418
1419
def __del__(self):
1420
self.destroy()
1421
1422
def destroy(self):
1423
"""Destroy the test branch, removing the scratch directory."""
1424
from shutil import rmtree
1425
try:
1426
if self.base:
1427
mutter("delete ScratchBranch %s" % self.base)
1428
rmtree(self.base)
1429
except OSError, e:
1430
# Work around for shutil.rmtree failing on Windows when
1431
# readonly files are encountered
1432
mutter("hit exception in destroying ScratchBranch: %s" % e)
1433
for root, dirs, files in os.walk(self.base, topdown=False):
1434
for name in files:
1435
os.chmod(os.path.join(root, name), 0700)
1436
rmtree(self.base)
1437
self.base = None
1438
904
1439
905
1440
906
1441
######################################################################
909
1444
910
1445
def is_control_file(filename):
911
1446
## FIXME: better check
912
filename = normpath(filename)
1447
filename = os.path.normpath(filename)
913
1448
while filename != '':
914
1449
head, tail = os.path.split(filename)
915
1450
## mutter('check %r for control file' % ((head, tail), ))
919
1454
break
920
1455
filename = head
921
1456
return False
1457
1458
1459
1460
def gen_file_id(name):
1461
"""Return new file id.
1462
1463
This should probably generate proper UUIDs, but for the moment we
1464
cope with just randomness because running uuidgen every time is
1465
slow."""
1466
import re
1467
from binascii import hexlify
1468
from time import time
1469
1470
# get last component
1471
idx = name.rfind('/')
1472
if idx != -1:
1473
name = name[idx+1 : ]
1474
idx = name.rfind('\\')
1475
if idx != -1:
1476
name = name[idx+1 : ]
1477
1478
# make it not a hidden file
1479
name = name.lstrip('.')
1480
1481
# remove any wierd characters; we don't escape them but rather
1482
# just pull them out
1483
name = re.sub(r'[^\w.]', '', name)
1484
1485
s = hexlify(rand_bytes(8))
1486
return '-'.join((name, compact_date(time()), s))
1487
1488
1489
def gen_root_id():
1490
"""Return a new tree-root file id."""
1491
return gen_file_id('TREE_ROOT')
1492
1493
1494
def pull_loc(branch):
1495
# TODO: Should perhaps just make attribute be 'base' in
1496
# RemoteBranch and Branch?
1497
if hasattr(branch, "baseurl"):
1498
return branch.baseurl
1499
else:
1500
return branch.base
1501
1502
1503
def copy_branch(branch_from, to_location, revision=None):
1504
"""Copy branch_from into the existing directory to_location.
1505
1506
revision
1507
If not None, only revisions up to this point will be copied.
1508
The head of the new branch will be that revision.
1509
1510
to_location
1511
The name of a local directory that exists but is empty.
1512
"""
1513
from bzrlib.merge import merge
1514
from bzrlib.branch import Branch
1515
1516
assert isinstance(branch_from, Branch)
1517
assert isinstance(to_location, basestring)
1518
1519
br_to = Branch(to_location, init=True)
1520
br_to.set_root_id(branch_from.get_root_id())
1521
if revision is None:
1522
revno = branch_from.revno()
1523
else:
1524
revno, rev_id = branch_from.get_revision_info(revision)
1525
br_to.update_revisions(branch_from, stop_revision=revno)
1526
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1527
check_clean=False, ignore_zero=True)
1528
1529
from_location = pull_loc(branch_from)
1530
br_to.set_parent(pull_loc(branch_from))
1531
Loggerhead is a web-based interface for Breezy
Version: 2.0.1