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