« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1711.2.24
- compare with another revision
- download diff
- download tarball
- view history from revision 1711.2.24
- Committer: John Arbash Meinel
- Date: 2006-05-29 01:00:30 UTC
- mto: (1753.1.3 add) (1711.7.2 win32) (1946.2.6 reduce-knit-churn)
- mto: This revision was merged to the branch mainline in revision 1733.
- Revision ID: john@arbash-meinel.com-20060529010030-f3f00c67bbea7e16
Late bind to PatienceSequenceMatcher to allow plugin to override.
- files added:
- BRANCH.TODO
- bzrlib/benchmarks
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins/launchpad
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport/http
- bzrlib/ui
- tools/doc_generate
- files removed:
- bzrlib/changeset.py
- notes
- patches
- files renamed:
- bzrlib/store/weave.py => bzrlib/store/versioned/__init__.py
- bzrlib/selftest/ => bzrlib/tests/
- bzrlib/selftest/testannotate.py => bzrlib/tests/blackbox/test_annotate.py
- bzrlib/selftest/test_revision_info.py => bzrlib/tests/blackbox/test_revision_info.py
- bzrlib/selftest/teststatus.py => bzrlib/tests/blackbox/test_status.py
- bzrlib/selftest/blackbox.py => bzrlib/tests/blackbox/test_too_much.py
- bzrlib/selftest/versioning.py => bzrlib/tests/blackbox/test_versioning.py
- bzrlib/selftest/testbranch.py => bzrlib/tests/branch_implementations/test_branch.py
- bzrlib/selftest/test_parent.py => bzrlib/tests/branch_implementations/test_parent.py
- bzrlib/selftest/testconfig.py => bzrlib/tests/test_config.py
- bzrlib/selftest/testdiff.py => bzrlib/tests/test_diff.py
- bzrlib/selftest/testfetch.py => bzrlib/tests/test_fetch.py
- bzrlib/selftest/testgpg.py => bzrlib/tests/test_gpg.py
- bzrlib/selftest/testgraph.py => bzrlib/tests/test_graph.py
- bzrlib/selftest/testhashcache.py => bzrlib/tests/test_hashcache.py
- bzrlib/selftest/testhttp.py => bzrlib/tests/test_http.py
- bzrlib/selftest/testidentitymap.py => bzrlib/tests/test_identitymap.py
- bzrlib/selftest/testinv.py => bzrlib/tests/test_inv.py
- bzrlib/selftest/testlog.py => bzrlib/tests/test_log.py
- bzrlib/selftest/testmerge.py => bzrlib/tests/test_merge.py
- bzrlib/selftest/testmerge3.py => bzrlib/tests/test_merge3.py
- bzrlib/selftest/testnonascii.py => bzrlib/tests/test_nonascii.py
- bzrlib/selftest/testoptions.py => bzrlib/tests/test_options.py
- bzrlib/selftest/plugins.py => bzrlib/tests/test_plugins.py
- bzrlib/selftest/testrevision.py => bzrlib/tests/test_revision.py
- bzrlib/selftest/testrevisionnamespaces.py => bzrlib/tests/test_revisionnamespaces.py
- bzrlib/selftest/testrevprops.py => bzrlib/tests/test_revprops.py
- bzrlib/selftest/testsampler.py => bzrlib/tests/test_sampler.py
- bzrlib/selftest/teststore.py => bzrlib/tests/test_store.py
- bzrlib/selftest/testtestament.py => bzrlib/tests/test_testament.py
- bzrlib/selftest/testtransactions.py => bzrlib/tests/test_transactions.py
- bzrlib/selftest/testtransport.py => bzrlib/tests/test_transport.py
- bzrlib/selftest/whitebox.py => bzrlib/tests/test_whitebox.py
- bzrlib/selftest/testworkingtree.py => bzrlib/tests/test_workingtree.py
- bzrlib/transport/http.py => bzrlib/transport/http/__init__.py
- bzrlib/ui.py => bzrlib/ui/__init__.py
- bzrlib/xml.py => bzrlib/xml_serializer.py
- tutorial.txt => doc/tutorial.txt
- bzr-man.py => tools/doc_generate/autodoc_man.py
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005 Canonical Ltd
2
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
from copy import deepcopy
19
from cStringIO import StringIO
20
import errno
21
import os
22
import shutil
18
23
import sys
19
import os
20
import errno
24
from unittest import TestSuite
21
25
from warnings import warn
22
from cStringIO import StringIO
23
24
26
25
27
import bzrlib
26
from bzrlib.inventory import InventoryEntry
27
import bzrlib.inventory as inventory
28
from bzrlib.trace import mutter, note
29
from bzrlib.osutils import (isdir, quotefn, compact_date, rand_bytes,
30
rename, splitpath, sha_file, appendpath,
31
file_kind, abspath)
28
import bzrlib.bzrdir as bzrdir
29
from bzrlib.config import TreeConfig
30
from bzrlib.decorators import needs_read_lock, needs_write_lock
31
from bzrlib.delta import compare_trees
32
32
import bzrlib.errors as errors
33
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
34
34
NoSuchRevision, HistoryMissing, NotBranchError,
35
DivergedBranches, LockError, UnlistableStore,
36
UnlistableBranch, NoSuchFile, NotVersionedError)
35
DivergedBranches, LockError,
36
UninitializableFormat,
37
UnlistableStore,
38
UnlistableBranch, NoSuchFile, NotVersionedError,
39
NoWorkingTree)
40
import bzrlib.inventory as inventory
41
from bzrlib.inventory import Inventory
42
from bzrlib.lockable_files import LockableFiles, TransportLock
43
from bzrlib.lockdir import LockDir
44
from bzrlib.osutils import (isdir, quotefn,
45
rename, splitpath, sha_file,
46
file_kind, abspath, normpath, pathjoin,
47
safe_unicode,
48
rmtree,
49
)
37
50
from bzrlib.textui import show_status
38
from bzrlib.revision import Revision, is_ancestor, get_intervening_revisions
39
40
from bzrlib.delta import compare_trees
51
from bzrlib.trace import mutter, note
41
52
from bzrlib.tree import EmptyTree, RevisionTree
42
from bzrlib.inventory import Inventory
53
from bzrlib.repository import Repository
54
from bzrlib.revision import (
55
is_ancestor,
56
NULL_REVISION,
57
Revision,
58
)
43
59
from bzrlib.store import copy_all
44
from bzrlib.store.compressed_text import CompressedTextStore
45
from bzrlib.store.text import TextStore
46
from bzrlib.store.weave import WeaveStore
47
from bzrlib.testament import Testament
60
from bzrlib.symbol_versioning import *
48
61
import bzrlib.transactions as transactions
49
62
from bzrlib.transport import Transport, get_transport
63
from bzrlib.tree import EmptyTree, RevisionTree
64
import bzrlib.ui
50
65
import bzrlib.xml5
51
import bzrlib.ui
52
66
53
67
54
68
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
55
69
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
56
70
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
57
## TODO: Maybe include checks for common corruption of newlines, etc?
58
71
72
73
# TODO: Maybe include checks for common corruption of newlines, etc?
59
74
60
75
# TODO: Some operations like log might retrieve the same revisions
61
76
# repeatedly to calculate deltas. We could perhaps have a weakref
62
77
# cache in memory to make this faster. In general anything can be
63
# cached in memory between lock and unlock operations.
64
65
def find_branch(*ignored, **ignored_too):
66
# XXX: leave this here for about one release, then remove it
67
raise NotImplementedError('find_branch() is not supported anymore, '
68
'please use one of the new branch constructors')
69
70
71
def needs_read_lock(unbound):
72
"""Decorate unbound to take out and release a read lock."""
73
def decorated(self, *args, **kwargs):
74
self.lock_read()
75
try:
76
return unbound(self, *args, **kwargs)
77
finally:
78
self.unlock()
79
return decorated
80
81
82
def needs_write_lock(unbound):
83
"""Decorate unbound to take out and release a write lock."""
84
def decorated(self, *args, **kwargs):
85
self.lock_write()
86
try:
87
return unbound(self, *args, **kwargs)
88
finally:
89
self.unlock()
90
return decorated
78
# cached in memory between lock and unlock operations. .. nb thats
79
# what the transaction identity map provides
80
91
81
92
82
######################################################################
93
83
# branch objects
98
88
base
99
89
Base directory/url of the branch.
100
90
"""
91
# this is really an instance variable - FIXME move it there
92
# - RBC 20060112
101
93
base = None
102
94
103
95
def __init__(self, *ignored, **ignored_too):
104
96
raise NotImplementedError('The Branch class is abstract')
105
97
98
def break_lock(self):
99
"""Break a lock if one is present from another instance.
100
101
Uses the ui factory to ask for confirmation if the lock may be from
102
an active process.
103
104
This will probe the repository for its lock as well.
105
"""
106
self.control_files.break_lock()
107
self.repository.break_lock()
108
master = self.get_master_branch()
109
if master is not None:
110
master.break_lock()
111
106
112
@staticmethod
113
@deprecated_method(zero_eight)
107
114
def open_downlevel(base):
108
"""Open a branch which may be of an old format.
109
110
Only local branches are supported."""
111
return _Branch(get_transport(base), relax_version_check=True)
115
"""Open a branch which may be of an old format."""
116
return Branch.open(base, _unsupported=True)
112
117
113
118
@staticmethod
114
def open(base):
115
"""Open an existing branch, rooted at 'base' (url)"""
116
t = get_transport(base)
117
mutter("trying to open %r with transport %r", base, t)
118
return _Branch(t)
119
def open(base, _unsupported=False):
120
"""Open the repository rooted at base.
121
122
For instance, if the repository is at URL/.bzr/repository,
123
Repository.open(URL) -> a Repository instance.
124
"""
125
control = bzrdir.BzrDir.open(base, _unsupported)
126
return control.open_branch(_unsupported)
119
127
120
128
@staticmethod
121
129
def open_containing(url):
125
133
126
134
Basically we keep looking up until we find the control directory or
127
135
run into the root. If there isn't one, raises NotBranchError.
136
If there is one and it is either an unrecognised format or an unsupported
137
format, UnknownFormatError or UnsupportedFormatError are raised.
128
138
If there is one, it is returned, along with the unused portion of url.
129
139
"""
130
t = get_transport(url)
131
while True:
132
try:
133
return _Branch(t), t.relpath(url)
134
except NotBranchError:
135
pass
136
new_t = t.clone('..')
137
if new_t.base == t.base:
138
# reached the root, whatever that may be
139
raise NotBranchError(path=url)
140
t = new_t
140
control, relpath = bzrdir.BzrDir.open_containing(url)
141
return control.open_branch(), relpath
141
142
142
143
@staticmethod
144
@deprecated_function(zero_eight)
143
145
def initialize(base):
144
"""Create a new branch, rooted at 'base' (url)"""
145
t = get_transport(base)
146
return _Branch(t, init=True)
146
"""Create a new working tree and branch, rooted at 'base' (url)
147
148
NOTE: This will soon be deprecated in favour of creation
149
through a BzrDir.
150
"""
151
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
147
152
148
153
def setup_caching(self, cache_root):
149
154
"""Subclasses that care about caching should override this, and set
150
155
up cached stores located under cache_root.
151
156
"""
157
# seems to be unused, 2006-01-13 mbp
158
warn('%s is deprecated' % self.setup_caching)
152
159
self.cache_root = cache_root
153
160
154
155
class _Branch(Branch):
156
"""A branch stored in the actual filesystem.
157
158
Note that it's "local" in the context of the filesystem; it doesn't
159
really matter if it's on an nfs/smb/afs/coda/... share, as long as
160
it's writable, and can be accessed via the normal filesystem API.
161
162
_lock_mode
163
None, or 'r' or 'w'
164
165
_lock_count
166
If _lock_mode is true, a positive count of the number of times the
167
lock has been taken.
168
169
_lock
170
Lock object from bzrlib.lock.
171
"""
172
# We actually expect this class to be somewhat short-lived; part of its
173
# purpose is to try to isolate what bits of the branch logic are tied to
174
# filesystem access, so that in a later step, we can extricate them to
175
# a separarte ("storage") class.
176
_lock_mode = None
177
_lock_count = None
178
_lock = None
179
_inventory_weave = None
180
181
# Map some sort of prefix into a namespace
182
# stuff like "revno:10", "revid:", etc.
183
# This should match a prefix with a function which accepts
184
REVISION_NAMESPACES = {}
185
186
def push_stores(self, branch_to):
187
"""Copy the content of this branches store to branch_to."""
188
if (self._branch_format != branch_to._branch_format
189
or self._branch_format != 4):
190
from bzrlib.fetch import greedy_fetch
191
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
192
self, self._branch_format, branch_to, branch_to._branch_format)
193
greedy_fetch(to_branch=branch_to, from_branch=self,
194
revision=self.last_revision())
195
return
196
197
store_pairs = ((self.text_store, branch_to.text_store),
198
(self.inventory_store, branch_to.inventory_store),
199
(self.revision_store, branch_to.revision_store))
200
try:
201
for from_store, to_store in store_pairs:
202
copy_all(from_store, to_store)
203
except UnlistableStore:
204
raise UnlistableBranch(from_store)
205
206
def __init__(self, transport, init=False,
207
relax_version_check=False):
208
"""Create new branch object at a particular location.
209
210
transport -- A Transport object, defining how to access files.
211
(If a string, transport.transport() will be used to
212
create a Transport object)
213
214
init -- If True, create new control files in a previously
215
unversioned directory. If False, the branch must already
216
be versioned.
217
218
relax_version_check -- If true, the usual check for the branch
219
version is not applied. This is intended only for
220
upgrade/recovery type use; it's not guaranteed that
221
all operations will work on old format branches.
222
223
In the test suite, creation of new trees is tested using the
224
`ScratchBranch` class.
225
"""
226
assert isinstance(transport, Transport), \
227
"%r is not a Transport" % transport
228
self._transport = transport
229
if init:
230
self._make_control()
231
self._check_format(relax_version_check)
232
233
def get_store(name, compressed=True, prefixed=False):
234
# FIXME: This approach of assuming stores are all entirely compressed
235
# or entirely uncompressed is tidy, but breaks upgrade from
236
# some existing branches where there's a mixture; we probably
237
# still want the option to look for both.
238
relpath = self._rel_controlfilename(name)
239
if compressed:
240
store = CompressedTextStore(self._transport.clone(relpath),
241
prefixed=prefixed)
242
else:
243
store = TextStore(self._transport.clone(relpath),
244
prefixed=prefixed)
245
#if self._transport.should_cache():
246
# cache_path = os.path.join(self.cache_root, name)
247
# os.mkdir(cache_path)
248
# store = bzrlib.store.CachedStore(store, cache_path)
249
return store
250
def get_weave(name, prefixed=False):
251
relpath = self._rel_controlfilename(name)
252
ws = WeaveStore(self._transport.clone(relpath), prefixed=prefixed)
253
if self._transport.should_cache():
254
ws.enable_cache = True
255
return ws
256
257
if self._branch_format == 4:
258
self.inventory_store = get_store('inventory-store')
259
self.text_store = get_store('text-store')
260
self.revision_store = get_store('revision-store')
261
elif self._branch_format == 5:
262
self.control_weaves = get_weave('')
263
self.weave_store = get_weave('weaves')
264
self.revision_store = get_store('revision-store', compressed=False)
265
elif self._branch_format == 6:
266
self.control_weaves = get_weave('')
267
self.weave_store = get_weave('weaves', prefixed=True)
268
self.revision_store = get_store('revision-store', compressed=False,
269
prefixed=True)
270
self.revision_store.register_suffix('sig')
271
self._transaction = None
272
273
def __str__(self):
274
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
275
276
277
__repr__ = __str__
278
279
280
def __del__(self):
281
if self._lock_mode or self._lock:
282
# XXX: This should show something every time, and be suitable for
283
# headless operation and embedding
284
warn("branch %r was not explicitly unlocked" % self)
285
self._lock.unlock()
286
287
# TODO: It might be best to do this somewhere else,
288
# but it is nice for a Branch object to automatically
289
# cache it's information.
290
# Alternatively, we could have the Transport objects cache requests
291
# See the earlier discussion about how major objects (like Branch)
292
# should never expect their __del__ function to run.
293
if hasattr(self, 'cache_root') and self.cache_root is not None:
294
try:
295
import shutil
296
shutil.rmtree(self.cache_root)
297
except:
298
pass
299
self.cache_root = None
300
301
def _get_base(self):
302
if self._transport:
303
return self._transport.base
304
return None
305
306
base = property(_get_base, doc="The URL for the root of this branch.")
307
308
def _finish_transaction(self):
309
"""Exit the current transaction."""
310
if self._transaction is None:
311
raise errors.LockError('Branch %s is not in a transaction' %
312
self)
313
transaction = self._transaction
314
self._transaction = None
315
transaction.finish()
316
317
def get_transaction(self):
318
"""Return the current active transaction.
319
320
If no transaction is active, this returns a passthrough object
321
for which all data is immedaitely flushed and no caching happens.
322
"""
323
if self._transaction is None:
324
return transactions.PassThroughTransaction()
325
else:
326
return self._transaction
327
328
def _set_transaction(self, new_transaction):
329
"""Set a new active transaction."""
330
if self._transaction is not None:
331
raise errors.LockError('Branch %s is in a transaction already.' %
332
self)
333
self._transaction = new_transaction
161
def _get_nick(self):
162
cfg = self.tree_config()
163
return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
164
165
def _set_nick(self, nick):
166
cfg = self.tree_config()
167
cfg.set_option(nick, "nickname")
168
assert cfg.get_option("nickname") == nick
169
170
nick = property(_get_nick, _set_nick)
171
172
def is_locked(self):
173
raise NotImplementedError('is_locked is abstract')
334
174
335
175
def lock_write(self):
336
mutter("lock write: %s (%s)", self, self._lock_count)
337
# TODO: Upgrade locking to support using a Transport,
338
# and potentially a remote locking protocol
339
if self._lock_mode:
340
if self._lock_mode != 'w':
341
raise LockError("can't upgrade to a write lock from %r" %
342
self._lock_mode)
343
self._lock_count += 1
344
else:
345
self._lock = self._transport.lock_write(
346
self._rel_controlfilename('branch-lock'))
347
self._lock_mode = 'w'
348
self._lock_count = 1
349
self._set_transaction(transactions.PassThroughTransaction())
176
raise NotImplementedError('lock_write is abstract')
350
177
351
178
def lock_read(self):
352
mutter("lock read: %s (%s)", self, self._lock_count)
353
if self._lock_mode:
354
assert self._lock_mode in ('r', 'w'), \
355
"invalid lock mode %r" % self._lock_mode
356
self._lock_count += 1
357
else:
358
self._lock = self._transport.lock_read(
359
self._rel_controlfilename('branch-lock'))
360
self._lock_mode = 'r'
361
self._lock_count = 1
362
self._set_transaction(transactions.ReadOnlyTransaction())
363
# 5K may be excessive, but hey, its a knob.
364
self.get_transaction().set_cache_size(5000)
365
179
raise NotImplementedError('lock_read is abstract')
180
366
181
def unlock(self):
367
mutter("unlock: %s (%s)", self, self._lock_count)
368
if not self._lock_mode:
369
raise LockError('branch %r is not locked' % (self))
370
371
if self._lock_count > 1:
372
self._lock_count -= 1
373
else:
374
self._finish_transaction()
375
self._lock.unlock()
376
self._lock = None
377
self._lock_mode = self._lock_count = None
182
raise NotImplementedError('unlock is abstract')
183
184
def peek_lock_mode(self):
185
"""Return lock mode for the Branch: 'r', 'w' or None"""
186
raise NotImplementedError(self.peek_lock_mode)
187
188
def get_physical_lock_status(self):
189
raise NotImplementedError('get_physical_lock_status is abstract')
378
190
379
191
def abspath(self, name):
380
192
"""Return absolute filename for something in the branch
382
194
XXX: Robert Collins 20051017 what is this used for? why is it a branch
383
195
method and not a tree method.
384
196
"""
385
return self._transport.abspath(name)
386
387
def _rel_controlfilename(self, file_or_path):
388
if not isinstance(file_or_path, basestring):
389
file_or_path = '/'.join(file_or_path)
390
if file_or_path == '':
391
return bzrlib.BZRDIR
392
return bzrlib.transport.urlescape(bzrlib.BZRDIR + '/' + file_or_path)
393
394
def controlfilename(self, file_or_path):
395
"""Return location relative to branch."""
396
return self._transport.abspath(self._rel_controlfilename(file_or_path))
397
398
399
def controlfile(self, file_or_path, mode='r'):
400
"""Open a control file for this branch.
401
402
There are two classes of file in the control directory: text
403
and binary. binary files are untranslated byte streams. Text
404
control files are stored with Unix newlines and in UTF-8, even
405
if the platform or locale defaults are different.
406
407
Controlfiles should almost never be opened in write mode but
408
rather should be atomically copied and replaced using atomicfile.
409
"""
410
import codecs
411
412
relpath = self._rel_controlfilename(file_or_path)
413
#TODO: codecs.open() buffers linewise, so it was overloaded with
414
# a much larger buffer, do we need to do the same for getreader/getwriter?
415
if mode == 'rb':
416
return self._transport.get(relpath)
417
elif mode == 'wb':
418
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
419
elif mode == 'r':
420
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
421
elif mode == 'w':
422
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
197
raise NotImplementedError('abspath is abstract')
198
199
def bind(self, other):
200
"""Bind the local branch the other branch.
201
202
:param other: The branch to bind to
203
:type other: Branch
204
"""
205
raise errors.UpgradeRequired(self.base)
206
207
@needs_write_lock
208
def fetch(self, from_branch, last_revision=None, pb=None):
209
"""Copy revisions from from_branch into this branch.
210
211
:param from_branch: Where to copy from.
212
:param last_revision: What revision to stop at (None for at the end
213
of the branch.
214
:param pb: An optional progress bar to use.
215
216
Returns the copied revision count and the failed revisions in a tuple:
217
(copied, failures).
218
"""
219
if self.base == from_branch.base:
220
return (0, [])
221
if pb is None:
222
nested_pb = bzrlib.ui.ui_factory.nested_progress_bar()
223
pb = nested_pb
423
224
else:
424
raise BzrError("invalid controlfile mode %r" % mode)
425
426
def put_controlfile(self, path, f, encode=True):
427
"""Write an entry as a controlfile.
428
429
:param path: The path to put the file, relative to the .bzr control
430
directory
431
:param f: A file-like or string object whose contents should be copied.
432
:param encode: If true, encode the contents as utf-8
433
"""
434
self.put_controlfiles([(path, f)], encode=encode)
435
436
def put_controlfiles(self, files, encode=True):
437
"""Write several entries as controlfiles.
438
439
:param files: A list of [(path, file)] pairs, where the path is the directory
440
underneath the bzr control directory
441
:param encode: If true, encode the contents as utf-8
442
"""
443
import codecs
444
ctrl_files = []
445
for path, f in files:
446
if encode:
447
if isinstance(f, basestring):
448
f = f.encode('utf-8', 'replace')
225
nested_pb = None
226
227
from_branch.lock_read()
228
try:
229
if last_revision is None:
230
pb.update('get source history')
231
from_history = from_branch.revision_history()
232
if from_history:
233
last_revision = from_history[-1]
449
234
else:
450
f = codecs.getwriter('utf-8')(f, errors='replace')
451
path = self._rel_controlfilename(path)
452
ctrl_files.append((path, f))
453
self._transport.put_multi(ctrl_files)
454
455
def _make_control(self):
456
from bzrlib.inventory import Inventory
457
from bzrlib.weavefile import write_weave_v5
458
from bzrlib.weave import Weave
235
# no history in the source branch
236
last_revision = NULL_REVISION
237
return self.repository.fetch(from_branch.repository,
238
revision_id=last_revision,
239
pb=nested_pb)
240
finally:
241
if nested_pb is not None:
242
nested_pb.finished()
243
from_branch.unlock()
244
245
def get_bound_location(self):
246
"""Return the URL of the branch we are bound to.
247
248
Older format branches cannot bind, please be sure to use a metadir
249
branch.
250
"""
251
return None
252
253
def get_master_branch(self):
254
"""Return the branch we are bound to.
459
255
460
# Create an empty inventory
461
sio = StringIO()
462
# if we want per-tree root ids then this is the place to set
463
# them; they're not needed for now and so ommitted for
464
# simplicity.
465
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
466
empty_inv = sio.getvalue()
467
sio = StringIO()
468
bzrlib.weavefile.write_weave_v5(Weave(), sio)
469
empty_weave = sio.getvalue()
470
471
dirs = [[], 'revision-store', 'weaves']
472
files = [('README',
473
"This is a Bazaar-NG control directory.\n"
474
"Do not change any files in this directory.\n"),
475
('branch-format', BZR_BRANCH_FORMAT_6),
476
('revision-history', ''),
477
('branch-name', ''),
478
('branch-lock', ''),
479
('pending-merges', ''),
480
('inventory', empty_inv),
481
('inventory.weave', empty_weave),
482
('ancestry.weave', empty_weave)
483
]
484
cfn = self._rel_controlfilename
485
self._transport.mkdir_multi([cfn(d) for d in dirs])
486
self.put_controlfiles(files)
487
mutter('created control directory in ' + self._transport.base)
488
489
def _check_format(self, relax_version_check):
490
"""Check this branch format is supported.
491
492
The format level is stored, as an integer, in
493
self._branch_format for code that needs to check it later.
494
495
In the future, we might need different in-memory Branch
496
classes to support downlevel branches. But not yet.
256
:return: Either a Branch, or None
497
257
"""
498
try:
499
fmt = self.controlfile('branch-format', 'r').read()
500
except NoSuchFile:
501
raise NotBranchError(path=self.base)
502
mutter("got branch format %r", fmt)
503
if fmt == BZR_BRANCH_FORMAT_6:
504
self._branch_format = 6
505
elif fmt == BZR_BRANCH_FORMAT_5:
506
self._branch_format = 5
507
elif fmt == BZR_BRANCH_FORMAT_4:
508
self._branch_format = 4
509
510
if (not relax_version_check
511
and self._branch_format not in (5, 6)):
512
raise errors.UnsupportedFormatError(
513
'sorry, branch format %r not supported' % fmt,
514
['use a different bzr version',
515
'or remove the .bzr directory'
516
' and "bzr init" again'])
258
return None
517
259
518
260
def get_root_id(self):
519
261
"""Return the id of this branches root"""
520
inv = self.read_working_inventory()
521
return inv.root.file_id
522
523
def set_root_id(self, file_id):
524
inv = self.read_working_inventory()
525
orig_root_id = inv.root.file_id
526
del inv._byid[inv.root.file_id]
527
inv.root.file_id = file_id
528
inv._byid[inv.root.file_id] = inv.root
529
for fid in inv:
530
entry = inv[fid]
531
if entry.parent_id in (None, orig_root_id):
532
entry.parent_id = inv.root.file_id
533
self._write_inventory(inv)
534
535
@needs_read_lock
536
def read_working_inventory(self):
537
"""Read the working inventory."""
538
# ElementTree does its own conversion from UTF-8, so open in
539
# binary.
540
f = self.controlfile('inventory', 'rb')
541
return bzrlib.xml5.serializer_v5.read_inventory(f)
542
543
@needs_write_lock
544
def _write_inventory(self, inv):
545
"""Update the working inventory.
546
547
That is to say, the inventory describing changes underway, that
548
will be committed to the next revision.
549
"""
550
from cStringIO import StringIO
551
sio = StringIO()
552
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
553
sio.seek(0)
554
# Transport handles atomicity
555
self.put_controlfile('inventory', sio)
556
557
mutter('wrote working inventory')
558
559
inventory = property(read_working_inventory, _write_inventory, None,
560
"""Inventory for the working copy.""")
561
562
@needs_write_lock
563
def add(self, files, ids=None):
564
"""Make files versioned.
565
566
Note that the command line normally calls smart_add instead,
567
which can automatically recurse.
568
569
This puts the files in the Added state, so that they will be
570
recorded by the next commit.
571
572
files
573
List of paths to add, relative to the base of the tree.
574
575
ids
576
If set, use these instead of automatically generated ids.
577
Must be the same length as the list of files, but may
578
contain None for ids that are to be autogenerated.
579
580
TODO: Perhaps have an option to add the ids even if the files do
581
not (yet) exist.
582
583
TODO: Perhaps yield the ids and paths as they're added.
584
"""
585
# TODO: Re-adding a file that is removed in the working copy
586
# should probably put it back with the previous ID.
587
if isinstance(files, basestring):
588
assert(ids is None or isinstance(ids, basestring))
589
files = [files]
590
if ids is not None:
591
ids = [ids]
592
593
if ids is None:
594
ids = [None] * len(files)
595
else:
596
assert(len(ids) == len(files))
597
598
inv = self.read_working_inventory()
599
for f,file_id in zip(files, ids):
600
if is_control_file(f):
601
raise BzrError("cannot add control file %s" % quotefn(f))
602
603
fp = splitpath(f)
604
605
if len(fp) == 0:
606
raise BzrError("cannot add top-level %r" % f)
607
608
fullpath = os.path.normpath(self.abspath(f))
609
610
try:
611
kind = file_kind(fullpath)
612
except OSError:
613
# maybe something better?
614
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
615
616
if not InventoryEntry.versionable_kind(kind):
617
raise BzrError('cannot add: not a versionable file ('
618
'i.e. regular file, symlink or directory): %s' % quotefn(f))
619
620
if file_id is None:
621
file_id = gen_file_id(f)
622
inv.add_path(f, kind=kind, file_id=file_id)
623
624
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
625
626
self._write_inventory(inv)
627
628
@needs_read_lock
629
def print_file(self, file, revno):
262
raise NotImplementedError('get_root_id is abstract')
263
264
def print_file(self, file, revision_id):
630
265
"""Print `file` to stdout."""
631
tree = self.revision_tree(self.get_rev_id(revno))
632
# use inventory as it was in that revision
633
file_id = tree.inventory.path2id(file)
634
if not file_id:
635
raise BzrError("%r is not present in revision %s" % (file, revno))
636
tree.print_file(file_id)
637
638
# FIXME: this doesn't need to be a branch method
639
def set_inventory(self, new_inventory_list):
640
from bzrlib.inventory import Inventory, InventoryEntry
641
inv = Inventory(self.get_root_id())
642
for path, file_id, parent, kind in new_inventory_list:
643
name = os.path.basename(path)
644
if name == "":
645
continue
646
# fixme, there should be a factory function inv,add_??
647
if kind == 'directory':
648
inv.add(inventory.InventoryDirectory(file_id, name, parent))
649
elif kind == 'file':
650
inv.add(inventory.InventoryFile(file_id, name, parent))
651
elif kind == 'symlink':
652
inv.add(inventory.InventoryLink(file_id, name, parent))
653
else:
654
raise BzrError("unknown kind %r" % kind)
655
self._write_inventory(inv)
656
657
def unknowns(self):
658
"""Return all unknown files.
659
660
These are files in the working directory that are not versioned or
661
control files or ignored.
662
663
>>> from bzrlib.workingtree import WorkingTree
664
>>> b = ScratchBranch(files=['foo', 'foo~'])
665
>>> map(str, b.unknowns())
666
['foo']
667
>>> b.add('foo')
668
>>> list(b.unknowns())
669
[]
670
>>> WorkingTree(b.base, b).remove('foo')
671
>>> list(b.unknowns())
672
[u'foo']
673
"""
674
return self.working_tree().unknowns()
675
676
@needs_write_lock
266
raise NotImplementedError('print_file is abstract')
267
677
268
def append_revision(self, *revision_ids):
678
for revision_id in revision_ids:
679
mutter("add {%s} to revision-history" % revision_id)
680
rev_history = self.revision_history()
681
rev_history.extend(revision_ids)
682
self.set_revision_history(rev_history)
269
raise NotImplementedError('append_revision is abstract')
683
270
684
@needs_write_lock
685
271
def set_revision_history(self, rev_history):
686
self.put_controlfile('revision-history', '\n'.join(rev_history))
687
688
def has_revision(self, revision_id):
689
"""True if this branch has a copy of the revision.
690
691
This does not necessarily imply the revision is merge
692
or on the mainline."""
693
return (revision_id is None
694
or self.revision_store.has_id(revision_id))
695
696
@needs_read_lock
697
def get_revision_xml_file(self, revision_id):
698
"""Return XML file object for revision object."""
699
if not revision_id or not isinstance(revision_id, basestring):
700
raise InvalidRevisionId(revision_id)
701
try:
702
return self.revision_store.get(revision_id)
703
except (IndexError, KeyError):
704
raise bzrlib.errors.NoSuchRevision(self, revision_id)
705
706
#deprecated
707
get_revision_xml = get_revision_xml_file
708
709
def get_revision_xml(self, revision_id):
710
return self.get_revision_xml_file(revision_id).read()
711
712
713
def get_revision(self, revision_id):
714
"""Return the Revision object for a named revision"""
715
xml_file = self.get_revision_xml_file(revision_id)
716
717
try:
718
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
719
except SyntaxError, e:
720
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
721
[revision_id,
722
str(e)])
723
724
assert r.revision_id == revision_id
725
return r
726
727
def get_revision_delta(self, revno):
728
"""Return the delta for one revision.
729
730
The delta is relative to its mainline predecessor, or the
731
empty tree for revision 1.
732
"""
733
assert isinstance(revno, int)
734
rh = self.revision_history()
735
if not (1 <= revno <= len(rh)):
736
raise InvalidRevisionNumber(revno)
737
738
# revno is 1-based; list is 0-based
739
740
new_tree = self.revision_tree(rh[revno-1])
741
if revno == 1:
742
old_tree = EmptyTree()
743
else:
744
old_tree = self.revision_tree(rh[revno-2])
745
746
return compare_trees(old_tree, new_tree)
747
748
def get_revision_sha1(self, revision_id):
749
"""Hash the stored value of a revision, and return it."""
750
# In the future, revision entries will be signed. At that
751
# point, it is probably best *not* to include the signature
752
# in the revision hash. Because that lets you re-sign
753
# the revision, (add signatures/remove signatures) and still
754
# have all hash pointers stay consistent.
755
# But for now, just hash the contents.
756
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
757
758
def get_ancestry(self, revision_id):
759
"""Return a list of revision-ids integrated by a revision.
760
761
This currently returns a list, but the ordering is not guaranteed:
762
treat it as a set.
763
"""
764
if revision_id is None:
765
return [None]
766
w = self.get_inventory_weave()
767
return [None] + map(w.idx_to_name,
768
w.inclusions([w.lookup(revision_id)]))
769
770
def get_inventory_weave(self):
771
return self.control_weaves.get_weave('inventory',
772
self.get_transaction())
773
774
def get_inventory(self, revision_id):
775
"""Get Inventory object by hash."""
776
xml = self.get_inventory_xml(revision_id)
777
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
778
779
def get_inventory_xml(self, revision_id):
780
"""Get inventory XML as a file object."""
781
try:
782
assert isinstance(revision_id, basestring), type(revision_id)
783
iw = self.get_inventory_weave()
784
return iw.get_text(iw.lookup(revision_id))
785
except IndexError:
786
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
787
788
def get_inventory_sha1(self, revision_id):
789
"""Return the sha1 hash of the inventory entry
790
"""
791
return self.get_revision(revision_id).inventory_sha1
792
793
def get_revision_inventory(self, revision_id):
794
"""Return inventory of a past revision."""
795
# TODO: Unify this with get_inventory()
796
# bzr 0.0.6 and later imposes the constraint that the inventory_id
797
# must be the same as its revision, so this is trivial.
798
if revision_id == None:
799
return Inventory(self.get_root_id())
800
else:
801
return self.get_inventory(revision_id)
802
803
@needs_read_lock
272
raise NotImplementedError('set_revision_history is abstract')
273
804
274
def revision_history(self):
805
275
"""Return sequence of revision hashes on to this branch."""
806
transaction = self.get_transaction()
807
history = transaction.map.find_revision_history()
808
if history is not None:
809
mutter("cache hit for revision-history in %s", self)
810
return list(history)
811
history = [l.rstrip('\r\n') for l in
812
self.controlfile('revision-history', 'r').readlines()]
813
transaction.map.add_revision_history(history)
814
# this call is disabled because revision_history is
815
# not really an object yet, and the transaction is for objects.
816
# transaction.register_clean(history, precious=True)
817
return list(history)
276
raise NotImplementedError('revision_history is abstract')
818
277
819
278
def revno(self):
820
279
"""Return current revision number for this branch.
824
283
"""
825
284
return len(self.revision_history())
826
285
286
def unbind(self):
287
"""Older format branches cannot bind or unbind."""
288
raise errors.UpgradeRequired(self.base)
289
827
290
def last_revision(self):
828
"""Return last patch hash, or None if no history.
829
"""
291
"""Return last patch hash, or None if no history."""
830
292
ph = self.revision_history()
831
293
if ph:
832
294
return ph[-1]
833
295
else:
834
296
return None
835
297
836
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
298
def missing_revisions(self, other, stop_revision=None):
837
299
"""Return a list of new revisions that would perfectly fit.
838
300
839
301
If self and other have not diverged, return a list of the revisions
840
302
present in other, but missing from self.
841
303
842
>>> from bzrlib.commit import commit
304
>>> from bzrlib.workingtree import WorkingTree
843
305
>>> bzrlib.trace.silent = True
844
>>> br1 = ScratchBranch()
845
>>> br2 = ScratchBranch()
306
>>> d1 = bzrdir.ScratchDir()
307
>>> br1 = d1.open_branch()
308
>>> wt1 = d1.open_workingtree()
309
>>> d2 = bzrdir.ScratchDir()
310
>>> br2 = d2.open_branch()
311
>>> wt2 = d2.open_workingtree()
846
312
>>> br1.missing_revisions(br2)
847
313
[]
848
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
314
>>> wt2.commit("lala!", rev_id="REVISION-ID-1")
849
315
>>> br1.missing_revisions(br2)
850
316
[u'REVISION-ID-1']
851
317
>>> br2.missing_revisions(br1)
852
318
[]
853
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
319
>>> wt1.commit("lala!", rev_id="REVISION-ID-1")
854
320
>>> br1.missing_revisions(br2)
855
321
[]
856
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
322
>>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
857
323
>>> br1.missing_revisions(br2)
858
324
[u'REVISION-ID-2A']
859
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
325
>>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
860
326
>>> br1.missing_revisions(br2)
861
327
Traceback (most recent call last):
862
DivergedBranches: These branches have diverged.
328
DivergedBranches: These branches have diverged. Try merge.
863
329
"""
864
330
self_history = self.revision_history()
865
331
self_len = len(self_history)
879
345
return other_history[self_len:stop_revision]
880
346
881
347
def update_revisions(self, other, stop_revision=None):
882
"""Pull in new perfect-fit revisions."""
883
# FIXME: If the branches have diverged, but the latest
884
# revision in this branch is completely merged into the other,
885
# then we should still be able to pull.
886
from bzrlib.fetch import greedy_fetch
887
if stop_revision is None:
888
stop_revision = other.last_revision()
889
### Should this be checking is_ancestor instead of revision_history?
890
if (stop_revision is not None and
891
stop_revision in self.revision_history()):
892
return
893
greedy_fetch(to_branch=self, from_branch=other,
894
revision=stop_revision)
895
pullable_revs = self.pullable_revisions(other, stop_revision)
896
if len(pullable_revs) > 0:
897
self.append_revision(*pullable_revs)
898
899
def pullable_revisions(self, other, stop_revision):
900
other_revno = other.revision_id_to_revno(stop_revision)
901
try:
902
return self.missing_revisions(other, other_revno)
903
except DivergedBranches, e:
904
try:
905
pullable_revs = get_intervening_revisions(self.last_revision(),
906
stop_revision, self)
907
assert self.last_revision() not in pullable_revs
908
return pullable_revs
909
except bzrlib.errors.NotAncestor:
910
if is_ancestor(self.last_revision(), stop_revision, self):
911
return []
912
else:
913
raise e
914
915
def commit(self, *args, **kw):
916
from bzrlib.commit import Commit
917
Commit().commit(self, *args, **kw)
918
348
"""Pull in new perfect-fit revisions.
349
350
:param other: Another Branch to pull from
351
:param stop_revision: Updated until the given revision
352
:return: None
353
"""
354
raise NotImplementedError('update_revisions is abstract')
355
919
356
def revision_id_to_revno(self, revision_id):
920
357
"""Given a revision id, return its revno"""
921
358
if revision_id is None:
936
373
raise bzrlib.errors.NoSuchRevision(self, revno)
937
374
return history[revno - 1]
938
375
939
def revision_tree(self, revision_id):
940
"""Return Tree for a revision on this branch.
941
942
`revision_id` may be None for the null revision, in which case
943
an `EmptyTree` is returned."""
944
# TODO: refactor this to use an existing revision object
945
# so we don't need to read it in twice.
946
if revision_id == None:
947
return EmptyTree()
948
else:
949
inv = self.get_revision_inventory(revision_id)
950
return RevisionTree(self.weave_store, inv, revision_id)
951
952
def working_tree(self):
953
"""Return a `Tree` for the working copy."""
954
from bzrlib.workingtree import WorkingTree
955
# TODO: In the future, perhaps WorkingTree should utilize Transport
956
# RobertCollins 20051003 - I don't think it should - working trees are
957
# much more complex to keep consistent than our careful .bzr subset.
958
# instead, we should say that working trees are local only, and optimise
959
# for that.
960
return WorkingTree(self.base, branch=self)
961
376
def pull(self, source, overwrite=False, stop_revision=None):
377
raise NotImplementedError('pull is abstract')
962
378
963
379
def basis_tree(self):
964
380
"""Return `Tree` object for last revision.
965
381
966
382
If there are no revisions yet, return an `EmptyTree`.
967
383
"""
968
return self.revision_tree(self.last_revision())
384
return self.repository.revision_tree(self.last_revision())
969
385
970
@needs_write_lock
971
386
def rename_one(self, from_rel, to_rel):
972
387
"""Rename one file.
973
388
974
389
This can change the directory or the filename or both.
975
390
"""
976
tree = self.working_tree()
977
inv = tree.inventory
978
if not tree.has_filename(from_rel):
979
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
980
if tree.has_filename(to_rel):
981
raise BzrError("can't rename: new working file %r already exists" % to_rel)
982
983
file_id = inv.path2id(from_rel)
984
if file_id == None:
985
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
986
987
if inv.path2id(to_rel):
988
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
989
990
to_dir, to_tail = os.path.split(to_rel)
991
to_dir_id = inv.path2id(to_dir)
992
if to_dir_id == None and to_dir != '':
993
raise BzrError("can't determine destination directory id for %r" % to_dir)
994
995
mutter("rename_one:")
996
mutter(" file_id {%s}" % file_id)
997
mutter(" from_rel %r" % from_rel)
998
mutter(" to_rel %r" % to_rel)
999
mutter(" to_dir %r" % to_dir)
1000
mutter(" to_dir_id {%s}" % to_dir_id)
1001
1002
inv.rename(file_id, to_dir_id, to_tail)
1003
1004
from_abs = self.abspath(from_rel)
1005
to_abs = self.abspath(to_rel)
1006
try:
1007
rename(from_abs, to_abs)
1008
except OSError, e:
1009
raise BzrError("failed to rename %r to %r: %s"
1010
% (from_abs, to_abs, e[1]),
1011
["rename rolled back"])
1012
1013
self._write_inventory(inv)
1014
1015
@needs_write_lock
391
raise NotImplementedError('rename_one is abstract')
392
1016
393
def move(self, from_paths, to_name):
1017
394
"""Rename files.
1018
395
1027
404
This returns a list of (from_path, to_path) pairs for each
1028
405
entry that is moved.
1029
406
"""
1030
result = []
1031
## TODO: Option to move IDs only
1032
assert not isinstance(from_paths, basestring)
1033
tree = self.working_tree()
1034
inv = tree.inventory
1035
to_abs = self.abspath(to_name)
1036
if not isdir(to_abs):
1037
raise BzrError("destination %r is not a directory" % to_abs)
1038
if not tree.has_filename(to_name):
1039
raise BzrError("destination %r not in working directory" % to_abs)
1040
to_dir_id = inv.path2id(to_name)
1041
if to_dir_id == None and to_name != '':
1042
raise BzrError("destination %r is not a versioned directory" % to_name)
1043
to_dir_ie = inv[to_dir_id]
1044
if to_dir_ie.kind not in ('directory', 'root_directory'):
1045
raise BzrError("destination %r is not a directory" % to_abs)
1046
1047
to_idpath = inv.get_idpath(to_dir_id)
1048
1049
for f in from_paths:
1050
if not tree.has_filename(f):
1051
raise BzrError("%r does not exist in working tree" % f)
1052
f_id = inv.path2id(f)
1053
if f_id == None:
1054
raise BzrError("%r is not versioned" % f)
1055
name_tail = splitpath(f)[-1]
1056
dest_path = appendpath(to_name, name_tail)
1057
if tree.has_filename(dest_path):
1058
raise BzrError("destination %r already exists" % dest_path)
1059
if f_id in to_idpath:
1060
raise BzrError("can't move %r to a subdirectory of itself" % f)
1061
1062
# OK, so there's a race here, it's possible that someone will
1063
# create a file in this interval and then the rename might be
1064
# left half-done. But we should have caught most problems.
1065
1066
for f in from_paths:
1067
name_tail = splitpath(f)[-1]
1068
dest_path = appendpath(to_name, name_tail)
1069
result.append((f, dest_path))
1070
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1071
try:
1072
rename(self.abspath(f), self.abspath(dest_path))
1073
except OSError, e:
1074
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1075
["rename rolled back"])
1076
1077
self._write_inventory(inv)
1078
return result
1079
1080
1081
def revert(self, filenames, old_tree=None, backups=True):
1082
"""Restore selected files to the versions from a previous tree.
1083
1084
backups
1085
If true (default) backups are made of files before
1086
they're renamed.
1087
"""
1088
from bzrlib.atomicfile import AtomicFile
1089
from bzrlib.osutils import backup_file
1090
1091
inv = self.read_working_inventory()
1092
if old_tree is None:
1093
old_tree = self.basis_tree()
1094
old_inv = old_tree.inventory
1095
1096
nids = []
1097
for fn in filenames:
1098
file_id = inv.path2id(fn)
1099
if not file_id:
1100
raise NotVersionedError(path=fn)
1101
if not old_inv.has_id(file_id):
1102
raise BzrError("file not present in old tree", fn, file_id)
1103
nids.append((fn, file_id))
1104
1105
# TODO: Rename back if it was previously at a different location
1106
1107
# TODO: If given a directory, restore the entire contents from
1108
# the previous version.
1109
1110
# TODO: Make a backup to a temporary file.
1111
1112
# TODO: If the file previously didn't exist, delete it?
1113
for fn, file_id in nids:
1114
backup_file(fn)
1115
1116
f = AtomicFile(fn, 'wb')
1117
try:
1118
f.write(old_tree.get_file(file_id).read())
1119
f.commit()
1120
finally:
1121
f.close()
1122
1123
1124
def pending_merges(self):
1125
"""Return a list of pending merges.
1126
1127
These are revisions that have been merged into the working
1128
directory but not yet committed.
1129
"""
1130
cfn = self._rel_controlfilename('pending-merges')
1131
if not self._transport.has(cfn):
1132
return []
1133
p = []
1134
for l in self.controlfile('pending-merges', 'r').readlines():
1135
p.append(l.rstrip('\n'))
1136
return p
1137
1138
1139
def add_pending_merge(self, *revision_ids):
1140
# TODO: Perhaps should check at this point that the
1141
# history of the revision is actually present?
1142
p = self.pending_merges()
1143
updated = False
1144
for rev_id in revision_ids:
1145
if rev_id in p:
1146
continue
1147
p.append(rev_id)
1148
updated = True
1149
if updated:
1150
self.set_pending_merges(p)
1151
1152
@needs_write_lock
1153
def set_pending_merges(self, rev_list):
1154
self.put_controlfile('pending-merges', '\n'.join(rev_list))
407
raise NotImplementedError('move is abstract')
1155
408
1156
409
def get_parent(self):
1157
410
"""Return the parent location of the branch.
1160
413
pattern is that the user can override it by specifying a
1161
414
location.
1162
415
"""
1163
import errno
1164
_locs = ['parent', 'pull', 'x-pull']
1165
for l in _locs:
1166
try:
1167
return self.controlfile(l, 'r').read().strip('\n')
1168
except IOError, e:
1169
if e.errno != errno.ENOENT:
1170
raise
416
raise NotImplementedError('get_parent is abstract')
417
418
def get_push_location(self):
419
"""Return the None or the location to push this branch to."""
420
raise NotImplementedError('get_push_location is abstract')
421
422
def set_push_location(self, location):
423
"""Set a new push location for this branch."""
424
raise NotImplementedError('set_push_location is abstract')
425
426
def set_parent(self, url):
427
raise NotImplementedError('set_parent is abstract')
428
429
@needs_write_lock
430
def update(self):
431
"""Synchronise this branch with the master branch if any.
432
433
:return: None or the last_revision pivoted out during the update.
434
"""
1171
435
return None
1172
436
1173
@needs_write_lock
1174
def set_parent(self, url):
1175
# TODO: Maybe delete old location files?
1176
from bzrlib.atomicfile import AtomicFile
1177
f = AtomicFile(self.controlfilename('parent'))
1178
try:
1179
f.write(url + '\n')
1180
f.commit()
1181
finally:
1182
f.close()
1183
1184
437
def check_revno(self, revno):
1185
438
"""\
1186
439
Check whether a revno corresponds to any revision.
1196
449
"""
1197
450
if revno < 1 or revno > self.revno():
1198
451
raise InvalidRevisionNumber(revno)
1199
1200
def sign_revision(self, revision_id, gpg_strategy):
1201
plaintext = Testament.from_revision(self, revision_id).as_short_text()
1202
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1203
1204
@needs_write_lock
1205
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1206
self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)),
1207
revision_id, "sig")
1208
1209
1210
class ScratchBranch(_Branch):
1211
"""Special test class: a branch that cleans up after itself.
1212
1213
>>> b = ScratchBranch()
1214
>>> isdir(b.base)
1215
True
1216
>>> bd = b.base
1217
>>> b._transport.__del__()
1218
>>> isdir(bd)
1219
False
1220
"""
1221
1222
def __init__(self, files=[], dirs=[], transport=None):
1223
"""Make a test branch.
1224
1225
This creates a temporary directory and runs init-tree in it.
1226
1227
If any files are listed, they are created in the working copy.
1228
"""
1229
if transport is None:
1230
transport = bzrlib.transport.local.ScratchTransport()
1231
super(ScratchBranch, self).__init__(transport, init=True)
1232
else:
1233
super(ScratchBranch, self).__init__(transport)
1234
1235
for d in dirs:
1236
self._transport.mkdir(d)
1237
1238
for f in files:
1239
self._transport.put(f, 'content of %s' % f)
1240
1241
1242
def clone(self):
1243
"""
1244
>>> orig = ScratchBranch(files=["file1", "file2"])
1245
>>> clone = orig.clone()
1246
>>> if os.name != 'nt':
1247
... os.path.samefile(orig.base, clone.base)
1248
... else:
1249
... orig.base == clone.base
1250
...
1251
False
1252
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1253
True
1254
"""
1255
from shutil import copytree
1256
from tempfile import mkdtemp
1257
base = mkdtemp()
1258
os.rmdir(base)
1259
copytree(self.base, base, symlinks=True)
1260
return ScratchBranch(
1261
transport=bzrlib.transport.local.ScratchTransport(base))
1262
452
453
@needs_read_lock
454
def clone(self, *args, **kwargs):
455
"""Clone this branch into to_bzrdir preserving all semantic values.
456
457
revision_id: if not None, the revision history in the new branch will
458
be truncated to end with revision_id.
459
"""
460
# for API compatability, until 0.8 releases we provide the old api:
461
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
462
# after 0.8 releases, the *args and **kwargs should be changed:
463
# def clone(self, to_bzrdir, revision_id=None):
464
if (kwargs.get('to_location', None) or
465
kwargs.get('revision', None) or
466
kwargs.get('basis_branch', None) or
467
(len(args) and isinstance(args[0], basestring))):
468
# backwards compatability api:
469
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
470
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
471
# get basis_branch
472
if len(args) > 2:
473
basis_branch = args[2]
474
else:
475
basis_branch = kwargs.get('basis_branch', None)
476
if basis_branch:
477
basis = basis_branch.bzrdir
478
else:
479
basis = None
480
# get revision
481
if len(args) > 1:
482
revision_id = args[1]
483
else:
484
revision_id = kwargs.get('revision', None)
485
# get location
486
if len(args):
487
url = args[0]
488
else:
489
# no default to raise if not provided.
490
url = kwargs.get('to_location')
491
return self.bzrdir.clone(url,
492
revision_id=revision_id,
493
basis=basis).open_branch()
494
# new cleaner api.
495
# generate args by hand
496
if len(args) > 1:
497
revision_id = args[1]
498
else:
499
revision_id = kwargs.get('revision_id', None)
500
if len(args):
501
to_bzrdir = args[0]
502
else:
503
# no default to raise if not provided.
504
to_bzrdir = kwargs.get('to_bzrdir')
505
result = self._format.initialize(to_bzrdir)
506
self.copy_content_into(result, revision_id=revision_id)
507
return result
508
509
@needs_read_lock
510
def sprout(self, to_bzrdir, revision_id=None):
511
"""Create a new line of development from the branch, into to_bzrdir.
512
513
revision_id: if not None, the revision history in the new branch will
514
be truncated to end with revision_id.
515
"""
516
result = self._format.initialize(to_bzrdir)
517
self.copy_content_into(result, revision_id=revision_id)
518
result.set_parent(self.bzrdir.root_transport.base)
519
return result
520
521
@needs_read_lock
522
def copy_content_into(self, destination, revision_id=None):
523
"""Copy the content of self into destination.
524
525
revision_id: if not None, the revision history in the new branch will
526
be truncated to end with revision_id.
527
"""
528
new_history = self.revision_history()
529
if revision_id is not None:
530
try:
531
new_history = new_history[:new_history.index(revision_id) + 1]
532
except ValueError:
533
rev = self.repository.get_revision(revision_id)
534
new_history = rev.get_history(self.repository)[1:]
535
destination.set_revision_history(new_history)
536
parent = self.get_parent()
537
if parent:
538
destination.set_parent(parent)
539
540
541
class BranchFormat(object):
542
"""An encapsulation of the initialization and open routines for a format.
543
544
Formats provide three things:
545
* An initialization routine,
546
* a format string,
547
* an open routine.
548
549
Formats are placed in an dict by their format string for reference
550
during branch opening. Its not required that these be instances, they
551
can be classes themselves with class methods - it simply depends on
552
whether state is needed for a given format or not.
553
554
Once a format is deprecated, just deprecate the initialize and open
555
methods on the format class. Do not deprecate the object, as the
556
object will be created every time regardless.
557
"""
558
559
_default_format = None
560
"""The default format used for new branches."""
561
562
_formats = {}
563
"""The known formats."""
564
565
@classmethod
566
def find_format(klass, a_bzrdir):
567
"""Return the format for the branch object in a_bzrdir."""
568
try:
569
transport = a_bzrdir.get_branch_transport(None)
570
format_string = transport.get("format").read()
571
return klass._formats[format_string]
572
except NoSuchFile:
573
raise NotBranchError(path=transport.base)
574
except KeyError:
575
raise errors.UnknownFormatError(format_string)
576
577
@classmethod
578
def get_default_format(klass):
579
"""Return the current default format."""
580
return klass._default_format
581
582
def get_format_string(self):
583
"""Return the ASCII format string that identifies this format."""
584
raise NotImplementedError(self.get_format_string)
585
586
def get_format_description(self):
587
"""Return the short format description for this format."""
588
raise NotImplementedError(self.get_format_string)
589
590
def initialize(self, a_bzrdir):
591
"""Create a branch of this format in a_bzrdir."""
592
raise NotImplementedError(self.initialized)
593
594
def is_supported(self):
595
"""Is this format supported?
596
597
Supported formats can be initialized and opened.
598
Unsupported formats may not support initialization or committing or
599
some other features depending on the reason for not being supported.
600
"""
601
return True
602
603
def open(self, a_bzrdir, _found=False):
604
"""Return the branch object for a_bzrdir
605
606
_found is a private parameter, do not use it. It is used to indicate
607
if format probing has already be done.
608
"""
609
raise NotImplementedError(self.open)
610
611
@classmethod
612
def register_format(klass, format):
613
klass._formats[format.get_format_string()] = format
614
615
@classmethod
616
def set_default_format(klass, format):
617
klass._default_format = format
618
619
@classmethod
620
def unregister_format(klass, format):
621
assert klass._formats[format.get_format_string()] is format
622
del klass._formats[format.get_format_string()]
623
624
def __str__(self):
625
return self.get_format_string().rstrip()
626
627
628
class BzrBranchFormat4(BranchFormat):
629
"""Bzr branch format 4.
630
631
This format has:
632
- a revision-history file.
633
- a branch-lock lock file [ to be shared with the bzrdir ]
634
"""
635
636
def get_format_description(self):
637
"""See BranchFormat.get_format_description()."""
638
return "Branch format 4"
639
640
def initialize(self, a_bzrdir):
641
"""Create a branch of this format in a_bzrdir."""
642
mutter('creating branch in %s', a_bzrdir.transport.base)
643
branch_transport = a_bzrdir.get_branch_transport(self)
644
utf8_files = [('revision-history', ''),
645
('branch-name', ''),
646
]
647
control_files = LockableFiles(branch_transport, 'branch-lock',
648
TransportLock)
649
control_files.create_lock()
650
control_files.lock_write()
651
try:
652
for file, content in utf8_files:
653
control_files.put_utf8(file, content)
654
finally:
655
control_files.unlock()
656
return self.open(a_bzrdir, _found=True)
657
658
def __init__(self):
659
super(BzrBranchFormat4, self).__init__()
660
self._matchingbzrdir = bzrdir.BzrDirFormat6()
661
662
def open(self, a_bzrdir, _found=False):
663
"""Return the branch object for a_bzrdir
664
665
_found is a private parameter, do not use it. It is used to indicate
666
if format probing has already be done.
667
"""
668
if not _found:
669
# we are being called directly and must probe.
670
raise NotImplementedError
671
return BzrBranch(_format=self,
672
_control_files=a_bzrdir._control_files,
673
a_bzrdir=a_bzrdir,
674
_repository=a_bzrdir.open_repository())
675
676
def __str__(self):
677
return "Bazaar-NG branch format 4"
678
679
680
class BzrBranchFormat5(BranchFormat):
681
"""Bzr branch format 5.
682
683
This format has:
684
- a revision-history file.
685
- a format string
686
- a lock dir guarding the branch itself
687
- all of this stored in a branch/ subdirectory
688
- works with shared repositories.
689
690
This format is new in bzr 0.8.
691
"""
692
693
def get_format_string(self):
694
"""See BranchFormat.get_format_string()."""
695
return "Bazaar-NG branch format 5\n"
696
697
def get_format_description(self):
698
"""See BranchFormat.get_format_description()."""
699
return "Branch format 5"
700
701
def initialize(self, a_bzrdir):
702
"""Create a branch of this format in a_bzrdir."""
703
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
704
branch_transport = a_bzrdir.get_branch_transport(self)
705
utf8_files = [('revision-history', ''),
706
('branch-name', ''),
707
]
708
control_files = LockableFiles(branch_transport, 'lock', LockDir)
709
control_files.create_lock()
710
control_files.lock_write()
711
control_files.put_utf8('format', self.get_format_string())
712
try:
713
for file, content in utf8_files:
714
control_files.put_utf8(file, content)
715
finally:
716
control_files.unlock()
717
return self.open(a_bzrdir, _found=True, )
718
719
def __init__(self):
720
super(BzrBranchFormat5, self).__init__()
721
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
722
723
def open(self, a_bzrdir, _found=False):
724
"""Return the branch object for a_bzrdir
725
726
_found is a private parameter, do not use it. It is used to indicate
727
if format probing has already be done.
728
"""
729
if not _found:
730
format = BranchFormat.find_format(a_bzrdir)
731
assert format.__class__ == self.__class__
732
transport = a_bzrdir.get_branch_transport(None)
733
control_files = LockableFiles(transport, 'lock', LockDir)
734
return BzrBranch5(_format=self,
735
_control_files=control_files,
736
a_bzrdir=a_bzrdir,
737
_repository=a_bzrdir.find_repository())
738
739
def __str__(self):
740
return "Bazaar-NG Metadir branch format 5"
741
742
743
class BranchReferenceFormat(BranchFormat):
744
"""Bzr branch reference format.
745
746
Branch references are used in implementing checkouts, they
747
act as an alias to the real branch which is at some other url.
748
749
This format has:
750
- A location file
751
- a format string
752
"""
753
754
def get_format_string(self):
755
"""See BranchFormat.get_format_string()."""
756
return "Bazaar-NG Branch Reference Format 1\n"
757
758
def get_format_description(self):
759
"""See BranchFormat.get_format_description()."""
760
return "Checkout reference format 1"
761
762
def initialize(self, a_bzrdir, target_branch=None):
763
"""Create a branch of this format in a_bzrdir."""
764
if target_branch is None:
765
# this format does not implement branch itself, thus the implicit
766
# creation contract must see it as uninitializable
767
raise errors.UninitializableFormat(self)
768
mutter('creating branch reference in %s', a_bzrdir.transport.base)
769
branch_transport = a_bzrdir.get_branch_transport(self)
770
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
771
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
772
branch_transport.put('format', StringIO(self.get_format_string()))
773
return self.open(a_bzrdir, _found=True)
774
775
def __init__(self):
776
super(BranchReferenceFormat, self).__init__()
777
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
778
779
def _make_reference_clone_function(format, a_branch):
780
"""Create a clone() routine for a branch dynamically."""
781
def clone(to_bzrdir, revision_id=None):
782
"""See Branch.clone()."""
783
return format.initialize(to_bzrdir, a_branch)
784
# cannot obey revision_id limits when cloning a reference ...
785
# FIXME RBC 20060210 either nuke revision_id for clone, or
786
# emit some sort of warning/error to the caller ?!
787
return clone
788
789
def open(self, a_bzrdir, _found=False):
790
"""Return the branch that the branch reference in a_bzrdir points at.
791
792
_found is a private parameter, do not use it. It is used to indicate
793
if format probing has already be done.
794
"""
795
if not _found:
796
format = BranchFormat.find_format(a_bzrdir)
797
assert format.__class__ == self.__class__
798
transport = a_bzrdir.get_branch_transport(None)
799
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
800
result = real_bzrdir.open_branch()
801
# this changes the behaviour of result.clone to create a new reference
802
# rather than a copy of the content of the branch.
803
# I did not use a proxy object because that needs much more extensive
804
# testing, and we are only changing one behaviour at the moment.
805
# If we decide to alter more behaviours - i.e. the implicit nickname
806
# then this should be refactored to introduce a tested proxy branch
807
# and a subclass of that for use in overriding clone() and ....
808
# - RBC 20060210
809
result.clone = self._make_reference_clone_function(result)
810
return result
811
812
813
# formats which have no format string are not discoverable
814
# and not independently creatable, so are not registered.
815
__default_format = BzrBranchFormat5()
816
BranchFormat.register_format(__default_format)
817
BranchFormat.register_format(BranchReferenceFormat())
818
BranchFormat.set_default_format(__default_format)
819
_legacy_formats = [BzrBranchFormat4(),
820
]
821
822
class BzrBranch(Branch):
823
"""A branch stored in the actual filesystem.
824
825
Note that it's "local" in the context of the filesystem; it doesn't
826
really matter if it's on an nfs/smb/afs/coda/... share, as long as
827
it's writable, and can be accessed via the normal filesystem API.
828
"""
829
830
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
831
relax_version_check=DEPRECATED_PARAMETER, _format=None,
832
_control_files=None, a_bzrdir=None, _repository=None):
833
"""Create new branch object at a particular location.
834
835
transport -- A Transport object, defining how to access files.
836
837
init -- If True, create new control files in a previously
838
unversioned directory. If False, the branch must already
839
be versioned.
840
841
relax_version_check -- If true, the usual check for the branch
842
version is not applied. This is intended only for
843
upgrade/recovery type use; it's not guaranteed that
844
all operations will work on old format branches.
845
"""
846
if a_bzrdir is None:
847
self.bzrdir = bzrdir.BzrDir.open(transport.base)
848
else:
849
self.bzrdir = a_bzrdir
850
self._transport = self.bzrdir.transport.clone('..')
851
self._base = self._transport.base
852
self._format = _format
853
if _control_files is None:
854
raise BzrBadParameterMissing('_control_files')
855
self.control_files = _control_files
856
if deprecated_passed(init):
857
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
858
"deprecated as of bzr 0.8. Please use Branch.create().",
859
DeprecationWarning,
860
stacklevel=2)
861
if init:
862
# this is slower than before deprecation, oh well never mind.
863
# -> its deprecated.
864
self._initialize(transport.base)
865
self._check_format(_format)
866
if deprecated_passed(relax_version_check):
867
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
868
"relax_version_check parameter is deprecated as of bzr 0.8. "
869
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
870
"open() method.",
871
DeprecationWarning,
872
stacklevel=2)
873
if (not relax_version_check
874
and not self._format.is_supported()):
875
raise errors.UnsupportedFormatError(
876
'sorry, branch format %r not supported' % fmt,
877
['use a different bzr version',
878
'or remove the .bzr directory'
879
' and "bzr init" again'])
880
if deprecated_passed(transport):
881
warn("BzrBranch.__init__(transport=XXX...): The transport "
882
"parameter is deprecated as of bzr 0.8. "
883
"Please use Branch.open, or bzrdir.open_branch().",
884
DeprecationWarning,
885
stacklevel=2)
886
self.repository = _repository
887
888
def __str__(self):
889
return '%s(%r)' % (self.__class__.__name__, self.base)
890
891
__repr__ = __str__
892
893
def __del__(self):
894
# TODO: It might be best to do this somewhere else,
895
# but it is nice for a Branch object to automatically
896
# cache it's information.
897
# Alternatively, we could have the Transport objects cache requests
898
# See the earlier discussion about how major objects (like Branch)
899
# should never expect their __del__ function to run.
900
# XXX: cache_root seems to be unused, 2006-01-13 mbp
901
if hasattr(self, 'cache_root') and self.cache_root is not None:
902
try:
903
rmtree(self.cache_root)
904
except:
905
pass
906
self.cache_root = None
907
908
def _get_base(self):
909
return self._base
910
911
base = property(_get_base, doc="The URL for the root of this branch.")
912
913
def _finish_transaction(self):
914
"""Exit the current transaction."""
915
return self.control_files._finish_transaction()
916
917
def get_transaction(self):
918
"""Return the current active transaction.
919
920
If no transaction is active, this returns a passthrough object
921
for which all data is immediately flushed and no caching happens.
922
"""
923
# this is an explicit function so that we can do tricky stuff
924
# when the storage in rev_storage is elsewhere.
925
# we probably need to hook the two 'lock a location' and
926
# 'have a transaction' together more delicately, so that
927
# we can have two locks (branch and storage) and one transaction
928
# ... and finishing the transaction unlocks both, but unlocking
929
# does not. - RBC 20051121
930
return self.control_files.get_transaction()
931
932
def _set_transaction(self, transaction):
933
"""Set a new active transaction."""
934
return self.control_files._set_transaction(transaction)
935
936
def abspath(self, name):
937
"""See Branch.abspath."""
938
return self.control_files._transport.abspath(name)
939
940
def _check_format(self, format):
941
"""Identify the branch format if needed.
942
943
The format is stored as a reference to the format object in
944
self._format for code that needs to check it later.
945
946
The format parameter is either None or the branch format class
947
used to open this branch.
948
949
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
950
"""
951
if format is None:
952
format = BzrBranchFormat.find_format(self.bzrdir)
953
self._format = format
954
mutter("got branch format %s", self._format)
955
956
@needs_read_lock
957
def get_root_id(self):
958
"""See Branch.get_root_id."""
959
tree = self.repository.revision_tree(self.last_revision())
960
return tree.inventory.root.file_id
961
962
def is_locked(self):
963
return self.control_files.is_locked()
964
965
def lock_write(self):
966
# TODO: test for failed two phase locks. This is known broken.
967
self.control_files.lock_write()
968
self.repository.lock_write()
969
970
def lock_read(self):
971
# TODO: test for failed two phase locks. This is known broken.
972
self.control_files.lock_read()
973
self.repository.lock_read()
974
975
def unlock(self):
976
# TODO: test for failed two phase locks. This is known broken.
977
try:
978
self.repository.unlock()
979
finally:
980
self.control_files.unlock()
981
982
def peek_lock_mode(self):
983
if self.control_files._lock_count == 0:
984
return None
985
else:
986
return self.control_files._lock_mode
987
988
def get_physical_lock_status(self):
989
return self.control_files.get_physical_lock_status()
990
991
@needs_read_lock
992
def print_file(self, file, revision_id):
993
"""See Branch.print_file."""
994
return self.repository.print_file(file, revision_id)
995
996
@needs_write_lock
997
def append_revision(self, *revision_ids):
998
"""See Branch.append_revision."""
999
for revision_id in revision_ids:
1000
mutter("add {%s} to revision-history" % revision_id)
1001
rev_history = self.revision_history()
1002
rev_history.extend(revision_ids)
1003
self.set_revision_history(rev_history)
1004
1005
@needs_write_lock
1006
def set_revision_history(self, rev_history):
1007
"""See Branch.set_revision_history."""
1008
self.control_files.put_utf8(
1009
'revision-history', '\n'.join(rev_history))
1010
transaction = self.get_transaction()
1011
history = transaction.map.find_revision_history()
1012
if history is not None:
1013
# update the revision history in the identity map.
1014
history[:] = list(rev_history)
1015
# this call is disabled because revision_history is
1016
# not really an object yet, and the transaction is for objects.
1017
# transaction.register_dirty(history)
1018
else:
1019
transaction.map.add_revision_history(rev_history)
1020
# this call is disabled because revision_history is
1021
# not really an object yet, and the transaction is for objects.
1022
# transaction.register_clean(history)
1023
1024
def get_revision_delta(self, revno):
1025
"""Return the delta for one revision.
1026
1027
The delta is relative to its mainline predecessor, or the
1028
empty tree for revision 1.
1029
"""
1030
assert isinstance(revno, int)
1031
rh = self.revision_history()
1032
if not (1 <= revno <= len(rh)):
1033
raise InvalidRevisionNumber(revno)
1034
1035
# revno is 1-based; list is 0-based
1036
1037
new_tree = self.repository.revision_tree(rh[revno-1])
1038
if revno == 1:
1039
old_tree = EmptyTree()
1040
else:
1041
old_tree = self.repository.revision_tree(rh[revno-2])
1042
return compare_trees(old_tree, new_tree)
1043
1044
@needs_read_lock
1045
def revision_history(self):
1046
"""See Branch.revision_history."""
1047
transaction = self.get_transaction()
1048
history = transaction.map.find_revision_history()
1049
if history is not None:
1050
mutter("cache hit for revision-history in %s", self)
1051
return list(history)
1052
history = [l.rstrip('\r\n') for l in
1053
self.control_files.get_utf8('revision-history').readlines()]
1054
transaction.map.add_revision_history(history)
1055
# this call is disabled because revision_history is
1056
# not really an object yet, and the transaction is for objects.
1057
# transaction.register_clean(history, precious=True)
1058
return list(history)
1059
1060
@needs_write_lock
1061
def update_revisions(self, other, stop_revision=None):
1062
"""See Branch.update_revisions."""
1063
other.lock_read()
1064
try:
1065
if stop_revision is None:
1066
stop_revision = other.last_revision()
1067
if stop_revision is None:
1068
# if there are no commits, we're done.
1069
return
1070
# whats the current last revision, before we fetch [and change it
1071
# possibly]
1072
last_rev = self.last_revision()
1073
# we fetch here regardless of whether we need to so that we pickup
1074
# filled in ghosts.
1075
self.fetch(other, stop_revision)
1076
my_ancestry = self.repository.get_ancestry(last_rev)
1077
if stop_revision in my_ancestry:
1078
# last_revision is a descendant of stop_revision
1079
return
1080
# stop_revision must be a descendant of last_revision
1081
stop_graph = self.repository.get_revision_graph(stop_revision)
1082
if last_rev is not None and last_rev not in stop_graph:
1083
# our previous tip is not merged into stop_revision
1084
raise errors.DivergedBranches(self, other)
1085
# make a new revision history from the graph
1086
current_rev_id = stop_revision
1087
new_history = []
1088
while current_rev_id not in (None, NULL_REVISION):
1089
new_history.append(current_rev_id)
1090
current_rev_id_parents = stop_graph[current_rev_id]
1091
try:
1092
current_rev_id = current_rev_id_parents[0]
1093
except IndexError:
1094
current_rev_id = None
1095
new_history.reverse()
1096
self.set_revision_history(new_history)
1097
finally:
1098
other.unlock()
1099
1100
def basis_tree(self):
1101
"""See Branch.basis_tree."""
1102
return self.repository.revision_tree(self.last_revision())
1103
1104
@deprecated_method(zero_eight)
1105
def working_tree(self):
1106
"""Create a Working tree object for this branch."""
1107
from bzrlib.workingtree import WorkingTree
1108
from bzrlib.transport.local import LocalTransport
1109
if (self.base.find('://') != -1 or
1110
not isinstance(self._transport, LocalTransport)):
1111
raise NoWorkingTree(self.base)
1112
return self.bzrdir.open_workingtree()
1113
1114
@needs_write_lock
1115
def pull(self, source, overwrite=False, stop_revision=None):
1116
"""See Branch.pull."""
1117
source.lock_read()
1118
try:
1119
old_count = len(self.revision_history())
1120
try:
1121
self.update_revisions(source,stop_revision)
1122
except DivergedBranches:
1123
if not overwrite:
1124
raise
1125
if overwrite:
1126
self.set_revision_history(source.revision_history())
1127
new_count = len(self.revision_history())
1128
return new_count - old_count
1129
finally:
1130
source.unlock()
1131
1132
def get_parent(self):
1133
"""See Branch.get_parent."""
1134
import errno
1135
_locs = ['parent', 'pull', 'x-pull']
1136
for l in _locs:
1137
try:
1138
return self.control_files.get_utf8(l).read().strip('\n')
1139
except NoSuchFile:
1140
pass
1141
return None
1142
1143
def get_push_location(self):
1144
"""See Branch.get_push_location."""
1145
config = bzrlib.config.BranchConfig(self)
1146
push_loc = config.get_user_option('push_location')
1147
return push_loc
1148
1149
def set_push_location(self, location):
1150
"""See Branch.set_push_location."""
1151
config = bzrlib.config.LocationConfig(self.base)
1152
config.set_user_option('push_location', location)
1153
1154
@needs_write_lock
1155
def set_parent(self, url):
1156
"""See Branch.set_parent."""
1157
# TODO: Maybe delete old location files?
1158
# URLs should never be unicode, even on the local fs,
1159
# FIXUP this and get_parent in a future branch format bump:
1160
# read and rewrite the file, and have the new format code read
1161
# using .get not .get_utf8. RBC 20060125
1162
if url is None:
1163
self.control_files._transport.delete('parent')
1164
else:
1165
self.control_files.put_utf8('parent', url + '\n')
1166
1167
def tree_config(self):
1168
return TreeConfig(self)
1169
1170
1171
class BzrBranch5(BzrBranch):
1172
"""A format 5 branch. This supports new features over plan branches.
1173
1174
It has support for a master_branch which is the data for bound branches.
1175
"""
1176
1177
def __init__(self,
1178
_format,
1179
_control_files,
1180
a_bzrdir,
1181
_repository):
1182
super(BzrBranch5, self).__init__(_format=_format,
1183
_control_files=_control_files,
1184
a_bzrdir=a_bzrdir,
1185
_repository=_repository)
1186
1187
@needs_write_lock
1188
def pull(self, source, overwrite=False, stop_revision=None):
1189
"""Updates branch.pull to be bound branch aware."""
1190
bound_location = self.get_bound_location()
1191
if source.base != bound_location:
1192
# not pulling from master, so we need to update master.
1193
master_branch = self.get_master_branch()
1194
if master_branch:
1195
master_branch.pull(source)
1196
source = master_branch
1197
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1198
1199
def get_bound_location(self):
1200
try:
1201
return self.control_files.get_utf8('bound').read()[:-1]
1202
except errors.NoSuchFile:
1203
return None
1204
1205
@needs_read_lock
1206
def get_master_branch(self):
1207
"""Return the branch we are bound to.
1208
1209
:return: Either a Branch, or None
1210
1211
This could memoise the branch, but if thats done
1212
it must be revalidated on each new lock.
1213
So for now we just dont memoise it.
1214
# RBC 20060304 review this decision.
1215
"""
1216
bound_loc = self.get_bound_location()
1217
if not bound_loc:
1218
return None
1219
try:
1220
return Branch.open(bound_loc)
1221
except (errors.NotBranchError, errors.ConnectionError), e:
1222
raise errors.BoundBranchConnectionFailure(
1223
self, bound_loc, e)
1224
1225
@needs_write_lock
1226
def set_bound_location(self, location):
1227
"""Set the target where this branch is bound to.
1228
1229
:param location: URL to the target branch
1230
"""
1231
if location:
1232
self.control_files.put_utf8('bound', location+'\n')
1233
else:
1234
try:
1235
self.control_files._transport.delete('bound')
1236
except NoSuchFile:
1237
return False
1238
return True
1239
1240
@needs_write_lock
1241
def bind(self, other):
1242
"""Bind the local branch the other branch.
1243
1244
:param other: The branch to bind to
1245
:type other: Branch
1246
"""
1247
# TODO: jam 20051230 Consider checking if the target is bound
1248
# It is debatable whether you should be able to bind to
1249
# a branch which is itself bound.
1250
# Committing is obviously forbidden,
1251
# but binding itself may not be.
1252
# Since we *have* to check at commit time, we don't
1253
# *need* to check here
1254
self.pull(other)
1255
1256
# we are now equal to or a suffix of other.
1257
1258
# Since we have 'pulled' from the remote location,
1259
# now we should try to pull in the opposite direction
1260
# in case the local tree has more revisions than the
1261
# remote one.
1262
# There may be a different check you could do here
1263
# rather than actually trying to install revisions remotely.
1264
# TODO: capture an exception which indicates the remote branch
1265
# is not writeable.
1266
# If it is up-to-date, this probably should not be a failure
1267
1268
# lock other for write so the revision-history syncing cannot race
1269
other.lock_write()
1270
try:
1271
other.pull(self)
1272
# if this does not error, other now has the same last rev we do
1273
# it can only error if the pull from other was concurrent with
1274
# a commit to other from someone else.
1275
1276
# until we ditch revision-history, we need to sync them up:
1277
self.set_revision_history(other.revision_history())
1278
# now other and self are up to date with each other and have the
1279
# same revision-history.
1280
finally:
1281
other.unlock()
1282
1283
self.set_bound_location(other.base)
1284
1285
@needs_write_lock
1286
def unbind(self):
1287
"""If bound, unbind"""
1288
return self.set_bound_location(None)
1289
1290
@needs_write_lock
1291
def update(self):
1292
"""Synchronise this branch with the master branch if any.
1293
1294
:return: None or the last_revision that was pivoted out during the
1295
update.
1296
"""
1297
master = self.get_master_branch()
1298
if master is not None:
1299
old_tip = self.last_revision()
1300
self.pull(master, overwrite=True)
1301
if old_tip in self.repository.get_ancestry(self.last_revision()):
1302
return None
1303
return old_tip
1304
return None
1305
1306
1307
class BranchTestProviderAdapter(object):
1308
"""A tool to generate a suite testing multiple branch formats at once.
1309
1310
This is done by copying the test once for each transport and injecting
1311
the transport_server, transport_readonly_server, and branch_format
1312
classes into each copy. Each copy is also given a new id() to make it
1313
easy to identify.
1314
"""
1315
1316
def __init__(self, transport_server, transport_readonly_server, formats):
1317
self._transport_server = transport_server
1318
self._transport_readonly_server = transport_readonly_server
1319
self._formats = formats
1320
1321
def adapt(self, test):
1322
result = TestSuite()
1323
for branch_format, bzrdir_format in self._formats:
1324
new_test = deepcopy(test)
1325
new_test.transport_server = self._transport_server
1326
new_test.transport_readonly_server = self._transport_readonly_server
1327
new_test.bzrdir_format = bzrdir_format
1328
new_test.branch_format = branch_format
1329
def make_new_test_id():
1330
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1331
return lambda: new_id
1332
new_test.id = make_new_test_id()
1333
result.addTest(new_test)
1334
return result
1335
1263
1336
1264
1337
######################################################################
1265
1338
# predicates
1266
1339
1267
1340
1268
def is_control_file(filename):
1269
## FIXME: better check
1270
filename = os.path.normpath(filename)
1271
while filename != '':
1272
head, tail = os.path.split(filename)
1273
## mutter('check %r for control file' % ((head, tail), ))
1274
if tail == bzrlib.BZRDIR:
1275
return True
1276
if filename == head:
1277
break
1278
filename = head
1279
return False
1280
1281
1282
1283
def gen_file_id(name):
1284
"""Return new file id.
1285
1286
This should probably generate proper UUIDs, but for the moment we
1287
cope with just randomness because running uuidgen every time is
1288
slow."""
1289
import re
1290
from binascii import hexlify
1291
from time import time
1292
1293
# get last component
1294
idx = name.rfind('/')
1295
if idx != -1:
1296
name = name[idx+1 : ]
1297
idx = name.rfind('\\')
1298
if idx != -1:
1299
name = name[idx+1 : ]
1300
1301
# make it not a hidden file
1302
name = name.lstrip('.')
1303
1304
# remove any wierd characters; we don't escape them but rather
1305
# just pull them out
1306
name = re.sub(r'[^\w.]', '', name)
1307
1308
s = hexlify(rand_bytes(8))
1309
return '-'.join((name, compact_date(time()), s))
1310
1311
1312
def gen_root_id():
1313
"""Return a new tree-root file id."""
1314
return gen_file_id('TREE_ROOT')
1315
1316
1341
@deprecated_function(zero_eight)
1342
def ScratchBranch(*args, **kwargs):
1343
"""See bzrlib.bzrdir.ScratchDir."""
1344
d = ScratchDir(*args, **kwargs)
1345
return d.open_branch()
1346
1347
1348
@deprecated_function(zero_eight)
1349
def is_control_file(*args, **kwargs):
1350
"""See bzrlib.workingtree.is_control_file."""
1351
return bzrlib.workingtree.is_control_file(*args, **kwargs)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1