« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 54
- compare with another revision
- download diff
- download tarball
- view history from revision 54
- Committer: mbp at sourcefrog
- Date: 2005-03-22 00:02:45 UTC
- Revision ID: mbp@sourcefrog.net-20050322000245-a4bf0592e9f6c6c1
suggestions from robert about the inventory format
- files added:
- bzrlib/tests.py
- files removed:
- .rsyncexclude
- bzrlib/selftest
- contrib
- contrib/bash
- contrib/zsh
- elementtree
- patches
- plugins
- plugins/changeset
- urlgrabber
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005 Canonical Ltd
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
2
3
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
17
18
19
from sets import Set
20
18
21
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
19
22
import traceback, socket, fnmatch, difflib, time
20
23
from binascii import hexlify
22
25
import bzrlib
23
26
from inventory import Inventory
24
27
from trace import mutter, note
25
from tree import Tree, EmptyTree, RevisionTree
28
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
26
29
from inventory import InventoryEntry, Inventory
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
30
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
28
31
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
29
joinpath, sha_file, sha_string, file_kind, local_time_offset, appendpath
32
joinpath, sha_string, file_kind, local_time_offset
30
33
from store import ImmutableStore
31
34
from revision import Revision
32
from errors import BzrError
35
from errors import bailout
33
36
from textui import show_status
37
from diff import diff_trees
34
38
35
39
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
36
40
## TODO: Maybe include checks for common corruption of newlines, etc?
37
41
38
42
39
43
40
def find_branch(f, **args):
41
if f and (f.startswith('http://') or f.startswith('https://')):
42
import remotebranch
43
return remotebranch.RemoteBranch(f, **args)
44
else:
45
return Branch(f, **args)
46
47
48
49
def _relpath(base, path):
50
"""Return path relative to base, or raise exception.
51
52
The path may be either an absolute path or a path relative to the
53
current working directory.
54
55
Lifted out of Branch.relpath for ease of testing.
56
57
os.path.commonprefix (python2.4) has a bad bug that it works just
58
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
59
avoids that problem."""
60
rp = os.path.abspath(path)
61
62
s = []
63
head = rp
64
while len(head) >= len(base):
65
if head == base:
66
break
67
head, tail = os.path.split(head)
68
if tail:
69
s.insert(0, tail)
70
else:
71
from errors import NotBranchError
72
raise NotBranchError("path %r is not within branch %r" % (rp, base))
73
74
return os.sep.join(s)
75
76
77
def find_branch_root(f=None):
78
"""Find the branch root enclosing f, or pwd.
79
80
f may be a filename or a URL.
81
82
It is not necessary that f exists.
83
84
Basically we keep looking up until we find the control directory or
85
run into the root."""
86
if f == None:
87
f = os.getcwd()
88
elif hasattr(os.path, 'realpath'):
89
f = os.path.realpath(f)
90
else:
91
f = os.path.abspath(f)
92
if not os.path.exists(f):
93
raise BzrError('%r does not exist' % f)
94
95
96
orig_f = f
97
98
while True:
99
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
100
return f
101
head, tail = os.path.split(f)
102
if head == f:
103
# reached the root, whatever that may be
104
raise BzrError('%r is not in a branch' % orig_f)
105
f = head
106
107
class DivergedBranches(Exception):
108
def __init__(self, branch1, branch2):
109
self.branch1 = branch1
110
self.branch2 = branch2
111
Exception.__init__(self, "These branches have diverged.")
112
113
114
class NoSuchRevision(BzrError):
115
def __init__(self, branch, revision):
116
self.branch = branch
117
self.revision = revision
118
msg = "Branch %s has no revision %d" % (branch, revision)
119
BzrError.__init__(self, msg)
120
44
121
45
122
46
######################################################################
123
47
# branch objects
124
48
125
class Branch(object):
49
class Branch:
126
50
"""Branch holding a history of revisions.
127
51
128
base
129
Base directory of the branch.
130
131
_lock_mode
132
None, or 'r' or 'w'
133
134
_lock_count
135
If _lock_mode is true, a positive count of the number of times the
136
lock has been taken.
137
138
_lock
139
Lock object from bzrlib.lock.
52
:todo: Perhaps use different stores for different classes of object,
53
so that we can keep track of how much space each one uses,
54
or garbage-collect them.
55
56
:todo: Add a RemoteBranch subclass. For the basic case of read-only
57
HTTP access this should be very easy by,
58
just redirecting controlfile access into HTTP requests.
59
We would need a RemoteStore working similarly.
60
61
:todo: Keep the on-disk branch locked while the object exists.
62
63
:todo: mkdir() method.
140
64
"""
141
base = None
142
_lock_mode = None
143
_lock_count = None
144
_lock = None
145
146
def __init__(self, base, init=False, find_root=True):
65
def __init__(self, base, init=False):
147
66
"""Create new branch object at a particular location.
148
67
149
base -- Base directory for the branch.
150
151
init -- If True, create new control files in a previously
68
:param base: Base directory for the branch.
69
70
:param init: If True, create new control files in a previously
152
71
unversioned directory. If False, the branch must already
153
72
be versioned.
154
73
155
find_root -- If true and init is false, find the root of the
156
existing branch containing base.
157
158
74
In the test suite, creation of new trees is tested using the
159
75
`ScratchBranch` class.
160
76
"""
77
self.base = os.path.realpath(base)
161
78
if init:
162
self.base = os.path.realpath(base)
163
79
self._make_control()
164
elif find_root:
165
self.base = find_branch_root(base)
166
80
else:
167
self.base = os.path.realpath(base)
168
81
if not isdir(self.controlfilename('.')):
169
from errors import NotBranchError
170
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
171
['use "bzr init" to initialize a new working tree',
172
'current bzr can only operate from top-of-tree'])
173
self._check_format()
82
bailout("not a bzr branch: %s" % quotefn(base),
83
['use "bzr init" to initialize a new working tree',
84
'current bzr can only operate from top-of-tree'])
85
self._check_format()
174
86
175
87
self.text_store = ImmutableStore(self.controlfilename('text-store'))
176
88
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
184
96
__repr__ = __str__
185
97
186
98
187
def __del__(self):
188
if self._lock_mode or self._lock:
189
from warnings import warn
190
warn("branch %r was not explicitly unlocked" % self)
191
self._lock.unlock()
192
193
194
195
def lock_write(self):
196
if self._lock_mode:
197
if self._lock_mode != 'w':
198
from errors import LockError
199
raise LockError("can't upgrade to a write lock from %r" %
200
self._lock_mode)
201
self._lock_count += 1
202
else:
203
from bzrlib.lock import WriteLock
204
205
self._lock = WriteLock(self.controlfilename('branch-lock'))
206
self._lock_mode = 'w'
207
self._lock_count = 1
208
209
210
211
def lock_read(self):
212
if self._lock_mode:
213
assert self._lock_mode in ('r', 'w'), \
214
"invalid lock mode %r" % self._lock_mode
215
self._lock_count += 1
216
else:
217
from bzrlib.lock import ReadLock
218
219
self._lock = ReadLock(self.controlfilename('branch-lock'))
220
self._lock_mode = 'r'
221
self._lock_count = 1
222
223
224
225
def unlock(self):
226
if not self._lock_mode:
227
from errors import LockError
228
raise LockError('branch %r is not locked' % (self))
229
230
if self._lock_count > 1:
231
self._lock_count -= 1
232
else:
233
self._lock.unlock()
234
self._lock = None
235
self._lock_mode = self._lock_count = None
236
237
238
def abspath(self, name):
239
"""Return absolute filename for something in the branch"""
99
def _rel(self, name):
100
"""Return filename relative to branch top"""
240
101
return os.path.join(self.base, name)
241
242
243
def relpath(self, path):
244
"""Return path relative to this branch of something inside it.
245
246
Raises an error if path is not in this branch."""
247
return _relpath(self.base, path)
248
102
249
103
250
104
def controlfilename(self, file_or_path):
251
105
"""Return location relative to branch."""
255
109
256
110
257
111
def controlfile(self, file_or_path, mode='r'):
258
"""Open a control file for this branch.
259
260
There are two classes of file in the control directory: text
261
and binary. binary files are untranslated byte streams. Text
262
control files are stored with Unix newlines and in UTF-8, even
263
if the platform or locale defaults are different.
264
265
Controlfiles should almost never be opened in write mode but
266
rather should be atomically copied and replaced using atomicfile.
267
"""
268
269
fn = self.controlfilename(file_or_path)
270
271
if mode == 'rb' or mode == 'wb':
272
return file(fn, mode)
273
elif mode == 'r' or mode == 'w':
274
# open in binary mode anyhow so there's no newline translation;
275
# codecs uses line buffering by default; don't want that.
276
import codecs
277
return codecs.open(fn, mode + 'b', 'utf-8',
278
buffering=60000)
279
else:
280
raise BzrError("invalid controlfile mode %r" % mode)
281
112
"""Open a control file for this branch"""
113
return file(self.controlfilename(file_or_path), mode)
282
114
283
115
284
116
def _make_control(self):
285
117
os.mkdir(self.controlfilename([]))
286
118
self.controlfile('README', 'w').write(
287
119
"This is a Bazaar-NG control directory.\n"
288
"Do not change any files in this directory.\n")
120
"Do not change any files in this directory.")
289
121
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
290
122
for d in ('text-store', 'inventory-store', 'revision-store'):
291
123
os.mkdir(self.controlfilename(d))
292
124
for f in ('revision-history', 'merged-patches',
293
'pending-merged-patches', 'branch-name',
294
'branch-lock'):
125
'pending-merged-patches', 'branch-name'):
295
126
self.controlfile(f, 'w').write('')
296
127
mutter('created control directory in ' + self.base)
297
128
Inventory().write_xml(self.controlfile('inventory','w'))
304
135
305
136
In the future, we might need different in-memory Branch
306
137
classes to support downlevel branches. But not yet.
307
"""
308
# This ignores newlines so that we can open branches created
309
# on Windows from Linux and so on. I think it might be better
310
# to always make all internal files in unix format.
311
fmt = self.controlfile('branch-format', 'r').read()
312
fmt.replace('\r\n', '')
138
"""
139
# read in binary mode to detect newline wierdness.
140
fmt = self.controlfile('branch-format', 'rb').read()
313
141
if fmt != BZR_BRANCH_FORMAT:
314
raise BzrError('sorry, branch format %r not supported' % fmt,
315
['use a different bzr version',
316
'or remove the .bzr directory and "bzr init" again'])
317
142
bailout('sorry, branch format %r not supported' % fmt,
143
['use a different bzr version',
144
'or remove the .bzr directory and "bzr init" again'])
318
145
319
146
320
147
def read_working_inventory(self):
321
148
"""Read the working inventory."""
322
149
before = time.time()
323
# ElementTree does its own conversion from UTF-8, so open in
324
# binary.
325
self.lock_read()
326
try:
327
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
328
mutter("loaded inventory of %d items in %f"
329
% (len(inv), time.time() - before))
330
return inv
331
finally:
332
self.unlock()
333
150
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
151
mutter("loaded inventory of %d items in %f"
152
% (len(inv), time.time() - before))
153
return inv
154
334
155
335
156
def _write_inventory(self, inv):
336
157
"""Update the working inventory.
339
160
will be committed to the next revision.
340
161
"""
341
162
## TODO: factor out to atomicfile? is rename safe on windows?
342
## TODO: Maybe some kind of clean/dirty marker on inventory?
343
163
tmpfname = self.controlfilename('inventory.tmp')
344
tmpf = file(tmpfname, 'wb')
164
tmpf = file(tmpfname, 'w')
345
165
inv.write_xml(tmpf)
346
166
tmpf.close()
347
inv_fname = self.controlfilename('inventory')
348
if sys.platform == 'win32':
349
os.remove(inv_fname)
350
os.rename(tmpfname, inv_fname)
167
os.rename(tmpfname, self.controlfilename('inventory'))
351
168
mutter('wrote working inventory')
352
169
353
170
354
171
inventory = property(read_working_inventory, _write_inventory, None,
355
172
"""Inventory for the working copy.""")
356
173
357
174
358
def add(self, files, verbose=False, ids=None):
175
def add(self, files, verbose=False):
359
176
"""Make files versioned.
360
177
361
Note that the command line normally calls smart_add instead.
362
363
178
This puts the files in the Added state, so that they will be
364
179
recorded by the next commit.
365
180
366
files
367
List of paths to add, relative to the base of the tree.
368
369
ids
370
If set, use these instead of automatically generated ids.
371
Must be the same length as the list of files, but may
372
contain None for ids that are to be autogenerated.
373
374
TODO: Perhaps have an option to add the ids even if the files do
375
not (yet) exist.
376
377
TODO: Perhaps return the ids of the files? But then again it
378
is easy to retrieve them if they're needed.
379
380
TODO: Adding a directory should optionally recurse down and
381
add all non-ignored children. Perhaps do that in a
382
higher-level method.
181
:todo: Perhaps have an option to add the ids even if the files do
182
not (yet) exist.
183
184
:todo: Perhaps return the ids of the files? But then again it
185
is easy to retrieve them if they're needed.
186
187
:todo: Option to specify file id.
188
189
:todo: Adding a directory should optionally recurse down and
190
add all non-ignored children. Perhaps do that in a
191
higher-level method.
192
193
>>> b = ScratchBranch(files=['foo'])
194
>>> 'foo' in b.unknowns()
195
True
196
>>> b.show_status()
197
? foo
198
>>> b.add('foo')
199
>>> 'foo' in b.unknowns()
200
False
201
>>> bool(b.inventory.path2id('foo'))
202
True
203
>>> b.show_status()
204
A foo
205
206
>>> b.add('foo')
207
Traceback (most recent call last):
208
...
209
BzrError: ('foo is already versioned', [])
210
211
>>> b.add(['nothere'])
212
Traceback (most recent call last):
213
BzrError: ('cannot add: not a regular file or directory: nothere', [])
383
214
"""
215
384
216
# TODO: Re-adding a file that is removed in the working copy
385
217
# should probably put it back with the previous ID.
386
218
if isinstance(files, types.StringTypes):
387
assert(ids is None or isinstance(ids, types.StringTypes))
388
219
files = [files]
389
if ids is not None:
390
ids = [ids]
391
392
if ids is None:
393
ids = [None] * len(files)
394
else:
395
assert(len(ids) == len(files))
396
397
self.lock_write()
398
try:
399
inv = self.read_working_inventory()
400
for f,file_id in zip(files, ids):
401
if is_control_file(f):
402
raise BzrError("cannot add control file %s" % quotefn(f))
403
404
fp = splitpath(f)
405
406
if len(fp) == 0:
407
raise BzrError("cannot add top-level %r" % f)
408
409
fullpath = os.path.normpath(self.abspath(f))
410
411
try:
412
kind = file_kind(fullpath)
413
except OSError:
414
# maybe something better?
415
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
416
417
if kind != 'file' and kind != 'directory':
418
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
419
420
if file_id is None:
421
file_id = gen_file_id(f)
422
inv.add_path(f, kind=kind, file_id=file_id)
423
424
if verbose:
425
show_status('A', kind, quotefn(f))
426
427
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
428
429
self._write_inventory(inv)
430
finally:
431
self.unlock()
432
433
434
def print_file(self, file, revno):
435
"""Print `file` to stdout."""
436
self.lock_read()
437
try:
438
tree = self.revision_tree(self.lookup_revision(revno))
439
# use inventory as it was in that revision
440
file_id = tree.inventory.path2id(file)
441
if not file_id:
442
raise BzrError("%r is not present in revision %d" % (file, revno))
443
tree.print_file(file_id)
444
finally:
445
self.unlock()
220
221
inv = self.read_working_inventory()
222
for f in files:
223
if is_control_file(f):
224
bailout("cannot add control file %s" % quotefn(f))
225
226
fp = splitpath(f)
227
228
if len(fp) == 0:
229
bailout("cannot add top-level %r" % f)
230
231
fullpath = os.path.normpath(self._rel(f))
232
233
if isfile(fullpath):
234
kind = 'file'
235
elif isdir(fullpath):
236
kind = 'directory'
237
else:
238
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
239
240
if len(fp) > 1:
241
parent_name = joinpath(fp[:-1])
242
mutter("lookup parent %r" % parent_name)
243
parent_id = inv.path2id(parent_name)
244
if parent_id == None:
245
bailout("cannot add: parent %r is not versioned"
246
% joinpath(fp[:-1]))
247
else:
248
parent_id = None
249
250
file_id = _gen_file_id(fp[-1])
251
inv.add(InventoryEntry(file_id, fp[-1], kind=kind, parent_id=parent_id))
252
if verbose:
253
show_status('A', kind, quotefn(f))
254
255
mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
256
% (f, file_id, kind, parent_id))
257
self._write_inventory(inv)
258
446
259
447
260
448
261
def remove(self, files, verbose=False):
450
263
451
264
This does not remove their text. This does not run on
452
265
453
TODO: Refuse to remove modified files unless --force is given?
454
455
TODO: Do something useful with directories.
456
457
TODO: Should this remove the text or not? Tough call; not
266
:todo: Refuse to remove modified files unless --force is given?
267
268
>>> b = ScratchBranch(files=['foo'])
269
>>> b.add('foo')
270
>>> b.inventory.has_filename('foo')
271
True
272
>>> b.remove('foo')
273
>>> b.working_tree().has_filename('foo')
274
True
275
>>> b.inventory.has_filename('foo')
276
False
277
278
>>> b = ScratchBranch(files=['foo'])
279
>>> b.add('foo')
280
>>> b.commit('one')
281
>>> b.remove('foo')
282
>>> b.commit('two')
283
>>> b.inventory.has_filename('foo')
284
False
285
>>> b.basis_tree().has_filename('foo')
286
False
287
>>> b.working_tree().has_filename('foo')
288
True
289
290
:todo: Do something useful with directories.
291
292
:todo: Should this remove the text or not? Tough call; not
458
293
removing may be useful and the user can just use use rm, and
459
294
is the opposite of add. Removing it is consistent with most
460
295
other tools. Maybe an option.
461
296
"""
462
297
## TODO: Normalize names
463
298
## TODO: Remove nested loops; better scalability
299
464
300
if isinstance(files, types.StringTypes):
465
301
files = [files]
466
467
self.lock_write()
468
469
try:
470
tree = self.working_tree()
471
inv = tree.inventory
472
473
# do this before any modifications
474
for f in files:
475
fid = inv.path2id(f)
476
if not fid:
477
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
478
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
479
if verbose:
480
# having remove it, it must be either ignored or unknown
481
if tree.is_ignored(f):
482
new_status = 'I'
483
else:
484
new_status = '?'
485
show_status(new_status, inv[fid].kind, quotefn(f))
486
del inv[fid]
487
488
self._write_inventory(inv)
489
finally:
490
self.unlock()
491
492
493
# FIXME: this doesn't need to be a branch method
494
def set_inventory(self, new_inventory_list):
495
inv = Inventory()
496
for path, file_id, parent, kind in new_inventory_list:
497
name = os.path.basename(path)
498
if name == "":
499
continue
500
inv.add(InventoryEntry(file_id, name, kind, parent))
302
303
tree = self.working_tree()
304
inv = tree.inventory
305
306
# do this before any modifications
307
for f in files:
308
fid = inv.path2id(f)
309
if not fid:
310
bailout("cannot remove unversioned file %s" % quotefn(f))
311
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
312
if verbose:
313
# having remove it, it must be either ignored or unknown
314
if tree.is_ignored(f):
315
new_status = 'I'
316
else:
317
new_status = '?'
318
show_status(new_status, inv[fid].kind, quotefn(f))
319
del inv[fid]
320
501
321
self._write_inventory(inv)
502
322
503
323
520
340
return self.working_tree().unknowns()
521
341
522
342
523
def append_revision(self, revision_id):
524
mutter("add {%s} to revision-history" % revision_id)
525
rev_history = self.revision_history()
526
527
tmprhname = self.controlfilename('revision-history.tmp')
528
rhname = self.controlfilename('revision-history')
529
530
f = file(tmprhname, 'wt')
531
rev_history.append(revision_id)
532
f.write('\n'.join(rev_history))
533
f.write('\n')
534
f.close()
535
536
if sys.platform == 'win32':
537
os.remove(rhname)
538
os.rename(tmprhname, rhname)
539
343
def commit(self, message, timestamp=None, timezone=None,
344
committer=None,
345
verbose=False):
346
"""Commit working copy as a new revision.
347
348
The basic approach is to add all the file texts into the
349
store, then the inventory, then make a new revision pointing
350
to that inventory and store that.
351
352
This is not quite safe if the working copy changes during the
353
commit; for the moment that is simply not allowed. A better
354
approach is to make a temporary copy of the files before
355
computing their hashes, and then add those hashes in turn to
356
the inventory. This should mean at least that there are no
357
broken hash pointers. There is no way we can get a snapshot
358
of the whole directory at an instant. This would also have to
359
be robust against files disappearing, moving, etc. So the
360
whole thing is a bit hard.
361
362
:param timestamp: if not None, seconds-since-epoch for a
363
postdated/predated commit.
364
"""
365
366
## TODO: Show branch names
367
368
# TODO: Don't commit if there are no changes, unless forced?
369
370
# First walk over the working inventory; and both update that
371
# and also build a new revision inventory. The revision
372
# inventory needs to hold the text-id, sha1 and size of the
373
# actual file versions committed in the revision. (These are
374
# not present in the working inventory.) We also need to
375
# detect missing/deleted files, and remove them from the
376
# working inventory.
377
378
work_inv = self.read_working_inventory()
379
inv = Inventory()
380
basis = self.basis_tree()
381
basis_inv = basis.inventory
382
missing_ids = []
383
for path, entry in work_inv.iter_entries():
384
## TODO: Cope with files that have gone missing.
385
386
## TODO: Check that the file kind has not changed from the previous
387
## revision of this file (if any).
388
389
entry = entry.copy()
390
391
p = self._rel(path)
392
file_id = entry.file_id
393
mutter('commit prep file %s, id %r ' % (p, file_id))
394
395
if not os.path.exists(p):
396
mutter(" file is missing, removing from inventory")
397
if verbose:
398
show_status('D', entry.kind, quotefn(path))
399
missing_ids.append(file_id)
400
continue
401
402
# TODO: Handle files that have been deleted
403
404
# TODO: Maybe a special case for empty files? Seems a
405
# waste to store them many times.
406
407
inv.add(entry)
408
409
if basis_inv.has_id(file_id):
410
old_kind = basis_inv[file_id].kind
411
if old_kind != entry.kind:
412
bailout("entry %r changed kind from %r to %r"
413
% (file_id, old_kind, entry.kind))
414
415
if entry.kind == 'directory':
416
if not isdir(p):
417
bailout("%s is entered as directory but not a directory" % quotefn(p))
418
elif entry.kind == 'file':
419
if not isfile(p):
420
bailout("%s is entered as file but is not a file" % quotefn(p))
421
422
content = file(p, 'rb').read()
423
424
entry.text_sha1 = sha_string(content)
425
entry.text_size = len(content)
426
427
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
428
if (old_ie
429
and (old_ie.text_size == entry.text_size)
430
and (old_ie.text_sha1 == entry.text_sha1)):
431
## assert content == basis.get_file(file_id).read()
432
entry.text_id = basis_inv[file_id].text_id
433
mutter(' unchanged from previous text_id {%s}' %
434
entry.text_id)
435
436
else:
437
entry.text_id = _gen_file_id(entry.name)
438
self.text_store.add(content, entry.text_id)
439
mutter(' stored with text_id {%s}' % entry.text_id)
440
if verbose:
441
if not old_ie:
442
state = 'A'
443
elif (old_ie.name == entry.name
444
and old_ie.parent_id == entry.parent_id):
445
state = 'R'
446
else:
447
state = 'M'
448
449
show_status(state, entry.kind, quotefn(path))
450
451
for file_id in missing_ids:
452
# have to do this later so we don't mess up the iterator.
453
# since parents may be removed before their children we
454
# have to test.
455
456
# FIXME: There's probably a better way to do this; perhaps
457
# the workingtree should know how to filter itself.
458
if work_inv.has_id(file_id):
459
del work_inv[file_id]
460
461
462
inv_id = rev_id = _gen_revision_id(time.time())
463
464
inv_tmp = tempfile.TemporaryFile()
465
inv.write_xml(inv_tmp)
466
inv_tmp.seek(0)
467
self.inventory_store.add(inv_tmp, inv_id)
468
mutter('new inventory_id is {%s}' % inv_id)
469
470
self._write_inventory(work_inv)
471
472
if timestamp == None:
473
timestamp = time.time()
474
475
if committer == None:
476
committer = username()
477
478
if timezone == None:
479
timezone = local_time_offset()
480
481
mutter("building commit log message")
482
rev = Revision(timestamp=timestamp,
483
timezone=timezone,
484
committer=committer,
485
precursor = self.last_patch(),
486
message = message,
487
inventory_id=inv_id,
488
revision_id=rev_id)
489
490
rev_tmp = tempfile.TemporaryFile()
491
rev.write_xml(rev_tmp)
492
rev_tmp.seek(0)
493
self.revision_store.add(rev_tmp, rev_id)
494
mutter("new revision_id is {%s}" % rev_id)
495
496
## XXX: Everything up to here can simply be orphaned if we abort
497
## the commit; it will leave junk files behind but that doesn't
498
## matter.
499
500
## TODO: Read back the just-generated changeset, and make sure it
501
## applies and recreates the right state.
502
503
## TODO: Also calculate and store the inventory SHA1
504
mutter("committing patch r%d" % (self.revno() + 1))
505
506
mutter("append to revision-history")
507
self.controlfile('revision-history', 'at').write(rev_id + '\n')
508
509
mutter("done!")
540
510
541
511
542
512
def get_revision(self, revision_id):
543
513
"""Return the Revision object for a named revision"""
544
if not revision_id or not isinstance(revision_id, basestring):
545
raise ValueError('invalid revision-id: %r' % revision_id)
546
514
r = Revision.read_xml(self.revision_store[revision_id])
547
515
assert r.revision_id == revision_id
548
516
return r
549
517
550
def get_revision_sha1(self, revision_id):
551
"""Hash the stored value of a revision, and return it."""
552
# In the future, revision entries will be signed. At that
553
# point, it is probably best *not* to include the signature
554
# in the revision hash. Because that lets you re-sign
555
# the revision, (add signatures/remove signatures) and still
556
# have all hash pointers stay consistent.
557
# But for now, just hash the contents.
558
return sha_file(self.revision_store[revision_id])
559
560
518
561
519
def get_inventory(self, inventory_id):
562
520
"""Get Inventory object by hash.
563
521
564
TODO: Perhaps for this and similar methods, take a revision
522
:todo: Perhaps for this and similar methods, take a revision
565
523
parameter which can be either an integer revno or a
566
524
string hash."""
567
525
i = Inventory.read_xml(self.inventory_store[inventory_id])
568
526
return i
569
527
570
def get_inventory_sha1(self, inventory_id):
571
"""Return the sha1 hash of the inventory entry
572
"""
573
return sha_file(self.inventory_store[inventory_id])
574
575
528
576
529
def get_revision_inventory(self, revision_id):
577
530
"""Return inventory of a past revision."""
587
540
>>> ScratchBranch().revision_history()
588
541
[]
589
542
"""
590
self.lock_read()
591
try:
592
return [l.rstrip('\r\n') for l in
593
self.controlfile('revision-history', 'r').readlines()]
594
finally:
595
self.unlock()
596
597
598
def common_ancestor(self, other, self_revno=None, other_revno=None):
599
"""
600
>>> import commit
601
>>> sb = ScratchBranch(files=['foo', 'foo~'])
602
>>> sb.common_ancestor(sb) == (None, None)
603
True
604
>>> commit.commit(sb, "Committing first revision", verbose=False)
605
>>> sb.common_ancestor(sb)[0]
606
1
607
>>> clone = sb.clone()
608
>>> commit.commit(sb, "Committing second revision", verbose=False)
609
>>> sb.common_ancestor(sb)[0]
610
2
611
>>> sb.common_ancestor(clone)[0]
612
1
613
>>> commit.commit(clone, "Committing divergent second revision",
614
... verbose=False)
615
>>> sb.common_ancestor(clone)[0]
616
1
617
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
618
True
619
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
620
True
621
>>> clone2 = sb.clone()
622
>>> sb.common_ancestor(clone2)[0]
623
2
624
>>> sb.common_ancestor(clone2, self_revno=1)[0]
625
1
626
>>> sb.common_ancestor(clone2, other_revno=1)[0]
627
1
628
"""
629
my_history = self.revision_history()
630
other_history = other.revision_history()
631
if self_revno is None:
632
self_revno = len(my_history)
633
if other_revno is None:
634
other_revno = len(other_history)
635
indices = range(min((self_revno, other_revno)))
636
indices.reverse()
637
for r in indices:
638
if my_history[r] == other_history[r]:
639
return r+1, my_history[r]
640
return None, None
641
642
def enum_history(self, direction):
643
"""Return (revno, revision_id) for history of branch.
644
645
direction
646
'forward' is from earliest to latest
647
'reverse' is from latest to earliest
648
"""
649
rh = self.revision_history()
650
if direction == 'forward':
651
i = 1
652
for rid in rh:
653
yield i, rid
654
i += 1
655
elif direction == 'reverse':
656
i = len(rh)
657
while i > 0:
658
yield i, rh[i-1]
659
i -= 1
660
else:
661
raise ValueError('invalid history direction', direction)
543
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
662
544
663
545
664
546
def revno(self):
666
548
667
549
That is equivalent to the number of revisions committed to
668
550
this branch.
551
552
>>> b = ScratchBranch()
553
>>> b.revno()
554
0
555
>>> b.commit('no foo')
556
>>> b.revno()
557
1
669
558
"""
670
559
return len(self.revision_history())
671
560
672
561
673
562
def last_patch(self):
674
563
"""Return last patch hash, or None if no history.
564
565
>>> ScratchBranch().last_patch() == None
566
True
675
567
"""
676
568
ph = self.revision_history()
677
569
if ph:
678
570
return ph[-1]
679
else:
680
return None
681
682
683
def missing_revisions(self, other, stop_revision=None):
684
"""
685
If self and other have not diverged, return a list of the revisions
686
present in other, but missing from self.
687
688
>>> from bzrlib.commit import commit
689
>>> bzrlib.trace.silent = True
690
>>> br1 = ScratchBranch()
691
>>> br2 = ScratchBranch()
692
>>> br1.missing_revisions(br2)
693
[]
694
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
695
>>> br1.missing_revisions(br2)
696
[u'REVISION-ID-1']
697
>>> br2.missing_revisions(br1)
698
[]
699
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
700
>>> br1.missing_revisions(br2)
701
[]
702
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
703
>>> br1.missing_revisions(br2)
704
[u'REVISION-ID-2A']
705
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
706
>>> br1.missing_revisions(br2)
707
Traceback (most recent call last):
708
DivergedBranches: These branches have diverged.
709
"""
710
self_history = self.revision_history()
711
self_len = len(self_history)
712
other_history = other.revision_history()
713
other_len = len(other_history)
714
common_index = min(self_len, other_len) -1
715
if common_index >= 0 and \
716
self_history[common_index] != other_history[common_index]:
717
raise DivergedBranches(self, other)
718
719
if stop_revision is None:
720
stop_revision = other_len
721
elif stop_revision > other_len:
722
raise NoSuchRevision(self, stop_revision)
723
724
return other_history[self_len:stop_revision]
725
726
727
def update_revisions(self, other, stop_revision=None):
728
"""Pull in all new revisions from other branch.
729
730
>>> from bzrlib.commit import commit
731
>>> bzrlib.trace.silent = True
732
>>> br1 = ScratchBranch(files=['foo', 'bar'])
733
>>> br1.add('foo')
734
>>> br1.add('bar')
735
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
736
>>> br2 = ScratchBranch()
737
>>> br2.update_revisions(br1)
738
Added 2 texts.
739
Added 1 inventories.
740
Added 1 revisions.
741
>>> br2.revision_history()
742
[u'REVISION-ID-1']
743
>>> br2.update_revisions(br1)
744
Added 0 texts.
745
Added 0 inventories.
746
Added 0 revisions.
747
>>> br1.text_store.total_size() == br2.text_store.total_size()
748
True
749
"""
750
from bzrlib.progress import ProgressBar
751
752
pb = ProgressBar()
753
754
pb.update('comparing histories')
755
revision_ids = self.missing_revisions(other, stop_revision)
756
revisions = []
757
needed_texts = sets.Set()
758
i = 0
759
for rev_id in revision_ids:
760
i += 1
761
pb.update('fetching revision', i, len(revision_ids))
762
rev = other.get_revision(rev_id)
763
revisions.append(rev)
764
inv = other.get_inventory(str(rev.inventory_id))
765
for key, entry in inv.iter_entries():
766
if entry.text_id is None:
767
continue
768
if entry.text_id not in self.text_store:
769
needed_texts.add(entry.text_id)
770
771
pb.clear()
772
773
count = self.text_store.copy_multi(other.text_store, needed_texts)
774
print "Added %d texts." % count
775
inventory_ids = [ f.inventory_id for f in revisions ]
776
count = self.inventory_store.copy_multi(other.inventory_store,
777
inventory_ids)
778
print "Added %d inventories." % count
779
revision_ids = [ f.revision_id for f in revisions]
780
count = self.revision_store.copy_multi(other.revision_store,
781
revision_ids)
782
for revision_id in revision_ids:
783
self.append_revision(revision_id)
784
print "Added %d revisions." % count
785
786
787
def commit(self, *args, **kw):
788
from bzrlib.commit import commit
789
commit(self, *args, **kw)
790
571
791
572
792
573
def lookup_revision(self, revno):
793
574
"""Return revision hash for revision number."""
798
579
# list is 0-based; revisions are 1-based
799
580
return self.revision_history()[revno-1]
800
581
except IndexError:
801
raise BzrError("no such revision %s" % revno)
582
bailout("no such revision %s" % revno)
802
583
803
584
804
585
def revision_tree(self, revision_id):
806
587
807
588
`revision_id` may be None for the null revision, in which case
808
589
an `EmptyTree` is returned."""
809
# TODO: refactor this to use an existing revision object
810
# so we don't need to read it in twice.
590
811
591
if revision_id == None:
812
592
return EmptyTree()
813
593
else:
817
597
818
598
def working_tree(self):
819
599
"""Return a `Tree` for the working copy."""
820
from workingtree import WorkingTree
821
600
return WorkingTree(self.base, self.read_working_inventory())
822
601
823
602
825
604
"""Return `Tree` object for last revision.
826
605
827
606
If there are no revisions yet, return an `EmptyTree`.
607
608
>>> b = ScratchBranch(files=['foo'])
609
>>> b.basis_tree().has_filename('foo')
610
False
611
>>> b.working_tree().has_filename('foo')
612
True
613
>>> b.add('foo')
614
>>> b.commit('add foo')
615
>>> b.basis_tree().has_filename('foo')
616
True
828
617
"""
829
618
r = self.last_patch()
830
619
if r == None:
834
623
835
624
836
625
837
def rename_one(self, from_rel, to_rel):
838
"""Rename one file.
839
840
This can change the directory or the filename or both.
841
"""
842
self.lock_write()
843
try:
844
tree = self.working_tree()
845
inv = tree.inventory
846
if not tree.has_filename(from_rel):
847
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
848
if tree.has_filename(to_rel):
849
raise BzrError("can't rename: new working file %r already exists" % to_rel)
850
851
file_id = inv.path2id(from_rel)
852
if file_id == None:
853
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
854
855
if inv.path2id(to_rel):
856
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
857
858
to_dir, to_tail = os.path.split(to_rel)
859
to_dir_id = inv.path2id(to_dir)
860
if to_dir_id == None and to_dir != '':
861
raise BzrError("can't determine destination directory id for %r" % to_dir)
862
863
mutter("rename_one:")
864
mutter(" file_id {%s}" % file_id)
865
mutter(" from_rel %r" % from_rel)
866
mutter(" to_rel %r" % to_rel)
867
mutter(" to_dir %r" % to_dir)
868
mutter(" to_dir_id {%s}" % to_dir_id)
869
870
inv.rename(file_id, to_dir_id, to_tail)
871
872
print "%s => %s" % (from_rel, to_rel)
873
874
from_abs = self.abspath(from_rel)
875
to_abs = self.abspath(to_rel)
876
try:
877
os.rename(from_abs, to_abs)
878
except OSError, e:
879
raise BzrError("failed to rename %r to %r: %s"
880
% (from_abs, to_abs, e[1]),
881
["rename rolled back"])
882
883
self._write_inventory(inv)
884
finally:
885
self.unlock()
886
887
888
def move(self, from_paths, to_name):
889
"""Rename files.
890
891
to_name must exist as a versioned directory.
892
893
If to_name exists and is a directory, the files are moved into
894
it, keeping their old names. If it is a directory,
895
896
Note that to_name is only the last component of the new name;
897
this doesn't change the directory.
898
"""
899
self.lock_write()
900
try:
901
## TODO: Option to move IDs only
902
assert not isinstance(from_paths, basestring)
903
tree = self.working_tree()
904
inv = tree.inventory
905
to_abs = self.abspath(to_name)
906
if not isdir(to_abs):
907
raise BzrError("destination %r is not a directory" % to_abs)
908
if not tree.has_filename(to_name):
909
raise BzrError("destination %r not in working directory" % to_abs)
910
to_dir_id = inv.path2id(to_name)
911
if to_dir_id == None and to_name != '':
912
raise BzrError("destination %r is not a versioned directory" % to_name)
913
to_dir_ie = inv[to_dir_id]
914
if to_dir_ie.kind not in ('directory', 'root_directory'):
915
raise BzrError("destination %r is not a directory" % to_abs)
916
917
to_idpath = inv.get_idpath(to_dir_id)
918
919
for f in from_paths:
920
if not tree.has_filename(f):
921
raise BzrError("%r does not exist in working tree" % f)
922
f_id = inv.path2id(f)
923
if f_id == None:
924
raise BzrError("%r is not versioned" % f)
925
name_tail = splitpath(f)[-1]
926
dest_path = appendpath(to_name, name_tail)
927
if tree.has_filename(dest_path):
928
raise BzrError("destination %r already exists" % dest_path)
929
if f_id in to_idpath:
930
raise BzrError("can't move %r to a subdirectory of itself" % f)
931
932
# OK, so there's a race here, it's possible that someone will
933
# create a file in this interval and then the rename might be
934
# left half-done. But we should have caught most problems.
935
936
for f in from_paths:
937
name_tail = splitpath(f)[-1]
938
dest_path = appendpath(to_name, name_tail)
939
print "%s => %s" % (f, dest_path)
940
inv.rename(inv.path2id(f), to_dir_id, name_tail)
941
try:
942
os.rename(self.abspath(f), self.abspath(dest_path))
943
except OSError, e:
944
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
945
["rename rolled back"])
946
947
self._write_inventory(inv)
948
finally:
949
self.unlock()
950
626
def write_log(self, show_timezone='original'):
627
"""Write out human-readable log of commits to this branch
628
629
:param utc: If true, show dates in universal time, not local time."""
630
## TODO: Option to choose either original, utc or local timezone
631
revno = 1
632
precursor = None
633
for p in self.revision_history():
634
print '-' * 40
635
print 'revno:', revno
636
## TODO: Show hash if --id is given.
637
##print 'revision-hash:', p
638
rev = self.get_revision(p)
639
print 'committer:', rev.committer
640
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
641
show_timezone))
642
643
## opportunistic consistency check, same as check_patch_chaining
644
if rev.precursor != precursor:
645
bailout("mismatched precursor!")
646
647
print 'message:'
648
if not rev.message:
649
print ' (no message)'
650
else:
651
for l in rev.message.split('\n'):
652
print ' ' + l
653
654
revno += 1
655
precursor = p
656
657
658
659
def show_status(branch, show_all=False):
660
"""Display single-line status for non-ignored working files.
661
662
The list is show sorted in order by file name.
663
664
>>> b = ScratchBranch(files=['foo', 'foo~'])
665
>>> b.show_status()
666
? foo
667
>>> b.add('foo')
668
>>> b.show_status()
669
A foo
670
>>> b.commit("add foo")
671
>>> b.show_status()
672
>>> os.unlink(b._rel('foo'))
673
>>> b.show_status()
674
D foo
675
676
677
:todo: Get state for single files.
678
679
:todo: Perhaps show a slash at the end of directory names.
680
681
"""
682
683
# We have to build everything into a list first so that it can
684
# sorted by name, incorporating all the different sources.
685
686
# FIXME: Rather than getting things in random order and then sorting,
687
# just step through in order.
688
689
# Interesting case: the old ID for a file has been removed,
690
# but a new file has been created under that name.
691
692
old = branch.basis_tree()
693
old_inv = old.inventory
694
new = branch.working_tree()
695
new_inv = new.inventory
696
697
for fs, fid, oldname, newname, kind in diff_trees(old, new):
698
if fs == 'R':
699
show_status(fs, kind,
700
oldname + ' => ' + newname)
701
elif fs == 'A' or fs == 'M':
702
show_status(fs, kind, newname)
703
elif fs == 'D':
704
show_status(fs, kind, oldname)
705
elif fs == '.':
706
if show_all:
707
show_status(fs, kind, newname)
708
elif fs == 'I':
709
if show_all:
710
show_status(fs, kind, newname)
711
elif fs == '?':
712
show_status(fs, kind, newname)
713
else:
714
bailout("wierd file state %r" % ((fs, fid),))
715
951
716
952
717
953
718
class ScratchBranch(Branch):
957
722
>>> isdir(b.base)
958
723
True
959
724
>>> bd = b.base
960
>>> b.destroy()
725
>>> del b
961
726
>>> isdir(bd)
962
727
False
963
728
"""
964
def __init__(self, files=[], dirs=[], base=None):
729
def __init__(self, files = []):
965
730
"""Make a test branch.
966
731
967
732
This creates a temporary directory and runs init-tree in it.
968
733
969
734
If any files are listed, they are created in the working copy.
970
735
"""
971
init = False
972
if base is None:
973
base = tempfile.mkdtemp()
974
init = True
975
Branch.__init__(self, base, init=init)
976
for d in dirs:
977
os.mkdir(self.abspath(d))
978
736
Branch.__init__(self, tempfile.mkdtemp(), init=True)
979
737
for f in files:
980
738
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
981
739
982
740
983
def clone(self):
984
"""
985
>>> orig = ScratchBranch(files=["file1", "file2"])
986
>>> clone = orig.clone()
987
>>> os.path.samefile(orig.base, clone.base)
988
False
989
>>> os.path.isfile(os.path.join(clone.base, "file1"))
990
True
991
"""
992
base = tempfile.mkdtemp()
993
os.rmdir(base)
994
shutil.copytree(self.base, base, symlinks=True)
995
return ScratchBranch(base=base)
996
997
741
def __del__(self):
998
self.destroy()
999
1000
def destroy(self):
1001
742
"""Destroy the test branch, removing the scratch directory."""
1002
try:
1003
if self.base:
1004
mutter("delete ScratchBranch %s" % self.base)
1005
shutil.rmtree(self.base)
1006
except OSError, e:
1007
# Work around for shutil.rmtree failing on Windows when
1008
# readonly files are encountered
1009
mutter("hit exception in destroying ScratchBranch: %s" % e)
1010
for root, dirs, files in os.walk(self.base, topdown=False):
1011
for name in files:
1012
os.chmod(os.path.join(root, name), 0700)
1013
shutil.rmtree(self.base)
1014
self.base = None
743
shutil.rmtree(self.base)
1015
744
1016
745
1017
746
1027
756
## mutter('check %r for control file' % ((head, tail), ))
1028
757
if tail == bzrlib.BZRDIR:
1029
758
return True
1030
if filename == head:
1031
break
1032
759
filename = head
1033
760
return False
1034
761
1035
762
1036
763
1037
def gen_file_id(name):
764
def _gen_revision_id(when):
765
"""Return new revision-id."""
766
s = '%s-%s-' % (user_email(), compact_date(when))
767
s += hexlify(rand_bytes(8))
768
return s
769
770
771
def _gen_file_id(name):
1038
772
"""Return new file id.
1039
773
1040
774
This should probably generate proper UUIDs, but for the moment we
1041
775
cope with just randomness because running uuidgen every time is
1042
776
slow."""
1043
import re
1044
1045
# get last component
1046
idx = name.rfind('/')
1047
if idx != -1:
1048
name = name[idx+1 : ]
1049
idx = name.rfind('\\')
1050
if idx != -1:
1051
name = name[idx+1 : ]
1052
1053
# make it not a hidden file
1054
name = name.lstrip('.')
1055
1056
# remove any wierd characters; we don't escape them but rather
1057
# just pull them out
1058
name = re.sub(r'[^\w.]', '', name)
1059
777
assert '/' not in name
778
while name[0] == '.':
779
name = name[1:]
1060
780
s = hexlify(rand_bytes(8))
1061
781
return '-'.join((name, compact_date(time.time()), s))
782
783
Loggerhead is a web-based interface for Breezy
Version: 2.0.1