(root)/brz/remove-bazaar
» Revision
0.200.1036
(compared to revision 2001.1.1)
: bzrlib/repository.py
To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/repository.py
- browse files at revision 0.200.1036
- compare with another revision
- download diff
- download tarball
- view history from revision 0.200.1036
- Committer: Jelmer Vernooij
- Date: 2010-09-11 17:48:45 UTC
- mto: (0.312.1 master) (6883.23.1 bundle-git)
- mto: This revision was merged to the branch mainline in revision 6960.
- Revision ID: jelmer@samba.org-20100911174845-ro06bb6gg6ws8jit
More work on roundtrip push support.
- files added:
- .bzrignore
- notes
- tests
- files removed:
- .bzrignore
- bzrlib
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/plugins/launchpad
- bzrlib/store
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/intertree_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- doc
- tools
- tools/doc_generate
- tools/win32
added
removed
bzrlib/repository.py
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
#
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
7
#
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
12
#
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
from binascii import hexlify
18
from copy import deepcopy
19
from cStringIO import StringIO
20
import re
21
import time
22
from unittest import TestSuite
23
24
from bzrlib import (
25
bzrdir,
26
check,
27
delta,
28
gpg,
29
errors,
30
osutils,
31
transactions,
32
ui,
33
xml5,
34
xml6,
35
)
36
from bzrlib.decorators import needs_read_lock, needs_write_lock
37
from bzrlib.errors import InvalidRevisionId
38
from bzrlib.graph import Graph
39
from bzrlib.inter import InterObject
40
from bzrlib.inventory import Inventory, InventoryDirectory, ROOT_ID
41
from bzrlib.knit import KnitVersionedFile, KnitPlainFactory
42
from bzrlib.lockable_files import LockableFiles, TransportLock
43
from bzrlib.lockdir import LockDir
44
from bzrlib.osutils import (safe_unicode, rand_bytes, compact_date,
45
local_time_offset)
46
from bzrlib.revision import NULL_REVISION, Revision
47
from bzrlib.revisiontree import RevisionTree
48
from bzrlib.store.versioned import VersionedFileStore, WeaveStore
49
from bzrlib.store.text import TextStore
50
from bzrlib import symbol_versioning
51
from bzrlib.symbol_versioning import (deprecated_method,
52
zero_nine,
53
)
54
from bzrlib.testament import Testament
55
from bzrlib.trace import mutter, note, warning
56
from bzrlib.tsort import topo_sort
57
from bzrlib.weave import WeaveFile
58
59
60
# Old formats display a warning, but only once
61
_deprecation_warning_done = False
62
63
64
class Repository(object):
65
"""Repository holding history for one or more branches.
66
67
The repository holds and retrieves historical information including
68
revisions and file history. It's normally accessed only by the Branch,
69
which views a particular line of development through that history.
70
71
The Repository builds on top of Stores and a Transport, which respectively
72
describe the disk data format and the way of accessing the (possibly
73
remote) disk.
74
"""
75
76
@needs_write_lock
77
def add_inventory(self, revid, inv, parents):
78
"""Add the inventory inv to the repository as revid.
79
80
:param parents: The revision ids of the parents that revid
81
is known to have and are in the repository already.
82
83
returns the sha1 of the serialized inventory.
84
"""
85
assert inv.revision_id is None or inv.revision_id == revid, \
86
"Mismatch between inventory revision" \
87
" id and insertion revid (%r, %r)" % (inv.revision_id, revid)
88
assert inv.root is not None
89
inv_text = self.serialise_inventory(inv)
90
inv_sha1 = osutils.sha_string(inv_text)
91
inv_vf = self.control_weaves.get_weave('inventory',
92
self.get_transaction())
93
self._inventory_add_lines(inv_vf, revid, parents, osutils.split_lines(inv_text))
94
return inv_sha1
95
96
def _inventory_add_lines(self, inv_vf, revid, parents, lines):
97
final_parents = []
98
for parent in parents:
99
if parent in inv_vf:
100
final_parents.append(parent)
101
102
inv_vf.add_lines(revid, final_parents, lines)
103
104
@needs_write_lock
105
def add_revision(self, rev_id, rev, inv=None, config=None):
106
"""Add rev to the revision store as rev_id.
107
108
:param rev_id: the revision id to use.
109
:param rev: The revision object.
110
:param inv: The inventory for the revision. if None, it will be looked
111
up in the inventory storer
112
:param config: If None no digital signature will be created.
113
If supplied its signature_needed method will be used
114
to determine if a signature should be made.
115
"""
116
if config is not None and config.signature_needed():
117
if inv is None:
118
inv = self.get_inventory(rev_id)
119
plaintext = Testament(rev, inv).as_short_text()
120
self.store_revision_signature(
121
gpg.GPGStrategy(config), plaintext, rev_id)
122
if not rev_id in self.get_inventory_weave():
123
if inv is None:
124
raise errors.WeaveRevisionNotPresent(rev_id,
125
self.get_inventory_weave())
126
else:
127
# yes, this is not suitable for adding with ghosts.
128
self.add_inventory(rev_id, inv, rev.parent_ids)
129
self._revision_store.add_revision(rev, self.get_transaction())
130
131
@needs_read_lock
132
def _all_possible_ids(self):
133
"""Return all the possible revisions that we could find."""
134
return self.get_inventory_weave().versions()
135
136
def all_revision_ids(self):
137
"""Returns a list of all the revision ids in the repository.
138
139
This is deprecated because code should generally work on the graph
140
reachable from a particular revision, and ignore any other revisions
141
that might be present. There is no direct replacement method.
142
"""
143
return self._all_revision_ids()
144
145
@needs_read_lock
146
def _all_revision_ids(self):
147
"""Returns a list of all the revision ids in the repository.
148
149
These are in as much topological order as the underlying store can
150
present: for weaves ghosts may lead to a lack of correctness until
151
the reweave updates the parents list.
152
"""
153
if self._revision_store.text_store.listable():
154
return self._revision_store.all_revision_ids(self.get_transaction())
155
result = self._all_possible_ids()
156
return self._eliminate_revisions_not_present(result)
157
158
def break_lock(self):
159
"""Break a lock if one is present from another instance.
160
161
Uses the ui factory to ask for confirmation if the lock may be from
162
an active process.
163
"""
164
self.control_files.break_lock()
165
166
@needs_read_lock
167
def _eliminate_revisions_not_present(self, revision_ids):
168
"""Check every revision id in revision_ids to see if we have it.
169
170
Returns a set of the present revisions.
171
"""
172
result = []
173
for id in revision_ids:
174
if self.has_revision(id):
175
result.append(id)
176
return result
177
178
@staticmethod
179
def create(a_bzrdir):
180
"""Construct the current default format repository in a_bzrdir."""
181
return RepositoryFormat.get_default_format().initialize(a_bzrdir)
182
183
def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
184
"""instantiate a Repository.
185
186
:param _format: The format of the repository on disk.
187
:param a_bzrdir: The BzrDir of the repository.
188
189
In the future we will have a single api for all stores for
190
getting file texts, inventories and revisions, then
191
this construct will accept instances of those things.
192
"""
193
super(Repository, self).__init__()
194
self._format = _format
195
# the following are part of the public API for Repository:
196
self.bzrdir = a_bzrdir
197
self.control_files = control_files
198
self._revision_store = _revision_store
199
self.text_store = text_store
200
# backwards compatibility
201
self.weave_store = text_store
202
# not right yet - should be more semantically clear ?
203
#
204
self.control_store = control_store
205
self.control_weaves = control_store
206
# TODO: make sure to construct the right store classes, etc, depending
207
# on whether escaping is required.
208
self._warn_if_deprecated()
209
self._serializer = xml5.serializer_v5
210
211
def __repr__(self):
212
return '%s(%r)' % (self.__class__.__name__,
213
self.bzrdir.transport.base)
214
215
def is_locked(self):
216
return self.control_files.is_locked()
217
218
def lock_write(self):
219
self.control_files.lock_write()
220
221
def lock_read(self):
222
self.control_files.lock_read()
223
224
def get_physical_lock_status(self):
225
return self.control_files.get_physical_lock_status()
226
227
@needs_read_lock
228
def missing_revision_ids(self, other, revision_id=None):
229
"""Return the revision ids that other has that this does not.
230
231
These are returned in topological order.
232
233
revision_id: only return revision ids included by revision_id.
234
"""
235
return InterRepository.get(other, self).missing_revision_ids(revision_id)
236
237
@staticmethod
238
def open(base):
239
"""Open the repository rooted at base.
240
241
For instance, if the repository is at URL/.bzr/repository,
242
Repository.open(URL) -> a Repository instance.
243
"""
244
control = bzrdir.BzrDir.open(base)
245
return control.open_repository()
246
247
def copy_content_into(self, destination, revision_id=None, basis=None):
248
"""Make a complete copy of the content in self into destination.
249
250
This is a destructive operation! Do not use it on existing
251
repositories.
252
"""
253
return InterRepository.get(self, destination).copy_content(revision_id, basis)
254
255
def fetch(self, source, revision_id=None, pb=None):
256
"""Fetch the content required to construct revision_id from source.
257
258
If revision_id is None all content is copied.
259
"""
260
return InterRepository.get(source, self).fetch(revision_id=revision_id,
261
pb=pb)
262
263
def get_commit_builder(self, branch, parents, config, timestamp=None,
264
timezone=None, committer=None, revprops=None,
265
revision_id=None):
266
"""Obtain a CommitBuilder for this repository.
267
268
:param branch: Branch to commit to.
269
:param parents: Revision ids of the parents of the new revision.
270
:param config: Configuration to use.
271
:param timestamp: Optional timestamp recorded for commit.
272
:param timezone: Optional timezone for timestamp.
273
:param committer: Optional committer to set for commit.
274
:param revprops: Optional dictionary of revision properties.
275
:param revision_id: Optional revision id.
276
"""
277
return _CommitBuilder(self, parents, config, timestamp, timezone,
278
committer, revprops, revision_id)
279
280
def unlock(self):
281
self.control_files.unlock()
282
283
@needs_read_lock
284
def clone(self, a_bzrdir, revision_id=None, basis=None):
285
"""Clone this repository into a_bzrdir using the current format.
286
287
Currently no check is made that the format of this repository and
288
the bzrdir format are compatible. FIXME RBC 20060201.
289
"""
290
if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
291
# use target default format.
292
result = a_bzrdir.create_repository()
293
# FIXME RBC 20060209 split out the repository type to avoid this check ?
294
elif isinstance(a_bzrdir._format,
295
(bzrdir.BzrDirFormat4,
296
bzrdir.BzrDirFormat5,
297
bzrdir.BzrDirFormat6)):
298
result = a_bzrdir.open_repository()
299
else:
300
result = self._format.initialize(a_bzrdir, shared=self.is_shared())
301
self.copy_content_into(result, revision_id, basis)
302
return result
303
304
@needs_read_lock
305
def has_revision(self, revision_id):
306
"""True if this repository has a copy of the revision."""
307
return self._revision_store.has_revision_id(revision_id,
308
self.get_transaction())
309
310
@needs_read_lock
311
def get_revision_reconcile(self, revision_id):
312
"""'reconcile' helper routine that allows access to a revision always.
313
314
This variant of get_revision does not cross check the weave graph
315
against the revision one as get_revision does: but it should only
316
be used by reconcile, or reconcile-alike commands that are correcting
317
or testing the revision graph.
318
"""
319
if not revision_id or not isinstance(revision_id, basestring):
320
raise InvalidRevisionId(revision_id=revision_id, branch=self)
321
return self._revision_store.get_revisions([revision_id],
322
self.get_transaction())[0]
323
@needs_read_lock
324
def get_revisions(self, revision_ids):
325
return self._revision_store.get_revisions(revision_ids,
326
self.get_transaction())
327
328
@needs_read_lock
329
def get_revision_xml(self, revision_id):
330
rev = self.get_revision(revision_id)
331
rev_tmp = StringIO()
332
# the current serializer..
333
self._revision_store._serializer.write_revision(rev, rev_tmp)
334
rev_tmp.seek(0)
335
return rev_tmp.getvalue()
336
337
@needs_read_lock
338
def get_revision(self, revision_id):
339
"""Return the Revision object for a named revision"""
340
r = self.get_revision_reconcile(revision_id)
341
# weave corruption can lead to absent revision markers that should be
342
# present.
343
# the following test is reasonably cheap (it needs a single weave read)
344
# and the weave is cached in read transactions. In write transactions
345
# it is not cached but typically we only read a small number of
346
# revisions. For knits when they are introduced we will probably want
347
# to ensure that caching write transactions are in use.
348
inv = self.get_inventory_weave()
349
self._check_revision_parents(r, inv)
350
return r
351
352
@needs_read_lock
353
def get_deltas_for_revisions(self, revisions):
354
"""Produce a generator of revision deltas.
355
356
Note that the input is a sequence of REVISIONS, not revision_ids.
357
Trees will be held in memory until the generator exits.
358
Each delta is relative to the revision's lefthand predecessor.
359
"""
360
required_trees = set()
361
for revision in revisions:
362
required_trees.add(revision.revision_id)
363
required_trees.update(revision.parent_ids[:1])
364
trees = dict((t.get_revision_id(), t) for
365
t in self.revision_trees(required_trees))
366
for revision in revisions:
367
if not revision.parent_ids:
368
old_tree = self.revision_tree(None)
369
else:
370
old_tree = trees[revision.parent_ids[0]]
371
yield trees[revision.revision_id].changes_from(old_tree)
372
373
@needs_read_lock
374
def get_revision_delta(self, revision_id):
375
"""Return the delta for one revision.
376
377
The delta is relative to the left-hand predecessor of the
378
revision.
379
"""
380
r = self.get_revision(revision_id)
381
return list(self.get_deltas_for_revisions([r]))[0]
382
383
def _check_revision_parents(self, revision, inventory):
384
"""Private to Repository and Fetch.
385
386
This checks the parentage of revision in an inventory weave for
387
consistency and is only applicable to inventory-weave-for-ancestry
388
using repository formats & fetchers.
389
"""
390
weave_parents = inventory.get_parents(revision.revision_id)
391
weave_names = inventory.versions()
392
for parent_id in revision.parent_ids:
393
if parent_id in weave_names:
394
# this parent must not be a ghost.
395
if not parent_id in weave_parents:
396
# but it is a ghost
397
raise errors.CorruptRepository(self)
398
399
@needs_write_lock
400
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
401
signature = gpg_strategy.sign(plaintext)
402
self._revision_store.add_revision_signature_text(revision_id,
403
signature,
404
self.get_transaction())
405
406
def fileids_altered_by_revision_ids(self, revision_ids):
407
"""Find the file ids and versions affected by revisions.
408
409
:param revisions: an iterable containing revision ids.
410
:return: a dictionary mapping altered file-ids to an iterable of
411
revision_ids. Each altered file-ids has the exact revision_ids that
412
altered it listed explicitly.
413
"""
414
assert self._serializer.support_altered_by_hack, \
415
("fileids_altered_by_revision_ids only supported for branches "
416
"which store inventory as unnested xml, not on %r" % self)
417
selected_revision_ids = set(revision_ids)
418
w = self.get_inventory_weave()
419
result = {}
420
421
# this code needs to read every new line in every inventory for the
422
# inventories [revision_ids]. Seeing a line twice is ok. Seeing a line
423
# not present in one of those inventories is unnecessary but not
424
# harmful because we are filtering by the revision id marker in the
425
# inventory lines : we only select file ids altered in one of those
426
# revisions. We don't need to see all lines in the inventory because
427
# only those added in an inventory in rev X can contain a revision=X
428
# line.
429
for line in w.iter_lines_added_or_present_in_versions(selected_revision_ids):
430
start = line.find('file_id="')+9
431
if start < 9: continue
432
end = line.find('"', start)
433
assert end>= 0
434
file_id = _unescape_xml(line[start:end])
435
436
start = line.find('revision="')+10
437
if start < 10: continue
438
end = line.find('"', start)
439
assert end>= 0
440
revision_id = _unescape_xml(line[start:end])
441
if revision_id in selected_revision_ids:
442
result.setdefault(file_id, set()).add(revision_id)
443
return result
444
445
@needs_read_lock
446
def get_inventory_weave(self):
447
return self.control_weaves.get_weave('inventory',
448
self.get_transaction())
449
450
@needs_read_lock
451
def get_inventory(self, revision_id):
452
"""Get Inventory object by hash."""
453
return self.deserialise_inventory(
454
revision_id, self.get_inventory_xml(revision_id))
455
456
def deserialise_inventory(self, revision_id, xml):
457
"""Transform the xml into an inventory object.
458
459
:param revision_id: The expected revision id of the inventory.
460
:param xml: A serialised inventory.
461
"""
462
result = self._serializer.read_inventory_from_string(xml)
463
result.root.revision = revision_id
464
return result
465
466
def serialise_inventory(self, inv):
467
return self._serializer.write_inventory_to_string(inv)
468
469
@needs_read_lock
470
def get_inventory_xml(self, revision_id):
471
"""Get inventory XML as a file object."""
472
try:
473
assert isinstance(revision_id, basestring), type(revision_id)
474
iw = self.get_inventory_weave()
475
return iw.get_text(revision_id)
476
except IndexError:
477
raise errors.HistoryMissing(self, 'inventory', revision_id)
478
479
@needs_read_lock
480
def get_inventory_sha1(self, revision_id):
481
"""Return the sha1 hash of the inventory entry
482
"""
483
return self.get_revision(revision_id).inventory_sha1
484
485
@needs_read_lock
486
def get_revision_graph(self, revision_id=None):
487
"""Return a dictionary containing the revision graph.
488
489
:param revision_id: The revision_id to get a graph from. If None, then
490
the entire revision graph is returned. This is a deprecated mode of
491
operation and will be removed in the future.
492
:return: a dictionary of revision_id->revision_parents_list.
493
"""
494
# special case NULL_REVISION
495
if revision_id == NULL_REVISION:
496
return {}
497
weave = self.get_inventory_weave()
498
all_revisions = self._eliminate_revisions_not_present(weave.versions())
499
entire_graph = dict([(node, weave.get_parents(node)) for
500
node in all_revisions])
501
if revision_id is None:
502
return entire_graph
503
elif revision_id not in entire_graph:
504
raise errors.NoSuchRevision(self, revision_id)
505
else:
506
# add what can be reached from revision_id
507
result = {}
508
pending = set([revision_id])
509
while len(pending) > 0:
510
node = pending.pop()
511
result[node] = entire_graph[node]
512
for revision_id in result[node]:
513
if revision_id not in result:
514
pending.add(revision_id)
515
return result
516
517
@needs_read_lock
518
def get_revision_graph_with_ghosts(self, revision_ids=None):
519
"""Return a graph of the revisions with ghosts marked as applicable.
520
521
:param revision_ids: an iterable of revisions to graph or None for all.
522
:return: a Graph object with the graph reachable from revision_ids.
523
"""
524
result = Graph()
525
if not revision_ids:
526
pending = set(self.all_revision_ids())
527
required = set([])
528
else:
529
pending = set(revision_ids)
530
# special case NULL_REVISION
531
if NULL_REVISION in pending:
532
pending.remove(NULL_REVISION)
533
required = set(pending)
534
done = set([])
535
while len(pending):
536
revision_id = pending.pop()
537
try:
538
rev = self.get_revision(revision_id)
539
except errors.NoSuchRevision:
540
if revision_id in required:
541
raise
542
# a ghost
543
result.add_ghost(revision_id)
544
continue
545
for parent_id in rev.parent_ids:
546
# is this queued or done ?
547
if (parent_id not in pending and
548
parent_id not in done):
549
# no, queue it.
550
pending.add(parent_id)
551
result.add_node(revision_id, rev.parent_ids)
552
done.add(revision_id)
553
return result
554
555
@needs_read_lock
556
def get_revision_inventory(self, revision_id):
557
"""Return inventory of a past revision."""
558
# TODO: Unify this with get_inventory()
559
# bzr 0.0.6 and later imposes the constraint that the inventory_id
560
# must be the same as its revision, so this is trivial.
561
if revision_id is None:
562
# This does not make sense: if there is no revision,
563
# then it is the current tree inventory surely ?!
564
# and thus get_root_id() is something that looks at the last
565
# commit on the branch, and the get_root_id is an inventory check.
566
raise NotImplementedError
567
# return Inventory(self.get_root_id())
568
else:
569
return self.get_inventory(revision_id)
570
571
@needs_read_lock
572
def is_shared(self):
573
"""Return True if this repository is flagged as a shared repository."""
574
raise NotImplementedError(self.is_shared)
575
576
@needs_write_lock
577
def reconcile(self, other=None, thorough=False):
578
"""Reconcile this repository."""
579
from bzrlib.reconcile import RepoReconciler
580
reconciler = RepoReconciler(self, thorough=thorough)
581
reconciler.reconcile()
582
return reconciler
583
584
@needs_read_lock
585
def revision_tree(self, revision_id):
586
"""Return Tree for a revision on this branch.
587
588
`revision_id` may be None for the empty tree revision.
589
"""
590
# TODO: refactor this to use an existing revision object
591
# so we don't need to read it in twice.
592
if revision_id is None or revision_id == NULL_REVISION:
593
return RevisionTree(self, Inventory(), NULL_REVISION)
594
else:
595
inv = self.get_revision_inventory(revision_id)
596
return RevisionTree(self, inv, revision_id)
597
598
@needs_read_lock
599
def revision_trees(self, revision_ids):
600
"""Return Tree for a revision on this branch.
601
602
`revision_id` may not be None or 'null:'"""
603
assert None not in revision_ids
604
assert NULL_REVISION not in revision_ids
605
texts = self.get_inventory_weave().get_texts(revision_ids)
606
for text, revision_id in zip(texts, revision_ids):
607
inv = self.deserialise_inventory(revision_id, text)
608
yield RevisionTree(self, inv, revision_id)
609
610
@needs_read_lock
611
def get_ancestry(self, revision_id):
612
"""Return a list of revision-ids integrated by a revision.
613
614
The first element of the list is always None, indicating the origin
615
revision. This might change when we have history horizons, or
616
perhaps we should have a new API.
617
618
This is topologically sorted.
619
"""
620
if revision_id is None:
621
return [None]
622
if not self.has_revision(revision_id):
623
raise errors.NoSuchRevision(self, revision_id)
624
w = self.get_inventory_weave()
625
candidates = w.get_ancestry(revision_id)
626
return [None] + candidates # self._eliminate_revisions_not_present(candidates)
627
628
@needs_read_lock
629
def print_file(self, file, revision_id):
630
"""Print `file` to stdout.
631
632
FIXME RBC 20060125 as John Meinel points out this is a bad api
633
- it writes to stdout, it assumes that that is valid etc. Fix
634
by creating a new more flexible convenience function.
635
"""
636
tree = self.revision_tree(revision_id)
637
# use inventory as it was in that revision
638
file_id = tree.inventory.path2id(file)
639
if not file_id:
640
# TODO: jam 20060427 Write a test for this code path
641
# it had a bug in it, and was raising the wrong
642
# exception.
643
raise errors.BzrError("%r is not present in revision %s" % (file, revision_id))
644
tree.print_file(file_id)
645
646
def get_transaction(self):
647
return self.control_files.get_transaction()
648
649
def revision_parents(self, revid):
650
return self.get_inventory_weave().parent_names(revid)
651
652
@needs_write_lock
653
def set_make_working_trees(self, new_value):
654
"""Set the policy flag for making working trees when creating branches.
655
656
This only applies to branches that use this repository.
657
658
The default is 'True'.
659
:param new_value: True to restore the default, False to disable making
660
working trees.
661
"""
662
raise NotImplementedError(self.set_make_working_trees)
663
664
def make_working_trees(self):
665
"""Returns the policy for making working trees on new branches."""
666
raise NotImplementedError(self.make_working_trees)
667
668
@needs_write_lock
669
def sign_revision(self, revision_id, gpg_strategy):
670
plaintext = Testament.from_revision(self, revision_id).as_short_text()
671
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
672
673
@needs_read_lock
674
def has_signature_for_revision_id(self, revision_id):
675
"""Query for a revision signature for revision_id in the repository."""
676
return self._revision_store.has_signature(revision_id,
677
self.get_transaction())
678
679
@needs_read_lock
680
def get_signature_text(self, revision_id):
681
"""Return the text for a signature."""
682
return self._revision_store.get_signature_text(revision_id,
683
self.get_transaction())
684
685
@needs_read_lock
686
def check(self, revision_ids):
687
"""Check consistency of all history of given revision_ids.
688
689
Different repository implementations should override _check().
690
691
:param revision_ids: A non-empty list of revision_ids whose ancestry
692
will be checked. Typically the last revision_id of a branch.
693
"""
694
if not revision_ids:
695
raise ValueError("revision_ids must be non-empty in %s.check"
696
% (self,))
697
return self._check(revision_ids)
698
699
def _check(self, revision_ids):
700
result = check.Check(self)
701
result.check()
702
return result
703
704
def _warn_if_deprecated(self):
705
global _deprecation_warning_done
706
if _deprecation_warning_done:
707
return
708
_deprecation_warning_done = True
709
warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
710
% (self._format, self.bzrdir.transport.base))
711
712
713
class AllInOneRepository(Repository):
714
"""Legacy support - the repository behaviour for all-in-one branches."""
715
716
def __init__(self, _format, a_bzrdir, _revision_store, control_store, text_store):
717
# we reuse one control files instance.
718
dir_mode = a_bzrdir._control_files._dir_mode
719
file_mode = a_bzrdir._control_files._file_mode
720
721
def get_store(name, compressed=True, prefixed=False):
722
# FIXME: This approach of assuming stores are all entirely compressed
723
# or entirely uncompressed is tidy, but breaks upgrade from
724
# some existing branches where there's a mixture; we probably
725
# still want the option to look for both.
726
relpath = a_bzrdir._control_files._escape(name)
727
store = TextStore(a_bzrdir._control_files._transport.clone(relpath),
728
prefixed=prefixed, compressed=compressed,
729
dir_mode=dir_mode,
730
file_mode=file_mode)
731
#if self._transport.should_cache():
732
# cache_path = os.path.join(self.cache_root, name)
733
# os.mkdir(cache_path)
734
# store = bzrlib.store.CachedStore(store, cache_path)
735
return store
736
737
# not broken out yet because the controlweaves|inventory_store
738
# and text_store | weave_store bits are still different.
739
if isinstance(_format, RepositoryFormat4):
740
# cannot remove these - there is still no consistent api
741
# which allows access to this old info.
742
self.inventory_store = get_store('inventory-store')
743
text_store = get_store('text-store')
744
super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)
745
746
@needs_read_lock
747
def is_shared(self):
748
"""AllInOne repositories cannot be shared."""
749
return False
750
751
@needs_write_lock
752
def set_make_working_trees(self, new_value):
753
"""Set the policy flag for making working trees when creating branches.
754
755
This only applies to branches that use this repository.
756
757
The default is 'True'.
758
:param new_value: True to restore the default, False to disable making
759
working trees.
760
"""
761
raise NotImplementedError(self.set_make_working_trees)
762
763
def make_working_trees(self):
764
"""Returns the policy for making working trees on new branches."""
765
return True
766
767
768
def install_revision(repository, rev, revision_tree):
769
"""Install all revision data into a repository."""
770
present_parents = []
771
parent_trees = {}
772
for p_id in rev.parent_ids:
773
if repository.has_revision(p_id):
774
present_parents.append(p_id)
775
parent_trees[p_id] = repository.revision_tree(p_id)
776
else:
777
parent_trees[p_id] = repository.revision_tree(None)
778
779
inv = revision_tree.inventory
780
781
# backwards compatability hack: skip the root id.
782
entries = inv.iter_entries()
783
entries.next()
784
# Add the texts that are not already present
785
for path, ie in entries:
786
w = repository.weave_store.get_weave_or_empty(ie.file_id,
787
repository.get_transaction())
788
if ie.revision not in w:
789
text_parents = []
790
# FIXME: TODO: The following loop *may* be overlapping/duplicate
791
# with InventoryEntry.find_previous_heads(). if it is, then there
792
# is a latent bug here where the parents may have ancestors of each
793
# other. RBC, AB
794
for revision, tree in parent_trees.iteritems():
795
if ie.file_id not in tree:
796
continue
797
parent_id = tree.inventory[ie.file_id].revision
798
if parent_id in text_parents:
799
continue
800
text_parents.append(parent_id)
801
802
vfile = repository.weave_store.get_weave_or_empty(ie.file_id,
803
repository.get_transaction())
804
lines = revision_tree.get_file(ie.file_id).readlines()
805
vfile.add_lines(rev.revision_id, text_parents, lines)
806
try:
807
# install the inventory
808
repository.add_inventory(rev.revision_id, inv, present_parents)
809
except errors.RevisionAlreadyPresent:
810
pass
811
repository.add_revision(rev.revision_id, rev, inv)
812
813
814
class MetaDirRepository(Repository):
815
"""Repositories in the new meta-dir layout."""
816
817
def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
818
super(MetaDirRepository, self).__init__(_format,
819
a_bzrdir,
820
control_files,
821
_revision_store,
822
control_store,
823
text_store)
824
dir_mode = self.control_files._dir_mode
825
file_mode = self.control_files._file_mode
826
827
@needs_read_lock
828
def is_shared(self):
829
"""Return True if this repository is flagged as a shared repository."""
830
return self.control_files._transport.has('shared-storage')
831
832
@needs_write_lock
833
def set_make_working_trees(self, new_value):
834
"""Set the policy flag for making working trees when creating branches.
835
836
This only applies to branches that use this repository.
837
838
The default is 'True'.
839
:param new_value: True to restore the default, False to disable making
840
working trees.
841
"""
842
if new_value:
843
try:
844
self.control_files._transport.delete('no-working-trees')
845
except errors.NoSuchFile:
846
pass
847
else:
848
self.control_files.put_utf8('no-working-trees', '')
849
850
def make_working_trees(self):
851
"""Returns the policy for making working trees on new branches."""
852
return not self.control_files._transport.has('no-working-trees')
853
854
855
class KnitRepository(MetaDirRepository):
856
"""Knit format repository."""
857
858
def _warn_if_deprecated(self):
859
# This class isn't deprecated
860
pass
861
862
def _inventory_add_lines(self, inv_vf, revid, parents, lines):
863
inv_vf.add_lines_with_ghosts(revid, parents, lines)
864
865
@needs_read_lock
866
def _all_revision_ids(self):
867
"""See Repository.all_revision_ids()."""
868
# Knits get the revision graph from the index of the revision knit, so
869
# it's always possible even if they're on an unlistable transport.
870
return self._revision_store.all_revision_ids(self.get_transaction())
871
872
def fileid_involved_between_revs(self, from_revid, to_revid):
873
"""Find file_id(s) which are involved in the changes between revisions.
874
875
This determines the set of revisions which are involved, and then
876
finds all file ids affected by those revisions.
877
"""
878
vf = self._get_revision_vf()
879
from_set = set(vf.get_ancestry(from_revid))
880
to_set = set(vf.get_ancestry(to_revid))
881
changed = to_set.difference(from_set)
882
return self._fileid_involved_by_set(changed)
883
884
def fileid_involved(self, last_revid=None):
885
"""Find all file_ids modified in the ancestry of last_revid.
886
887
:param last_revid: If None, last_revision() will be used.
888
"""
889
if not last_revid:
890
changed = set(self.all_revision_ids())
891
else:
892
changed = set(self.get_ancestry(last_revid))
893
if None in changed:
894
changed.remove(None)
895
return self._fileid_involved_by_set(changed)
896
897
@needs_read_lock
898
def get_ancestry(self, revision_id):
899
"""Return a list of revision-ids integrated by a revision.
900
901
This is topologically sorted.
902
"""
903
if revision_id is None:
904
return [None]
905
vf = self._get_revision_vf()
906
try:
907
return [None] + vf.get_ancestry(revision_id)
908
except errors.RevisionNotPresent:
909
raise errors.NoSuchRevision(self, revision_id)
910
911
@needs_read_lock
912
def get_revision(self, revision_id):
913
"""Return the Revision object for a named revision"""
914
return self.get_revision_reconcile(revision_id)
915
916
@needs_read_lock
917
def get_revision_graph(self, revision_id=None):
918
"""Return a dictionary containing the revision graph.
919
920
:param revision_id: The revision_id to get a graph from. If None, then
921
the entire revision graph is returned. This is a deprecated mode of
922
operation and will be removed in the future.
923
:return: a dictionary of revision_id->revision_parents_list.
924
"""
925
# special case NULL_REVISION
926
if revision_id == NULL_REVISION:
927
return {}
928
weave = self._get_revision_vf()
929
entire_graph = weave.get_graph()
930
if revision_id is None:
931
return weave.get_graph()
932
elif revision_id not in weave:
933
raise errors.NoSuchRevision(self, revision_id)
934
else:
935
# add what can be reached from revision_id
936
result = {}
937
pending = set([revision_id])
938
while len(pending) > 0:
939
node = pending.pop()
940
result[node] = weave.get_parents(node)
941
for revision_id in result[node]:
942
if revision_id not in result:
943
pending.add(revision_id)
944
return result
945
946
@needs_read_lock
947
def get_revision_graph_with_ghosts(self, revision_ids=None):
948
"""Return a graph of the revisions with ghosts marked as applicable.
949
950
:param revision_ids: an iterable of revisions to graph or None for all.
951
:return: a Graph object with the graph reachable from revision_ids.
952
"""
953
result = Graph()
954
vf = self._get_revision_vf()
955
versions = set(vf.versions())
956
if not revision_ids:
957
pending = set(self.all_revision_ids())
958
required = set([])
959
else:
960
pending = set(revision_ids)
961
# special case NULL_REVISION
962
if NULL_REVISION in pending:
963
pending.remove(NULL_REVISION)
964
required = set(pending)
965
done = set([])
966
while len(pending):
967
revision_id = pending.pop()
968
if not revision_id in versions:
969
if revision_id in required:
970
raise errors.NoSuchRevision(self, revision_id)
971
# a ghost
972
result.add_ghost(revision_id)
973
# mark it as done so we don't try for it again.
974
done.add(revision_id)
975
continue
976
parent_ids = vf.get_parents_with_ghosts(revision_id)
977
for parent_id in parent_ids:
978
# is this queued or done ?
979
if (parent_id not in pending and
980
parent_id not in done):
981
# no, queue it.
982
pending.add(parent_id)
983
result.add_node(revision_id, parent_ids)
984
done.add(revision_id)
985
return result
986
987
def _get_revision_vf(self):
988
""":return: a versioned file containing the revisions."""
989
vf = self._revision_store.get_revision_file(self.get_transaction())
990
return vf
991
992
@needs_write_lock
993
def reconcile(self, other=None, thorough=False):
994
"""Reconcile this repository."""
995
from bzrlib.reconcile import KnitReconciler
996
reconciler = KnitReconciler(self, thorough=thorough)
997
reconciler.reconcile()
998
return reconciler
999
1000
def revision_parents(self, revision_id):
1001
return self._get_revision_vf().get_parents(revision_id)
1002
1003
1004
class KnitRepository2(KnitRepository):
1005
""""""
1006
def __init__(self, _format, a_bzrdir, control_files, _revision_store,
1007
control_store, text_store):
1008
KnitRepository.__init__(self, _format, a_bzrdir, control_files,
1009
_revision_store, control_store, text_store)
1010
self._serializer = xml6.serializer_v6
1011
1012
def deserialise_inventory(self, revision_id, xml):
1013
"""Transform the xml into an inventory object.
1014
1015
:param revision_id: The expected revision id of the inventory.
1016
:param xml: A serialised inventory.
1017
"""
1018
result = self._serializer.read_inventory_from_string(xml)
1019
assert result.root.revision is not None
1020
return result
1021
1022
def serialise_inventory(self, inv):
1023
"""Transform the inventory object into XML text.
1024
1025
:param revision_id: The expected revision id of the inventory.
1026
:param xml: A serialised inventory.
1027
"""
1028
assert inv.revision_id is not None
1029
assert inv.root.revision is not None
1030
return KnitRepository.serialise_inventory(self, inv)
1031
1032
def get_commit_builder(self, branch, parents, config, timestamp=None,
1033
timezone=None, committer=None, revprops=None,
1034
revision_id=None):
1035
"""Obtain a CommitBuilder for this repository.
1036
1037
:param branch: Branch to commit to.
1038
:param parents: Revision ids of the parents of the new revision.
1039
:param config: Configuration to use.
1040
:param timestamp: Optional timestamp recorded for commit.
1041
:param timezone: Optional timezone for timestamp.
1042
:param committer: Optional committer to set for commit.
1043
:param revprops: Optional dictionary of revision properties.
1044
:param revision_id: Optional revision id.
1045
"""
1046
return RootCommitBuilder(self, parents, config, timestamp, timezone,
1047
committer, revprops, revision_id)
1048
1049
1050
class RepositoryFormat(object):
1051
"""A repository format.
1052
1053
Formats provide three things:
1054
* An initialization routine to construct repository data on disk.
1055
* a format string which is used when the BzrDir supports versioned
1056
children.
1057
* an open routine which returns a Repository instance.
1058
1059
Formats are placed in an dict by their format string for reference
1060
during opening. These should be subclasses of RepositoryFormat
1061
for consistency.
1062
1063
Once a format is deprecated, just deprecate the initialize and open
1064
methods on the format class. Do not deprecate the object, as the
1065
object will be created every system load.
1066
1067
Common instance attributes:
1068
_matchingbzrdir - the bzrdir format that the repository format was
1069
originally written to work with. This can be used if manually
1070
constructing a bzrdir and repository, or more commonly for test suite
1071
parameterisation.
1072
"""
1073
1074
_default_format = None
1075
"""The default format used for new repositories."""
1076
1077
_formats = {}
1078
"""The known formats."""
1079
1080
def __str__(self):
1081
return "<%s>" % self.__class__.__name__
1082
1083
@classmethod
1084
def find_format(klass, a_bzrdir):
1085
"""Return the format for the repository object in a_bzrdir."""
1086
try:
1087
transport = a_bzrdir.get_repository_transport(None)
1088
format_string = transport.get("format").read()
1089
return klass._formats[format_string]
1090
except errors.NoSuchFile:
1091
raise errors.NoRepositoryPresent(a_bzrdir)
1092
except KeyError:
1093
raise errors.UnknownFormatError(format=format_string)
1094
1095
def _get_control_store(self, repo_transport, control_files):
1096
"""Return the control store for this repository."""
1097
raise NotImplementedError(self._get_control_store)
1098
1099
@classmethod
1100
def get_default_format(klass):
1101
"""Return the current default format."""
1102
return klass._default_format
1103
1104
def get_format_string(self):
1105
"""Return the ASCII format string that identifies this format.
1106
1107
Note that in pre format ?? repositories the format string is
1108
not permitted nor written to disk.
1109
"""
1110
raise NotImplementedError(self.get_format_string)
1111
1112
def get_format_description(self):
1113
"""Return the short description for this format."""
1114
raise NotImplementedError(self.get_format_description)
1115
1116
def _get_revision_store(self, repo_transport, control_files):
1117
"""Return the revision store object for this a_bzrdir."""
1118
raise NotImplementedError(self._get_revision_store)
1119
1120
def _get_text_rev_store(self,
1121
transport,
1122
control_files,
1123
name,
1124
compressed=True,
1125
prefixed=False,
1126
serializer=None):
1127
"""Common logic for getting a revision store for a repository.
1128
1129
see self._get_revision_store for the subclass-overridable method to
1130
get the store for a repository.
1131
"""
1132
from bzrlib.store.revision.text import TextRevisionStore
1133
dir_mode = control_files._dir_mode
1134
file_mode = control_files._file_mode
1135
text_store =TextStore(transport.clone(name),
1136
prefixed=prefixed,
1137
compressed=compressed,
1138
dir_mode=dir_mode,
1139
file_mode=file_mode)
1140
_revision_store = TextRevisionStore(text_store, serializer)
1141
return _revision_store
1142
1143
def _get_versioned_file_store(self,
1144
name,
1145
transport,
1146
control_files,
1147
prefixed=True,
1148
versionedfile_class=WeaveFile,
1149
versionedfile_kwargs={},
1150
escaped=False):
1151
weave_transport = control_files._transport.clone(name)
1152
dir_mode = control_files._dir_mode
1153
file_mode = control_files._file_mode
1154
return VersionedFileStore(weave_transport, prefixed=prefixed,
1155
dir_mode=dir_mode,
1156
file_mode=file_mode,
1157
versionedfile_class=versionedfile_class,
1158
versionedfile_kwargs=versionedfile_kwargs,
1159
escaped=escaped)
1160
1161
def initialize(self, a_bzrdir, shared=False):
1162
"""Initialize a repository of this format in a_bzrdir.
1163
1164
:param a_bzrdir: The bzrdir to put the new repository in it.
1165
:param shared: The repository should be initialized as a sharable one.
1166
1167
This may raise UninitializableFormat if shared repository are not
1168
compatible the a_bzrdir.
1169
"""
1170
1171
def is_supported(self):
1172
"""Is this format supported?
1173
1174
Supported formats must be initializable and openable.
1175
Unsupported formats may not support initialization or committing or
1176
some other features depending on the reason for not being supported.
1177
"""
1178
return True
1179
1180
def check_conversion_target(self, target_format):
1181
raise NotImplementedError(self.check_conversion_target)
1182
1183
def open(self, a_bzrdir, _found=False):
1184
"""Return an instance of this format for the bzrdir a_bzrdir.
1185
1186
_found is a private parameter, do not use it.
1187
"""
1188
raise NotImplementedError(self.open)
1189
1190
@classmethod
1191
def register_format(klass, format):
1192
klass._formats[format.get_format_string()] = format
1193
1194
@classmethod
1195
def set_default_format(klass, format):
1196
klass._default_format = format
1197
1198
@classmethod
1199
def unregister_format(klass, format):
1200
assert klass._formats[format.get_format_string()] is format
1201
del klass._formats[format.get_format_string()]
1202
1203
1204
class PreSplitOutRepositoryFormat(RepositoryFormat):
1205
"""Base class for the pre split out repository formats."""
1206
1207
rich_root_data = False
1208
1209
def initialize(self, a_bzrdir, shared=False, _internal=False):
1210
"""Create a weave repository.
1211
1212
TODO: when creating split out bzr branch formats, move this to a common
1213
base for Format5, Format6. or something like that.
1214
"""
1215
from bzrlib.weavefile import write_weave_v5
1216
from bzrlib.weave import Weave
1217
1218
if shared:
1219
raise errors.IncompatibleFormat(self, a_bzrdir._format)
1220
1221
if not _internal:
1222
# always initialized when the bzrdir is.
1223
return self.open(a_bzrdir, _found=True)
1224
1225
# Create an empty weave
1226
sio = StringIO()
1227
write_weave_v5(Weave(), sio)
1228
empty_weave = sio.getvalue()
1229
1230
mutter('creating repository in %s.', a_bzrdir.transport.base)
1231
dirs = ['revision-store', 'weaves']
1232
files = [('inventory.weave', StringIO(empty_weave)),
1233
]
1234
1235
# FIXME: RBC 20060125 don't peek under the covers
1236
# NB: no need to escape relative paths that are url safe.
1237
control_files = LockableFiles(a_bzrdir.transport, 'branch-lock',
1238
TransportLock)
1239
control_files.create_lock()
1240
control_files.lock_write()
1241
control_files._transport.mkdir_multi(dirs,
1242
mode=control_files._dir_mode)
1243
try:
1244
for file, content in files:
1245
control_files.put(file, content)
1246
finally:
1247
control_files.unlock()
1248
return self.open(a_bzrdir, _found=True)
1249
1250
def _get_control_store(self, repo_transport, control_files):
1251
"""Return the control store for this repository."""
1252
return self._get_versioned_file_store('',
1253
repo_transport,
1254
control_files,
1255
prefixed=False)
1256
1257
def _get_text_store(self, transport, control_files):
1258
"""Get a store for file texts for this format."""
1259
raise NotImplementedError(self._get_text_store)
1260
1261
def open(self, a_bzrdir, _found=False):
1262
"""See RepositoryFormat.open()."""
1263
if not _found:
1264
# we are being called directly and must probe.
1265
raise NotImplementedError
1266
1267
repo_transport = a_bzrdir.get_repository_transport(None)
1268
control_files = a_bzrdir._control_files
1269
text_store = self._get_text_store(repo_transport, control_files)
1270
control_store = self._get_control_store(repo_transport, control_files)
1271
_revision_store = self._get_revision_store(repo_transport, control_files)
1272
return AllInOneRepository(_format=self,
1273
a_bzrdir=a_bzrdir,
1274
_revision_store=_revision_store,
1275
control_store=control_store,
1276
text_store=text_store)
1277
1278
def check_conversion_target(self, target_format):
1279
pass
1280
1281
1282
class RepositoryFormat4(PreSplitOutRepositoryFormat):
1283
"""Bzr repository format 4.
1284
1285
This repository format has:
1286
- flat stores
1287
- TextStores for texts, inventories,revisions.
1288
1289
This format is deprecated: it indexes texts using a text id which is
1290
removed in format 5; initialization and write support for this format
1291
has been removed.
1292
"""
1293
1294
def __init__(self):
1295
super(RepositoryFormat4, self).__init__()
1296
self._matchingbzrdir = bzrdir.BzrDirFormat4()
1297
1298
def get_format_description(self):
1299
"""See RepositoryFormat.get_format_description()."""
1300
return "Repository format 4"
1301
1302
def initialize(self, url, shared=False, _internal=False):
1303
"""Format 4 branches cannot be created."""
1304
raise errors.UninitializableFormat(self)
1305
1306
def is_supported(self):
1307
"""Format 4 is not supported.
1308
1309
It is not supported because the model changed from 4 to 5 and the
1310
conversion logic is expensive - so doing it on the fly was not
1311
feasible.
1312
"""
1313
return False
1314
1315
def _get_control_store(self, repo_transport, control_files):
1316
"""Format 4 repositories have no formal control store at this point.
1317
1318
This will cause any control-file-needing apis to fail - this is desired.
1319
"""
1320
return None
1321
1322
def _get_revision_store(self, repo_transport, control_files):
1323
"""See RepositoryFormat._get_revision_store()."""
1324
from bzrlib.xml4 import serializer_v4
1325
return self._get_text_rev_store(repo_transport,
1326
control_files,
1327
'revision-store',
1328
serializer=serializer_v4)
1329
1330
def _get_text_store(self, transport, control_files):
1331
"""See RepositoryFormat._get_text_store()."""
1332
1333
1334
class RepositoryFormat5(PreSplitOutRepositoryFormat):
1335
"""Bzr control format 5.
1336
1337
This repository format has:
1338
- weaves for file texts and inventory
1339
- flat stores
1340
- TextStores for revisions and signatures.
1341
"""
1342
1343
def __init__(self):
1344
super(RepositoryFormat5, self).__init__()
1345
self._matchingbzrdir = bzrdir.BzrDirFormat5()
1346
1347
def get_format_description(self):
1348
"""See RepositoryFormat.get_format_description()."""
1349
return "Weave repository format 5"
1350
1351
def _get_revision_store(self, repo_transport, control_files):
1352
"""See RepositoryFormat._get_revision_store()."""
1353
"""Return the revision store object for this a_bzrdir."""
1354
return self._get_text_rev_store(repo_transport,
1355
control_files,
1356
'revision-store',
1357
compressed=False)
1358
1359
def _get_text_store(self, transport, control_files):
1360
"""See RepositoryFormat._get_text_store()."""
1361
return self._get_versioned_file_store('weaves', transport, control_files, prefixed=False)
1362
1363
1364
class RepositoryFormat6(PreSplitOutRepositoryFormat):
1365
"""Bzr control format 6.
1366
1367
This repository format has:
1368
- weaves for file texts and inventory
1369
- hash subdirectory based stores.
1370
- TextStores for revisions and signatures.
1371
"""
1372
1373
def __init__(self):
1374
super(RepositoryFormat6, self).__init__()
1375
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1376
1377
def get_format_description(self):
1378
"""See RepositoryFormat.get_format_description()."""
1379
return "Weave repository format 6"
1380
1381
def _get_revision_store(self, repo_transport, control_files):
1382
"""See RepositoryFormat._get_revision_store()."""
1383
return self._get_text_rev_store(repo_transport,
1384
control_files,
1385
'revision-store',
1386
compressed=False,
1387
prefixed=True)
1388
1389
def _get_text_store(self, transport, control_files):
1390
"""See RepositoryFormat._get_text_store()."""
1391
return self._get_versioned_file_store('weaves', transport, control_files)
1392
1393
1394
class MetaDirRepositoryFormat(RepositoryFormat):
1395
"""Common base class for the new repositories using the metadir layout."""
1396
1397
rich_root_data = False
1398
1399
def __init__(self):
1400
super(MetaDirRepositoryFormat, self).__init__()
1401
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1402
1403
def _create_control_files(self, a_bzrdir):
1404
"""Create the required files and the initial control_files object."""
1405
# FIXME: RBC 20060125 don't peek under the covers
1406
# NB: no need to escape relative paths that are url safe.
1407
repository_transport = a_bzrdir.get_repository_transport(self)
1408
control_files = LockableFiles(repository_transport, 'lock', LockDir)
1409
control_files.create_lock()
1410
return control_files
1411
1412
def _upload_blank_content(self, a_bzrdir, dirs, files, utf8_files, shared):
1413
"""Upload the initial blank content."""
1414
control_files = self._create_control_files(a_bzrdir)
1415
control_files.lock_write()
1416
try:
1417
control_files._transport.mkdir_multi(dirs,
1418
mode=control_files._dir_mode)
1419
for file, content in files:
1420
control_files.put(file, content)
1421
for file, content in utf8_files:
1422
control_files.put_utf8(file, content)
1423
if shared == True:
1424
control_files.put_utf8('shared-storage', '')
1425
finally:
1426
control_files.unlock()
1427
1428
1429
class RepositoryFormat7(MetaDirRepositoryFormat):
1430
"""Bzr repository 7.
1431
1432
This repository format has:
1433
- weaves for file texts and inventory
1434
- hash subdirectory based stores.
1435
- TextStores for revisions and signatures.
1436
- a format marker of its own
1437
- an optional 'shared-storage' flag
1438
- an optional 'no-working-trees' flag
1439
"""
1440
1441
def _get_control_store(self, repo_transport, control_files):
1442
"""Return the control store for this repository."""
1443
return self._get_versioned_file_store('',
1444
repo_transport,
1445
control_files,
1446
prefixed=False)
1447
1448
def get_format_string(self):
1449
"""See RepositoryFormat.get_format_string()."""
1450
return "Bazaar-NG Repository format 7"
1451
1452
def get_format_description(self):
1453
"""See RepositoryFormat.get_format_description()."""
1454
return "Weave repository format 7"
1455
1456
def check_conversion_target(self, target_format):
1457
pass
1458
1459
def _get_revision_store(self, repo_transport, control_files):
1460
"""See RepositoryFormat._get_revision_store()."""
1461
return self._get_text_rev_store(repo_transport,
1462
control_files,
1463
'revision-store',
1464
compressed=False,
1465
prefixed=True,
1466
)
1467
1468
def _get_text_store(self, transport, control_files):
1469
"""See RepositoryFormat._get_text_store()."""
1470
return self._get_versioned_file_store('weaves',
1471
transport,
1472
control_files)
1473
1474
def initialize(self, a_bzrdir, shared=False):
1475
"""Create a weave repository.
1476
1477
:param shared: If true the repository will be initialized as a shared
1478
repository.
1479
"""
1480
from bzrlib.weavefile import write_weave_v5
1481
from bzrlib.weave import Weave
1482
1483
# Create an empty weave
1484
sio = StringIO()
1485
write_weave_v5(Weave(), sio)
1486
empty_weave = sio.getvalue()
1487
1488
mutter('creating repository in %s.', a_bzrdir.transport.base)
1489
dirs = ['revision-store', 'weaves']
1490
files = [('inventory.weave', StringIO(empty_weave)),
1491
]
1492
utf8_files = [('format', self.get_format_string())]
1493
1494
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1495
return self.open(a_bzrdir=a_bzrdir, _found=True)
1496
1497
def open(self, a_bzrdir, _found=False, _override_transport=None):
1498
"""See RepositoryFormat.open().
1499
1500
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1501
repository at a slightly different url
1502
than normal. I.e. during 'upgrade'.
1503
"""
1504
if not _found:
1505
format = RepositoryFormat.find_format(a_bzrdir)
1506
assert format.__class__ == self.__class__
1507
if _override_transport is not None:
1508
repo_transport = _override_transport
1509
else:
1510
repo_transport = a_bzrdir.get_repository_transport(None)
1511
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1512
text_store = self._get_text_store(repo_transport, control_files)
1513
control_store = self._get_control_store(repo_transport, control_files)
1514
_revision_store = self._get_revision_store(repo_transport, control_files)
1515
return MetaDirRepository(_format=self,
1516
a_bzrdir=a_bzrdir,
1517
control_files=control_files,
1518
_revision_store=_revision_store,
1519
control_store=control_store,
1520
text_store=text_store)
1521
1522
1523
class RepositoryFormatKnit(MetaDirRepositoryFormat):
1524
"""Bzr repository knit format (generalized).
1525
1526
This repository format has:
1527
- knits for file texts and inventory
1528
- hash subdirectory based stores.
1529
- knits for revisions and signatures
1530
- TextStores for revisions and signatures.
1531
- a format marker of its own
1532
- an optional 'shared-storage' flag
1533
- an optional 'no-working-trees' flag
1534
- a LockDir lock
1535
"""
1536
1537
def _get_control_store(self, repo_transport, control_files):
1538
"""Return the control store for this repository."""
1539
return VersionedFileStore(
1540
repo_transport,
1541
prefixed=False,
1542
file_mode=control_files._file_mode,
1543
versionedfile_class=KnitVersionedFile,
1544
versionedfile_kwargs={'factory':KnitPlainFactory()},
1545
)
1546
1547
def _get_revision_store(self, repo_transport, control_files):
1548
"""See RepositoryFormat._get_revision_store()."""
1549
from bzrlib.store.revision.knit import KnitRevisionStore
1550
versioned_file_store = VersionedFileStore(
1551
repo_transport,
1552
file_mode=control_files._file_mode,
1553
prefixed=False,
1554
precious=True,
1555
versionedfile_class=KnitVersionedFile,
1556
versionedfile_kwargs={'delta':False, 'factory':KnitPlainFactory(),},
1557
escaped=True,
1558
)
1559
return KnitRevisionStore(versioned_file_store)
1560
1561
def _get_text_store(self, transport, control_files):
1562
"""See RepositoryFormat._get_text_store()."""
1563
return self._get_versioned_file_store('knits',
1564
transport,
1565
control_files,
1566
versionedfile_class=KnitVersionedFile,
1567
versionedfile_kwargs={
1568
'create_parent_dir':True,
1569
'delay_create':True,
1570
'dir_mode':control_files._dir_mode,
1571
},
1572
escaped=True)
1573
1574
def initialize(self, a_bzrdir, shared=False):
1575
"""Create a knit format 1 repository.
1576
1577
:param a_bzrdir: bzrdir to contain the new repository; must already
1578
be initialized.
1579
:param shared: If true the repository will be initialized as a shared
1580
repository.
1581
"""
1582
mutter('creating repository in %s.', a_bzrdir.transport.base)
1583
dirs = ['revision-store', 'knits']
1584
files = []
1585
utf8_files = [('format', self.get_format_string())]
1586
1587
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1588
repo_transport = a_bzrdir.get_repository_transport(None)
1589
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1590
control_store = self._get_control_store(repo_transport, control_files)
1591
transaction = transactions.WriteTransaction()
1592
# trigger a write of the inventory store.
1593
control_store.get_weave_or_empty('inventory', transaction)
1594
_revision_store = self._get_revision_store(repo_transport, control_files)
1595
_revision_store.has_revision_id('A', transaction)
1596
_revision_store.get_signature_file(transaction)
1597
return self.open(a_bzrdir=a_bzrdir, _found=True)
1598
1599
def open(self, a_bzrdir, _found=False, _override_transport=None):
1600
"""See RepositoryFormat.open().
1601
1602
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1603
repository at a slightly different url
1604
than normal. I.e. during 'upgrade'.
1605
"""
1606
if not _found:
1607
format = RepositoryFormat.find_format(a_bzrdir)
1608
assert format.__class__ == self.__class__
1609
if _override_transport is not None:
1610
repo_transport = _override_transport
1611
else:
1612
repo_transport = a_bzrdir.get_repository_transport(None)
1613
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1614
text_store = self._get_text_store(repo_transport, control_files)
1615
control_store = self._get_control_store(repo_transport, control_files)
1616
_revision_store = self._get_revision_store(repo_transport, control_files)
1617
return KnitRepository(_format=self,
1618
a_bzrdir=a_bzrdir,
1619
control_files=control_files,
1620
_revision_store=_revision_store,
1621
control_store=control_store,
1622
text_store=text_store)
1623
1624
1625
class RepositoryFormatKnit1(RepositoryFormatKnit):
1626
"""Bzr repository knit format 1.
1627
1628
This repository format has:
1629
- knits for file texts and inventory
1630
- hash subdirectory based stores.
1631
- knits for revisions and signatures
1632
- TextStores for revisions and signatures.
1633
- a format marker of its own
1634
- an optional 'shared-storage' flag
1635
- an optional 'no-working-trees' flag
1636
- a LockDir lock
1637
1638
This format was introduced in bzr 0.8.
1639
"""
1640
def get_format_string(self):
1641
"""See RepositoryFormat.get_format_string()."""
1642
return "Bazaar-NG Knit Repository Format 1"
1643
1644
def get_format_description(self):
1645
"""See RepositoryFormat.get_format_description()."""
1646
return "Knit repository format 1"
1647
1648
def check_conversion_target(self, target_format):
1649
pass
1650
1651
1652
class RepositoryFormatKnit2(RepositoryFormatKnit):
1653
"""Bzr repository knit format 2.
1654
1655
THIS FORMAT IS EXPERIMENTAL
1656
This repository format has:
1657
- knits for file texts and inventory
1658
- hash subdirectory based stores.
1659
- knits for revisions and signatures
1660
- TextStores for revisions and signatures.
1661
- a format marker of its own
1662
- an optional 'shared-storage' flag
1663
- an optional 'no-working-trees' flag
1664
- a LockDir lock
1665
- Support for recording full info about the tree root
1666
1667
"""
1668
1669
rich_root_data = True
1670
1671
def get_format_string(self):
1672
"""See RepositoryFormat.get_format_string()."""
1673
return "Bazaar Knit Repository Format 2\n"
1674
1675
def get_format_description(self):
1676
"""See RepositoryFormat.get_format_description()."""
1677
return "Knit repository format 2"
1678
1679
def check_conversion_target(self, target_format):
1680
if not target_format.rich_root_data:
1681
raise errors.BadConversionTarget(
1682
'Does not support rich root data.', target_format)
1683
1684
def open(self, a_bzrdir, _found=False, _override_transport=None):
1685
"""See RepositoryFormat.open().
1686
1687
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1688
repository at a slightly different url
1689
than normal. I.e. during 'upgrade'.
1690
"""
1691
if not _found:
1692
format = RepositoryFormat.find_format(a_bzrdir)
1693
assert format.__class__ == self.__class__
1694
if _override_transport is not None:
1695
repo_transport = _override_transport
1696
else:
1697
repo_transport = a_bzrdir.get_repository_transport(None)
1698
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1699
text_store = self._get_text_store(repo_transport, control_files)
1700
control_store = self._get_control_store(repo_transport, control_files)
1701
_revision_store = self._get_revision_store(repo_transport, control_files)
1702
return KnitRepository2(_format=self,
1703
a_bzrdir=a_bzrdir,
1704
control_files=control_files,
1705
_revision_store=_revision_store,
1706
control_store=control_store,
1707
text_store=text_store)
1708
1709
1710
1711
# formats which have no format string are not discoverable
1712
# and not independently creatable, so are not registered.
1713
RepositoryFormat.register_format(RepositoryFormat7())
1714
_default_format = RepositoryFormatKnit1()
1715
RepositoryFormat.register_format(_default_format)
1716
RepositoryFormat.register_format(RepositoryFormatKnit2())
1717
RepositoryFormat.set_default_format(_default_format)
1718
_legacy_formats = [RepositoryFormat4(),
1719
RepositoryFormat5(),
1720
RepositoryFormat6()]
1721
1722
1723
class InterRepository(InterObject):
1724
"""This class represents operations taking place between two repositories.
1725
1726
Its instances have methods like copy_content and fetch, and contain
1727
references to the source and target repositories these operations can be
1728
carried out on.
1729
1730
Often we will provide convenience methods on 'repository' which carry out
1731
operations with another repository - they will always forward to
1732
InterRepository.get(other).method_name(parameters).
1733
"""
1734
1735
_optimisers = []
1736
"""The available optimised InterRepository types."""
1737
1738
def copy_content(self, revision_id=None, basis=None):
1739
raise NotImplementedError(self.copy_content)
1740
1741
def fetch(self, revision_id=None, pb=None):
1742
raise NotImplementedError(self.fetch)
1743
1744
@needs_read_lock
1745
def missing_revision_ids(self, revision_id=None):
1746
"""Return the revision ids that source has that target does not.
1747
1748
These are returned in topological order.
1749
1750
:param revision_id: only return revision ids included by this
1751
revision_id.
1752
"""
1753
# generic, possibly worst case, slow code path.
1754
target_ids = set(self.target.all_revision_ids())
1755
if revision_id is not None:
1756
source_ids = self.source.get_ancestry(revision_id)
1757
assert source_ids[0] is None
1758
source_ids.pop(0)
1759
else:
1760
source_ids = self.source.all_revision_ids()
1761
result_set = set(source_ids).difference(target_ids)
1762
# this may look like a no-op: its not. It preserves the ordering
1763
# other_ids had while only returning the members from other_ids
1764
# that we've decided we need.
1765
return [rev_id for rev_id in source_ids if rev_id in result_set]
1766
1767
1768
class InterSameDataRepository(InterRepository):
1769
"""Code for converting between repositories that represent the same data.
1770
1771
Data format and model must match for this to work.
1772
"""
1773
1774
_matching_repo_format = RepositoryFormat4()
1775
"""Repository format for testing with."""
1776
1777
@staticmethod
1778
def is_compatible(source, target):
1779
if not isinstance(source, Repository):
1780
return False
1781
if not isinstance(target, Repository):
1782
return False
1783
if source._format.rich_root_data == target._format.rich_root_data:
1784
return True
1785
else:
1786
return False
1787
1788
@needs_write_lock
1789
def copy_content(self, revision_id=None, basis=None):
1790
"""Make a complete copy of the content in self into destination.
1791
1792
This is a destructive operation! Do not use it on existing
1793
repositories.
1794
1795
:param revision_id: Only copy the content needed to construct
1796
revision_id and its parents.
1797
:param basis: Copy the needed data preferentially from basis.
1798
"""
1799
try:
1800
self.target.set_make_working_trees(self.source.make_working_trees())
1801
except NotImplementedError:
1802
pass
1803
# grab the basis available data
1804
if basis is not None:
1805
self.target.fetch(basis, revision_id=revision_id)
1806
# but don't bother fetching if we have the needed data now.
1807
if (revision_id not in (None, NULL_REVISION) and
1808
self.target.has_revision(revision_id)):
1809
return
1810
self.target.fetch(self.source, revision_id=revision_id)
1811
1812
@needs_write_lock
1813
def fetch(self, revision_id=None, pb=None):
1814
"""Fetch the content required to construct revision_id.
1815
1816
The content is copied from source to target.
1817
1818
:param revision_id: if None all content is copied, if NULL_REVISION no
1819
content is copied.
1820
:param pb: optional progress bar to use for progress reports. If not
1821
provided a default one will be created.
1822
1823
Returns the copied revision count and the failed revisions in a tuple:
1824
(copied, failures).
1825
"""
1826
from bzrlib.fetch import GenericRepoFetcher
1827
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1828
self.source, self.source._format, self.target,
1829
self.target._format)
1830
f = GenericRepoFetcher(to_repository=self.target,
1831
from_repository=self.source,
1832
last_revision=revision_id,
1833
pb=pb)
1834
return f.count_copied, f.failed_revisions
1835
1836
1837
class InterWeaveRepo(InterSameDataRepository):
1838
"""Optimised code paths between Weave based repositories."""
1839
1840
_matching_repo_format = RepositoryFormat7()
1841
"""Repository format for testing with."""
1842
1843
@staticmethod
1844
def is_compatible(source, target):
1845
"""Be compatible with known Weave formats.
1846
1847
We don't test for the stores being of specific types because that
1848
could lead to confusing results, and there is no need to be
1849
overly general.
1850
"""
1851
try:
1852
return (isinstance(source._format, (RepositoryFormat5,
1853
RepositoryFormat6,
1854
RepositoryFormat7)) and
1855
isinstance(target._format, (RepositoryFormat5,
1856
RepositoryFormat6,
1857
RepositoryFormat7)))
1858
except AttributeError:
1859
return False
1860
1861
@needs_write_lock
1862
def copy_content(self, revision_id=None, basis=None):
1863
"""See InterRepository.copy_content()."""
1864
# weave specific optimised path:
1865
if basis is not None:
1866
# copy the basis in, then fetch remaining data.
1867
basis.copy_content_into(self.target, revision_id)
1868
# the basis copy_content_into could miss-set this.
1869
try:
1870
self.target.set_make_working_trees(self.source.make_working_trees())
1871
except NotImplementedError:
1872
pass
1873
self.target.fetch(self.source, revision_id=revision_id)
1874
else:
1875
try:
1876
self.target.set_make_working_trees(self.source.make_working_trees())
1877
except NotImplementedError:
1878
pass
1879
# FIXME do not peek!
1880
if self.source.control_files._transport.listable():
1881
pb = ui.ui_factory.nested_progress_bar()
1882
try:
1883
self.target.weave_store.copy_all_ids(
1884
self.source.weave_store,
1885
pb=pb,
1886
from_transaction=self.source.get_transaction(),
1887
to_transaction=self.target.get_transaction())
1888
pb.update('copying inventory', 0, 1)
1889
self.target.control_weaves.copy_multi(
1890
self.source.control_weaves, ['inventory'],
1891
from_transaction=self.source.get_transaction(),
1892
to_transaction=self.target.get_transaction())
1893
self.target._revision_store.text_store.copy_all_ids(
1894
self.source._revision_store.text_store,
1895
pb=pb)
1896
finally:
1897
pb.finished()
1898
else:
1899
self.target.fetch(self.source, revision_id=revision_id)
1900
1901
@needs_write_lock
1902
def fetch(self, revision_id=None, pb=None):
1903
"""See InterRepository.fetch()."""
1904
from bzrlib.fetch import GenericRepoFetcher
1905
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1906
self.source, self.source._format, self.target, self.target._format)
1907
f = GenericRepoFetcher(to_repository=self.target,
1908
from_repository=self.source,
1909
last_revision=revision_id,
1910
pb=pb)
1911
return f.count_copied, f.failed_revisions
1912
1913
@needs_read_lock
1914
def missing_revision_ids(self, revision_id=None):
1915
"""See InterRepository.missing_revision_ids()."""
1916
# we want all revisions to satisfy revision_id in source.
1917
# but we don't want to stat every file here and there.
1918
# we want then, all revisions other needs to satisfy revision_id
1919
# checked, but not those that we have locally.
1920
# so the first thing is to get a subset of the revisions to
1921
# satisfy revision_id in source, and then eliminate those that
1922
# we do already have.
1923
# this is slow on high latency connection to self, but as as this
1924
# disk format scales terribly for push anyway due to rewriting
1925
# inventory.weave, this is considered acceptable.
1926
# - RBC 20060209
1927
if revision_id is not None:
1928
source_ids = self.source.get_ancestry(revision_id)
1929
assert source_ids[0] is None
1930
source_ids.pop(0)
1931
else:
1932
source_ids = self.source._all_possible_ids()
1933
source_ids_set = set(source_ids)
1934
# source_ids is the worst possible case we may need to pull.
1935
# now we want to filter source_ids against what we actually
1936
# have in target, but don't try to check for existence where we know
1937
# we do not have a revision as that would be pointless.
1938
target_ids = set(self.target._all_possible_ids())
1939
possibly_present_revisions = target_ids.intersection(source_ids_set)
1940
actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
1941
required_revisions = source_ids_set.difference(actually_present_revisions)
1942
required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
1943
if revision_id is not None:
1944
# we used get_ancestry to determine source_ids then we are assured all
1945
# revisions referenced are present as they are installed in topological order.
1946
# and the tip revision was validated by get_ancestry.
1947
return required_topo_revisions
1948
else:
1949
# if we just grabbed the possibly available ids, then
1950
# we only have an estimate of whats available and need to validate
1951
# that against the revision records.
1952
return self.source._eliminate_revisions_not_present(required_topo_revisions)
1953
1954
1955
class InterKnitRepo(InterSameDataRepository):
1956
"""Optimised code paths between Knit based repositories."""
1957
1958
_matching_repo_format = RepositoryFormatKnit1()
1959
"""Repository format for testing with."""
1960
1961
@staticmethod
1962
def is_compatible(source, target):
1963
"""Be compatible with known Knit formats.
1964
1965
We don't test for the stores being of specific types because that
1966
could lead to confusing results, and there is no need to be
1967
overly general.
1968
"""
1969
try:
1970
return (isinstance(source._format, (RepositoryFormatKnit1)) and
1971
isinstance(target._format, (RepositoryFormatKnit1)))
1972
except AttributeError:
1973
return False
1974
1975
@needs_write_lock
1976
def fetch(self, revision_id=None, pb=None):
1977
"""See InterRepository.fetch()."""
1978
from bzrlib.fetch import KnitRepoFetcher
1979
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1980
self.source, self.source._format, self.target, self.target._format)
1981
f = KnitRepoFetcher(to_repository=self.target,
1982
from_repository=self.source,
1983
last_revision=revision_id,
1984
pb=pb)
1985
return f.count_copied, f.failed_revisions
1986
1987
@needs_read_lock
1988
def missing_revision_ids(self, revision_id=None):
1989
"""See InterRepository.missing_revision_ids()."""
1990
if revision_id is not None:
1991
source_ids = self.source.get_ancestry(revision_id)
1992
assert source_ids[0] is None
1993
source_ids.pop(0)
1994
else:
1995
source_ids = self.source._all_possible_ids()
1996
source_ids_set = set(source_ids)
1997
# source_ids is the worst possible case we may need to pull.
1998
# now we want to filter source_ids against what we actually
1999
# have in target, but don't try to check for existence where we know
2000
# we do not have a revision as that would be pointless.
2001
target_ids = set(self.target._all_possible_ids())
2002
possibly_present_revisions = target_ids.intersection(source_ids_set)
2003
actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
2004
required_revisions = source_ids_set.difference(actually_present_revisions)
2005
required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
2006
if revision_id is not None:
2007
# we used get_ancestry to determine source_ids then we are assured all
2008
# revisions referenced are present as they are installed in topological order.
2009
# and the tip revision was validated by get_ancestry.
2010
return required_topo_revisions
2011
else:
2012
# if we just grabbed the possibly available ids, then
2013
# we only have an estimate of whats available and need to validate
2014
# that against the revision records.
2015
return self.source._eliminate_revisions_not_present(required_topo_revisions)
2016
2017
2018
class InterModel1and2(InterRepository):
2019
2020
_matching_repo_format = None
2021
2022
@staticmethod
2023
def is_compatible(source, target):
2024
if not isinstance(source, Repository):
2025
return False
2026
if not isinstance(target, Repository):
2027
return False
2028
if not source._format.rich_root_data and target._format.rich_root_data:
2029
return True
2030
else:
2031
return False
2032
2033
@needs_write_lock
2034
def fetch(self, revision_id=None, pb=None):
2035
"""See InterRepository.fetch()."""
2036
from bzrlib.fetch import Model1toKnit2Fetcher
2037
f = Model1toKnit2Fetcher(to_repository=self.target,
2038
from_repository=self.source,
2039
last_revision=revision_id,
2040
pb=pb)
2041
return f.count_copied, f.failed_revisions
2042
2043
@needs_write_lock
2044
def copy_content(self, revision_id=None, basis=None):
2045
"""Make a complete copy of the content in self into destination.
2046
2047
This is a destructive operation! Do not use it on existing
2048
repositories.
2049
2050
:param revision_id: Only copy the content needed to construct
2051
revision_id and its parents.
2052
:param basis: Copy the needed data preferentially from basis.
2053
"""
2054
try:
2055
self.target.set_make_working_trees(self.source.make_working_trees())
2056
except NotImplementedError:
2057
pass
2058
# grab the basis available data
2059
if basis is not None:
2060
self.target.fetch(basis, revision_id=revision_id)
2061
# but don't bother fetching if we have the needed data now.
2062
if (revision_id not in (None, NULL_REVISION) and
2063
self.target.has_revision(revision_id)):
2064
return
2065
self.target.fetch(self.source, revision_id=revision_id)
2066
2067
2068
class InterKnit1and2(InterKnitRepo):
2069
2070
_matching_repo_format = None
2071
2072
@staticmethod
2073
def is_compatible(source, target):
2074
"""Be compatible with Knit1 source and Knit2 target"""
2075
try:
2076
return (isinstance(source._format, (RepositoryFormatKnit1)) and
2077
isinstance(target._format, (RepositoryFormatKnit2)))
2078
except AttributeError:
2079
return False
2080
2081
@needs_write_lock
2082
def fetch(self, revision_id=None, pb=None):
2083
"""See InterRepository.fetch()."""
2084
from bzrlib.fetch import Knit1to2Fetcher
2085
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2086
self.source, self.source._format, self.target,
2087
self.target._format)
2088
f = Knit1to2Fetcher(to_repository=self.target,
2089
from_repository=self.source,
2090
last_revision=revision_id,
2091
pb=pb)
2092
return f.count_copied, f.failed_revisions
2093
2094
2095
InterRepository.register_optimiser(InterSameDataRepository)
2096
InterRepository.register_optimiser(InterWeaveRepo)
2097
InterRepository.register_optimiser(InterKnitRepo)
2098
InterRepository.register_optimiser(InterModel1and2)
2099
InterRepository.register_optimiser(InterKnit1and2)
2100
2101
2102
class RepositoryTestProviderAdapter(object):
2103
"""A tool to generate a suite testing multiple repository formats at once.
2104
2105
This is done by copying the test once for each transport and injecting
2106
the transport_server, transport_readonly_server, and bzrdir_format and
2107
repository_format classes into each copy. Each copy is also given a new id()
2108
to make it easy to identify.
2109
"""
2110
2111
def __init__(self, transport_server, transport_readonly_server, formats):
2112
self._transport_server = transport_server
2113
self._transport_readonly_server = transport_readonly_server
2114
self._formats = formats
2115
2116
def adapt(self, test):
2117
result = TestSuite()
2118
for repository_format, bzrdir_format in self._formats:
2119
new_test = deepcopy(test)
2120
new_test.transport_server = self._transport_server
2121
new_test.transport_readonly_server = self._transport_readonly_server
2122
new_test.bzrdir_format = bzrdir_format
2123
new_test.repository_format = repository_format
2124
def make_new_test_id():
2125
new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
2126
return lambda: new_id
2127
new_test.id = make_new_test_id()
2128
result.addTest(new_test)
2129
return result
2130
2131
2132
class InterRepositoryTestProviderAdapter(object):
2133
"""A tool to generate a suite testing multiple inter repository formats.
2134
2135
This is done by copying the test once for each interrepo provider and injecting
2136
the transport_server, transport_readonly_server, repository_format and
2137
repository_to_format classes into each copy.
2138
Each copy is also given a new id() to make it easy to identify.
2139
"""
2140
2141
def __init__(self, transport_server, transport_readonly_server, formats):
2142
self._transport_server = transport_server
2143
self._transport_readonly_server = transport_readonly_server
2144
self._formats = formats
2145
2146
def adapt(self, test):
2147
result = TestSuite()
2148
for interrepo_class, repository_format, repository_format_to in self._formats:
2149
new_test = deepcopy(test)
2150
new_test.transport_server = self._transport_server
2151
new_test.transport_readonly_server = self._transport_readonly_server
2152
new_test.interrepo_class = interrepo_class
2153
new_test.repository_format = repository_format
2154
new_test.repository_format_to = repository_format_to
2155
def make_new_test_id():
2156
new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
2157
return lambda: new_id
2158
new_test.id = make_new_test_id()
2159
result.addTest(new_test)
2160
return result
2161
2162
@staticmethod
2163
def default_test_list():
2164
"""Generate the default list of interrepo permutations to test."""
2165
result = []
2166
# test the default InterRepository between format 6 and the current
2167
# default format.
2168
# XXX: robertc 20060220 reinstate this when there are two supported
2169
# formats which do not have an optimal code path between them.
2170
#result.append((InterRepository,
2171
# RepositoryFormat6(),
2172
# RepositoryFormatKnit1()))
2173
for optimiser in InterRepository._optimisers:
2174
if optimiser._matching_repo_format is not None:
2175
result.append((optimiser,
2176
optimiser._matching_repo_format,
2177
optimiser._matching_repo_format
2178
))
2179
# if there are specific combinations we want to use, we can add them
2180
# here.
2181
result.append((InterModel1and2, RepositoryFormat5(),
2182
RepositoryFormatKnit2()))
2183
result.append((InterKnit1and2, RepositoryFormatKnit1(),
2184
RepositoryFormatKnit2()))
2185
return result
2186
2187
2188
class CopyConverter(object):
2189
"""A repository conversion tool which just performs a copy of the content.
2190
2191
This is slow but quite reliable.
2192
"""
2193
2194
def __init__(self, target_format):
2195
"""Create a CopyConverter.
2196
2197
:param target_format: The format the resulting repository should be.
2198
"""
2199
self.target_format = target_format
2200
2201
def convert(self, repo, pb):
2202
"""Perform the conversion of to_convert, giving feedback via pb.
2203
2204
:param to_convert: The disk object to convert.
2205
:param pb: a progress bar to use for progress information.
2206
"""
2207
self.pb = pb
2208
self.count = 0
2209
self.total = 4
2210
# this is only useful with metadir layouts - separated repo content.
2211
# trigger an assertion if not such
2212
repo._format.get_format_string()
2213
self.repo_dir = repo.bzrdir
2214
self.step('Moving repository to repository.backup')
2215
self.repo_dir.transport.move('repository', 'repository.backup')
2216
backup_transport = self.repo_dir.transport.clone('repository.backup')
2217
repo._format.check_conversion_target(self.target_format)
2218
self.source_repo = repo._format.open(self.repo_dir,
2219
_found=True,
2220
_override_transport=backup_transport)
2221
self.step('Creating new repository')
2222
converted = self.target_format.initialize(self.repo_dir,
2223
self.source_repo.is_shared())
2224
converted.lock_write()
2225
try:
2226
self.step('Copying content into repository.')
2227
self.source_repo.copy_content_into(converted)
2228
finally:
2229
converted.unlock()
2230
self.step('Deleting old repository content.')
2231
self.repo_dir.transport.delete_tree('repository.backup')
2232
self.pb.note('repository converted')
2233
2234
def step(self, message):
2235
"""Update the pb by a step."""
2236
self.count +=1
2237
self.pb.update(message, self.count, self.total)
2238
2239
2240
class CommitBuilder(object):
2241
"""Provides an interface to build up a commit.
2242
2243
This allows describing a tree to be committed without needing to
2244
know the internals of the format of the repository.
2245
"""
2246
2247
record_root_entry = False
2248
def __init__(self, repository, parents, config, timestamp=None,
2249
timezone=None, committer=None, revprops=None,
2250
revision_id=None):
2251
"""Initiate a CommitBuilder.
2252
2253
:param repository: Repository to commit to.
2254
:param parents: Revision ids of the parents of the new revision.
2255
:param config: Configuration to use.
2256
:param timestamp: Optional timestamp recorded for commit.
2257
:param timezone: Optional timezone for timestamp.
2258
:param committer: Optional committer to set for commit.
2259
:param revprops: Optional dictionary of revision properties.
2260
:param revision_id: Optional revision id.
2261
"""
2262
self._config = config
2263
2264
if committer is None:
2265
self._committer = self._config.username()
2266
else:
2267
assert isinstance(committer, basestring), type(committer)
2268
self._committer = committer
2269
2270
self.new_inventory = Inventory(None)
2271
self._new_revision_id = revision_id
2272
self.parents = parents
2273
self.repository = repository
2274
2275
self._revprops = {}
2276
if revprops is not None:
2277
self._revprops.update(revprops)
2278
2279
if timestamp is None:
2280
timestamp = time.time()
2281
# Restrict resolution to 1ms
2282
self._timestamp = round(timestamp, 3)
2283
2284
if timezone is None:
2285
self._timezone = local_time_offset()
2286
else:
2287
self._timezone = int(timezone)
2288
2289
self._generate_revision_if_needed()
2290
2291
def commit(self, message):
2292
"""Make the actual commit.
2293
2294
:return: The revision id of the recorded revision.
2295
"""
2296
rev = Revision(timestamp=self._timestamp,
2297
timezone=self._timezone,
2298
committer=self._committer,
2299
message=message,
2300
inventory_sha1=self.inv_sha1,
2301
revision_id=self._new_revision_id,
2302
properties=self._revprops)
2303
rev.parent_ids = self.parents
2304
self.repository.add_revision(self._new_revision_id, rev,
2305
self.new_inventory, self._config)
2306
return self._new_revision_id
2307
2308
def finish_inventory(self):
2309
"""Tell the builder that the inventory is finished."""
2310
if self.new_inventory.root is None:
2311
symbol_versioning.warn('Root entry should be supplied to'
2312
' record_entry_contents, as of bzr 0.10.',
2313
DeprecationWarning, stacklevel=2)
2314
self.new_inventory.add(InventoryDirectory(ROOT_ID, '', None))
2315
self.new_inventory.revision_id = self._new_revision_id
2316
self.inv_sha1 = self.repository.add_inventory(
2317
self._new_revision_id,
2318
self.new_inventory,
2319
self.parents
2320
)
2321
2322
def _gen_revision_id(self):
2323
"""Return new revision-id."""
2324
s = '%s-%s-' % (self._config.user_email(),
2325
compact_date(self._timestamp))
2326
s += hexlify(rand_bytes(8))
2327
return s
2328
2329
def _generate_revision_if_needed(self):
2330
"""Create a revision id if None was supplied.
2331
2332
If the repository can not support user-specified revision ids
2333
they should override this function and raise UnsupportedOperation
2334
if _new_revision_id is not None.
2335
2336
:raises: UnsupportedOperation
2337
"""
2338
if self._new_revision_id is None:
2339
self._new_revision_id = self._gen_revision_id()
2340
2341
def record_entry_contents(self, ie, parent_invs, path, tree):
2342
"""Record the content of ie from tree into the commit if needed.
2343
2344
Side effect: sets ie.revision when unchanged
2345
2346
:param ie: An inventory entry present in the commit.
2347
:param parent_invs: The inventories of the parent revisions of the
2348
commit.
2349
:param path: The path the entry is at in the tree.
2350
:param tree: The tree which contains this entry and should be used to
2351
obtain content.
2352
"""
2353
if self.new_inventory.root is None and ie.parent_id is not None:
2354
symbol_versioning.warn('Root entry should be supplied to'
2355
' record_entry_contents, as of bzr 0.10.',
2356
DeprecationWarning, stacklevel=2)
2357
self.record_entry_contents(tree.inventory.root.copy(), parent_invs,
2358
'', tree)
2359
self.new_inventory.add(ie)
2360
2361
# ie.revision is always None if the InventoryEntry is considered
2362
# for committing. ie.snapshot will record the correct revision
2363
# which may be the sole parent if it is untouched.
2364
if ie.revision is not None:
2365
return
2366
2367
# In this revision format, root entries have no knit or weave
2368
if ie is self.new_inventory.root:
2369
if len(parent_invs):
2370
ie.revision = parent_invs[0].root.revision
2371
else:
2372
ie.revision = None
2373
return
2374
previous_entries = ie.find_previous_heads(
2375
parent_invs,
2376
self.repository.weave_store,
2377
self.repository.get_transaction())
2378
# we are creating a new revision for ie in the history store
2379
# and inventory.
2380
ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
2381
2382
def modified_directory(self, file_id, file_parents):
2383
"""Record the presence of a symbolic link.
2384
2385
:param file_id: The file_id of the link to record.
2386
:param file_parents: The per-file parent revision ids.
2387
"""
2388
self._add_text_to_weave(file_id, [], file_parents.keys())
2389
2390
def modified_file_text(self, file_id, file_parents,
2391
get_content_byte_lines, text_sha1=None,
2392
text_size=None):
2393
"""Record the text of file file_id
2394
2395
:param file_id: The file_id of the file to record the text of.
2396
:param file_parents: The per-file parent revision ids.
2397
:param get_content_byte_lines: A callable which will return the byte
2398
lines for the file.
2399
:param text_sha1: Optional SHA1 of the file contents.
2400
:param text_size: Optional size of the file contents.
2401
"""
2402
# mutter('storing text of file {%s} in revision {%s} into %r',
2403
# file_id, self._new_revision_id, self.repository.weave_store)
2404
# special case to avoid diffing on renames or
2405
# reparenting
2406
if (len(file_parents) == 1
2407
and text_sha1 == file_parents.values()[0].text_sha1
2408
and text_size == file_parents.values()[0].text_size):
2409
previous_ie = file_parents.values()[0]
2410
versionedfile = self.repository.weave_store.get_weave(file_id,
2411
self.repository.get_transaction())
2412
versionedfile.clone_text(self._new_revision_id,
2413
previous_ie.revision, file_parents.keys())
2414
return text_sha1, text_size
2415
else:
2416
new_lines = get_content_byte_lines()
2417
# TODO: Rather than invoking sha_strings here, _add_text_to_weave
2418
# should return the SHA1 and size
2419
self._add_text_to_weave(file_id, new_lines, file_parents.keys())
2420
return osutils.sha_strings(new_lines), \
2421
sum(map(len, new_lines))
2422
2423
def modified_link(self, file_id, file_parents, link_target):
2424
"""Record the presence of a symbolic link.
2425
2426
:param file_id: The file_id of the link to record.
2427
:param file_parents: The per-file parent revision ids.
2428
:param link_target: Target location of this link.
2429
"""
2430
self._add_text_to_weave(file_id, [], file_parents.keys())
2431
2432
def _add_text_to_weave(self, file_id, new_lines, parents):
2433
versionedfile = self.repository.weave_store.get_weave_or_empty(
2434
file_id, self.repository.get_transaction())
2435
versionedfile.add_lines(self._new_revision_id, parents, new_lines)
2436
versionedfile.clear_cache()
2437
2438
2439
class _CommitBuilder(CommitBuilder):
2440
"""Temporary class so old CommitBuilders are detected properly
2441
2442
Note: CommitBuilder works whether or not root entry is recorded.
2443
"""
2444
2445
record_root_entry = True
2446
2447
2448
class RootCommitBuilder(CommitBuilder):
2449
"""This commitbuilder actually records the root id"""
2450
2451
record_root_entry = True
2452
2453
def record_entry_contents(self, ie, parent_invs, path, tree):
2454
"""Record the content of ie from tree into the commit if needed.
2455
2456
Side effect: sets ie.revision when unchanged
2457
2458
:param ie: An inventory entry present in the commit.
2459
:param parent_invs: The inventories of the parent revisions of the
2460
commit.
2461
:param path: The path the entry is at in the tree.
2462
:param tree: The tree which contains this entry and should be used to
2463
obtain content.
2464
"""
2465
assert self.new_inventory.root is not None or ie.parent_id is None
2466
self.new_inventory.add(ie)
2467
2468
# ie.revision is always None if the InventoryEntry is considered
2469
# for committing. ie.snapshot will record the correct revision
2470
# which may be the sole parent if it is untouched.
2471
if ie.revision is not None:
2472
return
2473
2474
previous_entries = ie.find_previous_heads(
2475
parent_invs,
2476
self.repository.weave_store,
2477
self.repository.get_transaction())
2478
# we are creating a new revision for ie in the history store
2479
# and inventory.
2480
ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
2481
2482
2483
_unescape_map = {
2484
'apos':"'",
2485
'quot':'"',
2486
'amp':'&',
2487
'lt':'<',
2488
'gt':'>'
2489
}
2490
2491
2492
def _unescaper(match, _map=_unescape_map):
2493
return _map[match.group(1)]
2494
2495
2496
_unescape_re = None
2497
2498
2499
def _unescape_xml(data):
2500
"""Unescape predefined XML entities in a string of data."""
2501
global _unescape_re
2502
if _unescape_re is None:
2503
_unescape_re = re.compile('\&([^;]*);')
2504
return _unescape_re.sub(_unescaper, data)
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0