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