« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1185.1.29
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.1.29
- Committer: Robert Collins
- Date: 2005-09-19 06:05:19 UTC
- mfrom: (974.1.92)
- mto: (1185.41.1 bzr.sftp) (1092.3.4) (1417.1.4) (1464.1.1) (1534.1.1 integration) (1495.1.4) (1505.1.16 bzr-bound-branch) (1508.1.15) (1526.1.3 run_tests_twice_for_i18n) (1540.1.3 bzr.dev (Main development branch)) (1685.1.1 bzr-encoding) (1553.5.1 bzr.dev (Main development branch)) (1608.2.1 bzr.mbp.escape-stores) (1393.1.21)
- mto: This revision was merged to the branch mainline in revision 1390.
- Revision ID: robertc@robertcollins.net-20050919060519-f582f62146b0b458
merge merge tweaks from aaron, which includes latest .dev
- files added:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files removed:
- bzrlib/statcache.py
- files renamed:
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/urlgrabber/
- contrib/bash/bzr => contrib/bash/bzr.simple
- 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
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
19
import traceback, socket, fnmatch, difflib, time
20
from binascii import hexlify
18
import sys
19
import os
21
20
22
21
import bzrlib
23
from inventory import Inventory
24
from trace import mutter, note
25
from tree import Tree, EmptyTree, RevisionTree
26
from inventory import InventoryEntry, Inventory
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
28
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
29
joinpath, sha_string, file_kind, local_time_offset, appendpath
30
from store import ImmutableStore
31
from revision import Revision
32
from errors import bailout, BzrError
33
from textui import show_status
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
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
36
34
37
35
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
36
39
## TODO: Maybe include checks for common corruption of newlines, etc?
37
40
38
41
39
40
def find_branch(f, **args):
41
if f and (f.startswith('http://') or f.startswith('https://')):
42
import remotebranch
43
return remotebranch.RemoteBranch(f, **args)
42
# TODO: Some operations like log might retrieve the same revisions
43
# repeatedly to calculate deltas. We could perhaps have a weakref
44
# cache in memory to make this faster.
45
46
def find_branch(*ignored, **ignored_too):
47
# XXX: leave this here for about one release, then remove it
48
raise NotImplementedError('find_branch() is not supported anymore, '
49
'please use one of the new branch constructors')
50
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)
44
72
else:
45
return Branch(f, **args)
73
raise NotBranchError("path %r is not within branch %r" % (rp, base))
74
75
return os.sep.join(s)
46
76
47
77
48
78
def find_branch_root(f=None):
53
83
It is not necessary that f exists.
54
84
55
85
Basically we keep looking up until we find the control directory or
56
run into the root."""
86
run into the root. If there isn't one, raises NotBranchError.
87
"""
57
88
if f == None:
58
89
f = os.getcwd()
59
90
elif hasattr(os.path, 'realpath'):
72
103
head, tail = os.path.split(f)
73
104
if head == f:
74
105
# reached the root, whatever that may be
75
raise BzrError('%r is not in a branch' % orig_f)
106
raise NotBranchError('%s is not in a branch' % orig_f)
76
107
f = head
77
108
109
78
110
79
111
80
112
######################################################################
84
116
"""Branch holding a history of revisions.
85
117
86
118
base
87
Base directory of the branch.
119
Base directory/url of the branch.
88
120
"""
89
_lockmode = None
90
121
base = None
91
92
def __init__(self, base, init=False, find_root=True, lock_mode='w'):
122
123
def __init__(self, *ignored, **ignored_too):
124
raise NotImplementedError('The Branch class is abstract')
125
126
@staticmethod
127
def open(base):
128
"""Open an existing branch, rooted at 'base' (url)"""
129
if base and (base.startswith('http://') or base.startswith('https://')):
130
from bzrlib.remotebranch import RemoteBranch
131
return RemoteBranch(base, find_root=False)
132
else:
133
return LocalBranch(base, find_root=False)
134
135
@staticmethod
136
def open_containing(url):
137
"""Open an existing branch, containing url (search upwards for the root)
138
"""
139
if url and (url.startswith('http://') or url.startswith('https://')):
140
from bzrlib.remotebranch import RemoteBranch
141
return RemoteBranch(url)
142
else:
143
return LocalBranch(url)
144
145
@staticmethod
146
def initialize(base):
147
"""Create a new branch, rooted at 'base' (url)"""
148
if base and (base.startswith('http://') or base.startswith('https://')):
149
from bzrlib.remotebranch import RemoteBranch
150
return RemoteBranch(base, init=True)
151
else:
152
return LocalBranch(base, init=True)
153
154
def setup_caching(self, cache_root):
155
"""Subclasses that care about caching should override this, and set
156
up cached stores located under cache_root.
157
"""
158
159
160
class LocalBranch(Branch):
161
"""A branch stored in the actual filesystem.
162
163
Note that it's "local" in the context of the filesystem; it doesn't
164
really matter if it's on an nfs/smb/afs/coda/... share, as long as
165
it's writable, and can be accessed via the normal filesystem API.
166
167
_lock_mode
168
None, or 'r' or 'w'
169
170
_lock_count
171
If _lock_mode is true, a positive count of the number of times the
172
lock has been taken.
173
174
_lock
175
Lock object from bzrlib.lock.
176
"""
177
# We actually expect this class to be somewhat short-lived; part of its
178
# purpose is to try to isolate what bits of the branch logic are tied to
179
# filesystem access, so that in a later step, we can extricate them to
180
# a separarte ("storage") class.
181
_lock_mode = None
182
_lock_count = None
183
_lock = None
184
185
def __init__(self, base, init=False, find_root=True):
93
186
"""Create new branch object at a particular location.
94
187
95
base -- Base directory for the branch.
188
base -- Base directory for the branch. May be a file:// url.
96
189
97
190
init -- If True, create new control files in a previously
98
191
unversioned directory. If False, the branch must already
104
197
In the test suite, creation of new trees is tested using the
105
198
`ScratchBranch` class.
106
199
"""
200
from bzrlib.store import ImmutableStore
107
201
if init:
108
202
self.base = os.path.realpath(base)
109
203
self._make_control()
110
204
elif find_root:
111
205
self.base = find_branch_root(base)
112
206
else:
207
if base.startswith("file://"):
208
base = base[7:]
113
209
self.base = os.path.realpath(base)
114
210
if not isdir(self.controlfilename('.')):
115
bailout("not a bzr branch: %s" % quotefn(base),
116
['use "bzr init" to initialize a new working tree',
117
'current bzr can only operate from top-of-tree'])
211
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
212
['use "bzr init" to initialize a new working tree',
213
'current bzr can only operate from top-of-tree'])
118
214
self._check_format()
119
self.lock(lock_mode)
120
215
121
216
self.text_store = ImmutableStore(self.controlfilename('text-store'))
122
217
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
130
225
__repr__ = __str__
131
226
132
227
133
134
def lock(self, mode='w'):
135
"""Lock the on-disk branch, excluding other processes."""
136
try:
137
import fcntl, errno
138
139
if mode == 'w':
140
lm = fcntl.LOCK_EX
141
om = os.O_WRONLY | os.O_CREAT
142
elif mode == 'r':
143
lm = fcntl.LOCK_SH
144
om = os.O_RDONLY
145
else:
146
raise BzrError("invalid locking mode %r" % mode)
147
148
try:
149
lockfile = os.open(self.controlfilename('branch-lock'), om)
150
except OSError, e:
151
if e.errno == errno.ENOENT:
152
# might not exist on branches from <0.0.4
153
self.controlfile('branch-lock', 'w').close()
154
lockfile = os.open(self.controlfilename('branch-lock'), om)
155
else:
156
raise e
157
158
fcntl.lockf(lockfile, lm)
159
def unlock():
160
fcntl.lockf(lockfile, fcntl.LOCK_UN)
161
os.close(lockfile)
162
self._lockmode = None
163
self.unlock = unlock
164
self._lockmode = mode
165
except ImportError:
166
warning("please write a locking method for platform %r" % sys.platform)
167
def unlock():
168
self._lockmode = None
169
self.unlock = unlock
170
self._lockmode = mode
171
172
173
def _need_readlock(self):
174
if self._lockmode not in ['r', 'w']:
175
raise BzrError('need read lock on branch, only have %r' % self._lockmode)
176
177
def _need_writelock(self):
178
if self._lockmode not in ['w']:
179
raise BzrError('need write lock on branch, only have %r' % self._lockmode)
180
228
def __del__(self):
229
if self._lock_mode or self._lock:
230
from bzrlib.warnings import warn
231
warn("branch %r was not explicitly unlocked" % self)
232
self._lock.unlock()
233
234
def lock_write(self):
235
if self._lock_mode:
236
if self._lock_mode != 'w':
237
from bzrlib.errors import LockError
238
raise LockError("can't upgrade to a write lock from %r" %
239
self._lock_mode)
240
self._lock_count += 1
241
else:
242
from bzrlib.lock import WriteLock
243
244
self._lock = WriteLock(self.controlfilename('branch-lock'))
245
self._lock_mode = 'w'
246
self._lock_count = 1
247
248
249
def lock_read(self):
250
if self._lock_mode:
251
assert self._lock_mode in ('r', 'w'), \
252
"invalid lock mode %r" % self._lock_mode
253
self._lock_count += 1
254
else:
255
from bzrlib.lock import ReadLock
256
257
self._lock = ReadLock(self.controlfilename('branch-lock'))
258
self._lock_mode = 'r'
259
self._lock_count = 1
260
261
def unlock(self):
262
if not self._lock_mode:
263
from bzrlib.errors import LockError
264
raise LockError('branch %r is not locked' % (self))
265
266
if self._lock_count > 1:
267
self._lock_count -= 1
268
else:
269
self._lock.unlock()
270
self._lock = None
271
self._lock_mode = self._lock_count = None
181
272
182
273
def abspath(self, name):
183
274
"""Return absolute filename for something in the branch"""
184
275
return os.path.join(self.base, name)
185
276
186
187
277
def relpath(self, path):
188
278
"""Return path relative to this branch of something inside it.
189
279
190
280
Raises an error if path is not in this branch."""
191
rp = os.path.realpath(path)
192
# FIXME: windows
193
if not rp.startswith(self.base):
194
bailout("path %r is not within branch %r" % (rp, self.base))
195
rp = rp[len(self.base):]
196
rp = rp.lstrip(os.sep)
197
return rp
198
281
return _relpath(self.base, path)
199
282
200
283
def controlfilename(self, file_or_path):
201
284
"""Return location relative to branch."""
202
if isinstance(file_or_path, types.StringTypes):
285
if isinstance(file_or_path, basestring):
203
286
file_or_path = [file_or_path]
204
287
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
205
288
229
312
else:
230
313
raise BzrError("invalid controlfile mode %r" % mode)
231
314
232
233
234
315
def _make_control(self):
316
from bzrlib.inventory import Inventory
317
235
318
os.mkdir(self.controlfilename([]))
236
319
self.controlfile('README', 'w').write(
237
320
"This is a Bazaar-NG control directory.\n"
238
"Do not change any files in this directory.")
321
"Do not change any files in this directory.\n")
239
322
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
240
323
for d in ('text-store', 'inventory-store', 'revision-store'):
241
324
os.mkdir(self.controlfilename(d))
242
325
for f in ('revision-history', 'merged-patches',
243
326
'pending-merged-patches', 'branch-name',
244
'branch-lock'):
327
'branch-lock',
328
'pending-merges'):
245
329
self.controlfile(f, 'w').write('')
246
330
mutter('created control directory in ' + self.base)
247
Inventory().write_xml(self.controlfile('inventory','w'))
331
332
# if we want per-tree root ids then this is the place to set
333
# them; they're not needed for now and so ommitted for
334
# simplicity.
335
f = self.controlfile('inventory','w')
336
bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
248
337
249
338
250
339
def _check_format(self):
259
348
# on Windows from Linux and so on. I think it might be better
260
349
# to always make all internal files in unix format.
261
350
fmt = self.controlfile('branch-format', 'r').read()
262
fmt.replace('\r\n', '')
351
fmt = fmt.replace('\r\n', '\n')
263
352
if fmt != BZR_BRANCH_FORMAT:
264
bailout('sorry, branch format %r not supported' % fmt,
265
['use a different bzr version',
266
'or remove the .bzr directory and "bzr init" again'])
267
353
raise BzrError('sorry, branch format %r not supported' % fmt,
354
['use a different bzr version',
355
'or remove the .bzr directory and "bzr init" again'])
356
357
def get_root_id(self):
358
"""Return the id of this branches root"""
359
inv = self.read_working_inventory()
360
return inv.root.file_id
361
362
def set_root_id(self, file_id):
363
inv = self.read_working_inventory()
364
orig_root_id = inv.root.file_id
365
del inv._byid[inv.root.file_id]
366
inv.root.file_id = file_id
367
inv._byid[inv.root.file_id] = inv.root
368
for fid in inv:
369
entry = inv[fid]
370
if entry.parent_id in (None, orig_root_id):
371
entry.parent_id = inv.root.file_id
372
self._write_inventory(inv)
268
373
269
374
def read_working_inventory(self):
270
375
"""Read the working inventory."""
271
self._need_readlock()
272
before = time.time()
273
# ElementTree does its own conversion from UTF-8, so open in
274
# binary.
275
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
276
mutter("loaded inventory of %d items in %f"
277
% (len(inv), time.time() - before))
278
return inv
279
376
from bzrlib.inventory import Inventory
377
self.lock_read()
378
try:
379
# ElementTree does its own conversion from UTF-8, so open in
380
# binary.
381
f = self.controlfile('inventory', 'rb')
382
return bzrlib.xml.serializer_v4.read_inventory(f)
383
finally:
384
self.unlock()
385
280
386
281
387
def _write_inventory(self, inv):
282
388
"""Update the working inventory.
284
390
That is to say, the inventory describing changes underway, that
285
391
will be committed to the next revision.
286
392
"""
287
self._need_writelock()
288
## TODO: factor out to atomicfile? is rename safe on windows?
289
## TODO: Maybe some kind of clean/dirty marker on inventory?
290
tmpfname = self.controlfilename('inventory.tmp')
291
tmpf = file(tmpfname, 'wb')
292
inv.write_xml(tmpf)
293
tmpf.close()
294
inv_fname = self.controlfilename('inventory')
295
if sys.platform == 'win32':
296
os.remove(inv_fname)
297
os.rename(tmpfname, inv_fname)
393
from bzrlib.atomicfile import AtomicFile
394
395
self.lock_write()
396
try:
397
f = AtomicFile(self.controlfilename('inventory'), 'wb')
398
try:
399
bzrlib.xml.serializer_v4.write_inventory(inv, f)
400
f.commit()
401
finally:
402
f.close()
403
finally:
404
self.unlock()
405
298
406
mutter('wrote working inventory')
299
407
300
408
301
409
inventory = property(read_working_inventory, _write_inventory, None,
302
410
"""Inventory for the working copy.""")
303
411
304
412
305
def add(self, files, verbose=False, ids=None):
413
def add(self, files, ids=None):
306
414
"""Make files versioned.
307
415
308
Note that the command line normally calls smart_add instead.
416
Note that the command line normally calls smart_add instead,
417
which can automatically recurse.
309
418
310
419
This puts the files in the Added state, so that they will be
311
420
recorded by the next commit.
312
421
422
files
423
List of paths to add, relative to the base of the tree.
424
425
ids
426
If set, use these instead of automatically generated ids.
427
Must be the same length as the list of files, but may
428
contain None for ids that are to be autogenerated.
429
313
430
TODO: Perhaps have an option to add the ids even if the files do
314
not (yet) exist.
315
316
TODO: Perhaps return the ids of the files? But then again it
317
is easy to retrieve them if they're needed.
318
319
TODO: Option to specify file id.
320
321
TODO: Adding a directory should optionally recurse down and
322
add all non-ignored children. Perhaps do that in a
323
higher-level method.
431
not (yet) exist.
432
433
TODO: Perhaps yield the ids and paths as they're added.
324
434
"""
325
self._need_writelock()
326
327
435
# TODO: Re-adding a file that is removed in the working copy
328
436
# should probably put it back with the previous ID.
329
if isinstance(files, types.StringTypes):
330
assert(ids is None or isinstance(ids, types.StringTypes))
437
if isinstance(files, basestring):
438
assert(ids is None or isinstance(ids, basestring))
331
439
files = [files]
332
440
if ids is not None:
333
441
ids = [ids]
336
444
ids = [None] * len(files)
337
445
else:
338
446
assert(len(ids) == len(files))
339
340
inv = self.read_working_inventory()
341
for f,file_id in zip(files, ids):
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
if file_id is None:
362
file_id = gen_file_id(f)
363
inv.add_path(f, kind=kind, file_id=file_id)
364
365
if verbose:
366
show_status('A', kind, quotefn(f))
367
368
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
369
370
self._write_inventory(inv)
371
447
448
self.lock_write()
449
try:
450
inv = self.read_working_inventory()
451
for f,file_id in zip(files, ids):
452
if is_control_file(f):
453
raise BzrError("cannot add control file %s" % quotefn(f))
454
455
fp = splitpath(f)
456
457
if len(fp) == 0:
458
raise BzrError("cannot add top-level %r" % f)
459
460
fullpath = os.path.normpath(self.abspath(f))
461
462
try:
463
kind = file_kind(fullpath)
464
except OSError:
465
# maybe something better?
466
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
467
468
if kind != 'file' and kind != 'directory':
469
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
470
471
if file_id is None:
472
file_id = gen_file_id(f)
473
inv.add_path(f, kind=kind, file_id=file_id)
474
475
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
476
477
self._write_inventory(inv)
478
finally:
479
self.unlock()
480
372
481
373
482
def print_file(self, file, revno):
374
483
"""Print `file` to stdout."""
375
self._need_readlock()
376
tree = self.revision_tree(self.lookup_revision(revno))
377
# use inventory as it was in that revision
378
file_id = tree.inventory.path2id(file)
379
if not file_id:
380
bailout("%r is not present in revision %d" % (file, revno))
381
tree.print_file(file_id)
382
484
self.lock_read()
485
try:
486
tree = self.revision_tree(self.get_rev_id(revno))
487
# use inventory as it was in that revision
488
file_id = tree.inventory.path2id(file)
489
if not file_id:
490
raise BzrError("%r is not present in revision %s" % (file, revno))
491
tree.print_file(file_id)
492
finally:
493
self.unlock()
494
383
495
384
496
def remove(self, files, verbose=False):
385
497
"""Mark nominated files for removal from the inventory.
397
509
"""
398
510
## TODO: Normalize names
399
511
## TODO: Remove nested loops; better scalability
400
self._need_writelock()
401
402
if isinstance(files, types.StringTypes):
512
if isinstance(files, basestring):
403
513
files = [files]
404
405
tree = self.working_tree()
406
inv = tree.inventory
407
408
# do this before any modifications
409
for f in files:
410
fid = inv.path2id(f)
411
if not fid:
412
bailout("cannot remove unversioned file %s" % quotefn(f))
413
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
414
if verbose:
415
# having remove it, it must be either ignored or unknown
416
if tree.is_ignored(f):
417
new_status = 'I'
418
else:
419
new_status = '?'
420
show_status(new_status, inv[fid].kind, quotefn(f))
421
del inv[fid]
422
423
self._write_inventory(inv)
424
514
515
self.lock_write()
516
517
try:
518
tree = self.working_tree()
519
inv = tree.inventory
520
521
# do this before any modifications
522
for f in files:
523
fid = inv.path2id(f)
524
if not fid:
525
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
526
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
527
if verbose:
528
# having remove it, it must be either ignored or unknown
529
if tree.is_ignored(f):
530
new_status = 'I'
531
else:
532
new_status = '?'
533
show_status(new_status, inv[fid].kind, quotefn(f))
534
del inv[fid]
535
536
self._write_inventory(inv)
537
finally:
538
self.unlock()
539
540
541
# FIXME: this doesn't need to be a branch method
425
542
def set_inventory(self, new_inventory_list):
426
inv = Inventory()
543
from bzrlib.inventory import Inventory, InventoryEntry
544
inv = Inventory(self.get_root_id())
427
545
for path, file_id, parent, kind in new_inventory_list:
428
546
name = os.path.basename(path)
429
547
if name == "":
451
569
return self.working_tree().unknowns()
452
570
453
571
454
def append_revision(self, revision_id):
455
mutter("add {%s} to revision-history" % revision_id)
572
def append_revision(self, *revision_ids):
573
from bzrlib.atomicfile import AtomicFile
574
575
for revision_id in revision_ids:
576
mutter("add {%s} to revision-history" % revision_id)
577
456
578
rev_history = self.revision_history()
457
458
tmprhname = self.controlfilename('revision-history.tmp')
459
rhname = self.controlfilename('revision-history')
460
461
f = file(tmprhname, 'wt')
462
rev_history.append(revision_id)
463
f.write('\n'.join(rev_history))
464
f.write('\n')
465
f.close()
466
467
if sys.platform == 'win32':
468
os.remove(rhname)
469
os.rename(tmprhname, rhname)
470
579
rev_history.extend(revision_ids)
580
581
f = AtomicFile(self.controlfilename('revision-history'))
582
try:
583
for rev_id in rev_history:
584
print >>f, rev_id
585
f.commit()
586
finally:
587
f.close()
588
589
590
def get_revision_xml_file(self, revision_id):
591
"""Return XML file object for revision object."""
592
if not revision_id or not isinstance(revision_id, basestring):
593
raise InvalidRevisionId(revision_id)
594
595
self.lock_read()
596
try:
597
try:
598
return self.revision_store[revision_id]
599
except (IndexError, KeyError):
600
raise bzrlib.errors.NoSuchRevision(self, revision_id)
601
finally:
602
self.unlock()
603
604
605
#deprecated
606
get_revision_xml = get_revision_xml_file
471
607
472
608
473
609
def get_revision(self, revision_id):
474
610
"""Return the Revision object for a named revision"""
475
self._need_readlock()
476
r = Revision.read_xml(self.revision_store[revision_id])
611
xml_file = self.get_revision_xml_file(revision_id)
612
613
try:
614
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
615
except SyntaxError, e:
616
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
617
[revision_id,
618
str(e)])
619
477
620
assert r.revision_id == revision_id
478
621
return r
479
622
480
623
624
def get_revision_delta(self, revno):
625
"""Return the delta for one revision.
626
627
The delta is relative to its mainline predecessor, or the
628
empty tree for revision 1.
629
"""
630
assert isinstance(revno, int)
631
rh = self.revision_history()
632
if not (1 <= revno <= len(rh)):
633
raise InvalidRevisionNumber(revno)
634
635
# revno is 1-based; list is 0-based
636
637
new_tree = self.revision_tree(rh[revno-1])
638
if revno == 1:
639
old_tree = EmptyTree()
640
else:
641
old_tree = self.revision_tree(rh[revno-2])
642
643
return compare_trees(old_tree, new_tree)
644
645
646
647
def get_revision_sha1(self, revision_id):
648
"""Hash the stored value of a revision, and return it."""
649
# In the future, revision entries will be signed. At that
650
# point, it is probably best *not* to include the signature
651
# in the revision hash. Because that lets you re-sign
652
# the revision, (add signatures/remove signatures) and still
653
# have all hash pointers stay consistent.
654
# But for now, just hash the contents.
655
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
656
657
481
658
def get_inventory(self, inventory_id):
482
659
"""Get Inventory object by hash.
483
660
484
661
TODO: Perhaps for this and similar methods, take a revision
485
662
parameter which can be either an integer revno or a
486
663
string hash."""
487
self._need_readlock()
488
i = Inventory.read_xml(self.inventory_store[inventory_id])
489
return i
664
from bzrlib.inventory import Inventory
665
666
f = self.get_inventory_xml_file(inventory_id)
667
return bzrlib.xml.serializer_v4.read_inventory(f)
668
669
670
def get_inventory_xml(self, inventory_id):
671
"""Get inventory XML as a file object."""
672
return self.inventory_store[inventory_id]
673
674
get_inventory_xml_file = get_inventory_xml
675
676
677
def get_inventory_sha1(self, inventory_id):
678
"""Return the sha1 hash of the inventory entry
679
"""
680
return sha_file(self.get_inventory_xml(inventory_id))
490
681
491
682
492
683
def get_revision_inventory(self, revision_id):
493
684
"""Return inventory of a past revision."""
494
self._need_readlock()
685
# bzr 0.0.6 imposes the constraint that the inventory_id
686
# must be the same as its revision, so this is trivial.
495
687
if revision_id == None:
496
return Inventory()
688
from bzrlib.inventory import Inventory
689
return Inventory(self.get_root_id())
497
690
else:
498
return self.get_inventory(self.get_revision(revision_id).inventory_id)
691
return self.get_inventory(revision_id)
499
692
500
693
501
694
def revision_history(self):
504
697
>>> ScratchBranch().revision_history()
505
698
[]
506
699
"""
507
self._need_readlock()
508
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
509
510
511
def enum_history(self, direction):
512
"""Return (revno, revision_id) for history of branch.
513
514
direction
515
'forward' is from earliest to latest
516
'reverse' is from latest to earliest
517
"""
518
rh = self.revision_history()
519
if direction == 'forward':
520
i = 1
521
for rid in rh:
522
yield i, rid
523
i += 1
524
elif direction == 'reverse':
525
i = len(rh)
526
while i > 0:
527
yield i, rh[i-1]
528
i -= 1
529
else:
530
raise ValueError('invalid history direction', direction)
700
self.lock_read()
701
try:
702
return [l.rstrip('\r\n') for l in
703
self.controlfile('revision-history', 'r').readlines()]
704
finally:
705
self.unlock()
706
707
708
def common_ancestor(self, other, self_revno=None, other_revno=None):
709
"""
710
>>> from bzrlib.commit import commit
711
>>> sb = ScratchBranch(files=['foo', 'foo~'])
712
>>> sb.common_ancestor(sb) == (None, None)
713
True
714
>>> commit(sb, "Committing first revision", verbose=False)
715
>>> sb.common_ancestor(sb)[0]
716
1
717
>>> clone = sb.clone()
718
>>> commit(sb, "Committing second revision", verbose=False)
719
>>> sb.common_ancestor(sb)[0]
720
2
721
>>> sb.common_ancestor(clone)[0]
722
1
723
>>> commit(clone, "Committing divergent second revision",
724
... verbose=False)
725
>>> sb.common_ancestor(clone)[0]
726
1
727
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
728
True
729
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
730
True
731
>>> clone2 = sb.clone()
732
>>> sb.common_ancestor(clone2)[0]
733
2
734
>>> sb.common_ancestor(clone2, self_revno=1)[0]
735
1
736
>>> sb.common_ancestor(clone2, other_revno=1)[0]
737
1
738
"""
739
my_history = self.revision_history()
740
other_history = other.revision_history()
741
if self_revno is None:
742
self_revno = len(my_history)
743
if other_revno is None:
744
other_revno = len(other_history)
745
indices = range(min((self_revno, other_revno)))
746
indices.reverse()
747
for r in indices:
748
if my_history[r] == other_history[r]:
749
return r+1, my_history[r]
750
return None, None
531
751
532
752
533
753
def revno(self):
549
769
return None
550
770
551
771
772
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
773
"""
774
If self and other have not diverged, return a list of the revisions
775
present in other, but missing from self.
776
777
>>> from bzrlib.commit import commit
778
>>> bzrlib.trace.silent = True
779
>>> br1 = ScratchBranch()
780
>>> br2 = ScratchBranch()
781
>>> br1.missing_revisions(br2)
782
[]
783
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
784
>>> br1.missing_revisions(br2)
785
[u'REVISION-ID-1']
786
>>> br2.missing_revisions(br1)
787
[]
788
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
789
>>> br1.missing_revisions(br2)
790
[]
791
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
792
>>> br1.missing_revisions(br2)
793
[u'REVISION-ID-2A']
794
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
795
>>> br1.missing_revisions(br2)
796
Traceback (most recent call last):
797
DivergedBranches: These branches have diverged.
798
"""
799
self_history = self.revision_history()
800
self_len = len(self_history)
801
other_history = other.revision_history()
802
other_len = len(other_history)
803
common_index = min(self_len, other_len) -1
804
if common_index >= 0 and \
805
self_history[common_index] != other_history[common_index]:
806
raise DivergedBranches(self, other)
807
808
if stop_revision is None:
809
stop_revision = other_len
810
elif stop_revision > other_len:
811
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
812
813
return other_history[self_len:stop_revision]
814
815
816
def update_revisions(self, other, stop_revision=None):
817
"""Pull in all new revisions from other branch.
818
"""
819
from bzrlib.fetch import greedy_fetch
820
from bzrlib.revision import get_intervening_revisions
821
822
pb = bzrlib.ui.ui_factory.progress_bar()
823
pb.update('comparing histories')
824
if stop_revision is None:
825
other_revision = other.last_patch()
826
else:
827
other_revision = other.get_rev_id(stop_revision)
828
count = greedy_fetch(self, other, other_revision, pb)[0]
829
try:
830
revision_ids = self.missing_revisions(other, stop_revision)
831
except DivergedBranches, e:
832
try:
833
revision_ids = get_intervening_revisions(self.last_patch(),
834
other_revision, self)
835
assert self.last_patch() not in revision_ids
836
except bzrlib.errors.NotAncestor:
837
raise e
838
839
self.append_revision(*revision_ids)
840
pb.clear()
841
842
def install_revisions(self, other, revision_ids, pb):
843
if hasattr(other.revision_store, "prefetch"):
844
other.revision_store.prefetch(revision_ids)
845
if hasattr(other.inventory_store, "prefetch"):
846
inventory_ids = []
847
for rev_id in revision_ids:
848
try:
849
revision = other.get_revision(rev_id).inventory_id
850
inventory_ids.append(revision)
851
except bzrlib.errors.NoSuchRevision:
852
pass
853
other.inventory_store.prefetch(inventory_ids)
854
855
if pb is None:
856
pb = bzrlib.ui.ui_factory.progress_bar()
857
858
revisions = []
859
needed_texts = set()
860
i = 0
861
862
failures = set()
863
for i, rev_id in enumerate(revision_ids):
864
pb.update('fetching revision', i+1, len(revision_ids))
865
try:
866
rev = other.get_revision(rev_id)
867
except bzrlib.errors.NoSuchRevision:
868
failures.add(rev_id)
869
continue
870
871
revisions.append(rev)
872
inv = other.get_inventory(str(rev.inventory_id))
873
for key, entry in inv.iter_entries():
874
if entry.text_id is None:
875
continue
876
if entry.text_id not in self.text_store:
877
needed_texts.add(entry.text_id)
878
879
pb.clear()
880
881
count, cp_fail = self.text_store.copy_multi(other.text_store,
882
needed_texts)
883
#print "Added %d texts." % count
884
inventory_ids = [ f.inventory_id for f in revisions ]
885
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
886
inventory_ids)
887
#print "Added %d inventories." % count
888
revision_ids = [ f.revision_id for f in revisions]
889
890
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
891
revision_ids,
892
permit_failure=True)
893
assert len(cp_fail) == 0
894
return count, failures
895
896
552
897
def commit(self, *args, **kw):
553
"""Deprecated"""
554
898
from bzrlib.commit import commit
555
899
commit(self, *args, **kw)
556
900
901
def revision_id_to_revno(self, revision_id):
902
"""Given a revision id, return its revno"""
903
history = self.revision_history()
904
try:
905
return history.index(revision_id) + 1
906
except ValueError:
907
raise bzrlib.errors.NoSuchRevision(self, revision_id)
557
908
558
def lookup_revision(self, revno):
559
"""Return revision hash for revision number."""
909
def get_rev_id(self, revno, history=None):
910
"""Find the revision id of the specified revno."""
560
911
if revno == 0:
561
912
return None
562
563
try:
564
# list is 0-based; revisions are 1-based
565
return self.revision_history()[revno-1]
566
except IndexError:
567
raise BzrError("no such revision %s" % revno)
913
if history is None:
914
history = self.revision_history()
915
elif revno <= 0 or revno > len(history):
916
raise bzrlib.errors.NoSuchRevision(self, revno)
917
return history[revno - 1]
568
918
569
919
570
920
def revision_tree(self, revision_id):
574
924
an `EmptyTree` is returned."""
575
925
# TODO: refactor this to use an existing revision object
576
926
# so we don't need to read it in twice.
577
self._need_readlock()
578
927
if revision_id == None:
579
928
return EmptyTree()
580
929
else:
584
933
585
934
def working_tree(self):
586
935
"""Return a `Tree` for the working copy."""
587
from workingtree import WorkingTree
936
from bzrlib.workingtree import WorkingTree
588
937
return WorkingTree(self.base, self.read_working_inventory())
589
938
590
939
606
955
607
956
This can change the directory or the filename or both.
608
957
"""
609
self._need_writelock()
610
tree = self.working_tree()
611
inv = tree.inventory
612
if not tree.has_filename(from_rel):
613
bailout("can't rename: old working file %r does not exist" % from_rel)
614
if tree.has_filename(to_rel):
615
bailout("can't rename: new working file %r already exists" % to_rel)
616
617
file_id = inv.path2id(from_rel)
618
if file_id == None:
619
bailout("can't rename: old name %r is not versioned" % from_rel)
620
621
if inv.path2id(to_rel):
622
bailout("can't rename: new name %r is already versioned" % to_rel)
623
624
to_dir, to_tail = os.path.split(to_rel)
625
to_dir_id = inv.path2id(to_dir)
626
if to_dir_id == None and to_dir != '':
627
bailout("can't determine destination directory id for %r" % to_dir)
628
629
mutter("rename_one:")
630
mutter(" file_id {%s}" % file_id)
631
mutter(" from_rel %r" % from_rel)
632
mutter(" to_rel %r" % to_rel)
633
mutter(" to_dir %r" % to_dir)
634
mutter(" to_dir_id {%s}" % to_dir_id)
635
636
inv.rename(file_id, to_dir_id, to_tail)
637
638
print "%s => %s" % (from_rel, to_rel)
639
640
from_abs = self.abspath(from_rel)
641
to_abs = self.abspath(to_rel)
958
self.lock_write()
642
959
try:
643
os.rename(from_abs, to_abs)
644
except OSError, e:
645
bailout("failed to rename %r to %r: %s"
646
% (from_abs, to_abs, e[1]),
647
["rename rolled back"])
648
649
self._write_inventory(inv)
650
960
tree = self.working_tree()
961
inv = tree.inventory
962
if not tree.has_filename(from_rel):
963
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
964
if tree.has_filename(to_rel):
965
raise BzrError("can't rename: new working file %r already exists" % to_rel)
966
967
file_id = inv.path2id(from_rel)
968
if file_id == None:
969
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
970
971
if inv.path2id(to_rel):
972
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
973
974
to_dir, to_tail = os.path.split(to_rel)
975
to_dir_id = inv.path2id(to_dir)
976
if to_dir_id == None and to_dir != '':
977
raise BzrError("can't determine destination directory id for %r" % to_dir)
978
979
mutter("rename_one:")
980
mutter(" file_id {%s}" % file_id)
981
mutter(" from_rel %r" % from_rel)
982
mutter(" to_rel %r" % to_rel)
983
mutter(" to_dir %r" % to_dir)
984
mutter(" to_dir_id {%s}" % to_dir_id)
985
986
inv.rename(file_id, to_dir_id, to_tail)
987
988
from_abs = self.abspath(from_rel)
989
to_abs = self.abspath(to_rel)
990
try:
991
os.rename(from_abs, to_abs)
992
except OSError, e:
993
raise BzrError("failed to rename %r to %r: %s"
994
% (from_abs, to_abs, e[1]),
995
["rename rolled back"])
996
997
self._write_inventory(inv)
998
finally:
999
self.unlock()
651
1000
652
1001
653
1002
def move(self, from_paths, to_name):
660
1009
661
1010
Note that to_name is only the last component of the new name;
662
1011
this doesn't change the directory.
663
"""
664
self._need_writelock()
665
## TODO: Option to move IDs only
666
assert not isinstance(from_paths, basestring)
667
tree = self.working_tree()
668
inv = tree.inventory
669
to_abs = self.abspath(to_name)
670
if not isdir(to_abs):
671
bailout("destination %r is not a directory" % to_abs)
672
if not tree.has_filename(to_name):
673
bailout("destination %r not in working directory" % to_abs)
674
to_dir_id = inv.path2id(to_name)
675
if to_dir_id == None and to_name != '':
676
bailout("destination %r is not a versioned directory" % to_name)
677
to_dir_ie = inv[to_dir_id]
678
if to_dir_ie.kind not in ('directory', 'root_directory'):
679
bailout("destination %r is not a directory" % to_abs)
680
681
to_idpath = inv.get_idpath(to_dir_id)
682
683
for f in from_paths:
684
if not tree.has_filename(f):
685
bailout("%r does not exist in working tree" % f)
686
f_id = inv.path2id(f)
687
if f_id == None:
688
bailout("%r is not versioned" % f)
689
name_tail = splitpath(f)[-1]
690
dest_path = appendpath(to_name, name_tail)
691
if tree.has_filename(dest_path):
692
bailout("destination %r already exists" % dest_path)
693
if f_id in to_idpath:
694
bailout("can't move %r to a subdirectory of itself" % f)
695
696
# OK, so there's a race here, it's possible that someone will
697
# create a file in this interval and then the rename might be
698
# left half-done. But we should have caught most problems.
699
700
for f in from_paths:
701
name_tail = splitpath(f)[-1]
702
dest_path = appendpath(to_name, name_tail)
703
print "%s => %s" % (f, dest_path)
704
inv.rename(inv.path2id(f), to_dir_id, name_tail)
705
try:
706
os.rename(self.abspath(f), self.abspath(dest_path))
707
except OSError, e:
708
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
709
["rename rolled back"])
710
711
self._write_inventory(inv)
712
713
714
715
716
class ScratchBranch(Branch):
1012
1013
This returns a list of (from_path, to_path) pairs for each
1014
entry that is moved.
1015
"""
1016
result = []
1017
self.lock_write()
1018
try:
1019
## TODO: Option to move IDs only
1020
assert not isinstance(from_paths, basestring)
1021
tree = self.working_tree()
1022
inv = tree.inventory
1023
to_abs = self.abspath(to_name)
1024
if not isdir(to_abs):
1025
raise BzrError("destination %r is not a directory" % to_abs)
1026
if not tree.has_filename(to_name):
1027
raise BzrError("destination %r not in working directory" % to_abs)
1028
to_dir_id = inv.path2id(to_name)
1029
if to_dir_id == None and to_name != '':
1030
raise BzrError("destination %r is not a versioned directory" % to_name)
1031
to_dir_ie = inv[to_dir_id]
1032
if to_dir_ie.kind not in ('directory', 'root_directory'):
1033
raise BzrError("destination %r is not a directory" % to_abs)
1034
1035
to_idpath = inv.get_idpath(to_dir_id)
1036
1037
for f in from_paths:
1038
if not tree.has_filename(f):
1039
raise BzrError("%r does not exist in working tree" % f)
1040
f_id = inv.path2id(f)
1041
if f_id == None:
1042
raise BzrError("%r is not versioned" % f)
1043
name_tail = splitpath(f)[-1]
1044
dest_path = appendpath(to_name, name_tail)
1045
if tree.has_filename(dest_path):
1046
raise BzrError("destination %r already exists" % dest_path)
1047
if f_id in to_idpath:
1048
raise BzrError("can't move %r to a subdirectory of itself" % f)
1049
1050
# OK, so there's a race here, it's possible that someone will
1051
# create a file in this interval and then the rename might be
1052
# left half-done. But we should have caught most problems.
1053
1054
for f in from_paths:
1055
name_tail = splitpath(f)[-1]
1056
dest_path = appendpath(to_name, name_tail)
1057
result.append((f, dest_path))
1058
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1059
try:
1060
os.rename(self.abspath(f), self.abspath(dest_path))
1061
except OSError, e:
1062
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1063
["rename rolled back"])
1064
1065
self._write_inventory(inv)
1066
finally:
1067
self.unlock()
1068
1069
return result
1070
1071
1072
def revert(self, filenames, old_tree=None, backups=True):
1073
"""Restore selected files to the versions from a previous tree.
1074
1075
backups
1076
If true (default) backups are made of files before
1077
they're renamed.
1078
"""
1079
from bzrlib.errors import NotVersionedError, BzrError
1080
from bzrlib.atomicfile import AtomicFile
1081
from bzrlib.osutils import backup_file
1082
1083
inv = self.read_working_inventory()
1084
if old_tree is None:
1085
old_tree = self.basis_tree()
1086
old_inv = old_tree.inventory
1087
1088
nids = []
1089
for fn in filenames:
1090
file_id = inv.path2id(fn)
1091
if not file_id:
1092
raise NotVersionedError("not a versioned file", fn)
1093
if not old_inv.has_id(file_id):
1094
raise BzrError("file not present in old tree", fn, file_id)
1095
nids.append((fn, file_id))
1096
1097
# TODO: Rename back if it was previously at a different location
1098
1099
# TODO: If given a directory, restore the entire contents from
1100
# the previous version.
1101
1102
# TODO: Make a backup to a temporary file.
1103
1104
# TODO: If the file previously didn't exist, delete it?
1105
for fn, file_id in nids:
1106
backup_file(fn)
1107
1108
f = AtomicFile(fn, 'wb')
1109
try:
1110
f.write(old_tree.get_file(file_id).read())
1111
f.commit()
1112
finally:
1113
f.close()
1114
1115
1116
def pending_merges(self):
1117
"""Return a list of pending merges.
1118
1119
These are revisions that have been merged into the working
1120
directory but not yet committed.
1121
"""
1122
cfn = self.controlfilename('pending-merges')
1123
if not os.path.exists(cfn):
1124
return []
1125
p = []
1126
for l in self.controlfile('pending-merges', 'r').readlines():
1127
p.append(l.rstrip('\n'))
1128
return p
1129
1130
1131
def add_pending_merge(self, revision_id):
1132
from bzrlib.revision import validate_revision_id
1133
1134
validate_revision_id(revision_id)
1135
1136
p = self.pending_merges()
1137
if revision_id in p:
1138
return
1139
p.append(revision_id)
1140
self.set_pending_merges(p)
1141
1142
1143
def set_pending_merges(self, rev_list):
1144
from bzrlib.atomicfile import AtomicFile
1145
self.lock_write()
1146
try:
1147
f = AtomicFile(self.controlfilename('pending-merges'))
1148
try:
1149
for l in rev_list:
1150
print >>f, l
1151
f.commit()
1152
finally:
1153
f.close()
1154
finally:
1155
self.unlock()
1156
1157
1158
def get_parent(self):
1159
"""Return the parent location of the branch.
1160
1161
This is the default location for push/pull/missing. The usual
1162
pattern is that the user can override it by specifying a
1163
location.
1164
"""
1165
import errno
1166
_locs = ['parent', 'pull', 'x-pull']
1167
for l in _locs:
1168
try:
1169
return self.controlfile(l, 'r').read().strip('\n')
1170
except IOError, e:
1171
if e.errno != errno.ENOENT:
1172
raise
1173
return None
1174
1175
1176
def set_parent(self, url):
1177
# TODO: Maybe delete old location files?
1178
from bzrlib.atomicfile import AtomicFile
1179
self.lock_write()
1180
try:
1181
f = AtomicFile(self.controlfilename('parent'))
1182
try:
1183
f.write(url + '\n')
1184
f.commit()
1185
finally:
1186
f.close()
1187
finally:
1188
self.unlock()
1189
1190
def check_revno(self, revno):
1191
"""\
1192
Check whether a revno corresponds to any revision.
1193
Zero (the NULL revision) is considered valid.
1194
"""
1195
if revno != 0:
1196
self.check_real_revno(revno)
1197
1198
def check_real_revno(self, revno):
1199
"""\
1200
Check whether a revno corresponds to a real revision.
1201
Zero (the NULL revision) is considered invalid
1202
"""
1203
if revno < 1 or revno > self.revno():
1204
raise InvalidRevisionNumber(revno)
1205
1206
1207
1208
1209
1210
class ScratchBranch(LocalBranch):
717
1211
"""Special test class: a branch that cleans up after itself.
718
1212
719
1213
>>> b = ScratchBranch()
724
1218
>>> isdir(bd)
725
1219
False
726
1220
"""
727
def __init__(self, files=[], dirs=[]):
1221
def __init__(self, files=[], dirs=[], base=None):
728
1222
"""Make a test branch.
729
1223
730
1224
This creates a temporary directory and runs init-tree in it.
731
1225
732
1226
If any files are listed, they are created in the working copy.
733
1227
"""
734
Branch.__init__(self, tempfile.mkdtemp(), init=True)
1228
from tempfile import mkdtemp
1229
init = False
1230
if base is None:
1231
base = mkdtemp()
1232
init = True
1233
LocalBranch.__init__(self, base, init=init)
735
1234
for d in dirs:
736
1235
os.mkdir(self.abspath(d))
737
1236
739
1238
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
740
1239
741
1240
1241
def clone(self):
1242
"""
1243
>>> orig = ScratchBranch(files=["file1", "file2"])
1244
>>> clone = orig.clone()
1245
>>> os.path.samefile(orig.base, clone.base)
1246
False
1247
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1248
True
1249
"""
1250
from shutil import copytree
1251
from tempfile import mkdtemp
1252
base = mkdtemp()
1253
os.rmdir(base)
1254
copytree(self.base, base, symlinks=True)
1255
return ScratchBranch(base=base)
1256
1257
1258
742
1259
def __del__(self):
743
1260
self.destroy()
744
1261
745
1262
def destroy(self):
746
1263
"""Destroy the test branch, removing the scratch directory."""
1264
from shutil import rmtree
747
1265
try:
748
mutter("delete ScratchBranch %s" % self.base)
749
shutil.rmtree(self.base)
1266
if self.base:
1267
mutter("delete ScratchBranch %s" % self.base)
1268
rmtree(self.base)
750
1269
except OSError, e:
751
1270
# Work around for shutil.rmtree failing on Windows when
752
1271
# readonly files are encountered
754
1273
for root, dirs, files in os.walk(self.base, topdown=False):
755
1274
for name in files:
756
1275
os.chmod(os.path.join(root, name), 0700)
757
shutil.rmtree(self.base)
1276
rmtree(self.base)
758
1277
self.base = None
759
1278
760
1279
785
1304
cope with just randomness because running uuidgen every time is
786
1305
slow."""
787
1306
import re
1307
from binascii import hexlify
1308
from time import time
788
1309
789
1310
# get last component
790
1311
idx = name.rfind('/')
802
1323
name = re.sub(r'[^\w.]', '', name)
803
1324
804
1325
s = hexlify(rand_bytes(8))
805
return '-'.join((name, compact_date(time.time()), s))
1326
return '-'.join((name, compact_date(time()), s))
1327
1328
1329
def gen_root_id():
1330
"""Return a new tree-root file id."""
1331
return gen_file_id('TREE_ROOT')
1332
1333
1334
def copy_branch(branch_from, to_location, revision=None):
1335
"""Copy branch_from into the existing directory to_location.
1336
1337
revision
1338
If not None, only revisions up to this point will be copied.
1339
The head of the new branch will be that revision.
1340
1341
to_location
1342
The name of a local directory that exists but is empty.
1343
"""
1344
from bzrlib.merge import merge
1345
from bzrlib.revisionspec import RevisionSpec
1346
1347
assert isinstance(branch_from, Branch)
1348
assert isinstance(to_location, basestring)
1349
1350
br_to = Branch.initialize(to_location)
1351
br_to.set_root_id(branch_from.get_root_id())
1352
if revision is None:
1353
revno = branch_from.revno()
1354
else:
1355
revno, rev_id = RevisionSpec(revision).in_history(branch_from)
1356
br_to.update_revisions(branch_from, stop_revision=revno)
1357
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1358
check_clean=False, ignore_zero=True)
1359
br_to.set_parent(branch_from.base)
1360
return br_to
Loggerhead is a web-based interface for Breezy
Version: 2.0.1