« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 403
- compare with another revision
- download diff
- download tarball
- view history from revision 403
- Committer: Martin Pool
- Date: 2005-05-09 03:03:55 UTC
- Revision ID: mbp@sourcefrog.net-20050509030355-ad6ab558d1362959
- Don't give an error if the trace file can't be opened
- files added:
- bzrlib/cache.py
- files removed:
- HACKING
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/store
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/transport
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- patches
- tools
- files renamed:
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/store/__init__.py => bzrlib/store.py
- contrib/bash/bzr.simple => contrib/bash/bzr
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- 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
import shutil
19
import sys
20
import os
21
import errno
22
from warnings import warn
23
from cStringIO import StringIO
18
from sets import Set
24
19
20
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
21
import traceback, socket, fnmatch, difflib, time
22
from binascii import hexlify
25
23
26
24
import bzrlib
27
import bzrlib.inventory as inventory
28
from bzrlib.trace import mutter, note
29
from bzrlib.osutils import (isdir, quotefn,
30
rename, splitpath, sha_file, appendpath,
31
file_kind, abspath)
32
import bzrlib.errors as errors
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
34
NoSuchRevision, HistoryMissing, NotBranchError,
35
DivergedBranches, LockError, UnlistableStore,
36
UnlistableBranch, NoSuchFile, NotVersionedError,
37
NoWorkingTree)
38
from bzrlib.textui import show_status
39
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions,
40
NULL_REVISION)
41
42
from bzrlib.delta import compare_trees
43
from bzrlib.tree import EmptyTree, RevisionTree
44
from bzrlib.inventory import Inventory
45
from bzrlib.store import copy_all
46
from bzrlib.store.text import TextStore
47
from bzrlib.store.weave import WeaveStore
48
from bzrlib.testament import Testament
49
import bzrlib.transactions as transactions
50
from bzrlib.transport import Transport, get_transport
51
import bzrlib.xml5
52
import bzrlib.ui
53
from config import TreeConfig
54
55
56
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
57
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
58
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
25
from inventory import Inventory
26
from trace import mutter, note
27
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
28
from inventory import InventoryEntry, Inventory
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
32
from store import ImmutableStore
33
from revision import Revision
34
from errors import bailout, BzrError
35
from textui import show_status
36
from diff import diff_trees
37
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
59
39
## TODO: Maybe include checks for common corruption of newlines, etc?
60
40
61
41
62
# TODO: Some operations like log might retrieve the same revisions
63
# repeatedly to calculate deltas. We could perhaps have a weakref
64
# cache in memory to make this faster. In general anything can be
65
# cached in memory between lock and unlock operations.
66
67
def find_branch(*ignored, **ignored_too):
68
# XXX: leave this here for about one release, then remove it
69
raise NotImplementedError('find_branch() is not supported anymore, '
70
'please use one of the new branch constructors')
71
72
73
def needs_read_lock(unbound):
74
"""Decorate unbound to take out and release a read lock."""
75
def decorated(self, *args, **kwargs):
76
self.lock_read()
77
try:
78
return unbound(self, *args, **kwargs)
79
finally:
80
self.unlock()
81
return decorated
82
83
84
def needs_write_lock(unbound):
85
"""Decorate unbound to take out and release a write lock."""
86
def decorated(self, *args, **kwargs):
87
self.lock_write()
88
try:
89
return unbound(self, *args, **kwargs)
90
finally:
91
self.unlock()
92
return decorated
42
43
def find_branch_root(f=None):
44
"""Find the branch root enclosing f, or pwd.
45
46
It is not necessary that f exists.
47
48
Basically we keep looking up until we find the control directory or
49
run into the root."""
50
if f == None:
51
f = os.getcwd()
52
elif hasattr(os.path, 'realpath'):
53
f = os.path.realpath(f)
54
else:
55
f = os.path.abspath(f)
56
57
orig_f = f
58
59
while True:
60
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
61
return f
62
head, tail = os.path.split(f)
63
if head == f:
64
# reached the root, whatever that may be
65
raise BzrError('%r is not in a branch' % orig_f)
66
f = head
67
68
93
69
94
70
######################################################################
95
71
# branch objects
96
72
97
class Branch(object):
73
class Branch:
98
74
"""Branch holding a history of revisions.
99
75
100
76
base
101
Base directory/url of the branch.
77
Base directory of the branch.
102
78
"""
103
base = None
104
105
def __init__(self, *ignored, **ignored_too):
106
raise NotImplementedError('The Branch class is abstract')
107
108
@staticmethod
109
def open_downlevel(base):
110
"""Open a branch which may be of an old format.
111
112
Only local branches are supported."""
113
return BzrBranch(get_transport(base), relax_version_check=True)
114
115
@staticmethod
116
def open(base):
117
"""Open an existing branch, rooted at 'base' (url)"""
118
t = get_transport(base)
119
mutter("trying to open %r with transport %r", base, t)
120
return BzrBranch(t)
121
122
@staticmethod
123
def open_containing(url):
124
"""Open an existing branch which contains url.
125
126
This probes for a branch at url, and searches upwards from there.
127
128
Basically we keep looking up until we find the control directory or
129
run into the root. If there isn't one, raises NotBranchError.
130
If there is one, it is returned, along with the unused portion of url.
79
_lockmode = None
80
81
def __init__(self, base, init=False, find_root=True, lock_mode='w'):
82
"""Create new branch object at a particular location.
83
84
base -- Base directory for the branch.
85
86
init -- If True, create new control files in a previously
87
unversioned directory. If False, the branch must already
88
be versioned.
89
90
find_root -- If true and init is false, find the root of the
91
existing branch containing base.
92
93
In the test suite, creation of new trees is tested using the
94
`ScratchBranch` class.
131
95
"""
132
t = get_transport(url)
133
while True:
96
if init:
97
self.base = os.path.realpath(base)
98
self._make_control()
99
elif find_root:
100
self.base = find_branch_root(base)
101
else:
102
self.base = os.path.realpath(base)
103
if not isdir(self.controlfilename('.')):
104
bailout("not a bzr branch: %s" % quotefn(base),
105
['use "bzr init" to initialize a new working tree',
106
'current bzr can only operate from top-of-tree'])
107
self._check_format()
108
self.lock(lock_mode)
109
110
self.text_store = ImmutableStore(self.controlfilename('text-store'))
111
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
112
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
113
114
115
def __str__(self):
116
return '%s(%r)' % (self.__class__.__name__, self.base)
117
118
119
__repr__ = __str__
120
121
122
123
def lock(self, mode='w'):
124
"""Lock the on-disk branch, excluding other processes."""
125
try:
126
import fcntl, errno
127
128
if mode == 'w':
129
lm = fcntl.LOCK_EX
130
om = os.O_WRONLY | os.O_CREAT
131
elif mode == 'r':
132
lm = fcntl.LOCK_SH
133
om = os.O_RDONLY
134
else:
135
raise BzrError("invalid locking mode %r" % mode)
136
134
137
try:
135
return BzrBranch(t), t.relpath(url)
136
except NotBranchError:
137
pass
138
new_t = t.clone('..')
139
if new_t.base == t.base:
140
# reached the root, whatever that may be
141
raise NotBranchError(path=url)
142
t = new_t
143
144
@staticmethod
145
def initialize(base):
146
"""Create a new branch, rooted at 'base' (url)"""
147
t = get_transport(base)
148
return BzrBranch(t, init=True)
149
150
def setup_caching(self, cache_root):
151
"""Subclasses that care about caching should override this, and set
152
up cached stores located under cache_root.
153
"""
154
self.cache_root = cache_root
155
156
def _get_nick(self):
157
cfg = self.tree_config()
158
return cfg.get_option(u"nickname", default=self.base.split('/')[-1])
159
160
def _set_nick(self, nick):
161
cfg = self.tree_config()
162
cfg.set_option(nick, "nickname")
163
assert cfg.get_option("nickname") == nick
164
165
nick = property(_get_nick, _set_nick)
166
167
def push_stores(self, branch_to):
168
"""Copy the content of this branches store to branch_to."""
169
raise NotImplementedError('push_stores is abstract')
170
171
def get_transaction(self):
172
"""Return the current active transaction.
173
174
If no transaction is active, this returns a passthrough object
175
for which all data is immediately flushed and no caching happens.
176
"""
177
raise NotImplementedError('get_transaction is abstract')
178
179
def lock_write(self):
180
raise NotImplementedError('lock_write is abstract')
181
182
def lock_read(self):
183
raise NotImplementedError('lock_read is abstract')
184
185
def unlock(self):
186
raise NotImplementedError('unlock is abstract')
138
lockfile = os.open(self.controlfilename('branch-lock'), om)
139
except OSError, e:
140
if e.errno == errno.ENOENT:
141
# might not exist on branches from <0.0.4
142
self.controlfile('branch-lock', 'w').close()
143
lockfile = os.open(self.controlfilename('branch-lock'), om)
144
else:
145
raise e
146
147
fcntl.lockf(lockfile, lm)
148
def unlock():
149
fcntl.lockf(lockfile, fcntl.LOCK_UN)
150
os.close(lockfile)
151
self._lockmode = None
152
self.unlock = unlock
153
self._lockmode = mode
154
except ImportError:
155
warning("please write a locking method for platform %r" % sys.platform)
156
def unlock():
157
self._lockmode = None
158
self.unlock = unlock
159
self._lockmode = mode
160
161
162
def _need_readlock(self):
163
if self._lockmode not in ['r', 'w']:
164
raise BzrError('need read lock on branch, only have %r' % self._lockmode)
165
166
def _need_writelock(self):
167
if self._lockmode not in ['w']:
168
raise BzrError('need write lock on branch, only have %r' % self._lockmode)
169
187
170
188
171
def abspath(self, name):
189
"""Return absolute filename for something in the branch
190
191
XXX: Robert Collins 20051017 what is this used for? why is it a branch
192
method and not a tree method.
193
"""
194
raise NotImplementedError('abspath is abstract')
172
"""Return absolute filename for something in the branch"""
173
return os.path.join(self.base, name)
174
175
176
def relpath(self, path):
177
"""Return path relative to this branch of something inside it.
178
179
Raises an error if path is not in this branch."""
180
rp = os.path.realpath(path)
181
# FIXME: windows
182
if not rp.startswith(self.base):
183
bailout("path %r is not within branch %r" % (rp, self.base))
184
rp = rp[len(self.base):]
185
rp = rp.lstrip(os.sep)
186
return rp
187
195
188
196
189
def controlfilename(self, file_or_path):
197
190
"""Return location relative to branch."""
198
raise NotImplementedError('controlfilename is abstract')
191
if isinstance(file_or_path, types.StringTypes):
192
file_or_path = [file_or_path]
193
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
194
199
195
200
196
def controlfile(self, file_or_path, mode='r'):
201
197
"""Open a control file for this branch.
204
200
and binary. binary files are untranslated byte streams. Text
205
201
control files are stored with Unix newlines and in UTF-8, even
206
202
if the platform or locale defaults are different.
207
208
Controlfiles should almost never be opened in write mode but
209
rather should be atomically copied and replaced using atomicfile.
210
"""
211
raise NotImplementedError('controlfile is abstract')
212
213
def put_controlfile(self, path, f, encode=True):
214
"""Write an entry as a controlfile.
215
216
:param path: The path to put the file, relative to the .bzr control
217
directory
218
:param f: A file-like or string object whose contents should be copied.
219
:param encode: If true, encode the contents as utf-8
220
"""
221
raise NotImplementedError('put_controlfile is abstract')
222
223
def put_controlfiles(self, files, encode=True):
224
"""Write several entries as controlfiles.
225
226
:param files: A list of [(path, file)] pairs, where the path is the directory
227
underneath the bzr control directory
228
:param encode: If true, encode the contents as utf-8
229
"""
230
raise NotImplementedError('put_controlfiles is abstract')
231
232
def get_root_id(self):
233
"""Return the id of this branches root"""
234
raise NotImplementedError('get_root_id is abstract')
235
236
def set_root_id(self, file_id):
237
raise NotImplementedError('set_root_id is abstract')
238
239
def print_file(self, file, revision_id):
203
"""
204
205
fn = self.controlfilename(file_or_path)
206
207
if mode == 'rb' or mode == 'wb':
208
return file(fn, mode)
209
elif mode == 'r' or mode == 'w':
210
# open in binary mode anyhow so there's no newline translation;
211
# codecs uses line buffering by default; don't want that.
212
import codecs
213
return codecs.open(fn, mode + 'b', 'utf-8',
214
buffering=60000)
215
else:
216
raise BzrError("invalid controlfile mode %r" % mode)
217
218
219
220
def _make_control(self):
221
os.mkdir(self.controlfilename([]))
222
self.controlfile('README', 'w').write(
223
"This is a Bazaar-NG control directory.\n"
224
"Do not change any files in this directory.")
225
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
226
for d in ('text-store', 'inventory-store', 'revision-store'):
227
os.mkdir(self.controlfilename(d))
228
for f in ('revision-history', 'merged-patches',
229
'pending-merged-patches', 'branch-name',
230
'branch-lock'):
231
self.controlfile(f, 'w').write('')
232
mutter('created control directory in ' + self.base)
233
Inventory().write_xml(self.controlfile('inventory','w'))
234
235
236
def _check_format(self):
237
"""Check this branch format is supported.
238
239
The current tool only supports the current unstable format.
240
241
In the future, we might need different in-memory Branch
242
classes to support downlevel branches. But not yet.
243
"""
244
# This ignores newlines so that we can open branches created
245
# on Windows from Linux and so on. I think it might be better
246
# to always make all internal files in unix format.
247
fmt = self.controlfile('branch-format', 'r').read()
248
fmt.replace('\r\n', '')
249
if fmt != BZR_BRANCH_FORMAT:
250
bailout('sorry, branch format %r not supported' % fmt,
251
['use a different bzr version',
252
'or remove the .bzr directory and "bzr init" again'])
253
254
255
def read_working_inventory(self):
256
"""Read the working inventory."""
257
self._need_readlock()
258
before = time.time()
259
# ElementTree does its own conversion from UTF-8, so open in
260
# binary.
261
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
262
mutter("loaded inventory of %d items in %f"
263
% (len(inv), time.time() - before))
264
return inv
265
266
267
def _write_inventory(self, inv):
268
"""Update the working inventory.
269
270
That is to say, the inventory describing changes underway, that
271
will be committed to the next revision.
272
"""
273
self._need_writelock()
274
## TODO: factor out to atomicfile? is rename safe on windows?
275
## TODO: Maybe some kind of clean/dirty marker on inventory?
276
tmpfname = self.controlfilename('inventory.tmp')
277
tmpf = file(tmpfname, 'wb')
278
inv.write_xml(tmpf)
279
tmpf.close()
280
inv_fname = self.controlfilename('inventory')
281
if sys.platform == 'win32':
282
os.remove(inv_fname)
283
os.rename(tmpfname, inv_fname)
284
mutter('wrote working inventory')
285
286
287
inventory = property(read_working_inventory, _write_inventory, None,
288
"""Inventory for the working copy.""")
289
290
291
def add(self, files, verbose=False):
292
"""Make files versioned.
293
294
Note that the command line normally calls smart_add instead.
295
296
This puts the files in the Added state, so that they will be
297
recorded by the next commit.
298
299
TODO: Perhaps have an option to add the ids even if the files do
300
not (yet) exist.
301
302
TODO: Perhaps return the ids of the files? But then again it
303
is easy to retrieve them if they're needed.
304
305
TODO: Option to specify file id.
306
307
TODO: Adding a directory should optionally recurse down and
308
add all non-ignored children. Perhaps do that in a
309
higher-level method.
310
311
>>> b = ScratchBranch(files=['foo'])
312
>>> 'foo' in b.unknowns()
313
True
314
>>> b.show_status()
315
? foo
316
>>> b.add('foo')
317
>>> 'foo' in b.unknowns()
318
False
319
>>> bool(b.inventory.path2id('foo'))
320
True
321
>>> b.show_status()
322
A foo
323
324
>>> b.add('foo')
325
Traceback (most recent call last):
326
...
327
BzrError: ('foo is already versioned', [])
328
329
>>> b.add(['nothere'])
330
Traceback (most recent call last):
331
BzrError: ('cannot add: not a regular file or directory: nothere', [])
332
"""
333
self._need_writelock()
334
335
# TODO: Re-adding a file that is removed in the working copy
336
# should probably put it back with the previous ID.
337
if isinstance(files, types.StringTypes):
338
files = [files]
339
340
inv = self.read_working_inventory()
341
for f in files:
342
if is_control_file(f):
343
bailout("cannot add control file %s" % quotefn(f))
344
345
fp = splitpath(f)
346
347
if len(fp) == 0:
348
bailout("cannot add top-level %r" % f)
349
350
fullpath = os.path.normpath(self.abspath(f))
351
352
try:
353
kind = file_kind(fullpath)
354
except OSError:
355
# maybe something better?
356
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
357
358
if kind != 'file' and kind != 'directory':
359
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
360
361
file_id = gen_file_id(f)
362
inv.add_path(f, kind=kind, file_id=file_id)
363
364
if verbose:
365
show_status('A', kind, quotefn(f))
366
367
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
368
369
self._write_inventory(inv)
370
371
372
def print_file(self, file, revno):
240
373
"""Print `file` to stdout."""
241
raise NotImplementedError('print_file is abstract')
242
243
def append_revision(self, *revision_ids):
244
raise NotImplementedError('append_revision is abstract')
245
246
def set_revision_history(self, rev_history):
247
raise NotImplementedError('set_revision_history is abstract')
248
249
def has_revision(self, revision_id):
250
"""True if this branch has a copy of the revision.
251
252
This does not necessarily imply the revision is merge
253
or on the mainline."""
254
raise NotImplementedError('has_revision is abstract')
255
256
def get_revision_xml(self, revision_id):
257
raise NotImplementedError('get_revision_xml is abstract')
374
self._need_readlock()
375
tree = self.revision_tree(self.lookup_revision(revno))
376
# use inventory as it was in that revision
377
file_id = tree.inventory.path2id(file)
378
if not file_id:
379
bailout("%r is not present in revision %d" % (file, revno))
380
tree.print_file(file_id)
381
382
383
def remove(self, files, verbose=False):
384
"""Mark nominated files for removal from the inventory.
385
386
This does not remove their text. This does not run on
387
388
TODO: Refuse to remove modified files unless --force is given?
389
390
>>> b = ScratchBranch(files=['foo'])
391
>>> b.add('foo')
392
>>> b.inventory.has_filename('foo')
393
True
394
>>> b.remove('foo')
395
>>> b.working_tree().has_filename('foo')
396
True
397
>>> b.inventory.has_filename('foo')
398
False
399
400
>>> b = ScratchBranch(files=['foo'])
401
>>> b.add('foo')
402
>>> b.commit('one')
403
>>> b.remove('foo')
404
>>> b.commit('two')
405
>>> b.inventory.has_filename('foo')
406
False
407
>>> b.basis_tree().has_filename('foo')
408
False
409
>>> b.working_tree().has_filename('foo')
410
True
411
412
TODO: Do something useful with directories.
413
414
TODO: Should this remove the text or not? Tough call; not
415
removing may be useful and the user can just use use rm, and
416
is the opposite of add. Removing it is consistent with most
417
other tools. Maybe an option.
418
"""
419
## TODO: Normalize names
420
## TODO: Remove nested loops; better scalability
421
self._need_writelock()
422
423
if isinstance(files, types.StringTypes):
424
files = [files]
425
426
tree = self.working_tree()
427
inv = tree.inventory
428
429
# do this before any modifications
430
for f in files:
431
fid = inv.path2id(f)
432
if not fid:
433
bailout("cannot remove unversioned file %s" % quotefn(f))
434
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
435
if verbose:
436
# having remove it, it must be either ignored or unknown
437
if tree.is_ignored(f):
438
new_status = 'I'
439
else:
440
new_status = '?'
441
show_status(new_status, inv[fid].kind, quotefn(f))
442
del inv[fid]
443
444
self._write_inventory(inv)
445
446
447
def unknowns(self):
448
"""Return all unknown files.
449
450
These are files in the working directory that are not versioned or
451
control files or ignored.
452
453
>>> b = ScratchBranch(files=['foo', 'foo~'])
454
>>> list(b.unknowns())
455
['foo']
456
>>> b.add('foo')
457
>>> list(b.unknowns())
458
[]
459
>>> b.remove('foo')
460
>>> list(b.unknowns())
461
['foo']
462
"""
463
return self.working_tree().unknowns()
464
465
466
def commit(self, message, timestamp=None, timezone=None,
467
committer=None,
468
verbose=False):
469
"""Commit working copy as a new revision.
470
471
The basic approach is to add all the file texts into the
472
store, then the inventory, then make a new revision pointing
473
to that inventory and store that.
474
475
This is not quite safe if the working copy changes during the
476
commit; for the moment that is simply not allowed. A better
477
approach is to make a temporary copy of the files before
478
computing their hashes, and then add those hashes in turn to
479
the inventory. This should mean at least that there are no
480
broken hash pointers. There is no way we can get a snapshot
481
of the whole directory at an instant. This would also have to
482
be robust against files disappearing, moving, etc. So the
483
whole thing is a bit hard.
484
485
timestamp -- if not None, seconds-since-epoch for a
486
postdated/predated commit.
487
"""
488
self._need_writelock()
489
490
## TODO: Show branch names
491
492
# TODO: Don't commit if there are no changes, unless forced?
493
494
# First walk over the working inventory; and both update that
495
# and also build a new revision inventory. The revision
496
# inventory needs to hold the text-id, sha1 and size of the
497
# actual file versions committed in the revision. (These are
498
# not present in the working inventory.) We also need to
499
# detect missing/deleted files, and remove them from the
500
# working inventory.
501
502
work_inv = self.read_working_inventory()
503
inv = Inventory()
504
basis = self.basis_tree()
505
basis_inv = basis.inventory
506
missing_ids = []
507
for path, entry in work_inv.iter_entries():
508
## TODO: Cope with files that have gone missing.
509
510
## TODO: Check that the file kind has not changed from the previous
511
## revision of this file (if any).
512
513
entry = entry.copy()
514
515
p = self.abspath(path)
516
file_id = entry.file_id
517
mutter('commit prep file %s, id %r ' % (p, file_id))
518
519
if not os.path.exists(p):
520
mutter(" file is missing, removing from inventory")
521
if verbose:
522
show_status('D', entry.kind, quotefn(path))
523
missing_ids.append(file_id)
524
continue
525
526
# TODO: Handle files that have been deleted
527
528
# TODO: Maybe a special case for empty files? Seems a
529
# waste to store them many times.
530
531
inv.add(entry)
532
533
if basis_inv.has_id(file_id):
534
old_kind = basis_inv[file_id].kind
535
if old_kind != entry.kind:
536
bailout("entry %r changed kind from %r to %r"
537
% (file_id, old_kind, entry.kind))
538
539
if entry.kind == 'directory':
540
if not isdir(p):
541
bailout("%s is entered as directory but not a directory" % quotefn(p))
542
elif entry.kind == 'file':
543
if not isfile(p):
544
bailout("%s is entered as file but is not a file" % quotefn(p))
545
546
content = file(p, 'rb').read()
547
548
entry.text_sha1 = sha_string(content)
549
entry.text_size = len(content)
550
551
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
552
if (old_ie
553
and (old_ie.text_size == entry.text_size)
554
and (old_ie.text_sha1 == entry.text_sha1)):
555
## assert content == basis.get_file(file_id).read()
556
entry.text_id = basis_inv[file_id].text_id
557
mutter(' unchanged from previous text_id {%s}' %
558
entry.text_id)
559
560
else:
561
entry.text_id = gen_file_id(entry.name)
562
self.text_store.add(content, entry.text_id)
563
mutter(' stored with text_id {%s}' % entry.text_id)
564
if verbose:
565
if not old_ie:
566
state = 'A'
567
elif (old_ie.name == entry.name
568
and old_ie.parent_id == entry.parent_id):
569
state = 'M'
570
else:
571
state = 'R'
572
573
show_status(state, entry.kind, quotefn(path))
574
575
for file_id in missing_ids:
576
# have to do this later so we don't mess up the iterator.
577
# since parents may be removed before their children we
578
# have to test.
579
580
# FIXME: There's probably a better way to do this; perhaps
581
# the workingtree should know how to filter itself.
582
if work_inv.has_id(file_id):
583
del work_inv[file_id]
584
585
586
inv_id = rev_id = _gen_revision_id(time.time())
587
588
inv_tmp = tempfile.TemporaryFile()
589
inv.write_xml(inv_tmp)
590
inv_tmp.seek(0)
591
self.inventory_store.add(inv_tmp, inv_id)
592
mutter('new inventory_id is {%s}' % inv_id)
593
594
self._write_inventory(work_inv)
595
596
if timestamp == None:
597
timestamp = time.time()
598
599
if committer == None:
600
committer = username()
601
602
if timezone == None:
603
timezone = local_time_offset()
604
605
mutter("building commit log message")
606
rev = Revision(timestamp=timestamp,
607
timezone=timezone,
608
committer=committer,
609
precursor = self.last_patch(),
610
message = message,
611
inventory_id=inv_id,
612
revision_id=rev_id)
613
614
rev_tmp = tempfile.TemporaryFile()
615
rev.write_xml(rev_tmp)
616
rev_tmp.seek(0)
617
self.revision_store.add(rev_tmp, rev_id)
618
mutter("new revision_id is {%s}" % rev_id)
619
620
## XXX: Everything up to here can simply be orphaned if we abort
621
## the commit; it will leave junk files behind but that doesn't
622
## matter.
623
624
## TODO: Read back the just-generated changeset, and make sure it
625
## applies and recreates the right state.
626
627
## TODO: Also calculate and store the inventory SHA1
628
mutter("committing patch r%d" % (self.revno() + 1))
629
630
631
self.append_revision(rev_id)
632
633
if verbose:
634
note("commited r%d" % self.revno())
635
636
637
def append_revision(self, revision_id):
638
mutter("add {%s} to revision-history" % revision_id)
639
rev_history = self.revision_history()
640
641
tmprhname = self.controlfilename('revision-history.tmp')
642
rhname = self.controlfilename('revision-history')
643
644
f = file(tmprhname, 'wt')
645
rev_history.append(revision_id)
646
f.write('\n'.join(rev_history))
647
f.write('\n')
648
f.close()
649
650
if sys.platform == 'win32':
651
os.remove(rhname)
652
os.rename(tmprhname, rhname)
653
654
258
655
259
656
def get_revision(self, revision_id):
260
657
"""Return the Revision object for a named revision"""
261
raise NotImplementedError('get_revision is abstract')
262
263
def get_revision_delta(self, revno):
264
"""Return the delta for one revision.
265
266
The delta is relative to its mainline predecessor, or the
267
empty tree for revision 1.
268
"""
269
assert isinstance(revno, int)
658
self._need_readlock()
659
r = Revision.read_xml(self.revision_store[revision_id])
660
assert r.revision_id == revision_id
661
return r
662
663
664
def get_inventory(self, inventory_id):
665
"""Get Inventory object by hash.
666
667
TODO: Perhaps for this and similar methods, take a revision
668
parameter which can be either an integer revno or a
669
string hash."""
670
self._need_readlock()
671
i = Inventory.read_xml(self.inventory_store[inventory_id])
672
return i
673
674
675
def get_revision_inventory(self, revision_id):
676
"""Return inventory of a past revision."""
677
self._need_readlock()
678
if revision_id == None:
679
return Inventory()
680
else:
681
return self.get_inventory(self.get_revision(revision_id).inventory_id)
682
683
684
def revision_history(self):
685
"""Return sequence of revision hashes on to this branch.
686
687
>>> ScratchBranch().revision_history()
688
[]
689
"""
690
self._need_readlock()
691
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
692
693
694
def enum_history(self, direction):
695
"""Return (revno, revision_id) for history of branch.
696
697
direction
698
'forward' is from earliest to latest
699
'reverse' is from latest to earliest
700
"""
270
701
rh = self.revision_history()
271
if not (1 <= revno <= len(rh)):
272
raise InvalidRevisionNumber(revno)
273
274
# revno is 1-based; list is 0-based
275
276
new_tree = self.revision_tree(rh[revno-1])
277
if revno == 1:
278
old_tree = EmptyTree()
702
if direction == 'forward':
703
i = 1
704
for rid in rh:
705
yield i, rid
706
i += 1
707
elif direction == 'reverse':
708
i = len(rh)
709
while i > 0:
710
yield i, rh[i-1]
711
i -= 1
279
712
else:
280
old_tree = self.revision_tree(rh[revno-2])
281
282
return compare_trees(old_tree, new_tree)
283
284
def get_revision_sha1(self, revision_id):
285
"""Hash the stored value of a revision, and return it."""
286
raise NotImplementedError('get_revision_sha1 is abstract')
287
288
def get_ancestry(self, revision_id):
289
"""Return a list of revision-ids integrated by a revision.
290
291
This currently returns a list, but the ordering is not guaranteed:
292
treat it as a set.
293
"""
294
raise NotImplementedError('get_ancestry is abstract')
295
296
def get_inventory(self, revision_id):
297
"""Get Inventory object by hash."""
298
raise NotImplementedError('get_inventory is abstract')
299
300
def get_inventory_xml(self, revision_id):
301
"""Get inventory XML as a file object."""
302
raise NotImplementedError('get_inventory_xml is abstract')
303
304
def get_inventory_sha1(self, revision_id):
305
"""Return the sha1 hash of the inventory entry."""
306
raise NotImplementedError('get_inventory_sha1 is abstract')
307
308
def get_revision_inventory(self, revision_id):
309
"""Return inventory of a past revision."""
310
raise NotImplementedError('get_revision_inventory is abstract')
311
312
def revision_history(self):
313
"""Return sequence of revision hashes on to this branch."""
314
raise NotImplementedError('revision_history is abstract')
713
raise BzrError('invalid history direction %r' % direction)
714
315
715
316
716
def revno(self):
317
717
"""Return current revision number for this branch.
318
718
319
719
That is equivalent to the number of revisions committed to
320
720
this branch.
721
722
>>> b = ScratchBranch()
723
>>> b.revno()
724
0
725
>>> b.commit('no foo')
726
>>> b.revno()
727
1
321
728
"""
322
729
return len(self.revision_history())
323
730
324
def last_revision(self):
325
"""Return last patch hash, or None if no history."""
731
732
def last_patch(self):
733
"""Return last patch hash, or None if no history.
734
735
>>> ScratchBranch().last_patch() == None
736
True
737
"""
326
738
ph = self.revision_history()
327
739
if ph:
328
740
return ph[-1]
329
741
else:
330
742
return None
331
332
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
333
"""Return a list of new revisions that would perfectly fit.
334
335
If self and other have not diverged, return a list of the revisions
336
present in other, but missing from self.
337
338
>>> from bzrlib.commit import commit
339
>>> bzrlib.trace.silent = True
340
>>> br1 = ScratchBranch()
341
>>> br2 = ScratchBranch()
342
>>> br1.missing_revisions(br2)
343
[]
344
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
345
>>> br1.missing_revisions(br2)
346
[u'REVISION-ID-1']
347
>>> br2.missing_revisions(br1)
348
[]
349
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
350
>>> br1.missing_revisions(br2)
351
[]
352
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
353
>>> br1.missing_revisions(br2)
354
[u'REVISION-ID-2A']
355
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
356
>>> br1.missing_revisions(br2)
357
Traceback (most recent call last):
358
DivergedBranches: These branches have diverged. Try merge.
359
"""
360
self_history = self.revision_history()
361
self_len = len(self_history)
362
other_history = other.revision_history()
363
other_len = len(other_history)
364
common_index = min(self_len, other_len) -1
365
if common_index >= 0 and \
366
self_history[common_index] != other_history[common_index]:
367
raise DivergedBranches(self, other)
368
369
if stop_revision is None:
370
stop_revision = other_len
371
else:
372
assert isinstance(stop_revision, int)
373
if stop_revision > other_len:
374
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
375
return other_history[self_len:stop_revision]
376
377
def update_revisions(self, other, stop_revision=None):
378
"""Pull in new perfect-fit revisions."""
379
raise NotImplementedError('update_revisions is abstract')
380
381
def pullable_revisions(self, other, stop_revision):
382
raise NotImplementedError('pullable_revisions is abstract')
383
384
def revision_id_to_revno(self, revision_id):
385
"""Given a revision id, return its revno"""
386
if revision_id is None:
387
return 0
388
history = self.revision_history()
389
try:
390
return history.index(revision_id) + 1
391
except ValueError:
392
raise bzrlib.errors.NoSuchRevision(self, revision_id)
393
394
def get_rev_id(self, revno, history=None):
395
"""Find the revision id of the specified revno."""
743
744
745
def lookup_revision(self, revno):
746
"""Return revision hash for revision number."""
396
747
if revno == 0:
397
748
return None
398
if history is None:
399
history = self.revision_history()
400
elif revno <= 0 or revno > len(history):
401
raise bzrlib.errors.NoSuchRevision(self, revno)
402
return history[revno - 1]
749
750
try:
751
# list is 0-based; revisions are 1-based
752
return self.revision_history()[revno-1]
753
except IndexError:
754
raise BzrError("no such revision %s" % revno)
755
403
756
404
757
def revision_tree(self, revision_id):
405
758
"""Return Tree for a revision on this branch.
406
759
407
760
`revision_id` may be None for the null revision, in which case
408
761
an `EmptyTree` is returned."""
409
raise NotImplementedError('revision_tree is abstract')
762
self._need_readlock()
763
if revision_id == None:
764
return EmptyTree()
765
else:
766
inv = self.get_revision_inventory(revision_id)
767
return RevisionTree(self.text_store, inv)
768
410
769
411
770
def working_tree(self):
412
"""Return a `Tree` for the working copy if this is a local branch."""
413
raise NotImplementedError('working_tree is abstract')
771
"""Return a `Tree` for the working copy."""
772
return WorkingTree(self.base, self.read_working_inventory())
414
773
415
def pull(self, source, overwrite=False):
416
raise NotImplementedError('pull is abstract')
417
774
418
775
def basis_tree(self):
419
776
"""Return `Tree` object for last revision.
420
777
421
778
If there are no revisions yet, return an `EmptyTree`.
779
780
>>> b = ScratchBranch(files=['foo'])
781
>>> b.basis_tree().has_filename('foo')
782
False
783
>>> b.working_tree().has_filename('foo')
784
True
785
>>> b.add('foo')
786
>>> b.commit('add foo')
787
>>> b.basis_tree().has_filename('foo')
788
True
422
789
"""
423
return self.revision_tree(self.last_revision())
790
r = self.last_patch()
791
if r == None:
792
return EmptyTree()
793
else:
794
return RevisionTree(self.text_store, self.get_revision_inventory(r))
795
796
424
797
425
798
def rename_one(self, from_rel, to_rel):
426
799
"""Rename one file.
427
800
428
801
This can change the directory or the filename or both.
429
802
"""
430
raise NotImplementedError('rename_one is abstract')
803
self._need_writelock()
804
tree = self.working_tree()
805
inv = tree.inventory
806
if not tree.has_filename(from_rel):
807
bailout("can't rename: old working file %r does not exist" % from_rel)
808
if tree.has_filename(to_rel):
809
bailout("can't rename: new working file %r already exists" % to_rel)
810
811
file_id = inv.path2id(from_rel)
812
if file_id == None:
813
bailout("can't rename: old name %r is not versioned" % from_rel)
814
815
if inv.path2id(to_rel):
816
bailout("can't rename: new name %r is already versioned" % to_rel)
817
818
to_dir, to_tail = os.path.split(to_rel)
819
to_dir_id = inv.path2id(to_dir)
820
if to_dir_id == None and to_dir != '':
821
bailout("can't determine destination directory id for %r" % to_dir)
822
823
mutter("rename_one:")
824
mutter(" file_id {%s}" % file_id)
825
mutter(" from_rel %r" % from_rel)
826
mutter(" to_rel %r" % to_rel)
827
mutter(" to_dir %r" % to_dir)
828
mutter(" to_dir_id {%s}" % to_dir_id)
829
830
inv.rename(file_id, to_dir_id, to_tail)
831
832
print "%s => %s" % (from_rel, to_rel)
833
834
from_abs = self.abspath(from_rel)
835
to_abs = self.abspath(to_rel)
836
try:
837
os.rename(from_abs, to_abs)
838
except OSError, e:
839
bailout("failed to rename %r to %r: %s"
840
% (from_abs, to_abs, e[1]),
841
["rename rolled back"])
842
843
self._write_inventory(inv)
844
845
431
846
432
847
def move(self, from_paths, to_name):
433
848
"""Rename files.
439
854
440
855
Note that to_name is only the last component of the new name;
441
856
this doesn't change the directory.
442
443
This returns a list of (from_path, to_path) pairs for each
444
entry that is moved.
445
"""
446
raise NotImplementedError('move is abstract')
447
448
def get_parent(self):
449
"""Return the parent location of the branch.
450
451
This is the default location for push/pull/missing. The usual
452
pattern is that the user can override it by specifying a
453
location.
454
"""
455
raise NotImplementedError('get_parent is abstract')
456
457
def get_push_location(self):
458
"""Return the None or the location to push this branch to."""
459
raise NotImplementedError('get_push_location is abstract')
460
461
def set_push_location(self, location):
462
"""Set a new push location for this branch."""
463
raise NotImplementedError('set_push_location is abstract')
464
465
def set_parent(self, url):
466
raise NotImplementedError('set_parent is abstract')
467
468
def check_revno(self, revno):
469
"""\
470
Check whether a revno corresponds to any revision.
471
Zero (the NULL revision) is considered valid.
472
"""
473
if revno != 0:
474
self.check_real_revno(revno)
475
476
def check_real_revno(self, revno):
477
"""\
478
Check whether a revno corresponds to a real revision.
479
Zero (the NULL revision) is considered invalid
480
"""
481
if revno < 1 or revno > self.revno():
482
raise InvalidRevisionNumber(revno)
483
484
def sign_revision(self, revision_id, gpg_strategy):
485
raise NotImplementedError('sign_revision is abstract')
486
487
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
488
raise NotImplementedError('store_revision_signature is abstract')
489
490
class BzrBranch(Branch):
491
"""A branch stored in the actual filesystem.
492
493
Note that it's "local" in the context of the filesystem; it doesn't
494
really matter if it's on an nfs/smb/afs/coda/... share, as long as
495
it's writable, and can be accessed via the normal filesystem API.
496
497
_lock_mode
498
None, or 'r' or 'w'
499
500
_lock_count
501
If _lock_mode is true, a positive count of the number of times the
502
lock has been taken.
503
504
_lock
505
Lock object from bzrlib.lock.
506
"""
507
# We actually expect this class to be somewhat short-lived; part of its
508
# purpose is to try to isolate what bits of the branch logic are tied to
509
# filesystem access, so that in a later step, we can extricate them to
510
# a separarte ("storage") class.
511
_lock_mode = None
512
_lock_count = None
513
_lock = None
514
_inventory_weave = None
515
516
# Map some sort of prefix into a namespace
517
# stuff like "revno:10", "revid:", etc.
518
# This should match a prefix with a function which accepts
519
REVISION_NAMESPACES = {}
520
521
def push_stores(self, branch_to):
522
"""See Branch.push_stores."""
523
if (self._branch_format != branch_to._branch_format
524
or self._branch_format != 4):
525
from bzrlib.fetch import greedy_fetch
526
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
527
self, self._branch_format, branch_to, branch_to._branch_format)
528
greedy_fetch(to_branch=branch_to, from_branch=self,
529
revision=self.last_revision())
530
return
531
532
store_pairs = ((self.text_store, branch_to.text_store),
533
(self.inventory_store, branch_to.inventory_store),
534
(self.revision_store, branch_to.revision_store))
535
try:
536
for from_store, to_store in store_pairs:
537
copy_all(from_store, to_store)
538
except UnlistableStore:
539
raise UnlistableBranch(from_store)
540
541
def __init__(self, transport, init=False,
542
relax_version_check=False):
543
"""Create new branch object at a particular location.
544
545
transport -- A Transport object, defining how to access files.
546
547
init -- If True, create new control files in a previously
548
unversioned directory. If False, the branch must already
549
be versioned.
550
551
relax_version_check -- If true, the usual check for the branch
552
version is not applied. This is intended only for
553
upgrade/recovery type use; it's not guaranteed that
554
all operations will work on old format branches.
555
556
In the test suite, creation of new trees is tested using the
557
`ScratchBranch` class.
558
"""
559
assert isinstance(transport, Transport), \
560
"%r is not a Transport" % transport
561
self._transport = transport
562
if init:
563
self._make_control()
564
self._check_format(relax_version_check)
565
566
def get_store(name, compressed=True, prefixed=False):
567
# FIXME: This approach of assuming stores are all entirely compressed
568
# or entirely uncompressed is tidy, but breaks upgrade from
569
# some existing branches where there's a mixture; we probably
570
# still want the option to look for both.
571
relpath = self._rel_controlfilename(unicode(name))
572
store = TextStore(self._transport.clone(relpath),
573
prefixed=prefixed,
574
compressed=compressed)
575
#if self._transport.should_cache():
576
# cache_path = os.path.join(self.cache_root, name)
577
# os.mkdir(cache_path)
578
# store = bzrlib.store.CachedStore(store, cache_path)
579
return store
580
581
def get_weave(name, prefixed=False):
582
relpath = self._rel_controlfilename(unicode(name))
583
ws = WeaveStore(self._transport.clone(relpath), prefixed=prefixed)
584
if self._transport.should_cache():
585
ws.enable_cache = True
586
return ws
587
588
if self._branch_format == 4:
589
self.inventory_store = get_store('inventory-store')
590
self.text_store = get_store('text-store')
591
self.revision_store = get_store('revision-store')
592
elif self._branch_format == 5:
593
self.control_weaves = get_weave(u'')
594
self.weave_store = get_weave(u'weaves')
595
self.revision_store = get_store(u'revision-store', compressed=False)
596
elif self._branch_format == 6:
597
self.control_weaves = get_weave(u'')
598
self.weave_store = get_weave(u'weaves', prefixed=True)
599
self.revision_store = get_store(u'revision-store', compressed=False,
600
prefixed=True)
601
self.revision_store.register_suffix('sig')
602
self._transaction = None
603
604
def __str__(self):
605
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
606
607
__repr__ = __str__
608
609
def __del__(self):
610
if self._lock_mode or self._lock:
611
# XXX: This should show something every time, and be suitable for
612
# headless operation and embedding
613
warn("branch %r was not explicitly unlocked" % self)
614
self._lock.unlock()
615
616
# TODO: It might be best to do this somewhere else,
617
# but it is nice for a Branch object to automatically
618
# cache it's information.
619
# Alternatively, we could have the Transport objects cache requests
620
# See the earlier discussion about how major objects (like Branch)
621
# should never expect their __del__ function to run.
622
if hasattr(self, 'cache_root') and self.cache_root is not None:
623
try:
624
shutil.rmtree(self.cache_root)
625
except:
626
pass
627
self.cache_root = None
628
629
def _get_base(self):
630
if self._transport:
631
return self._transport.base
632
return None
633
634
base = property(_get_base, doc="The URL for the root of this branch.")
635
636
def _finish_transaction(self):
637
"""Exit the current transaction."""
638
if self._transaction is None:
639
raise errors.LockError('Branch %s is not in a transaction' %
640
self)
641
transaction = self._transaction
642
self._transaction = None
643
transaction.finish()
644
645
def get_transaction(self):
646
"""See Branch.get_transaction."""
647
if self._transaction is None:
648
return transactions.PassThroughTransaction()
649
else:
650
return self._transaction
651
652
def _set_transaction(self, new_transaction):
653
"""Set a new active transaction."""
654
if self._transaction is not None:
655
raise errors.LockError('Branch %s is in a transaction already.' %
656
self)
657
self._transaction = new_transaction
658
659
def lock_write(self):
660
#mutter("lock write: %s (%s)", self, self._lock_count)
661
# TODO: Upgrade locking to support using a Transport,
662
# and potentially a remote locking protocol
663
if self._lock_mode:
664
if self._lock_mode != 'w':
665
raise LockError("can't upgrade to a write lock from %r" %
666
self._lock_mode)
667
self._lock_count += 1
668
else:
669
self._lock = self._transport.lock_write(
670
self._rel_controlfilename('branch-lock'))
671
self._lock_mode = 'w'
672
self._lock_count = 1
673
self._set_transaction(transactions.PassThroughTransaction())
674
675
def lock_read(self):
676
#mutter("lock read: %s (%s)", self, self._lock_count)
677
if self._lock_mode:
678
assert self._lock_mode in ('r', 'w'), \
679
"invalid lock mode %r" % self._lock_mode
680
self._lock_count += 1
681
else:
682
self._lock = self._transport.lock_read(
683
self._rel_controlfilename('branch-lock'))
684
self._lock_mode = 'r'
685
self._lock_count = 1
686
self._set_transaction(transactions.ReadOnlyTransaction())
687
# 5K may be excessive, but hey, its a knob.
688
self.get_transaction().set_cache_size(5000)
689
690
def unlock(self):
691
#mutter("unlock: %s (%s)", self, self._lock_count)
692
if not self._lock_mode:
693
raise LockError('branch %r is not locked' % (self))
694
695
if self._lock_count > 1:
696
self._lock_count -= 1
697
else:
698
self._finish_transaction()
699
self._lock.unlock()
700
self._lock = None
701
self._lock_mode = self._lock_count = None
702
703
def abspath(self, name):
704
"""See Branch.abspath."""
705
return self._transport.abspath(name)
706
707
def _rel_controlfilename(self, file_or_path):
708
if not isinstance(file_or_path, basestring):
709
file_or_path = u'/'.join(file_or_path)
710
if file_or_path == '':
711
return bzrlib.BZRDIR
712
return bzrlib.transport.urlescape(bzrlib.BZRDIR + u'/' + file_or_path)
713
714
def controlfilename(self, file_or_path):
715
"""See Branch.controlfilename."""
716
return self._transport.abspath(self._rel_controlfilename(file_or_path))
717
718
def controlfile(self, file_or_path, mode='r'):
719
"""See Branch.controlfile."""
720
import codecs
721
722
relpath = self._rel_controlfilename(file_or_path)
723
#TODO: codecs.open() buffers linewise, so it was overloaded with
724
# a much larger buffer, do we need to do the same for getreader/getwriter?
725
if mode == 'rb':
726
return self._transport.get(relpath)
727
elif mode == 'wb':
728
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
729
elif mode == 'r':
730
# XXX: Do we really want errors='replace'? Perhaps it should be
731
# an error, or at least reported, if there's incorrectly-encoded
732
# data inside a file.
733
# <https://launchpad.net/products/bzr/+bug/3823>
734
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
735
elif mode == 'w':
736
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
737
else:
738
raise BzrError("invalid controlfile mode %r" % mode)
739
740
def put_controlfile(self, path, f, encode=True):
741
"""See Branch.put_controlfile."""
742
self.put_controlfiles([(path, f)], encode=encode)
743
744
def put_controlfiles(self, files, encode=True):
745
"""See Branch.put_controlfiles."""
746
import codecs
747
ctrl_files = []
748
for path, f in files:
749
if encode:
750
if isinstance(f, basestring):
751
f = f.encode('utf-8', 'replace')
752
else:
753
f = codecs.getwriter('utf-8')(f, errors='replace')
754
path = self._rel_controlfilename(path)
755
ctrl_files.append((path, f))
756
self._transport.put_multi(ctrl_files)
757
758
def _make_control(self):
759
from bzrlib.inventory import Inventory
760
from bzrlib.weavefile import write_weave_v5
761
from bzrlib.weave import Weave
762
763
# Create an empty inventory
764
sio = StringIO()
765
# if we want per-tree root ids then this is the place to set
766
# them; they're not needed for now and so ommitted for
767
# simplicity.
768
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
769
empty_inv = sio.getvalue()
770
sio = StringIO()
771
bzrlib.weavefile.write_weave_v5(Weave(), sio)
772
empty_weave = sio.getvalue()
773
774
dirs = [[], 'revision-store', 'weaves']
775
files = [('README',
776
"This is a Bazaar-NG control directory.\n"
777
"Do not change any files in this directory.\n"),
778
('branch-format', BZR_BRANCH_FORMAT_6),
779
('revision-history', ''),
780
('branch-name', ''),
781
('branch-lock', ''),
782
('pending-merges', ''),
783
('inventory', empty_inv),
784
('inventory.weave', empty_weave),
785
('ancestry.weave', empty_weave)
786
]
787
cfn = self._rel_controlfilename
788
self._transport.mkdir_multi([cfn(d) for d in dirs])
789
self.put_controlfiles(files)
790
mutter('created control directory in ' + self._transport.base)
791
792
def _check_format(self, relax_version_check):
793
"""Check this branch format is supported.
794
795
The format level is stored, as an integer, in
796
self._branch_format for code that needs to check it later.
797
798
In the future, we might need different in-memory Branch
799
classes to support downlevel branches. But not yet.
800
"""
801
try:
802
fmt = self.controlfile('branch-format', 'r').read()
803
except NoSuchFile:
804
raise NotBranchError(path=self.base)
805
mutter("got branch format %r", fmt)
806
if fmt == BZR_BRANCH_FORMAT_6:
807
self._branch_format = 6
808
elif fmt == BZR_BRANCH_FORMAT_5:
809
self._branch_format = 5
810
elif fmt == BZR_BRANCH_FORMAT_4:
811
self._branch_format = 4
812
813
if (not relax_version_check
814
and self._branch_format not in (5, 6)):
815
raise errors.UnsupportedFormatError(
816
'sorry, branch format %r not supported' % fmt,
817
['use a different bzr version',
818
'or remove the .bzr directory'
819
' and "bzr init" again'])
820
821
@needs_read_lock
822
def get_root_id(self):
823
"""See Branch.get_root_id."""
824
inv = self.get_inventory(self.last_revision())
825
return inv.root.file_id
826
827
@needs_read_lock
828
def print_file(self, file, revision_id):
829
"""See Branch.print_file."""
830
tree = self.revision_tree(revision_id)
831
# use inventory as it was in that revision
832
file_id = tree.inventory.path2id(file)
833
if not file_id:
834
try:
835
revno = self.revision_id_to_revno(revision_id)
836
except errors.NoSuchRevision:
837
# TODO: This should not be BzrError,
838
# but NoSuchFile doesn't fit either
839
raise BzrError('%r is not present in revision %s'
840
% (file, revision_id))
857
"""
858
self._need_writelock()
859
## TODO: Option to move IDs only
860
assert not isinstance(from_paths, basestring)
861
tree = self.working_tree()
862
inv = tree.inventory
863
to_abs = self.abspath(to_name)
864
if not isdir(to_abs):
865
bailout("destination %r is not a directory" % to_abs)
866
if not tree.has_filename(to_name):
867
bailout("destination %r not in working directory" % to_abs)
868
to_dir_id = inv.path2id(to_name)
869
if to_dir_id == None and to_name != '':
870
bailout("destination %r is not a versioned directory" % to_name)
871
to_dir_ie = inv[to_dir_id]
872
if to_dir_ie.kind not in ('directory', 'root_directory'):
873
bailout("destination %r is not a directory" % to_abs)
874
875
to_idpath = Set(inv.get_idpath(to_dir_id))
876
877
for f in from_paths:
878
if not tree.has_filename(f):
879
bailout("%r does not exist in working tree" % f)
880
f_id = inv.path2id(f)
881
if f_id == None:
882
bailout("%r is not versioned" % f)
883
name_tail = splitpath(f)[-1]
884
dest_path = appendpath(to_name, name_tail)
885
if tree.has_filename(dest_path):
886
bailout("destination %r already exists" % dest_path)
887
if f_id in to_idpath:
888
bailout("can't move %r to a subdirectory of itself" % f)
889
890
# OK, so there's a race here, it's possible that someone will
891
# create a file in this interval and then the rename might be
892
# left half-done. But we should have caught most problems.
893
894
for f in from_paths:
895
name_tail = splitpath(f)[-1]
896
dest_path = appendpath(to_name, name_tail)
897
print "%s => %s" % (f, dest_path)
898
inv.rename(inv.path2id(f), to_dir_id, name_tail)
899
try:
900
os.rename(self.abspath(f), self.abspath(dest_path))
901
except OSError, e:
902
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
903
["rename rolled back"])
904
905
self._write_inventory(inv)
906
907
908
909
def show_status(self, show_all=False):
910
"""Display single-line status for non-ignored working files.
911
912
The list is show sorted in order by file name.
913
914
>>> b = ScratchBranch(files=['foo', 'foo~'])
915
>>> b.show_status()
916
? foo
917
>>> b.add('foo')
918
>>> b.show_status()
919
A foo
920
>>> b.commit("add foo")
921
>>> b.show_status()
922
>>> os.unlink(b.abspath('foo'))
923
>>> b.show_status()
924
D foo
925
926
TODO: Get state for single files.
927
"""
928
self._need_readlock()
929
930
# We have to build everything into a list first so that it can
931
# sorted by name, incorporating all the different sources.
932
933
# FIXME: Rather than getting things in random order and then sorting,
934
# just step through in order.
935
936
# Interesting case: the old ID for a file has been removed,
937
# but a new file has been created under that name.
938
939
old = self.basis_tree()
940
new = self.working_tree()
941
942
for fs, fid, oldname, newname, kind in diff_trees(old, new):
943
if fs == 'R':
944
show_status(fs, kind,
945
oldname + ' => ' + newname)
946
elif fs == 'A' or fs == 'M':
947
show_status(fs, kind, newname)
948
elif fs == 'D':
949
show_status(fs, kind, oldname)
950
elif fs == '.':
951
if show_all:
952
show_status(fs, kind, newname)
953
elif fs == 'I':
954
if show_all:
955
show_status(fs, kind, newname)
956
elif fs == '?':
957
show_status(fs, kind, newname)
841
958
else:
842
raise BzrError('%r is not present in revision %s'
843
% (file, revno))
844
tree.print_file(file_id)
845
846
@needs_write_lock
847
def append_revision(self, *revision_ids):
848
"""See Branch.append_revision."""
849
for revision_id in revision_ids:
850
mutter("add {%s} to revision-history" % revision_id)
851
rev_history = self.revision_history()
852
rev_history.extend(revision_ids)
853
self.set_revision_history(rev_history)
854
855
@needs_write_lock
856
def set_revision_history(self, rev_history):
857
"""See Branch.set_revision_history."""
858
old_revision = self.last_revision()
859
new_revision = rev_history[-1]
860
self.put_controlfile('revision-history', '\n'.join(rev_history))
861
try:
862
self.working_tree().set_last_revision(new_revision, old_revision)
863
except NoWorkingTree:
864
mutter('Unable to set_last_revision without a working tree.')
865
866
def has_revision(self, revision_id):
867
"""See Branch.has_revision."""
868
return (revision_id is None
869
or self.revision_store.has_id(revision_id))
870
871
@needs_read_lock
872
def _get_revision_xml_file(self, revision_id):
873
if not revision_id or not isinstance(revision_id, basestring):
874
raise InvalidRevisionId(revision_id=revision_id, branch=self)
875
try:
876
return self.revision_store.get(revision_id)
877
except (IndexError, KeyError):
878
raise bzrlib.errors.NoSuchRevision(self, revision_id)
879
880
def get_revision_xml(self, revision_id):
881
"""See Branch.get_revision_xml."""
882
return self._get_revision_xml_file(revision_id).read()
883
884
def get_revision(self, revision_id):
885
"""See Branch.get_revision."""
886
xml_file = self._get_revision_xml_file(revision_id)
887
888
try:
889
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
890
except SyntaxError, e:
891
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
892
[revision_id,
893
str(e)])
894
895
assert r.revision_id == revision_id
896
return r
897
898
def get_revision_sha1(self, revision_id):
899
"""See Branch.get_revision_sha1."""
900
# In the future, revision entries will be signed. At that
901
# point, it is probably best *not* to include the signature
902
# in the revision hash. Because that lets you re-sign
903
# the revision, (add signatures/remove signatures) and still
904
# have all hash pointers stay consistent.
905
# But for now, just hash the contents.
906
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
907
908
def get_ancestry(self, revision_id):
909
"""See Branch.get_ancestry."""
910
if revision_id is None:
911
return [None]
912
w = self._get_inventory_weave()
913
return [None] + map(w.idx_to_name,
914
w.inclusions([w.lookup(revision_id)]))
915
916
def _get_inventory_weave(self):
917
return self.control_weaves.get_weave('inventory',
918
self.get_transaction())
919
920
def get_inventory(self, revision_id):
921
"""See Branch.get_inventory."""
922
xml = self.get_inventory_xml(revision_id)
923
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
924
925
def get_inventory_xml(self, revision_id):
926
"""See Branch.get_inventory_xml."""
927
try:
928
assert isinstance(revision_id, basestring), type(revision_id)
929
iw = self._get_inventory_weave()
930
return iw.get_text(iw.lookup(revision_id))
931
except IndexError:
932
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
933
934
def get_inventory_sha1(self, revision_id):
935
"""See Branch.get_inventory_sha1."""
936
return self.get_revision(revision_id).inventory_sha1
937
938
def get_revision_inventory(self, revision_id):
939
"""See Branch.get_revision_inventory."""
940
# TODO: Unify this with get_inventory()
941
# bzr 0.0.6 and later imposes the constraint that the inventory_id
942
# must be the same as its revision, so this is trivial.
943
if revision_id == None:
944
# This does not make sense: if there is no revision,
945
# then it is the current tree inventory surely ?!
946
# and thus get_root_id() is something that looks at the last
947
# commit on the branch, and the get_root_id is an inventory check.
948
raise NotImplementedError
949
# return Inventory(self.get_root_id())
950
else:
951
return self.get_inventory(revision_id)
952
953
@needs_read_lock
954
def revision_history(self):
955
"""See Branch.revision_history."""
956
transaction = self.get_transaction()
957
history = transaction.map.find_revision_history()
958
if history is not None:
959
mutter("cache hit for revision-history in %s", self)
960
return list(history)
961
history = [l.rstrip('\r\n') for l in
962
self.controlfile('revision-history', 'r').readlines()]
963
transaction.map.add_revision_history(history)
964
# this call is disabled because revision_history is
965
# not really an object yet, and the transaction is for objects.
966
# transaction.register_clean(history, precious=True)
967
return list(history)
968
969
def update_revisions(self, other, stop_revision=None):
970
"""See Branch.update_revisions."""
971
from bzrlib.fetch import greedy_fetch
972
if stop_revision is None:
973
stop_revision = other.last_revision()
974
### Should this be checking is_ancestor instead of revision_history?
975
if (stop_revision is not None and
976
stop_revision in self.revision_history()):
977
return
978
greedy_fetch(to_branch=self, from_branch=other,
979
revision=stop_revision)
980
pullable_revs = self.pullable_revisions(other, stop_revision)
981
if len(pullable_revs) > 0:
982
self.append_revision(*pullable_revs)
983
984
def pullable_revisions(self, other, stop_revision):
985
"""See Branch.pullable_revisions."""
986
other_revno = other.revision_id_to_revno(stop_revision)
987
try:
988
return self.missing_revisions(other, other_revno)
989
except DivergedBranches, e:
990
try:
991
pullable_revs = get_intervening_revisions(self.last_revision(),
992
stop_revision, self)
993
assert self.last_revision() not in pullable_revs
994
return pullable_revs
995
except bzrlib.errors.NotAncestor:
996
if is_ancestor(self.last_revision(), stop_revision, self):
997
return []
998
else:
999
raise e
1000
1001
def revision_tree(self, revision_id):
1002
"""See Branch.revision_tree."""
1003
# TODO: refactor this to use an existing revision object
1004
# so we don't need to read it in twice.
1005
if revision_id == None or revision_id == NULL_REVISION:
1006
return EmptyTree()
1007
else:
1008
inv = self.get_revision_inventory(revision_id)
1009
return RevisionTree(self.weave_store, inv, revision_id)
1010
1011
def basis_tree(self):
1012
"""See Branch.basis_tree."""
1013
try:
1014
revision_id = self.revision_history()[-1]
1015
xml = self.working_tree().read_basis_inventory(revision_id)
1016
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
1017
return RevisionTree(self.weave_store, inv, revision_id)
1018
except (IndexError, NoSuchFile, NoWorkingTree), e:
1019
return self.revision_tree(self.last_revision())
1020
1021
def working_tree(self):
1022
"""See Branch.working_tree."""
1023
from bzrlib.workingtree import WorkingTree
1024
if self._transport.base.find('://') != -1:
1025
raise NoWorkingTree(self.base)
1026
return WorkingTree(self.base, branch=self)
1027
1028
@needs_write_lock
1029
def pull(self, source, overwrite=False):
1030
"""See Branch.pull."""
1031
source.lock_read()
1032
try:
1033
old_count = len(self.revision_history())
1034
try:
1035
self.update_revisions(source)
1036
except DivergedBranches:
1037
if not overwrite:
1038
raise
1039
if overwrite:
1040
self.set_revision_history(source.revision_history())
1041
new_count = len(self.revision_history())
1042
return new_count - old_count
1043
finally:
1044
source.unlock()
1045
1046
def get_parent(self):
1047
"""See Branch.get_parent."""
1048
import errno
1049
_locs = ['parent', 'pull', 'x-pull']
1050
for l in _locs:
1051
try:
1052
return self.controlfile(l, 'r').read().strip('\n')
1053
except NoSuchFile:
1054
pass
1055
return None
1056
1057
def get_push_location(self):
1058
"""See Branch.get_push_location."""
1059
config = bzrlib.config.BranchConfig(self)
1060
push_loc = config.get_user_option('push_location')
1061
return push_loc
1062
1063
def set_push_location(self, location):
1064
"""See Branch.set_push_location."""
1065
config = bzrlib.config.LocationConfig(self.base)
1066
config.set_user_option('push_location', location)
1067
1068
@needs_write_lock
1069
def set_parent(self, url):
1070
"""See Branch.set_parent."""
1071
# TODO: Maybe delete old location files?
1072
from bzrlib.atomicfile import AtomicFile
1073
f = AtomicFile(self.controlfilename('parent'))
1074
try:
1075
f.write(url + '\n')
1076
f.commit()
1077
finally:
1078
f.close()
1079
1080
def tree_config(self):
1081
return TreeConfig(self)
1082
1083
def sign_revision(self, revision_id, gpg_strategy):
1084
"""See Branch.sign_revision."""
1085
plaintext = Testament.from_revision(self, revision_id).as_short_text()
1086
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1087
1088
@needs_write_lock
1089
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1090
"""See Branch.store_revision_signature."""
1091
self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)),
1092
revision_id, "sig")
1093
1094
1095
class ScratchBranch(BzrBranch):
959
bailout("weird file state %r" % ((fs, fid),))
960
961
962
963
class ScratchBranch(Branch):
1096
964
"""Special test class: a branch that cleans up after itself.
1097
965
1098
966
>>> b = ScratchBranch()
1099
967
>>> isdir(b.base)
1100
968
True
1101
969
>>> bd = b.base
1102
>>> b._transport.__del__()
970
>>> b.destroy()
1103
971
>>> isdir(bd)
1104
972
False
1105
973
"""
1106
1107
def __init__(self, files=[], dirs=[], transport=None):
974
def __init__(self, files=[], dirs=[]):
1108
975
"""Make a test branch.
1109
976
1110
977
This creates a temporary directory and runs init-tree in it.
1111
978
1112
979
If any files are listed, they are created in the working copy.
1113
980
"""
1114
if transport is None:
1115
transport = bzrlib.transport.local.ScratchTransport()
1116
super(ScratchBranch, self).__init__(transport, init=True)
1117
else:
1118
super(ScratchBranch, self).__init__(transport)
1119
981
Branch.__init__(self, tempfile.mkdtemp(), init=True)
1120
982
for d in dirs:
1121
self._transport.mkdir(d)
983
os.mkdir(self.abspath(d))
1122
984
1123
985
for f in files:
1124
self._transport.put(f, 'content of %s' % f)
1125
1126
1127
def clone(self):
1128
"""
1129
>>> orig = ScratchBranch(files=["file1", "file2"])
1130
>>> clone = orig.clone()
1131
>>> if os.name != 'nt':
1132
... os.path.samefile(orig.base, clone.base)
1133
... else:
1134
... orig.base == clone.base
1135
...
1136
False
1137
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1138
True
1139
"""
1140
from shutil import copytree
1141
from tempfile import mkdtemp
1142
base = mkdtemp()
1143
os.rmdir(base)
1144
copytree(self.base, base, symlinks=True)
1145
return ScratchBranch(
1146
transport=bzrlib.transport.local.ScratchTransport(base))
986
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
987
988
989
def __del__(self):
990
self.destroy()
991
992
def destroy(self):
993
"""Destroy the test branch, removing the scratch directory."""
994
try:
995
mutter("delete ScratchBranch %s" % self.base)
996
shutil.rmtree(self.base)
997
except OSError, e:
998
# Work around for shutil.rmtree failing on Windows when
999
# readonly files are encountered
1000
mutter("hit exception in destroying ScratchBranch: %s" % e)
1001
for root, dirs, files in os.walk(self.base, topdown=False):
1002
for name in files:
1003
os.chmod(os.path.join(root, name), 0700)
1004
shutil.rmtree(self.base)
1005
self.base = None
1006
1147
1007
1148
1008
1149
1009
######################################################################
1162
1022
break
1163
1023
filename = head
1164
1024
return False
1025
1026
1027
1028
def _gen_revision_id(when):
1029
"""Return new revision-id."""
1030
s = '%s-%s-' % (user_email(), compact_date(when))
1031
s += hexlify(rand_bytes(8))
1032
return s
1033
1034
1035
def gen_file_id(name):
1036
"""Return new file id.
1037
1038
This should probably generate proper UUIDs, but for the moment we
1039
cope with just randomness because running uuidgen every time is
1040
slow."""
1041
idx = name.rfind('/')
1042
if idx != -1:
1043
name = name[idx+1 : ]
1044
idx = name.rfind('\\')
1045
if idx != -1:
1046
name = name[idx+1 : ]
1047
1048
name = name.lstrip('.')
1049
1050
s = hexlify(rand_bytes(8))
1051
return '-'.join((name, compact_date(time.time()), s))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1