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