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