1
# Copyright (C) 2005, 2006 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
from binascii import hexlify
18
from copy import deepcopy
19
from cStringIO import StringIO
22
from unittest import TestSuite
24
import bzrlib.bzrdir as bzrdir
25
from bzrlib.decorators import needs_read_lock, needs_write_lock
26
import bzrlib.errors as errors
27
from bzrlib.errors import InvalidRevisionId
28
import bzrlib.gpg as gpg
29
from bzrlib.graph import Graph
30
from bzrlib.inter import InterObject
31
from bzrlib.inventory import Inventory
32
from bzrlib.knit import KnitVersionedFile, KnitPlainFactory
33
from bzrlib.lockable_files import LockableFiles, TransportLock
34
from bzrlib.lockdir import LockDir
35
from bzrlib.osutils import (safe_unicode, rand_bytes, compact_date,
37
from bzrlib.revision import NULL_REVISION, Revision
38
from bzrlib.store.versioned import VersionedFileStore, WeaveStore
39
from bzrlib.store.text import TextStore
40
from bzrlib.symbol_versioning import *
41
from bzrlib.trace import mutter, note
42
from bzrlib.tree import RevisionTree
43
from bzrlib.tsort import topo_sort
44
from bzrlib.testament import Testament
45
from bzrlib.tree import EmptyTree
47
from bzrlib.weave import WeaveFile
51
class Repository(object):
52
"""Repository holding history for one or more branches.
54
The repository holds and retrieves historical information including
55
revisions and file history. It's normally accessed only by the Branch,
56
which views a particular line of development through that history.
58
The Repository builds on top of Stores and a Transport, which respectively
59
describe the disk data format and the way of accessing the (possibly
64
def add_inventory(self, revid, inv, parents):
65
"""Add the inventory inv to the repository as revid.
67
:param parents: The revision ids of the parents that revid
68
is known to have and are in the repository already.
70
returns the sha1 of the serialized inventory.
72
assert inv.revision_id is None or inv.revision_id == revid, \
73
"Mismatch between inventory revision" \
74
" id and insertion revid (%r, %r)" % (inv.revision_id, revid)
75
inv_text = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
76
inv_sha1 = bzrlib.osutils.sha_string(inv_text)
77
inv_vf = self.control_weaves.get_weave('inventory',
78
self.get_transaction())
79
self._inventory_add_lines(inv_vf, revid, parents, bzrlib.osutils.split_lines(inv_text))
82
def _inventory_add_lines(self, inv_vf, revid, parents, lines):
84
for parent in parents:
86
final_parents.append(parent)
88
inv_vf.add_lines(revid, final_parents, lines)
91
def add_revision(self, rev_id, rev, inv=None, config=None):
92
"""Add rev to the revision store as rev_id.
94
:param rev_id: the revision id to use.
95
:param rev: The revision object.
96
:param inv: The inventory for the revision. if None, it will be looked
97
up in the inventory storer
98
:param config: If None no digital signature will be created.
99
If supplied its signature_needed method will be used
100
to determine if a signature should be made.
102
if config is not None and config.signature_needed():
104
inv = self.get_inventory(rev_id)
105
plaintext = Testament(rev, inv).as_short_text()
106
self.store_revision_signature(
107
gpg.GPGStrategy(config), plaintext, rev_id)
108
if not rev_id in self.get_inventory_weave():
110
raise errors.WeaveRevisionNotPresent(rev_id,
111
self.get_inventory_weave())
113
# yes, this is not suitable for adding with ghosts.
114
self.add_inventory(rev_id, inv, rev.parent_ids)
115
self._revision_store.add_revision(rev, self.get_transaction())
118
def _all_possible_ids(self):
119
"""Return all the possible revisions that we could find."""
120
return self.get_inventory_weave().versions()
122
@deprecated_method(zero_nine)
123
def all_revision_ids(self):
124
"""Returns a list of all the revision ids in the repository.
126
This is deprecated because code should generally work on the graph
127
reachable from a particular revision, and ignore any other revisions
128
that might be present. There is no direct replacement method.
130
return self._all_revision_ids()
133
def _all_revision_ids(self):
134
"""Returns a list of all the revision ids in the repository.
136
These are in as much topological order as the underlying store can
137
present: for weaves ghosts may lead to a lack of correctness until
138
the reweave updates the parents list.
140
if self._revision_store.text_store.listable():
141
return self._revision_store.all_revision_ids(self.get_transaction())
142
result = self._all_possible_ids()
143
return self._eliminate_revisions_not_present(result)
145
def break_lock(self):
146
"""Break a lock if one is present from another instance.
148
Uses the ui factory to ask for confirmation if the lock may be from
151
self.control_files.break_lock()
154
def _eliminate_revisions_not_present(self, revision_ids):
155
"""Check every revision id in revision_ids to see if we have it.
157
Returns a set of the present revisions.
160
for id in revision_ids:
161
if self.has_revision(id):
166
def create(a_bzrdir):
167
"""Construct the current default format repository in a_bzrdir."""
168
return RepositoryFormat.get_default_format().initialize(a_bzrdir)
170
def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
171
"""instantiate a Repository.
173
:param _format: The format of the repository on disk.
174
:param a_bzrdir: The BzrDir of the repository.
176
In the future we will have a single api for all stores for
177
getting file texts, inventories and revisions, then
178
this construct will accept instances of those things.
180
super(Repository, self).__init__()
181
self._format = _format
182
# the following are part of the public API for Repository:
183
self.bzrdir = a_bzrdir
184
self.control_files = control_files
185
self._revision_store = _revision_store
186
self.text_store = text_store
187
# backwards compatability
188
self.weave_store = text_store
189
# not right yet - should be more semantically clear ?
191
self.control_store = control_store
192
self.control_weaves = control_store
193
# TODO: make sure to construct the right store classes, etc, depending
194
# on whether escaping is required.
197
return '%s(%r)' % (self.__class__.__name__,
198
self.bzrdir.transport.base)
201
return self.control_files.is_locked()
203
def lock_write(self):
204
self.control_files.lock_write()
207
self.control_files.lock_read()
209
def get_physical_lock_status(self):
210
return self.control_files.get_physical_lock_status()
213
def missing_revision_ids(self, other, revision_id=None):
214
"""Return the revision ids that other has that this does not.
216
These are returned in topological order.
218
revision_id: only return revision ids included by revision_id.
220
return InterRepository.get(other, self).missing_revision_ids(revision_id)
224
"""Open the repository rooted at base.
226
For instance, if the repository is at URL/.bzr/repository,
227
Repository.open(URL) -> a Repository instance.
229
control = bzrlib.bzrdir.BzrDir.open(base)
230
return control.open_repository()
232
def copy_content_into(self, destination, revision_id=None, basis=None):
233
"""Make a complete copy of the content in self into destination.
235
This is a destructive operation! Do not use it on existing
238
return InterRepository.get(self, destination).copy_content(revision_id, basis)
240
def fetch(self, source, revision_id=None, pb=None):
241
"""Fetch the content required to construct revision_id from source.
243
If revision_id is None all content is copied.
245
return InterRepository.get(source, self).fetch(revision_id=revision_id,
248
def get_commit_builder(self, branch, parents, config, timestamp=None,
249
timezone=None, committer=None, revprops=None,
251
"""Obtain a CommitBuilder for this repository.
253
:param branch: Branch to commit to.
254
:param parents: Revision ids of the parents of the new revision.
255
:param config: Configuration to use.
256
:param timestamp: Optional timestamp recorded for commit.
257
:param timezone: Optional timezone for timestamp.
258
:param committer: Optional committer to set for commit.
259
:param revprops: Optional dictionary of revision properties.
260
:param revision_id: Optional revision id.
262
return CommitBuilder(self, parents, config, timestamp, timezone,
263
committer, revprops, revision_id)
266
self.control_files.unlock()
269
def clone(self, a_bzrdir, revision_id=None, basis=None):
270
"""Clone this repository into a_bzrdir using the current format.
272
Currently no check is made that the format of this repository and
273
the bzrdir format are compatible. FIXME RBC 20060201.
275
if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
276
# use target default format.
277
result = a_bzrdir.create_repository()
278
# FIXME RBC 20060209 split out the repository type to avoid this check ?
279
elif isinstance(a_bzrdir._format,
280
(bzrlib.bzrdir.BzrDirFormat4,
281
bzrlib.bzrdir.BzrDirFormat5,
282
bzrlib.bzrdir.BzrDirFormat6)):
283
result = a_bzrdir.open_repository()
285
result = self._format.initialize(a_bzrdir, shared=self.is_shared())
286
self.copy_content_into(result, revision_id, basis)
290
def has_revision(self, revision_id):
291
"""True if this repository has a copy of the revision."""
292
return self._revision_store.has_revision_id(revision_id,
293
self.get_transaction())
296
def get_revision_reconcile(self, revision_id):
297
"""'reconcile' helper routine that allows access to a revision always.
299
This variant of get_revision does not cross check the weave graph
300
against the revision one as get_revision does: but it should only
301
be used by reconcile, or reconcile-alike commands that are correcting
302
or testing the revision graph.
304
if not revision_id or not isinstance(revision_id, basestring):
305
raise InvalidRevisionId(revision_id=revision_id, branch=self)
306
return self._revision_store.get_revision(revision_id,
307
self.get_transaction())
310
def get_revision_xml(self, revision_id):
311
rev = self.get_revision(revision_id)
313
# the current serializer..
314
self._revision_store._serializer.write_revision(rev, rev_tmp)
316
return rev_tmp.getvalue()
319
def get_revision(self, revision_id):
320
"""Return the Revision object for a named revision"""
321
r = self.get_revision_reconcile(revision_id)
322
# weave corruption can lead to absent revision markers that should be
324
# the following test is reasonably cheap (it needs a single weave read)
325
# and the weave is cached in read transactions. In write transactions
326
# it is not cached but typically we only read a small number of
327
# revisions. For knits when they are introduced we will probably want
328
# to ensure that caching write transactions are in use.
329
inv = self.get_inventory_weave()
330
self._check_revision_parents(r, inv)
333
def _check_revision_parents(self, revision, inventory):
334
"""Private to Repository and Fetch.
336
This checks the parentage of revision in an inventory weave for
337
consistency and is only applicable to inventory-weave-for-ancestry
338
using repository formats & fetchers.
340
weave_parents = inventory.get_parents(revision.revision_id)
341
weave_names = inventory.versions()
342
for parent_id in revision.parent_ids:
343
if parent_id in weave_names:
344
# this parent must not be a ghost.
345
if not parent_id in weave_parents:
347
raise errors.CorruptRepository(self)
350
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
351
signature = gpg_strategy.sign(plaintext)
352
self._revision_store.add_revision_signature_text(revision_id,
354
self.get_transaction())
356
def fileids_altered_by_revision_ids(self, revision_ids):
357
"""Find the file ids and versions affected by revisions.
359
:param revisions: an iterable containing revision ids.
360
:return: a dictionary mapping altered file-ids to an iterable of
361
revision_ids. Each altered file-ids has the exact revision_ids that
362
altered it listed explicitly.
364
assert isinstance(self._format, (RepositoryFormat5,
367
RepositoryFormatKnit1)), \
368
("fileids_altered_by_revision_ids only supported for branches "
369
"which store inventory as unnested xml, not on %r" % self)
370
selected_revision_ids = set(revision_ids)
371
w = self.get_inventory_weave()
374
# this code needs to read every new line in every inventory for the
375
# inventories [revision_ids]. Seeing a line twice is ok. Seeing a line
376
# not pesent in one of those inventories is unnecessary but not
377
# harmful because we are filtering by the revision id marker in the
378
# inventory lines : we only select file ids altered in one of those
379
# revisions. We dont need to see all lines in the inventory because
380
# only those added in an inventory in rev X can contain a revision=X
382
for line in w.iter_lines_added_or_present_in_versions(selected_revision_ids):
383
start = line.find('file_id="')+9
384
if start < 9: continue
385
end = line.find('"', start)
387
file_id = _unescape_xml(line[start:end])
389
start = line.find('revision="')+10
390
if start < 10: continue
391
end = line.find('"', start)
393
revision_id = _unescape_xml(line[start:end])
394
if revision_id in selected_revision_ids:
395
result.setdefault(file_id, set()).add(revision_id)
399
def get_inventory_weave(self):
400
return self.control_weaves.get_weave('inventory',
401
self.get_transaction())
404
def get_inventory(self, revision_id):
405
"""Get Inventory object by hash."""
406
return self.deserialise_inventory(
407
revision_id, self.get_inventory_xml(revision_id))
409
def deserialise_inventory(self, revision_id, xml):
410
"""Transform the xml into an inventory object.
412
:param revision_id: The expected revision id of the inventory.
413
:param xml: A serialised inventory.
415
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
418
def get_inventory_xml(self, revision_id):
419
"""Get inventory XML as a file object."""
421
assert isinstance(revision_id, basestring), type(revision_id)
422
iw = self.get_inventory_weave()
423
return iw.get_text(revision_id)
425
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
428
def get_inventory_sha1(self, revision_id):
429
"""Return the sha1 hash of the inventory entry
431
return self.get_revision(revision_id).inventory_sha1
434
def get_revision_graph(self, revision_id=None):
435
"""Return a dictionary containing the revision graph.
437
:return: a dictionary of revision_id->revision_parents_list.
439
weave = self.get_inventory_weave()
440
all_revisions = self._eliminate_revisions_not_present(weave.versions())
441
entire_graph = dict([(node, weave.get_parents(node)) for
442
node in all_revisions])
443
if revision_id is None:
445
elif revision_id not in entire_graph:
446
raise errors.NoSuchRevision(self, revision_id)
448
# add what can be reached from revision_id
450
pending = set([revision_id])
451
while len(pending) > 0:
453
result[node] = entire_graph[node]
454
for revision_id in result[node]:
455
if revision_id not in result:
456
pending.add(revision_id)
460
def get_revision_graph_with_ghosts(self, revision_ids=None):
461
"""Return a graph of the revisions with ghosts marked as applicable.
463
:param revision_ids: an iterable of revisions to graph or None for all.
464
:return: a Graph object with the graph reachable from revision_ids.
468
pending = set(self.all_revision_ids())
471
pending = set(revision_ids)
472
required = set(revision_ids)
475
revision_id = pending.pop()
477
rev = self.get_revision(revision_id)
478
except errors.NoSuchRevision:
479
if revision_id in required:
482
result.add_ghost(revision_id)
484
for parent_id in rev.parent_ids:
485
# is this queued or done ?
486
if (parent_id not in pending and
487
parent_id not in done):
489
pending.add(parent_id)
490
result.add_node(revision_id, rev.parent_ids)
491
done.add(revision_id)
495
def get_revision_inventory(self, revision_id):
496
"""Return inventory of a past revision."""
497
# TODO: Unify this with get_inventory()
498
# bzr 0.0.6 and later imposes the constraint that the inventory_id
499
# must be the same as its revision, so this is trivial.
500
if revision_id is None:
501
# This does not make sense: if there is no revision,
502
# then it is the current tree inventory surely ?!
503
# and thus get_root_id() is something that looks at the last
504
# commit on the branch, and the get_root_id is an inventory check.
505
raise NotImplementedError
506
# return Inventory(self.get_root_id())
508
return self.get_inventory(revision_id)
512
"""Return True if this repository is flagged as a shared repository."""
513
raise NotImplementedError(self.is_shared)
516
def reconcile(self, other=None, thorough=False):
517
"""Reconcile this repository."""
518
from bzrlib.reconcile import RepoReconciler
519
reconciler = RepoReconciler(self, thorough=thorough)
520
reconciler.reconcile()
524
def revision_tree(self, revision_id):
525
"""Return Tree for a revision on this branch.
527
`revision_id` may be None for the null revision, in which case
528
an `EmptyTree` is returned."""
529
# TODO: refactor this to use an existing revision object
530
# so we don't need to read it in twice.
531
if revision_id is None or revision_id == NULL_REVISION:
534
inv = self.get_revision_inventory(revision_id)
535
return RevisionTree(self, inv, revision_id)
538
def get_ancestry(self, revision_id):
539
"""Return a list of revision-ids integrated by a revision.
541
The first element of the list is always None, indicating the origin
542
revision. This might change when we have history horizons, or
543
perhaps we should have a new API.
545
This is topologically sorted.
547
if revision_id is None:
549
if not self.has_revision(revision_id):
550
raise errors.NoSuchRevision(self, revision_id)
551
w = self.get_inventory_weave()
552
candidates = w.get_ancestry(revision_id)
553
return [None] + candidates # self._eliminate_revisions_not_present(candidates)
556
def print_file(self, file, revision_id):
557
"""Print `file` to stdout.
559
FIXME RBC 20060125 as John Meinel points out this is a bad api
560
- it writes to stdout, it assumes that that is valid etc. Fix
561
by creating a new more flexible convenience function.
563
tree = self.revision_tree(revision_id)
564
# use inventory as it was in that revision
565
file_id = tree.inventory.path2id(file)
567
# TODO: jam 20060427 Write a test for this code path
568
# it had a bug in it, and was raising the wrong
570
raise errors.BzrError("%r is not present in revision %s" % (file, revision_id))
571
tree.print_file(file_id)
573
def get_transaction(self):
574
return self.control_files.get_transaction()
576
def revision_parents(self, revid):
577
return self.get_inventory_weave().parent_names(revid)
580
def set_make_working_trees(self, new_value):
581
"""Set the policy flag for making working trees when creating branches.
583
This only applies to branches that use this repository.
585
The default is 'True'.
586
:param new_value: True to restore the default, False to disable making
589
raise NotImplementedError(self.set_make_working_trees)
591
def make_working_trees(self):
592
"""Returns the policy for making working trees on new branches."""
593
raise NotImplementedError(self.make_working_trees)
596
def sign_revision(self, revision_id, gpg_strategy):
597
plaintext = Testament.from_revision(self, revision_id).as_short_text()
598
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
601
def has_signature_for_revision_id(self, revision_id):
602
"""Query for a revision signature for revision_id in the repository."""
603
return self._revision_store.has_signature(revision_id,
604
self.get_transaction())
607
def get_signature_text(self, revision_id):
608
"""Return the text for a signature."""
609
return self._revision_store.get_signature_text(revision_id,
610
self.get_transaction())
613
def check(self, revision_ids):
614
"""Check consistency of all history of given revision_ids.
616
Different repository implementations should override _check().
618
:param revision_ids: A non-empty list of revision_ids whose ancestry
619
will be checked. Typically the last revision_id of a branch.
622
raise ValueError("revision_ids must be non-empty in %s.check"
624
return self._check(revision_ids)
626
def _check(self, revision_ids):
627
result = bzrlib.check.Check(self)
632
class AllInOneRepository(Repository):
633
"""Legacy support - the repository behaviour for all-in-one branches."""
635
def __init__(self, _format, a_bzrdir, _revision_store, control_store, text_store):
636
# we reuse one control files instance.
637
dir_mode = a_bzrdir._control_files._dir_mode
638
file_mode = a_bzrdir._control_files._file_mode
640
def get_store(name, compressed=True, prefixed=False):
641
# FIXME: This approach of assuming stores are all entirely compressed
642
# or entirely uncompressed is tidy, but breaks upgrade from
643
# some existing branches where there's a mixture; we probably
644
# still want the option to look for both.
645
relpath = a_bzrdir._control_files._escape(name)
646
store = TextStore(a_bzrdir._control_files._transport.clone(relpath),
647
prefixed=prefixed, compressed=compressed,
650
#if self._transport.should_cache():
651
# cache_path = os.path.join(self.cache_root, name)
652
# os.mkdir(cache_path)
653
# store = bzrlib.store.CachedStore(store, cache_path)
656
# not broken out yet because the controlweaves|inventory_store
657
# and text_store | weave_store bits are still different.
658
if isinstance(_format, RepositoryFormat4):
659
# cannot remove these - there is still no consistent api
660
# which allows access to this old info.
661
self.inventory_store = get_store('inventory-store')
662
text_store = get_store('text-store')
663
super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)
667
"""AllInOne repositories cannot be shared."""
671
def set_make_working_trees(self, new_value):
672
"""Set the policy flag for making working trees when creating branches.
674
This only applies to branches that use this repository.
676
The default is 'True'.
677
:param new_value: True to restore the default, False to disable making
680
raise NotImplementedError(self.set_make_working_trees)
682
def make_working_trees(self):
683
"""Returns the policy for making working trees on new branches."""
687
def install_revision(repository, rev, revision_tree):
688
"""Install all revision data into a repository."""
691
for p_id in rev.parent_ids:
692
if repository.has_revision(p_id):
693
present_parents.append(p_id)
694
parent_trees[p_id] = repository.revision_tree(p_id)
696
parent_trees[p_id] = EmptyTree()
698
inv = revision_tree.inventory
700
# Add the texts that are not already present
701
for path, ie in inv.iter_entries():
702
w = repository.weave_store.get_weave_or_empty(ie.file_id,
703
repository.get_transaction())
704
if ie.revision not in w:
706
# FIXME: TODO: The following loop *may* be overlapping/duplicate
707
# with inventoryEntry.find_previous_heads(). if it is, then there
708
# is a latent bug here where the parents may have ancestors of each
710
for revision, tree in parent_trees.iteritems():
711
if ie.file_id not in tree:
713
parent_id = tree.inventory[ie.file_id].revision
714
if parent_id in text_parents:
716
text_parents.append(parent_id)
718
vfile = repository.weave_store.get_weave_or_empty(ie.file_id,
719
repository.get_transaction())
720
lines = revision_tree.get_file(ie.file_id).readlines()
721
vfile.add_lines(rev.revision_id, text_parents, lines)
723
# install the inventory
724
repository.add_inventory(rev.revision_id, inv, present_parents)
725
except errors.RevisionAlreadyPresent:
727
repository.add_revision(rev.revision_id, rev, inv)
730
class MetaDirRepository(Repository):
731
"""Repositories in the new meta-dir layout."""
733
def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
734
super(MetaDirRepository, self).__init__(_format,
741
dir_mode = self.control_files._dir_mode
742
file_mode = self.control_files._file_mode
746
"""Return True if this repository is flagged as a shared repository."""
747
return self.control_files._transport.has('shared-storage')
750
def set_make_working_trees(self, new_value):
751
"""Set the policy flag for making working trees when creating branches.
753
This only applies to branches that use this repository.
755
The default is 'True'.
756
:param new_value: True to restore the default, False to disable making
761
self.control_files._transport.delete('no-working-trees')
762
except errors.NoSuchFile:
765
self.control_files.put_utf8('no-working-trees', '')
767
def make_working_trees(self):
768
"""Returns the policy for making working trees on new branches."""
769
return not self.control_files._transport.has('no-working-trees')
772
class KnitRepository(MetaDirRepository):
773
"""Knit format repository."""
775
def _inventory_add_lines(self, inv_vf, revid, parents, lines):
776
inv_vf.add_lines_with_ghosts(revid, parents, lines)
779
def _all_revision_ids(self):
780
"""See Repository.all_revision_ids()."""
781
# Knits get the revision graph from the index of the revision knit, so
782
# it's always possible even if they're on an unlistable transport.
783
return self._revision_store.all_revision_ids(self.get_transaction())
786
def get_ancestry(self, revision_id):
787
"""Return a list of revision-ids integrated by a revision.
789
This is topologically sorted.
791
if revision_id is None:
793
vf = self._get_revision_vf()
795
return [None] + vf.get_ancestry(revision_id)
796
except errors.RevisionNotPresent:
797
raise errors.NoSuchRevision(self, revision_id)
800
def get_revision(self, revision_id):
801
"""Return the Revision object for a named revision"""
802
return self.get_revision_reconcile(revision_id)
805
def get_revision_graph(self, revision_id=None):
806
"""Return a dictionary containing the revision graph.
808
:return: a dictionary of revision_id->revision_parents_list.
810
weave = self._get_revision_vf()
811
entire_graph = weave.get_graph()
812
if revision_id is None:
813
return weave.get_graph()
814
elif revision_id not in weave:
815
raise errors.NoSuchRevision(self, revision_id)
817
# add what can be reached from revision_id
819
pending = set([revision_id])
820
while len(pending) > 0:
822
result[node] = weave.get_parents(node)
823
for revision_id in result[node]:
824
if revision_id not in result:
825
pending.add(revision_id)
829
def get_revision_graph_with_ghosts(self, revision_ids=None):
830
"""Return a graph of the revisions with ghosts marked as applicable.
832
:param revision_ids: an iterable of revisions to graph or None for all.
833
:return: a Graph object with the graph reachable from revision_ids.
836
vf = self._get_revision_vf()
837
versions = set(vf.versions())
839
pending = set(self.all_revision_ids())
842
pending = set(revision_ids)
843
required = set(revision_ids)
846
revision_id = pending.pop()
847
if not revision_id in versions:
848
if revision_id in required:
849
raise errors.NoSuchRevision(self, revision_id)
851
result.add_ghost(revision_id)
852
# mark it as done so we dont try for it again.
853
done.add(revision_id)
855
parent_ids = vf.get_parents_with_ghosts(revision_id)
856
for parent_id in parent_ids:
857
# is this queued or done ?
858
if (parent_id not in pending and
859
parent_id not in done):
861
pending.add(parent_id)
862
result.add_node(revision_id, parent_ids)
863
done.add(revision_id)
866
def _get_revision_vf(self):
867
""":return: a versioned file containing the revisions."""
868
vf = self._revision_store.get_revision_file(self.get_transaction())
872
def reconcile(self, other=None, thorough=False):
873
"""Reconcile this repository."""
874
from bzrlib.reconcile import KnitReconciler
875
reconciler = KnitReconciler(self, thorough=thorough)
876
reconciler.reconcile()
879
def revision_parents(self, revid):
880
return self._get_revision_vf().get_parents(rev_id)
882
class RepositoryFormat(object):
883
"""A repository format.
885
Formats provide three things:
886
* An initialization routine to construct repository data on disk.
887
* a format string which is used when the BzrDir supports versioned
889
* an open routine which returns a Repository instance.
891
Formats are placed in an dict by their format string for reference
892
during opening. These should be subclasses of RepositoryFormat
895
Once a format is deprecated, just deprecate the initialize and open
896
methods on the format class. Do not deprecate the object, as the
897
object will be created every system load.
899
Common instance attributes:
900
_matchingbzrdir - the bzrdir format that the repository format was
901
originally written to work with. This can be used if manually
902
constructing a bzrdir and repository, or more commonly for test suite
906
_default_format = None
907
"""The default format used for new repositories."""
910
"""The known formats."""
913
def find_format(klass, a_bzrdir):
914
"""Return the format for the repository object in a_bzrdir."""
916
transport = a_bzrdir.get_repository_transport(None)
917
format_string = transport.get("format").read()
918
return klass._formats[format_string]
919
except errors.NoSuchFile:
920
raise errors.NoRepositoryPresent(a_bzrdir)
922
raise errors.UnknownFormatError(format_string)
924
def _get_control_store(self, repo_transport, control_files):
925
"""Return the control store for this repository."""
926
raise NotImplementedError(self._get_control_store)
929
def get_default_format(klass):
930
"""Return the current default format."""
931
return klass._default_format
933
def get_format_string(self):
934
"""Return the ASCII format string that identifies this format.
936
Note that in pre format ?? repositories the format string is
937
not permitted nor written to disk.
939
raise NotImplementedError(self.get_format_string)
941
def get_format_description(self):
942
"""Return the short desciption for this format."""
943
raise NotImplementedError(self.get_format_description)
945
def _get_revision_store(self, repo_transport, control_files):
946
"""Return the revision store object for this a_bzrdir."""
947
raise NotImplementedError(self._get_revision_store)
949
def _get_text_rev_store(self,
956
"""Common logic for getting a revision store for a repository.
958
see self._get_revision_store for the subclass-overridable method to
959
get the store for a repository.
961
from bzrlib.store.revision.text import TextRevisionStore
962
dir_mode = control_files._dir_mode
963
file_mode = control_files._file_mode
964
text_store =TextStore(transport.clone(name),
966
compressed=compressed,
969
_revision_store = TextRevisionStore(text_store, serializer)
970
return _revision_store
972
def _get_versioned_file_store(self,
977
versionedfile_class=WeaveFile,
979
weave_transport = control_files._transport.clone(name)
980
dir_mode = control_files._dir_mode
981
file_mode = control_files._file_mode
982
return VersionedFileStore(weave_transport, prefixed=prefixed,
985
versionedfile_class=versionedfile_class,
988
def initialize(self, a_bzrdir, shared=False):
989
"""Initialize a repository of this format in a_bzrdir.
991
:param a_bzrdir: The bzrdir to put the new repository in it.
992
:param shared: The repository should be initialized as a sharable one.
994
This may raise UninitializableFormat if shared repository are not
995
compatible the a_bzrdir.
998
def is_supported(self):
999
"""Is this format supported?
1001
Supported formats must be initializable and openable.
1002
Unsupported formats may not support initialization or committing or
1003
some other features depending on the reason for not being supported.
1007
def open(self, a_bzrdir, _found=False):
1008
"""Return an instance of this format for the bzrdir a_bzrdir.
1010
_found is a private parameter, do not use it.
1012
raise NotImplementedError(self.open)
1015
def register_format(klass, format):
1016
klass._formats[format.get_format_string()] = format
1019
def set_default_format(klass, format):
1020
klass._default_format = format
1023
def unregister_format(klass, format):
1024
assert klass._formats[format.get_format_string()] is format
1025
del klass._formats[format.get_format_string()]
1028
class PreSplitOutRepositoryFormat(RepositoryFormat):
1029
"""Base class for the pre split out repository formats."""
1031
def initialize(self, a_bzrdir, shared=False, _internal=False):
1032
"""Create a weave repository.
1034
TODO: when creating split out bzr branch formats, move this to a common
1035
base for Format5, Format6. or something like that.
1037
from bzrlib.weavefile import write_weave_v5
1038
from bzrlib.weave import Weave
1041
raise errors.IncompatibleFormat(self, a_bzrdir._format)
1044
# always initialized when the bzrdir is.
1045
return self.open(a_bzrdir, _found=True)
1047
# Create an empty weave
1049
bzrlib.weavefile.write_weave_v5(Weave(), sio)
1050
empty_weave = sio.getvalue()
1052
mutter('creating repository in %s.', a_bzrdir.transport.base)
1053
dirs = ['revision-store', 'weaves']
1054
files = [('inventory.weave', StringIO(empty_weave)),
1057
# FIXME: RBC 20060125 dont peek under the covers
1058
# NB: no need to escape relative paths that are url safe.
1059
control_files = LockableFiles(a_bzrdir.transport, 'branch-lock',
1061
control_files.create_lock()
1062
control_files.lock_write()
1063
control_files._transport.mkdir_multi(dirs,
1064
mode=control_files._dir_mode)
1066
for file, content in files:
1067
control_files.put(file, content)
1069
control_files.unlock()
1070
return self.open(a_bzrdir, _found=True)
1072
def _get_control_store(self, repo_transport, control_files):
1073
"""Return the control store for this repository."""
1074
return self._get_versioned_file_store('',
1079
def _get_text_store(self, transport, control_files):
1080
"""Get a store for file texts for this format."""
1081
raise NotImplementedError(self._get_text_store)
1083
def open(self, a_bzrdir, _found=False):
1084
"""See RepositoryFormat.open()."""
1086
# we are being called directly and must probe.
1087
raise NotImplementedError
1089
repo_transport = a_bzrdir.get_repository_transport(None)
1090
control_files = a_bzrdir._control_files
1091
text_store = self._get_text_store(repo_transport, control_files)
1092
control_store = self._get_control_store(repo_transport, control_files)
1093
_revision_store = self._get_revision_store(repo_transport, control_files)
1094
return AllInOneRepository(_format=self,
1096
_revision_store=_revision_store,
1097
control_store=control_store,
1098
text_store=text_store)
1101
class RepositoryFormat4(PreSplitOutRepositoryFormat):
1102
"""Bzr repository format 4.
1104
This repository format has:
1106
- TextStores for texts, inventories,revisions.
1108
This format is deprecated: it indexes texts using a text id which is
1109
removed in format 5; initializationa and write support for this format
1114
super(RepositoryFormat4, self).__init__()
1115
self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat4()
1117
def get_format_description(self):
1118
"""See RepositoryFormat.get_format_description()."""
1119
return "Repository format 4"
1121
def initialize(self, url, shared=False, _internal=False):
1122
"""Format 4 branches cannot be created."""
1123
raise errors.UninitializableFormat(self)
1125
def is_supported(self):
1126
"""Format 4 is not supported.
1128
It is not supported because the model changed from 4 to 5 and the
1129
conversion logic is expensive - so doing it on the fly was not
1134
def _get_control_store(self, repo_transport, control_files):
1135
"""Format 4 repositories have no formal control store at this point.
1137
This will cause any control-file-needing apis to fail - this is desired.
1141
def _get_revision_store(self, repo_transport, control_files):
1142
"""See RepositoryFormat._get_revision_store()."""
1143
from bzrlib.xml4 import serializer_v4
1144
return self._get_text_rev_store(repo_transport,
1147
serializer=serializer_v4)
1149
def _get_text_store(self, transport, control_files):
1150
"""See RepositoryFormat._get_text_store()."""
1153
class RepositoryFormat5(PreSplitOutRepositoryFormat):
1154
"""Bzr control format 5.
1156
This repository format has:
1157
- weaves for file texts and inventory
1159
- TextStores for revisions and signatures.
1163
super(RepositoryFormat5, self).__init__()
1164
self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat5()
1166
def get_format_description(self):
1167
"""See RepositoryFormat.get_format_description()."""
1168
return "Weave repository format 5"
1170
def _get_revision_store(self, repo_transport, control_files):
1171
"""See RepositoryFormat._get_revision_store()."""
1172
"""Return the revision store object for this a_bzrdir."""
1173
return self._get_text_rev_store(repo_transport,
1178
def _get_text_store(self, transport, control_files):
1179
"""See RepositoryFormat._get_text_store()."""
1180
return self._get_versioned_file_store('weaves', transport, control_files, prefixed=False)
1183
class RepositoryFormat6(PreSplitOutRepositoryFormat):
1184
"""Bzr control format 6.
1186
This repository format has:
1187
- weaves for file texts and inventory
1188
- hash subdirectory based stores.
1189
- TextStores for revisions and signatures.
1193
super(RepositoryFormat6, self).__init__()
1194
self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat6()
1196
def get_format_description(self):
1197
"""See RepositoryFormat.get_format_description()."""
1198
return "Weave repository format 6"
1200
def _get_revision_store(self, repo_transport, control_files):
1201
"""See RepositoryFormat._get_revision_store()."""
1202
return self._get_text_rev_store(repo_transport,
1208
def _get_text_store(self, transport, control_files):
1209
"""See RepositoryFormat._get_text_store()."""
1210
return self._get_versioned_file_store('weaves', transport, control_files)
1213
class MetaDirRepositoryFormat(RepositoryFormat):
1214
"""Common base class for the new repositories using the metadir layour."""
1217
super(MetaDirRepositoryFormat, self).__init__()
1218
self._matchingbzrdir = bzrlib.bzrdir.BzrDirMetaFormat1()
1220
def _create_control_files(self, a_bzrdir):
1221
"""Create the required files and the initial control_files object."""
1222
# FIXME: RBC 20060125 dont peek under the covers
1223
# NB: no need to escape relative paths that are url safe.
1224
repository_transport = a_bzrdir.get_repository_transport(self)
1225
control_files = LockableFiles(repository_transport, 'lock', LockDir)
1226
control_files.create_lock()
1227
return control_files
1229
def _upload_blank_content(self, a_bzrdir, dirs, files, utf8_files, shared):
1230
"""Upload the initial blank content."""
1231
control_files = self._create_control_files(a_bzrdir)
1232
control_files.lock_write()
1234
control_files._transport.mkdir_multi(dirs,
1235
mode=control_files._dir_mode)
1236
for file, content in files:
1237
control_files.put(file, content)
1238
for file, content in utf8_files:
1239
control_files.put_utf8(file, content)
1241
control_files.put_utf8('shared-storage', '')
1243
control_files.unlock()
1246
class RepositoryFormat7(MetaDirRepositoryFormat):
1247
"""Bzr repository 7.
1249
This repository format has:
1250
- weaves for file texts and inventory
1251
- hash subdirectory based stores.
1252
- TextStores for revisions and signatures.
1253
- a format marker of its own
1254
- an optional 'shared-storage' flag
1255
- an optional 'no-working-trees' flag
1258
def _get_control_store(self, repo_transport, control_files):
1259
"""Return the control store for this repository."""
1260
return self._get_versioned_file_store('',
1265
def get_format_string(self):
1266
"""See RepositoryFormat.get_format_string()."""
1267
return "Bazaar-NG Repository format 7"
1269
def get_format_description(self):
1270
"""See RepositoryFormat.get_format_description()."""
1271
return "Weave repository format 7"
1273
def _get_revision_store(self, repo_transport, control_files):
1274
"""See RepositoryFormat._get_revision_store()."""
1275
return self._get_text_rev_store(repo_transport,
1282
def _get_text_store(self, transport, control_files):
1283
"""See RepositoryFormat._get_text_store()."""
1284
return self._get_versioned_file_store('weaves',
1288
def initialize(self, a_bzrdir, shared=False):
1289
"""Create a weave repository.
1291
:param shared: If true the repository will be initialized as a shared
1294
from bzrlib.weavefile import write_weave_v5
1295
from bzrlib.weave import Weave
1297
# Create an empty weave
1299
bzrlib.weavefile.write_weave_v5(Weave(), sio)
1300
empty_weave = sio.getvalue()
1302
mutter('creating repository in %s.', a_bzrdir.transport.base)
1303
dirs = ['revision-store', 'weaves']
1304
files = [('inventory.weave', StringIO(empty_weave)),
1306
utf8_files = [('format', self.get_format_string())]
1308
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1309
return self.open(a_bzrdir=a_bzrdir, _found=True)
1311
def open(self, a_bzrdir, _found=False, _override_transport=None):
1312
"""See RepositoryFormat.open().
1314
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1315
repository at a slightly different url
1316
than normal. I.e. during 'upgrade'.
1319
format = RepositoryFormat.find_format(a_bzrdir)
1320
assert format.__class__ == self.__class__
1321
if _override_transport is not None:
1322
repo_transport = _override_transport
1324
repo_transport = a_bzrdir.get_repository_transport(None)
1325
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1326
text_store = self._get_text_store(repo_transport, control_files)
1327
control_store = self._get_control_store(repo_transport, control_files)
1328
_revision_store = self._get_revision_store(repo_transport, control_files)
1329
return MetaDirRepository(_format=self,
1331
control_files=control_files,
1332
_revision_store=_revision_store,
1333
control_store=control_store,
1334
text_store=text_store)
1337
class RepositoryFormatKnit1(MetaDirRepositoryFormat):
1338
"""Bzr repository knit format 1.
1340
This repository format has:
1341
- knits for file texts and inventory
1342
- hash subdirectory based stores.
1343
- knits for revisions and signatures
1344
- TextStores for revisions and signatures.
1345
- a format marker of its own
1346
- an optional 'shared-storage' flag
1347
- an optional 'no-working-trees' flag
1350
This format was introduced in bzr 0.8.
1353
def _get_control_store(self, repo_transport, control_files):
1354
"""Return the control store for this repository."""
1355
return VersionedFileStore(
1358
file_mode=control_files._file_mode,
1359
versionedfile_class=KnitVersionedFile,
1360
versionedfile_kwargs={'factory':KnitPlainFactory()},
1363
def get_format_string(self):
1364
"""See RepositoryFormat.get_format_string()."""
1365
return "Bazaar-NG Knit Repository Format 1"
1367
def get_format_description(self):
1368
"""See RepositoryFormat.get_format_description()."""
1369
return "Knit repository format 1"
1371
def _get_revision_store(self, repo_transport, control_files):
1372
"""See RepositoryFormat._get_revision_store()."""
1373
from bzrlib.store.revision.knit import KnitRevisionStore
1374
versioned_file_store = VersionedFileStore(
1376
file_mode=control_files._file_mode,
1379
versionedfile_class=KnitVersionedFile,
1380
versionedfile_kwargs={'delta':False, 'factory':KnitPlainFactory()},
1383
return KnitRevisionStore(versioned_file_store)
1385
def _get_text_store(self, transport, control_files):
1386
"""See RepositoryFormat._get_text_store()."""
1387
return self._get_versioned_file_store('knits',
1390
versionedfile_class=KnitVersionedFile,
1393
def initialize(self, a_bzrdir, shared=False):
1394
"""Create a knit format 1 repository.
1396
:param a_bzrdir: bzrdir to contain the new repository; must already
1398
:param shared: If true the repository will be initialized as a shared
1401
mutter('creating repository in %s.', a_bzrdir.transport.base)
1402
dirs = ['revision-store', 'knits']
1404
utf8_files = [('format', self.get_format_string())]
1406
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1407
repo_transport = a_bzrdir.get_repository_transport(None)
1408
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1409
control_store = self._get_control_store(repo_transport, control_files)
1410
transaction = bzrlib.transactions.WriteTransaction()
1411
# trigger a write of the inventory store.
1412
control_store.get_weave_or_empty('inventory', transaction)
1413
_revision_store = self._get_revision_store(repo_transport, control_files)
1414
_revision_store.has_revision_id('A', transaction)
1415
_revision_store.get_signature_file(transaction)
1416
return self.open(a_bzrdir=a_bzrdir, _found=True)
1418
def open(self, a_bzrdir, _found=False, _override_transport=None):
1419
"""See RepositoryFormat.open().
1421
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1422
repository at a slightly different url
1423
than normal. I.e. during 'upgrade'.
1426
format = RepositoryFormat.find_format(a_bzrdir)
1427
assert format.__class__ == self.__class__
1428
if _override_transport is not None:
1429
repo_transport = _override_transport
1431
repo_transport = a_bzrdir.get_repository_transport(None)
1432
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1433
text_store = self._get_text_store(repo_transport, control_files)
1434
control_store = self._get_control_store(repo_transport, control_files)
1435
_revision_store = self._get_revision_store(repo_transport, control_files)
1436
return KnitRepository(_format=self,
1438
control_files=control_files,
1439
_revision_store=_revision_store,
1440
control_store=control_store,
1441
text_store=text_store)
1444
# formats which have no format string are not discoverable
1445
# and not independently creatable, so are not registered.
1446
RepositoryFormat.register_format(RepositoryFormat7())
1447
_default_format = RepositoryFormatKnit1()
1448
RepositoryFormat.register_format(_default_format)
1449
RepositoryFormat.set_default_format(_default_format)
1450
_legacy_formats = [RepositoryFormat4(),
1451
RepositoryFormat5(),
1452
RepositoryFormat6()]
1455
class InterRepository(InterObject):
1456
"""This class represents operations taking place between two repositories.
1458
Its instances have methods like copy_content and fetch, and contain
1459
references to the source and target repositories these operations can be
1462
Often we will provide convenience methods on 'repository' which carry out
1463
operations with another repository - they will always forward to
1464
InterRepository.get(other).method_name(parameters).
1468
"""The available optimised InterRepository types."""
1471
def copy_content(self, revision_id=None, basis=None):
1472
"""Make a complete copy of the content in self into destination.
1474
This is a destructive operation! Do not use it on existing
1477
:param revision_id: Only copy the content needed to construct
1478
revision_id and its parents.
1479
:param basis: Copy the needed data preferentially from basis.
1482
self.target.set_make_working_trees(self.source.make_working_trees())
1483
except NotImplementedError:
1485
# grab the basis available data
1486
if basis is not None:
1487
self.target.fetch(basis, revision_id=revision_id)
1488
# but dont bother fetching if we have the needed data now.
1489
if (revision_id not in (None, NULL_REVISION) and
1490
self.target.has_revision(revision_id)):
1492
self.target.fetch(self.source, revision_id=revision_id)
1494
def _double_lock(self, lock_source, lock_target):
1495
"""Take out too locks, rolling back the first if the second throws."""
1500
# we want to ensure that we don't leave source locked by mistake.
1501
# and any error on target should not confuse source.
1502
self.source.unlock()
1506
def fetch(self, revision_id=None, pb=None):
1507
"""Fetch the content required to construct revision_id.
1509
The content is copied from source to target.
1511
:param revision_id: if None all content is copied, if NULL_REVISION no
1513
:param pb: optional progress bar to use for progress reports. If not
1514
provided a default one will be created.
1516
Returns the copied revision count and the failed revisions in a tuple:
1519
from bzrlib.fetch import GenericRepoFetcher
1520
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1521
self.source, self.source._format, self.target, self.target._format)
1522
f = GenericRepoFetcher(to_repository=self.target,
1523
from_repository=self.source,
1524
last_revision=revision_id,
1526
return f.count_copied, f.failed_revisions
1528
def lock_read(self):
1529
"""Take out a logical read lock.
1531
This will lock the source branch and the target branch. The source gets
1532
a read lock and the target a read lock.
1534
self._double_lock(self.source.lock_read, self.target.lock_read)
1536
def lock_write(self):
1537
"""Take out a logical write lock.
1539
This will lock the source branch and the target branch. The source gets
1540
a read lock and the target a write lock.
1542
self._double_lock(self.source.lock_read, self.target.lock_write)
1545
def missing_revision_ids(self, revision_id=None):
1546
"""Return the revision ids that source has that target does not.
1548
These are returned in topological order.
1550
:param revision_id: only return revision ids included by this
1553
# generic, possibly worst case, slow code path.
1554
target_ids = set(self.target.all_revision_ids())
1555
if revision_id is not None:
1556
source_ids = self.source.get_ancestry(revision_id)
1557
assert source_ids[0] == None
1560
source_ids = self.source.all_revision_ids()
1561
result_set = set(source_ids).difference(target_ids)
1562
# this may look like a no-op: its not. It preserves the ordering
1563
# other_ids had while only returning the members from other_ids
1564
# that we've decided we need.
1565
return [rev_id for rev_id in source_ids if rev_id in result_set]
1568
"""Release the locks on source and target."""
1570
self.target.unlock()
1572
self.source.unlock()
1575
class InterWeaveRepo(InterRepository):
1576
"""Optimised code paths between Weave based repositories."""
1578
_matching_repo_format = RepositoryFormat7()
1579
"""Repository format for testing with."""
1582
def is_compatible(source, target):
1583
"""Be compatible with known Weave formats.
1585
We dont test for the stores being of specific types becase that
1586
could lead to confusing results, and there is no need to be
1590
return (isinstance(source._format, (RepositoryFormat5,
1592
RepositoryFormat7)) and
1593
isinstance(target._format, (RepositoryFormat5,
1595
RepositoryFormat7)))
1596
except AttributeError:
1600
def copy_content(self, revision_id=None, basis=None):
1601
"""See InterRepository.copy_content()."""
1602
# weave specific optimised path:
1603
if basis is not None:
1604
# copy the basis in, then fetch remaining data.
1605
basis.copy_content_into(self.target, revision_id)
1606
# the basis copy_content_into could misset this.
1608
self.target.set_make_working_trees(self.source.make_working_trees())
1609
except NotImplementedError:
1611
self.target.fetch(self.source, revision_id=revision_id)
1614
self.target.set_make_working_trees(self.source.make_working_trees())
1615
except NotImplementedError:
1617
# FIXME do not peek!
1618
if self.source.control_files._transport.listable():
1619
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1621
self.target.weave_store.copy_all_ids(
1622
self.source.weave_store,
1624
from_transaction=self.source.get_transaction(),
1625
to_transaction=self.target.get_transaction())
1626
pb.update('copying inventory', 0, 1)
1627
self.target.control_weaves.copy_multi(
1628
self.source.control_weaves, ['inventory'],
1629
from_transaction=self.source.get_transaction(),
1630
to_transaction=self.target.get_transaction())
1631
self.target._revision_store.text_store.copy_all_ids(
1632
self.source._revision_store.text_store,
1637
self.target.fetch(self.source, revision_id=revision_id)
1640
def fetch(self, revision_id=None, pb=None):
1641
"""See InterRepository.fetch()."""
1642
from bzrlib.fetch import GenericRepoFetcher
1643
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1644
self.source, self.source._format, self.target, self.target._format)
1645
f = GenericRepoFetcher(to_repository=self.target,
1646
from_repository=self.source,
1647
last_revision=revision_id,
1649
return f.count_copied, f.failed_revisions
1652
def missing_revision_ids(self, revision_id=None):
1653
"""See InterRepository.missing_revision_ids()."""
1654
# we want all revisions to satisfy revision_id in source.
1655
# but we dont want to stat every file here and there.
1656
# we want then, all revisions other needs to satisfy revision_id
1657
# checked, but not those that we have locally.
1658
# so the first thing is to get a subset of the revisions to
1659
# satisfy revision_id in source, and then eliminate those that
1660
# we do already have.
1661
# this is slow on high latency connection to self, but as as this
1662
# disk format scales terribly for push anyway due to rewriting
1663
# inventory.weave, this is considered acceptable.
1665
if revision_id is not None:
1666
source_ids = self.source.get_ancestry(revision_id)
1667
assert source_ids[0] == None
1670
source_ids = self.source._all_possible_ids()
1671
source_ids_set = set(source_ids)
1672
# source_ids is the worst possible case we may need to pull.
1673
# now we want to filter source_ids against what we actually
1674
# have in target, but dont try to check for existence where we know
1675
# we do not have a revision as that would be pointless.
1676
target_ids = set(self.target._all_possible_ids())
1677
possibly_present_revisions = target_ids.intersection(source_ids_set)
1678
actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
1679
required_revisions = source_ids_set.difference(actually_present_revisions)
1680
required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
1681
if revision_id is not None:
1682
# we used get_ancestry to determine source_ids then we are assured all
1683
# revisions referenced are present as they are installed in topological order.
1684
# and the tip revision was validated by get_ancestry.
1685
return required_topo_revisions
1687
# if we just grabbed the possibly available ids, then
1688
# we only have an estimate of whats available and need to validate
1689
# that against the revision records.
1690
return self.source._eliminate_revisions_not_present(required_topo_revisions)
1693
class InterKnitRepo(InterRepository):
1694
"""Optimised code paths between Knit based repositories."""
1696
_matching_repo_format = RepositoryFormatKnit1()
1697
"""Repository format for testing with."""
1700
def is_compatible(source, target):
1701
"""Be compatible with known Knit formats.
1703
We dont test for the stores being of specific types becase that
1704
could lead to confusing results, and there is no need to be
1708
return (isinstance(source._format, (RepositoryFormatKnit1)) and
1709
isinstance(target._format, (RepositoryFormatKnit1)))
1710
except AttributeError:
1714
def fetch(self, revision_id=None, pb=None):
1715
"""See InterRepository.fetch()."""
1716
from bzrlib.fetch import KnitRepoFetcher
1717
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1718
self.source, self.source._format, self.target, self.target._format)
1719
f = KnitRepoFetcher(to_repository=self.target,
1720
from_repository=self.source,
1721
last_revision=revision_id,
1723
return f.count_copied, f.failed_revisions
1726
def missing_revision_ids(self, revision_id=None):
1727
"""See InterRepository.missing_revision_ids()."""
1728
if revision_id is not None:
1729
source_ids = self.source.get_ancestry(revision_id)
1730
assert source_ids[0] == None
1733
source_ids = self.source._all_possible_ids()
1734
source_ids_set = set(source_ids)
1735
# source_ids is the worst possible case we may need to pull.
1736
# now we want to filter source_ids against what we actually
1737
# have in target, but dont try to check for existence where we know
1738
# we do not have a revision as that would be pointless.
1739
target_ids = set(self.target._all_possible_ids())
1740
possibly_present_revisions = target_ids.intersection(source_ids_set)
1741
actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
1742
required_revisions = source_ids_set.difference(actually_present_revisions)
1743
required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
1744
if revision_id is not None:
1745
# we used get_ancestry to determine source_ids then we are assured all
1746
# revisions referenced are present as they are installed in topological order.
1747
# and the tip revision was validated by get_ancestry.
1748
return required_topo_revisions
1750
# if we just grabbed the possibly available ids, then
1751
# we only have an estimate of whats available and need to validate
1752
# that against the revision records.
1753
return self.source._eliminate_revisions_not_present(required_topo_revisions)
1755
InterRepository.register_optimiser(InterWeaveRepo)
1756
InterRepository.register_optimiser(InterKnitRepo)
1759
class RepositoryTestProviderAdapter(object):
1760
"""A tool to generate a suite testing multiple repository formats at once.
1762
This is done by copying the test once for each transport and injecting
1763
the transport_server, transport_readonly_server, and bzrdir_format and
1764
repository_format classes into each copy. Each copy is also given a new id()
1765
to make it easy to identify.
1768
def __init__(self, transport_server, transport_readonly_server, formats):
1769
self._transport_server = transport_server
1770
self._transport_readonly_server = transport_readonly_server
1771
self._formats = formats
1773
def adapt(self, test):
1774
result = TestSuite()
1775
for repository_format, bzrdir_format in self._formats:
1776
new_test = deepcopy(test)
1777
new_test.transport_server = self._transport_server
1778
new_test.transport_readonly_server = self._transport_readonly_server
1779
new_test.bzrdir_format = bzrdir_format
1780
new_test.repository_format = repository_format
1781
def make_new_test_id():
1782
new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
1783
return lambda: new_id
1784
new_test.id = make_new_test_id()
1785
result.addTest(new_test)
1789
class InterRepositoryTestProviderAdapter(object):
1790
"""A tool to generate a suite testing multiple inter repository formats.
1792
This is done by copying the test once for each interrepo provider and injecting
1793
the transport_server, transport_readonly_server, repository_format and
1794
repository_to_format classes into each copy.
1795
Each copy is also given a new id() to make it easy to identify.
1798
def __init__(self, transport_server, transport_readonly_server, formats):
1799
self._transport_server = transport_server
1800
self._transport_readonly_server = transport_readonly_server
1801
self._formats = formats
1803
def adapt(self, test):
1804
result = TestSuite()
1805
for interrepo_class, repository_format, repository_format_to in self._formats:
1806
new_test = deepcopy(test)
1807
new_test.transport_server = self._transport_server
1808
new_test.transport_readonly_server = self._transport_readonly_server
1809
new_test.interrepo_class = interrepo_class
1810
new_test.repository_format = repository_format
1811
new_test.repository_format_to = repository_format_to
1812
def make_new_test_id():
1813
new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
1814
return lambda: new_id
1815
new_test.id = make_new_test_id()
1816
result.addTest(new_test)
1820
def default_test_list():
1821
"""Generate the default list of interrepo permutations to test."""
1823
# test the default InterRepository between format 6 and the current
1825
# XXX: robertc 20060220 reinstate this when there are two supported
1826
# formats which do not have an optimal code path between them.
1827
result.append((InterRepository,
1828
RepositoryFormat6(),
1829
RepositoryFormatKnit1()))
1830
for optimiser in InterRepository._optimisers:
1831
result.append((optimiser,
1832
optimiser._matching_repo_format,
1833
optimiser._matching_repo_format
1835
# if there are specific combinations we want to use, we can add them
1840
class CopyConverter(object):
1841
"""A repository conversion tool which just performs a copy of the content.
1843
This is slow but quite reliable.
1846
def __init__(self, target_format):
1847
"""Create a CopyConverter.
1849
:param target_format: The format the resulting repository should be.
1851
self.target_format = target_format
1853
def convert(self, repo, pb):
1854
"""Perform the conversion of to_convert, giving feedback via pb.
1856
:param to_convert: The disk object to convert.
1857
:param pb: a progress bar to use for progress information.
1862
# this is only useful with metadir layouts - separated repo content.
1863
# trigger an assertion if not such
1864
repo._format.get_format_string()
1865
self.repo_dir = repo.bzrdir
1866
self.step('Moving repository to repository.backup')
1867
self.repo_dir.transport.move('repository', 'repository.backup')
1868
backup_transport = self.repo_dir.transport.clone('repository.backup')
1869
self.source_repo = repo._format.open(self.repo_dir,
1871
_override_transport=backup_transport)
1872
self.step('Creating new repository')
1873
converted = self.target_format.initialize(self.repo_dir,
1874
self.source_repo.is_shared())
1875
converted.lock_write()
1877
self.step('Copying content into repository.')
1878
self.source_repo.copy_content_into(converted)
1881
self.step('Deleting old repository content.')
1882
self.repo_dir.transport.delete_tree('repository.backup')
1883
self.pb.note('repository converted')
1885
def step(self, message):
1886
"""Update the pb by a step."""
1888
self.pb.update(message, self.count, self.total)
1891
class CommitBuilder(object):
1892
"""Provides an interface to build up a commit.
1894
This allows describing a tree to be committed without needing to
1895
know the internals of the format of the repository.
1897
def __init__(self, repository, parents, config, timestamp=None,
1898
timezone=None, committer=None, revprops=None,
1900
"""Initiate a CommitBuilder.
1902
:param repository: Repository to commit to.
1903
:param parents: Revision ids of the parents of the new revision.
1904
:param config: Configuration to use.
1905
:param timestamp: Optional timestamp recorded for commit.
1906
:param timezone: Optional timezone for timestamp.
1907
:param committer: Optional committer to set for commit.
1908
:param revprops: Optional dictionary of revision properties.
1909
:param revision_id: Optional revision id.
1911
self._config = config
1913
if committer is None:
1914
self._committer = self._config.username()
1916
assert isinstance(committer, basestring), type(committer)
1917
self._committer = committer
1919
self.new_inventory = Inventory()
1920
self._new_revision_id = revision_id
1921
self.parents = parents
1922
self.repository = repository
1925
if revprops is not None:
1926
self._revprops.update(revprops)
1928
if timestamp is None:
1929
self._timestamp = time.time()
1931
self._timestamp = long(timestamp)
1933
if timezone is None:
1934
self._timezone = local_time_offset()
1936
self._timezone = int(timezone)
1938
self._generate_revision_if_needed()
1940
def commit(self, message):
1941
"""Make the actual commit.
1943
:return: The revision id of the recorded revision.
1945
rev = Revision(timestamp=self._timestamp,
1946
timezone=self._timezone,
1947
committer=self._committer,
1949
inventory_sha1=self.inv_sha1,
1950
revision_id=self._new_revision_id,
1951
properties=self._revprops)
1952
rev.parent_ids = self.parents
1953
self.repository.add_revision(self._new_revision_id, rev,
1954
self.new_inventory, self._config)
1955
return self._new_revision_id
1957
def finish_inventory(self):
1958
"""Tell the builder that the inventory is finished."""
1959
self.new_inventory.revision_id = self._new_revision_id
1960
self.inv_sha1 = self.repository.add_inventory(
1961
self._new_revision_id,
1966
def _gen_revision_id(self):
1967
"""Return new revision-id."""
1968
s = '%s-%s-' % (self._config.user_email(),
1969
compact_date(self._timestamp))
1970
s += hexlify(rand_bytes(8))
1973
def _generate_revision_if_needed(self):
1974
"""Create a revision id if None was supplied.
1976
If the repository can not support user-specified revision ids
1977
they should override this function and raise UnsupportedOperation
1978
if _new_revision_id is not None.
1980
:raises: UnsupportedOperation
1982
if self._new_revision_id is None:
1983
self._new_revision_id = self._gen_revision_id()
1985
def record_entry_contents(self, ie, parent_invs, path, tree):
1986
"""Record the content of ie from tree into the commit if needed.
1988
:param ie: An inventory entry present in the commit.
1989
:param parent_invs: The inventories of the parent revisions of the
1991
:param path: The path the entry is at in the tree.
1992
:param tree: The tree which contains this entry and should be used to
1995
self.new_inventory.add(ie)
1997
# ie.revision is always None if the InventoryEntry is considered
1998
# for committing. ie.snapshot will record the correct revision
1999
# which may be the sole parent if it is untouched.
2000
if ie.revision is not None:
2002
previous_entries = ie.find_previous_heads(
2004
self.repository.weave_store,
2005
self.repository.get_transaction())
2006
# we are creating a new revision for ie in the history store
2008
ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
2010
def modified_directory(self, file_id, file_parents):
2011
"""Record the presence of a symbolic link.
2013
:param file_id: The file_id of the link to record.
2014
:param file_parents: The per-file parent revision ids.
2016
self._add_text_to_weave(file_id, [], file_parents.keys())
2018
def modified_file_text(self, file_id, file_parents,
2019
get_content_byte_lines, text_sha1=None,
2021
"""Record the text of file file_id
2023
:param file_id: The file_id of the file to record the text of.
2024
:param file_parents: The per-file parent revision ids.
2025
:param get_content_byte_lines: A callable which will return the byte
2027
:param text_sha1: Optional SHA1 of the file contents.
2028
:param text_size: Optional size of the file contents.
2030
mutter('storing text of file {%s} in revision {%s} into %r',
2031
file_id, self._new_revision_id, self.repository.weave_store)
2032
# special case to avoid diffing on renames or
2034
if (len(file_parents) == 1
2035
and text_sha1 == file_parents.values()[0].text_sha1
2036
and text_size == file_parents.values()[0].text_size):
2037
previous_ie = file_parents.values()[0]
2038
versionedfile = self.repository.weave_store.get_weave(file_id,
2039
self.repository.get_transaction())
2040
versionedfile.clone_text(self._new_revision_id,
2041
previous_ie.revision, file_parents.keys())
2042
return text_sha1, text_size
2044
new_lines = get_content_byte_lines()
2045
# TODO: Rather than invoking sha_strings here, _add_text_to_weave
2046
# should return the SHA1 and size
2047
self._add_text_to_weave(file_id, new_lines, file_parents.keys())
2048
return bzrlib.osutils.sha_strings(new_lines), \
2049
sum(map(len, new_lines))
2051
def modified_link(self, file_id, file_parents, link_target):
2052
"""Record the presence of a symbolic link.
2054
:param file_id: The file_id of the link to record.
2055
:param file_parents: The per-file parent revision ids.
2056
:param link_target: Target location of this link.
2058
self._add_text_to_weave(file_id, [], file_parents.keys())
2060
def _add_text_to_weave(self, file_id, new_lines, parents):
2061
versionedfile = self.repository.weave_store.get_weave_or_empty(
2062
file_id, self.repository.get_transaction())
2063
versionedfile.add_lines(self._new_revision_id, parents, new_lines)
2064
versionedfile.clear_cache()
2067
# Copied from xml.sax.saxutils
2068
def _unescape_xml(data):
2069
"""Unescape &, <, and > in a string of data.
2071
data = data.replace("<", "<")
2072
data = data.replace(">", ">")
2073
# must do ampersand last
2074
return data.replace("&", "&")
added
removed
bzrlib/repository.py
