« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1530.2.1
- compare with another revision
- download diff
- download tarball
- view history from revision 1530.2.1
- Committer: Robert Collins
- Date: 2005-12-24 02:20:45 UTC
- mto: (1185.50.57 bzr-jam-integration)
- mto: This revision was merged to the branch mainline in revision 1550.
- Revision ID: robertc@robertcollins.net-20051224022045-14efc8dfa0e1a4e9
Start tests for api usage.
- files added:
- .rsyncexclude
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/store
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/transport
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- patches
- tools
- files removed:
- bzrlib/tests.py
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- elementtree/ => bzrlib/util/elementtree/
- bzrlib/newinventory.py => contrib/newinventory.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
from sets import Set
18
import shutil
19
import sys
20
import os
21
import errno
22
from warnings import warn
23
from cStringIO import StringIO
19
24
20
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
21
import traceback, socket, fnmatch, difflib, time
22
from binascii import hexlify
23
25
24
26
import bzrlib
25
from inventory import Inventory
26
from trace import mutter, note
27
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
28
from inventory import InventoryEntry, Inventory
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
32
from store import ImmutableStore
33
from revision import Revision
34
from errors import bailout
35
from textui import show_status
36
from diff import diff_trees
37
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
27
import bzrlib.inventory as inventory
28
from bzrlib.trace import mutter, note
29
from bzrlib.osutils import (isdir, quotefn,
30
rename, splitpath, sha_file, appendpath,
31
file_kind, abspath)
32
import bzrlib.errors as errors
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
34
NoSuchRevision, HistoryMissing, NotBranchError,
35
DivergedBranches, LockError, UnlistableStore,
36
UnlistableBranch, NoSuchFile, NotVersionedError,
37
NoWorkingTree)
38
from bzrlib.textui import show_status
39
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions,
40
NULL_REVISION)
41
42
from bzrlib.delta import compare_trees
43
from bzrlib.tree import EmptyTree, RevisionTree
44
from bzrlib.inventory import Inventory
45
from bzrlib.store import copy_all
46
from bzrlib.store.text import TextStore
47
from bzrlib.store.weave import WeaveStore
48
from bzrlib.testament import Testament
49
import bzrlib.transactions as transactions
50
from bzrlib.transport import Transport, get_transport
51
import bzrlib.xml5
52
import bzrlib.ui
53
from config import TreeConfig
54
55
56
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
57
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
58
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
39
59
## TODO: Maybe include checks for common corruption of newlines, etc?
40
60
41
61
42
43
def find_branch_root(f=None):
44
"""Find the branch root enclosing f, or pwd.
45
46
It is not necessary that f exists.
47
48
Basically we keep looking up until we find the control directory or
49
run into the root."""
50
if f is None:
51
f = os.getcwd()
52
elif hasattr(os.path, 'realpath'):
53
f = os.path.realpath(f)
54
else:
55
f = os.path.abspath(f)
56
57
orig_f = f
58
59
last_f = f
60
while True:
61
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
62
return f
63
head, tail = os.path.split(f)
64
if head == f:
65
# reached the root, whatever that may be
66
bailout('%r is not in a branch' % orig_f)
67
f = head
68
69
62
# TODO: Some operations like log might retrieve the same revisions
63
# repeatedly to calculate deltas. We could perhaps have a weakref
64
# cache in memory to make this faster. In general anything can be
65
# cached in memory between lock and unlock operations.
66
67
def find_branch(*ignored, **ignored_too):
68
# XXX: leave this here for about one release, then remove it
69
raise NotImplementedError('find_branch() is not supported anymore, '
70
'please use one of the new branch constructors')
71
72
73
def needs_read_lock(unbound):
74
"""Decorate unbound to take out and release a read lock."""
75
def decorated(self, *args, **kwargs):
76
self.lock_read()
77
try:
78
return unbound(self, *args, **kwargs)
79
finally:
80
self.unlock()
81
return decorated
82
83
84
def needs_write_lock(unbound):
85
"""Decorate unbound to take out and release a write lock."""
86
def decorated(self, *args, **kwargs):
87
self.lock_write()
88
try:
89
return unbound(self, *args, **kwargs)
90
finally:
91
self.unlock()
92
return decorated
70
93
71
94
######################################################################
72
95
# branch objects
73
96
74
class Branch:
97
class Branch(object):
75
98
"""Branch holding a history of revisions.
76
99
77
:todo: Perhaps use different stores for different classes of object,
78
so that we can keep track of how much space each one uses,
79
or garbage-collect them.
80
81
:todo: Add a RemoteBranch subclass. For the basic case of read-only
82
HTTP access this should be very easy by,
83
just redirecting controlfile access into HTTP requests.
84
We would need a RemoteStore working similarly.
85
86
:todo: Keep the on-disk branch locked while the object exists.
87
88
:todo: mkdir() method.
100
base
101
Base directory/url of the branch.
89
102
"""
90
def __init__(self, base, init=False, find_root=True):
91
"""Create new branch object at a particular location.
92
93
:param base: Base directory for the branch.
94
95
:param init: If True, create new control files in a previously
96
unversioned directory. If False, the branch must already
97
be versioned.
98
99
:param find_root: If true and init is false, find the root of the
100
existing branch containing base.
101
102
In the test suite, creation of new trees is tested using the
103
`ScratchBranch` class.
104
"""
105
if init:
106
self.base = os.path.realpath(base)
107
self._make_control()
108
elif find_root:
109
self.base = find_branch_root(base)
110
else:
111
self.base = os.path.realpath(base)
112
if not isdir(self.controlfilename('.')):
113
bailout("not a bzr branch: %s" % quotefn(base),
114
['use "bzr init" to initialize a new working tree',
115
'current bzr can only operate from top-of-tree'])
116
self._check_format()
117
118
self.text_store = ImmutableStore(self.controlfilename('text-store'))
119
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
120
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
121
122
123
def __str__(self):
124
return '%s(%r)' % (self.__class__.__name__, self.base)
125
126
127
__repr__ = __str__
128
103
base = None
104
105
def __init__(self, *ignored, **ignored_too):
106
raise NotImplementedError('The Branch class is abstract')
107
108
@staticmethod
109
def open_downlevel(base):
110
"""Open a branch which may be of an old format.
111
112
Only local branches are supported."""
113
return BzrBranch(get_transport(base), relax_version_check=True)
114
115
@staticmethod
116
def open(base):
117
"""Open an existing branch, rooted at 'base' (url)"""
118
t = get_transport(base)
119
mutter("trying to open %r with transport %r", base, t)
120
return BzrBranch(t)
121
122
@staticmethod
123
def open_containing(url):
124
"""Open an existing branch which contains url.
125
126
This probes for a branch at url, and searches upwards from there.
127
128
Basically we keep looking up until we find the control directory or
129
run into the root. If there isn't one, raises NotBranchError.
130
If there is one, it is returned, along with the unused portion of url.
131
"""
132
t = get_transport(url)
133
while True:
134
try:
135
return BzrBranch(t), t.relpath(url)
136
except NotBranchError:
137
pass
138
new_t = t.clone('..')
139
if new_t.base == t.base:
140
# reached the root, whatever that may be
141
raise NotBranchError(path=url)
142
t = new_t
143
144
@staticmethod
145
def initialize(base):
146
"""Create a new branch, rooted at 'base' (url)"""
147
t = get_transport(base)
148
return BzrBranch(t, init=True)
149
150
def setup_caching(self, cache_root):
151
"""Subclasses that care about caching should override this, and set
152
up cached stores located under cache_root.
153
"""
154
self.cache_root = cache_root
155
156
def _get_nick(self):
157
cfg = self.tree_config()
158
return cfg.get_option(u"nickname", default=self.base.split('/')[-1])
159
160
def _set_nick(self, nick):
161
cfg = self.tree_config()
162
cfg.set_option(nick, "nickname")
163
assert cfg.get_option("nickname") == nick
164
165
nick = property(_get_nick, _set_nick)
166
167
def push_stores(self, branch_to):
168
"""Copy the content of this branches store to branch_to."""
169
raise NotImplementedError('push_stores is abstract')
170
171
def get_transaction(self):
172
"""Return the current active transaction.
173
174
If no transaction is active, this returns a passthrough object
175
for which all data is immediately flushed and no caching happens.
176
"""
177
raise NotImplementedError('get_transaction is abstract')
178
179
def lock_write(self):
180
raise NotImplementedError('lock_write is abstract')
181
182
def lock_read(self):
183
raise NotImplementedError('lock_read is abstract')
184
185
def unlock(self):
186
raise NotImplementedError('unlock is abstract')
129
187
130
188
def abspath(self, name):
131
"""Return absolute filename for something in the branch"""
132
return os.path.join(self.base, name)
133
134
135
def relpath(self, path):
136
"""Return path relative to this branch of something inside it.
137
138
Raises an error if path is not in this branch."""
139
rp = os.path.realpath(path)
140
# FIXME: windows
141
if not rp.startswith(self.base):
142
bailout("path %r is not within branch %r" % (rp, self.base))
143
rp = rp[len(self.base):]
144
rp = rp.lstrip(os.sep)
145
return rp
146
189
"""Return absolute filename for something in the branch
190
191
XXX: Robert Collins 20051017 what is this used for? why is it a branch
192
method and not a tree method.
193
"""
194
raise NotImplementedError('abspath is abstract')
147
195
148
196
def controlfilename(self, file_or_path):
149
197
"""Return location relative to branch."""
150
if isinstance(file_or_path, types.StringTypes):
151
file_or_path = [file_or_path]
152
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
153
198
raise NotImplementedError('controlfilename is abstract')
154
199
155
200
def controlfile(self, file_or_path, mode='r'):
156
"""Open a control file for this branch"""
157
return file(self.controlfilename(file_or_path), mode)
158
159
160
def _make_control(self):
161
os.mkdir(self.controlfilename([]))
162
self.controlfile('README', 'w').write(
163
"This is a Bazaar-NG control directory.\n"
164
"Do not change any files in this directory.")
165
self.controlfile('branch-format', 'wb').write(BZR_BRANCH_FORMAT)
166
for d in ('text-store', 'inventory-store', 'revision-store'):
167
os.mkdir(self.controlfilename(d))
168
for f in ('revision-history', 'merged-patches',
169
'pending-merged-patches', 'branch-name'):
170
self.controlfile(f, 'w').write('')
171
mutter('created control directory in ' + self.base)
172
Inventory().write_xml(self.controlfile('inventory','w'))
173
174
175
def _check_format(self):
176
"""Check this branch format is supported.
177
178
The current tool only supports the current unstable format.
179
180
In the future, we might need different in-memory Branch
181
classes to support downlevel branches. But not yet.
182
"""
183
# This ignores newlines so that we can open branches created
184
# on Windows from Linux and so on. I think it might be better
185
# to always make all internal files in unix format.
186
fmt = self.controlfile('branch-format', 'rb').read()
187
fmt.replace('\r\n', '')
188
if fmt != BZR_BRANCH_FORMAT:
189
bailout('sorry, branch format %r not supported' % fmt,
190
['use a different bzr version',
191
'or remove the .bzr directory and "bzr init" again'])
192
193
194
def read_working_inventory(self):
195
"""Read the working inventory."""
196
before = time.time()
197
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
198
mutter("loaded inventory of %d items in %f"
199
% (len(inv), time.time() - before))
200
return inv
201
202
203
def _write_inventory(self, inv):
204
"""Update the working inventory.
205
206
That is to say, the inventory describing changes underway, that
207
will be committed to the next revision.
208
"""
209
## TODO: factor out to atomicfile? is rename safe on windows?
210
## TODO: Maybe some kind of clean/dirty marker on inventory?
211
tmpfname = self.controlfilename('inventory.tmp')
212
tmpf = file(tmpfname, 'w')
213
inv.write_xml(tmpf)
214
tmpf.close()
215
inv_fname = self.controlfilename('inventory')
216
if sys.platform == 'win32':
217
os.remove(inv_fname)
218
os.rename(tmpfname, inv_fname)
219
mutter('wrote working inventory')
220
221
222
inventory = property(read_working_inventory, _write_inventory, None,
223
"""Inventory for the working copy.""")
224
225
226
def add(self, files, verbose=False):
227
"""Make files versioned.
228
229
This puts the files in the Added state, so that they will be
230
recorded by the next commit.
231
232
:todo: Perhaps have an option to add the ids even if the files do
233
not (yet) exist.
234
235
:todo: Perhaps return the ids of the files? But then again it
236
is easy to retrieve them if they're needed.
237
238
:todo: Option to specify file id.
239
240
:todo: Adding a directory should optionally recurse down and
241
add all non-ignored children. Perhaps do that in a
242
higher-level method.
243
244
>>> b = ScratchBranch(files=['foo'])
245
>>> 'foo' in b.unknowns()
246
True
247
>>> b.show_status()
248
? foo
249
>>> b.add('foo')
250
>>> 'foo' in b.unknowns()
251
False
252
>>> bool(b.inventory.path2id('foo'))
253
True
254
>>> b.show_status()
255
A foo
256
257
>>> b.add('foo')
258
Traceback (most recent call last):
259
...
260
BzrError: ('foo is already versioned', [])
261
262
>>> b.add(['nothere'])
263
Traceback (most recent call last):
264
BzrError: ('cannot add: not a regular file or directory: nothere', [])
265
"""
266
267
# TODO: Re-adding a file that is removed in the working copy
268
# should probably put it back with the previous ID.
269
if isinstance(files, types.StringTypes):
270
files = [files]
271
272
inv = self.read_working_inventory()
273
for f in files:
274
if is_control_file(f):
275
bailout("cannot add control file %s" % quotefn(f))
276
277
fp = splitpath(f)
278
279
if len(fp) == 0:
280
bailout("cannot add top-level %r" % f)
281
282
fullpath = os.path.normpath(self.abspath(f))
283
284
try:
285
kind = file_kind(fullpath)
286
except OSError:
287
# maybe something better?
288
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
289
290
if kind != 'file' and kind != 'directory':
291
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
292
293
file_id = gen_file_id(f)
294
inv.add_path(f, kind=kind, file_id=file_id)
295
296
if verbose:
297
show_status('A', kind, quotefn(f))
298
299
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
300
301
self._write_inventory(inv)
302
303
304
305
def remove(self, files, verbose=False):
306
"""Mark nominated files for removal from the inventory.
307
308
This does not remove their text. This does not run on
309
310
:todo: Refuse to remove modified files unless --force is given?
311
312
>>> b = ScratchBranch(files=['foo'])
313
>>> b.add('foo')
314
>>> b.inventory.has_filename('foo')
315
True
316
>>> b.remove('foo')
317
>>> b.working_tree().has_filename('foo')
318
True
319
>>> b.inventory.has_filename('foo')
320
False
321
322
>>> b = ScratchBranch(files=['foo'])
323
>>> b.add('foo')
324
>>> b.commit('one')
325
>>> b.remove('foo')
326
>>> b.commit('two')
327
>>> b.inventory.has_filename('foo')
328
False
329
>>> b.basis_tree().has_filename('foo')
330
False
331
>>> b.working_tree().has_filename('foo')
332
True
333
334
:todo: Do something useful with directories.
335
336
:todo: Should this remove the text or not? Tough call; not
337
removing may be useful and the user can just use use rm, and
338
is the opposite of add. Removing it is consistent with most
339
other tools. Maybe an option.
340
"""
341
## TODO: Normalize names
342
## TODO: Remove nested loops; better scalability
343
344
if isinstance(files, types.StringTypes):
345
files = [files]
346
347
tree = self.working_tree()
348
inv = tree.inventory
349
350
# do this before any modifications
351
for f in files:
352
fid = inv.path2id(f)
353
if not fid:
354
bailout("cannot remove unversioned file %s" % quotefn(f))
355
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
356
if verbose:
357
# having remove it, it must be either ignored or unknown
358
if tree.is_ignored(f):
359
new_status = 'I'
360
else:
361
new_status = '?'
362
show_status(new_status, inv[fid].kind, quotefn(f))
363
del inv[fid]
364
365
self._write_inventory(inv)
366
367
368
def unknowns(self):
369
"""Return all unknown files.
370
371
These are files in the working directory that are not versioned or
372
control files or ignored.
373
374
>>> b = ScratchBranch(files=['foo', 'foo~'])
375
>>> list(b.unknowns())
376
['foo']
377
>>> b.add('foo')
378
>>> list(b.unknowns())
379
[]
380
>>> b.remove('foo')
381
>>> list(b.unknowns())
382
['foo']
383
"""
384
return self.working_tree().unknowns()
385
386
387
def commit(self, message, timestamp=None, timezone=None,
388
committer=None,
389
verbose=False):
390
"""Commit working copy as a new revision.
391
392
The basic approach is to add all the file texts into the
393
store, then the inventory, then make a new revision pointing
394
to that inventory and store that.
395
396
This is not quite safe if the working copy changes during the
397
commit; for the moment that is simply not allowed. A better
398
approach is to make a temporary copy of the files before
399
computing their hashes, and then add those hashes in turn to
400
the inventory. This should mean at least that there are no
401
broken hash pointers. There is no way we can get a snapshot
402
of the whole directory at an instant. This would also have to
403
be robust against files disappearing, moving, etc. So the
404
whole thing is a bit hard.
405
406
:param timestamp: if not None, seconds-since-epoch for a
407
postdated/predated commit.
408
"""
409
410
## TODO: Show branch names
411
412
# TODO: Don't commit if there are no changes, unless forced?
413
414
# First walk over the working inventory; and both update that
415
# and also build a new revision inventory. The revision
416
# inventory needs to hold the text-id, sha1 and size of the
417
# actual file versions committed in the revision. (These are
418
# not present in the working inventory.) We also need to
419
# detect missing/deleted files, and remove them from the
420
# working inventory.
421
422
work_inv = self.read_working_inventory()
423
inv = Inventory()
424
basis = self.basis_tree()
425
basis_inv = basis.inventory
426
missing_ids = []
427
for path, entry in work_inv.iter_entries():
428
## TODO: Cope with files that have gone missing.
429
430
## TODO: Check that the file kind has not changed from the previous
431
## revision of this file (if any).
432
433
entry = entry.copy()
434
435
p = self.abspath(path)
436
file_id = entry.file_id
437
mutter('commit prep file %s, id %r ' % (p, file_id))
438
439
if not os.path.exists(p):
440
mutter(" file is missing, removing from inventory")
441
if verbose:
442
show_status('D', entry.kind, quotefn(path))
443
missing_ids.append(file_id)
444
continue
445
446
# TODO: Handle files that have been deleted
447
448
# TODO: Maybe a special case for empty files? Seems a
449
# waste to store them many times.
450
451
inv.add(entry)
452
453
if basis_inv.has_id(file_id):
454
old_kind = basis_inv[file_id].kind
455
if old_kind != entry.kind:
456
bailout("entry %r changed kind from %r to %r"
457
% (file_id, old_kind, entry.kind))
458
459
if entry.kind == 'directory':
460
if not isdir(p):
461
bailout("%s is entered as directory but not a directory" % quotefn(p))
462
elif entry.kind == 'file':
463
if not isfile(p):
464
bailout("%s is entered as file but is not a file" % quotefn(p))
465
466
content = file(p, 'rb').read()
467
468
entry.text_sha1 = sha_string(content)
469
entry.text_size = len(content)
470
471
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
472
if (old_ie
473
and (old_ie.text_size == entry.text_size)
474
and (old_ie.text_sha1 == entry.text_sha1)):
475
## assert content == basis.get_file(file_id).read()
476
entry.text_id = basis_inv[file_id].text_id
477
mutter(' unchanged from previous text_id {%s}' %
478
entry.text_id)
479
480
else:
481
entry.text_id = gen_file_id(entry.name)
482
self.text_store.add(content, entry.text_id)
483
mutter(' stored with text_id {%s}' % entry.text_id)
484
if verbose:
485
if not old_ie:
486
state = 'A'
487
elif (old_ie.name == entry.name
488
and old_ie.parent_id == entry.parent_id):
489
state = 'M'
490
else:
491
state = 'R'
492
493
show_status(state, entry.kind, quotefn(path))
494
495
for file_id in missing_ids:
496
# have to do this later so we don't mess up the iterator.
497
# since parents may be removed before their children we
498
# have to test.
499
500
# FIXME: There's probably a better way to do this; perhaps
501
# the workingtree should know how to filter itself.
502
if work_inv.has_id(file_id):
503
del work_inv[file_id]
504
505
506
inv_id = rev_id = _gen_revision_id(time.time())
507
508
inv_tmp = tempfile.TemporaryFile()
509
inv.write_xml(inv_tmp)
510
inv_tmp.seek(0)
511
self.inventory_store.add(inv_tmp, inv_id)
512
mutter('new inventory_id is {%s}' % inv_id)
513
514
self._write_inventory(work_inv)
515
516
if timestamp == None:
517
timestamp = time.time()
518
519
if committer == None:
520
committer = username()
521
522
if timezone == None:
523
timezone = local_time_offset()
524
525
mutter("building commit log message")
526
rev = Revision(timestamp=timestamp,
527
timezone=timezone,
528
committer=committer,
529
precursor = self.last_patch(),
530
message = message,
531
inventory_id=inv_id,
532
revision_id=rev_id)
533
534
rev_tmp = tempfile.TemporaryFile()
535
rev.write_xml(rev_tmp)
536
rev_tmp.seek(0)
537
self.revision_store.add(rev_tmp, rev_id)
538
mutter("new revision_id is {%s}" % rev_id)
539
540
## XXX: Everything up to here can simply be orphaned if we abort
541
## the commit; it will leave junk files behind but that doesn't
542
## matter.
543
544
## TODO: Read back the just-generated changeset, and make sure it
545
## applies and recreates the right state.
546
547
## TODO: Also calculate and store the inventory SHA1
548
mutter("committing patch r%d" % (self.revno() + 1))
549
550
mutter("append to revision-history")
551
f = self.controlfile('revision-history', 'at')
552
f.write(rev_id + '\n')
553
f.close()
554
555
if verbose:
556
note("commited r%d" % self.revno())
557
201
"""Open a control file for this branch.
202
203
There are two classes of file in the control directory: text
204
and binary. binary files are untranslated byte streams. Text
205
control files are stored with Unix newlines and in UTF-8, even
206
if the platform or locale defaults are different.
207
208
Controlfiles should almost never be opened in write mode but
209
rather should be atomically copied and replaced using atomicfile.
210
"""
211
raise NotImplementedError('controlfile is abstract')
212
213
def put_controlfile(self, path, f, encode=True):
214
"""Write an entry as a controlfile.
215
216
:param path: The path to put the file, relative to the .bzr control
217
directory
218
:param f: A file-like or string object whose contents should be copied.
219
:param encode: If true, encode the contents as utf-8
220
"""
221
raise NotImplementedError('put_controlfile is abstract')
222
223
def put_controlfiles(self, files, encode=True):
224
"""Write several entries as controlfiles.
225
226
:param files: A list of [(path, file)] pairs, where the path is the directory
227
underneath the bzr control directory
228
:param encode: If true, encode the contents as utf-8
229
"""
230
raise NotImplementedError('put_controlfiles is abstract')
231
232
def get_root_id(self):
233
"""Return the id of this branches root"""
234
raise NotImplementedError('get_root_id is abstract')
235
236
def set_root_id(self, file_id):
237
raise NotImplementedError('set_root_id is abstract')
238
239
def print_file(self, file, revision_id):
240
"""Print `file` to stdout."""
241
raise NotImplementedError('print_file is abstract')
242
243
def append_revision(self, *revision_ids):
244
raise NotImplementedError('append_revision is abstract')
245
246
def set_revision_history(self, rev_history):
247
raise NotImplementedError('set_revision_history is abstract')
248
249
def has_revision(self, revision_id):
250
"""True if this branch has a copy of the revision.
251
252
This does not necessarily imply the revision is merge
253
or on the mainline."""
254
raise NotImplementedError('has_revision is abstract')
255
256
def get_revision_xml(self, revision_id):
257
raise NotImplementedError('get_revision_xml is abstract')
558
258
559
259
def get_revision(self, revision_id):
560
260
"""Return the Revision object for a named revision"""
561
r = Revision.read_xml(self.revision_store[revision_id])
562
assert r.revision_id == revision_id
563
return r
564
565
566
def get_inventory(self, inventory_id):
567
"""Get Inventory object by hash.
568
569
:todo: Perhaps for this and similar methods, take a revision
570
parameter which can be either an integer revno or a
571
string hash."""
572
i = Inventory.read_xml(self.inventory_store[inventory_id])
573
return i
574
261
raise NotImplementedError('get_revision is abstract')
262
263
def get_revision_delta(self, revno):
264
"""Return the delta for one revision.
265
266
The delta is relative to its mainline predecessor, or the
267
empty tree for revision 1.
268
"""
269
assert isinstance(revno, int)
270
rh = self.revision_history()
271
if not (1 <= revno <= len(rh)):
272
raise InvalidRevisionNumber(revno)
273
274
# revno is 1-based; list is 0-based
275
276
new_tree = self.revision_tree(rh[revno-1])
277
if revno == 1:
278
old_tree = EmptyTree()
279
else:
280
old_tree = self.revision_tree(rh[revno-2])
281
282
return compare_trees(old_tree, new_tree)
283
284
def get_revision_sha1(self, revision_id):
285
"""Hash the stored value of a revision, and return it."""
286
raise NotImplementedError('get_revision_sha1 is abstract')
287
288
def get_ancestry(self, revision_id):
289
"""Return a list of revision-ids integrated by a revision.
290
291
This currently returns a list, but the ordering is not guaranteed:
292
treat it as a set.
293
"""
294
raise NotImplementedError('get_ancestry is abstract')
295
296
def get_inventory(self, revision_id):
297
"""Get Inventory object by hash."""
298
raise NotImplementedError('get_inventory is abstract')
299
300
def get_inventory_xml(self, revision_id):
301
"""Get inventory XML as a file object."""
302
raise NotImplementedError('get_inventory_xml is abstract')
303
304
def get_inventory_sha1(self, revision_id):
305
"""Return the sha1 hash of the inventory entry."""
306
raise NotImplementedError('get_inventory_sha1 is abstract')
575
307
576
308
def get_revision_inventory(self, revision_id):
577
309
"""Return inventory of a past revision."""
578
if revision_id == None:
579
return Inventory()
580
else:
581
return self.get_inventory(self.get_revision(revision_id).inventory_id)
582
310
raise NotImplementedError('get_revision_inventory is abstract')
583
311
584
312
def revision_history(self):
585
"""Return sequence of revision hashes on to this branch.
586
587
>>> ScratchBranch().revision_history()
588
[]
589
"""
590
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
591
313
"""Return sequence of revision hashes on to this branch."""
314
raise NotImplementedError('revision_history is abstract')
592
315
593
316
def revno(self):
594
317
"""Return current revision number for this branch.
595
318
596
319
That is equivalent to the number of revisions committed to
597
320
this branch.
598
599
>>> b = ScratchBranch()
600
>>> b.revno()
601
0
602
>>> b.commit('no foo')
603
>>> b.revno()
604
1
605
321
"""
606
322
return len(self.revision_history())
607
323
608
609
def last_patch(self):
610
"""Return last patch hash, or None if no history.
611
612
>>> ScratchBranch().last_patch() == None
613
True
614
"""
324
def last_revision(self):
325
"""Return last patch hash, or None if no history."""
615
326
ph = self.revision_history()
616
327
if ph:
617
328
return ph[-1]
618
619
620
def lookup_revision(self, revno):
621
"""Return revision hash for revision number."""
329
else:
330
return None
331
332
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
333
"""Return a list of new revisions that would perfectly fit.
334
335
If self and other have not diverged, return a list of the revisions
336
present in other, but missing from self.
337
338
>>> from bzrlib.commit import commit
339
>>> bzrlib.trace.silent = True
340
>>> br1 = ScratchBranch()
341
>>> br2 = ScratchBranch()
342
>>> br1.missing_revisions(br2)
343
[]
344
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
345
>>> br1.missing_revisions(br2)
346
[u'REVISION-ID-1']
347
>>> br2.missing_revisions(br1)
348
[]
349
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
350
>>> br1.missing_revisions(br2)
351
[]
352
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
353
>>> br1.missing_revisions(br2)
354
[u'REVISION-ID-2A']
355
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
356
>>> br1.missing_revisions(br2)
357
Traceback (most recent call last):
358
DivergedBranches: These branches have diverged. Try merge.
359
"""
360
self_history = self.revision_history()
361
self_len = len(self_history)
362
other_history = other.revision_history()
363
other_len = len(other_history)
364
common_index = min(self_len, other_len) -1
365
if common_index >= 0 and \
366
self_history[common_index] != other_history[common_index]:
367
raise DivergedBranches(self, other)
368
369
if stop_revision is None:
370
stop_revision = other_len
371
else:
372
assert isinstance(stop_revision, int)
373
if stop_revision > other_len:
374
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
375
return other_history[self_len:stop_revision]
376
377
def update_revisions(self, other, stop_revision=None):
378
"""Pull in new perfect-fit revisions."""
379
raise NotImplementedError('update_revisions is abstract')
380
381
def pullable_revisions(self, other, stop_revision):
382
raise NotImplementedError('pullable_revisions is abstract')
383
384
def revision_id_to_revno(self, revision_id):
385
"""Given a revision id, return its revno"""
386
if revision_id is None:
387
return 0
388
history = self.revision_history()
389
try:
390
return history.index(revision_id) + 1
391
except ValueError:
392
raise bzrlib.errors.NoSuchRevision(self, revision_id)
393
394
def get_rev_id(self, revno, history=None):
395
"""Find the revision id of the specified revno."""
622
396
if revno == 0:
623
397
return None
624
625
try:
626
# list is 0-based; revisions are 1-based
627
return self.revision_history()[revno-1]
628
except IndexError:
629
bailout("no such revision %s" % revno)
630
398
if history is None:
399
history = self.revision_history()
400
elif revno <= 0 or revno > len(history):
401
raise bzrlib.errors.NoSuchRevision(self, revno)
402
return history[revno - 1]
631
403
632
404
def revision_tree(self, revision_id):
633
405
"""Return Tree for a revision on this branch.
634
406
635
407
`revision_id` may be None for the null revision, in which case
636
408
an `EmptyTree` is returned."""
637
638
if revision_id == None:
639
return EmptyTree()
640
else:
641
inv = self.get_revision_inventory(revision_id)
642
return RevisionTree(self.text_store, inv)
643
409
raise NotImplementedError('revision_tree is abstract')
644
410
645
411
def working_tree(self):
646
"""Return a `Tree` for the working copy."""
647
return WorkingTree(self.base, self.read_working_inventory())
412
"""Return a `Tree` for the working copy if this is a local branch."""
413
raise NotImplementedError('working_tree is abstract')
648
414
415
def pull(self, source, overwrite=False):
416
raise NotImplementedError('pull is abstract')
649
417
650
418
def basis_tree(self):
651
419
"""Return `Tree` object for last revision.
652
420
653
421
If there are no revisions yet, return an `EmptyTree`.
654
655
>>> b = ScratchBranch(files=['foo'])
656
>>> b.basis_tree().has_filename('foo')
657
False
658
>>> b.working_tree().has_filename('foo')
659
True
660
>>> b.add('foo')
661
>>> b.commit('add foo')
662
>>> b.basis_tree().has_filename('foo')
663
True
664
422
"""
665
r = self.last_patch()
666
if r == None:
667
return EmptyTree()
668
else:
669
return RevisionTree(self.text_store, self.get_revision_inventory(r))
670
671
672
673
def write_log(self, show_timezone='original'):
674
"""Write out human-readable log of commits to this branch
675
676
:param utc: If true, show dates in universal time, not local time."""
677
## TODO: Option to choose either original, utc or local timezone
678
revno = 1
679
precursor = None
680
for p in self.revision_history():
681
print '-' * 40
682
print 'revno:', revno
683
## TODO: Show hash if --id is given.
684
##print 'revision-hash:', p
685
rev = self.get_revision(p)
686
print 'committer:', rev.committer
687
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
688
show_timezone))
689
690
## opportunistic consistency check, same as check_patch_chaining
691
if rev.precursor != precursor:
692
bailout("mismatched precursor!")
693
694
print 'message:'
695
if not rev.message:
696
print ' (no message)'
697
else:
698
for l in rev.message.split('\n'):
699
print ' ' + l
700
701
revno += 1
702
precursor = p
703
423
return self.revision_tree(self.last_revision())
704
424
705
425
def rename_one(self, from_rel, to_rel):
706
tree = self.working_tree()
707
inv = tree.inventory
708
if not tree.has_filename(from_rel):
709
bailout("can't rename: old working file %r does not exist" % from_rel)
710
if tree.has_filename(to_rel):
711
bailout("can't rename: new working file %r already exists" % to_rel)
712
713
file_id = inv.path2id(from_rel)
714
if file_id == None:
715
bailout("can't rename: old name %r is not versioned" % from_rel)
716
717
if inv.path2id(to_rel):
718
bailout("can't rename: new name %r is already versioned" % to_rel)
719
720
to_dir, to_tail = os.path.split(to_rel)
721
to_dir_id = inv.path2id(to_dir)
722
if to_dir_id == None and to_dir != '':
723
bailout("can't determine destination directory id for %r" % to_dir)
724
725
mutter("rename_one:")
726
mutter(" file_id {%s}" % file_id)
727
mutter(" from_rel %r" % from_rel)
728
mutter(" to_rel %r" % to_rel)
729
mutter(" to_dir %r" % to_dir)
730
mutter(" to_dir_id {%s}" % to_dir_id)
731
732
inv.rename(file_id, to_dir_id, to_tail)
733
os.rename(self.abspath(from_rel), self.abspath(to_rel))
734
735
self._write_inventory(inv)
736
737
738
739
def rename(self, from_paths, to_name):
426
"""Rename one file.
427
428
This can change the directory or the filename or both.
429
"""
430
raise NotImplementedError('rename_one is abstract')
431
432
def move(self, from_paths, to_name):
740
433
"""Rename files.
741
434
435
to_name must exist as a versioned directory.
436
742
437
If to_name exists and is a directory, the files are moved into
743
438
it, keeping their old names. If it is a directory,
744
439
745
440
Note that to_name is only the last component of the new name;
746
441
this doesn't change the directory.
747
"""
748
## TODO: Option to move IDs only
749
assert not isinstance(from_paths, basestring)
750
tree = self.working_tree()
751
inv = tree.inventory
752
dest_dir = isdir(self.abspath(to_name))
753
if dest_dir:
754
# TODO: Wind back properly if some can't be moved?
755
dest_dir_id = inv.path2id(to_name)
756
if not dest_dir_id and to_name != '':
757
bailout("destination %r is not a versioned directory" % to_name)
758
for f in from_paths:
759
name_tail = splitpath(f)[-1]
760
dest_path = appendpath(to_name, name_tail)
761
print "%s => %s" % (f, dest_path)
762
inv.rename(inv.path2id(f), dest_dir_id, name_tail)
763
os.rename(self.abspath(f), self.abspath(dest_path))
764
self._write_inventory(inv)
765
else:
766
if len(from_paths) != 1:
767
bailout("when moving multiple files, destination must be a directory")
768
bailout("rename to non-directory %r not implemented sorry" % to_name)
769
770
771
772
def show_status(branch, show_all=False):
773
"""Display single-line status for non-ignored working files.
774
775
The list is show sorted in order by file name.
776
777
>>> b = ScratchBranch(files=['foo', 'foo~'])
778
>>> b.show_status()
779
? foo
780
>>> b.add('foo')
781
>>> b.show_status()
782
A foo
783
>>> b.commit("add foo")
784
>>> b.show_status()
785
>>> os.unlink(b.abspath('foo'))
786
>>> b.show_status()
787
D foo
788
789
790
:todo: Get state for single files.
791
792
:todo: Perhaps show a slash at the end of directory names.
793
794
"""
795
796
# We have to build everything into a list first so that it can
797
# sorted by name, incorporating all the different sources.
798
799
# FIXME: Rather than getting things in random order and then sorting,
800
# just step through in order.
801
802
# Interesting case: the old ID for a file has been removed,
803
# but a new file has been created under that name.
804
805
old = branch.basis_tree()
806
old_inv = old.inventory
807
new = branch.working_tree()
808
new_inv = new.inventory
809
810
for fs, fid, oldname, newname, kind in diff_trees(old, new):
811
if fs == 'R':
812
show_status(fs, kind,
813
oldname + ' => ' + newname)
814
elif fs == 'A' or fs == 'M':
815
show_status(fs, kind, newname)
816
elif fs == 'D':
817
show_status(fs, kind, oldname)
818
elif fs == '.':
819
if show_all:
820
show_status(fs, kind, newname)
821
elif fs == 'I':
822
if show_all:
823
show_status(fs, kind, newname)
824
elif fs == '?':
825
show_status(fs, kind, newname)
442
443
This returns a list of (from_path, to_path) pairs for each
444
entry that is moved.
445
"""
446
raise NotImplementedError('move is abstract')
447
448
def get_parent(self):
449
"""Return the parent location of the branch.
450
451
This is the default location for push/pull/missing. The usual
452
pattern is that the user can override it by specifying a
453
location.
454
"""
455
raise NotImplementedError('get_parent is abstract')
456
457
def get_push_location(self):
458
"""Return the None or the location to push this branch to."""
459
raise NotImplementedError('get_push_location is abstract')
460
461
def set_push_location(self, location):
462
"""Set a new push location for this branch."""
463
raise NotImplementedError('set_push_location is abstract')
464
465
def set_parent(self, url):
466
raise NotImplementedError('set_parent is abstract')
467
468
def check_revno(self, revno):
469
"""\
470
Check whether a revno corresponds to any revision.
471
Zero (the NULL revision) is considered valid.
472
"""
473
if revno != 0:
474
self.check_real_revno(revno)
475
476
def check_real_revno(self, revno):
477
"""\
478
Check whether a revno corresponds to a real revision.
479
Zero (the NULL revision) is considered invalid
480
"""
481
if revno < 1 or revno > self.revno():
482
raise InvalidRevisionNumber(revno)
483
484
def sign_revision(self, revision_id, gpg_strategy):
485
raise NotImplementedError('sign_revision is abstract')
486
487
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
488
raise NotImplementedError('store_revision_signature is abstract')
489
490
class BzrBranch(Branch):
491
"""A branch stored in the actual filesystem.
492
493
Note that it's "local" in the context of the filesystem; it doesn't
494
really matter if it's on an nfs/smb/afs/coda/... share, as long as
495
it's writable, and can be accessed via the normal filesystem API.
496
497
_lock_mode
498
None, or 'r' or 'w'
499
500
_lock_count
501
If _lock_mode is true, a positive count of the number of times the
502
lock has been taken.
503
504
_lock
505
Lock object from bzrlib.lock.
506
"""
507
# We actually expect this class to be somewhat short-lived; part of its
508
# purpose is to try to isolate what bits of the branch logic are tied to
509
# filesystem access, so that in a later step, we can extricate them to
510
# a separarte ("storage") class.
511
_lock_mode = None
512
_lock_count = None
513
_lock = None
514
_inventory_weave = None
515
516
# Map some sort of prefix into a namespace
517
# stuff like "revno:10", "revid:", etc.
518
# This should match a prefix with a function which accepts
519
REVISION_NAMESPACES = {}
520
521
def push_stores(self, branch_to):
522
"""See Branch.push_stores."""
523
if (self._branch_format != branch_to._branch_format
524
or self._branch_format != 4):
525
from bzrlib.fetch import greedy_fetch
526
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
527
self, self._branch_format, branch_to, branch_to._branch_format)
528
greedy_fetch(to_branch=branch_to, from_branch=self,
529
revision=self.last_revision())
530
return
531
532
store_pairs = ((self.text_store, branch_to.text_store),
533
(self.inventory_store, branch_to.inventory_store),
534
(self.revision_store, branch_to.revision_store))
535
try:
536
for from_store, to_store in store_pairs:
537
copy_all(from_store, to_store)
538
except UnlistableStore:
539
raise UnlistableBranch(from_store)
540
541
def __init__(self, transport, init=False,
542
relax_version_check=False):
543
"""Create new branch object at a particular location.
544
545
transport -- A Transport object, defining how to access files.
546
547
init -- If True, create new control files in a previously
548
unversioned directory. If False, the branch must already
549
be versioned.
550
551
relax_version_check -- If true, the usual check for the branch
552
version is not applied. This is intended only for
553
upgrade/recovery type use; it's not guaranteed that
554
all operations will work on old format branches.
555
556
In the test suite, creation of new trees is tested using the
557
`ScratchBranch` class.
558
"""
559
assert isinstance(transport, Transport), \
560
"%r is not a Transport" % transport
561
self._transport = transport
562
if init:
563
self._make_control()
564
self._check_format(relax_version_check)
565
566
def get_store(name, compressed=True, prefixed=False):
567
# FIXME: This approach of assuming stores are all entirely compressed
568
# or entirely uncompressed is tidy, but breaks upgrade from
569
# some existing branches where there's a mixture; we probably
570
# still want the option to look for both.
571
relpath = self._rel_controlfilename(unicode(name))
572
store = TextStore(self._transport.clone(relpath),
573
prefixed=prefixed,
574
compressed=compressed)
575
#if self._transport.should_cache():
576
# cache_path = os.path.join(self.cache_root, name)
577
# os.mkdir(cache_path)
578
# store = bzrlib.store.CachedStore(store, cache_path)
579
return store
580
581
def get_weave(name, prefixed=False):
582
relpath = self._rel_controlfilename(unicode(name))
583
ws = WeaveStore(self._transport.clone(relpath), prefixed=prefixed)
584
if self._transport.should_cache():
585
ws.enable_cache = True
586
return ws
587
588
if self._branch_format == 4:
589
self.inventory_store = get_store('inventory-store')
590
self.text_store = get_store('text-store')
591
self.revision_store = get_store('revision-store')
592
elif self._branch_format == 5:
593
self.control_weaves = get_weave(u'')
594
self.weave_store = get_weave(u'weaves')
595
self.revision_store = get_store(u'revision-store', compressed=False)
596
elif self._branch_format == 6:
597
self.control_weaves = get_weave(u'')
598
self.weave_store = get_weave(u'weaves', prefixed=True)
599
self.revision_store = get_store(u'revision-store', compressed=False,
600
prefixed=True)
601
self.revision_store.register_suffix('sig')
602
self._transaction = None
603
604
def __str__(self):
605
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
606
607
__repr__ = __str__
608
609
def __del__(self):
610
if self._lock_mode or self._lock:
611
# XXX: This should show something every time, and be suitable for
612
# headless operation and embedding
613
warn("branch %r was not explicitly unlocked" % self)
614
self._lock.unlock()
615
616
# TODO: It might be best to do this somewhere else,
617
# but it is nice for a Branch object to automatically
618
# cache it's information.
619
# Alternatively, we could have the Transport objects cache requests
620
# See the earlier discussion about how major objects (like Branch)
621
# should never expect their __del__ function to run.
622
if hasattr(self, 'cache_root') and self.cache_root is not None:
623
try:
624
shutil.rmtree(self.cache_root)
625
except:
626
pass
627
self.cache_root = None
628
629
def _get_base(self):
630
if self._transport:
631
return self._transport.base
632
return None
633
634
base = property(_get_base, doc="The URL for the root of this branch.")
635
636
def _finish_transaction(self):
637
"""Exit the current transaction."""
638
if self._transaction is None:
639
raise errors.LockError('Branch %s is not in a transaction' %
640
self)
641
transaction = self._transaction
642
self._transaction = None
643
transaction.finish()
644
645
def get_transaction(self):
646
"""See Branch.get_transaction."""
647
if self._transaction is None:
648
return transactions.PassThroughTransaction()
649
else:
650
return self._transaction
651
652
def _set_transaction(self, new_transaction):
653
"""Set a new active transaction."""
654
if self._transaction is not None:
655
raise errors.LockError('Branch %s is in a transaction already.' %
656
self)
657
self._transaction = new_transaction
658
659
def lock_write(self):
660
#mutter("lock write: %s (%s)", self, self._lock_count)
661
# TODO: Upgrade locking to support using a Transport,
662
# and potentially a remote locking protocol
663
if self._lock_mode:
664
if self._lock_mode != 'w':
665
raise LockError("can't upgrade to a write lock from %r" %
666
self._lock_mode)
667
self._lock_count += 1
668
else:
669
self._lock = self._transport.lock_write(
670
self._rel_controlfilename('branch-lock'))
671
self._lock_mode = 'w'
672
self._lock_count = 1
673
self._set_transaction(transactions.PassThroughTransaction())
674
675
def lock_read(self):
676
#mutter("lock read: %s (%s)", self, self._lock_count)
677
if self._lock_mode:
678
assert self._lock_mode in ('r', 'w'), \
679
"invalid lock mode %r" % self._lock_mode
680
self._lock_count += 1
681
else:
682
self._lock = self._transport.lock_read(
683
self._rel_controlfilename('branch-lock'))
684
self._lock_mode = 'r'
685
self._lock_count = 1
686
self._set_transaction(transactions.ReadOnlyTransaction())
687
# 5K may be excessive, but hey, its a knob.
688
self.get_transaction().set_cache_size(5000)
689
690
def unlock(self):
691
#mutter("unlock: %s (%s)", self, self._lock_count)
692
if not self._lock_mode:
693
raise LockError('branch %r is not locked' % (self))
694
695
if self._lock_count > 1:
696
self._lock_count -= 1
697
else:
698
self._finish_transaction()
699
self._lock.unlock()
700
self._lock = None
701
self._lock_mode = self._lock_count = None
702
703
def abspath(self, name):
704
"""See Branch.abspath."""
705
return self._transport.abspath(name)
706
707
def _rel_controlfilename(self, file_or_path):
708
if not isinstance(file_or_path, basestring):
709
file_or_path = u'/'.join(file_or_path)
710
if file_or_path == '':
711
return bzrlib.BZRDIR
712
return bzrlib.transport.urlescape(bzrlib.BZRDIR + u'/' + file_or_path)
713
714
def controlfilename(self, file_or_path):
715
"""See Branch.controlfilename."""
716
return self._transport.abspath(self._rel_controlfilename(file_or_path))
717
718
def controlfile(self, file_or_path, mode='r'):
719
"""See Branch.controlfile."""
720
import codecs
721
722
relpath = self._rel_controlfilename(file_or_path)
723
#TODO: codecs.open() buffers linewise, so it was overloaded with
724
# a much larger buffer, do we need to do the same for getreader/getwriter?
725
if mode == 'rb':
726
return self._transport.get(relpath)
727
elif mode == 'wb':
728
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
729
elif mode == 'r':
730
# XXX: Do we really want errors='replace'? Perhaps it should be
731
# an error, or at least reported, if there's incorrectly-encoded
732
# data inside a file.
733
# <https://launchpad.net/products/bzr/+bug/3823>
734
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
735
elif mode == 'w':
736
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
737
else:
738
raise BzrError("invalid controlfile mode %r" % mode)
739
740
def put_controlfile(self, path, f, encode=True):
741
"""See Branch.put_controlfile."""
742
self.put_controlfiles([(path, f)], encode=encode)
743
744
def put_controlfiles(self, files, encode=True):
745
"""See Branch.put_controlfiles."""
746
import codecs
747
ctrl_files = []
748
for path, f in files:
749
if encode:
750
if isinstance(f, basestring):
751
f = f.encode('utf-8', 'replace')
752
else:
753
f = codecs.getwriter('utf-8')(f, errors='replace')
754
path = self._rel_controlfilename(path)
755
ctrl_files.append((path, f))
756
self._transport.put_multi(ctrl_files)
757
758
def _make_control(self):
759
from bzrlib.inventory import Inventory
760
from bzrlib.weavefile import write_weave_v5
761
from bzrlib.weave import Weave
762
763
# Create an empty inventory
764
sio = StringIO()
765
# if we want per-tree root ids then this is the place to set
766
# them; they're not needed for now and so ommitted for
767
# simplicity.
768
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
769
empty_inv = sio.getvalue()
770
sio = StringIO()
771
bzrlib.weavefile.write_weave_v5(Weave(), sio)
772
empty_weave = sio.getvalue()
773
774
dirs = [[], 'revision-store', 'weaves']
775
files = [('README',
776
"This is a Bazaar-NG control directory.\n"
777
"Do not change any files in this directory.\n"),
778
('branch-format', BZR_BRANCH_FORMAT_6),
779
('revision-history', ''),
780
('branch-name', ''),
781
('branch-lock', ''),
782
('pending-merges', ''),
783
('inventory', empty_inv),
784
('inventory.weave', empty_weave),
785
('ancestry.weave', empty_weave)
786
]
787
cfn = self._rel_controlfilename
788
self._transport.mkdir_multi([cfn(d) for d in dirs])
789
self.put_controlfiles(files)
790
mutter('created control directory in ' + self._transport.base)
791
792
def _check_format(self, relax_version_check):
793
"""Check this branch format is supported.
794
795
The format level is stored, as an integer, in
796
self._branch_format for code that needs to check it later.
797
798
In the future, we might need different in-memory Branch
799
classes to support downlevel branches. But not yet.
800
"""
801
try:
802
fmt = self.controlfile('branch-format', 'r').read()
803
except NoSuchFile:
804
raise NotBranchError(path=self.base)
805
mutter("got branch format %r", fmt)
806
if fmt == BZR_BRANCH_FORMAT_6:
807
self._branch_format = 6
808
elif fmt == BZR_BRANCH_FORMAT_5:
809
self._branch_format = 5
810
elif fmt == BZR_BRANCH_FORMAT_4:
811
self._branch_format = 4
812
813
if (not relax_version_check
814
and self._branch_format not in (5, 6)):
815
raise errors.UnsupportedFormatError(
816
'sorry, branch format %r not supported' % fmt,
817
['use a different bzr version',
818
'or remove the .bzr directory'
819
' and "bzr init" again'])
820
821
@needs_read_lock
822
def get_root_id(self):
823
"""See Branch.get_root_id."""
824
inv = self.get_inventory(self.last_revision())
825
return inv.root.file_id
826
827
@needs_read_lock
828
def print_file(self, file, revision_id):
829
"""See Branch.print_file."""
830
tree = self.revision_tree(revision_id)
831
# use inventory as it was in that revision
832
file_id = tree.inventory.path2id(file)
833
if not file_id:
834
try:
835
revno = self.revision_id_to_revno(revision_id)
836
except errors.NoSuchRevision:
837
# TODO: This should not be BzrError,
838
# but NoSuchFile doesn't fit either
839
raise BzrError('%r is not present in revision %s'
840
% (file, revision_id))
826
841
else:
827
bailout("wierd file state %r" % ((fs, fid),))
828
829
830
831
class ScratchBranch(Branch):
842
raise BzrError('%r is not present in revision %s'
843
% (file, revno))
844
tree.print_file(file_id)
845
846
@needs_write_lock
847
def append_revision(self, *revision_ids):
848
"""See Branch.append_revision."""
849
for revision_id in revision_ids:
850
mutter("add {%s} to revision-history" % revision_id)
851
rev_history = self.revision_history()
852
rev_history.extend(revision_ids)
853
self.set_revision_history(rev_history)
854
855
@needs_write_lock
856
def set_revision_history(self, rev_history):
857
"""See Branch.set_revision_history."""
858
old_revision = self.last_revision()
859
new_revision = rev_history[-1]
860
self.put_controlfile('revision-history', '\n'.join(rev_history))
861
try:
862
self.working_tree().set_last_revision(new_revision, old_revision)
863
except NoWorkingTree:
864
mutter('Unable to set_last_revision without a working tree.')
865
866
def has_revision(self, revision_id):
867
"""See Branch.has_revision."""
868
return (revision_id is None
869
or self.revision_store.has_id(revision_id))
870
871
@needs_read_lock
872
def _get_revision_xml_file(self, revision_id):
873
if not revision_id or not isinstance(revision_id, basestring):
874
raise InvalidRevisionId(revision_id=revision_id, branch=self)
875
try:
876
return self.revision_store.get(revision_id)
877
except (IndexError, KeyError):
878
raise bzrlib.errors.NoSuchRevision(self, revision_id)
879
880
def get_revision_xml(self, revision_id):
881
"""See Branch.get_revision_xml."""
882
return self._get_revision_xml_file(revision_id).read()
883
884
def get_revision(self, revision_id):
885
"""See Branch.get_revision."""
886
xml_file = self._get_revision_xml_file(revision_id)
887
888
try:
889
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
890
except SyntaxError, e:
891
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
892
[revision_id,
893
str(e)])
894
895
assert r.revision_id == revision_id
896
return r
897
898
def get_revision_sha1(self, revision_id):
899
"""See Branch.get_revision_sha1."""
900
# In the future, revision entries will be signed. At that
901
# point, it is probably best *not* to include the signature
902
# in the revision hash. Because that lets you re-sign
903
# the revision, (add signatures/remove signatures) and still
904
# have all hash pointers stay consistent.
905
# But for now, just hash the contents.
906
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
907
908
def get_ancestry(self, revision_id):
909
"""See Branch.get_ancestry."""
910
if revision_id is None:
911
return [None]
912
w = self._get_inventory_weave()
913
return [None] + map(w.idx_to_name,
914
w.inclusions([w.lookup(revision_id)]))
915
916
def _get_inventory_weave(self):
917
return self.control_weaves.get_weave('inventory',
918
self.get_transaction())
919
920
def get_inventory(self, revision_id):
921
"""See Branch.get_inventory."""
922
xml = self.get_inventory_xml(revision_id)
923
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
924
925
def get_inventory_xml(self, revision_id):
926
"""See Branch.get_inventory_xml."""
927
try:
928
assert isinstance(revision_id, basestring), type(revision_id)
929
iw = self._get_inventory_weave()
930
return iw.get_text(iw.lookup(revision_id))
931
except IndexError:
932
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
933
934
def get_inventory_sha1(self, revision_id):
935
"""See Branch.get_inventory_sha1."""
936
return self.get_revision(revision_id).inventory_sha1
937
938
def get_revision_inventory(self, revision_id):
939
"""See Branch.get_revision_inventory."""
940
# TODO: Unify this with get_inventory()
941
# bzr 0.0.6 and later imposes the constraint that the inventory_id
942
# must be the same as its revision, so this is trivial.
943
if revision_id == None:
944
# This does not make sense: if there is no revision,
945
# then it is the current tree inventory surely ?!
946
# and thus get_root_id() is something that looks at the last
947
# commit on the branch, and the get_root_id is an inventory check.
948
raise NotImplementedError
949
# return Inventory(self.get_root_id())
950
else:
951
return self.get_inventory(revision_id)
952
953
@needs_read_lock
954
def revision_history(self):
955
"""See Branch.revision_history."""
956
transaction = self.get_transaction()
957
history = transaction.map.find_revision_history()
958
if history is not None:
959
mutter("cache hit for revision-history in %s", self)
960
return list(history)
961
history = [l.rstrip('\r\n') for l in
962
self.controlfile('revision-history', 'r').readlines()]
963
transaction.map.add_revision_history(history)
964
# this call is disabled because revision_history is
965
# not really an object yet, and the transaction is for objects.
966
# transaction.register_clean(history, precious=True)
967
return list(history)
968
969
def update_revisions(self, other, stop_revision=None):
970
"""See Branch.update_revisions."""
971
from bzrlib.fetch import greedy_fetch
972
if stop_revision is None:
973
stop_revision = other.last_revision()
974
### Should this be checking is_ancestor instead of revision_history?
975
if (stop_revision is not None and
976
stop_revision in self.revision_history()):
977
return
978
greedy_fetch(to_branch=self, from_branch=other,
979
revision=stop_revision)
980
pullable_revs = self.pullable_revisions(other, stop_revision)
981
if len(pullable_revs) > 0:
982
self.append_revision(*pullable_revs)
983
984
def pullable_revisions(self, other, stop_revision):
985
"""See Branch.pullable_revisions."""
986
other_revno = other.revision_id_to_revno(stop_revision)
987
try:
988
return self.missing_revisions(other, other_revno)
989
except DivergedBranches, e:
990
try:
991
pullable_revs = get_intervening_revisions(self.last_revision(),
992
stop_revision, self)
993
assert self.last_revision() not in pullable_revs
994
return pullable_revs
995
except bzrlib.errors.NotAncestor:
996
if is_ancestor(self.last_revision(), stop_revision, self):
997
return []
998
else:
999
raise e
1000
1001
def revision_tree(self, revision_id):
1002
"""See Branch.revision_tree."""
1003
# TODO: refactor this to use an existing revision object
1004
# so we don't need to read it in twice.
1005
if revision_id == None or revision_id == NULL_REVISION:
1006
return EmptyTree()
1007
else:
1008
inv = self.get_revision_inventory(revision_id)
1009
return RevisionTree(self.weave_store, inv, revision_id)
1010
1011
def basis_tree(self):
1012
"""See Branch.basis_tree."""
1013
try:
1014
revision_id = self.revision_history()[-1]
1015
xml = self.working_tree().read_basis_inventory(revision_id)
1016
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
1017
return RevisionTree(self.weave_store, inv, revision_id)
1018
except (IndexError, NoSuchFile, NoWorkingTree), e:
1019
return self.revision_tree(self.last_revision())
1020
1021
def working_tree(self):
1022
"""See Branch.working_tree."""
1023
from bzrlib.workingtree import WorkingTree
1024
if self._transport.base.find('://') != -1:
1025
raise NoWorkingTree(self.base)
1026
return WorkingTree(self.base, branch=self)
1027
1028
@needs_write_lock
1029
def pull(self, source, overwrite=False):
1030
"""See Branch.pull."""
1031
source.lock_read()
1032
try:
1033
old_count = len(self.revision_history())
1034
try:
1035
self.update_revisions(source)
1036
except DivergedBranches:
1037
if not overwrite:
1038
raise
1039
if overwrite:
1040
self.set_revision_history(source.revision_history())
1041
new_count = len(self.revision_history())
1042
return new_count - old_count
1043
finally:
1044
source.unlock()
1045
1046
def get_parent(self):
1047
"""See Branch.get_parent."""
1048
import errno
1049
_locs = ['parent', 'pull', 'x-pull']
1050
for l in _locs:
1051
try:
1052
return self.controlfile(l, 'r').read().strip('\n')
1053
except NoSuchFile:
1054
pass
1055
return None
1056
1057
def get_push_location(self):
1058
"""See Branch.get_push_location."""
1059
config = bzrlib.config.BranchConfig(self)
1060
push_loc = config.get_user_option('push_location')
1061
return push_loc
1062
1063
def set_push_location(self, location):
1064
"""See Branch.set_push_location."""
1065
config = bzrlib.config.LocationConfig(self.base)
1066
config.set_user_option('push_location', location)
1067
1068
@needs_write_lock
1069
def set_parent(self, url):
1070
"""See Branch.set_parent."""
1071
# TODO: Maybe delete old location files?
1072
from bzrlib.atomicfile import AtomicFile
1073
f = AtomicFile(self.controlfilename('parent'))
1074
try:
1075
f.write(url + '\n')
1076
f.commit()
1077
finally:
1078
f.close()
1079
1080
def tree_config(self):
1081
return TreeConfig(self)
1082
1083
def sign_revision(self, revision_id, gpg_strategy):
1084
"""See Branch.sign_revision."""
1085
plaintext = Testament.from_revision(self, revision_id).as_short_text()
1086
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1087
1088
@needs_write_lock
1089
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1090
"""See Branch.store_revision_signature."""
1091
self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)),
1092
revision_id, "sig")
1093
1094
1095
class ScratchBranch(BzrBranch):
832
1096
"""Special test class: a branch that cleans up after itself.
833
1097
834
1098
>>> b = ScratchBranch()
835
1099
>>> isdir(b.base)
836
1100
True
837
1101
>>> bd = b.base
838
>>> del b
1102
>>> b._transport.__del__()
839
1103
>>> isdir(bd)
840
1104
False
841
1105
"""
842
def __init__(self, files=[], dirs=[]):
1106
1107
def __init__(self, files=[], dirs=[], transport=None):
843
1108
"""Make a test branch.
844
1109
845
1110
This creates a temporary directory and runs init-tree in it.
846
1111
847
1112
If any files are listed, they are created in the working copy.
848
1113
"""
849
Branch.__init__(self, tempfile.mkdtemp(), init=True)
1114
if transport is None:
1115
transport = bzrlib.transport.local.ScratchTransport()
1116
super(ScratchBranch, self).__init__(transport, init=True)
1117
else:
1118
super(ScratchBranch, self).__init__(transport)
1119
850
1120
for d in dirs:
851
os.mkdir(self.abspath(d))
1121
self._transport.mkdir(d)
852
1122
853
1123
for f in files:
854
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
855
856
857
def __del__(self):
858
"""Destroy the test branch, removing the scratch directory."""
859
try:
860
shutil.rmtree(self.base)
861
except OSError:
862
# Work around for shutil.rmtree failing on Windows when
863
# readonly files are encountered
864
for root, dirs, files in os.walk(self.base, topdown=False):
865
for name in files:
866
os.chmod(os.path.join(root, name), 0700)
867
shutil.rmtree(self.base)
868
1124
self._transport.put(f, 'content of %s' % f)
1125
1126
1127
def clone(self):
1128
"""
1129
>>> orig = ScratchBranch(files=["file1", "file2"])
1130
>>> clone = orig.clone()
1131
>>> if os.name != 'nt':
1132
... os.path.samefile(orig.base, clone.base)
1133
... else:
1134
... orig.base == clone.base
1135
...
1136
False
1137
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1138
True
1139
"""
1140
from shutil import copytree
1141
from tempfile import mkdtemp
1142
base = mkdtemp()
1143
os.rmdir(base)
1144
copytree(self.base, base, symlinks=True)
1145
return ScratchBranch(
1146
transport=bzrlib.transport.local.ScratchTransport(base))
869
1147
870
1148
871
1149
######################################################################
884
1162
break
885
1163
filename = head
886
1164
return False
887
888
889
890
def _gen_revision_id(when):
891
"""Return new revision-id."""
892
s = '%s-%s-' % (user_email(), compact_date(when))
893
s += hexlify(rand_bytes(8))
894
return s
895
896
897
def gen_file_id(name):
898
"""Return new file id.
899
900
This should probably generate proper UUIDs, but for the moment we
901
cope with just randomness because running uuidgen every time is
902
slow."""
903
idx = name.rfind('/')
904
if idx != -1:
905
name = name[idx+1 : ]
906
907
name = name.lstrip('.')
908
909
s = hexlify(rand_bytes(8))
910
return '-'.join((name, compact_date(time.time()), s))
911
912
Loggerhead is a web-based interface for Breezy
Version: 2.0.1