← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Jelmer Vernooij
  • Date: 2009-01-28 18:42:55 UTC
  • mto: This revision was merged to the branch mainline in revision 3968.
  • Revision ID: jelmer@samba.org-20090128184255-bdmklkvm83ltk191
https://launchpad.net/bugs/321183
Update NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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
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,
44
43
# 'unprintable'.
45
44
 
46
45
 
 
46
# return codes from the bzr program
 
47
EXIT_OK = 0
 
48
EXIT_ERROR = 3
 
49
EXIT_INTERNAL_ERROR = 4
 
50
 
 
51
 
47
52
class BzrError(StandardError):
48
53
    """
49
54
    Base class for errors raised by bzrlib.
50
55
 
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
 
56
    :cvar internal_error: if True this was probably caused by a bzr bug and
 
57
    should be displayed with a traceback; if False (or absent) this was
53
58
    probably a user or environment error and they don't need the gory details.
54
59
    (That can be overridden by -Derror on the command line.)
55
60
 
75
80
        parameters.
76
81
 
77
82
        :param msg: If given, this is the literal complete text for the error,
78
 
        not subject to expansion.
 
83
           not subject to expansion. 'msg' is used instead of 'message' because
 
84
           python evolved and, in 2.6, forbids the use of 'message'.
79
85
        """
80
86
        StandardError.__init__(self)
81
87
        if msg is not None:
87
93
            for key, value in kwds.items():
88
94
                setattr(self, key, value)
89
95
 
90
 
    def __str__(self):
 
96
    def _format(self):
91
97
        s = getattr(self, '_preformatted_string', None)
92
98
        if s is not None:
93
 
            # contains a preformatted message; must be cast to plain str
94
 
            return str(s)
 
99
            # contains a preformatted message
 
100
            return s
95
101
        try:
96
102
            fmt = self._get_format_string()
97
103
            if fmt:
98
 
                s = fmt % self.__dict__
 
104
                d = dict(self.__dict__)
 
105
                s = fmt % d
99
106
                # __str__() should always return a 'str' object
100
107
                # never a 'unicode' object.
101
 
                if isinstance(s, unicode):
102
 
                    return s.encode('utf8')
103
108
                return s
104
109
        except (AttributeError, TypeError, NameError, ValueError, KeyError), e:
105
 
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%s' \
 
110
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
106
111
                % (self.__class__.__name__,
107
112
                   self.__dict__,
108
113
                   getattr(self, '_fmt', None),
109
 
                   str(e))
 
114
                   e)
 
115
 
 
116
    def __unicode__(self):
 
117
        u = self._format()
 
118
        if isinstance(u, str):
 
119
            # Try decoding the str using the default encoding.
 
120
            u = unicode(u)
 
121
        elif not isinstance(u, unicode):
 
122
            # Try to make a unicode object from it, because __unicode__ must
 
123
            # return a unicode object.
 
124
            u = unicode(u)
 
125
        return u
 
126
 
 
127
    def __str__(self):
 
128
        s = self._format()
 
129
        if isinstance(s, unicode):
 
130
            s = s.encode('utf8')
 
131
        else:
 
132
            # __str__ must return a str.
 
133
            s = str(s)
 
134
        return s
 
135
 
 
136
    def __repr__(self):
 
137
        return '%s(%s)' % (self.__class__.__name__, str(self))
110
138
 
111
139
    def _get_format_string(self):
112
140
        """Return format string for this exception or None"""
125
153
               getattr(self, '_fmt', None),
126
154
               )
127
155
 
 
156
    def __eq__(self, other):
 
157
        if self.__class__ != other.__class__:
 
158
            return NotImplemented
 
159
        return self.__dict__ == other.__dict__
 
160
 
 
161
 
 
162
class InternalBzrError(BzrError):
 
163
    """Base class for errors that are internal in nature.
 
164
 
 
165
    This is a convenience class for errors that are internal. The
 
166
    internal_error attribute can still be altered in subclasses, if needed.
 
167
    Using this class is simply an easy way to get internal errors.
 
168
    """
 
169
 
 
170
    internal_error = True
 
171
 
128
172
 
129
173
class BzrNewError(BzrError):
130
174
    """Deprecated error base class."""
132
176
    # readable explanation
133
177
 
134
178
    def __init__(self, *args, **kwds):
135
 
        # XXX: Use the underlying BzrError to always generate the args attribute
136
 
        # if it doesn't exist.  We can't use super here, because exceptions are
137
 
        # old-style classes in python2.4 (but new in 2.5).  --bmc, 20060426
 
179
        # XXX: Use the underlying BzrError to always generate the args
 
180
        # attribute if it doesn't exist.  We can't use super here, because
 
181
        # exceptions are old-style classes in python2.4 (but new in 2.5).
 
182
        # --bmc, 20060426
138
183
        symbol_versioning.warn('BzrNewError was deprecated in bzr 0.13; '
139
 
             'please convert %s to use BzrError instead' 
 
184
             'please convert %s to use BzrError instead'
140
185
             % self.__class__.__name__,
141
186
             DeprecationWarning,
142
187
             stacklevel=2)
153
198
                return s.encode('utf8')
154
199
            return s
155
200
        except (TypeError, NameError, ValueError, KeyError), e:
156
 
            return 'Unprintable exception %s(%r): %s' \
 
201
            return 'Unprintable exception %s(%r): %r' \
157
202
                % (self.__class__.__name__,
158
 
                   self.__dict__, str(e))
 
203
                   self.__dict__, e)
159
204
 
160
205
 
161
206
class AlreadyBuilding(BzrError):
162
 
    
 
207
 
163
208
    _fmt = "The tree builder is already building a tree."
164
209
 
165
210
 
166
 
class BzrCheckError(BzrError):
167
 
    
168
 
    _fmt = "Internal check failed: %(message)s"
169
 
 
170
 
    internal_error = True
171
 
 
172
 
    def __init__(self, message):
173
 
        BzrError.__init__(self)
174
 
        self.message = message
175
 
 
176
 
 
177
 
class InvalidEntryName(BzrError):
 
211
class BranchError(BzrError):
 
212
    """Base class for concrete 'errors about a branch'."""
 
213
 
 
214
    def __init__(self, branch):
 
215
        BzrError.__init__(self, branch=branch)
 
216
 
 
217
 
 
218
class BzrCheckError(InternalBzrError):
 
219
 
 
220
    _fmt = "Internal check failed: %(msg)s"
 
221
 
 
222
    def __init__(self, msg):
 
223
        BzrError.__init__(self)
 
224
        self.msg = msg
 
225
 
 
226
 
 
227
class DirstateCorrupt(BzrError):
 
228
 
 
229
    _fmt = "The dirstate file (%(state)s) appears to be corrupt: %(msg)s"
 
230
 
 
231
    def __init__(self, state, msg):
 
232
        BzrError.__init__(self)
 
233
        self.state = state
 
234
        self.msg = msg
 
235
 
 
236
 
 
237
class DisabledMethod(InternalBzrError):
 
238
 
 
239
    _fmt = "The smart server method '%(class_name)s' is disabled."
 
240
 
 
241
    def __init__(self, class_name):
 
242
        BzrError.__init__(self)
 
243
        self.class_name = class_name
 
244
 
 
245
 
 
246
class IncompatibleAPI(BzrError):
 
247
 
 
248
    _fmt = 'The API for "%(api)s" is not compatible with "%(wanted)s". '\
 
249
        'It supports versions "%(minimum)s" to "%(current)s".'
 
250
 
 
251
    def __init__(self, api, wanted, minimum, current):
 
252
        self.api = api
 
253
        self.wanted = wanted
 
254
        self.minimum = minimum
 
255
        self.current = current
 
256
 
 
257
 
 
258
class InProcessTransport(BzrError):
 
259
 
 
260
    _fmt = "The transport '%(transport)s' is only accessible within this " \
 
261
        "process."
 
262
 
 
263
    def __init__(self, transport):
 
264
        self.transport = transport
 
265
 
 
266
 
 
267
class InvalidEntryName(InternalBzrError):
178
268
    
179
269
    _fmt = "Invalid entry name: %(name)s"
180
270
 
181
 
    internal_error = True
182
 
 
183
271
    def __init__(self, name):
184
272
        BzrError.__init__(self)
185
273
        self.name = name
204
292
        self.revision_id = revision_id
205
293
        self.branch = branch
206
294
 
 
295
 
207
296
class ReservedId(BzrError):
208
297
 
209
298
    _fmt = "Reserved revision-id {%(revision_id)s}"
211
300
    def __init__(self, revision_id):
212
301
        self.revision_id = revision_id
213
302
 
 
303
 
 
304
class RootMissing(InternalBzrError):
 
305
 
 
306
    _fmt = ("The root entry of a tree must be the first entry supplied to "
 
307
        "record_entry_contents.")
 
308
 
 
309
 
 
310
class NoPublicBranch(BzrError):
 
311
 
 
312
    _fmt = 'There is no public branch set for "%(branch_url)s".'
 
313
 
 
314
    def __init__(self, branch):
 
315
        import bzrlib.urlutils as urlutils
 
316
        public_location = urlutils.unescape_for_display(branch.base, 'ascii')
 
317
        BzrError.__init__(self, branch_url=public_location)
 
318
 
 
319
 
 
320
class NoHelpTopic(BzrError):
 
321
 
 
322
    _fmt = ("No help could be found for '%(topic)s'. "
 
323
        "Please use 'bzr help topics' to obtain a list of topics.")
 
324
 
 
325
    def __init__(self, topic):
 
326
        self.topic = topic
 
327
 
 
328
 
214
329
class NoSuchId(BzrError):
215
330
 
216
 
    _fmt = "The file id %(file_id)s is not present in the tree %(tree)s."
 
331
    _fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
217
332
    
218
333
    def __init__(self, tree, file_id):
219
334
        BzrError.__init__(self)
221
336
        self.tree = tree
222
337
 
223
338
 
224
 
class InventoryModified(BzrError):
225
 
 
226
 
    _fmt = ("The current inventory for the tree %(tree)r has been modified, "
227
 
            "so a clean inventory cannot be read without data loss.")
228
 
 
229
 
    internal_error = True
 
339
class NoSuchIdInRepository(NoSuchId):
 
340
 
 
341
    _fmt = ('The file id "%(file_id)s" is not present in the repository'
 
342
            ' %(repository)r')
 
343
 
 
344
    def __init__(self, repository, file_id):
 
345
        BzrError.__init__(self, repository=repository, file_id=file_id)
 
346
 
 
347
 
 
348
class NotStacked(BranchError):
 
349
 
 
350
    _fmt = "The branch '%(branch)s' is not stacked."
 
351
 
 
352
 
 
353
class InventoryModified(InternalBzrError):
 
354
 
 
355
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
 
356
            " so a clean inventory cannot be read without data loss.")
230
357
 
231
358
    def __init__(self, tree):
232
359
        self.tree = tree
234
361
 
235
362
class NoWorkingTree(BzrError):
236
363
 
237
 
    _fmt = "No WorkingTree exists for %(base)s."
 
364
    _fmt = 'No WorkingTree exists for "%(base)s".'
238
365
    
239
366
    def __init__(self, base):
240
367
        BzrError.__init__(self)
254
381
        self.url = url
255
382
 
256
383
 
257
 
class WorkingTreeAlreadyPopulated(BzrError):
258
 
 
259
 
    _fmt = """Working tree already populated in %(base)s"""
260
 
 
261
 
    internal_error = True
 
384
class WorkingTreeAlreadyPopulated(InternalBzrError):
 
385
 
 
386
    _fmt = 'Working tree already populated in "%(base)s"'
262
387
 
263
388
    def __init__(self, base):
264
389
        self.base = base
265
390
 
 
391
 
266
392
class BzrCommandError(BzrError):
267
393
    """Error from user command"""
268
394
 
269
 
    internal_error = False
270
 
 
271
395
    # Error from malformed user command; please avoid raising this as a
272
396
    # generic exception not caused by user input.
273
397
    #
275
399
    # are not intended to be caught anyway.  UI code need not subclass
276
400
    # BzrCommandError, and non-UI code should not throw a subclass of
277
401
    # BzrCommandError.  ADHB 20051211
278
 
    def __init__(self, msg):
279
 
        # Object.__str__() must return a real string
280
 
        # returning a Unicode string is a python error.
281
 
        if isinstance(msg, unicode):
282
 
            self.msg = msg.encode('utf8')
283
 
        else:
284
 
            self.msg = msg
285
 
 
286
 
    def __str__(self):
287
 
        return self.msg
288
402
 
289
403
 
290
404
class NotWriteLocked(BzrError):
300
414
    _fmt = "Error in command line options"
301
415
 
302
416
 
 
417
class BadIndexFormatSignature(BzrError):
 
418
 
 
419
    _fmt = "%(value)s is not an index of type %(_type)s."
 
420
 
 
421
    def __init__(self, value, _type):
 
422
        BzrError.__init__(self)
 
423
        self.value = value
 
424
        self._type = _type
 
425
 
 
426
 
 
427
class BadIndexData(BzrError):
 
428
 
 
429
    _fmt = "Error in data for index %(value)s."
 
430
 
 
431
    def __init__(self, value):
 
432
        BzrError.__init__(self)
 
433
        self.value = value
 
434
 
 
435
 
 
436
class BadIndexDuplicateKey(BzrError):
 
437
 
 
438
    _fmt = "The key '%(key)s' is already in index '%(index)s'."
 
439
 
 
440
    def __init__(self, key, index):
 
441
        BzrError.__init__(self)
 
442
        self.key = key
 
443
        self.index = index
 
444
 
 
445
 
 
446
class BadIndexKey(BzrError):
 
447
 
 
448
    _fmt = "The key '%(key)s' is not a valid key."
 
449
 
 
450
    def __init__(self, key):
 
451
        BzrError.__init__(self)
 
452
        self.key = key
 
453
 
 
454
 
 
455
class BadIndexOptions(BzrError):
 
456
 
 
457
    _fmt = "Could not parse options for index %(value)s."
 
458
 
 
459
    def __init__(self, value):
 
460
        BzrError.__init__(self)
 
461
        self.value = value
 
462
 
 
463
 
 
464
class BadIndexValue(BzrError):
 
465
 
 
466
    _fmt = "The value '%(value)s' is not a valid value."
 
467
 
 
468
    def __init__(self, value):
 
469
        BzrError.__init__(self)
 
470
        self.value = value
 
471
 
 
472
 
303
473
class BadOptionValue(BzrError):
304
474
 
305
475
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
315
485
 
316
486
# XXX: Should be unified with TransportError; they seem to represent the
317
487
# same thing
 
488
# RBC 20060929: I think that unifiying with TransportError would be a mistake
 
489
# - this is finer than a TransportError - and more useful as such. It 
 
490
# differentiates between 'transport has failed' and 'operation on a transport
 
491
# has failed.'
318
492
class PathError(BzrError):
319
493
    
320
494
    _fmt = "Generic path error: %(path)r%(extra)s)"
342
516
    """Used when renaming and both source and dest exist."""
343
517
 
344
518
    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
345
 
         "%(extra)s")
 
519
            " (Use --after to tell bzr about a rename that has already"
 
520
            " happened)%(extra)s")
346
521
 
347
522
    def __init__(self, source, dest, extra=None):
348
523
        BzrError.__init__(self)
356
531
 
357
532
class NotADirectory(PathError):
358
533
 
359
 
    _fmt = "%(path)r is not a directory %(extra)s"
 
534
    _fmt = '"%(path)s" is not a directory %(extra)s'
360
535
 
361
536
 
362
537
class NotInWorkingDirectory(PathError):
363
538
 
364
 
    _fmt = "%(path)r is not in the working directory %(extra)s"
 
539
    _fmt = '"%(path)s" is not in the working directory %(extra)s'
365
540
 
366
541
 
367
542
class DirectoryNotEmpty(PathError):
368
543
 
369
 
    _fmt = "Directory not empty: %(path)r%(extra)s"
370
 
 
371
 
 
372
 
class ReadingCompleted(BzrError):
 
544
    _fmt = 'Directory not empty: "%(path)s"%(extra)s'
 
545
 
 
546
 
 
547
class HardLinkNotSupported(PathError):
 
548
 
 
549
    _fmt = 'Hard-linking "%(path)s" is not supported'
 
550
 
 
551
 
 
552
class ReadingCompleted(InternalBzrError):
373
553
    
374
554
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
375
555
            "called upon it - the request has been completed and no more "
376
556
            "data may be read.")
377
557
 
378
 
    internal_error = True
379
 
 
380
558
    def __init__(self, request):
381
559
        self.request = request
382
560
 
383
561
 
384
562
class ResourceBusy(PathError):
385
563
 
386
 
    _fmt = "Device or resource busy: %(path)r%(extra)s"
 
564
    _fmt = 'Device or resource busy: "%(path)s"%(extra)s'
387
565
 
388
566
 
389
567
class PermissionDenied(PathError):
390
568
 
391
 
    _fmt = "Permission denied: %(path)r%(extra)s"
 
569
    _fmt = 'Permission denied: "%(path)s"%(extra)s'
392
570
 
393
571
 
394
572
class InvalidURL(PathError):
395
573
 
396
 
    _fmt = "Invalid url supplied to transport: %(path)r%(extra)s"
 
574
    _fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
397
575
 
398
576
 
399
577
class InvalidURLJoin(PathError):
400
578
 
401
 
    _fmt = "Invalid URL join request: %(args)s%(extra)s"
402
 
 
403
 
    def __init__(self, msg, base, args):
404
 
        PathError.__init__(self, base, msg)
405
 
        self.args = [base] + list(args)
 
579
    _fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"
 
580
 
 
581
    def __init__(self, reason, base, join_args):
 
582
        self.reason = reason
 
583
        self.base = base
 
584
        self.join_args = join_args
 
585
        PathError.__init__(self, base, reason)
 
586
 
 
587
 
 
588
class InvalidRebaseURLs(PathError):
 
589
 
 
590
    _fmt = "URLs differ by more than path: %(from_)r and %(to)r"
 
591
 
 
592
    def __init__(self, from_, to):
 
593
        self.from_ = from_
 
594
        self.to = to
 
595
        PathError.__init__(self, from_, 'URLs differ by more than path.')
 
596
 
 
597
 
 
598
class UnavailableRepresentation(InternalBzrError):
 
599
 
 
600
    _fmt = ("The encoding '%(wanted)s' is not available for key %(key)s which "
 
601
        "is encoded as '%(native)s'.")
 
602
 
 
603
    def __init__(self, key, wanted, native):
 
604
        InternalBzrError.__init__(self)
 
605
        self.wanted = wanted
 
606
        self.native = native
 
607
        self.key = key
406
608
 
407
609
 
408
610
class UnknownHook(BzrError):
423
625
        PathError.__init__(self, url, extra=extra)
424
626
 
425
627
 
 
628
class UnstackableBranchFormat(BzrError):
 
629
 
 
630
    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
 
631
        "You will need to upgrade the branch to permit branch stacking.")
 
632
 
 
633
    def __init__(self, format, url):
 
634
        BzrError.__init__(self)
 
635
        self.format = format
 
636
        self.url = url
 
637
 
 
638
 
 
639
class UnstackableRepositoryFormat(BzrError):
 
640
 
 
641
    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
 
642
        "You will need to upgrade the repository to permit branch stacking.")
 
643
 
 
644
    def __init__(self, format, url):
 
645
        BzrError.__init__(self)
 
646
        self.format = format
 
647
        self.url = url
 
648
 
 
649
 
 
650
class ReadError(PathError):
 
651
    
 
652
    _fmt = """Error reading from %(path)r."""
 
653
 
 
654
 
426
655
class ShortReadvError(PathError):
427
656
 
428
 
    _fmt = "readv() read %(actual)s bytes rather than %(length)s bytes at %(offset)s for %(path)s%(extra)s"
 
657
    _fmt = ('readv() read %(actual)s bytes rather than %(length)s bytes'
 
658
            ' at %(offset)s for "%(path)s"%(extra)s')
429
659
 
430
660
    internal_error = True
431
661
 
436
666
        self.actual = actual
437
667
 
438
668
 
439
 
class PathNotChild(BzrError):
 
669
class PathNotChild(PathError):
440
670
 
441
 
    _fmt = "Path %(path)r is not a child of path %(base)r%(extra)s"
 
671
    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
442
672
 
443
673
    internal_error = True
444
674
 
454
684
 
455
685
class InvalidNormalization(PathError):
456
686
 
457
 
    _fmt = "Path %(path)r is not unicode normalized"
 
687
    _fmt = 'Path "%(path)s" is not unicode normalized'
458
688
 
459
689
 
460
690
# TODO: This is given a URL; we try to unescape it but doing that from inside
462
692
# TODO: Probably this behavior of should be a common superclass 
463
693
class NotBranchError(PathError):
464
694
 
465
 
    _fmt = "Not a branch: %(path)s"
 
695
    _fmt = 'Not a branch: "%(path)s".'
466
696
 
467
697
    def __init__(self, path):
468
698
       import bzrlib.urlutils as urlutils
469
699
       self.path = urlutils.unescape_for_display(path, 'ascii')
470
700
 
471
701
 
 
702
class NoSubmitBranch(PathError):
 
703
 
 
704
    _fmt = 'No submit branch available for branch "%(path)s"'
 
705
 
 
706
    def __init__(self, branch):
 
707
       import bzrlib.urlutils as urlutils
 
708
       self.path = urlutils.unescape_for_display(branch.base, 'ascii')
 
709
 
 
710
 
472
711
class AlreadyBranchError(PathError):
473
712
 
474
 
    _fmt = "Already a branch: %(path)s."
 
713
    _fmt = 'Already a branch: "%(path)s".'
475
714
 
476
715
 
477
716
class BranchExistsWithoutWorkingTree(PathError):
478
717
 
479
 
    _fmt = "Directory contains a branch, but no working tree \
480
 
(use bzr checkout if you wish to build a working tree): %(path)s"
 
718
    _fmt = 'Directory contains a branch, but no working tree \
 
719
(use bzr checkout if you wish to build a working tree): "%(path)s"'
481
720
 
482
721
 
483
722
class AtomicFileAlreadyClosed(PathError):
484
723
 
485
 
    _fmt = "'%(function)s' called on an AtomicFile after it was closed: %(path)s"
 
724
    _fmt = ('"%(function)s" called on an AtomicFile after it was closed:'
 
725
            ' "%(path)s"')
486
726
 
487
727
    def __init__(self, path, function):
488
728
        PathError.__init__(self, path=path, extra=None)
491
731
 
492
732
class InaccessibleParent(PathError):
493
733
 
494
 
    _fmt = "Parent not accessible given base %(base)s and relative path %(path)s"
 
734
    _fmt = ('Parent not accessible given base "%(base)s" and'
 
735
            ' relative path "%(path)s"')
495
736
 
496
737
    def __init__(self, path, base):
497
738
        PathError.__init__(self, path)
500
741
 
501
742
class NoRepositoryPresent(BzrError):
502
743
 
503
 
    _fmt = "No repository present: %(path)r"
 
744
    _fmt = 'No repository present: "%(path)s"'
504
745
    def __init__(self, bzrdir):
505
746
        BzrError.__init__(self)
506
747
        self.path = bzrdir.transport.clone('..').base
508
749
 
509
750
class FileInWrongBranch(BzrError):
510
751
 
511
 
    _fmt = "File %(path)s in not in branch %(branch_base)s."
 
752
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
512
753
 
513
754
    def __init__(self, branch, path):
514
755
        BzrError.__init__(self)
518
759
 
519
760
 
520
761
class UnsupportedFormatError(BzrError):
521
 
    
522
 
    _fmt = "Unsupported branch format: %(format)s"
 
762
 
 
763
    _fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
523
764
 
524
765
 
525
766
class UnknownFormatError(BzrError):
526
767
    
527
 
    _fmt = "Unknown branch format: %(format)r"
 
768
    _fmt = "Unknown %(kind)s format: %(format)r"
 
769
 
 
770
    def __init__(self, format, kind='branch'):
 
771
        self.kind = kind
 
772
        self.format = format
528
773
 
529
774
 
530
775
class IncompatibleFormat(BzrError):
537
782
        self.bzrdir = bzrdir_format
538
783
 
539
784
 
 
785
class IncompatibleRepositories(BzrError):
 
786
 
 
787
    _fmt = "%(target)s\n" \
 
788
            "is not compatible with\n" \
 
789
            "%(source)s\n" \
 
790
            "%(details)s"
 
791
 
 
792
    def __init__(self, source, target, details=None):
 
793
        if details is None:
 
794
            details = "(no details)"
 
795
        BzrError.__init__(self, target=target, source=source, details=details)
 
796
 
 
797
 
540
798
class IncompatibleRevision(BzrError):
541
799
    
542
800
    _fmt = "Revision is not compatible with %(repo_format)s"
549
807
class AlreadyVersionedError(BzrError):
550
808
    """Used when a path is expected not to be versioned, but it is."""
551
809
 
552
 
    _fmt = "%(context_info)s%(path)s is already versioned"
 
810
    _fmt = "%(context_info)s%(path)s is already versioned."
553
811
 
554
812
    def __init__(self, path, context_info=None):
555
813
        """Construct a new AlreadyVersionedError.
570
828
class NotVersionedError(BzrError):
571
829
    """Used when a path is expected to be versioned, but it is not."""
572
830
 
573
 
    _fmt = "%(context_info)s%(path)s is not versioned"
 
831
    _fmt = "%(context_info)s%(path)s is not versioned."
574
832
 
575
833
    def __init__(self, path, context_info=None):
576
834
        """Construct a new NotVersionedError.
621
879
 
622
880
class BadFileKindError(BzrError):
623
881
 
624
 
    _fmt = "Cannot operate on %(filename)s of unsupported kind %(kind)s"
 
882
    _fmt = 'Cannot operate on "%(filename)s" of unsupported kind "%(kind)s"'
 
883
 
 
884
    def __init__(self, filename, kind):
 
885
        BzrError.__init__(self, filename=filename, kind=kind)
 
886
 
 
887
 
 
888
class BadFilenameEncoding(BzrError):
 
889
 
 
890
    _fmt = ('Filename %(filename)r is not valid in your current filesystem'
 
891
            ' encoding %(fs_encoding)s')
 
892
 
 
893
    def __init__(self, filename, fs_encoding):
 
894
        BzrError.__init__(self)
 
895
        self.filename = filename
 
896
        self.fs_encoding = fs_encoding
625
897
 
626
898
 
627
899
class ForbiddenControlFileError(BzrError):
628
900
 
629
 
    _fmt = "Cannot operate on %(filename)s because it is a control file"
630
 
 
631
 
 
632
 
class LockError(BzrError):
633
 
 
634
 
    _fmt = "Lock error: %(message)s"
635
 
 
636
 
    internal_error = True
 
901
    _fmt = 'Cannot operate on "%(filename)s" because it is a control file'
 
902
 
 
903
 
 
904
class LockError(InternalBzrError):
 
905
 
 
906
    _fmt = "Lock error: %(msg)s"
637
907
 
638
908
    # All exceptions from the lock/unlock functions should be from
639
909
    # this exception class.  They will be translated as necessary. The
641
911
    #
642
912
    # New code should prefer to raise specific subclasses
643
913
    def __init__(self, message):
644
 
        self.message = message
 
914
        # Python 2.5 uses a slot for StandardError.message,
 
915
        # so use a different variable name.  We now work around this in
 
916
        # BzrError.__str__, but this member name is kept for compatability.
 
917
        self.msg = message
645
918
 
646
919
 
647
920
class LockActive(LockError):
674
947
 
675
948
    _fmt = "A write attempt was made in a read only transaction on %(obj)s"
676
949
 
 
950
    # TODO: There should also be an error indicating that you need a write
 
951
    # lock and don't have any lock at all... mbp 20070226
 
952
 
677
953
    def __init__(self, obj):
678
954
        self.obj = obj
679
955
 
680
956
 
 
957
class LockFailed(LockError):
 
958
 
 
959
    internal_error = False
 
960
 
 
961
    _fmt = "Cannot lock %(lock)s: %(why)s"
 
962
 
 
963
    def __init__(self, lock, why):
 
964
        LockError.__init__(self, '')
 
965
        self.lock = lock
 
966
        self.why = why
 
967
 
 
968
 
681
969
class OutSideTransaction(BzrError):
682
970
 
683
 
    _fmt = "A transaction related operation was attempted after the transaction finished."
 
971
    _fmt = ("A transaction related operation was attempted after"
 
972
            " the transaction finished.")
684
973
 
685
974
 
686
975
class ObjectNotLocked(LockError):
704
993
 
705
994
class UnlockableTransport(LockError):
706
995
 
 
996
    internal_error = False
 
997
 
707
998
    _fmt = "Cannot lock: transport is read only: %(transport)s"
708
999
 
709
1000
    def __init__(self, transport):
712
1003
 
713
1004
class LockContention(LockError):
714
1005
 
715
 
    _fmt = "Could not acquire lock %(lock)s"
 
1006
    _fmt = 'Could not acquire lock "%(lock)s"'
716
1007
    # TODO: show full url for lock, combining the transport and relative
717
1008
    # bits?
718
1009
 
719
1010
    internal_error = False
720
 
    
 
1011
 
721
1012
    def __init__(self, lock):
722
1013
        self.lock = lock
723
1014
 
724
1015
 
725
1016
class LockBroken(LockError):
726
1017
 
727
 
    _fmt = "Lock was broken while still open: %(lock)s - check storage consistency!"
 
1018
    _fmt = ("Lock was broken while still open: %(lock)s"
 
1019
            " - check storage consistency!")
728
1020
 
729
1021
    internal_error = False
730
1022
 
734
1026
 
735
1027
class LockBreakMismatch(LockError):
736
1028
 
737
 
    _fmt = "Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)r, wanted to break %(target)r"
 
1029
    _fmt = ("Lock was released and re-acquired before being broken:"
 
1030
            " %(lock)s: held by %(holder)r, wanted to break %(target)r")
738
1031
 
739
1032
    internal_error = False
740
1033
 
754
1047
        self.lock = lock
755
1048
 
756
1049
 
 
1050
class TokenLockingNotSupported(LockError):
 
1051
 
 
1052
    _fmt = "The object %(obj)s does not support token specifying a token when locking."
 
1053
 
 
1054
    def __init__(self, obj):
 
1055
        self.obj = obj
 
1056
 
 
1057
 
 
1058
class TokenMismatch(LockBroken):
 
1059
 
 
1060
    _fmt = "The lock token %(given_token)r does not match lock token %(lock_token)r."
 
1061
 
 
1062
    internal_error = True
 
1063
 
 
1064
    def __init__(self, given_token, lock_token):
 
1065
        self.given_token = given_token
 
1066
        self.lock_token = lock_token
 
1067
 
 
1068
 
757
1069
class PointlessCommit(BzrError):
758
1070
 
759
1071
    _fmt = "No changes to commit"
760
1072
 
761
1073
 
 
1074
class CannotCommitSelectedFileMerge(BzrError):
 
1075
 
 
1076
    _fmt = 'Selected-file commit of merges is not supported yet:'\
 
1077
        ' files %(files_str)s'
 
1078
 
 
1079
    def __init__(self, files):
 
1080
        files_str = ', '.join(files)
 
1081
        BzrError.__init__(self, files=files, files_str=files_str)
 
1082
 
 
1083
 
 
1084
class BadCommitMessageEncoding(BzrError):
 
1085
 
 
1086
    _fmt = 'The specified commit message contains characters unsupported by '\
 
1087
        'the current encoding.'
 
1088
 
 
1089
 
762
1090
class UpgradeReadonly(BzrError):
763
1091
 
764
1092
    _fmt = "Upgrade URL cannot work with readonly URLs."
778
1106
    _fmt = "Commit refused because there are unknowns in the tree."
779
1107
 
780
1108
 
781
 
class NoSuchRevision(BzrError):
782
 
 
783
 
    _fmt = "Branch %(branch)s has no revision %(revision)s"
784
 
 
785
 
    internal_error = True
 
1109
class NoSuchRevision(InternalBzrError):
 
1110
 
 
1111
    _fmt = "%(branch)s has no revision %(revision)s"
786
1112
 
787
1113
    def __init__(self, branch, revision):
 
1114
        # 'branch' may sometimes be an internal object like a KnitRevisionStore
788
1115
        BzrError.__init__(self, branch=branch, revision=revision)
789
1116
 
790
1117
 
791
 
class NotLeftParentDescendant(BzrError):
792
 
 
793
 
    _fmt = "Revision %(old_revision)s is not the left parent of"\
794
 
        " %(new_revision)s, but branch %(branch_location)s expects this"
795
 
 
796
 
    internal_error = True
797
 
 
798
 
    def __init__(self, branch, old_revision, new_revision):
799
 
        BzrError.__init__(self, branch_location=branch.base,
800
 
                          old_revision=old_revision,
801
 
                          new_revision=new_revision)
 
1118
class RangeInChangeOption(BzrError):
 
1119
 
 
1120
    _fmt = "Option --change does not accept revision ranges"
802
1121
 
803
1122
 
804
1123
class NoSuchRevisionSpec(BzrError):
812
1131
class NoSuchRevisionInTree(NoSuchRevision):
813
1132
    """When using Tree.revision_tree, and the revision is not accessible."""
814
1133
    
815
 
    _fmt = "The revision id %(revision_id)s is not present in the tree %(tree)s."
 
1134
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
816
1135
 
817
1136
    def __init__(self, tree, revision_id):
818
1137
        BzrError.__init__(self)
822
1141
 
823
1142
class InvalidRevisionSpec(BzrError):
824
1143
 
825
 
    _fmt = "Requested revision: %(spec)r does not exist in branch: %(branch)s%(extra)s"
 
1144
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
 
1145
            " %(branch)s%(extra)s")
826
1146
 
827
1147
    def __init__(self, spec, branch, extra=None):
828
1148
        BzrError.__init__(self, branch=branch, spec=spec)
839
1159
 
840
1160
class AppendRevisionsOnlyViolation(BzrError):
841
1161
 
842
 
    _fmt = 'Operation denied because it would change the main history, '\
843
 
           'which is not permitted by the append_revisions_only setting on'\
844
 
           ' branch "%(location)s".'
 
1162
    _fmt = ('Operation denied because it would change the main history,'
 
1163
           ' which is not permitted by the append_revisions_only setting on'
 
1164
           ' branch "%(location)s".')
845
1165
 
846
1166
    def __init__(self, location):
847
1167
       import bzrlib.urlutils as urlutils
850
1170
 
851
1171
 
852
1172
class DivergedBranches(BzrError):
853
 
    
854
 
    _fmt = "These branches have diverged.  Use the merge command to reconcile them."""
855
1173
 
856
 
    internal_error = False
 
1174
    _fmt = ("These branches have diverged."
 
1175
            " Use the merge command to reconcile them.")
857
1176
 
858
1177
    def __init__(self, branch1, branch2):
859
1178
        self.branch1 = branch1
860
1179
        self.branch2 = branch2
861
1180
 
862
1181
 
863
 
class NotLefthandHistory(BzrError):
 
1182
class NotLefthandHistory(InternalBzrError):
864
1183
 
865
1184
    _fmt = "Supplied history does not follow left-hand parents"
866
1185
 
867
 
    internal_error = True
868
 
 
869
1186
    def __init__(self, history):
870
1187
        BzrError.__init__(self, history=history)
871
1188
 
872
1189
 
873
1190
class UnrelatedBranches(BzrError):
874
1191
 
875
 
    _fmt = "Branches have no common ancestor, and no merge base revision was specified."
876
 
 
877
 
    internal_error = False
 
1192
    _fmt = ("Branches have no common ancestor, and"
 
1193
            " no merge base revision was specified.")
 
1194
 
 
1195
 
 
1196
class CannotReverseCherrypick(BzrError):
 
1197
 
 
1198
    _fmt = ('Selected merge cannot perform reverse cherrypicks.  Try merge3'
 
1199
            ' or diff3.')
878
1200
 
879
1201
 
880
1202
class NoCommonAncestor(BzrError):
888
1210
 
889
1211
class NoCommonRoot(BzrError):
890
1212
 
891
 
    _fmt = "Revisions are not derived from the same root: " \
892
 
           "%(revision_a)s %(revision_b)s."
 
1213
    _fmt = ("Revisions are not derived from the same root: "
 
1214
           "%(revision_a)s %(revision_b)s.")
893
1215
 
894
1216
    def __init__(self, revision_a, revision_b):
895
1217
        BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
918
1240
    def __init__(self, bases):
919
1241
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
920
1242
                DeprecationWarning)
921
 
        msg = "The correct base is unclear, because %s are all equally close" %\
922
 
            ", ".join(bases)
 
1243
        msg = ("The correct base is unclear, because %s are all equally close"
 
1244
                % ", ".join(bases))
923
1245
        BzrError.__init__(self, msg)
924
1246
        self.bases = bases
925
1247
 
926
1248
 
927
 
class NoCommits(BzrError):
 
1249
class NoCommits(BranchError):
928
1250
 
929
1251
    _fmt = "Branch %(branch)s has no commits."
930
1252
 
931
 
    def __init__(self, branch):
932
 
        BzrError.__init__(self, branch=branch)
933
 
 
934
1253
 
935
1254
class UnlistableStore(BzrError):
936
1255
 
947
1266
 
948
1267
class BoundBranchOutOfDate(BzrError):
949
1268
 
950
 
    _fmt = "Bound branch %(branch)s is out of date with master branch %(master)s."
 
1269
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
 
1270
            " %(master)s.")
951
1271
 
952
1272
    def __init__(self, branch, master):
953
1273
        BzrError.__init__(self)
957
1277
        
958
1278
class CommitToDoubleBoundBranch(BzrError):
959
1279
 
960
 
    _fmt = "Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."
 
1280
    _fmt = ("Cannot commit to branch %(branch)s."
 
1281
            " It is bound to %(master)s, which is bound to %(remote)s.")
961
1282
 
962
1283
    def __init__(self, branch, master, remote):
963
1284
        BzrError.__init__(self)
977
1298
 
978
1299
class BoundBranchConnectionFailure(BzrError):
979
1300
 
980
 
    _fmt = "Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"
 
1301
    _fmt = ("Unable to connect to target of bound branch %(branch)s"
 
1302
            " => %(target)s: %(error)s")
981
1303
 
982
1304
    def __init__(self, branch, target, error):
983
1305
        BzrError.__init__(self)
988
1310
 
989
1311
class WeaveError(BzrError):
990
1312
 
991
 
    _fmt = "Error in processing weave: %(message)s"
 
1313
    _fmt = "Error in processing weave: %(msg)s"
992
1314
 
993
 
    def __init__(self, message=None):
 
1315
    def __init__(self, msg=None):
994
1316
        BzrError.__init__(self)
995
 
        self.message = message
 
1317
        self.msg = msg
996
1318
 
997
1319
 
998
1320
class WeaveRevisionAlreadyPresent(WeaveError):
1027
1349
 
1028
1350
class WeaveParentMismatch(WeaveError):
1029
1351
 
1030
 
    _fmt = "Parents are mismatched between two revisions."
 
1352
    _fmt = "Parents are mismatched between two revisions. %(message)s"
1031
1353
    
1032
1354
 
1033
1355
class WeaveInvalidChecksum(WeaveError):
1037
1359
 
1038
1360
class WeaveTextDiffers(WeaveError):
1039
1361
 
1040
 
    _fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"
 
1362
    _fmt = ("Weaves differ on text content. Revision:"
 
1363
            " {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1041
1364
 
1042
1365
    def __init__(self, revision_id, weave_a, weave_b):
1043
1366
        WeaveError.__init__(self)
1048
1371
 
1049
1372
class WeaveTextDiffers(WeaveError):
1050
1373
 
1051
 
    _fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"
 
1374
    _fmt = ("Weaves differ on text content. Revision:"
 
1375
            " {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1052
1376
 
1053
1377
    def __init__(self, revision_id, weave_a, weave_b):
1054
1378
        WeaveError.__init__(self)
1064
1388
 
1065
1389
class RevisionNotPresent(VersionedFileError):
1066
1390
    
1067
 
    _fmt = "Revision {%(revision_id)s} not present in %(file_id)s."
 
1391
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1068
1392
 
1069
1393
    def __init__(self, revision_id, file_id):
1070
1394
        VersionedFileError.__init__(self)
1074
1398
 
1075
1399
class RevisionAlreadyPresent(VersionedFileError):
1076
1400
    
1077
 
    _fmt = "Revision {%(revision_id)s} already present in %(file_id)s."
 
1401
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1078
1402
 
1079
1403
    def __init__(self, revision_id, file_id):
1080
1404
        VersionedFileError.__init__(self)
1082
1406
        self.file_id = file_id
1083
1407
 
1084
1408
 
1085
 
class KnitError(BzrError):
 
1409
class VersionedFileInvalidChecksum(VersionedFileError):
 
1410
 
 
1411
    _fmt = "Text did not match its checksum: %(message)s"
 
1412
 
 
1413
 
 
1414
class KnitError(InternalBzrError):
1086
1415
    
1087
1416
    _fmt = "Knit error"
1088
1417
 
1089
 
    internal_error = True
1090
 
 
1091
 
 
1092
 
class KnitHeaderError(KnitError):
1093
 
 
1094
 
    _fmt = "Knit header error: %(badline)r unexpected for file %(filename)s"
1095
 
 
1096
 
    def __init__(self, badline, filename):
1097
 
        KnitError.__init__(self)
1098
 
        self.badline = badline
1099
 
        self.filename = filename
1100
 
 
1101
1418
 
1102
1419
class KnitCorrupt(KnitError):
1103
1420
 
1109
1426
        self.how = how
1110
1427
 
1111
1428
 
 
1429
class SHA1KnitCorrupt(KnitCorrupt):
 
1430
 
 
1431
    _fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "
 
1432
        "match expected sha-1. key %(key)s expected sha %(expected)s actual "
 
1433
        "sha %(actual)s")
 
1434
 
 
1435
    def __init__(self, filename, actual, expected, key, content):
 
1436
        KnitError.__init__(self)
 
1437
        self.filename = filename
 
1438
        self.actual = actual
 
1439
        self.expected = expected
 
1440
        self.key = key
 
1441
        self.content = content
 
1442
 
 
1443
 
 
1444
class KnitDataStreamIncompatible(KnitError):
 
1445
    # Not raised anymore, as we can convert data streams.  In future we may
 
1446
    # need it again for more exotic cases, so we're keeping it around for now.
 
1447
 
 
1448
    _fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."
 
1449
 
 
1450
    def __init__(self, stream_format, target_format):
 
1451
        self.stream_format = stream_format
 
1452
        self.target_format = target_format
 
1453
        
 
1454
 
 
1455
class KnitDataStreamUnknown(KnitError):
 
1456
    # Indicates a data stream we don't know how to handle.
 
1457
 
 
1458
    _fmt = "Cannot parse knit data stream of format \"%(stream_format)s\"."
 
1459
 
 
1460
    def __init__(self, stream_format):
 
1461
        self.stream_format = stream_format
 
1462
        
 
1463
 
 
1464
class KnitHeaderError(KnitError):
 
1465
 
 
1466
    _fmt = 'Knit header error: %(badline)r unexpected for file "%(filename)s".'
 
1467
 
 
1468
    def __init__(self, badline, filename):
 
1469
        KnitError.__init__(self)
 
1470
        self.badline = badline
 
1471
        self.filename = filename
 
1472
 
1112
1473
class KnitIndexUnknownMethod(KnitError):
1113
1474
    """Raised when we don't understand the storage method.
1114
1475
 
1124
1485
        self.options = options
1125
1486
 
1126
1487
 
 
1488
class RetryWithNewPacks(BzrError):
 
1489
    """Raised when we realize that the packs on disk have changed.
 
1490
 
 
1491
    This is meant as more of a signaling exception, to trap between where a
 
1492
    local error occurred and the code that can actually handle the error and
 
1493
    code that can retry appropriately.
 
1494
    """
 
1495
 
 
1496
    internal_error = True
 
1497
 
 
1498
    _fmt = ("Pack files have changed, reload and retry. context: %(context)s"
 
1499
            " %(orig_error)s")
 
1500
 
 
1501
    def __init__(self, context, reload_occurred, exc_info):
 
1502
        """create a new RetryWithNewPacks error.
 
1503
 
 
1504
        :param reload_occurred: Set to True if we know that the packs have
 
1505
            already been reloaded, and we are failing because of an in-memory
 
1506
            cache miss. If set to True then we will ignore if a reload says
 
1507
            nothing has changed, because we assume it has already reloaded. If
 
1508
            False, then a reload with nothing changed will force an error.
 
1509
        :param exc_info: The original exception traceback, so if there is a
 
1510
            problem we can raise the original error (value from sys.exc_info())
 
1511
        """
 
1512
        BzrError.__init__(self)
 
1513
        self.reload_occurred = reload_occurred
 
1514
        self.exc_info = exc_info
 
1515
        self.orig_error = exc_info[1]
 
1516
        # TODO: The global error handler should probably treat this by
 
1517
        #       raising/printing the original exception with a bit about
 
1518
        #       RetryWithNewPacks also not being caught
 
1519
 
 
1520
 
 
1521
class RetryAutopack(RetryWithNewPacks):
 
1522
    """Raised when we are autopacking and we find a missing file.
 
1523
 
 
1524
    Meant as a signaling exception, to tell the autopack code it should try
 
1525
    again.
 
1526
    """
 
1527
 
 
1528
    internal_error = True
 
1529
 
 
1530
    _fmt = ("Pack files have changed, reload and try autopack again."
 
1531
            " context: %(context)s %(orig_error)s")
 
1532
 
 
1533
 
1127
1534
class NoSuchExportFormat(BzrError):
1128
1535
    
1129
1536
    _fmt = "Export format %(format)r not supported"
1149
1556
        BzrError.__init__(self)
1150
1557
 
1151
1558
 
1152
 
class TooManyConcurrentRequests(BzrError):
1153
 
 
1154
 
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit. "
1155
 
            "Be sure to finish_writing and finish_reading on the "
1156
 
            "current request that is open.")
1157
 
 
1158
 
    internal_error = True
 
1559
class TooManyConcurrentRequests(InternalBzrError):
 
1560
 
 
1561
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
 
1562
            " Be sure to finish_writing and finish_reading on the"
 
1563
            " currently open request.")
1159
1564
 
1160
1565
    def __init__(self, medium):
1161
1566
        self.medium = medium
1169
1574
        self.details = details
1170
1575
 
1171
1576
 
 
1577
class UnexpectedProtocolVersionMarker(TransportError):
 
1578
 
 
1579
    _fmt = "Received bad protocol version marker: %(marker)r"
 
1580
 
 
1581
    def __init__(self, marker):
 
1582
        self.marker = marker
 
1583
 
 
1584
 
 
1585
class UnknownSmartMethod(InternalBzrError):
 
1586
 
 
1587
    _fmt = "The server does not recognise the '%(verb)s' request."
 
1588
 
 
1589
    def __init__(self, verb):
 
1590
        self.verb = verb
 
1591
 
 
1592
 
 
1593
class SmartMessageHandlerError(InternalBzrError):
 
1594
 
 
1595
    _fmt = ("The message handler raised an exception:\n"
 
1596
            "%(traceback_text)s")
 
1597
 
 
1598
    def __init__(self, exc_info):
 
1599
        import traceback
 
1600
        self.exc_type, self.exc_value, self.exc_tb = exc_info
 
1601
        self.exc_info = exc_info
 
1602
        traceback_strings = traceback.format_exception(
 
1603
                self.exc_type, self.exc_value, self.exc_tb)
 
1604
        self.traceback_text = ''.join(traceback_strings)
 
1605
 
 
1606
 
1172
1607
# A set of semi-meaningful errors which can be thrown
1173
1608
class TransportNotPossible(TransportError):
1174
1609
 
1206
1641
 
1207
1642
class InvalidRange(TransportError):
1208
1643
 
1209
 
    _fmt = "Invalid range access in %(path)s at %(offset)s."
1210
 
    
1211
 
    def __init__(self, path, offset):
1212
 
        TransportError.__init__(self, ("Invalid range access in %s at %d"
1213
 
                                       % (path, offset)))
 
1644
    _fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
 
1645
 
 
1646
    def __init__(self, path, offset, msg=None):
 
1647
        TransportError.__init__(self, msg)
1214
1648
        self.path = path
1215
1649
        self.offset = offset
1216
1650
 
1227
1661
class InvalidHttpRange(InvalidHttpResponse):
1228
1662
 
1229
1663
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1230
 
    
 
1664
 
1231
1665
    def __init__(self, path, range, msg):
1232
1666
        self.range = range
1233
1667
        InvalidHttpResponse.__init__(self, path, msg)
1236
1670
class InvalidHttpContentType(InvalidHttpResponse):
1237
1671
 
1238
1672
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1239
 
    
 
1673
 
1240
1674
    def __init__(self, path, ctype, msg):
1241
1675
        self.ctype = ctype
1242
1676
        InvalidHttpResponse.__init__(self, path, msg)
1243
1677
 
1244
1678
 
 
1679
class RedirectRequested(TransportError):
 
1680
 
 
1681
    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'
 
1682
 
 
1683
    def __init__(self, source, target, is_permanent=False):
 
1684
        self.source = source
 
1685
        self.target = target
 
1686
        if is_permanent:
 
1687
            self.permanently = ' permanently'
 
1688
        else:
 
1689
            self.permanently = ''
 
1690
        TransportError.__init__(self)
 
1691
 
 
1692
 
 
1693
class TooManyRedirections(TransportError):
 
1694
 
 
1695
    _fmt = "Too many redirections"
 
1696
 
 
1697
 
1245
1698
class ConflictsInTree(BzrError):
1246
1699
 
1247
1700
    _fmt = "Working tree has conflicts."
1253
1706
        if filename is None:
1254
1707
            filename = ""
1255
1708
        message = "Error(s) parsing config file %s:\n%s" % \
1256
 
            (filename, ('\n'.join(e.message for e in errors)))
 
1709
            (filename, ('\n'.join(e.msg for e in errors)))
1257
1710
        BzrError.__init__(self, message)
1258
1711
 
1259
1712
 
1268
1721
 
1269
1722
class SigningFailed(BzrError):
1270
1723
 
1271
 
    _fmt = "Failed to gpg sign data with command %(command_line)r"
 
1724
    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'
1272
1725
 
1273
1726
    def __init__(self, command_line):
1274
1727
        BzrError.__init__(self, command_line=command_line)
1286
1739
 
1287
1740
class CantReprocessAndShowBase(BzrError):
1288
1741
 
1289
 
    _fmt = "Can't reprocess and show base, because reprocessing obscures " \
1290
 
           "the relationship of conflicting lines to the base"
 
1742
    _fmt = ("Can't reprocess and show base, because reprocessing obscures "
 
1743
           "the relationship of conflicting lines to the base")
1291
1744
 
1292
1745
 
1293
1746
class GraphCycleError(BzrError):
1299
1752
        self.graph = graph
1300
1753
 
1301
1754
 
1302
 
class WritingCompleted(BzrError):
 
1755
class WritingCompleted(InternalBzrError):
1303
1756
 
1304
1757
    _fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1305
1758
            "called upon it - accept bytes may not be called anymore.")
1306
1759
 
1307
 
    internal_error = True
1308
 
 
1309
1760
    def __init__(self, request):
1310
1761
        self.request = request
1311
1762
 
1312
1763
 
1313
 
class WritingNotComplete(BzrError):
 
1764
class WritingNotComplete(InternalBzrError):
1314
1765
 
1315
1766
    _fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1316
1767
            "called upon it - until the write phase is complete no "
1317
1768
            "data may be read.")
1318
1769
 
1319
 
    internal_error = True
1320
 
 
1321
1770
    def __init__(self, request):
1322
1771
        self.request = request
1323
1772
 
1331
1780
        self.filename = filename
1332
1781
 
1333
1782
 
1334
 
class MediumNotConnected(BzrError):
 
1783
class MediumNotConnected(InternalBzrError):
1335
1784
 
1336
1785
    _fmt = """The medium '%(medium)s' is not connected."""
1337
1786
 
1338
 
    internal_error = True
1339
 
 
1340
1787
    def __init__(self, medium):
1341
1788
        self.medium = medium
1342
1789
 
1343
1790
 
1344
1791
class MustUseDecorated(Exception):
1345
 
    
1346
 
    _fmt = """A decorating function has requested its original command be used."""
1347
 
    
 
1792
 
 
1793
    _fmt = "A decorating function has requested its original command be used."
 
1794
 
1348
1795
 
1349
1796
class NoBundleFound(BzrError):
1350
1797
 
1351
 
    _fmt = "No bundle was found in %(filename)s"
 
1798
    _fmt = 'No bundle was found in "%(filename)s".'
1352
1799
 
1353
1800
    def __init__(self, filename):
1354
1801
        BzrError.__init__(self)
1367
1814
 
1368
1815
class MissingText(BzrError):
1369
1816
 
1370
 
    _fmt = "Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"
 
1817
    _fmt = ("Branch %(base)s is missing revision"
 
1818
            " %(text_revision)s of %(file_id)s")
1371
1819
 
1372
1820
    def __init__(self, branch, text_revision, file_id):
1373
1821
        BzrError.__init__(self)
1392
1840
    _fmt = "Key %(key)s is already present in map"
1393
1841
 
1394
1842
 
 
1843
class DuplicateHelpPrefix(BzrError):
 
1844
 
 
1845
    _fmt = "The prefix %(prefix)s is in the help search path twice."
 
1846
 
 
1847
    def __init__(self, prefix):
 
1848
        self.prefix = prefix
 
1849
 
 
1850
 
1395
1851
class MalformedTransform(BzrError):
1396
1852
 
1397
1853
    _fmt = "Tree transform is malformed %(conflicts)r"
1409
1865
        self.root_trans_id = transform.root
1410
1866
 
1411
1867
 
1412
 
class BzrBadParameter(BzrError):
 
1868
class BzrBadParameter(InternalBzrError):
1413
1869
 
1414
1870
    _fmt = "Bad parameter: %(param)r"
1415
1871
 
1441
1897
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
1442
1898
 
1443
1899
    def __init__(self, from_path='', to_path='', extra=None):
 
1900
        from bzrlib.osutils import splitpath
1444
1901
        BzrError.__init__(self)
1445
1902
        if extra:
1446
1903
            self.extra = ': ' + str(extra)
1450
1907
        has_from = len(from_path) > 0
1451
1908
        has_to = len(to_path) > 0
1452
1909
        if has_from:
1453
 
            self.from_path = osutils.splitpath(from_path)[-1]
 
1910
            self.from_path = splitpath(from_path)[-1]
1454
1911
        else:
1455
1912
            self.from_path = ''
1456
1913
 
1457
1914
        if has_to:
1458
 
            self.to_path = osutils.splitpath(to_path)[-1]
 
1915
            self.to_path = splitpath(to_path)[-1]
1459
1916
        else:
1460
1917
            self.to_path = ''
1461
1918
 
1477
1934
    def __init__(self, from_path, to_path, extra=None):
1478
1935
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1479
1936
 
 
1937
class BzrRemoveChangedFilesError(BzrError):
 
1938
    """Used when user is trying to remove changed files."""
 
1939
 
 
1940
    _fmt = ("Can't safely remove modified or unknown files:\n"
 
1941
        "%(changes_as_text)s"
 
1942
        "Use --keep to not delete them, or --force to delete them regardless.")
 
1943
 
 
1944
    def __init__(self, tree_delta):
 
1945
        BzrError.__init__(self)
 
1946
        self.changes_as_text = tree_delta.get_changes_as_text()
 
1947
        #self.paths_as_string = '\n'.join(changed_files)
 
1948
        #self.paths_as_string = '\n'.join([quotefn(p) for p in changed_files])
 
1949
 
1480
1950
 
1481
1951
class BzrBadParameterNotString(BzrBadParameter):
1482
1952
 
1490
1960
 
1491
1961
class BzrBadParameterUnicode(BzrBadParameter):
1492
1962
 
1493
 
    _fmt = "Parameter %(param)s is unicode but only byte-strings are permitted."
 
1963
    _fmt = ("Parameter %(param)s is unicode but"
 
1964
            " only byte-strings are permitted.")
1494
1965
 
1495
1966
 
1496
1967
class BzrBadParameterContainsNewline(BzrBadParameter):
1538
2009
        self.format = format
1539
2010
 
1540
2011
 
 
2012
class NoDiffFound(BzrError):
 
2013
 
 
2014
    _fmt = 'Could not find an appropriate Differ for file "%(path)s"'
 
2015
 
 
2016
    def __init__(self, path):
 
2017
        BzrError.__init__(self, path)
 
2018
 
 
2019
 
 
2020
class ExecutableMissing(BzrError):
 
2021
 
 
2022
    _fmt = "%(exe_name)s could not be found on this machine"
 
2023
 
 
2024
    def __init__(self, exe_name):
 
2025
        BzrError.__init__(self, exe_name=exe_name)
 
2026
 
 
2027
 
1541
2028
class NoDiff(BzrError):
1542
2029
 
1543
2030
    _fmt = "Diff is not installed on this machine: %(msg)s"
1551
2038
    _fmt = "Diff3 is not installed on this machine."
1552
2039
 
1553
2040
 
 
2041
class ExistingContent(BzrError):
 
2042
    # Added in bzrlib 0.92, used by VersionedFile.add_lines.
 
2043
 
 
2044
    _fmt = "The content being inserted is already present."
 
2045
 
 
2046
 
1554
2047
class ExistingLimbo(BzrError):
1555
2048
 
1556
2049
    _fmt = """This tree contains left-over files from a failed operation.
1562
2055
       self.limbo_dir = limbo_dir
1563
2056
 
1564
2057
 
 
2058
class ExistingPendingDeletion(BzrError):
 
2059
 
 
2060
    _fmt = """This tree contains left-over files from a failed operation.
 
2061
    Please examine %(pending_deletion)s to see if it contains any files you
 
2062
    wish to keep, and delete it when you are done."""
 
2063
 
 
2064
    def __init__(self, pending_deletion):
 
2065
       BzrError.__init__(self, pending_deletion=pending_deletion)
 
2066
 
 
2067
 
1565
2068
class ImmortalLimbo(BzrError):
1566
2069
 
1567
 
    _fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
 
2070
    _fmt = """Unable to delete transform temporary directory %(limbo_dir)s.
1568
2071
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1569
2072
    keep, and delete it when you are done."""
1570
2073
 
1573
2076
       self.limbo_dir = limbo_dir
1574
2077
 
1575
2078
 
 
2079
class ImmortalPendingDeletion(BzrError):
 
2080
 
 
2081
    _fmt = ("Unable to delete transform temporary directory "
 
2082
    "%(pending_deletion)s.  Please examine %(pending_deletion)s to see if it "
 
2083
    "contains any files you wish to keep, and delete it when you are done.")
 
2084
 
 
2085
    def __init__(self, pending_deletion):
 
2086
       BzrError.__init__(self, pending_deletion=pending_deletion)
 
2087
 
 
2088
 
1576
2089
class OutOfDateTree(BzrError):
1577
2090
 
1578
2091
    _fmt = "Working tree is out of date, please run 'bzr update'."
1582
2095
        self.tree = tree
1583
2096
 
1584
2097
 
 
2098
class PublicBranchOutOfDate(BzrError):
 
2099
 
 
2100
    _fmt = 'Public branch "%(public_location)s" lacks revision '\
 
2101
        '"%(revstring)s".'
 
2102
 
 
2103
    def __init__(self, public_location, revstring):
 
2104
        import bzrlib.urlutils as urlutils
 
2105
        public_location = urlutils.unescape_for_display(public_location,
 
2106
                                                        'ascii')
 
2107
        BzrError.__init__(self, public_location=public_location,
 
2108
                          revstring=revstring)
 
2109
 
 
2110
 
1585
2111
class MergeModifiedFormatError(BzrError):
1586
2112
 
1587
2113
    _fmt = "Error in merge modified format"
1592
2118
    _fmt = "Format error in conflict listings"
1593
2119
 
1594
2120
 
 
2121
class CorruptDirstate(BzrError):
 
2122
 
 
2123
    _fmt = ("Inconsistency in dirstate file %(dirstate_path)s.\n"
 
2124
            "Error: %(description)s")
 
2125
 
 
2126
    def __init__(self, dirstate_path, description):
 
2127
        BzrError.__init__(self)
 
2128
        self.dirstate_path = dirstate_path
 
2129
        self.description = description
 
2130
 
 
2131
 
1595
2132
class CorruptRepository(BzrError):
1596
2133
 
1597
 
    _fmt = """An error has been detected in the repository %(repo_path)s.
1598
 
Please run bzr reconcile on this repository."""
 
2134
    _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
 
2135
            "Please run bzr reconcile on this repository.")
1599
2136
 
1600
2137
    def __init__(self, repo):
1601
2138
        BzrError.__init__(self)
1602
2139
        self.repo_path = repo.bzrdir.root_transport.base
1603
2140
 
1604
2141
 
 
2142
class InconsistentDelta(BzrError):
 
2143
    """Used when we get a delta that is not valid."""
 
2144
 
 
2145
    _fmt = ("An inconsistent delta was supplied involving %(path)r,"
 
2146
            " %(file_id)r\nreason: %(reason)s")
 
2147
 
 
2148
    def __init__(self, path, file_id, reason):
 
2149
        BzrError.__init__(self)
 
2150
        self.path = path
 
2151
        self.file_id = file_id
 
2152
        self.reason = reason
 
2153
 
 
2154
 
1605
2155
class UpgradeRequired(BzrError):
1606
2156
 
1607
2157
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
1611
2161
        self.path = path
1612
2162
 
1613
2163
 
 
2164
class RepositoryUpgradeRequired(UpgradeRequired):
 
2165
 
 
2166
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
 
2167
 
 
2168
 
1614
2169
class LocalRequiresBoundBranch(BzrError):
1615
2170
 
1616
2171
    _fmt = "Cannot perform local-only commits on unbound branches."
1617
2172
 
1618
2173
 
1619
 
class MissingProgressBarFinish(BzrError):
1620
 
 
1621
 
    _fmt = "A nested progress bar was not 'finished' correctly."
1622
 
 
1623
 
 
1624
2174
class InvalidProgressBarType(BzrError):
1625
2175
 
1626
 
    _fmt = """Environment variable BZR_PROGRESS_BAR='%(bar_type)s is not a supported type
1627
 
Select one of: %(valid_types)s"""
 
2176
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
 
2177
            " is not a supported type Select one of: %(valid_types)s")
1628
2178
 
1629
2179
    def __init__(self, bar_type, valid_types):
1630
2180
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1632
2182
 
1633
2183
class UnsupportedOperation(BzrError):
1634
2184
 
1635
 
    _fmt = "The method %(mname)s is not supported on objects of type %(tname)s."
 
2185
    _fmt = ("The method %(mname)s is not supported on"
 
2186
            " objects of type %(tname)s.")
1636
2187
 
1637
2188
    def __init__(self, method, method_self):
1638
2189
        self.method = method
1645
2196
 
1646
2197
 
1647
2198
class NonAsciiRevisionId(UnsupportedOperation):
1648
 
    """Raised when a commit is attempting to set a non-ascii revision id but cant."""
 
2199
    """Raised when a commit is attempting to set a non-ascii revision id
 
2200
       but cant.
 
2201
    """
1649
2202
 
1650
2203
 
1651
2204
class BinaryFile(BzrError):
1664
2217
 
1665
2218
class TestamentMismatch(BzrError):
1666
2219
 
1667
 
    _fmt = """Testament did not match expected value.  
1668
 
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured 
 
2220
    _fmt = """Testament did not match expected value.
 
2221
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
1669
2222
       {%(measured)s}"""
1670
2223
 
1671
2224
    def __init__(self, revision_id, expected, measured):
1740
2293
        BadInventoryFormat.__init__(self, msg=msg)
1741
2294
 
1742
2295
 
1743
 
class NoSmartMedium(BzrError):
 
2296
class RootNotRich(BzrError):
 
2297
 
 
2298
    _fmt = """This operation requires rich root data storage"""
 
2299
 
 
2300
 
 
2301
class NoSmartMedium(InternalBzrError):
1744
2302
 
1745
2303
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
1746
 
    internal_error = True
1747
2304
 
1748
2305
    def __init__(self, transport):
1749
2306
        self.transport = transport
1753
2310
 
1754
2311
    _fmt = "No smart server available at %(url)s"
1755
2312
 
 
2313
    @symbol_versioning.deprecated_method(symbol_versioning.one_four)
1756
2314
    def __init__(self, url):
1757
2315
        self.url = url
1758
2316
 
1766
2324
        self.vendor = vendor
1767
2325
 
1768
2326
 
 
2327
class SSHVendorNotFound(BzrError):
 
2328
 
 
2329
    _fmt = ("Don't know how to handle SSH connections."
 
2330
            " Please set BZR_SSH environment variable.")
 
2331
 
 
2332
 
 
2333
class GhostRevisionsHaveNoRevno(BzrError):
 
2334
    """When searching for revnos, if we encounter a ghost, we are stuck"""
 
2335
 
 
2336
    _fmt = ("Could not determine revno for {%(revision_id)s} because"
 
2337
            " its ancestry shows a ghost at {%(ghost_revision_id)s}")
 
2338
 
 
2339
    def __init__(self, revision_id, ghost_revision_id):
 
2340
        self.revision_id = revision_id
 
2341
        self.ghost_revision_id = ghost_revision_id
 
2342
 
 
2343
        
1769
2344
class GhostRevisionUnusableHere(BzrError):
1770
2345
 
1771
2346
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
1775
2350
        self.revision_id = revision_id
1776
2351
 
1777
2352
 
1778
 
class IllegalUseOfScopeReplacer(BzrError):
1779
 
 
1780
 
    _fmt = "ScopeReplacer object %(name)r was used incorrectly: %(msg)s%(extra)s"
1781
 
 
1782
 
    internal_error = True
 
2353
class IllegalUseOfScopeReplacer(InternalBzrError):
 
2354
 
 
2355
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
 
2356
            " %(msg)s%(extra)s")
1783
2357
 
1784
2358
    def __init__(self, name, msg, extra=None):
1785
2359
        BzrError.__init__(self)
1791
2365
            self.extra = ''
1792
2366
 
1793
2367
 
1794
 
class InvalidImportLine(BzrError):
 
2368
class InvalidImportLine(InternalBzrError):
1795
2369
 
1796
2370
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
1797
2371
 
1798
 
    internal_error = True
1799
 
 
1800
2372
    def __init__(self, text, msg):
1801
2373
        BzrError.__init__(self)
1802
2374
        self.text = text
1803
2375
        self.msg = msg
1804
2376
 
1805
2377
 
1806
 
class ImportNameCollision(BzrError):
1807
 
 
1808
 
    _fmt = "Tried to import an object to the same name as an existing object. %(name)s"
 
2378
class ImportNameCollision(InternalBzrError):
 
2379
 
 
2380
    _fmt = ("Tried to import an object to the same name as"
 
2381
            " an existing object. %(name)s")
 
2382
 
 
2383
    def __init__(self, name):
 
2384
        BzrError.__init__(self)
 
2385
        self.name = name
 
2386
 
 
2387
 
 
2388
class NotAMergeDirective(BzrError):
 
2389
    """File starting with %(firstline)r is not a merge directive"""
 
2390
    def __init__(self, firstline):
 
2391
        BzrError.__init__(self, firstline=firstline)
 
2392
 
 
2393
 
 
2394
class NoMergeSource(BzrError):
 
2395
    """Raise if no merge source was specified for a merge directive"""
 
2396
 
 
2397
    _fmt = "A merge directive must provide either a bundle or a public"\
 
2398
        " branch location."
 
2399
 
 
2400
 
 
2401
class IllegalMergeDirectivePayload(BzrError):
 
2402
    """A merge directive contained something other than a patch or bundle"""
 
2403
 
 
2404
    _fmt = "Bad merge directive payload %(start)r"
 
2405
 
 
2406
    def __init__(self, start):
 
2407
        BzrError(self)
 
2408
        self.start = start
 
2409
 
 
2410
 
 
2411
class PatchVerificationFailed(BzrError):
 
2412
    """A patch from a merge directive could not be verified"""
 
2413
 
 
2414
    _fmt = "Preview patch does not match requested changes."
 
2415
 
 
2416
 
 
2417
class PatchMissing(BzrError):
 
2418
    """Raise a patch type was specified but no patch supplied"""
 
2419
 
 
2420
    _fmt = "Patch_type was %(patch_type)s, but no patch was supplied."
 
2421
 
 
2422
    def __init__(self, patch_type):
 
2423
        BzrError.__init__(self)
 
2424
        self.patch_type = patch_type
 
2425
 
 
2426
 
 
2427
class TargetNotBranch(BzrError):
 
2428
    """A merge directive's target branch is required, but isn't a branch"""
 
2429
 
 
2430
    _fmt = ("Your branch does not have all of the revisions required in "
 
2431
            "order to merge this merge directive and the target "
 
2432
            "location specified in the merge directive is not a branch: "
 
2433
            "%(location)s.")
 
2434
 
 
2435
    def __init__(self, location):
 
2436
        BzrError.__init__(self)
 
2437
        self.location = location
 
2438
 
 
2439
 
 
2440
class UnsupportedInventoryKind(BzrError):
 
2441
    
 
2442
    _fmt = """Unsupported entry kind %(kind)s"""
 
2443
 
 
2444
    def __init__(self, kind):
 
2445
        self.kind = kind
 
2446
 
 
2447
 
 
2448
class BadSubsumeSource(BzrError):
 
2449
 
 
2450
    _fmt = "Can't subsume %(other_tree)s into %(tree)s. %(reason)s"
 
2451
 
 
2452
    def __init__(self, tree, other_tree, reason):
 
2453
        self.tree = tree
 
2454
        self.other_tree = other_tree
 
2455
        self.reason = reason
 
2456
 
 
2457
 
 
2458
class SubsumeTargetNeedsUpgrade(BzrError):
 
2459
    
 
2460
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
 
2461
 
 
2462
    def __init__(self, other_tree):
 
2463
        self.other_tree = other_tree
 
2464
 
 
2465
 
 
2466
class BadReferenceTarget(InternalBzrError):
 
2467
 
 
2468
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
 
2469
           "%(reason)s"
 
2470
 
 
2471
    def __init__(self, tree, other_tree, reason):
 
2472
        self.tree = tree
 
2473
        self.other_tree = other_tree
 
2474
        self.reason = reason
 
2475
 
 
2476
 
 
2477
class NoSuchTag(BzrError):
 
2478
 
 
2479
    _fmt = "No such tag: %(tag_name)s"
 
2480
 
 
2481
    def __init__(self, tag_name):
 
2482
        self.tag_name = tag_name
 
2483
 
 
2484
 
 
2485
class TagsNotSupported(BzrError):
 
2486
 
 
2487
    _fmt = ("Tags not supported by %(branch)s;"
 
2488
            " you may be able to use bzr upgrade.")
 
2489
 
 
2490
    def __init__(self, branch):
 
2491
        self.branch = branch
 
2492
 
 
2493
        
 
2494
class TagAlreadyExists(BzrError):
 
2495
 
 
2496
    _fmt = "Tag %(tag_name)s already exists."
 
2497
 
 
2498
    def __init__(self, tag_name):
 
2499
        self.tag_name = tag_name
 
2500
 
 
2501
 
 
2502
class MalformedBugIdentifier(BzrError):
 
2503
 
 
2504
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
 
2505
 
 
2506
    def __init__(self, bug_id, reason):
 
2507
        self.bug_id = bug_id
 
2508
        self.reason = reason
 
2509
 
 
2510
 
 
2511
class InvalidBugTrackerURL(BzrError):
 
2512
 
 
2513
    _fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
 
2514
            "contain {id}: %(url)s")
 
2515
 
 
2516
    def __init__(self, abbreviation, url):
 
2517
        self.abbreviation = abbreviation
 
2518
        self.url = url
 
2519
 
 
2520
 
 
2521
class UnknownBugTrackerAbbreviation(BzrError):
 
2522
 
 
2523
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
 
2524
            "on %(branch)s")
 
2525
 
 
2526
    def __init__(self, abbreviation, branch):
 
2527
        self.abbreviation = abbreviation
 
2528
        self.branch = branch
 
2529
 
 
2530
 
 
2531
class UnexpectedSmartServerResponse(BzrError):
 
2532
 
 
2533
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
 
2534
 
 
2535
    def __init__(self, response_tuple):
 
2536
        self.response_tuple = response_tuple
 
2537
 
 
2538
 
 
2539
class ErrorFromSmartServer(BzrError):
 
2540
    """An error was received from a smart server.
 
2541
 
 
2542
    :seealso: UnknownErrorFromSmartServer
 
2543
    """
 
2544
 
 
2545
    _fmt = "Error received from smart server: %(error_tuple)r"
1809
2546
 
1810
2547
    internal_error = True
1811
2548
 
1812
 
    def __init__(self, name):
1813
 
        BzrError.__init__(self)
1814
 
        self.name = name
 
2549
    def __init__(self, error_tuple):
 
2550
        self.error_tuple = error_tuple
 
2551
        try:
 
2552
            self.error_verb = error_tuple[0]
 
2553
        except IndexError:
 
2554
            self.error_verb = None
 
2555
        self.error_args = error_tuple[1:]
 
2556
 
 
2557
 
 
2558
class UnknownErrorFromSmartServer(BzrError):
 
2559
    """An ErrorFromSmartServer could not be translated into a typical bzrlib
 
2560
    error.
 
2561
 
 
2562
    This is distinct from ErrorFromSmartServer so that it is possible to
 
2563
    distinguish between the following two cases:
 
2564
      - ErrorFromSmartServer was uncaught.  This is logic error in the client
 
2565
        and so should provoke a traceback to the user.
 
2566
      - ErrorFromSmartServer was caught but its error_tuple could not be
 
2567
        translated.  This is probably because the server sent us garbage, and
 
2568
        should not provoke a traceback.
 
2569
    """
 
2570
 
 
2571
    _fmt = "Server sent an unexpected error: %(error_tuple)r"
 
2572
 
 
2573
    internal_error = False
 
2574
 
 
2575
    def __init__(self, error_from_smart_server):
 
2576
        """Constructor.
 
2577
 
 
2578
        :param error_from_smart_server: An ErrorFromSmartServer instance.
 
2579
        """
 
2580
        self.error_from_smart_server = error_from_smart_server
 
2581
        self.error_tuple = error_from_smart_server.error_tuple
 
2582
        
 
2583
 
 
2584
class ContainerError(BzrError):
 
2585
    """Base class of container errors."""
 
2586
 
 
2587
 
 
2588
class UnknownContainerFormatError(ContainerError):
 
2589
 
 
2590
    _fmt = "Unrecognised container format: %(container_format)r"
 
2591
    
 
2592
    def __init__(self, container_format):
 
2593
        self.container_format = container_format
 
2594
 
 
2595
 
 
2596
class UnexpectedEndOfContainerError(ContainerError):
 
2597
 
 
2598
    _fmt = "Unexpected end of container stream"
 
2599
 
 
2600
 
 
2601
class UnknownRecordTypeError(ContainerError):
 
2602
 
 
2603
    _fmt = "Unknown record type: %(record_type)r"
 
2604
 
 
2605
    def __init__(self, record_type):
 
2606
        self.record_type = record_type
 
2607
 
 
2608
 
 
2609
class InvalidRecordError(ContainerError):
 
2610
 
 
2611
    _fmt = "Invalid record: %(reason)s"
 
2612
 
 
2613
    def __init__(self, reason):
 
2614
        self.reason = reason
 
2615
 
 
2616
 
 
2617
class ContainerHasExcessDataError(ContainerError):
 
2618
 
 
2619
    _fmt = "Container has data after end marker: %(excess)r"
 
2620
 
 
2621
    def __init__(self, excess):
 
2622
        self.excess = excess
 
2623
 
 
2624
 
 
2625
class DuplicateRecordNameError(ContainerError):
 
2626
 
 
2627
    _fmt = "Container has multiple records with the same name: %(name)s"
 
2628
 
 
2629
    def __init__(self, name):
 
2630
        self.name = name
 
2631
 
 
2632
 
 
2633
class NoDestinationAddress(InternalBzrError):
 
2634
 
 
2635
    _fmt = "Message does not have a destination address."
 
2636
 
 
2637
 
 
2638
class RepositoryDataStreamError(BzrError):
 
2639
 
 
2640
    _fmt = "Corrupt or incompatible data stream: %(reason)s"
 
2641
 
 
2642
    def __init__(self, reason):
 
2643
        self.reason = reason
 
2644
 
 
2645
 
 
2646
class SMTPError(BzrError):
 
2647
 
 
2648
    _fmt = "SMTP error: %(error)s"
 
2649
 
 
2650
    def __init__(self, error):
 
2651
        self.error = error
 
2652
 
 
2653
 
 
2654
class NoMessageSupplied(BzrError):
 
2655
 
 
2656
    _fmt = "No message supplied."
 
2657
 
 
2658
 
 
2659
class NoMailAddressSpecified(BzrError):
 
2660
 
 
2661
    _fmt = "No mail-to address specified."
 
2662
 
 
2663
 
 
2664
class UnknownMailClient(BzrError):
 
2665
 
 
2666
    _fmt = "Unknown mail client: %(mail_client)s"
 
2667
 
 
2668
    def __init__(self, mail_client):
 
2669
        BzrError.__init__(self, mail_client=mail_client)
 
2670
 
 
2671
 
 
2672
class MailClientNotFound(BzrError):
 
2673
 
 
2674
    _fmt = "Unable to find mail client with the following names:"\
 
2675
        " %(mail_command_list_string)s"
 
2676
 
 
2677
    def __init__(self, mail_command_list):
 
2678
        mail_command_list_string = ', '.join(mail_command_list)
 
2679
        BzrError.__init__(self, mail_command_list=mail_command_list,
 
2680
                          mail_command_list_string=mail_command_list_string)
 
2681
 
 
2682
class SMTPConnectionRefused(SMTPError):
 
2683
 
 
2684
    _fmt = "SMTP connection to %(host)s refused"
 
2685
 
 
2686
    def __init__(self, error, host):
 
2687
        self.error = error
 
2688
        self.host = host
 
2689
 
 
2690
 
 
2691
class DefaultSMTPConnectionRefused(SMTPConnectionRefused):
 
2692
 
 
2693
    _fmt = "Please specify smtp_server.  No server at default %(host)s."
 
2694
 
 
2695
 
 
2696
class BzrDirError(BzrError):
 
2697
 
 
2698
    def __init__(self, bzrdir):
 
2699
        import bzrlib.urlutils as urlutils
 
2700
        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,
 
2701
                                                    'ascii')
 
2702
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
 
2703
 
 
2704
 
 
2705
class UnsyncedBranches(BzrDirError):
 
2706
 
 
2707
    _fmt = ("'%(display_url)s' is not in sync with %(target_url)s.  See"
 
2708
            " bzr help sync-for-reconfigure.")
 
2709
 
 
2710
    def __init__(self, bzrdir, target_branch):
 
2711
        BzrDirError.__init__(self, bzrdir)
 
2712
        import bzrlib.urlutils as urlutils
 
2713
        self.target_url = urlutils.unescape_for_display(target_branch.base,
 
2714
                                                        'ascii')
 
2715
 
 
2716
 
 
2717
class AlreadyBranch(BzrDirError):
 
2718
 
 
2719
    _fmt = "'%(display_url)s' is already a branch."
 
2720
 
 
2721
 
 
2722
class AlreadyTree(BzrDirError):
 
2723
 
 
2724
    _fmt = "'%(display_url)s' is already a tree."
 
2725
 
 
2726
 
 
2727
class AlreadyCheckout(BzrDirError):
 
2728
 
 
2729
    _fmt = "'%(display_url)s' is already a checkout."
 
2730
 
 
2731
 
 
2732
class AlreadyLightweightCheckout(BzrDirError):
 
2733
 
 
2734
    _fmt = "'%(display_url)s' is already a lightweight checkout."
 
2735
 
 
2736
 
 
2737
class AlreadyUsingShared(BzrDirError):
 
2738
 
 
2739
    _fmt = "'%(display_url)s' is already using a shared repository."
 
2740
 
 
2741
 
 
2742
class AlreadyStandalone(BzrDirError):
 
2743
 
 
2744
    _fmt = "'%(display_url)s' is already standalone."
 
2745
 
 
2746
 
 
2747
class ReconfigurationNotSupported(BzrDirError):
 
2748
 
 
2749
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
 
2750
 
 
2751
 
 
2752
class NoBindLocation(BzrDirError):
 
2753
 
 
2754
    _fmt = "No location could be found to bind to at %(display_url)s."
 
2755
 
 
2756
 
 
2757
class UncommittedChanges(BzrError):
 
2758
 
 
2759
    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'
 
2760
 
 
2761
    def __init__(self, tree):
 
2762
        import bzrlib.urlutils as urlutils
 
2763
        display_url = urlutils.unescape_for_display(
 
2764
            tree.bzrdir.root_transport.base, 'ascii')
 
2765
        BzrError.__init__(self, tree=tree, display_url=display_url)
 
2766
 
 
2767
 
 
2768
class MissingTemplateVariable(BzrError):
 
2769
 
 
2770
    _fmt = 'Variable {%(name)s} is not available.'
 
2771
 
 
2772
    def __init__(self, name):
 
2773
        self.name = name
 
2774
 
 
2775
 
 
2776
class NoTemplate(BzrError):
 
2777
 
 
2778
    _fmt = 'No template specified.'
 
2779
 
 
2780
 
 
2781
class UnableCreateSymlink(BzrError):
 
2782
 
 
2783
    _fmt = 'Unable to create symlink %(path_str)son this platform'
 
2784
 
 
2785
    def __init__(self, path=None):
 
2786
        path_str = ''
 
2787
        if path:
 
2788
            try:
 
2789
                path_str = repr(str(path))
 
2790
            except UnicodeEncodeError:
 
2791
                path_str = repr(path)
 
2792
            path_str += ' '
 
2793
        self.path_str = path_str
 
2794
 
 
2795
 
 
2796
class UnsupportedTimezoneFormat(BzrError):
 
2797
 
 
2798
    _fmt = ('Unsupported timezone format "%(timezone)s", '
 
2799
            'options are "utc", "original", "local".')
 
2800
 
 
2801
    def __init__(self, timezone):
 
2802
        self.timezone = timezone
 
2803
 
 
2804
 
 
2805
class CommandAvailableInPlugin(StandardError):
 
2806
    
 
2807
    internal_error = False
 
2808
 
 
2809
    def __init__(self, cmd_name, plugin_metadata, provider):
 
2810
        
 
2811
        self.plugin_metadata = plugin_metadata
 
2812
        self.cmd_name = cmd_name
 
2813
        self.provider = provider
 
2814
 
 
2815
    def __str__(self):
 
2816
 
 
2817
        _fmt = ('"%s" is not a standard bzr command. \n' 
 
2818
                'However, the following official plugin provides this command: %s\n'
 
2819
                'You can install it by going to: %s'
 
2820
                % (self.cmd_name, self.plugin_metadata['name'], 
 
2821
                    self.plugin_metadata['url']))
 
2822
 
 
2823
        return _fmt
 
2824
 
 
2825
 
 
2826
class NoPluginAvailable(BzrError):
 
2827
    pass    
 
2828
 
 
2829
 
 
2830
class NotATerminal(BzrError):
 
2831
 
 
2832
    _fmt = 'Unable to ask for a password without real terminal.'
 
2833
 
 
2834
 
 
2835
class UnableEncodePath(BzrError):
 
2836
 
 
2837
    _fmt = ('Unable to encode %(kind)s path %(path)r in '
 
2838
            'user encoding %(user_encoding)s')
 
2839
 
 
2840
    def __init__(self, path, kind):
 
2841
        from bzrlib.osutils import get_user_encoding
 
2842
        self.path = path
 
2843
        self.kind = kind
 
2844
        self.user_encoding = osutils.get_user_encoding()
 
2845
 
 
2846
 
 
2847
class NoSuchAlias(BzrError):
 
2848
 
 
2849
    _fmt = ('The alias "%(alias_name)s" does not exist.')
 
2850
 
 
2851
    def __init__(self, alias_name):
 
2852
        BzrError.__init__(self, alias_name=alias_name)
 
2853
 
 
2854
 
 
2855
class DirectoryLookupFailure(BzrError):
 
2856
    """Base type for lookup errors."""
 
2857
 
 
2858
    pass
 
2859
 
 
2860
 
 
2861
class InvalidLocationAlias(DirectoryLookupFailure):
 
2862
 
 
2863
    _fmt = '"%(alias_name)s" is not a valid location alias.'
 
2864
 
 
2865
    def __init__(self, alias_name):
 
2866
        DirectoryLookupFailure.__init__(self, alias_name=alias_name)
 
2867
 
 
2868
 
 
2869
class UnsetLocationAlias(DirectoryLookupFailure):
 
2870
 
 
2871
    _fmt = 'No %(alias_name)s location assigned.'
 
2872
 
 
2873
    def __init__(self, alias_name):
 
2874
        DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
 
2875
 
 
2876
 
 
2877
class CannotBindAddress(BzrError):
 
2878
 
 
2879
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
 
2880
 
 
2881
    def __init__(self, host, port, orig_error):
 
2882
        BzrError.__init__(self, host=host, port=port,
 
2883
            orig_error=orig_error[1])
 
2884
 
 
2885
 
 
2886
class UnknownRules(BzrError):
 
2887
 
 
2888
    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
 
2889
 
 
2890
    def __init__(self, unknowns):
 
2891
        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
 
2892
 
 
2893
 
 
2894
class HookFailed(BzrError):
 
2895
    """Raised when a pre_change_branch_tip hook function fails anything other
 
2896
    than TipChangeRejected.
 
2897
    """
 
2898
 
 
2899
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
 
2900
            "%(traceback_text)s%(exc_value)s")
 
2901
 
 
2902
    def __init__(self, hook_stage, hook_name, exc_info):
 
2903
        import traceback
 
2904
        self.hook_stage = hook_stage
 
2905
        self.hook_name = hook_name
 
2906
        self.exc_info = exc_info
 
2907
        self.exc_type = exc_info[0]
 
2908
        self.exc_value = exc_info[1]
 
2909
        self.exc_tb = exc_info[2]
 
2910
        self.traceback_text = ''.join(traceback.format_tb(self.exc_tb))
 
2911
 
 
2912
 
 
2913
class TipChangeRejected(BzrError):
 
2914
    """A pre_change_branch_tip hook function may raise this to cleanly and
 
2915
    explicitly abort a change to a branch tip.
 
2916
    """
 
2917
    
 
2918
    _fmt = u"Tip change rejected: %(msg)s"
 
2919
 
 
2920
    def __init__(self, msg):
 
2921
        self.msg = msg
 
2922
 
 
2923
 
 
2924
class ShelfCorrupt(BzrError):
 
2925
 
 
2926
    _fmt = "Shelf corrupt."
 
2927
 
 
2928
 
 
2929
class NoSuchShelfId(BzrError):
 
2930
 
 
2931
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
 
2932
 
 
2933
    def __init__(self, shelf_id):
 
2934
        BzrError.__init__(self, shelf_id=shelf_id)
 
2935
 
 
2936
 
 
2937
class UserAbort(BzrError):
 
2938
 
 
2939
    _fmt = 'The user aborted the operation.'