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

  • Committer: Vincent Ladeuil
  • Date: 2010-12-17 11:35:28 UTC
  • mto: (5575.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 5576.
  • Revision ID: v.ladeuil+lp@free.fr-20101217113528-ixl4lx8pmnaartzt
Get rid of _verbose_warning and rework the messages overall display (revealing some incoherences) and fixing the tests accordingly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/upgrade.py
21
21
    errors,
22
22
    osutils,
23
23
    repository,
 
24
    trace,
24
25
    ui,
25
26
    )
26
27
from bzrlib.bzrdir import BzrDir, format_registry
27
28
from bzrlib.remote import RemoteBzrDir
28
 
from bzrlib.trace import mutter, note, warning
29
29
 
30
30
 
31
31
class Convert(object):
69
69
        try:
70
70
            branch = self.bzrdir.open_branch()
71
71
            if branch.user_url != self.bzrdir.user_url:
72
 
                ui.ui_factory.note("This is a checkout. The branch (%s) needs to be "
73
 
                             "upgraded separately." %
74
 
                             branch.user_url)
 
72
                ui.ui_factory.note(
 
73
                    'This is a checkout. The branch (%s) needs to be upgraded'
 
74
                    ' separately.' % (branch.user_url,))
75
75
            del branch
76
76
        except (errors.NotBranchError, errors.IncompatibleRepositories):
77
77
            # might not be a format we can open without upgrading; see e.g.
101
101
        while self.bzrdir.needs_format_conversion(format):
102
102
            converter = self.bzrdir._format.get_converter(format)
103
103
            self.bzrdir = converter.convert(self.bzrdir, None)
104
 
        ui.ui_factory.note("finished")
 
104
        ui.ui_factory.note('finished')
105
105
 
106
106
    def clean_up(self):
107
107
        """Clean-up after a conversion.
141
141
        attempted_count = len(attempted)
142
142
        succeeded_count = len(succeeded)
143
143
        failed_count = attempted_count - succeeded_count
144
 
        note("\nSUMMARY: %d upgrades attempted, %d succeeded, %d failed",
145
 
            attempted_count, succeeded_count, failed_count)
 
144
        ui.ui_factory.note(
 
145
            '\nSUMMARY: %d upgrades attempted, %d succeeded, %d failed'
 
146
            % (attempted_count, succeeded_count, failed_count))
146
147
    return exceptions
147
148
 
148
149
 
195
196
    # Do the conversions
196
197
    attempted = [control_dir]
197
198
    succeeded, exceptions = _convert_items([control_dir], format, clean_up,
198
 
        dry_run, verbose=dependents)
 
199
                                           dry_run)
199
200
    if succeeded and dependents:
200
 
        note("Found %d dependent branches - upgrading ...", len(dependents))
201
 
 
 
201
        ui.ui_factory.note('Found %d dependent branches - upgrading ...'
 
202
                           % (len(dependents),))
202
203
        # Convert dependent branches
203
204
        branch_cdirs = [b.bzrdir for b in dependents]
204
205
        successes, problems = _convert_items(branch_cdirs, format, clean_up,
211
212
    return attempted, succeeded, exceptions
212
213
 
213
214
 
214
 
def _convert_items(items, format, clean_up, dry_run, label=None,
215
 
    verbose=True):
 
215
def _convert_items(items, format, clean_up, dry_run, label=None):
216
216
    """Convert a sequence of control directories to the given format.
217
217
 
218
218
    :param items: the control directories to upgrade
221
221
      upgrade succeeded for a given repo/branch/tree
222
222
    :param dry_run: show what would happen but don't actually do any upgrades
223
223
    :param label: the label for these items or None to calculate one
224
 
    :param verbose: if True, output a message before starting and
225
 
      display any problems encountered
226
224
    :return: items successfully upgraded, exceptions
227
225
    """
228
226
    succeeded = []
229
227
    exceptions = []
230
228
    child_pb = ui.ui_factory.nested_progress_bar()
231
 
    i = 0
232
 
    child_pb.update('Upgrading bzrdirs', i, len(items))
233
 
    for control_dir in items:
234
 
        i += 1
 
229
    child_pb.update('Upgrading bzrdirs', 0, len(items))
 
230
    for i, control_dir in enumerate(items):
235
231
        # Do the conversion
236
232
        location = control_dir.root_transport.base
237
233
        bzr_object, bzr_label = control_dir._get_object_and_label()
238
234
        type_label = label or bzr_label
239
 
        child_pb.update("Upgrading %s" % (type_label), i, len(items))
240
 
        if verbose:
241
 
            note("Upgrading %s %s ...", type_label, location)
 
235
        child_pb.update("Upgrading %s" % (type_label), i+1, len(items))
 
236
        ui.ui_factory.note('Upgrading %s %s ...' % (type_label, location,))
242
237
        try:
243
238
            if not dry_run:
244
239
                cv = Convert(control_dir=control_dir, format=format)
245
240
        except Exception, ex:
246
 
            _verbose_warning(verbose, "conversion error: %s" % ex)
 
241
            trace.warning('conversion error: %s' % ex)
247
242
            exceptions.append(ex)
248
243
            continue
249
244
 
251
246
        succeeded.append(control_dir)
252
247
        if clean_up:
253
248
            try:
254
 
                note("Removing backup ...")
 
249
                ui.ui_factory.note('Removing backup ...')
255
250
                if not dry_run:
256
251
                    cv.clean_up()
257
252
            except Exception, ex:
258
 
                _verbose_warning(verbose, "failed to clean-up %s: %s" %
259
 
                    (location, ex))
 
253
                trace.warning('failed to clean-up %s: %s' % (location, ex))
260
254
                exceptions.append(ex)
261
255
 
262
256
    child_pb.finished()
263
257
 
264
258
    # Return the result
265
259
    return succeeded, exceptions
266
 
 
267
 
 
268
 
def _verbose_warning(verbose, msg):
269
 
    mutter(msg)
270
 
    if verbose:
271
 
        warning(msg)