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