« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1440
- compare with another revision
- download diff
- download tarball
- view history from revision 1440
- Committer: Robert Collins
- Date: 2005-10-11 03:19:29 UTC
- Revision ID: robertc@robertcollins.net-20051011031929-2d523107133c43be
further tuning of pull, do not do a local merge or fetch at all, if the remote branch is no newer than we are
- files added:
- bzrlib/mdiff.py
- files removed:
- BRANCH.TODO
- bzrlib/export
- bzrlib/tests/blackbox
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- files renamed:
- bzr_man.py => bzr-man.py
- bzrlib/conflicts.py => bzrlib/plugins/conflicts.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/blackbox/test_revision_info.py => bzrlib/selftest/test_revision_info.py
- bzrlib/tests/test_branch_implementations.py => bzrlib/selftest/testbranch.py
- bzrlib/tests/test_diff.py => bzrlib/selftest/testdiff.py
- bzrlib/tests/test_fetch.py => bzrlib/selftest/testfetch.py
- bzrlib/tests/test_graph.py => bzrlib/selftest/testgraph.py
- bzrlib/tests/test_hashcache.py => bzrlib/selftest/testhashcache.py
- bzrlib/tests/test_identitymap.py => bzrlib/selftest/testidentitymap.py
- bzrlib/tests/test_inv.py => bzrlib/selftest/testinv.py
- bzrlib/tests/test_log.py => bzrlib/selftest/testlog.py
- bzrlib/tests/test_merge.py => bzrlib/selftest/testmerge.py
- bzrlib/tests/test_merge3.py => bzrlib/selftest/testmerge3.py
- bzrlib/tests/test_revision.py => bzrlib/selftest/testrevision.py
- bzrlib/tests/test_revisionnamespaces.py => bzrlib/selftest/testrevisionnamespaces.py
- bzrlib/tests/test_sampler.py => bzrlib/selftest/testsampler.py
- bzrlib/tests/test_status.py => bzrlib/selftest/teststatus.py
- bzrlib/tests/test_store.py => bzrlib/selftest/teststore.py
- bzrlib/tests/test_transactions.py => bzrlib/selftest/testtransactions.py
- bzrlib/tests/test_transport.py => bzrlib/selftest/testtransport.py
- bzrlib/tests/test_workingtree.py => bzrlib/selftest/testworkingtree.py
- bzrlib/tests/blackbox/test_versioning.py => bzrlib/selftest/versioning.py
- bzrlib/tests/test_whitebox.py => bzrlib/selftest/whitebox.py
- bzrlib/ui/__init__.py => bzrlib/ui.py
- files modified:
- .bzrignore
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
18
import sys
19
import os
20
20
import errno
21
import os
22
import shutil
23
import sys
24
from unittest import TestSuite
25
21
from warnings import warn
22
from cStringIO import StringIO
26
23
27
24
28
25
import bzrlib
29
from bzrlib.config import TreeConfig
30
from bzrlib.delta import compare_trees
26
from bzrlib.inventory import InventoryEntry
27
import bzrlib.inventory as inventory
28
from bzrlib.trace import mutter, note
29
from bzrlib.osutils import (isdir, quotefn, compact_date, rand_bytes,
30
rename, splitpath, sha_file, appendpath,
31
file_kind)
31
32
import bzrlib.errors as errors
32
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
33
34
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
)
35
DivergedBranches, LockError, UnlistableStore,
36
UnlistableBranch, NoSuchFile)
46
37
from bzrlib.textui import show_status
47
from bzrlib.trace import mutter, note
38
from bzrlib.revision import Revision
39
from bzrlib.delta import compare_trees
48
40
from bzrlib.tree import EmptyTree, RevisionTree
49
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions,
50
NULL_REVISION)
41
from bzrlib.inventory import Inventory
51
42
from bzrlib.store import copy_all
43
from bzrlib.store.compressed_text import CompressedTextStore
52
44
from bzrlib.store.text import TextStore
53
45
from bzrlib.store.weave import WeaveStore
54
from bzrlib.symbol_versioning import deprecated_nonce, deprecated_passed
55
from bzrlib.testament import Testament
56
46
import bzrlib.transactions as transactions
57
47
from bzrlib.transport import Transport, get_transport
58
48
import bzrlib.xml5
74
64
# XXX: leave this here for about one release, then remove it
75
65
raise NotImplementedError('find_branch() is not supported anymore, '
76
66
'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
67
def _relpath(base, path):
68
"""Return path relative to base, or raise exception.
69
70
The path may be either an absolute path or a path relative to the
71
current working directory.
72
73
Lifted out of Branch.relpath for ease of testing.
74
75
os.path.commonprefix (python2.4) has a bad bug that it works just
76
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
77
avoids that problem."""
78
rp = os.path.abspath(path)
79
80
s = []
81
head = rp
82
while len(head) >= len(base):
83
if head == base:
84
break
85
head, tail = os.path.split(head)
86
if tail:
87
s.insert(0, tail)
88
else:
89
raise NotBranchError("path %r is not within branch %r" % (rp, base))
90
91
return os.sep.join(s)
92
93
94
def find_branch_root(t):
95
"""Find the branch root enclosing the transport's base.
96
97
t is a Transport object.
98
99
It is not necessary that the base of t exists.
100
101
Basically we keep looking up until we find the control directory or
102
run into the root. If there isn't one, raises NotBranchError.
103
"""
104
orig_base = t.base
105
while True:
106
if t.has(bzrlib.BZRDIR):
107
return t
108
new_t = t.clone('..')
109
if new_t.base == t.base:
110
# reached the root, whatever that may be
111
raise NotBranchError('%s is not in a branch' % orig_base)
112
t = new_t
113
99
114
100
115
######################################################################
101
116
# branch objects
106
121
base
107
122
Base directory/url of the branch.
108
123
"""
109
# this is really an instance variable - FIXME move it there
110
# - RBC 20060112
111
124
base = None
112
125
113
_default_initializer = None
114
"""The default initializer for making new branches."""
115
116
126
def __init__(self, *ignored, **ignored_too):
117
127
raise NotImplementedError('The Branch class is abstract')
118
128
119
129
@staticmethod
120
130
def open_downlevel(base):
121
"""Open a branch which may be of an old format."""
122
return Branch.open(base, _unsupported=True)
131
"""Open a branch which may be of an old format.
132
133
Only local branches are supported."""
134
return _Branch(get_transport(base), relax_version_check=True)
123
135
124
136
@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
"""
137
def open(base):
138
"""Open an existing branch, rooted at 'base' (url)"""
130
139
t = get_transport(base)
131
140
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
return _Branch(t)
141
142
142
143
@staticmethod
143
144
def open_containing(url):
144
145
"""Open an existing branch which contains url.
145
146
146
147
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
148
"""
152
149
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
150
t = find_branch_root(t)
151
return _Branch(t)
167
152
168
153
@staticmethod
169
154
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)
155
"""Create a new branch, rooted at 'base' (url)"""
156
t = get_transport(base)
157
return _Branch(t, init=True)
186
158
187
159
def setup_caching(self, cache_root):
188
160
"""Subclasses that care about caching should override this, and set
190
162
"""
191
163
self.cache_root = cache_root
192
164
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')
215
216
def lock_write(self):
217
raise NotImplementedError('lock_write is abstract')
218
219
def lock_read(self):
220
raise NotImplementedError('lock_read is abstract')
221
222
def unlock(self):
223
raise NotImplementedError('unlock is abstract')
224
225
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')
232
233
def controlfilename(self, file_or_path):
234
"""Return location relative to branch."""
235
raise NotImplementedError('controlfilename is abstract')
236
237
def controlfile(self, file_or_path, mode='r'):
238
"""Open a control file for this branch.
239
240
There are two classes of file in the control directory: text
241
and binary. binary files are untranslated byte streams. Text
242
control files are stored with Unix newlines and in UTF-8, even
243
if the platform or locale defaults are different.
244
245
Controlfiles should almost never be opened in write mode but
246
rather should be atomically copied and replaced using atomicfile.
247
"""
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')
268
269
def get_root_id(self):
270
"""Return the id of this branches root"""
271
raise NotImplementedError('get_root_id is abstract')
272
273
def set_root_id(self, file_id):
274
raise NotImplementedError('set_root_id is abstract')
275
276
def print_file(self, file, revision_id):
277
"""Print `file` to stdout."""
278
raise NotImplementedError('print_file is abstract')
279
280
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')
292
293
def get_revision_xml(self, revision_id):
294
raise NotImplementedError('get_revision_xml is abstract')
295
296
def get_revision(self, revision_id):
297
"""Return the Revision object for a named revision"""
298
raise NotImplementedError('get_revision is abstract')
299
300
def get_revision_delta(self, revno):
301
"""Return the delta for one revision.
302
303
The delta is relative to its mainline predecessor, or the
304
empty tree for revision 1.
305
"""
306
assert isinstance(revno, int)
307
rh = self.revision_history()
308
if not (1 <= revno <= len(rh)):
309
raise InvalidRevisionNumber(revno)
310
311
# revno is 1-based; list is 0-based
312
313
new_tree = self.revision_tree(rh[revno-1])
314
if revno == 1:
315
old_tree = EmptyTree()
316
else:
317
old_tree = self.revision_tree(rh[revno-2])
318
319
return compare_trees(old_tree, new_tree)
320
321
def get_revision_sha1(self, revision_id):
322
"""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.
330
"""
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')
344
345
def get_revision_inventory(self, revision_id):
346
"""Return inventory of a past revision."""
347
raise NotImplementedError('get_revision_inventory is abstract')
348
349
def revision_history(self):
350
"""Return sequence of revision hashes on to this branch."""
351
raise NotImplementedError('revision_history is abstract')
352
353
def revno(self):
354
"""Return current revision number for this branch.
355
356
That is equivalent to the number of revisions committed to
357
this branch.
358
"""
359
return len(self.revision_history())
360
361
def last_revision(self):
362
"""Return last patch hash, or None if no history."""
363
ph = self.revision_history()
364
if ph:
365
return ph[-1]
366
else:
367
return None
368
369
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
370
"""Return a list of new revisions that would perfectly fit.
371
372
If self and other have not diverged, return a list of the revisions
373
present in other, but missing from self.
374
375
>>> from bzrlib.commit import commit
376
>>> bzrlib.trace.silent = True
377
>>> br1 = ScratchBranch()
378
>>> br2 = ScratchBranch()
379
>>> br1.missing_revisions(br2)
380
[]
381
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
382
>>> br1.missing_revisions(br2)
383
[u'REVISION-ID-1']
384
>>> br2.missing_revisions(br1)
385
[]
386
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
387
>>> br1.missing_revisions(br2)
388
[]
389
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
390
>>> br1.missing_revisions(br2)
391
[u'REVISION-ID-2A']
392
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
393
>>> br1.missing_revisions(br2)
394
Traceback (most recent call last):
395
DivergedBranches: These branches have diverged. Try merge.
396
"""
397
self_history = self.revision_history()
398
self_len = len(self_history)
399
other_history = other.revision_history()
400
other_len = len(other_history)
401
common_index = min(self_len, other_len) -1
402
if common_index >= 0 and \
403
self_history[common_index] != other_history[common_index]:
404
raise DivergedBranches(self, other)
405
406
if stop_revision is None:
407
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)
412
return other_history[self_len:stop_revision]
413
414
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]
440
441
def revision_tree(self, revision_id):
442
"""Return Tree for a revision on this branch.
443
444
`revision_id` may be None for the null revision, in which case
445
an `EmptyTree` is returned."""
446
raise NotImplementedError('revision_tree is abstract')
447
448
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')
451
452
def pull(self, source, overwrite=False):
453
raise NotImplementedError('pull is abstract')
454
455
def basis_tree(self):
456
"""Return `Tree` object for last revision.
457
458
If there are no revisions yet, return an `EmptyTree`.
459
"""
460
return self.revision_tree(self.last_revision())
461
462
def rename_one(self, from_rel, to_rel):
463
"""Rename one file.
464
465
This can change the directory or the filename or both.
466
"""
467
raise NotImplementedError('rename_one is abstract')
468
469
def move(self, from_paths, to_name):
470
"""Rename files.
471
472
to_name must exist as a versioned directory.
473
474
If to_name exists and is a directory, the files are moved into
475
it, keeping their old names. If it is a directory,
476
477
Note that to_name is only the last component of the new name;
478
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):
165
166
class _Branch(Branch):
715
167
"""A branch stored in the actual filesystem.
716
168
717
169
Note that it's "local" in the context of the filesystem; it doesn't
736
188
_lock_count = None
737
189
_lock = None
738
190
_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
191
744
192
# Map some sort of prefix into a namespace
745
193
# stuff like "revno:10", "revid:", etc.
747
195
REVISION_NAMESPACES = {}
748
196
749
197
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):
198
"""Copy the content of this branches store to branch_to."""
199
if (self._branch_format != branch_to._branch_format
200
or self._branch_format != 4):
753
201
from bzrlib.fetch import greedy_fetch
754
mutter("Using fetch logic to push between %s(%s) and %s(%s)",
202
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
755
203
self, self._branch_format, branch_to, branch_to._branch_format)
756
204
greedy_fetch(to_branch=branch_to, from_branch=self,
757
205
revision=self.last_revision())
758
206
return
759
207
760
# format 4 to format 4 logic only.
761
208
store_pairs = ((self.text_store, branch_to.text_store),
762
209
(self.inventory_store, branch_to.inventory_store),
763
210
(self.revision_store, branch_to.revision_store))
767
214
except UnlistableStore:
768
215
raise UnlistableBranch(from_store)
769
216
770
def __init__(self, transport, init=deprecated_nonce,
771
relax_version_check=deprecated_nonce, format=None):
217
def __init__(self, transport, init=False,
218
relax_version_check=False):
772
219
"""Create new branch object at a particular location.
773
220
774
221
transport -- A Transport object, defining how to access files.
222
(If a string, transport.transport() will be used to
223
create a Transport object)
775
224
776
225
init -- If True, create new control files in a previously
777
226
unversioned directory. If False, the branch must already
788
237
assert isinstance(transport, Transport), \
789
238
"%r is not a Transport" % transport
790
239
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'])
240
if init:
241
self._make_control()
242
self._check_format(relax_version_check)
813
243
814
244
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)
245
# FIXME: This approach of assuming stores are all entirely compressed
246
# or entirely uncompressed is tidy, but breaks upgrade from
247
# some existing branches where there's a mixture; we probably
248
# still want the option to look for both.
249
relpath = self._rel_controlfilename(name)
250
if compressed:
251
store = CompressedTextStore(self._transport.clone(relpath),
252
prefixed=prefixed)
253
else:
254
store = TextStore(self._transport.clone(relpath),
255
prefixed=prefixed)
256
#if self._transport.should_cache():
257
# cache_path = os.path.join(self.cache_root, name)
258
# os.mkdir(cache_path)
259
# store = bzrlib.store.CachedStore(store, cache_path)
821
260
return store
822
823
261
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)
262
relpath = self._rel_controlfilename(name)
263
ws = WeaveStore(self._transport.clone(relpath), prefixed=prefixed)
829
264
if self._transport.should_cache():
830
265
ws.enable_cache = True
831
266
return ws
832
267
833
if isinstance(self._branch_format, BzrBranchFormat4):
268
if self._branch_format == 4:
834
269
self.inventory_store = get_store('inventory-store')
835
270
self.text_store = get_store('text-store')
836
271
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,
272
elif self._branch_format == 5:
273
self.control_weaves = get_weave([])
274
self.weave_store = get_weave('weaves')
275
self.revision_store = get_store('revision-store', compressed=False)
276
elif self._branch_format == 6:
277
self.control_weaves = get_weave([])
278
self.weave_store = get_weave('weaves', prefixed=True)
279
self.revision_store = get_store('revision-store', compressed=False,
845
280
prefixed=True)
846
self.revision_store.register_suffix('sig')
847
281
self._transaction = None
848
282
849
@staticmethod
850
def _initialize(base):
851
"""Create a bzr branch in the latest format."""
852
return BzrBranchFormat6().initialize(base)
853
854
283
def __str__(self):
855
284
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
856
285
286
857
287
__repr__ = __str__
858
288
289
859
290
def __del__(self):
860
291
if self._lock_mode or self._lock:
861
292
# XXX: This should show something every time, and be suitable for
871
302
# should never expect their __del__ function to run.
872
303
if hasattr(self, 'cache_root') and self.cache_root is not None:
873
304
try:
305
import shutil
874
306
shutil.rmtree(self.cache_root)
875
307
except:
876
308
pass
881
313
return self._transport.base
882
314
return None
883
315
884
base = property(_get_base, doc="The URL for the root of this branch.")
316
base = property(_get_base)
885
317
886
318
def _finish_transaction(self):
887
319
"""Exit the current transaction."""
893
325
transaction.finish()
894
326
895
327
def get_transaction(self):
896
"""See Branch.get_transaction."""
328
"""Return the current active transaction.
329
330
If no transaction is active, this returns a passthrough object
331
for which all data is immedaitely flushed and no caching happens.
332
"""
897
333
if self._transaction is None:
898
334
return transactions.PassThroughTransaction()
899
335
else:
907
343
self._transaction = new_transaction
908
344
909
345
def lock_write(self):
910
#mutter("lock write: %s (%s)", self, self._lock_count)
346
mutter("lock write: %s (%s)", self, self._lock_count)
911
347
# TODO: Upgrade locking to support using a Transport,
912
348
# and potentially a remote locking protocol
913
349
if self._lock_mode:
923
359
self._set_transaction(transactions.PassThroughTransaction())
924
360
925
361
def lock_read(self):
926
#mutter("lock read: %s (%s)", self, self._lock_count)
362
mutter("lock read: %s (%s)", self, self._lock_count)
927
363
if self._lock_mode:
928
364
assert self._lock_mode in ('r', 'w'), \
929
365
"invalid lock mode %r" % self._lock_mode
938
374
self.get_transaction().set_cache_size(5000)
939
375
940
376
def unlock(self):
941
#mutter("unlock: %s (%s)", self, self._lock_count)
377
mutter("unlock: %s (%s)", self, self._lock_count)
942
378
if not self._lock_mode:
943
379
raise LockError('branch %r is not locked' % (self))
944
380
951
387
self._lock_mode = self._lock_count = None
952
388
953
389
def abspath(self, name):
954
"""See Branch.abspath."""
390
"""Return absolute filename for something in the branch"""
955
391
return self._transport.abspath(name)
956
392
393
def relpath(self, path):
394
"""Return path relative to this branch of something inside it.
395
396
Raises an error if path is not in this branch."""
397
return self._transport.relpath(path)
398
399
957
400
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)
401
if isinstance(file_or_path, basestring):
402
file_or_path = [file_or_path]
403
return [bzrlib.BZRDIR] + file_or_path
963
404
964
405
def controlfilename(self, file_or_path):
965
"""See Branch.controlfilename."""
406
"""Return location relative to branch."""
966
407
return self._transport.abspath(self._rel_controlfilename(file_or_path))
967
408
409
968
410
def controlfile(self, file_or_path, mode='r'):
969
"""See Branch.controlfile."""
411
"""Open a control file for this branch.
412
413
There are two classes of file in the control directory: text
414
and binary. binary files are untranslated byte streams. Text
415
control files are stored with Unix newlines and in UTF-8, even
416
if the platform or locale defaults are different.
417
418
Controlfiles should almost never be opened in write mode but
419
rather should be atomically copied and replaced using atomicfile.
420
"""
970
421
import codecs
971
422
972
423
relpath = self._rel_controlfilename(file_or_path)
977
428
elif mode == 'wb':
978
429
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
979
430
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
431
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
985
432
elif mode == 'w':
986
433
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
988
435
raise BzrError("invalid controlfile mode %r" % mode)
989
436
990
437
def put_controlfile(self, path, f, encode=True):
991
"""See Branch.put_controlfile."""
438
"""Write an entry as a controlfile.
439
440
:param path: The path to put the file, relative to the .bzr control
441
directory
442
:param f: A file-like or string object whose contents should be copied.
443
:param encode: If true, encode the contents as utf-8
444
"""
992
445
self.put_controlfiles([(path, f)], encode=encode)
993
446
994
447
def put_controlfiles(self, files, encode=True):
995
"""See Branch.put_controlfiles."""
448
"""Write several entries as controlfiles.
449
450
:param files: A list of [(path, file)] pairs, where the path is the directory
451
underneath the bzr control directory
452
:param encode: If true, encode the contents as utf-8
453
"""
996
454
import codecs
997
455
ctrl_files = []
998
456
for path, f in files:
1003
461
f = codecs.getwriter('utf-8')(f, errors='replace')
1004
462
path = self._rel_controlfilename(path)
1005
463
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
464
self._transport.put_multi(ctrl_files)
465
466
def _make_control(self):
467
from bzrlib.inventory import Inventory
468
from bzrlib.weavefile import write_weave_v5
469
from bzrlib.weave import Weave
470
471
# Create an empty inventory
472
sio = StringIO()
473
# if we want per-tree root ids then this is the place to set
474
# them; they're not needed for now and so ommitted for
475
# simplicity.
476
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
477
empty_inv = sio.getvalue()
478
sio = StringIO()
479
bzrlib.weavefile.write_weave_v5(Weave(), sio)
480
empty_weave = sio.getvalue()
481
482
dirs = [[], 'revision-store', 'weaves']
483
files = [('README',
484
"This is a Bazaar-NG control directory.\n"
485
"Do not change any files in this directory.\n"),
486
('branch-format', BZR_BRANCH_FORMAT_6),
487
('revision-history', ''),
488
('branch-name', ''),
489
('branch-lock', ''),
490
('pending-merges', ''),
491
('inventory', empty_inv),
492
('inventory.weave', empty_weave),
493
('ancestry.weave', empty_weave)
494
]
495
cfn = self._rel_controlfilename
496
self._transport.mkdir_multi([cfn(d) for d in dirs])
497
self.put_controlfiles(files)
498
mutter('created control directory in ' + self._transport.base)
499
500
def _check_format(self, relax_version_check):
501
"""Check this branch format is supported.
502
503
The format level is stored, as an integer, in
1030
504
self._branch_format for code that needs to check it later.
1031
505
1032
The format parameter is either None or the branch format class
1033
used to open this branch.
506
In the future, we might need different in-memory Branch
507
classes to support downlevel branches. But not yet.
1034
508
"""
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
509
try:
510
fmt = self.controlfile('branch-format', 'r').read()
511
except NoSuchFile:
512
raise NotBranchError(self.base)
513
mutter("got branch format %r", fmt)
514
if fmt == BZR_BRANCH_FORMAT_6:
515
self._branch_format = 6
516
elif fmt == BZR_BRANCH_FORMAT_5:
517
self._branch_format = 5
518
elif fmt == BZR_BRANCH_FORMAT_4:
519
self._branch_format = 4
520
521
if (not relax_version_check
522
and self._branch_format not in (5, 6)):
523
raise errors.UnsupportedFormatError(
524
'sorry, branch format %r not supported' % fmt,
525
['use a different bzr version',
526
'or remove the .bzr directory'
527
' and "bzr init" again'])
528
1041
529
def get_root_id(self):
1042
"""See Branch.get_root_id."""
1043
inv = self.get_inventory(self.last_revision())
530
"""Return the id of this branches root"""
531
inv = self.read_working_inventory()
1044
532
return inv.root.file_id
1045
533
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))
534
def set_root_id(self, file_id):
535
inv = self.read_working_inventory()
536
orig_root_id = inv.root.file_id
537
del inv._byid[inv.root.file_id]
538
inv.root.file_id = file_id
539
inv._byid[inv.root.file_id] = inv.root
540
for fid in inv:
541
entry = inv[fid]
542
if entry.parent_id in (None, orig_root_id):
543
entry.parent_id = inv.root.file_id
544
self._write_inventory(inv)
545
546
def read_working_inventory(self):
547
"""Read the working inventory."""
548
self.lock_read()
549
try:
550
# ElementTree does its own conversion from UTF-8, so open in
551
# binary.
552
f = self.controlfile('inventory', 'rb')
553
return bzrlib.xml5.serializer_v5.read_inventory(f)
554
finally:
555
self.unlock()
556
557
558
def _write_inventory(self, inv):
559
"""Update the working inventory.
560
561
That is to say, the inventory describing changes underway, that
562
will be committed to the next revision.
563
"""
564
from cStringIO import StringIO
565
self.lock_write()
566
try:
567
sio = StringIO()
568
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
569
sio.seek(0)
570
# Transport handles atomicity
571
self.put_controlfile('inventory', sio)
572
finally:
573
self.unlock()
574
575
mutter('wrote working inventory')
576
577
inventory = property(read_working_inventory, _write_inventory, None,
578
"""Inventory for the working copy.""")
579
580
def add(self, files, ids=None):
581
"""Make files versioned.
582
583
Note that the command line normally calls smart_add instead,
584
which can automatically recurse.
585
586
This puts the files in the Added state, so that they will be
587
recorded by the next commit.
588
589
files
590
List of paths to add, relative to the base of the tree.
591
592
ids
593
If set, use these instead of automatically generated ids.
594
Must be the same length as the list of files, but may
595
contain None for ids that are to be autogenerated.
596
597
TODO: Perhaps have an option to add the ids even if the files do
598
not (yet) exist.
599
600
TODO: Perhaps yield the ids and paths as they're added.
601
"""
602
# TODO: Re-adding a file that is removed in the working copy
603
# should probably put it back with the previous ID.
604
if isinstance(files, basestring):
605
assert(ids is None or isinstance(ids, basestring))
606
files = [files]
607
if ids is not None:
608
ids = [ids]
609
610
if ids is None:
611
ids = [None] * len(files)
612
else:
613
assert(len(ids) == len(files))
614
615
self.lock_write()
616
try:
617
inv = self.read_working_inventory()
618
for f,file_id in zip(files, ids):
619
if is_control_file(f):
620
raise BzrError("cannot add control file %s" % quotefn(f))
621
622
fp = splitpath(f)
623
624
if len(fp) == 0:
625
raise BzrError("cannot add top-level %r" % f)
626
627
fullpath = os.path.normpath(self.abspath(f))
628
629
try:
630
kind = file_kind(fullpath)
631
except OSError:
632
# maybe something better?
633
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
634
635
if not InventoryEntry.versionable_kind(kind):
636
raise BzrError('cannot add: not a versionable file ('
637
'i.e. regular file, symlink or directory): %s' % quotefn(f))
638
639
if file_id is None:
640
file_id = gen_file_id(f)
641
inv.add_path(f, kind=kind, file_id=file_id)
642
643
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
644
645
self._write_inventory(inv)
646
finally:
647
self.unlock()
648
649
650
def print_file(self, file, revno):
651
"""Print `file` to stdout."""
652
self.lock_read()
653
try:
654
tree = self.revision_tree(self.get_rev_id(revno))
655
# use inventory as it was in that revision
656
file_id = tree.inventory.path2id(file)
657
if not file_id:
658
raise BzrError("%r is not present in revision %s" % (file, revno))
659
tree.print_file(file_id)
660
finally:
661
self.unlock()
662
663
664
def remove(self, files, verbose=False):
665
"""Mark nominated files for removal from the inventory.
666
667
This does not remove their text. This does not run on
668
669
TODO: Refuse to remove modified files unless --force is given?
670
671
TODO: Do something useful with directories.
672
673
TODO: Should this remove the text or not? Tough call; not
674
removing may be useful and the user can just use use rm, and
675
is the opposite of add. Removing it is consistent with most
676
other tools. Maybe an option.
677
"""
678
## TODO: Normalize names
679
## TODO: Remove nested loops; better scalability
680
if isinstance(files, basestring):
681
files = [files]
682
683
self.lock_write()
684
685
try:
686
tree = self.working_tree()
687
inv = tree.inventory
688
689
# do this before any modifications
690
for f in files:
691
fid = inv.path2id(f)
692
if not fid:
693
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
694
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
695
if verbose:
696
# having remove it, it must be either ignored or unknown
697
if tree.is_ignored(f):
698
new_status = 'I'
699
else:
700
new_status = '?'
701
show_status(new_status, inv[fid].kind, quotefn(f))
702
del inv[fid]
703
704
self._write_inventory(inv)
705
finally:
706
self.unlock()
707
708
# FIXME: this doesn't need to be a branch method
709
def set_inventory(self, new_inventory_list):
710
from bzrlib.inventory import Inventory, InventoryEntry
711
inv = Inventory(self.get_root_id())
712
for path, file_id, parent, kind in new_inventory_list:
713
name = os.path.basename(path)
714
if name == "":
715
continue
716
# fixme, there should be a factory function inv,add_??
717
if kind == 'directory':
718
inv.add(inventory.InventoryDirectory(file_id, name, parent))
719
elif kind == 'file':
720
inv.add(inventory.InventoryFile(file_id, name, parent))
721
elif kind == 'symlink':
722
inv.add(inventory.InventoryLink(file_id, name, parent))
1060
723
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
724
raise BzrError("unknown kind %r" % kind)
725
self._write_inventory(inv)
726
727
def unknowns(self):
728
"""Return all unknown files.
729
730
These are files in the working directory that are not versioned or
731
control files or ignored.
732
733
>>> b = ScratchBranch(files=['foo', 'foo~'])
734
>>> list(b.unknowns())
735
['foo']
736
>>> b.add('foo')
737
>>> list(b.unknowns())
738
[]
739
>>> b.remove('foo')
740
>>> list(b.unknowns())
741
['foo']
742
"""
743
return self.working_tree().unknowns()
744
745
1066
746
def append_revision(self, *revision_ids):
1067
"""See Branch.append_revision."""
1068
747
for revision_id in revision_ids:
1069
748
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))
749
self.lock_write()
1080
750
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.')
751
rev_history = self.revision_history()
752
rev_history.extend(revision_ids)
753
self.put_controlfile('revision-history', '\n'.join(rev_history))
754
finally:
755
self.unlock()
1084
756
1085
757
def has_revision(self, revision_id):
1086
"""See Branch.has_revision."""
758
"""True if this branch has a copy of the revision.
759
760
This does not necessarily imply the revision is merge
761
or on the mainline."""
1087
762
return (revision_id is None
1088
or self.revision_store.has_id(revision_id))
763
or revision_id in self.revision_store)
1089
764
1090
@needs_read_lock
1091
def _get_revision_xml_file(self, revision_id):
765
def get_revision_xml_file(self, revision_id):
766
"""Return XML file object for revision object."""
1092
767
if not revision_id or not isinstance(revision_id, basestring):
1093
raise InvalidRevisionId(revision_id=revision_id, branch=self)
768
raise InvalidRevisionId(revision_id)
769
770
self.lock_read()
1094
771
try:
1095
return self.revision_store.get(revision_id)
1096
except (IndexError, KeyError):
1097
raise bzrlib.errors.NoSuchRevision(self, revision_id)
772
try:
773
return self.revision_store[revision_id]
774
except (IndexError, KeyError):
775
raise bzrlib.errors.NoSuchRevision(self, revision_id)
776
finally:
777
self.unlock()
778
779
#deprecated
780
get_revision_xml = get_revision_xml_file
1098
781
1099
782
def get_revision_xml(self, revision_id):
1100
"""See Branch.get_revision_xml."""
1101
return self._get_revision_xml_file(revision_id).read()
783
return self.get_revision_xml_file(revision_id).read()
784
1102
785
1103
786
def get_revision(self, revision_id):
1104
"""See Branch.get_revision."""
1105
xml_file = self._get_revision_xml_file(revision_id)
787
"""Return the Revision object for a named revision"""
788
xml_file = self.get_revision_xml_file(revision_id)
1106
789
1107
790
try:
1108
791
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
1114
797
assert r.revision_id == revision_id
1115
798
return r
1116
799
800
def get_revision_delta(self, revno):
801
"""Return the delta for one revision.
802
803
The delta is relative to its mainline predecessor, or the
804
empty tree for revision 1.
805
"""
806
assert isinstance(revno, int)
807
rh = self.revision_history()
808
if not (1 <= revno <= len(rh)):
809
raise InvalidRevisionNumber(revno)
810
811
# revno is 1-based; list is 0-based
812
813
new_tree = self.revision_tree(rh[revno-1])
814
if revno == 1:
815
old_tree = EmptyTree()
816
else:
817
old_tree = self.revision_tree(rh[revno-2])
818
819
return compare_trees(old_tree, new_tree)
820
1117
821
def get_revision_sha1(self, revision_id):
1118
"""See Branch.get_revision_sha1."""
822
"""Hash the stored value of a revision, and return it."""
1119
823
# In the future, revision entries will be signed. At that
1120
824
# point, it is probably best *not* to include the signature
1121
825
# in the revision hash. Because that lets you re-sign
1125
829
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
1126
830
1127
831
def get_ancestry(self, revision_id):
1128
"""See Branch.get_ancestry."""
832
"""Return a list of revision-ids integrated by a revision.
833
834
This currently returns a list, but the ordering is not guaranteed:
835
treat it as a set.
836
"""
1129
837
if revision_id is None:
1130
838
return [None]
1131
w = self._get_inventory_weave()
839
w = self.get_inventory_weave()
1132
840
return [None] + map(w.idx_to_name,
1133
841
w.inclusions([w.lookup(revision_id)]))
1134
842
1135
def _get_inventory_weave(self):
843
def get_inventory_weave(self):
1136
844
return self.control_weaves.get_weave('inventory',
1137
845
self.get_transaction())
1138
846
1139
847
def get_inventory(self, revision_id):
1140
"""See Branch.get_inventory."""
848
"""Get Inventory object by hash."""
1141
849
xml = self.get_inventory_xml(revision_id)
1142
850
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
1143
851
1144
852
def get_inventory_xml(self, revision_id):
1145
"""See Branch.get_inventory_xml."""
853
"""Get inventory XML as a file object."""
1146
854
try:
1147
855
assert isinstance(revision_id, basestring), type(revision_id)
1148
iw = self._get_inventory_weave()
856
iw = self.get_inventory_weave()
1149
857
return iw.get_text(iw.lookup(revision_id))
1150
858
except IndexError:
1151
859
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
1152
860
1153
861
def get_inventory_sha1(self, revision_id):
1154
"""See Branch.get_inventory_sha1."""
862
"""Return the sha1 hash of the inventory entry
863
"""
1155
864
return self.get_revision(revision_id).inventory_sha1
1156
865
1157
866
def get_revision_inventory(self, revision_id):
1158
"""See Branch.get_revision_inventory."""
867
"""Return inventory of a past revision."""
1159
868
# TODO: Unify this with get_inventory()
1160
869
# bzr 0.0.6 and later imposes the constraint that the inventory_id
1161
870
# must be the same as its revision, so this is trivial.
1162
871
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())
872
return Inventory(self.get_root_id())
1169
873
else:
1170
874
return self.get_inventory(revision_id)
1171
875
1172
@needs_read_lock
1173
876
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)
877
"""Return sequence of revision hashes on to this branch."""
878
self.lock_read()
879
try:
880
transaction = self.get_transaction()
881
history = transaction.map.find_revision_history()
882
if history is not None:
883
mutter("cache hit for revision-history in %s", self)
884
return list(history)
885
history = [l.rstrip('\r\n') for l in
886
self.controlfile('revision-history', 'r').readlines()]
887
transaction.map.add_revision_history(history)
888
# this call is disabled because revision_history is
889
# not really an object yet, and the transaction is for objects.
890
# transaction.register_clean(history, precious=True)
1179
891
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)
892
finally:
893
self.unlock()
894
895
def common_ancestor(self, other, self_revno=None, other_revno=None):
896
"""
897
>>> from bzrlib.commit import commit
898
>>> sb = ScratchBranch(files=['foo', 'foo~'])
899
>>> sb.common_ancestor(sb) == (None, None)
900
True
901
>>> commit(sb, "Committing first revision", verbose=False)
902
>>> sb.common_ancestor(sb)[0]
903
1
904
>>> clone = sb.clone()
905
>>> commit(sb, "Committing second revision", verbose=False)
906
>>> sb.common_ancestor(sb)[0]
907
2
908
>>> sb.common_ancestor(clone)[0]
909
1
910
>>> commit(clone, "Committing divergent second revision",
911
... verbose=False)
912
>>> sb.common_ancestor(clone)[0]
913
1
914
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
915
True
916
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
917
True
918
>>> clone2 = sb.clone()
919
>>> sb.common_ancestor(clone2)[0]
920
2
921
>>> sb.common_ancestor(clone2, self_revno=1)[0]
922
1
923
>>> sb.common_ancestor(clone2, other_revno=1)[0]
924
1
925
"""
926
my_history = self.revision_history()
927
other_history = other.revision_history()
928
if self_revno is None:
929
self_revno = len(my_history)
930
if other_revno is None:
931
other_revno = len(other_history)
932
indices = range(min((self_revno, other_revno)))
933
indices.reverse()
934
for r in indices:
935
if my_history[r] == other_history[r]:
936
return r+1, my_history[r]
937
return None, None
938
939
940
def revno(self):
941
"""Return current revision number for this branch.
942
943
That is equivalent to the number of revisions committed to
944
this branch.
945
"""
946
return len(self.revision_history())
947
948
949
def last_revision(self):
950
"""Return last patch hash, or None if no history.
951
"""
952
ph = self.revision_history()
953
if ph:
954
return ph[-1]
955
else:
956
return None
957
958
959
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
960
"""Return a list of new revisions that would perfectly fit.
961
962
If self and other have not diverged, return a list of the revisions
963
present in other, but missing from self.
964
965
>>> from bzrlib.commit import commit
966
>>> bzrlib.trace.silent = True
967
>>> br1 = ScratchBranch()
968
>>> br2 = ScratchBranch()
969
>>> br1.missing_revisions(br2)
970
[]
971
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
972
>>> br1.missing_revisions(br2)
973
[u'REVISION-ID-1']
974
>>> br2.missing_revisions(br1)
975
[]
976
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
977
>>> br1.missing_revisions(br2)
978
[]
979
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
980
>>> br1.missing_revisions(br2)
981
[u'REVISION-ID-2A']
982
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
983
>>> br1.missing_revisions(br2)
984
Traceback (most recent call last):
985
DivergedBranches: These branches have diverged.
986
"""
987
# FIXME: If the branches have diverged, but the latest
988
# revision in this branch is completely merged into the other,
989
# then we should still be able to pull.
990
self_history = self.revision_history()
991
self_len = len(self_history)
992
other_history = other.revision_history()
993
other_len = len(other_history)
994
common_index = min(self_len, other_len) -1
995
if common_index >= 0 and \
996
self_history[common_index] != other_history[common_index]:
997
raise DivergedBranches(self, other)
998
999
if stop_revision is None:
1000
stop_revision = other_len
1001
else:
1002
assert isinstance(stop_revision, int)
1003
if stop_revision > other_len:
1004
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
1005
return other_history[self_len:stop_revision]
1187
1006
1188
1007
def update_revisions(self, other, stop_revision=None):
1189
"""See Branch.update_revisions."""
1008
"""Pull in new perfect-fit revisions."""
1190
1009
from bzrlib.fetch import greedy_fetch
1010
from bzrlib.revision import get_intervening_revisions
1191
1011
if stop_revision is None:
1192
1012
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()):
1013
if stop_revision is not None and self.has_revision(stop_revision):
1196
1014
return
1197
1015
greedy_fetch(to_branch=self, from_branch=other,
1198
1016
revision=stop_revision)
1199
pullable_revs = self.pullable_revisions(other, stop_revision)
1200
if len(pullable_revs) > 0:
1017
pullable_revs = self.missing_revisions(
1018
other, other.revision_id_to_revno(stop_revision))
1019
if pullable_revs:
1020
greedy_fetch(to_branch=self,
1021
from_branch=other,
1022
revision=pullable_revs[-1])
1201
1023
self.append_revision(*pullable_revs)
1024
1202
1025
1203
def pullable_revisions(self, other, stop_revision):
1204
"""See Branch.pullable_revisions."""
1205
other_revno = other.revision_id_to_revno(stop_revision)
1026
def commit(self, *args, **kw):
1027
from bzrlib.commit import Commit
1028
Commit().commit(self, *args, **kw)
1029
1030
def revision_id_to_revno(self, revision_id):
1031
"""Given a revision id, return its revno"""
1032
if revision_id is None:
1033
return 0
1034
history = self.revision_history()
1206
1035
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
1036
return history.index(revision_id) + 1
1037
except ValueError:
1038
raise bzrlib.errors.NoSuchRevision(self, revision_id)
1039
1040
def get_rev_id(self, revno, history=None):
1041
"""Find the revision id of the specified revno."""
1042
if revno == 0:
1043
return None
1044
if history is None:
1045
history = self.revision_history()
1046
elif revno <= 0 or revno > len(history):
1047
raise bzrlib.errors.NoSuchRevision(self, revno)
1048
return history[revno - 1]
1049
1220
1050
def revision_tree(self, revision_id):
1221
"""See Branch.revision_tree."""
1051
"""Return Tree for a revision on this branch.
1052
1053
`revision_id` may be None for the null revision, in which case
1054
an `EmptyTree` is returned."""
1222
1055
# TODO: refactor this to use an existing revision object
1223
1056
# so we don't need to read it in twice.
1224
if revision_id == None or revision_id == NULL_REVISION:
1057
if revision_id == None:
1225
1058
return EmptyTree()
1226
1059
else:
1227
1060
inv = self.get_revision_inventory(revision_id)
1228
return RevisionTree(self, inv, revision_id)
1061
return RevisionTree(self.weave_store, inv, revision_id)
1229
1062
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
1063
1240
1064
def working_tree(self):
1241
"""See Branch.working_tree."""
1065
"""Return a `Tree` for the working copy."""
1242
1066
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()
1067
# TODO: In the future, WorkingTree should utilize Transport
1068
# RobertCollins 20051003 - I don't think it should - working trees are
1069
# much more complex to keep consistent than our careful .bzr subset.
1070
# instead, we should say that working trees are local only, and optimise
1071
# for that.
1072
return WorkingTree(self._transport.base, self.read_working_inventory())
1073
1074
1075
def basis_tree(self):
1076
"""Return `Tree` object for last revision.
1077
1078
If there are no revisions yet, return an `EmptyTree`.
1079
"""
1080
return self.revision_tree(self.last_revision())
1081
1082
1083
def rename_one(self, from_rel, to_rel):
1084
"""Rename one file.
1085
1086
This can change the directory or the filename or both.
1087
"""
1088
self.lock_write()
1089
try:
1090
tree = self.working_tree()
1091
inv = tree.inventory
1092
if not tree.has_filename(from_rel):
1093
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1094
if tree.has_filename(to_rel):
1095
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1096
1097
file_id = inv.path2id(from_rel)
1098
if file_id == None:
1099
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1100
1101
if inv.path2id(to_rel):
1102
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1103
1104
to_dir, to_tail = os.path.split(to_rel)
1105
to_dir_id = inv.path2id(to_dir)
1106
if to_dir_id == None and to_dir != '':
1107
raise BzrError("can't determine destination directory id for %r" % to_dir)
1108
1109
mutter("rename_one:")
1110
mutter(" file_id {%s}" % file_id)
1111
mutter(" from_rel %r" % from_rel)
1112
mutter(" to_rel %r" % to_rel)
1113
mutter(" to_dir %r" % to_dir)
1114
mutter(" to_dir_id {%s}" % to_dir_id)
1115
1116
inv.rename(file_id, to_dir_id, to_tail)
1117
1118
from_abs = self.abspath(from_rel)
1119
to_abs = self.abspath(to_rel)
1120
try:
1121
rename(from_abs, to_abs)
1122
except OSError, e:
1123
raise BzrError("failed to rename %r to %r: %s"
1124
% (from_abs, to_abs, e[1]),
1125
["rename rolled back"])
1126
1127
self._write_inventory(inv)
1128
finally:
1129
self.unlock()
1130
1131
1132
def move(self, from_paths, to_name):
1133
"""Rename files.
1134
1135
to_name must exist as a versioned directory.
1136
1137
If to_name exists and is a directory, the files are moved into
1138
it, keeping their old names. If it is a directory,
1139
1140
Note that to_name is only the last component of the new name;
1141
this doesn't change the directory.
1142
1143
This returns a list of (from_path, to_path) pairs for each
1144
entry that is moved.
1145
"""
1146
result = []
1147
self.lock_write()
1148
try:
1149
## TODO: Option to move IDs only
1150
assert not isinstance(from_paths, basestring)
1151
tree = self.working_tree()
1152
inv = tree.inventory
1153
to_abs = self.abspath(to_name)
1154
if not isdir(to_abs):
1155
raise BzrError("destination %r is not a directory" % to_abs)
1156
if not tree.has_filename(to_name):
1157
raise BzrError("destination %r not in working directory" % to_abs)
1158
to_dir_id = inv.path2id(to_name)
1159
if to_dir_id == None and to_name != '':
1160
raise BzrError("destination %r is not a versioned directory" % to_name)
1161
to_dir_ie = inv[to_dir_id]
1162
if to_dir_ie.kind not in ('directory', 'root_directory'):
1163
raise BzrError("destination %r is not a directory" % to_abs)
1164
1165
to_idpath = inv.get_idpath(to_dir_id)
1166
1167
for f in from_paths:
1168
if not tree.has_filename(f):
1169
raise BzrError("%r does not exist in working tree" % f)
1170
f_id = inv.path2id(f)
1171
if f_id == None:
1172
raise BzrError("%r is not versioned" % f)
1173
name_tail = splitpath(f)[-1]
1174
dest_path = appendpath(to_name, name_tail)
1175
if tree.has_filename(dest_path):
1176
raise BzrError("destination %r already exists" % dest_path)
1177
if f_id in to_idpath:
1178
raise BzrError("can't move %r to a subdirectory of itself" % f)
1179
1180
# OK, so there's a race here, it's possible that someone will
1181
# create a file in this interval and then the rename might be
1182
# left half-done. But we should have caught most problems.
1183
1184
for f in from_paths:
1185
name_tail = splitpath(f)[-1]
1186
dest_path = appendpath(to_name, name_tail)
1187
result.append((f, dest_path))
1188
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1189
try:
1190
rename(self.abspath(f), self.abspath(dest_path))
1191
except OSError, e:
1192
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1193
["rename rolled back"])
1194
1195
self._write_inventory(inv)
1196
finally:
1197
self.unlock()
1198
1199
return result
1200
1201
1202
def revert(self, filenames, old_tree=None, backups=True):
1203
"""Restore selected files to the versions from a previous tree.
1204
1205
backups
1206
If true (default) backups are made of files before
1207
they're renamed.
1208
"""
1209
from bzrlib.errors import NotVersionedError, BzrError
1210
from bzrlib.atomicfile import AtomicFile
1211
from bzrlib.osutils import backup_file
1212
1213
inv = self.read_working_inventory()
1214
if old_tree is None:
1215
old_tree = self.basis_tree()
1216
old_inv = old_tree.inventory
1217
1218
nids = []
1219
for fn in filenames:
1220
file_id = inv.path2id(fn)
1221
if not file_id:
1222
raise NotVersionedError("not a versioned file", fn)
1223
if not old_inv.has_id(file_id):
1224
raise BzrError("file not present in old tree", fn, file_id)
1225
nids.append((fn, file_id))
1226
1227
# TODO: Rename back if it was previously at a different location
1228
1229
# TODO: If given a directory, restore the entire contents from
1230
# the previous version.
1231
1232
# TODO: Make a backup to a temporary file.
1233
1234
# TODO: If the file previously didn't exist, delete it?
1235
for fn, file_id in nids:
1236
backup_file(fn)
1237
1238
f = AtomicFile(fn, 'wb')
1239
try:
1240
f.write(old_tree.get_file(file_id).read())
1241
f.commit()
1242
finally:
1243
f.close()
1244
1245
1246
def pending_merges(self):
1247
"""Return a list of pending merges.
1248
1249
These are revisions that have been merged into the working
1250
directory but not yet committed.
1251
"""
1252
cfn = self._rel_controlfilename('pending-merges')
1253
if not self._transport.has(cfn):
1254
return []
1255
p = []
1256
for l in self.controlfile('pending-merges', 'r').readlines():
1257
p.append(l.rstrip('\n'))
1258
return p
1259
1260
1261
def add_pending_merge(self, *revision_ids):
1262
# TODO: Perhaps should check at this point that the
1263
# history of the revision is actually present?
1264
p = self.pending_merges()
1265
updated = False
1266
for rev_id in revision_ids:
1267
if rev_id in p:
1268
continue
1269
p.append(rev_id)
1270
updated = True
1271
if updated:
1272
self.set_pending_merges(p)
1273
1274
def set_pending_merges(self, rev_list):
1275
self.lock_write()
1276
try:
1277
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1278
finally:
1279
self.unlock()
1280
1264
1281
1265
1282
def get_parent(self):
1266
"""See Branch.get_parent."""
1283
"""Return the parent location of the branch.
1284
1285
This is the default location for push/pull/missing. The usual
1286
pattern is that the user can override it by specifying a
1287
location.
1288
"""
1267
1289
import errno
1268
1290
_locs = ['parent', 'pull', 'x-pull']
1269
1291
for l in _locs:
1270
1292
try:
1271
1293
return self.controlfile(l, 'r').read().strip('\n')
1272
except NoSuchFile:
1273
pass
1294
except IOError, e:
1295
if e.errno != errno.ENOENT:
1296
raise
1274
1297
return None
1275
1298
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
1299
1288
1300
def set_parent(self, url):
1289
"""See Branch.set_parent."""
1290
1301
# TODO: Maybe delete old location files?
1291
1302
from bzrlib.atomicfile import AtomicFile
1292
f = AtomicFile(self.controlfilename('parent'))
1303
self.lock_write()
1293
1304
try:
1294
f.write(url + '\n')
1295
f.commit()
1305
f = AtomicFile(self.controlfilename('parent'))
1306
try:
1307
f.write(url + '\n')
1308
f.commit()
1309
finally:
1310
f.close()
1296
1311
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):
1312
self.unlock()
1313
1314
def check_revno(self, revno):
1315
"""\
1316
Check whether a revno corresponds to any revision.
1317
Zero (the NULL revision) is considered valid.
1318
"""
1319
if revno != 0:
1320
self.check_real_revno(revno)
1321
1322
def check_real_revno(self, revno):
1323
"""\
1324
Check whether a revno corresponds to a real revision.
1325
Zero (the NULL revision) is considered invalid
1326
"""
1327
if revno < 1 or revno > self.revno():
1328
raise InvalidRevisionNumber(revno)
1329
1330
1331
1332
1333
1334
class ScratchBranch(_Branch):
1347
1335
"""Special test class: a branch that cleans up after itself.
1348
1336
1349
1337
>>> b = ScratchBranch()
1350
1338
>>> isdir(b.base)
1351
1339
True
1352
1340
>>> bd = b.base
1353
>>> b._transport.__del__()
1341
>>> b.destroy()
1354
1342
>>> isdir(bd)
1355
1343
False
1356
1344
"""
1357
1358
def __init__(self, files=[], dirs=[], transport=None):
1345
def __init__(self, files=[], dirs=[], base=None):
1359
1346
"""Make a test branch.
1360
1347
1361
1348
This creates a temporary directory and runs init-tree in it.
1362
1349
1363
1350
If any files are listed, they are created in the working copy.
1364
1351
"""
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
1352
from tempfile import mkdtemp
1353
init = False
1354
if base is None:
1355
base = mkdtemp()
1356
init = True
1357
if isinstance(base, basestring):
1358
base = get_transport(base)
1359
_Branch.__init__(self, base, init=init)
1372
1360
for d in dirs:
1373
1361
self._transport.mkdir(d)
1374
1362
1386
1374
... orig.base == clone.base
1387
1375
...
1388
1376
False
1389
>>> os.path.isfile(pathjoin(clone.base, "file1"))
1377
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1390
1378
True
1391
1379
"""
1392
1380
from shutil import copytree
1393
from bzrlib.osutils import mkdtemp
1381
from tempfile import mkdtemp
1394
1382
base = mkdtemp()
1395
1383
os.rmdir(base)
1396
1384
copytree(self.base, base, symlinks=True)
1397
return ScratchBranch(
1398
transport=bzrlib.transport.local.ScratchTransport(base))
1385
return ScratchBranch(base=base)
1386
1387
def __del__(self):
1388
self.destroy()
1389
1390
def destroy(self):
1391
"""Destroy the test branch, removing the scratch directory."""
1392
from shutil import rmtree
1393
try:
1394
if self.base:
1395
mutter("delete ScratchBranch %s" % self.base)
1396
rmtree(self.base)
1397
except OSError, e:
1398
# Work around for shutil.rmtree failing on Windows when
1399
# readonly files are encountered
1400
mutter("hit exception in destroying ScratchBranch: %s" % e)
1401
for root, dirs, files in os.walk(self.base, topdown=False):
1402
for name in files:
1403
os.chmod(os.path.join(root, name), 0700)
1404
rmtree(self.base)
1405
self._transport = None
1406
1399
1407
1400
1408
1401
1409
######################################################################
1404
1412
1405
1413
def is_control_file(filename):
1406
1414
## FIXME: better check
1407
filename = normpath(filename)
1415
filename = os.path.normpath(filename)
1408
1416
while filename != '':
1409
1417
head, tail = os.path.split(filename)
1410
1418
## mutter('check %r for control file' % ((head, tail), ))
1414
1422
break
1415
1423
filename = head
1416
1424
return False
1425
1426
1427
1428
def gen_file_id(name):
1429
"""Return new file id.
1430
1431
This should probably generate proper UUIDs, but for the moment we
1432
cope with just randomness because running uuidgen every time is
1433
slow."""
1434
import re
1435
from binascii import hexlify
1436
from time import time
1437
1438
# get last component
1439
idx = name.rfind('/')
1440
if idx != -1:
1441
name = name[idx+1 : ]
1442
idx = name.rfind('\\')
1443
if idx != -1:
1444
name = name[idx+1 : ]
1445
1446
# make it not a hidden file
1447
name = name.lstrip('.')
1448
1449
# remove any wierd characters; we don't escape them but rather
1450
# just pull them out
1451
name = re.sub(r'[^\w.]', '', name)
1452
1453
s = hexlify(rand_bytes(8))
1454
return '-'.join((name, compact_date(time()), s))
1455
1456
1457
def gen_root_id():
1458
"""Return a new tree-root file id."""
1459
return gen_file_id('TREE_ROOT')
1460
1461
Loggerhead is a web-based interface for Breezy
Version: 2.0.1