/brz/remove-bazaar

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

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-03-08 00:37:41 UTC
  • mfrom: (1594.2.4 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060308003741-08afccbf89005e87
Merge in :
 * Knit repositories use knits
 * Nested progress bar support.
 * Ghost aware graph api.

Show diffs side-by-side

added added

removed removed

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