« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1185.50.72
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.50.72
- Committer: John Arbash Meinel
- Date: 2006-02-06 14:02:09 UTC
- mfrom: (1185.76.8 Erik Bågfors' pull --revision branch)
- mto: (1534.1.20 integration) (1553.4.1 revision-ranges) (1185.79.1 bzr-jam-pending)
- mto: This revision was merged to the branch mainline in revision 1554.
- Revision ID: john@arbash-meinel.com-20060206140209-793eeeb7f3f3d069
[merge] Erik Bågfors: add --revision to bzr pull
- files added:
- BRANCH.TODO
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/store
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/transport
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- tools/doc_generate
- files removed:
- bzrlib/mdiff.py
- files renamed:
- bzrlib/changeset.py => bzrlib/_changeset.py
- bzrlib/merge_core.py => bzrlib/_merge_core.py
- bzrlib/store.py => bzrlib/store/__init__.py
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/urlgrabber/
- bzrlib/xml.py => bzrlib/xml_serializer.py
- contrib/bash/bzr => contrib/bash/bzr.simple
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
from sets import Set
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
try:
27
import xml.sax.saxutils
28
except ImportError:
29
raise ImportError("We were unable to import 'xml.sax.saxutils',"
30
" most likely you have an xml.pyc or xml.pyo file"
31
" lying around in your bzrlib directory."
32
" Please remove it.")
33
from cStringIO import StringIO
19
34
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
23
35
24
36
import bzrlib
25
from inventory import Inventory
26
from trace import mutter, note
27
from tree import Tree, EmptyTree, RevisionTree
28
from inventory import InventoryEntry, Inventory
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
32
from store import ImmutableStore
33
from revision import Revision
34
from errors import bailout, BzrError
35
from textui import show_status
36
37
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
38
## TODO: Maybe include checks for common corruption of newlines, etc?
39
40
41
42
def find_branch(f, **args):
43
if f and (f.startswith('http://') or f.startswith('https://')):
44
import remotebranch
45
return remotebranch.RemoteBranch(f, **args)
46
else:
47
return Branch(f, **args)
48
49
50
def find_branch_root(f=None):
51
"""Find the branch root enclosing f, or pwd.
52
53
f may be a filename or a URL.
54
55
It is not necessary that f exists.
56
57
Basically we keep looking up until we find the control directory or
58
run into the root."""
59
if f == None:
60
f = os.getcwd()
61
elif hasattr(os.path, 'realpath'):
62
f = os.path.realpath(f)
63
else:
64
f = os.path.abspath(f)
65
if not os.path.exists(f):
66
raise BzrError('%r does not exist' % f)
67
68
69
orig_f = f
70
71
while True:
72
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
73
return f
74
head, tail = os.path.split(f)
75
if head == f:
76
# reached the root, whatever that may be
77
raise BzrError('%r is not in a branch' % orig_f)
78
f = head
79
37
from bzrlib.config import TreeConfig
38
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
from bzrlib.delta import compare_trees
40
import bzrlib.errors as errors
41
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
42
NoSuchRevision, HistoryMissing, NotBranchError,
43
DivergedBranches, LockError,
44
UninitializableFormat,
45
UnlistableStore,
46
UnlistableBranch, NoSuchFile, NotVersionedError,
47
NoWorkingTree)
48
import bzrlib.inventory as inventory
49
from bzrlib.inventory import Inventory
50
from bzrlib.lockable_files import LockableFiles
51
from bzrlib.osutils import (isdir, quotefn,
52
rename, splitpath, sha_file,
53
file_kind, abspath, normpath, pathjoin,
54
safe_unicode,
55
)
56
from bzrlib.textui import show_status
57
from bzrlib.trace import mutter, note
58
from bzrlib.tree import EmptyTree, RevisionTree
59
from bzrlib.repository import Repository
60
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions)
61
from bzrlib.store import copy_all
62
from bzrlib.symbol_versioning import *
63
import bzrlib.transactions as transactions
64
from bzrlib.transport import Transport, get_transport
65
from bzrlib.tree import EmptyTree, RevisionTree
66
import bzrlib.ui
67
import bzrlib.xml5
68
69
70
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
71
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
72
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
73
74
75
# TODO: Maybe include checks for common corruption of newlines, etc?
76
77
# TODO: Some operations like log might retrieve the same revisions
78
# repeatedly to calculate deltas. We could perhaps have a weakref
79
# cache in memory to make this faster. In general anything can be
80
# cached in memory between lock and unlock operations. .. nb thats
81
# what the transaction identity map provides
80
82
81
83
82
84
######################################################################
83
85
# branch objects
84
86
85
class Branch:
87
class Branch(object):
86
88
"""Branch holding a history of revisions.
87
89
88
90
base
89
Base directory of the branch.
91
Base directory/url of the branch.
90
92
"""
91
_lockmode = None
92
93
def __init__(self, base, init=False, find_root=True, lock_mode='w'):
94
"""Create new branch object at a particular location.
95
96
base -- Base directory for the branch.
97
98
init -- If True, create new control files in a previously
99
unversioned directory. If False, the branch must already
100
be versioned.
101
102
find_root -- If true and init is false, find the root of the
103
existing branch containing base.
104
105
In the test suite, creation of new trees is tested using the
106
`ScratchBranch` class.
107
"""
108
if init:
109
self.base = os.path.realpath(base)
110
self._make_control()
111
elif find_root:
112
self.base = find_branch_root(base)
113
else:
114
self.base = os.path.realpath(base)
115
if not isdir(self.controlfilename('.')):
116
bailout("not a bzr branch: %s" % quotefn(base),
117
['use "bzr init" to initialize a new working tree',
118
'current bzr can only operate from top-of-tree'])
119
self._check_format()
120
self.lock(lock_mode)
121
122
self.text_store = ImmutableStore(self.controlfilename('text-store'))
123
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
124
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
125
126
127
def __str__(self):
128
return '%s(%r)' % (self.__class__.__name__, self.base)
129
130
131
__repr__ = __str__
132
133
134
135
def lock(self, mode='w'):
136
"""Lock the on-disk branch, excluding other processes."""
137
try:
138
import fcntl, errno
139
140
if mode == 'w':
141
lm = fcntl.LOCK_EX
142
om = os.O_WRONLY | os.O_CREAT
143
elif mode == 'r':
144
lm = fcntl.LOCK_SH
145
om = os.O_RDONLY
146
else:
147
raise BzrError("invalid locking mode %r" % mode)
148
149
try:
150
lockfile = os.open(self.controlfilename('branch-lock'), om)
151
except OSError, e:
152
if e.errno == errno.ENOENT:
153
# might not exist on branches from <0.0.4
154
self.controlfile('branch-lock', 'w').close()
155
lockfile = os.open(self.controlfilename('branch-lock'), om)
156
else:
157
raise e
158
159
fcntl.lockf(lockfile, lm)
160
def unlock():
161
fcntl.lockf(lockfile, fcntl.LOCK_UN)
162
os.close(lockfile)
163
self._lockmode = None
164
self.unlock = unlock
165
self._lockmode = mode
166
except ImportError:
167
warning("please write a locking method for platform %r" % sys.platform)
168
def unlock():
169
self._lockmode = None
170
self.unlock = unlock
171
self._lockmode = mode
172
173
174
def _need_readlock(self):
175
if self._lockmode not in ['r', 'w']:
176
raise BzrError('need read lock on branch, only have %r' % self._lockmode)
177
178
def _need_writelock(self):
179
if self._lockmode not in ['w']:
180
raise BzrError('need write lock on branch, only have %r' % self._lockmode)
181
182
183
def abspath(self, name):
184
"""Return absolute filename for something in the branch"""
185
return os.path.join(self.base, name)
186
187
188
def relpath(self, path):
189
"""Return path relative to this branch of something inside it.
190
191
Raises an error if path is not in this branch."""
192
rp = os.path.realpath(path)
193
# FIXME: windows
194
if not rp.startswith(self.base):
195
bailout("path %r is not within branch %r" % (rp, self.base))
196
rp = rp[len(self.base):]
197
rp = rp.lstrip(os.sep)
198
return rp
199
200
201
def controlfilename(self, file_or_path):
202
"""Return location relative to branch."""
203
if isinstance(file_or_path, types.StringTypes):
204
file_or_path = [file_or_path]
205
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
206
207
208
def controlfile(self, file_or_path, mode='r'):
209
"""Open a control file for this branch.
210
211
There are two classes of file in the control directory: text
212
and binary. binary files are untranslated byte streams. Text
213
control files are stored with Unix newlines and in UTF-8, even
214
if the platform or locale defaults are different.
215
216
Controlfiles should almost never be opened in write mode but
217
rather should be atomically copied and replaced using atomicfile.
218
"""
219
220
fn = self.controlfilename(file_or_path)
221
222
if mode == 'rb' or mode == 'wb':
223
return file(fn, mode)
224
elif mode == 'r' or mode == 'w':
225
# open in binary mode anyhow so there's no newline translation;
226
# codecs uses line buffering by default; don't want that.
227
import codecs
228
return codecs.open(fn, mode + 'b', 'utf-8',
229
buffering=60000)
230
else:
231
raise BzrError("invalid controlfile mode %r" % mode)
232
233
234
235
def _make_control(self):
236
os.mkdir(self.controlfilename([]))
237
self.controlfile('README', 'w').write(
238
"This is a Bazaar-NG control directory.\n"
239
"Do not change any files in this directory.")
240
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
241
for d in ('text-store', 'inventory-store', 'revision-store'):
242
os.mkdir(self.controlfilename(d))
243
for f in ('revision-history', 'merged-patches',
244
'pending-merged-patches', 'branch-name',
245
'branch-lock'):
246
self.controlfile(f, 'w').write('')
247
mutter('created control directory in ' + self.base)
248
Inventory().write_xml(self.controlfile('inventory','w'))
249
250
251
def _check_format(self):
252
"""Check this branch format is supported.
253
254
The current tool only supports the current unstable format.
255
256
In the future, we might need different in-memory Branch
257
classes to support downlevel branches. But not yet.
258
"""
259
# This ignores newlines so that we can open branches created
260
# on Windows from Linux and so on. I think it might be better
261
# to always make all internal files in unix format.
262
fmt = self.controlfile('branch-format', 'r').read()
263
fmt.replace('\r\n', '')
264
if fmt != BZR_BRANCH_FORMAT:
265
bailout('sorry, branch format %r not supported' % fmt,
93
# this is really an instance variable - FIXME move it there
94
# - RBC 20060112
95
base = None
96
97
_default_initializer = None
98
"""The default initializer for making new branches."""
99
100
def __init__(self, *ignored, **ignored_too):
101
raise NotImplementedError('The Branch class is abstract')
102
103
@staticmethod
104
def open_downlevel(base):
105
"""Open a branch which may be of an old format."""
106
return Branch.open(base, _unsupported=True)
107
108
@staticmethod
109
def open(base, _unsupported=False):
110
"""Open an existing branch, rooted at 'base' (url)
111
112
_unsupported is a private parameter to the Branch class.
113
"""
114
t = get_transport(base)
115
mutter("trying to open %r with transport %r", base, t)
116
format = BzrBranchFormat.find_format(t)
117
if not _unsupported and not format.is_supported():
118
# see open_downlevel to open legacy branches.
119
raise errors.UnsupportedFormatError(
120
'sorry, branch format %s not supported' % format,
266
121
['use a different bzr version',
267
'or remove the .bzr directory and "bzr init" again'])
268
269
270
def read_working_inventory(self):
271
"""Read the working inventory."""
272
self._need_readlock()
273
before = time.time()
274
# ElementTree does its own conversion from UTF-8, so open in
275
# binary.
276
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
277
mutter("loaded inventory of %d items in %f"
278
% (len(inv), time.time() - before))
279
return inv
280
281
282
def _write_inventory(self, inv):
283
"""Update the working inventory.
284
285
That is to say, the inventory describing changes underway, that
286
will be committed to the next revision.
287
"""
288
self._need_writelock()
289
## TODO: factor out to atomicfile? is rename safe on windows?
290
## TODO: Maybe some kind of clean/dirty marker on inventory?
291
tmpfname = self.controlfilename('inventory.tmp')
292
tmpf = file(tmpfname, 'wb')
293
inv.write_xml(tmpf)
294
tmpf.close()
295
inv_fname = self.controlfilename('inventory')
296
if sys.platform == 'win32':
297
os.remove(inv_fname)
298
os.rename(tmpfname, inv_fname)
299
mutter('wrote working inventory')
300
301
302
inventory = property(read_working_inventory, _write_inventory, None,
303
"""Inventory for the working copy.""")
304
305
306
def add(self, files, verbose=False, ids=None):
307
"""Make files versioned.
308
309
Note that the command line normally calls smart_add instead.
310
311
This puts the files in the Added state, so that they will be
312
recorded by the next commit.
313
314
TODO: Perhaps have an option to add the ids even if the files do
315
not (yet) exist.
316
317
TODO: Perhaps return the ids of the files? But then again it
318
is easy to retrieve them if they're needed.
319
320
TODO: Option to specify file id.
321
322
TODO: Adding a directory should optionally recurse down and
323
add all non-ignored children. Perhaps do that in a
324
higher-level method.
325
"""
326
self._need_writelock()
327
328
# TODO: Re-adding a file that is removed in the working copy
329
# should probably put it back with the previous ID.
330
if isinstance(files, types.StringTypes):
331
assert(ids is None or isinstance(ids, types.StringTypes))
332
files = [files]
333
if ids is not None:
334
ids = [ids]
335
336
if ids is None:
337
ids = [None] * len(files)
338
else:
339
assert(len(ids) == len(files))
122
'or remove the .bzr directory'
123
' and "bzr init" again'])
124
return format.open(t)
125
126
@staticmethod
127
def open_containing(url):
128
"""Open an existing branch which contains url.
340
129
341
inv = self.read_working_inventory()
342
for f,file_id in zip(files, ids):
343
if is_control_file(f):
344
bailout("cannot add control file %s" % quotefn(f))
345
346
fp = splitpath(f)
347
348
if len(fp) == 0:
349
bailout("cannot add top-level %r" % f)
350
351
fullpath = os.path.normpath(self.abspath(f))
352
130
This probes for a branch at url, and searches upwards from there.
131
132
Basically we keep looking up until we find the control directory or
133
run into the root. If there isn't one, raises NotBranchError.
134
If there is one and it is either an unrecognised format or an unsupported
135
format, UnknownFormatError or UnsupportedFormatError are raised.
136
If there is one, it is returned, along with the unused portion of url.
137
"""
138
t = get_transport(url)
139
# this gets the normalised url back. I.e. '.' -> the full path.
140
url = t.base
141
while True:
353
142
try:
354
kind = file_kind(fullpath)
355
except OSError:
356
# maybe something better?
357
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
358
359
if kind != 'file' and kind != 'directory':
360
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
361
362
if file_id is None:
363
file_id = gen_file_id(f)
364
inv.add_path(f, kind=kind, file_id=file_id)
365
366
if verbose:
367
show_status('A', kind, quotefn(f))
368
369
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
370
371
self._write_inventory(inv)
372
373
374
def print_file(self, file, revno):
143
format = BzrBranchFormat.find_format(t)
144
return format.open(t), t.relpath(url)
145
except NotBranchError, e:
146
mutter('not a branch in: %r %s', t.base, e)
147
new_t = t.clone('..')
148
if new_t.base == t.base:
149
# reached the root, whatever that may be
150
raise NotBranchError(path=url)
151
t = new_t
152
153
@staticmethod
154
def create(base):
155
"""Create a new Branch at the url 'bzr'.
156
157
This will call the current default initializer with base
158
as the only parameter.
159
"""
160
return Branch._default_initializer(safe_unicode(base))
161
162
@staticmethod
163
@deprecated_function(zero_eight)
164
def initialize(base):
165
"""Create a new working tree and branch, rooted at 'base' (url)
166
167
NOTE: This will soon be deprecated in favour of creation
168
through a BzrDir.
169
"""
170
# imported here to prevent scope creep as this is going.
171
from bzrlib.workingtree import WorkingTree
172
return WorkingTree.create_standalone(safe_unicode(base)).branch
173
174
@staticmethod
175
def get_default_initializer():
176
"""Return the initializer being used for new branches."""
177
return Branch._default_initializer
178
179
@staticmethod
180
def set_default_initializer(initializer):
181
"""Set the initializer to be used for new branches."""
182
Branch._default_initializer = staticmethod(initializer)
183
184
def setup_caching(self, cache_root):
185
"""Subclasses that care about caching should override this, and set
186
up cached stores located under cache_root.
187
"""
188
# seems to be unused, 2006-01-13 mbp
189
warn('%s is deprecated' % self.setup_caching)
190
self.cache_root = cache_root
191
192
def _get_nick(self):
193
cfg = self.tree_config()
194
return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
195
196
def _set_nick(self, nick):
197
cfg = self.tree_config()
198
cfg.set_option(nick, "nickname")
199
assert cfg.get_option("nickname") == nick
200
201
nick = property(_get_nick, _set_nick)
202
203
def push_stores(self, branch_to):
204
"""Copy the content of this branches store to branch_to."""
205
raise NotImplementedError('push_stores is abstract')
206
207
def lock_write(self):
208
raise NotImplementedError('lock_write is abstract')
209
210
def lock_read(self):
211
raise NotImplementedError('lock_read is abstract')
212
213
def unlock(self):
214
raise NotImplementedError('unlock is abstract')
215
216
def peek_lock_mode(self):
217
"""Return lock mode for the Branch: 'r', 'w' or None"""
218
raise NotImplementedError(self.peek_lock_mode)
219
220
def abspath(self, name):
221
"""Return absolute filename for something in the branch
222
223
XXX: Robert Collins 20051017 what is this used for? why is it a branch
224
method and not a tree method.
225
"""
226
raise NotImplementedError('abspath is abstract')
227
228
def get_root_id(self):
229
"""Return the id of this branches root"""
230
raise NotImplementedError('get_root_id is abstract')
231
232
def print_file(self, file, revision_id):
375
233
"""Print `file` to stdout."""
376
self._need_readlock()
377
tree = self.revision_tree(self.lookup_revision(revno))
378
# use inventory as it was in that revision
379
file_id = tree.inventory.path2id(file)
380
if not file_id:
381
bailout("%r is not present in revision %d" % (file, revno))
382
tree.print_file(file_id)
383
384
385
def remove(self, files, verbose=False):
386
"""Mark nominated files for removal from the inventory.
387
388
This does not remove their text. This does not run on
389
390
TODO: Refuse to remove modified files unless --force is given?
391
392
TODO: Do something useful with directories.
393
394
TODO: Should this remove the text or not? Tough call; not
395
removing may be useful and the user can just use use rm, and
396
is the opposite of add. Removing it is consistent with most
397
other tools. Maybe an option.
398
"""
399
## TODO: Normalize names
400
## TODO: Remove nested loops; better scalability
401
self._need_writelock()
402
403
if isinstance(files, types.StringTypes):
404
files = [files]
405
406
tree = self.working_tree()
407
inv = tree.inventory
408
409
# do this before any modifications
410
for f in files:
411
fid = inv.path2id(f)
412
if not fid:
413
bailout("cannot remove unversioned file %s" % quotefn(f))
414
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
415
if verbose:
416
# having remove it, it must be either ignored or unknown
417
if tree.is_ignored(f):
418
new_status = 'I'
419
else:
420
new_status = '?'
421
show_status(new_status, inv[fid].kind, quotefn(f))
422
del inv[fid]
423
424
self._write_inventory(inv)
425
426
def set_inventory(self, new_inventory_list):
427
inv = Inventory()
428
for path, file_id, parent, kind in new_inventory_list:
429
name = os.path.basename(path)
430
if name == "":
431
continue
432
inv.add(InventoryEntry(file_id, name, kind, parent))
433
self._write_inventory(inv)
434
435
436
def unknowns(self):
437
"""Return all unknown files.
438
439
These are files in the working directory that are not versioned or
440
control files or ignored.
441
442
>>> b = ScratchBranch(files=['foo', 'foo~'])
443
>>> list(b.unknowns())
444
['foo']
445
>>> b.add('foo')
446
>>> list(b.unknowns())
447
[]
448
>>> b.remove('foo')
449
>>> list(b.unknowns())
450
['foo']
451
"""
452
return self.working_tree().unknowns()
453
454
455
def append_revision(self, revision_id):
456
mutter("add {%s} to revision-history" % revision_id)
457
rev_history = self.revision_history()
458
459
tmprhname = self.controlfilename('revision-history.tmp')
460
rhname = self.controlfilename('revision-history')
461
462
f = file(tmprhname, 'wt')
463
rev_history.append(revision_id)
464
f.write('\n'.join(rev_history))
465
f.write('\n')
466
f.close()
467
468
if sys.platform == 'win32':
469
os.remove(rhname)
470
os.rename(tmprhname, rhname)
471
472
473
474
def get_revision(self, revision_id):
475
"""Return the Revision object for a named revision"""
476
self._need_readlock()
477
r = Revision.read_xml(self.revision_store[revision_id])
478
assert r.revision_id == revision_id
479
return r
480
481
482
def get_inventory(self, inventory_id):
483
"""Get Inventory object by hash.
484
485
TODO: Perhaps for this and similar methods, take a revision
486
parameter which can be either an integer revno or a
487
string hash."""
488
self._need_readlock()
489
i = Inventory.read_xml(self.inventory_store[inventory_id])
490
return i
491
492
493
def get_revision_inventory(self, revision_id):
494
"""Return inventory of a past revision."""
495
self._need_readlock()
496
if revision_id == None:
497
return Inventory()
498
else:
499
return self.get_inventory(self.get_revision(revision_id).inventory_id)
500
234
raise NotImplementedError('print_file is abstract')
235
236
def append_revision(self, *revision_ids):
237
raise NotImplementedError('append_revision is abstract')
238
239
def set_revision_history(self, rev_history):
240
raise NotImplementedError('set_revision_history is abstract')
501
241
502
242
def revision_history(self):
503
"""Return sequence of revision hashes on to this branch.
504
505
>>> ScratchBranch().revision_history()
506
[]
507
"""
508
self._need_readlock()
509
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
510
511
512
def enum_history(self, direction):
513
"""Return (revno, revision_id) for history of branch.
514
515
direction
516
'forward' is from earliest to latest
517
'reverse' is from latest to earliest
518
"""
519
rh = self.revision_history()
520
if direction == 'forward':
521
i = 1
522
for rid in rh:
523
yield i, rid
524
i += 1
525
elif direction == 'reverse':
526
i = len(rh)
527
while i > 0:
528
yield i, rh[i-1]
529
i -= 1
530
else:
531
raise BzrError('invalid history direction %r' % direction)
532
243
"""Return sequence of revision hashes on to this branch."""
244
raise NotImplementedError('revision_history is abstract')
533
245
534
246
def revno(self):
535
247
"""Return current revision number for this branch.
539
251
"""
540
252
return len(self.revision_history())
541
253
542
543
def last_patch(self):
544
"""Return last patch hash, or None if no history.
545
"""
254
def last_revision(self):
255
"""Return last patch hash, or None if no history."""
546
256
ph = self.revision_history()
547
257
if ph:
548
258
return ph[-1]
549
259
else:
550
260
return None
551
261
552
553
def commit(self, *args, **kw):
554
"""Deprecated"""
555
from bzrlib.commit import commit
556
commit(self, *args, **kw)
557
558
559
def lookup_revision(self, revno):
560
"""Return revision hash for revision number."""
262
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
263
"""Return a list of new revisions that would perfectly fit.
264
265
If self and other have not diverged, return a list of the revisions
266
present in other, but missing from self.
267
268
>>> bzrlib.trace.silent = True
269
>>> br1 = ScratchBranch()
270
>>> br2 = ScratchBranch()
271
>>> br1.missing_revisions(br2)
272
[]
273
>>> br2.working_tree().commit("lala!", rev_id="REVISION-ID-1")
274
>>> br1.missing_revisions(br2)
275
[u'REVISION-ID-1']
276
>>> br2.missing_revisions(br1)
277
[]
278
>>> br1.working_tree().commit("lala!", rev_id="REVISION-ID-1")
279
>>> br1.missing_revisions(br2)
280
[]
281
>>> br2.working_tree().commit("lala!", rev_id="REVISION-ID-2A")
282
>>> br1.missing_revisions(br2)
283
[u'REVISION-ID-2A']
284
>>> br1.working_tree().commit("lala!", rev_id="REVISION-ID-2B")
285
>>> br1.missing_revisions(br2)
286
Traceback (most recent call last):
287
DivergedBranches: These branches have diverged. Try merge.
288
"""
289
self_history = self.revision_history()
290
self_len = len(self_history)
291
other_history = other.revision_history()
292
other_len = len(other_history)
293
common_index = min(self_len, other_len) -1
294
if common_index >= 0 and \
295
self_history[common_index] != other_history[common_index]:
296
raise DivergedBranches(self, other)
297
298
if stop_revision is None:
299
stop_revision = other_len
300
else:
301
assert isinstance(stop_revision, int)
302
if stop_revision > other_len:
303
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
304
return other_history[self_len:stop_revision]
305
306
def update_revisions(self, other, stop_revision=None):
307
"""Pull in new perfect-fit revisions."""
308
raise NotImplementedError('update_revisions is abstract')
309
310
def pullable_revisions(self, other, stop_revision):
311
raise NotImplementedError('pullable_revisions is abstract')
312
313
def revision_id_to_revno(self, revision_id):
314
"""Given a revision id, return its revno"""
315
if revision_id is None:
316
return 0
317
history = self.revision_history()
318
try:
319
return history.index(revision_id) + 1
320
except ValueError:
321
raise bzrlib.errors.NoSuchRevision(self, revision_id)
322
323
def get_rev_id(self, revno, history=None):
324
"""Find the revision id of the specified revno."""
561
325
if revno == 0:
562
326
return None
563
564
try:
565
# list is 0-based; revisions are 1-based
566
return self.revision_history()[revno-1]
567
except IndexError:
568
raise BzrError("no such revision %s" % revno)
569
570
571
def revision_tree(self, revision_id):
572
"""Return Tree for a revision on this branch.
573
574
`revision_id` may be None for the null revision, in which case
575
an `EmptyTree` is returned."""
576
self._need_readlock()
577
if revision_id == None:
578
return EmptyTree()
579
else:
580
inv = self.get_revision_inventory(revision_id)
581
return RevisionTree(self.text_store, inv)
582
327
if history is None:
328
history = self.revision_history()
329
elif revno <= 0 or revno > len(history):
330
raise bzrlib.errors.NoSuchRevision(self, revno)
331
return history[revno - 1]
583
332
584
333
def working_tree(self):
585
"""Return a `Tree` for the working copy."""
586
from workingtree import WorkingTree
587
return WorkingTree(self.base, self.read_working_inventory())
334
"""Return a `Tree` for the working copy if this is a local branch."""
335
raise NotImplementedError('working_tree is abstract')
588
336
337
def pull(self, source, overwrite=False, stop_revision=None):
338
raise NotImplementedError('pull is abstract')
589
339
590
340
def basis_tree(self):
591
341
"""Return `Tree` object for last revision.
592
342
593
343
If there are no revisions yet, return an `EmptyTree`.
594
344
"""
595
r = self.last_patch()
596
if r == None:
597
return EmptyTree()
598
else:
599
return RevisionTree(self.text_store, self.get_revision_inventory(r))
600
601
345
return self.repository.revision_tree(self.last_revision())
602
346
603
347
def rename_one(self, from_rel, to_rel):
604
348
"""Rename one file.
605
349
606
350
This can change the directory or the filename or both.
607
351
"""
608
self._need_writelock()
609
tree = self.working_tree()
610
inv = tree.inventory
611
if not tree.has_filename(from_rel):
612
bailout("can't rename: old working file %r does not exist" % from_rel)
613
if tree.has_filename(to_rel):
614
bailout("can't rename: new working file %r already exists" % to_rel)
615
616
file_id = inv.path2id(from_rel)
617
if file_id == None:
618
bailout("can't rename: old name %r is not versioned" % from_rel)
619
620
if inv.path2id(to_rel):
621
bailout("can't rename: new name %r is already versioned" % to_rel)
622
623
to_dir, to_tail = os.path.split(to_rel)
624
to_dir_id = inv.path2id(to_dir)
625
if to_dir_id == None and to_dir != '':
626
bailout("can't determine destination directory id for %r" % to_dir)
627
628
mutter("rename_one:")
629
mutter(" file_id {%s}" % file_id)
630
mutter(" from_rel %r" % from_rel)
631
mutter(" to_rel %r" % to_rel)
632
mutter(" to_dir %r" % to_dir)
633
mutter(" to_dir_id {%s}" % to_dir_id)
634
635
inv.rename(file_id, to_dir_id, to_tail)
636
637
print "%s => %s" % (from_rel, to_rel)
638
639
from_abs = self.abspath(from_rel)
640
to_abs = self.abspath(to_rel)
641
try:
642
os.rename(from_abs, to_abs)
643
except OSError, e:
644
bailout("failed to rename %r to %r: %s"
645
% (from_abs, to_abs, e[1]),
646
["rename rolled back"])
647
648
self._write_inventory(inv)
649
650
352
raise NotImplementedError('rename_one is abstract')
651
353
652
354
def move(self, from_paths, to_name):
653
355
"""Rename files.
659
361
660
362
Note that to_name is only the last component of the new name;
661
363
this doesn't change the directory.
662
"""
663
self._need_writelock()
664
## TODO: Option to move IDs only
665
assert not isinstance(from_paths, basestring)
666
tree = self.working_tree()
667
inv = tree.inventory
668
to_abs = self.abspath(to_name)
669
if not isdir(to_abs):
670
bailout("destination %r is not a directory" % to_abs)
671
if not tree.has_filename(to_name):
672
bailout("destination %r not in working directory" % to_abs)
673
to_dir_id = inv.path2id(to_name)
674
if to_dir_id == None and to_name != '':
675
bailout("destination %r is not a versioned directory" % to_name)
676
to_dir_ie = inv[to_dir_id]
677
if to_dir_ie.kind not in ('directory', 'root_directory'):
678
bailout("destination %r is not a directory" % to_abs)
679
680
to_idpath = Set(inv.get_idpath(to_dir_id))
681
682
for f in from_paths:
683
if not tree.has_filename(f):
684
bailout("%r does not exist in working tree" % f)
685
f_id = inv.path2id(f)
686
if f_id == None:
687
bailout("%r is not versioned" % f)
688
name_tail = splitpath(f)[-1]
689
dest_path = appendpath(to_name, name_tail)
690
if tree.has_filename(dest_path):
691
bailout("destination %r already exists" % dest_path)
692
if f_id in to_idpath:
693
bailout("can't move %r to a subdirectory of itself" % f)
694
695
# OK, so there's a race here, it's possible that someone will
696
# create a file in this interval and then the rename might be
697
# left half-done. But we should have caught most problems.
698
699
for f in from_paths:
700
name_tail = splitpath(f)[-1]
701
dest_path = appendpath(to_name, name_tail)
702
print "%s => %s" % (f, dest_path)
703
inv.rename(inv.path2id(f), to_dir_id, name_tail)
704
try:
705
os.rename(self.abspath(f), self.abspath(dest_path))
706
except OSError, e:
707
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
708
["rename rolled back"])
709
710
self._write_inventory(inv)
711
712
713
714
715
class ScratchBranch(Branch):
364
365
This returns a list of (from_path, to_path) pairs for each
366
entry that is moved.
367
"""
368
raise NotImplementedError('move is abstract')
369
370
def get_parent(self):
371
"""Return the parent location of the branch.
372
373
This is the default location for push/pull/missing. The usual
374
pattern is that the user can override it by specifying a
375
location.
376
"""
377
raise NotImplementedError('get_parent is abstract')
378
379
def get_push_location(self):
380
"""Return the None or the location to push this branch to."""
381
raise NotImplementedError('get_push_location is abstract')
382
383
def set_push_location(self, location):
384
"""Set a new push location for this branch."""
385
raise NotImplementedError('set_push_location is abstract')
386
387
def set_parent(self, url):
388
raise NotImplementedError('set_parent is abstract')
389
390
def check_revno(self, revno):
391
"""\
392
Check whether a revno corresponds to any revision.
393
Zero (the NULL revision) is considered valid.
394
"""
395
if revno != 0:
396
self.check_real_revno(revno)
397
398
def check_real_revno(self, revno):
399
"""\
400
Check whether a revno corresponds to a real revision.
401
Zero (the NULL revision) is considered invalid
402
"""
403
if revno < 1 or revno > self.revno():
404
raise InvalidRevisionNumber(revno)
405
406
def clone(self, to_location, revision=None, basis_branch=None, to_branch_type=None):
407
"""Copy this branch into the existing directory to_location.
408
409
Returns the newly created branch object.
410
411
revision
412
If not None, only revisions up to this point will be copied.
413
The head of the new branch will be that revision. Must be a
414
revid or None.
415
416
to_location -- The destination directory; must either exist and be
417
empty, or not exist, in which case it is created.
418
419
basis_branch
420
A local branch to copy revisions from, related to this branch.
421
This is used when branching from a remote (slow) branch, and we have
422
a local branch that might contain some relevant revisions.
423
424
to_branch_type
425
Branch type of destination branch
426
"""
427
from bzrlib.workingtree import WorkingTree
428
assert isinstance(to_location, basestring)
429
if not bzrlib.osutils.lexists(to_location):
430
os.mkdir(to_location)
431
if to_branch_type is None:
432
to_branch_type = BzrBranch
433
print "FIXME use a branch format here"
434
br_to = to_branch_type.initialize(to_location)
435
mutter("copy branch from %s to %s", self, br_to)
436
if basis_branch is not None:
437
basis_branch.push_stores(br_to)
438
if revision is None:
439
revision = self.last_revision()
440
br_to.update_revisions(self, stop_revision=revision)
441
br_to.set_parent(self.base)
442
WorkingTree.create(br_to, to_location).set_root_id(self.get_root_id())
443
mutter("copied")
444
return br_to
445
446
def fileid_involved_between_revs(self, from_revid, to_revid):
447
""" This function returns the file_id(s) involved in the
448
changes between the from_revid revision and the to_revid
449
revision
450
"""
451
raise NotImplementedError('fileid_involved_between_revs is abstract')
452
453
def fileid_involved(self, last_revid=None):
454
""" This function returns the file_id(s) involved in the
455
changes up to the revision last_revid
456
If no parametr is passed, then all file_id[s] present in the
457
repository are returned
458
"""
459
raise NotImplementedError('fileid_involved is abstract')
460
461
def fileid_involved_by_set(self, changes):
462
""" This function returns the file_id(s) involved in the
463
changes present in the set 'changes'
464
"""
465
raise NotImplementedError('fileid_involved_by_set is abstract')
466
467
def fileid_involved_between_revs(self, from_revid, to_revid):
468
""" This function returns the file_id(s) involved in the
469
changes between the from_revid revision and the to_revid
470
revision
471
"""
472
raise NotImplementedError('fileid_involved_between_revs is abstract')
473
474
def fileid_involved(self, last_revid=None):
475
""" This function returns the file_id(s) involved in the
476
changes up to the revision last_revid
477
If no parametr is passed, then all file_id[s] present in the
478
repository are returned
479
"""
480
raise NotImplementedError('fileid_involved is abstract')
481
482
def fileid_involved_by_set(self, changes):
483
""" This function returns the file_id(s) involved in the
484
changes present in the set 'changes'
485
"""
486
raise NotImplementedError('fileid_involved_by_set is abstract')
487
488
class BzrBranchFormat(object):
489
"""An encapsulation of the initialization and open routines for a format.
490
491
Formats provide three things:
492
* An initialization routine,
493
* a format string,
494
* an open routine.
495
496
Formats are placed in an dict by their format string for reference
497
during branch opening. Its not required that these be instances, they
498
can be classes themselves with class methods - it simply depends on
499
whether state is needed for a given format or not.
500
501
Once a format is deprecated, just deprecate the initialize and open
502
methods on the format class. Do not deprecate the object, as the
503
object will be created every time regardless.
504
"""
505
506
_formats = {}
507
"""The known formats."""
508
509
@classmethod
510
def find_format(klass, transport):
511
"""Return the format registered for URL."""
512
try:
513
format_string = transport.get(".bzr/branch-format").read()
514
return klass._formats[format_string]
515
except NoSuchFile:
516
raise NotBranchError(path=transport.base)
517
except KeyError:
518
raise errors.UnknownFormatError(format_string)
519
520
def get_format_string(self):
521
"""Return the ASCII format string that identifies this format."""
522
raise NotImplementedError(self.get_format_string)
523
524
def _find_modes(self, t):
525
"""Determine the appropriate modes for files and directories.
526
527
FIXME: When this merges into, or from storage,
528
this code becomes delgatable to a LockableFiles instance.
529
530
For now its cribbed and returns (dir_mode, file_mode)
531
"""
532
try:
533
st = t.stat('.')
534
except errors.TransportNotPossible:
535
dir_mode = 0755
536
file_mode = 0644
537
else:
538
dir_mode = st.st_mode & 07777
539
# Remove the sticky and execute bits for files
540
file_mode = dir_mode & ~07111
541
if not BzrBranch._set_dir_mode:
542
dir_mode = None
543
if not BzrBranch._set_file_mode:
544
file_mode = None
545
return dir_mode, file_mode
546
547
def initialize(self, url):
548
"""Create a branch of this format at url and return an open branch."""
549
t = get_transport(url)
550
from bzrlib.weavefile import write_weave_v5
551
from bzrlib.weave import Weave
552
553
# Create an empty weave
554
sio = StringIO()
555
bzrlib.weavefile.write_weave_v5(Weave(), sio)
556
empty_weave = sio.getvalue()
557
558
# Since we don't have a .bzr directory, inherit the
559
# mode from the root directory
560
temp_control = LockableFiles(t, '')
561
temp_control._transport.mkdir('.bzr',
562
mode=temp_control._dir_mode)
563
file_mode = temp_control._file_mode
564
del temp_control
565
mutter('created control directory in ' + t.base)
566
control = t.clone('.bzr')
567
dirs = ['revision-store', 'weaves']
568
lock_file = 'branch-lock'
569
utf8_files = [('README',
570
"This is a Bazaar-NG control directory.\n"
571
"Do not change any files in this directory.\n"),
572
('branch-format', self.get_format_string()),
573
('revision-history', ''),
574
('branch-name', ''),
575
]
576
files = [('inventory.weave', StringIO(empty_weave)),
577
]
578
579
# FIXME: RBC 20060125 dont peek under the covers
580
# NB: no need to escape relative paths that are url safe.
581
control.put(lock_file, StringIO(), mode=file_mode)
582
control_files = LockableFiles(control, lock_file)
583
control_files.lock_write()
584
control_files._transport.mkdir_multi(dirs,
585
mode=control_files._dir_mode)
586
try:
587
for file, content in utf8_files:
588
control_files.put_utf8(file, content)
589
for file, content in files:
590
control_files.put(file, content)
591
finally:
592
control_files.unlock()
593
return BzrBranch(t, _format=self, _control_files=control_files)
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, transport):
605
"""Fill out the data in branch for the branch at url."""
606
return BzrBranch(transport, _format=self)
607
608
@classmethod
609
def register_format(klass, format):
610
klass._formats[format.get_format_string()] = format
611
612
@classmethod
613
def unregister_format(klass, format):
614
assert klass._formats[format.get_format_string()] is format
615
del klass._formats[format.get_format_string()]
616
617
618
class BzrBranchFormat4(BzrBranchFormat):
619
"""Bzr branch format 4.
620
621
This format has:
622
- flat stores
623
- TextStores for texts, inventories,revisions.
624
625
This format is deprecated: it indexes texts using a text it which is
626
removed in format 5; write support for this format has been removed.
627
"""
628
629
def get_format_string(self):
630
"""See BzrBranchFormat.get_format_string()."""
631
return BZR_BRANCH_FORMAT_4
632
633
def initialize(self, url):
634
"""Format 4 branches cannot be created."""
635
raise UninitializableFormat(self)
636
637
def is_supported(self):
638
"""Format 4 is not supported.
639
640
It is not supported because the model changed from 4 to 5 and the
641
conversion logic is expensive - so doing it on the fly was not
642
feasible.
643
"""
644
return False
645
646
647
class BzrBranchFormat5(BzrBranchFormat):
648
"""Bzr branch format 5.
649
650
This format has:
651
- weaves for file texts and inventory
652
- flat stores
653
- TextStores for revisions and signatures.
654
"""
655
656
def get_format_string(self):
657
"""See BzrBranchFormat.get_format_string()."""
658
return BZR_BRANCH_FORMAT_5
659
660
661
class BzrBranchFormat6(BzrBranchFormat):
662
"""Bzr branch format 6.
663
664
This format has:
665
- weaves for file texts and inventory
666
- hash subdirectory based stores.
667
- TextStores for revisions and signatures.
668
"""
669
670
def get_format_string(self):
671
"""See BzrBranchFormat.get_format_string()."""
672
return BZR_BRANCH_FORMAT_6
673
674
675
BzrBranchFormat.register_format(BzrBranchFormat4())
676
BzrBranchFormat.register_format(BzrBranchFormat5())
677
BzrBranchFormat.register_format(BzrBranchFormat6())
678
679
# TODO: jam 20060108 Create a new branch format, and as part of upgrade
680
# make sure that ancestry.weave is deleted (it is never used, but
681
# used to be created)
682
683
684
class BzrBranch(Branch):
685
"""A branch stored in the actual filesystem.
686
687
Note that it's "local" in the context of the filesystem; it doesn't
688
really matter if it's on an nfs/smb/afs/coda/... share, as long as
689
it's writable, and can be accessed via the normal filesystem API.
690
691
"""
692
# We actually expect this class to be somewhat short-lived; part of its
693
# purpose is to try to isolate what bits of the branch logic are tied to
694
# filesystem access, so that in a later step, we can extricate them to
695
# a separarte ("storage") class.
696
_inventory_weave = None
697
698
# Map some sort of prefix into a namespace
699
# stuff like "revno:10", "revid:", etc.
700
# This should match a prefix with a function which accepts
701
REVISION_NAMESPACES = {}
702
703
def push_stores(self, branch_to):
704
"""See Branch.push_stores."""
705
if (not isinstance(self._branch_format, BzrBranchFormat4) or
706
self._branch_format != branch_to._branch_format):
707
from bzrlib.fetch import greedy_fetch
708
mutter("Using fetch logic to push between %s(%s) and %s(%s)",
709
self, self._branch_format, branch_to, branch_to._branch_format)
710
greedy_fetch(to_branch=branch_to, from_branch=self,
711
revision=self.last_revision())
712
return
713
714
# format 4 to format 4 logic only.
715
store_pairs = ((self.text_store, branch_to.text_store),
716
(self.inventory_store, branch_to.inventory_store),
717
(self.revision_store, branch_to.revision_store))
718
try:
719
for from_store, to_store in store_pairs:
720
copy_all(from_store, to_store)
721
except UnlistableStore:
722
raise UnlistableBranch(from_store)
723
724
def __init__(self, transport, init=DEPRECATED_PARAMETER,
725
relax_version_check=DEPRECATED_PARAMETER, _format=None,
726
_control_files=None):
727
"""Create new branch object at a particular location.
728
729
transport -- A Transport object, defining how to access files.
730
731
init -- If True, create new control files in a previously
732
unversioned directory. If False, the branch must already
733
be versioned.
734
735
relax_version_check -- If true, the usual check for the branch
736
version is not applied. This is intended only for
737
upgrade/recovery type use; it's not guaranteed that
738
all operations will work on old format branches.
739
740
In the test suite, creation of new trees is tested using the
741
`ScratchBranch` class.
742
"""
743
assert isinstance(transport, Transport), \
744
"%r is not a Transport" % transport
745
self._transport = transport
746
self._base = self._transport.base
747
if _control_files is None:
748
_control_files = LockableFiles(self._transport.clone(bzrlib.BZRDIR),
749
'branch-lock')
750
self.control_files = _control_files
751
if deprecated_passed(init):
752
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
753
"deprecated as of bzr 0.8. Please use Branch.create().",
754
DeprecationWarning,
755
stacklevel=2)
756
if init:
757
# this is slower than before deprecation, oh well never mind.
758
# -> its deprecated.
759
self._initialize(transport.base)
760
self._check_format(_format)
761
if deprecated_passed(relax_version_check):
762
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
763
"relax_version_check parameter is deprecated as of bzr 0.8. "
764
"Please use Branch.open_downlevel, or a BzrBranchFormat's "
765
"open() method.",
766
DeprecationWarning,
767
stacklevel=2)
768
if (not relax_version_check
769
and not self._branch_format.is_supported()):
770
raise errors.UnsupportedFormatError(
771
'sorry, branch format %r not supported' % fmt,
772
['use a different bzr version',
773
'or remove the .bzr directory'
774
' and "bzr init" again'])
775
self.repository = Repository(transport, self._branch_format)
776
777
778
@staticmethod
779
def _initialize(base):
780
"""Create a bzr branch in the latest format."""
781
return BzrBranchFormat6().initialize(base)
782
783
def __str__(self):
784
return '%s(%r)' % (self.__class__.__name__, self.base)
785
786
__repr__ = __str__
787
788
def __del__(self):
789
# TODO: It might be best to do this somewhere else,
790
# but it is nice for a Branch object to automatically
791
# cache it's information.
792
# Alternatively, we could have the Transport objects cache requests
793
# See the earlier discussion about how major objects (like Branch)
794
# should never expect their __del__ function to run.
795
# XXX: cache_root seems to be unused, 2006-01-13 mbp
796
if hasattr(self, 'cache_root') and self.cache_root is not None:
797
try:
798
shutil.rmtree(self.cache_root)
799
except:
800
pass
801
self.cache_root = None
802
803
def _get_base(self):
804
return self._base
805
806
base = property(_get_base, doc="The URL for the root of this branch.")
807
808
def _finish_transaction(self):
809
"""Exit the current transaction."""
810
return self.control_files._finish_transaction()
811
812
def get_transaction(self):
813
"""Return the current active transaction.
814
815
If no transaction is active, this returns a passthrough object
816
for which all data is immediately flushed and no caching happens.
817
"""
818
# this is an explicit function so that we can do tricky stuff
819
# when the storage in rev_storage is elsewhere.
820
# we probably need to hook the two 'lock a location' and
821
# 'have a transaction' together more delicately, so that
822
# we can have two locks (branch and storage) and one transaction
823
# ... and finishing the transaction unlocks both, but unlocking
824
# does not. - RBC 20051121
825
return self.control_files.get_transaction()
826
827
def _set_transaction(self, transaction):
828
"""Set a new active transaction."""
829
return self.control_files._set_transaction(transaction)
830
831
def abspath(self, name):
832
"""See Branch.abspath."""
833
return self.control_files._transport.abspath(name)
834
835
def _check_format(self, format):
836
"""Identify the branch format if needed.
837
838
The format is stored as a reference to the format object in
839
self._branch_format for code that needs to check it later.
840
841
The format parameter is either None or the branch format class
842
used to open this branch.
843
"""
844
if format is None:
845
format = BzrBranchFormat.find_format(self._transport)
846
self._branch_format = format
847
mutter("got branch format %s", self._branch_format)
848
849
@needs_read_lock
850
def get_root_id(self):
851
"""See Branch.get_root_id."""
852
tree = self.repository.revision_tree(self.last_revision())
853
return tree.inventory.root.file_id
854
855
def lock_write(self):
856
# TODO: test for failed two phase locks. This is known broken.
857
self.control_files.lock_write()
858
self.repository.lock_write()
859
860
def lock_read(self):
861
# TODO: test for failed two phase locks. This is known broken.
862
self.control_files.lock_read()
863
self.repository.lock_read()
864
865
def unlock(self):
866
# TODO: test for failed two phase locks. This is known broken.
867
self.repository.unlock()
868
self.control_files.unlock()
869
870
def peek_lock_mode(self):
871
if self.control_files._lock_count == 0:
872
return None
873
else:
874
return self.control_files._lock_mode
875
876
@needs_read_lock
877
def print_file(self, file, revision_id):
878
"""See Branch.print_file."""
879
return self.repository.print_file(file, revision_id)
880
881
@needs_write_lock
882
def append_revision(self, *revision_ids):
883
"""See Branch.append_revision."""
884
for revision_id in revision_ids:
885
mutter("add {%s} to revision-history" % revision_id)
886
rev_history = self.revision_history()
887
rev_history.extend(revision_ids)
888
self.set_revision_history(rev_history)
889
890
@needs_write_lock
891
def set_revision_history(self, rev_history):
892
"""See Branch.set_revision_history."""
893
self.control_files.put_utf8(
894
'revision-history', '\n'.join(rev_history))
895
896
def get_revision_delta(self, revno):
897
"""Return the delta for one revision.
898
899
The delta is relative to its mainline predecessor, or the
900
empty tree for revision 1.
901
"""
902
assert isinstance(revno, int)
903
rh = self.revision_history()
904
if not (1 <= revno <= len(rh)):
905
raise InvalidRevisionNumber(revno)
906
907
# revno is 1-based; list is 0-based
908
909
new_tree = self.repository.revision_tree(rh[revno-1])
910
if revno == 1:
911
old_tree = EmptyTree()
912
else:
913
old_tree = self.repository.revision_tree(rh[revno-2])
914
return compare_trees(old_tree, new_tree)
915
916
@needs_read_lock
917
def revision_history(self):
918
"""See Branch.revision_history."""
919
# FIXME are transactions bound to control files ? RBC 20051121
920
transaction = self.get_transaction()
921
history = transaction.map.find_revision_history()
922
if history is not None:
923
mutter("cache hit for revision-history in %s", self)
924
return list(history)
925
history = [l.rstrip('\r\n') for l in
926
self.control_files.get_utf8('revision-history').readlines()]
927
transaction.map.add_revision_history(history)
928
# this call is disabled because revision_history is
929
# not really an object yet, and the transaction is for objects.
930
# transaction.register_clean(history, precious=True)
931
return list(history)
932
933
def update_revisions(self, other, stop_revision=None):
934
"""See Branch.update_revisions."""
935
from bzrlib.fetch import greedy_fetch
936
937
if stop_revision is None:
938
stop_revision = other.last_revision()
939
### Should this be checking is_ancestor instead of revision_history?
940
if (stop_revision is not None and
941
stop_revision in self.revision_history()):
942
return
943
greedy_fetch(to_branch=self, from_branch=other,
944
revision=stop_revision)
945
pullable_revs = self.pullable_revisions(other, stop_revision)
946
if len(pullable_revs) > 0:
947
self.append_revision(*pullable_revs)
948
949
def pullable_revisions(self, other, stop_revision):
950
"""See Branch.pullable_revisions."""
951
other_revno = other.revision_id_to_revno(stop_revision)
952
try:
953
return self.missing_revisions(other, other_revno)
954
except DivergedBranches, e:
955
try:
956
pullable_revs = get_intervening_revisions(self.last_revision(),
957
stop_revision,
958
self.repository)
959
assert self.last_revision() not in pullable_revs
960
return pullable_revs
961
except bzrlib.errors.NotAncestor:
962
if is_ancestor(self.last_revision(), stop_revision, self):
963
return []
964
else:
965
raise e
966
967
def basis_tree(self):
968
"""See Branch.basis_tree."""
969
try:
970
revision_id = self.revision_history()[-1]
971
# FIXME: This is an abstraction violation, the basis tree
972
# here as defined is on the working tree, the method should
973
# be too. The basis tree for a branch can be different than
974
# that for a working tree. RBC 20051207
975
xml = self.working_tree().read_basis_inventory(revision_id)
976
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
977
return RevisionTree(self.repository, inv, revision_id)
978
except (IndexError, NoSuchFile, NoWorkingTree), e:
979
return self.repository.revision_tree(self.last_revision())
980
981
def working_tree(self):
982
"""See Branch.working_tree."""
983
from bzrlib.workingtree import WorkingTree
984
from bzrlib.transport.local import LocalTransport
985
if (self.base.find('://') != -1 or
986
not isinstance(self._transport, LocalTransport)):
987
raise NoWorkingTree(self.base)
988
return WorkingTree(self.base, branch=self)
989
990
@needs_write_lock
991
def pull(self, source, overwrite=False, stop_revision=None):
992
"""See Branch.pull."""
993
source.lock_read()
994
try:
995
old_count = len(self.revision_history())
996
try:
997
self.update_revisions(source,stop_revision)
998
except DivergedBranches:
999
if not overwrite:
1000
raise
1001
if overwrite:
1002
self.set_revision_history(source.revision_history())
1003
new_count = len(self.revision_history())
1004
return new_count - old_count
1005
finally:
1006
source.unlock()
1007
1008
def get_parent(self):
1009
"""See Branch.get_parent."""
1010
import errno
1011
_locs = ['parent', 'pull', 'x-pull']
1012
for l in _locs:
1013
try:
1014
return self.control_files.get_utf8(l).read().strip('\n')
1015
except NoSuchFile:
1016
pass
1017
return None
1018
1019
def get_push_location(self):
1020
"""See Branch.get_push_location."""
1021
config = bzrlib.config.BranchConfig(self)
1022
push_loc = config.get_user_option('push_location')
1023
return push_loc
1024
1025
def set_push_location(self, location):
1026
"""See Branch.set_push_location."""
1027
config = bzrlib.config.LocationConfig(self.base)
1028
config.set_user_option('push_location', location)
1029
1030
@needs_write_lock
1031
def set_parent(self, url):
1032
"""See Branch.set_parent."""
1033
# TODO: Maybe delete old location files?
1034
# URLs should never be unicode, even on the local fs,
1035
# FIXUP this and get_parent in a future branch format bump:
1036
# read and rewrite the file, and have the new format code read
1037
# using .get not .get_utf8. RBC 20060125
1038
self.control_files.put_utf8('parent', url + '\n')
1039
1040
def tree_config(self):
1041
return TreeConfig(self)
1042
1043
def _get_truncated_history(self, revision_id):
1044
history = self.revision_history()
1045
if revision_id is None:
1046
return history
1047
try:
1048
idx = history.index(revision_id)
1049
except ValueError:
1050
raise InvalidRevisionId(revision_id=revision, branch=self)
1051
return history[:idx+1]
1052
1053
@needs_read_lock
1054
def _clone_weave(self, to_location, revision=None, basis_branch=None):
1055
# prevent leakage
1056
from bzrlib.workingtree import WorkingTree
1057
assert isinstance(to_location, basestring)
1058
if basis_branch is not None:
1059
note("basis_branch is not supported for fast weave copy yet.")
1060
1061
history = self._get_truncated_history(revision)
1062
if not bzrlib.osutils.lexists(to_location):
1063
os.mkdir(to_location)
1064
branch_to = Branch.initialize(to_location)
1065
mutter("copy branch from %s to %s", self, branch_to)
1066
1067
self.repository.copy(branch_to.repository)
1068
1069
# must be done *after* history is copied across
1070
# FIXME duplicate code with base .clone().
1071
# .. would template method be useful here? RBC 20051207
1072
branch_to.set_parent(self.base)
1073
branch_to.append_revision(*history)
1074
# FIXME: this should be in workingtree.clone
1075
WorkingTree.create(branch_to, to_location).set_root_id(self.get_root_id())
1076
mutter("copied")
1077
return branch_to
1078
1079
def clone(self, to_location, revision=None, basis_branch=None, to_branch_type=None):
1080
print "FIXME: clone via create and fetch is probably faster when versioned file comes in."
1081
if to_branch_type is None:
1082
to_branch_type = BzrBranch
1083
1084
if to_branch_type == BzrBranch \
1085
and self.repository.weave_store.listable() \
1086
and self.repository.revision_store.listable():
1087
return self._clone_weave(to_location, revision, basis_branch)
1088
1089
return Branch.clone(self, to_location, revision, basis_branch, to_branch_type)
1090
1091
def fileid_involved_between_revs(self, from_revid, to_revid):
1092
"""Find file_id(s) which are involved in the changes between revisions.
1093
1094
This determines the set of revisions which are involved, and then
1095
finds all file ids affected by those revisions.
1096
"""
1097
# TODO: jam 20060119 This code assumes that w.inclusions will
1098
# always be correct. But because of the presence of ghosts
1099
# it is possible to be wrong.
1100
# One specific example from Robert Collins:
1101
# Two branches, with revisions ABC, and AD
1102
# C is a ghost merge of D.
1103
# Inclusions doesn't recognize D as an ancestor.
1104
# If D is ever merged in the future, the weave
1105
# won't be fixed, because AD never saw revision C
1106
# to cause a conflict which would force a reweave.
1107
w = self.repository.get_inventory_weave()
1108
from_set = set(w.inclusions([w.lookup(from_revid)]))
1109
to_set = set(w.inclusions([w.lookup(to_revid)]))
1110
included = to_set.difference(from_set)
1111
changed = map(w.idx_to_name, included)
1112
return self._fileid_involved_by_set(changed)
1113
1114
def fileid_involved(self, last_revid=None):
1115
"""Find all file_ids modified in the ancestry of last_revid.
1116
1117
:param last_revid: If None, last_revision() will be used.
1118
"""
1119
w = self.repository.get_inventory_weave()
1120
if not last_revid:
1121
changed = set(w._names)
1122
else:
1123
included = w.inclusions([w.lookup(last_revid)])
1124
changed = map(w.idx_to_name, included)
1125
return self._fileid_involved_by_set(changed)
1126
1127
def fileid_involved_by_set(self, changes):
1128
"""Find all file_ids modified by the set of revisions passed in.
1129
1130
:param changes: A set() of revision ids
1131
"""
1132
# TODO: jam 20060119 This line does *nothing*, remove it.
1133
# or better yet, change _fileid_involved_by_set so
1134
# that it takes the inventory weave, rather than
1135
# pulling it out by itself.
1136
w = self.repository.get_inventory_weave()
1137
return self._fileid_involved_by_set(changes)
1138
1139
def _fileid_involved_by_set(self, changes):
1140
"""Find the set of file-ids affected by the set of revisions.
1141
1142
:param changes: A set() of revision ids.
1143
:return: A set() of file ids.
1144
1145
This peaks at the Weave, interpreting each line, looking to
1146
see if it mentions one of the revisions. And if so, includes
1147
the file id mentioned.
1148
This expects both the Weave format, and the serialization
1149
to have a single line per file/directory, and to have
1150
fileid="" and revision="" on that line.
1151
"""
1152
assert (isinstance(self._branch_format, BzrBranchFormat5) or
1153
isinstance(self._branch_format, BzrBranchFormat6)), \
1154
"fileid_involved only supported for branches which store inventory as xml"
1155
1156
w = self.repository.get_inventory_weave()
1157
file_ids = set()
1158
for line in w._weave:
1159
1160
# it is ugly, but it is due to the weave structure
1161
if not isinstance(line, basestring): continue
1162
1163
start = line.find('file_id="')+9
1164
if start < 9: continue
1165
end = line.find('"', start)
1166
assert end>= 0
1167
file_id = xml.sax.saxutils.unescape(line[start:end])
1168
1169
# check if file_id is already present
1170
if file_id in file_ids: continue
1171
1172
start = line.find('revision="')+10
1173
if start < 10: continue
1174
end = line.find('"', start)
1175
assert end>= 0
1176
revision_id = xml.sax.saxutils.unescape(line[start:end])
1177
1178
if revision_id in changes:
1179
file_ids.add(file_id)
1180
1181
return file_ids
1182
1183
1184
Branch.set_default_initializer(BzrBranch._initialize)
1185
1186
1187
class BranchTestProviderAdapter(object):
1188
"""A tool to generate a suite testing multiple branch formats at once.
1189
1190
This is done by copying the test once for each transport and injecting
1191
the transport_server, transport_readonly_server, and branch_format
1192
classes into each copy. Each copy is also given a new id() to make it
1193
easy to identify.
1194
"""
1195
1196
def __init__(self, transport_server, transport_readonly_server, formats):
1197
self._transport_server = transport_server
1198
self._transport_readonly_server = transport_readonly_server
1199
self._formats = formats
1200
1201
def adapt(self, test):
1202
result = TestSuite()
1203
for format in self._formats:
1204
new_test = deepcopy(test)
1205
new_test.transport_server = self._transport_server
1206
new_test.transport_readonly_server = self._transport_readonly_server
1207
new_test.branch_format = format
1208
def make_new_test_id():
1209
new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1210
return lambda: new_id
1211
new_test.id = make_new_test_id()
1212
result.addTest(new_test)
1213
return result
1214
1215
1216
class ScratchBranch(BzrBranch):
716
1217
"""Special test class: a branch that cleans up after itself.
717
1218
718
1219
>>> b = ScratchBranch()
719
1220
>>> isdir(b.base)
720
1221
True
721
1222
>>> bd = b.base
722
>>> b.destroy()
1223
>>> b._transport.__del__()
723
1224
>>> isdir(bd)
724
1225
False
725
1226
"""
726
def __init__(self, files=[], dirs=[]):
1227
1228
def __init__(self, files=[], dirs=[], transport=None):
727
1229
"""Make a test branch.
728
1230
729
1231
This creates a temporary directory and runs init-tree in it.
730
1232
731
1233
If any files are listed, they are created in the working copy.
732
1234
"""
733
Branch.__init__(self, tempfile.mkdtemp(), init=True)
1235
if transport is None:
1236
transport = bzrlib.transport.local.ScratchTransport()
1237
# local import for scope restriction
1238
from bzrlib.workingtree import WorkingTree
1239
WorkingTree.create_standalone(transport.base)
1240
super(ScratchBranch, self).__init__(transport)
1241
else:
1242
super(ScratchBranch, self).__init__(transport)
1243
1244
# BzrBranch creates a clone to .bzr and then forgets about the
1245
# original transport. A ScratchTransport() deletes itself and
1246
# everything underneath it when it goes away, so we need to
1247
# grab a local copy to prevent that from happening
1248
self._transport = transport
1249
734
1250
for d in dirs:
735
os.mkdir(self.abspath(d))
1251
self._transport.mkdir(d)
736
1252
737
1253
for f in files:
738
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
739
740
741
def __del__(self):
742
self.destroy()
743
744
def destroy(self):
745
"""Destroy the test branch, removing the scratch directory."""
746
try:
747
mutter("delete ScratchBranch %s" % self.base)
748
shutil.rmtree(self.base)
749
except OSError, e:
750
# Work around for shutil.rmtree failing on Windows when
751
# readonly files are encountered
752
mutter("hit exception in destroying ScratchBranch: %s" % e)
753
for root, dirs, files in os.walk(self.base, topdown=False):
754
for name in files:
755
os.chmod(os.path.join(root, name), 0700)
756
shutil.rmtree(self.base)
757
self.base = None
758
1254
self._transport.put(f, 'content of %s' % f)
1255
1256
def clone(self):
1257
"""
1258
>>> orig = ScratchBranch(files=["file1", "file2"])
1259
>>> os.listdir(orig.base)
1260
[u'.bzr', u'file1', u'file2']
1261
>>> clone = orig.clone()
1262
>>> if os.name != 'nt':
1263
... os.path.samefile(orig.base, clone.base)
1264
... else:
1265
... orig.base == clone.base
1266
...
1267
False
1268
>>> os.listdir(clone.base)
1269
[u'.bzr', u'file1', u'file2']
1270
"""
1271
from shutil import copytree
1272
from bzrlib.osutils import mkdtemp
1273
base = mkdtemp()
1274
os.rmdir(base)
1275
copytree(self.base, base, symlinks=True)
1276
return ScratchBranch(
1277
transport=bzrlib.transport.local.ScratchTransport(base))
759
1278
760
1279
761
1280
######################################################################
764
1283
765
1284
def is_control_file(filename):
766
1285
## FIXME: better check
767
filename = os.path.normpath(filename)
1286
filename = normpath(filename)
768
1287
while filename != '':
769
1288
head, tail = os.path.split(filename)
770
## mutter('check %r for control file' % ((head, tail), ))
1289
## mutter('check %r for control file' % ((head, tail),))
771
1290
if tail == bzrlib.BZRDIR:
772
1291
return True
773
1292
if filename == head:
774
1293
break
775
1294
filename = head
776
1295
return False
777
778
779
780
def gen_file_id(name):
781
"""Return new file id.
782
783
This should probably generate proper UUIDs, but for the moment we
784
cope with just randomness because running uuidgen every time is
785
slow."""
786
idx = name.rfind('/')
787
if idx != -1:
788
name = name[idx+1 : ]
789
idx = name.rfind('\\')
790
if idx != -1:
791
name = name[idx+1 : ]
792
793
name = name.lstrip('.')
794
795
s = hexlify(rand_bytes(8))
796
return '-'.join((name, compact_date(time.time()), s))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1