/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 breezy/upgrade.py

  • Committer: Jelmer Vernooij
  • Date: 2018-02-18 21:42:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6859.
  • Revision ID: jelmer@jelmer.uk-20180218214257-jpevutp1wa30tz3v
Update TODO to reference Breezy, not Bazaar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/upgrade.py
16
16
 
17
17
"""brz upgrade logic."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
from . import (
20
22
    errors,
21
23
    trace,
84
86
            try:
85
87
                rich_root = self.controldir.find_repository()._format.rich_root_data
86
88
            except errors.NoRepositoryPresent:
87
 
                rich_root = False  # assume no rich roots
 
89
                rich_root = False # assume no rich roots
88
90
            if rich_root:
89
91
                format_name = "default-rich-root"
90
92
            else:
96
98
            raise errors.UpToDateFormat(self.controldir._format)
97
99
        if not self.controldir.can_convert_format():
98
100
            raise errors.BzrError(gettext("cannot upgrade from bzrdir format %s") %
99
 
                                  self.controldir._format)
 
101
                           self.controldir._format)
100
102
        self.controldir.check_conversion_target(format)
101
 
        ui.ui_factory.note(gettext('starting upgrade of %s') %
102
 
                           urlutils.unescape_for_display(self.transport.base, 'utf-8'))
 
103
        ui.ui_factory.note(gettext('starting upgrade of %s') % 
 
104
            urlutils.unescape_for_display(self.transport.base, 'utf-8'))
103
105
 
104
106
        self.backup_oldpath, self.backup_newpath = self.controldir.backup_bzrdir()
105
107
        while self.controldir.needs_format_conversion(format):
114
116
        """
115
117
        transport = self.transport
116
118
        backup_relpath = transport.relpath(self.backup_newpath)
117
 
        with ui.ui_factory.nested_progress_bar() as child_pb:
118
 
            child_pb.update(gettext('Deleting backup.bzr'))
 
119
        child_pb = ui.ui_factory.nested_progress_bar()
 
120
        child_pb.update(gettext('Deleting backup.bzr'))
 
121
        try:
119
122
            transport.delete_tree(backup_relpath)
 
123
        finally:
 
124
            child_pb.finished()
120
125
 
121
126
 
122
127
def upgrade(url, format=None, clean_up=False, dry_run=False):
123
128
    """Upgrade locations to format.
124
 
 
 
129
 
125
130
    This routine wraps the smart_upgrade() routine with a nicer UI.
126
131
    In particular, it ensures all URLs can be opened before starting
127
132
    and reports a summary at the end if more than one upgrade was attempted.
137
142
    """
138
143
    control_dirs = [ControlDir.open_unsupported(url)]
139
144
    attempted, succeeded, exceptions = smart_upgrade(control_dirs,
140
 
                                                     format, clean_up=clean_up, dry_run=dry_run)
 
145
        format, clean_up=clean_up, dry_run=dry_run)
141
146
    if len(attempted) > 1:
142
147
        attempted_count = len(attempted)
143
148
        succeeded_count = len(succeeded)
144
149
        failed_count = attempted_count - succeeded_count
145
150
        ui.ui_factory.note(
146
 
            gettext('\nSUMMARY: {0} upgrades attempted, {1} succeeded,'
 
151
            gettext('\nSUMMARY: {0} upgrades attempted, {1} succeeded,'\
147
152
                    ' {2} failed').format(
148
 
                attempted_count, succeeded_count, failed_count))
 
153
                     attempted_count, succeeded_count, failed_count))
149
154
    return exceptions
150
155
 
151
156
 
152
157
def smart_upgrade(control_dirs, format, clean_up=False,
153
 
                  dry_run=False):
 
158
    dry_run=False):
154
159
    """Convert control directories to a new format intelligently.
155
160
 
156
161
    If the control directory is a shared repository, dependent branches
169
174
    all_exceptions = []
170
175
    for control_dir in control_dirs:
171
176
        attempted, succeeded, exceptions = _smart_upgrade_one(control_dir,
172
 
                                                              format, clean_up=clean_up, dry_run=dry_run)
 
177
            format, clean_up=clean_up, dry_run=dry_run)
173
178
        all_attempted.extend(attempted)
174
179
        all_succeeded.extend(succeeded)
175
180
        all_exceptions.extend(exceptions)
177
182
 
178
183
 
179
184
def _smart_upgrade_one(control_dir, format, clean_up=False,
180
 
                       dry_run=False):
 
185
    dry_run=False):
181
186
    """Convert a control directory to a new format intelligently.
182
187
 
183
188
    See smart_upgrade for parameter details.
193
198
        # The URL is a repository. If it successfully upgrades,
194
199
        # then upgrade the dependent branches as well.
195
200
        if repo.is_shared():
196
 
            dependents = list(repo.find_branches(using=True))
 
201
            dependents = repo.find_branches(using=True)
197
202
 
198
203
    # Do the conversions
199
204
    attempted = [control_dir]
205
210
        # Convert dependent branches
206
211
        branch_cdirs = [b.controldir for b in dependents]
207
212
        successes, problems = _convert_items(branch_cdirs, format, clean_up,
208
 
                                             dry_run, label="branch")
 
213
            dry_run, label="branch")
209
214
        attempted.extend(branch_cdirs)
210
215
        succeeded.extend(successes)
211
216
        exceptions.extend(problems)
218
223
# - raising AssertionError is rude and may not be necessary
219
224
# - no tests
220
225
# - the only caller uses only the label
221
 
 
222
 
 
223
226
def _get_object_and_label(control_dir):
224
227
    """Return the primary object and type label for a control directory.
225
228
 
258
261
 
259
262
def _convert_items(items, format, clean_up, dry_run, label=None):
260
263
    """Convert a sequence of control directories to the given format.
261
 
 
 
264
 
262
265
    :param items: the control directories to upgrade
263
266
    :param format: the format to convert to or None for the best default
264
267
    :param clean-up: if True, the backup.bzr directory is removed if the
269
272
    """
270
273
    succeeded = []
271
274
    exceptions = []
272
 
    with ui.ui_factory.nested_progress_bar() as child_pb:
273
 
        child_pb.update(gettext('Upgrading bzrdirs'), 0, len(items))
274
 
        for i, control_dir in enumerate(items):
275
 
            # Do the conversion
276
 
            location = control_dir.root_transport.base
277
 
            bzr_object, bzr_label = _get_object_and_label(control_dir)
278
 
            type_label = label or bzr_label
279
 
            child_pb.update(gettext("Upgrading %s") %
280
 
                            (type_label), i + 1, len(items))
281
 
            ui.ui_factory.note(gettext('Upgrading {0} {1} ...').format(type_label,
282
 
                                                                       urlutils.unescape_for_display(location, 'utf-8'),))
 
275
    child_pb = ui.ui_factory.nested_progress_bar()
 
276
    child_pb.update(gettext('Upgrading bzrdirs'), 0, len(items))
 
277
    for i, control_dir in enumerate(items):
 
278
        # Do the conversion
 
279
        location = control_dir.root_transport.base
 
280
        bzr_object, bzr_label = _get_object_and_label(control_dir)
 
281
        type_label = label or bzr_label
 
282
        child_pb.update(gettext("Upgrading %s") % (type_label), i+1, len(items))
 
283
        ui.ui_factory.note(gettext('Upgrading {0} {1} ...').format(type_label, 
 
284
            urlutils.unescape_for_display(location, 'utf-8'),))
 
285
        try:
 
286
            if not dry_run:
 
287
                cv = Convert(control_dir=control_dir, format=format)
 
288
        except errors.UpToDateFormat as ex:
 
289
            ui.ui_factory.note(str(ex))
 
290
            succeeded.append(control_dir)
 
291
            continue
 
292
        except Exception as ex:
 
293
            trace.warning('conversion error: %s' % ex)
 
294
            exceptions.append(ex)
 
295
            continue
 
296
 
 
297
        # Do any required post processing
 
298
        succeeded.append(control_dir)
 
299
        if clean_up:
283
300
            try:
 
301
                ui.ui_factory.note(gettext('Removing backup ...'))
284
302
                if not dry_run:
285
 
                    cv = Convert(control_dir=control_dir, format=format)
286
 
            except errors.UpToDateFormat as ex:
287
 
                ui.ui_factory.note(str(ex))
288
 
                succeeded.append(control_dir)
289
 
                continue
 
303
                    cv.clean_up()
290
304
            except Exception as ex:
291
 
                trace.warning('conversion error: %s' % ex)
 
305
                trace.warning(gettext('failed to clean-up {0}: {1}') % (location, ex))
292
306
                exceptions.append(ex)
293
 
                continue
294
307
 
295
 
            # Do any required post processing
296
 
            succeeded.append(control_dir)
297
 
            if clean_up:
298
 
                try:
299
 
                    ui.ui_factory.note(gettext('Removing backup ...'))
300
 
                    if not dry_run:
301
 
                        cv.clean_up()
302
 
                except Exception as ex:
303
 
                    trace.warning(
304
 
                        gettext('failed to clean-up {0}: {1}') % (location, ex))
305
 
                    exceptions.append(ex)
 
308
    child_pb.finished()
306
309
 
307
310
    # Return the result
308
311
    return succeeded, exceptions