← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Patch Queue Manager
  • Date: 2011-09-22 14:12:18 UTC
  • mfrom: (6155.3.1 jam)
  • Revision ID: pqm@pqm.ubuntu.com-20110922141218-86s4uu6nqvourw4f
(jameinel) Cleanup comments bzrlib/smart/__init__.py (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Exceptions for bzr, and reporting of them.
18
18
"""
19
19
 
20
 
 
21
20
from bzrlib import (
22
21
    osutils,
23
22
    symbol_versioning,
 
23
    i18n,
 
24
    trace,
24
25
    )
 
26
from bzrlib.i18n import gettext
25
27
from bzrlib.patches import (
26
28
    MalformedHunkHeader,
27
29
    MalformedLine,
32
34
 
33
35
 
34
36
# TODO: is there any value in providing the .args field used by standard
35
 
# python exceptions?   A list of values with no names seems less useful 
 
37
# python exceptions?   A list of values with no names seems less useful
36
38
# to me.
37
39
 
38
 
# TODO: Perhaps convert the exception to a string at the moment it's 
 
40
# TODO: Perhaps convert the exception to a string at the moment it's
39
41
# constructed to make sure it will succeed.  But that says nothing about
40
42
# exceptions that are never raised.
41
43
 
44
46
# 'unprintable'.
45
47
 
46
48
 
 
49
# return codes from the bzr program
 
50
EXIT_OK = 0
 
51
EXIT_ERROR = 3
 
52
EXIT_INTERNAL_ERROR = 4
 
53
 
 
54
 
47
55
class BzrError(StandardError):
48
56
    """
49
57
    Base class for errors raised by bzrlib.
50
58
 
51
 
    :cvar internal_error: if true (or absent) this was probably caused by a
52
 
    bzr bug and should be displayed with a traceback; if False this was
53
 
    probably a user or environment error and they don't need the gory details.
54
 
    (That can be overridden by -Derror on the command line.)
 
59
    :cvar internal_error: if True this was probably caused by a bzr bug and
 
60
        should be displayed with a traceback; if False (or absent) this was
 
61
        probably a user or environment error and they don't need the gory
 
62
        details.  (That can be overridden by -Derror on the command line.)
55
63
 
56
64
    :cvar _fmt: Format string to display the error; this is expanded
57
 
    by the instance's dict.
 
65
        by the instance's dict.
58
66
    """
59
 
    
 
67
 
60
68
    internal_error = False
61
69
 
62
70
    def __init__(self, msg=None, **kwds):
67
75
        arguments can be given.  The first is for generic "user" errors which
68
76
        are not intended to be caught and so do not need a specific subclass.
69
77
        The second case is for use with subclasses that provide a _fmt format
70
 
        string to print the arguments.  
 
78
        string to print the arguments.
71
79
 
72
 
        Keyword arguments are taken as parameters to the error, which can 
73
 
        be inserted into the format string template.  It's recommended 
74
 
        that subclasses override the __init__ method to require specific 
 
80
        Keyword arguments are taken as parameters to the error, which can
 
81
        be inserted into the format string template.  It's recommended
 
82
        that subclasses override the __init__ method to require specific
75
83
        parameters.
76
84
 
77
85
        :param msg: If given, this is the literal complete text for the error,
78
 
        not subject to expansion.
 
86
           not subject to expansion. 'msg' is used instead of 'message' because
 
87
           python evolved and, in 2.6, forbids the use of 'message'.
79
88
        """
80
89
        StandardError.__init__(self)
81
90
        if msg is not None:
87
96
            for key, value in kwds.items():
88
97
                setattr(self, key, value)
89
98
 
90
 
    def __str__(self):
 
99
    def _format(self):
91
100
        s = getattr(self, '_preformatted_string', None)
92
101
        if s is not None:
93
 
            # contains a preformatted message; must be cast to plain str
94
 
            return str(s)
 
102
            # contains a preformatted message
 
103
            return s
95
104
        try:
96
105
            fmt = self._get_format_string()
97
106
            if fmt:
98
 
                s = fmt % self.__dict__
 
107
                d = dict(self.__dict__)
 
108
                s = fmt % d
99
109
                # __str__() should always return a 'str' object
100
110
                # never a 'unicode' object.
101
 
                if isinstance(s, unicode):
102
 
                    return s.encode('utf8')
103
111
                return s
104
112
        except (AttributeError, TypeError, NameError, ValueError, KeyError), e:
105
 
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%s' \
 
113
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
106
114
                % (self.__class__.__name__,
107
115
                   self.__dict__,
108
116
                   getattr(self, '_fmt', None),
109
 
                   str(e))
 
117
                   e)
 
118
 
 
119
    def __unicode__(self):
 
120
        u = self._format()
 
121
        if isinstance(u, str):
 
122
            # Try decoding the str using the default encoding.
 
123
            u = unicode(u)
 
124
        elif not isinstance(u, unicode):
 
125
            # Try to make a unicode object from it, because __unicode__ must
 
126
            # return a unicode object.
 
127
            u = unicode(u)
 
128
        return u
 
129
 
 
130
    def __str__(self):
 
131
        s = self._format()
 
132
        if isinstance(s, unicode):
 
133
            s = s.encode('utf8')
 
134
        else:
 
135
            # __str__ must return a str.
 
136
            s = str(s)
 
137
        return s
 
138
 
 
139
    def __repr__(self):
 
140
        return '%s(%s)' % (self.__class__.__name__, str(self))
110
141
 
111
142
    def _get_format_string(self):
112
143
        """Return format string for this exception or None"""
113
144
        fmt = getattr(self, '_fmt', None)
114
145
        if fmt is not None:
115
 
            return fmt
 
146
            i18n.install()
 
147
            unicode_fmt = unicode(fmt) #_fmt strings should be ascii
 
148
            if type(fmt) == unicode:
 
149
                trace.mutter("Unicode strings in error.fmt are deprecated")
 
150
            return gettext(unicode_fmt)
116
151
        fmt = getattr(self, '__doc__', None)
117
152
        if fmt is not None:
118
153
            symbol_versioning.warn("%s uses its docstring as a format, "
125
160
               getattr(self, '_fmt', None),
126
161
               )
127
162
 
 
163
    def __eq__(self, other):
 
164
        if self.__class__ is not other.__class__:
 
165
            return NotImplemented
 
166
        return self.__dict__ == other.__dict__
 
167
 
 
168
 
 
169
class InternalBzrError(BzrError):
 
170
    """Base class for errors that are internal in nature.
 
171
 
 
172
    This is a convenience class for errors that are internal. The
 
173
    internal_error attribute can still be altered in subclasses, if needed.
 
174
    Using this class is simply an easy way to get internal errors.
 
175
    """
 
176
 
 
177
    internal_error = True
 
178
 
128
179
 
129
180
class BzrNewError(BzrError):
130
181
    """Deprecated error base class."""
154
205
                return s.encode('utf8')
155
206
            return s
156
207
        except (TypeError, NameError, ValueError, KeyError), e:
157
 
            return 'Unprintable exception %s(%r): %s' \
 
208
            return 'Unprintable exception %s(%r): %r' \
158
209
                % (self.__class__.__name__,
159
 
                   self.__dict__, str(e))
 
210
                   self.__dict__, e)
160
211
 
161
212
 
162
213
class AlreadyBuilding(BzrError):
163
 
    
 
214
 
164
215
    _fmt = "The tree builder is already building a tree."
165
216
 
166
217
 
167
 
class BzrCheckError(BzrError):
168
 
    
169
 
    _fmt = "Internal check failed: %(message)s"
170
 
 
171
 
    internal_error = True
172
 
 
173
 
    def __init__(self, message):
174
 
        BzrError.__init__(self)
175
 
        self.message = message
176
 
 
177
 
 
178
 
class InvalidEntryName(BzrError):
179
 
    
 
218
class BranchError(BzrError):
 
219
    """Base class for concrete 'errors about a branch'."""
 
220
 
 
221
    def __init__(self, branch):
 
222
        BzrError.__init__(self, branch=branch)
 
223
 
 
224
 
 
225
class BzrCheckError(InternalBzrError):
 
226
 
 
227
    _fmt = "Internal check failed: %(msg)s"
 
228
 
 
229
    def __init__(self, msg):
 
230
        BzrError.__init__(self)
 
231
        self.msg = msg
 
232
 
 
233
 
 
234
class DirstateCorrupt(BzrError):
 
235
 
 
236
    _fmt = "The dirstate file (%(state)s) appears to be corrupt: %(msg)s"
 
237
 
 
238
    def __init__(self, state, msg):
 
239
        BzrError.__init__(self)
 
240
        self.state = state
 
241
        self.msg = msg
 
242
 
 
243
 
 
244
class DisabledMethod(InternalBzrError):
 
245
 
 
246
    _fmt = "The smart server method '%(class_name)s' is disabled."
 
247
 
 
248
    def __init__(self, class_name):
 
249
        BzrError.__init__(self)
 
250
        self.class_name = class_name
 
251
 
 
252
 
 
253
class IncompatibleAPI(BzrError):
 
254
 
 
255
    _fmt = 'The API for "%(api)s" is not compatible with "%(wanted)s". '\
 
256
        'It supports versions "%(minimum)s" to "%(current)s".'
 
257
 
 
258
    def __init__(self, api, wanted, minimum, current):
 
259
        self.api = api
 
260
        self.wanted = wanted
 
261
        self.minimum = minimum
 
262
        self.current = current
 
263
 
 
264
 
 
265
class InProcessTransport(BzrError):
 
266
 
 
267
    _fmt = "The transport '%(transport)s' is only accessible within this " \
 
268
        "process."
 
269
 
 
270
    def __init__(self, transport):
 
271
        self.transport = transport
 
272
 
 
273
 
 
274
class InvalidEntryName(InternalBzrError):
 
275
 
180
276
    _fmt = "Invalid entry name: %(name)s"
181
277
 
182
 
    internal_error = True
183
 
 
184
278
    def __init__(self, name):
185
279
        BzrError.__init__(self)
186
280
        self.name = name
187
281
 
188
282
 
189
283
class InvalidRevisionNumber(BzrError):
190
 
    
 
284
 
191
285
    _fmt = "Invalid revision number %(revno)s"
192
286
 
193
287
    def __init__(self, revno):
205
299
        self.revision_id = revision_id
206
300
        self.branch = branch
207
301
 
 
302
 
208
303
class ReservedId(BzrError):
209
304
 
210
305
    _fmt = "Reserved revision-id {%(revision_id)s}"
212
307
    def __init__(self, revision_id):
213
308
        self.revision_id = revision_id
214
309
 
 
310
 
 
311
class RootMissing(InternalBzrError):
 
312
 
 
313
    _fmt = ("The root entry of a tree must be the first entry supplied to "
 
314
        "the commit builder.")
 
315
 
 
316
 
 
317
class NoPublicBranch(BzrError):
 
318
 
 
319
    _fmt = 'There is no public branch set for "%(branch_url)s".'
 
320
 
 
321
    def __init__(self, branch):
 
322
        import bzrlib.urlutils as urlutils
 
323
        public_location = urlutils.unescape_for_display(branch.base, 'ascii')
 
324
        BzrError.__init__(self, branch_url=public_location)
 
325
 
 
326
 
 
327
class NoHelpTopic(BzrError):
 
328
 
 
329
    _fmt = ("No help could be found for '%(topic)s'. "
 
330
        "Please use 'bzr help topics' to obtain a list of topics.")
 
331
 
 
332
    def __init__(self, topic):
 
333
        self.topic = topic
 
334
 
 
335
 
215
336
class NoSuchId(BzrError):
216
337
 
217
 
    _fmt = "The file id %(file_id)s is not present in the tree %(tree)s."
218
 
    
 
338
    _fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
 
339
 
219
340
    def __init__(self, tree, file_id):
220
341
        BzrError.__init__(self)
221
342
        self.file_id = file_id
222
343
        self.tree = tree
223
344
 
224
345
 
225
 
class InventoryModified(BzrError):
 
346
class NoSuchIdInRepository(NoSuchId):
 
347
 
 
348
    _fmt = ('The file id "%(file_id)s" is not present in the repository'
 
349
            ' %(repository)r')
 
350
 
 
351
    def __init__(self, repository, file_id):
 
352
        BzrError.__init__(self, repository=repository, file_id=file_id)
 
353
 
 
354
 
 
355
class NotStacked(BranchError):
 
356
 
 
357
    _fmt = "The branch '%(branch)s' is not stacked."
 
358
 
 
359
 
 
360
class InventoryModified(InternalBzrError):
226
361
 
227
362
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
228
363
            " so a clean inventory cannot be read without data loss.")
229
364
 
230
 
    internal_error = True
231
 
 
232
365
    def __init__(self, tree):
233
366
        self.tree = tree
234
367
 
235
368
 
236
369
class NoWorkingTree(BzrError):
237
370
 
238
 
    _fmt = "No WorkingTree exists for %(base)s."
239
 
    
 
371
    _fmt = 'No WorkingTree exists for "%(base)s".'
 
372
 
240
373
    def __init__(self, base):
241
374
        BzrError.__init__(self)
242
375
        self.base = base
255
388
        self.url = url
256
389
 
257
390
 
258
 
class WorkingTreeAlreadyPopulated(BzrError):
259
 
 
260
 
    _fmt = """Working tree already populated in %(base)s"""
261
 
 
262
 
    internal_error = True
 
391
class WorkingTreeAlreadyPopulated(InternalBzrError):
 
392
 
 
393
    _fmt = 'Working tree already populated in "%(base)s"'
263
394
 
264
395
    def __init__(self, base):
265
396
        self.base = base
266
397
 
 
398
 
267
399
class BzrCommandError(BzrError):
268
400
    """Error from user command"""
269
401
 
270
 
    internal_error = False
271
 
 
272
402
    # Error from malformed user command; please avoid raising this as a
273
403
    # generic exception not caused by user input.
274
404
    #
276
406
    # are not intended to be caught anyway.  UI code need not subclass
277
407
    # BzrCommandError, and non-UI code should not throw a subclass of
278
408
    # BzrCommandError.  ADHB 20051211
279
 
    def __init__(self, msg):
280
 
        # Object.__str__() must return a real string
281
 
        # returning a Unicode string is a python error.
282
 
        if isinstance(msg, unicode):
283
 
            self.msg = msg.encode('utf8')
284
 
        else:
285
 
            self.msg = msg
286
 
 
287
 
    def __str__(self):
288
 
        return self.msg
289
409
 
290
410
 
291
411
class NotWriteLocked(BzrError):
301
421
    _fmt = "Error in command line options"
302
422
 
303
423
 
 
424
class BadIndexFormatSignature(BzrError):
 
425
 
 
426
    _fmt = "%(value)s is not an index of type %(_type)s."
 
427
 
 
428
    def __init__(self, value, _type):
 
429
        BzrError.__init__(self)
 
430
        self.value = value
 
431
        self._type = _type
 
432
 
 
433
 
 
434
class BadIndexData(BzrError):
 
435
 
 
436
    _fmt = "Error in data for index %(value)s."
 
437
 
 
438
    def __init__(self, value):
 
439
        BzrError.__init__(self)
 
440
        self.value = value
 
441
 
 
442
 
 
443
class BadIndexDuplicateKey(BzrError):
 
444
 
 
445
    _fmt = "The key '%(key)s' is already in index '%(index)s'."
 
446
 
 
447
    def __init__(self, key, index):
 
448
        BzrError.__init__(self)
 
449
        self.key = key
 
450
        self.index = index
 
451
 
 
452
 
 
453
class BadIndexKey(BzrError):
 
454
 
 
455
    _fmt = "The key '%(key)s' is not a valid key."
 
456
 
 
457
    def __init__(self, key):
 
458
        BzrError.__init__(self)
 
459
        self.key = key
 
460
 
 
461
 
 
462
class BadIndexOptions(BzrError):
 
463
 
 
464
    _fmt = "Could not parse options for index %(value)s."
 
465
 
 
466
    def __init__(self, value):
 
467
        BzrError.__init__(self)
 
468
        self.value = value
 
469
 
 
470
 
 
471
class BadIndexValue(BzrError):
 
472
 
 
473
    _fmt = "The value '%(value)s' is not a valid value."
 
474
 
 
475
    def __init__(self, value):
 
476
        BzrError.__init__(self)
 
477
        self.value = value
 
478
 
 
479
 
304
480
class BadOptionValue(BzrError):
305
481
 
306
482
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
308
484
    def __init__(self, name, value):
309
485
        BzrError.__init__(self, name=name, value=value)
310
486
 
311
 
    
 
487
 
312
488
class StrictCommitFailed(BzrError):
313
489
 
314
490
    _fmt = "Commit refused because there are unknown files in the tree"
316
492
 
317
493
# XXX: Should be unified with TransportError; they seem to represent the
318
494
# same thing
 
495
# RBC 20060929: I think that unifiying with TransportError would be a mistake
 
496
# - this is finer than a TransportError - and more useful as such. It
 
497
# differentiates between 'transport has failed' and 'operation on a transport
 
498
# has failed.'
319
499
class PathError(BzrError):
320
 
    
 
500
 
321
501
    _fmt = "Generic path error: %(path)r%(extra)s)"
322
502
 
323
503
    def __init__(self, path, extra=None):
343
523
    """Used when renaming and both source and dest exist."""
344
524
 
345
525
    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
346
 
            "%(extra)s")
 
526
            " (Use --after to tell bzr about a rename that has already"
 
527
            " happened)%(extra)s")
347
528
 
348
529
    def __init__(self, source, dest, extra=None):
349
530
        BzrError.__init__(self)
357
538
 
358
539
class NotADirectory(PathError):
359
540
 
360
 
    _fmt = "%(path)r is not a directory %(extra)s"
 
541
    _fmt = '"%(path)s" is not a directory %(extra)s'
361
542
 
362
543
 
363
544
class NotInWorkingDirectory(PathError):
364
545
 
365
 
    _fmt = "%(path)r is not in the working directory %(extra)s"
 
546
    _fmt = '"%(path)s" is not in the working directory %(extra)s'
366
547
 
367
548
 
368
549
class DirectoryNotEmpty(PathError):
369
550
 
370
 
    _fmt = "Directory not empty: %(path)r%(extra)s"
371
 
 
372
 
 
373
 
class ReadingCompleted(BzrError):
374
 
    
 
551
    _fmt = 'Directory not empty: "%(path)s"%(extra)s'
 
552
 
 
553
 
 
554
class HardLinkNotSupported(PathError):
 
555
 
 
556
    _fmt = 'Hard-linking "%(path)s" is not supported'
 
557
 
 
558
 
 
559
class ReadingCompleted(InternalBzrError):
 
560
 
375
561
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
376
562
            "called upon it - the request has been completed and no more "
377
563
            "data may be read.")
378
564
 
379
 
    internal_error = True
380
 
 
381
565
    def __init__(self, request):
382
566
        self.request = request
383
567
 
384
568
 
385
569
class ResourceBusy(PathError):
386
570
 
387
 
    _fmt = "Device or resource busy: %(path)r%(extra)s"
 
571
    _fmt = 'Device or resource busy: "%(path)s"%(extra)s'
388
572
 
389
573
 
390
574
class PermissionDenied(PathError):
391
575
 
392
 
    _fmt = "Permission denied: %(path)r%(extra)s"
 
576
    _fmt = 'Permission denied: "%(path)s"%(extra)s'
393
577
 
394
578
 
395
579
class InvalidURL(PathError):
396
580
 
397
 
    _fmt = "Invalid url supplied to transport: %(path)r%(extra)s"
 
581
    _fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
398
582
 
399
583
 
400
584
class InvalidURLJoin(PathError):
401
585
 
402
 
    _fmt = "Invalid URL join request: %(args)s%(extra)s"
403
 
 
404
 
    def __init__(self, msg, base, args):
405
 
        PathError.__init__(self, base, msg)
406
 
        self.args = [base] + list(args)
 
586
    _fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"
 
587
 
 
588
    def __init__(self, reason, base, join_args):
 
589
        self.reason = reason
 
590
        self.base = base
 
591
        self.join_args = join_args
 
592
        PathError.__init__(self, base, reason)
 
593
 
 
594
 
 
595
class InvalidRebaseURLs(PathError):
 
596
 
 
597
    _fmt = "URLs differ by more than path: %(from_)r and %(to)r"
 
598
 
 
599
    def __init__(self, from_, to):
 
600
        self.from_ = from_
 
601
        self.to = to
 
602
        PathError.__init__(self, from_, 'URLs differ by more than path.')
 
603
 
 
604
 
 
605
class UnavailableRepresentation(InternalBzrError):
 
606
 
 
607
    _fmt = ("The encoding '%(wanted)s' is not available for key %(key)s which "
 
608
        "is encoded as '%(native)s'.")
 
609
 
 
610
    def __init__(self, key, wanted, native):
 
611
        InternalBzrError.__init__(self)
 
612
        self.wanted = wanted
 
613
        self.native = native
 
614
        self.key = key
407
615
 
408
616
 
409
617
class UnknownHook(BzrError):
420
628
 
421
629
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
422
630
 
423
 
    def __init__(self, url, extra):
 
631
    def __init__(self, url, extra=""):
424
632
        PathError.__init__(self, url, extra=extra)
425
633
 
426
634
 
 
635
class UnstackableBranchFormat(BzrError):
 
636
 
 
637
    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
 
638
        "You will need to upgrade the branch to permit branch stacking.")
 
639
 
 
640
    def __init__(self, format, url):
 
641
        BzrError.__init__(self)
 
642
        self.format = format
 
643
        self.url = url
 
644
 
 
645
 
 
646
class UnstackableLocationError(BzrError):
 
647
 
 
648
    _fmt = "The branch '%(branch_url)s' cannot be stacked on '%(target_url)s'."
 
649
 
 
650
    def __init__(self, branch_url, target_url):
 
651
        BzrError.__init__(self)
 
652
        self.branch_url = branch_url
 
653
        self.target_url = target_url
 
654
 
 
655
 
 
656
class UnstackableRepositoryFormat(BzrError):
 
657
 
 
658
    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
 
659
        "You will need to upgrade the repository to permit branch stacking.")
 
660
 
 
661
    def __init__(self, format, url):
 
662
        BzrError.__init__(self)
 
663
        self.format = format
 
664
        self.url = url
 
665
 
 
666
 
 
667
class ReadError(PathError):
 
668
 
 
669
    _fmt = """Error reading from %(path)r."""
 
670
 
 
671
 
427
672
class ShortReadvError(PathError):
428
673
 
429
 
    _fmt = ("readv() read %(actual)s bytes rather than %(length)s bytes"
430
 
            " at %(offset)s for %(path)s%(extra)s")
 
674
    _fmt = ('readv() read %(actual)s bytes rather than %(length)s bytes'
 
675
            ' at %(offset)s for "%(path)s"%(extra)s')
431
676
 
432
677
    internal_error = True
433
678
 
438
683
        self.actual = actual
439
684
 
440
685
 
441
 
class PathNotChild(BzrError):
442
 
 
443
 
    _fmt = "Path %(path)r is not a child of path %(base)r%(extra)s"
444
 
 
445
 
    internal_error = True
 
686
class PathNotChild(PathError):
 
687
 
 
688
    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
 
689
 
 
690
    internal_error = False
446
691
 
447
692
    def __init__(self, path, base, extra=None):
448
693
        BzrError.__init__(self)
456
701
 
457
702
class InvalidNormalization(PathError):
458
703
 
459
 
    _fmt = "Path %(path)r is not unicode normalized"
 
704
    _fmt = 'Path "%(path)s" is not unicode normalized'
460
705
 
461
706
 
462
707
# TODO: This is given a URL; we try to unescape it but doing that from inside
463
708
# the exception object is a bit undesirable.
464
 
# TODO: Probably this behavior of should be a common superclass 
 
709
# TODO: Probably this behavior of should be a common superclass
465
710
class NotBranchError(PathError):
466
711
 
467
 
    _fmt = "Not a branch: %(path)s"
 
712
    _fmt = 'Not a branch: "%(path)s"%(detail)s.'
468
713
 
469
 
    def __init__(self, path):
 
714
    def __init__(self, path, detail=None, bzrdir=None):
470
715
       import bzrlib.urlutils as urlutils
471
 
       self.path = urlutils.unescape_for_display(path, 'ascii')
 
716
       path = urlutils.unescape_for_display(path, 'ascii')
 
717
       if detail is not None:
 
718
           detail = ': ' + detail
 
719
       self.detail = detail
 
720
       self.bzrdir = bzrdir
 
721
       PathError.__init__(self, path=path)
 
722
 
 
723
    def __repr__(self):
 
724
        return '<%s %r>' % (self.__class__.__name__, self.__dict__)
 
725
 
 
726
    def _format(self):
 
727
        # XXX: Ideally self.detail would be a property, but Exceptions in
 
728
        # Python 2.4 have to be old-style classes so properties don't work.
 
729
        # Instead we override _format.
 
730
        if self.detail is None:
 
731
            if self.bzrdir is not None:
 
732
                try:
 
733
                    self.bzrdir.open_repository()
 
734
                except NoRepositoryPresent:
 
735
                    self.detail = ''
 
736
                except Exception:
 
737
                    # Just ignore unexpected errors.  Raising arbitrary errors
 
738
                    # during str(err) can provoke strange bugs.  Concretely
 
739
                    # Launchpad's codehosting managed to raise NotBranchError
 
740
                    # here, and then get stuck in an infinite loop/recursion
 
741
                    # trying to str() that error.  All this error really cares
 
742
                    # about that there's no working repository there, and if
 
743
                    # open_repository() fails, there probably isn't.
 
744
                    self.detail = ''
 
745
                else:
 
746
                    self.detail = ': location is a repository'
 
747
            else:
 
748
                self.detail = ''
 
749
        return PathError._format(self)
472
750
 
473
751
 
474
752
class NoSubmitBranch(PathError):
482
760
 
483
761
class AlreadyBranchError(PathError):
484
762
 
485
 
    _fmt = "Already a branch: %(path)s."
 
763
    _fmt = 'Already a branch: "%(path)s".'
486
764
 
487
765
 
488
766
class BranchExistsWithoutWorkingTree(PathError):
489
767
 
490
 
    _fmt = "Directory contains a branch, but no working tree \
491
 
(use bzr checkout if you wish to build a working tree): %(path)s"
 
768
    _fmt = 'Directory contains a branch, but no working tree \
 
769
(use bzr checkout if you wish to build a working tree): "%(path)s"'
492
770
 
493
771
 
494
772
class AtomicFileAlreadyClosed(PathError):
495
773
 
496
 
    _fmt = ("'%(function)s' called on an AtomicFile after it was closed:"
497
 
            " %(path)s")
 
774
    _fmt = ('"%(function)s" called on an AtomicFile after it was closed:'
 
775
            ' "%(path)s"')
498
776
 
499
777
    def __init__(self, path, function):
500
778
        PathError.__init__(self, path=path, extra=None)
503
781
 
504
782
class InaccessibleParent(PathError):
505
783
 
506
 
    _fmt = ("Parent not accessible given base %(base)s and"
507
 
            " relative path %(path)s")
 
784
    _fmt = ('Parent not accessible given base "%(base)s" and'
 
785
            ' relative path "%(path)s"')
508
786
 
509
787
    def __init__(self, path, base):
510
788
        PathError.__init__(self, path)
513
791
 
514
792
class NoRepositoryPresent(BzrError):
515
793
 
516
 
    _fmt = "No repository present: %(path)r"
 
794
    _fmt = 'No repository present: "%(path)s"'
517
795
    def __init__(self, bzrdir):
518
796
        BzrError.__init__(self)
519
797
        self.path = bzrdir.transport.clone('..').base
521
799
 
522
800
class FileInWrongBranch(BzrError):
523
801
 
524
 
    _fmt = "File %(path)s in not in branch %(branch_base)s."
 
802
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
525
803
 
 
804
    # use PathNotChild instead
 
805
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 3, 0)))
526
806
    def __init__(self, branch, path):
527
807
        BzrError.__init__(self)
528
808
        self.branch = branch
531
811
 
532
812
 
533
813
class UnsupportedFormatError(BzrError):
534
 
    
535
 
    _fmt = "Unsupported branch format: %(format)s"
 
814
 
 
815
    _fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
536
816
 
537
817
 
538
818
class UnknownFormatError(BzrError):
539
 
    
540
 
    _fmt = "Unknown branch format: %(format)r"
 
819
 
 
820
    _fmt = "Unknown %(kind)s format: %(format)r"
 
821
 
 
822
    def __init__(self, format, kind='branch'):
 
823
        self.kind = kind
 
824
        self.format = format
541
825
 
542
826
 
543
827
class IncompatibleFormat(BzrError):
544
 
    
 
828
 
545
829
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
546
830
 
547
831
    def __init__(self, format, bzrdir_format):
550
834
        self.bzrdir = bzrdir_format
551
835
 
552
836
 
 
837
class IncompatibleRepositories(BzrError):
 
838
    """Report an error that two repositories are not compatible.
 
839
 
 
840
    Note that the source and target repositories are permitted to be strings:
 
841
    this exception is thrown from the smart server and may refer to a
 
842
    repository the client hasn't opened.
 
843
    """
 
844
 
 
845
    _fmt = "%(target)s\n" \
 
846
            "is not compatible with\n" \
 
847
            "%(source)s\n" \
 
848
            "%(details)s"
 
849
 
 
850
    def __init__(self, source, target, details=None):
 
851
        if details is None:
 
852
            details = "(no details)"
 
853
        BzrError.__init__(self, target=target, source=source, details=details)
 
854
 
 
855
 
553
856
class IncompatibleRevision(BzrError):
554
 
    
 
857
 
555
858
    _fmt = "Revision is not compatible with %(repo_format)s"
556
859
 
557
860
    def __init__(self, repo_format):
562
865
class AlreadyVersionedError(BzrError):
563
866
    """Used when a path is expected not to be versioned, but it is."""
564
867
 
565
 
    _fmt = "%(context_info)s%(path)s is already versioned"
 
868
    _fmt = "%(context_info)s%(path)s is already versioned."
566
869
 
567
870
    def __init__(self, path, context_info=None):
568
871
        """Construct a new AlreadyVersionedError.
569
872
 
570
873
        :param path: This is the path which is versioned,
571
 
        which should be in a user friendly form.
 
874
            which should be in a user friendly form.
572
875
        :param context_info: If given, this is information about the context,
573
 
        which could explain why this is expected to not be versioned.
 
876
            which could explain why this is expected to not be versioned.
574
877
        """
575
878
        BzrError.__init__(self)
576
879
        self.path = path
583
886
class NotVersionedError(BzrError):
584
887
    """Used when a path is expected to be versioned, but it is not."""
585
888
 
586
 
    _fmt = "%(context_info)s%(path)s is not versioned"
 
889
    _fmt = "%(context_info)s%(path)s is not versioned."
587
890
 
588
891
    def __init__(self, path, context_info=None):
589
892
        """Construct a new NotVersionedError.
590
893
 
591
894
        :param path: This is the path which is not versioned,
592
 
        which should be in a user friendly form.
 
895
            which should be in a user friendly form.
593
896
        :param context_info: If given, this is information about the context,
594
 
        which could explain why this is expected to be versioned.
 
897
            which could explain why this is expected to be versioned.
595
898
        """
596
899
        BzrError.__init__(self)
597
900
        self.path = path
640
943
        BzrError.__init__(self, filename=filename, kind=kind)
641
944
 
642
945
 
 
946
class BadFilenameEncoding(BzrError):
 
947
 
 
948
    _fmt = ('Filename %(filename)r is not valid in your current filesystem'
 
949
            ' encoding %(fs_encoding)s')
 
950
 
 
951
    def __init__(self, filename, fs_encoding):
 
952
        BzrError.__init__(self)
 
953
        self.filename = filename
 
954
        self.fs_encoding = fs_encoding
 
955
 
 
956
 
643
957
class ForbiddenControlFileError(BzrError):
644
958
 
645
 
    _fmt = "Cannot operate on %(filename)s because it is a control file"
646
 
 
647
 
 
648
 
class LockError(BzrError):
649
 
 
650
 
    _fmt = "Lock error: %(message)s"
651
 
 
652
 
    internal_error = True
 
959
    _fmt = 'Cannot operate on "%(filename)s" because it is a control file'
 
960
 
 
961
 
 
962
class LockError(InternalBzrError):
 
963
 
 
964
    _fmt = "Lock error: %(msg)s"
653
965
 
654
966
    # All exceptions from the lock/unlock functions should be from
655
967
    # this exception class.  They will be translated as necessary. The
656
968
    # original exception is available as e.original_error
657
969
    #
658
970
    # New code should prefer to raise specific subclasses
659
 
    def __init__(self, message):
660
 
        self.message = message
 
971
    def __init__(self, msg):
 
972
        self.msg = msg
661
973
 
662
974
 
663
975
class LockActive(LockError):
697
1009
        self.obj = obj
698
1010
 
699
1011
 
 
1012
class LockFailed(LockError):
 
1013
 
 
1014
    internal_error = False
 
1015
 
 
1016
    _fmt = "Cannot lock %(lock)s: %(why)s"
 
1017
 
 
1018
    def __init__(self, lock, why):
 
1019
        LockError.__init__(self, '')
 
1020
        self.lock = lock
 
1021
        self.why = why
 
1022
 
 
1023
 
700
1024
class OutSideTransaction(BzrError):
701
1025
 
702
1026
    _fmt = ("A transaction related operation was attempted after"
724
1048
 
725
1049
class UnlockableTransport(LockError):
726
1050
 
 
1051
    internal_error = False
 
1052
 
727
1053
    _fmt = "Cannot lock: transport is read only: %(transport)s"
728
1054
 
729
1055
    def __init__(self, transport):
732
1058
 
733
1059
class LockContention(LockError):
734
1060
 
735
 
    _fmt = "Could not acquire lock %(lock)s"
736
 
    # TODO: show full url for lock, combining the transport and relative
737
 
    # bits?
 
1061
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
738
1062
 
739
1063
    internal_error = False
740
 
    
741
 
    def __init__(self, lock):
 
1064
 
 
1065
    def __init__(self, lock, msg=''):
742
1066
        self.lock = lock
 
1067
        self.msg = msg
743
1068
 
744
1069
 
745
1070
class LockBroken(LockError):
766
1091
        self.target = target
767
1092
 
768
1093
 
 
1094
class LockCorrupt(LockError):
 
1095
 
 
1096
    _fmt = ("Lock is apparently held, but corrupted: %(corruption_info)s\n"
 
1097
            "Use 'bzr break-lock' to clear it")
 
1098
 
 
1099
    internal_error = False
 
1100
 
 
1101
    def __init__(self, corruption_info, file_data=None):
 
1102
        self.corruption_info = corruption_info
 
1103
        self.file_data = file_data
 
1104
 
 
1105
 
769
1106
class LockNotHeld(LockError):
770
1107
 
771
1108
    _fmt = "Lock not held: %(lock)s"
776
1113
        self.lock = lock
777
1114
 
778
1115
 
 
1116
class TokenLockingNotSupported(LockError):
 
1117
 
 
1118
    _fmt = "The object %(obj)s does not support token specifying a token when locking."
 
1119
 
 
1120
    def __init__(self, obj):
 
1121
        self.obj = obj
 
1122
 
 
1123
 
 
1124
class TokenMismatch(LockBroken):
 
1125
 
 
1126
    _fmt = "The lock token %(given_token)r does not match lock token %(lock_token)r."
 
1127
 
 
1128
    internal_error = True
 
1129
 
 
1130
    def __init__(self, given_token, lock_token):
 
1131
        self.given_token = given_token
 
1132
        self.lock_token = lock_token
 
1133
 
 
1134
 
779
1135
class PointlessCommit(BzrError):
780
1136
 
781
1137
    _fmt = "No changes to commit"
782
1138
 
783
1139
 
 
1140
class CannotCommitSelectedFileMerge(BzrError):
 
1141
 
 
1142
    _fmt = 'Selected-file commit of merges is not supported yet:'\
 
1143
        ' files %(files_str)s'
 
1144
 
 
1145
    def __init__(self, files):
 
1146
        files_str = ', '.join(files)
 
1147
        BzrError.__init__(self, files=files, files_str=files_str)
 
1148
 
 
1149
 
 
1150
class ExcludesUnsupported(BzrError):
 
1151
 
 
1152
    _fmt = ('Excluding paths during commit is not supported by '
 
1153
            'repository at %(repository)r.')
 
1154
 
 
1155
    def __init__(self, repository):
 
1156
        BzrError.__init__(self, repository=repository)
 
1157
 
 
1158
 
 
1159
class BadCommitMessageEncoding(BzrError):
 
1160
 
 
1161
    _fmt = 'The specified commit message contains characters unsupported by '\
 
1162
        'the current encoding.'
 
1163
 
 
1164
 
784
1165
class UpgradeReadonly(BzrError):
785
1166
 
786
1167
    _fmt = "Upgrade URL cannot work with readonly URLs."
800
1181
    _fmt = "Commit refused because there are unknowns in the tree."
801
1182
 
802
1183
 
803
 
class NoSuchRevision(BzrError):
804
 
 
805
 
    _fmt = "Branch %(branch)s has no revision %(revision)s"
806
 
 
807
 
    internal_error = True
 
1184
class NoSuchRevision(InternalBzrError):
 
1185
 
 
1186
    _fmt = "%(branch)s has no revision %(revision)s"
808
1187
 
809
1188
    def __init__(self, branch, revision):
 
1189
        # 'branch' may sometimes be an internal object like a KnitRevisionStore
810
1190
        BzrError.__init__(self, branch=branch, revision=revision)
811
1191
 
812
1192
 
813
 
class NotLeftParentDescendant(BzrError):
814
 
 
815
 
    _fmt = ("Revision %(old_revision)s is not the left parent of"
816
 
            " %(new_revision)s, but branch %(branch_location)s expects this")
817
 
 
818
 
    internal_error = True
819
 
 
820
 
    def __init__(self, branch, old_revision, new_revision):
821
 
        BzrError.__init__(self, branch_location=branch.base,
822
 
                          old_revision=old_revision,
823
 
                          new_revision=new_revision)
 
1193
class RangeInChangeOption(BzrError):
 
1194
 
 
1195
    _fmt = "Option --change does not accept revision ranges"
824
1196
 
825
1197
 
826
1198
class NoSuchRevisionSpec(BzrError):
833
1205
 
834
1206
class NoSuchRevisionInTree(NoSuchRevision):
835
1207
    """When using Tree.revision_tree, and the revision is not accessible."""
836
 
    
837
 
    _fmt = "The revision id %(revision_id)s is not present in the tree %(tree)s."
 
1208
 
 
1209
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
838
1210
 
839
1211
    def __init__(self, tree, revision_id):
840
1212
        BzrError.__init__(self)
844
1216
 
845
1217
class InvalidRevisionSpec(BzrError):
846
1218
 
847
 
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
848
 
            " %(branch)s%(extra)s")
 
1219
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
 
1220
            " %(branch_url)s%(extra)s")
849
1221
 
850
1222
    def __init__(self, spec, branch, extra=None):
851
1223
        BzrError.__init__(self, branch=branch, spec=spec)
 
1224
        self.branch_url = getattr(branch, 'user_url', str(branch))
852
1225
        if extra:
853
1226
            self.extra = '\n' + str(extra)
854
1227
        else:
875
1248
class DivergedBranches(BzrError):
876
1249
 
877
1250
    _fmt = ("These branches have diverged."
878
 
            " Use the merge command to reconcile them.")
879
 
 
880
 
    internal_error = False
 
1251
            " Use the missing command to see how.\n"
 
1252
            "Use the merge command to reconcile them.")
881
1253
 
882
1254
    def __init__(self, branch1, branch2):
883
1255
        self.branch1 = branch1
884
1256
        self.branch2 = branch2
885
1257
 
886
1258
 
887
 
class NotLefthandHistory(BzrError):
 
1259
class NotLefthandHistory(InternalBzrError):
888
1260
 
889
1261
    _fmt = "Supplied history does not follow left-hand parents"
890
1262
 
891
 
    internal_error = True
892
 
 
893
1263
    def __init__(self, history):
894
1264
        BzrError.__init__(self, history=history)
895
1265
 
899
1269
    _fmt = ("Branches have no common ancestor, and"
900
1270
            " no merge base revision was specified.")
901
1271
 
902
 
    internal_error = False
 
1272
 
 
1273
class CannotReverseCherrypick(BzrError):
 
1274
 
 
1275
    _fmt = ('Selected merge cannot perform reverse cherrypicks.  Try merge3'
 
1276
            ' or diff3.')
903
1277
 
904
1278
 
905
1279
class NoCommonAncestor(BzrError):
906
 
    
 
1280
 
907
1281
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
908
1282
 
909
1283
    def __init__(self, revision_a, revision_b):
929
1303
            not_ancestor_id=not_ancestor_id)
930
1304
 
931
1305
 
932
 
class InstallFailed(BzrError):
933
 
 
934
 
    def __init__(self, revisions):
935
 
        revision_str = ", ".join(str(r) for r in revisions)
936
 
        msg = "Could not install revisions:\n%s" % revision_str
937
 
        BzrError.__init__(self, msg)
938
 
        self.revisions = revisions
939
 
 
940
 
 
941
1306
class AmbiguousBase(BzrError):
942
1307
 
943
1308
    def __init__(self, bases):
944
 
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
945
 
                DeprecationWarning)
 
1309
        symbol_versioning.warn("BzrError AmbiguousBase has been deprecated "
 
1310
            "as of bzrlib 0.8.", DeprecationWarning, stacklevel=2)
946
1311
        msg = ("The correct base is unclear, because %s are all equally close"
947
1312
                % ", ".join(bases))
948
1313
        BzrError.__init__(self, msg)
949
1314
        self.bases = bases
950
1315
 
951
1316
 
952
 
class NoCommits(BzrError):
 
1317
class NoCommits(BranchError):
953
1318
 
954
1319
    _fmt = "Branch %(branch)s has no commits."
955
1320
 
956
 
    def __init__(self, branch):
957
 
        BzrError.__init__(self, branch=branch)
958
 
 
959
1321
 
960
1322
class UnlistableStore(BzrError):
961
1323
 
972
1334
 
973
1335
class BoundBranchOutOfDate(BzrError):
974
1336
 
975
 
    _fmt = ("Bound branch %(branch)s is out of date"
976
 
            " with master branch %(master)s.")
 
1337
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
 
1338
            " %(master)s.%(extra_help)s")
977
1339
 
978
1340
    def __init__(self, branch, master):
979
1341
        BzrError.__init__(self)
980
1342
        self.branch = branch
981
1343
        self.master = master
982
 
 
983
 
        
 
1344
        self.extra_help = ''
 
1345
 
 
1346
 
984
1347
class CommitToDoubleBoundBranch(BzrError):
985
1348
 
986
1349
    _fmt = ("Cannot commit to branch %(branch)s."
1016
1379
 
1017
1380
class WeaveError(BzrError):
1018
1381
 
1019
 
    _fmt = "Error in processing weave: %(message)s"
 
1382
    _fmt = "Error in processing weave: %(msg)s"
1020
1383
 
1021
 
    def __init__(self, message=None):
 
1384
    def __init__(self, msg=None):
1022
1385
        BzrError.__init__(self)
1023
 
        self.message = message
 
1386
        self.msg = msg
1024
1387
 
1025
1388
 
1026
1389
class WeaveRevisionAlreadyPresent(WeaveError):
1055
1418
 
1056
1419
class WeaveParentMismatch(WeaveError):
1057
1420
 
1058
 
    _fmt = "Parents are mismatched between two revisions."
1059
 
    
 
1421
    _fmt = "Parents are mismatched between two revisions. %(msg)s"
 
1422
 
1060
1423
 
1061
1424
class WeaveInvalidChecksum(WeaveError):
1062
1425
 
1063
 
    _fmt = "Text did not match it's checksum: %(message)s"
 
1426
    _fmt = "Text did not match its checksum: %(msg)s"
1064
1427
 
1065
1428
 
1066
1429
class WeaveTextDiffers(WeaveError):
1088
1451
 
1089
1452
 
1090
1453
class VersionedFileError(BzrError):
1091
 
    
 
1454
 
1092
1455
    _fmt = "Versioned file error"
1093
1456
 
1094
1457
 
1095
1458
class RevisionNotPresent(VersionedFileError):
1096
 
    
1097
 
    _fmt = "Revision {%(revision_id)s} not present in %(file_id)s."
 
1459
 
 
1460
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1098
1461
 
1099
1462
    def __init__(self, revision_id, file_id):
1100
1463
        VersionedFileError.__init__(self)
1103
1466
 
1104
1467
 
1105
1468
class RevisionAlreadyPresent(VersionedFileError):
1106
 
    
1107
 
    _fmt = "Revision {%(revision_id)s} already present in %(file_id)s."
 
1469
 
 
1470
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1108
1471
 
1109
1472
    def __init__(self, revision_id, file_id):
1110
1473
        VersionedFileError.__init__(self)
1112
1475
        self.file_id = file_id
1113
1476
 
1114
1477
 
1115
 
class KnitError(BzrError):
1116
 
    
 
1478
class VersionedFileInvalidChecksum(VersionedFileError):
 
1479
 
 
1480
    _fmt = "Text did not match its checksum: %(msg)s"
 
1481
 
 
1482
 
 
1483
class KnitError(InternalBzrError):
 
1484
 
1117
1485
    _fmt = "Knit error"
1118
1486
 
1119
 
    internal_error = True
1120
 
 
1121
 
 
1122
 
class KnitHeaderError(KnitError):
1123
 
 
1124
 
    _fmt = "Knit header error: %(badline)r unexpected for file %(filename)s"
1125
 
 
1126
 
    def __init__(self, badline, filename):
1127
 
        KnitError.__init__(self)
1128
 
        self.badline = badline
1129
 
        self.filename = filename
1130
 
 
1131
1487
 
1132
1488
class KnitCorrupt(KnitError):
1133
1489
 
1139
1495
        self.how = how
1140
1496
 
1141
1497
 
 
1498
class SHA1KnitCorrupt(KnitCorrupt):
 
1499
 
 
1500
    _fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "
 
1501
        "match expected sha-1. key %(key)s expected sha %(expected)s actual "
 
1502
        "sha %(actual)s")
 
1503
 
 
1504
    def __init__(self, filename, actual, expected, key, content):
 
1505
        KnitError.__init__(self)
 
1506
        self.filename = filename
 
1507
        self.actual = actual
 
1508
        self.expected = expected
 
1509
        self.key = key
 
1510
        self.content = content
 
1511
 
 
1512
 
 
1513
class KnitDataStreamIncompatible(KnitError):
 
1514
    # Not raised anymore, as we can convert data streams.  In future we may
 
1515
    # need it again for more exotic cases, so we're keeping it around for now.
 
1516
 
 
1517
    _fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."
 
1518
 
 
1519
    def __init__(self, stream_format, target_format):
 
1520
        self.stream_format = stream_format
 
1521
        self.target_format = target_format
 
1522
 
 
1523
 
 
1524
class KnitDataStreamUnknown(KnitError):
 
1525
    # Indicates a data stream we don't know how to handle.
 
1526
 
 
1527
    _fmt = "Cannot parse knit data stream of format \"%(stream_format)s\"."
 
1528
 
 
1529
    def __init__(self, stream_format):
 
1530
        self.stream_format = stream_format
 
1531
 
 
1532
 
 
1533
class KnitHeaderError(KnitError):
 
1534
 
 
1535
    _fmt = 'Knit header error: %(badline)r unexpected for file "%(filename)s".'
 
1536
 
 
1537
    def __init__(self, badline, filename):
 
1538
        KnitError.__init__(self)
 
1539
        self.badline = badline
 
1540
        self.filename = filename
 
1541
 
1142
1542
class KnitIndexUnknownMethod(KnitError):
1143
1543
    """Raised when we don't understand the storage method.
1144
1544
 
1145
1545
    Currently only 'fulltext' and 'line-delta' are supported.
1146
1546
    """
1147
 
    
 
1547
 
1148
1548
    _fmt = ("Knit index %(filename)s does not have a known method"
1149
1549
            " in options: %(options)r")
1150
1550
 
1154
1554
        self.options = options
1155
1555
 
1156
1556
 
 
1557
class RetryWithNewPacks(BzrError):
 
1558
    """Raised when we realize that the packs on disk have changed.
 
1559
 
 
1560
    This is meant as more of a signaling exception, to trap between where a
 
1561
    local error occurred and the code that can actually handle the error and
 
1562
    code that can retry appropriately.
 
1563
    """
 
1564
 
 
1565
    internal_error = True
 
1566
 
 
1567
    _fmt = ("Pack files have changed, reload and retry. context: %(context)s"
 
1568
            " %(orig_error)s")
 
1569
 
 
1570
    def __init__(self, context, reload_occurred, exc_info):
 
1571
        """create a new RetryWithNewPacks error.
 
1572
 
 
1573
        :param reload_occurred: Set to True if we know that the packs have
 
1574
            already been reloaded, and we are failing because of an in-memory
 
1575
            cache miss. If set to True then we will ignore if a reload says
 
1576
            nothing has changed, because we assume it has already reloaded. If
 
1577
            False, then a reload with nothing changed will force an error.
 
1578
        :param exc_info: The original exception traceback, so if there is a
 
1579
            problem we can raise the original error (value from sys.exc_info())
 
1580
        """
 
1581
        BzrError.__init__(self)
 
1582
        self.reload_occurred = reload_occurred
 
1583
        self.exc_info = exc_info
 
1584
        self.orig_error = exc_info[1]
 
1585
        # TODO: The global error handler should probably treat this by
 
1586
        #       raising/printing the original exception with a bit about
 
1587
        #       RetryWithNewPacks also not being caught
 
1588
 
 
1589
 
 
1590
class RetryAutopack(RetryWithNewPacks):
 
1591
    """Raised when we are autopacking and we find a missing file.
 
1592
 
 
1593
    Meant as a signaling exception, to tell the autopack code it should try
 
1594
    again.
 
1595
    """
 
1596
 
 
1597
    internal_error = True
 
1598
 
 
1599
    _fmt = ("Pack files have changed, reload and try autopack again."
 
1600
            " context: %(context)s %(orig_error)s")
 
1601
 
 
1602
 
1157
1603
class NoSuchExportFormat(BzrError):
1158
 
    
 
1604
 
1159
1605
    _fmt = "Export format %(format)r not supported"
1160
1606
 
1161
1607
    def __init__(self, format):
1164
1610
 
1165
1611
 
1166
1612
class TransportError(BzrError):
1167
 
    
 
1613
 
1168
1614
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1169
1615
 
1170
1616
    def __init__(self, msg=None, orig_error=None):
1179
1625
        BzrError.__init__(self)
1180
1626
 
1181
1627
 
1182
 
class TooManyConcurrentRequests(BzrError):
 
1628
class TooManyConcurrentRequests(InternalBzrError):
1183
1629
 
1184
1630
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
1185
1631
            " Be sure to finish_writing and finish_reading on the"
1186
 
            " current request that is open.")
1187
 
 
1188
 
    internal_error = True
 
1632
            " currently open request.")
1189
1633
 
1190
1634
    def __init__(self, medium):
1191
1635
        self.medium = medium
1199
1643
        self.details = details
1200
1644
 
1201
1645
 
 
1646
class UnexpectedProtocolVersionMarker(TransportError):
 
1647
 
 
1648
    _fmt = "Received bad protocol version marker: %(marker)r"
 
1649
 
 
1650
    def __init__(self, marker):
 
1651
        self.marker = marker
 
1652
 
 
1653
 
 
1654
class UnknownSmartMethod(InternalBzrError):
 
1655
 
 
1656
    _fmt = "The server does not recognise the '%(verb)s' request."
 
1657
 
 
1658
    def __init__(self, verb):
 
1659
        self.verb = verb
 
1660
 
 
1661
 
 
1662
class SmartMessageHandlerError(InternalBzrError):
 
1663
 
 
1664
    _fmt = ("The message handler raised an exception:\n"
 
1665
            "%(traceback_text)s")
 
1666
 
 
1667
    def __init__(self, exc_info):
 
1668
        import traceback
 
1669
        self.exc_type, self.exc_value, self.exc_tb = exc_info
 
1670
        self.exc_info = exc_info
 
1671
        traceback_strings = traceback.format_exception(
 
1672
                self.exc_type, self.exc_value, self.exc_tb)
 
1673
        self.traceback_text = ''.join(traceback_strings)
 
1674
 
 
1675
 
1202
1676
# A set of semi-meaningful errors which can be thrown
1203
1677
class TransportNotPossible(TransportError):
1204
1678
 
1229
1703
            self.port = ':%s' % port
1230
1704
 
1231
1705
 
 
1706
# XXX: This is also used for unexpected end of file, which is different at the
 
1707
# TCP level from "connection reset".
1232
1708
class ConnectionReset(TransportError):
1233
1709
 
1234
1710
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1236
1712
 
1237
1713
class InvalidRange(TransportError):
1238
1714
 
1239
 
    _fmt = "Invalid range access in %(path)s at %(offset)s."
1240
 
    
1241
 
    def __init__(self, path, offset):
1242
 
        TransportError.__init__(self, ("Invalid range access in %s at %d"
1243
 
                                       % (path, offset)))
 
1715
    _fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
 
1716
 
 
1717
    def __init__(self, path, offset, msg=None):
 
1718
        TransportError.__init__(self, msg)
1244
1719
        self.path = path
1245
1720
        self.offset = offset
1246
1721
 
1247
1722
 
1248
1723
class InvalidHttpResponse(TransportError):
1249
1724
 
1250
 
    _fmt = "Invalid http response for %(path)s: %(msg)s"
 
1725
    _fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"
1251
1726
 
1252
1727
    def __init__(self, path, msg, orig_error=None):
1253
1728
        self.path = path
 
1729
        if orig_error is None:
 
1730
            orig_error = ''
 
1731
        else:
 
1732
            # This is reached for obscure and unusual errors so we want to
 
1733
            # preserve as much info as possible to ease debug.
 
1734
            orig_error = ': %r' % (orig_error,)
1254
1735
        TransportError.__init__(self, msg, orig_error=orig_error)
1255
1736
 
1256
1737
 
1257
1738
class InvalidHttpRange(InvalidHttpResponse):
1258
1739
 
1259
1740
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1260
 
    
 
1741
 
1261
1742
    def __init__(self, path, range, msg):
1262
1743
        self.range = range
1263
1744
        InvalidHttpResponse.__init__(self, path, msg)
1264
1745
 
1265
1746
 
 
1747
class HttpBoundaryMissing(InvalidHttpResponse):
 
1748
    """A multipart response ends with no boundary marker.
 
1749
 
 
1750
    This is a special case caused by buggy proxies, described in
 
1751
    <https://bugs.launchpad.net/bzr/+bug/198646>.
 
1752
    """
 
1753
 
 
1754
    _fmt = "HTTP MIME Boundary missing for %(path)s: %(msg)s"
 
1755
 
 
1756
    def __init__(self, path, msg):
 
1757
        InvalidHttpResponse.__init__(self, path, msg)
 
1758
 
 
1759
 
1266
1760
class InvalidHttpContentType(InvalidHttpResponse):
1267
1761
 
1268
1762
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1269
 
    
 
1763
 
1270
1764
    def __init__(self, path, ctype, msg):
1271
1765
        self.ctype = ctype
1272
1766
        InvalidHttpResponse.__init__(self, path, msg)
1273
1767
 
1274
1768
 
 
1769
class RedirectRequested(TransportError):
 
1770
 
 
1771
    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'
 
1772
 
 
1773
    def __init__(self, source, target, is_permanent=False):
 
1774
        self.source = source
 
1775
        self.target = target
 
1776
        if is_permanent:
 
1777
            self.permanently = ' permanently'
 
1778
        else:
 
1779
            self.permanently = ''
 
1780
        TransportError.__init__(self)
 
1781
 
 
1782
 
 
1783
class TooManyRedirections(TransportError):
 
1784
 
 
1785
    _fmt = "Too many redirections"
 
1786
 
 
1787
 
1275
1788
class ConflictsInTree(BzrError):
1276
1789
 
1277
1790
    _fmt = "Working tree has conflicts."
1278
1791
 
1279
1792
 
 
1793
class ConfigContentError(BzrError):
 
1794
 
 
1795
    _fmt = "Config file %(filename)s is not UTF-8 encoded\n"
 
1796
 
 
1797
    def __init__(self, filename):
 
1798
        BzrError.__init__(self)
 
1799
        self.filename = filename
 
1800
 
 
1801
 
1280
1802
class ParseConfigError(BzrError):
1281
1803
 
 
1804
    _fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
 
1805
 
1282
1806
    def __init__(self, errors, filename):
1283
 
        if filename is None:
1284
 
            filename = ""
1285
 
        message = "Error(s) parsing config file %s:\n%s" % \
1286
 
            (filename, ('\n'.join(e.message for e in errors)))
1287
 
        BzrError.__init__(self, message)
 
1807
        BzrError.__init__(self)
 
1808
        self.filename = filename
 
1809
        self.errors = '\n'.join(e.msg for e in errors)
 
1810
 
 
1811
 
 
1812
class ConfigOptionValueError(BzrError):
 
1813
 
 
1814
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
 
1815
 
 
1816
    def __init__(self, name, value):
 
1817
        BzrError.__init__(self, name=name, value=value)
1288
1818
 
1289
1819
 
1290
1820
class NoEmailInUsername(BzrError):
1298
1828
 
1299
1829
class SigningFailed(BzrError):
1300
1830
 
1301
 
    _fmt = "Failed to gpg sign data with command %(command_line)r"
 
1831
    _fmt = 'Failed to GPG sign data with command "%(command_line)s"'
1302
1832
 
1303
1833
    def __init__(self, command_line):
1304
1834
        BzrError.__init__(self, command_line=command_line)
1305
1835
 
1306
1836
 
 
1837
class SignatureVerificationFailed(BzrError):
 
1838
 
 
1839
    _fmt = 'Failed to verify GPG signature data with error "%(error)s"'
 
1840
 
 
1841
    def __init__(self, error):
 
1842
        BzrError.__init__(self, error=error)
 
1843
 
 
1844
 
 
1845
class DependencyNotPresent(BzrError):
 
1846
 
 
1847
    _fmt = 'Unable to import library "%(library)s": %(error)s'
 
1848
 
 
1849
    def __init__(self, library, error):
 
1850
        BzrError.__init__(self, library=library, error=error)
 
1851
 
 
1852
 
 
1853
class GpgmeNotInstalled(DependencyNotPresent):
 
1854
 
 
1855
    _fmt = 'python-gpgme is not installed, it is needed to verify signatures'
 
1856
 
 
1857
    def __init__(self, error):
 
1858
        DependencyNotPresent.__init__(self, 'gpgme', error)
 
1859
 
 
1860
 
1307
1861
class WorkingTreeNotRevision(BzrError):
1308
1862
 
1309
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
 
1863
    _fmt = ("The working tree for %(basedir)s has changed since"
1310
1864
            " the last commit, but weave merge requires that it be"
1311
1865
            " unchanged")
1312
1866
 
1329
1883
        self.graph = graph
1330
1884
 
1331
1885
 
1332
 
class WritingCompleted(BzrError):
 
1886
class WritingCompleted(InternalBzrError):
1333
1887
 
1334
1888
    _fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1335
1889
            "called upon it - accept bytes may not be called anymore.")
1336
1890
 
1337
 
    internal_error = True
1338
 
 
1339
1891
    def __init__(self, request):
1340
1892
        self.request = request
1341
1893
 
1342
1894
 
1343
 
class WritingNotComplete(BzrError):
 
1895
class WritingNotComplete(InternalBzrError):
1344
1896
 
1345
1897
    _fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1346
1898
            "called upon it - until the write phase is complete no "
1347
1899
            "data may be read.")
1348
1900
 
1349
 
    internal_error = True
1350
 
 
1351
1901
    def __init__(self, request):
1352
1902
        self.request = request
1353
1903
 
1361
1911
        self.filename = filename
1362
1912
 
1363
1913
 
1364
 
class MediumNotConnected(BzrError):
 
1914
class MediumNotConnected(InternalBzrError):
1365
1915
 
1366
1916
    _fmt = """The medium '%(medium)s' is not connected."""
1367
1917
 
1368
 
    internal_error = True
1369
 
 
1370
1918
    def __init__(self, medium):
1371
1919
        self.medium = medium
1372
1920
 
1378
1926
 
1379
1927
class NoBundleFound(BzrError):
1380
1928
 
1381
 
    _fmt = "No bundle was found in %(filename)s"
 
1929
    _fmt = 'No bundle was found in "%(filename)s".'
1382
1930
 
1383
1931
    def __init__(self, filename):
1384
1932
        BzrError.__init__(self)
1423
1971
    _fmt = "Key %(key)s is already present in map"
1424
1972
 
1425
1973
 
 
1974
class DuplicateHelpPrefix(BzrError):
 
1975
 
 
1976
    _fmt = "The prefix %(prefix)s is in the help search path twice."
 
1977
 
 
1978
    def __init__(self, prefix):
 
1979
        self.prefix = prefix
 
1980
 
 
1981
 
1426
1982
class MalformedTransform(BzrError):
1427
1983
 
1428
1984
    _fmt = "Tree transform is malformed %(conflicts)r"
1440
1996
        self.root_trans_id = transform.root
1441
1997
 
1442
1998
 
1443
 
class BzrBadParameter(BzrError):
 
1999
class BzrBadParameter(InternalBzrError):
1444
2000
 
1445
2001
    _fmt = "Bad parameter: %(param)r"
1446
2002
 
1467
2023
    _fmt = "Moving the root directory is not supported at this time"
1468
2024
 
1469
2025
 
 
2026
class TransformRenameFailed(BzrError):
 
2027
 
 
2028
    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
 
2029
 
 
2030
    def __init__(self, from_path, to_path, why, errno):
 
2031
        self.from_path = from_path
 
2032
        self.to_path = to_path
 
2033
        self.why = why
 
2034
        self.errno = errno
 
2035
 
 
2036
 
1470
2037
class BzrMoveFailedError(BzrError):
1471
2038
 
1472
 
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
 
2039
    _fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
 
2040
        "%(_has_extra)s%(extra)s")
1473
2041
 
1474
2042
    def __init__(self, from_path='', to_path='', extra=None):
 
2043
        from bzrlib.osutils import splitpath
1475
2044
        BzrError.__init__(self)
1476
2045
        if extra:
1477
 
            self.extra = ': ' + str(extra)
 
2046
            self.extra, self._has_extra = extra, ': '
1478
2047
        else:
1479
 
            self.extra = ''
 
2048
            self.extra = self._has_extra = ''
1480
2049
 
1481
2050
        has_from = len(from_path) > 0
1482
2051
        has_to = len(to_path) > 0
1483
2052
        if has_from:
1484
 
            self.from_path = osutils.splitpath(from_path)[-1]
 
2053
            self.from_path = splitpath(from_path)[-1]
1485
2054
        else:
1486
2055
            self.from_path = ''
1487
2056
 
1488
2057
        if has_to:
1489
 
            self.to_path = osutils.splitpath(to_path)[-1]
 
2058
            self.to_path = splitpath(to_path)[-1]
1490
2059
        else:
1491
2060
            self.to_path = ''
1492
2061
 
1503
2072
 
1504
2073
class BzrRenameFailedError(BzrMoveFailedError):
1505
2074
 
1506
 
    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
 
2075
    _fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
 
2076
        "%(_has_extra)s%(extra)s")
1507
2077
 
1508
2078
    def __init__(self, from_path, to_path, extra=None):
1509
2079
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1510
2080
 
1511
2081
 
 
2082
class BzrRemoveChangedFilesError(BzrError):
 
2083
    """Used when user is trying to remove changed files."""
 
2084
 
 
2085
    _fmt = ("Can't safely remove modified or unknown files:\n"
 
2086
        "%(changes_as_text)s"
 
2087
        "Use --keep to not delete them, or --force to delete them regardless.")
 
2088
 
 
2089
    def __init__(self, tree_delta):
 
2090
        symbol_versioning.warn(symbol_versioning.deprecated_in((2, 3, 0)) %
 
2091
            "BzrRemoveChangedFilesError", DeprecationWarning, stacklevel=2)
 
2092
        BzrError.__init__(self)
 
2093
        self.changes_as_text = tree_delta.get_changes_as_text()
 
2094
        #self.paths_as_string = '\n'.join(changed_files)
 
2095
        #self.paths_as_string = '\n'.join([quotefn(p) for p in changed_files])
 
2096
 
 
2097
 
1512
2098
class BzrBadParameterNotString(BzrBadParameter):
1513
2099
 
1514
2100
    _fmt = "Parameter %(param)s is not a string or unicode string."
1516
2102
 
1517
2103
class BzrBadParameterMissing(BzrBadParameter):
1518
2104
 
1519
 
    _fmt = "Parameter $(param)s is required but not present."
 
2105
    _fmt = "Parameter %(param)s is required but not present."
1520
2106
 
1521
2107
 
1522
2108
class BzrBadParameterUnicode(BzrBadParameter):
1530
2116
    _fmt = "Parameter %(param)s contains a newline."
1531
2117
 
1532
2118
 
1533
 
class DependencyNotPresent(BzrError):
1534
 
 
1535
 
    _fmt = 'Unable to import library "%(library)s": %(error)s'
1536
 
 
1537
 
    def __init__(self, library, error):
1538
 
        BzrError.__init__(self, library=library, error=error)
1539
 
 
1540
 
 
1541
2119
class ParamikoNotPresent(DependencyNotPresent):
1542
2120
 
1543
2121
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
1562
2140
 
1563
2141
class BadConversionTarget(BzrError):
1564
2142
 
1565
 
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
 
2143
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
 
2144
            "    %(problem)s"
1566
2145
 
1567
 
    def __init__(self, problem, format):
 
2146
    def __init__(self, problem, format, from_format=None):
1568
2147
        BzrError.__init__(self)
1569
2148
        self.problem = problem
1570
2149
        self.format = format
 
2150
        self.from_format = from_format or '(unspecified)'
 
2151
 
 
2152
 
 
2153
class NoDiffFound(BzrError):
 
2154
 
 
2155
    _fmt = 'Could not find an appropriate Differ for file "%(path)s"'
 
2156
 
 
2157
    def __init__(self, path):
 
2158
        BzrError.__init__(self, path)
 
2159
 
 
2160
 
 
2161
class ExecutableMissing(BzrError):
 
2162
 
 
2163
    _fmt = "%(exe_name)s could not be found on this machine"
 
2164
 
 
2165
    def __init__(self, exe_name):
 
2166
        BzrError.__init__(self, exe_name=exe_name)
1571
2167
 
1572
2168
 
1573
2169
class NoDiff(BzrError):
1583
2179
    _fmt = "Diff3 is not installed on this machine."
1584
2180
 
1585
2181
 
 
2182
class ExistingContent(BzrError):
 
2183
    # Added in bzrlib 0.92, used by VersionedFile.add_lines.
 
2184
 
 
2185
    _fmt = "The content being inserted is already present."
 
2186
 
 
2187
 
1586
2188
class ExistingLimbo(BzrError):
1587
2189
 
1588
2190
    _fmt = """This tree contains left-over files from a failed operation.
1589
2191
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1590
2192
    keep, and delete it when you are done."""
1591
 
    
 
2193
 
1592
2194
    def __init__(self, limbo_dir):
1593
2195
       BzrError.__init__(self)
1594
2196
       self.limbo_dir = limbo_dir
1595
2197
 
1596
2198
 
 
2199
class ExistingPendingDeletion(BzrError):
 
2200
 
 
2201
    _fmt = """This tree contains left-over files from a failed operation.
 
2202
    Please examine %(pending_deletion)s to see if it contains any files you
 
2203
    wish to keep, and delete it when you are done."""
 
2204
 
 
2205
    def __init__(self, pending_deletion):
 
2206
       BzrError.__init__(self, pending_deletion=pending_deletion)
 
2207
 
 
2208
 
1597
2209
class ImmortalLimbo(BzrError):
1598
2210
 
1599
 
    _fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
 
2211
    _fmt = """Unable to delete transform temporary directory %(limbo_dir)s.
1600
2212
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1601
2213
    keep, and delete it when you are done."""
1602
2214
 
1605
2217
       self.limbo_dir = limbo_dir
1606
2218
 
1607
2219
 
 
2220
class ImmortalPendingDeletion(BzrError):
 
2221
 
 
2222
    _fmt = ("Unable to delete transform temporary directory "
 
2223
    "%(pending_deletion)s.  Please examine %(pending_deletion)s to see if it "
 
2224
    "contains any files you wish to keep, and delete it when you are done.")
 
2225
 
 
2226
    def __init__(self, pending_deletion):
 
2227
       BzrError.__init__(self, pending_deletion=pending_deletion)
 
2228
 
 
2229
 
1608
2230
class OutOfDateTree(BzrError):
1609
2231
 
1610
 
    _fmt = "Working tree is out of date, please run 'bzr update'."
 
2232
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
1611
2233
 
1612
 
    def __init__(self, tree):
 
2234
    def __init__(self, tree, more=None):
 
2235
        if more is None:
 
2236
            more = ''
 
2237
        else:
 
2238
            more = ' ' + more
1613
2239
        BzrError.__init__(self)
1614
2240
        self.tree = tree
 
2241
        self.more = more
1615
2242
 
1616
2243
 
1617
2244
class PublicBranchOutOfDate(BzrError):
1637
2264
    _fmt = "Format error in conflict listings"
1638
2265
 
1639
2266
 
 
2267
class CorruptDirstate(BzrError):
 
2268
 
 
2269
    _fmt = ("Inconsistency in dirstate file %(dirstate_path)s.\n"
 
2270
            "Error: %(description)s")
 
2271
 
 
2272
    def __init__(self, dirstate_path, description):
 
2273
        BzrError.__init__(self)
 
2274
        self.dirstate_path = dirstate_path
 
2275
        self.description = description
 
2276
 
 
2277
 
1640
2278
class CorruptRepository(BzrError):
1641
2279
 
1642
2280
    _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
1644
2282
 
1645
2283
    def __init__(self, repo):
1646
2284
        BzrError.__init__(self)
1647
 
        self.repo_path = repo.bzrdir.root_transport.base
 
2285
        self.repo_path = repo.user_url
 
2286
 
 
2287
 
 
2288
class InconsistentDelta(BzrError):
 
2289
    """Used when we get a delta that is not valid."""
 
2290
 
 
2291
    _fmt = ("An inconsistent delta was supplied involving %(path)r,"
 
2292
            " %(file_id)r\nreason: %(reason)s")
 
2293
 
 
2294
    def __init__(self, path, file_id, reason):
 
2295
        BzrError.__init__(self)
 
2296
        self.path = path
 
2297
        self.file_id = file_id
 
2298
        self.reason = reason
 
2299
 
 
2300
 
 
2301
class InconsistentDeltaDelta(InconsistentDelta):
 
2302
    """Used when we get a delta that is not valid."""
 
2303
 
 
2304
    _fmt = ("An inconsistent delta was supplied: %(delta)r"
 
2305
            "\nreason: %(reason)s")
 
2306
 
 
2307
    def __init__(self, delta, reason):
 
2308
        BzrError.__init__(self)
 
2309
        self.delta = delta
 
2310
        self.reason = reason
1648
2311
 
1649
2312
 
1650
2313
class UpgradeRequired(BzrError):
1656
2319
        self.path = path
1657
2320
 
1658
2321
 
 
2322
class RepositoryUpgradeRequired(UpgradeRequired):
 
2323
 
 
2324
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
 
2325
 
 
2326
 
 
2327
class RichRootUpgradeRequired(UpgradeRequired):
 
2328
 
 
2329
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
 
2330
           " a format which supports rich roots.")
 
2331
 
 
2332
 
1659
2333
class LocalRequiresBoundBranch(BzrError):
1660
2334
 
1661
2335
    _fmt = "Cannot perform local-only commits on unbound branches."
1662
2336
 
1663
2337
 
1664
 
class MissingProgressBarFinish(BzrError):
1665
 
 
1666
 
    _fmt = "A nested progress bar was not 'finished' correctly."
1667
 
 
1668
 
 
1669
 
class InvalidProgressBarType(BzrError):
1670
 
 
1671
 
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
1672
 
            " is not a supported type Select one of: %(valid_types)s")
1673
 
 
1674
 
    def __init__(self, bar_type, valid_types):
1675
 
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1676
 
 
1677
 
 
1678
2338
class UnsupportedOperation(BzrError):
1679
2339
 
1680
2340
    _fmt = ("The method %(mname)s is not supported on"
1696
2356
    """
1697
2357
 
1698
2358
 
 
2359
class GhostTagsNotSupported(BzrError):
 
2360
 
 
2361
    _fmt = "Ghost tags not supported by format %(format)r."
 
2362
 
 
2363
    def __init__(self, format):
 
2364
        self.format = format
 
2365
 
 
2366
 
1699
2367
class BinaryFile(BzrError):
1700
 
    
 
2368
 
1701
2369
    _fmt = "File is binary but should be text."
1702
2370
 
1703
2371
 
1723
2391
 
1724
2392
 
1725
2393
class NotABundle(BzrError):
1726
 
    
 
2394
 
1727
2395
    _fmt = "Not a bzr revision-bundle: %(text)r"
1728
2396
 
1729
2397
    def __init__(self, text):
1731
2399
        self.text = text
1732
2400
 
1733
2401
 
1734
 
class BadBundle(BzrError): 
1735
 
    
 
2402
class BadBundle(BzrError):
 
2403
 
1736
2404
    _fmt = "Bad bzr revision-bundle: %(text)r"
1737
2405
 
1738
2406
    def __init__(self, text):
1740
2408
        self.text = text
1741
2409
 
1742
2410
 
1743
 
class MalformedHeader(BadBundle): 
1744
 
    
 
2411
class MalformedHeader(BadBundle):
 
2412
 
1745
2413
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
1746
2414
 
1747
2415
 
1748
 
class MalformedPatches(BadBundle): 
1749
 
    
 
2416
class MalformedPatches(BadBundle):
 
2417
 
1750
2418
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
1751
2419
 
1752
2420
 
1753
 
class MalformedFooter(BadBundle): 
1754
 
    
 
2421
class MalformedFooter(BadBundle):
 
2422
 
1755
2423
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
1756
2424
 
1757
2425
 
1758
2426
class UnsupportedEOLMarker(BadBundle):
1759
 
    
1760
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
 
2427
 
 
2428
    _fmt = "End of line marker was not \\n in bzr revision-bundle"
1761
2429
 
1762
2430
    def __init__(self):
1763
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
 
2431
        # XXX: BadBundle's constructor assumes there's explanatory text,
1764
2432
        # but for this there is not
1765
2433
        BzrError.__init__(self)
1766
2434
 
1767
2435
 
1768
2436
class IncompatibleBundleFormat(BzrError):
1769
 
    
 
2437
 
1770
2438
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
1771
2439
 
1772
2440
    def __init__(self, bundle_format, other):
1776
2444
 
1777
2445
 
1778
2446
class BadInventoryFormat(BzrError):
1779
 
    
 
2447
 
1780
2448
    _fmt = "Root class for inventory serialization errors"
1781
2449
 
1782
2450
 
1793
2461
    _fmt = """This operation requires rich root data storage"""
1794
2462
 
1795
2463
 
1796
 
class NoSmartMedium(BzrError):
 
2464
class NoSmartMedium(InternalBzrError):
1797
2465
 
1798
2466
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
1799
2467
 
1800
 
    internal_error = True
1801
 
 
1802
2468
    def __init__(self, transport):
1803
2469
        self.transport = transport
1804
2470
 
1805
2471
 
1806
 
class NoSmartServer(NotBranchError):
1807
 
 
1808
 
    _fmt = "No smart server available at %(url)s"
1809
 
 
1810
 
    def __init__(self, url):
1811
 
        self.url = url
1812
 
 
1813
 
 
1814
2472
class UnknownSSH(BzrError):
1815
2473
 
1816
2474
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
1826
2484
            " Please set BZR_SSH environment variable.")
1827
2485
 
1828
2486
 
 
2487
class GhostRevisionsHaveNoRevno(BzrError):
 
2488
    """When searching for revnos, if we encounter a ghost, we are stuck"""
 
2489
 
 
2490
    _fmt = ("Could not determine revno for {%(revision_id)s} because"
 
2491
            " its ancestry shows a ghost at {%(ghost_revision_id)s}")
 
2492
 
 
2493
    def __init__(self, revision_id, ghost_revision_id):
 
2494
        self.revision_id = revision_id
 
2495
        self.ghost_revision_id = ghost_revision_id
 
2496
 
 
2497
 
1829
2498
class GhostRevisionUnusableHere(BzrError):
1830
2499
 
1831
2500
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
1835
2504
        self.revision_id = revision_id
1836
2505
 
1837
2506
 
1838
 
class IllegalUseOfScopeReplacer(BzrError):
 
2507
class IllegalUseOfScopeReplacer(InternalBzrError):
1839
2508
 
1840
2509
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
1841
2510
            " %(msg)s%(extra)s")
1842
2511
 
1843
 
    internal_error = True
1844
 
 
1845
2512
    def __init__(self, name, msg, extra=None):
1846
2513
        BzrError.__init__(self)
1847
2514
        self.name = name
1852
2519
            self.extra = ''
1853
2520
 
1854
2521
 
1855
 
class InvalidImportLine(BzrError):
 
2522
class InvalidImportLine(InternalBzrError):
1856
2523
 
1857
2524
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
1858
2525
 
1859
 
    internal_error = True
1860
 
 
1861
2526
    def __init__(self, text, msg):
1862
2527
        BzrError.__init__(self)
1863
2528
        self.text = text
1864
2529
        self.msg = msg
1865
2530
 
1866
2531
 
1867
 
class ImportNameCollision(BzrError):
 
2532
class ImportNameCollision(InternalBzrError):
1868
2533
 
1869
2534
    _fmt = ("Tried to import an object to the same name as"
1870
2535
            " an existing object. %(name)s")
1871
2536
 
1872
 
    internal_error = True
1873
 
 
1874
2537
    def __init__(self, name):
1875
2538
        BzrError.__init__(self)
1876
2539
        self.name = name
1889
2552
        " branch location."
1890
2553
 
1891
2554
 
 
2555
class IllegalMergeDirectivePayload(BzrError):
 
2556
    """A merge directive contained something other than a patch or bundle"""
 
2557
 
 
2558
    _fmt = "Bad merge directive payload %(start)r"
 
2559
 
 
2560
    def __init__(self, start):
 
2561
        BzrError(self)
 
2562
        self.start = start
 
2563
 
 
2564
 
 
2565
class PatchVerificationFailed(BzrError):
 
2566
    """A patch from a merge directive could not be verified"""
 
2567
 
 
2568
    _fmt = "Preview patch does not match requested changes."
 
2569
 
 
2570
 
1892
2571
class PatchMissing(BzrError):
1893
2572
    """Raise a patch type was specified but no patch supplied"""
1894
2573
 
1895
 
    _fmt = "patch_type was %(patch_type)s, but no patch was supplied."
 
2574
    _fmt = "Patch_type was %(patch_type)s, but no patch was supplied."
1896
2575
 
1897
2576
    def __init__(self, patch_type):
1898
2577
        BzrError.__init__(self)
1899
2578
        self.patch_type = patch_type
1900
2579
 
1901
2580
 
 
2581
class TargetNotBranch(BzrError):
 
2582
    """A merge directive's target branch is required, but isn't a branch"""
 
2583
 
 
2584
    _fmt = ("Your branch does not have all of the revisions required in "
 
2585
            "order to merge this merge directive and the target "
 
2586
            "location specified in the merge directive is not a branch: "
 
2587
            "%(location)s.")
 
2588
 
 
2589
    def __init__(self, location):
 
2590
        BzrError.__init__(self)
 
2591
        self.location = location
 
2592
 
 
2593
 
1902
2594
class UnsupportedInventoryKind(BzrError):
1903
 
    
 
2595
 
1904
2596
    _fmt = """Unsupported entry kind %(kind)s"""
1905
2597
 
1906
2598
    def __init__(self, kind):
1909
2601
 
1910
2602
class BadSubsumeSource(BzrError):
1911
2603
 
1912
 
    _fmt = """Can't subsume %(other_tree)s into %(tree)s.  %(reason)s"""
 
2604
    _fmt = "Can't subsume %(other_tree)s into %(tree)s. %(reason)s"
1913
2605
 
1914
2606
    def __init__(self, tree, other_tree, reason):
1915
2607
        self.tree = tree
1918
2610
 
1919
2611
 
1920
2612
class SubsumeTargetNeedsUpgrade(BzrError):
1921
 
    
 
2613
 
1922
2614
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
1923
2615
 
1924
2616
    def __init__(self, other_tree):
1925
2617
        self.other_tree = other_tree
1926
2618
 
1927
2619
 
1928
 
class BadReferenceTarget(BzrError):
1929
 
 
1930
 
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s.  %(reason)s"
1931
 
 
1932
 
    internal_error = True
 
2620
class BadReferenceTarget(InternalBzrError):
 
2621
 
 
2622
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
 
2623
           "%(reason)s"
1933
2624
 
1934
2625
    def __init__(self, tree, other_tree, reason):
1935
2626
        self.tree = tree
1953
2644
    def __init__(self, branch):
1954
2645
        self.branch = branch
1955
2646
 
1956
 
        
 
2647
 
1957
2648
class TagAlreadyExists(BzrError):
1958
2649
 
1959
2650
    _fmt = "Tag %(tag_name)s already exists."
1960
2651
 
1961
2652
    def __init__(self, tag_name):
1962
2653
        self.tag_name = tag_name
 
2654
 
 
2655
 
 
2656
class MalformedBugIdentifier(BzrError):
 
2657
 
 
2658
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
 
2659
            'See "bzr help bugs" for more information on this feature.')
 
2660
 
 
2661
    def __init__(self, bug_id, reason):
 
2662
        self.bug_id = bug_id
 
2663
        self.reason = reason
 
2664
 
 
2665
 
 
2666
class InvalidBugTrackerURL(BzrError):
 
2667
 
 
2668
    _fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
 
2669
            "contain {id}: %(url)s")
 
2670
 
 
2671
    def __init__(self, abbreviation, url):
 
2672
        self.abbreviation = abbreviation
 
2673
        self.url = url
 
2674
 
 
2675
 
 
2676
class UnknownBugTrackerAbbreviation(BzrError):
 
2677
 
 
2678
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
 
2679
            "on %(branch)s")
 
2680
 
 
2681
    def __init__(self, abbreviation, branch):
 
2682
        self.abbreviation = abbreviation
 
2683
        self.branch = branch
 
2684
 
 
2685
 
 
2686
class InvalidLineInBugsProperty(BzrError):
 
2687
 
 
2688
    _fmt = ("Invalid line in bugs property: '%(line)s'")
 
2689
 
 
2690
    def __init__(self, line):
 
2691
        self.line = line
 
2692
 
 
2693
 
 
2694
class InvalidBugStatus(BzrError):
 
2695
 
 
2696
    _fmt = ("Invalid bug status: '%(status)s'")
 
2697
 
 
2698
    def __init__(self, status):
 
2699
        self.status = status
 
2700
 
 
2701
 
 
2702
class UnexpectedSmartServerResponse(BzrError):
 
2703
 
 
2704
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
 
2705
 
 
2706
    def __init__(self, response_tuple):
 
2707
        self.response_tuple = response_tuple
 
2708
 
 
2709
 
 
2710
class ErrorFromSmartServer(BzrError):
 
2711
    """An error was received from a smart server.
 
2712
 
 
2713
    :seealso: UnknownErrorFromSmartServer
 
2714
    """
 
2715
 
 
2716
    _fmt = "Error received from smart server: %(error_tuple)r"
 
2717
 
 
2718
    internal_error = True
 
2719
 
 
2720
    def __init__(self, error_tuple):
 
2721
        self.error_tuple = error_tuple
 
2722
        try:
 
2723
            self.error_verb = error_tuple[0]
 
2724
        except IndexError:
 
2725
            self.error_verb = None
 
2726
        self.error_args = error_tuple[1:]
 
2727
 
 
2728
 
 
2729
class UnknownErrorFromSmartServer(BzrError):
 
2730
    """An ErrorFromSmartServer could not be translated into a typical bzrlib
 
2731
    error.
 
2732
 
 
2733
    This is distinct from ErrorFromSmartServer so that it is possible to
 
2734
    distinguish between the following two cases:
 
2735
 
 
2736
    - ErrorFromSmartServer was uncaught.  This is logic error in the client
 
2737
      and so should provoke a traceback to the user.
 
2738
    - ErrorFromSmartServer was caught but its error_tuple could not be
 
2739
      translated.  This is probably because the server sent us garbage, and
 
2740
      should not provoke a traceback.
 
2741
    """
 
2742
 
 
2743
    _fmt = "Server sent an unexpected error: %(error_tuple)r"
 
2744
 
 
2745
    internal_error = False
 
2746
 
 
2747
    def __init__(self, error_from_smart_server):
 
2748
        """Constructor.
 
2749
 
 
2750
        :param error_from_smart_server: An ErrorFromSmartServer instance.
 
2751
        """
 
2752
        self.error_from_smart_server = error_from_smart_server
 
2753
        self.error_tuple = error_from_smart_server.error_tuple
 
2754
 
 
2755
 
 
2756
class ContainerError(BzrError):
 
2757
    """Base class of container errors."""
 
2758
 
 
2759
 
 
2760
class UnknownContainerFormatError(ContainerError):
 
2761
 
 
2762
    _fmt = "Unrecognised container format: %(container_format)r"
 
2763
 
 
2764
    def __init__(self, container_format):
 
2765
        self.container_format = container_format
 
2766
 
 
2767
 
 
2768
class UnexpectedEndOfContainerError(ContainerError):
 
2769
 
 
2770
    _fmt = "Unexpected end of container stream"
 
2771
 
 
2772
 
 
2773
class UnknownRecordTypeError(ContainerError):
 
2774
 
 
2775
    _fmt = "Unknown record type: %(record_type)r"
 
2776
 
 
2777
    def __init__(self, record_type):
 
2778
        self.record_type = record_type
 
2779
 
 
2780
 
 
2781
class InvalidRecordError(ContainerError):
 
2782
 
 
2783
    _fmt = "Invalid record: %(reason)s"
 
2784
 
 
2785
    def __init__(self, reason):
 
2786
        self.reason = reason
 
2787
 
 
2788
 
 
2789
class ContainerHasExcessDataError(ContainerError):
 
2790
 
 
2791
    _fmt = "Container has data after end marker: %(excess)r"
 
2792
 
 
2793
    def __init__(self, excess):
 
2794
        self.excess = excess
 
2795
 
 
2796
 
 
2797
class DuplicateRecordNameError(ContainerError):
 
2798
 
 
2799
    _fmt = "Container has multiple records with the same name: %(name)s"
 
2800
 
 
2801
    def __init__(self, name):
 
2802
        self.name = name.decode("utf-8")
 
2803
 
 
2804
 
 
2805
class NoDestinationAddress(InternalBzrError):
 
2806
 
 
2807
    _fmt = "Message does not have a destination address."
 
2808
 
 
2809
 
 
2810
class RepositoryDataStreamError(BzrError):
 
2811
 
 
2812
    _fmt = "Corrupt or incompatible data stream: %(reason)s"
 
2813
 
 
2814
    def __init__(self, reason):
 
2815
        self.reason = reason
 
2816
 
 
2817
 
 
2818
class SMTPError(BzrError):
 
2819
 
 
2820
    _fmt = "SMTP error: %(error)s"
 
2821
 
 
2822
    def __init__(self, error):
 
2823
        self.error = error
 
2824
 
 
2825
 
 
2826
class NoMessageSupplied(BzrError):
 
2827
 
 
2828
    _fmt = "No message supplied."
 
2829
 
 
2830
 
 
2831
class NoMailAddressSpecified(BzrError):
 
2832
 
 
2833
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
 
2834
 
 
2835
 
 
2836
class UnknownMailClient(BzrError):
 
2837
 
 
2838
    _fmt = "Unknown mail client: %(mail_client)s"
 
2839
 
 
2840
    def __init__(self, mail_client):
 
2841
        BzrError.__init__(self, mail_client=mail_client)
 
2842
 
 
2843
 
 
2844
class MailClientNotFound(BzrError):
 
2845
 
 
2846
    _fmt = "Unable to find mail client with the following names:"\
 
2847
        " %(mail_command_list_string)s"
 
2848
 
 
2849
    def __init__(self, mail_command_list):
 
2850
        mail_command_list_string = ', '.join(mail_command_list)
 
2851
        BzrError.__init__(self, mail_command_list=mail_command_list,
 
2852
                          mail_command_list_string=mail_command_list_string)
 
2853
 
 
2854
class SMTPConnectionRefused(SMTPError):
 
2855
 
 
2856
    _fmt = "SMTP connection to %(host)s refused"
 
2857
 
 
2858
    def __init__(self, error, host):
 
2859
        self.error = error
 
2860
        self.host = host
 
2861
 
 
2862
 
 
2863
class DefaultSMTPConnectionRefused(SMTPConnectionRefused):
 
2864
 
 
2865
    _fmt = "Please specify smtp_server.  No server at default %(host)s."
 
2866
 
 
2867
 
 
2868
class BzrDirError(BzrError):
 
2869
 
 
2870
    def __init__(self, bzrdir):
 
2871
        import bzrlib.urlutils as urlutils
 
2872
        display_url = urlutils.unescape_for_display(bzrdir.user_url,
 
2873
                                                    'ascii')
 
2874
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
 
2875
 
 
2876
 
 
2877
class UnsyncedBranches(BzrDirError):
 
2878
 
 
2879
    _fmt = ("'%(display_url)s' is not in sync with %(target_url)s.  See"
 
2880
            " bzr help sync-for-reconfigure.")
 
2881
 
 
2882
    def __init__(self, bzrdir, target_branch):
 
2883
        BzrDirError.__init__(self, bzrdir)
 
2884
        import bzrlib.urlutils as urlutils
 
2885
        self.target_url = urlutils.unescape_for_display(target_branch.base,
 
2886
                                                        'ascii')
 
2887
 
 
2888
 
 
2889
class AlreadyBranch(BzrDirError):
 
2890
 
 
2891
    _fmt = "'%(display_url)s' is already a branch."
 
2892
 
 
2893
 
 
2894
class AlreadyTree(BzrDirError):
 
2895
 
 
2896
    _fmt = "'%(display_url)s' is already a tree."
 
2897
 
 
2898
 
 
2899
class AlreadyCheckout(BzrDirError):
 
2900
 
 
2901
    _fmt = "'%(display_url)s' is already a checkout."
 
2902
 
 
2903
 
 
2904
class AlreadyLightweightCheckout(BzrDirError):
 
2905
 
 
2906
    _fmt = "'%(display_url)s' is already a lightweight checkout."
 
2907
 
 
2908
 
 
2909
class AlreadyUsingShared(BzrDirError):
 
2910
 
 
2911
    _fmt = "'%(display_url)s' is already using a shared repository."
 
2912
 
 
2913
 
 
2914
class AlreadyStandalone(BzrDirError):
 
2915
 
 
2916
    _fmt = "'%(display_url)s' is already standalone."
 
2917
 
 
2918
 
 
2919
class AlreadyWithTrees(BzrDirError):
 
2920
 
 
2921
    _fmt = ("Shared repository '%(display_url)s' already creates "
 
2922
            "working trees.")
 
2923
 
 
2924
 
 
2925
class AlreadyWithNoTrees(BzrDirError):
 
2926
 
 
2927
    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
 
2928
            "working trees.")
 
2929
 
 
2930
 
 
2931
class ReconfigurationNotSupported(BzrDirError):
 
2932
 
 
2933
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
 
2934
 
 
2935
 
 
2936
class NoBindLocation(BzrDirError):
 
2937
 
 
2938
    _fmt = "No location could be found to bind to at %(display_url)s."
 
2939
 
 
2940
 
 
2941
class UncommittedChanges(BzrError):
 
2942
 
 
2943
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
 
2944
            ' (See bzr status).%(more)s')
 
2945
 
 
2946
    def __init__(self, tree, more=None):
 
2947
        if more is None:
 
2948
            more = ''
 
2949
        else:
 
2950
            more = ' ' + more
 
2951
        import bzrlib.urlutils as urlutils
 
2952
        user_url = getattr(tree, "user_url", None)
 
2953
        if user_url is None:
 
2954
            display_url = str(tree)
 
2955
        else:
 
2956
            display_url = urlutils.unescape_for_display(user_url, 'ascii')
 
2957
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
 
2958
 
 
2959
 
 
2960
class ShelvedChanges(UncommittedChanges):
 
2961
 
 
2962
    _fmt = ('Working tree "%(display_url)s" has shelved changes'
 
2963
            ' (See bzr shelve --list).%(more)s')
 
2964
 
 
2965
 
 
2966
class MissingTemplateVariable(BzrError):
 
2967
 
 
2968
    _fmt = 'Variable {%(name)s} is not available.'
 
2969
 
 
2970
    def __init__(self, name):
 
2971
        self.name = name
 
2972
 
 
2973
 
 
2974
class NoTemplate(BzrError):
 
2975
 
 
2976
    _fmt = 'No template specified.'
 
2977
 
 
2978
 
 
2979
class UnableCreateSymlink(BzrError):
 
2980
 
 
2981
    _fmt = 'Unable to create symlink %(path_str)son this platform'
 
2982
 
 
2983
    def __init__(self, path=None):
 
2984
        path_str = ''
 
2985
        if path:
 
2986
            try:
 
2987
                path_str = repr(str(path))
 
2988
            except UnicodeEncodeError:
 
2989
                path_str = repr(path)
 
2990
            path_str += ' '
 
2991
        self.path_str = path_str
 
2992
 
 
2993
 
 
2994
class UnsupportedTimezoneFormat(BzrError):
 
2995
 
 
2996
    _fmt = ('Unsupported timezone format "%(timezone)s", '
 
2997
            'options are "utc", "original", "local".')
 
2998
 
 
2999
    def __init__(self, timezone):
 
3000
        self.timezone = timezone
 
3001
 
 
3002
 
 
3003
class CommandAvailableInPlugin(StandardError):
 
3004
 
 
3005
    internal_error = False
 
3006
 
 
3007
    def __init__(self, cmd_name, plugin_metadata, provider):
 
3008
 
 
3009
        self.plugin_metadata = plugin_metadata
 
3010
        self.cmd_name = cmd_name
 
3011
        self.provider = provider
 
3012
 
 
3013
    def __str__(self):
 
3014
 
 
3015
        _fmt = ('"%s" is not a standard bzr command. \n'
 
3016
                'However, the following official plugin provides this command: %s\n'
 
3017
                'You can install it by going to: %s'
 
3018
                % (self.cmd_name, self.plugin_metadata['name'],
 
3019
                    self.plugin_metadata['url']))
 
3020
 
 
3021
        return _fmt
 
3022
 
 
3023
 
 
3024
class NoPluginAvailable(BzrError):
 
3025
    pass
 
3026
 
 
3027
 
 
3028
class UnableEncodePath(BzrError):
 
3029
 
 
3030
    _fmt = ('Unable to encode %(kind)s path %(path)r in '
 
3031
            'user encoding %(user_encoding)s')
 
3032
 
 
3033
    def __init__(self, path, kind):
 
3034
        from bzrlib.osutils import get_user_encoding
 
3035
        self.path = path
 
3036
        self.kind = kind
 
3037
        self.user_encoding = osutils.get_user_encoding()
 
3038
 
 
3039
 
 
3040
class NoSuchConfig(BzrError):
 
3041
 
 
3042
    _fmt = ('The "%(config_id)s" configuration does not exist.')
 
3043
 
 
3044
    def __init__(self, config_id):
 
3045
        BzrError.__init__(self, config_id=config_id)
 
3046
 
 
3047
 
 
3048
class NoSuchConfigOption(BzrError):
 
3049
 
 
3050
    _fmt = ('The "%(option_name)s" configuration option does not exist.')
 
3051
 
 
3052
    def __init__(self, option_name):
 
3053
        BzrError.__init__(self, option_name=option_name)
 
3054
 
 
3055
 
 
3056
class NoSuchAlias(BzrError):
 
3057
 
 
3058
    _fmt = ('The alias "%(alias_name)s" does not exist.')
 
3059
 
 
3060
    def __init__(self, alias_name):
 
3061
        BzrError.__init__(self, alias_name=alias_name)
 
3062
 
 
3063
 
 
3064
class DirectoryLookupFailure(BzrError):
 
3065
    """Base type for lookup errors."""
 
3066
 
 
3067
    pass
 
3068
 
 
3069
 
 
3070
class InvalidLocationAlias(DirectoryLookupFailure):
 
3071
 
 
3072
    _fmt = '"%(alias_name)s" is not a valid location alias.'
 
3073
 
 
3074
    def __init__(self, alias_name):
 
3075
        DirectoryLookupFailure.__init__(self, alias_name=alias_name)
 
3076
 
 
3077
 
 
3078
class UnsetLocationAlias(DirectoryLookupFailure):
 
3079
 
 
3080
    _fmt = 'No %(alias_name)s location assigned.'
 
3081
 
 
3082
    def __init__(self, alias_name):
 
3083
        DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
 
3084
 
 
3085
 
 
3086
class CannotBindAddress(BzrError):
 
3087
 
 
3088
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
 
3089
 
 
3090
    def __init__(self, host, port, orig_error):
 
3091
        # nb: in python2.4 socket.error doesn't have a useful repr
 
3092
        BzrError.__init__(self, host=host, port=port,
 
3093
            orig_error=repr(orig_error.args))
 
3094
 
 
3095
 
 
3096
class UnknownRules(BzrError):
 
3097
 
 
3098
    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
 
3099
 
 
3100
    def __init__(self, unknowns):
 
3101
        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
 
3102
 
 
3103
 
 
3104
class HookFailed(BzrError):
 
3105
    """Raised when a pre_change_branch_tip hook function fails anything other
 
3106
    than TipChangeRejected.
 
3107
 
 
3108
    Note that this exception is no longer raised, and the import is only left
 
3109
    to be nice to code which might catch it in a plugin.
 
3110
    """
 
3111
 
 
3112
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
 
3113
            "%(traceback_text)s%(exc_value)s")
 
3114
 
 
3115
    def __init__(self, hook_stage, hook_name, exc_info, warn=True):
 
3116
        if warn:
 
3117
            symbol_versioning.warn("BzrError HookFailed has been deprecated "
 
3118
                "as of bzrlib 2.1.", DeprecationWarning, stacklevel=2)
 
3119
        import traceback
 
3120
        self.hook_stage = hook_stage
 
3121
        self.hook_name = hook_name
 
3122
        self.exc_info = exc_info
 
3123
        self.exc_type = exc_info[0]
 
3124
        self.exc_value = exc_info[1]
 
3125
        self.exc_tb = exc_info[2]
 
3126
        self.traceback_text = ''.join(traceback.format_tb(self.exc_tb))
 
3127
 
 
3128
 
 
3129
class TipChangeRejected(BzrError):
 
3130
    """A pre_change_branch_tip hook function may raise this to cleanly and
 
3131
    explicitly abort a change to a branch tip.
 
3132
    """
 
3133
 
 
3134
    _fmt = u"Tip change rejected: %(msg)s"
 
3135
 
 
3136
    def __init__(self, msg):
 
3137
        self.msg = msg
 
3138
 
 
3139
 
 
3140
class ShelfCorrupt(BzrError):
 
3141
 
 
3142
    _fmt = "Shelf corrupt."
 
3143
 
 
3144
 
 
3145
class DecompressCorruption(BzrError):
 
3146
 
 
3147
    _fmt = "Corruption while decompressing repository file%(orig_error)s"
 
3148
 
 
3149
    def __init__(self, orig_error=None):
 
3150
        if orig_error is not None:
 
3151
            self.orig_error = ", %s" % (orig_error,)
 
3152
        else:
 
3153
            self.orig_error = ""
 
3154
        BzrError.__init__(self)
 
3155
 
 
3156
 
 
3157
class NoSuchShelfId(BzrError):
 
3158
 
 
3159
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
 
3160
 
 
3161
    def __init__(self, shelf_id):
 
3162
        BzrError.__init__(self, shelf_id=shelf_id)
 
3163
 
 
3164
 
 
3165
class InvalidShelfId(BzrError):
 
3166
 
 
3167
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
 
3168
 
 
3169
    def __init__(self, invalid_id):
 
3170
        BzrError.__init__(self, invalid_id=invalid_id)
 
3171
 
 
3172
 
 
3173
class JailBreak(BzrError):
 
3174
 
 
3175
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
 
3176
 
 
3177
    def __init__(self, url):
 
3178
        BzrError.__init__(self, url=url)
 
3179
 
 
3180
 
 
3181
class UserAbort(BzrError):
 
3182
 
 
3183
    _fmt = 'The user aborted the operation.'
 
3184
 
 
3185
 
 
3186
class MustHaveWorkingTree(BzrError):
 
3187
 
 
3188
    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
 
3189
 
 
3190
    def __init__(self, format, url):
 
3191
        BzrError.__init__(self, format=format, url=url)
 
3192
 
 
3193
 
 
3194
class NoSuchView(BzrError):
 
3195
    """A view does not exist.
 
3196
    """
 
3197
 
 
3198
    _fmt = u"No such view: %(view_name)s."
 
3199
 
 
3200
    def __init__(self, view_name):
 
3201
        self.view_name = view_name
 
3202
 
 
3203
 
 
3204
class ViewsNotSupported(BzrError):
 
3205
    """Views are not supported by a tree format.
 
3206
    """
 
3207
 
 
3208
    _fmt = ("Views are not supported by %(tree)s;"
 
3209
            " use 'bzr upgrade' to change your tree to a later format.")
 
3210
 
 
3211
    def __init__(self, tree):
 
3212
        self.tree = tree
 
3213
 
 
3214
 
 
3215
class FileOutsideView(BzrError):
 
3216
 
 
3217
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
 
3218
            '%(view_str)s')
 
3219
 
 
3220
    def __init__(self, file_name, view_files):
 
3221
        self.file_name = file_name
 
3222
        self.view_str = ", ".join(view_files)
 
3223
 
 
3224
 
 
3225
class UnresumableWriteGroup(BzrError):
 
3226
 
 
3227
    _fmt = ("Repository %(repository)s cannot resume write group "
 
3228
            "%(write_groups)r: %(reason)s")
 
3229
 
 
3230
    internal_error = True
 
3231
 
 
3232
    def __init__(self, repository, write_groups, reason):
 
3233
        self.repository = repository
 
3234
        self.write_groups = write_groups
 
3235
        self.reason = reason
 
3236
 
 
3237
 
 
3238
class UnsuspendableWriteGroup(BzrError):
 
3239
 
 
3240
    _fmt = ("Repository %(repository)s cannot suspend a write group.")
 
3241
 
 
3242
    internal_error = True
 
3243
 
 
3244
    def __init__(self, repository):
 
3245
        self.repository = repository
 
3246
 
 
3247
 
 
3248
class LossyPushToSameVCS(BzrError):
 
3249
 
 
3250
    _fmt = ("Lossy push not possible between %(source_branch)r and "
 
3251
            "%(target_branch)r that are in the same VCS.")
 
3252
 
 
3253
    internal_error = True
 
3254
 
 
3255
    def __init__(self, source_branch, target_branch):
 
3256
        self.source_branch = source_branch
 
3257
        self.target_branch = target_branch
 
3258
 
 
3259
 
 
3260
class NoRoundtrippingSupport(BzrError):
 
3261
 
 
3262
    _fmt = ("Roundtripping is not supported between %(source_branch)r and "
 
3263
            "%(target_branch)r.")
 
3264
 
 
3265
    internal_error = True
 
3266
 
 
3267
    def __init__(self, source_branch, target_branch):
 
3268
        self.source_branch = source_branch
 
3269
        self.target_branch = target_branch
 
3270
 
 
3271
 
 
3272
class FileTimestampUnavailable(BzrError):
 
3273
 
 
3274
    _fmt = "The filestamp for %(path)s is not available."
 
3275
 
 
3276
    internal_error = True
 
3277
 
 
3278
    def __init__(self, path):
 
3279
        self.path = path
 
3280
 
 
3281
 
 
3282
class NoColocatedBranchSupport(BzrError):
 
3283
 
 
3284
    _fmt = ("%(bzrdir)r does not support co-located branches.")
 
3285
 
 
3286
    def __init__(self, bzrdir):
 
3287
        self.bzrdir = bzrdir
 
3288
 
 
3289
 
 
3290
class NoWhoami(BzrError):
 
3291
 
 
3292
    _fmt = ('Unable to determine your name.\n'
 
3293
        "Please, set your name with the 'whoami' command.\n"
 
3294
        'E.g. bzr whoami "Your Name <name@example.com>"')
 
3295
 
 
3296
 
 
3297
class InvalidPattern(BzrError):
 
3298
 
 
3299
    _fmt = ('Invalid pattern(s) found. %(msg)s')
 
3300
 
 
3301
    def __init__(self, msg):
 
3302
        self.msg = msg
 
3303
 
 
3304
 
 
3305
class RecursiveBind(BzrError):
 
3306
 
 
3307
    _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
 
3308
        'Please use `bzr unbind` to fix.')
 
3309
 
 
3310
    def __init__(self, branch_url):
 
3311
        self.branch_url = branch_url
 
3312
 
 
3313
 
 
3314
# FIXME: I would prefer to define the config related exception classes in
 
3315
# config.py but the lazy import mechanism proscribes this -- vila 20101222
 
3316
class OptionExpansionLoop(BzrError):
 
3317
 
 
3318
    _fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
 
3319
 
 
3320
    def __init__(self, string, refs):
 
3321
        self.string = string
 
3322
        self.refs = '->'.join(refs)
 
3323
 
 
3324
 
 
3325
class ExpandingUnknownOption(BzrError):
 
3326
 
 
3327
    _fmt = 'Option %(name)s is not defined while expanding "%(string)s".'
 
3328
 
 
3329
    def __init__(self, name, string):
 
3330
        self.name = name
 
3331
        self.string = string
 
3332
 
 
3333
 
 
3334
class NoCompatibleInter(BzrError):
 
3335
 
 
3336
    _fmt = ('No compatible object available for operations from %(source)r '
 
3337
            'to %(target)r.')
 
3338
 
 
3339
    def __init__(self, source, target):
 
3340
        self.source = source
 
3341
        self.target = target
 
3342
 
 
3343
 
 
3344
class HpssVfsRequestNotAllowed(BzrError):
 
3345
 
 
3346
    _fmt = ("VFS requests over the smart server are not allowed. Encountered: "
 
3347
            "%(method)s, %(arguments)s.")
 
3348
 
 
3349
    def __init__(self, method, arguments):
 
3350
        self.method = method
 
3351
        self.arguments = arguments