« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1418
- compare with another revision
- download diff
- download tarball
- view history from revision 1418
- Committer: Robert Collins
- Date: 2005-10-06 12:14:01 UTC
- mfrom: (1393.1.67)
- Revision ID: robertc@robertcollins.net-20051006121401-ce87bcb93909bbdf
merge martins latest
- files added:
- HACKING
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- contrib/emacs
- files removed:
- bzrlib/meta_store.py
- plugins/changeset
- files renamed:
- plugins/ => bzrlib/plugins/
- tools/testweave.py => bzrlib/selftest/test_weave.py
- bzrlib/store.py => bzrlib/store/__init__.py
- effbot/ => bzrlib/util/effbot/
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/urlgrabber/
- bzrlib/newinventory.py => contrib/newinventory.py
- 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
18
import sys
19
import os
20
import errno
21
from warnings import warn
22
from cStringIO import StringIO
23
19
24
20
25
import bzrlib
26
from bzrlib.inventory import InventoryEntry
27
import bzrlib.inventory as inventory
21
28
from bzrlib.trace import mutter, note
22
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, splitpath, \
23
sha_file, appendpath, file_kind
24
from bzrlib.errors import BzrError
25
26
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
29
from bzrlib.osutils import (isdir, quotefn, compact_date, rand_bytes,
30
rename, splitpath, sha_file, appendpath,
31
file_kind)
32
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
33
NoSuchRevision, HistoryMissing, NotBranchError,
34
DivergedBranches, LockError, UnlistableStore,
35
UnlistableBranch, NoSuchFile)
36
from bzrlib.textui import show_status
37
from bzrlib.revision import Revision
38
from bzrlib.delta import compare_trees
39
from bzrlib.tree import EmptyTree, RevisionTree
40
from bzrlib.inventory import Inventory
41
from bzrlib.store import copy_all
42
from bzrlib.store.compressed_text import CompressedTextStore
43
from bzrlib.store.text import TextStore
44
from bzrlib.store.weave import WeaveStore
45
from bzrlib.transport import Transport, get_transport
46
import bzrlib.xml5
47
import bzrlib.ui
48
49
50
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
51
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
27
52
## TODO: Maybe include checks for common corruption of newlines, etc?
28
53
29
54
30
31
def find_branch(f, **args):
32
if f and (f.startswith('http://') or f.startswith('https://')):
33
import remotebranch
34
return remotebranch.RemoteBranch(f, **args)
35
else:
36
return Branch(f, **args)
37
38
39
def find_cached_branch(f, cache_root, **args):
40
from remotebranch import RemoteBranch
41
br = find_branch(f, **args)
42
def cacheify(br, store_name):
43
from meta_store import CachedStore
44
cache_path = os.path.join(cache_root, store_name)
45
os.mkdir(cache_path)
46
new_store = CachedStore(getattr(br, store_name), cache_path)
47
setattr(br, store_name, new_store)
48
49
if isinstance(br, RemoteBranch):
50
cacheify(br, 'inventory_store')
51
cacheify(br, 'text_store')
52
cacheify(br, 'revision_store')
53
return br
54
55
55
# TODO: Some operations like log might retrieve the same revisions
56
# repeatedly to calculate deltas. We could perhaps have a weakref
57
# cache in memory to make this faster. In general anything can be
58
# cached in memory between lock and unlock operations.
59
60
def find_branch(*ignored, **ignored_too):
61
# XXX: leave this here for about one release, then remove it
62
raise NotImplementedError('find_branch() is not supported anymore, '
63
'please use one of the new branch constructors')
56
64
def _relpath(base, path):
57
65
"""Return path relative to base, or raise exception.
58
66
75
83
if tail:
76
84
s.insert(0, tail)
77
85
else:
78
from errors import NotBranchError
79
86
raise NotBranchError("path %r is not within branch %r" % (rp, base))
80
87
81
88
return os.sep.join(s)
82
89
83
90
84
def find_branch_root(f=None):
85
"""Find the branch root enclosing f, or pwd.
86
87
f may be a filename or a URL.
88
89
It is not necessary that f exists.
91
def find_branch_root(t):
92
"""Find the branch root enclosing the transport's base.
93
94
t is a Transport object.
95
96
It is not necessary that the base of t exists.
90
97
91
98
Basically we keep looking up until we find the control directory or
92
run into the root."""
93
if f == None:
94
f = os.getcwd()
95
elif hasattr(os.path, 'realpath'):
96
f = os.path.realpath(f)
97
else:
98
f = os.path.abspath(f)
99
if not os.path.exists(f):
100
raise BzrError('%r does not exist' % f)
101
102
103
orig_f = f
104
99
run into the root. If there isn't one, raises NotBranchError.
100
"""
101
orig_base = t.base
105
102
while True:
106
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
107
return f
108
head, tail = os.path.split(f)
109
if head == f:
103
if t.has(bzrlib.BZRDIR):
104
return t
105
new_t = t.clone('..')
106
if new_t.base == t.base:
110
107
# reached the root, whatever that may be
111
raise BzrError('%r is not in a branch' % orig_f)
112
f = head
113
114
class DivergedBranches(Exception):
115
def __init__(self, branch1, branch2):
116
self.branch1 = branch1
117
self.branch2 = branch2
118
Exception.__init__(self, "These branches have diverged.")
119
120
121
class NoSuchRevision(BzrError):
122
def __init__(self, branch, revision):
123
self.branch = branch
124
self.revision = revision
125
msg = "Branch %s has no revision %d" % (branch, revision)
126
BzrError.__init__(self, msg)
108
raise NotBranchError('%s is not in a branch' % orig_base)
109
t = new_t
127
110
128
111
129
112
######################################################################
133
116
"""Branch holding a history of revisions.
134
117
135
118
base
136
Base directory of the branch.
119
Base directory/url of the branch.
120
"""
121
base = None
122
123
def __init__(self, *ignored, **ignored_too):
124
raise NotImplementedError('The Branch class is abstract')
125
126
@staticmethod
127
def open_downlevel(base):
128
"""Open a branch which may be of an old format.
129
130
Only local branches are supported."""
131
return _Branch(get_transport(base), relax_version_check=True)
132
133
@staticmethod
134
def open(base):
135
"""Open an existing branch, rooted at 'base' (url)"""
136
t = get_transport(base)
137
mutter("trying to open %r with transport %r", base, t)
138
return _Branch(t)
139
140
@staticmethod
141
def open_containing(url):
142
"""Open an existing branch which contains url.
143
144
This probes for a branch at url, and searches upwards from there.
145
"""
146
t = get_transport(url)
147
t = find_branch_root(t)
148
return _Branch(t)
149
150
@staticmethod
151
def initialize(base):
152
"""Create a new branch, rooted at 'base' (url)"""
153
t = get_transport(base)
154
return _Branch(t, init=True)
155
156
def setup_caching(self, cache_root):
157
"""Subclasses that care about caching should override this, and set
158
up cached stores located under cache_root.
159
"""
160
self.cache_root = cache_root
161
162
163
class _Branch(Branch):
164
"""A branch stored in the actual filesystem.
165
166
Note that it's "local" in the context of the filesystem; it doesn't
167
really matter if it's on an nfs/smb/afs/coda/... share, as long as
168
it's writable, and can be accessed via the normal filesystem API.
137
169
138
170
_lock_mode
139
171
None, or 'r' or 'w'
145
177
_lock
146
178
Lock object from bzrlib.lock.
147
179
"""
148
base = None
180
# We actually expect this class to be somewhat short-lived; part of its
181
# purpose is to try to isolate what bits of the branch logic are tied to
182
# filesystem access, so that in a later step, we can extricate them to
183
# a separarte ("storage") class.
149
184
_lock_mode = None
150
185
_lock_count = None
151
186
_lock = None
187
_inventory_weave = None
152
188
153
def __init__(self, base, init=False, find_root=True):
189
# Map some sort of prefix into a namespace
190
# stuff like "revno:10", "revid:", etc.
191
# This should match a prefix with a function which accepts
192
REVISION_NAMESPACES = {}
193
194
def push_stores(self, branch_to):
195
"""Copy the content of this branches store to branch_to."""
196
if (self._branch_format != branch_to._branch_format
197
or self._branch_format != 4):
198
from bzrlib.fetch import greedy_fetch
199
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
200
self, self._branch_format, branch_to, branch_to._branch_format)
201
greedy_fetch(to_branch=branch_to, from_branch=self,
202
revision=self.last_revision())
203
return
204
205
store_pairs = ((self.text_store, branch_to.text_store),
206
(self.inventory_store, branch_to.inventory_store),
207
(self.revision_store, branch_to.revision_store))
208
try:
209
for from_store, to_store in store_pairs:
210
copy_all(from_store, to_store)
211
except UnlistableStore:
212
raise UnlistableBranch(from_store)
213
214
def __init__(self, transport, init=False,
215
relax_version_check=False):
154
216
"""Create new branch object at a particular location.
155
217
156
base -- Base directory for the branch.
218
transport -- A Transport object, defining how to access files.
219
(If a string, transport.transport() will be used to
220
create a Transport object)
157
221
158
222
init -- If True, create new control files in a previously
159
223
unversioned directory. If False, the branch must already
160
224
be versioned.
161
225
162
find_root -- If true and init is false, find the root of the
163
existing branch containing base.
226
relax_version_check -- If true, the usual check for the branch
227
version is not applied. This is intended only for
228
upgrade/recovery type use; it's not guaranteed that
229
all operations will work on old format branches.
164
230
165
231
In the test suite, creation of new trees is tested using the
166
232
`ScratchBranch` class.
167
233
"""
168
from bzrlib.store import ImmutableStore
234
assert isinstance(transport, Transport), \
235
"%r is not a Transport" % transport
236
self._transport = transport
169
237
if init:
170
self.base = os.path.realpath(base)
171
238
self._make_control()
172
elif find_root:
173
self.base = find_branch_root(base)
174
else:
175
self.base = os.path.realpath(base)
176
if not isdir(self.controlfilename('.')):
177
from errors import NotBranchError
178
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
179
['use "bzr init" to initialize a new working tree',
180
'current bzr can only operate from top-of-tree'])
181
self._check_format()
182
183
self.text_store = ImmutableStore(self.controlfilename('text-store'))
184
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
185
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
186
239
self._check_format(relax_version_check)
240
241
def get_store(name, compressed=True):
242
# FIXME: This approach of assuming stores are all entirely compressed
243
# or entirely uncompressed is tidy, but breaks upgrade from
244
# some existing branches where there's a mixture; we probably
245
# still want the option to look for both.
246
relpath = self._rel_controlfilename(name)
247
if compressed:
248
store = CompressedTextStore(self._transport.clone(relpath))
249
else:
250
store = TextStore(self._transport.clone(relpath))
251
#if self._transport.should_cache():
252
# cache_path = os.path.join(self.cache_root, name)
253
# os.mkdir(cache_path)
254
# store = bzrlib.store.CachedStore(store, cache_path)
255
return store
256
def get_weave(name):
257
relpath = self._rel_controlfilename(name)
258
ws = WeaveStore(self._transport.clone(relpath))
259
if self._transport.should_cache():
260
ws.enable_cache = True
261
return ws
262
263
if self._branch_format == 4:
264
self.inventory_store = get_store('inventory-store')
265
self.text_store = get_store('text-store')
266
self.revision_store = get_store('revision-store')
267
elif self._branch_format == 5:
268
self.control_weaves = get_weave([])
269
self.weave_store = get_weave('weaves')
270
self.revision_store = get_store('revision-store', compressed=False)
187
271
188
272
def __str__(self):
189
return '%s(%r)' % (self.__class__.__name__, self.base)
273
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
190
274
191
275
192
276
__repr__ = __str__
194
278
195
279
def __del__(self):
196
280
if self._lock_mode or self._lock:
197
from warnings import warn
281
# XXX: This should show something every time, and be suitable for
282
# headless operation and embedding
198
283
warn("branch %r was not explicitly unlocked" % self)
199
284
self._lock.unlock()
200
285
286
# TODO: It might be best to do this somewhere else,
287
# but it is nice for a Branch object to automatically
288
# cache it's information.
289
# Alternatively, we could have the Transport objects cache requests
290
# See the earlier discussion about how major objects (like Branch)
291
# should never expect their __del__ function to run.
292
if hasattr(self, 'cache_root') and self.cache_root is not None:
293
try:
294
import shutil
295
shutil.rmtree(self.cache_root)
296
except:
297
pass
298
self.cache_root = None
299
300
def _get_base(self):
301
if self._transport:
302
return self._transport.base
303
return None
304
305
base = property(_get_base)
201
306
202
307
203
308
def lock_write(self):
309
# TODO: Upgrade locking to support using a Transport,
310
# and potentially a remote locking protocol
204
311
if self._lock_mode:
205
312
if self._lock_mode != 'w':
206
from errors import LockError
207
313
raise LockError("can't upgrade to a write lock from %r" %
208
314
self._lock_mode)
209
315
self._lock_count += 1
210
316
else:
211
from bzrlib.lock import WriteLock
212
213
self._lock = WriteLock(self.controlfilename('branch-lock'))
317
self._lock = self._transport.lock_write(
318
self._rel_controlfilename('branch-lock'))
214
319
self._lock_mode = 'w'
215
320
self._lock_count = 1
216
321
217
322
218
219
323
def lock_read(self):
220
324
if self._lock_mode:
221
325
assert self._lock_mode in ('r', 'w'), \
222
326
"invalid lock mode %r" % self._lock_mode
223
327
self._lock_count += 1
224
328
else:
225
from bzrlib.lock import ReadLock
226
227
self._lock = ReadLock(self.controlfilename('branch-lock'))
329
self._lock = self._transport.lock_read(
330
self._rel_controlfilename('branch-lock'))
228
331
self._lock_mode = 'r'
229
332
self._lock_count = 1
230
333
231
232
233
334
def unlock(self):
234
335
if not self._lock_mode:
235
from errors import LockError
236
336
raise LockError('branch %r is not locked' % (self))
237
337
238
338
if self._lock_count > 1:
242
342
self._lock = None
243
343
self._lock_mode = self._lock_count = None
244
344
245
246
345
def abspath(self, name):
247
346
"""Return absolute filename for something in the branch"""
248
return os.path.join(self.base, name)
249
347
return self._transport.abspath(name)
250
348
251
349
def relpath(self, path):
252
350
"""Return path relative to this branch of something inside it.
253
351
254
352
Raises an error if path is not in this branch."""
255
return _relpath(self.base, path)
256
353
return self._transport.relpath(path)
354
355
356
def _rel_controlfilename(self, file_or_path):
357
if isinstance(file_or_path, basestring):
358
file_or_path = [file_or_path]
359
return [bzrlib.BZRDIR] + file_or_path
257
360
258
361
def controlfilename(self, file_or_path):
259
362
"""Return location relative to branch."""
260
if isinstance(file_or_path, basestring):
261
file_or_path = [file_or_path]
262
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
363
return self._transport.abspath(self._rel_controlfilename(file_or_path))
263
364
264
365
265
366
def controlfile(self, file_or_path, mode='r'):
273
374
Controlfiles should almost never be opened in write mode but
274
375
rather should be atomically copied and replaced using atomicfile.
275
376
"""
276
277
fn = self.controlfilename(file_or_path)
278
279
if mode == 'rb' or mode == 'wb':
280
return file(fn, mode)
281
elif mode == 'r' or mode == 'w':
282
# open in binary mode anyhow so there's no newline translation;
283
# codecs uses line buffering by default; don't want that.
284
import codecs
285
return codecs.open(fn, mode + 'b', 'utf-8',
286
buffering=60000)
377
import codecs
378
379
relpath = self._rel_controlfilename(file_or_path)
380
#TODO: codecs.open() buffers linewise, so it was overloaded with
381
# a much larger buffer, do we need to do the same for getreader/getwriter?
382
if mode == 'rb':
383
return self._transport.get(relpath)
384
elif mode == 'wb':
385
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
386
elif mode == 'r':
387
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
388
elif mode == 'w':
389
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
287
390
else:
288
391
raise BzrError("invalid controlfile mode %r" % mode)
289
392
290
393
def put_controlfile(self, path, f, encode=True):
394
"""Write an entry as a controlfile.
395
396
:param path: The path to put the file, relative to the .bzr control
397
directory
398
:param f: A file-like or string object whose contents should be copied.
399
:param encode: If true, encode the contents as utf-8
400
"""
401
self.put_controlfiles([(path, f)], encode=encode)
402
403
def put_controlfiles(self, files, encode=True):
404
"""Write several entries as controlfiles.
405
406
:param files: A list of [(path, file)] pairs, where the path is the directory
407
underneath the bzr control directory
408
:param encode: If true, encode the contents as utf-8
409
"""
410
import codecs
411
ctrl_files = []
412
for path, f in files:
413
if encode:
414
if isinstance(f, basestring):
415
f = f.encode('utf-8', 'replace')
416
else:
417
f = codecs.getwriter('utf-8')(f, errors='replace')
418
path = self._rel_controlfilename(path)
419
ctrl_files.append((path, f))
420
self._transport.put_multi(ctrl_files)
291
421
292
422
def _make_control(self):
293
423
from bzrlib.inventory import Inventory
294
from bzrlib.xml import pack_xml
424
from bzrlib.weavefile import write_weave_v5
425
from bzrlib.weave import Weave
295
426
296
os.mkdir(self.controlfilename([]))
297
self.controlfile('README', 'w').write(
427
# Create an empty inventory
428
sio = StringIO()
429
# if we want per-tree root ids then this is the place to set
430
# them; they're not needed for now and so ommitted for
431
# simplicity.
432
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
433
empty_inv = sio.getvalue()
434
sio = StringIO()
435
bzrlib.weavefile.write_weave_v5(Weave(), sio)
436
empty_weave = sio.getvalue()
437
438
dirs = [[], 'revision-store', 'weaves']
439
files = [('README',
298
440
"This is a Bazaar-NG control directory.\n"
299
"Do not change any files in this directory.\n")
300
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
301
for d in ('text-store', 'inventory-store', 'revision-store'):
302
os.mkdir(self.controlfilename(d))
303
for f in ('revision-history', 'merged-patches',
304
'pending-merged-patches', 'branch-name',
305
'branch-lock',
306
'pending-merges'):
307
self.controlfile(f, 'w').write('')
308
mutter('created control directory in ' + self.base)
309
310
pack_xml(Inventory(), self.controlfile('inventory','w'))
311
312
313
def _check_format(self):
441
"Do not change any files in this directory.\n"),
442
('branch-format', BZR_BRANCH_FORMAT_5),
443
('revision-history', ''),
444
('branch-name', ''),
445
('branch-lock', ''),
446
('pending-merges', ''),
447
('inventory', empty_inv),
448
('inventory.weave', empty_weave),
449
('ancestry.weave', empty_weave)
450
]
451
cfn = self._rel_controlfilename
452
self._transport.mkdir_multi([cfn(d) for d in dirs])
453
self.put_controlfiles(files)
454
mutter('created control directory in ' + self._transport.base)
455
456
def _check_format(self, relax_version_check):
314
457
"""Check this branch format is supported.
315
458
316
The current tool only supports the current unstable format.
459
The format level is stored, as an integer, in
460
self._branch_format for code that needs to check it later.
317
461
318
462
In the future, we might need different in-memory Branch
319
463
classes to support downlevel branches. But not yet.
320
464
"""
321
# This ignores newlines so that we can open branches created
322
# on Windows from Linux and so on. I think it might be better
323
# to always make all internal files in unix format.
324
fmt = self.controlfile('branch-format', 'r').read()
325
fmt.replace('\r\n', '')
326
if fmt != BZR_BRANCH_FORMAT:
465
try:
466
fmt = self.controlfile('branch-format', 'r').read()
467
except NoSuchFile:
468
raise NotBranchError(self.base)
469
mutter("got branch format %r", fmt)
470
if fmt == BZR_BRANCH_FORMAT_5:
471
self._branch_format = 5
472
elif fmt == BZR_BRANCH_FORMAT_4:
473
self._branch_format = 4
474
475
if (not relax_version_check
476
and self._branch_format != 5):
327
477
raise BzrError('sorry, branch format %r not supported' % fmt,
328
478
['use a different bzr version',
329
'or remove the .bzr directory and "bzr init" again'])
330
331
479
'or remove the .bzr directory'
480
' and "bzr init" again'])
481
482
def get_root_id(self):
483
"""Return the id of this branches root"""
484
inv = self.read_working_inventory()
485
return inv.root.file_id
486
487
def set_root_id(self, file_id):
488
inv = self.read_working_inventory()
489
orig_root_id = inv.root.file_id
490
del inv._byid[inv.root.file_id]
491
inv.root.file_id = file_id
492
inv._byid[inv.root.file_id] = inv.root
493
for fid in inv:
494
entry = inv[fid]
495
if entry.parent_id in (None, orig_root_id):
496
entry.parent_id = inv.root.file_id
497
self._write_inventory(inv)
332
498
333
499
def read_working_inventory(self):
334
500
"""Read the working inventory."""
335
from bzrlib.inventory import Inventory
336
from bzrlib.xml import unpack_xml
337
from time import time
338
before = time()
339
501
self.lock_read()
340
502
try:
341
503
# ElementTree does its own conversion from UTF-8, so open in
342
504
# binary.
343
inv = unpack_xml(Inventory,
344
self.controlfile('inventory', 'rb'))
345
mutter("loaded inventory of %d items in %f"
346
% (len(inv), time() - before))
347
return inv
505
f = self.controlfile('inventory', 'rb')
506
return bzrlib.xml5.serializer_v5.read_inventory(f)
348
507
finally:
349
508
self.unlock()
350
509
355
514
That is to say, the inventory describing changes underway, that
356
515
will be committed to the next revision.
357
516
"""
358
from bzrlib.atomicfile import AtomicFile
359
from bzrlib.xml import pack_xml
360
517
from cStringIO import StringIO
361
518
self.lock_write()
362
519
try:
363
f = AtomicFile(self.controlfilename('inventory'), 'wb')
364
try:
365
pack_xml(inv, f)
366
f.commit()
367
finally:
368
f.close()
520
sio = StringIO()
521
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
522
sio.seek(0)
523
# Transport handles atomicity
524
self.put_controlfile('inventory', sio)
369
525
finally:
370
526
self.unlock()
371
527
372
528
mutter('wrote working inventory')
373
529
374
375
530
inventory = property(read_working_inventory, _write_inventory, None,
376
531
"""Inventory for the working copy.""")
377
532
378
379
def add(self, files, verbose=False, ids=None):
533
def add(self, files, ids=None):
380
534
"""Make files versioned.
381
535
382
Note that the command line normally calls smart_add instead.
536
Note that the command line normally calls smart_add instead,
537
which can automatically recurse.
383
538
384
539
This puts the files in the Added state, so that they will be
385
540
recorded by the next commit.
395
550
TODO: Perhaps have an option to add the ids even if the files do
396
551
not (yet) exist.
397
552
398
TODO: Perhaps return the ids of the files? But then again it
399
is easy to retrieve them if they're needed.
400
401
TODO: Adding a directory should optionally recurse down and
402
add all non-ignored children. Perhaps do that in a
403
higher-level method.
553
TODO: Perhaps yield the ids and paths as they're added.
404
554
"""
405
from bzrlib.textui import show_status
406
555
# TODO: Re-adding a file that is removed in the working copy
407
556
# should probably put it back with the previous ID.
408
557
if isinstance(files, basestring):
434
583
kind = file_kind(fullpath)
435
584
except OSError:
436
585
# maybe something better?
437
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
586
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
438
587
439
if kind != 'file' and kind != 'directory':
440
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
588
if not InventoryEntry.versionable_kind(kind):
589
raise BzrError('cannot add: not a versionable file ('
590
'i.e. regular file, symlink or directory): %s' % quotefn(f))
441
591
442
592
if file_id is None:
443
593
file_id = gen_file_id(f)
444
594
inv.add_path(f, kind=kind, file_id=file_id)
445
595
446
if verbose:
447
print 'added', quotefn(f)
448
449
596
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
450
597
451
598
self._write_inventory(inv)
457
604
"""Print `file` to stdout."""
458
605
self.lock_read()
459
606
try:
460
tree = self.revision_tree(self.lookup_revision(revno))
607
tree = self.revision_tree(self.get_rev_id(revno))
461
608
# use inventory as it was in that revision
462
609
file_id = tree.inventory.path2id(file)
463
610
if not file_id:
464
raise BzrError("%r is not present in revision %d" % (file, revno))
611
raise BzrError("%r is not present in revision %s" % (file, revno))
465
612
tree.print_file(file_id)
466
613
finally:
467
614
self.unlock()
481
628
is the opposite of add. Removing it is consistent with most
482
629
other tools. Maybe an option.
483
630
"""
484
from bzrlib.textui import show_status
485
631
## TODO: Normalize names
486
632
## TODO: Remove nested loops; better scalability
487
633
if isinstance(files, basestring):
512
658
finally:
513
659
self.unlock()
514
660
515
516
661
# FIXME: this doesn't need to be a branch method
517
662
def set_inventory(self, new_inventory_list):
518
663
from bzrlib.inventory import Inventory, InventoryEntry
519
inv = Inventory()
664
inv = Inventory(self.get_root_id())
520
665
for path, file_id, parent, kind in new_inventory_list:
521
666
name = os.path.basename(path)
522
667
if name == "":
523
668
continue
524
inv.add(InventoryEntry(file_id, name, kind, parent))
669
# fixme, there should be a factory function inv,add_??
670
if kind == 'directory':
671
inv.add(inventory.InventoryDirectory(file_id, name, parent))
672
elif kind == 'file':
673
inv.add(inventory.InventoryFile(file_id, name, parent))
674
elif kind == 'symlink':
675
inv.add(inventory.InventoryLink(file_id, name, parent))
676
else:
677
raise BzrError("unknown kind %r" % kind)
525
678
self._write_inventory(inv)
526
679
527
528
680
def unknowns(self):
529
681
"""Return all unknown files.
530
682
544
696
return self.working_tree().unknowns()
545
697
546
698
547
def append_revision(self, revision_id):
548
from bzrlib.atomicfile import AtomicFile
549
550
mutter("add {%s} to revision-history" % revision_id)
551
rev_history = self.revision_history() + [revision_id]
552
553
f = AtomicFile(self.controlfilename('revision-history'))
554
try:
555
for rev_id in rev_history:
556
print >>f, rev_id
557
f.commit()
558
finally:
559
f.close()
699
def append_revision(self, *revision_ids):
700
for revision_id in revision_ids:
701
mutter("add {%s} to revision-history" % revision_id)
702
self.lock_write()
703
try:
704
rev_history = self.revision_history()
705
rev_history.extend(revision_ids)
706
self.put_controlfile('revision-history', '\n'.join(rev_history))
707
finally:
708
self.unlock()
709
710
def has_revision(self, revision_id):
711
"""True if this branch has a copy of the revision.
712
713
This does not necessarily imply the revision is merge
714
or on the mainline."""
715
return (revision_id is None
716
or revision_id in self.revision_store)
717
718
def get_revision_xml_file(self, revision_id):
719
"""Return XML file object for revision object."""
720
if not revision_id or not isinstance(revision_id, basestring):
721
raise InvalidRevisionId(revision_id)
722
723
self.lock_read()
724
try:
725
try:
726
return self.revision_store[revision_id]
727
except (IndexError, KeyError):
728
raise bzrlib.errors.NoSuchRevision(self, revision_id)
729
finally:
730
self.unlock()
731
732
#deprecated
733
get_revision_xml = get_revision_xml_file
734
735
def get_revision_xml(self, revision_id):
736
return self.get_revision_xml_file(revision_id).read()
560
737
561
738
562
739
def get_revision(self, revision_id):
563
740
"""Return the Revision object for a named revision"""
564
from bzrlib.revision import Revision
565
from bzrlib.xml import unpack_xml
741
xml_file = self.get_revision_xml_file(revision_id)
566
742
567
self.lock_read()
568
743
try:
569
if not revision_id or not isinstance(revision_id, basestring):
570
raise ValueError('invalid revision-id: %r' % revision_id)
571
r = unpack_xml(Revision, self.revision_store[revision_id])
572
finally:
573
self.unlock()
744
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
745
except SyntaxError, e:
746
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
747
[revision_id,
748
str(e)])
574
749
575
750
assert r.revision_id == revision_id
576
751
return r
577
752
753
def get_revision_delta(self, revno):
754
"""Return the delta for one revision.
755
756
The delta is relative to its mainline predecessor, or the
757
empty tree for revision 1.
758
"""
759
assert isinstance(revno, int)
760
rh = self.revision_history()
761
if not (1 <= revno <= len(rh)):
762
raise InvalidRevisionNumber(revno)
763
764
# revno is 1-based; list is 0-based
765
766
new_tree = self.revision_tree(rh[revno-1])
767
if revno == 1:
768
old_tree = EmptyTree()
769
else:
770
old_tree = self.revision_tree(rh[revno-2])
771
772
return compare_trees(old_tree, new_tree)
578
773
579
774
def get_revision_sha1(self, revision_id):
580
775
"""Hash the stored value of a revision, and return it."""
584
779
# the revision, (add signatures/remove signatures) and still
585
780
# have all hash pointers stay consistent.
586
781
# But for now, just hash the contents.
587
return sha_file(self.revision_store[revision_id])
588
589
590
def get_inventory(self, inventory_id):
591
"""Get Inventory object by hash.
592
593
TODO: Perhaps for this and similar methods, take a revision
594
parameter which can be either an integer revno or a
595
string hash."""
596
from bzrlib.inventory import Inventory
597
from bzrlib.xml import unpack_xml
598
599
return unpack_xml(Inventory, self.inventory_store[inventory_id])
600
601
602
def get_inventory_sha1(self, inventory_id):
782
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
783
784
def get_ancestry(self, revision_id):
785
"""Return a list of revision-ids integrated by a revision.
786
787
This currently returns a list, but the ordering is not guaranteed:
788
treat it as a set.
789
"""
790
if revision_id is None:
791
return [None]
792
w = self.control_weaves.get_weave('inventory')
793
return [None] + map(w.idx_to_name,
794
w.inclusions([w.lookup(revision_id)]))
795
796
def get_inventory_weave(self):
797
return self.control_weaves.get_weave('inventory')
798
799
def get_inventory(self, revision_id):
800
"""Get Inventory object by hash."""
801
xml = self.get_inventory_xml(revision_id)
802
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
803
804
def get_inventory_xml(self, revision_id):
805
"""Get inventory XML as a file object."""
806
try:
807
assert isinstance(revision_id, basestring), type(revision_id)
808
iw = self.get_inventory_weave()
809
return iw.get_text(iw.lookup(revision_id))
810
except IndexError:
811
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
812
813
def get_inventory_sha1(self, revision_id):
603
814
"""Return the sha1 hash of the inventory entry
604
815
"""
605
return sha_file(self.inventory_store[inventory_id])
606
816
return self.get_revision(revision_id).inventory_sha1
607
817
608
818
def get_revision_inventory(self, revision_id):
609
819
"""Return inventory of a past revision."""
610
# bzr 0.0.6 imposes the constraint that the inventory_id
820
# TODO: Unify this with get_inventory()
821
# bzr 0.0.6 and later imposes the constraint that the inventory_id
611
822
# must be the same as its revision, so this is trivial.
612
823
if revision_id == None:
613
from bzrlib.inventory import Inventory
614
return Inventory()
824
return Inventory(self.get_root_id())
615
825
else:
616
826
return self.get_inventory(revision_id)
617
827
618
619
828
def revision_history(self):
620
"""Return sequence of revision hashes on to this branch.
621
622
>>> ScratchBranch().revision_history()
623
[]
624
"""
829
"""Return sequence of revision hashes on to this branch."""
625
830
self.lock_read()
626
831
try:
627
832
return [l.rstrip('\r\n') for l in
629
834
finally:
630
835
self.unlock()
631
836
632
633
837
def common_ancestor(self, other, self_revno=None, other_revno=None):
634
838
"""
635
>>> import commit
839
>>> from bzrlib.commit import commit
636
840
>>> sb = ScratchBranch(files=['foo', 'foo~'])
637
841
>>> sb.common_ancestor(sb) == (None, None)
638
842
True
639
>>> commit.commit(sb, "Committing first revision", verbose=False)
843
>>> commit(sb, "Committing first revision", verbose=False)
640
844
>>> sb.common_ancestor(sb)[0]
641
845
1
642
846
>>> clone = sb.clone()
643
>>> commit.commit(sb, "Committing second revision", verbose=False)
847
>>> commit(sb, "Committing second revision", verbose=False)
644
848
>>> sb.common_ancestor(sb)[0]
645
849
2
646
850
>>> sb.common_ancestor(clone)[0]
647
851
1
648
>>> commit.commit(clone, "Committing divergent second revision",
852
>>> commit(clone, "Committing divergent second revision",
649
853
... verbose=False)
650
854
>>> sb.common_ancestor(clone)[0]
651
855
1
674
878
return r+1, my_history[r]
675
879
return None, None
676
880
677
def enum_history(self, direction):
678
"""Return (revno, revision_id) for history of branch.
679
680
direction
681
'forward' is from earliest to latest
682
'reverse' is from latest to earliest
683
"""
684
rh = self.revision_history()
685
if direction == 'forward':
686
i = 1
687
for rid in rh:
688
yield i, rid
689
i += 1
690
elif direction == 'reverse':
691
i = len(rh)
692
while i > 0:
693
yield i, rh[i-1]
694
i -= 1
695
else:
696
raise ValueError('invalid history direction', direction)
697
698
881
699
882
def revno(self):
700
883
"""Return current revision number for this branch.
705
888
return len(self.revision_history())
706
889
707
890
708
def last_patch(self):
891
def last_revision(self):
709
892
"""Return last patch hash, or None if no history.
710
893
"""
711
894
ph = self.revision_history()
715
898
return None
716
899
717
900
718
def missing_revisions(self, other, stop_revision=None):
719
"""
901
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
902
"""Return a list of new revisions that would perfectly fit.
903
720
904
If self and other have not diverged, return a list of the revisions
721
905
present in other, but missing from self.
722
906
742
926
Traceback (most recent call last):
743
927
DivergedBranches: These branches have diverged.
744
928
"""
929
# FIXME: If the branches have diverged, but the latest
930
# revision in this branch is completely merged into the other,
931
# then we should still be able to pull.
745
932
self_history = self.revision_history()
746
933
self_len = len(self_history)
747
934
other_history = other.revision_history()
753
940
754
941
if stop_revision is None:
755
942
stop_revision = other_len
756
elif stop_revision > other_len:
757
raise NoSuchRevision(self, stop_revision)
758
943
else:
944
assert isinstance(stop_revision, int)
945
if stop_revision > other_len:
946
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
759
947
return other_history[self_len:stop_revision]
760
948
761
762
949
def update_revisions(self, other, stop_revision=None):
763
"""Pull in all new revisions from other branch.
764
765
>>> from bzrlib.commit import commit
766
>>> bzrlib.trace.silent = True
767
>>> br1 = ScratchBranch(files=['foo', 'bar'])
768
>>> br1.add('foo')
769
>>> br1.add('bar')
770
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
771
>>> br2 = ScratchBranch()
772
>>> br2.update_revisions(br1)
773
Added 2 texts.
774
Added 1 inventories.
775
Added 1 revisions.
776
>>> br2.revision_history()
777
[u'REVISION-ID-1']
778
>>> br2.update_revisions(br1)
779
Added 0 texts.
780
Added 0 inventories.
781
Added 0 revisions.
782
>>> br1.text_store.total_size() == br2.text_store.total_size()
783
True
784
"""
785
from bzrlib.progress import ProgressBar
786
try:
787
set
788
except NameError:
789
from sets import Set as set
790
791
pb = ProgressBar()
792
793
pb.update('comparing histories')
794
revision_ids = self.missing_revisions(other, stop_revision)
795
796
if hasattr(other.revision_store, "prefetch"):
797
other.revision_store.prefetch(revision_ids)
798
if hasattr(other.inventory_store, "prefetch"):
799
inventory_ids = [other.get_revision(r).inventory_id
800
for r in revision_ids]
801
other.inventory_store.prefetch(inventory_ids)
802
803
revisions = []
804
needed_texts = set()
805
i = 0
806
for rev_id in revision_ids:
807
i += 1
808
pb.update('fetching revision', i, len(revision_ids))
809
rev = other.get_revision(rev_id)
810
revisions.append(rev)
811
inv = other.get_inventory(str(rev.inventory_id))
812
for key, entry in inv.iter_entries():
813
if entry.text_id is None:
814
continue
815
if entry.text_id not in self.text_store:
816
needed_texts.add(entry.text_id)
817
818
pb.clear()
819
820
count = self.text_store.copy_multi(other.text_store, needed_texts)
821
print "Added %d texts." % count
822
inventory_ids = [ f.inventory_id for f in revisions ]
823
count = self.inventory_store.copy_multi(other.inventory_store,
824
inventory_ids)
825
print "Added %d inventories." % count
826
revision_ids = [ f.revision_id for f in revisions]
827
count = self.revision_store.copy_multi(other.revision_store,
828
revision_ids)
829
for revision_id in revision_ids:
830
self.append_revision(revision_id)
831
print "Added %d revisions." % count
832
833
950
"""Pull in new perfect-fit revisions."""
951
from bzrlib.fetch import greedy_fetch
952
from bzrlib.revision import get_intervening_revisions
953
if stop_revision is None:
954
stop_revision = other.last_revision()
955
greedy_fetch(to_branch=self, from_branch=other,
956
revision=stop_revision)
957
pullable_revs = self.missing_revisions(
958
other, other.revision_id_to_revno(stop_revision))
959
if pullable_revs:
960
greedy_fetch(to_branch=self,
961
from_branch=other,
962
revision=pullable_revs[-1])
963
self.append_revision(*pullable_revs)
964
965
834
966
def commit(self, *args, **kw):
835
from bzrlib.commit import commit
836
commit(self, *args, **kw)
837
967
from bzrlib.commit import Commit
968
Commit().commit(self, *args, **kw)
969
970
def revision_id_to_revno(self, revision_id):
971
"""Given a revision id, return its revno"""
972
if revision_id is None:
973
return 0
974
history = self.revision_history()
975
try:
976
return history.index(revision_id) + 1
977
except ValueError:
978
raise bzrlib.errors.NoSuchRevision(self, revision_id)
838
979
839
def lookup_revision(self, revno):
840
"""Return revision hash for revision number."""
980
def get_rev_id(self, revno, history=None):
981
"""Find the revision id of the specified revno."""
841
982
if revno == 0:
842
983
return None
843
844
try:
845
# list is 0-based; revisions are 1-based
846
return self.revision_history()[revno-1]
847
except IndexError:
848
raise BzrError("no such revision %s" % revno)
849
984
if history is None:
985
history = self.revision_history()
986
elif revno <= 0 or revno > len(history):
987
raise bzrlib.errors.NoSuchRevision(self, revno)
988
return history[revno - 1]
850
989
851
990
def revision_tree(self, revision_id):
852
991
"""Return Tree for a revision on this branch.
853
992
854
993
`revision_id` may be None for the null revision, in which case
855
994
an `EmptyTree` is returned."""
856
from bzrlib.tree import EmptyTree, RevisionTree
857
995
# TODO: refactor this to use an existing revision object
858
996
# so we don't need to read it in twice.
859
997
if revision_id == None:
860
998
return EmptyTree()
861
999
else:
862
1000
inv = self.get_revision_inventory(revision_id)
863
return RevisionTree(self.text_store, inv)
1001
return RevisionTree(self.weave_store, inv, revision_id)
864
1002
865
1003
866
1004
def working_tree(self):
867
1005
"""Return a `Tree` for the working copy."""
868
from workingtree import WorkingTree
869
return WorkingTree(self.base, self.read_working_inventory())
1006
from bzrlib.workingtree import WorkingTree
1007
# TODO: In the future, WorkingTree should utilize Transport
1008
# RobertCollins 20051003 - I don't think it should - working trees are
1009
# much more complex to keep consistent than our careful .bzr subset.
1010
# instead, we should say that working trees are local only, and optimise
1011
# for that.
1012
return WorkingTree(self._transport.base, self.read_working_inventory())
870
1013
871
1014
872
1015
def basis_tree(self):
874
1017
875
1018
If there are no revisions yet, return an `EmptyTree`.
876
1019
"""
877
from bzrlib.tree import EmptyTree, RevisionTree
878
r = self.last_patch()
879
if r == None:
880
return EmptyTree()
881
else:
882
return RevisionTree(self.text_store, self.get_revision_inventory(r))
883
1020
return self.revision_tree(self.last_revision())
884
1021
885
1022
886
1023
def rename_one(self, from_rel, to_rel):
918
1055
919
1056
inv.rename(file_id, to_dir_id, to_tail)
920
1057
921
print "%s => %s" % (from_rel, to_rel)
922
923
1058
from_abs = self.abspath(from_rel)
924
1059
to_abs = self.abspath(to_rel)
925
1060
try:
926
os.rename(from_abs, to_abs)
1061
rename(from_abs, to_abs)
927
1062
except OSError, e:
928
1063
raise BzrError("failed to rename %r to %r: %s"
929
1064
% (from_abs, to_abs, e[1]),
944
1079
945
1080
Note that to_name is only the last component of the new name;
946
1081
this doesn't change the directory.
1082
1083
This returns a list of (from_path, to_path) pairs for each
1084
entry that is moved.
947
1085
"""
1086
result = []
948
1087
self.lock_write()
949
1088
try:
950
1089
## TODO: Option to move IDs only
985
1124
for f in from_paths:
986
1125
name_tail = splitpath(f)[-1]
987
1126
dest_path = appendpath(to_name, name_tail)
988
print "%s => %s" % (f, dest_path)
1127
result.append((f, dest_path))
989
1128
inv.rename(inv.path2id(f), to_dir_id, name_tail)
990
1129
try:
991
os.rename(self.abspath(f), self.abspath(dest_path))
1130
rename(self.abspath(f), self.abspath(dest_path))
992
1131
except OSError, e:
993
1132
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
994
1133
["rename rolled back"])
997
1136
finally:
998
1137
self.unlock()
999
1138
1139
return result
1140
1000
1141
1001
1142
def revert(self, filenames, old_tree=None, backups=True):
1002
1143
"""Restore selected files to the versions from a previous tree.
1048
1189
These are revisions that have been merged into the working
1049
1190
directory but not yet committed.
1050
1191
"""
1051
cfn = self.controlfilename('pending-merges')
1052
if not os.path.exists(cfn):
1192
cfn = self._rel_controlfilename('pending-merges')
1193
if not self._transport.has(cfn):
1053
1194
return []
1054
1195
p = []
1055
1196
for l in self.controlfile('pending-merges', 'r').readlines():
1057
1198
return p
1058
1199
1059
1200
1060
def add_pending_merge(self, revision_id):
1061
from bzrlib.revision import validate_revision_id
1062
1063
validate_revision_id(revision_id)
1064
1201
def add_pending_merge(self, *revision_ids):
1202
# TODO: Perhaps should check at this point that the
1203
# history of the revision is actually present?
1065
1204
p = self.pending_merges()
1066
if revision_id in p:
1067
return
1068
p.append(revision_id)
1069
self.set_pending_merges(p)
1070
1205
updated = False
1206
for rev_id in revision_ids:
1207
if rev_id in p:
1208
continue
1209
p.append(rev_id)
1210
updated = True
1211
if updated:
1212
self.set_pending_merges(p)
1071
1213
1072
1214
def set_pending_merges(self, rev_list):
1215
self.lock_write()
1216
try:
1217
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1218
finally:
1219
self.unlock()
1220
1221
1222
def get_parent(self):
1223
"""Return the parent location of the branch.
1224
1225
This is the default location for push/pull/missing. The usual
1226
pattern is that the user can override it by specifying a
1227
location.
1228
"""
1229
import errno
1230
_locs = ['parent', 'pull', 'x-pull']
1231
for l in _locs:
1232
try:
1233
return self.controlfile(l, 'r').read().strip('\n')
1234
except IOError, e:
1235
if e.errno != errno.ENOENT:
1236
raise
1237
return None
1238
1239
1240
def set_parent(self, url):
1241
# TODO: Maybe delete old location files?
1073
1242
from bzrlib.atomicfile import AtomicFile
1074
1243
self.lock_write()
1075
1244
try:
1076
f = AtomicFile(self.controlfilename('pending-merges'))
1245
f = AtomicFile(self.controlfilename('parent'))
1077
1246
try:
1078
for l in rev_list:
1079
print >>f, l
1247
f.write(url + '\n')
1080
1248
f.commit()
1081
1249
finally:
1082
1250
f.close()
1083
1251
finally:
1084
1252
self.unlock()
1085
1253
1086
1087
1088
class ScratchBranch(Branch):
1254
def check_revno(self, revno):
1255
"""\
1256
Check whether a revno corresponds to any revision.
1257
Zero (the NULL revision) is considered valid.
1258
"""
1259
if revno != 0:
1260
self.check_real_revno(revno)
1261
1262
def check_real_revno(self, revno):
1263
"""\
1264
Check whether a revno corresponds to a real revision.
1265
Zero (the NULL revision) is considered invalid
1266
"""
1267
if revno < 1 or revno > self.revno():
1268
raise InvalidRevisionNumber(revno)
1269
1270
1271
1272
1273
1274
class ScratchBranch(_Branch):
1089
1275
"""Special test class: a branch that cleans up after itself.
1090
1276
1091
1277
>>> b = ScratchBranch()
1108
1294
if base is None:
1109
1295
base = mkdtemp()
1110
1296
init = True
1111
Branch.__init__(self, base, init=init)
1297
if isinstance(base, basestring):
1298
base = get_transport(base)
1299
_Branch.__init__(self, base, init=init)
1112
1300
for d in dirs:
1113
os.mkdir(self.abspath(d))
1301
self._transport.mkdir(d)
1114
1302
1115
1303
for f in files:
1116
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1304
self._transport.put(f, 'content of %s' % f)
1117
1305
1118
1306
1119
1307
def clone(self):
1120
1308
"""
1121
1309
>>> orig = ScratchBranch(files=["file1", "file2"])
1122
1310
>>> clone = orig.clone()
1123
>>> os.path.samefile(orig.base, clone.base)
1311
>>> if os.name != 'nt':
1312
... os.path.samefile(orig.base, clone.base)
1313
... else:
1314
... orig.base == clone.base
1315
...
1124
1316
False
1125
1317
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1126
1318
True
1131
1323
os.rmdir(base)
1132
1324
copytree(self.base, base, symlinks=True)
1133
1325
return ScratchBranch(base=base)
1134
1326
1135
1327
def __del__(self):
1136
1328
self.destroy()
1137
1329
1150
1342
for name in files:
1151
1343
os.chmod(os.path.join(root, name), 0700)
1152
1344
rmtree(self.base)
1153
self.base = None
1345
self._transport = None
1154
1346
1155
1347
1156
1348
1200
1392
1201
1393
s = hexlify(rand_bytes(8))
1202
1394
return '-'.join((name, compact_date(time()), s))
1395
1396
1397
def gen_root_id():
1398
"""Return a new tree-root file id."""
1399
return gen_file_id('TREE_ROOT')
1400
1401
Loggerhead is a web-based interface for Breezy
Version: 2.0.1