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