« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1185.11.24
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.11.24
- Committer: John Arbash Meinel
- Date: 2005-09-22 19:16:57 UTC
- mto: (1393.2.1)
- mto: This revision was merged to the branch mainline in revision 1396.
- Revision ID: john@arbash-meinel.com-20050922191657-f94ee98ba0f9f83e
Made it so that we don't loop forever on EAGAIN.
- files added:
- .rsyncexclude
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- patches
- tools
- files removed:
- bzrlib/tests.py
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- elementtree/ => bzrlib/util/elementtree/
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
from sets import Set
19
20
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
21
import traceback, socket, fnmatch, difflib, time
22
from binascii import hexlify
18
import sys
19
import os
23
20
24
21
import bzrlib
25
from inventory import Inventory
26
from trace import mutter, note
27
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
28
from inventory import InventoryEntry, Inventory
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
joinpath, sha_string, file_kind, local_time_offset
32
from store import ImmutableStore
33
from revision import Revision
34
from errors import bailout
35
from textui import show_status
36
from diff import diff_trees
22
from bzrlib.trace import mutter, note
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
24
splitpath, \
25
sha_file, appendpath, file_kind
26
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId, \
28
DivergedBranches, NotBranchError, NoSuchFile
29
from bzrlib.textui import show_status
30
from bzrlib.revision import Revision
31
from bzrlib.delta import compare_trees
32
from bzrlib.tree import EmptyTree, RevisionTree
33
import bzrlib.xml
34
import bzrlib.ui
35
import bzrlib.transport
36
37
37
38
38
39
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
40
## TODO: Maybe include checks for common corruption of newlines, etc?
40
41
41
42
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.
43
# TODO: Some operations like log might retrieve the same revisions
44
# repeatedly to calculate deltas. We could perhaps have a weakref
45
# cache in memory to make this faster.
46
47
def find_branch(*ignored, **ignored_too):
48
# XXX: leave this here for about one release, then remove it
49
raise NotImplementedError('find_branch() is not supported anymore, '
50
'please use one of the new branch constructors')
51
def _relpath(base, path):
52
"""Return path relative to base, or raise exception.
53
54
The path may be either an absolute path or a path relative to the
55
current working directory.
56
57
Lifted out of Branch.relpath for ease of testing.
58
59
os.path.commonprefix (python2.4) has a bad bug that it works just
60
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
61
avoids that problem."""
62
rp = os.path.abspath(path)
63
64
s = []
65
head = rp
66
while len(head) >= len(base):
67
if head == base:
68
break
69
head, tail = os.path.split(head)
70
if tail:
71
s.insert(0, tail)
72
else:
73
raise NotBranchError("path %r is not within branch %r" % (rp, base))
74
75
return os.sep.join(s)
76
77
78
def find_branch_root(t):
79
"""Find the branch root enclosing the transport's base.
80
81
t is a Transport object.
82
83
It is not necessary that the base of t exists.
47
84
48
85
Basically we keep looking up until we find the control directory or
49
run into the root."""
50
if f is None:
51
f = os.getcwd()
52
elif hasattr(os.path, 'realpath'):
53
f = os.path.realpath(f)
54
else:
55
f = os.path.abspath(f)
56
57
orig_f = f
58
59
last_f = f
86
run into the root. If there isn't one, raises NotBranchError.
87
"""
88
orig_base = t.base
60
89
while True:
61
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
62
return f
63
head, tail = os.path.split(f)
64
if head == f:
90
if t.has(bzrlib.BZRDIR):
91
return t
92
new_t = t.clone('..')
93
if new_t.base == t.base:
65
94
# reached the root, whatever that may be
66
bailout('%r is not in a branch' % orig_f)
67
f = head
68
95
raise NotBranchError('%s is not in a branch' % orig_base)
96
t = new_t
69
97
70
98
71
99
######################################################################
72
100
# branch objects
73
101
74
class Branch:
102
class Branch(object):
75
103
"""Branch holding a history of revisions.
76
104
77
:todo: Perhaps use different stores for different classes of object,
78
so that we can keep track of how much space each one uses,
79
or garbage-collect them.
80
81
:todo: Add a RemoteBranch subclass. For the basic case of read-only
82
HTTP access this should be very easy by,
83
just redirecting controlfile access into HTTP requests.
84
We would need a RemoteStore working similarly.
85
86
:todo: Keep the on-disk branch locked while the object exists.
87
88
:todo: mkdir() method.
89
"""
90
def __init__(self, base, init=False, find_root=True):
105
base
106
Base directory/url of the branch.
107
"""
108
base = None
109
110
def __init__(self, *ignored, **ignored_too):
111
raise NotImplementedError('The Branch class is abstract')
112
113
@staticmethod
114
def open(base):
115
"""Open an existing branch, rooted at 'base' (url)"""
116
t = bzrlib.transport.transport(base)
117
return _Branch(t)
118
119
@staticmethod
120
def open_containing(base):
121
"""Open an existing branch, containing url (search upwards for the root)
122
"""
123
t = bzrlib.transport.transport(base)
124
t = find_branch_root(t)
125
return _Branch(t)
126
127
@staticmethod
128
def initialize(base):
129
"""Create a new branch, rooted at 'base' (url)"""
130
t = bzrlib.transport.transport(base)
131
return _Branch(t, init=True)
132
133
def setup_caching(self, cache_root):
134
"""Subclasses that care about caching should override this, and set
135
up cached stores located under cache_root.
136
"""
137
138
139
class _Branch(Branch):
140
"""A branch stored in the actual filesystem.
141
142
Note that it's "local" in the context of the filesystem; it doesn't
143
really matter if it's on an nfs/smb/afs/coda/... share, as long as
144
it's writable, and can be accessed via the normal filesystem API.
145
146
_lock_mode
147
None, or 'r' or 'w'
148
149
_lock_count
150
If _lock_mode is true, a positive count of the number of times the
151
lock has been taken.
152
153
_lock
154
Lock object from bzrlib.lock.
155
"""
156
# We actually expect this class to be somewhat short-lived; part of its
157
# purpose is to try to isolate what bits of the branch logic are tied to
158
# filesystem access, so that in a later step, we can extricate them to
159
# a separarte ("storage") class.
160
_lock_mode = None
161
_lock_count = None
162
_lock = None
163
164
def __init__(self, transport, init=False):
91
165
"""Create new branch object at a particular location.
92
166
93
:param base: Base directory for the branch.
167
transport -- A Transport object, defining how to access files.
168
(If a string, transport.transport() will be used to
169
create a Transport object)
94
170
95
:param init: If True, create new control files in a previously
171
init -- If True, create new control files in a previously
96
172
unversioned directory. If False, the branch must already
97
173
be versioned.
98
174
99
:param find_root: If true and init is false, find the root of the
100
existing branch containing base.
101
102
175
In the test suite, creation of new trees is tested using the
103
176
`ScratchBranch` class.
104
177
"""
178
if isinstance(transport, basestring):
179
from bzrlib.transport import transport as get_transport
180
transport = get_transport(transport)
181
182
self._transport = transport
105
183
if init:
106
self.base = os.path.realpath(base)
107
184
self._make_control()
108
elif find_root:
109
self.base = find_branch_root(base)
110
else:
111
self.base = os.path.realpath(base)
112
if not isdir(self.controlfilename('.')):
113
bailout("not a bzr branch: %s" % quotefn(base),
114
['use "bzr init" to initialize a new working tree',
115
'current bzr can only operate from top-of-tree'])
116
185
self._check_format()
117
186
118
self.text_store = ImmutableStore(self.controlfilename('text-store'))
119
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
120
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
121
122
187
123
188
def __str__(self):
124
return '%s(%r)' % (self.__class__.__name__, self.base)
189
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
125
190
126
191
127
192
__repr__ = __str__
128
193
129
194
195
def __del__(self):
196
if self._lock_mode or self._lock:
197
from bzrlib.trace import warning
198
warning("branch %r was not explicitly unlocked" % self)
199
self._lock.unlock()
200
201
# TODO: It might be best to do this somewhere else,
202
# but it is nice for a Branch object to automatically
203
# cache it's information.
204
# Alternatively, we could have the Transport objects cache requests
205
# See the earlier discussion about how major objects (like Branch)
206
# should never expect their __del__ function to run.
207
if hasattr(self, 'cache_root') and self.cache_root is not None:
208
try:
209
import shutil
210
shutil.rmtree(self.cache_root)
211
except:
212
pass
213
self.cache_root = None
214
215
def _get_base(self):
216
if self._transport:
217
return self._transport.base
218
return None
219
220
base = property(_get_base)
221
222
223
def lock_write(self):
224
# TODO: Upgrade locking to support using a Transport,
225
# and potentially a remote locking protocol
226
if self._lock_mode:
227
if self._lock_mode != 'w':
228
from bzrlib.errors import LockError
229
raise LockError("can't upgrade to a write lock from %r" %
230
self._lock_mode)
231
self._lock_count += 1
232
else:
233
self._lock = self._transport.lock_write(
234
self._rel_controlfilename('branch-lock'))
235
self._lock_mode = 'w'
236
self._lock_count = 1
237
238
239
def lock_read(self):
240
if self._lock_mode:
241
assert self._lock_mode in ('r', 'w'), \
242
"invalid lock mode %r" % self._lock_mode
243
self._lock_count += 1
244
else:
245
self._lock = self._transport.lock_read(
246
self._rel_controlfilename('branch-lock'))
247
self._lock_mode = 'r'
248
self._lock_count = 1
249
250
def unlock(self):
251
if not self._lock_mode:
252
from bzrlib.errors import LockError
253
raise LockError('branch %r is not locked' % (self))
254
255
if self._lock_count > 1:
256
self._lock_count -= 1
257
else:
258
self._lock.unlock()
259
self._lock = None
260
self._lock_mode = self._lock_count = None
261
130
262
def abspath(self, name):
131
263
"""Return absolute filename for something in the branch"""
132
return os.path.join(self.base, name)
133
264
return self._transport.abspath(name)
134
265
135
266
def relpath(self, path):
136
267
"""Return path relative to this branch of something inside it.
137
268
138
269
Raises an error if path is not in this branch."""
139
rp = os.path.realpath(path)
140
# FIXME: windows
141
if not rp.startswith(self.base):
142
bailout("path %r is not within branch %r" % (rp, self.base))
143
rp = rp[len(self.base):]
144
rp = rp.lstrip(os.sep)
145
return rp
146
270
return self._transport.relpath(path)
271
272
273
def _rel_controlfilename(self, file_or_path):
274
if isinstance(file_or_path, basestring):
275
file_or_path = [file_or_path]
276
return [bzrlib.BZRDIR] + file_or_path
147
277
148
278
def controlfilename(self, file_or_path):
149
279
"""Return location relative to branch."""
150
if isinstance(file_or_path, types.StringTypes):
151
file_or_path = [file_or_path]
152
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
280
return self._transport.abspath(self._rel_controlfilename(file_or_path))
153
281
154
282
155
283
def controlfile(self, file_or_path, mode='r'):
156
"""Open a control file for this branch"""
157
return file(self.controlfilename(file_or_path), mode)
158
284
"""Open a control file for this branch.
285
286
There are two classes of file in the control directory: text
287
and binary. binary files are untranslated byte streams. Text
288
control files are stored with Unix newlines and in UTF-8, even
289
if the platform or locale defaults are different.
290
291
Controlfiles should almost never be opened in write mode but
292
rather should be atomically copied and replaced using atomicfile.
293
"""
294
import codecs
295
296
relpath = self._rel_controlfilename(file_or_path)
297
#TODO: codecs.open() buffers linewise, so it was overloaded with
298
# a much larger buffer, do we need to do the same for getreader/getwriter?
299
if mode == 'rb':
300
return self._transport.get(relpath)
301
elif mode == 'wb':
302
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
303
elif mode == 'r':
304
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
305
elif mode == 'w':
306
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
307
else:
308
raise BzrError("invalid controlfile mode %r" % mode)
309
310
def put_controlfile(self, path, f, encode=True):
311
"""Write an entry as a controlfile.
312
313
:param path: The path to put the file, relative to the .bzr control
314
directory
315
:param f: A file-like or string object whose contents should be copied.
316
:param encode: If true, encode the contents as utf-8
317
"""
318
self.put_controlfiles([(path, f)], encode=encode)
319
320
def put_controlfiles(self, files, encode=True):
321
"""Write several entries as controlfiles.
322
323
:param files: A list of [(path, file)] pairs, where the path is the directory
324
underneath the bzr control directory
325
:param encode: If true, encode the contents as utf-8
326
"""
327
import codecs
328
ctrl_files = []
329
for path, f in files:
330
if encode:
331
if isinstance(f, basestring):
332
f = f.encode('utf-8', 'replace')
333
else:
334
f = codecs.getwriter('utf-8')(f, errors='replace')
335
path = self._rel_controlfilename(path)
336
ctrl_files.append((path, f))
337
self._transport.put_multi(ctrl_files)
159
338
160
339
def _make_control(self):
161
os.mkdir(self.controlfilename([]))
162
self.controlfile('README', 'w').write(
340
from bzrlib.inventory import Inventory
341
from cStringIO import StringIO
342
343
# Create an empty inventory
344
sio = StringIO()
345
# if we want per-tree root ids then this is the place to set
346
# them; they're not needed for now and so ommitted for
347
# simplicity.
348
bzrlib.xml.serializer_v4.write_inventory(Inventory(), sio)
349
350
dirs = [[], 'text-store', 'inventory-store', 'revision-store']
351
files = [('README',
163
352
"This is a Bazaar-NG control directory.\n"
164
"Do not change any files in this directory.")
165
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
166
for d in ('text-store', 'inventory-store', 'revision-store'):
167
os.mkdir(self.controlfilename(d))
168
for f in ('revision-history', 'merged-patches',
169
'pending-merged-patches', 'branch-name'):
170
self.controlfile(f, 'w').write('')
171
mutter('created control directory in ' + self.base)
172
Inventory().write_xml(self.controlfile('inventory','w'))
173
353
"Do not change any files in this directory.\n"),
354
('branch-format', BZR_BRANCH_FORMAT),
355
('revision-history', ''),
356
('merged-patches', ''),
357
('pending-merged-patches', ''),
358
('branch-name', ''),
359
('branch-lock', ''),
360
('pending-merges', ''),
361
('inventory', sio.getvalue())
362
]
363
self._transport.mkdir_multi([self._rel_controlfilename(d) for d in dirs])
364
self.put_controlfiles(files)
365
mutter('created control directory in ' + self._transport.base)
174
366
175
367
def _check_format(self):
176
368
"""Check this branch format is supported.
179
371
180
372
In the future, we might need different in-memory Branch
181
373
classes to support downlevel branches. But not yet.
182
"""
183
# read in binary mode to detect newline wierdness.
184
fmt = self.controlfile('branch-format', 'rb').read()
374
"""
375
# This ignores newlines so that we can open branches created
376
# on Windows from Linux and so on. I think it might be better
377
# to always make all internal files in unix format.
378
try:
379
fmt = self.controlfile('branch-format', 'r').read()
380
except NoSuchFile:
381
raise NotBranchError('Could not find .bzr/branch-format in %s'
382
% self._transport.base)
383
fmt = fmt.replace('\r\n', '\n')
185
384
if fmt != BZR_BRANCH_FORMAT:
186
bailout('sorry, branch format %r not supported' % fmt,
187
['use a different bzr version',
188
'or remove the .bzr directory and "bzr init" again'])
189
385
raise BzrError('sorry, branch format %r not supported' % fmt,
386
['use a different bzr version',
387
'or remove the .bzr directory and "bzr init" again'])
388
389
# We know that the format is the currently supported one.
390
# So create the rest of the entries.
391
from bzrlib.store.compressed_text import CompressedTextStore
392
393
if self._transport.should_cache():
394
import tempfile
395
self.cache_root = tempfile.mkdtemp(prefix='bzr-cache')
396
mutter('Branch %r using caching in %r' % (self, self.cache_root))
397
else:
398
self.cache_root = None
399
400
def get_store(name):
401
relpath = self._rel_controlfilename(name)
402
store = CompressedTextStore(self._transport.clone(relpath))
403
if self._transport.should_cache():
404
from meta_store import CachedStore
405
cache_path = os.path.join(self.cache_root, name)
406
os.mkdir(cache_path)
407
store = CachedStore(store, cache_path)
408
return store
409
410
self.text_store = get_store('text-store')
411
self.revision_store = get_store('revision-store')
412
self.inventory_store = get_store('inventory-store')
413
414
def get_root_id(self):
415
"""Return the id of this branches root"""
416
inv = self.read_working_inventory()
417
return inv.root.file_id
418
419
def set_root_id(self, file_id):
420
inv = self.read_working_inventory()
421
orig_root_id = inv.root.file_id
422
del inv._byid[inv.root.file_id]
423
inv.root.file_id = file_id
424
inv._byid[inv.root.file_id] = inv.root
425
for fid in inv:
426
entry = inv[fid]
427
if entry.parent_id in (None, orig_root_id):
428
entry.parent_id = inv.root.file_id
429
self._write_inventory(inv)
190
430
191
431
def read_working_inventory(self):
192
432
"""Read the working inventory."""
193
before = time.time()
194
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
195
mutter("loaded inventory of %d items in %f"
196
% (len(inv), time.time() - before))
197
return inv
198
433
from bzrlib.inventory import Inventory
434
self.lock_read()
435
try:
436
# ElementTree does its own conversion from UTF-8, so open in
437
# binary.
438
f = self.controlfile('inventory', 'rb')
439
return bzrlib.xml.serializer_v4.read_inventory(f)
440
finally:
441
self.unlock()
442
199
443
200
444
def _write_inventory(self, inv):
201
445
"""Update the working inventory.
203
447
That is to say, the inventory describing changes underway, that
204
448
will be committed to the next revision.
205
449
"""
206
## TODO: factor out to atomicfile? is rename safe on windows?
207
## TODO: Maybe some kind of clean/dirty marker on inventory?
208
tmpfname = self.controlfilename('inventory.tmp')
209
tmpf = file(tmpfname, 'w')
210
inv.write_xml(tmpf)
211
tmpf.close()
212
os.rename(tmpfname, self.controlfilename('inventory'))
450
from cStringIO import StringIO
451
self.lock_write()
452
try:
453
sio = StringIO()
454
bzrlib.xml.serializer_v4.write_inventory(inv, sio)
455
sio.seek(0)
456
# Transport handles atomicity
457
self.put_controlfile('inventory', sio)
458
finally:
459
self.unlock()
460
213
461
mutter('wrote working inventory')
214
462
215
463
216
464
inventory = property(read_working_inventory, _write_inventory, None,
217
465
"""Inventory for the working copy.""")
218
466
219
467
220
def add(self, files, verbose=False):
468
def add(self, files, ids=None):
221
469
"""Make files versioned.
222
470
471
Note that the command line normally calls smart_add instead,
472
which can automatically recurse.
473
223
474
This puts the files in the Added state, so that they will be
224
475
recorded by the next commit.
225
476
226
:todo: Perhaps have an option to add the ids even if the files do
227
not (yet) exist.
228
229
:todo: Perhaps return the ids of the files? But then again it
230
is easy to retrieve them if they're needed.
231
232
:todo: Option to specify file id.
233
234
:todo: Adding a directory should optionally recurse down and
235
add all non-ignored children. Perhaps do that in a
236
higher-level method.
237
238
>>> b = ScratchBranch(files=['foo'])
239
>>> 'foo' in b.unknowns()
240
True
241
>>> b.show_status()
242
? foo
243
>>> b.add('foo')
244
>>> 'foo' in b.unknowns()
245
False
246
>>> bool(b.inventory.path2id('foo'))
247
True
248
>>> b.show_status()
249
A foo
250
251
>>> b.add('foo')
252
Traceback (most recent call last):
253
...
254
BzrError: ('foo is already versioned', [])
255
256
>>> b.add(['nothere'])
257
Traceback (most recent call last):
258
BzrError: ('cannot add: not a regular file or directory: nothere', [])
477
files
478
List of paths to add, relative to the base of the tree.
479
480
ids
481
If set, use these instead of automatically generated ids.
482
Must be the same length as the list of files, but may
483
contain None for ids that are to be autogenerated.
484
485
TODO: Perhaps have an option to add the ids even if the files do
486
not (yet) exist.
487
488
TODO: Perhaps yield the ids and paths as they're added.
259
489
"""
260
261
490
# TODO: Re-adding a file that is removed in the working copy
262
491
# should probably put it back with the previous ID.
263
if isinstance(files, types.StringTypes):
492
if isinstance(files, basestring):
493
assert(ids is None or isinstance(ids, basestring))
264
494
files = [files]
265
266
inv = self.read_working_inventory()
267
for f in files:
268
if is_control_file(f):
269
bailout("cannot add control file %s" % quotefn(f))
270
271
fp = splitpath(f)
272
273
if len(fp) == 0:
274
bailout("cannot add top-level %r" % f)
275
276
fullpath = os.path.normpath(self.abspath(f))
277
278
try:
279
kind = file_kind(fullpath)
280
except OSError:
281
# maybe something better?
282
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
283
284
if kind != 'file' and kind != 'directory':
285
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
286
287
file_id = gen_file_id(f)
288
inv.add_path(f, kind=kind, file_id=file_id)
289
290
if verbose:
291
show_status('A', kind, quotefn(f))
292
293
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
294
295
self._write_inventory(inv)
296
495
if ids is not None:
496
ids = [ids]
497
498
if ids is None:
499
ids = [None] * len(files)
500
else:
501
assert(len(ids) == len(files))
502
503
self.lock_write()
504
try:
505
inv = self.read_working_inventory()
506
for f,file_id in zip(files, ids):
507
if is_control_file(f):
508
raise BzrError("cannot add control file %s" % quotefn(f))
509
510
fp = splitpath(f)
511
512
if len(fp) == 0:
513
raise BzrError("cannot add top-level %r" % f)
514
515
fullpath = os.path.normpath(self.abspath(f))
516
517
try:
518
kind = file_kind(fullpath)
519
except OSError:
520
# maybe something better?
521
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
522
523
if kind != 'file' and kind != 'directory':
524
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
525
526
if file_id is None:
527
file_id = gen_file_id(f)
528
inv.add_path(f, kind=kind, file_id=file_id)
529
530
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
531
532
self._write_inventory(inv)
533
finally:
534
self.unlock()
535
536
537
def print_file(self, file, revno):
538
"""Print `file` to stdout."""
539
self.lock_read()
540
try:
541
tree = self.revision_tree(self.get_rev_id(revno))
542
# use inventory as it was in that revision
543
file_id = tree.inventory.path2id(file)
544
if not file_id:
545
raise BzrError("%r is not present in revision %s" % (file, revno))
546
tree.print_file(file_id)
547
finally:
548
self.unlock()
297
549
298
550
299
551
def remove(self, files, verbose=False):
301
553
302
554
This does not remove their text. This does not run on
303
555
304
:todo: Refuse to remove modified files unless --force is given?
305
306
>>> b = ScratchBranch(files=['foo'])
307
>>> b.add('foo')
308
>>> b.inventory.has_filename('foo')
309
True
310
>>> b.remove('foo')
311
>>> b.working_tree().has_filename('foo')
312
True
313
>>> b.inventory.has_filename('foo')
314
False
315
316
>>> b = ScratchBranch(files=['foo'])
317
>>> b.add('foo')
318
>>> b.commit('one')
319
>>> b.remove('foo')
320
>>> b.commit('two')
321
>>> b.inventory.has_filename('foo')
322
False
323
>>> b.basis_tree().has_filename('foo')
324
False
325
>>> b.working_tree().has_filename('foo')
326
True
327
328
:todo: Do something useful with directories.
329
330
:todo: Should this remove the text or not? Tough call; not
556
TODO: Refuse to remove modified files unless --force is given?
557
558
TODO: Do something useful with directories.
559
560
TODO: Should this remove the text or not? Tough call; not
331
561
removing may be useful and the user can just use use rm, and
332
562
is the opposite of add. Removing it is consistent with most
333
563
other tools. Maybe an option.
334
564
"""
335
565
## TODO: Normalize names
336
566
## TODO: Remove nested loops; better scalability
337
338
if isinstance(files, types.StringTypes):
567
if isinstance(files, basestring):
339
568
files = [files]
340
341
tree = self.working_tree()
342
inv = tree.inventory
343
344
# do this before any modifications
345
for f in files:
346
fid = inv.path2id(f)
347
if not fid:
348
bailout("cannot remove unversioned file %s" % quotefn(f))
349
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
350
if verbose:
351
# having remove it, it must be either ignored or unknown
352
if tree.is_ignored(f):
353
new_status = 'I'
354
else:
355
new_status = '?'
356
show_status(new_status, inv[fid].kind, quotefn(f))
357
del inv[fid]
358
569
570
self.lock_write()
571
572
try:
573
tree = self.working_tree()
574
inv = tree.inventory
575
576
# do this before any modifications
577
for f in files:
578
fid = inv.path2id(f)
579
if not fid:
580
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
581
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
582
if verbose:
583
# having remove it, it must be either ignored or unknown
584
if tree.is_ignored(f):
585
new_status = 'I'
586
else:
587
new_status = '?'
588
show_status(new_status, inv[fid].kind, quotefn(f))
589
del inv[fid]
590
591
self._write_inventory(inv)
592
finally:
593
self.unlock()
594
595
596
# FIXME: this doesn't need to be a branch method
597
def set_inventory(self, new_inventory_list):
598
from bzrlib.inventory import Inventory, InventoryEntry
599
inv = Inventory(self.get_root_id())
600
for path, file_id, parent, kind in new_inventory_list:
601
name = os.path.basename(path)
602
if name == "":
603
continue
604
inv.add(InventoryEntry(file_id, name, kind, parent))
359
605
self._write_inventory(inv)
360
606
361
607
378
624
return self.working_tree().unknowns()
379
625
380
626
381
def commit(self, message, timestamp=None, timezone=None,
382
committer=None,
383
verbose=False):
384
"""Commit working copy as a new revision.
385
386
The basic approach is to add all the file texts into the
387
store, then the inventory, then make a new revision pointing
388
to that inventory and store that.
389
390
This is not quite safe if the working copy changes during the
391
commit; for the moment that is simply not allowed. A better
392
approach is to make a temporary copy of the files before
393
computing their hashes, and then add those hashes in turn to
394
the inventory. This should mean at least that there are no
395
broken hash pointers. There is no way we can get a snapshot
396
of the whole directory at an instant. This would also have to
397
be robust against files disappearing, moving, etc. So the
398
whole thing is a bit hard.
399
400
:param timestamp: if not None, seconds-since-epoch for a
401
postdated/predated commit.
402
"""
403
404
## TODO: Show branch names
405
406
# TODO: Don't commit if there are no changes, unless forced?
407
408
# First walk over the working inventory; and both update that
409
# and also build a new revision inventory. The revision
410
# inventory needs to hold the text-id, sha1 and size of the
411
# actual file versions committed in the revision. (These are
412
# not present in the working inventory.) We also need to
413
# detect missing/deleted files, and remove them from the
414
# working inventory.
415
416
work_inv = self.read_working_inventory()
417
inv = Inventory()
418
basis = self.basis_tree()
419
basis_inv = basis.inventory
420
missing_ids = []
421
for path, entry in work_inv.iter_entries():
422
## TODO: Cope with files that have gone missing.
423
424
## TODO: Check that the file kind has not changed from the previous
425
## revision of this file (if any).
426
427
entry = entry.copy()
428
429
p = self.abspath(path)
430
file_id = entry.file_id
431
mutter('commit prep file %s, id %r ' % (p, file_id))
432
433
if not os.path.exists(p):
434
mutter(" file is missing, removing from inventory")
435
if verbose:
436
show_status('D', entry.kind, quotefn(path))
437
missing_ids.append(file_id)
438
continue
439
440
# TODO: Handle files that have been deleted
441
442
# TODO: Maybe a special case for empty files? Seems a
443
# waste to store them many times.
444
445
inv.add(entry)
446
447
if basis_inv.has_id(file_id):
448
old_kind = basis_inv[file_id].kind
449
if old_kind != entry.kind:
450
bailout("entry %r changed kind from %r to %r"
451
% (file_id, old_kind, entry.kind))
452
453
if entry.kind == 'directory':
454
if not isdir(p):
455
bailout("%s is entered as directory but not a directory" % quotefn(p))
456
elif entry.kind == 'file':
457
if not isfile(p):
458
bailout("%s is entered as file but is not a file" % quotefn(p))
459
460
content = file(p, 'rb').read()
461
462
entry.text_sha1 = sha_string(content)
463
entry.text_size = len(content)
464
465
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
466
if (old_ie
467
and (old_ie.text_size == entry.text_size)
468
and (old_ie.text_sha1 == entry.text_sha1)):
469
## assert content == basis.get_file(file_id).read()
470
entry.text_id = basis_inv[file_id].text_id
471
mutter(' unchanged from previous text_id {%s}' %
472
entry.text_id)
473
474
else:
475
entry.text_id = gen_file_id(entry.name)
476
self.text_store.add(content, entry.text_id)
477
mutter(' stored with text_id {%s}' % entry.text_id)
478
if verbose:
479
if not old_ie:
480
state = 'A'
481
elif (old_ie.name == entry.name
482
and old_ie.parent_id == entry.parent_id):
483
state = 'M'
484
else:
485
state = 'R'
486
487
show_status(state, entry.kind, quotefn(path))
488
489
for file_id in missing_ids:
490
# have to do this later so we don't mess up the iterator.
491
# since parents may be removed before their children we
492
# have to test.
493
494
# FIXME: There's probably a better way to do this; perhaps
495
# the workingtree should know how to filter itself.
496
if work_inv.has_id(file_id):
497
del work_inv[file_id]
498
499
500
inv_id = rev_id = _gen_revision_id(time.time())
501
502
inv_tmp = tempfile.TemporaryFile()
503
inv.write_xml(inv_tmp)
504
inv_tmp.seek(0)
505
self.inventory_store.add(inv_tmp, inv_id)
506
mutter('new inventory_id is {%s}' % inv_id)
507
508
self._write_inventory(work_inv)
509
510
if timestamp == None:
511
timestamp = time.time()
512
513
if committer == None:
514
committer = username()
515
516
if timezone == None:
517
timezone = local_time_offset()
518
519
mutter("building commit log message")
520
rev = Revision(timestamp=timestamp,
521
timezone=timezone,
522
committer=committer,
523
precursor = self.last_patch(),
524
message = message,
525
inventory_id=inv_id,
526
revision_id=rev_id)
527
528
rev_tmp = tempfile.TemporaryFile()
529
rev.write_xml(rev_tmp)
530
rev_tmp.seek(0)
531
self.revision_store.add(rev_tmp, rev_id)
532
mutter("new revision_id is {%s}" % rev_id)
533
534
## XXX: Everything up to here can simply be orphaned if we abort
535
## the commit; it will leave junk files behind but that doesn't
536
## matter.
537
538
## TODO: Read back the just-generated changeset, and make sure it
539
## applies and recreates the right state.
540
541
## TODO: Also calculate and store the inventory SHA1
542
mutter("committing patch r%d" % (self.revno() + 1))
543
544
mutter("append to revision-history")
545
f = self.controlfile('revision-history', 'at')
546
f.write(rev_id + '\n')
547
f.close()
548
549
if verbose:
550
note("commited r%d" % self.revno())
627
def append_revision(self, *revision_ids):
628
for revision_id in revision_ids:
629
mutter("add {%s} to revision-history" % revision_id)
630
631
rev_history = self.revision_history()
632
rev_history.extend(revision_ids)
633
634
self.lock_write()
635
try:
636
self.put_controlfile('revision-history', '\n'.join(rev_history))
637
finally:
638
self.unlock()
639
640
641
def get_revision_xml_file(self, revision_id):
642
"""Return XML file object for revision object."""
643
if not revision_id or not isinstance(revision_id, basestring):
644
raise InvalidRevisionId(revision_id)
645
646
self.lock_read()
647
try:
648
try:
649
return self.revision_store[revision_id]
650
except (IndexError, KeyError):
651
raise bzrlib.errors.NoSuchRevision(self, revision_id)
652
finally:
653
self.unlock()
654
655
656
#deprecated
657
get_revision_xml = get_revision_xml_file
551
658
552
659
553
660
def get_revision(self, revision_id):
554
661
"""Return the Revision object for a named revision"""
555
r = Revision.read_xml(self.revision_store[revision_id])
662
xml_file = self.get_revision_xml_file(revision_id)
663
664
try:
665
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
666
except SyntaxError, e:
667
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
668
[revision_id,
669
str(e)])
670
556
671
assert r.revision_id == revision_id
557
672
return r
558
673
559
674
675
def get_revision_delta(self, revno):
676
"""Return the delta for one revision.
677
678
The delta is relative to its mainline predecessor, or the
679
empty tree for revision 1.
680
"""
681
assert isinstance(revno, int)
682
rh = self.revision_history()
683
if not (1 <= revno <= len(rh)):
684
raise InvalidRevisionNumber(revno)
685
686
# revno is 1-based; list is 0-based
687
688
new_tree = self.revision_tree(rh[revno-1])
689
if revno == 1:
690
old_tree = EmptyTree()
691
else:
692
old_tree = self.revision_tree(rh[revno-2])
693
694
return compare_trees(old_tree, new_tree)
695
696
697
def get_revisions(self, revision_ids, pb=None):
698
"""Return the Revision object for a set of named revisions"""
699
from bzrlib.revision import Revision
700
from bzrlib.xml import unpack_xml
701
702
# TODO: We need to decide what to do here
703
# we cannot use a generator with a try/finally, because
704
# you cannot guarantee that the caller will iterate through
705
# all entries.
706
# in the past, get_inventory wasn't even wrapped in a
707
# try/finally locking block.
708
# We could either lock without the try/finally, or just
709
# not lock at all. We are reading entries that should
710
# never be updated.
711
# I prefer locking with no finally, so that if someone
712
# asks for a list of revisions, but doesn't consume them,
713
# that is their problem, and they will suffer the consequences
714
self.lock_read()
715
for xml_file in self.revision_store.get(revision_ids, pb=pb):
716
try:
717
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
718
except SyntaxError, e:
719
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
720
[revision_id,
721
str(e)])
722
yield r
723
self.unlock()
724
725
def get_revision_sha1(self, revision_id):
726
"""Hash the stored value of a revision, and return it."""
727
# In the future, revision entries will be signed. At that
728
# point, it is probably best *not* to include the signature
729
# in the revision hash. Because that lets you re-sign
730
# the revision, (add signatures/remove signatures) and still
731
# have all hash pointers stay consistent.
732
# But for now, just hash the contents.
733
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
734
735
560
736
def get_inventory(self, inventory_id):
561
737
"""Get Inventory object by hash.
562
738
563
:todo: Perhaps for this and similar methods, take a revision
739
TODO: Perhaps for this and similar methods, take a revision
564
740
parameter which can be either an integer revno or a
565
string hash."""
566
i = Inventory.read_xml(self.inventory_store[inventory_id])
567
return i
741
string hash.
742
"""
743
f = self.get_inventory_xml_file(inventory_id)
744
return bzrlib.xml.serializer_v4.read_inventory(f)
745
746
747
def get_inventory_xml(self, inventory_id):
748
"""Get inventory XML as a file object."""
749
# Shouldn't this have a read-lock around it?
750
# As well as some sort of trap for missing ids?
751
return self.inventory_store[inventory_id]
752
753
get_inventory_xml_file = get_inventory_xml
754
755
def get_inventories(self, inventory_ids, pb=None, permit_failure=False):
756
"""Get Inventory objects by id
757
"""
758
# See the discussion in get_revisions for why
759
# we don't use a try/finally block here
760
self.lock_read()
761
for f in self.inventory_store.get(inventory_ids,
762
permit_failure=permit_failure, pb=pb):
763
if f is not None:
764
# TODO: Possibly put a try/except around this to handle
765
# read serialization errors
766
r = bzrlib.xml.serializer_v4.read_inventory(f)
767
yield r
768
elif permit_failure:
769
yield None
770
else:
771
raise bzrlib.errors.NoSuchRevision(self, revision_id)
772
self.unlock()
773
774
def get_inventory_sha1(self, inventory_id):
775
"""Return the sha1 hash of the inventory entry
776
"""
777
return sha_file(self.get_inventory_xml(inventory_id))
568
778
569
779
570
780
def get_revision_inventory(self, revision_id):
571
781
"""Return inventory of a past revision."""
782
# bzr 0.0.6 imposes the constraint that the inventory_id
783
# must be the same as its revision, so this is trivial.
572
784
if revision_id == None:
573
return Inventory()
785
from bzrlib.inventory import Inventory
786
return Inventory(self.get_root_id())
574
787
else:
575
return self.get_inventory(self.get_revision(revision_id).inventory_id)
788
return self.get_inventory(revision_id)
576
789
577
790
578
791
def revision_history(self):
581
794
>>> ScratchBranch().revision_history()
582
795
[]
583
796
"""
584
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
797
self.lock_read()
798
try:
799
return [l.rstrip('\r\n') for l in
800
self.controlfile('revision-history', 'r').readlines()]
801
finally:
802
self.unlock()
803
804
805
def common_ancestor(self, other, self_revno=None, other_revno=None):
806
"""
807
>>> from bzrlib.commit import commit
808
>>> sb = ScratchBranch(files=['foo', 'foo~'])
809
>>> sb.common_ancestor(sb) == (None, None)
810
True
811
>>> commit(sb, "Committing first revision", verbose=False)
812
>>> sb.common_ancestor(sb)[0]
813
1
814
>>> clone = sb.clone()
815
>>> commit(sb, "Committing second revision", verbose=False)
816
>>> sb.common_ancestor(sb)[0]
817
2
818
>>> sb.common_ancestor(clone)[0]
819
1
820
>>> commit(clone, "Committing divergent second revision",
821
... verbose=False)
822
>>> sb.common_ancestor(clone)[0]
823
1
824
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
825
True
826
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
827
True
828
>>> clone2 = sb.clone()
829
>>> sb.common_ancestor(clone2)[0]
830
2
831
>>> sb.common_ancestor(clone2, self_revno=1)[0]
832
1
833
>>> sb.common_ancestor(clone2, other_revno=1)[0]
834
1
835
"""
836
my_history = self.revision_history()
837
other_history = other.revision_history()
838
if self_revno is None:
839
self_revno = len(my_history)
840
if other_revno is None:
841
other_revno = len(other_history)
842
indices = range(min((self_revno, other_revno)))
843
indices.reverse()
844
for r in indices:
845
if my_history[r] == other_history[r]:
846
return r+1, my_history[r]
847
return None, None
585
848
586
849
587
850
def revno(self):
589
852
590
853
That is equivalent to the number of revisions committed to
591
854
this branch.
592
593
>>> b = ScratchBranch()
594
>>> b.revno()
595
0
596
>>> b.commit('no foo')
597
>>> b.revno()
598
1
599
855
"""
600
856
return len(self.revision_history())
601
857
602
858
603
859
def last_patch(self):
604
860
"""Return last patch hash, or None if no history.
605
606
>>> ScratchBranch().last_patch() == None
607
True
608
861
"""
609
862
ph = self.revision_history()
610
863
if ph:
611
864
return ph[-1]
612
613
614
def lookup_revision(self, revno):
615
"""Return revision hash for revision number."""
865
else:
866
return None
867
868
869
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
870
"""
871
If self and other have not diverged, return a list of the revisions
872
present in other, but missing from self.
873
874
>>> from bzrlib.commit import commit
875
>>> bzrlib.trace.silent = True
876
>>> br1 = ScratchBranch()
877
>>> br2 = ScratchBranch()
878
>>> br1.missing_revisions(br2)
879
[]
880
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
881
>>> br1.missing_revisions(br2)
882
[u'REVISION-ID-1']
883
>>> br2.missing_revisions(br1)
884
[]
885
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
886
>>> br1.missing_revisions(br2)
887
[]
888
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
889
>>> br1.missing_revisions(br2)
890
[u'REVISION-ID-2A']
891
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
892
>>> br1.missing_revisions(br2)
893
Traceback (most recent call last):
894
DivergedBranches: These branches have diverged.
895
"""
896
self_history = self.revision_history()
897
self_len = len(self_history)
898
other_history = other.revision_history()
899
other_len = len(other_history)
900
common_index = min(self_len, other_len) -1
901
if common_index >= 0 and \
902
self_history[common_index] != other_history[common_index]:
903
raise DivergedBranches(self, other)
904
905
if stop_revision is None:
906
stop_revision = other_len
907
elif stop_revision > other_len:
908
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
909
910
return other_history[self_len:stop_revision]
911
912
913
def update_revisions(self, other, stop_revision=None):
914
"""Pull in all new revisions from other branch.
915
"""
916
from bzrlib.fetch import greedy_fetch
917
from bzrlib.revision import get_intervening_revisions
918
919
pb = bzrlib.ui.ui_factory.progress_bar()
920
pb.update('comparing histories')
921
if stop_revision is None:
922
other_revision = other.last_patch()
923
else:
924
other_revision = other.get_rev_id(stop_revision)
925
count = greedy_fetch(self, other, other_revision, pb)[0]
926
try:
927
revision_ids = self.missing_revisions(other, stop_revision)
928
except DivergedBranches, e:
929
try:
930
revision_ids = get_intervening_revisions(self.last_patch(),
931
other_revision, self)
932
assert self.last_patch() not in revision_ids
933
except bzrlib.errors.NotAncestor:
934
raise e
935
936
self.append_revision(*revision_ids)
937
pb.clear()
938
939
def install_revisions(self, other, revision_ids, pb):
940
# We are going to iterate this many times, so make sure
941
# that it is a list, and not a generator
942
revision_ids = list(revision_ids)
943
if hasattr(other.revision_store, "prefetch"):
944
other.revision_store.prefetch(revision_ids)
945
if hasattr(other.inventory_store, "prefetch"):
946
other.inventory_store.prefetch(revision_ids)
947
948
if pb is None:
949
pb = bzrlib.ui.ui_factory.progress_bar()
950
951
# This entire next section is generally done
952
# with either generators, or bulk updates
953
inventories = other.get_inventories(revision_ids, permit_failure=True)
954
needed_texts = set()
955
956
failures = set()
957
good_revisions = set()
958
for i, (inv, rev_id) in enumerate(zip(inventories, revision_ids)):
959
pb.update('fetching revision', i+1, len(revision_ids))
960
961
# We don't really need to get the revision here, because
962
# the only thing we needed was the inventory_id, which now
963
# is (by design) identical to the revision_id
964
# try:
965
# rev = other.get_revision(rev_id)
966
# except bzrlib.errors.NoSuchRevision:
967
# failures.add(rev_id)
968
# continue
969
970
if inv is None:
971
failures.add(rev_id)
972
continue
973
else:
974
good_revisions.add(rev_id)
975
976
text_ids = []
977
for key, entry in inv.iter_entries():
978
if entry.text_id is None:
979
continue
980
text_ids.append(entry.text_id)
981
982
has_ids = self.text_store.has(text_ids)
983
for has, text_id in zip(has_ids, text_ids):
984
if not has:
985
needed_texts.add(text_id)
986
987
pb.clear()
988
989
count, cp_fail = self.text_store.copy_multi(other.text_store,
990
needed_texts)
991
#print "Added %d texts." % count
992
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
993
good_revisions)
994
#print "Added %d inventories." % count
995
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
996
good_revisions,
997
permit_failure=True)
998
assert len(cp_fail) == 0
999
return count, failures
1000
1001
1002
def commit(self, *args, **kw):
1003
from bzrlib.commit import commit
1004
commit(self, *args, **kw)
1005
1006
1007
def revision_id_to_revno(self, revision_id):
1008
"""Given a revision id, return its revno"""
1009
history = self.revision_history()
1010
try:
1011
return history.index(revision_id) + 1
1012
except ValueError:
1013
raise bzrlib.errors.NoSuchRevision(self, revision_id)
1014
1015
1016
def get_rev_id(self, revno, history=None):
1017
"""Find the revision id of the specified revno."""
616
1018
if revno == 0:
617
1019
return None
618
619
try:
620
# list is 0-based; revisions are 1-based
621
return self.revision_history()[revno-1]
622
except IndexError:
623
bailout("no such revision %s" % revno)
1020
if history is None:
1021
history = self.revision_history()
1022
elif revno <= 0 or revno > len(history):
1023
raise bzrlib.errors.NoSuchRevision(self, revno)
1024
return history[revno - 1]
624
1025
625
1026
626
1027
def revision_tree(self, revision_id):
628
1029
629
1030
`revision_id` may be None for the null revision, in which case
630
1031
an `EmptyTree` is returned."""
631
1032
# TODO: refactor this to use an existing revision object
1033
# so we don't need to read it in twice.
632
1034
if revision_id == None:
633
1035
return EmptyTree()
634
1036
else:
638
1040
639
1041
def working_tree(self):
640
1042
"""Return a `Tree` for the working copy."""
641
return WorkingTree(self.base, self.read_working_inventory())
1043
from bzrlib.workingtree import WorkingTree
1044
# TODO: In the future, WorkingTree should utilize Transport
1045
return WorkingTree(self._transport.base, self.read_working_inventory())
642
1046
643
1047
644
1048
def basis_tree(self):
645
1049
"""Return `Tree` object for last revision.
646
1050
647
1051
If there are no revisions yet, return an `EmptyTree`.
648
649
>>> b = ScratchBranch(files=['foo'])
650
>>> b.basis_tree().has_filename('foo')
651
False
652
>>> b.working_tree().has_filename('foo')
653
True
654
>>> b.add('foo')
655
>>> b.commit('add foo')
656
>>> b.basis_tree().has_filename('foo')
657
True
658
1052
"""
659
1053
r = self.last_patch()
660
1054
if r == None:
664
1058
665
1059
666
1060
667
def write_log(self, show_timezone='original'):
668
"""Write out human-readable log of commits to this branch
669
670
:param utc: If true, show dates in universal time, not local time."""
671
## TODO: Option to choose either original, utc or local timezone
672
revno = 1
673
precursor = None
674
for p in self.revision_history():
675
print '-' * 40
676
print 'revno:', revno
677
## TODO: Show hash if --id is given.
678
##print 'revision-hash:', p
679
rev = self.get_revision(p)
680
print 'committer:', rev.committer
681
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
682
show_timezone))
683
684
## opportunistic consistency check, same as check_patch_chaining
685
if rev.precursor != precursor:
686
bailout("mismatched precursor!")
687
688
print 'message:'
689
if not rev.message:
690
print ' (no message)'
691
else:
692
for l in rev.message.split('\n'):
693
print ' ' + l
694
695
revno += 1
696
precursor = p
697
698
699
700
def show_status(branch, show_all=False):
701
"""Display single-line status for non-ignored working files.
702
703
The list is show sorted in order by file name.
704
705
>>> b = ScratchBranch(files=['foo', 'foo~'])
706
>>> b.show_status()
707
? foo
708
>>> b.add('foo')
709
>>> b.show_status()
710
A foo
711
>>> b.commit("add foo")
712
>>> b.show_status()
713
>>> os.unlink(b.abspath('foo'))
714
>>> b.show_status()
715
D foo
716
717
718
:todo: Get state for single files.
719
720
:todo: Perhaps show a slash at the end of directory names.
721
722
"""
723
724
# We have to build everything into a list first so that it can
725
# sorted by name, incorporating all the different sources.
726
727
# FIXME: Rather than getting things in random order and then sorting,
728
# just step through in order.
729
730
# Interesting case: the old ID for a file has been removed,
731
# but a new file has been created under that name.
732
733
old = branch.basis_tree()
734
old_inv = old.inventory
735
new = branch.working_tree()
736
new_inv = new.inventory
737
738
for fs, fid, oldname, newname, kind in diff_trees(old, new):
739
if fs == 'R':
740
show_status(fs, kind,
741
oldname + ' => ' + newname)
742
elif fs == 'A' or fs == 'M':
743
show_status(fs, kind, newname)
744
elif fs == 'D':
745
show_status(fs, kind, oldname)
746
elif fs == '.':
747
if show_all:
748
show_status(fs, kind, newname)
749
elif fs == 'I':
750
if show_all:
751
show_status(fs, kind, newname)
752
elif fs == '?':
753
show_status(fs, kind, newname)
754
else:
755
bailout("wierd file state %r" % ((fs, fid),))
756
757
758
759
class ScratchBranch(Branch):
1061
def rename_one(self, from_rel, to_rel):
1062
"""Rename one file.
1063
1064
This can change the directory or the filename or both.
1065
"""
1066
self.lock_write()
1067
try:
1068
tree = self.working_tree()
1069
inv = tree.inventory
1070
if not tree.has_filename(from_rel):
1071
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1072
if tree.has_filename(to_rel):
1073
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1074
1075
file_id = inv.path2id(from_rel)
1076
if file_id == None:
1077
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1078
1079
if inv.path2id(to_rel):
1080
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1081
1082
to_dir, to_tail = os.path.split(to_rel)
1083
to_dir_id = inv.path2id(to_dir)
1084
if to_dir_id == None and to_dir != '':
1085
raise BzrError("can't determine destination directory id for %r" % to_dir)
1086
1087
mutter("rename_one:")
1088
mutter(" file_id {%s}" % file_id)
1089
mutter(" from_rel %r" % from_rel)
1090
mutter(" to_rel %r" % to_rel)
1091
mutter(" to_dir %r" % to_dir)
1092
mutter(" to_dir_id {%s}" % to_dir_id)
1093
1094
inv.rename(file_id, to_dir_id, to_tail)
1095
1096
from_abs = self.abspath(from_rel)
1097
to_abs = self.abspath(to_rel)
1098
try:
1099
os.rename(from_abs, to_abs)
1100
except OSError, e:
1101
raise BzrError("failed to rename %r to %r: %s"
1102
% (from_abs, to_abs, e[1]),
1103
["rename rolled back"])
1104
1105
self._write_inventory(inv)
1106
finally:
1107
self.unlock()
1108
1109
1110
def move(self, from_paths, to_name):
1111
"""Rename files.
1112
1113
to_name must exist as a versioned directory.
1114
1115
If to_name exists and is a directory, the files are moved into
1116
it, keeping their old names. If it is a directory,
1117
1118
Note that to_name is only the last component of the new name;
1119
this doesn't change the directory.
1120
1121
This returns a list of (from_path, to_path) pairs for each
1122
entry that is moved.
1123
"""
1124
result = []
1125
self.lock_write()
1126
try:
1127
## TODO: Option to move IDs only
1128
assert not isinstance(from_paths, basestring)
1129
tree = self.working_tree()
1130
inv = tree.inventory
1131
to_abs = self.abspath(to_name)
1132
if not isdir(to_abs):
1133
raise BzrError("destination %r is not a directory" % to_abs)
1134
if not tree.has_filename(to_name):
1135
raise BzrError("destination %r not in working directory" % to_abs)
1136
to_dir_id = inv.path2id(to_name)
1137
if to_dir_id == None and to_name != '':
1138
raise BzrError("destination %r is not a versioned directory" % to_name)
1139
to_dir_ie = inv[to_dir_id]
1140
if to_dir_ie.kind not in ('directory', 'root_directory'):
1141
raise BzrError("destination %r is not a directory" % to_abs)
1142
1143
to_idpath = inv.get_idpath(to_dir_id)
1144
1145
for f in from_paths:
1146
if not tree.has_filename(f):
1147
raise BzrError("%r does not exist in working tree" % f)
1148
f_id = inv.path2id(f)
1149
if f_id == None:
1150
raise BzrError("%r is not versioned" % f)
1151
name_tail = splitpath(f)[-1]
1152
dest_path = appendpath(to_name, name_tail)
1153
if tree.has_filename(dest_path):
1154
raise BzrError("destination %r already exists" % dest_path)
1155
if f_id in to_idpath:
1156
raise BzrError("can't move %r to a subdirectory of itself" % f)
1157
1158
# OK, so there's a race here, it's possible that someone will
1159
# create a file in this interval and then the rename might be
1160
# left half-done. But we should have caught most problems.
1161
1162
for f in from_paths:
1163
name_tail = splitpath(f)[-1]
1164
dest_path = appendpath(to_name, name_tail)
1165
result.append((f, dest_path))
1166
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1167
try:
1168
os.rename(self.abspath(f), self.abspath(dest_path))
1169
except OSError, e:
1170
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1171
["rename rolled back"])
1172
1173
self._write_inventory(inv)
1174
finally:
1175
self.unlock()
1176
1177
return result
1178
1179
1180
def revert(self, filenames, old_tree=None, backups=True):
1181
"""Restore selected files to the versions from a previous tree.
1182
1183
backups
1184
If true (default) backups are made of files before
1185
they're renamed.
1186
"""
1187
from bzrlib.errors import NotVersionedError, BzrError
1188
from bzrlib.atomicfile import AtomicFile
1189
from bzrlib.osutils import backup_file
1190
1191
inv = self.read_working_inventory()
1192
if old_tree is None:
1193
old_tree = self.basis_tree()
1194
old_inv = old_tree.inventory
1195
1196
nids = []
1197
for fn in filenames:
1198
file_id = inv.path2id(fn)
1199
if not file_id:
1200
raise NotVersionedError("not a versioned file", fn)
1201
if not old_inv.has_id(file_id):
1202
raise BzrError("file not present in old tree", fn, file_id)
1203
nids.append((fn, file_id))
1204
1205
# TODO: Rename back if it was previously at a different location
1206
1207
# TODO: If given a directory, restore the entire contents from
1208
# the previous version.
1209
1210
# TODO: Make a backup to a temporary file.
1211
1212
# TODO: If the file previously didn't exist, delete it?
1213
for fn, file_id in nids:
1214
backup_file(fn)
1215
1216
f = AtomicFile(fn, 'wb')
1217
try:
1218
f.write(old_tree.get_file(file_id).read())
1219
f.commit()
1220
finally:
1221
f.close()
1222
1223
1224
def pending_merges(self):
1225
"""Return a list of pending merges.
1226
1227
These are revisions that have been merged into the working
1228
directory but not yet committed.
1229
"""
1230
cfn = self._rel_controlfilename('pending-merges')
1231
if not self._transport.has(cfn):
1232
return []
1233
p = []
1234
for l in self.controlfile('pending-merges', 'r').readlines():
1235
p.append(l.rstrip('\n'))
1236
return p
1237
1238
1239
def add_pending_merge(self, *revision_ids):
1240
from bzrlib.revision import validate_revision_id
1241
1242
for rev_id in revision_ids:
1243
validate_revision_id(rev_id)
1244
1245
p = self.pending_merges()
1246
updated = False
1247
for rev_id in revision_ids:
1248
if rev_id in p:
1249
continue
1250
p.append(rev_id)
1251
updated = True
1252
if updated:
1253
self.set_pending_merges(p)
1254
1255
def set_pending_merges(self, rev_list):
1256
self.lock_write()
1257
try:
1258
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1259
finally:
1260
self.unlock()
1261
1262
1263
def get_parent(self):
1264
"""Return the parent location of the branch.
1265
1266
This is the default location for push/pull/missing. The usual
1267
pattern is that the user can override it by specifying a
1268
location.
1269
"""
1270
import errno
1271
_locs = ['parent', 'pull', 'x-pull']
1272
for l in _locs:
1273
try:
1274
return self.controlfile(l, 'r').read().strip('\n')
1275
except IOError, e:
1276
if e.errno != errno.ENOENT:
1277
raise
1278
return None
1279
1280
1281
def set_parent(self, url):
1282
# TODO: Maybe delete old location files?
1283
from bzrlib.atomicfile import AtomicFile
1284
self.lock_write()
1285
try:
1286
f = AtomicFile(self.controlfilename('parent'))
1287
try:
1288
f.write(url + '\n')
1289
f.commit()
1290
finally:
1291
f.close()
1292
finally:
1293
self.unlock()
1294
1295
def check_revno(self, revno):
1296
"""\
1297
Check whether a revno corresponds to any revision.
1298
Zero (the NULL revision) is considered valid.
1299
"""
1300
if revno != 0:
1301
self.check_real_revno(revno)
1302
1303
def check_real_revno(self, revno):
1304
"""\
1305
Check whether a revno corresponds to a real revision.
1306
Zero (the NULL revision) is considered invalid
1307
"""
1308
if revno < 1 or revno > self.revno():
1309
raise InvalidRevisionNumber(revno)
1310
1311
1312
1313
1314
1315
class ScratchBranch(_Branch):
760
1316
"""Special test class: a branch that cleans up after itself.
761
1317
762
1318
>>> b = ScratchBranch()
763
1319
>>> isdir(b.base)
764
1320
True
765
1321
>>> bd = b.base
766
>>> del b
1322
>>> b.destroy()
767
1323
>>> isdir(bd)
768
1324
False
769
1325
"""
770
def __init__(self, files=[], dirs=[]):
1326
def __init__(self, files=[], dirs=[], base=None):
771
1327
"""Make a test branch.
772
1328
773
1329
This creates a temporary directory and runs init-tree in it.
774
1330
775
1331
If any files are listed, they are created in the working copy.
776
1332
"""
777
Branch.__init__(self, tempfile.mkdtemp(), init=True)
1333
from tempfile import mkdtemp
1334
init = False
1335
if base is None:
1336
base = mkdtemp()
1337
init = True
1338
_Branch.__init__(self, base, init=init)
778
1339
for d in dirs:
779
os.mkdir(self.abspath(d))
1340
self._transport.mkdir(d)
780
1341
781
1342
for f in files:
782
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
783
784
1343
self._transport.put(f, 'content of %s' % f)
1344
1345
1346
def clone(self):
1347
"""
1348
>>> orig = ScratchBranch(files=["file1", "file2"])
1349
>>> clone = orig.clone()
1350
>>> os.path.samefile(orig.base, clone.base)
1351
False
1352
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1353
True
1354
"""
1355
from shutil import copytree
1356
from tempfile import mkdtemp
1357
base = mkdtemp()
1358
os.rmdir(base)
1359
copytree(self.base, base, symlinks=True)
1360
return ScratchBranch(base=base)
1361
1362
1363
785
1364
def __del__(self):
1365
self.destroy()
1366
1367
def destroy(self):
786
1368
"""Destroy the test branch, removing the scratch directory."""
787
shutil.rmtree(self.base)
1369
from shutil import rmtree
1370
try:
1371
if self.base:
1372
mutter("delete ScratchBranch %s" % self.base)
1373
rmtree(self.base)
1374
except OSError, e:
1375
# Work around for shutil.rmtree failing on Windows when
1376
# readonly files are encountered
1377
mutter("hit exception in destroying ScratchBranch: %s" % e)
1378
for root, dirs, files in os.walk(self.base, topdown=False):
1379
for name in files:
1380
os.chmod(os.path.join(root, name), 0700)
1381
rmtree(self.base)
1382
self._transport = None
788
1383
789
1384
790
1385
807
1402
808
1403
809
1404
810
def _gen_revision_id(when):
811
"""Return new revision-id."""
812
s = '%s-%s-' % (user_email(), compact_date(when))
813
s += hexlify(rand_bytes(8))
814
return s
815
816
817
1405
def gen_file_id(name):
818
1406
"""Return new file id.
819
1407
820
1408
This should probably generate proper UUIDs, but for the moment we
821
1409
cope with just randomness because running uuidgen every time is
822
1410
slow."""
1411
import re
1412
from binascii import hexlify
1413
from time import time
1414
1415
# get last component
823
1416
idx = name.rfind('/')
824
1417
if idx != -1:
825
1418
name = name[idx+1 : ]
1419
idx = name.rfind('\\')
1420
if idx != -1:
1421
name = name[idx+1 : ]
826
1422
1423
# make it not a hidden file
827
1424
name = name.lstrip('.')
828
1425
1426
# remove any wierd characters; we don't escape them but rather
1427
# just pull them out
1428
name = re.sub(r'[^\w.]', '', name)
1429
829
1430
s = hexlify(rand_bytes(8))
830
return '-'.join((name, compact_date(time.time()), s))
831
832
1431
return '-'.join((name, compact_date(time()), s))
1432
1433
1434
def gen_root_id():
1435
"""Return a new tree-root file id."""
1436
return gen_file_id('TREE_ROOT')
1437
1438
1439
def copy_branch(branch_from, to_location, revision=None):
1440
"""Copy branch_from into the existing directory to_location.
1441
1442
revision
1443
If not None, only revisions up to this point will be copied.
1444
The head of the new branch will be that revision.
1445
1446
to_location
1447
The name of a local directory that exists but is empty.
1448
"""
1449
from bzrlib.merge import merge
1450
from bzrlib.revisionspec import RevisionSpec
1451
1452
assert isinstance(branch_from, Branch)
1453
assert isinstance(to_location, basestring)
1454
1455
br_to = Branch.initialize(to_location)
1456
br_to.set_root_id(branch_from.get_root_id())
1457
if revision is None:
1458
revno = branch_from.revno()
1459
else:
1460
revno, rev_id = RevisionSpec(revision).in_history(branch_from)
1461
br_to.update_revisions(branch_from, stop_revision=revno)
1462
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1463
check_clean=False, ignore_zero=True)
1464
br_to.set_parent(branch_from.base)
1465
return br_to
Loggerhead is a web-based interface for Breezy
Version: 2.0.1