« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 108
- compare with another revision
- download diff
- download tarball
- view history from revision 108
- Committer: mbp at sourcefrog
- Date: 2005-03-28 02:24:18 UTC
- Revision ID: mbp@sourcefrog.net-20050328022418-9d37f56361aa18e9
doc: more on ignore patterns
- files added:
- bzrlib/tests.py
- files removed:
- .rsyncexclude
- 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
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- tools
- tools/doc_generate
- files renamed:
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/xml_serializer.py => bzrlib/xml.py
- bzrlib/util/elementtree/ => elementtree/
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005, 2006 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
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
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
26
23
27
24
import bzrlib
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
25
from inventory import Inventory
26
from trace import mutter, note
27
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
28
from inventory import InventoryEntry, Inventory
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
joinpath, sha_string, file_kind, local_time_offset
32
from store import ImmutableStore
33
from revision import Revision
34
from errors import bailout
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 is 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
last_f = f
60
while True:
61
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
62
return f
63
head, tail = os.path.split(f)
64
if head == f:
65
# reached the root, whatever that may be
66
bailout('%r is not in a branch' % orig_f)
67
f = head
68
81
69
82
70
83
71
######################################################################
84
72
# branch objects
85
73
86
class Branch(object):
74
class Branch:
87
75
"""Branch holding a history of revisions.
88
76
89
base
90
Base directory/url of the branch.
77
:todo: Perhaps use different stores for different classes of object,
78
so that we can keep track of how much space each one uses,
79
or garbage-collect them.
80
81
:todo: Add a RemoteBranch subclass. For the basic case of read-only
82
HTTP access this should be very easy by,
83
just redirecting controlfile access into HTTP requests.
84
We would need a RemoteStore working similarly.
85
86
:todo: Keep the on-disk branch locked while the object exists.
87
88
:todo: mkdir() method.
91
89
"""
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')
90
def __init__(self, base, init=False, find_root=True):
91
"""Create new branch object at a particular location.
92
93
:param base: Base directory for the branch.
94
95
:param init: If True, create new control files in a previously
96
unversioned directory. If False, the branch must already
97
be versioned.
98
99
:param find_root: If true and init is false, find the root of the
100
existing branch containing base.
101
102
In the test suite, creation of new trees is tested using the
103
`ScratchBranch` class.
104
"""
105
if init:
106
self.base = os.path.realpath(base)
107
self._make_control()
108
elif find_root:
109
self.base = find_branch_root(base)
110
else:
111
self.base = os.path.realpath(base)
112
if not isdir(self.controlfilename('.')):
113
bailout("not a bzr branch: %s" % quotefn(base),
114
['use "bzr init" to initialize a new working tree',
115
'current bzr can only operate from top-of-tree'])
116
self._check_format()
117
118
self.text_store = ImmutableStore(self.controlfilename('text-store'))
119
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
120
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
121
122
123
def __str__(self):
124
return '%s(%r)' % (self.__class__.__name__, self.base)
125
126
127
__repr__ = __str__
128
191
129
192
130
def abspath(self, name):
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
131
"""Return absolute filename for something in the branch"""
132
return os.path.join(self.base, name)
133
134
135
def relpath(self, path):
136
"""Return path relative to this branch of something inside it.
137
138
Raises an error if path is not in this branch."""
139
rp = os.path.realpath(path)
140
# FIXME: windows
141
if not rp.startswith(self.base):
142
bailout("path %r is not within branch %r" % (rp, self.base))
143
rp = rp[len(self.base):]
144
rp = rp.lstrip(os.sep)
145
return rp
146
147
148
def controlfilename(self, file_or_path):
149
"""Return location relative to branch."""
150
if isinstance(file_or_path, types.StringTypes):
151
file_or_path = [file_or_path]
152
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
153
154
155
def controlfile(self, file_or_path, mode='r'):
156
"""Open a control file for this branch"""
157
return file(self.controlfilename(file_or_path), mode)
158
159
160
def _make_control(self):
161
os.mkdir(self.controlfilename([]))
162
self.controlfile('README', 'w').write(
163
"This is a Bazaar-NG control directory.\n"
164
"Do not change any files in this directory.")
165
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
166
for d in ('text-store', 'inventory-store', 'revision-store'):
167
os.mkdir(self.controlfilename(d))
168
for f in ('revision-history', 'merged-patches',
169
'pending-merged-patches', 'branch-name'):
170
self.controlfile(f, 'w').write('')
171
mutter('created control directory in ' + self.base)
172
Inventory().write_xml(self.controlfile('inventory','w'))
173
174
175
def _check_format(self):
176
"""Check this branch format is supported.
177
178
The current tool only supports the current unstable format.
179
180
In the future, we might need different in-memory Branch
181
classes to support downlevel branches. But not yet.
182
"""
183
# read in binary mode to detect newline wierdness.
184
fmt = self.controlfile('branch-format', 'rb').read()
185
if fmt != BZR_BRANCH_FORMAT:
186
bailout('sorry, branch format %r not supported' % fmt,
187
['use a different bzr version',
188
'or remove the .bzr directory and "bzr init" again'])
189
190
191
def read_working_inventory(self):
192
"""Read the working inventory."""
193
before = time.time()
194
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
195
mutter("loaded inventory of %d items in %f"
196
% (len(inv), time.time() - before))
197
return inv
198
199
200
def _write_inventory(self, inv):
201
"""Update the working inventory.
202
203
That is to say, the inventory describing changes underway, that
204
will be committed to the next revision.
205
"""
206
## TODO: factor out to atomicfile? is rename safe on windows?
207
## TODO: Maybe some kind of clean/dirty marker on inventory?
208
tmpfname = self.controlfilename('inventory.tmp')
209
tmpf = file(tmpfname, 'w')
210
inv.write_xml(tmpf)
211
tmpf.close()
212
os.rename(tmpfname, self.controlfilename('inventory'))
213
mutter('wrote working inventory')
214
215
216
inventory = property(read_working_inventory, _write_inventory, None,
217
"""Inventory for the working copy.""")
218
219
220
def add(self, files, verbose=False):
221
"""Make files versioned.
222
223
This puts the files in the Added state, so that they will be
224
recorded by the next commit.
225
226
:todo: Perhaps have an option to add the ids even if the files do
227
not (yet) exist.
228
229
:todo: Perhaps return the ids of the files? But then again it
230
is easy to retrieve them if they're needed.
231
232
:todo: Option to specify file id.
233
234
:todo: Adding a directory should optionally recurse down and
235
add all non-ignored children. Perhaps do that in a
236
higher-level method.
237
238
>>> b = ScratchBranch(files=['foo'])
239
>>> 'foo' in b.unknowns()
240
True
241
>>> b.show_status()
242
? foo
243
>>> b.add('foo')
244
>>> 'foo' in b.unknowns()
245
False
246
>>> bool(b.inventory.path2id('foo'))
247
True
248
>>> b.show_status()
249
A foo
250
251
>>> b.add('foo')
252
Traceback (most recent call last):
253
...
254
BzrError: ('foo is already versioned', [])
255
256
>>> b.add(['nothere'])
257
Traceback (most recent call last):
258
BzrError: ('cannot add: not a regular file or directory: nothere', [])
259
"""
260
261
# TODO: Re-adding a file that is removed in the working copy
262
# should probably put it back with the previous ID.
263
if isinstance(files, types.StringTypes):
264
files = [files]
265
266
inv = self.read_working_inventory()
267
for f in files:
268
if is_control_file(f):
269
bailout("cannot add control file %s" % quotefn(f))
270
271
fp = splitpath(f)
272
273
if len(fp) == 0:
274
bailout("cannot add top-level %r" % f)
275
276
fullpath = os.path.normpath(self.abspath(f))
277
278
try:
279
kind = file_kind(fullpath)
280
except OSError:
281
# maybe something better?
282
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
283
284
if kind != 'file' and kind != 'directory':
285
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
286
287
file_id = gen_file_id(f)
288
inv.add_path(f, kind=kind, file_id=file_id)
289
290
if verbose:
291
show_status('A', kind, quotefn(f))
292
293
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
294
295
self._write_inventory(inv)
296
297
298
299
def remove(self, files, verbose=False):
300
"""Mark nominated files for removal from the inventory.
301
302
This does not remove their text. This does not run on
303
304
:todo: Refuse to remove modified files unless --force is given?
305
306
>>> b = ScratchBranch(files=['foo'])
307
>>> b.add('foo')
308
>>> b.inventory.has_filename('foo')
309
True
310
>>> b.remove('foo')
311
>>> b.working_tree().has_filename('foo')
312
True
313
>>> b.inventory.has_filename('foo')
314
False
315
316
>>> b = ScratchBranch(files=['foo'])
317
>>> b.add('foo')
318
>>> b.commit('one')
319
>>> b.remove('foo')
320
>>> b.commit('two')
321
>>> b.inventory.has_filename('foo')
322
False
323
>>> b.basis_tree().has_filename('foo')
324
False
325
>>> b.working_tree().has_filename('foo')
326
True
327
328
:todo: Do something useful with directories.
329
330
:todo: Should this remove the text or not? Tough call; not
331
removing may be useful and the user can just use use rm, and
332
is the opposite of add. Removing it is consistent with most
333
other tools. Maybe an option.
334
"""
335
## TODO: Normalize names
336
## TODO: Remove nested loops; better scalability
337
338
if isinstance(files, types.StringTypes):
339
files = [files]
340
341
tree = self.working_tree()
342
inv = tree.inventory
343
344
# do this before any modifications
345
for f in files:
346
fid = inv.path2id(f)
347
if not fid:
348
bailout("cannot remove unversioned file %s" % quotefn(f))
349
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
350
if verbose:
351
# having remove it, it must be either ignored or unknown
352
if tree.is_ignored(f):
353
new_status = 'I'
354
else:
355
new_status = '?'
356
show_status(new_status, inv[fid].kind, quotefn(f))
357
del inv[fid]
358
359
self._write_inventory(inv)
360
361
362
def unknowns(self):
363
"""Return all unknown files.
364
365
These are files in the working directory that are not versioned or
366
control files or ignored.
367
368
>>> b = ScratchBranch(files=['foo', 'foo~'])
369
>>> list(b.unknowns())
370
['foo']
371
>>> b.add('foo')
372
>>> list(b.unknowns())
373
[]
374
>>> b.remove('foo')
375
>>> list(b.unknowns())
376
['foo']
377
"""
378
return self.working_tree().unknowns()
379
380
381
def commit(self, message, timestamp=None, timezone=None,
382
committer=None,
383
verbose=False):
384
"""Commit working copy as a new revision.
385
386
The basic approach is to add all the file texts into the
387
store, then the inventory, then make a new revision pointing
388
to that inventory and store that.
389
390
This is not quite safe if the working copy changes during the
391
commit; for the moment that is simply not allowed. A better
392
approach is to make a temporary copy of the files before
393
computing their hashes, and then add those hashes in turn to
394
the inventory. This should mean at least that there are no
395
broken hash pointers. There is no way we can get a snapshot
396
of the whole directory at an instant. This would also have to
397
be robust against files disappearing, moving, etc. So the
398
whole thing is a bit hard.
399
400
:param timestamp: if not None, seconds-since-epoch for a
401
postdated/predated commit.
402
"""
403
404
## TODO: Show branch names
405
406
# TODO: Don't commit if there are no changes, unless forced?
407
408
# First walk over the working inventory; and both update that
409
# and also build a new revision inventory. The revision
410
# inventory needs to hold the text-id, sha1 and size of the
411
# actual file versions committed in the revision. (These are
412
# not present in the working inventory.) We also need to
413
# detect missing/deleted files, and remove them from the
414
# working inventory.
415
416
work_inv = self.read_working_inventory()
417
inv = Inventory()
418
basis = self.basis_tree()
419
basis_inv = basis.inventory
420
missing_ids = []
421
for path, entry in work_inv.iter_entries():
422
## TODO: Cope with files that have gone missing.
423
424
## TODO: Check that the file kind has not changed from the previous
425
## revision of this file (if any).
426
427
entry = entry.copy()
428
429
p = self.abspath(path)
430
file_id = entry.file_id
431
mutter('commit prep file %s, id %r ' % (p, file_id))
432
433
if not os.path.exists(p):
434
mutter(" file is missing, removing from inventory")
435
if verbose:
436
show_status('D', entry.kind, quotefn(path))
437
missing_ids.append(file_id)
438
continue
439
440
# TODO: Handle files that have been deleted
441
442
# TODO: Maybe a special case for empty files? Seems a
443
# waste to store them many times.
444
445
inv.add(entry)
446
447
if basis_inv.has_id(file_id):
448
old_kind = basis_inv[file_id].kind
449
if old_kind != entry.kind:
450
bailout("entry %r changed kind from %r to %r"
451
% (file_id, old_kind, entry.kind))
452
453
if entry.kind == 'directory':
454
if not isdir(p):
455
bailout("%s is entered as directory but not a directory" % quotefn(p))
456
elif entry.kind == 'file':
457
if not isfile(p):
458
bailout("%s is entered as file but is not a file" % quotefn(p))
459
460
content = file(p, 'rb').read()
461
462
entry.text_sha1 = sha_string(content)
463
entry.text_size = len(content)
464
465
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
466
if (old_ie
467
and (old_ie.text_size == entry.text_size)
468
and (old_ie.text_sha1 == entry.text_sha1)):
469
## assert content == basis.get_file(file_id).read()
470
entry.text_id = basis_inv[file_id].text_id
471
mutter(' unchanged from previous text_id {%s}' %
472
entry.text_id)
473
474
else:
475
entry.text_id = gen_file_id(entry.name)
476
self.text_store.add(content, entry.text_id)
477
mutter(' stored with text_id {%s}' % entry.text_id)
478
if verbose:
479
if not old_ie:
480
state = 'A'
481
elif (old_ie.name == entry.name
482
and old_ie.parent_id == entry.parent_id):
483
state = 'M'
484
else:
485
state = 'R'
486
487
show_status(state, entry.kind, quotefn(path))
488
489
for file_id in missing_ids:
490
# have to do this later so we don't mess up the iterator.
491
# since parents may be removed before their children we
492
# have to test.
493
494
# FIXME: There's probably a better way to do this; perhaps
495
# the workingtree should know how to filter itself.
496
if work_inv.has_id(file_id):
497
del work_inv[file_id]
498
499
500
inv_id = rev_id = _gen_revision_id(time.time())
501
502
inv_tmp = tempfile.TemporaryFile()
503
inv.write_xml(inv_tmp)
504
inv_tmp.seek(0)
505
self.inventory_store.add(inv_tmp, inv_id)
506
mutter('new inventory_id is {%s}' % inv_id)
507
508
self._write_inventory(work_inv)
509
510
if timestamp == None:
511
timestamp = time.time()
512
513
if committer == None:
514
committer = username()
515
516
if timezone == None:
517
timezone = local_time_offset()
518
519
mutter("building commit log message")
520
rev = Revision(timestamp=timestamp,
521
timezone=timezone,
522
committer=committer,
523
precursor = self.last_patch(),
524
message = message,
525
inventory_id=inv_id,
526
revision_id=rev_id)
527
528
rev_tmp = tempfile.TemporaryFile()
529
rev.write_xml(rev_tmp)
530
rev_tmp.seek(0)
531
self.revision_store.add(rev_tmp, rev_id)
532
mutter("new revision_id is {%s}" % rev_id)
533
534
## XXX: Everything up to here can simply be orphaned if we abort
535
## the commit; it will leave junk files behind but that doesn't
536
## matter.
537
538
## TODO: Read back the just-generated changeset, and make sure it
539
## applies and recreates the right state.
540
541
## TODO: Also calculate and store the inventory SHA1
542
mutter("committing patch r%d" % (self.revno() + 1))
543
544
mutter("append to revision-history")
545
f = self.controlfile('revision-history', 'at')
546
f.write(rev_id + '\n')
547
f.close()
548
549
if verbose:
550
note("commited r%d" % self.revno())
551
552
553
def get_revision(self, revision_id):
554
"""Return the Revision object for a named revision"""
555
r = Revision.read_xml(self.revision_store[revision_id])
556
assert r.revision_id == revision_id
557
return r
558
559
560
def get_inventory(self, inventory_id):
561
"""Get Inventory object by hash.
562
563
:todo: Perhaps for this and similar methods, take a revision
564
parameter which can be either an integer revno or a
565
string hash."""
566
i = Inventory.read_xml(self.inventory_store[inventory_id])
567
return i
568
569
570
def get_revision_inventory(self, revision_id):
571
"""Return inventory of a past revision."""
572
if revision_id == None:
573
return Inventory()
225
574
else:
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.
256
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):
266
"""Print `file` to stdout."""
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')
575
return self.get_inventory(self.get_revision(revision_id).inventory_id)
576
274
577
275
578
def revision_history(self):
276
"""Return sequence of revision hashes on to this branch."""
277
raise NotImplementedError('revision_history is abstract')
579
"""Return sequence of revision hashes on to this branch.
580
581
>>> ScratchBranch().revision_history()
582
[]
583
"""
584
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
585
278
586
279
587
def revno(self):
280
588
"""Return current revision number for this branch.
281
589
282
590
That is equivalent to the number of revisions committed to
283
591
this branch.
592
593
>>> b = ScratchBranch()
594
>>> b.revno()
595
0
596
>>> b.commit('no foo')
597
>>> b.revno()
598
1
284
599
"""
285
600
return len(self.revision_history())
286
601
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."""
602
603
def last_patch(self):
604
"""Return last patch hash, or None if no history.
605
606
>>> ScratchBranch().last_patch() == None
607
True
608
"""
293
609
ph = self.revision_history()
294
610
if ph:
295
611
return ph[-1]
296
else:
297
return None
298
299
def missing_revisions(self, other, stop_revision=None):
300
"""Return a list of new revisions that would perfectly fit.
301
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."""
612
613
614
def lookup_revision(self, revno):
615
"""Return revision hash for revision number."""
369
616
if revno == 0:
370
617
return None
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')
618
619
try:
620
# list is 0-based; revisions are 1-based
621
return self.revision_history()[revno-1]
622
except IndexError:
623
bailout("no such revision %s" % revno)
624
625
626
def revision_tree(self, revision_id):
627
"""Return Tree for a revision on this branch.
628
629
`revision_id` may be None for the null revision, in which case
630
an `EmptyTree` is returned."""
631
632
if revision_id == None:
633
return EmptyTree()
634
else:
635
inv = self.get_revision_inventory(revision_id)
636
return RevisionTree(self.text_store, inv)
637
638
639
def working_tree(self):
640
"""Return a `Tree` for the working copy."""
641
return WorkingTree(self.base, self.read_working_inventory())
642
379
643
380
644
def basis_tree(self):
381
645
"""Return `Tree` object for last revision.
382
646
383
647
If there are no revisions yet, return an `EmptyTree`.
384
"""
385
return self.repository.revision_tree(self.last_revision())
386
387
def rename_one(self, from_rel, to_rel):
388
"""Rename one file.
389
390
This can change the directory or the filename or both.
391
"""
392
raise NotImplementedError('rename_one is abstract')
393
394
def move(self, from_paths, to_name):
395
"""Rename files.
396
397
to_name must exist as a versioned directory.
398
399
If to_name exists and is a directory, the files are moved into
400
it, keeping their old names. If it is a directory,
401
402
Note that to_name is only the last component of the new name;
403
this doesn't change the directory.
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)
648
649
>>> b = ScratchBranch(files=['foo'])
650
>>> b.basis_tree().has_filename('foo')
651
False
652
>>> b.working_tree().has_filename('foo')
653
True
654
>>> b.add('foo')
655
>>> b.commit('add foo')
656
>>> b.basis_tree().has_filename('foo')
657
True
658
"""
659
r = self.last_patch()
660
if r == None:
661
return EmptyTree()
662
else:
663
return RevisionTree(self.text_store, self.get_revision_inventory(r))
664
665
666
667
def write_log(self, show_timezone='original'):
668
"""Write out human-readable log of commits to this branch
669
670
:param utc: If true, show dates in universal time, not local time."""
671
## TODO: Option to choose either original, utc or local timezone
672
revno = 1
673
precursor = None
674
for p in self.revision_history():
675
print '-' * 40
676
print 'revno:', revno
677
## TODO: Show hash if --id is given.
678
##print 'revision-hash:', p
679
rev = self.get_revision(p)
680
print 'committer:', rev.committer
681
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
682
show_timezone))
683
684
## opportunistic consistency check, same as check_patch_chaining
685
if rev.precursor != precursor:
686
bailout("mismatched precursor!")
687
688
print 'message:'
689
if not rev.message:
690
print ' (no message)'
691
else:
692
for l in rev.message.split('\n'):
693
print ' ' + l
694
695
revno += 1
696
precursor = p
697
698
699
700
def show_status(branch, show_all=False):
701
"""Display single-line status for non-ignored working files.
702
703
The list is show sorted in order by file name.
704
705
>>> b = ScratchBranch(files=['foo', 'foo~'])
706
>>> b.show_status()
707
? foo
708
>>> b.add('foo')
709
>>> b.show_status()
710
A foo
711
>>> b.commit("add foo")
712
>>> b.show_status()
713
>>> os.unlink(b.abspath('foo'))
714
>>> b.show_status()
715
D foo
716
717
718
:todo: Get state for single files.
719
720
:todo: Perhaps show a slash at the end of directory names.
721
722
"""
723
724
# We have to build everything into a list first so that it can
725
# sorted by name, incorporating all the different sources.
726
727
# FIXME: Rather than getting things in random order and then sorting,
728
# just step through in order.
729
730
# Interesting case: the old ID for a file has been removed,
731
# but a new file has been created under that name.
732
733
old = branch.basis_tree()
734
old_inv = old.inventory
735
new = branch.working_tree()
736
new_inv = new.inventory
737
738
for fs, fid, oldname, newname, kind in diff_trees(old, new):
739
if fs == 'R':
740
show_status(fs, kind,
741
oldname + ' => ' + newname)
742
elif fs == 'A' or fs == 'M':
743
show_status(fs, kind, newname)
744
elif fs == 'D':
745
show_status(fs, kind, oldname)
746
elif fs == '.':
747
if show_all:
748
show_status(fs, kind, newname)
749
elif fs == 'I':
750
if show_all:
751
show_status(fs, kind, newname)
752
elif fs == '?':
753
show_status(fs, kind, newname)
754
else:
755
bailout("wierd file state %r" % ((fs, fid),))
756
757
758
759
class ScratchBranch(Branch):
760
"""Special test class: a branch that cleans up after itself.
761
762
>>> b = ScratchBranch()
763
>>> isdir(b.base)
764
True
765
>>> bd = b.base
766
>>> del b
767
>>> isdir(bd)
768
False
769
"""
770
def __init__(self, files=[], dirs=[]):
771
"""Make a test branch.
772
773
This creates a temporary directory and runs init-tree in it.
774
775
If any files are listed, they are created in the working copy.
776
"""
777
Branch.__init__(self, tempfile.mkdtemp(), init=True)
778
for d in dirs:
779
os.mkdir(self.abspath(d))
445
780
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:
531
try:
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__
781
for f in files:
782
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
783
893
784
894
785
def __del__(self):
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
786
"""Destroy the test branch, removing the scratch directory."""
787
shutil.rmtree(self.base)
788
789
790
791
######################################################################
792
# predicates
793
794
795
def is_control_file(filename):
796
## FIXME: better check
797
filename = os.path.normpath(filename)
798
while filename != '':
799
head, tail = os.path.split(filename)
800
## mutter('check %r for control file' % ((head, tail), ))
801
if tail == bzrlib.BZRDIR:
1258
802
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
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
1356
1357
######################################################################
1358
# predicates
1359
1360
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)
803
if filename == head:
804
break
805
filename = head
806
return False
807
808
809
810
def _gen_revision_id(when):
811
"""Return new revision-id."""
812
s = '%s-%s-' % (user_email(), compact_date(when))
813
s += hexlify(rand_bytes(8))
814
return s
815
816
817
def gen_file_id(name):
818
"""Return new file id.
819
820
This should probably generate proper UUIDs, but for the moment we
821
cope with just randomness because running uuidgen every time is
822
slow."""
823
idx = name.rfind('/')
824
if idx != -1:
825
name = name[idx+1 : ]
826
827
name = name.lstrip('.')
828
829
s = hexlify(rand_bytes(8))
830
return '-'.join((name, compact_date(time.time()), s))
831
832
Loggerhead is a web-based interface for Breezy
Version: 2.0.1