« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1417.1.4
- compare with another revision
- download diff
- download tarball
- view history from revision 1417.1.4
- Committer: Robert Collins
- Date: 2005-10-06 22:15:52 UTC
- mfrom: (1185.13.2)
- mto: This revision was merged to the branch mainline in revision 1420.
- Revision ID: robertc@robertcollins.net-20051006221552-9b15c96fa504e0ad
merge from upstream
- files added:
- bzrlib/clone.py
- bzrlib/util/urlgrabber
- notes
- patches
- files removed:
- BRANCH.TODO
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins/launchpad
- bzrlib/repofmt
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/intertree_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/version_info_formats
- tools/doc_generate
- tools/win32
- files renamed:
- tools/doc_generate/autodoc_man.py => bzr-man.py
- bzrlib/bundle/__init__.py => bzrlib/changeset.py
- bzrlib/conflicts.py => bzrlib/plugins/conflicts.py
- bzrlib/tests/ => bzrlib/selftest/
- bzrlib/tests/blackbox/test_too_much.py => bzrlib/selftest/blackbox.py
- bzrlib/tests/test_plugins.py => bzrlib/selftest/plugins.py
- bzrlib/tests/branch_implementations/test_parent.py => bzrlib/selftest/test_parent.py
- bzrlib/tests/blackbox/test_revision_info.py => bzrlib/selftest/test_revision_info.py
- bzrlib/tests/branch_implementations/test_branch.py => bzrlib/selftest/testbranch.py
- bzrlib/tests/test_diff.py => bzrlib/selftest/testdiff.py
- bzrlib/tests/test_fetch.py => bzrlib/selftest/testfetch.py
- bzrlib/tests/test_graph.py => bzrlib/selftest/testgraph.py
- bzrlib/tests/test_hashcache.py => bzrlib/selftest/testhashcache.py
- bzrlib/tests/test_inv.py => bzrlib/selftest/testinv.py
- bzrlib/tests/test_log.py => bzrlib/selftest/testlog.py
- bzrlib/tests/test_merge.py => bzrlib/selftest/testmerge.py
- bzrlib/tests/test_merge3.py => bzrlib/selftest/testmerge3.py
- bzrlib/tests/test_revision.py => bzrlib/selftest/testrevision.py
- bzrlib/tests/test_revisionnamespaces.py => bzrlib/selftest/testrevisionnamespaces.py
- bzrlib/tests/test_sampler.py => bzrlib/selftest/testsampler.py
- bzrlib/tests/blackbox/test_status.py => bzrlib/selftest/teststatus.py
- bzrlib/tests/test_store.py => bzrlib/selftest/teststore.py
- bzrlib/tests/test_transport.py => bzrlib/selftest/testtransport.py
- bzrlib/tests/test_workingtree.py => bzrlib/selftest/testworkingtree.py
- bzrlib/tests/blackbox/test_versioning.py => bzrlib/selftest/versioning.py
- bzrlib/tests/test_whitebox.py => bzrlib/selftest/whitebox.py
- bzrlib/store/versioned/__init__.py => bzrlib/store/weave.py
- bzrlib/transport/http/__init__.py => bzrlib/transport/http.py
- bzrlib/ui/__init__.py => bzrlib/ui.py
- bzrlib/xml_serializer.py => bzrlib/xml.py
- doc/tutorial.txt => tutorial.txt
- files modified:
- .bzrignore
- bzr *
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
#
1
# Copyright (C) 2005 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
import sys
19
import os
20
import errno
21
from warnings import warn
18
22
from cStringIO import StringIO
19
23
20
from bzrlib.lazy_import import lazy_import
21
lazy_import(globals(), """
22
from copy import deepcopy
23
from unittest import TestSuite
24
from warnings import warn
25
24
26
25
import bzrlib
27
from bzrlib import (
28
bzrdir,
29
cache_utf8,
30
config as _mod_config,
31
errors,
32
lockdir,
33
lockable_files,
34
osutils,
35
revision as _mod_revision,
36
transport,
37
tree,
38
ui,
39
urlutils,
40
)
41
from bzrlib.config import BranchConfig, TreeConfig
42
from bzrlib.lockable_files import LockableFiles, TransportLock
43
""")
44
45
from bzrlib.decorators import needs_read_lock, needs_write_lock
46
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
47
HistoryMissing, InvalidRevisionId,
48
InvalidRevisionNumber, LockError, NoSuchFile,
49
NoSuchRevision, NoWorkingTree, NotVersionedError,
50
NotBranchError, UninitializableFormat,
51
UnlistableStore, UnlistableBranch,
52
)
53
from bzrlib.symbol_versioning import (deprecated_function,
54
deprecated_method,
55
DEPRECATED_PARAMETER,
56
deprecated_passed,
57
zero_eight, zero_nine,
58
)
26
from bzrlib.inventory import InventoryEntry
27
import bzrlib.inventory as inventory
59
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)
32
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
33
NoSuchRevision, HistoryMissing, NotBranchError,
34
DivergedBranches, LockError, UnlistableStore,
35
UnlistableBranch, NoSuchFile)
36
from bzrlib.textui import show_status
37
from bzrlib.revision import Revision
38
from bzrlib.delta import compare_trees
39
from bzrlib.tree import EmptyTree, RevisionTree
40
from bzrlib.inventory import Inventory
41
from bzrlib.store import copy_all
42
from bzrlib.store.compressed_text import CompressedTextStore
43
from bzrlib.store.text import TextStore
44
from bzrlib.store.weave import WeaveStore
45
from bzrlib.transport import Transport, get_transport
46
import bzrlib.xml5
47
import bzrlib.ui
60
48
61
49
62
50
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
63
51
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
64
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
65
66
67
# TODO: Maybe include checks for common corruption of newlines, etc?
52
## TODO: Maybe include checks for common corruption of newlines, etc?
53
68
54
69
55
# TODO: Some operations like log might retrieve the same revisions
70
56
# repeatedly to calculate deltas. We could perhaps have a weakref
71
57
# cache in memory to make this faster. In general anything can be
72
# cached in memory between lock and unlock operations. .. nb thats
73
# what the transaction identity map provides
58
# cached in memory between lock and unlock operations.
59
60
def find_branch(*ignored, **ignored_too):
61
# XXX: leave this here for about one release, then remove it
62
raise NotImplementedError('find_branch() is not supported anymore, '
63
'please use one of the new branch constructors')
64
def _relpath(base, path):
65
"""Return path relative to base, or raise exception.
66
67
The path may be either an absolute path or a path relative to the
68
current working directory.
69
70
Lifted out of Branch.relpath for ease of testing.
71
72
os.path.commonprefix (python2.4) has a bad bug that it works just
73
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
74
avoids that problem."""
75
rp = os.path.abspath(path)
76
77
s = []
78
head = rp
79
while len(head) >= len(base):
80
if head == base:
81
break
82
head, tail = os.path.split(head)
83
if tail:
84
s.insert(0, tail)
85
else:
86
raise NotBranchError("path %r is not within branch %r" % (rp, base))
87
88
return os.sep.join(s)
89
90
91
def find_branch_root(t):
92
"""Find the branch root enclosing the transport's base.
93
94
t is a Transport object.
95
96
It is not necessary that the base of t exists.
97
98
Basically we keep looking up until we find the control directory or
99
run into the root. If there isn't one, raises NotBranchError.
100
"""
101
orig_base = t.base
102
while True:
103
if t.has(bzrlib.BZRDIR):
104
return t
105
new_t = t.clone('..')
106
if new_t.base == t.base:
107
# reached the root, whatever that may be
108
raise NotBranchError('%s is not in a branch' % orig_base)
109
t = new_t
74
110
75
111
76
112
######################################################################
81
117
82
118
base
83
119
Base directory/url of the branch.
84
85
hooks: An instance of BranchHooks.
86
120
"""
87
# this is really an instance variable - FIXME move it there
88
# - RBC 20060112
89
121
base = None
90
122
91
123
def __init__(self, *ignored, **ignored_too):
92
124
raise NotImplementedError('The Branch class is abstract')
93
125
94
def break_lock(self):
95
"""Break a lock if one is present from another instance.
96
97
Uses the ui factory to ask for confirmation if the lock may be from
98
an active process.
99
100
This will probe the repository for its lock as well.
101
"""
102
self.control_files.break_lock()
103
self.repository.break_lock()
104
master = self.get_master_branch()
105
if master is not None:
106
master.break_lock()
107
108
126
@staticmethod
109
@deprecated_method(zero_eight)
110
127
def open_downlevel(base):
111
"""Open a branch which may be of an old format."""
112
return Branch.open(base, _unsupported=True)
128
"""Open a branch which may be of an old format.
129
130
Only local branches are supported."""
131
return _Branch(get_transport(base), relax_version_check=True)
113
132
114
133
@staticmethod
115
def open(base, _unsupported=False):
116
"""Open the branch rooted at base.
117
118
For instance, if the branch is at URL/.bzr/branch,
119
Branch.open(URL) -> a Branch instance.
120
"""
121
control = bzrdir.BzrDir.open(base, _unsupported)
122
return control.open_branch(_unsupported)
134
def open(base):
135
"""Open an existing branch, rooted at 'base' (url)"""
136
t = get_transport(base)
137
mutter("trying to open %r with transport %r", base, t)
138
return _Branch(t)
123
139
124
140
@staticmethod
125
141
def open_containing(url):
126
142
"""Open an existing branch which contains url.
127
143
128
144
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 and it is either an unrecognised format or an unsupported
133
format, UnknownFormatError or UnsupportedFormatError are raised.
134
If there is one, it is returned, along with the unused portion of url.
135
145
"""
136
control, relpath = bzrdir.BzrDir.open_containing(url)
137
return control.open_branch(), relpath
146
t = get_transport(url)
147
t = find_branch_root(t)
148
return _Branch(t)
138
149
139
150
@staticmethod
140
@deprecated_function(zero_eight)
141
151
def initialize(base):
142
"""Create a new working tree and branch, rooted at 'base' (url)
143
144
NOTE: This will soon be deprecated in favour of creation
145
through a BzrDir.
146
"""
147
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
148
149
@deprecated_function(zero_eight)
152
"""Create a new branch, rooted at 'base' (url)"""
153
t = get_transport(base)
154
return _Branch(t, init=True)
155
150
156
def setup_caching(self, cache_root):
151
157
"""Subclasses that care about caching should override this, and set
152
158
up cached stores located under cache_root.
159
"""
160
self.cache_root = cache_root
161
162
163
class _Branch(Branch):
164
"""A branch stored in the actual filesystem.
165
166
Note that it's "local" in the context of the filesystem; it doesn't
167
really matter if it's on an nfs/smb/afs/coda/... share, as long as
168
it's writable, and can be accessed via the normal filesystem API.
169
170
_lock_mode
171
None, or 'r' or 'w'
172
173
_lock_count
174
If _lock_mode is true, a positive count of the number of times the
175
lock has been taken.
176
177
_lock
178
Lock object from bzrlib.lock.
179
"""
180
# We actually expect this class to be somewhat short-lived; part of its
181
# purpose is to try to isolate what bits of the branch logic are tied to
182
# filesystem access, so that in a later step, we can extricate them to
183
# a separarte ("storage") class.
184
_lock_mode = None
185
_lock_count = None
186
_lock = None
187
_inventory_weave = None
188
189
# Map some sort of prefix into a namespace
190
# stuff like "revno:10", "revid:", etc.
191
# This should match a prefix with a function which accepts
192
REVISION_NAMESPACES = {}
193
194
def push_stores(self, branch_to):
195
"""Copy the content of this branches store to branch_to."""
196
if (self._branch_format != branch_to._branch_format
197
or self._branch_format != 4):
198
from bzrlib.fetch import greedy_fetch
199
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
200
self, self._branch_format, branch_to, branch_to._branch_format)
201
greedy_fetch(to_branch=branch_to, from_branch=self,
202
revision=self.last_revision())
203
return
204
205
store_pairs = ((self.text_store, branch_to.text_store),
206
(self.inventory_store, branch_to.inventory_store),
207
(self.revision_store, branch_to.revision_store))
208
try:
209
for from_store, to_store in store_pairs:
210
copy_all(from_store, to_store)
211
except UnlistableStore:
212
raise UnlistableBranch(from_store)
213
214
def __init__(self, transport, init=False,
215
relax_version_check=False):
216
"""Create new branch object at a particular location.
217
218
transport -- A Transport object, defining how to access files.
219
(If a string, transport.transport() will be used to
220
create a Transport object)
153
221
154
NOTE: This is unused.
222
init -- If True, create new control files in a previously
223
unversioned directory. If False, the branch must already
224
be versioned.
225
226
relax_version_check -- If true, the usual check for the branch
227
version is not applied. This is intended only for
228
upgrade/recovery type use; it's not guaranteed that
229
all operations will work on old format branches.
230
231
In the test suite, creation of new trees is tested using the
232
`ScratchBranch` class.
155
233
"""
156
pass
157
158
def get_config(self):
159
return BranchConfig(self)
160
161
def _get_nick(self):
162
return self.get_config().get_nickname()
163
164
def _set_nick(self, nick):
165
self.get_config().set_user_option('nickname', nick)
166
167
nick = property(_get_nick, _set_nick)
168
169
def is_locked(self):
170
raise NotImplementedError(self.is_locked)
234
assert isinstance(transport, Transport), \
235
"%r is not a Transport" % transport
236
self._transport = transport
237
if init:
238
self._make_control()
239
self._check_format(relax_version_check)
240
241
def get_store(name, compressed=True):
242
# FIXME: This approach of assuming stores are all entirely compressed
243
# or entirely uncompressed is tidy, but breaks upgrade from
244
# some existing branches where there's a mixture; we probably
245
# still want the option to look for both.
246
relpath = self._rel_controlfilename(name)
247
if compressed:
248
store = CompressedTextStore(self._transport.clone(relpath))
249
else:
250
store = TextStore(self._transport.clone(relpath))
251
#if self._transport.should_cache():
252
# cache_path = os.path.join(self.cache_root, name)
253
# os.mkdir(cache_path)
254
# store = bzrlib.store.CachedStore(store, cache_path)
255
return store
256
def get_weave(name):
257
relpath = self._rel_controlfilename(name)
258
ws = WeaveStore(self._transport.clone(relpath))
259
if self._transport.should_cache():
260
ws.enable_cache = True
261
return ws
262
263
if self._branch_format == 4:
264
self.inventory_store = get_store('inventory-store')
265
self.text_store = get_store('text-store')
266
self.revision_store = get_store('revision-store')
267
elif self._branch_format == 5:
268
self.control_weaves = get_weave([])
269
self.weave_store = get_weave('weaves')
270
self.revision_store = get_store('revision-store', compressed=False)
271
272
def __str__(self):
273
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
274
275
276
__repr__ = __str__
277
278
279
def __del__(self):
280
if self._lock_mode or self._lock:
281
# XXX: This should show something every time, and be suitable for
282
# headless operation and embedding
283
warn("branch %r was not explicitly unlocked" % self)
284
self._lock.unlock()
285
286
# TODO: It might be best to do this somewhere else,
287
# but it is nice for a Branch object to automatically
288
# cache it's information.
289
# Alternatively, we could have the Transport objects cache requests
290
# See the earlier discussion about how major objects (like Branch)
291
# should never expect their __del__ function to run.
292
if hasattr(self, 'cache_root') and self.cache_root is not None:
293
try:
294
import shutil
295
shutil.rmtree(self.cache_root)
296
except:
297
pass
298
self.cache_root = None
299
300
def _get_base(self):
301
if self._transport:
302
return self._transport.base
303
return None
304
305
base = property(_get_base)
306
171
307
172
308
def lock_write(self):
173
raise NotImplementedError(self.lock_write)
309
# TODO: Upgrade locking to support using a Transport,
310
# and potentially a remote locking protocol
311
if self._lock_mode:
312
if self._lock_mode != 'w':
313
raise LockError("can't upgrade to a write lock from %r" %
314
self._lock_mode)
315
self._lock_count += 1
316
else:
317
self._lock = self._transport.lock_write(
318
self._rel_controlfilename('branch-lock'))
319
self._lock_mode = 'w'
320
self._lock_count = 1
321
174
322
175
323
def lock_read(self):
176
raise NotImplementedError(self.lock_read)
177
324
if self._lock_mode:
325
assert self._lock_mode in ('r', 'w'), \
326
"invalid lock mode %r" % self._lock_mode
327
self._lock_count += 1
328
else:
329
self._lock = self._transport.lock_read(
330
self._rel_controlfilename('branch-lock'))
331
self._lock_mode = 'r'
332
self._lock_count = 1
333
178
334
def unlock(self):
179
raise NotImplementedError(self.unlock)
180
181
def peek_lock_mode(self):
182
"""Return lock mode for the Branch: 'r', 'w' or None"""
183
raise NotImplementedError(self.peek_lock_mode)
184
185
def get_physical_lock_status(self):
186
raise NotImplementedError(self.get_physical_lock_status)
335
if not self._lock_mode:
336
raise LockError('branch %r is not locked' % (self))
337
338
if self._lock_count > 1:
339
self._lock_count -= 1
340
else:
341
self._lock.unlock()
342
self._lock = None
343
self._lock_mode = self._lock_count = None
187
344
188
345
def abspath(self, name):
189
"""Return absolute filename for something in the branch
190
191
XXX: Robert Collins 20051017 what is this used for? why is it a branch
192
method and not a tree method.
193
"""
194
raise NotImplementedError(self.abspath)
195
196
def bind(self, other):
197
"""Bind the local branch the other branch.
198
199
:param other: The branch to bind to
200
:type other: Branch
201
"""
202
raise errors.UpgradeRequired(self.base)
203
204
@needs_write_lock
205
def fetch(self, from_branch, last_revision=None, pb=None):
206
"""Copy revisions from from_branch into this branch.
207
208
:param from_branch: Where to copy from.
209
:param last_revision: What revision to stop at (None for at the end
210
of the branch.
211
:param pb: An optional progress bar to use.
212
213
Returns the copied revision count and the failed revisions in a tuple:
214
(copied, failures).
215
"""
216
if self.base == from_branch.base:
217
return (0, [])
218
if pb is None:
219
nested_pb = ui.ui_factory.nested_progress_bar()
220
pb = nested_pb
221
else:
222
nested_pb = None
223
224
from_branch.lock_read()
225
try:
226
if last_revision is None:
227
pb.update('get source history')
228
last_revision = from_branch.last_revision()
229
if last_revision is None:
230
last_revision = _mod_revision.NULL_REVISION
231
return self.repository.fetch(from_branch.repository,
232
revision_id=last_revision,
233
pb=nested_pb)
234
finally:
235
if nested_pb is not None:
236
nested_pb.finished()
237
from_branch.unlock()
238
239
def get_bound_location(self):
240
"""Return the URL of the branch we are bound to.
241
242
Older format branches cannot bind, please be sure to use a metadir
243
branch.
244
"""
245
return None
246
247
def get_old_bound_location(self):
248
"""Return the URL of the branch we used to be bound to
249
"""
250
raise errors.UpgradeRequired(self.base)
251
252
def get_commit_builder(self, parents, config=None, timestamp=None,
253
timezone=None, committer=None, revprops=None,
254
revision_id=None):
255
"""Obtain a CommitBuilder for this branch.
256
257
:param parents: Revision ids of the parents of the new revision.
258
:param config: Optional configuration to use.
259
:param timestamp: Optional timestamp recorded for commit.
260
:param timezone: Optional timezone for timestamp.
261
:param committer: Optional committer to set for commit.
262
:param revprops: Optional dictionary of revision properties.
263
:param revision_id: Optional revision id.
264
"""
265
266
if config is None:
267
config = self.get_config()
268
269
return self.repository.get_commit_builder(self, parents, config,
270
timestamp, timezone, committer, revprops, revision_id)
271
272
def get_master_branch(self):
273
"""Return the branch we are bound to.
274
275
:return: Either a Branch, or None
276
"""
277
return None
346
"""Return absolute filename for something in the branch"""
347
return self._transport.abspath(name)
348
349
def relpath(self, path):
350
"""Return path relative to this branch of something inside it.
351
352
Raises an error if path is not in this branch."""
353
return self._transport.relpath(path)
354
355
356
def _rel_controlfilename(self, file_or_path):
357
if isinstance(file_or_path, basestring):
358
file_or_path = [file_or_path]
359
return [bzrlib.BZRDIR] + file_or_path
360
361
def controlfilename(self, file_or_path):
362
"""Return location relative to branch."""
363
return self._transport.abspath(self._rel_controlfilename(file_or_path))
364
365
366
def controlfile(self, file_or_path, mode='r'):
367
"""Open a control file for this branch.
368
369
There are two classes of file in the control directory: text
370
and binary. binary files are untranslated byte streams. Text
371
control files are stored with Unix newlines and in UTF-8, even
372
if the platform or locale defaults are different.
373
374
Controlfiles should almost never be opened in write mode but
375
rather should be atomically copied and replaced using atomicfile.
376
"""
377
import codecs
378
379
relpath = self._rel_controlfilename(file_or_path)
380
#TODO: codecs.open() buffers linewise, so it was overloaded with
381
# a much larger buffer, do we need to do the same for getreader/getwriter?
382
if mode == 'rb':
383
return self._transport.get(relpath)
384
elif mode == 'wb':
385
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
386
elif mode == 'r':
387
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
388
elif mode == 'w':
389
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
390
else:
391
raise BzrError("invalid controlfile mode %r" % mode)
392
393
def put_controlfile(self, path, f, encode=True):
394
"""Write an entry as a controlfile.
395
396
:param path: The path to put the file, relative to the .bzr control
397
directory
398
:param f: A file-like or string object whose contents should be copied.
399
:param encode: If true, encode the contents as utf-8
400
"""
401
self.put_controlfiles([(path, f)], encode=encode)
402
403
def put_controlfiles(self, files, encode=True):
404
"""Write several entries as controlfiles.
405
406
:param files: A list of [(path, file)] pairs, where the path is the directory
407
underneath the bzr control directory
408
:param encode: If true, encode the contents as utf-8
409
"""
410
import codecs
411
ctrl_files = []
412
for path, f in files:
413
if encode:
414
if isinstance(f, basestring):
415
f = f.encode('utf-8', 'replace')
416
else:
417
f = codecs.getwriter('utf-8')(f, errors='replace')
418
path = self._rel_controlfilename(path)
419
ctrl_files.append((path, f))
420
self._transport.put_multi(ctrl_files)
421
422
def _make_control(self):
423
from bzrlib.inventory import Inventory
424
from bzrlib.weavefile import write_weave_v5
425
from bzrlib.weave import Weave
426
427
# Create an empty inventory
428
sio = StringIO()
429
# if we want per-tree root ids then this is the place to set
430
# them; they're not needed for now and so ommitted for
431
# simplicity.
432
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
433
empty_inv = sio.getvalue()
434
sio = StringIO()
435
bzrlib.weavefile.write_weave_v5(Weave(), sio)
436
empty_weave = sio.getvalue()
437
438
dirs = [[], 'revision-store', 'weaves']
439
files = [('README',
440
"This is a Bazaar-NG control directory.\n"
441
"Do not change any files in this directory.\n"),
442
('branch-format', BZR_BRANCH_FORMAT_5),
443
('revision-history', ''),
444
('branch-name', ''),
445
('branch-lock', ''),
446
('pending-merges', ''),
447
('inventory', empty_inv),
448
('inventory.weave', empty_weave),
449
('ancestry.weave', empty_weave)
450
]
451
cfn = self._rel_controlfilename
452
self._transport.mkdir_multi([cfn(d) for d in dirs])
453
self.put_controlfiles(files)
454
mutter('created control directory in ' + self._transport.base)
455
456
def _check_format(self, relax_version_check):
457
"""Check this branch format is supported.
458
459
The format level is stored, as an integer, in
460
self._branch_format for code that needs to check it later.
461
462
In the future, we might need different in-memory Branch
463
classes to support downlevel branches. But not yet.
464
"""
465
try:
466
fmt = self.controlfile('branch-format', 'r').read()
467
except NoSuchFile:
468
raise NotBranchError(self.base)
469
mutter("got branch format %r", fmt)
470
if fmt == BZR_BRANCH_FORMAT_5:
471
self._branch_format = 5
472
elif fmt == BZR_BRANCH_FORMAT_4:
473
self._branch_format = 4
474
475
if (not relax_version_check
476
and self._branch_format != 5):
477
raise BzrError('sorry, branch format %r not supported' % fmt,
478
['use a different bzr version',
479
'or remove the .bzr directory'
480
' and "bzr init" again'])
481
482
def get_root_id(self):
483
"""Return the id of this branches root"""
484
inv = self.read_working_inventory()
485
return inv.root.file_id
486
487
def set_root_id(self, file_id):
488
inv = self.read_working_inventory()
489
orig_root_id = inv.root.file_id
490
del inv._byid[inv.root.file_id]
491
inv.root.file_id = file_id
492
inv._byid[inv.root.file_id] = inv.root
493
for fid in inv:
494
entry = inv[fid]
495
if entry.parent_id in (None, orig_root_id):
496
entry.parent_id = inv.root.file_id
497
self._write_inventory(inv)
498
499
def read_working_inventory(self):
500
"""Read the working inventory."""
501
self.lock_read()
502
try:
503
# ElementTree does its own conversion from UTF-8, so open in
504
# binary.
505
f = self.controlfile('inventory', 'rb')
506
return bzrlib.xml5.serializer_v5.read_inventory(f)
507
finally:
508
self.unlock()
509
510
511
def _write_inventory(self, inv):
512
"""Update the working inventory.
513
514
That is to say, the inventory describing changes underway, that
515
will be committed to the next revision.
516
"""
517
from cStringIO import StringIO
518
self.lock_write()
519
try:
520
sio = StringIO()
521
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
522
sio.seek(0)
523
# Transport handles atomicity
524
self.put_controlfile('inventory', sio)
525
finally:
526
self.unlock()
527
528
mutter('wrote working inventory')
529
530
inventory = property(read_working_inventory, _write_inventory, None,
531
"""Inventory for the working copy.""")
532
533
def add(self, files, ids=None):
534
"""Make files versioned.
535
536
Note that the command line normally calls smart_add instead,
537
which can automatically recurse.
538
539
This puts the files in the Added state, so that they will be
540
recorded by the next commit.
541
542
files
543
List of paths to add, relative to the base of the tree.
544
545
ids
546
If set, use these instead of automatically generated ids.
547
Must be the same length as the list of files, but may
548
contain None for ids that are to be autogenerated.
549
550
TODO: Perhaps have an option to add the ids even if the files do
551
not (yet) exist.
552
553
TODO: Perhaps yield the ids and paths as they're added.
554
"""
555
# TODO: Re-adding a file that is removed in the working copy
556
# should probably put it back with the previous ID.
557
if isinstance(files, basestring):
558
assert(ids is None or isinstance(ids, basestring))
559
files = [files]
560
if ids is not None:
561
ids = [ids]
562
563
if ids is None:
564
ids = [None] * len(files)
565
else:
566
assert(len(ids) == len(files))
567
568
self.lock_write()
569
try:
570
inv = self.read_working_inventory()
571
for f,file_id in zip(files, ids):
572
if is_control_file(f):
573
raise BzrError("cannot add control file %s" % quotefn(f))
574
575
fp = splitpath(f)
576
577
if len(fp) == 0:
578
raise BzrError("cannot add top-level %r" % f)
579
580
fullpath = os.path.normpath(self.abspath(f))
581
582
try:
583
kind = file_kind(fullpath)
584
except OSError:
585
# maybe something better?
586
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
587
588
if not InventoryEntry.versionable_kind(kind):
589
raise BzrError('cannot add: not a versionable file ('
590
'i.e. regular file, symlink or directory): %s' % quotefn(f))
591
592
if file_id is None:
593
file_id = gen_file_id(f)
594
inv.add_path(f, kind=kind, file_id=file_id)
595
596
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
597
598
self._write_inventory(inv)
599
finally:
600
self.unlock()
601
602
603
def print_file(self, file, revno):
604
"""Print `file` to stdout."""
605
self.lock_read()
606
try:
607
tree = self.revision_tree(self.get_rev_id(revno))
608
# use inventory as it was in that revision
609
file_id = tree.inventory.path2id(file)
610
if not file_id:
611
raise BzrError("%r is not present in revision %s" % (file, revno))
612
tree.print_file(file_id)
613
finally:
614
self.unlock()
615
616
617
def remove(self, files, verbose=False):
618
"""Mark nominated files for removal from the inventory.
619
620
This does not remove their text. This does not run on
621
622
TODO: Refuse to remove modified files unless --force is given?
623
624
TODO: Do something useful with directories.
625
626
TODO: Should this remove the text or not? Tough call; not
627
removing may be useful and the user can just use use rm, and
628
is the opposite of add. Removing it is consistent with most
629
other tools. Maybe an option.
630
"""
631
## TODO: Normalize names
632
## TODO: Remove nested loops; better scalability
633
if isinstance(files, basestring):
634
files = [files]
635
636
self.lock_write()
637
638
try:
639
tree = self.working_tree()
640
inv = tree.inventory
641
642
# do this before any modifications
643
for f in files:
644
fid = inv.path2id(f)
645
if not fid:
646
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
647
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
648
if verbose:
649
# having remove it, it must be either ignored or unknown
650
if tree.is_ignored(f):
651
new_status = 'I'
652
else:
653
new_status = '?'
654
show_status(new_status, inv[fid].kind, quotefn(f))
655
del inv[fid]
656
657
self._write_inventory(inv)
658
finally:
659
self.unlock()
660
661
# FIXME: this doesn't need to be a branch method
662
def set_inventory(self, new_inventory_list):
663
from bzrlib.inventory import Inventory, InventoryEntry
664
inv = Inventory(self.get_root_id())
665
for path, file_id, parent, kind in new_inventory_list:
666
name = os.path.basename(path)
667
if name == "":
668
continue
669
# fixme, there should be a factory function inv,add_??
670
if kind == 'directory':
671
inv.add(inventory.InventoryDirectory(file_id, name, parent))
672
elif kind == 'file':
673
inv.add(inventory.InventoryFile(file_id, name, parent))
674
elif kind == 'symlink':
675
inv.add(inventory.InventoryLink(file_id, name, parent))
676
else:
677
raise BzrError("unknown kind %r" % kind)
678
self._write_inventory(inv)
679
680
def unknowns(self):
681
"""Return all unknown files.
682
683
These are files in the working directory that are not versioned or
684
control files or ignored.
685
686
>>> b = ScratchBranch(files=['foo', 'foo~'])
687
>>> list(b.unknowns())
688
['foo']
689
>>> b.add('foo')
690
>>> list(b.unknowns())
691
[]
692
>>> b.remove('foo')
693
>>> list(b.unknowns())
694
['foo']
695
"""
696
return self.working_tree().unknowns()
697
698
699
def append_revision(self, *revision_ids):
700
for revision_id in revision_ids:
701
mutter("add {%s} to revision-history" % revision_id)
702
self.lock_write()
703
try:
704
rev_history = self.revision_history()
705
rev_history.extend(revision_ids)
706
self.put_controlfile('revision-history', '\n'.join(rev_history))
707
finally:
708
self.unlock()
709
710
def has_revision(self, revision_id):
711
"""True if this branch has a copy of the revision.
712
713
This does not necessarily imply the revision is merge
714
or on the mainline."""
715
return (revision_id is None
716
or revision_id in self.revision_store)
717
718
def get_revision_xml_file(self, revision_id):
719
"""Return XML file object for revision object."""
720
if not revision_id or not isinstance(revision_id, basestring):
721
raise InvalidRevisionId(revision_id)
722
723
self.lock_read()
724
try:
725
try:
726
return self.revision_store[revision_id]
727
except (IndexError, KeyError):
728
raise bzrlib.errors.NoSuchRevision(self, revision_id)
729
finally:
730
self.unlock()
731
732
#deprecated
733
get_revision_xml = get_revision_xml_file
734
735
def get_revision_xml(self, revision_id):
736
return self.get_revision_xml_file(revision_id).read()
737
738
739
def get_revision(self, revision_id):
740
"""Return the Revision object for a named revision"""
741
xml_file = self.get_revision_xml_file(revision_id)
742
743
try:
744
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
745
except SyntaxError, e:
746
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
747
[revision_id,
748
str(e)])
749
750
assert r.revision_id == revision_id
751
return r
278
752
279
753
def get_revision_delta(self, revno):
280
754
"""Return the delta for one revision.
286
760
rh = self.revision_history()
287
761
if not (1 <= revno <= len(rh)):
288
762
raise InvalidRevisionNumber(revno)
289
return self.repository.get_revision_delta(rh[revno-1])
290
291
def get_root_id(self):
292
"""Return the id of this branches root"""
293
raise NotImplementedError(self.get_root_id)
294
295
def print_file(self, file, revision_id):
296
"""Print `file` to stdout."""
297
raise NotImplementedError(self.print_file)
298
299
def append_revision(self, *revision_ids):
300
raise NotImplementedError(self.append_revision)
301
302
def set_revision_history(self, rev_history):
303
raise NotImplementedError(self.set_revision_history)
763
764
# revno is 1-based; list is 0-based
765
766
new_tree = self.revision_tree(rh[revno-1])
767
if revno == 1:
768
old_tree = EmptyTree()
769
else:
770
old_tree = self.revision_tree(rh[revno-2])
771
772
return compare_trees(old_tree, new_tree)
773
774
def get_revision_sha1(self, revision_id):
775
"""Hash the stored value of a revision, and return it."""
776
# In the future, revision entries will be signed. At that
777
# point, it is probably best *not* to include the signature
778
# in the revision hash. Because that lets you re-sign
779
# the revision, (add signatures/remove signatures) and still
780
# have all hash pointers stay consistent.
781
# But for now, just hash the contents.
782
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
783
784
def get_ancestry(self, revision_id):
785
"""Return a list of revision-ids integrated by a revision.
786
787
This currently returns a list, but the ordering is not guaranteed:
788
treat it as a set.
789
"""
790
if revision_id is None:
791
return [None]
792
w = self.control_weaves.get_weave('inventory')
793
return [None] + map(w.idx_to_name,
794
w.inclusions([w.lookup(revision_id)]))
795
796
def get_inventory_weave(self):
797
return self.control_weaves.get_weave('inventory')
798
799
def get_inventory(self, revision_id):
800
"""Get Inventory object by hash."""
801
xml = self.get_inventory_xml(revision_id)
802
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
803
804
def get_inventory_xml(self, revision_id):
805
"""Get inventory XML as a file object."""
806
try:
807
assert isinstance(revision_id, basestring), type(revision_id)
808
iw = self.get_inventory_weave()
809
return iw.get_text(iw.lookup(revision_id))
810
except IndexError:
811
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
812
813
def get_inventory_sha1(self, revision_id):
814
"""Return the sha1 hash of the inventory entry
815
"""
816
return self.get_revision(revision_id).inventory_sha1
817
818
def get_revision_inventory(self, revision_id):
819
"""Return inventory of a past revision."""
820
# TODO: Unify this with get_inventory()
821
# bzr 0.0.6 and later imposes the constraint that the inventory_id
822
# must be the same as its revision, so this is trivial.
823
if revision_id == None:
824
return Inventory(self.get_root_id())
825
else:
826
return self.get_inventory(revision_id)
304
827
305
828
def revision_history(self):
306
829
"""Return sequence of revision hashes on to this branch."""
307
raise NotImplementedError(self.revision_history)
830
self.lock_read()
831
try:
832
return [l.rstrip('\r\n') for l in
833
self.controlfile('revision-history', 'r').readlines()]
834
finally:
835
self.unlock()
836
837
def common_ancestor(self, other, self_revno=None, other_revno=None):
838
"""
839
>>> from bzrlib.commit import commit
840
>>> sb = ScratchBranch(files=['foo', 'foo~'])
841
>>> sb.common_ancestor(sb) == (None, None)
842
True
843
>>> commit(sb, "Committing first revision", verbose=False)
844
>>> sb.common_ancestor(sb)[0]
845
1
846
>>> clone = sb.clone()
847
>>> commit(sb, "Committing second revision", verbose=False)
848
>>> sb.common_ancestor(sb)[0]
849
2
850
>>> sb.common_ancestor(clone)[0]
851
1
852
>>> commit(clone, "Committing divergent second revision",
853
... verbose=False)
854
>>> sb.common_ancestor(clone)[0]
855
1
856
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
857
True
858
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
859
True
860
>>> clone2 = sb.clone()
861
>>> sb.common_ancestor(clone2)[0]
862
2
863
>>> sb.common_ancestor(clone2, self_revno=1)[0]
864
1
865
>>> sb.common_ancestor(clone2, other_revno=1)[0]
866
1
867
"""
868
my_history = self.revision_history()
869
other_history = other.revision_history()
870
if self_revno is None:
871
self_revno = len(my_history)
872
if other_revno is None:
873
other_revno = len(other_history)
874
indices = range(min((self_revno, other_revno)))
875
indices.reverse()
876
for r in indices:
877
if my_history[r] == other_history[r]:
878
return r+1, my_history[r]
879
return None, None
880
308
881
309
882
def revno(self):
310
883
"""Return current revision number for this branch.
314
887
"""
315
888
return len(self.revision_history())
316
889
317
def unbind(self):
318
"""Older format branches cannot bind or unbind."""
319
raise errors.UpgradeRequired(self.base)
320
321
def set_append_revisions_only(self, enabled):
322
"""Older format branches are never restricted to append-only"""
323
raise errors.UpgradeRequired(self.base)
324
890
325
891
def last_revision(self):
326
"""Return last revision id, or None"""
892
"""Return last patch hash, or None if no history.
893
"""
327
894
ph = self.revision_history()
328
895
if ph:
329
896
return ph[-1]
330
897
else:
331
898
return None
332
899
333
def last_revision_info(self):
334
"""Return information about the last revision.
335
336
:return: A tuple (revno, last_revision_id).
337
"""
338
rh = self.revision_history()
339
revno = len(rh)
340
if revno:
341
return (revno, rh[-1])
342
else:
343
return (0, _mod_revision.NULL_REVISION)
344
345
def missing_revisions(self, other, stop_revision=None):
900
901
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
346
902
"""Return a list of new revisions that would perfectly fit.
347
903
348
904
If self and other have not diverged, return a list of the revisions
349
905
present in other, but missing from self.
906
907
>>> from bzrlib.commit import commit
908
>>> bzrlib.trace.silent = True
909
>>> br1 = ScratchBranch()
910
>>> br2 = ScratchBranch()
911
>>> br1.missing_revisions(br2)
912
[]
913
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
914
>>> br1.missing_revisions(br2)
915
[u'REVISION-ID-1']
916
>>> br2.missing_revisions(br1)
917
[]
918
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
919
>>> br1.missing_revisions(br2)
920
[]
921
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
922
>>> br1.missing_revisions(br2)
923
[u'REVISION-ID-2A']
924
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
925
>>> br1.missing_revisions(br2)
926
Traceback (most recent call last):
927
DivergedBranches: These branches have diverged.
350
928
"""
929
# FIXME: If the branches have diverged, but the latest
930
# revision in this branch is completely merged into the other,
931
# then we should still be able to pull.
351
932
self_history = self.revision_history()
352
933
self_len = len(self_history)
353
934
other_history = other.revision_history()
362
943
else:
363
944
assert isinstance(stop_revision, int)
364
945
if stop_revision > other_len:
365
raise errors.NoSuchRevision(self, stop_revision)
946
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
366
947
return other_history[self_len:stop_revision]
367
948
368
949
def update_revisions(self, other, stop_revision=None):
369
"""Pull in new perfect-fit revisions.
370
371
:param other: Another Branch to pull from
372
:param stop_revision: Updated until the given revision
373
:return: None
374
"""
375
raise NotImplementedError(self.update_revisions)
376
950
"""Pull in new perfect-fit revisions."""
951
from bzrlib.fetch import greedy_fetch
952
from bzrlib.revision import get_intervening_revisions
953
if stop_revision is None:
954
stop_revision = other.last_revision()
955
greedy_fetch(to_branch=self, from_branch=other,
956
revision=stop_revision)
957
pullable_revs = self.missing_revisions(
958
other, other.revision_id_to_revno(stop_revision))
959
if pullable_revs:
960
greedy_fetch(to_branch=self,
961
from_branch=other,
962
revision=pullable_revs[-1])
963
self.append_revision(*pullable_revs)
964
965
966
def commit(self, *args, **kw):
967
from bzrlib.commit import Commit
968
Commit().commit(self, *args, **kw)
969
377
970
def revision_id_to_revno(self, revision_id):
378
971
"""Given a revision id, return its revno"""
379
972
if revision_id is None:
380
973
return 0
381
revision_id = osutils.safe_revision_id(revision_id)
382
974
history = self.revision_history()
383
975
try:
384
976
return history.index(revision_id) + 1
391
983
return None
392
984
if history is None:
393
985
history = self.revision_history()
394
if revno <= 0 or revno > len(history):
986
elif revno <= 0 or revno > len(history):
395
987
raise bzrlib.errors.NoSuchRevision(self, revno)
396
988
return history[revno - 1]
397
989
398
def pull(self, source, overwrite=False, stop_revision=None):
399
"""Mirror source into this branch.
400
401
This branch is considered to be 'local', having low latency.
402
"""
403
raise NotImplementedError(self.pull)
404
405
def push(self, target, overwrite=False, stop_revision=None):
406
"""Mirror this branch into target.
407
408
This branch is considered to be 'local', having low latency.
409
"""
410
raise NotImplementedError(self.push)
990
def revision_tree(self, revision_id):
991
"""Return Tree for a revision on this branch.
992
993
`revision_id` may be None for the null revision, in which case
994
an `EmptyTree` is returned."""
995
# TODO: refactor this to use an existing revision object
996
# so we don't need to read it in twice.
997
if revision_id == None:
998
return EmptyTree()
999
else:
1000
inv = self.get_revision_inventory(revision_id)
1001
return RevisionTree(self.weave_store, inv, revision_id)
1002
1003
1004
def working_tree(self):
1005
"""Return a `Tree` for the working copy."""
1006
from bzrlib.workingtree import WorkingTree
1007
# TODO: In the future, WorkingTree should utilize Transport
1008
# RobertCollins 20051003 - I don't think it should - working trees are
1009
# much more complex to keep consistent than our careful .bzr subset.
1010
# instead, we should say that working trees are local only, and optimise
1011
# for that.
1012
return WorkingTree(self._transport.base, self.read_working_inventory())
1013
411
1014
412
1015
def basis_tree(self):
413
"""Return `Tree` object for last revision."""
414
return self.repository.revision_tree(self.last_revision())
1016
"""Return `Tree` object for last revision.
1017
1018
If there are no revisions yet, return an `EmptyTree`.
1019
"""
1020
return self.revision_tree(self.last_revision())
1021
415
1022
416
1023
def rename_one(self, from_rel, to_rel):
417
1024
"""Rename one file.
418
1025
419
1026
This can change the directory or the filename or both.
420
1027
"""
421
raise NotImplementedError(self.rename_one)
1028
self.lock_write()
1029
try:
1030
tree = self.working_tree()
1031
inv = tree.inventory
1032
if not tree.has_filename(from_rel):
1033
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1034
if tree.has_filename(to_rel):
1035
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1036
1037
file_id = inv.path2id(from_rel)
1038
if file_id == None:
1039
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1040
1041
if inv.path2id(to_rel):
1042
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1043
1044
to_dir, to_tail = os.path.split(to_rel)
1045
to_dir_id = inv.path2id(to_dir)
1046
if to_dir_id == None and to_dir != '':
1047
raise BzrError("can't determine destination directory id for %r" % to_dir)
1048
1049
mutter("rename_one:")
1050
mutter(" file_id {%s}" % file_id)
1051
mutter(" from_rel %r" % from_rel)
1052
mutter(" to_rel %r" % to_rel)
1053
mutter(" to_dir %r" % to_dir)
1054
mutter(" to_dir_id {%s}" % to_dir_id)
1055
1056
inv.rename(file_id, to_dir_id, to_tail)
1057
1058
from_abs = self.abspath(from_rel)
1059
to_abs = self.abspath(to_rel)
1060
try:
1061
rename(from_abs, to_abs)
1062
except OSError, e:
1063
raise BzrError("failed to rename %r to %r: %s"
1064
% (from_abs, to_abs, e[1]),
1065
["rename rolled back"])
1066
1067
self._write_inventory(inv)
1068
finally:
1069
self.unlock()
1070
422
1071
423
1072
def move(self, from_paths, to_name):
424
1073
"""Rename files.
434
1083
This returns a list of (from_path, to_path) pairs for each
435
1084
entry that is moved.
436
1085
"""
437
raise NotImplementedError(self.move)
1086
result = []
1087
self.lock_write()
1088
try:
1089
## TODO: Option to move IDs only
1090
assert not isinstance(from_paths, basestring)
1091
tree = self.working_tree()
1092
inv = tree.inventory
1093
to_abs = self.abspath(to_name)
1094
if not isdir(to_abs):
1095
raise BzrError("destination %r is not a directory" % to_abs)
1096
if not tree.has_filename(to_name):
1097
raise BzrError("destination %r not in working directory" % to_abs)
1098
to_dir_id = inv.path2id(to_name)
1099
if to_dir_id == None and to_name != '':
1100
raise BzrError("destination %r is not a versioned directory" % to_name)
1101
to_dir_ie = inv[to_dir_id]
1102
if to_dir_ie.kind not in ('directory', 'root_directory'):
1103
raise BzrError("destination %r is not a directory" % to_abs)
1104
1105
to_idpath = inv.get_idpath(to_dir_id)
1106
1107
for f in from_paths:
1108
if not tree.has_filename(f):
1109
raise BzrError("%r does not exist in working tree" % f)
1110
f_id = inv.path2id(f)
1111
if f_id == None:
1112
raise BzrError("%r is not versioned" % f)
1113
name_tail = splitpath(f)[-1]
1114
dest_path = appendpath(to_name, name_tail)
1115
if tree.has_filename(dest_path):
1116
raise BzrError("destination %r already exists" % dest_path)
1117
if f_id in to_idpath:
1118
raise BzrError("can't move %r to a subdirectory of itself" % f)
1119
1120
# OK, so there's a race here, it's possible that someone will
1121
# create a file in this interval and then the rename might be
1122
# left half-done. But we should have caught most problems.
1123
1124
for f in from_paths:
1125
name_tail = splitpath(f)[-1]
1126
dest_path = appendpath(to_name, name_tail)
1127
result.append((f, dest_path))
1128
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1129
try:
1130
rename(self.abspath(f), self.abspath(dest_path))
1131
except OSError, e:
1132
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1133
["rename rolled back"])
1134
1135
self._write_inventory(inv)
1136
finally:
1137
self.unlock()
1138
1139
return result
1140
1141
1142
def revert(self, filenames, old_tree=None, backups=True):
1143
"""Restore selected files to the versions from a previous tree.
1144
1145
backups
1146
If true (default) backups are made of files before
1147
they're renamed.
1148
"""
1149
from bzrlib.errors import NotVersionedError, BzrError
1150
from bzrlib.atomicfile import AtomicFile
1151
from bzrlib.osutils import backup_file
1152
1153
inv = self.read_working_inventory()
1154
if old_tree is None:
1155
old_tree = self.basis_tree()
1156
old_inv = old_tree.inventory
1157
1158
nids = []
1159
for fn in filenames:
1160
file_id = inv.path2id(fn)
1161
if not file_id:
1162
raise NotVersionedError("not a versioned file", fn)
1163
if not old_inv.has_id(file_id):
1164
raise BzrError("file not present in old tree", fn, file_id)
1165
nids.append((fn, file_id))
1166
1167
# TODO: Rename back if it was previously at a different location
1168
1169
# TODO: If given a directory, restore the entire contents from
1170
# the previous version.
1171
1172
# TODO: Make a backup to a temporary file.
1173
1174
# TODO: If the file previously didn't exist, delete it?
1175
for fn, file_id in nids:
1176
backup_file(fn)
1177
1178
f = AtomicFile(fn, 'wb')
1179
try:
1180
f.write(old_tree.get_file(file_id).read())
1181
f.commit()
1182
finally:
1183
f.close()
1184
1185
1186
def pending_merges(self):
1187
"""Return a list of pending merges.
1188
1189
These are revisions that have been merged into the working
1190
directory but not yet committed.
1191
"""
1192
cfn = self._rel_controlfilename('pending-merges')
1193
if not self._transport.has(cfn):
1194
return []
1195
p = []
1196
for l in self.controlfile('pending-merges', 'r').readlines():
1197
p.append(l.rstrip('\n'))
1198
return p
1199
1200
1201
def add_pending_merge(self, *revision_ids):
1202
# TODO: Perhaps should check at this point that the
1203
# history of the revision is actually present?
1204
p = self.pending_merges()
1205
updated = False
1206
for rev_id in revision_ids:
1207
if rev_id in p:
1208
continue
1209
p.append(rev_id)
1210
updated = True
1211
if updated:
1212
self.set_pending_merges(p)
1213
1214
def set_pending_merges(self, rev_list):
1215
self.lock_write()
1216
try:
1217
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1218
finally:
1219
self.unlock()
1220
438
1221
439
1222
def get_parent(self):
440
1223
"""Return the parent location of the branch.
443
1226
pattern is that the user can override it by specifying a
444
1227
location.
445
1228
"""
446
raise NotImplementedError(self.get_parent)
447
448
def get_submit_branch(self):
449
"""Return the submit location of the branch.
450
451
This is the default location for bundle. The usual
452
pattern is that the user can override it by specifying a
453
location.
454
"""
455
return self.get_config().get_user_option('submit_branch')
456
457
def set_submit_branch(self, location):
458
"""Return the submit location of the branch.
459
460
This is the default location for bundle. The usual
461
pattern is that the user can override it by specifying a
462
location.
463
"""
464
self.get_config().set_user_option('submit_branch', location)
465
466
def get_push_location(self):
467
"""Return the None or the location to push this branch to."""
468
raise NotImplementedError(self.get_push_location)
469
470
def set_push_location(self, location):
471
"""Set a new push location for this branch."""
472
raise NotImplementedError(self.set_push_location)
1229
import errno
1230
_locs = ['parent', 'pull', 'x-pull']
1231
for l in _locs:
1232
try:
1233
return self.controlfile(l, 'r').read().strip('\n')
1234
except IOError, e:
1235
if e.errno != errno.ENOENT:
1236
raise
1237
return None
1238
473
1239
474
1240
def set_parent(self, url):
475
raise NotImplementedError(self.set_parent)
476
477
@needs_write_lock
478
def update(self):
479
"""Synchronise this branch with the master branch if any.
480
481
:return: None or the last_revision pivoted out during the update.
482
"""
483
return None
1241
# TODO: Maybe delete old location files?
1242
from bzrlib.atomicfile import AtomicFile
1243
self.lock_write()
1244
try:
1245
f = AtomicFile(self.controlfilename('parent'))
1246
try:
1247
f.write(url + '\n')
1248
f.commit()
1249
finally:
1250
f.close()
1251
finally:
1252
self.unlock()
484
1253
485
1254
def check_revno(self, revno):
486
1255
"""\
497
1266
"""
498
1267
if revno < 1 or revno > self.revno():
499
1268
raise InvalidRevisionNumber(revno)
500
501
@needs_read_lock
502
def clone(self, *args, **kwargs):
503
"""Clone this branch into to_bzrdir preserving all semantic values.
504
505
revision_id: if not None, the revision history in the new branch will
506
be truncated to end with revision_id.
507
"""
508
# for API compatibility, until 0.8 releases we provide the old api:
509
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
510
# after 0.8 releases, the *args and **kwargs should be changed:
511
# def clone(self, to_bzrdir, revision_id=None):
512
if (kwargs.get('to_location', None) or
513
kwargs.get('revision', None) or
514
kwargs.get('basis_branch', None) or
515
(len(args) and isinstance(args[0], basestring))):
516
# backwards compatibility api:
517
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
518
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
519
# get basis_branch
520
if len(args) > 2:
521
basis_branch = args[2]
522
else:
523
basis_branch = kwargs.get('basis_branch', None)
524
if basis_branch:
525
basis = basis_branch.bzrdir
526
else:
527
basis = None
528
# get revision
529
if len(args) > 1:
530
revision_id = args[1]
531
else:
532
revision_id = kwargs.get('revision', None)
533
# get location
534
if len(args):
535
url = args[0]
536
else:
537
# no default to raise if not provided.
538
url = kwargs.get('to_location')
539
return self.bzrdir.clone(url,
540
revision_id=revision_id,
541
basis=basis).open_branch()
542
# new cleaner api.
543
# generate args by hand
544
if len(args) > 1:
545
revision_id = args[1]
546
else:
547
revision_id = kwargs.get('revision_id', None)
548
if len(args):
549
to_bzrdir = args[0]
550
else:
551
# no default to raise if not provided.
552
to_bzrdir = kwargs.get('to_bzrdir')
553
result = self._format.initialize(to_bzrdir)
554
self.copy_content_into(result, revision_id=revision_id)
555
return result
556
557
@needs_read_lock
558
def sprout(self, to_bzrdir, revision_id=None):
559
"""Create a new line of development from the branch, into to_bzrdir.
560
561
revision_id: if not None, the revision history in the new branch will
562
be truncated to end with revision_id.
563
"""
564
result = self._format.initialize(to_bzrdir)
565
self.copy_content_into(result, revision_id=revision_id)
566
result.set_parent(self.bzrdir.root_transport.base)
567
return result
568
569
def _synchronize_history(self, destination, revision_id):
570
"""Synchronize last revision and revision history between branches.
571
572
This version is most efficient when the destination is also a
573
BzrBranch5, but works for BzrBranch6 as long as the revision
574
history is the true lefthand parent history, and all of the revisions
575
are in the destination's repository. If not, set_revision_history
576
will fail.
577
578
:param destination: The branch to copy the history into
579
:param revision_id: The revision-id to truncate history at. May
580
be None to copy complete history.
581
"""
582
new_history = self.revision_history()
583
if revision_id is not None:
584
revision_id = osutils.safe_revision_id(revision_id)
585
try:
586
new_history = new_history[:new_history.index(revision_id) + 1]
587
except ValueError:
588
rev = self.repository.get_revision(revision_id)
589
new_history = rev.get_history(self.repository)[1:]
590
destination.set_revision_history(new_history)
591
592
@needs_read_lock
593
def copy_content_into(self, destination, revision_id=None):
594
"""Copy the content of self into destination.
595
596
revision_id: if not None, the revision history in the new branch will
597
be truncated to end with revision_id.
598
"""
599
self._synchronize_history(destination, revision_id)
600
try:
601
parent = self.get_parent()
602
except errors.InaccessibleParent, e:
603
mutter('parent was not accessible to copy: %s', e)
604
else:
605
if parent:
606
destination.set_parent(parent)
607
608
@needs_read_lock
609
def check(self):
610
"""Check consistency of the branch.
611
612
In particular this checks that revisions given in the revision-history
613
do actually match up in the revision graph, and that they're all
614
present in the repository.
615
616
Callers will typically also want to check the repository.
617
618
:return: A BranchCheckResult.
619
"""
620
mainline_parent_id = None
621
for revision_id in self.revision_history():
622
try:
623
revision = self.repository.get_revision(revision_id)
624
except errors.NoSuchRevision, e:
625
raise errors.BzrCheckError("mainline revision {%s} not in repository"
626
% revision_id)
627
# In general the first entry on the revision history has no parents.
628
# But it's not illegal for it to have parents listed; this can happen
629
# in imports from Arch when the parents weren't reachable.
630
if mainline_parent_id is not None:
631
if mainline_parent_id not in revision.parent_ids:
632
raise errors.BzrCheckError("previous revision {%s} not listed among "
633
"parents of {%s}"
634
% (mainline_parent_id, revision_id))
635
mainline_parent_id = revision_id
636
return BranchCheckResult(self)
637
638
def _get_checkout_format(self):
639
"""Return the most suitable metadir for a checkout of this branch.
640
Weaves are used if this branch's repostory uses weaves.
641
"""
642
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
643
from bzrlib.repofmt import weaverepo
644
format = bzrdir.BzrDirMetaFormat1()
645
format.repository_format = weaverepo.RepositoryFormat7()
646
else:
647
format = self.repository.bzrdir.cloning_metadir()
648
format.branch_format = self._format
649
return format
650
651
def create_checkout(self, to_location, revision_id=None,
652
lightweight=False):
653
"""Create a checkout of a branch.
654
655
:param to_location: The url to produce the checkout at
656
:param revision_id: The revision to check out
657
:param lightweight: If True, produce a lightweight checkout, otherwise,
658
produce a bound branch (heavyweight checkout)
659
:return: The tree of the created checkout
660
"""
661
t = transport.get_transport(to_location)
662
try:
663
t.mkdir('.')
664
except errors.FileExists:
665
pass
666
if lightweight:
667
checkout = bzrdir.BzrDirMetaFormat1().initialize_on_transport(t)
668
BranchReferenceFormat().initialize(checkout, self)
669
else:
670
format = self._get_checkout_format()
671
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
672
to_location, force_new_tree=False, format=format)
673
checkout = checkout_branch.bzrdir
674
checkout_branch.bind(self)
675
# pull up to the specified revision_id to set the initial
676
# branch tip correctly, and seed it with history.
677
checkout_branch.pull(self, stop_revision=revision_id)
678
return checkout.create_workingtree(revision_id)
679
680
681
class BranchFormat(object):
682
"""An encapsulation of the initialization and open routines for a format.
683
684
Formats provide three things:
685
* An initialization routine,
686
* a format string,
687
* an open routine.
688
689
Formats are placed in an dict by their format string for reference
690
during branch opening. Its not required that these be instances, they
691
can be classes themselves with class methods - it simply depends on
692
whether state is needed for a given format or not.
693
694
Once a format is deprecated, just deprecate the initialize and open
695
methods on the format class. Do not deprecate the object, as the
696
object will be created every time regardless.
697
"""
698
699
_default_format = None
700
"""The default format used for new branches."""
701
702
_formats = {}
703
"""The known formats."""
704
705
@classmethod
706
def find_format(klass, a_bzrdir):
707
"""Return the format for the branch object in a_bzrdir."""
708
try:
709
transport = a_bzrdir.get_branch_transport(None)
710
format_string = transport.get("format").read()
711
return klass._formats[format_string]
712
except NoSuchFile:
713
raise NotBranchError(path=transport.base)
714
except KeyError:
715
raise errors.UnknownFormatError(format=format_string)
716
717
@classmethod
718
def get_default_format(klass):
719
"""Return the current default format."""
720
return klass._default_format
721
722
def get_format_string(self):
723
"""Return the ASCII format string that identifies this format."""
724
raise NotImplementedError(self.get_format_string)
725
726
def get_format_description(self):
727
"""Return the short format description for this format."""
728
raise NotImplementedError(self.get_format_description)
729
730
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
731
set_format=True):
732
"""Initialize a branch in a bzrdir, with specified files
733
734
:param a_bzrdir: The bzrdir to initialize the branch in
735
:param utf8_files: The files to create as a list of
736
(filename, content) tuples
737
:param set_format: If True, set the format with
738
self.get_format_string. (BzrBranch4 has its format set
739
elsewhere)
740
:return: a branch in this format
741
"""
742
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
743
branch_transport = a_bzrdir.get_branch_transport(self)
744
lock_map = {
745
'metadir': ('lock', lockdir.LockDir),
746
'branch4': ('branch-lock', lockable_files.TransportLock),
747
}
748
lock_name, lock_class = lock_map[lock_type]
749
control_files = lockable_files.LockableFiles(branch_transport,
750
lock_name, lock_class)
751
control_files.create_lock()
752
control_files.lock_write()
753
if set_format:
754
control_files.put_utf8('format', self.get_format_string())
755
try:
756
for file, content in utf8_files:
757
control_files.put_utf8(file, content)
758
finally:
759
control_files.unlock()
760
return self.open(a_bzrdir, _found=True)
761
762
def initialize(self, a_bzrdir):
763
"""Create a branch of this format in a_bzrdir."""
764
raise NotImplementedError(self.initialize)
765
766
def is_supported(self):
767
"""Is this format supported?
768
769
Supported formats can be initialized and opened.
770
Unsupported formats may not support initialization or committing or
771
some other features depending on the reason for not being supported.
772
"""
773
return True
774
775
def open(self, a_bzrdir, _found=False):
776
"""Return the branch object for a_bzrdir
777
778
_found is a private parameter, do not use it. It is used to indicate
779
if format probing has already be done.
780
"""
781
raise NotImplementedError(self.open)
782
783
@classmethod
784
def register_format(klass, format):
785
klass._formats[format.get_format_string()] = format
786
787
@classmethod
788
def set_default_format(klass, format):
789
klass._default_format = format
790
791
@classmethod
792
def unregister_format(klass, format):
793
assert klass._formats[format.get_format_string()] is format
794
del klass._formats[format.get_format_string()]
795
796
def __str__(self):
797
return self.get_format_string().rstrip()
798
799
800
class BranchHooks(dict):
801
"""A dictionary mapping hook name to a list of callables for branch hooks.
802
803
e.g. ['set_rh'] Is the list of items to be called when the
804
set_revision_history function is invoked.
805
"""
806
807
def __init__(self):
808
"""Create the default hooks.
809
810
These are all empty initially, because by default nothing should get
811
notified.
812
"""
813
dict.__init__(self)
814
# Introduced in 0.15:
815
# invoked whenever the revision history has been set
816
# with set_revision_history. The api signature is
817
# (branch, revision_history), and the branch will
818
# be write-locked.
819
self['set_rh'] = []
820
# invoked after a push operation completes.
821
# the api signature is
822
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
823
# where local is the local branch or None, master is the target
824
# master branch, and the rest should be self explanatory. The source
825
# is read locked and the target branches write locked. Source will
826
# be the local low-latency branch.
827
self['post_push'] = []
828
# invoked after a pull operation completes.
829
# the api signature is
830
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
831
# where local is the local branch or None, master is the target
832
# master branch, and the rest should be self explanatory. The source
833
# is read locked and the target branches write locked. The local
834
# branch is the low-latency branch.
835
self['post_pull'] = []
836
# invoked after a commit operation completes.
837
# the api signature is
838
# (local, master, old_revno, old_revid, new_revno, new_revid)
839
# old_revid is NULL_REVISION for the first commit to a branch.
840
self['post_commit'] = []
841
# invoked after a uncommit operation completes.
842
# the api signature is
843
# (local, master, old_revno, old_revid, new_revno, new_revid) where
844
# local is the local branch or None, master is the target branch,
845
# and an empty branch recieves new_revno of 0, new_revid of None.
846
self['post_uncommit'] = []
847
848
def install_hook(self, hook_name, a_callable):
849
"""Install a_callable in to the hook hook_name.
850
851
:param hook_name: A hook name. See the __init__ method of BranchHooks
852
for the complete list of hooks.
853
:param a_callable: The callable to be invoked when the hook triggers.
854
The exact signature will depend on the hook - see the __init__
855
method of BranchHooks for details on each hook.
856
"""
857
try:
858
self[hook_name].append(a_callable)
859
except KeyError:
860
raise errors.UnknownHook('branch', hook_name)
861
862
863
# install the default hooks into the Branch class.
864
Branch.hooks = BranchHooks()
865
866
867
class BzrBranchFormat4(BranchFormat):
868
"""Bzr branch format 4.
869
870
This format has:
871
- a revision-history file.
872
- a branch-lock lock file [ to be shared with the bzrdir ]
873
"""
874
875
def get_format_description(self):
876
"""See BranchFormat.get_format_description()."""
877
return "Branch format 4"
878
879
def initialize(self, a_bzrdir):
880
"""Create a branch of this format in a_bzrdir."""
881
utf8_files = [('revision-history', ''),
882
('branch-name', ''),
883
]
884
return self._initialize_helper(a_bzrdir, utf8_files,
885
lock_type='branch4', set_format=False)
886
887
def __init__(self):
888
super(BzrBranchFormat4, self).__init__()
889
self._matchingbzrdir = bzrdir.BzrDirFormat6()
890
891
def open(self, a_bzrdir, _found=False):
892
"""Return the branch object for a_bzrdir
893
894
_found is a private parameter, do not use it. It is used to indicate
895
if format probing has already be done.
896
"""
897
if not _found:
898
# we are being called directly and must probe.
899
raise NotImplementedError
900
return BzrBranch(_format=self,
901
_control_files=a_bzrdir._control_files,
902
a_bzrdir=a_bzrdir,
903
_repository=a_bzrdir.open_repository())
904
905
def __str__(self):
906
return "Bazaar-NG branch format 4"
907
908
909
class BzrBranchFormat5(BranchFormat):
910
"""Bzr branch format 5.
911
912
This format has:
913
- a revision-history file.
914
- a format string
915
- a lock dir guarding the branch itself
916
- all of this stored in a branch/ subdirectory
917
- works with shared repositories.
918
919
This format is new in bzr 0.8.
920
"""
921
922
def get_format_string(self):
923
"""See BranchFormat.get_format_string()."""
924
return "Bazaar-NG branch format 5\n"
925
926
def get_format_description(self):
927
"""See BranchFormat.get_format_description()."""
928
return "Branch format 5"
929
930
def initialize(self, a_bzrdir):
931
"""Create a branch of this format in a_bzrdir."""
932
utf8_files = [('revision-history', ''),
933
('branch-name', ''),
934
]
935
return self._initialize_helper(a_bzrdir, utf8_files)
936
937
def __init__(self):
938
super(BzrBranchFormat5, self).__init__()
939
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
940
941
def open(self, a_bzrdir, _found=False):
942
"""Return the branch object for a_bzrdir
943
944
_found is a private parameter, do not use it. It is used to indicate
945
if format probing has already be done.
946
"""
947
if not _found:
948
format = BranchFormat.find_format(a_bzrdir)
949
assert format.__class__ == self.__class__
950
transport = a_bzrdir.get_branch_transport(None)
951
control_files = lockable_files.LockableFiles(transport, 'lock',
952
lockdir.LockDir)
953
return BzrBranch5(_format=self,
954
_control_files=control_files,
955
a_bzrdir=a_bzrdir,
956
_repository=a_bzrdir.find_repository())
957
958
def __str__(self):
959
return "Bazaar-NG Metadir branch format 5"
960
961
962
class BzrBranchFormat6(BzrBranchFormat5):
963
"""Branch format with last-revision
964
965
Unlike previous formats, this has no explicit revision history. Instead,
966
this just stores the last-revision, and the left-hand history leading
967
up to there is the history.
968
969
This format was introduced in bzr 0.15
970
"""
971
972
def get_format_string(self):
973
"""See BranchFormat.get_format_string()."""
974
return "Bazaar-NG branch format 6\n"
975
976
def get_format_description(self):
977
"""See BranchFormat.get_format_description()."""
978
return "Branch format 6"
979
980
def initialize(self, a_bzrdir):
981
"""Create a branch of this format in a_bzrdir."""
982
utf8_files = [('last-revision', '0 null:\n'),
983
('branch-name', ''),
984
('branch.conf', '')
985
]
986
return self._initialize_helper(a_bzrdir, utf8_files)
987
988
def open(self, a_bzrdir, _found=False):
989
"""Return the branch object for a_bzrdir
990
991
_found is a private parameter, do not use it. It is used to indicate
992
if format probing has already be done.
993
"""
994
if not _found:
995
format = BranchFormat.find_format(a_bzrdir)
996
assert format.__class__ == self.__class__
997
transport = a_bzrdir.get_branch_transport(None)
998
control_files = lockable_files.LockableFiles(transport, 'lock',
999
lockdir.LockDir)
1000
return BzrBranch6(_format=self,
1001
_control_files=control_files,
1002
a_bzrdir=a_bzrdir,
1003
_repository=a_bzrdir.find_repository())
1004
1005
1006
class BranchReferenceFormat(BranchFormat):
1007
"""Bzr branch reference format.
1008
1009
Branch references are used in implementing checkouts, they
1010
act as an alias to the real branch which is at some other url.
1011
1012
This format has:
1013
- A location file
1014
- a format string
1015
"""
1016
1017
def get_format_string(self):
1018
"""See BranchFormat.get_format_string()."""
1019
return "Bazaar-NG Branch Reference Format 1\n"
1020
1021
def get_format_description(self):
1022
"""See BranchFormat.get_format_description()."""
1023
return "Checkout reference format 1"
1024
1025
def initialize(self, a_bzrdir, target_branch=None):
1026
"""Create a branch of this format in a_bzrdir."""
1027
if target_branch is None:
1028
# this format does not implement branch itself, thus the implicit
1029
# creation contract must see it as uninitializable
1030
raise errors.UninitializableFormat(self)
1031
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1032
branch_transport = a_bzrdir.get_branch_transport(self)
1033
branch_transport.put_bytes('location',
1034
target_branch.bzrdir.root_transport.base)
1035
branch_transport.put_bytes('format', self.get_format_string())
1036
return self.open(a_bzrdir, _found=True)
1037
1038
def __init__(self):
1039
super(BranchReferenceFormat, self).__init__()
1040
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1041
1042
def _make_reference_clone_function(format, a_branch):
1043
"""Create a clone() routine for a branch dynamically."""
1044
def clone(to_bzrdir, revision_id=None):
1045
"""See Branch.clone()."""
1046
return format.initialize(to_bzrdir, a_branch)
1047
# cannot obey revision_id limits when cloning a reference ...
1048
# FIXME RBC 20060210 either nuke revision_id for clone, or
1049
# emit some sort of warning/error to the caller ?!
1050
return clone
1051
1052
def open(self, a_bzrdir, _found=False):
1053
"""Return the branch that the branch reference in a_bzrdir points at.
1054
1055
_found is a private parameter, do not use it. It is used to indicate
1056
if format probing has already be done.
1057
"""
1058
if not _found:
1059
format = BranchFormat.find_format(a_bzrdir)
1060
assert format.__class__ == self.__class__
1061
transport = a_bzrdir.get_branch_transport(None)
1062
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
1063
result = real_bzrdir.open_branch()
1064
# this changes the behaviour of result.clone to create a new reference
1065
# rather than a copy of the content of the branch.
1066
# I did not use a proxy object because that needs much more extensive
1067
# testing, and we are only changing one behaviour at the moment.
1068
# If we decide to alter more behaviours - i.e. the implicit nickname
1069
# then this should be refactored to introduce a tested proxy branch
1070
# and a subclass of that for use in overriding clone() and ....
1071
# - RBC 20060210
1072
result.clone = self._make_reference_clone_function(result)
1073
return result
1074
1075
1076
# formats which have no format string are not discoverable
1077
# and not independently creatable, so are not registered.
1078
__default_format = BzrBranchFormat5()
1079
BranchFormat.register_format(__default_format)
1080
BranchFormat.register_format(BranchReferenceFormat())
1081
BranchFormat.register_format(BzrBranchFormat6())
1082
BranchFormat.set_default_format(__default_format)
1083
_legacy_formats = [BzrBranchFormat4(),
1084
]
1085
1086
class BzrBranch(Branch):
1087
"""A branch stored in the actual filesystem.
1088
1089
Note that it's "local" in the context of the filesystem; it doesn't
1090
really matter if it's on an nfs/smb/afs/coda/... share, as long as
1091
it's writable, and can be accessed via the normal filesystem API.
1092
"""
1093
1094
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
1095
relax_version_check=DEPRECATED_PARAMETER, _format=None,
1096
_control_files=None, a_bzrdir=None, _repository=None):
1097
"""Create new branch object at a particular location.
1098
1099
transport -- A Transport object, defining how to access files.
1100
1101
init -- If True, create new control files in a previously
1102
unversioned directory. If False, the branch must already
1103
be versioned.
1104
1105
relax_version_check -- If true, the usual check for the branch
1106
version is not applied. This is intended only for
1107
upgrade/recovery type use; it's not guaranteed that
1108
all operations will work on old format branches.
1109
"""
1110
if a_bzrdir is None:
1111
self.bzrdir = bzrdir.BzrDir.open(transport.base)
1112
else:
1113
self.bzrdir = a_bzrdir
1114
self._transport = self.bzrdir.transport.clone('..')
1115
self._base = self._transport.base
1116
self._format = _format
1117
if _control_files is None:
1118
raise ValueError('BzrBranch _control_files is None')
1119
self.control_files = _control_files
1120
if deprecated_passed(init):
1121
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
1122
"deprecated as of bzr 0.8. Please use Branch.create().",
1123
DeprecationWarning,
1124
stacklevel=2)
1125
if init:
1126
# this is slower than before deprecation, oh well never mind.
1127
# -> its deprecated.
1128
self._initialize(transport.base)
1129
self._check_format(_format)
1130
if deprecated_passed(relax_version_check):
1131
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
1132
"relax_version_check parameter is deprecated as of bzr 0.8. "
1133
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
1134
"open() method.",
1135
DeprecationWarning,
1136
stacklevel=2)
1137
if (not relax_version_check
1138
and not self._format.is_supported()):
1139
raise errors.UnsupportedFormatError(format=fmt)
1140
if deprecated_passed(transport):
1141
warn("BzrBranch.__init__(transport=XXX...): The transport "
1142
"parameter is deprecated as of bzr 0.8. "
1143
"Please use Branch.open, or bzrdir.open_branch().",
1144
DeprecationWarning,
1145
stacklevel=2)
1146
self.repository = _repository
1147
1148
def __str__(self):
1149
return '%s(%r)' % (self.__class__.__name__, self.base)
1150
1151
__repr__ = __str__
1152
1153
def _get_base(self):
1154
return self._base
1155
1156
base = property(_get_base, doc="The URL for the root of this branch.")
1157
1158
def _finish_transaction(self):
1159
"""Exit the current transaction."""
1160
return self.control_files._finish_transaction()
1161
1162
def get_transaction(self):
1163
"""Return the current active transaction.
1164
1165
If no transaction is active, this returns a passthrough object
1166
for which all data is immediately flushed and no caching happens.
1167
"""
1168
# this is an explicit function so that we can do tricky stuff
1169
# when the storage in rev_storage is elsewhere.
1170
# we probably need to hook the two 'lock a location' and
1171
# 'have a transaction' together more delicately, so that
1172
# we can have two locks (branch and storage) and one transaction
1173
# ... and finishing the transaction unlocks both, but unlocking
1174
# does not. - RBC 20051121
1175
return self.control_files.get_transaction()
1176
1177
def _set_transaction(self, transaction):
1178
"""Set a new active transaction."""
1179
return self.control_files._set_transaction(transaction)
1180
1181
def abspath(self, name):
1182
"""See Branch.abspath."""
1183
return self.control_files._transport.abspath(name)
1184
1185
def _check_format(self, format):
1186
"""Identify the branch format if needed.
1187
1188
The format is stored as a reference to the format object in
1189
self._format for code that needs to check it later.
1190
1191
The format parameter is either None or the branch format class
1192
used to open this branch.
1193
1194
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
1195
"""
1196
if format is None:
1197
format = BranchFormat.find_format(self.bzrdir)
1198
self._format = format
1199
mutter("got branch format %s", self._format)
1200
1201
@needs_read_lock
1202
def get_root_id(self):
1203
"""See Branch.get_root_id."""
1204
tree = self.repository.revision_tree(self.last_revision())
1205
return tree.inventory.root.file_id
1206
1207
def is_locked(self):
1208
return self.control_files.is_locked()
1209
1210
def lock_write(self):
1211
self.repository.lock_write()
1212
try:
1213
self.control_files.lock_write()
1214
except:
1215
self.repository.unlock()
1216
raise
1217
1218
def lock_read(self):
1219
self.repository.lock_read()
1220
try:
1221
self.control_files.lock_read()
1222
except:
1223
self.repository.unlock()
1224
raise
1225
1226
def unlock(self):
1227
# TODO: test for failed two phase locks. This is known broken.
1228
try:
1229
self.control_files.unlock()
1230
finally:
1231
self.repository.unlock()
1232
1233
def peek_lock_mode(self):
1234
if self.control_files._lock_count == 0:
1235
return None
1236
else:
1237
return self.control_files._lock_mode
1238
1239
def get_physical_lock_status(self):
1240
return self.control_files.get_physical_lock_status()
1241
1242
@needs_read_lock
1243
def print_file(self, file, revision_id):
1244
"""See Branch.print_file."""
1245
return self.repository.print_file(file, revision_id)
1246
1247
@needs_write_lock
1248
def append_revision(self, *revision_ids):
1249
"""See Branch.append_revision."""
1250
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1251
for revision_id in revision_ids:
1252
_mod_revision.check_not_reserved_id(revision_id)
1253
mutter("add {%s} to revision-history" % revision_id)
1254
rev_history = self.revision_history()
1255
rev_history.extend(revision_ids)
1256
self.set_revision_history(rev_history)
1257
1258
def _write_revision_history(self, history):
1259
"""Factored out of set_revision_history.
1260
1261
This performs the actual writing to disk.
1262
It is intended to be called by BzrBranch5.set_revision_history."""
1263
self.control_files.put_bytes(
1264
'revision-history', '\n'.join(history))
1265
1266
@needs_write_lock
1267
def set_revision_history(self, rev_history):
1268
"""See Branch.set_revision_history."""
1269
rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1270
self._write_revision_history(rev_history)
1271
transaction = self.get_transaction()
1272
history = transaction.map.find_revision_history()
1273
if history is not None:
1274
# update the revision history in the identity map.
1275
history[:] = list(rev_history)
1276
# this call is disabled because revision_history is
1277
# not really an object yet, and the transaction is for objects.
1278
# transaction.register_dirty(history)
1279
else:
1280
transaction.map.add_revision_history(rev_history)
1281
# this call is disabled because revision_history is
1282
# not really an object yet, and the transaction is for objects.
1283
# transaction.register_clean(history)
1284
for hook in Branch.hooks['set_rh']:
1285
hook(self, rev_history)
1286
1287
@needs_write_lock
1288
def set_last_revision_info(self, revno, revision_id):
1289
revision_id = osutils.safe_revision_id(revision_id)
1290
history = self._lefthand_history(revision_id)
1291
assert len(history) == revno, '%d != %d' % (len(history), revno)
1292
self.set_revision_history(history)
1293
1294
def _gen_revision_history(self):
1295
get_cached_utf8 = cache_utf8.get_cached_utf8
1296
history = [get_cached_utf8(l.rstrip('\r\n')) for l in
1297
self.control_files.get('revision-history').readlines()]
1298
return history
1299
1300
@needs_read_lock
1301
def revision_history(self):
1302
"""See Branch.revision_history."""
1303
transaction = self.get_transaction()
1304
history = transaction.map.find_revision_history()
1305
if history is not None:
1306
# mutter("cache hit for revision-history in %s", self)
1307
return list(history)
1308
history = self._gen_revision_history()
1309
transaction.map.add_revision_history(history)
1310
# this call is disabled because revision_history is
1311
# not really an object yet, and the transaction is for objects.
1312
# transaction.register_clean(history, precious=True)
1313
return list(history)
1314
1315
def _lefthand_history(self, revision_id, last_rev=None,
1316
other_branch=None):
1317
# stop_revision must be a descendant of last_revision
1318
stop_graph = self.repository.get_revision_graph(revision_id)
1319
if last_rev is not None and last_rev not in stop_graph:
1320
# our previous tip is not merged into stop_revision
1321
raise errors.DivergedBranches(self, other_branch)
1322
# make a new revision history from the graph
1323
current_rev_id = revision_id
1324
new_history = []
1325
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1326
new_history.append(current_rev_id)
1327
current_rev_id_parents = stop_graph[current_rev_id]
1328
try:
1329
current_rev_id = current_rev_id_parents[0]
1330
except IndexError:
1331
current_rev_id = None
1332
new_history.reverse()
1333
return new_history
1334
1335
@needs_write_lock
1336
def generate_revision_history(self, revision_id, last_rev=None,
1337
other_branch=None):
1338
"""Create a new revision history that will finish with revision_id.
1339
1340
:param revision_id: the new tip to use.
1341
:param last_rev: The previous last_revision. If not None, then this
1342
must be a ancestory of revision_id, or DivergedBranches is raised.
1343
:param other_branch: The other branch that DivergedBranches should
1344
raise with respect to.
1345
"""
1346
revision_id = osutils.safe_revision_id(revision_id)
1347
self.set_revision_history(self._lefthand_history(revision_id,
1348
last_rev, other_branch))
1349
1350
@needs_write_lock
1351
def update_revisions(self, other, stop_revision=None):
1352
"""See Branch.update_revisions."""
1353
other.lock_read()
1354
try:
1355
if stop_revision is None:
1356
stop_revision = other.last_revision()
1357
if stop_revision is None:
1358
# if there are no commits, we're done.
1359
return
1360
else:
1361
stop_revision = osutils.safe_revision_id(stop_revision)
1362
# whats the current last revision, before we fetch [and change it
1363
# possibly]
1364
last_rev = self.last_revision()
1365
# we fetch here regardless of whether we need to so that we pickup
1366
# filled in ghosts.
1367
self.fetch(other, stop_revision)
1368
my_ancestry = self.repository.get_ancestry(last_rev)
1369
if stop_revision in my_ancestry:
1370
# last_revision is a descendant of stop_revision
1371
return
1372
self.generate_revision_history(stop_revision, last_rev=last_rev,
1373
other_branch=other)
1374
finally:
1375
other.unlock()
1376
1377
def basis_tree(self):
1378
"""See Branch.basis_tree."""
1379
return self.repository.revision_tree(self.last_revision())
1380
1381
@deprecated_method(zero_eight)
1382
def working_tree(self):
1383
"""Create a Working tree object for this branch."""
1384
1385
from bzrlib.transport.local import LocalTransport
1386
if (self.base.find('://') != -1 or
1387
not isinstance(self._transport, LocalTransport)):
1388
raise NoWorkingTree(self.base)
1389
return self.bzrdir.open_workingtree()
1390
1391
@needs_write_lock
1392
def pull(self, source, overwrite=False, stop_revision=None,
1393
_hook_master=None, _run_hooks=True):
1394
"""See Branch.pull.
1395
1396
:param _hook_master: Private parameter - set the branch to
1397
be supplied as the master to push hooks.
1398
:param _run_hooks: Private parameter - allow disabling of
1399
hooks, used when pushing to a master branch.
1400
"""
1401
source.lock_read()
1402
try:
1403
old_count, old_tip = self.last_revision_info()
1404
try:
1405
self.update_revisions(source, stop_revision)
1406
except DivergedBranches:
1407
if not overwrite:
1408
raise
1409
if overwrite:
1410
self.set_revision_history(source.revision_history())
1411
new_count, new_tip = self.last_revision_info()
1412
if _run_hooks:
1413
if _hook_master:
1414
_hook_local = self
1415
else:
1416
_hook_master = self
1417
_hook_local = None
1418
for hook in Branch.hooks['post_pull']:
1419
hook(source, _hook_local, _hook_master, old_count, old_tip,
1420
new_count, new_tip)
1421
return new_count - old_count
1422
finally:
1423
source.unlock()
1424
1425
def _get_parent_location(self):
1426
_locs = ['parent', 'pull', 'x-pull']
1427
for l in _locs:
1428
try:
1429
return self.control_files.get(l).read().strip('\n')
1430
except NoSuchFile:
1431
pass
1432
return None
1433
1434
@needs_read_lock
1435
def push(self, target, overwrite=False, stop_revision=None,
1436
_hook_master=None, _run_hooks=True):
1437
"""See Branch.push.
1438
1439
:param _hook_master: Private parameter - set the branch to
1440
be supplied as the master to push hooks.
1441
:param _run_hooks: Private parameter - allow disabling of
1442
hooks, used when pushing to a master branch.
1443
"""
1444
target.lock_write()
1445
try:
1446
old_count, old_tip = target.last_revision_info()
1447
try:
1448
target.update_revisions(self, stop_revision)
1449
except DivergedBranches:
1450
if not overwrite:
1451
raise
1452
if overwrite:
1453
target.set_revision_history(self.revision_history())
1454
new_count, new_tip = target.last_revision_info()
1455
if _run_hooks:
1456
if _hook_master:
1457
_hook_local = target
1458
else:
1459
_hook_master = target
1460
_hook_local = None
1461
for hook in Branch.hooks['post_push']:
1462
hook(self, _hook_local, _hook_master, old_count, old_tip,
1463
new_count, new_tip)
1464
return new_count - old_count
1465
finally:
1466
target.unlock()
1467
1468
def get_parent(self):
1469
"""See Branch.get_parent."""
1470
1471
assert self.base[-1] == '/'
1472
parent = self._get_parent_location()
1473
if parent is None:
1474
return parent
1475
# This is an old-format absolute path to a local branch
1476
# turn it into a url
1477
if parent.startswith('/'):
1478
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1479
try:
1480
return urlutils.join(self.base[:-1], parent)
1481
except errors.InvalidURLJoin, e:
1482
raise errors.InaccessibleParent(parent, self.base)
1483
1484
def get_push_location(self):
1485
"""See Branch.get_push_location."""
1486
push_loc = self.get_config().get_user_option('push_location')
1487
return push_loc
1488
1489
def set_push_location(self, location):
1490
"""See Branch.set_push_location."""
1491
self.get_config().set_user_option(
1492
'push_location', location,
1493
store=_mod_config.STORE_LOCATION_NORECURSE)
1494
1495
@needs_write_lock
1496
def set_parent(self, url):
1497
"""See Branch.set_parent."""
1498
# TODO: Maybe delete old location files?
1499
# URLs should never be unicode, even on the local fs,
1500
# FIXUP this and get_parent in a future branch format bump:
1501
# read and rewrite the file, and have the new format code read
1502
# using .get not .get_utf8. RBC 20060125
1503
if url is not None:
1504
if isinstance(url, unicode):
1505
try:
1506
url = url.encode('ascii')
1507
except UnicodeEncodeError:
1508
raise bzrlib.errors.InvalidURL(url,
1509
"Urls must be 7-bit ascii, "
1510
"use bzrlib.urlutils.escape")
1511
url = urlutils.relative_url(self.base, url)
1512
self._set_parent_location(url)
1513
1514
def _set_parent_location(self, url):
1515
if url is None:
1516
self.control_files._transport.delete('parent')
1517
else:
1518
assert isinstance(url, str)
1519
self.control_files.put_bytes('parent', url + '\n')
1520
1521
@deprecated_function(zero_nine)
1522
def tree_config(self):
1523
"""DEPRECATED; call get_config instead.
1524
TreeConfig has become part of BranchConfig."""
1525
return TreeConfig(self)
1526
1527
1528
class BzrBranch5(BzrBranch):
1529
"""A format 5 branch. This supports new features over plan branches.
1530
1531
It has support for a master_branch which is the data for bound branches.
1532
"""
1533
1534
def __init__(self,
1535
_format,
1536
_control_files,
1537
a_bzrdir,
1538
_repository):
1539
super(BzrBranch5, self).__init__(_format=_format,
1540
_control_files=_control_files,
1541
a_bzrdir=a_bzrdir,
1542
_repository=_repository)
1543
1544
@needs_write_lock
1545
def pull(self, source, overwrite=False, stop_revision=None,
1546
_run_hooks=True):
1547
"""Extends branch.pull to be bound branch aware.
1548
1549
:param _run_hooks: Private parameter used to force hook running
1550
off during bound branch double-pushing.
1551
"""
1552
bound_location = self.get_bound_location()
1553
master_branch = None
1554
if bound_location and source.base != bound_location:
1555
# not pulling from master, so we need to update master.
1556
master_branch = self.get_master_branch()
1557
master_branch.lock_write()
1558
try:
1559
if master_branch:
1560
# pull from source into master.
1561
master_branch.pull(source, overwrite, stop_revision,
1562
_run_hooks=False)
1563
return super(BzrBranch5, self).pull(source, overwrite,
1564
stop_revision, _hook_master=master_branch,
1565
_run_hooks=_run_hooks)
1566
finally:
1567
if master_branch:
1568
master_branch.unlock()
1569
1570
@needs_read_lock
1571
def push(self, target, overwrite=False, stop_revision=None):
1572
"""Updates branch.push to be bound branch aware."""
1573
bound_location = target.get_bound_location()
1574
master_branch = None
1575
if bound_location and target.base != bound_location:
1576
# not pushing to master, so we need to update master.
1577
master_branch = target.get_master_branch()
1578
master_branch.lock_write()
1579
try:
1580
if master_branch:
1581
# push into the master from this branch.
1582
super(BzrBranch5, self).push(master_branch, overwrite,
1583
stop_revision, _run_hooks=False)
1584
# and push into the target branch from this. Note that we push from
1585
# this branch again, because its considered the highest bandwidth
1586
# repository.
1587
return super(BzrBranch5, self).push(target, overwrite,
1588
stop_revision, _hook_master=master_branch)
1589
finally:
1590
if master_branch:
1591
master_branch.unlock()
1592
1593
def get_bound_location(self):
1594
try:
1595
return self.control_files.get_utf8('bound').read()[:-1]
1596
except errors.NoSuchFile:
1597
return None
1598
1599
@needs_read_lock
1600
def get_master_branch(self):
1601
"""Return the branch we are bound to.
1602
1603
:return: Either a Branch, or None
1604
1605
This could memoise the branch, but if thats done
1606
it must be revalidated on each new lock.
1607
So for now we just don't memoise it.
1608
# RBC 20060304 review this decision.
1609
"""
1610
bound_loc = self.get_bound_location()
1611
if not bound_loc:
1612
return None
1613
try:
1614
return Branch.open(bound_loc)
1615
except (errors.NotBranchError, errors.ConnectionError), e:
1616
raise errors.BoundBranchConnectionFailure(
1617
self, bound_loc, e)
1618
1619
@needs_write_lock
1620
def set_bound_location(self, location):
1621
"""Set the target where this branch is bound to.
1622
1623
:param location: URL to the target branch
1624
"""
1625
if location:
1626
self.control_files.put_utf8('bound', location+'\n')
1627
else:
1628
try:
1629
self.control_files._transport.delete('bound')
1630
except NoSuchFile:
1631
return False
1269
1270
1271
1272
1273
1274
class ScratchBranch(_Branch):
1275
"""Special test class: a branch that cleans up after itself.
1276
1277
>>> b = ScratchBranch()
1278
>>> isdir(b.base)
1279
True
1280
>>> bd = b.base
1281
>>> b.destroy()
1282
>>> isdir(bd)
1283
False
1284
"""
1285
def __init__(self, files=[], dirs=[], base=None):
1286
"""Make a test branch.
1287
1288
This creates a temporary directory and runs init-tree in it.
1289
1290
If any files are listed, they are created in the working copy.
1291
"""
1292
from tempfile import mkdtemp
1293
init = False
1294
if base is None:
1295
base = mkdtemp()
1296
init = True
1297
if isinstance(base, basestring):
1298
base = get_transport(base)
1299
_Branch.__init__(self, base, init=init)
1300
for d in dirs:
1301
self._transport.mkdir(d)
1302
1303
for f in files:
1304
self._transport.put(f, 'content of %s' % f)
1305
1306
1307
def clone(self):
1308
"""
1309
>>> orig = ScratchBranch(files=["file1", "file2"])
1310
>>> clone = orig.clone()
1311
>>> if os.name != 'nt':
1312
... os.path.samefile(orig.base, clone.base)
1313
... else:
1314
... orig.base == clone.base
1315
...
1316
False
1317
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1318
True
1319
"""
1320
from shutil import copytree
1321
from tempfile import mkdtemp
1322
base = mkdtemp()
1323
os.rmdir(base)
1324
copytree(self.base, base, symlinks=True)
1325
return ScratchBranch(base=base)
1326
1327
def __del__(self):
1328
self.destroy()
1329
1330
def destroy(self):
1331
"""Destroy the test branch, removing the scratch directory."""
1332
from shutil import rmtree
1333
try:
1334
if self.base:
1335
mutter("delete ScratchBranch %s" % self.base)
1336
rmtree(self.base)
1337
except OSError, e:
1338
# Work around for shutil.rmtree failing on Windows when
1339
# readonly files are encountered
1340
mutter("hit exception in destroying ScratchBranch: %s" % e)
1341
for root, dirs, files in os.walk(self.base, topdown=False):
1342
for name in files:
1343
os.chmod(os.path.join(root, name), 0700)
1344
rmtree(self.base)
1345
self._transport = None
1346
1347
1348
1349
######################################################################
1350
# predicates
1351
1352
1353
def is_control_file(filename):
1354
## FIXME: better check
1355
filename = os.path.normpath(filename)
1356
while filename != '':
1357
head, tail = os.path.split(filename)
1358
## mutter('check %r for control file' % ((head, tail), ))
1359
if tail == bzrlib.BZRDIR:
1632
1360
return True
1633
1634
@needs_write_lock
1635
def bind(self, other):
1636
"""Bind this branch to the branch other.
1637
1638
This does not push or pull data between the branches, though it does
1639
check for divergence to raise an error when the branches are not
1640
either the same, or one a prefix of the other. That behaviour may not
1641
be useful, so that check may be removed in future.
1642
1643
:param other: The branch to bind to
1644
:type other: Branch
1645
"""
1646
# TODO: jam 20051230 Consider checking if the target is bound
1647
# It is debatable whether you should be able to bind to
1648
# a branch which is itself bound.
1649
# Committing is obviously forbidden,
1650
# but binding itself may not be.
1651
# Since we *have* to check at commit time, we don't
1652
# *need* to check here
1653
1654
# we want to raise diverged if:
1655
# last_rev is not in the other_last_rev history, AND
1656
# other_last_rev is not in our history, and do it without pulling
1657
# history around
1658
last_rev = self.last_revision()
1659
if last_rev is not None:
1660
other.lock_read()
1661
try:
1662
other_last_rev = other.last_revision()
1663
if other_last_rev is not None:
1664
# neither branch is new, we have to do some work to
1665
# ascertain diversion.
1666
remote_graph = other.repository.get_revision_graph(
1667
other_last_rev)
1668
local_graph = self.repository.get_revision_graph(last_rev)
1669
if (last_rev not in remote_graph and
1670
other_last_rev not in local_graph):
1671
raise errors.DivergedBranches(self, other)
1672
finally:
1673
other.unlock()
1674
self.set_bound_location(other.base)
1675
1676
@needs_write_lock
1677
def unbind(self):
1678
"""If bound, unbind"""
1679
return self.set_bound_location(None)
1680
1681
@needs_write_lock
1682
def update(self):
1683
"""Synchronise this branch with the master branch if any.
1684
1685
:return: None or the last_revision that was pivoted out during the
1686
update.
1687
"""
1688
master = self.get_master_branch()
1689
if master is not None:
1690
old_tip = self.last_revision()
1691
self.pull(master, overwrite=True)
1692
if old_tip in self.repository.get_ancestry(self.last_revision()):
1693
return None
1694
return old_tip
1695
return None
1696
1697
1698
class BzrBranch6(BzrBranch5):
1699
1700
@needs_read_lock
1701
def last_revision_info(self):
1702
revision_string = self.control_files.get('last-revision').read()
1703
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1704
revision_id = cache_utf8.get_cached_utf8(revision_id)
1705
revno = int(revno)
1706
return revno, revision_id
1707
1708
def last_revision(self):
1709
"""Return last revision id, or None"""
1710
revision_id = self.last_revision_info()[1]
1711
if revision_id == _mod_revision.NULL_REVISION:
1712
revision_id = None
1713
return revision_id
1714
1715
def _write_last_revision_info(self, revno, revision_id):
1716
"""Simply write out the revision id, with no checks.
1717
1718
Use set_last_revision_info to perform this safely.
1719
1720
Does not update the revision_history cache.
1721
Intended to be called by set_last_revision_info and
1722
_write_revision_history.
1723
"""
1724
if revision_id is None:
1725
revision_id = 'null:'
1726
out_string = '%d %s\n' % (revno, revision_id)
1727
self.control_files.put_bytes('last-revision', out_string)
1728
1729
@needs_write_lock
1730
def set_last_revision_info(self, revno, revision_id):
1731
revision_id = osutils.safe_revision_id(revision_id)
1732
if self._get_append_revisions_only():
1733
self._check_history_violation(revision_id)
1734
self._write_last_revision_info(revno, revision_id)
1735
transaction = self.get_transaction()
1736
cached_history = transaction.map.find_revision_history()
1737
if cached_history is not None:
1738
transaction.map.remove_object(cached_history)
1739
1740
def _check_history_violation(self, revision_id):
1741
last_revision = self.last_revision()
1742
if last_revision is None:
1743
return
1744
if last_revision not in self._lefthand_history(revision_id):
1745
raise errors.AppendRevisionsOnlyViolation(self.base)
1746
1747
def _gen_revision_history(self):
1748
"""Generate the revision history from last revision
1749
"""
1750
history = list(self.repository.iter_reverse_revision_history(
1751
self.last_revision()))
1752
history.reverse()
1753
return history
1754
1755
def _write_revision_history(self, history):
1756
"""Factored out of set_revision_history.
1757
1758
This performs the actual writing to disk, with format-specific checks.
1759
It is intended to be called by BzrBranch5.set_revision_history.
1760
"""
1761
if len(history) == 0:
1762
last_revision = 'null:'
1763
else:
1764
if history != self._lefthand_history(history[-1]):
1765
raise errors.NotLefthandHistory(history)
1766
last_revision = history[-1]
1767
if self._get_append_revisions_only():
1768
self._check_history_violation(last_revision)
1769
self._write_last_revision_info(len(history), last_revision)
1770
1771
@needs_write_lock
1772
def append_revision(self, *revision_ids):
1773
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1774
if len(revision_ids) == 0:
1775
return
1776
prev_revno, prev_revision = self.last_revision_info()
1777
for revision in self.repository.get_revisions(revision_ids):
1778
if prev_revision == _mod_revision.NULL_REVISION:
1779
if revision.parent_ids != []:
1780
raise errors.NotLeftParentDescendant(self, prev_revision,
1781
revision.revision_id)
1782
else:
1783
if revision.parent_ids[0] != prev_revision:
1784
raise errors.NotLeftParentDescendant(self, prev_revision,
1785
revision.revision_id)
1786
prev_revision = revision.revision_id
1787
self.set_last_revision_info(prev_revno + len(revision_ids),
1788
revision_ids[-1])
1789
1790
def _set_config_location(self, name, url, config=None,
1791
make_relative=False):
1792
if config is None:
1793
config = self.get_config()
1794
if url is None:
1795
url = ''
1796
elif make_relative:
1797
url = urlutils.relative_url(self.base, url)
1798
config.set_user_option(name, url)
1799
1800
1801
def _get_config_location(self, name, config=None):
1802
if config is None:
1803
config = self.get_config()
1804
location = config.get_user_option(name)
1805
if location == '':
1806
location = None
1807
return location
1808
1809
@needs_write_lock
1810
def _set_parent_location(self, url):
1811
"""Set the parent branch"""
1812
self._set_config_location('parent_location', url, make_relative=True)
1813
1814
@needs_read_lock
1815
def _get_parent_location(self):
1816
"""Set the parent branch"""
1817
return self._get_config_location('parent_location')
1818
1819
def set_push_location(self, location):
1820
"""See Branch.set_push_location."""
1821
self._set_config_location('push_location', location)
1822
1823
def set_bound_location(self, location):
1824
"""See Branch.set_push_location."""
1825
result = None
1826
config = self.get_config()
1827
if location is None:
1828
if config.get_user_option('bound') != 'True':
1829
return False
1830
else:
1831
config.set_user_option('bound', 'False')
1832
return True
1833
else:
1834
self._set_config_location('bound_location', location,
1835
config=config)
1836
config.set_user_option('bound', 'True')
1837
return True
1838
1839
def _get_bound_location(self, bound):
1840
"""Return the bound location in the config file.
1841
1842
Return None if the bound parameter does not match"""
1843
config = self.get_config()
1844
config_bound = (config.get_user_option('bound') == 'True')
1845
if config_bound != bound:
1846
return None
1847
return self._get_config_location('bound_location', config=config)
1848
1849
def get_bound_location(self):
1850
"""See Branch.set_push_location."""
1851
return self._get_bound_location(True)
1852
1853
def get_old_bound_location(self):
1854
"""See Branch.get_old_bound_location"""
1855
return self._get_bound_location(False)
1856
1857
def set_append_revisions_only(self, enabled):
1858
if enabled:
1859
value = 'True'
1860
else:
1861
value = 'False'
1862
self.get_config().set_user_option('append_revisions_only', value)
1863
1864
def _get_append_revisions_only(self):
1865
value = self.get_config().get_user_option('append_revisions_only')
1866
return value == 'True'
1867
1868
def _synchronize_history(self, destination, revision_id):
1869
"""Synchronize last revision and revision history between branches.
1870
1871
This version is most efficient when the destination is also a
1872
BzrBranch6, but works for BzrBranch5, as long as the destination's
1873
repository contains all the lefthand ancestors of the intended
1874
last_revision. If not, set_last_revision_info will fail.
1875
1876
:param destination: The branch to copy the history into
1877
:param revision_id: The revision-id to truncate history at. May
1878
be None to copy complete history.
1879
"""
1880
if revision_id is None:
1881
revno, revision_id = self.last_revision_info()
1882
else:
1883
revno = self.revision_id_to_revno(revision_id)
1884
destination.set_last_revision_info(revno, revision_id)
1885
1886
1887
class BranchTestProviderAdapter(object):
1888
"""A tool to generate a suite testing multiple branch formats at once.
1889
1890
This is done by copying the test once for each transport and injecting
1891
the transport_server, transport_readonly_server, and branch_format
1892
classes into each copy. Each copy is also given a new id() to make it
1893
easy to identify.
1894
"""
1895
1896
def __init__(self, transport_server, transport_readonly_server, formats):
1897
self._transport_server = transport_server
1898
self._transport_readonly_server = transport_readonly_server
1899
self._formats = formats
1900
1901
def adapt(self, test):
1902
result = TestSuite()
1903
for branch_format, bzrdir_format in self._formats:
1904
new_test = deepcopy(test)
1905
new_test.transport_server = self._transport_server
1906
new_test.transport_readonly_server = self._transport_readonly_server
1907
new_test.bzrdir_format = bzrdir_format
1908
new_test.branch_format = branch_format
1909
def make_new_test_id():
1910
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1911
return lambda: new_id
1912
new_test.id = make_new_test_id()
1913
result.addTest(new_test)
1914
return result
1915
1916
1917
class BranchCheckResult(object):
1918
"""Results of checking branch consistency.
1919
1920
:see: Branch.check
1921
"""
1922
1923
def __init__(self, branch):
1924
self.branch = branch
1925
1926
def report_results(self, verbose):
1927
"""Report the check results via trace.note.
1928
1929
:param verbose: Requests more detailed display of what was checked,
1930
if any.
1931
"""
1932
note('checked branch %s format %s',
1933
self.branch.base,
1934
self.branch._format)
1935
1936
1937
######################################################################
1938
# predicates
1939
1940
1941
@deprecated_function(zero_eight)
1942
def is_control_file(*args, **kwargs):
1943
"""See bzrlib.workingtree.is_control_file."""
1944
from bzrlib import workingtree
1945
return workingtree.is_control_file(*args, **kwargs)
1946
1947
1948
class Converter5to6(object):
1949
"""Perform an in-place upgrade of format 5 to format 6"""
1950
1951
def convert(self, branch):
1952
# Data for 5 and 6 can peacefully coexist.
1953
format = BzrBranchFormat6()
1954
new_branch = format.open(branch.bzrdir, _found=True)
1955
1956
# Copy source data into target
1957
new_branch.set_last_revision_info(*branch.last_revision_info())
1958
new_branch.set_parent(branch.get_parent())
1959
new_branch.set_bound_location(branch.get_bound_location())
1960
new_branch.set_push_location(branch.get_push_location())
1961
1962
# Copying done; now update target format
1963
new_branch.control_files.put_utf8('format',
1964
format.get_format_string())
1965
1966
# Clean up old files
1967
new_branch.control_files._transport.delete('revision-history')
1968
try:
1969
branch.set_parent(None)
1970
except NoSuchFile:
1971
pass
1972
branch.set_bound_location(None)
1361
if filename == head:
1362
break
1363
filename = head
1364
return False
1365
1366
1367
1368
def gen_file_id(name):
1369
"""Return new file id.
1370
1371
This should probably generate proper UUIDs, but for the moment we
1372
cope with just randomness because running uuidgen every time is
1373
slow."""
1374
import re
1375
from binascii import hexlify
1376
from time import time
1377
1378
# get last component
1379
idx = name.rfind('/')
1380
if idx != -1:
1381
name = name[idx+1 : ]
1382
idx = name.rfind('\\')
1383
if idx != -1:
1384
name = name[idx+1 : ]
1385
1386
# make it not a hidden file
1387
name = name.lstrip('.')
1388
1389
# remove any wierd characters; we don't escape them but rather
1390
# just pull them out
1391
name = re.sub(r'[^\w.]', '', name)
1392
1393
s = hexlify(rand_bytes(8))
1394
return '-'.join((name, compact_date(time()), s))
1395
1396
1397
def gen_root_id():
1398
"""Return a new tree-root file id."""
1399
return gen_file_id('TREE_ROOT')
1400
1401
Loggerhead is a web-based interface for Breezy
Version: 2.0.1