/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 brzlib/plugins/weave_fmt/bzrdir.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 12:41:27 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521124127-iv8etg0vwymyai6y
s/bzr/brz/ in apport config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
brzlib/plugins/weave_fmt/bzrdir.py
16
16
 
17
17
"""Weave-era BzrDir formats."""
18
18
 
19
 
from io import BytesIO
 
19
from __future__ import absolute_import
20
20
 
21
 
from ...bzr.bzrdir import (
 
21
from brzlib.bzrdir import (
22
22
    BzrDir,
23
23
    BzrDirFormat,
24
24
    BzrDirMetaFormat1,
25
25
    )
26
 
from ...controldir import (
 
26
from brzlib.controldir import (
27
27
    ControlDir,
28
28
    Converter,
29
 
    MustHaveWorkingTree,
30
29
    format_registry,
31
30
    )
32
 
from ... import (
33
 
    errors,
34
 
    )
35
 
from ...lazy_import import lazy_import
 
31
from brzlib.lazy_import import lazy_import
36
32
lazy_import(globals(), """
37
33
import os
38
34
import warnings
39
35
 
40
 
from breezy import (
41
 
    branch as _mod_branch,,
 
36
from brzlib import (
 
37
    errors,
42
38
    graph,
43
39
    lockable_files,
44
40
    lockdir,
47
43
    trace,
48
44
    ui,
49
45
    urlutils,
50
 
    )
51
 
from breezy.bzr import (
52
46
    versionedfile,
53
47
    weave,
54
48
    xml5,
55
49
    )
56
 
from breezy.i18n import gettext
57
 
from breezy.plugins.weave_fmt.store.versioned import VersionedFileStore
58
 
from breezy.transactions import WriteTransaction
59
 
from breezy.transport import (
 
50
from brzlib.i18n import gettext
 
51
from brzlib.store.versioned import VersionedFileStore
 
52
from brzlib.transactions import WriteTransaction
 
53
from brzlib.transport import (
60
54
    get_transport,
61
55
    local,
62
56
    )
63
 
from breezy.plugins.weave_fmt import xml4
 
57
from brzlib.plugins.weave_fmt import xml4
64
58
""")
65
59
 
66
60
 
70
64
    fixed_components = True
71
65
 
72
66
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
73
 
                                   create_prefix=False, force_new_repo=False, stacked_on=None,
74
 
                                   stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
75
 
                                   shared_repo=False):
 
67
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
68
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
69
        shared_repo=False):
76
70
        """See ControlDir.initialize_on_transport_ex."""
77
71
        require_stacking = (stacked_on is not None)
78
72
        # Format 5 cannot stack, but we've been asked to - actually init
80
74
        if require_stacking:
81
75
            format = BzrDirMetaFormat1()
82
76
            return format.initialize_on_transport_ex(transport,
83
 
                                                     use_existing_dir=use_existing_dir, create_prefix=create_prefix,
84
 
                                                     force_new_repo=force_new_repo, stacked_on=stacked_on,
85
 
                                                     stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
86
 
                                                     make_working_trees=make_working_trees, shared_repo=shared_repo)
 
77
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
78
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
79
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
80
                make_working_trees=make_working_trees, shared_repo=shared_repo)
87
81
        return BzrDirFormat.initialize_on_transport_ex(self, transport,
88
 
                                                       use_existing_dir=use_existing_dir, create_prefix=create_prefix,
89
 
                                                       force_new_repo=force_new_repo, stacked_on=stacked_on,
90
 
                                                       stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
91
 
                                                       make_working_trees=make_working_trees, shared_repo=shared_repo)
 
82
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
83
            force_new_repo=force_new_repo, stacked_on=stacked_on,
 
84
            stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
85
            make_working_trees=make_working_trees, shared_repo=shared_repo)
92
86
 
93
87
    @classmethod
94
88
    def from_string(cls, format_string):
111
105
    _lock_class = lockable_files.TransportLock
112
106
 
113
107
    def __eq__(self, other):
114
 
        return isinstance(self, type(other))
 
108
        return type(self) == type(other)
115
109
 
116
110
    @classmethod
117
111
    def get_format_string(cls):
118
112
        """See BzrDirFormat.get_format_string()."""
119
 
        return b"Bazaar-NG branch, format 5\n"
 
113
        return "Bazaar-NG branch, format 5\n"
120
114
 
121
115
    def get_branch_format(self):
122
 
        from .branch import BzrBranchFormat4
 
116
        from brzlib.plugins.weave_fmt.branch import BzrBranchFormat4
123
117
        return BzrBranchFormat4()
124
118
 
125
119
    def get_format_description(self):
139
133
 
140
134
        Except when they are being cloned.
141
135
        """
142
 
        from .branch import BzrBranchFormat4
143
 
        from .repository import RepositoryFormat5
 
136
        from brzlib.plugins.weave_fmt.branch import BzrBranchFormat4
 
137
        from brzlib.plugins.weave_fmt.repository import RepositoryFormat5
144
138
        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
145
139
        RepositoryFormat5().initialize(result, _internal=True)
146
140
        if not _cloning:
157
151
 
158
152
    def __return_repository_format(self):
159
153
        """Circular import protection."""
160
 
        from .repository import RepositoryFormat5
 
154
        from brzlib.plugins.weave_fmt.repository import RepositoryFormat5
161
155
        return RepositoryFormat5()
162
156
    repository_format = property(__return_repository_format)
163
157
 
175
169
    _lock_class = lockable_files.TransportLock
176
170
 
177
171
    def __eq__(self, other):
178
 
        return isinstance(self, type(other))
 
172
        return type(self) == type(other)
179
173
 
180
174
    @classmethod
181
175
    def get_format_string(cls):
182
176
        """See BzrDirFormat.get_format_string()."""
183
 
        return b"Bazaar-NG branch, format 6\n"
 
177
        return "Bazaar-NG branch, format 6\n"
184
178
 
185
179
    def get_format_description(self):
186
180
        """See ControlDirFormat.get_format_description()."""
187
181
        return "All-in-one format 6"
188
182
 
189
183
    def get_branch_format(self):
190
 
        from .branch import BzrBranchFormat4
 
184
        from brzlib.plugins.weave_fmt.branch import BzrBranchFormat4
191
185
        return BzrBranchFormat4()
192
186
 
193
187
    def get_converter(self, format=None):
203
197
 
204
198
        Except when they are being cloned.
205
199
        """
206
 
        from .branch import BzrBranchFormat4
207
 
        from .repository import RepositoryFormat6
 
200
        from brzlib.plugins.weave_fmt.branch import BzrBranchFormat4
 
201
        from brzlib.plugins.weave_fmt.repository import RepositoryFormat6
208
202
        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
209
203
        RepositoryFormat6().initialize(result, _internal=True)
210
204
        if not _cloning:
221
215
 
222
216
    def __return_repository_format(self):
223
217
        """Circular import protection."""
224
 
        from .repository import RepositoryFormat6
 
218
        from brzlib.plugins.weave_fmt.repository import RepositoryFormat6
225
219
        return RepositoryFormat6()
226
220
    repository_format = property(__return_repository_format)
227
221
 
238
232
 
239
233
    def convert(self, to_convert, pb):
240
234
        """See Converter.convert()."""
241
 
        self.controldir = to_convert
 
235
        self.bzrdir = to_convert
242
236
        if pb is not None:
243
237
            warnings.warn(gettext("pb parameter to convert() is deprecated"))
244
 
        with ui.ui_factory.nested_progress_bar() as self.pb:
 
238
        self.pb = ui.ui_factory.nested_progress_bar()
 
239
        try:
245
240
            ui.ui_factory.note(gettext('starting upgrade from format 4 to 5'))
246
 
            if isinstance(self.controldir.transport, local.LocalTransport):
247
 
                self.controldir.get_workingtree_transport(
248
 
                    None).delete('stat-cache')
 
241
            if isinstance(self.bzrdir.transport, local.LocalTransport):
 
242
                self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
249
243
            self._convert_to_weaves()
250
 
            return ControlDir.open(self.controldir.user_url)
 
244
            return ControlDir.open(self.bzrdir.user_url)
 
245
        finally:
 
246
            self.pb.finished()
251
247
 
252
248
    def _convert_to_weaves(self):
253
249
        ui.ui_factory.note(gettext(
254
 
            'note: upgrade may be faster if all store files are ungzipped first'))
 
250
          'note: upgrade may be faster if all store files are ungzipped first'))
255
251
        try:
256
252
            # TODO permissions
257
 
            stat = self.controldir.transport.stat('weaves')
 
253
            stat = self.bzrdir.transport.stat('weaves')
258
254
            if not S_ISDIR(stat.st_mode):
259
 
                self.controldir.transport.delete('weaves')
260
 
                self.controldir.transport.mkdir('weaves')
 
255
                self.bzrdir.transport.delete('weaves')
 
256
                self.bzrdir.transport.mkdir('weaves')
261
257
        except errors.NoSuchFile:
262
 
            self.controldir.transport.mkdir('weaves')
 
258
            self.bzrdir.transport.mkdir('weaves')
263
259
        # deliberately not a WeaveFile as we want to build it up slowly.
264
260
        self.inv_weave = weave.Weave('inventory')
265
261
        # holds in-memory weaves for all files
266
262
        self.text_weaves = {}
267
 
        self.controldir.transport.delete('branch-format')
268
 
        self.branch = self.controldir.open_branch()
 
263
        self.bzrdir.transport.delete('branch-format')
 
264
        self.branch = self.bzrdir.open_branch()
269
265
        self._convert_working_inv()
270
266
        rev_history = self.branch._revision_history()
271
267
        # to_read is a stack holding the revisions we still need to process;
274
270
        self.to_read = rev_history[-1:]
275
271
        while self.to_read:
276
272
            rev_id = self.to_read.pop()
277
 
            if (rev_id not in self.revisions and
278
 
                    rev_id not in self.absent_revisions):
 
273
            if (rev_id not in self.revisions
 
274
                and rev_id not in self.absent_revisions):
279
275
                self._load_one_rev(rev_id)
280
276
        self.pb.clear()
281
277
        to_import = self._make_order()
287
283
        self._write_all_revs()
288
284
        ui.ui_factory.note(gettext('upgraded to weaves:'))
289
285
        ui.ui_factory.note('  ' + gettext('%6d revisions and inventories') %
290
 
                           len(self.revisions))
 
286
                                                        len(self.revisions))
291
287
        ui.ui_factory.note('  ' + gettext('%6d revisions not present') %
292
 
                           len(self.absent_revisions))
 
288
                                                    len(self.absent_revisions))
293
289
        ui.ui_factory.note('  ' + gettext('%6d texts') % self.text_count)
294
290
        self._cleanup_spare_files_after_format4()
295
291
        self.branch._transport.put_bytes(
296
292
            'branch-format',
297
293
            BzrDirFormat5().get_format_string(),
298
 
            mode=self.controldir._get_file_mode())
 
294
            mode=self.bzrdir._get_file_mode())
299
295
 
300
296
    def _cleanup_spare_files_after_format4(self):
301
297
        # FIXME working tree upgrade foo.
302
298
        for n in 'merged-patches', 'pending-merged-patches':
303
299
            try:
304
300
                ## assert os.path.getsize(p) == 0
305
 
                self.controldir.transport.delete(n)
 
301
                self.bzrdir.transport.delete(n)
306
302
            except errors.NoSuchFile:
307
303
                pass
308
 
        self.controldir.transport.delete_tree('inventory-store')
309
 
        self.controldir.transport.delete_tree('text-store')
 
304
        self.bzrdir.transport.delete_tree('inventory-store')
 
305
        self.bzrdir.transport.delete_tree('text-store')
310
306
 
311
307
    def _convert_working_inv(self):
312
308
        inv = xml4.serializer_v4.read_inventory(
313
 
            self.branch._transport.get('inventory'))
314
 
        f = BytesIO()
315
 
        xml5.serializer_v5.write_inventory(inv, f, working=True)
316
 
        self.branch._transport.put_bytes('inventory', f.getvalue(),
317
 
                                         mode=self.controldir._get_file_mode())
 
309
                self.branch._transport.get('inventory'))
 
310
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
 
311
        self.branch._transport.put_bytes('inventory', new_inv_xml,
 
312
            mode=self.bzrdir._get_file_mode())
318
313
 
319
314
    def _write_all_weaves(self):
320
 
        controlweaves = VersionedFileStore(self.controldir.transport, prefixed=False,
321
 
                                           versionedfile_class=weave.WeaveFile)
322
 
        weave_transport = self.controldir.transport.clone('weaves')
 
315
        controlweaves = VersionedFileStore(self.bzrdir.transport, prefixed=False,
 
316
            versionedfile_class=weave.WeaveFile)
 
317
        weave_transport = self.bzrdir.transport.clone('weaves')
323
318
        weaves = VersionedFileStore(weave_transport, prefixed=False,
324
 
                                    versionedfile_class=weave.WeaveFile)
 
319
                versionedfile_class=weave.WeaveFile)
325
320
        transaction = WriteTransaction()
326
321
 
327
322
        try:
328
323
            i = 0
329
324
            for file_id, file_weave in self.text_weaves.items():
330
325
                self.pb.update(gettext('writing weave'), i,
331
 
                               len(self.text_weaves))
 
326
                                                        len(self.text_weaves))
332
327
                weaves._put_weave(file_id, file_weave, transaction)
333
328
                i += 1
334
329
            self.pb.update(gettext('inventory'), 0, 1)
335
 
            controlweaves._put_weave(b'inventory', self.inv_weave, transaction)
 
330
            controlweaves._put_weave('inventory', self.inv_weave, transaction)
336
331
            self.pb.update(gettext('inventory'), 1, 1)
337
332
        finally:
338
333
            self.pb.clear()
339
334
 
340
335
    def _write_all_revs(self):
341
336
        """Write all revisions out in new form."""
342
 
        self.controldir.transport.delete_tree('revision-store')
343
 
        self.controldir.transport.mkdir('revision-store')
344
 
        revision_transport = self.controldir.transport.clone('revision-store')
 
337
        self.bzrdir.transport.delete_tree('revision-store')
 
338
        self.bzrdir.transport.mkdir('revision-store')
 
339
        revision_transport = self.bzrdir.transport.clone('revision-store')
345
340
        # TODO permissions
346
 
        from ...bzr.xml5 import serializer_v5
347
 
        from .repository import RevisionTextStore
 
341
        from brzlib.xml5 import serializer_v5
 
342
        from brzlib.plugins.weave_fmt.repository import RevisionTextStore
348
343
        revision_store = RevisionTextStore(revision_transport,
349
 
                                           serializer_v5, False, versionedfile.PrefixMapper(),
350
 
                                           lambda: True, lambda: True)
 
344
            serializer_v5, False, versionedfile.PrefixMapper(),
 
345
            lambda:True, lambda:True)
351
346
        try:
352
347
            for i, rev_id in enumerate(self.converted_revs):
353
348
                self.pb.update(gettext('write revision'), i,
354
 
                               len(self.converted_revs))
355
 
                lines = serializer_v5.write_revision_to_lines(
 
349
                                                len(self.converted_revs))
 
350
                text = serializer_v5.write_revision_to_string(
356
351
                    self.revisions[rev_id])
357
352
                key = (rev_id,)
358
 
                revision_store.add_lines(key, None, lines)
 
353
                revision_store.add_lines(key, None, osutils.split_lines(text))
359
354
        finally:
360
355
            self.pb.clear()
361
356
 
370
365
        if not self.branch.repository.has_revision(rev_id):
371
366
            self.pb.clear()
372
367
            ui.ui_factory.note(gettext('revision {%s} not present in branch; '
373
 
                                       'will be converted as a ghost') %
374
 
                               rev_id)
 
368
                         'will be converted as a ghost') %
 
369
                         rev_id)
375
370
            self.absent_revisions.add(rev_id)
376
371
        else:
377
372
            rev = self.branch.repository.get_revision(rev_id)
381
376
            self.revisions[rev_id] = rev
382
377
 
383
378
    def _load_old_inventory(self, rev_id):
384
 
        with self.branch.repository.inventory_store.get(rev_id) as f:
385
 
            inv = xml4.serializer_v4.read_inventory(f)
 
379
        f = self.branch.repository.inventory_store.get(rev_id)
 
380
        try:
 
381
            old_inv_xml = f.read()
 
382
        finally:
 
383
            f.close()
 
384
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
386
385
        inv.revision_id = rev_id
387
386
        rev = self.revisions[rev_id]
388
387
        return inv
389
388
 
390
389
    def _load_updated_inventory(self, rev_id):
391
 
        inv_xml = self.inv_weave.get_lines(rev_id)
392
 
        inv = xml5.serializer_v5.read_inventory_from_lines(inv_xml, rev_id)
 
390
        inv_xml = self.inv_weave.get_text(rev_id)
 
391
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
393
392
        return inv
394
393
 
395
394
    def _convert_one_rev(self, rev_id):
403
402
        self.converted_revs.add(rev_id)
404
403
 
405
404
    def _store_new_inv(self, rev, inv, present_parents):
406
 
        new_inv_xml = xml5.serializer_v5.write_inventory_to_lines(inv)
407
 
        new_inv_sha1 = osutils.sha_strings(new_inv_xml)
 
405
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
 
406
        new_inv_sha1 = osutils.sha_string(new_inv_xml)
408
407
        self.inv_weave.add_lines(rev.revision_id,
409
408
                                 present_parents,
410
 
                                 new_inv_xml)
 
409
                                 new_inv_xml.splitlines(True))
411
410
        rev.inventory_sha1 = new_inv_sha1
412
411
 
413
412
    def _convert_revision_contents(self, rev, inv, present_parents):
416
415
        Also upgrade the inventory to refer to the text revision ids."""
417
416
        rev_id = rev.revision_id
418
417
        trace.mutter('converting texts of revision {%s}', rev_id)
419
 
        parent_invs = list(map(self._load_updated_inventory, present_parents))
 
418
        parent_invs = map(self._load_updated_inventory, present_parents)
420
419
        entries = inv.iter_entries()
421
 
        next(entries)
 
420
        entries.next()
422
421
        for path, ie in entries:
423
422
            self._convert_file_version(rev, ie, parent_invs)
424
423
 
436
435
            self.text_weaves[file_id] = w
437
436
        text_changed = False
438
437
        parent_candiate_entries = ie.parent_candidates(parent_invs)
439
 
        heads = graph.Graph(self).heads(parent_candiate_entries)
 
438
        heads = graph.Graph(self).heads(parent_candiate_entries.keys())
440
439
        # XXX: Note that this is unordered - and this is tolerable because
441
440
        # the previous code was also unordered.
442
 
        previous_entries = {head: parent_candiate_entries[head]
443
 
                            for head in heads}
 
441
        previous_entries = dict((head, parent_candiate_entries[head]) for head
 
442
            in heads)
444
443
        self.snapshot_ie(previous_entries, ie, w, rev_id)
445
444
 
446
445
    def get_parent_map(self, revision_ids):
447
446
        """See graph.StackedParentsProvider.get_parent_map"""
448
447
        return dict((revision_id, self.revisions[revision_id])
449
448
                    for revision_id in revision_ids
450
 
                    if revision_id in self.revisions)
 
449
                     if revision_id in self.revisions)
451
450
 
452
451
    def snapshot_ie(self, previous_revisions, ie, w, rev_id):
453
452
        # TODO: convert this logic, which is ~= snapshot to
458
457
        # save against.
459
458
        #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
460
459
        if len(previous_revisions) == 1:
461
 
            previous_ie = next(iter(previous_revisions.values()))
 
460
            previous_ie = previous_revisions.values()[0]
462
461
            if ie._unchanged(previous_ie):
463
462
                ie.revision = previous_ie.revision
464
463
                return
465
464
        if ie.has_text():
466
 
            with self.branch.repository._text_store.get(ie.text_id) as f:
 
465
            f = self.branch.repository._text_store.get(ie.text_id)
 
466
            try:
467
467
                file_lines = f.readlines()
 
468
            finally:
 
469
                f.close()
468
470
            w.add_lines(rev_id, previous_revisions, file_lines)
469
471
            self.text_count += 1
470
472
        else:
477
479
        The order must be such that an revision is imported after all
478
480
        its (present) parents.
479
481
        """
480
 
        todo = set(self.revisions)
 
482
        todo = set(self.revisions.keys())
481
483
        done = self.absent_revisions.copy()
482
484
        order = []
483
485
        while todo:
499
501
 
500
502
    def convert(self, to_convert, pb):
501
503
        """See Converter.convert()."""
502
 
        self.controldir = to_convert
503
 
        with ui.ui_factory.nested_progress_bar() as pb:
 
504
        self.bzrdir = to_convert
 
505
        pb = ui.ui_factory.nested_progress_bar()
 
506
        try:
504
507
            ui.ui_factory.note(gettext('starting upgrade from format 5 to 6'))
505
508
            self._convert_to_prefixed()
506
 
            return ControlDir.open(self.controldir.user_url)
 
509
            return ControlDir.open(self.bzrdir.user_url)
 
510
        finally:
 
511
            pb.finished()
507
512
 
508
513
    def _convert_to_prefixed(self):
509
 
        from .store import TransportStore
510
 
        self.controldir.transport.delete('branch-format')
 
514
        from brzlib.store import TransportStore
 
515
        self.bzrdir.transport.delete('branch-format')
511
516
        for store_name in ["weaves", "revision-store"]:
512
517
            ui.ui_factory.note(gettext("adding prefixes to %s") % store_name)
513
 
            store_transport = self.controldir.transport.clone(store_name)
 
518
            store_transport = self.bzrdir.transport.clone(store_name)
514
519
            store = TransportStore(store_transport, prefixed=True)
515
520
            for urlfilename in store_transport.list_dir('.'):
516
521
                filename = urlutils.unescape(urlfilename)
517
 
                if (filename.endswith(".weave")
518
 
                    or filename.endswith(".gz")
519
 
                        or filename.endswith(".sig")):
 
522
                if (filename.endswith(".weave") or
 
523
                    filename.endswith(".gz") or
 
524
                    filename.endswith(".sig")):
520
525
                    file_id, suffix = os.path.splitext(filename)
521
526
                else:
522
527
                    file_id = filename
523
528
                    suffix = ''
524
 
                new_name = store._mapper.map(
525
 
                    (file_id.encode('utf-8'),)) + suffix
 
529
                new_name = store._mapper.map((file_id,)) + suffix
526
530
                # FIXME keep track of the dirs made RBC 20060121
527
531
                try:
528
532
                    store_transport.move(filename, new_name)
529
 
                except errors.NoSuchFile:  # catches missing dirs strangely enough
 
533
                except errors.NoSuchFile: # catches missing dirs strangely enough
530
534
                    store_transport.mkdir(osutils.dirname(new_name))
531
535
                    store_transport.move(filename, new_name)
532
 
        self.controldir.transport.put_bytes(
 
536
        self.bzrdir.transport.put_bytes(
533
537
            'branch-format',
534
538
            BzrDirFormat6().get_format_string(),
535
 
            mode=self.controldir._get_file_mode())
 
539
            mode=self.bzrdir._get_file_mode())
536
540
 
537
541
 
538
542
class ConvertBzrDir6ToMeta(Converter):
540
544
 
541
545
    def convert(self, to_convert, pb):
542
546
        """See Converter.convert()."""
543
 
        from .repository import RepositoryFormat7
544
 
        from ...bzr.fullhistory import BzrBranchFormat5
545
 
        self.controldir = to_convert
 
547
        from brzlib.plugins.weave_fmt.repository import RepositoryFormat7
 
548
        from brzlib.branchfmt.fullhistory import BzrBranchFormat5
 
549
        self.bzrdir = to_convert
546
550
        self.pb = ui.ui_factory.nested_progress_bar()
547
551
        self.count = 0
548
 
        self.total = 20  # the steps we know about
 
552
        self.total = 20 # the steps we know about
549
553
        self.garbage_inventories = []
550
 
        self.dir_mode = self.controldir._get_dir_mode()
551
 
        self.file_mode = self.controldir._get_file_mode()
 
554
        self.dir_mode = self.bzrdir._get_dir_mode()
 
555
        self.file_mode = self.bzrdir._get_file_mode()
552
556
 
553
 
        ui.ui_factory.note(
554
 
            gettext('starting upgrade from format 6 to metadir'))
555
 
        self.controldir.transport.put_bytes(
556
 
            'branch-format',
557
 
            b"Converting to format 6",
558
 
            mode=self.file_mode)
 
557
        ui.ui_factory.note(gettext('starting upgrade from format 6 to metadir'))
 
558
        self.bzrdir.transport.put_bytes(
 
559
                'branch-format',
 
560
                "Converting to format 6",
 
561
                mode=self.file_mode)
559
562
        # its faster to move specific files around than to open and use the apis...
560
563
        # first off, nuke ancestry.weave, it was never used.
561
564
        try:
562
565
            self.step(gettext('Removing ancestry.weave'))
563
 
            self.controldir.transport.delete('ancestry.weave')
 
566
            self.bzrdir.transport.delete('ancestry.weave')
564
567
        except errors.NoSuchFile:
565
568
            pass
566
569
        # find out whats there
567
570
        self.step(gettext('Finding branch files'))
568
 
        last_revision = self.controldir.open_branch().last_revision()
569
 
        bzrcontents = self.controldir.transport.list_dir('.')
 
571
        last_revision = self.bzrdir.open_branch().last_revision()
 
572
        bzrcontents = self.bzrdir.transport.list_dir('.')
570
573
        for name in bzrcontents:
571
574
            if name.startswith('basis-inventory.'):
572
575
                self.garbage_inventories.append(name)
575
578
                            ('revision-store', True),
576
579
                            ('weaves', True)]
577
580
        self.step(gettext('Upgrading repository') + '  ')
578
 
        self.controldir.transport.mkdir('repository', mode=self.dir_mode)
 
581
        self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)
579
582
        self.make_lock('repository')
580
583
        # we hard code the formats here because we are converting into
581
584
        # the meta format. The meta format upgrader can take this to a
585
588
            self.move_entry('repository', entry)
586
589
 
587
590
        self.step(gettext('Upgrading branch') + '      ')
588
 
        self.controldir.transport.mkdir('branch', mode=self.dir_mode)
 
591
        self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
589
592
        self.make_lock('branch')
590
593
        self.put_format('branch', BzrBranchFormat5())
591
594
        branch_files = [('revision-history', True),
611
614
            # If some checkout files are there, we may as well get rid of them.
612
615
            for name, mandatory in checkout_files:
613
616
                if name in bzrcontents:
614
 
                    self.controldir.transport.delete(name)
 
617
                    self.bzrdir.transport.delete(name)
615
618
        else:
616
 
            from ...bzr.workingtree_3 import WorkingTreeFormat3
 
619
            from brzlib.workingtree_3 import WorkingTreeFormat3
617
620
            self.step(gettext('Upgrading working tree'))
618
 
            self.controldir.transport.mkdir('checkout', mode=self.dir_mode)
 
621
            self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
619
622
            self.make_lock('checkout')
620
 
            self.put_format('checkout', WorkingTreeFormat3())
621
 
            for path in self.garbage_inventories:
622
 
                self.controldir.transport.delete(path)
 
623
            self.put_format(
 
624
                'checkout', WorkingTreeFormat3())
 
625
            self.bzrdir.transport.delete_multi(
 
626
                self.garbage_inventories, self.pb)
623
627
            for entry in checkout_files:
624
628
                self.move_entry('checkout', entry)
625
629
            if last_revision is not None:
626
 
                self.controldir.transport.put_bytes(
 
630
                self.bzrdir.transport.put_bytes(
627
631
                    'checkout/last-revision', last_revision)
628
 
        self.controldir.transport.put_bytes(
 
632
        self.bzrdir.transport.put_bytes(
629
633
            'branch-format',
630
634
            BzrDirMetaFormat1().get_format_string(),
631
635
            mode=self.file_mode)
632
636
        self.pb.finished()
633
 
        return ControlDir.open(self.controldir.user_url)
 
637
        return ControlDir.open(self.bzrdir.user_url)
634
638
 
635
639
    def make_lock(self, name):
636
640
        """Make a lock for the new control dir name."""
637
641
        self.step(gettext('Make %s lock') % name)
638
 
        ld = lockdir.LockDir(self.controldir.transport,
 
642
        ld = lockdir.LockDir(self.bzrdir.transport,
639
643
                             '%s/lock' % name,
640
644
                             file_modebits=self.file_mode,
641
645
                             dir_modebits=self.dir_mode)
647
651
        mandatory = entry[1]
648
652
        self.step(gettext('Moving %s') % name)
649
653
        try:
650
 
            self.controldir.transport.move(name, '%s/%s' % (new_dir, name))
 
654
            self.bzrdir.transport.move(name, '%s/%s' % (new_dir, name))
651
655
        except errors.NoSuchFile:
652
656
            if mandatory:
653
657
                raise
654
658
 
655
659
    def put_format(self, dirname, format):
656
 
        self.controldir.transport.put_bytes('%s/format' % dirname,
657
 
                                            format.get_format_string(),
658
 
                                            self.file_mode)
 
660
        self.bzrdir.transport.put_bytes('%s/format' % dirname,
 
661
            format.get_format_string(),
 
662
            self.file_mode)
659
663
 
660
664
 
661
665
class BzrDirFormat4(BzrDirFormat):
674
678
    _lock_class = lockable_files.TransportLock
675
679
 
676
680
    def __eq__(self, other):
677
 
        return isinstance(self, type(other))
 
681
        return type(self) == type(other)
678
682
 
679
683
    @classmethod
680
684
    def get_format_string(cls):
681
685
        """See BzrDirFormat.get_format_string()."""
682
 
        return b"Bazaar-NG branch, format 0.0.4\n"
 
686
        return "Bazaar-NG branch, format 0.0.4\n"
683
687
 
684
688
    def get_format_description(self):
685
689
        """See ControlDirFormat.get_format_description()."""
712
716
 
713
717
    def __return_repository_format(self):
714
718
        """Circular import protection."""
715
 
        from .repository import RepositoryFormat4
 
719
        from brzlib.plugins.weave_fmt.repository import RepositoryFormat4
716
720
        return RepositoryFormat4()
717
721
    repository_format = property(__return_repository_format)
718
722
 
730
734
        """See ControlDir.__init__."""
731
735
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
732
736
        self._control_files = lockable_files.LockableFiles(
733
 
            self.get_branch_transport(None),
734
 
            self._format._lock_file_name,
735
 
            self._format._lock_class)
 
737
                                            self.get_branch_transport(None),
 
738
                                            self._format._lock_file_name,
 
739
                                            self._format._lock_class)
736
740
 
737
741
    def break_lock(self):
738
742
        """Pre-splitout bzrdirs do not suffer from stale locks."""
741
745
    def cloning_metadir(self, require_stacking=False):
742
746
        """Produce a metadir suitable for cloning with."""
743
747
        if require_stacking:
744
 
            return format_registry.make_controldir('1.6')
 
748
            return format_registry.make_bzrdir('1.6')
745
749
        return self._format.__class__()
746
750
 
747
751
    def clone(self, url, revision_id=None, force_new_repo=False,
774
778
            raise NotImplementedError(
775
779
                "create_branch(repository=<not None>) on %r" % (self,))
776
780
        return self._format.get_branch_format().initialize(self, name=name,
777
 
                                                           append_revisions_only=append_revisions_only)
 
781
            append_revisions_only=append_revisions_only)
778
782
 
779
783
    def destroy_branch(self, name=None):
780
784
        """See ControlDir.destroy_branch."""
807
811
        # done on this format anyway. So - acceptable wart.
808
812
        if hardlink:
809
813
            warning("can't support hardlinked working trees in %r"
810
 
                    % (self,))
 
814
                % (self,))
811
815
        try:
812
816
            result = self.open_workingtree(recommend_upgrade=False)
813
817
        except errors.NoSuchFile:
820
824
        return result
821
825
 
822
826
    def _init_workingtree(self):
823
 
        from .workingtree import WorkingTreeFormat2
 
827
        from brzlib.plugins.weave_fmt.workingtree import WorkingTreeFormat2
824
828
        try:
825
829
            return WorkingTreeFormat2().initialize(self)
826
830
        except errors.NotLocalUrl:
870
874
            return self.transport
871
875
        raise errors.IncompatibleFormat(workingtree_format, self._format)
872
876
 
873
 
    def needs_format_conversion(self, format):
 
877
    def needs_format_conversion(self, format=None):
874
878
        """See ControlDir.needs_format_conversion()."""
875
879
        # if the format is not the same as the system default,
876
880
        # an upgrade is needed.
 
881
        if format is None:
 
882
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
883
                % 'needs_format_conversion(format=None)')
 
884
            format = BzrDirFormat.get_default_format()
877
885
        return not isinstance(self._format, format.__class__)
878
886
 
879
887
    def open_branch(self, name=None, unsupported=False,
880
888
                    ignore_fallbacks=False, possible_transports=None):
881
889
        """See ControlDir.open_branch."""
882
 
        from .branch import BzrBranchFormat4
 
890
        from brzlib.plugins.weave_fmt.branch import BzrBranchFormat4
883
891
        format = BzrBranchFormat4()
884
892
        format.check_support_status(unsupported)
885
893
        return format.open(self, name, _found=True,
886
 
                           possible_transports=possible_transports)
 
894
            possible_transports=possible_transports)
887
895
 
888
896
    def sprout(self, url, revision_id=None, force_new_repo=False,
889
 
               recurse=None, possible_transports=None, accelerator_tree=None,
 
897
               possible_transports=None, accelerator_tree=None,
890
898
               hardlink=False, stacked=False, create_tree_if_local=True,
891
899
               source_branch=None):
892
900
        """See ControlDir.sprout()."""
897
905
                    "source branch %r is not within %r with branch %r" %
898
906
                    (source_branch, self, my_branch))
899
907
        if stacked:
900
 
            raise _mod_branch.UnstackableBranchFormat(
 
908
            raise errors.UnstackableBranchFormat(
901
909
                self._format, self.root_transport.base)
902
910
        if not create_tree_if_local:
903
 
            raise MustHaveWorkingTree(
 
911
            raise errors.MustHaveWorkingTree(
904
912
                self._format, self.root_transport.base)
905
 
        from .workingtree import WorkingTreeFormat2
 
913
        from brzlib.plugins.weave_fmt.workingtree import WorkingTreeFormat2
906
914
        self._make_tail(url)
907
915
        result = self._format._initialize_for_clone(url)
908
916
        try:
921
929
        return result
922
930
 
923
931
    def set_branch_reference(self, target_branch, name=None):
924
 
        from ...bzr.branch import BranchReferenceFormat
 
932
        from brzlib.branch import BranchReferenceFormat
925
933
        if name is not None:
926
934
            raise errors.NoColocatedBranchSupport(self)
927
935
        raise errors.IncompatibleFormat(BranchReferenceFormat, self._format)
937
945
        """See ControlDir.create_repository."""
938
946
        return self._format.repository_format.initialize(self, shared)
939
947
 
940
 
    def needs_format_conversion(self, format):
 
948
    def needs_format_conversion(self, format=None):
941
949
        """Format 4 dirs are always in need of conversion."""
 
950
        if format is None:
 
951
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
952
                % 'needs_format_conversion(format=None)')
942
953
        return True
943
954
 
944
955
    def open_repository(self):
945
956
        """See ControlDir.open_repository."""
946
 
        from .repository import RepositoryFormat4
 
957
        from brzlib.plugins.weave_fmt.repository import RepositoryFormat4
947
958
        return RepositoryFormat4().open(self, _found=True)
948
959
 
949
960
 
956
967
    def has_workingtree(self):
957
968
        """See ControlDir.has_workingtree."""
958
969
        return True
959
 
 
 
970
    
960
971
    def open_repository(self):
961
972
        """See ControlDir.open_repository."""
962
 
        from .repository import RepositoryFormat5
 
973
        from brzlib.plugins.weave_fmt.repository import RepositoryFormat5
963
974
        return RepositoryFormat5().open(self, _found=True)
964
975
 
965
976
    def open_workingtree(self, unsupported=False,
966
 
                         recommend_upgrade=True):
 
977
            recommend_upgrade=True):
967
978
        """See ControlDir.create_workingtree."""
968
 
        from .workingtree import WorkingTreeFormat2
 
979
        from brzlib.plugins.weave_fmt.workingtree import WorkingTreeFormat2
969
980
        wt_format = WorkingTreeFormat2()
970
981
        # we don't warn here about upgrades; that ought to be handled for the
971
982
        # bzrdir as a whole
984
995
 
985
996
    def open_repository(self):
986
997
        """See ControlDir.open_repository."""
987
 
        from .repository import RepositoryFormat6
 
998
        from brzlib.plugins.weave_fmt.repository import RepositoryFormat6
988
999
        return RepositoryFormat6().open(self, _found=True)
989
1000
 
990
1001
    def open_workingtree(self, unsupported=False, recommend_upgrade=True):
991
1002
        """See ControlDir.create_workingtree."""
992
1003
        # we don't warn here about upgrades; that ought to be handled for the
993
1004
        # bzrdir as a whole
994
 
        from .workingtree import WorkingTreeFormat2
 
1005
        from brzlib.plugins.weave_fmt.workingtree import WorkingTreeFormat2
995
1006
        return WorkingTreeFormat2().open(self, _found=True)