« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: mbp at sourcefrog
- Date: 2005-03-09 04:08:15 UTC
- Revision ID: mbp@sourcefrog.net-20050309040815-13242001617e4a06
import from baz patch-364
- files added:
- bzrlib/tests.py
- files removed:
- .bzrignore
- bzrlib/selftest
- contrib
- contrib/bash
- contrib/plugins
- contrib/plugins/changeset
- contrib/zsh
- doc
- elementtree
- notes
- patches
- urlgrabber
- files renamed:
- bzrlib/commands.py => bzr.py
- files modified:
- README
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
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.
338
159
That is to say, the inventory describing changes underway, that
339
160
will be committed to the next revision.
340
161
"""
341
## TODO: factor out to atomicfile? is rename safe on windows?
342
## TODO: Maybe some kind of clean/dirty marker on inventory?
343
tmpfname = self.controlfilename('inventory.tmp')
344
tmpf = file(tmpfname, 'wb')
345
inv.write_xml(tmpf)
346
tmpf.close()
347
inv_fname = self.controlfilename('inventory')
348
if sys.platform == 'win32':
349
os.remove(inv_fname)
350
os.rename(tmpfname, inv_fname)
351
mutter('wrote working inventory')
352
162
inv.write_xml(self.controlfile('inventory', 'w'))
163
mutter('wrote inventory to %s' % quotefn(self.controlfilename('inventory')))
164
353
165
354
166
inventory = property(read_working_inventory, _write_inventory, None,
355
167
"""Inventory for the working copy.""")
356
168
357
169
358
def add(self, files, verbose=False, ids=None):
170
def add(self, files, verbose=False):
359
171
"""Make files versioned.
360
172
361
Note that the command line normally calls smart_add instead.
362
363
173
This puts the files in the Added state, so that they will be
364
174
recorded by the next commit.
365
175
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.
176
:todo: Perhaps have an option to add the ids even if the files do
177
not (yet) exist.
178
179
:todo: Perhaps return the ids of the files? But then again it
180
is easy to retrieve them if they're needed.
181
182
:todo: Option to specify file id.
183
184
:todo: Adding a directory should optionally recurse down and
185
add all non-ignored children. Perhaps do that in a
186
higher-level method.
187
188
>>> b = ScratchBranch(files=['foo'])
189
>>> 'foo' in b.unknowns()
190
True
191
>>> b.show_status()
192
? foo
193
>>> b.add('foo')
194
>>> 'foo' in b.unknowns()
195
False
196
>>> bool(b.inventory.path2id('foo'))
197
True
198
>>> b.show_status()
199
A foo
200
201
>>> b.add('foo')
202
Traceback (most recent call last):
203
...
204
BzrError: ('foo is already versioned', [])
205
206
>>> b.add(['nothere'])
207
Traceback (most recent call last):
208
BzrError: ('cannot add: not a regular file or directory: nothere', [])
383
209
"""
210
384
211
# TODO: Re-adding a file that is removed in the working copy
385
212
# should probably put it back with the previous ID.
386
213
if isinstance(files, types.StringTypes):
387
assert(ids is None or isinstance(ids, types.StringTypes))
388
214
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()
215
216
inv = self.read_working_inventory()
217
for f in files:
218
if is_control_file(f):
219
bailout("cannot add control file %s" % quotefn(f))
220
221
fp = splitpath(f)
222
223
if len(fp) == 0:
224
bailout("cannot add top-level %r" % f)
225
226
fullpath = os.path.normpath(self._rel(f))
227
228
if isfile(fullpath):
229
kind = 'file'
230
elif isdir(fullpath):
231
kind = 'directory'
232
else:
233
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
234
235
if len(fp) > 1:
236
parent_name = joinpath(fp[:-1])
237
mutter("lookup parent %r" % parent_name)
238
parent_id = inv.path2id(parent_name)
239
if parent_id == None:
240
bailout("cannot add: parent %r is not versioned"
241
% joinpath(fp[:-1]))
242
else:
243
parent_id = None
244
245
file_id = _gen_file_id(fp[-1])
246
inv.add(InventoryEntry(file_id, fp[-1], kind=kind, parent_id=parent_id))
247
if verbose:
248
show_status('A', kind, quotefn(f))
249
250
mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
251
% (f, file_id, kind, parent_id))
252
self._write_inventory(inv)
253
446
254
447
255
448
256
def remove(self, files, verbose=False):
450
258
451
259
This does not remove their text. This does not run on
452
260
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
261
:todo: Refuse to remove modified files unless --force is given?
262
263
>>> b = ScratchBranch(files=['foo'])
264
>>> b.add('foo')
265
>>> b.inventory.has_filename('foo')
266
True
267
>>> b.remove('foo')
268
>>> b.working_tree().has_filename('foo')
269
True
270
>>> b.inventory.has_filename('foo')
271
False
272
273
>>> b = ScratchBranch(files=['foo'])
274
>>> b.add('foo')
275
>>> b.commit('one')
276
>>> b.remove('foo')
277
>>> b.commit('two')
278
>>> b.inventory.has_filename('foo')
279
False
280
>>> b.basis_tree().has_filename('foo')
281
False
282
>>> b.working_tree().has_filename('foo')
283
True
284
285
:todo: Do something useful with directories.
286
287
:todo: Should this remove the text or not? Tough call; not
458
288
removing may be useful and the user can just use use rm, and
459
289
is the opposite of add. Removing it is consistent with most
460
290
other tools. Maybe an option.
461
291
"""
462
292
## TODO: Normalize names
463
293
## TODO: Remove nested loops; better scalability
294
464
295
if isinstance(files, types.StringTypes):
465
296
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))
297
298
inv = self.read_working_inventory()
299
300
# do this before any modifications
301
for f in files:
302
fid = inv.path2id(f)
303
if not fid:
304
bailout("cannot remove unversioned file %s" % quotefn(f))
305
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
306
if verbose:
307
show_status('D', inv[fid].kind, quotefn(f))
308
del inv[fid]
309
501
310
self._write_inventory(inv)
502
311
503
312
520
329
return self.working_tree().unknowns()
521
330
522
331
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
332
def commit(self, message, timestamp=None, committer=None,
333
verbose=False):
334
"""Commit working copy as a new revision.
335
336
The basic approach is to add all the file texts into the
337
store, then the inventory, then make a new revision pointing
338
to that inventory and store that.
339
340
This is not quite safe if the working copy changes during the
341
commit; for the moment that is simply not allowed. A better
342
approach is to make a temporary copy of the files before
343
computing their hashes, and then add those hashes in turn to
344
the inventory. This should mean at least that there are no
345
broken hash pointers. There is no way we can get a snapshot
346
of the whole directory at an instant. This would also have to
347
be robust against files disappearing, moving, etc. So the
348
whole thing is a bit hard.
349
350
:param timestamp: if not None, seconds-since-epoch for a
351
postdated/predated commit.
352
"""
353
354
## TODO: Show branch names
355
356
# TODO: Don't commit if there are no changes, unless forced?
357
358
# First walk over the working inventory; and both update that
359
# and also build a new revision inventory. The revision
360
# inventory needs to hold the text-id, sha1 and size of the
361
# actual file versions committed in the revision. (These are
362
# not present in the working inventory.) We also need to
363
# detect missing/deleted files, and remove them from the
364
# working inventory.
365
366
work_inv = self.read_working_inventory()
367
inv = Inventory()
368
basis = self.basis_tree()
369
basis_inv = basis.inventory
370
missing_ids = []
371
for path, entry in work_inv.iter_entries():
372
## TODO: Cope with files that have gone missing.
373
374
## TODO: Check that the file kind has not changed from the previous
375
## revision of this file (if any).
376
377
entry = entry.copy()
378
379
p = self._rel(path)
380
file_id = entry.file_id
381
mutter('commit prep file %s, id %r ' % (p, file_id))
382
383
if not os.path.exists(p):
384
mutter(" file is missing, removing from inventory")
385
if verbose:
386
show_status('D', entry.kind, quotefn(path))
387
missing_ids.append(file_id)
388
continue
389
390
# TODO: Handle files that have been deleted
391
392
# TODO: Maybe a special case for empty files? Seems a
393
# waste to store them many times.
394
395
inv.add(entry)
396
397
if basis_inv.has_id(file_id):
398
old_kind = basis_inv[file_id].kind
399
if old_kind != entry.kind:
400
bailout("entry %r changed kind from %r to %r"
401
% (file_id, old_kind, entry.kind))
402
403
if entry.kind == 'directory':
404
if not isdir(p):
405
bailout("%s is entered as directory but not a directory" % quotefn(p))
406
elif entry.kind == 'file':
407
if not isfile(p):
408
bailout("%s is entered as file but is not a file" % quotefn(p))
409
410
content = file(p, 'rb').read()
411
412
entry.text_sha1 = sha_string(content)
413
entry.text_size = len(content)
414
415
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
416
if (old_ie
417
and (old_ie.text_size == entry.text_size)
418
and (old_ie.text_sha1 == entry.text_sha1)):
419
## assert content == basis.get_file(file_id).read()
420
entry.text_id = basis_inv[file_id].text_id
421
mutter(' unchanged from previous text_id {%s}' %
422
entry.text_id)
423
424
else:
425
entry.text_id = _gen_file_id(entry.name)
426
self.text_store.add(content, entry.text_id)
427
mutter(' stored with text_id {%s}' % entry.text_id)
428
if verbose:
429
if not old_ie:
430
state = 'A'
431
elif (old_ie.name == entry.name
432
and old_ie.parent_id == entry.parent_id):
433
state = 'R'
434
else:
435
state = 'M'
436
437
show_status(state, entry.kind, quotefn(path))
438
439
for file_id in missing_ids:
440
# have to do this later so we don't mess up the iterator.
441
# since parents may be removed before their children we
442
# have to test.
443
444
# FIXME: There's probably a better way to do this; perhaps
445
# the workingtree should know how to filter itself.
446
if work_inv.has_id(file_id):
447
del work_inv[file_id]
448
449
450
inv_id = rev_id = _gen_revision_id(time.time())
451
452
inv_tmp = tempfile.TemporaryFile()
453
inv.write_xml(inv_tmp)
454
inv_tmp.seek(0)
455
self.inventory_store.add(inv_tmp, inv_id)
456
mutter('new inventory_id is {%s}' % inv_id)
457
458
self._write_inventory(work_inv)
459
460
if timestamp == None:
461
timestamp = time.time()
462
463
if committer == None:
464
committer = username()
465
466
mutter("building commit log message")
467
rev = Revision(timestamp=timestamp,
468
committer=committer,
469
precursor = self.last_patch(),
470
message = message,
471
inventory_id=inv_id,
472
revision_id=rev_id)
473
474
rev_tmp = tempfile.TemporaryFile()
475
rev.write_xml(rev_tmp)
476
rev_tmp.seek(0)
477
self.revision_store.add(rev_tmp, rev_id)
478
mutter("new revision_id is {%s}" % rev_id)
479
480
## XXX: Everything up to here can simply be orphaned if we abort
481
## the commit; it will leave junk files behind but that doesn't
482
## matter.
483
484
## TODO: Read back the just-generated changeset, and make sure it
485
## applies and recreates the right state.
486
487
## TODO: Also calculate and store the inventory SHA1
488
mutter("committing patch r%d" % (self.revno() + 1))
489
490
mutter("append to revision-history")
491
self.controlfile('revision-history', 'at').write(rev_id + '\n')
492
493
mutter("done!")
540
494
541
495
542
496
def get_revision(self, revision_id):
543
497
"""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
498
r = Revision.read_xml(self.revision_store[revision_id])
547
499
assert r.revision_id == revision_id
548
500
return r
549
501
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
502
561
503
def get_inventory(self, inventory_id):
562
504
"""Get Inventory object by hash.
563
505
564
TODO: Perhaps for this and similar methods, take a revision
506
:todo: Perhaps for this and similar methods, take a revision
565
507
parameter which can be either an integer revno or a
566
508
string hash."""
567
509
i = Inventory.read_xml(self.inventory_store[inventory_id])
568
510
return i
569
511
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
512
576
513
def get_revision_inventory(self, revision_id):
577
514
"""Return inventory of a past revision."""
587
524
>>> ScratchBranch().revision_history()
588
525
[]
589
526
"""
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)
527
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
662
528
663
529
664
530
def revno(self):
666
532
667
533
That is equivalent to the number of revisions committed to
668
534
this branch.
535
536
>>> b = ScratchBranch()
537
>>> b.revno()
538
0
539
>>> b.commit('no foo')
540
>>> b.revno()
541
1
669
542
"""
670
543
return len(self.revision_history())
671
544
672
545
673
546
def last_patch(self):
674
547
"""Return last patch hash, or None if no history.
548
549
>>> ScratchBranch().last_patch() == None
550
True
675
551
"""
676
552
ph = self.revision_history()
677
553
if ph:
678
554
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
"""Deprecated"""
789
from bzrlib.commit import commit
790
commit(self, *args, **kw)
791
555
792
556
793
557
def lookup_revision(self, revno):
794
558
"""Return revision hash for revision number."""
799
563
# list is 0-based; revisions are 1-based
800
564
return self.revision_history()[revno-1]
801
565
except IndexError:
802
raise BzrError("no such revision %s" % revno)
566
bailout("no such revision %s" % revno)
803
567
804
568
805
569
def revision_tree(self, revision_id):
807
571
808
572
`revision_id` may be None for the null revision, in which case
809
573
an `EmptyTree` is returned."""
810
# TODO: refactor this to use an existing revision object
811
# so we don't need to read it in twice.
574
812
575
if revision_id == None:
813
576
return EmptyTree()
814
577
else:
818
581
819
582
def working_tree(self):
820
583
"""Return a `Tree` for the working copy."""
821
from workingtree import WorkingTree
822
584
return WorkingTree(self.base, self.read_working_inventory())
823
585
824
586
826
588
"""Return `Tree` object for last revision.
827
589
828
590
If there are no revisions yet, return an `EmptyTree`.
591
592
>>> b = ScratchBranch(files=['foo'])
593
>>> b.basis_tree().has_filename('foo')
594
False
595
>>> b.working_tree().has_filename('foo')
596
True
597
>>> b.add('foo')
598
>>> b.commit('add foo')
599
>>> b.basis_tree().has_filename('foo')
600
True
829
601
"""
830
602
r = self.last_patch()
831
603
if r == None:
835
607
836
608
837
609
838
def rename_one(self, from_rel, to_rel):
839
"""Rename one file.
840
841
This can change the directory or the filename or both.
842
"""
843
self.lock_write()
844
try:
845
tree = self.working_tree()
846
inv = tree.inventory
847
if not tree.has_filename(from_rel):
848
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
849
if tree.has_filename(to_rel):
850
raise BzrError("can't rename: new working file %r already exists" % to_rel)
851
852
file_id = inv.path2id(from_rel)
853
if file_id == None:
854
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
855
856
if inv.path2id(to_rel):
857
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
858
859
to_dir, to_tail = os.path.split(to_rel)
860
to_dir_id = inv.path2id(to_dir)
861
if to_dir_id == None and to_dir != '':
862
raise BzrError("can't determine destination directory id for %r" % to_dir)
863
864
mutter("rename_one:")
865
mutter(" file_id {%s}" % file_id)
866
mutter(" from_rel %r" % from_rel)
867
mutter(" to_rel %r" % to_rel)
868
mutter(" to_dir %r" % to_dir)
869
mutter(" to_dir_id {%s}" % to_dir_id)
870
871
inv.rename(file_id, to_dir_id, to_tail)
872
873
print "%s => %s" % (from_rel, to_rel)
874
875
from_abs = self.abspath(from_rel)
876
to_abs = self.abspath(to_rel)
877
try:
878
os.rename(from_abs, to_abs)
879
except OSError, e:
880
raise BzrError("failed to rename %r to %r: %s"
881
% (from_abs, to_abs, e[1]),
882
["rename rolled back"])
883
884
self._write_inventory(inv)
885
finally:
886
self.unlock()
887
888
889
def move(self, from_paths, to_name):
890
"""Rename files.
891
892
to_name must exist as a versioned directory.
893
894
If to_name exists and is a directory, the files are moved into
895
it, keeping their old names. If it is a directory,
896
897
Note that to_name is only the last component of the new name;
898
this doesn't change the directory.
899
"""
900
self.lock_write()
901
try:
902
## TODO: Option to move IDs only
903
assert not isinstance(from_paths, basestring)
904
tree = self.working_tree()
905
inv = tree.inventory
906
to_abs = self.abspath(to_name)
907
if not isdir(to_abs):
908
raise BzrError("destination %r is not a directory" % to_abs)
909
if not tree.has_filename(to_name):
910
raise BzrError("destination %r not in working directory" % to_abs)
911
to_dir_id = inv.path2id(to_name)
912
if to_dir_id == None and to_name != '':
913
raise BzrError("destination %r is not a versioned directory" % to_name)
914
to_dir_ie = inv[to_dir_id]
915
if to_dir_ie.kind not in ('directory', 'root_directory'):
916
raise BzrError("destination %r is not a directory" % to_abs)
917
918
to_idpath = inv.get_idpath(to_dir_id)
919
920
for f in from_paths:
921
if not tree.has_filename(f):
922
raise BzrError("%r does not exist in working tree" % f)
923
f_id = inv.path2id(f)
924
if f_id == None:
925
raise BzrError("%r is not versioned" % f)
926
name_tail = splitpath(f)[-1]
927
dest_path = appendpath(to_name, name_tail)
928
if tree.has_filename(dest_path):
929
raise BzrError("destination %r already exists" % dest_path)
930
if f_id in to_idpath:
931
raise BzrError("can't move %r to a subdirectory of itself" % f)
932
933
# OK, so there's a race here, it's possible that someone will
934
# create a file in this interval and then the rename might be
935
# left half-done. But we should have caught most problems.
936
937
for f in from_paths:
938
name_tail = splitpath(f)[-1]
939
dest_path = appendpath(to_name, name_tail)
940
print "%s => %s" % (f, dest_path)
941
inv.rename(inv.path2id(f), to_dir_id, name_tail)
942
try:
943
os.rename(self.abspath(f), self.abspath(dest_path))
944
except OSError, e:
945
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
946
["rename rolled back"])
947
948
self._write_inventory(inv)
949
finally:
950
self.unlock()
951
610
def write_log(self, utc=False):
611
"""Write out human-readable log of commits to this branch
612
613
:param utc: If true, show dates in universal time, not local time."""
614
revno = 1
615
precursor = None
616
for p in self.revision_history():
617
print '-' * 40
618
print 'revno:', revno
619
## TODO: Show hash if --id is given.
620
##print 'revision-hash:', p
621
rev = self.get_revision(p)
622
print 'committer:', rev.committer
623
print 'timestamp: %s' % (format_date(rev.timestamp, utc))
624
625
## opportunistic consistency check, same as check_patch_chaining
626
if rev.precursor != precursor:
627
bailout("mismatched precursor!")
628
629
print 'message:'
630
if not rev.message:
631
print ' (no message)'
632
else:
633
for l in rev.message.split('\n'):
634
print ' ' + l
635
636
revno += 1
637
precursor = p
638
639
640
641
def show_status(branch, show_all=False):
642
"""Display single-line status for non-ignored working files.
643
644
The list is show sorted in order by file name.
645
646
>>> b = ScratchBranch(files=['foo', 'foo~'])
647
>>> b.show_status()
648
? foo
649
>>> b.add('foo')
650
>>> b.show_status()
651
A foo
652
>>> b.commit("add foo")
653
>>> b.show_status()
654
655
:todo: Get state for single files.
656
657
:todo: Perhaps show a slash at the end of directory names.
658
659
"""
660
661
# We have to build everything into a list first so that it can
662
# sorted by name, incorporating all the different sources.
663
664
# FIXME: Rather than getting things in random order and then sorting,
665
# just step through in order.
666
667
# Interesting case: the old ID for a file has been removed,
668
# but a new file has been created under that name.
669
670
old = branch.basis_tree()
671
old_inv = old.inventory
672
new = branch.working_tree()
673
new_inv = new.inventory
674
675
for fs, fid, oldname, newname, kind in diff_trees(old, new):
676
if fs == 'R':
677
show_status(fs, kind,
678
oldname + ' => ' + newname)
679
elif fs == 'A' or fs == 'M':
680
show_status(fs, kind, newname)
681
elif fs == 'D':
682
show_status(fs, kind, oldname)
683
elif fs == '.':
684
if show_all:
685
show_status(fs, kind, newname)
686
elif fs == 'I':
687
if show_all:
688
show_status(fs, kind, newname)
689
elif fs == '?':
690
show_status(fs, kind, newname)
691
else:
692
bailout("wierd file state %r" % ((fs, fid),))
693
952
694
953
695
954
696
class ScratchBranch(Branch):
958
700
>>> isdir(b.base)
959
701
True
960
702
>>> bd = b.base
961
>>> b.destroy()
703
>>> del b
962
704
>>> isdir(bd)
963
705
False
964
706
"""
965
def __init__(self, files=[], dirs=[], base=None):
707
def __init__(self, files = []):
966
708
"""Make a test branch.
967
709
968
710
This creates a temporary directory and runs init-tree in it.
969
711
970
712
If any files are listed, they are created in the working copy.
971
713
"""
972
init = False
973
if base is None:
974
base = tempfile.mkdtemp()
975
init = True
976
Branch.__init__(self, base, init=init)
977
for d in dirs:
978
os.mkdir(self.abspath(d))
979
714
Branch.__init__(self, tempfile.mkdtemp(), init=True)
980
715
for f in files:
981
716
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
982
717
983
718
984
def clone(self):
985
"""
986
>>> orig = ScratchBranch(files=["file1", "file2"])
987
>>> clone = orig.clone()
988
>>> os.path.samefile(orig.base, clone.base)
989
False
990
>>> os.path.isfile(os.path.join(clone.base, "file1"))
991
True
992
"""
993
base = tempfile.mkdtemp()
994
os.rmdir(base)
995
shutil.copytree(self.base, base, symlinks=True)
996
return ScratchBranch(base=base)
997
998
719
def __del__(self):
999
self.destroy()
1000
1001
def destroy(self):
1002
720
"""Destroy the test branch, removing the scratch directory."""
1003
try:
1004
if self.base:
1005
mutter("delete ScratchBranch %s" % self.base)
1006
shutil.rmtree(self.base)
1007
except OSError, e:
1008
# Work around for shutil.rmtree failing on Windows when
1009
# readonly files are encountered
1010
mutter("hit exception in destroying ScratchBranch: %s" % e)
1011
for root, dirs, files in os.walk(self.base, topdown=False):
1012
for name in files:
1013
os.chmod(os.path.join(root, name), 0700)
1014
shutil.rmtree(self.base)
1015
self.base = None
721
shutil.rmtree(self.base)
1016
722
1017
723
1018
724
1028
734
## mutter('check %r for control file' % ((head, tail), ))
1029
735
if tail == bzrlib.BZRDIR:
1030
736
return True
1031
if filename == head:
1032
break
1033
737
filename = head
1034
738
return False
1035
739
1036
740
1037
741
1038
def gen_file_id(name):
742
def _gen_revision_id(when):
743
"""Return new revision-id."""
744
s = '%s-%s-' % (user_email(), compact_date(when))
745
s += hexlify(rand_bytes(8))
746
return s
747
748
749
def _gen_file_id(name):
1039
750
"""Return new file id.
1040
751
1041
752
This should probably generate proper UUIDs, but for the moment we
1042
753
cope with just randomness because running uuidgen every time is
1043
754
slow."""
1044
import re
1045
1046
# get last component
1047
idx = name.rfind('/')
1048
if idx != -1:
1049
name = name[idx+1 : ]
1050
idx = name.rfind('\\')
1051
if idx != -1:
1052
name = name[idx+1 : ]
1053
1054
# make it not a hidden file
1055
name = name.lstrip('.')
1056
1057
# remove any wierd characters; we don't escape them but rather
1058
# just pull them out
1059
name = re.sub(r'[^\w.]', '', name)
1060
755
assert '/' not in name
756
while name[0] == '.':
757
name = name[1:]
1061
758
s = hexlify(rand_bytes(8))
1062
759
return '-'.join((name, compact_date(time.time()), s))
760
761
Loggerhead is a web-based interface for Breezy
Version: 2.0.1