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