« back to all changes in this revision
Viewing changes to bzrlib/repository.py
- browse files at revision 1728.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 1728.1.1
- Committer: Robert Collins
- Date: 2006-05-24 08:14:45 UTC
- mfrom: (1725.1.1 benchmark)
- mto: (1725.2.6 commit)
- mto: This revision was merged to the branch mainline in revision 1729.
- Revision ID: robertc@robertcollins.net-20060524081445-c046b4406ffc8dfa
(rbc)Merge in benchmark --lsprof-timed lsprofiling feature. (Robert Collins, Martin Pool).
- files added:
- BRANCH.TODO
- bzrlib/benchmarks
- 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/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_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
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- tools
- tools/doc_generate
- files removed:
- bzrlib/mdiff.py
- notes
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/urlgrabber/
- bzrlib/xml.py => bzrlib/xml_serializer.py
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
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 copy import deepcopy
18
from cStringIO import StringIO
19
from unittest import TestSuite
20
21
import bzrlib.bzrdir as bzrdir
22
from bzrlib.decorators import needs_read_lock, needs_write_lock
23
import bzrlib.errors as errors
24
from bzrlib.errors import InvalidRevisionId
25
import bzrlib.gpg as gpg
26
from bzrlib.graph import Graph
27
from bzrlib.inter import InterObject
28
from bzrlib.knit import KnitVersionedFile, KnitPlainFactory
29
from bzrlib.lockable_files import LockableFiles, TransportLock
30
from bzrlib.lockdir import LockDir
31
from bzrlib.osutils import safe_unicode
32
from bzrlib.revision import NULL_REVISION
33
from bzrlib.store.versioned import VersionedFileStore, WeaveStore
34
from bzrlib.store.text import TextStore
35
from bzrlib.symbol_versioning import *
36
from bzrlib.trace import mutter, note
37
from bzrlib.tree import RevisionTree
38
from bzrlib.tsort import topo_sort
39
from bzrlib.testament import Testament
40
from bzrlib.tree import EmptyTree
41
import bzrlib.ui
42
from bzrlib.weave import WeaveFile
43
import bzrlib.xml5
44
45
46
class Repository(object):
47
"""Repository holding history for one or more branches.
48
49
The repository holds and retrieves historical information including
50
revisions and file history. It's normally accessed only by the Branch,
51
which views a particular line of development through that history.
52
53
The Repository builds on top of Stores and a Transport, which respectively
54
describe the disk data format and the way of accessing the (possibly
55
remote) disk.
56
"""
57
58
@needs_write_lock
59
def add_inventory(self, revid, inv, parents):
60
"""Add the inventory inv to the repository as revid.
61
62
:param parents: The revision ids of the parents that revid
63
is known to have and are in the repository already.
64
65
returns the sha1 of the serialized inventory.
66
"""
67
inv_text = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
68
inv_sha1 = bzrlib.osutils.sha_string(inv_text)
69
inv_vf = self.control_weaves.get_weave('inventory',
70
self.get_transaction())
71
inv_vf.add_lines(revid, parents, bzrlib.osutils.split_lines(inv_text))
72
return inv_sha1
73
74
@needs_write_lock
75
def add_revision(self, rev_id, rev, inv=None, config=None):
76
"""Add rev to the revision store as rev_id.
77
78
:param rev_id: the revision id to use.
79
:param rev: The revision object.
80
:param inv: The inventory for the revision. if None, it will be looked
81
up in the inventory storer
82
:param config: If None no digital signature will be created.
83
If supplied its signature_needed method will be used
84
to determine if a signature should be made.
85
"""
86
if config is not None and config.signature_needed():
87
if inv is None:
88
inv = self.get_inventory(rev_id)
89
plaintext = Testament(rev, inv).as_short_text()
90
self.store_revision_signature(
91
gpg.GPGStrategy(config), plaintext, rev_id)
92
if not rev_id in self.get_inventory_weave():
93
if inv is None:
94
raise errors.WeaveRevisionNotPresent(rev_id,
95
self.get_inventory_weave())
96
else:
97
# yes, this is not suitable for adding with ghosts.
98
self.add_inventory(rev_id, inv, rev.parent_ids)
99
self._revision_store.add_revision(rev, self.get_transaction())
100
101
@needs_read_lock
102
def _all_possible_ids(self):
103
"""Return all the possible revisions that we could find."""
104
return self.get_inventory_weave().versions()
105
106
@needs_read_lock
107
def all_revision_ids(self):
108
"""Returns a list of all the revision ids in the repository.
109
110
These are in as much topological order as the underlying store can
111
present: for weaves ghosts may lead to a lack of correctness until
112
the reweave updates the parents list.
113
"""
114
if self._revision_store.text_store.listable():
115
return self._revision_store.all_revision_ids(self.get_transaction())
116
result = self._all_possible_ids()
117
return self._eliminate_revisions_not_present(result)
118
119
def break_lock(self):
120
"""Break a lock if one is present from another instance.
121
122
Uses the ui factory to ask for confirmation if the lock may be from
123
an active process.
124
"""
125
self.control_files.break_lock()
126
127
@needs_read_lock
128
def _eliminate_revisions_not_present(self, revision_ids):
129
"""Check every revision id in revision_ids to see if we have it.
130
131
Returns a set of the present revisions.
132
"""
133
result = []
134
for id in revision_ids:
135
if self.has_revision(id):
136
result.append(id)
137
return result
138
139
@staticmethod
140
def create(a_bzrdir):
141
"""Construct the current default format repository in a_bzrdir."""
142
return RepositoryFormat.get_default_format().initialize(a_bzrdir)
143
144
def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
145
"""instantiate a Repository.
146
147
:param _format: The format of the repository on disk.
148
:param a_bzrdir: The BzrDir of the repository.
149
150
In the future we will have a single api for all stores for
151
getting file texts, inventories and revisions, then
152
this construct will accept instances of those things.
153
"""
154
super(Repository, self).__init__()
155
self._format = _format
156
# the following are part of the public API for Repository:
157
self.bzrdir = a_bzrdir
158
self.control_files = control_files
159
self._revision_store = _revision_store
160
self.text_store = text_store
161
# backwards compatability
162
self.weave_store = text_store
163
# not right yet - should be more semantically clear ?
164
#
165
self.control_store = control_store
166
self.control_weaves = control_store
167
# TODO: make sure to construct the right store classes, etc, depending
168
# on whether escaping is required.
169
170
def __repr__(self):
171
return '%s(%r)' % (self.__class__.__name__,
172
self.bzrdir.transport.base)
173
174
def is_locked(self):
175
return self.control_files.is_locked()
176
177
def lock_write(self):
178
self.control_files.lock_write()
179
180
def lock_read(self):
181
self.control_files.lock_read()
182
183
def get_physical_lock_status(self):
184
return self.control_files.get_physical_lock_status()
185
186
@needs_read_lock
187
def missing_revision_ids(self, other, revision_id=None):
188
"""Return the revision ids that other has that this does not.
189
190
These are returned in topological order.
191
192
revision_id: only return revision ids included by revision_id.
193
"""
194
return InterRepository.get(other, self).missing_revision_ids(revision_id)
195
196
@staticmethod
197
def open(base):
198
"""Open the repository rooted at base.
199
200
For instance, if the repository is at URL/.bzr/repository,
201
Repository.open(URL) -> a Repository instance.
202
"""
203
control = bzrlib.bzrdir.BzrDir.open(base)
204
return control.open_repository()
205
206
def copy_content_into(self, destination, revision_id=None, basis=None):
207
"""Make a complete copy of the content in self into destination.
208
209
This is a destructive operation! Do not use it on existing
210
repositories.
211
"""
212
return InterRepository.get(self, destination).copy_content(revision_id, basis)
213
214
def fetch(self, source, revision_id=None, pb=None):
215
"""Fetch the content required to construct revision_id from source.
216
217
If revision_id is None all content is copied.
218
"""
219
return InterRepository.get(source, self).fetch(revision_id=revision_id,
220
pb=pb)
221
222
def unlock(self):
223
self.control_files.unlock()
224
225
@needs_read_lock
226
def clone(self, a_bzrdir, revision_id=None, basis=None):
227
"""Clone this repository into a_bzrdir using the current format.
228
229
Currently no check is made that the format of this repository and
230
the bzrdir format are compatible. FIXME RBC 20060201.
231
"""
232
if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
233
# use target default format.
234
result = a_bzrdir.create_repository()
235
# FIXME RBC 20060209 split out the repository type to avoid this check ?
236
elif isinstance(a_bzrdir._format,
237
(bzrlib.bzrdir.BzrDirFormat4,
238
bzrlib.bzrdir.BzrDirFormat5,
239
bzrlib.bzrdir.BzrDirFormat6)):
240
result = a_bzrdir.open_repository()
241
else:
242
result = self._format.initialize(a_bzrdir, shared=self.is_shared())
243
self.copy_content_into(result, revision_id, basis)
244
return result
245
246
@needs_read_lock
247
def has_revision(self, revision_id):
248
"""True if this repository has a copy of the revision."""
249
return self._revision_store.has_revision_id(revision_id,
250
self.get_transaction())
251
252
@needs_read_lock
253
def get_revision_reconcile(self, revision_id):
254
"""'reconcile' helper routine that allows access to a revision always.
255
256
This variant of get_revision does not cross check the weave graph
257
against the revision one as get_revision does: but it should only
258
be used by reconcile, or reconcile-alike commands that are correcting
259
or testing the revision graph.
260
"""
261
if not revision_id or not isinstance(revision_id, basestring):
262
raise InvalidRevisionId(revision_id=revision_id, branch=self)
263
return self._revision_store.get_revision(revision_id,
264
self.get_transaction())
265
266
@needs_read_lock
267
def get_revision_xml(self, revision_id):
268
rev = self.get_revision(revision_id)
269
rev_tmp = StringIO()
270
# the current serializer..
271
self._revision_store._serializer.write_revision(rev, rev_tmp)
272
rev_tmp.seek(0)
273
return rev_tmp.getvalue()
274
275
@needs_read_lock
276
def get_revision(self, revision_id):
277
"""Return the Revision object for a named revision"""
278
r = self.get_revision_reconcile(revision_id)
279
# weave corruption can lead to absent revision markers that should be
280
# present.
281
# the following test is reasonably cheap (it needs a single weave read)
282
# and the weave is cached in read transactions. In write transactions
283
# it is not cached but typically we only read a small number of
284
# revisions. For knits when they are introduced we will probably want
285
# to ensure that caching write transactions are in use.
286
inv = self.get_inventory_weave()
287
self._check_revision_parents(r, inv)
288
return r
289
290
def _check_revision_parents(self, revision, inventory):
291
"""Private to Repository and Fetch.
292
293
This checks the parentage of revision in an inventory weave for
294
consistency and is only applicable to inventory-weave-for-ancestry
295
using repository formats & fetchers.
296
"""
297
weave_parents = inventory.get_parents(revision.revision_id)
298
weave_names = inventory.versions()
299
for parent_id in revision.parent_ids:
300
if parent_id in weave_names:
301
# this parent must not be a ghost.
302
if not parent_id in weave_parents:
303
# but it is a ghost
304
raise errors.CorruptRepository(self)
305
306
@needs_write_lock
307
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
308
signature = gpg_strategy.sign(plaintext)
309
self._revision_store.add_revision_signature_text(revision_id,
310
signature,
311
self.get_transaction())
312
313
def fileids_altered_by_revision_ids(self, revision_ids):
314
"""Find the file ids and versions affected by revisions.
315
316
:param revisions: an iterable containing revision ids.
317
:return: a dictionary mapping altered file-ids to an iterable of
318
revision_ids. Each altered file-ids has the exact revision_ids that
319
altered it listed explicitly.
320
"""
321
assert isinstance(self._format, (RepositoryFormat5,
322
RepositoryFormat6,
323
RepositoryFormat7,
324
RepositoryFormatKnit1)), \
325
"fileid_involved only supported for branches which store inventory as unnested xml"
326
selected_revision_ids = set(revision_ids)
327
w = self.get_inventory_weave()
328
result = {}
329
330
# this code needs to read every new line in every inventory for the
331
# inventories [revision_ids]. Seeing a line twice is ok. Seeing a line
332
# not pesent in one of those inventories is unnecessary but not
333
# harmful because we are filtering by the revision id marker in the
334
# inventory lines : we only select file ids altered in one of those
335
# revisions. We dont need to see all lines in the inventory because
336
# only those added in an inventory in rev X can contain a revision=X
337
# line.
338
for line in w.iter_lines_added_or_present_in_versions(selected_revision_ids):
339
start = line.find('file_id="')+9
340
if start < 9: continue
341
end = line.find('"', start)
342
assert end>= 0
343
file_id = _unescape_xml(line[start:end])
344
345
start = line.find('revision="')+10
346
if start < 10: continue
347
end = line.find('"', start)
348
assert end>= 0
349
revision_id = _unescape_xml(line[start:end])
350
if revision_id in selected_revision_ids:
351
result.setdefault(file_id, set()).add(revision_id)
352
return result
353
354
@needs_read_lock
355
def get_inventory_weave(self):
356
return self.control_weaves.get_weave('inventory',
357
self.get_transaction())
358
359
@needs_read_lock
360
def get_inventory(self, revision_id):
361
"""Get Inventory object by hash."""
362
xml = self.get_inventory_xml(revision_id)
363
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
364
365
@needs_read_lock
366
def get_inventory_xml(self, revision_id):
367
"""Get inventory XML as a file object."""
368
try:
369
assert isinstance(revision_id, basestring), type(revision_id)
370
iw = self.get_inventory_weave()
371
return iw.get_text(revision_id)
372
except IndexError:
373
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
374
375
@needs_read_lock
376
def get_inventory_sha1(self, revision_id):
377
"""Return the sha1 hash of the inventory entry
378
"""
379
return self.get_revision(revision_id).inventory_sha1
380
381
@needs_read_lock
382
def get_revision_graph(self, revision_id=None):
383
"""Return a dictionary containing the revision graph.
384
385
:return: a dictionary of revision_id->revision_parents_list.
386
"""
387
weave = self.get_inventory_weave()
388
all_revisions = self._eliminate_revisions_not_present(weave.versions())
389
entire_graph = dict([(node, weave.get_parents(node)) for
390
node in all_revisions])
391
if revision_id is None:
392
return entire_graph
393
elif revision_id not in entire_graph:
394
raise errors.NoSuchRevision(self, revision_id)
395
else:
396
# add what can be reached from revision_id
397
result = {}
398
pending = set([revision_id])
399
while len(pending) > 0:
400
node = pending.pop()
401
result[node] = entire_graph[node]
402
for revision_id in result[node]:
403
if revision_id not in result:
404
pending.add(revision_id)
405
return result
406
407
@needs_read_lock
408
def get_revision_graph_with_ghosts(self, revision_ids=None):
409
"""Return a graph of the revisions with ghosts marked as applicable.
410
411
:param revision_ids: an iterable of revisions to graph or None for all.
412
:return: a Graph object with the graph reachable from revision_ids.
413
"""
414
result = Graph()
415
if not revision_ids:
416
pending = set(self.all_revision_ids())
417
required = set([])
418
else:
419
pending = set(revision_ids)
420
required = set(revision_ids)
421
done = set([])
422
while len(pending):
423
revision_id = pending.pop()
424
try:
425
rev = self.get_revision(revision_id)
426
except errors.NoSuchRevision:
427
if revision_id in required:
428
raise
429
# a ghost
430
result.add_ghost(revision_id)
431
continue
432
for parent_id in rev.parent_ids:
433
# is this queued or done ?
434
if (parent_id not in pending and
435
parent_id not in done):
436
# no, queue it.
437
pending.add(parent_id)
438
result.add_node(revision_id, rev.parent_ids)
439
done.add(revision_id)
440
return result
441
442
@needs_read_lock
443
def get_revision_inventory(self, revision_id):
444
"""Return inventory of a past revision."""
445
# TODO: Unify this with get_inventory()
446
# bzr 0.0.6 and later imposes the constraint that the inventory_id
447
# must be the same as its revision, so this is trivial.
448
if revision_id is None:
449
# This does not make sense: if there is no revision,
450
# then it is the current tree inventory surely ?!
451
# and thus get_root_id() is something that looks at the last
452
# commit on the branch, and the get_root_id is an inventory check.
453
raise NotImplementedError
454
# return Inventory(self.get_root_id())
455
else:
456
return self.get_inventory(revision_id)
457
458
@needs_read_lock
459
def is_shared(self):
460
"""Return True if this repository is flagged as a shared repository."""
461
raise NotImplementedError(self.is_shared)
462
463
@needs_write_lock
464
def reconcile(self, other=None, thorough=False):
465
"""Reconcile this repository."""
466
from bzrlib.reconcile import RepoReconciler
467
reconciler = RepoReconciler(self, thorough=thorough)
468
reconciler.reconcile()
469
return reconciler
470
471
@needs_read_lock
472
def revision_tree(self, revision_id):
473
"""Return Tree for a revision on this branch.
474
475
`revision_id` may be None for the null revision, in which case
476
an `EmptyTree` is returned."""
477
# TODO: refactor this to use an existing revision object
478
# so we don't need to read it in twice.
479
if revision_id is None or revision_id == NULL_REVISION:
480
return EmptyTree()
481
else:
482
inv = self.get_revision_inventory(revision_id)
483
return RevisionTree(self, inv, revision_id)
484
485
@needs_read_lock
486
def get_ancestry(self, revision_id):
487
"""Return a list of revision-ids integrated by a revision.
488
489
This is topologically sorted.
490
"""
491
if revision_id is None:
492
return [None]
493
if not self.has_revision(revision_id):
494
raise errors.NoSuchRevision(self, revision_id)
495
w = self.get_inventory_weave()
496
candidates = w.get_ancestry(revision_id)
497
return [None] + candidates # self._eliminate_revisions_not_present(candidates)
498
499
@needs_read_lock
500
def print_file(self, file, revision_id):
501
"""Print `file` to stdout.
502
503
FIXME RBC 20060125 as John Meinel points out this is a bad api
504
- it writes to stdout, it assumes that that is valid etc. Fix
505
by creating a new more flexible convenience function.
506
"""
507
tree = self.revision_tree(revision_id)
508
# use inventory as it was in that revision
509
file_id = tree.inventory.path2id(file)
510
if not file_id:
511
raise BzrError("%r is not present in revision %s" % (file, revno))
512
try:
513
revno = self.revision_id_to_revno(revision_id)
514
except errors.NoSuchRevision:
515
# TODO: This should not be BzrError,
516
# but NoSuchFile doesn't fit either
517
raise BzrError('%r is not present in revision %s'
518
% (file, revision_id))
519
else:
520
raise BzrError('%r is not present in revision %s'
521
% (file, revno))
522
tree.print_file(file_id)
523
524
def get_transaction(self):
525
return self.control_files.get_transaction()
526
527
def revision_parents(self, revid):
528
return self.get_inventory_weave().parent_names(revid)
529
530
@needs_write_lock
531
def set_make_working_trees(self, new_value):
532
"""Set the policy flag for making working trees when creating branches.
533
534
This only applies to branches that use this repository.
535
536
The default is 'True'.
537
:param new_value: True to restore the default, False to disable making
538
working trees.
539
"""
540
raise NotImplementedError(self.set_make_working_trees)
541
542
def make_working_trees(self):
543
"""Returns the policy for making working trees on new branches."""
544
raise NotImplementedError(self.make_working_trees)
545
546
@needs_write_lock
547
def sign_revision(self, revision_id, gpg_strategy):
548
plaintext = Testament.from_revision(self, revision_id).as_short_text()
549
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
550
551
@needs_read_lock
552
def has_signature_for_revision_id(self, revision_id):
553
"""Query for a revision signature for revision_id in the repository."""
554
return self._revision_store.has_signature(revision_id,
555
self.get_transaction())
556
557
@needs_read_lock
558
def get_signature_text(self, revision_id):
559
"""Return the text for a signature."""
560
return self._revision_store.get_signature_text(revision_id,
561
self.get_transaction())
562
563
564
class AllInOneRepository(Repository):
565
"""Legacy support - the repository behaviour for all-in-one branches."""
566
567
def __init__(self, _format, a_bzrdir, _revision_store, control_store, text_store):
568
# we reuse one control files instance.
569
dir_mode = a_bzrdir._control_files._dir_mode
570
file_mode = a_bzrdir._control_files._file_mode
571
572
def get_store(name, compressed=True, prefixed=False):
573
# FIXME: This approach of assuming stores are all entirely compressed
574
# or entirely uncompressed is tidy, but breaks upgrade from
575
# some existing branches where there's a mixture; we probably
576
# still want the option to look for both.
577
relpath = a_bzrdir._control_files._escape(name)
578
store = TextStore(a_bzrdir._control_files._transport.clone(relpath),
579
prefixed=prefixed, compressed=compressed,
580
dir_mode=dir_mode,
581
file_mode=file_mode)
582
#if self._transport.should_cache():
583
# cache_path = os.path.join(self.cache_root, name)
584
# os.mkdir(cache_path)
585
# store = bzrlib.store.CachedStore(store, cache_path)
586
return store
587
588
# not broken out yet because the controlweaves|inventory_store
589
# and text_store | weave_store bits are still different.
590
if isinstance(_format, RepositoryFormat4):
591
# cannot remove these - there is still no consistent api
592
# which allows access to this old info.
593
self.inventory_store = get_store('inventory-store')
594
text_store = get_store('text-store')
595
super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)
596
597
@needs_read_lock
598
def is_shared(self):
599
"""AllInOne repositories cannot be shared."""
600
return False
601
602
@needs_write_lock
603
def set_make_working_trees(self, new_value):
604
"""Set the policy flag for making working trees when creating branches.
605
606
This only applies to branches that use this repository.
607
608
The default is 'True'.
609
:param new_value: True to restore the default, False to disable making
610
working trees.
611
"""
612
raise NotImplementedError(self.set_make_working_trees)
613
614
def make_working_trees(self):
615
"""Returns the policy for making working trees on new branches."""
616
return True
617
618
619
class MetaDirRepository(Repository):
620
"""Repositories in the new meta-dir layout."""
621
622
def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
623
super(MetaDirRepository, self).__init__(_format,
624
a_bzrdir,
625
control_files,
626
_revision_store,
627
control_store,
628
text_store)
629
630
dir_mode = self.control_files._dir_mode
631
file_mode = self.control_files._file_mode
632
633
@needs_read_lock
634
def is_shared(self):
635
"""Return True if this repository is flagged as a shared repository."""
636
return self.control_files._transport.has('shared-storage')
637
638
@needs_write_lock
639
def set_make_working_trees(self, new_value):
640
"""Set the policy flag for making working trees when creating branches.
641
642
This only applies to branches that use this repository.
643
644
The default is 'True'.
645
:param new_value: True to restore the default, False to disable making
646
working trees.
647
"""
648
if new_value:
649
try:
650
self.control_files._transport.delete('no-working-trees')
651
except errors.NoSuchFile:
652
pass
653
else:
654
self.control_files.put_utf8('no-working-trees', '')
655
656
def make_working_trees(self):
657
"""Returns the policy for making working trees on new branches."""
658
return not self.control_files._transport.has('no-working-trees')
659
660
661
class KnitRepository(MetaDirRepository):
662
"""Knit format repository."""
663
664
@needs_read_lock
665
def all_revision_ids(self):
666
"""See Repository.all_revision_ids()."""
667
return self._revision_store.all_revision_ids(self.get_transaction())
668
669
def fileid_involved_between_revs(self, from_revid, to_revid):
670
"""Find file_id(s) which are involved in the changes between revisions.
671
672
This determines the set of revisions which are involved, and then
673
finds all file ids affected by those revisions.
674
"""
675
vf = self._get_revision_vf()
676
from_set = set(vf.get_ancestry(from_revid))
677
to_set = set(vf.get_ancestry(to_revid))
678
changed = to_set.difference(from_set)
679
return self._fileid_involved_by_set(changed)
680
681
def fileid_involved(self, last_revid=None):
682
"""Find all file_ids modified in the ancestry of last_revid.
683
684
:param last_revid: If None, last_revision() will be used.
685
"""
686
if not last_revid:
687
changed = set(self.all_revision_ids())
688
else:
689
changed = set(self.get_ancestry(last_revid))
690
if None in changed:
691
changed.remove(None)
692
return self._fileid_involved_by_set(changed)
693
694
@needs_read_lock
695
def get_ancestry(self, revision_id):
696
"""Return a list of revision-ids integrated by a revision.
697
698
This is topologically sorted.
699
"""
700
if revision_id is None:
701
return [None]
702
vf = self._get_revision_vf()
703
try:
704
return [None] + vf.get_ancestry(revision_id)
705
except errors.RevisionNotPresent:
706
raise errors.NoSuchRevision(self, revision_id)
707
708
@needs_read_lock
709
def get_revision(self, revision_id):
710
"""Return the Revision object for a named revision"""
711
return self.get_revision_reconcile(revision_id)
712
713
@needs_read_lock
714
def get_revision_graph(self, revision_id=None):
715
"""Return a dictionary containing the revision graph.
716
717
:return: a dictionary of revision_id->revision_parents_list.
718
"""
719
weave = self._get_revision_vf()
720
entire_graph = weave.get_graph()
721
if revision_id is None:
722
return weave.get_graph()
723
elif revision_id not in weave:
724
raise errors.NoSuchRevision(self, revision_id)
725
else:
726
# add what can be reached from revision_id
727
result = {}
728
pending = set([revision_id])
729
while len(pending) > 0:
730
node = pending.pop()
731
result[node] = weave.get_parents(node)
732
for revision_id in result[node]:
733
if revision_id not in result:
734
pending.add(revision_id)
735
return result
736
737
@needs_read_lock
738
def get_revision_graph_with_ghosts(self, revision_ids=None):
739
"""Return a graph of the revisions with ghosts marked as applicable.
740
741
:param revision_ids: an iterable of revisions to graph or None for all.
742
:return: a Graph object with the graph reachable from revision_ids.
743
"""
744
result = Graph()
745
vf = self._get_revision_vf()
746
versions = set(vf.versions())
747
if not revision_ids:
748
pending = set(self.all_revision_ids())
749
required = set([])
750
else:
751
pending = set(revision_ids)
752
required = set(revision_ids)
753
done = set([])
754
while len(pending):
755
revision_id = pending.pop()
756
if not revision_id in versions:
757
if revision_id in required:
758
raise errors.NoSuchRevision(self, revision_id)
759
# a ghost
760
result.add_ghost(revision_id)
761
# mark it as done so we dont try for it again.
762
done.add(revision_id)
763
continue
764
parent_ids = vf.get_parents_with_ghosts(revision_id)
765
for parent_id in parent_ids:
766
# is this queued or done ?
767
if (parent_id not in pending and
768
parent_id not in done):
769
# no, queue it.
770
pending.add(parent_id)
771
result.add_node(revision_id, parent_ids)
772
done.add(revision_id)
773
return result
774
775
def _get_revision_vf(self):
776
""":return: a versioned file containing the revisions."""
777
vf = self._revision_store.get_revision_file(self.get_transaction())
778
return vf
779
780
@needs_write_lock
781
def reconcile(self, other=None, thorough=False):
782
"""Reconcile this repository."""
783
from bzrlib.reconcile import KnitReconciler
784
reconciler = KnitReconciler(self, thorough=thorough)
785
reconciler.reconcile()
786
return reconciler
787
788
def revision_parents(self, revid):
789
return self._get_revision_vf().get_parents(rev_id)
790
791
class RepositoryFormat(object):
792
"""A repository format.
793
794
Formats provide three things:
795
* An initialization routine to construct repository data on disk.
796
* a format string which is used when the BzrDir supports versioned
797
children.
798
* an open routine which returns a Repository instance.
799
800
Formats are placed in an dict by their format string for reference
801
during opening. These should be subclasses of RepositoryFormat
802
for consistency.
803
804
Once a format is deprecated, just deprecate the initialize and open
805
methods on the format class. Do not deprecate the object, as the
806
object will be created every system load.
807
808
Common instance attributes:
809
_matchingbzrdir - the bzrdir format that the repository format was
810
originally written to work with. This can be used if manually
811
constructing a bzrdir and repository, or more commonly for test suite
812
parameterisation.
813
"""
814
815
_default_format = None
816
"""The default format used for new repositories."""
817
818
_formats = {}
819
"""The known formats."""
820
821
@classmethod
822
def find_format(klass, a_bzrdir):
823
"""Return the format for the repository object in a_bzrdir."""
824
try:
825
transport = a_bzrdir.get_repository_transport(None)
826
format_string = transport.get("format").read()
827
return klass._formats[format_string]
828
except errors.NoSuchFile:
829
raise errors.NoRepositoryPresent(a_bzrdir)
830
except KeyError:
831
raise errors.UnknownFormatError(format_string)
832
833
def _get_control_store(self, repo_transport, control_files):
834
"""Return the control store for this repository."""
835
raise NotImplementedError(self._get_control_store)
836
837
@classmethod
838
def get_default_format(klass):
839
"""Return the current default format."""
840
return klass._default_format
841
842
def get_format_string(self):
843
"""Return the ASCII format string that identifies this format.
844
845
Note that in pre format ?? repositories the format string is
846
not permitted nor written to disk.
847
"""
848
raise NotImplementedError(self.get_format_string)
849
850
def get_format_description(self):
851
"""Return the short desciption for this format."""
852
raise NotImplementedError(self.get_format_description)
853
854
def _get_revision_store(self, repo_transport, control_files):
855
"""Return the revision store object for this a_bzrdir."""
856
raise NotImplementedError(self._get_revision_store)
857
858
def _get_text_rev_store(self,
859
transport,
860
control_files,
861
name,
862
compressed=True,
863
prefixed=False,
864
serializer=None):
865
"""Common logic for getting a revision store for a repository.
866
867
see self._get_revision_store for the subclass-overridable method to
868
get the store for a repository.
869
"""
870
from bzrlib.store.revision.text import TextRevisionStore
871
dir_mode = control_files._dir_mode
872
file_mode = control_files._file_mode
873
text_store =TextStore(transport.clone(name),
874
prefixed=prefixed,
875
compressed=compressed,
876
dir_mode=dir_mode,
877
file_mode=file_mode)
878
_revision_store = TextRevisionStore(text_store, serializer)
879
return _revision_store
880
881
def _get_versioned_file_store(self,
882
name,
883
transport,
884
control_files,
885
prefixed=True,
886
versionedfile_class=WeaveFile,
887
escaped=False):
888
weave_transport = control_files._transport.clone(name)
889
dir_mode = control_files._dir_mode
890
file_mode = control_files._file_mode
891
return VersionedFileStore(weave_transport, prefixed=prefixed,
892
dir_mode=dir_mode,
893
file_mode=file_mode,
894
versionedfile_class=versionedfile_class,
895
escaped=escaped)
896
897
def initialize(self, a_bzrdir, shared=False):
898
"""Initialize a repository of this format in a_bzrdir.
899
900
:param a_bzrdir: The bzrdir to put the new repository in it.
901
:param shared: The repository should be initialized as a sharable one.
902
903
This may raise UninitializableFormat if shared repository are not
904
compatible the a_bzrdir.
905
"""
906
907
def is_supported(self):
908
"""Is this format supported?
909
910
Supported formats must be initializable and openable.
911
Unsupported formats may not support initialization or committing or
912
some other features depending on the reason for not being supported.
913
"""
914
return True
915
916
def open(self, a_bzrdir, _found=False):
917
"""Return an instance of this format for the bzrdir a_bzrdir.
918
919
_found is a private parameter, do not use it.
920
"""
921
raise NotImplementedError(self.open)
922
923
@classmethod
924
def register_format(klass, format):
925
klass._formats[format.get_format_string()] = format
926
927
@classmethod
928
def set_default_format(klass, format):
929
klass._default_format = format
930
931
@classmethod
932
def unregister_format(klass, format):
933
assert klass._formats[format.get_format_string()] is format
934
del klass._formats[format.get_format_string()]
935
936
937
class PreSplitOutRepositoryFormat(RepositoryFormat):
938
"""Base class for the pre split out repository formats."""
939
940
def initialize(self, a_bzrdir, shared=False, _internal=False):
941
"""Create a weave repository.
942
943
TODO: when creating split out bzr branch formats, move this to a common
944
base for Format5, Format6. or something like that.
945
"""
946
from bzrlib.weavefile import write_weave_v5
947
from bzrlib.weave import Weave
948
949
if shared:
950
raise errors.IncompatibleFormat(self, a_bzrdir._format)
951
952
if not _internal:
953
# always initialized when the bzrdir is.
954
return self.open(a_bzrdir, _found=True)
955
956
# Create an empty weave
957
sio = StringIO()
958
bzrlib.weavefile.write_weave_v5(Weave(), sio)
959
empty_weave = sio.getvalue()
960
961
mutter('creating repository in %s.', a_bzrdir.transport.base)
962
dirs = ['revision-store', 'weaves']
963
files = [('inventory.weave', StringIO(empty_weave)),
964
]
965
966
# FIXME: RBC 20060125 dont peek under the covers
967
# NB: no need to escape relative paths that are url safe.
968
control_files = LockableFiles(a_bzrdir.transport, 'branch-lock',
969
TransportLock)
970
control_files.create_lock()
971
control_files.lock_write()
972
control_files._transport.mkdir_multi(dirs,
973
mode=control_files._dir_mode)
974
try:
975
for file, content in files:
976
control_files.put(file, content)
977
finally:
978
control_files.unlock()
979
return self.open(a_bzrdir, _found=True)
980
981
def _get_control_store(self, repo_transport, control_files):
982
"""Return the control store for this repository."""
983
return self._get_versioned_file_store('',
984
repo_transport,
985
control_files,
986
prefixed=False)
987
988
def _get_text_store(self, transport, control_files):
989
"""Get a store for file texts for this format."""
990
raise NotImplementedError(self._get_text_store)
991
992
def open(self, a_bzrdir, _found=False):
993
"""See RepositoryFormat.open()."""
994
if not _found:
995
# we are being called directly and must probe.
996
raise NotImplementedError
997
998
repo_transport = a_bzrdir.get_repository_transport(None)
999
control_files = a_bzrdir._control_files
1000
text_store = self._get_text_store(repo_transport, control_files)
1001
control_store = self._get_control_store(repo_transport, control_files)
1002
_revision_store = self._get_revision_store(repo_transport, control_files)
1003
return AllInOneRepository(_format=self,
1004
a_bzrdir=a_bzrdir,
1005
_revision_store=_revision_store,
1006
control_store=control_store,
1007
text_store=text_store)
1008
1009
1010
class RepositoryFormat4(PreSplitOutRepositoryFormat):
1011
"""Bzr repository format 4.
1012
1013
This repository format has:
1014
- flat stores
1015
- TextStores for texts, inventories,revisions.
1016
1017
This format is deprecated: it indexes texts using a text id which is
1018
removed in format 5; initializationa and write support for this format
1019
has been removed.
1020
"""
1021
1022
def __init__(self):
1023
super(RepositoryFormat4, self).__init__()
1024
self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat4()
1025
1026
def get_format_description(self):
1027
"""See RepositoryFormat.get_format_description()."""
1028
return "Repository format 4"
1029
1030
def initialize(self, url, shared=False, _internal=False):
1031
"""Format 4 branches cannot be created."""
1032
raise errors.UninitializableFormat(self)
1033
1034
def is_supported(self):
1035
"""Format 4 is not supported.
1036
1037
It is not supported because the model changed from 4 to 5 and the
1038
conversion logic is expensive - so doing it on the fly was not
1039
feasible.
1040
"""
1041
return False
1042
1043
def _get_control_store(self, repo_transport, control_files):
1044
"""Format 4 repositories have no formal control store at this point.
1045
1046
This will cause any control-file-needing apis to fail - this is desired.
1047
"""
1048
return None
1049
1050
def _get_revision_store(self, repo_transport, control_files):
1051
"""See RepositoryFormat._get_revision_store()."""
1052
from bzrlib.xml4 import serializer_v4
1053
return self._get_text_rev_store(repo_transport,
1054
control_files,
1055
'revision-store',
1056
serializer=serializer_v4)
1057
1058
def _get_text_store(self, transport, control_files):
1059
"""See RepositoryFormat._get_text_store()."""
1060
1061
1062
class RepositoryFormat5(PreSplitOutRepositoryFormat):
1063
"""Bzr control format 5.
1064
1065
This repository format has:
1066
- weaves for file texts and inventory
1067
- flat stores
1068
- TextStores for revisions and signatures.
1069
"""
1070
1071
def __init__(self):
1072
super(RepositoryFormat5, self).__init__()
1073
self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat5()
1074
1075
def get_format_description(self):
1076
"""See RepositoryFormat.get_format_description()."""
1077
return "Weave repository format 5"
1078
1079
def _get_revision_store(self, repo_transport, control_files):
1080
"""See RepositoryFormat._get_revision_store()."""
1081
"""Return the revision store object for this a_bzrdir."""
1082
return self._get_text_rev_store(repo_transport,
1083
control_files,
1084
'revision-store',
1085
compressed=False)
1086
1087
def _get_text_store(self, transport, control_files):
1088
"""See RepositoryFormat._get_text_store()."""
1089
return self._get_versioned_file_store('weaves', transport, control_files, prefixed=False)
1090
1091
1092
class RepositoryFormat6(PreSplitOutRepositoryFormat):
1093
"""Bzr control format 6.
1094
1095
This repository format has:
1096
- weaves for file texts and inventory
1097
- hash subdirectory based stores.
1098
- TextStores for revisions and signatures.
1099
"""
1100
1101
def __init__(self):
1102
super(RepositoryFormat6, self).__init__()
1103
self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat6()
1104
1105
def get_format_description(self):
1106
"""See RepositoryFormat.get_format_description()."""
1107
return "Weave repository format 6"
1108
1109
def _get_revision_store(self, repo_transport, control_files):
1110
"""See RepositoryFormat._get_revision_store()."""
1111
return self._get_text_rev_store(repo_transport,
1112
control_files,
1113
'revision-store',
1114
compressed=False,
1115
prefixed=True)
1116
1117
def _get_text_store(self, transport, control_files):
1118
"""See RepositoryFormat._get_text_store()."""
1119
return self._get_versioned_file_store('weaves', transport, control_files)
1120
1121
1122
class MetaDirRepositoryFormat(RepositoryFormat):
1123
"""Common base class for the new repositories using the metadir layour."""
1124
1125
def __init__(self):
1126
super(MetaDirRepositoryFormat, self).__init__()
1127
self._matchingbzrdir = bzrlib.bzrdir.BzrDirMetaFormat1()
1128
1129
def _create_control_files(self, a_bzrdir):
1130
"""Create the required files and the initial control_files object."""
1131
# FIXME: RBC 20060125 dont peek under the covers
1132
# NB: no need to escape relative paths that are url safe.
1133
repository_transport = a_bzrdir.get_repository_transport(self)
1134
control_files = LockableFiles(repository_transport, 'lock', LockDir)
1135
control_files.create_lock()
1136
return control_files
1137
1138
def _upload_blank_content(self, a_bzrdir, dirs, files, utf8_files, shared):
1139
"""Upload the initial blank content."""
1140
control_files = self._create_control_files(a_bzrdir)
1141
control_files.lock_write()
1142
try:
1143
control_files._transport.mkdir_multi(dirs,
1144
mode=control_files._dir_mode)
1145
for file, content in files:
1146
control_files.put(file, content)
1147
for file, content in utf8_files:
1148
control_files.put_utf8(file, content)
1149
if shared == True:
1150
control_files.put_utf8('shared-storage', '')
1151
finally:
1152
control_files.unlock()
1153
1154
1155
class RepositoryFormat7(MetaDirRepositoryFormat):
1156
"""Bzr repository 7.
1157
1158
This repository format has:
1159
- weaves for file texts and inventory
1160
- hash subdirectory based stores.
1161
- TextStores for revisions and signatures.
1162
- a format marker of its own
1163
- an optional 'shared-storage' flag
1164
- an optional 'no-working-trees' flag
1165
"""
1166
1167
def _get_control_store(self, repo_transport, control_files):
1168
"""Return the control store for this repository."""
1169
return self._get_versioned_file_store('',
1170
repo_transport,
1171
control_files,
1172
prefixed=False)
1173
1174
def get_format_string(self):
1175
"""See RepositoryFormat.get_format_string()."""
1176
return "Bazaar-NG Repository format 7"
1177
1178
def get_format_description(self):
1179
"""See RepositoryFormat.get_format_description()."""
1180
return "Weave repository format 7"
1181
1182
def _get_revision_store(self, repo_transport, control_files):
1183
"""See RepositoryFormat._get_revision_store()."""
1184
return self._get_text_rev_store(repo_transport,
1185
control_files,
1186
'revision-store',
1187
compressed=False,
1188
prefixed=True,
1189
)
1190
1191
def _get_text_store(self, transport, control_files):
1192
"""See RepositoryFormat._get_text_store()."""
1193
return self._get_versioned_file_store('weaves',
1194
transport,
1195
control_files)
1196
1197
def initialize(self, a_bzrdir, shared=False):
1198
"""Create a weave repository.
1199
1200
:param shared: If true the repository will be initialized as a shared
1201
repository.
1202
"""
1203
from bzrlib.weavefile import write_weave_v5
1204
from bzrlib.weave import Weave
1205
1206
# Create an empty weave
1207
sio = StringIO()
1208
bzrlib.weavefile.write_weave_v5(Weave(), sio)
1209
empty_weave = sio.getvalue()
1210
1211
mutter('creating repository in %s.', a_bzrdir.transport.base)
1212
dirs = ['revision-store', 'weaves']
1213
files = [('inventory.weave', StringIO(empty_weave)),
1214
]
1215
utf8_files = [('format', self.get_format_string())]
1216
1217
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1218
return self.open(a_bzrdir=a_bzrdir, _found=True)
1219
1220
def open(self, a_bzrdir, _found=False, _override_transport=None):
1221
"""See RepositoryFormat.open().
1222
1223
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1224
repository at a slightly different url
1225
than normal. I.e. during 'upgrade'.
1226
"""
1227
if not _found:
1228
format = RepositoryFormat.find_format(a_bzrdir)
1229
assert format.__class__ == self.__class__
1230
if _override_transport is not None:
1231
repo_transport = _override_transport
1232
else:
1233
repo_transport = a_bzrdir.get_repository_transport(None)
1234
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1235
text_store = self._get_text_store(repo_transport, control_files)
1236
control_store = self._get_control_store(repo_transport, control_files)
1237
_revision_store = self._get_revision_store(repo_transport, control_files)
1238
return MetaDirRepository(_format=self,
1239
a_bzrdir=a_bzrdir,
1240
control_files=control_files,
1241
_revision_store=_revision_store,
1242
control_store=control_store,
1243
text_store=text_store)
1244
1245
1246
class RepositoryFormatKnit1(MetaDirRepositoryFormat):
1247
"""Bzr repository knit format 1.
1248
1249
This repository format has:
1250
- knits for file texts and inventory
1251
- hash subdirectory based stores.
1252
- knits for revisions and signatures
1253
- TextStores for revisions and signatures.
1254
- a format marker of its own
1255
- an optional 'shared-storage' flag
1256
- an optional 'no-working-trees' flag
1257
- a LockDir lock
1258
1259
This format was introduced in bzr 0.8.
1260
"""
1261
1262
def _get_control_store(self, repo_transport, control_files):
1263
"""Return the control store for this repository."""
1264
return VersionedFileStore(
1265
repo_transport,
1266
prefixed=False,
1267
file_mode=control_files._file_mode,
1268
versionedfile_class=KnitVersionedFile,
1269
versionedfile_kwargs={'factory':KnitPlainFactory()},
1270
)
1271
1272
def get_format_string(self):
1273
"""See RepositoryFormat.get_format_string()."""
1274
return "Bazaar-NG Knit Repository Format 1"
1275
1276
def get_format_description(self):
1277
"""See RepositoryFormat.get_format_description()."""
1278
return "Knit repository format 1"
1279
1280
def _get_revision_store(self, repo_transport, control_files):
1281
"""See RepositoryFormat._get_revision_store()."""
1282
from bzrlib.store.revision.knit import KnitRevisionStore
1283
versioned_file_store = VersionedFileStore(
1284
repo_transport,
1285
file_mode=control_files._file_mode,
1286
prefixed=False,
1287
precious=True,
1288
versionedfile_class=KnitVersionedFile,
1289
versionedfile_kwargs={'delta':False, 'factory':KnitPlainFactory()},
1290
escaped=True,
1291
)
1292
return KnitRevisionStore(versioned_file_store)
1293
1294
def _get_text_store(self, transport, control_files):
1295
"""See RepositoryFormat._get_text_store()."""
1296
return self._get_versioned_file_store('knits',
1297
transport,
1298
control_files,
1299
versionedfile_class=KnitVersionedFile,
1300
escaped=True)
1301
1302
def initialize(self, a_bzrdir, shared=False):
1303
"""Create a knit format 1 repository.
1304
1305
:param a_bzrdir: bzrdir to contain the new repository; must already
1306
be initialized.
1307
:param shared: If true the repository will be initialized as a shared
1308
repository.
1309
"""
1310
mutter('creating repository in %s.', a_bzrdir.transport.base)
1311
dirs = ['revision-store', 'knits']
1312
files = []
1313
utf8_files = [('format', self.get_format_string())]
1314
1315
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1316
repo_transport = a_bzrdir.get_repository_transport(None)
1317
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1318
control_store = self._get_control_store(repo_transport, control_files)
1319
transaction = bzrlib.transactions.WriteTransaction()
1320
# trigger a write of the inventory store.
1321
control_store.get_weave_or_empty('inventory', transaction)
1322
_revision_store = self._get_revision_store(repo_transport, control_files)
1323
_revision_store.has_revision_id('A', transaction)
1324
_revision_store.get_signature_file(transaction)
1325
return self.open(a_bzrdir=a_bzrdir, _found=True)
1326
1327
def open(self, a_bzrdir, _found=False, _override_transport=None):
1328
"""See RepositoryFormat.open().
1329
1330
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1331
repository at a slightly different url
1332
than normal. I.e. during 'upgrade'.
1333
"""
1334
if not _found:
1335
format = RepositoryFormat.find_format(a_bzrdir)
1336
assert format.__class__ == self.__class__
1337
if _override_transport is not None:
1338
repo_transport = _override_transport
1339
else:
1340
repo_transport = a_bzrdir.get_repository_transport(None)
1341
control_files = LockableFiles(repo_transport, 'lock', LockDir)
1342
text_store = self._get_text_store(repo_transport, control_files)
1343
control_store = self._get_control_store(repo_transport, control_files)
1344
_revision_store = self._get_revision_store(repo_transport, control_files)
1345
return KnitRepository(_format=self,
1346
a_bzrdir=a_bzrdir,
1347
control_files=control_files,
1348
_revision_store=_revision_store,
1349
control_store=control_store,
1350
text_store=text_store)
1351
1352
1353
# formats which have no format string are not discoverable
1354
# and not independently creatable, so are not registered.
1355
RepositoryFormat.register_format(RepositoryFormat7())
1356
_default_format = RepositoryFormatKnit1()
1357
RepositoryFormat.register_format(_default_format)
1358
RepositoryFormat.set_default_format(_default_format)
1359
_legacy_formats = [RepositoryFormat4(),
1360
RepositoryFormat5(),
1361
RepositoryFormat6()]
1362
1363
1364
class InterRepository(InterObject):
1365
"""This class represents operations taking place between two repositories.
1366
1367
Its instances have methods like copy_content and fetch, and contain
1368
references to the source and target repositories these operations can be
1369
carried out on.
1370
1371
Often we will provide convenience methods on 'repository' which carry out
1372
operations with another repository - they will always forward to
1373
InterRepository.get(other).method_name(parameters).
1374
"""
1375
1376
_optimisers = set()
1377
"""The available optimised InterRepository types."""
1378
1379
@needs_write_lock
1380
def copy_content(self, revision_id=None, basis=None):
1381
"""Make a complete copy of the content in self into destination.
1382
1383
This is a destructive operation! Do not use it on existing
1384
repositories.
1385
1386
:param revision_id: Only copy the content needed to construct
1387
revision_id and its parents.
1388
:param basis: Copy the needed data preferentially from basis.
1389
"""
1390
try:
1391
self.target.set_make_working_trees(self.source.make_working_trees())
1392
except NotImplementedError:
1393
pass
1394
# grab the basis available data
1395
if basis is not None:
1396
self.target.fetch(basis, revision_id=revision_id)
1397
# but dont bother fetching if we have the needed data now.
1398
if (revision_id not in (None, NULL_REVISION) and
1399
self.target.has_revision(revision_id)):
1400
return
1401
self.target.fetch(self.source, revision_id=revision_id)
1402
1403
def _double_lock(self, lock_source, lock_target):
1404
"""Take out too locks, rolling back the first if the second throws."""
1405
lock_source()
1406
try:
1407
lock_target()
1408
except Exception:
1409
# we want to ensure that we don't leave source locked by mistake.
1410
# and any error on target should not confuse source.
1411
self.source.unlock()
1412
raise
1413
1414
@needs_write_lock
1415
def fetch(self, revision_id=None, pb=None):
1416
"""Fetch the content required to construct revision_id.
1417
1418
The content is copied from source to target.
1419
1420
:param revision_id: if None all content is copied, if NULL_REVISION no
1421
content is copied.
1422
:param pb: optional progress bar to use for progress reports. If not
1423
provided a default one will be created.
1424
1425
Returns the copied revision count and the failed revisions in a tuple:
1426
(copied, failures).
1427
"""
1428
from bzrlib.fetch import GenericRepoFetcher
1429
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1430
self.source, self.source._format, self.target, self.target._format)
1431
f = GenericRepoFetcher(to_repository=self.target,
1432
from_repository=self.source,
1433
last_revision=revision_id,
1434
pb=pb)
1435
return f.count_copied, f.failed_revisions
1436
1437
def lock_read(self):
1438
"""Take out a logical read lock.
1439
1440
This will lock the source branch and the target branch. The source gets
1441
a read lock and the target a read lock.
1442
"""
1443
self._double_lock(self.source.lock_read, self.target.lock_read)
1444
1445
def lock_write(self):
1446
"""Take out a logical write lock.
1447
1448
This will lock the source branch and the target branch. The source gets
1449
a read lock and the target a write lock.
1450
"""
1451
self._double_lock(self.source.lock_read, self.target.lock_write)
1452
1453
@needs_read_lock
1454
def missing_revision_ids(self, revision_id=None):
1455
"""Return the revision ids that source has that target does not.
1456
1457
These are returned in topological order.
1458
1459
:param revision_id: only return revision ids included by this
1460
revision_id.
1461
"""
1462
# generic, possibly worst case, slow code path.
1463
target_ids = set(self.target.all_revision_ids())
1464
if revision_id is not None:
1465
source_ids = self.source.get_ancestry(revision_id)
1466
assert source_ids[0] == None
1467
source_ids.pop(0)
1468
else:
1469
source_ids = self.source.all_revision_ids()
1470
result_set = set(source_ids).difference(target_ids)
1471
# this may look like a no-op: its not. It preserves the ordering
1472
# other_ids had while only returning the members from other_ids
1473
# that we've decided we need.
1474
return [rev_id for rev_id in source_ids if rev_id in result_set]
1475
1476
def unlock(self):
1477
"""Release the locks on source and target."""
1478
try:
1479
self.target.unlock()
1480
finally:
1481
self.source.unlock()
1482
1483
1484
class InterWeaveRepo(InterRepository):
1485
"""Optimised code paths between Weave based repositories."""
1486
1487
_matching_repo_format = RepositoryFormat7()
1488
"""Repository format for testing with."""
1489
1490
@staticmethod
1491
def is_compatible(source, target):
1492
"""Be compatible with known Weave formats.
1493
1494
We dont test for the stores being of specific types becase that
1495
could lead to confusing results, and there is no need to be
1496
overly general.
1497
"""
1498
try:
1499
return (isinstance(source._format, (RepositoryFormat5,
1500
RepositoryFormat6,
1501
RepositoryFormat7)) and
1502
isinstance(target._format, (RepositoryFormat5,
1503
RepositoryFormat6,
1504
RepositoryFormat7)))
1505
except AttributeError:
1506
return False
1507
1508
@needs_write_lock
1509
def copy_content(self, revision_id=None, basis=None):
1510
"""See InterRepository.copy_content()."""
1511
# weave specific optimised path:
1512
if basis is not None:
1513
# copy the basis in, then fetch remaining data.
1514
basis.copy_content_into(self.target, revision_id)
1515
# the basis copy_content_into could misset this.
1516
try:
1517
self.target.set_make_working_trees(self.source.make_working_trees())
1518
except NotImplementedError:
1519
pass
1520
self.target.fetch(self.source, revision_id=revision_id)
1521
else:
1522
try:
1523
self.target.set_make_working_trees(self.source.make_working_trees())
1524
except NotImplementedError:
1525
pass
1526
# FIXME do not peek!
1527
if self.source.control_files._transport.listable():
1528
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1529
try:
1530
self.target.weave_store.copy_all_ids(
1531
self.source.weave_store,
1532
pb=pb,
1533
from_transaction=self.source.get_transaction(),
1534
to_transaction=self.target.get_transaction())
1535
pb.update('copying inventory', 0, 1)
1536
self.target.control_weaves.copy_multi(
1537
self.source.control_weaves, ['inventory'],
1538
from_transaction=self.source.get_transaction(),
1539
to_transaction=self.target.get_transaction())
1540
self.target._revision_store.text_store.copy_all_ids(
1541
self.source._revision_store.text_store,
1542
pb=pb)
1543
finally:
1544
pb.finished()
1545
else:
1546
self.target.fetch(self.source, revision_id=revision_id)
1547
1548
@needs_write_lock
1549
def fetch(self, revision_id=None, pb=None):
1550
"""See InterRepository.fetch()."""
1551
from bzrlib.fetch import GenericRepoFetcher
1552
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1553
self.source, self.source._format, self.target, self.target._format)
1554
f = GenericRepoFetcher(to_repository=self.target,
1555
from_repository=self.source,
1556
last_revision=revision_id,
1557
pb=pb)
1558
return f.count_copied, f.failed_revisions
1559
1560
@needs_read_lock
1561
def missing_revision_ids(self, revision_id=None):
1562
"""See InterRepository.missing_revision_ids()."""
1563
# we want all revisions to satisfy revision_id in source.
1564
# but we dont want to stat every file here and there.
1565
# we want then, all revisions other needs to satisfy revision_id
1566
# checked, but not those that we have locally.
1567
# so the first thing is to get a subset of the revisions to
1568
# satisfy revision_id in source, and then eliminate those that
1569
# we do already have.
1570
# this is slow on high latency connection to self, but as as this
1571
# disk format scales terribly for push anyway due to rewriting
1572
# inventory.weave, this is considered acceptable.
1573
# - RBC 20060209
1574
if revision_id is not None:
1575
source_ids = self.source.get_ancestry(revision_id)
1576
assert source_ids[0] == None
1577
source_ids.pop(0)
1578
else:
1579
source_ids = self.source._all_possible_ids()
1580
source_ids_set = set(source_ids)
1581
# source_ids is the worst possible case we may need to pull.
1582
# now we want to filter source_ids against what we actually
1583
# have in target, but dont try to check for existence where we know
1584
# we do not have a revision as that would be pointless.
1585
target_ids = set(self.target._all_possible_ids())
1586
possibly_present_revisions = target_ids.intersection(source_ids_set)
1587
actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
1588
required_revisions = source_ids_set.difference(actually_present_revisions)
1589
required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
1590
if revision_id is not None:
1591
# we used get_ancestry to determine source_ids then we are assured all
1592
# revisions referenced are present as they are installed in topological order.
1593
# and the tip revision was validated by get_ancestry.
1594
return required_topo_revisions
1595
else:
1596
# if we just grabbed the possibly available ids, then
1597
# we only have an estimate of whats available and need to validate
1598
# that against the revision records.
1599
return self.source._eliminate_revisions_not_present(required_topo_revisions)
1600
1601
1602
class InterKnitRepo(InterRepository):
1603
"""Optimised code paths between Knit based repositories."""
1604
1605
_matching_repo_format = RepositoryFormatKnit1()
1606
"""Repository format for testing with."""
1607
1608
@staticmethod
1609
def is_compatible(source, target):
1610
"""Be compatible with known Knit formats.
1611
1612
We dont test for the stores being of specific types becase that
1613
could lead to confusing results, and there is no need to be
1614
overly general.
1615
"""
1616
try:
1617
return (isinstance(source._format, (RepositoryFormatKnit1)) and
1618
isinstance(target._format, (RepositoryFormatKnit1)))
1619
except AttributeError:
1620
return False
1621
1622
@needs_write_lock
1623
def fetch(self, revision_id=None, pb=None):
1624
"""See InterRepository.fetch()."""
1625
from bzrlib.fetch import KnitRepoFetcher
1626
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1627
self.source, self.source._format, self.target, self.target._format)
1628
f = KnitRepoFetcher(to_repository=self.target,
1629
from_repository=self.source,
1630
last_revision=revision_id,
1631
pb=pb)
1632
return f.count_copied, f.failed_revisions
1633
1634
@needs_read_lock
1635
def missing_revision_ids(self, revision_id=None):
1636
"""See InterRepository.missing_revision_ids()."""
1637
if revision_id is not None:
1638
source_ids = self.source.get_ancestry(revision_id)
1639
assert source_ids[0] == None
1640
source_ids.pop(0)
1641
else:
1642
source_ids = self.source._all_possible_ids()
1643
source_ids_set = set(source_ids)
1644
# source_ids is the worst possible case we may need to pull.
1645
# now we want to filter source_ids against what we actually
1646
# have in target, but dont try to check for existence where we know
1647
# we do not have a revision as that would be pointless.
1648
target_ids = set(self.target._all_possible_ids())
1649
possibly_present_revisions = target_ids.intersection(source_ids_set)
1650
actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
1651
required_revisions = source_ids_set.difference(actually_present_revisions)
1652
required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
1653
if revision_id is not None:
1654
# we used get_ancestry to determine source_ids then we are assured all
1655
# revisions referenced are present as they are installed in topological order.
1656
# and the tip revision was validated by get_ancestry.
1657
return required_topo_revisions
1658
else:
1659
# if we just grabbed the possibly available ids, then
1660
# we only have an estimate of whats available and need to validate
1661
# that against the revision records.
1662
return self.source._eliminate_revisions_not_present(required_topo_revisions)
1663
1664
InterRepository.register_optimiser(InterWeaveRepo)
1665
InterRepository.register_optimiser(InterKnitRepo)
1666
1667
1668
class RepositoryTestProviderAdapter(object):
1669
"""A tool to generate a suite testing multiple repository formats at once.
1670
1671
This is done by copying the test once for each transport and injecting
1672
the transport_server, transport_readonly_server, and bzrdir_format and
1673
repository_format classes into each copy. Each copy is also given a new id()
1674
to make it easy to identify.
1675
"""
1676
1677
def __init__(self, transport_server, transport_readonly_server, formats):
1678
self._transport_server = transport_server
1679
self._transport_readonly_server = transport_readonly_server
1680
self._formats = formats
1681
1682
def adapt(self, test):
1683
result = TestSuite()
1684
for repository_format, bzrdir_format in self._formats:
1685
new_test = deepcopy(test)
1686
new_test.transport_server = self._transport_server
1687
new_test.transport_readonly_server = self._transport_readonly_server
1688
new_test.bzrdir_format = bzrdir_format
1689
new_test.repository_format = repository_format
1690
def make_new_test_id():
1691
new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
1692
return lambda: new_id
1693
new_test.id = make_new_test_id()
1694
result.addTest(new_test)
1695
return result
1696
1697
1698
class InterRepositoryTestProviderAdapter(object):
1699
"""A tool to generate a suite testing multiple inter repository formats.
1700
1701
This is done by copying the test once for each interrepo provider and injecting
1702
the transport_server, transport_readonly_server, repository_format and
1703
repository_to_format classes into each copy.
1704
Each copy is also given a new id() to make it easy to identify.
1705
"""
1706
1707
def __init__(self, transport_server, transport_readonly_server, formats):
1708
self._transport_server = transport_server
1709
self._transport_readonly_server = transport_readonly_server
1710
self._formats = formats
1711
1712
def adapt(self, test):
1713
result = TestSuite()
1714
for interrepo_class, repository_format, repository_format_to in self._formats:
1715
new_test = deepcopy(test)
1716
new_test.transport_server = self._transport_server
1717
new_test.transport_readonly_server = self._transport_readonly_server
1718
new_test.interrepo_class = interrepo_class
1719
new_test.repository_format = repository_format
1720
new_test.repository_format_to = repository_format_to
1721
def make_new_test_id():
1722
new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
1723
return lambda: new_id
1724
new_test.id = make_new_test_id()
1725
result.addTest(new_test)
1726
return result
1727
1728
@staticmethod
1729
def default_test_list():
1730
"""Generate the default list of interrepo permutations to test."""
1731
result = []
1732
# test the default InterRepository between format 6 and the current
1733
# default format.
1734
# XXX: robertc 20060220 reinstate this when there are two supported
1735
# formats which do not have an optimal code path between them.
1736
result.append((InterRepository,
1737
RepositoryFormat6(),
1738
RepositoryFormatKnit1()))
1739
for optimiser in InterRepository._optimisers:
1740
result.append((optimiser,
1741
optimiser._matching_repo_format,
1742
optimiser._matching_repo_format
1743
))
1744
# if there are specific combinations we want to use, we can add them
1745
# here.
1746
return result
1747
1748
1749
class CopyConverter(object):
1750
"""A repository conversion tool which just performs a copy of the content.
1751
1752
This is slow but quite reliable.
1753
"""
1754
1755
def __init__(self, target_format):
1756
"""Create a CopyConverter.
1757
1758
:param target_format: The format the resulting repository should be.
1759
"""
1760
self.target_format = target_format
1761
1762
def convert(self, repo, pb):
1763
"""Perform the conversion of to_convert, giving feedback via pb.
1764
1765
:param to_convert: The disk object to convert.
1766
:param pb: a progress bar to use for progress information.
1767
"""
1768
self.pb = pb
1769
self.count = 0
1770
self.total = 4
1771
# this is only useful with metadir layouts - separated repo content.
1772
# trigger an assertion if not such
1773
repo._format.get_format_string()
1774
self.repo_dir = repo.bzrdir
1775
self.step('Moving repository to repository.backup')
1776
self.repo_dir.transport.move('repository', 'repository.backup')
1777
backup_transport = self.repo_dir.transport.clone('repository.backup')
1778
self.source_repo = repo._format.open(self.repo_dir,
1779
_found=True,
1780
_override_transport=backup_transport)
1781
self.step('Creating new repository')
1782
converted = self.target_format.initialize(self.repo_dir,
1783
self.source_repo.is_shared())
1784
converted.lock_write()
1785
try:
1786
self.step('Copying content into repository.')
1787
self.source_repo.copy_content_into(converted)
1788
finally:
1789
converted.unlock()
1790
self.step('Deleting old repository content.')
1791
self.repo_dir.transport.delete_tree('repository.backup')
1792
self.pb.note('repository converted')
1793
1794
def step(self, message):
1795
"""Update the pb by a step."""
1796
self.count +=1
1797
self.pb.update(message, self.count, self.total)
1798
1799
1800
# Copied from xml.sax.saxutils
1801
def _unescape_xml(data):
1802
"""Unescape &, <, and > in a string of data.
1803
"""
1804
data = data.replace("<", "<")
1805
data = data.replace(">", ">")
1806
# must do ampersand last
1807
return data.replace("&", "&")
Loggerhead is a web-based interface for Breezy
Version: 2.0.1