« back to all changes in this revision
Viewing changes to bzrlib/repository.py
- browse files at revision 3458
- compare with another revision
- download diff
- download tarball
- view history from revision 3458
- Committer: Canonical.com Patch Queue Manager
- Date: 2008-05-29 15:57:16 UTC
- mfrom: (3427.5.9 dep_warnings)
- Revision ID: pqm@pqm.ubuntu.com-20080529155716-0w3kic8lioa63231
(jam) Enable Deprecation Warnings when running -Werror and when
running selftest
running selftest
- files added:
- COPYING.txt
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/serializer
- bzrlib/help_topics
- bzrlib/help_topics/en
- bzrlib/plugins/launchpad
- bzrlib/repofmt
- bzrlib/smart
- bzrlib/tests/commands
- bzrlib/tests/intertree_implementations
- bzrlib/tests/inventory_implementations
- bzrlib/tests/per_lock
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/util/tests
- bzrlib/version_info_formats
- doc/developers
- doc/en
- doc/en/admin-guide
- doc/en/developer-guide
- doc/en/mini-tutorial
- doc/en/quick-reference
- doc/en/release-notes
- doc/en/tutorials
- doc/en/user-guide
- doc/en/user-guide/images
- doc/en/user-reference
- doc/es
- doc/es/guia-desarrollador
- doc/es/guia-usuario
- doc/es/mini-tutorial
- doc/es/notas-version
- doc/es/referencia
- doc/es/referencia-rapida
- man1
- tools/win32
- files removed:
- NEWS.developers
- bzrlib/util/urlgrabber
- notes
- files renamed:
- bzrlib/graph.py => bzrlib/deprecated_graph.py
- bzrlib/tests/test_annotate.py => bzrlib/tests/blackbox/test_annotate.py
- bzrlib/tests/HTTPTestUtil.py => bzrlib/tests/http_utils.py
- bzrlib/tests/test_revprops.py => bzrlib/tests/repository_implementations/test_revision.py
- bzrlib/tests/test_command.py => bzrlib/tests/test_commands.py
- bzrlib/tests/test_graph.py => bzrlib/tests/test_deprecated_graph.py
- bzrlib/tests/test_revisionnamespaces.py => bzrlib/tests/test_revisionspec.py
- bzrlib/tests/test_basis_inventory.py => bzrlib/tests/workingtree_implementations/test_basis_inventory.py
- bzrlib/win32console.py => bzrlib/win32utils.py
- bzrlib/xml5.py => bzrlib/xml8.py
- HACKING => doc/developers/HACKING.txt
- tutorial.txt => doc/en/tutorials/tutorial.txt
- files modified:
- .bzrignore
added
removed
bzrlib/repository.py
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
from copy import deepcopy
18
17
from cStringIO import StringIO
19
from unittest import TestSuite
20
21
import bzrlib.bzrdir as bzrdir
18
19
from bzrlib.lazy_import import lazy_import
20
lazy_import(globals(), """
21
import re
22
import time
23
24
from bzrlib import (
25
bzrdir,
26
check,
27
debug,
28
errors,
29
generate_ids,
30
gpg,
31
graph,
32
lazy_regex,
33
lockable_files,
34
lockdir,
35
lru_cache,
36
osutils,
37
registry,
38
remote,
39
revision as _mod_revision,
40
symbol_versioning,
41
transactions,
42
tsort,
43
ui,
44
)
45
from bzrlib.bundle import serializer
46
from bzrlib.revisiontree import RevisionTree
47
from bzrlib.store.versioned import VersionedFileStore
48
from bzrlib.store.text import TextStore
49
from bzrlib.testament import Testament
50
from bzrlib.util import bencode
51
""")
52
22
53
from bzrlib.decorators import needs_read_lock, needs_write_lock
23
import bzrlib.errors as errors
24
from bzrlib.errors import InvalidRevisionId
25
import bzrlib.gpg as gpg
26
from bzrlib.graph import Graph
27
54
from bzrlib.inter import InterObject
28
from bzrlib.knit import KnitVersionedFile, KnitPlainFactory
29
from bzrlib.lockable_files import LockableFiles, TransportLock
30
from bzrlib.lockdir import LockDir
31
from bzrlib.osutils import safe_unicode
32
from bzrlib.revision import NULL_REVISION
33
from bzrlib.store.versioned import VersionedFileStore, WeaveStore
34
from bzrlib.store.text import TextStore
35
from bzrlib.symbol_versioning import *
36
from bzrlib.trace import mutter, note
37
from bzrlib.tree import RevisionTree
38
from bzrlib.tsort import topo_sort
39
from bzrlib.testament import Testament
40
from bzrlib.tree import EmptyTree
41
import bzrlib.ui
42
from bzrlib.weave import WeaveFile
43
import bzrlib.xml5
44
55
from bzrlib.inventory import Inventory, InventoryDirectory, ROOT_ID
56
from bzrlib.symbol_versioning import (
57
deprecated_method,
58
)
59
from bzrlib.trace import mutter, mutter_callsite, note, warning
60
61
62
# Old formats display a warning, but only once
63
_deprecation_warning_done = False
64
65
66
class CommitBuilder(object):
67
"""Provides an interface to build up a commit.
68
69
This allows describing a tree to be committed without needing to
70
know the internals of the format of the repository.
71
"""
72
73
# all clients should supply tree roots.
74
record_root_entry = True
75
# the default CommitBuilder does not manage trees whose root is versioned.
76
_versioned_root = False
77
78
def __init__(self, repository, parents, config, timestamp=None,
79
timezone=None, committer=None, revprops=None,
80
revision_id=None):
81
"""Initiate a CommitBuilder.
82
83
:param repository: Repository to commit to.
84
:param parents: Revision ids of the parents of the new revision.
85
:param config: Configuration to use.
86
:param timestamp: Optional timestamp recorded for commit.
87
:param timezone: Optional timezone for timestamp.
88
:param committer: Optional committer to set for commit.
89
:param revprops: Optional dictionary of revision properties.
90
:param revision_id: Optional revision id.
91
"""
92
self._config = config
93
94
if committer is None:
95
self._committer = self._config.username()
96
else:
97
self._committer = committer
98
99
self.new_inventory = Inventory(None)
100
self._new_revision_id = revision_id
101
self.parents = parents
102
self.repository = repository
103
104
self._revprops = {}
105
if revprops is not None:
106
self._revprops.update(revprops)
107
108
if timestamp is None:
109
timestamp = time.time()
110
# Restrict resolution to 1ms
111
self._timestamp = round(timestamp, 3)
112
113
if timezone is None:
114
self._timezone = osutils.local_time_offset()
115
else:
116
self._timezone = int(timezone)
117
118
self._generate_revision_if_needed()
119
self.__heads = graph.HeadsCache(repository.get_graph()).heads
120
121
def commit(self, message):
122
"""Make the actual commit.
123
124
:return: The revision id of the recorded revision.
125
"""
126
rev = _mod_revision.Revision(
127
timestamp=self._timestamp,
128
timezone=self._timezone,
129
committer=self._committer,
130
message=message,
131
inventory_sha1=self.inv_sha1,
132
revision_id=self._new_revision_id,
133
properties=self._revprops)
134
rev.parent_ids = self.parents
135
self.repository.add_revision(self._new_revision_id, rev,
136
self.new_inventory, self._config)
137
self.repository.commit_write_group()
138
return self._new_revision_id
139
140
def abort(self):
141
"""Abort the commit that is being built.
142
"""
143
self.repository.abort_write_group()
144
145
def revision_tree(self):
146
"""Return the tree that was just committed.
147
148
After calling commit() this can be called to get a RevisionTree
149
representing the newly committed tree. This is preferred to
150
calling Repository.revision_tree() because that may require
151
deserializing the inventory, while we already have a copy in
152
memory.
153
"""
154
return RevisionTree(self.repository, self.new_inventory,
155
self._new_revision_id)
156
157
def finish_inventory(self):
158
"""Tell the builder that the inventory is finished."""
159
if self.new_inventory.root is None:
160
raise AssertionError('Root entry should be supplied to'
161
' record_entry_contents, as of bzr 0.10.',
162
DeprecationWarning, stacklevel=2)
163
self.new_inventory.add(InventoryDirectory(ROOT_ID, '', None))
164
self.new_inventory.revision_id = self._new_revision_id
165
self.inv_sha1 = self.repository.add_inventory(
166
self._new_revision_id,
167
self.new_inventory,
168
self.parents
169
)
170
171
def _gen_revision_id(self):
172
"""Return new revision-id."""
173
return generate_ids.gen_revision_id(self._config.username(),
174
self._timestamp)
175
176
def _generate_revision_if_needed(self):
177
"""Create a revision id if None was supplied.
178
179
If the repository can not support user-specified revision ids
180
they should override this function and raise CannotSetRevisionId
181
if _new_revision_id is not None.
182
183
:raises: CannotSetRevisionId
184
"""
185
if self._new_revision_id is None:
186
self._new_revision_id = self._gen_revision_id()
187
self.random_revid = True
188
else:
189
self.random_revid = False
190
191
def _heads(self, file_id, revision_ids):
192
"""Calculate the graph heads for revision_ids in the graph of file_id.
193
194
This can use either a per-file graph or a global revision graph as we
195
have an identity relationship between the two graphs.
196
"""
197
return self.__heads(revision_ids)
198
199
def _check_root(self, ie, parent_invs, tree):
200
"""Helper for record_entry_contents.
201
202
:param ie: An entry being added.
203
:param parent_invs: The inventories of the parent revisions of the
204
commit.
205
:param tree: The tree that is being committed.
206
"""
207
# In this revision format, root entries have no knit or weave When
208
# serializing out to disk and back in root.revision is always
209
# _new_revision_id
210
ie.revision = self._new_revision_id
211
212
def _get_delta(self, ie, basis_inv, path):
213
"""Get a delta against the basis inventory for ie."""
214
if ie.file_id not in basis_inv:
215
# add
216
return (None, path, ie.file_id, ie)
217
elif ie != basis_inv[ie.file_id]:
218
# common but altered
219
# TODO: avoid tis id2path call.
220
return (basis_inv.id2path(ie.file_id), path, ie.file_id, ie)
221
else:
222
# common, unaltered
223
return None
224
225
def record_entry_contents(self, ie, parent_invs, path, tree,
226
content_summary):
227
"""Record the content of ie from tree into the commit if needed.
228
229
Side effect: sets ie.revision when unchanged
230
231
:param ie: An inventory entry present in the commit.
232
:param parent_invs: The inventories of the parent revisions of the
233
commit.
234
:param path: The path the entry is at in the tree.
235
:param tree: The tree which contains this entry and should be used to
236
obtain content.
237
:param content_summary: Summary data from the tree about the paths
238
content - stat, length, exec, sha/link target. This is only
239
accessed when the entry has a revision of None - that is when it is
240
a candidate to commit.
241
:return: A tuple (change_delta, version_recorded). change_delta is
242
an inventory_delta change for this entry against the basis tree of
243
the commit, or None if no change occured against the basis tree.
244
version_recorded is True if a new version of the entry has been
245
recorded. For instance, committing a merge where a file was only
246
changed on the other side will return (delta, False).
247
"""
248
if self.new_inventory.root is None:
249
if ie.parent_id is not None:
250
raise errors.RootMissing()
251
self._check_root(ie, parent_invs, tree)
252
if ie.revision is None:
253
kind = content_summary[0]
254
else:
255
# ie is carried over from a prior commit
256
kind = ie.kind
257
# XXX: repository specific check for nested tree support goes here - if
258
# the repo doesn't want nested trees we skip it ?
259
if (kind == 'tree-reference' and
260
not self.repository._format.supports_tree_reference):
261
# mismatch between commit builder logic and repository:
262
# this needs the entry creation pushed down into the builder.
263
raise NotImplementedError('Missing repository subtree support.')
264
self.new_inventory.add(ie)
265
266
# TODO: slow, take it out of the inner loop.
267
try:
268
basis_inv = parent_invs[0]
269
except IndexError:
270
basis_inv = Inventory(root_id=None)
271
272
# ie.revision is always None if the InventoryEntry is considered
273
# for committing. We may record the previous parents revision if the
274
# content is actually unchanged against a sole head.
275
if ie.revision is not None:
276
if not self._versioned_root and path == '':
277
# repositories that do not version the root set the root's
278
# revision to the new commit even when no change occurs, and
279
# this masks when a change may have occurred against the basis,
280
# so calculate if one happened.
281
if ie.file_id in basis_inv:
282
delta = (basis_inv.id2path(ie.file_id), path,
283
ie.file_id, ie)
284
else:
285
# add
286
delta = (None, path, ie.file_id, ie)
287
return delta, False
288
else:
289
# we don't need to commit this, because the caller already
290
# determined that an existing revision of this file is
291
# appropriate.
292
return None, (ie.revision == self._new_revision_id)
293
# XXX: Friction: parent_candidates should return a list not a dict
294
# so that we don't have to walk the inventories again.
295
parent_candiate_entries = ie.parent_candidates(parent_invs)
296
head_set = self._heads(ie.file_id, parent_candiate_entries.keys())
297
heads = []
298
for inv in parent_invs:
299
if ie.file_id in inv:
300
old_rev = inv[ie.file_id].revision
301
if old_rev in head_set:
302
heads.append(inv[ie.file_id].revision)
303
head_set.remove(inv[ie.file_id].revision)
304
305
store = False
306
# now we check to see if we need to write a new record to the
307
# file-graph.
308
# We write a new entry unless there is one head to the ancestors, and
309
# the kind-derived content is unchanged.
310
311
# Cheapest check first: no ancestors, or more the one head in the
312
# ancestors, we write a new node.
313
if len(heads) != 1:
314
store = True
315
if not store:
316
# There is a single head, look it up for comparison
317
parent_entry = parent_candiate_entries[heads[0]]
318
# if the non-content specific data has changed, we'll be writing a
319
# node:
320
if (parent_entry.parent_id != ie.parent_id or
321
parent_entry.name != ie.name):
322
store = True
323
# now we need to do content specific checks:
324
if not store:
325
# if the kind changed the content obviously has
326
if kind != parent_entry.kind:
327
store = True
328
if kind == 'file':
329
if content_summary[2] is None:
330
raise ValueError("Files must not have executable = None")
331
if not store:
332
if (# if the file length changed we have to store:
333
parent_entry.text_size != content_summary[1] or
334
# if the exec bit has changed we have to store:
335
parent_entry.executable != content_summary[2]):
336
store = True
337
elif parent_entry.text_sha1 == content_summary[3]:
338
# all meta and content is unchanged (using a hash cache
339
# hit to check the sha)
340
ie.revision = parent_entry.revision
341
ie.text_size = parent_entry.text_size
342
ie.text_sha1 = parent_entry.text_sha1
343
ie.executable = parent_entry.executable
344
return self._get_delta(ie, basis_inv, path), False
345
else:
346
# Either there is only a hash change(no hash cache entry,
347
# or same size content change), or there is no change on
348
# this file at all.
349
# Provide the parent's hash to the store layer, so that the
350
# content is unchanged we will not store a new node.
351
nostore_sha = parent_entry.text_sha1
352
if store:
353
# We want to record a new node regardless of the presence or
354
# absence of a content change in the file.
355
nostore_sha = None
356
ie.executable = content_summary[2]
357
lines = tree.get_file(ie.file_id, path).readlines()
358
try:
359
ie.text_sha1, ie.text_size = self._add_text_to_weave(
360
ie.file_id, lines, heads, nostore_sha)
361
except errors.ExistingContent:
362
# Turns out that the file content was unchanged, and we were
363
# only going to store a new node if it was changed. Carry over
364
# the entry.
365
ie.revision = parent_entry.revision
366
ie.text_size = parent_entry.text_size
367
ie.text_sha1 = parent_entry.text_sha1
368
ie.executable = parent_entry.executable
369
return self._get_delta(ie, basis_inv, path), False
370
elif kind == 'directory':
371
if not store:
372
# all data is meta here, nothing specific to directory, so
373
# carry over:
374
ie.revision = parent_entry.revision
375
return self._get_delta(ie, basis_inv, path), False
376
lines = []
377
self._add_text_to_weave(ie.file_id, lines, heads, None)
378
elif kind == 'symlink':
379
current_link_target = content_summary[3]
380
if not store:
381
# symlink target is not generic metadata, check if it has
382
# changed.
383
if current_link_target != parent_entry.symlink_target:
384
store = True
385
if not store:
386
# unchanged, carry over.
387
ie.revision = parent_entry.revision
388
ie.symlink_target = parent_entry.symlink_target
389
return self._get_delta(ie, basis_inv, path), False
390
ie.symlink_target = current_link_target
391
lines = []
392
self._add_text_to_weave(ie.file_id, lines, heads, None)
393
elif kind == 'tree-reference':
394
if not store:
395
if content_summary[3] != parent_entry.reference_revision:
396
store = True
397
if not store:
398
# unchanged, carry over.
399
ie.reference_revision = parent_entry.reference_revision
400
ie.revision = parent_entry.revision
401
return self._get_delta(ie, basis_inv, path), False
402
ie.reference_revision = content_summary[3]
403
lines = []
404
self._add_text_to_weave(ie.file_id, lines, heads, None)
405
else:
406
raise NotImplementedError('unknown kind')
407
ie.revision = self._new_revision_id
408
return self._get_delta(ie, basis_inv, path), True
409
410
def _add_text_to_weave(self, file_id, new_lines, parents, nostore_sha):
411
versionedfile = self.repository.weave_store.get_weave_or_empty(
412
file_id, self.repository.get_transaction())
413
# Don't change this to add_lines - add_lines_with_ghosts is cheaper
414
# than add_lines, and allows committing when a parent is ghosted for
415
# some reason.
416
# Note: as we read the content directly from the tree, we know its not
417
# been turned into unicode or badly split - but a broken tree
418
# implementation could give us bad output from readlines() so this is
419
# not a guarantee of safety. What would be better is always checking
420
# the content during test suite execution. RBC 20070912
421
return versionedfile.add_lines_with_ghosts(
422
self._new_revision_id, parents, new_lines,
423
nostore_sha=nostore_sha, random_id=self.random_revid,
424
check_content=False)[0:2]
425
426
427
class RootCommitBuilder(CommitBuilder):
428
"""This commitbuilder actually records the root id"""
429
430
# the root entry gets versioned properly by this builder.
431
_versioned_root = True
432
433
def _check_root(self, ie, parent_invs, tree):
434
"""Helper for record_entry_contents.
435
436
:param ie: An entry being added.
437
:param parent_invs: The inventories of the parent revisions of the
438
commit.
439
:param tree: The tree that is being committed.
440
"""
441
442
443
######################################################################
444
# Repositories
45
445
46
446
class Repository(object):
47
447
"""Repository holding history for one or more branches.
53
453
The Repository builds on top of Stores and a Transport, which respectively
54
454
describe the disk data format and the way of accessing the (possibly
55
455
remote) disk.
456
457
:ivar _transport: Transport for file access to repository, typically
458
pointing to .bzr/repository.
56
459
"""
57
460
58
@needs_write_lock
59
def add_inventory(self, revid, inv, parents):
60
"""Add the inventory inv to the repository as revid.
61
62
:param parents: The revision ids of the parents that revid
461
# What class to use for a CommitBuilder. Often its simpler to change this
462
# in a Repository class subclass rather than to override
463
# get_commit_builder.
464
_commit_builder_class = CommitBuilder
465
# The search regex used by xml based repositories to determine what things
466
# where changed in a single commit.
467
_file_ids_altered_regex = lazy_regex.lazy_compile(
468
r'file_id="(?P<file_id>[^"]+)"'
469
r'.* revision="(?P<revision_id>[^"]+)"'
470
)
471
472
def abort_write_group(self):
473
"""Commit the contents accrued within the current write group.
474
475
:seealso: start_write_group.
476
"""
477
if self._write_group is not self.get_transaction():
478
# has an unlock or relock occured ?
479
raise errors.BzrError('mismatched lock context and write group.')
480
self._abort_write_group()
481
self._write_group = None
482
483
def _abort_write_group(self):
484
"""Template method for per-repository write group cleanup.
485
486
This is called during abort before the write group is considered to be
487
finished and should cleanup any internal state accrued during the write
488
group. There is no requirement that data handed to the repository be
489
*not* made available - this is not a rollback - but neither should any
490
attempt be made to ensure that data added is fully commited. Abort is
491
invoked when an error has occured so futher disk or network operations
492
may not be possible or may error and if possible should not be
493
attempted.
494
"""
495
496
def add_inventory(self, revision_id, inv, parents):
497
"""Add the inventory inv to the repository as revision_id.
498
499
:param parents: The revision ids of the parents that revision_id
63
500
is known to have and are in the repository already.
64
501
65
returns the sha1 of the serialized inventory.
502
:returns: The validator(which is a sha1 digest, though what is sha'd is
503
repository format specific) of the serialized inventory.
66
504
"""
67
inv_text = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
68
inv_sha1 = bzrlib.osutils.sha_string(inv_text)
69
inv_vf = self.control_weaves.get_weave('inventory',
70
self.get_transaction())
71
inv_vf.add_lines(revid, parents, bzrlib.osutils.split_lines(inv_text))
72
return inv_sha1
73
74
@needs_write_lock
75
def add_revision(self, rev_id, rev, inv=None, config=None):
76
"""Add rev to the revision store as rev_id.
77
78
:param rev_id: the revision id to use.
505
if not self.is_in_write_group():
506
raise AssertionError("%r not in write group" % (self,))
507
_mod_revision.check_not_reserved_id(revision_id)
508
if not (inv.revision_id is None or inv.revision_id == revision_id):
509
raise AssertionError(
510
"Mismatch between inventory revision"
511
" id and insertion revid (%r, %r)"
512
% (inv.revision_id, revision_id))
513
if inv.root is None:
514
raise AssertionError()
515
inv_lines = self._serialise_inventory_to_lines(inv)
516
inv_vf = self.get_inventory_weave()
517
return self._inventory_add_lines(inv_vf, revision_id, parents,
518
inv_lines, check_content=False)
519
520
def _inventory_add_lines(self, inv_vf, revision_id, parents, lines,
521
check_content=True):
522
"""Store lines in inv_vf and return the sha1 of the inventory."""
523
final_parents = []
524
for parent in parents:
525
if parent in inv_vf:
526
final_parents.append(parent)
527
return inv_vf.add_lines(revision_id, final_parents, lines,
528
check_content=check_content)[0]
529
530
def add_revision(self, revision_id, rev, inv=None, config=None):
531
"""Add rev to the revision store as revision_id.
532
533
:param revision_id: the revision id to use.
79
534
:param rev: The revision object.
80
535
:param inv: The inventory for the revision. if None, it will be looked
81
536
up in the inventory storer
83
538
If supplied its signature_needed method will be used
84
539
to determine if a signature should be made.
85
540
"""
541
# TODO: jam 20070210 Shouldn't we check rev.revision_id and
542
# rev.parent_ids?
543
_mod_revision.check_not_reserved_id(revision_id)
86
544
if config is not None and config.signature_needed():
87
545
if inv is None:
88
inv = self.get_inventory(rev_id)
546
inv = self.get_inventory(revision_id)
89
547
plaintext = Testament(rev, inv).as_short_text()
90
548
self.store_revision_signature(
91
gpg.GPGStrategy(config), plaintext, rev_id)
92
if not rev_id in self.get_inventory_weave():
549
gpg.GPGStrategy(config), plaintext, revision_id)
550
inventory_vf = self.get_inventory_weave()
551
if not revision_id in inventory_vf:
93
552
if inv is None:
94
raise errors.WeaveRevisionNotPresent(rev_id,
95
self.get_inventory_weave())
553
raise errors.WeaveRevisionNotPresent(revision_id,
554
inventory_vf)
96
555
else:
97
556
# yes, this is not suitable for adding with ghosts.
98
self.add_inventory(rev_id, inv, rev.parent_ids)
557
rev.inventory_sha1 = self.add_inventory(revision_id, inv,
558
rev.parent_ids)
559
else:
560
rev.inventory_sha1 = inventory_vf.get_sha1s([revision_id])[0]
99
561
self._revision_store.add_revision(rev, self.get_transaction())
100
562
101
@needs_read_lock
102
def _all_possible_ids(self):
103
"""Return all the possible revisions that we could find."""
104
return self.get_inventory_weave().versions()
563
def _add_revision_text(self, revision_id, text):
564
revision = self._revision_store._serializer.read_revision_from_string(
565
text)
566
self._revision_store._add_revision(revision, StringIO(text),
567
self.get_transaction())
105
568
106
@needs_read_lock
107
569
def all_revision_ids(self):
108
570
"""Returns a list of all the revision ids in the repository.
109
571
572
This is deprecated because code should generally work on the graph
573
reachable from a particular revision, and ignore any other revisions
574
that might be present. There is no direct replacement method.
575
"""
576
if 'evil' in debug.debug_flags:
577
mutter_callsite(2, "all_revision_ids is linear with history.")
578
return self._all_revision_ids()
579
580
def _all_revision_ids(self):
581
"""Returns a list of all the revision ids in the repository.
582
110
583
These are in as much topological order as the underlying store can
111
present: for weaves ghosts may lead to a lack of correctness until
112
the reweave updates the parents list.
113
"""
114
if self._revision_store.text_store.listable():
115
return self._revision_store.all_revision_ids(self.get_transaction())
116
result = self._all_possible_ids()
117
return self._eliminate_revisions_not_present(result)
584
present.
585
"""
586
raise NotImplementedError(self._all_revision_ids)
587
588
def break_lock(self):
589
"""Break a lock if one is present from another instance.
590
591
Uses the ui factory to ask for confirmation if the lock may be from
592
an active process.
593
"""
594
self.control_files.break_lock()
118
595
119
596
@needs_read_lock
120
597
def _eliminate_revisions_not_present(self, revision_ids):
123
600
Returns a set of the present revisions.
124
601
"""
125
602
result = []
126
for id in revision_ids:
127
if self.has_revision(id):
128
result.append(id)
129
return result
603
graph = self.get_graph()
604
parent_map = graph.get_parent_map(revision_ids)
605
# The old API returned a list, should this actually be a set?
606
return parent_map.keys()
130
607
131
608
@staticmethod
132
609
def create(a_bzrdir):
133
610
"""Construct the current default format repository in a_bzrdir."""
134
611
return RepositoryFormat.get_default_format().initialize(a_bzrdir)
135
612
136
def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
613
def __init__(self, _format, a_bzrdir, control_files,
614
_revision_store, control_store, text_store):
137
615
"""instantiate a Repository.
138
616
139
617
:param _format: The format of the repository on disk.
148
626
# the following are part of the public API for Repository:
149
627
self.bzrdir = a_bzrdir
150
628
self.control_files = control_files
629
self._transport = control_files._transport
630
self.base = self._transport.base
151
631
self._revision_store = _revision_store
152
self.text_store = text_store
153
# backwards compatability
632
# backwards compatibility
154
633
self.weave_store = text_store
634
# for tests
635
self._reconcile_does_inventory_gc = True
636
self._reconcile_fixes_text_parents = False
637
self._reconcile_backsup_inventory = True
155
638
# not right yet - should be more semantically clear ?
156
639
#
157
640
self.control_store = control_store
158
641
self.control_weaves = control_store
159
642
# TODO: make sure to construct the right store classes, etc, depending
160
643
# on whether escaping is required.
161
162
def lock_write(self):
163
self.control_files.lock_write()
164
165
def lock_read(self):
166
self.control_files.lock_read()
644
self._warn_if_deprecated()
645
self._write_group = None
646
647
def __repr__(self):
648
return '%s(%r)' % (self.__class__.__name__,
649
self.base)
650
651
def has_same_location(self, other):
652
"""Returns a boolean indicating if this repository is at the same
653
location as another repository.
654
655
This might return False even when two repository objects are accessing
656
the same physical repository via different URLs.
657
"""
658
if self.__class__ is not other.__class__:
659
return False
660
return (self._transport.base == other._transport.base)
661
662
def is_in_write_group(self):
663
"""Return True if there is an open write group.
664
665
:seealso: start_write_group.
666
"""
667
return self._write_group is not None
167
668
168
669
def is_locked(self):
169
670
return self.control_files.is_locked()
170
671
171
@needs_read_lock
172
def missing_revision_ids(self, other, revision_id=None):
173
"""Return the revision ids that other has that this does not.
174
175
These are returned in topological order.
176
177
revision_id: only return revision ids included by revision_id.
178
"""
179
return InterRepository.get(other, self).missing_revision_ids(revision_id)
672
def is_write_locked(self):
673
"""Return True if this object is write locked."""
674
return self.is_locked() and self.control_files._lock_mode == 'w'
675
676
def lock_write(self, token=None):
677
"""Lock this repository for writing.
678
679
This causes caching within the repository obejct to start accumlating
680
data during reads, and allows a 'write_group' to be obtained. Write
681
groups must be used for actual data insertion.
682
683
:param token: if this is already locked, then lock_write will fail
684
unless the token matches the existing lock.
685
:returns: a token if this instance supports tokens, otherwise None.
686
:raises TokenLockingNotSupported: when a token is given but this
687
instance doesn't support using token locks.
688
:raises MismatchedToken: if the specified token doesn't match the token
689
of the existing lock.
690
:seealso: start_write_group.
691
692
A token should be passed in if you know that you have locked the object
693
some other way, and need to synchronise this object's state with that
694
fact.
695
696
XXX: this docstring is duplicated in many places, e.g. lockable_files.py
697
"""
698
result = self.control_files.lock_write(token=token)
699
self._refresh_data()
700
return result
701
702
def lock_read(self):
703
self.control_files.lock_read()
704
self._refresh_data()
705
706
def get_physical_lock_status(self):
707
return self.control_files.get_physical_lock_status()
708
709
def leave_lock_in_place(self):
710
"""Tell this repository not to release the physical lock when this
711
object is unlocked.
712
713
If lock_write doesn't return a token, then this method is not supported.
714
"""
715
self.control_files.leave_in_place()
716
717
def dont_leave_lock_in_place(self):
718
"""Tell this repository to release the physical lock when this
719
object is unlocked, even if it didn't originally acquire it.
720
721
If lock_write doesn't return a token, then this method is not supported.
722
"""
723
self.control_files.dont_leave_in_place()
724
725
@needs_read_lock
726
def gather_stats(self, revid=None, committers=None):
727
"""Gather statistics from a revision id.
728
729
:param revid: The revision id to gather statistics from, if None, then
730
no revision specific statistics are gathered.
731
:param committers: Optional parameter controlling whether to grab
732
a count of committers from the revision specific statistics.
733
:return: A dictionary of statistics. Currently this contains:
734
committers: The number of committers if requested.
735
firstrev: A tuple with timestamp, timezone for the penultimate left
736
most ancestor of revid, if revid is not the NULL_REVISION.
737
latestrev: A tuple with timestamp, timezone for revid, if revid is
738
not the NULL_REVISION.
739
revisions: The total revision count in the repository.
740
size: An estimate disk size of the repository in bytes.
741
"""
742
result = {}
743
if revid and committers:
744
result['committers'] = 0
745
if revid and revid != _mod_revision.NULL_REVISION:
746
if committers:
747
all_committers = set()
748
revisions = self.get_ancestry(revid)
749
# pop the leading None
750
revisions.pop(0)
751
first_revision = None
752
if not committers:
753
# ignore the revisions in the middle - just grab first and last
754
revisions = revisions[0], revisions[-1]
755
for revision in self.get_revisions(revisions):
756
if not first_revision:
757
first_revision = revision
758
if committers:
759
all_committers.add(revision.committer)
760
last_revision = revision
761
if committers:
762
result['committers'] = len(all_committers)
763
result['firstrev'] = (first_revision.timestamp,
764
first_revision.timezone)
765
result['latestrev'] = (last_revision.timestamp,
766
last_revision.timezone)
767
768
# now gather global repository information
769
if self.bzrdir.root_transport.listable():
770
c, t = self._revision_store.total_size(self.get_transaction())
771
result['revisions'] = c
772
result['size'] = t
773
return result
774
775
def find_branches(self, using=False):
776
"""Find branches underneath this repository.
777
778
This will include branches inside other branches.
779
780
:param using: If True, list only branches using this repository.
781
"""
782
if using and not self.is_shared():
783
try:
784
return [self.bzrdir.open_branch()]
785
except errors.NotBranchError:
786
return []
787
class Evaluator(object):
788
789
def __init__(self):
790
self.first_call = True
791
792
def __call__(self, bzrdir):
793
# On the first call, the parameter is always the bzrdir
794
# containing the current repo.
795
if not self.first_call:
796
try:
797
repository = bzrdir.open_repository()
798
except errors.NoRepositoryPresent:
799
pass
800
else:
801
return False, (None, repository)
802
self.first_call = False
803
try:
804
value = (bzrdir.open_branch(), None)
805
except errors.NotBranchError:
806
value = (None, None)
807
return True, value
808
809
branches = []
810
for branch, repository in bzrdir.BzrDir.find_bzrdirs(
811
self.bzrdir.root_transport, evaluate=Evaluator()):
812
if branch is not None:
813
branches.append(branch)
814
if not using and repository is not None:
815
branches.extend(repository.find_branches())
816
return branches
817
818
def get_data_stream(self, revision_ids):
819
raise NotImplementedError(self.get_data_stream)
820
821
def get_data_stream_for_search(self, search_result):
822
"""Get a data stream that can be inserted to a repository.
823
824
:param search_result: A bzrlib.graph.SearchResult selecting the
825
revisions to get.
826
:return: A data stream that can be inserted into a repository using
827
insert_data_stream.
828
"""
829
raise NotImplementedError(self.get_data_stream_for_search)
830
831
def insert_data_stream(self, stream):
832
"""XXX What does this really do?
833
834
Is it a substitute for fetch?
835
Should it manage its own write group ?
836
"""
837
for item_key, bytes in stream:
838
if item_key[0] == 'file':
839
(file_id,) = item_key[1:]
840
knit = self.weave_store.get_weave_or_empty(
841
file_id, self.get_transaction())
842
elif item_key == ('inventory',):
843
knit = self.get_inventory_weave()
844
elif item_key == ('revisions',):
845
knit = self._revision_store.get_revision_file(
846
self.get_transaction())
847
elif item_key == ('signatures',):
848
knit = self._revision_store.get_signature_file(
849
self.get_transaction())
850
else:
851
raise errors.RepositoryDataStreamError(
852
"Unrecognised data stream key '%s'" % (item_key,))
853
decoded_list = bencode.bdecode(bytes)
854
format = decoded_list.pop(0)
855
data_list = []
856
knit_bytes = ''
857
for version, options, parents, some_bytes in decoded_list:
858
data_list.append((version, options, len(some_bytes), parents))
859
knit_bytes += some_bytes
860
buffer = StringIO(knit_bytes)
861
def reader_func(count):
862
if count is None:
863
return buffer.read()
864
else:
865
return buffer.read(count)
866
knit.insert_data_stream(
867
(format, data_list, reader_func))
868
869
@needs_read_lock
870
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
871
"""Return the revision ids that other has that this does not.
872
873
These are returned in topological order.
874
875
revision_id: only return revision ids included by revision_id.
876
"""
877
return InterRepository.get(other, self).search_missing_revision_ids(
878
revision_id, find_ghosts)
879
880
@deprecated_method(symbol_versioning.one_two)
881
@needs_read_lock
882
def missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
883
"""Return the revision ids that other has that this does not.
884
885
These are returned in topological order.
886
887
revision_id: only return revision ids included by revision_id.
888
"""
889
keys = self.search_missing_revision_ids(
890
other, revision_id, find_ghosts).get_keys()
891
other.lock_read()
892
try:
893
parents = other.get_graph().get_parent_map(keys)
894
finally:
895
other.unlock()
896
return tsort.topo_sort(parents)
180
897
181
898
@staticmethod
182
899
def open(base):
185
902
For instance, if the repository is at URL/.bzr/repository,
186
903
Repository.open(URL) -> a Repository instance.
187
904
"""
188
control = bzrlib.bzrdir.BzrDir.open(base)
905
control = bzrdir.BzrDir.open(base)
189
906
return control.open_repository()
190
907
191
def copy_content_into(self, destination, revision_id=None, basis=None):
908
def copy_content_into(self, destination, revision_id=None):
192
909
"""Make a complete copy of the content in self into destination.
193
910
194
911
This is a destructive operation! Do not use it on existing
195
912
repositories.
196
913
"""
197
return InterRepository.get(self, destination).copy_content(revision_id, basis)
198
199
def fetch(self, source, revision_id=None, pb=None):
914
return InterRepository.get(self, destination).copy_content(revision_id)
915
916
def commit_write_group(self):
917
"""Commit the contents accrued within the current write group.
918
919
:seealso: start_write_group.
920
"""
921
if self._write_group is not self.get_transaction():
922
# has an unlock or relock occured ?
923
raise errors.BzrError('mismatched lock context %r and '
924
'write group %r.' %
925
(self.get_transaction(), self._write_group))
926
self._commit_write_group()
927
self._write_group = None
928
929
def _commit_write_group(self):
930
"""Template method for per-repository write group cleanup.
931
932
This is called before the write group is considered to be
933
finished and should ensure that all data handed to the repository
934
for writing during the write group is safely committed (to the
935
extent possible considering file system caching etc).
936
"""
937
938
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False):
200
939
"""Fetch the content required to construct revision_id from source.
201
940
202
941
If revision_id is None all content is copied.
203
"""
204
return InterRepository.get(source, self).fetch(revision_id=revision_id,
205
pb=pb)
942
:param find_ghosts: Find and copy revisions in the source that are
943
ghosts in the target (and not reachable directly by walking out to
944
the first-present revision in target from revision_id).
945
"""
946
# fast path same-url fetch operations
947
if self.has_same_location(source):
948
# check that last_revision is in 'from' and then return a
949
# no-operation.
950
if (revision_id is not None and
951
not _mod_revision.is_null(revision_id)):
952
self.get_revision(revision_id)
953
return 0, []
954
inter = InterRepository.get(source, self)
955
try:
956
return inter.fetch(revision_id=revision_id, pb=pb, find_ghosts=find_ghosts)
957
except NotImplementedError:
958
raise errors.IncompatibleRepositories(source, self)
959
960
def create_bundle(self, target, base, fileobj, format=None):
961
return serializer.write_bundle(self, target, base, fileobj, format)
962
963
def get_commit_builder(self, branch, parents, config, timestamp=None,
964
timezone=None, committer=None, revprops=None,
965
revision_id=None):
966
"""Obtain a CommitBuilder for this repository.
967
968
:param branch: Branch to commit to.
969
:param parents: Revision ids of the parents of the new revision.
970
:param config: Configuration to use.
971
:param timestamp: Optional timestamp recorded for commit.
972
:param timezone: Optional timezone for timestamp.
973
:param committer: Optional committer to set for commit.
974
:param revprops: Optional dictionary of revision properties.
975
:param revision_id: Optional revision id.
976
"""
977
result = self._commit_builder_class(self, parents, config,
978
timestamp, timezone, committer, revprops, revision_id)
979
self.start_write_group()
980
return result
206
981
207
982
def unlock(self):
983
if (self.control_files._lock_count == 1 and
984
self.control_files._lock_mode == 'w'):
985
if self._write_group is not None:
986
self.abort_write_group()
987
self.control_files.unlock()
988
raise errors.BzrError(
989
'Must end write groups before releasing write locks.')
208
990
self.control_files.unlock()
209
991
210
992
@needs_read_lock
211
def clone(self, a_bzrdir, revision_id=None, basis=None):
993
def clone(self, a_bzrdir, revision_id=None):
212
994
"""Clone this repository into a_bzrdir using the current format.
213
995
214
996
Currently no check is made that the format of this repository and
215
997
the bzrdir format are compatible. FIXME RBC 20060201.
216
"""
998
999
:return: The newly created destination repository.
1000
"""
1001
# TODO: deprecate after 0.16; cloning this with all its settings is
1002
# probably not very useful -- mbp 20070423
1003
dest_repo = self._create_sprouting_repo(a_bzrdir, shared=self.is_shared())
1004
self.copy_content_into(dest_repo, revision_id)
1005
return dest_repo
1006
1007
def start_write_group(self):
1008
"""Start a write group in the repository.
1009
1010
Write groups are used by repositories which do not have a 1:1 mapping
1011
between file ids and backend store to manage the insertion of data from
1012
both fetch and commit operations.
1013
1014
A write lock is required around the start_write_group/commit_write_group
1015
for the support of lock-requiring repository formats.
1016
1017
One can only insert data into a repository inside a write group.
1018
1019
:return: None.
1020
"""
1021
if not self.is_write_locked():
1022
raise errors.NotWriteLocked(self)
1023
if self._write_group:
1024
raise errors.BzrError('already in a write group')
1025
self._start_write_group()
1026
# so we can detect unlock/relock - the write group is now entered.
1027
self._write_group = self.get_transaction()
1028
1029
def _start_write_group(self):
1030
"""Template method for per-repository write group startup.
1031
1032
This is called before the write group is considered to be
1033
entered.
1034
"""
1035
1036
@needs_read_lock
1037
def sprout(self, to_bzrdir, revision_id=None):
1038
"""Create a descendent repository for new development.
1039
1040
Unlike clone, this does not copy the settings of the repository.
1041
"""
1042
dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1043
dest_repo.fetch(self, revision_id=revision_id)
1044
return dest_repo
1045
1046
def _create_sprouting_repo(self, a_bzrdir, shared):
217
1047
if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
218
1048
# use target default format.
219
result = a_bzrdir.create_repository()
220
# FIXME RBC 20060209 split out the repository type to avoid this check ?
221
elif isinstance(a_bzrdir._format,
222
(bzrlib.bzrdir.BzrDirFormat4,
223
bzrlib.bzrdir.BzrDirFormat5,
224
bzrlib.bzrdir.BzrDirFormat6)):
225
result = a_bzrdir.open_repository()
1049
dest_repo = a_bzrdir.create_repository()
226
1050
else:
227
result = self._format.initialize(a_bzrdir, shared=self.is_shared())
228
self.copy_content_into(result, revision_id, basis)
229
return result
1051
# Most control formats need the repository to be specifically
1052
# created, but on some old all-in-one formats it's not needed
1053
try:
1054
dest_repo = self._format.initialize(a_bzrdir, shared=shared)
1055
except errors.UninitializableFormat:
1056
dest_repo = a_bzrdir.open_repository()
1057
return dest_repo
230
1058
231
1059
@needs_read_lock
232
1060
def has_revision(self, revision_id):
233
1061
"""True if this repository has a copy of the revision."""
1062
return revision_id in self.has_revisions((revision_id,))
1063
1064
def has_revisions(self, revision_ids):
1065
"""Probe to find out the presence of multiple revisions.
1066
1067
:param revision_ids: An iterable of revision_ids.
1068
:return: A set of the revision_ids that were present.
1069
"""
1070
raise NotImplementedError(self.has_revisions)
1071
234
1072
return self._revision_store.has_revision_id(revision_id,
235
1073
self.get_transaction())
236
1074
237
1075
@needs_read_lock
1076
def get_revision(self, revision_id):
1077
"""Return the Revision object for a named revision."""
1078
return self.get_revisions([revision_id])[0]
1079
1080
@needs_read_lock
238
1081
def get_revision_reconcile(self, revision_id):
239
1082
"""'reconcile' helper routine that allows access to a revision always.
240
1083
243
1086
be used by reconcile, or reconcile-alike commands that are correcting
244
1087
or testing the revision graph.
245
1088
"""
246
if not revision_id or not isinstance(revision_id, basestring):
247
raise InvalidRevisionId(revision_id=revision_id, branch=self)
248
return self._revision_store.get_revision(revision_id,
249
self.get_transaction())
1089
return self._get_revisions([revision_id])[0]
1090
1091
@needs_read_lock
1092
def get_revisions(self, revision_ids):
1093
"""Get many revisions at once."""
1094
return self._get_revisions(revision_ids)
1095
1096
@needs_read_lock
1097
def _get_revisions(self, revision_ids):
1098
"""Core work logic to get many revisions without sanity checks."""
1099
for rev_id in revision_ids:
1100
if not rev_id or not isinstance(rev_id, basestring):
1101
raise errors.InvalidRevisionId(revision_id=rev_id, branch=self)
1102
revs = self._revision_store.get_revisions(revision_ids,
1103
self.get_transaction())
1104
return revs
250
1105
251
1106
@needs_read_lock
252
1107
def get_revision_xml(self, revision_id):
253
rev = self.get_revision(revision_id)
1108
# TODO: jam 20070210 This shouldn't be necessary since get_revision
1109
# would have already do it.
1110
# TODO: jam 20070210 Just use _serializer.write_revision_to_string()
1111
rev = self.get_revision(revision_id)
254
1112
rev_tmp = StringIO()
255
1113
# the current serializer..
256
1114
self._revision_store._serializer.write_revision(rev, rev_tmp)
257
1115
rev_tmp.seek(0)
258
1116
return rev_tmp.getvalue()
259
1117
1118
def get_deltas_for_revisions(self, revisions):
1119
"""Produce a generator of revision deltas.
1120
1121
Note that the input is a sequence of REVISIONS, not revision_ids.
1122
Trees will be held in memory until the generator exits.
1123
Each delta is relative to the revision's lefthand predecessor.
1124
"""
1125
required_trees = set()
1126
for revision in revisions:
1127
required_trees.add(revision.revision_id)
1128
required_trees.update(revision.parent_ids[:1])
1129
trees = dict((t.get_revision_id(), t) for
1130
t in self.revision_trees(required_trees))
1131
for revision in revisions:
1132
if not revision.parent_ids:
1133
old_tree = self.revision_tree(None)
1134
else:
1135
old_tree = trees[revision.parent_ids[0]]
1136
yield trees[revision.revision_id].changes_from(old_tree)
1137
260
1138
@needs_read_lock
261
def get_revision(self, revision_id):
262
"""Return the Revision object for a named revision"""
263
r = self.get_revision_reconcile(revision_id)
264
# weave corruption can lead to absent revision markers that should be
265
# present.
266
# the following test is reasonably cheap (it needs a single weave read)
267
# and the weave is cached in read transactions. In write transactions
268
# it is not cached but typically we only read a small number of
269
# revisions. For knits when they are introduced we will probably want
270
# to ensure that caching write transactions are in use.
271
inv = self.get_inventory_weave()
272
self._check_revision_parents(r, inv)
273
return r
1139
def get_revision_delta(self, revision_id):
1140
"""Return the delta for one revision.
274
1141
275
def _check_revision_parents(self, revision, inventory):
276
"""Private to Repository and Fetch.
277
278
This checks the parentage of revision in an inventory weave for
279
consistency and is only applicable to inventory-weave-for-ancestry
280
using repository formats & fetchers.
1142
The delta is relative to the left-hand predecessor of the
1143
revision.
281
1144
"""
282
weave_parents = inventory.get_parents(revision.revision_id)
283
weave_names = inventory.versions()
284
for parent_id in revision.parent_ids:
285
if parent_id in weave_names:
286
# this parent must not be a ghost.
287
if not parent_id in weave_parents:
288
# but it is a ghost
289
raise errors.CorruptRepository(self)
1145
r = self.get_revision(revision_id)
1146
return list(self.get_deltas_for_revisions([r]))[0]
290
1147
291
1148
@needs_write_lock
292
1149
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
293
1150
signature = gpg_strategy.sign(plaintext)
1151
self.add_signature_text(revision_id, signature)
1152
1153
@needs_write_lock
1154
def add_signature_text(self, revision_id, signature):
294
1155
self._revision_store.add_revision_signature_text(revision_id,
295
1156
signature,
296
1157
self.get_transaction())
297
1158
298
def fileid_involved_between_revs(self, from_revid, to_revid):
299
"""Find file_id(s) which are involved in the changes between revisions.
300
301
This determines the set of revisions which are involved, and then
302
finds all file ids affected by those revisions.
303
"""
304
w = self.get_inventory_weave()
305
from_set = set(w.get_ancestry(from_revid))
306
to_set = set(w.get_ancestry(to_revid))
307
changed = to_set.difference(from_set)
308
return self._fileid_involved_by_set(changed)
309
310
def fileid_involved(self, last_revid=None):
311
"""Find all file_ids modified in the ancestry of last_revid.
312
313
:param last_revid: If None, last_revision() will be used.
314
"""
315
w = self.get_inventory_weave()
316
if not last_revid:
317
changed = set(w.versions())
318
else:
319
changed = set(w.get_ancestry(last_revid))
320
return self._fileid_involved_by_set(changed)
321
322
def fileid_involved_by_set(self, changes):
323
"""Find all file_ids modified by the set of revisions passed in.
324
325
:param changes: A set() of revision ids
326
"""
327
# TODO: jam 20060119 This line does *nothing*, remove it.
328
# or better yet, change _fileid_involved_by_set so
329
# that it takes the inventory weave, rather than
330
# pulling it out by itself.
331
return self._fileid_involved_by_set(changes)
332
333
def _fileid_involved_by_set(self, changes):
334
"""Find the set of file-ids affected by the set of revisions.
335
336
:param changes: A set() of revision ids.
337
:return: A set() of file ids.
338
339
This peaks at the Weave, interpreting each line, looking to
340
see if it mentions one of the revisions. And if so, includes
341
the file id mentioned.
342
This expects both the Weave format, and the serialization
343
to have a single line per file/directory, and to have
344
fileid="" and revision="" on that line.
345
"""
346
assert isinstance(self._format, (RepositoryFormat5,
347
RepositoryFormat6,
348
RepositoryFormat7,
349
RepositoryFormatKnit1)), \
350
"fileid_involved only supported for branches which store inventory as unnested xml"
351
352
w = self.get_inventory_weave()
353
file_ids = set()
354
355
# this code needs to read every line in every inventory for the
356
# inventories [changes]. Seeing a line twice is ok. Seeing a line
357
# not pesent in one of those inventories is unnecessary and not
1159
def find_text_key_references(self):
1160
"""Find the text key references within the repository.
1161
1162
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
1163
revision_ids. Each altered file-ids has the exact revision_ids that
1164
altered it listed explicitly.
1165
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
1166
to whether they were referred to by the inventory of the
1167
revision_id that they contain. The inventory texts from all present
1168
revision ids are assessed to generate this report.
1169
"""
1170
revision_ids = self.all_revision_ids()
1171
w = self.get_inventory_weave()
1172
pb = ui.ui_factory.nested_progress_bar()
1173
try:
1174
return self._find_text_key_references_from_xml_inventory_lines(
1175
w.iter_lines_added_or_present_in_versions(revision_ids, pb=pb))
1176
finally:
1177
pb.finished()
1178
1179
def _find_text_key_references_from_xml_inventory_lines(self,
1180
line_iterator):
1181
"""Core routine for extracting references to texts from inventories.
1182
1183
This performs the translation of xml lines to revision ids.
1184
1185
:param line_iterator: An iterator of lines, origin_version_id
1186
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
1187
to whether they were referred to by the inventory of the
1188
revision_id that they contain. Note that if that revision_id was
1189
not part of the line_iterator's output then False will be given -
1190
even though it may actually refer to that key.
1191
"""
1192
if not self._serializer.support_altered_by_hack:
1193
raise AssertionError(
1194
"_find_text_key_references_from_xml_inventory_lines only "
1195
"supported for branches which store inventory as unnested xml"
1196
", not on %r" % self)
1197
result = {}
1198
1199
# this code needs to read every new line in every inventory for the
1200
# inventories [revision_ids]. Seeing a line twice is ok. Seeing a line
1201
# not present in one of those inventories is unnecessary but not
358
1202
# harmful because we are filtering by the revision id marker in the
359
# inventory lines to only select file ids altered in one of those
360
# revisions. We dont need to see all lines in the inventory because
1203
# inventory lines : we only select file ids altered in one of those
1204
# revisions. We don't need to see all lines in the inventory because
361
1205
# only those added in an inventory in rev X can contain a revision=X
362
1206
# line.
363
for line in w.iter_lines_added_or_present_in_versions(changes):
364
start = line.find('file_id="')+9
365
if start < 9: continue
366
end = line.find('"', start)
367
assert end>= 0
368
file_id = _unescape_xml(line[start:end])
369
370
# check if file_id is already present
371
if file_id in file_ids: continue
372
373
start = line.find('revision="')+10
374
if start < 10: continue
375
end = line.find('"', start)
376
assert end>= 0
377
revision_id = _unescape_xml(line[start:end])
378
if revision_id in changes:
379
file_ids.add(file_id)
380
return file_ids
1207
unescape_revid_cache = {}
1208
unescape_fileid_cache = {}
1209
1210
# jam 20061218 In a big fetch, this handles hundreds of thousands
1211
# of lines, so it has had a lot of inlining and optimizing done.
1212
# Sorry that it is a little bit messy.
1213
# Move several functions to be local variables, since this is a long
1214
# running loop.
1215
search = self._file_ids_altered_regex.search
1216
unescape = _unescape_xml
1217
setdefault = result.setdefault
1218
for line, version_id in line_iterator:
1219
match = search(line)
1220
if match is None:
1221
continue
1222
# One call to match.group() returning multiple items is quite a
1223
# bit faster than 2 calls to match.group() each returning 1
1224
file_id, revision_id = match.group('file_id', 'revision_id')
1225
1226
# Inlining the cache lookups helps a lot when you make 170,000
1227
# lines and 350k ids, versus 8.4 unique ids.
1228
# Using a cache helps in 2 ways:
1229
# 1) Avoids unnecessary decoding calls
1230
# 2) Re-uses cached strings, which helps in future set and
1231
# equality checks.
1232
# (2) is enough that removing encoding entirely along with
1233
# the cache (so we are using plain strings) results in no
1234
# performance improvement.
1235
try:
1236
revision_id = unescape_revid_cache[revision_id]
1237
except KeyError:
1238
unescaped = unescape(revision_id)
1239
unescape_revid_cache[revision_id] = unescaped
1240
revision_id = unescaped
1241
1242
# Note that unconditionally unescaping means that we deserialise
1243
# every fileid, which for general 'pull' is not great, but we don't
1244
# really want to have some many fulltexts that this matters anyway.
1245
# RBC 20071114.
1246
try:
1247
file_id = unescape_fileid_cache[file_id]
1248
except KeyError:
1249
unescaped = unescape(file_id)
1250
unescape_fileid_cache[file_id] = unescaped
1251
file_id = unescaped
1252
1253
key = (file_id, revision_id)
1254
setdefault(key, False)
1255
if revision_id == version_id:
1256
result[key] = True
1257
return result
1258
1259
def _find_file_ids_from_xml_inventory_lines(self, line_iterator,
1260
revision_ids):
1261
"""Helper routine for fileids_altered_by_revision_ids.
1262
1263
This performs the translation of xml lines to revision ids.
1264
1265
:param line_iterator: An iterator of lines, origin_version_id
1266
:param revision_ids: The revision ids to filter for. This should be a
1267
set or other type which supports efficient __contains__ lookups, as
1268
the revision id from each parsed line will be looked up in the
1269
revision_ids filter.
1270
:return: a dictionary mapping altered file-ids to an iterable of
1271
revision_ids. Each altered file-ids has the exact revision_ids that
1272
altered it listed explicitly.
1273
"""
1274
result = {}
1275
setdefault = result.setdefault
1276
for file_id, revision_id in \
1277
self._find_text_key_references_from_xml_inventory_lines(
1278
line_iterator).iterkeys():
1279
# once data is all ensured-consistent; then this is
1280
# if revision_id == version_id
1281
if revision_id in revision_ids:
1282
setdefault(file_id, set()).add(revision_id)
1283
return result
1284
1285
def fileids_altered_by_revision_ids(self, revision_ids, _inv_weave=None):
1286
"""Find the file ids and versions affected by revisions.
1287
1288
:param revisions: an iterable containing revision ids.
1289
:param _inv_weave: The inventory weave from this repository or None.
1290
If None, the inventory weave will be opened automatically.
1291
:return: a dictionary mapping altered file-ids to an iterable of
1292
revision_ids. Each altered file-ids has the exact revision_ids that
1293
altered it listed explicitly.
1294
"""
1295
selected_revision_ids = set(revision_ids)
1296
w = _inv_weave or self.get_inventory_weave()
1297
pb = ui.ui_factory.nested_progress_bar()
1298
try:
1299
return self._find_file_ids_from_xml_inventory_lines(
1300
w.iter_lines_added_or_present_in_versions(
1301
selected_revision_ids, pb=pb),
1302
selected_revision_ids)
1303
finally:
1304
pb.finished()
1305
1306
def iter_files_bytes(self, desired_files):
1307
"""Iterate through file versions.
1308
1309
Files will not necessarily be returned in the order they occur in
1310
desired_files. No specific order is guaranteed.
1311
1312
Yields pairs of identifier, bytes_iterator. identifier is an opaque
1313
value supplied by the caller as part of desired_files. It should
1314
uniquely identify the file version in the caller's context. (Examples:
1315
an index number or a TreeTransform trans_id.)
1316
1317
bytes_iterator is an iterable of bytestrings for the file. The
1318
kind of iterable and length of the bytestrings are unspecified, but for
1319
this implementation, it is a list of lines produced by
1320
VersionedFile.get_lines().
1321
1322
:param desired_files: a list of (file_id, revision_id, identifier)
1323
triples
1324
"""
1325
transaction = self.get_transaction()
1326
for file_id, revision_id, callable_data in desired_files:
1327
try:
1328
weave = self.weave_store.get_weave(file_id, transaction)
1329
except errors.NoSuchFile:
1330
raise errors.NoSuchIdInRepository(self, file_id)
1331
yield callable_data, weave.get_lines(revision_id)
1332
1333
def _generate_text_key_index(self, text_key_references=None,
1334
ancestors=None):
1335
"""Generate a new text key index for the repository.
1336
1337
This is an expensive function that will take considerable time to run.
1338
1339
:return: A dict mapping text keys ((file_id, revision_id) tuples) to a
1340
list of parents, also text keys. When a given key has no parents,
1341
the parents list will be [NULL_REVISION].
1342
"""
1343
# All revisions, to find inventory parents.
1344
if ancestors is None:
1345
graph = self.get_graph()
1346
ancestors = graph.get_parent_map(self.all_revision_ids())
1347
if text_key_references is None:
1348
text_key_references = self.find_text_key_references()
1349
pb = ui.ui_factory.nested_progress_bar()
1350
try:
1351
return self._do_generate_text_key_index(ancestors,
1352
text_key_references, pb)
1353
finally:
1354
pb.finished()
1355
1356
def _do_generate_text_key_index(self, ancestors, text_key_references, pb):
1357
"""Helper for _generate_text_key_index to avoid deep nesting."""
1358
revision_order = tsort.topo_sort(ancestors)
1359
invalid_keys = set()
1360
revision_keys = {}
1361
for revision_id in revision_order:
1362
revision_keys[revision_id] = set()
1363
text_count = len(text_key_references)
1364
# a cache of the text keys to allow reuse; costs a dict of all the
1365
# keys, but saves a 2-tuple for every child of a given key.
1366
text_key_cache = {}
1367
for text_key, valid in text_key_references.iteritems():
1368
if not valid:
1369
invalid_keys.add(text_key)
1370
else:
1371
revision_keys[text_key[1]].add(text_key)
1372
text_key_cache[text_key] = text_key
1373
del text_key_references
1374
text_index = {}
1375
text_graph = graph.Graph(graph.DictParentsProvider(text_index))
1376
NULL_REVISION = _mod_revision.NULL_REVISION
1377
# Set a cache with a size of 10 - this suffices for bzr.dev but may be
1378
# too small for large or very branchy trees. However, for 55K path
1379
# trees, it would be easy to use too much memory trivially. Ideally we
1380
# could gauge this by looking at available real memory etc, but this is
1381
# always a tricky proposition.
1382
inventory_cache = lru_cache.LRUCache(10)
1383
batch_size = 10 # should be ~150MB on a 55K path tree
1384
batch_count = len(revision_order) / batch_size + 1
1385
processed_texts = 0
1386
pb.update("Calculating text parents.", processed_texts, text_count)
1387
for offset in xrange(batch_count):
1388
to_query = revision_order[offset * batch_size:(offset + 1) *
1389
batch_size]
1390
if not to_query:
1391
break
1392
for rev_tree in self.revision_trees(to_query):
1393
revision_id = rev_tree.get_revision_id()
1394
parent_ids = ancestors[revision_id]
1395
for text_key in revision_keys[revision_id]:
1396
pb.update("Calculating text parents.", processed_texts)
1397
processed_texts += 1
1398
candidate_parents = []
1399
for parent_id in parent_ids:
1400
parent_text_key = (text_key[0], parent_id)
1401
try:
1402
check_parent = parent_text_key not in \
1403
revision_keys[parent_id]
1404
except KeyError:
1405
# the parent parent_id is a ghost:
1406
check_parent = False
1407
# truncate the derived graph against this ghost.
1408
parent_text_key = None
1409
if check_parent:
1410
# look at the parent commit details inventories to
1411
# determine possible candidates in the per file graph.
1412
# TODO: cache here.
1413
try:
1414
inv = inventory_cache[parent_id]
1415
except KeyError:
1416
inv = self.revision_tree(parent_id).inventory
1417
inventory_cache[parent_id] = inv
1418
parent_entry = inv._byid.get(text_key[0], None)
1419
if parent_entry is not None:
1420
parent_text_key = (
1421
text_key[0], parent_entry.revision)
1422
else:
1423
parent_text_key = None
1424
if parent_text_key is not None:
1425
candidate_parents.append(
1426
text_key_cache[parent_text_key])
1427
parent_heads = text_graph.heads(candidate_parents)
1428
new_parents = list(parent_heads)
1429
new_parents.sort(key=lambda x:candidate_parents.index(x))
1430
if new_parents == []:
1431
new_parents = [NULL_REVISION]
1432
text_index[text_key] = new_parents
1433
1434
for text_key in invalid_keys:
1435
text_index[text_key] = [NULL_REVISION]
1436
return text_index
1437
1438
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1439
"""Get an iterable listing the keys of all the data introduced by a set
1440
of revision IDs.
1441
1442
The keys will be ordered so that the corresponding items can be safely
1443
fetched and inserted in that order.
1444
1445
:returns: An iterable producing tuples of (knit-kind, file-id,
1446
versions). knit-kind is one of 'file', 'inventory', 'signatures',
1447
'revisions'. file-id is None unless knit-kind is 'file'.
1448
"""
1449
# XXX: it's a bit weird to control the inventory weave caching in this
1450
# generator. Ideally the caching would be done in fetch.py I think. Or
1451
# maybe this generator should explicitly have the contract that it
1452
# should not be iterated until the previously yielded item has been
1453
# processed?
1454
inv_w = self.get_inventory_weave()
1455
1456
# file ids that changed
1457
file_ids = self.fileids_altered_by_revision_ids(revision_ids, inv_w)
1458
count = 0
1459
num_file_ids = len(file_ids)
1460
for file_id, altered_versions in file_ids.iteritems():
1461
if _files_pb is not None:
1462
_files_pb.update("fetch texts", count, num_file_ids)
1463
count += 1
1464
yield ("file", file_id, altered_versions)
1465
# We're done with the files_pb. Note that it finished by the caller,
1466
# just as it was created by the caller.
1467
del _files_pb
1468
1469
# inventory
1470
yield ("inventory", None, revision_ids)
1471
1472
# signatures
1473
revisions_with_signatures = set()
1474
for rev_id in revision_ids:
1475
try:
1476
self.get_signature_text(rev_id)
1477
except errors.NoSuchRevision:
1478
# not signed.
1479
pass
1480
else:
1481
revisions_with_signatures.add(rev_id)
1482
yield ("signatures", None, revisions_with_signatures)
1483
1484
# revisions
1485
yield ("revisions", None, revision_ids)
381
1486
382
1487
@needs_read_lock
383
1488
def get_inventory_weave(self):
386
1491
387
1492
@needs_read_lock
388
1493
def get_inventory(self, revision_id):
389
"""Get Inventory object by hash."""
390
xml = self.get_inventory_xml(revision_id)
391
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
1494
"""Get Inventory object by revision id."""
1495
return self.iter_inventories([revision_id]).next()
1496
1497
def iter_inventories(self, revision_ids):
1498
"""Get many inventories by revision_ids.
1499
1500
This will buffer some or all of the texts used in constructing the
1501
inventories in memory, but will only parse a single inventory at a
1502
time.
1503
1504
:return: An iterator of inventories.
1505
"""
1506
if ((None in revision_ids)
1507
or (_mod_revision.NULL_REVISION in revision_ids)):
1508
raise ValueError('cannot get null revision inventory')
1509
return self._iter_inventories(revision_ids)
1510
1511
def _iter_inventories(self, revision_ids):
1512
"""single-document based inventory iteration."""
1513
texts = self.get_inventory_weave().get_texts(revision_ids)
1514
for text, revision_id in zip(texts, revision_ids):
1515
yield self.deserialise_inventory(revision_id, text)
1516
1517
def deserialise_inventory(self, revision_id, xml):
1518
"""Transform the xml into an inventory object.
1519
1520
:param revision_id: The expected revision id of the inventory.
1521
:param xml: A serialised inventory.
1522
"""
1523
result = self._serializer.read_inventory_from_string(xml, revision_id)
1524
if result.revision_id != revision_id:
1525
raise AssertionError('revision id mismatch %s != %s' % (
1526
result.revision_id, revision_id))
1527
return result
1528
1529
def serialise_inventory(self, inv):
1530
return self._serializer.write_inventory_to_string(inv)
1531
1532
def _serialise_inventory_to_lines(self, inv):
1533
return self._serializer.write_inventory_to_lines(inv)
1534
1535
def get_serializer_format(self):
1536
return self._serializer.format_num
392
1537
393
1538
@needs_read_lock
394
1539
def get_inventory_xml(self, revision_id):
395
1540
"""Get inventory XML as a file object."""
396
1541
try:
397
assert isinstance(revision_id, basestring), type(revision_id)
398
1542
iw = self.get_inventory_weave()
399
1543
return iw.get_text(revision_id)
400
1544
except IndexError:
401
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
1545
raise errors.HistoryMissing(self, 'inventory', revision_id)
402
1546
403
1547
@needs_read_lock
404
1548
def get_inventory_sha1(self, revision_id):
406
1550
"""
407
1551
return self.get_revision(revision_id).inventory_sha1
408
1552
409
@needs_read_lock
410
def get_revision_graph(self, revision_id=None):
411
"""Return a dictionary containing the revision graph.
412
413
:return: a dictionary of revision_id->revision_parents_list.
414
"""
415
weave = self.get_inventory_weave()
416
all_revisions = self._eliminate_revisions_not_present(weave.versions())
417
entire_graph = dict([(node, weave.get_parents(node)) for
418
node in all_revisions])
419
if revision_id is None:
420
return entire_graph
421
elif revision_id not in entire_graph:
422
raise errors.NoSuchRevision(self, revision_id)
423
else:
424
# add what can be reached from revision_id
425
result = {}
426
pending = set([revision_id])
427
while len(pending) > 0:
428
node = pending.pop()
429
result[node] = entire_graph[node]
430
for revision_id in result[node]:
431
if revision_id not in result:
432
pending.add(revision_id)
433
return result
434
435
@needs_read_lock
436
def get_revision_graph_with_ghosts(self, revision_ids=None):
437
"""Return a graph of the revisions with ghosts marked as applicable.
438
439
:param revision_ids: an iterable of revisions to graph or None for all.
440
:return: a Graph object with the graph reachable from revision_ids.
441
"""
442
result = Graph()
443
if not revision_ids:
444
pending = set(self.all_revision_ids())
445
required = set([])
446
else:
447
pending = set(revision_ids)
448
required = set(revision_ids)
449
done = set([])
450
while len(pending):
451
revision_id = pending.pop()
452
try:
453
rev = self.get_revision(revision_id)
454
except errors.NoSuchRevision:
455
if revision_id in required:
456
raise
457
# a ghost
458
result.add_ghost(revision_id)
459
continue
460
for parent_id in rev.parent_ids:
461
# is this queued or done ?
462
if (parent_id not in pending and
463
parent_id not in done):
464
# no, queue it.
465
pending.add(parent_id)
466
result.add_node(revision_id, rev.parent_ids)
467
done.add(revision_id)
468
return result
1553
def iter_reverse_revision_history(self, revision_id):
1554
"""Iterate backwards through revision ids in the lefthand history
1555
1556
:param revision_id: The revision id to start with. All its lefthand
1557
ancestors will be traversed.
1558
"""
1559
graph = self.get_graph()
1560
next_id = revision_id
1561
while True:
1562
if next_id in (None, _mod_revision.NULL_REVISION):
1563
return
1564
yield next_id
1565
# Note: The following line may raise KeyError in the event of
1566
# truncated history. We decided not to have a try:except:raise
1567
# RevisionNotPresent here until we see a use for it, because of the
1568
# cost in an inner loop that is by its very nature O(history).
1569
# Robert Collins 20080326
1570
parents = graph.get_parent_map([next_id])[next_id]
1571
if len(parents) == 0:
1572
return
1573
else:
1574
next_id = parents[0]
469
1575
470
1576
@needs_read_lock
471
1577
def get_revision_inventory(self, revision_id):
489
1595
raise NotImplementedError(self.is_shared)
490
1596
491
1597
@needs_write_lock
492
def reconcile(self):
1598
def reconcile(self, other=None, thorough=False):
493
1599
"""Reconcile this repository."""
494
1600
from bzrlib.reconcile import RepoReconciler
495
reconciler = RepoReconciler(self)
1601
reconciler = RepoReconciler(self, thorough=thorough)
496
1602
reconciler.reconcile()
497
1603
return reconciler
498
1604
1605
def _refresh_data(self):
1606
"""Helper called from lock_* to ensure coherency with disk.
1607
1608
The default implementation does nothing; it is however possible
1609
for repositories to maintain loaded indices across multiple locks
1610
by checking inside their implementation of this method to see
1611
whether their indices are still valid. This depends of course on
1612
the disk format being validatable in this manner.
1613
"""
1614
499
1615
@needs_read_lock
500
1616
def revision_tree(self, revision_id):
501
1617
"""Return Tree for a revision on this branch.
502
1618
503
`revision_id` may be None for the null revision, in which case
504
an `EmptyTree` is returned."""
1619
`revision_id` may be None for the empty tree revision.
1620
"""
505
1621
# TODO: refactor this to use an existing revision object
506
1622
# so we don't need to read it in twice.
507
if revision_id is None or revision_id == NULL_REVISION:
508
return EmptyTree()
1623
if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
1624
return RevisionTree(self, Inventory(root_id=None),
1625
_mod_revision.NULL_REVISION)
509
1626
else:
510
1627
inv = self.get_revision_inventory(revision_id)
511
1628
return RevisionTree(self, inv, revision_id)
512
1629
1630
def revision_trees(self, revision_ids):
1631
"""Return Tree for a revision on this branch.
1632
1633
`revision_id` may not be None or 'null:'"""
1634
inventories = self.iter_inventories(revision_ids)
1635
for inv in inventories:
1636
yield RevisionTree(self, inv, inv.revision_id)
1637
513
1638
@needs_read_lock
514
def get_ancestry(self, revision_id):
1639
def get_ancestry(self, revision_id, topo_sorted=True):
515
1640
"""Return a list of revision-ids integrated by a revision.
1641
1642
The first element of the list is always None, indicating the origin
1643
revision. This might change when we have history horizons, or
1644
perhaps we should have a new API.
516
1645
517
1646
This is topologically sorted.
518
1647
"""
519
if revision_id is None:
1648
if _mod_revision.is_null(revision_id):
520
1649
return [None]
521
1650
if not self.has_revision(revision_id):
522
1651
raise errors.NoSuchRevision(self, revision_id)
523
1652
w = self.get_inventory_weave()
524
candidates = w.get_ancestry(revision_id)
1653
candidates = w.get_ancestry(revision_id, topo_sorted)
525
1654
return [None] + candidates # self._eliminate_revisions_not_present(candidates)
526
1655
1656
def pack(self):
1657
"""Compress the data within the repository.
1658
1659
This operation only makes sense for some repository types. For other
1660
types it should be a no-op that just returns.
1661
1662
This stub method does not require a lock, but subclasses should use
1663
@needs_write_lock as this is a long running call its reasonable to
1664
implicitly lock for the user.
1665
"""
1666
527
1667
@needs_read_lock
528
1668
def print_file(self, file, revision_id):
529
1669
"""Print `file` to stdout.
536
1676
# use inventory as it was in that revision
537
1677
file_id = tree.inventory.path2id(file)
538
1678
if not file_id:
539
raise BzrError("%r is not present in revision %s" % (file, revno))
540
try:
541
revno = self.revision_id_to_revno(revision_id)
542
except errors.NoSuchRevision:
543
# TODO: This should not be BzrError,
544
# but NoSuchFile doesn't fit either
545
raise BzrError('%r is not present in revision %s'
546
% (file, revision_id))
547
else:
548
raise BzrError('%r is not present in revision %s'
549
% (file, revno))
1679
# TODO: jam 20060427 Write a test for this code path
1680
# it had a bug in it, and was raising the wrong
1681
# exception.
1682
raise errors.BzrError("%r is not present in revision %s" % (file, revision_id))
550
1683
tree.print_file(file_id)
551
1684
552
1685
def get_transaction(self):
553
1686
return self.control_files.get_transaction()
554
1687
555
def revision_parents(self, revid):
556
return self.get_inventory_weave().parent_names(revid)
1688
@deprecated_method(symbol_versioning.one_one)
1689
def get_parents(self, revision_ids):
1690
"""See StackedParentsProvider.get_parents"""
1691
parent_map = self.get_parent_map(revision_ids)
1692
return [parent_map.get(r, None) for r in revision_ids]
1693
1694
def get_parent_map(self, keys):
1695
"""See graph._StackedParentsProvider.get_parent_map"""
1696
parent_map = {}
1697
for revision_id in keys:
1698
if revision_id is None:
1699
raise ValueError('get_parent_map(None) is not valid')
1700
if revision_id == _mod_revision.NULL_REVISION:
1701
parent_map[revision_id] = ()
1702
else:
1703
try:
1704
parent_id_list = self.get_revision(revision_id).parent_ids
1705
except errors.NoSuchRevision:
1706
pass
1707
else:
1708
if len(parent_id_list) == 0:
1709
parent_ids = (_mod_revision.NULL_REVISION,)
1710
else:
1711
parent_ids = tuple(parent_id_list)
1712
parent_map[revision_id] = parent_ids
1713
return parent_map
1714
1715
def _make_parents_provider(self):
1716
return self
1717
1718
def get_graph(self, other_repository=None):
1719
"""Return the graph walker for this repository format"""
1720
parents_provider = self._make_parents_provider()
1721
if (other_repository is not None and
1722
not self.has_same_location(other_repository)):
1723
parents_provider = graph._StackedParentsProvider(
1724
[parents_provider, other_repository._make_parents_provider()])
1725
return graph.Graph(parents_provider)
1726
1727
def _get_versioned_file_checker(self):
1728
"""Return an object suitable for checking versioned files."""
1729
return _VersionedFileChecker(self)
1730
1731
def revision_ids_to_search_result(self, result_set):
1732
"""Convert a set of revision ids to a graph SearchResult."""
1733
result_parents = set()
1734
for parents in self.get_graph().get_parent_map(
1735
result_set).itervalues():
1736
result_parents.update(parents)
1737
included_keys = result_set.intersection(result_parents)
1738
start_keys = result_set.difference(included_keys)
1739
exclude_keys = result_parents.difference(result_set)
1740
result = graph.SearchResult(start_keys, exclude_keys,
1741
len(result_set), result_set)
1742
return result
557
1743
558
1744
@needs_write_lock
559
1745
def set_make_working_trees(self, new_value):
588
1774
return self._revision_store.get_signature_text(revision_id,
589
1775
self.get_transaction())
590
1776
591
592
class AllInOneRepository(Repository):
593
"""Legacy support - the repository behaviour for all-in-one branches."""
594
595
def __init__(self, _format, a_bzrdir, _revision_store, control_store, text_store):
596
# we reuse one control files instance.
597
dir_mode = a_bzrdir._control_files._dir_mode
598
file_mode = a_bzrdir._control_files._file_mode
599
600
def get_store(name, compressed=True, prefixed=False):
601
# FIXME: This approach of assuming stores are all entirely compressed
602
# or entirely uncompressed is tidy, but breaks upgrade from
603
# some existing branches where there's a mixture; we probably
604
# still want the option to look for both.
605
relpath = a_bzrdir._control_files._escape(name)
606
store = TextStore(a_bzrdir._control_files._transport.clone(relpath),
607
prefixed=prefixed, compressed=compressed,
608
dir_mode=dir_mode,
609
file_mode=file_mode)
610
#if self._transport.should_cache():
611
# cache_path = os.path.join(self.cache_root, name)
612
# os.mkdir(cache_path)
613
# store = bzrlib.store.CachedStore(store, cache_path)
614
return store
615
616
# not broken out yet because the controlweaves|inventory_store
617
# and text_store | weave_store bits are still different.
618
if isinstance(_format, RepositoryFormat4):
619
# cannot remove these - there is still no consistent api
620
# which allows access to this old info.
621
self.inventory_store = get_store('inventory-store')
622
text_store = get_store('text-store')
623
super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)
624
625
1777
@needs_read_lock
626
def is_shared(self):
627
"""AllInOne repositories cannot be shared."""
628
return False
629
630
@needs_write_lock
631
def set_make_working_trees(self, new_value):
632
"""Set the policy flag for making working trees when creating branches.
633
634
This only applies to branches that use this repository.
635
636
The default is 'True'.
637
:param new_value: True to restore the default, False to disable making
638
working trees.
1778
def check(self, revision_ids=None):
1779
"""Check consistency of all history of given revision_ids.
1780
1781
Different repository implementations should override _check().
1782
1783
:param revision_ids: A non-empty list of revision_ids whose ancestry
1784
will be checked. Typically the last revision_id of a branch.
639
1785
"""
640
raise NotImplementedError(self.set_make_working_trees)
1786
return self._check(revision_ids)
1787
1788
def _check(self, revision_ids):
1789
result = check.Check(self)
1790
result.check()
1791
return result
1792
1793
def _warn_if_deprecated(self):
1794
global _deprecation_warning_done
1795
if _deprecation_warning_done:
1796
return
1797
_deprecation_warning_done = True
1798
warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
1799
% (self._format, self.bzrdir.transport.base))
1800
1801
def supports_rich_root(self):
1802
return self._format.rich_root_data
1803
1804
def _check_ascii_revisionid(self, revision_id, method):
1805
"""Private helper for ascii-only repositories."""
1806
# weave repositories refuse to store revisionids that are non-ascii.
1807
if revision_id is not None:
1808
# weaves require ascii revision ids.
1809
if isinstance(revision_id, unicode):
1810
try:
1811
revision_id.encode('ascii')
1812
except UnicodeEncodeError:
1813
raise errors.NonAsciiRevisionId(method, self)
1814
else:
1815
try:
1816
revision_id.decode('ascii')
1817
except UnicodeDecodeError:
1818
raise errors.NonAsciiRevisionId(method, self)
641
1819
642
def make_working_trees(self):
643
"""Returns the policy for making working trees on new branches."""
644
return True
1820
def revision_graph_can_have_wrong_parents(self):
1821
"""Is it possible for this repository to have a revision graph with
1822
incorrect parents?
1823
1824
If True, then this repository must also implement
1825
_find_inconsistent_revision_parents so that check and reconcile can
1826
check for inconsistencies before proceeding with other checks that may
1827
depend on the revision index being consistent.
1828
"""
1829
raise NotImplementedError(self.revision_graph_can_have_wrong_parents)
1830
1831
1832
# remove these delegates a while after bzr 0.15
1833
def __make_delegated(name, from_module):
1834
def _deprecated_repository_forwarder():
1835
symbol_versioning.warn('%s moved to %s in bzr 0.15'
1836
% (name, from_module),
1837
DeprecationWarning,
1838
stacklevel=2)
1839
m = __import__(from_module, globals(), locals(), [name])
1840
try:
1841
return getattr(m, name)
1842
except AttributeError:
1843
raise AttributeError('module %s has no name %s'
1844
% (m, name))
1845
globals()[name] = _deprecated_repository_forwarder
1846
1847
for _name in [
1848
'AllInOneRepository',
1849
'WeaveMetaDirRepository',
1850
'PreSplitOutRepositoryFormat',
1851
'RepositoryFormat4',
1852
'RepositoryFormat5',
1853
'RepositoryFormat6',
1854
'RepositoryFormat7',
1855
]:
1856
__make_delegated(_name, 'bzrlib.repofmt.weaverepo')
1857
1858
for _name in [
1859
'KnitRepository',
1860
'RepositoryFormatKnit',
1861
'RepositoryFormatKnit1',
1862
]:
1863
__make_delegated(_name, 'bzrlib.repofmt.knitrepo')
1864
1865
1866
def install_revision(repository, rev, revision_tree):
1867
"""Install all revision data into a repository."""
1868
install_revisions(repository, [(rev, revision_tree, None)])
1869
1870
1871
def install_revisions(repository, iterable, num_revisions=None, pb=None):
1872
"""Install all revision data into a repository.
1873
1874
Accepts an iterable of revision, tree, signature tuples. The signature
1875
may be None.
1876
"""
1877
repository.start_write_group()
1878
try:
1879
for n, (revision, revision_tree, signature) in enumerate(iterable):
1880
_install_revision(repository, revision, revision_tree, signature)
1881
if pb is not None:
1882
pb.update('Transferring revisions', n + 1, num_revisions)
1883
except:
1884
repository.abort_write_group()
1885
raise
1886
else:
1887
repository.commit_write_group()
1888
1889
1890
def _install_revision(repository, rev, revision_tree, signature):
1891
"""Install all revision data into a repository."""
1892
present_parents = []
1893
parent_trees = {}
1894
for p_id in rev.parent_ids:
1895
if repository.has_revision(p_id):
1896
present_parents.append(p_id)
1897
parent_trees[p_id] = repository.revision_tree(p_id)
1898
else:
1899
parent_trees[p_id] = repository.revision_tree(None)
1900
1901
inv = revision_tree.inventory
1902
entries = inv.iter_entries()
1903
# backwards compatibility hack: skip the root id.
1904
if not repository.supports_rich_root():
1905
path, root = entries.next()
1906
if root.revision != rev.revision_id:
1907
raise errors.IncompatibleRevision(repr(repository))
1908
# Add the texts that are not already present
1909
for path, ie in entries:
1910
w = repository.weave_store.get_weave_or_empty(ie.file_id,
1911
repository.get_transaction())
1912
if ie.revision not in w:
1913
text_parents = []
1914
# FIXME: TODO: The following loop *may* be overlapping/duplicate
1915
# with InventoryEntry.find_previous_heads(). if it is, then there
1916
# is a latent bug here where the parents may have ancestors of each
1917
# other. RBC, AB
1918
for revision, tree in parent_trees.iteritems():
1919
if ie.file_id not in tree:
1920
continue
1921
parent_id = tree.inventory[ie.file_id].revision
1922
if parent_id in text_parents:
1923
continue
1924
text_parents.append(parent_id)
1925
1926
vfile = repository.weave_store.get_weave_or_empty(ie.file_id,
1927
repository.get_transaction())
1928
lines = revision_tree.get_file(ie.file_id).readlines()
1929
vfile.add_lines(rev.revision_id, text_parents, lines)
1930
try:
1931
# install the inventory
1932
repository.add_inventory(rev.revision_id, inv, present_parents)
1933
except errors.RevisionAlreadyPresent:
1934
pass
1935
if signature is not None:
1936
repository.add_signature_text(rev.revision_id, signature)
1937
repository.add_revision(rev.revision_id, rev, inv)
645
1938
646
1939
647
1940
class MetaDirRepository(Repository):
648
"""Repositories in the new meta-dir layout."""
1941
"""Repositories in the new meta-dir layout.
1942
1943
:ivar _transport: Transport for access to repository control files,
1944
typically pointing to .bzr/repository.
1945
"""
649
1946
650
1947
def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
651
1948
super(MetaDirRepository, self).__init__(_format,
654
1951
_revision_store,
655
1952
control_store,
656
1953
text_store)
657
658
dir_mode = self.control_files._dir_mode
659
file_mode = self.control_files._file_mode
1954
self._transport = control_files._transport
660
1955
661
1956
@needs_read_lock
662
1957
def is_shared(self):
663
1958
"""Return True if this repository is flagged as a shared repository."""
664
return self.control_files._transport.has('shared-storage')
1959
return self._transport.has('shared-storage')
665
1960
666
1961
@needs_write_lock
667
1962
def set_make_working_trees(self, new_value):
675
1970
"""
676
1971
if new_value:
677
1972
try:
678
self.control_files._transport.delete('no-working-trees')
1973
self._transport.delete('no-working-trees')
679
1974
except errors.NoSuchFile:
680
1975
pass
681
1976
else:
682
self.control_files.put_utf8('no-working-trees', '')
1977
self._transport.put_bytes('no-working-trees', '',
1978
mode=self.control_files._file_mode)
683
1979
684
1980
def make_working_trees(self):
685
1981
"""Returns the policy for making working trees on new branches."""
686
return not self.control_files._transport.has('no-working-trees')
687
688
689
class KnitRepository(MetaDirRepository):
690
"""Knit format repository."""
691
692
@needs_read_lock
693
def all_revision_ids(self):
694
"""See Repository.all_revision_ids()."""
695
return self._revision_store.all_revision_ids(self.get_transaction())
696
697
def fileid_involved_between_revs(self, from_revid, to_revid):
698
"""Find file_id(s) which are involved in the changes between revisions.
699
700
This determines the set of revisions which are involved, and then
701
finds all file ids affected by those revisions.
702
"""
703
vf = self._get_revision_vf()
704
from_set = set(vf.get_ancestry(from_revid))
705
to_set = set(vf.get_ancestry(to_revid))
706
changed = to_set.difference(from_set)
707
return self._fileid_involved_by_set(changed)
708
709
def fileid_involved(self, last_revid=None):
710
"""Find all file_ids modified in the ancestry of last_revid.
711
712
:param last_revid: If None, last_revision() will be used.
713
"""
714
if not last_revid:
715
changed = set(self.all_revision_ids())
716
else:
717
changed = set(self.get_ancestry(last_revid))
718
if None in changed:
719
changed.remove(None)
720
return self._fileid_involved_by_set(changed)
721
722
@needs_read_lock
723
def get_ancestry(self, revision_id):
724
"""Return a list of revision-ids integrated by a revision.
725
726
This is topologically sorted.
727
"""
728
if revision_id is None:
729
return [None]
730
vf = self._get_revision_vf()
731
try:
732
return [None] + vf.get_ancestry(revision_id)
733
except errors.RevisionNotPresent:
734
raise errors.NoSuchRevision(self, revision_id)
735
736
@needs_read_lock
737
def get_revision(self, revision_id):
738
"""Return the Revision object for a named revision"""
739
return self.get_revision_reconcile(revision_id)
740
741
@needs_read_lock
742
def get_revision_graph(self, revision_id=None):
743
"""Return a dictionary containing the revision graph.
744
745
:return: a dictionary of revision_id->revision_parents_list.
746
"""
747
weave = self._get_revision_vf()
748
entire_graph = weave.get_graph()
749
if revision_id is None:
750
return weave.get_graph()
751
elif revision_id not in weave:
752
raise errors.NoSuchRevision(self, revision_id)
753
else:
754
# add what can be reached from revision_id
755
result = {}
756
pending = set([revision_id])
757
while len(pending) > 0:
758
node = pending.pop()
759
result[node] = weave.get_parents(node)
760
for revision_id in result[node]:
761
if revision_id not in result:
762
pending.add(revision_id)
763
return result
764
765
@needs_read_lock
766
def get_revision_graph_with_ghosts(self, revision_ids=None):
767
"""Return a graph of the revisions with ghosts marked as applicable.
768
769
:param revision_ids: an iterable of revisions to graph or None for all.
770
:return: a Graph object with the graph reachable from revision_ids.
771
"""
772
result = Graph()
773
vf = self._get_revision_vf()
774
versions = set(vf.versions())
775
if not revision_ids:
776
pending = set(self.all_revision_ids())
777
required = set([])
778
else:
779
pending = set(revision_ids)
780
required = set(revision_ids)
781
done = set([])
782
while len(pending):
783
revision_id = pending.pop()
784
if not revision_id in versions:
785
if revision_id in required:
786
raise errors.NoSuchRevision(self, revision_id)
787
# a ghost
788
result.add_ghost(revision_id)
789
# mark it as done so we dont try for it again.
790
done.add(revision_id)
791
continue
792
parent_ids = vf.get_parents_with_ghosts(revision_id)
793
for parent_id in parent_ids:
794
# is this queued or done ?
795
if (parent_id not in pending and
796
parent_id not in done):
797
# no, queue it.
798
pending.add(parent_id)
799
result.add_node(revision_id, parent_ids)
800
done.add(revision_id)
801
return result
802
803
def _get_revision_vf(self):
804
""":return: a versioned file containing the revisions."""
805
vf = self._revision_store.get_revision_file(self.get_transaction())
806
return vf
807
808
@needs_write_lock
809
def reconcile(self):
810
"""Reconcile this repository."""
811
from bzrlib.reconcile import KnitReconciler
812
reconciler = KnitReconciler(self)
813
reconciler.reconcile()
814
return reconciler
1982
return not self._transport.has('no-working-trees')
1983
1984
1985
class MetaDirVersionedFileRepository(MetaDirRepository):
1986
"""Repositories in a meta-dir, that work via versioned file objects."""
1987
1988
def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
1989
super(MetaDirVersionedFileRepository, self).__init__(_format, a_bzrdir,
1990
control_files, _revision_store, control_store, text_store)
1991
_revision_store.get_scope = self.get_transaction
1992
control_store.get_scope = self.get_transaction
1993
text_store.get_scope = self.get_transaction
1994
1995
1996
class RepositoryFormatRegistry(registry.Registry):
1997
"""Registry of RepositoryFormats."""
1998
1999
def get(self, format_string):
2000
r = registry.Registry.get(self, format_string)
2001
if callable(r):
2002
r = r()
2003
return r
815
2004
816
def revision_parents(self, revid):
817
return self._get_revision_vf().get_parents(rev_id)
2005
2006
format_registry = RepositoryFormatRegistry()
2007
"""Registry of formats, indexed by their identifying format string.
2008
2009
This can contain either format instances themselves, or classes/factories that
2010
can be called to obtain one.
2011
"""
2012
2013
2014
#####################################################################
2015
# Repository Formats
818
2016
819
2017
class RepositoryFormat(object):
820
2018
"""A repository format.
825
2023
children.
826
2024
* an open routine which returns a Repository instance.
827
2025
2026
There is one and only one Format subclass for each on-disk format. But
2027
there can be one Repository subclass that is used for several different
2028
formats. The _format attribute on a Repository instance can be used to
2029
determine the disk format.
2030
828
2031
Formats are placed in an dict by their format string for reference
829
2032
during opening. These should be subclasses of RepositoryFormat
830
2033
for consistency.
837
2040
_matchingbzrdir - the bzrdir format that the repository format was
838
2041
originally written to work with. This can be used if manually
839
2042
constructing a bzrdir and repository, or more commonly for test suite
840
parameterisation.
2043
parameterization.
841
2044
"""
842
2045
843
_default_format = None
844
"""The default format used for new repositories."""
845
846
_formats = {}
847
"""The known formats."""
2046
# Set to True or False in derived classes. True indicates that the format
2047
# supports ghosts gracefully.
2048
supports_ghosts = None
2049
# Can this repository be given external locations to lookup additional
2050
# data. Set to True or False in derived classes.
2051
supports_external_lookups = None
2052
2053
def __str__(self):
2054
return "<%s>" % self.__class__.__name__
2055
2056
def __eq__(self, other):
2057
# format objects are generally stateless
2058
return isinstance(other, self.__class__)
2059
2060
def __ne__(self, other):
2061
return not self == other
848
2062
849
2063
@classmethod
850
2064
def find_format(klass, a_bzrdir):
851
"""Return the format for the repository object in a_bzrdir."""
2065
"""Return the format for the repository object in a_bzrdir.
2066
2067
This is used by bzr native formats that have a "format" file in
2068
the repository. Other methods may be used by different types of
2069
control directory.
2070
"""
852
2071
try:
853
2072
transport = a_bzrdir.get_repository_transport(None)
854
2073
format_string = transport.get("format").read()
855
return klass._formats[format_string]
2074
return format_registry.get(format_string)
856
2075
except errors.NoSuchFile:
857
2076
raise errors.NoRepositoryPresent(a_bzrdir)
858
2077
except KeyError:
859
raise errors.UnknownFormatError(format_string)
860
861
def _get_control_store(self, repo_transport, control_files):
862
"""Return the control store for this repository."""
863
raise NotImplementedError(self._get_control_store)
2078
raise errors.UnknownFormatError(format=format_string,
2079
kind='repository')
2080
2081
@classmethod
2082
def register_format(klass, format):
2083
format_registry.register(format.get_format_string(), format)
2084
2085
@classmethod
2086
def unregister_format(klass, format):
2087
format_registry.remove(format.get_format_string())
864
2088
865
2089
@classmethod
866
2090
def get_default_format(klass):
867
2091
"""Return the current default format."""
868
return klass._default_format
2092
from bzrlib import bzrdir
2093
return bzrdir.format_registry.make_bzrdir('default').repository_format
2094
2095
def _get_control_store(self, repo_transport, control_files):
2096
"""Return the control store for this repository."""
2097
raise NotImplementedError(self._get_control_store)
869
2098
870
2099
def get_format_string(self):
871
2100
"""Return the ASCII format string that identifies this format.
876
2105
raise NotImplementedError(self.get_format_string)
877
2106
878
2107
def get_format_description(self):
879
"""Return the short desciption for this format."""
2108
"""Return the short description for this format."""
880
2109
raise NotImplementedError(self.get_format_description)
881
2110
882
2111
def _get_revision_store(self, repo_transport, control_files):
898
2127
from bzrlib.store.revision.text import TextRevisionStore
899
2128
dir_mode = control_files._dir_mode
900
2129
file_mode = control_files._file_mode
901
text_store =TextStore(transport.clone(name),
2130
text_store = TextStore(transport.clone(name),
902
2131
prefixed=prefixed,
903
2132
compressed=compressed,
904
2133
dir_mode=dir_mode,
906
2135
_revision_store = TextRevisionStore(text_store, serializer)
907
2136
return _revision_store
908
2137
2138
# TODO: this shouldn't be in the base class, it's specific to things that
2139
# use weaves or knits -- mbp 20070207
909
2140
def _get_versioned_file_store(self,
910
2141
name,
911
2142
transport,
912
2143
control_files,
913
2144
prefixed=True,
914
versionedfile_class=WeaveFile,
2145
versionedfile_class=None,
2146
versionedfile_kwargs={},
915
2147
escaped=False):
2148
if versionedfile_class is None:
2149
versionedfile_class = self._versionedfile_class
916
2150
weave_transport = control_files._transport.clone(name)
917
2151
dir_mode = control_files._dir_mode
918
2152
file_mode = control_files._file_mode
920
2154
dir_mode=dir_mode,
921
2155
file_mode=file_mode,
922
2156
versionedfile_class=versionedfile_class,
2157
versionedfile_kwargs=versionedfile_kwargs,
923
2158
escaped=escaped)
924
2159
925
2160
def initialize(self, a_bzrdir, shared=False):
927
2162
928
2163
:param a_bzrdir: The bzrdir to put the new repository in it.
929
2164
:param shared: The repository should be initialized as a sharable one.
930
2165
:returns: The new repository object.
2166
931
2167
This may raise UninitializableFormat if shared repository are not
932
2168
compatible the a_bzrdir.
933
2169
"""
2170
raise NotImplementedError(self.initialize)
934
2171
935
2172
def is_supported(self):
936
2173
"""Is this format supported?
941
2178
"""
942
2179
return True
943
2180
2181
def check_conversion_target(self, target_format):
2182
raise NotImplementedError(self.check_conversion_target)
2183
944
2184
def open(self, a_bzrdir, _found=False):
945
2185
"""Return an instance of this format for the bzrdir a_bzrdir.
946
2186
948
2188
"""
949
2189
raise NotImplementedError(self.open)
950
2190
951
@classmethod
952
def register_format(klass, format):
953
klass._formats[format.get_format_string()] = format
954
955
@classmethod
956
def set_default_format(klass, format):
957
klass._default_format = format
958
959
@classmethod
960
def unregister_format(klass, format):
961
assert klass._formats[format.get_format_string()] is format
962
del klass._formats[format.get_format_string()]
963
964
965
class PreSplitOutRepositoryFormat(RepositoryFormat):
966
"""Base class for the pre split out repository formats."""
967
968
def initialize(self, a_bzrdir, shared=False, _internal=False):
969
"""Create a weave repository.
970
971
TODO: when creating split out bzr branch formats, move this to a common
972
base for Format5, Format6. or something like that.
973
"""
974
from bzrlib.weavefile import write_weave_v5
975
from bzrlib.weave import Weave
976
977
if shared:
978
raise errors.IncompatibleFormat(self, a_bzrdir._format)
979
980
if not _internal:
981
# always initialized when the bzrdir is.
982
return self.open(a_bzrdir, _found=True)
983
984
# Create an empty weave
985
sio = StringIO()
986
bzrlib.weavefile.write_weave_v5(Weave(), sio)
987
empty_weave = sio.getvalue()
988
989
mutter('creating repository in %s.', a_bzrdir.transport.base)
990
dirs = ['revision-store', 'weaves']
991
files = [('inventory.weave', StringIO(empty_weave)),
992
]
993
994
# FIXME: RBC 20060125 dont peek under the covers
995
# NB: no need to escape relative paths that are url safe.
996
control_files = LockableFiles(a_bzrdir.transport, 'branch-lock',
997
TransportLock)
998
control_files.create_lock()
999
control_files.lock_write()
1000
control_files._transport.mkdir_multi(dirs,
1001
mode=control_files._dir_mode)
1002
try:
1003
for file, content in files:
1004
control_files.put(file, content)
1005
finally:
1006
control_files.unlock()
1007
return self.open(a_bzrdir, _found=True)
1008
1009
def _get_control_store(self, repo_transport, control_files):
1010
"""Return the control store for this repository."""
1011
return self._get_versioned_file_store('',
1012
repo_transport,
1013
control_files,
1014
prefixed=False)
1015
1016
def _get_text_store(self, transport, control_files):
1017
"""Get a store for file texts for this format."""
1018
raise NotImplementedError(self._get_text_store)
1019
1020
def open(self, a_bzrdir, _found=False):
1021
"""See RepositoryFormat.open()."""
1022
if not _found:
1023
# we are being called directly and must probe.
1024
raise NotImplementedError
1025
1026
repo_transport = a_bzrdir.get_repository_transport(None)
1027
control_files = a_bzrdir._control_files
1028
text_store = self._get_text_store(repo_transport, control_files)
1029
control_store = self._get_control_store(repo_transport, control_files)
1030
_revision_store = self._get_revision_store(repo_transport, control_files)
1031
return AllInOneRepository(_format=self,
1032
a_bzrdir=a_bzrdir,
1033
_revision_store=_revision_store,
1034
control_store=control_store,
1035
text_store=text_store)
1036
1037
1038
class RepositoryFormat4(PreSplitOutRepositoryFormat):
1039
"""Bzr repository format 4.
1040
1041
This repository format has:
1042
- flat stores
1043
- TextStores for texts, inventories,revisions.
1044
1045
This format is deprecated: it indexes texts using a text id which is
1046
removed in format 5; initializationa and write support for this format
1047
has been removed.
1048
"""
1049
1050
def __init__(self):
1051
super(RepositoryFormat4, self).__init__()
1052
self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat4()
1053
1054
def get_format_description(self):
1055
"""See RepositoryFormat.get_format_description()."""
1056
return "Repository format 4"
1057
1058
def initialize(self, url, shared=False, _internal=False):
1059
"""Format 4 branches cannot be created."""
1060
raise errors.UninitializableFormat(self)
1061
1062
def is_supported(self):
1063
"""Format 4 is not supported.
1064
1065
It is not supported because the model changed from 4 to 5 and the
1066
conversion logic is expensive - so doing it on the fly was not
1067
feasible.
1068
"""
1069
return False
1070
1071
def _get_control_store(self, repo_transport, control_files):
1072
"""Format 4 repositories have no formal control store at this point.
1073
1074
This will cause any control-file-needing apis to fail - this is desired.
1075
"""
1076
return None
1077
1078
def _get_revision_store(self, repo_transport, control_files):
1079
"""See RepositoryFormat._get_revision_store()."""
1080
from bzrlib.xml4 import serializer_v4
1081
return self._get_text_rev_store(repo_transport,
1082
control_files,
1083
'revision-store',
1084
serializer=serializer_v4)
1085
1086
def _get_text_store(self, transport, control_files):
1087
"""See RepositoryFormat._get_text_store()."""
1088
1089
1090
class RepositoryFormat5(PreSplitOutRepositoryFormat):
1091
"""Bzr control format 5.
1092
1093
This repository format has:
1094
- weaves for file texts and inventory
1095
- flat stores
1096
- TextStores for revisions and signatures.
1097
"""
1098
1099
def __init__(self):
1100
super(RepositoryFormat5, self).__init__()
1101
self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat5()
1102
1103
def get_format_description(self):
1104
"""See RepositoryFormat.get_format_description()."""
1105
return "Weave repository format 5"
1106
1107
def _get_revision_store(self, repo_transport, control_files):
1108
"""See RepositoryFormat._get_revision_store()."""
1109
"""Return the revision store object for this a_bzrdir."""
1110
return self._get_text_rev_store(repo_transport,
1111
control_files,
1112
'revision-store',
1113
compressed=False)
1114
1115
def _get_text_store(self, transport, control_files):
1116
"""See RepositoryFormat._get_text_store()."""
1117
return self._get_versioned_file_store('weaves', transport, control_files, prefixed=False)
1118
1119
1120
class RepositoryFormat6(PreSplitOutRepositoryFormat):
1121
"""Bzr control format 6.
1122
1123
This repository format has:
1124
- weaves for file texts and inventory
1125
- hash subdirectory based stores.
1126
- TextStores for revisions and signatures.
1127
"""
1128
1129
def __init__(self):
1130
super(RepositoryFormat6, self).__init__()
1131
self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat6()
1132
1133
def get_format_description(self):
1134
"""See RepositoryFormat.get_format_description()."""
1135
return "Weave repository format 6"
1136
1137
def _get_revision_store(self, repo_transport, control_files):
1138
"""See RepositoryFormat._get_revision_store()."""
1139
return self._get_text_rev_store(repo_transport,
1140
control_files,
1141
'revision-store',
1142
compressed=False,
1143
prefixed=True)
1144
1145
def _get_text_store(self, transport, control_files):
1146
"""See RepositoryFormat._get_text_store()."""
1147
return self._get_versioned_file_store('weaves', transport, control_files)
1148
1149
2191
1150
2192
class MetaDirRepositoryFormat(RepositoryFormat):
1151
"""Common base class for the new repositories using the metadir layour."""
2193
"""Common base class for the new repositories using the metadir layout."""
2194
2195
rich_root_data = False
2196
supports_tree_reference = False
2197
supports_external_lookups = False
2198
_matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1152
2199
1153
2200
def __init__(self):
1154
2201
super(MetaDirRepositoryFormat, self).__init__()
1155
self._matchingbzrdir = bzrlib.bzrdir.BzrDirMetaFormat1()
1156
2202
1157
2203
def _create_control_files(self, a_bzrdir):
1158
2204
"""Create the required files and the initial control_files object."""
1159
# FIXME: RBC 20060125 dont peek under the covers
2205
# FIXME: RBC 20060125 don't peek under the covers
1160
2206
# NB: no need to escape relative paths that are url safe.
1161
2207
repository_transport = a_bzrdir.get_repository_transport(self)
1162
control_files = LockableFiles(repository_transport, 'lock', LockDir)
2208
control_files = lockable_files.LockableFiles(repository_transport,
2209
'lock', lockdir.LockDir)
1163
2210
control_files.create_lock()
1164
2211
return control_files
1165
2212
1167
2214
"""Upload the initial blank content."""
1168
2215
control_files = self._create_control_files(a_bzrdir)
1169
2216
control_files.lock_write()
2217
transport = control_files._transport
2218
if shared == True:
2219
utf8_files += [('shared-storage', '')]
1170
2220
try:
1171
control_files._transport.mkdir_multi(dirs,
1172
mode=control_files._dir_mode)
1173
for file, content in files:
1174
control_files.put(file, content)
1175
for file, content in utf8_files:
1176
control_files.put_utf8(file, content)
1177
if shared == True:
1178
control_files.put_utf8('shared-storage', '')
2221
transport.mkdir_multi(dirs, mode=a_bzrdir._get_dir_mode())
2222
for (filename, content_stream) in files:
2223
transport.put_file(filename, content_stream,
2224
mode=a_bzrdir._get_file_mode())
2225
for (filename, content_bytes) in utf8_files:
2226
transport.put_bytes_non_atomic(filename, content_bytes,
2227
mode=a_bzrdir._get_file_mode())
1179
2228
finally:
1180
2229
control_files.unlock()
1181
2230
1182
2231
1183
class RepositoryFormat7(MetaDirRepositoryFormat):
1184
"""Bzr repository 7.
1185
1186
This repository format has:
1187
- weaves for file texts and inventory
1188
- hash subdirectory based stores.
1189
- TextStores for revisions and signatures.
1190
- a format marker of its own
1191
- an optional 'shared-storage' flag
1192
- an optional 'no-working-trees' flag
1193
"""
1194
1195
def _get_control_store(self, repo_transport, control_files):
1196
"""Return the control store for this repository."""
1197
return self._get_versioned_file_store('',
1198
repo_transport,
1199
control_files,
1200
prefixed=False)
1201
1202
def get_format_string(self):
1203
"""See RepositoryFormat.get_format_string()."""
1204
return "Bazaar-NG Repository format 7"
1205
1206
def get_format_description(self):
1207
"""See RepositoryFormat.get_format_description()."""
1208
return "Weave repository format 7"
1209
1210
def _get_revision_store(self, repo_transport, control_files):
1211
"""See RepositoryFormat._get_revision_store()."""
1212
return self._get_text_rev_store(repo_transport,
1213
control_files,
1214
'revision-store',
1215
compressed=False,
1216
prefixed=True,
1217
)
1218
1219
def _get_text_store(self, transport, control_files):
1220
"""See RepositoryFormat._get_text_store()."""
1221
return self._get_versioned_file_store('weaves',
1222
transport,
1223
control_files)
1224
1225
def initialize(self, a_bzrdir, shared=False):
1226
"""Create a weave repository.
1227
1228
:param shared: If true the repository will be initialized as a shared
1229
repository.
1230
"""
1231
from bzrlib.weavefile import write_weave_v5
1232
from bzrlib.weave import Weave
1233
1234
# Create an empty weave
1235
sio = StringIO()
1236
bzrlib.weavefile.write_weave_v5(Weave(), sio)
1237
empty_weave = sio.getvalue()
1238
1239
mutter('creating repository in %s.', a_bzrdir.transport.base)
1240
dirs = ['revision-store', 'weaves']
1241
files = [('inventory.weave', StringIO(empty_weave)),
1242
]
1243
utf8_files = [('format', self.get_format_string())]
1244
1245
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1246
return self.open(a_bzrdir=a_bzrdir, _found=True)
1247
1248
def open(self, a_bzrdir, _found=False, _override_transport=None):
1249
"""See RepositoryFormat.open().
1250
1251
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1252
repository at a slightly different url
1253
than normal. I.e. during 'upgrade'.
1254
"""
1255
if not _found:
1256
format = RepositoryFormat.find_format(a_bzrdir)
1257
assert format.__class__ == self.__class__
1258
if _override_transport is not None:
1259
repo_transport = _override_transport
1260
else:
1261
repo_transport = a_bzrdir.get_repository_transport(None)
1262
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1263
text_store = self._get_text_store(repo_transport, control_files)
1264
control_store = self._get_control_store(repo_transport, control_files)
1265
_revision_store = self._get_revision_store(repo_transport, control_files)
1266
return MetaDirRepository(_format=self,
1267
a_bzrdir=a_bzrdir,
1268
control_files=control_files,
1269
_revision_store=_revision_store,
1270
control_store=control_store,
1271
text_store=text_store)
1272
1273
1274
class RepositoryFormatKnit1(MetaDirRepositoryFormat):
1275
"""Bzr repository knit format 1.
1276
1277
This repository format has:
1278
- knits for file texts and inventory
1279
- hash subdirectory based stores.
1280
- knits for revisions and signatures
1281
- TextStores for revisions and signatures.
1282
- a format marker of its own
1283
- an optional 'shared-storage' flag
1284
- an optional 'no-working-trees' flag
1285
- a LockDir lock
1286
1287
This format was introduced in bzr 0.8.
1288
"""
1289
1290
def _get_control_store(self, repo_transport, control_files):
1291
"""Return the control store for this repository."""
1292
return VersionedFileStore(
1293
repo_transport,
1294
prefixed=False,
1295
file_mode=control_files._file_mode,
1296
versionedfile_class=KnitVersionedFile,
1297
versionedfile_kwargs={'factory':KnitPlainFactory()},
1298
)
1299
1300
def get_format_string(self):
1301
"""See RepositoryFormat.get_format_string()."""
1302
return "Bazaar-NG Knit Repository Format 1"
1303
1304
def get_format_description(self):
1305
"""See RepositoryFormat.get_format_description()."""
1306
return "Knit repository format 1"
1307
1308
def _get_revision_store(self, repo_transport, control_files):
1309
"""See RepositoryFormat._get_revision_store()."""
1310
from bzrlib.store.revision.knit import KnitRevisionStore
1311
versioned_file_store = VersionedFileStore(
1312
repo_transport,
1313
file_mode=control_files._file_mode,
1314
prefixed=False,
1315
precious=True,
1316
versionedfile_class=KnitVersionedFile,
1317
versionedfile_kwargs={'delta':False, 'factory':KnitPlainFactory()},
1318
escaped=True,
1319
)
1320
return KnitRevisionStore(versioned_file_store)
1321
1322
def _get_text_store(self, transport, control_files):
1323
"""See RepositoryFormat._get_text_store()."""
1324
return self._get_versioned_file_store('knits',
1325
transport,
1326
control_files,
1327
versionedfile_class=KnitVersionedFile,
1328
escaped=True)
1329
1330
def initialize(self, a_bzrdir, shared=False):
1331
"""Create a knit format 1 repository.
1332
1333
:param a_bzrdir: bzrdir to contain the new repository; must already
1334
be initialized.
1335
:param shared: If true the repository will be initialized as a shared
1336
repository.
1337
"""
1338
mutter('creating repository in %s.', a_bzrdir.transport.base)
1339
dirs = ['revision-store', 'knits']
1340
files = []
1341
utf8_files = [('format', self.get_format_string())]
1342
1343
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1344
repo_transport = a_bzrdir.get_repository_transport(None)
1345
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1346
control_store = self._get_control_store(repo_transport, control_files)
1347
transaction = bzrlib.transactions.WriteTransaction()
1348
# trigger a write of the inventory store.
1349
control_store.get_weave_or_empty('inventory', transaction)
1350
_revision_store = self._get_revision_store(repo_transport, control_files)
1351
_revision_store.has_revision_id('A', transaction)
1352
_revision_store.get_signature_file(transaction)
1353
return self.open(a_bzrdir=a_bzrdir, _found=True)
1354
1355
def open(self, a_bzrdir, _found=False, _override_transport=None):
1356
"""See RepositoryFormat.open().
1357
1358
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1359
repository at a slightly different url
1360
than normal. I.e. during 'upgrade'.
1361
"""
1362
if not _found:
1363
format = RepositoryFormat.find_format(a_bzrdir)
1364
assert format.__class__ == self.__class__
1365
if _override_transport is not None:
1366
repo_transport = _override_transport
1367
else:
1368
repo_transport = a_bzrdir.get_repository_transport(None)
1369
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1370
text_store = self._get_text_store(repo_transport, control_files)
1371
control_store = self._get_control_store(repo_transport, control_files)
1372
_revision_store = self._get_revision_store(repo_transport, control_files)
1373
return KnitRepository(_format=self,
1374
a_bzrdir=a_bzrdir,
1375
control_files=control_files,
1376
_revision_store=_revision_store,
1377
control_store=control_store,
1378
text_store=text_store)
1379
1380
1381
2232
# formats which have no format string are not discoverable
1382
# and not independently creatable, so are not registered.
1383
_default_format = RepositoryFormat7()
1384
RepositoryFormat.register_format(_default_format)
1385
RepositoryFormat.register_format(RepositoryFormatKnit1())
1386
RepositoryFormat.set_default_format(_default_format)
1387
_legacy_formats = [RepositoryFormat4(),
1388
RepositoryFormat5(),
1389
RepositoryFormat6()]
2233
# and not independently creatable, so are not registered. They're
2234
# all in bzrlib.repofmt.weaverepo now. When an instance of one of these is
2235
# needed, it's constructed directly by the BzrDir. Non-native formats where
2236
# the repository is not separately opened are similar.
2237
2238
format_registry.register_lazy(
2239
'Bazaar-NG Repository format 7',
2240
'bzrlib.repofmt.weaverepo',
2241
'RepositoryFormat7'
2242
)
2243
2244
format_registry.register_lazy(
2245
'Bazaar-NG Knit Repository Format 1',
2246
'bzrlib.repofmt.knitrepo',
2247
'RepositoryFormatKnit1',
2248
)
2249
2250
format_registry.register_lazy(
2251
'Bazaar Knit Repository Format 3 (bzr 0.15)\n',
2252
'bzrlib.repofmt.knitrepo',
2253
'RepositoryFormatKnit3',
2254
)
2255
2256
format_registry.register_lazy(
2257
'Bazaar Knit Repository Format 4 (bzr 1.0)\n',
2258
'bzrlib.repofmt.knitrepo',
2259
'RepositoryFormatKnit4',
2260
)
2261
2262
# Pack-based formats. There is one format for pre-subtrees, and one for
2263
# post-subtrees to allow ease of testing.
2264
# NOTE: These are experimental in 0.92. Stable in 1.0 and above
2265
format_registry.register_lazy(
2266
'Bazaar pack repository format 1 (needs bzr 0.92)\n',
2267
'bzrlib.repofmt.pack_repo',
2268
'RepositoryFormatKnitPack1',
2269
)
2270
format_registry.register_lazy(
2271
'Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n',
2272
'bzrlib.repofmt.pack_repo',
2273
'RepositoryFormatKnitPack3',
2274
)
2275
format_registry.register_lazy(
2276
'Bazaar pack repository format 1 with rich root (needs bzr 1.0)\n',
2277
'bzrlib.repofmt.pack_repo',
2278
'RepositoryFormatKnitPack4',
2279
)
2280
# Development formats.
2281
# 1.2->1.3
2282
# development 0 - stub to introduce development versioning scheme.
2283
format_registry.register_lazy(
2284
"Bazaar development format 0 (needs bzr.dev from before 1.3)\n",
2285
'bzrlib.repofmt.pack_repo',
2286
'RepositoryFormatPackDevelopment0',
2287
)
2288
format_registry.register_lazy(
2289
("Bazaar development format 0 with subtree support "
2290
"(needs bzr.dev from before 1.3)\n"),
2291
'bzrlib.repofmt.pack_repo',
2292
'RepositoryFormatPackDevelopment0Subtree',
2293
)
2294
# 1.3->1.4 go below here
1390
2295
1391
2296
1392
2297
class InterRepository(InterObject):
1401
2306
InterRepository.get(other).method_name(parameters).
1402
2307
"""
1403
2308
1404
_optimisers = set()
2309
_optimisers = []
1405
2310
"""The available optimised InterRepository types."""
1406
2311
1407
@needs_write_lock
1408
def copy_content(self, revision_id=None, basis=None):
1409
"""Make a complete copy of the content in self into destination.
1410
1411
This is a destructive operation! Do not use it on existing
1412
repositories.
1413
1414
:param revision_id: Only copy the content needed to construct
1415
revision_id and its parents.
1416
:param basis: Copy the needed data preferentially from basis.
1417
"""
1418
try:
1419
self.target.set_make_working_trees(self.source.make_working_trees())
1420
except NotImplementedError:
1421
pass
1422
# grab the basis available data
1423
if basis is not None:
1424
self.target.fetch(basis, revision_id=revision_id)
1425
# but dont bother fetching if we have the needed data now.
1426
if (revision_id not in (None, NULL_REVISION) and
1427
self.target.has_revision(revision_id)):
1428
return
1429
self.target.fetch(self.source, revision_id=revision_id)
1430
1431
def _double_lock(self, lock_source, lock_target):
1432
"""Take out too locks, rolling back the first if the second throws."""
1433
lock_source()
1434
try:
1435
lock_target()
1436
except Exception:
1437
# we want to ensure that we don't leave source locked by mistake.
1438
# and any error on target should not confuse source.
1439
self.source.unlock()
1440
raise
1441
1442
@needs_write_lock
1443
def fetch(self, revision_id=None, pb=None):
2312
def copy_content(self, revision_id=None):
2313
raise NotImplementedError(self.copy_content)
2314
2315
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1444
2316
"""Fetch the content required to construct revision_id.
1445
2317
1446
The content is copied from source to target.
2318
The content is copied from self.source to self.target.
1447
2319
1448
2320
:param revision_id: if None all content is copied, if NULL_REVISION no
1449
2321
content is copied.
1453
2325
Returns the copied revision count and the failed revisions in a tuple:
1454
2326
(copied, failures).
1455
2327
"""
1456
from bzrlib.fetch import GenericRepoFetcher
1457
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1458
self.source, self.source._format, self.target, self.target._format)
1459
f = GenericRepoFetcher(to_repository=self.target,
1460
from_repository=self.source,
1461
last_revision=revision_id,
1462
pb=pb)
1463
return f.count_copied, f.failed_revisions
1464
1465
def lock_read(self):
1466
"""Take out a logical read lock.
1467
1468
This will lock the source branch and the target branch. The source gets
1469
a read lock and the target a read lock.
1470
"""
1471
self._double_lock(self.source.lock_read, self.target.lock_read)
1472
1473
def lock_write(self):
1474
"""Take out a logical write lock.
1475
1476
This will lock the source branch and the target branch. The source gets
1477
a read lock and the target a write lock.
1478
"""
1479
self._double_lock(self.source.lock_read, self.target.lock_write)
1480
2328
raise NotImplementedError(self.fetch)
2329
2330
def _walk_to_common_revisions(self, revision_ids):
2331
"""Walk out from revision_ids in source to revisions target has.
2332
2333
:param revision_ids: The start point for the search.
2334
:return: A set of revision ids.
2335
"""
2336
target_graph = self.target.get_graph()
2337
revision_ids = frozenset(revision_ids)
2338
if set(target_graph.get_parent_map(revision_ids)) == revision_ids:
2339
return graph.SearchResult(revision_ids, set(), 0, set())
2340
missing_revs = set()
2341
source_graph = self.source.get_graph()
2342
# ensure we don't pay silly lookup costs.
2343
searcher = source_graph._make_breadth_first_searcher(revision_ids)
2344
null_set = frozenset([_mod_revision.NULL_REVISION])
2345
while True:
2346
try:
2347
next_revs, ghosts = searcher.next_with_ghosts()
2348
except StopIteration:
2349
break
2350
if revision_ids.intersection(ghosts):
2351
absent_ids = set(revision_ids.intersection(ghosts))
2352
# If all absent_ids are present in target, no error is needed.
2353
absent_ids.difference_update(
2354
set(target_graph.get_parent_map(absent_ids)))
2355
if absent_ids:
2356
raise errors.NoSuchRevision(self.source, absent_ids.pop())
2357
# we don't care about other ghosts as we can't fetch them and
2358
# haven't been asked to.
2359
next_revs = set(next_revs)
2360
# we always have NULL_REVISION present.
2361
have_revs = set(target_graph.get_parent_map(next_revs)).union(null_set)
2362
missing_revs.update(next_revs - have_revs)
2363
searcher.stop_searching_any(have_revs)
2364
return searcher.get_result()
2365
2366
@deprecated_method(symbol_versioning.one_two)
1481
2367
@needs_read_lock
1482
def missing_revision_ids(self, revision_id=None):
2368
def missing_revision_ids(self, revision_id=None, find_ghosts=True):
1483
2369
"""Return the revision ids that source has that target does not.
1484
2370
1485
2371
These are returned in topological order.
1486
2372
1487
2373
:param revision_id: only return revision ids included by this
1488
2374
revision_id.
1489
"""
2375
:param find_ghosts: If True find missing revisions in deep history
2376
rather than just finding the surface difference.
2377
"""
2378
return list(self.search_missing_revision_ids(
2379
revision_id, find_ghosts).get_keys())
2380
2381
@needs_read_lock
2382
def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
2383
"""Return the revision ids that source has that target does not.
2384
2385
:param revision_id: only return revision ids included by this
2386
revision_id.
2387
:param find_ghosts: If True find missing revisions in deep history
2388
rather than just finding the surface difference.
2389
:return: A bzrlib.graph.SearchResult.
2390
"""
2391
# stop searching at found target revisions.
2392
if not find_ghosts and revision_id is not None:
2393
return self._walk_to_common_revisions([revision_id])
1490
2394
# generic, possibly worst case, slow code path.
1491
2395
target_ids = set(self.target.all_revision_ids())
1492
2396
if revision_id is not None:
1493
2397
source_ids = self.source.get_ancestry(revision_id)
1494
assert source_ids.pop(0) == None
2398
if source_ids[0] is not None:
2399
raise AssertionError()
2400
source_ids.pop(0)
1495
2401
else:
1496
2402
source_ids = self.source.all_revision_ids()
1497
2403
result_set = set(source_ids).difference(target_ids)
1498
# this may look like a no-op: its not. It preserves the ordering
1499
# other_ids had while only returning the members from other_ids
1500
# that we've decided we need.
1501
return [rev_id for rev_id in source_ids if rev_id in result_set]
1502
1503
def unlock(self):
1504
"""Release the locks on source and target."""
2404
return self.source.revision_ids_to_search_result(result_set)
2405
2406
@staticmethod
2407
def _same_model(source, target):
2408
"""True if source and target have the same data representation."""
2409
if source.supports_rich_root() != target.supports_rich_root():
2410
return False
2411
if source._serializer != target._serializer:
2412
return False
2413
return True
2414
2415
2416
class InterSameDataRepository(InterRepository):
2417
"""Code for converting between repositories that represent the same data.
2418
2419
Data format and model must match for this to work.
2420
"""
2421
2422
@classmethod
2423
def _get_repo_format_to_test(self):
2424
"""Repository format for testing with.
2425
2426
InterSameData can pull from subtree to subtree and from non-subtree to
2427
non-subtree, so we test this with the richest repository format.
2428
"""
2429
from bzrlib.repofmt import knitrepo
2430
return knitrepo.RepositoryFormatKnit3()
2431
2432
@staticmethod
2433
def is_compatible(source, target):
2434
return InterRepository._same_model(source, target)
2435
2436
@needs_write_lock
2437
def copy_content(self, revision_id=None):
2438
"""Make a complete copy of the content in self into destination.
2439
2440
This copies both the repository's revision data, and configuration information
2441
such as the make_working_trees setting.
2442
2443
This is a destructive operation! Do not use it on existing
2444
repositories.
2445
2446
:param revision_id: Only copy the content needed to construct
2447
revision_id and its parents.
2448
"""
1505
2449
try:
1506
self.target.unlock()
1507
finally:
1508
self.source.unlock()
1509
1510
1511
class InterWeaveRepo(InterRepository):
1512
"""Optimised code paths between Weave based repositories."""
1513
1514
_matching_repo_format = _default_format
1515
"""Repository format for testing with."""
2450
self.target.set_make_working_trees(self.source.make_working_trees())
2451
except NotImplementedError:
2452
pass
2453
# but don't bother fetching if we have the needed data now.
2454
if (revision_id not in (None, _mod_revision.NULL_REVISION) and
2455
self.target.has_revision(revision_id)):
2456
return
2457
self.target.fetch(self.source, revision_id=revision_id)
2458
2459
@needs_write_lock
2460
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2461
"""See InterRepository.fetch()."""
2462
from bzrlib.fetch import GenericRepoFetcher
2463
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2464
self.source, self.source._format, self.target,
2465
self.target._format)
2466
f = GenericRepoFetcher(to_repository=self.target,
2467
from_repository=self.source,
2468
last_revision=revision_id,
2469
pb=pb, find_ghosts=find_ghosts)
2470
return f.count_copied, f.failed_revisions
2471
2472
2473
class InterWeaveRepo(InterSameDataRepository):
2474
"""Optimised code paths between Weave based repositories.
2475
2476
This should be in bzrlib/repofmt/weaverepo.py but we have not yet
2477
implemented lazy inter-object optimisation.
2478
"""
2479
2480
@classmethod
2481
def _get_repo_format_to_test(self):
2482
from bzrlib.repofmt import weaverepo
2483
return weaverepo.RepositoryFormat7()
1516
2484
1517
2485
@staticmethod
1518
2486
def is_compatible(source, target):
1519
2487
"""Be compatible with known Weave formats.
1520
2488
1521
We dont test for the stores being of specific types becase that
2489
We don't test for the stores being of specific types because that
1522
2490
could lead to confusing results, and there is no need to be
1523
2491
overly general.
1524
2492
"""
2493
from bzrlib.repofmt.weaverepo import (
2494
RepositoryFormat5,
2495
RepositoryFormat6,
2496
RepositoryFormat7,
2497
)
1525
2498
try:
1526
2499
return (isinstance(source._format, (RepositoryFormat5,
1527
2500
RepositoryFormat6,
1533
2506
return False
1534
2507
1535
2508
@needs_write_lock
1536
def copy_content(self, revision_id=None, basis=None):
2509
def copy_content(self, revision_id=None):
1537
2510
"""See InterRepository.copy_content()."""
1538
2511
# weave specific optimised path:
1539
if basis is not None:
1540
# copy the basis in, then fetch remaining data.
1541
basis.copy_content_into(self.target, revision_id)
1542
# the basis copy_content_into could misset this.
2512
try:
2513
self.target.set_make_working_trees(self.source.make_working_trees())
2514
except (errors.RepositoryUpgradeRequired, NotImplemented):
2515
pass
2516
# FIXME do not peek!
2517
if self.source._transport.listable():
2518
pb = ui.ui_factory.nested_progress_bar()
1543
2519
try:
1544
self.target.set_make_working_trees(self.source.make_working_trees())
1545
except NotImplementedError:
1546
pass
2520
self.target.weave_store.copy_all_ids(
2521
self.source.weave_store,
2522
pb=pb,
2523
from_transaction=self.source.get_transaction(),
2524
to_transaction=self.target.get_transaction())
2525
pb.update('copying inventory', 0, 1)
2526
self.target.control_weaves.copy_multi(
2527
self.source.control_weaves, ['inventory'],
2528
from_transaction=self.source.get_transaction(),
2529
to_transaction=self.target.get_transaction())
2530
self.target._revision_store.text_store.copy_all_ids(
2531
self.source._revision_store.text_store,
2532
pb=pb)
2533
finally:
2534
pb.finished()
2535
else:
1547
2536
self.target.fetch(self.source, revision_id=revision_id)
1548
else:
1549
try:
1550
self.target.set_make_working_trees(self.source.make_working_trees())
1551
except NotImplementedError:
1552
pass
1553
# FIXME do not peek!
1554
if self.source.control_files._transport.listable():
1555
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1556
try:
1557
self.target.weave_store.copy_all_ids(
1558
self.source.weave_store,
1559
pb=pb,
1560
from_transaction=self.source.get_transaction(),
1561
to_transaction=self.target.get_transaction())
1562
pb.update('copying inventory', 0, 1)
1563
self.target.control_weaves.copy_multi(
1564
self.source.control_weaves, ['inventory'],
1565
from_transaction=self.source.get_transaction(),
1566
to_transaction=self.target.get_transaction())
1567
self.target._revision_store.text_store.copy_all_ids(
1568
self.source._revision_store.text_store,
1569
pb=pb)
1570
finally:
1571
pb.finished()
1572
else:
1573
self.target.fetch(self.source, revision_id=revision_id)
1574
2537
1575
2538
@needs_write_lock
1576
def fetch(self, revision_id=None, pb=None):
2539
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1577
2540
"""See InterRepository.fetch()."""
1578
2541
from bzrlib.fetch import GenericRepoFetcher
1579
2542
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1581
2544
f = GenericRepoFetcher(to_repository=self.target,
1582
2545
from_repository=self.source,
1583
2546
last_revision=revision_id,
1584
pb=pb)
2547
pb=pb, find_ghosts=find_ghosts)
1585
2548
return f.count_copied, f.failed_revisions
1586
2549
1587
2550
@needs_read_lock
1588
def missing_revision_ids(self, revision_id=None):
2551
def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
1589
2552
"""See InterRepository.missing_revision_ids()."""
1590
2553
# we want all revisions to satisfy revision_id in source.
1591
# but we dont want to stat every file here and there.
2554
# but we don't want to stat every file here and there.
1592
2555
# we want then, all revisions other needs to satisfy revision_id
1593
2556
# checked, but not those that we have locally.
1594
2557
# so the first thing is to get a subset of the revisions to
1600
2563
# - RBC 20060209
1601
2564
if revision_id is not None:
1602
2565
source_ids = self.source.get_ancestry(revision_id)
1603
assert source_ids.pop(0) == None
2566
if source_ids[0] is not None:
2567
raise AssertionError()
2568
source_ids.pop(0)
1604
2569
else:
1605
2570
source_ids = self.source._all_possible_ids()
1606
2571
source_ids_set = set(source_ids)
1607
2572
# source_ids is the worst possible case we may need to pull.
1608
2573
# now we want to filter source_ids against what we actually
1609
# have in target, but dont try to check for existence where we know
2574
# have in target, but don't try to check for existence where we know
1610
2575
# we do not have a revision as that would be pointless.
1611
2576
target_ids = set(self.target._all_possible_ids())
1612
2577
possibly_present_revisions = target_ids.intersection(source_ids_set)
1613
actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
2578
actually_present_revisions = set(
2579
self.target._eliminate_revisions_not_present(possibly_present_revisions))
1614
2580
required_revisions = source_ids_set.difference(actually_present_revisions)
1615
required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
1616
2581
if revision_id is not None:
1617
2582
# we used get_ancestry to determine source_ids then we are assured all
1618
2583
# revisions referenced are present as they are installed in topological order.
1619
2584
# and the tip revision was validated by get_ancestry.
1620
return required_topo_revisions
2585
result_set = required_revisions
1621
2586
else:
1622
2587
# if we just grabbed the possibly available ids, then
1623
2588
# we only have an estimate of whats available and need to validate
1624
2589
# that against the revision records.
1625
return self.source._eliminate_revisions_not_present(required_topo_revisions)
1626
1627
1628
class InterKnitRepo(InterRepository):
2590
result_set = set(
2591
self.source._eliminate_revisions_not_present(required_revisions))
2592
return self.source.revision_ids_to_search_result(result_set)
2593
2594
2595
class InterKnitRepo(InterSameDataRepository):
1629
2596
"""Optimised code paths between Knit based repositories."""
1630
2597
1631
_matching_repo_format = RepositoryFormatKnit1()
1632
"""Repository format for testing with."""
2598
@classmethod
2599
def _get_repo_format_to_test(self):
2600
from bzrlib.repofmt import knitrepo
2601
return knitrepo.RepositoryFormatKnit1()
1633
2602
1634
2603
@staticmethod
1635
2604
def is_compatible(source, target):
1636
2605
"""Be compatible with known Knit formats.
1637
2606
1638
We dont test for the stores being of specific types becase that
2607
We don't test for the stores being of specific types because that
1639
2608
could lead to confusing results, and there is no need to be
1640
2609
overly general.
1641
2610
"""
2611
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit
1642
2612
try:
1643
return (isinstance(source._format, (RepositoryFormatKnit1)) and
1644
isinstance(target._format, (RepositoryFormatKnit1)))
2613
are_knits = (isinstance(source._format, RepositoryFormatKnit) and
2614
isinstance(target._format, RepositoryFormatKnit))
1645
2615
except AttributeError:
1646
2616
return False
2617
return are_knits and InterRepository._same_model(source, target)
1647
2618
1648
2619
@needs_write_lock
1649
def fetch(self, revision_id=None, pb=None):
2620
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1650
2621
"""See InterRepository.fetch()."""
1651
2622
from bzrlib.fetch import KnitRepoFetcher
1652
2623
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1654
2625
f = KnitRepoFetcher(to_repository=self.target,
1655
2626
from_repository=self.source,
1656
2627
last_revision=revision_id,
1657
pb=pb)
2628
pb=pb, find_ghosts=find_ghosts)
1658
2629
return f.count_copied, f.failed_revisions
1659
2630
1660
2631
@needs_read_lock
1661
def missing_revision_ids(self, revision_id=None):
2632
def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
1662
2633
"""See InterRepository.missing_revision_ids()."""
1663
2634
if revision_id is not None:
1664
2635
source_ids = self.source.get_ancestry(revision_id)
1665
assert source_ids.pop(0) == None
2636
if source_ids[0] is not None:
2637
raise AssertionError()
2638
source_ids.pop(0)
1666
2639
else:
1667
source_ids = self.source._all_possible_ids()
2640
source_ids = self.source.all_revision_ids()
1668
2641
source_ids_set = set(source_ids)
1669
2642
# source_ids is the worst possible case we may need to pull.
1670
2643
# now we want to filter source_ids against what we actually
1671
# have in target, but dont try to check for existence where we know
2644
# have in target, but don't try to check for existence where we know
1672
2645
# we do not have a revision as that would be pointless.
1673
target_ids = set(self.target._all_possible_ids())
2646
target_ids = set(self.target.all_revision_ids())
1674
2647
possibly_present_revisions = target_ids.intersection(source_ids_set)
1675
actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
2648
actually_present_revisions = set(
2649
self.target._eliminate_revisions_not_present(possibly_present_revisions))
1676
2650
required_revisions = source_ids_set.difference(actually_present_revisions)
1677
required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
1678
2651
if revision_id is not None:
1679
2652
# we used get_ancestry to determine source_ids then we are assured all
1680
2653
# revisions referenced are present as they are installed in topological order.
1681
2654
# and the tip revision was validated by get_ancestry.
1682
return required_topo_revisions
2655
result_set = required_revisions
1683
2656
else:
1684
2657
# if we just grabbed the possibly available ids, then
1685
2658
# we only have an estimate of whats available and need to validate
1686
2659
# that against the revision records.
1687
return self.source._eliminate_revisions_not_present(required_topo_revisions)
1688
2660
result_set = set(
2661
self.source._eliminate_revisions_not_present(required_revisions))
2662
return self.source.revision_ids_to_search_result(result_set)
2663
2664
2665
class InterPackRepo(InterSameDataRepository):
2666
"""Optimised code paths between Pack based repositories."""
2667
2668
@classmethod
2669
def _get_repo_format_to_test(self):
2670
from bzrlib.repofmt import pack_repo
2671
return pack_repo.RepositoryFormatKnitPack1()
2672
2673
@staticmethod
2674
def is_compatible(source, target):
2675
"""Be compatible with known Pack formats.
2676
2677
We don't test for the stores being of specific types because that
2678
could lead to confusing results, and there is no need to be
2679
overly general.
2680
"""
2681
from bzrlib.repofmt.pack_repo import RepositoryFormatPack
2682
try:
2683
are_packs = (isinstance(source._format, RepositoryFormatPack) and
2684
isinstance(target._format, RepositoryFormatPack))
2685
except AttributeError:
2686
return False
2687
return are_packs and InterRepository._same_model(source, target)
2688
2689
@needs_write_lock
2690
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2691
"""See InterRepository.fetch()."""
2692
from bzrlib.repofmt.pack_repo import Packer
2693
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2694
self.source, self.source._format, self.target, self.target._format)
2695
self.count_copied = 0
2696
if revision_id is None:
2697
# TODO:
2698
# everything to do - use pack logic
2699
# to fetch from all packs to one without
2700
# inventory parsing etc, IFF nothing to be copied is in the target.
2701
# till then:
2702
revision_ids = self.source.all_revision_ids()
2703
revision_keys = [(revid,) for revid in revision_ids]
2704
index = self.target._pack_collection.revision_index.combined_index
2705
present_revision_ids = set(item[1][0] for item in
2706
index.iter_entries(revision_keys))
2707
revision_ids = set(revision_ids) - present_revision_ids
2708
# implementing the TODO will involve:
2709
# - detecting when all of a pack is selected
2710
# - avoiding as much as possible pre-selection, so the
2711
# more-core routines such as create_pack_from_packs can filter in
2712
# a just-in-time fashion. (though having a HEADS list on a
2713
# repository might make this a lot easier, because we could
2714
# sensibly detect 'new revisions' without doing a full index scan.
2715
elif _mod_revision.is_null(revision_id):
2716
# nothing to do:
2717
return (0, [])
2718
else:
2719
try:
2720
revision_ids = self.search_missing_revision_ids(revision_id,
2721
find_ghosts=find_ghosts).get_keys()
2722
except errors.NoSuchRevision:
2723
raise errors.InstallFailed([revision_id])
2724
if len(revision_ids) == 0:
2725
return (0, [])
2726
packs = self.source._pack_collection.all_packs()
2727
pack = Packer(self.target._pack_collection, packs, '.fetch',
2728
revision_ids).pack()
2729
if pack is not None:
2730
self.target._pack_collection._save_pack_names()
2731
# Trigger an autopack. This may duplicate effort as we've just done
2732
# a pack creation, but for now it is simpler to think about as
2733
# 'upload data, then repack if needed'.
2734
self.target._pack_collection.autopack()
2735
return (pack.get_revision_count(), [])
2736
else:
2737
return (0, [])
2738
2739
@needs_read_lock
2740
def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
2741
"""See InterRepository.missing_revision_ids().
2742
2743
:param find_ghosts: Find ghosts throughout the ancestry of
2744
revision_id.
2745
"""
2746
if not find_ghosts and revision_id is not None:
2747
return self._walk_to_common_revisions([revision_id])
2748
elif revision_id is not None:
2749
source_ids = self.source.get_ancestry(revision_id)
2750
if source_ids[0] is not None:
2751
raise AssertionError()
2752
source_ids.pop(0)
2753
else:
2754
source_ids = self.source.all_revision_ids()
2755
# source_ids is the worst possible case we may need to pull.
2756
# now we want to filter source_ids against what we actually
2757
# have in target, but don't try to check for existence where we know
2758
# we do not have a revision as that would be pointless.
2759
target_ids = set(self.target.all_revision_ids())
2760
result_set = set(source_ids).difference(target_ids)
2761
return self.source.revision_ids_to_search_result(result_set)
2762
2763
2764
class InterModel1and2(InterRepository):
2765
2766
@classmethod
2767
def _get_repo_format_to_test(self):
2768
return None
2769
2770
@staticmethod
2771
def is_compatible(source, target):
2772
if not source.supports_rich_root() and target.supports_rich_root():
2773
return True
2774
else:
2775
return False
2776
2777
@needs_write_lock
2778
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2779
"""See InterRepository.fetch()."""
2780
from bzrlib.fetch import Model1toKnit2Fetcher
2781
f = Model1toKnit2Fetcher(to_repository=self.target,
2782
from_repository=self.source,
2783
last_revision=revision_id,
2784
pb=pb, find_ghosts=find_ghosts)
2785
return f.count_copied, f.failed_revisions
2786
2787
@needs_write_lock
2788
def copy_content(self, revision_id=None):
2789
"""Make a complete copy of the content in self into destination.
2790
2791
This is a destructive operation! Do not use it on existing
2792
repositories.
2793
2794
:param revision_id: Only copy the content needed to construct
2795
revision_id and its parents.
2796
"""
2797
try:
2798
self.target.set_make_working_trees(self.source.make_working_trees())
2799
except NotImplementedError:
2800
pass
2801
# but don't bother fetching if we have the needed data now.
2802
if (revision_id not in (None, _mod_revision.NULL_REVISION) and
2803
self.target.has_revision(revision_id)):
2804
return
2805
self.target.fetch(self.source, revision_id=revision_id)
2806
2807
2808
class InterKnit1and2(InterKnitRepo):
2809
2810
@classmethod
2811
def _get_repo_format_to_test(self):
2812
return None
2813
2814
@staticmethod
2815
def is_compatible(source, target):
2816
"""Be compatible with Knit1 source and Knit3 target"""
2817
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit3
2818
try:
2819
from bzrlib.repofmt.knitrepo import (RepositoryFormatKnit1,
2820
RepositoryFormatKnit3)
2821
from bzrlib.repofmt.pack_repo import (
2822
RepositoryFormatKnitPack1,
2823
RepositoryFormatKnitPack3,
2824
RepositoryFormatPackDevelopment0,
2825
RepositoryFormatPackDevelopment0Subtree,
2826
)
2827
nosubtrees = (
2828
RepositoryFormatKnit1,
2829
RepositoryFormatKnitPack1,
2830
RepositoryFormatPackDevelopment0,
2831
)
2832
subtrees = (
2833
RepositoryFormatKnit3,
2834
RepositoryFormatKnitPack3,
2835
RepositoryFormatPackDevelopment0Subtree,
2836
)
2837
return (isinstance(source._format, nosubtrees) and
2838
isinstance(target._format, subtrees))
2839
except AttributeError:
2840
return False
2841
2842
@needs_write_lock
2843
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2844
"""See InterRepository.fetch()."""
2845
from bzrlib.fetch import Knit1to2Fetcher
2846
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2847
self.source, self.source._format, self.target,
2848
self.target._format)
2849
f = Knit1to2Fetcher(to_repository=self.target,
2850
from_repository=self.source,
2851
last_revision=revision_id,
2852
pb=pb, find_ghosts=find_ghosts)
2853
return f.count_copied, f.failed_revisions
2854
2855
2856
class InterDifferingSerializer(InterKnitRepo):
2857
2858
@classmethod
2859
def _get_repo_format_to_test(self):
2860
return None
2861
2862
@staticmethod
2863
def is_compatible(source, target):
2864
"""Be compatible with Knit2 source and Knit3 target"""
2865
if source.supports_rich_root() != target.supports_rich_root():
2866
return False
2867
# Ideally, we'd support fetching if the source had no tree references
2868
# even if it supported them...
2869
if (getattr(source, '_format.supports_tree_reference', False) and
2870
not getattr(target, '_format.supports_tree_reference', False)):
2871
return False
2872
return True
2873
2874
@needs_write_lock
2875
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2876
"""See InterRepository.fetch()."""
2877
revision_ids = self.target.search_missing_revision_ids(self.source,
2878
revision_id, find_ghosts=find_ghosts).get_keys()
2879
revision_ids = tsort.topo_sort(
2880
self.source.get_graph().get_parent_map(revision_ids))
2881
def revisions_iterator():
2882
for current_revision_id in revision_ids:
2883
revision = self.source.get_revision(current_revision_id)
2884
tree = self.source.revision_tree(current_revision_id)
2885
try:
2886
signature = self.source.get_signature_text(
2887
current_revision_id)
2888
except errors.NoSuchRevision:
2889
signature = None
2890
yield revision, tree, signature
2891
if pb is None:
2892
my_pb = ui.ui_factory.nested_progress_bar()
2893
pb = my_pb
2894
else:
2895
my_pb = None
2896
try:
2897
install_revisions(self.target, revisions_iterator(),
2898
len(revision_ids), pb)
2899
finally:
2900
if my_pb is not None:
2901
my_pb.finished()
2902
return len(revision_ids), 0
2903
2904
2905
class InterRemoteToOther(InterRepository):
2906
2907
def __init__(self, source, target):
2908
InterRepository.__init__(self, source, target)
2909
self._real_inter = None
2910
2911
@staticmethod
2912
def is_compatible(source, target):
2913
if not isinstance(source, remote.RemoteRepository):
2914
return False
2915
# Is source's model compatible with target's model?
2916
source._ensure_real()
2917
real_source = source._real_repository
2918
if isinstance(real_source, remote.RemoteRepository):
2919
raise NotImplementedError(
2920
"We don't support remote repos backed by remote repos yet.")
2921
return InterRepository._same_model(real_source, target)
2922
2923
@needs_write_lock
2924
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2925
"""See InterRepository.fetch()."""
2926
from bzrlib.fetch import RemoteToOtherFetcher
2927
mutter("Using fetch logic to copy between %s(remote) and %s(%s)",
2928
self.source, self.target, self.target._format)
2929
# TODO: jam 20070210 This should be an assert, not a translate
2930
revision_id = osutils.safe_revision_id(revision_id)
2931
f = RemoteToOtherFetcher(to_repository=self.target,
2932
from_repository=self.source,
2933
last_revision=revision_id,
2934
pb=pb, find_ghosts=find_ghosts)
2935
return f.count_copied, f.failed_revisions
2936
2937
@classmethod
2938
def _get_repo_format_to_test(self):
2939
return None
2940
2941
2942
class InterOtherToRemote(InterRepository):
2943
2944
def __init__(self, source, target):
2945
InterRepository.__init__(self, source, target)
2946
self._real_inter = None
2947
2948
@staticmethod
2949
def is_compatible(source, target):
2950
if isinstance(target, remote.RemoteRepository):
2951
return True
2952
return False
2953
2954
def _ensure_real_inter(self):
2955
if self._real_inter is None:
2956
self.target._ensure_real()
2957
real_target = self.target._real_repository
2958
self._real_inter = InterRepository.get(self.source, real_target)
2959
2960
def copy_content(self, revision_id=None):
2961
self._ensure_real_inter()
2962
self._real_inter.copy_content(revision_id=revision_id)
2963
2964
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2965
self._ensure_real_inter()
2966
self._real_inter.fetch(revision_id=revision_id, pb=pb,
2967
find_ghosts=find_ghosts)
2968
2969
@classmethod
2970
def _get_repo_format_to_test(self):
2971
return None
2972
2973
2974
InterRepository.register_optimiser(InterDifferingSerializer)
2975
InterRepository.register_optimiser(InterSameDataRepository)
1689
2976
InterRepository.register_optimiser(InterWeaveRepo)
1690
2977
InterRepository.register_optimiser(InterKnitRepo)
1691
1692
1693
class RepositoryTestProviderAdapter(object):
1694
"""A tool to generate a suite testing multiple repository formats at once.
1695
1696
This is done by copying the test once for each transport and injecting
1697
the transport_server, transport_readonly_server, and bzrdir_format and
1698
repository_format classes into each copy. Each copy is also given a new id()
1699
to make it easy to identify.
1700
"""
1701
1702
def __init__(self, transport_server, transport_readonly_server, formats):
1703
self._transport_server = transport_server
1704
self._transport_readonly_server = transport_readonly_server
1705
self._formats = formats
1706
1707
def adapt(self, test):
1708
result = TestSuite()
1709
for repository_format, bzrdir_format in self._formats:
1710
new_test = deepcopy(test)
1711
new_test.transport_server = self._transport_server
1712
new_test.transport_readonly_server = self._transport_readonly_server
1713
new_test.bzrdir_format = bzrdir_format
1714
new_test.repository_format = repository_format
1715
def make_new_test_id():
1716
new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
1717
return lambda: new_id
1718
new_test.id = make_new_test_id()
1719
result.addTest(new_test)
1720
return result
1721
1722
1723
class InterRepositoryTestProviderAdapter(object):
1724
"""A tool to generate a suite testing multiple inter repository formats.
1725
1726
This is done by copying the test once for each interrepo provider and injecting
1727
the transport_server, transport_readonly_server, repository_format and
1728
repository_to_format classes into each copy.
1729
Each copy is also given a new id() to make it easy to identify.
1730
"""
1731
1732
def __init__(self, transport_server, transport_readonly_server, formats):
1733
self._transport_server = transport_server
1734
self._transport_readonly_server = transport_readonly_server
1735
self._formats = formats
1736
1737
def adapt(self, test):
1738
result = TestSuite()
1739
for interrepo_class, repository_format, repository_format_to in self._formats:
1740
new_test = deepcopy(test)
1741
new_test.transport_server = self._transport_server
1742
new_test.transport_readonly_server = self._transport_readonly_server
1743
new_test.interrepo_class = interrepo_class
1744
new_test.repository_format = repository_format
1745
new_test.repository_format_to = repository_format_to
1746
def make_new_test_id():
1747
new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
1748
return lambda: new_id
1749
new_test.id = make_new_test_id()
1750
result.addTest(new_test)
1751
return result
1752
1753
@staticmethod
1754
def default_test_list():
1755
"""Generate the default list of interrepo permutations to test."""
1756
result = []
1757
# test the default InterRepository between format 6 and the current
1758
# default format.
1759
# XXX: robertc 20060220 reinstate this when there are two supported
1760
# formats which do not have an optimal code path between them.
1761
result.append((InterRepository,
1762
RepositoryFormat6(),
1763
RepositoryFormatKnit1()))
1764
for optimiser in InterRepository._optimisers:
1765
result.append((optimiser,
1766
optimiser._matching_repo_format,
1767
optimiser._matching_repo_format
1768
))
1769
# if there are specific combinations we want to use, we can add them
1770
# here.
1771
return result
2978
InterRepository.register_optimiser(InterModel1and2)
2979
InterRepository.register_optimiser(InterKnit1and2)
2980
InterRepository.register_optimiser(InterPackRepo)
2981
InterRepository.register_optimiser(InterRemoteToOther)
2982
InterRepository.register_optimiser(InterOtherToRemote)
1772
2983
1773
2984
1774
2985
class CopyConverter(object):
1800
3011
self.step('Moving repository to repository.backup')
1801
3012
self.repo_dir.transport.move('repository', 'repository.backup')
1802
3013
backup_transport = self.repo_dir.transport.clone('repository.backup')
3014
repo._format.check_conversion_target(self.target_format)
1803
3015
self.source_repo = repo._format.open(self.repo_dir,
1804
3016
_found=True,
1805
3017
_override_transport=backup_transport)
1822
3034
self.pb.update(message, self.count, self.total)
1823
3035
1824
3036
1825
# Copied from xml.sax.saxutils
3037
_unescape_map = {
3038
'apos':"'",
3039
'quot':'"',
3040
'amp':'&',
3041
'lt':'<',
3042
'gt':'>'
3043
}
3044
3045
3046
def _unescaper(match, _map=_unescape_map):
3047
code = match.group(1)
3048
try:
3049
return _map[code]
3050
except KeyError:
3051
if not code.startswith('#'):
3052
raise
3053
return unichr(int(code[1:])).encode('utf8')
3054
3055
3056
_unescape_re = None
3057
3058
1826
3059
def _unescape_xml(data):
1827
"""Unescape &, <, and > in a string of data.
1828
"""
1829
data = data.replace("<", "<")
1830
data = data.replace(">", ">")
1831
# must do ampersand last
1832
return data.replace("&", "&")
3060
"""Unescape predefined XML entities in a string of data."""
3061
global _unescape_re
3062
if _unescape_re is None:
3063
_unescape_re = re.compile('\&([^;]*);')
3064
return _unescape_re.sub(_unescaper, data)
3065
3066
3067
class _VersionedFileChecker(object):
3068
3069
def __init__(self, repository):
3070
self.repository = repository
3071
self.text_index = self.repository._generate_text_key_index()
3072
3073
def calculate_file_version_parents(self, revision_id, file_id):
3074
"""Calculate the correct parents for a file version according to
3075
the inventories.
3076
"""
3077
parent_keys = self.text_index[(file_id, revision_id)]
3078
if parent_keys == [_mod_revision.NULL_REVISION]:
3079
return ()
3080
# strip the file_id, for the weave api
3081
return tuple([revision_id for file_id, revision_id in parent_keys])
3082
3083
def check_file_version_parents(self, weave, file_id):
3084
"""Check the parents stored in a versioned file are correct.
3085
3086
It also detects file versions that are not referenced by their
3087
corresponding revision's inventory.
3088
3089
:returns: A tuple of (wrong_parents, dangling_file_versions).
3090
wrong_parents is a dict mapping {revision_id: (stored_parents,
3091
correct_parents)} for each revision_id where the stored parents
3092
are not correct. dangling_file_versions is a set of (file_id,
3093
revision_id) tuples for versions that are present in this versioned
3094
file, but not used by the corresponding inventory.
3095
"""
3096
wrong_parents = {}
3097
unused_versions = set()
3098
versions = weave.versions()
3099
parent_map = weave.get_parent_map(versions)
3100
for num, revision_id in enumerate(versions):
3101
try:
3102
correct_parents = self.calculate_file_version_parents(
3103
revision_id, file_id)
3104
except KeyError:
3105
# The version is not part of the used keys.
3106
unused_versions.add(revision_id)
3107
else:
3108
try:
3109
knit_parents = tuple(parent_map[revision_id])
3110
except errors.RevisionNotPresent:
3111
knit_parents = None
3112
if correct_parents != knit_parents:
3113
wrong_parents[revision_id] = (knit_parents, correct_parents)
3114
return wrong_parents, unused_versions
3115
3116
3117
def _old_get_graph(repository, revision_id):
3118
"""DO NOT USE. That is all. I'm serious."""
3119
graph = repository.get_graph()
3120
revision_graph = dict(((key, value) for key, value in
3121
graph.iter_ancestry([revision_id]) if value is not None))
3122
return _strip_NULL_ghosts(revision_graph)
3123
3124
3125
def _strip_NULL_ghosts(revision_graph):
3126
"""Also don't use this. more compatibility code for unmigrated clients."""
3127
# Filter ghosts, and null:
3128
if _mod_revision.NULL_REVISION in revision_graph:
3129
del revision_graph[_mod_revision.NULL_REVISION]
3130
for key, parents in revision_graph.items():
3131
revision_graph[key] = tuple(parent for parent in parents if parent
3132
in revision_graph)
3133
return revision_graph
Loggerhead is a web-based interface for Breezy
Version: 2.0.1