« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 2
- compare with another revision
- download diff
- download tarball
- view history from revision 2
- Committer: mbp at sourcefrog
- Date: 2005-03-09 04:09:29 UTC
- Revision ID: mbp@sourcefrog.net-20050309040929-eee0eb3e6d1e7627
add python bytecode to default ignore pattern
- files added:
- bzrlib/tests.py
- files removed:
- .bzrignore
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/store
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- doc
- notes
- tools
- tools/doc_generate
- files renamed:
- bzrlib/commands.py => bzr.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/xml_serializer.py => bzrlib/xml.py
- files modified:
- README
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
#
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
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
5
6
# the Free Software Foundation; either version 2 of the License, or
6
7
# (at your option) any later version.
7
#
8
8
9
# This program is distributed in the hope that it will be useful,
9
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
12
# GNU General Public License for more details.
12
#
13
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
17
18
18
from copy import deepcopy
19
from cStringIO import StringIO
20
import errno
21
import os
22
import shutil
23
import sys
24
from unittest import TestSuite
25
from warnings import warn
19
from sets import Set
20
21
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
22
import traceback, socket, fnmatch, difflib, time
23
from binascii import hexlify
26
24
27
25
import bzrlib
28
import bzrlib.bzrdir as bzrdir
29
from bzrlib.config import TreeConfig
30
from bzrlib.decorators import needs_read_lock, needs_write_lock
31
from bzrlib.delta import compare_trees
32
import bzrlib.errors as errors
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
34
NoSuchRevision, HistoryMissing, NotBranchError,
35
DivergedBranches, LockError,
36
UninitializableFormat,
37
UnlistableStore,
38
UnlistableBranch, NoSuchFile, NotVersionedError,
39
NoWorkingTree)
40
import bzrlib.inventory as inventory
41
from bzrlib.inventory import Inventory
42
from bzrlib.lockable_files import LockableFiles, TransportLock
43
from bzrlib.lockdir import LockDir
44
from bzrlib.osutils import (isdir, quotefn,
45
rename, splitpath, sha_file,
46
file_kind, abspath, normpath, pathjoin,
47
safe_unicode,
48
rmtree,
49
)
50
from bzrlib.textui import show_status
51
from bzrlib.trace import mutter, note
52
from bzrlib.tree import EmptyTree, RevisionTree
53
from bzrlib.repository import Repository
54
from bzrlib.revision import (
55
get_intervening_revisions,
56
is_ancestor,
57
NULL_REVISION,
58
Revision,
59
)
60
from bzrlib.store import copy_all
61
from bzrlib.symbol_versioning import *
62
import bzrlib.transactions as transactions
63
from bzrlib.transport import Transport, get_transport
64
from bzrlib.tree import EmptyTree, RevisionTree
65
import bzrlib.ui
66
import bzrlib.xml5
67
68
69
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
70
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
71
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
72
73
74
# TODO: Maybe include checks for common corruption of newlines, etc?
75
76
# TODO: Some operations like log might retrieve the same revisions
77
# repeatedly to calculate deltas. We could perhaps have a weakref
78
# cache in memory to make this faster. In general anything can be
79
# cached in memory between lock and unlock operations. .. nb thats
80
# what the transaction identity map provides
26
from inventory import Inventory
27
from trace import mutter, note
28
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
29
from inventory import InventoryEntry, Inventory
30
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
31
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
32
joinpath, sha_string, file_kind
33
from store import ImmutableStore
34
from revision import Revision
35
from errors import bailout
36
from textui import show_status
37
from diff import diff_trees
38
39
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
40
## TODO: Maybe include checks for common corruption of newlines, etc?
41
42
43
81
44
82
45
83
46
######################################################################
84
47
# branch objects
85
48
86
class Branch(object):
49
class Branch:
87
50
"""Branch holding a history of revisions.
88
51
89
base
90
Base directory/url of the branch.
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.
91
64
"""
92
# this is really an instance variable - FIXME move it there
93
# - RBC 20060112
94
base = None
95
96
def __init__(self, *ignored, **ignored_too):
97
raise NotImplementedError('The Branch class is abstract')
98
99
def break_lock(self):
100
"""Break a lock if one is present from another instance.
101
102
Uses the ui factory to ask for confirmation if the lock may be from
103
an active process.
104
105
This will probe the repository for its lock as well.
106
"""
107
self.control_files.break_lock()
108
self.repository.break_lock()
109
master = self.get_master_branch()
110
if master is not None:
111
master.break_lock()
112
113
@staticmethod
114
@deprecated_method(zero_eight)
115
def open_downlevel(base):
116
"""Open a branch which may be of an old format."""
117
return Branch.open(base, _unsupported=True)
118
119
@staticmethod
120
def open(base, _unsupported=False):
121
"""Open the repository rooted at base.
122
123
For instance, if the repository is at URL/.bzr/repository,
124
Repository.open(URL) -> a Repository instance.
125
"""
126
control = bzrdir.BzrDir.open(base, _unsupported)
127
return control.open_branch(_unsupported)
128
129
@staticmethod
130
def open_containing(url):
131
"""Open an existing branch which contains url.
132
133
This probes for a branch at url, and searches upwards from there.
134
135
Basically we keep looking up until we find the control directory or
136
run into the root. If there isn't one, raises NotBranchError.
137
If there is one and it is either an unrecognised format or an unsupported
138
format, UnknownFormatError or UnsupportedFormatError are raised.
139
If there is one, it is returned, along with the unused portion of url.
140
"""
141
control, relpath = bzrdir.BzrDir.open_containing(url)
142
return control.open_branch(), relpath
143
144
@staticmethod
145
@deprecated_function(zero_eight)
146
def initialize(base):
147
"""Create a new working tree and branch, rooted at 'base' (url)
148
149
NOTE: This will soon be deprecated in favour of creation
150
through a BzrDir.
151
"""
152
return bzrdir.BzrDir.create_standalone_workingtree(base).branch
153
154
def setup_caching(self, cache_root):
155
"""Subclasses that care about caching should override this, and set
156
up cached stores located under cache_root.
157
"""
158
# seems to be unused, 2006-01-13 mbp
159
warn('%s is deprecated' % self.setup_caching)
160
self.cache_root = cache_root
161
162
def _get_nick(self):
163
cfg = self.tree_config()
164
return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
165
166
def _set_nick(self, nick):
167
cfg = self.tree_config()
168
cfg.set_option(nick, "nickname")
169
assert cfg.get_option("nickname") == nick
170
171
nick = property(_get_nick, _set_nick)
172
173
def is_locked(self):
174
raise NotImplementedError('is_locked is abstract')
175
176
def lock_write(self):
177
raise NotImplementedError('lock_write is abstract')
178
179
def lock_read(self):
180
raise NotImplementedError('lock_read is abstract')
181
182
def unlock(self):
183
raise NotImplementedError('unlock is abstract')
184
185
def peek_lock_mode(self):
186
"""Return lock mode for the Branch: 'r', 'w' or None"""
187
raise NotImplementedError(self.peek_lock_mode)
188
189
def get_physical_lock_status(self):
190
raise NotImplementedError('get_physical_lock_status is abstract')
191
192
def abspath(self, name):
193
"""Return absolute filename for something in the branch
194
195
XXX: Robert Collins 20051017 what is this used for? why is it a branch
196
method and not a tree method.
197
"""
198
raise NotImplementedError('abspath is abstract')
199
200
def bind(self, other):
201
"""Bind the local branch the other branch.
202
203
:param other: The branch to bind to
204
:type other: Branch
205
"""
206
raise errors.UpgradeRequired(self.base)
207
208
@needs_write_lock
209
def fetch(self, from_branch, last_revision=None, pb=None):
210
"""Copy revisions from from_branch into this branch.
211
212
:param from_branch: Where to copy from.
213
:param last_revision: What revision to stop at (None for at the end
214
of the branch.
215
:param pb: An optional progress bar to use.
216
217
Returns the copied revision count and the failed revisions in a tuple:
218
(copied, failures).
219
"""
220
if self.base == from_branch.base:
221
return (0, [])
222
if pb is None:
223
nested_pb = bzrlib.ui.ui_factory.nested_progress_bar()
224
pb = nested_pb
65
def __init__(self, base, init=False):
66
"""Create new branch object at a particular location.
67
68
:param base: Base directory for the branch.
69
70
:param init: If True, create new control files in a previously
71
unversioned directory. If False, the branch must already
72
be versioned.
73
74
In the test suite, creation of new trees is tested using the
75
`ScratchBranch` class.
76
"""
77
self.base = os.path.realpath(base)
78
if init:
79
self._make_control()
225
80
else:
226
nested_pb = None
227
228
from_branch.lock_read()
229
try:
230
if last_revision is None:
231
pb.update('get source history')
232
from_history = from_branch.revision_history()
233
if from_history:
234
last_revision = from_history[-1]
81
if not isdir(self.controlfilename('.')):
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()
86
87
self.text_store = ImmutableStore(self.controlfilename('text-store'))
88
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
89
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
90
91
92
def __str__(self):
93
return '%s(%r)' % (self.__class__.__name__, self.base)
94
95
96
__repr__ = __str__
97
98
99
def _rel(self, name):
100
"""Return filename relative to branch top"""
101
return os.path.join(self.base, name)
102
103
104
def controlfilename(self, file_or_path):
105
"""Return location relative to branch."""
106
if isinstance(file_or_path, types.StringTypes):
107
file_or_path = [file_or_path]
108
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
109
110
111
def controlfile(self, file_or_path, mode='r'):
112
"""Open a control file for this branch"""
113
return file(self.controlfilename(file_or_path), mode)
114
115
116
def _make_control(self):
117
os.mkdir(self.controlfilename([]))
118
self.controlfile('README', 'w').write(
119
"This is a Bazaar-NG control directory.\n"
120
"Do not change any files in this directory.")
121
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
122
for d in ('text-store', 'inventory-store', 'revision-store'):
123
os.mkdir(self.controlfilename(d))
124
for f in ('revision-history', 'merged-patches',
125
'pending-merged-patches', 'branch-name'):
126
self.controlfile(f, 'w').write('')
127
mutter('created control directory in ' + self.base)
128
Inventory().write_xml(self.controlfile('inventory','w'))
129
130
131
def _check_format(self):
132
"""Check this branch format is supported.
133
134
The current tool only supports the current unstable format.
135
136
In the future, we might need different in-memory Branch
137
classes to support downlevel branches. But not yet.
138
"""
139
# read in binary mode to detect newline wierdness.
140
fmt = self.controlfile('branch-format', 'rb').read()
141
if fmt != BZR_BRANCH_FORMAT:
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'])
145
146
147
def read_working_inventory(self):
148
"""Read the working inventory."""
149
before = time.time()
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
155
156
def _write_inventory(self, inv):
157
"""Update the working inventory.
158
159
That is to say, the inventory describing changes underway, that
160
will be committed to the next revision.
161
"""
162
inv.write_xml(self.controlfile('inventory', 'w'))
163
mutter('wrote inventory to %s' % quotefn(self.controlfilename('inventory')))
164
165
166
inventory = property(read_working_inventory, _write_inventory, None,
167
"""Inventory for the working copy.""")
168
169
170
def add(self, files, verbose=False):
171
"""Make files versioned.
172
173
This puts the files in the Added state, so that they will be
174
recorded by the next commit.
175
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', [])
209
"""
210
211
# TODO: Re-adding a file that is removed in the working copy
212
# should probably put it back with the previous ID.
213
if isinstance(files, types.StringTypes):
214
files = [files]
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
254
255
256
def remove(self, files, verbose=False):
257
"""Mark nominated files for removal from the inventory.
258
259
This does not remove their text. This does not run on
260
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
288
removing may be useful and the user can just use use rm, and
289
is the opposite of add. Removing it is consistent with most
290
other tools. Maybe an option.
291
"""
292
## TODO: Normalize names
293
## TODO: Remove nested loops; better scalability
294
295
if isinstance(files, types.StringTypes):
296
files = [files]
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
310
self._write_inventory(inv)
311
312
313
def unknowns(self):
314
"""Return all unknown files.
315
316
These are files in the working directory that are not versioned or
317
control files or ignored.
318
319
>>> b = ScratchBranch(files=['foo', 'foo~'])
320
>>> list(b.unknowns())
321
['foo']
322
>>> b.add('foo')
323
>>> list(b.unknowns())
324
[]
325
>>> b.remove('foo')
326
>>> list(b.unknowns())
327
['foo']
328
"""
329
return self.working_tree().unknowns()
330
331
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
235
424
else:
236
# no history in the source branch
237
last_revision = NULL_REVISION
238
return self.repository.fetch(from_branch.repository,
239
revision_id=last_revision,
240
pb=nested_pb)
241
finally:
242
if nested_pb is not None:
243
nested_pb.finished()
244
from_branch.unlock()
245
246
def get_bound_location(self):
247
"""Return the URL of the branch we are bound to.
248
249
Older format branches cannot bind, please be sure to use a metadir
250
branch.
251
"""
252
return None
253
254
def get_master_branch(self):
255
"""Return the branch we are bound to.
256
257
:return: Either a Branch, or None
258
"""
259
return None
260
261
def get_root_id(self):
262
"""Return the id of this branches root"""
263
raise NotImplementedError('get_root_id is abstract')
264
265
def print_file(self, file, revision_id):
266
"""Print `file` to stdout."""
267
raise NotImplementedError('print_file is abstract')
268
269
def append_revision(self, *revision_ids):
270
raise NotImplementedError('append_revision is abstract')
271
272
def set_revision_history(self, rev_history):
273
raise NotImplementedError('set_revision_history is abstract')
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!")
494
495
496
def get_revision(self, revision_id):
497
"""Return the Revision object for a named revision"""
498
r = Revision.read_xml(self.revision_store[revision_id])
499
assert r.revision_id == revision_id
500
return r
501
502
503
def get_inventory(self, inventory_id):
504
"""Get Inventory object by hash.
505
506
:todo: Perhaps for this and similar methods, take a revision
507
parameter which can be either an integer revno or a
508
string hash."""
509
i = Inventory.read_xml(self.inventory_store[inventory_id])
510
return i
511
512
513
def get_revision_inventory(self, revision_id):
514
"""Return inventory of a past revision."""
515
if revision_id == None:
516
return Inventory()
517
else:
518
return self.get_inventory(self.get_revision(revision_id).inventory_id)
519
274
520
275
521
def revision_history(self):
276
"""Return sequence of revision hashes on to this branch."""
277
raise NotImplementedError('revision_history is abstract')
522
"""Return sequence of revision hashes on to this branch.
523
524
>>> ScratchBranch().revision_history()
525
[]
526
"""
527
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
528
278
529
279
530
def revno(self):
280
531
"""Return current revision number for this branch.
281
532
282
533
That is equivalent to the number of revisions committed to
283
534
this branch.
535
536
>>> b = ScratchBranch()
537
>>> b.revno()
538
0
539
>>> b.commit('no foo')
540
>>> b.revno()
541
1
284
542
"""
285
543
return len(self.revision_history())
286
544
287
def unbind(self):
288
"""Older format branches cannot bind or unbind."""
289
raise errors.UpgradeRequired(self.base)
290
291
def last_revision(self):
292
"""Return last patch hash, or None if no history."""
545
546
def last_patch(self):
547
"""Return last patch hash, or None if no history.
548
549
>>> ScratchBranch().last_patch() == None
550
True
551
"""
293
552
ph = self.revision_history()
294
553
if ph:
295
554
return ph[-1]
296
else:
297
return None
298
299
def missing_revisions(self, other, stop_revision=None):
300
"""Return a list of new revisions that would perfectly fit.
301
302
If self and other have not diverged, return a list of the revisions
303
present in other, but missing from self.
304
305
>>> from bzrlib.workingtree import WorkingTree
306
>>> bzrlib.trace.silent = True
307
>>> d1 = bzrdir.ScratchDir()
308
>>> br1 = d1.open_branch()
309
>>> wt1 = d1.open_workingtree()
310
>>> d2 = bzrdir.ScratchDir()
311
>>> br2 = d2.open_branch()
312
>>> wt2 = d2.open_workingtree()
313
>>> br1.missing_revisions(br2)
314
[]
315
>>> wt2.commit("lala!", rev_id="REVISION-ID-1")
316
>>> br1.missing_revisions(br2)
317
[u'REVISION-ID-1']
318
>>> br2.missing_revisions(br1)
319
[]
320
>>> wt1.commit("lala!", rev_id="REVISION-ID-1")
321
>>> br1.missing_revisions(br2)
322
[]
323
>>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
324
>>> br1.missing_revisions(br2)
325
[u'REVISION-ID-2A']
326
>>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
327
>>> br1.missing_revisions(br2)
328
Traceback (most recent call last):
329
DivergedBranches: These branches have diverged. Try merge.
330
"""
331
self_history = self.revision_history()
332
self_len = len(self_history)
333
other_history = other.revision_history()
334
other_len = len(other_history)
335
common_index = min(self_len, other_len) -1
336
if common_index >= 0 and \
337
self_history[common_index] != other_history[common_index]:
338
raise DivergedBranches(self, other)
339
340
if stop_revision is None:
341
stop_revision = other_len
342
else:
343
assert isinstance(stop_revision, int)
344
if stop_revision > other_len:
345
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
346
return other_history[self_len:stop_revision]
347
348
def update_revisions(self, other, stop_revision=None):
349
"""Pull in new perfect-fit revisions.
350
351
:param other: Another Branch to pull from
352
:param stop_revision: Updated until the given revision
353
:return: None
354
"""
355
raise NotImplementedError('update_revisions is abstract')
356
357
def revision_id_to_revno(self, revision_id):
358
"""Given a revision id, return its revno"""
359
if revision_id is None:
360
return 0
361
history = self.revision_history()
362
try:
363
return history.index(revision_id) + 1
364
except ValueError:
365
raise bzrlib.errors.NoSuchRevision(self, revision_id)
366
367
def get_rev_id(self, revno, history=None):
368
"""Find the revision id of the specified revno."""
555
556
557
def lookup_revision(self, revno):
558
"""Return revision hash for revision number."""
369
559
if revno == 0:
370
560
return None
371
if history is None:
372
history = self.revision_history()
373
elif revno <= 0 or revno > len(history):
374
raise bzrlib.errors.NoSuchRevision(self, revno)
375
return history[revno - 1]
376
377
def pull(self, source, overwrite=False, stop_revision=None):
378
raise NotImplementedError('pull is abstract')
561
562
try:
563
# list is 0-based; revisions are 1-based
564
return self.revision_history()[revno-1]
565
except IndexError:
566
bailout("no such revision %s" % revno)
567
568
569
def revision_tree(self, revision_id):
570
"""Return Tree for a revision on this branch.
571
572
`revision_id` may be None for the null revision, in which case
573
an `EmptyTree` is returned."""
574
575
if revision_id == None:
576
return EmptyTree()
577
else:
578
inv = self.get_revision_inventory(revision_id)
579
return RevisionTree(self.text_store, inv)
580
581
582
def working_tree(self):
583
"""Return a `Tree` for the working copy."""
584
return WorkingTree(self.base, self.read_working_inventory())
585
379
586
380
587
def basis_tree(self):
381
588
"""Return `Tree` object for last revision.
382
589
383
590
If there are no revisions yet, return an `EmptyTree`.
384
"""
385
return self.repository.revision_tree(self.last_revision())
386
387
def rename_one(self, from_rel, to_rel):
388
"""Rename one file.
389
390
This can change the directory or the filename or both.
391
"""
392
raise NotImplementedError('rename_one is abstract')
393
394
def move(self, from_paths, to_name):
395
"""Rename files.
396
397
to_name must exist as a versioned directory.
398
399
If to_name exists and is a directory, the files are moved into
400
it, keeping their old names. If it is a directory,
401
402
Note that to_name is only the last component of the new name;
403
this doesn't change the directory.
404
405
This returns a list of (from_path, to_path) pairs for each
406
entry that is moved.
407
"""
408
raise NotImplementedError('move is abstract')
409
410
def get_parent(self):
411
"""Return the parent location of the branch.
412
413
This is the default location for push/pull/missing. The usual
414
pattern is that the user can override it by specifying a
415
location.
416
"""
417
raise NotImplementedError('get_parent is abstract')
418
419
def get_push_location(self):
420
"""Return the None or the location to push this branch to."""
421
raise NotImplementedError('get_push_location is abstract')
422
423
def set_push_location(self, location):
424
"""Set a new push location for this branch."""
425
raise NotImplementedError('set_push_location is abstract')
426
427
def set_parent(self, url):
428
raise NotImplementedError('set_parent is abstract')
429
430
@needs_write_lock
431
def update(self):
432
"""Synchronise this branch with the master branch if any.
433
434
:return: None or the last_revision pivoted out during the update.
435
"""
436
return None
437
438
def check_revno(self, revno):
439
"""\
440
Check whether a revno corresponds to any revision.
441
Zero (the NULL revision) is considered valid.
442
"""
443
if revno != 0:
444
self.check_real_revno(revno)
445
446
def check_real_revno(self, revno):
447
"""\
448
Check whether a revno corresponds to a real revision.
449
Zero (the NULL revision) is considered invalid
450
"""
451
if revno < 1 or revno > self.revno():
452
raise InvalidRevisionNumber(revno)
453
454
@needs_read_lock
455
def clone(self, *args, **kwargs):
456
"""Clone this branch into to_bzrdir preserving all semantic values.
457
458
revision_id: if not None, the revision history in the new branch will
459
be truncated to end with revision_id.
460
"""
461
# for API compatability, until 0.8 releases we provide the old api:
462
# def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
463
# after 0.8 releases, the *args and **kwargs should be changed:
464
# def clone(self, to_bzrdir, revision_id=None):
465
if (kwargs.get('to_location', None) or
466
kwargs.get('revision', None) or
467
kwargs.get('basis_branch', None) or
468
(len(args) and isinstance(args[0], basestring))):
469
# backwards compatability api:
470
warn("Branch.clone() has been deprecated for BzrDir.clone() from"
471
" bzrlib 0.8.", DeprecationWarning, stacklevel=3)
472
# get basis_branch
473
if len(args) > 2:
474
basis_branch = args[2]
475
else:
476
basis_branch = kwargs.get('basis_branch', None)
477
if basis_branch:
478
basis = basis_branch.bzrdir
479
else:
480
basis = None
481
# get revision
482
if len(args) > 1:
483
revision_id = args[1]
484
else:
485
revision_id = kwargs.get('revision', None)
486
# get location
487
if len(args):
488
url = args[0]
489
else:
490
# no default to raise if not provided.
491
url = kwargs.get('to_location')
492
return self.bzrdir.clone(url,
493
revision_id=revision_id,
494
basis=basis).open_branch()
495
# new cleaner api.
496
# generate args by hand
497
if len(args) > 1:
498
revision_id = args[1]
499
else:
500
revision_id = kwargs.get('revision_id', None)
501
if len(args):
502
to_bzrdir = args[0]
503
else:
504
# no default to raise if not provided.
505
to_bzrdir = kwargs.get('to_bzrdir')
506
result = self._format.initialize(to_bzrdir)
507
self.copy_content_into(result, revision_id=revision_id)
508
return result
509
510
@needs_read_lock
511
def sprout(self, to_bzrdir, revision_id=None):
512
"""Create a new line of development from the branch, into to_bzrdir.
513
514
revision_id: if not None, the revision history in the new branch will
515
be truncated to end with revision_id.
516
"""
517
result = self._format.initialize(to_bzrdir)
518
self.copy_content_into(result, revision_id=revision_id)
519
result.set_parent(self.bzrdir.root_transport.base)
520
return result
521
522
@needs_read_lock
523
def copy_content_into(self, destination, revision_id=None):
524
"""Copy the content of self into destination.
525
526
revision_id: if not None, the revision history in the new branch will
527
be truncated to end with revision_id.
528
"""
529
new_history = self.revision_history()
530
if revision_id is not None:
531
try:
532
new_history = new_history[:new_history.index(revision_id) + 1]
533
except ValueError:
534
rev = self.repository.get_revision(revision_id)
535
new_history = rev.get_history(self.repository)[1:]
536
destination.set_revision_history(new_history)
537
parent = self.get_parent()
538
if parent:
539
destination.set_parent(parent)
540
541
542
class BranchFormat(object):
543
"""An encapsulation of the initialization and open routines for a format.
544
545
Formats provide three things:
546
* An initialization routine,
547
* a format string,
548
* an open routine.
549
550
Formats are placed in an dict by their format string for reference
551
during branch opening. Its not required that these be instances, they
552
can be classes themselves with class methods - it simply depends on
553
whether state is needed for a given format or not.
554
555
Once a format is deprecated, just deprecate the initialize and open
556
methods on the format class. Do not deprecate the object, as the
557
object will be created every time regardless.
558
"""
559
560
_default_format = None
561
"""The default format used for new branches."""
562
563
_formats = {}
564
"""The known formats."""
565
566
@classmethod
567
def find_format(klass, a_bzrdir):
568
"""Return the format for the branch object in a_bzrdir."""
569
try:
570
transport = a_bzrdir.get_branch_transport(None)
571
format_string = transport.get("format").read()
572
return klass._formats[format_string]
573
except NoSuchFile:
574
raise NotBranchError(path=transport.base)
575
except KeyError:
576
raise errors.UnknownFormatError(format_string)
577
578
@classmethod
579
def get_default_format(klass):
580
"""Return the current default format."""
581
return klass._default_format
582
583
def get_format_string(self):
584
"""Return the ASCII format string that identifies this format."""
585
raise NotImplementedError(self.get_format_string)
586
587
def get_format_description(self):
588
"""Return the short format description for this format."""
589
raise NotImplementedError(self.get_format_string)
590
591
def initialize(self, a_bzrdir):
592
"""Create a branch of this format in a_bzrdir."""
593
raise NotImplementedError(self.initialized)
594
595
def is_supported(self):
596
"""Is this format supported?
597
598
Supported formats can be initialized and opened.
599
Unsupported formats may not support initialization or committing or
600
some other features depending on the reason for not being supported.
601
"""
602
return True
603
604
def open(self, a_bzrdir, _found=False):
605
"""Return the branch object for a_bzrdir
606
607
_found is a private parameter, do not use it. It is used to indicate
608
if format probing has already be done.
609
"""
610
raise NotImplementedError(self.open)
611
612
@classmethod
613
def register_format(klass, format):
614
klass._formats[format.get_format_string()] = format
615
616
@classmethod
617
def set_default_format(klass, format):
618
klass._default_format = format
619
620
@classmethod
621
def unregister_format(klass, format):
622
assert klass._formats[format.get_format_string()] is format
623
del klass._formats[format.get_format_string()]
624
625
def __str__(self):
626
return self.get_format_string().rstrip()
627
628
629
class BzrBranchFormat4(BranchFormat):
630
"""Bzr branch format 4.
631
632
This format has:
633
- a revision-history file.
634
- a branch-lock lock file [ to be shared with the bzrdir ]
635
"""
636
637
def get_format_description(self):
638
"""See BranchFormat.get_format_description()."""
639
return "Branch format 4"
640
641
def initialize(self, a_bzrdir):
642
"""Create a branch of this format in a_bzrdir."""
643
mutter('creating branch in %s', a_bzrdir.transport.base)
644
branch_transport = a_bzrdir.get_branch_transport(self)
645
utf8_files = [('revision-history', ''),
646
('branch-name', ''),
647
]
648
control_files = LockableFiles(branch_transport, 'branch-lock',
649
TransportLock)
650
control_files.create_lock()
651
control_files.lock_write()
652
try:
653
for file, content in utf8_files:
654
control_files.put_utf8(file, content)
655
finally:
656
control_files.unlock()
657
return self.open(a_bzrdir, _found=True)
658
659
def __init__(self):
660
super(BzrBranchFormat4, self).__init__()
661
self._matchingbzrdir = bzrdir.BzrDirFormat6()
662
663
def open(self, a_bzrdir, _found=False):
664
"""Return the branch object for a_bzrdir
665
666
_found is a private parameter, do not use it. It is used to indicate
667
if format probing has already be done.
668
"""
669
if not _found:
670
# we are being called directly and must probe.
671
raise NotImplementedError
672
return BzrBranch(_format=self,
673
_control_files=a_bzrdir._control_files,
674
a_bzrdir=a_bzrdir,
675
_repository=a_bzrdir.open_repository())
676
677
def __str__(self):
678
return "Bazaar-NG branch format 4"
679
680
681
class BzrBranchFormat5(BranchFormat):
682
"""Bzr branch format 5.
683
684
This format has:
685
- a revision-history file.
686
- a format string
687
- a lock dir guarding the branch itself
688
- all of this stored in a branch/ subdirectory
689
- works with shared repositories.
690
691
This format is new in bzr 0.8.
692
"""
693
694
def get_format_string(self):
695
"""See BranchFormat.get_format_string()."""
696
return "Bazaar-NG branch format 5\n"
697
698
def get_format_description(self):
699
"""See BranchFormat.get_format_description()."""
700
return "Branch format 5"
701
702
def initialize(self, a_bzrdir):
703
"""Create a branch of this format in a_bzrdir."""
704
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
705
branch_transport = a_bzrdir.get_branch_transport(self)
706
utf8_files = [('revision-history', ''),
707
('branch-name', ''),
708
]
709
control_files = LockableFiles(branch_transport, 'lock', LockDir)
710
control_files.create_lock()
711
control_files.lock_write()
712
control_files.put_utf8('format', self.get_format_string())
713
try:
714
for file, content in utf8_files:
715
control_files.put_utf8(file, content)
716
finally:
717
control_files.unlock()
718
return self.open(a_bzrdir, _found=True, )
719
720
def __init__(self):
721
super(BzrBranchFormat5, self).__init__()
722
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
723
724
def open(self, a_bzrdir, _found=False):
725
"""Return the branch object for a_bzrdir
726
727
_found is a private parameter, do not use it. It is used to indicate
728
if format probing has already be done.
729
"""
730
if not _found:
731
format = BranchFormat.find_format(a_bzrdir)
732
assert format.__class__ == self.__class__
733
transport = a_bzrdir.get_branch_transport(None)
734
control_files = LockableFiles(transport, 'lock', LockDir)
735
return BzrBranch5(_format=self,
736
_control_files=control_files,
737
a_bzrdir=a_bzrdir,
738
_repository=a_bzrdir.find_repository())
739
740
def __str__(self):
741
return "Bazaar-NG Metadir branch format 5"
742
743
744
class BranchReferenceFormat(BranchFormat):
745
"""Bzr branch reference format.
746
747
Branch references are used in implementing checkouts, they
748
act as an alias to the real branch which is at some other url.
749
750
This format has:
751
- A location file
752
- a format string
753
"""
754
755
def get_format_string(self):
756
"""See BranchFormat.get_format_string()."""
757
return "Bazaar-NG Branch Reference Format 1\n"
758
759
def get_format_description(self):
760
"""See BranchFormat.get_format_description()."""
761
return "Checkout reference format 1"
762
763
def initialize(self, a_bzrdir, target_branch=None):
764
"""Create a branch of this format in a_bzrdir."""
765
if target_branch is None:
766
# this format does not implement branch itself, thus the implicit
767
# creation contract must see it as uninitializable
768
raise errors.UninitializableFormat(self)
769
mutter('creating branch reference in %s', a_bzrdir.transport.base)
770
branch_transport = a_bzrdir.get_branch_transport(self)
771
# FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
772
branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
773
branch_transport.put('format', StringIO(self.get_format_string()))
774
return self.open(a_bzrdir, _found=True)
775
776
def __init__(self):
777
super(BranchReferenceFormat, self).__init__()
778
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
779
780
def _make_reference_clone_function(format, a_branch):
781
"""Create a clone() routine for a branch dynamically."""
782
def clone(to_bzrdir, revision_id=None):
783
"""See Branch.clone()."""
784
return format.initialize(to_bzrdir, a_branch)
785
# cannot obey revision_id limits when cloning a reference ...
786
# FIXME RBC 20060210 either nuke revision_id for clone, or
787
# emit some sort of warning/error to the caller ?!
788
return clone
789
790
def open(self, a_bzrdir, _found=False):
791
"""Return the branch that the branch reference in a_bzrdir points at.
792
793
_found is a private parameter, do not use it. It is used to indicate
794
if format probing has already be done.
795
"""
796
if not _found:
797
format = BranchFormat.find_format(a_bzrdir)
798
assert format.__class__ == self.__class__
799
transport = a_bzrdir.get_branch_transport(None)
800
real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
801
result = real_bzrdir.open_branch()
802
# this changes the behaviour of result.clone to create a new reference
803
# rather than a copy of the content of the branch.
804
# I did not use a proxy object because that needs much more extensive
805
# testing, and we are only changing one behaviour at the moment.
806
# If we decide to alter more behaviours - i.e. the implicit nickname
807
# then this should be refactored to introduce a tested proxy branch
808
# and a subclass of that for use in overriding clone() and ....
809
# - RBC 20060210
810
result.clone = self._make_reference_clone_function(result)
811
return result
812
813
814
# formats which have no format string are not discoverable
815
# and not independently creatable, so are not registered.
816
__default_format = BzrBranchFormat5()
817
BranchFormat.register_format(__default_format)
818
BranchFormat.register_format(BranchReferenceFormat())
819
BranchFormat.set_default_format(__default_format)
820
_legacy_formats = [BzrBranchFormat4(),
821
]
822
823
class BzrBranch(Branch):
824
"""A branch stored in the actual filesystem.
825
826
Note that it's "local" in the context of the filesystem; it doesn't
827
really matter if it's on an nfs/smb/afs/coda/... share, as long as
828
it's writable, and can be accessed via the normal filesystem API.
829
"""
830
831
def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
832
relax_version_check=DEPRECATED_PARAMETER, _format=None,
833
_control_files=None, a_bzrdir=None, _repository=None):
834
"""Create new branch object at a particular location.
835
836
transport -- A Transport object, defining how to access files.
837
838
init -- If True, create new control files in a previously
839
unversioned directory. If False, the branch must already
840
be versioned.
841
842
relax_version_check -- If true, the usual check for the branch
843
version is not applied. This is intended only for
844
upgrade/recovery type use; it's not guaranteed that
845
all operations will work on old format branches.
846
"""
847
if a_bzrdir is None:
848
self.bzrdir = bzrdir.BzrDir.open(transport.base)
849
else:
850
self.bzrdir = a_bzrdir
851
self._transport = self.bzrdir.transport.clone('..')
852
self._base = self._transport.base
853
self._format = _format
854
if _control_files is None:
855
raise BzrBadParameterMissing('_control_files')
856
self.control_files = _control_files
857
if deprecated_passed(init):
858
warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
859
"deprecated as of bzr 0.8. Please use Branch.create().",
860
DeprecationWarning,
861
stacklevel=2)
862
if init:
863
# this is slower than before deprecation, oh well never mind.
864
# -> its deprecated.
865
self._initialize(transport.base)
866
self._check_format(_format)
867
if deprecated_passed(relax_version_check):
868
warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
869
"relax_version_check parameter is deprecated as of bzr 0.8. "
870
"Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
871
"open() method.",
872
DeprecationWarning,
873
stacklevel=2)
874
if (not relax_version_check
875
and not self._format.is_supported()):
876
raise errors.UnsupportedFormatError(
877
'sorry, branch format %r not supported' % fmt,
878
['use a different bzr version',
879
'or remove the .bzr directory'
880
' and "bzr init" again'])
881
if deprecated_passed(transport):
882
warn("BzrBranch.__init__(transport=XXX...): The transport "
883
"parameter is deprecated as of bzr 0.8. "
884
"Please use Branch.open, or bzrdir.open_branch().",
885
DeprecationWarning,
886
stacklevel=2)
887
self.repository = _repository
888
889
def __str__(self):
890
return '%s(%r)' % (self.__class__.__name__, self.base)
891
892
__repr__ = __str__
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
601
"""
602
r = self.last_patch()
603
if r == None:
604
return EmptyTree()
605
else:
606
return RevisionTree(self.text_store, self.get_revision_inventory(r))
607
608
609
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
694
695
696
class ScratchBranch(Branch):
697
"""Special test class: a branch that cleans up after itself.
698
699
>>> b = ScratchBranch()
700
>>> isdir(b.base)
701
True
702
>>> bd = b.base
703
>>> del b
704
>>> isdir(bd)
705
False
706
"""
707
def __init__(self, files = []):
708
"""Make a test branch.
709
710
This creates a temporary directory and runs init-tree in it.
711
712
If any files are listed, they are created in the working copy.
713
"""
714
Branch.__init__(self, tempfile.mkdtemp(), init=True)
715
for f in files:
716
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
717
893
718
894
719
def __del__(self):
895
# TODO: It might be best to do this somewhere else,
896
# but it is nice for a Branch object to automatically
897
# cache it's information.
898
# Alternatively, we could have the Transport objects cache requests
899
# See the earlier discussion about how major objects (like Branch)
900
# should never expect their __del__ function to run.
901
# XXX: cache_root seems to be unused, 2006-01-13 mbp
902
if hasattr(self, 'cache_root') and self.cache_root is not None:
903
try:
904
rmtree(self.cache_root)
905
except:
906
pass
907
self.cache_root = None
908
909
def _get_base(self):
910
return self._base
911
912
base = property(_get_base, doc="The URL for the root of this branch.")
913
914
def _finish_transaction(self):
915
"""Exit the current transaction."""
916
return self.control_files._finish_transaction()
917
918
def get_transaction(self):
919
"""Return the current active transaction.
920
921
If no transaction is active, this returns a passthrough object
922
for which all data is immediately flushed and no caching happens.
923
"""
924
# this is an explicit function so that we can do tricky stuff
925
# when the storage in rev_storage is elsewhere.
926
# we probably need to hook the two 'lock a location' and
927
# 'have a transaction' together more delicately, so that
928
# we can have two locks (branch and storage) and one transaction
929
# ... and finishing the transaction unlocks both, but unlocking
930
# does not. - RBC 20051121
931
return self.control_files.get_transaction()
932
933
def _set_transaction(self, transaction):
934
"""Set a new active transaction."""
935
return self.control_files._set_transaction(transaction)
936
937
def abspath(self, name):
938
"""See Branch.abspath."""
939
return self.control_files._transport.abspath(name)
940
941
def _check_format(self, format):
942
"""Identify the branch format if needed.
943
944
The format is stored as a reference to the format object in
945
self._format for code that needs to check it later.
946
947
The format parameter is either None or the branch format class
948
used to open this branch.
949
950
FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
951
"""
952
if format is None:
953
format = BzrBranchFormat.find_format(self.bzrdir)
954
self._format = format
955
mutter("got branch format %s", self._format)
956
957
@needs_read_lock
958
def get_root_id(self):
959
"""See Branch.get_root_id."""
960
tree = self.repository.revision_tree(self.last_revision())
961
return tree.inventory.root.file_id
962
963
def is_locked(self):
964
return self.control_files.is_locked()
965
966
def lock_write(self):
967
# TODO: test for failed two phase locks. This is known broken.
968
self.control_files.lock_write()
969
self.repository.lock_write()
970
971
def lock_read(self):
972
# TODO: test for failed two phase locks. This is known broken.
973
self.control_files.lock_read()
974
self.repository.lock_read()
975
976
def unlock(self):
977
# TODO: test for failed two phase locks. This is known broken.
978
try:
979
self.repository.unlock()
980
finally:
981
self.control_files.unlock()
982
983
def peek_lock_mode(self):
984
if self.control_files._lock_count == 0:
985
return None
986
else:
987
return self.control_files._lock_mode
988
989
def get_physical_lock_status(self):
990
return self.control_files.get_physical_lock_status()
991
992
@needs_read_lock
993
def print_file(self, file, revision_id):
994
"""See Branch.print_file."""
995
return self.repository.print_file(file, revision_id)
996
997
@needs_write_lock
998
def append_revision(self, *revision_ids):
999
"""See Branch.append_revision."""
1000
for revision_id in revision_ids:
1001
mutter("add {%s} to revision-history" % revision_id)
1002
rev_history = self.revision_history()
1003
rev_history.extend(revision_ids)
1004
self.set_revision_history(rev_history)
1005
1006
@needs_write_lock
1007
def set_revision_history(self, rev_history):
1008
"""See Branch.set_revision_history."""
1009
self.control_files.put_utf8(
1010
'revision-history', '\n'.join(rev_history))
1011
transaction = self.get_transaction()
1012
history = transaction.map.find_revision_history()
1013
if history is not None:
1014
# update the revision history in the identity map.
1015
history[:] = list(rev_history)
1016
# this call is disabled because revision_history is
1017
# not really an object yet, and the transaction is for objects.
1018
# transaction.register_dirty(history)
1019
else:
1020
transaction.map.add_revision_history(rev_history)
1021
# this call is disabled because revision_history is
1022
# not really an object yet, and the transaction is for objects.
1023
# transaction.register_clean(history)
1024
1025
def get_revision_delta(self, revno):
1026
"""Return the delta for one revision.
1027
1028
The delta is relative to its mainline predecessor, or the
1029
empty tree for revision 1.
1030
"""
1031
assert isinstance(revno, int)
1032
rh = self.revision_history()
1033
if not (1 <= revno <= len(rh)):
1034
raise InvalidRevisionNumber(revno)
1035
1036
# revno is 1-based; list is 0-based
1037
1038
new_tree = self.repository.revision_tree(rh[revno-1])
1039
if revno == 1:
1040
old_tree = EmptyTree()
1041
else:
1042
old_tree = self.repository.revision_tree(rh[revno-2])
1043
return compare_trees(old_tree, new_tree)
1044
1045
@needs_read_lock
1046
def revision_history(self):
1047
"""See Branch.revision_history."""
1048
transaction = self.get_transaction()
1049
history = transaction.map.find_revision_history()
1050
if history is not None:
1051
mutter("cache hit for revision-history in %s", self)
1052
return list(history)
1053
history = [l.rstrip('\r\n') for l in
1054
self.control_files.get_utf8('revision-history').readlines()]
1055
transaction.map.add_revision_history(history)
1056
# this call is disabled because revision_history is
1057
# not really an object yet, and the transaction is for objects.
1058
# transaction.register_clean(history, precious=True)
1059
return list(history)
1060
1061
@needs_write_lock
1062
def update_revisions(self, other, stop_revision=None):
1063
"""See Branch.update_revisions."""
1064
other.lock_read()
1065
try:
1066
if stop_revision is None:
1067
stop_revision = other.last_revision()
1068
if stop_revision is None:
1069
# if there are no commits, we're done.
1070
return
1071
# whats the current last revision, before we fetch [and change it
1072
# possibly]
1073
last_rev = self.last_revision()
1074
# we fetch here regardless of whether we need to so that we pickup
1075
# filled in ghosts.
1076
self.fetch(other, stop_revision)
1077
my_ancestry = self.repository.get_ancestry(last_rev)
1078
if stop_revision in my_ancestry:
1079
# last_revision is a descendant of stop_revision
1080
return
1081
# stop_revision must be a descendant of last_revision
1082
stop_graph = self.repository.get_revision_graph(stop_revision)
1083
if last_rev is not None and last_rev not in stop_graph:
1084
# our previous tip is not merged into stop_revision
1085
raise errors.DivergedBranches(self, other)
1086
# make a new revision history from the graph
1087
current_rev_id = stop_revision
1088
new_history = []
1089
while current_rev_id not in (None, NULL_REVISION):
1090
new_history.append(current_rev_id)
1091
current_rev_id_parents = stop_graph[current_rev_id]
1092
try:
1093
current_rev_id = current_rev_id_parents[0]
1094
except IndexError:
1095
current_rev_id = None
1096
new_history.reverse()
1097
self.set_revision_history(new_history)
1098
finally:
1099
other.unlock()
1100
1101
@deprecated_method(zero_eight)
1102
def pullable_revisions(self, other, stop_revision):
1103
"""Please use bzrlib.missing instead."""
1104
other_revno = other.revision_id_to_revno(stop_revision)
1105
try:
1106
return self.missing_revisions(other, other_revno)
1107
except DivergedBranches, e:
1108
try:
1109
pullable_revs = get_intervening_revisions(self.last_revision(),
1110
stop_revision,
1111
self.repository)
1112
assert self.last_revision() not in pullable_revs
1113
return pullable_revs
1114
except bzrlib.errors.NotAncestor:
1115
if is_ancestor(self.last_revision(), stop_revision, self):
1116
return []
1117
else:
1118
raise e
1119
1120
def basis_tree(self):
1121
"""See Branch.basis_tree."""
1122
return self.repository.revision_tree(self.last_revision())
1123
1124
@deprecated_method(zero_eight)
1125
def working_tree(self):
1126
"""Create a Working tree object for this branch."""
1127
from bzrlib.workingtree import WorkingTree
1128
from bzrlib.transport.local import LocalTransport
1129
if (self.base.find('://') != -1 or
1130
not isinstance(self._transport, LocalTransport)):
1131
raise NoWorkingTree(self.base)
1132
return self.bzrdir.open_workingtree()
1133
1134
@needs_write_lock
1135
def pull(self, source, overwrite=False, stop_revision=None):
1136
"""See Branch.pull."""
1137
source.lock_read()
1138
try:
1139
old_count = len(self.revision_history())
1140
try:
1141
self.update_revisions(source,stop_revision)
1142
except DivergedBranches:
1143
if not overwrite:
1144
raise
1145
if overwrite:
1146
self.set_revision_history(source.revision_history())
1147
new_count = len(self.revision_history())
1148
return new_count - old_count
1149
finally:
1150
source.unlock()
1151
1152
def get_parent(self):
1153
"""See Branch.get_parent."""
1154
import errno
1155
_locs = ['parent', 'pull', 'x-pull']
1156
for l in _locs:
1157
try:
1158
return self.control_files.get_utf8(l).read().strip('\n')
1159
except NoSuchFile:
1160
pass
1161
return None
1162
1163
def get_push_location(self):
1164
"""See Branch.get_push_location."""
1165
config = bzrlib.config.BranchConfig(self)
1166
push_loc = config.get_user_option('push_location')
1167
return push_loc
1168
1169
def set_push_location(self, location):
1170
"""See Branch.set_push_location."""
1171
config = bzrlib.config.LocationConfig(self.base)
1172
config.set_user_option('push_location', location)
1173
1174
@needs_write_lock
1175
def set_parent(self, url):
1176
"""See Branch.set_parent."""
1177
# TODO: Maybe delete old location files?
1178
# URLs should never be unicode, even on the local fs,
1179
# FIXUP this and get_parent in a future branch format bump:
1180
# read and rewrite the file, and have the new format code read
1181
# using .get not .get_utf8. RBC 20060125
1182
if url is None:
1183
self.control_files._transport.delete('parent')
1184
else:
1185
self.control_files.put_utf8('parent', url + '\n')
1186
1187
def tree_config(self):
1188
return TreeConfig(self)
1189
1190
1191
class BzrBranch5(BzrBranch):
1192
"""A format 5 branch. This supports new features over plan branches.
1193
1194
It has support for a master_branch which is the data for bound branches.
1195
"""
1196
1197
def __init__(self,
1198
_format,
1199
_control_files,
1200
a_bzrdir,
1201
_repository):
1202
super(BzrBranch5, self).__init__(_format=_format,
1203
_control_files=_control_files,
1204
a_bzrdir=a_bzrdir,
1205
_repository=_repository)
1206
1207
@needs_write_lock
1208
def pull(self, source, overwrite=False, stop_revision=None):
1209
"""Updates branch.pull to be bound branch aware."""
1210
bound_location = self.get_bound_location()
1211
if source.base != bound_location:
1212
# not pulling from master, so we need to update master.
1213
master_branch = self.get_master_branch()
1214
if master_branch:
1215
master_branch.pull(source)
1216
source = master_branch
1217
return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1218
1219
def get_bound_location(self):
1220
try:
1221
return self.control_files.get_utf8('bound').read()[:-1]
1222
except errors.NoSuchFile:
1223
return None
1224
1225
@needs_read_lock
1226
def get_master_branch(self):
1227
"""Return the branch we are bound to.
1228
1229
:return: Either a Branch, or None
1230
1231
This could memoise the branch, but if thats done
1232
it must be revalidated on each new lock.
1233
So for now we just dont memoise it.
1234
# RBC 20060304 review this decision.
1235
"""
1236
bound_loc = self.get_bound_location()
1237
if not bound_loc:
1238
return None
1239
try:
1240
return Branch.open(bound_loc)
1241
except (errors.NotBranchError, errors.ConnectionError), e:
1242
raise errors.BoundBranchConnectionFailure(
1243
self, bound_loc, e)
1244
1245
@needs_write_lock
1246
def set_bound_location(self, location):
1247
"""Set the target where this branch is bound to.
1248
1249
:param location: URL to the target branch
1250
"""
1251
if location:
1252
self.control_files.put_utf8('bound', location+'\n')
1253
else:
1254
try:
1255
self.control_files._transport.delete('bound')
1256
except NoSuchFile:
1257
return False
720
"""Destroy the test branch, removing the scratch directory."""
721
shutil.rmtree(self.base)
722
723
724
725
######################################################################
726
# predicates
727
728
729
def is_control_file(filename):
730
## FIXME: better check
731
filename = os.path.normpath(filename)
732
while filename != '':
733
head, tail = os.path.split(filename)
734
## mutter('check %r for control file' % ((head, tail), ))
735
if tail == bzrlib.BZRDIR:
1258
736
return True
1259
1260
@needs_write_lock
1261
def bind(self, other):
1262
"""Bind the local branch the other branch.
1263
1264
:param other: The branch to bind to
1265
:type other: Branch
1266
"""
1267
# TODO: jam 20051230 Consider checking if the target is bound
1268
# It is debatable whether you should be able to bind to
1269
# a branch which is itself bound.
1270
# Committing is obviously forbidden,
1271
# but binding itself may not be.
1272
# Since we *have* to check at commit time, we don't
1273
# *need* to check here
1274
self.pull(other)
1275
1276
# we are now equal to or a suffix of other.
1277
1278
# Since we have 'pulled' from the remote location,
1279
# now we should try to pull in the opposite direction
1280
# in case the local tree has more revisions than the
1281
# remote one.
1282
# There may be a different check you could do here
1283
# rather than actually trying to install revisions remotely.
1284
# TODO: capture an exception which indicates the remote branch
1285
# is not writeable.
1286
# If it is up-to-date, this probably should not be a failure
1287
1288
# lock other for write so the revision-history syncing cannot race
1289
other.lock_write()
1290
try:
1291
other.pull(self)
1292
# if this does not error, other now has the same last rev we do
1293
# it can only error if the pull from other was concurrent with
1294
# a commit to other from someone else.
1295
1296
# until we ditch revision-history, we need to sync them up:
1297
self.set_revision_history(other.revision_history())
1298
# now other and self are up to date with each other and have the
1299
# same revision-history.
1300
finally:
1301
other.unlock()
1302
1303
self.set_bound_location(other.base)
1304
1305
@needs_write_lock
1306
def unbind(self):
1307
"""If bound, unbind"""
1308
return self.set_bound_location(None)
1309
1310
@needs_write_lock
1311
def update(self):
1312
"""Synchronise this branch with the master branch if any.
1313
1314
:return: None or the last_revision that was pivoted out during the
1315
update.
1316
"""
1317
master = self.get_master_branch()
1318
if master is not None:
1319
old_tip = self.last_revision()
1320
self.pull(master, overwrite=True)
1321
if old_tip in self.repository.get_ancestry(self.last_revision()):
1322
return None
1323
return old_tip
1324
return None
1325
1326
1327
class BranchTestProviderAdapter(object):
1328
"""A tool to generate a suite testing multiple branch formats at once.
1329
1330
This is done by copying the test once for each transport and injecting
1331
the transport_server, transport_readonly_server, and branch_format
1332
classes into each copy. Each copy is also given a new id() to make it
1333
easy to identify.
1334
"""
1335
1336
def __init__(self, transport_server, transport_readonly_server, formats):
1337
self._transport_server = transport_server
1338
self._transport_readonly_server = transport_readonly_server
1339
self._formats = formats
1340
1341
def adapt(self, test):
1342
result = TestSuite()
1343
for branch_format, bzrdir_format in self._formats:
1344
new_test = deepcopy(test)
1345
new_test.transport_server = self._transport_server
1346
new_test.transport_readonly_server = self._transport_readonly_server
1347
new_test.bzrdir_format = bzrdir_format
1348
new_test.branch_format = branch_format
1349
def make_new_test_id():
1350
new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1351
return lambda: new_id
1352
new_test.id = make_new_test_id()
1353
result.addTest(new_test)
1354
return result
1355
1356
1357
######################################################################
1358
# predicates
1359
1360
1361
@deprecated_function(zero_eight)
1362
def ScratchBranch(*args, **kwargs):
1363
"""See bzrlib.bzrdir.ScratchDir."""
1364
d = ScratchDir(*args, **kwargs)
1365
return d.open_branch()
1366
1367
1368
@deprecated_function(zero_eight)
1369
def is_control_file(*args, **kwargs):
1370
"""See bzrlib.workingtree.is_control_file."""
1371
return bzrlib.workingtree.is_control_file(*args, **kwargs)
737
filename = head
738
return False
739
740
741
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):
750
"""Return new file id.
751
752
This should probably generate proper UUIDs, but for the moment we
753
cope with just randomness because running uuidgen every time is
754
slow."""
755
assert '/' not in name
756
while name[0] == '.':
757
name = name[1:]
758
s = hexlify(rand_bytes(8))
759
return '-'.join((name, compact_date(time.time()), s))
760
761
Loggerhead is a web-based interface for Breezy
Version: 2.0.1