« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1563.2.8
- compare with another revision
- download diff
- download tarball
- view history from revision 1563.2.8
- Committer: Robert Collins
- Date: 2006-03-01 03:26:23 UTC
- mto: (1594.2.4 integration)
- mto: This revision was merged to the branch mainline in revision 1596.
- Revision ID: robertc@robertcollins.net-20060301032623-9d3c073e102f2239
Move WeaveStore down into bzrlib.store.versioned.weave.
- files added:
- BRANCH.TODO
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/store
- bzrlib/store/versioned
- 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
- contrib/emacs
- tools
- tools/doc_generate
- files removed:
- bzrlib/changeset.py
- patches
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- bzrlib/selftest.py => bzrlib/tests/__init__.py
- bzrlib/whitebox.py => bzrlib/tests/test_whitebox.py
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/urlgrabber/
- bzrlib/xml.py => bzrlib/xml_serializer.py
- bzrlib/newinventory.py => contrib/newinventory.py
- bzr-man.py => tools/doc_generate/autodoc_man.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005 Canonical Ltd
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
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
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
19
import traceback, socket, fnmatch, difflib, time
20
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
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
21
34
22
35
import bzrlib
23
from inventory import Inventory
24
from trace import mutter, note
25
from tree import Tree, EmptyTree, RevisionTree
26
from inventory import InventoryEntry, Inventory
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
28
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
29
joinpath, sha_file, sha_string, file_kind, local_time_offset, appendpath
30
from store import ImmutableStore
31
from revision import Revision
32
from errors import BzrError
33
from textui import show_status
34
35
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
36
## TODO: Maybe include checks for common corruption of newlines, etc?
37
38
39
40
def find_branch(f, **args):
41
if f and (f.startswith('http://') or f.startswith('https://')):
42
import remotebranch
43
return remotebranch.RemoteBranch(f, **args)
44
else:
45
return Branch(f, **args)
46
47
48
49
def _relpath(base, path):
50
"""Return path relative to base, or raise exception.
51
52
The path may be either an absolute path or a path relative to the
53
current working directory.
54
55
Lifted out of Branch.relpath for ease of testing.
56
57
os.path.commonprefix (python2.4) has a bad bug that it works just
58
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
59
avoids that problem."""
60
rp = os.path.abspath(path)
61
62
s = []
63
head = rp
64
while len(head) >= len(base):
65
if head == base:
66
break
67
head, tail = os.path.split(head)
68
if tail:
69
s.insert(0, tail)
70
else:
71
from errors import NotBranchError
72
raise NotBranchError("path %r is not within branch %r" % (rp, base))
73
74
return os.sep.join(s)
75
76
77
def find_branch_root(f=None):
78
"""Find the branch root enclosing f, or pwd.
79
80
f may be a filename or a URL.
81
82
It is not necessary that f exists.
83
84
Basically we keep looking up until we find the control directory or
85
run into the root."""
86
if f == None:
87
f = os.getcwd()
88
elif hasattr(os.path, 'realpath'):
89
f = os.path.realpath(f)
90
else:
91
f = os.path.abspath(f)
92
if not os.path.exists(f):
93
raise BzrError('%r does not exist' % f)
94
95
96
orig_f = f
97
98
while True:
99
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
100
return f
101
head, tail = os.path.split(f)
102
if head == f:
103
# reached the root, whatever that may be
104
raise BzrError('%r is not in a branch' % orig_f)
105
f = head
106
107
class DivergedBranches(Exception):
108
def __init__(self, branch1, branch2):
109
self.branch1 = branch1
110
self.branch2 = branch2
111
Exception.__init__(self, "These branches have diverged.")
112
113
114
class NoSuchRevision(BzrError):
115
def __init__(self, branch, revision):
116
self.branch = branch
117
self.revision = revision
118
msg = "Branch %s has no revision %d" % (branch, revision)
119
BzrError.__init__(self, msg)
36
import bzrlib.bzrdir as bzrdir
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 (
61
get_intervening_revisions,
62
is_ancestor,
63
NULL_REVISION,
64
Revision,
65
)
66
from bzrlib.store import copy_all
67
from bzrlib.symbol_versioning import *
68
import bzrlib.transactions as transactions
69
from bzrlib.transport import Transport, get_transport
70
from bzrlib.tree import EmptyTree, RevisionTree
71
import bzrlib.ui
72
import bzrlib.xml5
73
74
75
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
76
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
77
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
78
79
80
# TODO: Maybe include checks for common corruption of newlines, etc?
81
82
# TODO: Some operations like log might retrieve the same revisions
83
# repeatedly to calculate deltas. We could perhaps have a weakref
84
# cache in memory to make this faster. In general anything can be
85
# cached in memory between lock and unlock operations. .. nb thats
86
# what the transaction identity map provides
120
87
121
88
122
89
######################################################################
126
93
"""Branch holding a history of revisions.
127
94
128
95
base
129
Base directory of the branch.
130
131
_lock_mode
132
None, or 'r' or 'w'
133
134
_lock_count
135
If _lock_mode is true, a positive count of the number of times the
136
lock has been taken.
137
138
_lock
139
Lock object from bzrlib.lock.
96
Base directory/url of the branch.
140
97
"""
98
# this is really an instance variable - FIXME move it there
99
# - RBC 20060112
141
100
base = None
142
_lock_mode = None
143
_lock_count = None
144
_lock = None
145
146
def __init__(self, base, init=False, find_root=True):
147
"""Create new branch object at a particular location.
148
149
base -- Base directory for the branch.
150
151
init -- If True, create new control files in a previously
152
unversioned directory. If False, the branch must already
153
be versioned.
154
155
find_root -- If true and init is false, find the root of the
156
existing branch containing base.
157
158
In the test suite, creation of new trees is tested using the
159
`ScratchBranch` class.
160
"""
161
if init:
162
self.base = os.path.realpath(base)
163
self._make_control()
164
elif find_root:
165
self.base = find_branch_root(base)
166
else:
167
self.base = os.path.realpath(base)
168
if not isdir(self.controlfilename('.')):
169
from errors import NotBranchError
170
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
171
['use "bzr init" to initialize a new working tree',
172
'current bzr can only operate from top-of-tree'])
173
self._check_format()
174
175
self.text_store = ImmutableStore(self.controlfilename('text-store'))
176
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
177
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
178
179
180
def __str__(self):
181
return '%s(%r)' % (self.__class__.__name__, self.base)
182
183
184
__repr__ = __str__
185
186
187
def __del__(self):
188
if self._lock_mode or self._lock:
189
from warnings import warn
190
warn("branch %r was not explicitly unlocked" % self)
191
self._lock.unlock()
192
193
194
101
102
def __init__(self, *ignored, **ignored_too):
103
raise NotImplementedError('The Branch class is abstract')
104
105
@staticmethod
106
@deprecated_method(zero_eight)
107
def open_downlevel(base):
108
"""Open a branch which may be of an old format."""
109
return Branch.open(base, _unsupported=True)
110
111
@staticmethod
112
def open(base, _unsupported=False):
113
"""Open the repository rooted at base.
114
115
For instance, if the repository is at URL/.bzr/repository,
116
Repository.open(URL) -> a Repository instance.
117
"""
118
control = bzrdir.BzrDir.open(base, _unsupported)
119
return control.open_branch(_unsupported)
120
121
@staticmethod
122
def open_containing(url):
123
"""Open an existing branch which contains url.
124
125
This probes for a branch at url, and searches upwards from there.
126
127
Basically we keep looking up until we find the control directory or
128
run into the root. If there isn't one, raises NotBranchError.
129
If there is one and it is either an unrecognised format or an unsupported
130
format, UnknownFormatError or UnsupportedFormatError are raised.
131
If there is one, it is returned, along with the unused portion of url.
132
"""
133
control, relpath = bzrdir.BzrDir.open_containing(url)
134
return control.open_branch(), relpath
135
136
@staticmethod
137
@deprecated_function(zero_eight)
138
def initialize(base):
139
"""Create a new working tree and branch, rooted at 'base' (url)
140
141
NOTE: This will soon be deprecated in favour of creation
142
through a BzrDir.
143
"""
144
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
145
146
def setup_caching(self, cache_root):
147
"""Subclasses that care about caching should override this, and set
148
up cached stores located under cache_root.
149
"""
150
# seems to be unused, 2006-01-13 mbp
151
warn('%s is deprecated' % self.setup_caching)
152
self.cache_root = cache_root
153
154
def _get_nick(self):
155
cfg = self.tree_config()
156
return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
157
158
def _set_nick(self, nick):
159
cfg = self.tree_config()
160
cfg.set_option(nick, "nickname")
161
assert cfg.get_option("nickname") == nick
162
163
nick = property(_get_nick, _set_nick)
164
195
165
def lock_write(self):
196
if self._lock_mode:
197
if self._lock_mode != 'w':
198
from errors import LockError
199
raise LockError("can't upgrade to a write lock from %r" %
200
self._lock_mode)
201
self._lock_count += 1
202
else:
203
from bzrlib.lock import WriteLock
204
205
self._lock = WriteLock(self.controlfilename('branch-lock'))
206
self._lock_mode = 'w'
207
self._lock_count = 1
208
209
210
166
raise NotImplementedError('lock_write is abstract')
167
211
168
def lock_read(self):
212
if self._lock_mode:
213
assert self._lock_mode in ('r', 'w'), \
214
"invalid lock mode %r" % self._lock_mode
215
self._lock_count += 1
216
else:
217
from bzrlib.lock import ReadLock
218
219
self._lock = ReadLock(self.controlfilename('branch-lock'))
220
self._lock_mode = 'r'
221
self._lock_count = 1
222
223
224
169
raise NotImplementedError('lock_read is abstract')
170
225
171
def unlock(self):
226
if not self._lock_mode:
227
from errors import LockError
228
raise LockError('branch %r is not locked' % (self))
229
230
if self._lock_count > 1:
231
self._lock_count -= 1
232
else:
233
self._lock.unlock()
234
self._lock = None
235
self._lock_mode = self._lock_count = None
236
172
raise NotImplementedError('unlock is abstract')
173
174
def peek_lock_mode(self):
175
"""Return lock mode for the Branch: 'r', 'w' or None"""
176
raise NotImplementedError(self.peek_lock_mode)
237
177
238
178
def abspath(self, name):
239
"""Return absolute filename for something in the branch"""
240
return os.path.join(self.base, name)
241
242
243
def relpath(self, path):
244
"""Return path relative to this branch of something inside it.
245
246
Raises an error if path is not in this branch."""
247
return _relpath(self.base, path)
248
249
250
def controlfilename(self, file_or_path):
251
"""Return location relative to branch."""
252
if isinstance(file_or_path, types.StringTypes):
253
file_or_path = [file_or_path]
254
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
255
256
257
def controlfile(self, file_or_path, mode='r'):
258
"""Open a control file for this branch.
259
260
There are two classes of file in the control directory: text
261
and binary. binary files are untranslated byte streams. Text
262
control files are stored with Unix newlines and in UTF-8, even
263
if the platform or locale defaults are different.
264
265
Controlfiles should almost never be opened in write mode but
266
rather should be atomically copied and replaced using atomicfile.
267
"""
268
269
fn = self.controlfilename(file_or_path)
270
271
if mode == 'rb' or mode == 'wb':
272
return file(fn, mode)
273
elif mode == 'r' or mode == 'w':
274
# open in binary mode anyhow so there's no newline translation;
275
# codecs uses line buffering by default; don't want that.
276
import codecs
277
return codecs.open(fn, mode + 'b', 'utf-8',
278
buffering=60000)
279
else:
280
raise BzrError("invalid controlfile mode %r" % mode)
281
282
283
284
def _make_control(self):
285
os.mkdir(self.controlfilename([]))
286
self.controlfile('README', 'w').write(
287
"This is a Bazaar-NG control directory.\n"
288
"Do not change any files in this directory.\n")
289
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
290
for d in ('text-store', 'inventory-store', 'revision-store'):
291
os.mkdir(self.controlfilename(d))
292
for f in ('revision-history', 'merged-patches',
293
'pending-merged-patches', 'branch-name',
294
'branch-lock'):
295
self.controlfile(f, 'w').write('')
296
mutter('created control directory in ' + self.base)
297
Inventory().write_xml(self.controlfile('inventory','w'))
298
299
300
def _check_format(self):
301
"""Check this branch format is supported.
302
303
The current tool only supports the current unstable format.
304
305
In the future, we might need different in-memory Branch
306
classes to support downlevel branches. But not yet.
307
"""
308
# This ignores newlines so that we can open branches created
309
# on Windows from Linux and so on. I think it might be better
310
# to always make all internal files in unix format.
311
fmt = self.controlfile('branch-format', 'r').read()
312
fmt.replace('\r\n', '')
313
if fmt != BZR_BRANCH_FORMAT:
314
raise BzrError('sorry, branch format %r not supported' % fmt,
315
['use a different bzr version',
316
'or remove the .bzr directory and "bzr init" again'])
317
318
319
320
def read_working_inventory(self):
321
"""Read the working inventory."""
322
before = time.time()
323
# ElementTree does its own conversion from UTF-8, so open in
324
# binary.
325
self.lock_read()
326
try:
327
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
328
mutter("loaded inventory of %d items in %f"
329
% (len(inv), time.time() - before))
330
return inv
331
finally:
332
self.unlock()
333
334
335
def _write_inventory(self, inv):
336
"""Update the working inventory.
337
338
That is to say, the inventory describing changes underway, that
339
will be committed to the next revision.
340
"""
341
## TODO: factor out to atomicfile? is rename safe on windows?
342
## TODO: Maybe some kind of clean/dirty marker on inventory?
343
tmpfname = self.controlfilename('inventory.tmp')
344
tmpf = file(tmpfname, 'wb')
345
inv.write_xml(tmpf)
346
tmpf.close()
347
inv_fname = self.controlfilename('inventory')
348
if sys.platform == 'win32':
349
os.remove(inv_fname)
350
os.rename(tmpfname, inv_fname)
351
mutter('wrote working inventory')
352
353
354
inventory = property(read_working_inventory, _write_inventory, None,
355
"""Inventory for the working copy.""")
356
357
358
def add(self, files, verbose=False, ids=None):
359
"""Make files versioned.
360
361
Note that the command line normally calls smart_add instead.
362
363
This puts the files in the Added state, so that they will be
364
recorded by the next commit.
365
366
files
367
List of paths to add, relative to the base of the tree.
368
369
ids
370
If set, use these instead of automatically generated ids.
371
Must be the same length as the list of files, but may
372
contain None for ids that are to be autogenerated.
373
374
TODO: Perhaps have an option to add the ids even if the files do
375
not (yet) exist.
376
377
TODO: Perhaps return the ids of the files? But then again it
378
is easy to retrieve them if they're needed.
379
380
TODO: Adding a directory should optionally recurse down and
381
add all non-ignored children. Perhaps do that in a
382
higher-level method.
383
"""
384
# TODO: Re-adding a file that is removed in the working copy
385
# should probably put it back with the previous ID.
386
if isinstance(files, types.StringTypes):
387
assert(ids is None or isinstance(ids, types.StringTypes))
388
files = [files]
389
if ids is not None:
390
ids = [ids]
391
392
if ids is None:
393
ids = [None] * len(files)
394
else:
395
assert(len(ids) == len(files))
396
397
self.lock_write()
398
try:
399
inv = self.read_working_inventory()
400
for f,file_id in zip(files, ids):
401
if is_control_file(f):
402
raise BzrError("cannot add control file %s" % quotefn(f))
403
404
fp = splitpath(f)
405
406
if len(fp) == 0:
407
raise BzrError("cannot add top-level %r" % f)
408
409
fullpath = os.path.normpath(self.abspath(f))
410
411
try:
412
kind = file_kind(fullpath)
413
except OSError:
414
# maybe something better?
415
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
416
417
if kind != 'file' and kind != 'directory':
418
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
419
420
if file_id is None:
421
file_id = gen_file_id(f)
422
inv.add_path(f, kind=kind, file_id=file_id)
423
424
if verbose:
425
show_status('A', kind, quotefn(f))
426
427
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
428
429
self._write_inventory(inv)
430
finally:
431
self.unlock()
432
433
434
def print_file(self, file, revno):
179
"""Return absolute filename for something in the branch
180
181
XXX: Robert Collins 20051017 what is this used for? why is it a branch
182
method and not a tree method.
183
"""
184
raise NotImplementedError('abspath is abstract')
185
186
@needs_write_lock
187
def fetch(self, from_branch, last_revision=None, pb=None):
188
"""Copy revisions from from_branch into this branch.
189
190
:param from_branch: Where to copy from.
191
:param last_revision: What revision to stop at (None for at the end
192
of the branch.
193
:param pb: An optional progress bar to use.
194
195
Returns the copied revision count and the failed revisions in a tuple:
196
(copied, failures).
197
"""
198
if self.base == from_branch.base:
199
raise Exception("can't fetch from a branch to itself %s, %s" %
200
(self.base, to_branch.base))
201
if pb is None:
202
pb = bzrlib.ui.ui_factory.progress_bar()
203
204
from_branch.lock_read()
205
try:
206
if last_revision is None:
207
pb.update('get source history')
208
from_history = from_branch.revision_history()
209
if from_history:
210
last_revision = from_history[-1]
211
else:
212
# no history in the source branch
213
last_revision = NULL_REVISION
214
return self.repository.fetch(from_branch.repository,
215
revision_id=last_revision,
216
pb=pb)
217
finally:
218
from_branch.unlock()
219
220
def get_root_id(self):
221
"""Return the id of this branches root"""
222
raise NotImplementedError('get_root_id is abstract')
223
224
def print_file(self, file, revision_id):
435
225
"""Print `file` to stdout."""
436
self.lock_read()
437
try:
438
tree = self.revision_tree(self.lookup_revision(revno))
439
# use inventory as it was in that revision
440
file_id = tree.inventory.path2id(file)
441
if not file_id:
442
raise BzrError("%r is not present in revision %d" % (file, revno))
443
tree.print_file(file_id)
444
finally:
445
self.unlock()
446
447
448
def remove(self, files, verbose=False):
449
"""Mark nominated files for removal from the inventory.
450
451
This does not remove their text. This does not run on
452
453
TODO: Refuse to remove modified files unless --force is given?
454
455
TODO: Do something useful with directories.
456
457
TODO: Should this remove the text or not? Tough call; not
458
removing may be useful and the user can just use use rm, and
459
is the opposite of add. Removing it is consistent with most
460
other tools. Maybe an option.
461
"""
462
## TODO: Normalize names
463
## TODO: Remove nested loops; better scalability
464
if isinstance(files, types.StringTypes):
465
files = [files]
466
467
self.lock_write()
468
469
try:
470
tree = self.working_tree()
471
inv = tree.inventory
472
473
# do this before any modifications
474
for f in files:
475
fid = inv.path2id(f)
476
if not fid:
477
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
478
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
479
if verbose:
480
# having remove it, it must be either ignored or unknown
481
if tree.is_ignored(f):
482
new_status = 'I'
483
else:
484
new_status = '?'
485
show_status(new_status, inv[fid].kind, quotefn(f))
486
del inv[fid]
487
488
self._write_inventory(inv)
489
finally:
490
self.unlock()
491
492
493
# FIXME: this doesn't need to be a branch method
494
def set_inventory(self, new_inventory_list):
495
inv = Inventory()
496
for path, file_id, parent, kind in new_inventory_list:
497
name = os.path.basename(path)
498
if name == "":
499
continue
500
inv.add(InventoryEntry(file_id, name, kind, parent))
501
self._write_inventory(inv)
502
503
504
def unknowns(self):
505
"""Return all unknown files.
506
507
These are files in the working directory that are not versioned or
508
control files or ignored.
509
510
>>> b = ScratchBranch(files=['foo', 'foo~'])
511
>>> list(b.unknowns())
512
['foo']
513
>>> b.add('foo')
514
>>> list(b.unknowns())
515
[]
516
>>> b.remove('foo')
517
>>> list(b.unknowns())
518
['foo']
519
"""
520
return self.working_tree().unknowns()
521
522
523
def append_revision(self, revision_id):
524
mutter("add {%s} to revision-history" % revision_id)
525
rev_history = self.revision_history()
526
527
tmprhname = self.controlfilename('revision-history.tmp')
528
rhname = self.controlfilename('revision-history')
529
530
f = file(tmprhname, 'wt')
531
rev_history.append(revision_id)
532
f.write('\n'.join(rev_history))
533
f.write('\n')
534
f.close()
535
536
if sys.platform == 'win32':
537
os.remove(rhname)
538
os.rename(tmprhname, rhname)
539
540
541
542
def get_revision(self, revision_id):
543
"""Return the Revision object for a named revision"""
544
if not revision_id or not isinstance(revision_id, basestring):
545
raise ValueError('invalid revision-id: %r' % revision_id)
546
r = Revision.read_xml(self.revision_store[revision_id])
547
assert r.revision_id == revision_id
548
return r
549
550
def get_revision_sha1(self, revision_id):
551
"""Hash the stored value of a revision, and return it."""
552
# In the future, revision entries will be signed. At that
553
# point, it is probably best *not* to include the signature
554
# in the revision hash. Because that lets you re-sign
555
# the revision, (add signatures/remove signatures) and still
556
# have all hash pointers stay consistent.
557
# But for now, just hash the contents.
558
return sha_file(self.revision_store[revision_id])
559
560
561
def get_inventory(self, inventory_id):
562
"""Get Inventory object by hash.
563
564
TODO: Perhaps for this and similar methods, take a revision
565
parameter which can be either an integer revno or a
566
string hash."""
567
i = Inventory.read_xml(self.inventory_store[inventory_id])
568
return i
569
570
def get_inventory_sha1(self, inventory_id):
571
"""Return the sha1 hash of the inventory entry
572
"""
573
return sha_file(self.inventory_store[inventory_id])
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
226
raise NotImplementedError('print_file is abstract')
227
228
def append_revision(self, *revision_ids):
229
raise NotImplementedError('append_revision is abstract')
230
231
def set_revision_history(self, rev_history):
232
raise NotImplementedError('set_revision_history is abstract')
583
233
584
234
def revision_history(self):
585
"""Return sequence of revision hashes on to this branch.
586
587
>>> ScratchBranch().revision_history()
588
[]
589
"""
590
self.lock_read()
591
try:
592
return [l.rstrip('\r\n') for l in
593
self.controlfile('revision-history', 'r').readlines()]
594
finally:
595
self.unlock()
596
597
598
def common_ancestor(self, other, self_revno=None, other_revno=None):
599
"""
600
>>> import commit
601
>>> sb = ScratchBranch(files=['foo', 'foo~'])
602
>>> sb.common_ancestor(sb) == (None, None)
603
True
604
>>> commit.commit(sb, "Committing first revision", verbose=False)
605
>>> sb.common_ancestor(sb)[0]
606
1
607
>>> clone = sb.clone()
608
>>> commit.commit(sb, "Committing second revision", verbose=False)
609
>>> sb.common_ancestor(sb)[0]
610
2
611
>>> sb.common_ancestor(clone)[0]
612
1
613
>>> commit.commit(clone, "Committing divergent second revision",
614
... verbose=False)
615
>>> sb.common_ancestor(clone)[0]
616
1
617
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
618
True
619
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
620
True
621
>>> clone2 = sb.clone()
622
>>> sb.common_ancestor(clone2)[0]
623
2
624
>>> sb.common_ancestor(clone2, self_revno=1)[0]
625
1
626
>>> sb.common_ancestor(clone2, other_revno=1)[0]
627
1
628
"""
629
my_history = self.revision_history()
630
other_history = other.revision_history()
631
if self_revno is None:
632
self_revno = len(my_history)
633
if other_revno is None:
634
other_revno = len(other_history)
635
indices = range(min((self_revno, other_revno)))
636
indices.reverse()
637
for r in indices:
638
if my_history[r] == other_history[r]:
639
return r+1, my_history[r]
640
return None, None
641
642
def enum_history(self, direction):
643
"""Return (revno, revision_id) for history of branch.
644
645
direction
646
'forward' is from earliest to latest
647
'reverse' is from latest to earliest
648
"""
649
rh = self.revision_history()
650
if direction == 'forward':
651
i = 1
652
for rid in rh:
653
yield i, rid
654
i += 1
655
elif direction == 'reverse':
656
i = len(rh)
657
while i > 0:
658
yield i, rh[i-1]
659
i -= 1
660
else:
661
raise ValueError('invalid history direction', direction)
662
235
"""Return sequence of revision hashes on to this branch."""
236
raise NotImplementedError('revision_history is abstract')
663
237
664
238
def revno(self):
665
239
"""Return current revision number for this branch.
669
243
"""
670
244
return len(self.revision_history())
671
245
672
673
def last_patch(self):
674
"""Return last patch hash, or None if no history.
675
"""
246
def last_revision(self):
247
"""Return last patch hash, or None if no history."""
676
248
ph = self.revision_history()
677
249
if ph:
678
250
return ph[-1]
679
251
else:
680
252
return None
681
253
682
683
def missing_revisions(self, other, stop_revision=None):
684
"""
254
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
255
"""Return a list of new revisions that would perfectly fit.
256
685
257
If self and other have not diverged, return a list of the revisions
686
258
present in other, but missing from self.
687
259
688
>>> from bzrlib.commit import commit
260
>>> from bzrlib.workingtree import WorkingTree
689
261
>>> bzrlib.trace.silent = True
690
>>> br1 = ScratchBranch()
691
>>> br2 = ScratchBranch()
262
>>> d1 = bzrdir.ScratchDir()
263
>>> br1 = d1.open_branch()
264
>>> wt1 = d1.open_workingtree()
265
>>> d2 = bzrdir.ScratchDir()
266
>>> br2 = d2.open_branch()
267
>>> wt2 = d2.open_workingtree()
692
268
>>> br1.missing_revisions(br2)
693
269
[]
694
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
270
>>> wt2.commit("lala!", rev_id="REVISION-ID-1")
695
271
>>> br1.missing_revisions(br2)
696
272
[u'REVISION-ID-1']
697
273
>>> br2.missing_revisions(br1)
698
274
[]
699
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
275
>>> wt1.commit("lala!", rev_id="REVISION-ID-1")
700
276
>>> br1.missing_revisions(br2)
701
277
[]
702
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
278
>>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
703
279
>>> br1.missing_revisions(br2)
704
280
[u'REVISION-ID-2A']
705
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
281
>>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
706
282
>>> br1.missing_revisions(br2)
707
283
Traceback (most recent call last):
708
DivergedBranches: These branches have diverged.
284
DivergedBranches: These branches have diverged. Try merge.
709
285
"""
710
286
self_history = self.revision_history()
711
287
self_len = len(self_history)
718
294
719
295
if stop_revision is None:
720
296
stop_revision = other_len
721
elif stop_revision > other_len:
722
raise NoSuchRevision(self, stop_revision)
723
297
else:
298
assert isinstance(stop_revision, int)
299
if stop_revision > other_len:
300
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
724
301
return other_history[self_len:stop_revision]
725
302
726
727
303
def update_revisions(self, other, stop_revision=None):
728
"""Pull in all new revisions from other branch.
729
730
>>> from bzrlib.commit import commit
731
>>> bzrlib.trace.silent = True
732
>>> br1 = ScratchBranch(files=['foo', 'bar'])
733
>>> br1.add('foo')
734
>>> br1.add('bar')
735
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
736
>>> br2 = ScratchBranch()
737
>>> br2.update_revisions(br1)
738
Added 2 texts.
739
Added 1 inventories.
740
Added 1 revisions.
741
>>> br2.revision_history()
742
[u'REVISION-ID-1']
743
>>> br2.update_revisions(br1)
744
Added 0 texts.
745
Added 0 inventories.
746
Added 0 revisions.
747
>>> br1.text_store.total_size() == br2.text_store.total_size()
748
True
749
"""
750
from bzrlib.progress import ProgressBar
751
752
pb = ProgressBar()
753
754
pb.update('comparing histories')
755
revision_ids = self.missing_revisions(other, stop_revision)
756
revisions = []
757
needed_texts = sets.Set()
758
i = 0
759
for rev_id in revision_ids:
760
i += 1
761
pb.update('fetching revision', i, len(revision_ids))
762
rev = other.get_revision(rev_id)
763
revisions.append(rev)
764
inv = other.get_inventory(str(rev.inventory_id))
765
for key, entry in inv.iter_entries():
766
if entry.text_id is None:
767
continue
768
if entry.text_id not in self.text_store:
769
needed_texts.add(entry.text_id)
770
771
pb.clear()
772
773
count = self.text_store.copy_multi(other.text_store, needed_texts)
774
print "Added %d texts." % count
775
inventory_ids = [ f.inventory_id for f in revisions ]
776
count = self.inventory_store.copy_multi(other.inventory_store,
777
inventory_ids)
778
print "Added %d inventories." % count
779
revision_ids = [ f.revision_id for f in revisions]
780
count = self.revision_store.copy_multi(other.revision_store,
781
revision_ids)
782
for revision_id in revision_ids:
783
self.append_revision(revision_id)
784
print "Added %d revisions." % count
785
786
787
def commit(self, *args, **kw):
788
"""Deprecated"""
789
from bzrlib.commit import commit
790
commit(self, *args, **kw)
791
792
793
def lookup_revision(self, revno):
794
"""Return revision hash for revision number."""
304
"""Pull in new perfect-fit revisions."""
305
raise NotImplementedError('update_revisions is abstract')
306
307
def pullable_revisions(self, other, stop_revision):
308
raise NotImplementedError('pullable_revisions is abstract')
309
310
def revision_id_to_revno(self, revision_id):
311
"""Given a revision id, return its revno"""
312
if revision_id is None:
313
return 0
314
history = self.revision_history()
315
try:
316
return history.index(revision_id) + 1
317
except ValueError:
318
raise bzrlib.errors.NoSuchRevision(self, revision_id)
319
320
def get_rev_id(self, revno, history=None):
321
"""Find the revision id of the specified revno."""
795
322
if revno == 0:
796
323
return None
797
798
try:
799
# list is 0-based; revisions are 1-based
800
return self.revision_history()[revno-1]
801
except IndexError:
802
raise BzrError("no such revision %s" % revno)
803
804
805
def revision_tree(self, revision_id):
806
"""Return Tree for a revision on this branch.
807
808
`revision_id` may be None for the null revision, in which case
809
an `EmptyTree` is returned."""
810
# TODO: refactor this to use an existing revision object
811
# so we don't need to read it in twice.
812
if revision_id == None:
813
return EmptyTree()
814
else:
815
inv = self.get_revision_inventory(revision_id)
816
return RevisionTree(self.text_store, inv)
817
818
819
def working_tree(self):
820
"""Return a `Tree` for the working copy."""
821
from workingtree import WorkingTree
822
return WorkingTree(self.base, self.read_working_inventory())
823
324
if history is None:
325
history = self.revision_history()
326
elif revno <= 0 or revno > len(history):
327
raise bzrlib.errors.NoSuchRevision(self, revno)
328
return history[revno - 1]
329
330
def pull(self, source, overwrite=False, stop_revision=None):
331
raise NotImplementedError('pull is abstract')
824
332
825
333
def basis_tree(self):
826
334
"""Return `Tree` object for last revision.
827
335
828
336
If there are no revisions yet, return an `EmptyTree`.
829
337
"""
830
r = self.last_patch()
831
if r == None:
832
return EmptyTree()
833
else:
834
return RevisionTree(self.text_store, self.get_revision_inventory(r))
835
836
338
return self.repository.revision_tree(self.last_revision())
837
339
838
340
def rename_one(self, from_rel, to_rel):
839
341
"""Rename one file.
840
342
841
343
This can change the directory or the filename or both.
842
344
"""
843
self.lock_write()
844
try:
845
tree = self.working_tree()
846
inv = tree.inventory
847
if not tree.has_filename(from_rel):
848
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
849
if tree.has_filename(to_rel):
850
raise BzrError("can't rename: new working file %r already exists" % to_rel)
851
852
file_id = inv.path2id(from_rel)
853
if file_id == None:
854
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
855
856
if inv.path2id(to_rel):
857
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
858
859
to_dir, to_tail = os.path.split(to_rel)
860
to_dir_id = inv.path2id(to_dir)
861
if to_dir_id == None and to_dir != '':
862
raise BzrError("can't determine destination directory id for %r" % to_dir)
863
864
mutter("rename_one:")
865
mutter(" file_id {%s}" % file_id)
866
mutter(" from_rel %r" % from_rel)
867
mutter(" to_rel %r" % to_rel)
868
mutter(" to_dir %r" % to_dir)
869
mutter(" to_dir_id {%s}" % to_dir_id)
870
871
inv.rename(file_id, to_dir_id, to_tail)
872
873
print "%s => %s" % (from_rel, to_rel)
874
875
from_abs = self.abspath(from_rel)
876
to_abs = self.abspath(to_rel)
877
try:
878
os.rename(from_abs, to_abs)
879
except OSError, e:
880
raise BzrError("failed to rename %r to %r: %s"
881
% (from_abs, to_abs, e[1]),
882
["rename rolled back"])
883
884
self._write_inventory(inv)
885
finally:
886
self.unlock()
887
345
raise NotImplementedError('rename_one is abstract')
888
346
889
347
def move(self, from_paths, to_name):
890
348
"""Rename files.
896
354
897
355
Note that to_name is only the last component of the new name;
898
356
this doesn't change the directory.
899
"""
900
self.lock_write()
901
try:
902
## TODO: Option to move IDs only
903
assert not isinstance(from_paths, basestring)
904
tree = self.working_tree()
905
inv = tree.inventory
906
to_abs = self.abspath(to_name)
907
if not isdir(to_abs):
908
raise BzrError("destination %r is not a directory" % to_abs)
909
if not tree.has_filename(to_name):
910
raise BzrError("destination %r not in working directory" % to_abs)
911
to_dir_id = inv.path2id(to_name)
912
if to_dir_id == None and to_name != '':
913
raise BzrError("destination %r is not a versioned directory" % to_name)
914
to_dir_ie = inv[to_dir_id]
915
if to_dir_ie.kind not in ('directory', 'root_directory'):
916
raise BzrError("destination %r is not a directory" % to_abs)
917
918
to_idpath = inv.get_idpath(to_dir_id)
919
920
for f in from_paths:
921
if not tree.has_filename(f):
922
raise BzrError("%r does not exist in working tree" % f)
923
f_id = inv.path2id(f)
924
if f_id == None:
925
raise BzrError("%r is not versioned" % f)
926
name_tail = splitpath(f)[-1]
927
dest_path = appendpath(to_name, name_tail)
928
if tree.has_filename(dest_path):
929
raise BzrError("destination %r already exists" % dest_path)
930
if f_id in to_idpath:
931
raise BzrError("can't move %r to a subdirectory of itself" % f)
932
933
# OK, so there's a race here, it's possible that someone will
934
# create a file in this interval and then the rename might be
935
# left half-done. But we should have caught most problems.
936
937
for f in from_paths:
938
name_tail = splitpath(f)[-1]
939
dest_path = appendpath(to_name, name_tail)
940
print "%s => %s" % (f, dest_path)
941
inv.rename(inv.path2id(f), to_dir_id, name_tail)
942
try:
943
os.rename(self.abspath(f), self.abspath(dest_path))
944
except OSError, e:
945
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
946
["rename rolled back"])
947
948
self._write_inventory(inv)
949
finally:
950
self.unlock()
951
952
953
954
class ScratchBranch(Branch):
955
"""Special test class: a branch that cleans up after itself.
956
957
>>> b = ScratchBranch()
958
>>> isdir(b.base)
959
True
960
>>> bd = b.base
961
>>> b.destroy()
962
>>> isdir(bd)
963
False
964
"""
965
def __init__(self, files=[], dirs=[], base=None):
966
"""Make a test branch.
967
968
This creates a temporary directory and runs init-tree in it.
969
970
If any files are listed, they are created in the working copy.
971
"""
972
init = False
973
if base is None:
974
base = tempfile.mkdtemp()
975
init = True
976
Branch.__init__(self, base, init=init)
977
for d in dirs:
978
os.mkdir(self.abspath(d))
357
358
This returns a list of (from_path, to_path) pairs for each
359
entry that is moved.
360
"""
361
raise NotImplementedError('move is abstract')
362
363
def get_parent(self):
364
"""Return the parent location of the branch.
365
366
This is the default location for push/pull/missing. The usual
367
pattern is that the user can override it by specifying a
368
location.
369
"""
370
raise NotImplementedError('get_parent is abstract')
371
372
def get_push_location(self):
373
"""Return the None or the location to push this branch to."""
374
raise NotImplementedError('get_push_location is abstract')
375
376
def set_push_location(self, location):
377
"""Set a new push location for this branch."""
378
raise NotImplementedError('set_push_location is abstract')
379
380
def set_parent(self, url):
381
raise NotImplementedError('set_parent is abstract')
382
383
def check_revno(self, revno):
384
"""\
385
Check whether a revno corresponds to any revision.
386
Zero (the NULL revision) is considered valid.
387
"""
388
if revno != 0:
389
self.check_real_revno(revno)
979
390
980
for f in files:
981
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
982
983
984
def clone(self):
985
"""
986
>>> orig = ScratchBranch(files=["file1", "file2"])
987
>>> clone = orig.clone()
988
>>> os.path.samefile(orig.base, clone.base)
989
False
990
>>> os.path.isfile(os.path.join(clone.base, "file1"))
991
True
992
"""
993
base = tempfile.mkdtemp()
994
os.rmdir(base)
995
shutil.copytree(self.base, base, symlinks=True)
996
return ScratchBranch(base=base)
997
391
def check_real_revno(self, revno):
392
"""\
393
Check whether a revno corresponds to a real revision.
394
Zero (the NULL revision) is considered invalid
395
"""
396
if revno < 1 or revno > self.revno():
397
raise InvalidRevisionNumber(revno)
398
399
@needs_read_lock
400
def clone(self, *args, **kwargs):
401
"""Clone this branch into to_bzrdir preserving all semantic values.
402
403
revision_id: if not None, the revision history in the new branch will
404
be truncated to end with revision_id.
405
"""
406
# for API compatability, until 0.8 releases we provide the old api:
407
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
408
# after 0.8 releases, the *args and **kwargs should be changed:
409
# def clone(self, to_bzrdir, revision_id=None):
410
if (kwargs.get('to_location', None) or
411
kwargs.get('revision', None) or
412
kwargs.get('basis_branch', None) or
413
(len(args) and isinstance(args[0], basestring))):
414
# backwards compatability api:
415
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
416
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
417
# get basis_branch
418
if len(args) > 2:
419
basis_branch = args[2]
420
else:
421
basis_branch = kwargs.get('basis_branch', None)
422
if basis_branch:
423
basis = basis_branch.bzrdir
424
else:
425
basis = None
426
# get revision
427
if len(args) > 1:
428
revision_id = args[1]
429
else:
430
revision_id = kwargs.get('revision', None)
431
# get location
432
if len(args):
433
url = args[0]
434
else:
435
# no default to raise if not provided.
436
url = kwargs.get('to_location')
437
return self.bzrdir.clone(url,
438
revision_id=revision_id,
439
basis=basis).open_branch()
440
# new cleaner api.
441
# generate args by hand
442
if len(args) > 1:
443
revision_id = args[1]
444
else:
445
revision_id = kwargs.get('revision_id', None)
446
if len(args):
447
to_bzrdir = args[0]
448
else:
449
# no default to raise if not provided.
450
to_bzrdir = kwargs.get('to_bzrdir')
451
result = self._format.initialize(to_bzrdir)
452
self.copy_content_into(result, revision_id=revision_id)
453
return result
454
455
@needs_read_lock
456
def sprout(self, to_bzrdir, revision_id=None):
457
"""Create a new line of development from the branch, into to_bzrdir.
458
459
revision_id: if not None, the revision history in the new branch will
460
be truncated to end with revision_id.
461
"""
462
result = self._format.initialize(to_bzrdir)
463
self.copy_content_into(result, revision_id=revision_id)
464
result.set_parent(self.bzrdir.root_transport.base)
465
return result
466
467
@needs_read_lock
468
def copy_content_into(self, destination, revision_id=None):
469
"""Copy the content of self into destination.
470
471
revision_id: if not None, the revision history in the new branch will
472
be truncated to end with revision_id.
473
"""
474
new_history = self.revision_history()
475
if revision_id is not None:
476
try:
477
new_history = new_history[:new_history.index(revision_id) + 1]
478
except ValueError:
479
rev = self.repository.get_revision(revision_id)
480
new_history = rev.get_history(self.repository)[1:]
481
destination.set_revision_history(new_history)
482
parent = self.get_parent()
483
if parent:
484
destination.set_parent(parent)
485
486
487
class BranchFormat(object):
488
"""An encapsulation of the initialization and open routines for a format.
489
490
Formats provide three things:
491
* An initialization routine,
492
* a format string,
493
* an open routine.
494
495
Formats are placed in an dict by their format string for reference
496
during branch opening. Its not required that these be instances, they
497
can be classes themselves with class methods - it simply depends on
498
whether state is needed for a given format or not.
499
500
Once a format is deprecated, just deprecate the initialize and open
501
methods on the format class. Do not deprecate the object, as the
502
object will be created every time regardless.
503
"""
504
505
_default_format = None
506
"""The default format used for new branches."""
507
508
_formats = {}
509
"""The known formats."""
510
511
@classmethod
512
def find_format(klass, a_bzrdir):
513
"""Return the format for the branch object in a_bzrdir."""
514
try:
515
transport = a_bzrdir.get_branch_transport(None)
516
format_string = transport.get("format").read()
517
return klass._formats[format_string]
518
except NoSuchFile:
519
raise NotBranchError(path=transport.base)
520
except KeyError:
521
raise errors.UnknownFormatError(format_string)
522
523
@classmethod
524
def get_default_format(klass):
525
"""Return the current default format."""
526
return klass._default_format
527
528
def get_format_string(self):
529
"""Return the ASCII format string that identifies this format."""
530
raise NotImplementedError(self.get_format_string)
531
532
def initialize(self, a_bzrdir):
533
"""Create a branch of this format in a_bzrdir."""
534
raise NotImplementedError(self.initialized)
535
536
def is_supported(self):
537
"""Is this format supported?
538
539
Supported formats can be initialized and opened.
540
Unsupported formats may not support initialization or committing or
541
some other features depending on the reason for not being supported.
542
"""
543
return True
544
545
def open(self, a_bzrdir, _found=False):
546
"""Return the branch object for a_bzrdir
547
548
_found is a private parameter, do not use it. It is used to indicate
549
if format probing has already be done.
550
"""
551
raise NotImplementedError(self.open)
552
553
@classmethod
554
def register_format(klass, format):
555
klass._formats[format.get_format_string()] = format
556
557
@classmethod
558
def set_default_format(klass, format):
559
klass._default_format = format
560
561
@classmethod
562
def unregister_format(klass, format):
563
assert klass._formats[format.get_format_string()] is format
564
del klass._formats[format.get_format_string()]
565
566
567
class BzrBranchFormat4(BranchFormat):
568
"""Bzr branch format 4.
569
570
This format has:
571
- a revision-history file.
572
- a branch-lock lock file [ to be shared with the bzrdir ]
573
"""
574
575
def initialize(self, a_bzrdir):
576
"""Create a branch of this format in a_bzrdir."""
577
mutter('creating branch in %s', a_bzrdir.transport.base)
578
branch_transport = a_bzrdir.get_branch_transport(self)
579
utf8_files = [('revision-history', ''),
580
('branch-name', ''),
581
]
582
control_files = LockableFiles(branch_transport, 'branch-lock')
583
control_files.lock_write()
584
try:
585
for file, content in utf8_files:
586
control_files.put_utf8(file, content)
587
finally:
588
control_files.unlock()
589
return self.open(a_bzrdir, _found=True)
590
591
def __init__(self):
592
super(BzrBranchFormat4, self).__init__()
593
self._matchingbzrdir = bzrdir.BzrDirFormat6()
594
595
def open(self, a_bzrdir, _found=False):
596
"""Return the branch object for a_bzrdir
597
598
_found is a private parameter, do not use it. It is used to indicate
599
if format probing has already be done.
600
"""
601
if not _found:
602
# we are being called directly and must probe.
603
raise NotImplementedError
604
return BzrBranch(_format=self,
605
_control_files=a_bzrdir._control_files,
606
a_bzrdir=a_bzrdir,
607
_repository=a_bzrdir.open_repository())
608
609
610
class BzrBranchFormat5(BranchFormat):
611
"""Bzr branch format 5.
612
613
This format has:
614
- a revision-history file.
615
- a format string
616
- a lock file.
617
- works with shared repositories.
618
"""
619
620
def get_format_string(self):
621
"""See BranchFormat.get_format_string()."""
622
return "Bazaar-NG branch format 5\n"
623
624
def initialize(self, a_bzrdir):
625
"""Create a branch of this format in a_bzrdir."""
626
mutter('creating branch in %s', a_bzrdir.transport.base)
627
branch_transport = a_bzrdir.get_branch_transport(self)
628
629
utf8_files = [('revision-history', ''),
630
('branch-name', ''),
631
]
632
lock_file = 'lock'
633
branch_transport.put(lock_file, StringIO()) # TODO get the file mode from the bzrdir lock files., mode=file_mode)
634
control_files = LockableFiles(branch_transport, 'lock')
635
control_files.lock_write()
636
control_files.put_utf8('format', self.get_format_string())
637
try:
638
for file, content in utf8_files:
639
control_files.put_utf8(file, content)
640
finally:
641
control_files.unlock()
642
return self.open(a_bzrdir, _found=True, )
643
644
def __init__(self):
645
super(BzrBranchFormat5, self).__init__()
646
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
647
648
def open(self, a_bzrdir, _found=False):
649
"""Return the branch object for a_bzrdir
650
651
_found is a private parameter, do not use it. It is used to indicate
652
if format probing has already be done.
653
"""
654
if not _found:
655
format = BranchFormat.find_format(a_bzrdir)
656
assert format.__class__ == self.__class__
657
transport = a_bzrdir.get_branch_transport(None)
658
control_files = LockableFiles(transport, 'lock')
659
return BzrBranch(_format=self,
660
_control_files=control_files,
661
a_bzrdir=a_bzrdir,
662
_repository=a_bzrdir.find_repository())
663
664
665
class BranchReferenceFormat(BranchFormat):
666
"""Bzr branch reference format.
667
668
Branch references are used in implementing checkouts, they
669
act as an alias to the real branch which is at some other url.
670
671
This format has:
672
- A location file
673
- a format string
674
"""
675
676
def get_format_string(self):
677
"""See BranchFormat.get_format_string()."""
678
return "Bazaar-NG Branch Reference Format 1\n"
679
680
def initialize(self, a_bzrdir, target_branch=None):
681
"""Create a branch of this format in a_bzrdir."""
682
if target_branch is None:
683
# this format does not implement branch itself, thus the implicit
684
# creation contract must see it as uninitializable
685
raise errors.UninitializableFormat(self)
686
mutter('creating branch reference in %s', a_bzrdir.transport.base)
687
branch_transport = a_bzrdir.get_branch_transport(self)
688
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
689
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
690
branch_transport.put('format', StringIO(self.get_format_string()))
691
return self.open(a_bzrdir, _found=True)
692
693
def __init__(self):
694
super(BranchReferenceFormat, self).__init__()
695
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
696
697
def _make_reference_clone_function(format, a_branch):
698
"""Create a clone() routine for a branch dynamically."""
699
def clone(to_bzrdir, revision_id=None):
700
"""See Branch.clone()."""
701
return format.initialize(to_bzrdir, a_branch)
702
# cannot obey revision_id limits when cloning a reference ...
703
# FIXME RBC 20060210 either nuke revision_id for clone, or
704
# emit some sort of warning/error to the caller ?!
705
return clone
706
707
def open(self, a_bzrdir, _found=False):
708
"""Return the branch that the branch reference in a_bzrdir points at.
709
710
_found is a private parameter, do not use it. It is used to indicate
711
if format probing has already be done.
712
"""
713
if not _found:
714
format = BranchFormat.find_format(a_bzrdir)
715
assert format.__class__ == self.__class__
716
transport = a_bzrdir.get_branch_transport(None)
717
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
718
result = real_bzrdir.open_branch()
719
# this changes the behaviour of result.clone to create a new reference
720
# rather than a copy of the content of the branch.
721
# I did not use a proxy object because that needs much more extensive
722
# testing, and we are only changing one behaviour at the moment.
723
# If we decide to alter more behaviours - i.e. the implicit nickname
724
# then this should be refactored to introduce a tested proxy branch
725
# and a subclass of that for use in overriding clone() and ....
726
# - RBC 20060210
727
result.clone = self._make_reference_clone_function(result)
728
return result
729
730
731
# formats which have no format string are not discoverable
732
# and not independently creatable, so are not registered.
733
__default_format = BzrBranchFormat5()
734
BranchFormat.register_format(__default_format)
735
BranchFormat.register_format(BranchReferenceFormat())
736
BranchFormat.set_default_format(__default_format)
737
_legacy_formats = [BzrBranchFormat4(),
738
]
739
740
class BzrBranch(Branch):
741
"""A branch stored in the actual filesystem.
742
743
Note that it's "local" in the context of the filesystem; it doesn't
744
really matter if it's on an nfs/smb/afs/coda/... share, as long as
745
it's writable, and can be accessed via the normal filesystem API.
746
"""
747
# We actually expect this class to be somewhat short-lived; part of its
748
# purpose is to try to isolate what bits of the branch logic are tied to
749
# filesystem access, so that in a later step, we can extricate them to
750
# a separarte ("storage") class.
751
_inventory_weave = None
752
753
# Map some sort of prefix into a namespace
754
# stuff like "revno:10", "revid:", etc.
755
# This should match a prefix with a function which accepts
756
REVISION_NAMESPACES = {}
757
758
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
759
relax_version_check=DEPRECATED_PARAMETER, _format=None,
760
_control_files=None, a_bzrdir=None, _repository=None):
761
"""Create new branch object at a particular location.
762
763
transport -- A Transport object, defining how to access files.
764
765
init -- If True, create new control files in a previously
766
unversioned directory. If False, the branch must already
767
be versioned.
768
769
relax_version_check -- If true, the usual check for the branch
770
version is not applied. This is intended only for
771
upgrade/recovery type use; it's not guaranteed that
772
all operations will work on old format branches.
773
"""
774
if a_bzrdir is None:
775
self.bzrdir = bzrdir.BzrDir.open(transport.base)
776
else:
777
self.bzrdir = a_bzrdir
778
self._transport = self.bzrdir.transport.clone('..')
779
self._base = self._transport.base
780
self._format = _format
781
if _control_files is None:
782
raise BzrBadParameterMissing('_control_files')
783
self.control_files = _control_files
784
if deprecated_passed(init):
785
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
786
"deprecated as of bzr 0.8. Please use Branch.create().",
787
DeprecationWarning,
788
stacklevel=2)
789
if init:
790
# this is slower than before deprecation, oh well never mind.
791
# -> its deprecated.
792
self._initialize(transport.base)
793
self._check_format(_format)
794
if deprecated_passed(relax_version_check):
795
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
796
"relax_version_check parameter is deprecated as of bzr 0.8. "
797
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
798
"open() method.",
799
DeprecationWarning,
800
stacklevel=2)
801
if (not relax_version_check
802
and not self._format.is_supported()):
803
raise errors.UnsupportedFormatError(
804
'sorry, branch format %r not supported' % fmt,
805
['use a different bzr version',
806
'or remove the .bzr directory'
807
' and "bzr init" again'])
808
if deprecated_passed(transport):
809
warn("BzrBranch.__init__(transport=XXX...): The transport "
810
"parameter is deprecated as of bzr 0.8. "
811
"Please use Branch.open, or bzrdir.open_branch().",
812
DeprecationWarning,
813
stacklevel=2)
814
self.repository = _repository
815
816
def __str__(self):
817
return '%s(%r)' % (self.__class__.__name__, self.base)
818
819
__repr__ = __str__
820
998
821
def __del__(self):
999
self.destroy()
1000
1001
def destroy(self):
1002
"""Destroy the test branch, removing the scratch directory."""
1003
try:
1004
if self.base:
1005
mutter("delete ScratchBranch %s" % self.base)
1006
shutil.rmtree(self.base)
1007
except OSError, e:
1008
# Work around for shutil.rmtree failing on Windows when
1009
# readonly files are encountered
1010
mutter("hit exception in destroying ScratchBranch: %s" % e)
1011
for root, dirs, files in os.walk(self.base, topdown=False):
1012
for name in files:
1013
os.chmod(os.path.join(root, name), 0700)
1014
shutil.rmtree(self.base)
1015
self.base = None
1016
822
# TODO: It might be best to do this somewhere else,
823
# but it is nice for a Branch object to automatically
824
# cache it's information.
825
# Alternatively, we could have the Transport objects cache requests
826
# See the earlier discussion about how major objects (like Branch)
827
# should never expect their __del__ function to run.
828
# XXX: cache_root seems to be unused, 2006-01-13 mbp
829
if hasattr(self, 'cache_root') and self.cache_root is not None:
830
try:
831
shutil.rmtree(self.cache_root)
832
except:
833
pass
834
self.cache_root = None
835
836
def _get_base(self):
837
return self._base
838
839
base = property(_get_base, doc="The URL for the root of this branch.")
840
841
def _finish_transaction(self):
842
"""Exit the current transaction."""
843
return self.control_files._finish_transaction()
844
845
def get_transaction(self):
846
"""Return the current active transaction.
847
848
If no transaction is active, this returns a passthrough object
849
for which all data is immediately flushed and no caching happens.
850
"""
851
# this is an explicit function so that we can do tricky stuff
852
# when the storage in rev_storage is elsewhere.
853
# we probably need to hook the two 'lock a location' and
854
# 'have a transaction' together more delicately, so that
855
# we can have two locks (branch and storage) and one transaction
856
# ... and finishing the transaction unlocks both, but unlocking
857
# does not. - RBC 20051121
858
return self.control_files.get_transaction()
859
860
def _set_transaction(self, transaction):
861
"""Set a new active transaction."""
862
return self.control_files._set_transaction(transaction)
863
864
def abspath(self, name):
865
"""See Branch.abspath."""
866
return self.control_files._transport.abspath(name)
867
868
def _check_format(self, format):
869
"""Identify the branch format if needed.
870
871
The format is stored as a reference to the format object in
872
self._format for code that needs to check it later.
873
874
The format parameter is either None or the branch format class
875
used to open this branch.
876
877
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
878
"""
879
if format is None:
880
format = BzrBranchFormat.find_format(self.bzrdir)
881
self._format = format
882
mutter("got branch format %s", self._format)
883
884
@needs_read_lock
885
def get_root_id(self):
886
"""See Branch.get_root_id."""
887
tree = self.repository.revision_tree(self.last_revision())
888
return tree.inventory.root.file_id
889
890
def lock_write(self):
891
# TODO: test for failed two phase locks. This is known broken.
892
self.control_files.lock_write()
893
self.repository.lock_write()
894
895
def lock_read(self):
896
# TODO: test for failed two phase locks. This is known broken.
897
self.control_files.lock_read()
898
self.repository.lock_read()
899
900
def unlock(self):
901
# TODO: test for failed two phase locks. This is known broken.
902
self.repository.unlock()
903
self.control_files.unlock()
904
905
def peek_lock_mode(self):
906
if self.control_files._lock_count == 0:
907
return None
908
else:
909
return self.control_files._lock_mode
910
911
@needs_read_lock
912
def print_file(self, file, revision_id):
913
"""See Branch.print_file."""
914
return self.repository.print_file(file, revision_id)
915
916
@needs_write_lock
917
def append_revision(self, *revision_ids):
918
"""See Branch.append_revision."""
919
for revision_id in revision_ids:
920
mutter("add {%s} to revision-history" % revision_id)
921
rev_history = self.revision_history()
922
rev_history.extend(revision_ids)
923
self.set_revision_history(rev_history)
924
925
@needs_write_lock
926
def set_revision_history(self, rev_history):
927
"""See Branch.set_revision_history."""
928
self.control_files.put_utf8(
929
'revision-history', '\n'.join(rev_history))
930
931
def get_revision_delta(self, revno):
932
"""Return the delta for one revision.
933
934
The delta is relative to its mainline predecessor, or the
935
empty tree for revision 1.
936
"""
937
assert isinstance(revno, int)
938
rh = self.revision_history()
939
if not (1 <= revno <= len(rh)):
940
raise InvalidRevisionNumber(revno)
941
942
# revno is 1-based; list is 0-based
943
944
new_tree = self.repository.revision_tree(rh[revno-1])
945
if revno == 1:
946
old_tree = EmptyTree()
947
else:
948
old_tree = self.repository.revision_tree(rh[revno-2])
949
return compare_trees(old_tree, new_tree)
950
951
@needs_read_lock
952
def revision_history(self):
953
"""See Branch.revision_history."""
954
# FIXME are transactions bound to control files ? RBC 20051121
955
transaction = self.get_transaction()
956
history = transaction.map.find_revision_history()
957
if history is not None:
958
mutter("cache hit for revision-history in %s", self)
959
return list(history)
960
history = [l.rstrip('\r\n') for l in
961
self.control_files.get_utf8('revision-history').readlines()]
962
transaction.map.add_revision_history(history)
963
# this call is disabled because revision_history is
964
# not really an object yet, and the transaction is for objects.
965
# transaction.register_clean(history, precious=True)
966
return list(history)
967
968
def update_revisions(self, other, stop_revision=None):
969
"""See Branch.update_revisions."""
970
if stop_revision is None:
971
stop_revision = other.last_revision()
972
### Should this be checking is_ancestor instead of revision_history?
973
if (stop_revision is not None and
974
stop_revision in self.revision_history()):
975
return
976
self.fetch(other, stop_revision)
977
pullable_revs = self.pullable_revisions(other, stop_revision)
978
if len(pullable_revs) > 0:
979
self.append_revision(*pullable_revs)
980
981
def pullable_revisions(self, other, stop_revision):
982
"""See Branch.pullable_revisions."""
983
other_revno = other.revision_id_to_revno(stop_revision)
984
try:
985
return self.missing_revisions(other, other_revno)
986
except DivergedBranches, e:
987
try:
988
pullable_revs = get_intervening_revisions(self.last_revision(),
989
stop_revision,
990
self.repository)
991
assert self.last_revision() not in pullable_revs
992
return pullable_revs
993
except bzrlib.errors.NotAncestor:
994
if is_ancestor(self.last_revision(), stop_revision, self):
995
return []
996
else:
997
raise e
998
999
def basis_tree(self):
1000
"""See Branch.basis_tree."""
1001
return self.repository.revision_tree(self.last_revision())
1002
1003
@deprecated_method(zero_eight)
1004
def working_tree(self):
1005
"""Create a Working tree object for this branch."""
1006
from bzrlib.workingtree import WorkingTree
1007
from bzrlib.transport.local import LocalTransport
1008
if (self.base.find('://') != -1 or
1009
not isinstance(self._transport, LocalTransport)):
1010
raise NoWorkingTree(self.base)
1011
return self.bzrdir.open_workingtree()
1012
1013
@needs_write_lock
1014
def pull(self, source, overwrite=False, stop_revision=None):
1015
"""See Branch.pull."""
1016
source.lock_read()
1017
try:
1018
old_count = len(self.revision_history())
1019
try:
1020
self.update_revisions(source,stop_revision)
1021
except DivergedBranches:
1022
if not overwrite:
1023
raise
1024
if overwrite:
1025
self.set_revision_history(source.revision_history())
1026
new_count = len(self.revision_history())
1027
return new_count - old_count
1028
finally:
1029
source.unlock()
1030
1031
def get_parent(self):
1032
"""See Branch.get_parent."""
1033
import errno
1034
_locs = ['parent', 'pull', 'x-pull']
1035
for l in _locs:
1036
try:
1037
return self.control_files.get_utf8(l).read().strip('\n')
1038
except NoSuchFile:
1039
pass
1040
return None
1041
1042
def get_push_location(self):
1043
"""See Branch.get_push_location."""
1044
config = bzrlib.config.BranchConfig(self)
1045
push_loc = config.get_user_option('push_location')
1046
return push_loc
1047
1048
def set_push_location(self, location):
1049
"""See Branch.set_push_location."""
1050
config = bzrlib.config.LocationConfig(self.base)
1051
config.set_user_option('push_location', location)
1052
1053
@needs_write_lock
1054
def set_parent(self, url):
1055
"""See Branch.set_parent."""
1056
# TODO: Maybe delete old location files?
1057
# URLs should never be unicode, even on the local fs,
1058
# FIXUP this and get_parent in a future branch format bump:
1059
# read and rewrite the file, and have the new format code read
1060
# using .get not .get_utf8. RBC 20060125
1061
self.control_files.put_utf8('parent', url + '\n')
1062
1063
def tree_config(self):
1064
return TreeConfig(self)
1065
1066
def _get_truncated_history(self, revision_id):
1067
history = self.revision_history()
1068
if revision_id is None:
1069
return history
1070
try:
1071
idx = history.index(revision_id)
1072
except ValueError:
1073
raise InvalidRevisionId(revision_id=revision, branch=self)
1074
return history[:idx+1]
1075
1076
@needs_read_lock
1077
def _clone_weave(self, to_location, revision=None, basis_branch=None):
1078
# prevent leakage
1079
from bzrlib.workingtree import WorkingTree
1080
assert isinstance(to_location, basestring)
1081
if basis_branch is not None:
1082
note("basis_branch is not supported for fast weave copy yet.")
1083
1084
history = self._get_truncated_history(revision)
1085
if not bzrlib.osutils.lexists(to_location):
1086
os.mkdir(to_location)
1087
bzrdir_to = self.bzrdir._format.initialize(to_location)
1088
self.repository.clone(bzrdir_to)
1089
branch_to = bzrdir_to.create_branch()
1090
mutter("copy branch from %s to %s", self, branch_to)
1091
1092
# FIXME duplicate code with base .clone().
1093
# .. would template method be useful here? RBC 20051207
1094
branch_to.set_parent(self.base)
1095
branch_to.append_revision(*history)
1096
WorkingTree.create(branch_to, branch_to.base)
1097
mutter("copied")
1098
return branch_to
1099
1100
1101
class BranchTestProviderAdapter(object):
1102
"""A tool to generate a suite testing multiple branch formats at once.
1103
1104
This is done by copying the test once for each transport and injecting
1105
the transport_server, transport_readonly_server, and branch_format
1106
classes into each copy. Each copy is also given a new id() to make it
1107
easy to identify.
1108
"""
1109
1110
def __init__(self, transport_server, transport_readonly_server, formats):
1111
self._transport_server = transport_server
1112
self._transport_readonly_server = transport_readonly_server
1113
self._formats = formats
1017
1114
1115
def adapt(self, test):
1116
result = TestSuite()
1117
for branch_format, bzrdir_format in self._formats:
1118
new_test = deepcopy(test)
1119
new_test.transport_server = self._transport_server
1120
new_test.transport_readonly_server = self._transport_readonly_server
1121
new_test.bzrdir_format = bzrdir_format
1122
new_test.branch_format = branch_format
1123
def make_new_test_id():
1124
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1125
return lambda: new_id
1126
new_test.id = make_new_test_id()
1127
result.addTest(new_test)
1128
return result
1129
1018
1130
1019
1131
######################################################################
1020
1132
# predicates
1021
1133
1022
1134
1023
def is_control_file(filename):
1024
## FIXME: better check
1025
filename = os.path.normpath(filename)
1026
while filename != '':
1027
head, tail = os.path.split(filename)
1028
## mutter('check %r for control file' % ((head, tail), ))
1029
if tail == bzrlib.BZRDIR:
1030
return True
1031
if filename == head:
1032
break
1033
filename = head
1034
return False
1035
1036
1037
1038
def gen_file_id(name):
1039
"""Return new file id.
1040
1041
This should probably generate proper UUIDs, but for the moment we
1042
cope with just randomness because running uuidgen every time is
1043
slow."""
1044
import re
1045
1046
# get last component
1047
idx = name.rfind('/')
1048
if idx != -1:
1049
name = name[idx+1 : ]
1050
idx = name.rfind('\\')
1051
if idx != -1:
1052
name = name[idx+1 : ]
1053
1054
# make it not a hidden file
1055
name = name.lstrip('.')
1056
1057
# remove any wierd characters; we don't escape them but rather
1058
# just pull them out
1059
name = re.sub(r'[^\w.]', '', name)
1060
1061
s = hexlify(rand_bytes(8))
1062
return '-'.join((name, compact_date(time.time()), s))
1135
@deprecated_function(zero_eight)
1136
def ScratchBranch(*args, **kwargs):
1137
"""See bzrlib.bzrdir.ScratchDir."""
1138
d = ScratchDir(*args, **kwargs)
1139
return d.open_branch()
1140
1141
1142
@deprecated_function(zero_eight)
1143
def is_control_file(*args, **kwargs):
1144
"""See bzrlib.workingtree.is_control_file."""
1145
return bzrlib.workingtree.is_control_file(*args, **kwargs)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1