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