← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Ian Clatworthy
  • Date: 2010-03-03 03:28:30 UTC
  • mto: (4797.31.1 integration-2.1)
  • mto: This revision was merged to the branch mainline in revision 5075.
  • Revision ID: ian.clatworthy@canonical.com-20100303032830-qf3ty4z40i410bem
add What's New to the list of PDF documents generated

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-2010 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,
32
31
 
33
32
 
34
33
# 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 
 
34
# python exceptions?   A list of values with no names seems less useful
36
35
# to me.
37
36
 
38
 
# TODO: Perhaps convert the exception to a string at the moment it's 
 
37
# TODO: Perhaps convert the exception to a string at the moment it's
39
38
# constructed to make sure it will succeed.  But that says nothing about
40
39
# exceptions that are never raised.
41
40
 
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.
56
61
    :cvar _fmt: Format string to display the error; this is expanded
57
62
    by the instance's dict.
58
63
    """
59
 
    
 
64
 
60
65
    internal_error = False
61
66
 
62
67
    def __init__(self, msg=None, **kwds):
67
72
        arguments can be given.  The first is for generic "user" errors which
68
73
        are not intended to be caught and so do not need a specific subclass.
69
74
        The second case is for use with subclasses that provide a _fmt format
70
 
        string to print the arguments.  
 
75
        string to print the arguments.
71
76
 
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 
 
77
        Keyword arguments are taken as parameters to the error, which can
 
78
        be inserted into the format string template.  It's recommended
 
79
        that subclasses override the __init__ method to require specific
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
110
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
108
113
                   getattr(self, '_fmt', None),
109
114
                   e)
110
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))
 
138
 
111
139
    def _get_format_string(self):
112
140
        """Return format string for this exception or None"""
113
141
        fmt = getattr(self, '_fmt', None)
125
153
               getattr(self, '_fmt', None),
126
154
               )
127
155
 
 
156
    def __eq__(self, other):
 
157
        if self.__class__ is not 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."""
160
204
 
161
205
 
162
206
class AlreadyBuilding(BzrError):
163
 
    
 
207
 
164
208
    _fmt = "The tree builder is already building a tree."
165
209
 
166
210
 
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 DisabledMethod(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):
179
238
 
180
239
    _fmt = "The smart server method '%(class_name)s' is disabled."
181
240
 
182
 
    internal_error = True
183
 
 
184
241
    def __init__(self, class_name):
185
242
        BzrError.__init__(self)
186
243
        self.class_name = class_name
198
255
        self.current = current
199
256
 
200
257
 
201
 
class InvalidEntryName(BzrError):
202
 
    
 
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):
 
268
 
203
269
    _fmt = "Invalid entry name: %(name)s"
204
270
 
205
 
    internal_error = True
206
 
 
207
271
    def __init__(self, name):
208
272
        BzrError.__init__(self)
209
273
        self.name = name
210
274
 
211
275
 
212
276
class InvalidRevisionNumber(BzrError):
213
 
    
 
277
 
214
278
    _fmt = "Invalid revision number %(revno)s"
215
279
 
216
280
    def __init__(self, revno):
228
292
        self.revision_id = revision_id
229
293
        self.branch = branch
230
294
 
 
295
 
231
296
class ReservedId(BzrError):
232
297
 
233
298
    _fmt = "Reserved revision-id {%(revision_id)s}"
236
301
        self.revision_id = revision_id
237
302
 
238
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
 
239
320
class NoHelpTopic(BzrError):
240
321
 
241
322
    _fmt = ("No help could be found for '%(topic)s'. "
247
328
 
248
329
class NoSuchId(BzrError):
249
330
 
250
 
    _fmt = "The file id %(file_id)s is not present in the tree %(tree)s."
251
 
    
 
331
    _fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
 
332
 
252
333
    def __init__(self, tree, file_id):
253
334
        BzrError.__init__(self)
254
335
        self.file_id = file_id
255
336
        self.tree = tree
256
337
 
257
338
 
258
 
class InventoryModified(BzrError):
 
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):
259
354
 
260
355
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
261
356
            " so a clean inventory cannot be read without data loss.")
262
357
 
263
 
    internal_error = True
264
 
 
265
358
    def __init__(self, tree):
266
359
        self.tree = tree
267
360
 
268
361
 
269
362
class NoWorkingTree(BzrError):
270
363
 
271
 
    _fmt = "No WorkingTree exists for %(base)s."
272
 
    
 
364
    _fmt = 'No WorkingTree exists for "%(base)s".'
 
365
 
273
366
    def __init__(self, base):
274
367
        BzrError.__init__(self)
275
368
        self.base = base
288
381
        self.url = url
289
382
 
290
383
 
291
 
class WorkingTreeAlreadyPopulated(BzrError):
292
 
 
293
 
    _fmt = """Working tree already populated in %(base)s"""
294
 
 
295
 
    internal_error = True
 
384
class WorkingTreeAlreadyPopulated(InternalBzrError):
 
385
 
 
386
    _fmt = 'Working tree already populated in "%(base)s"'
296
387
 
297
388
    def __init__(self, base):
298
389
        self.base = base
299
390
 
 
391
 
300
392
class BzrCommandError(BzrError):
301
393
    """Error from user command"""
302
394
 
303
 
    internal_error = False
304
 
 
305
395
    # Error from malformed user command; please avoid raising this as a
306
396
    # generic exception not caused by user input.
307
397
    #
309
399
    # are not intended to be caught anyway.  UI code need not subclass
310
400
    # BzrCommandError, and non-UI code should not throw a subclass of
311
401
    # BzrCommandError.  ADHB 20051211
312
 
    def __init__(self, msg):
313
 
        # Object.__str__() must return a real string
314
 
        # returning a Unicode string is a python error.
315
 
        if isinstance(msg, unicode):
316
 
            self.msg = msg.encode('utf8')
317
 
        else:
318
 
            self.msg = msg
319
 
 
320
 
    def __str__(self):
321
 
        return self.msg
322
402
 
323
403
 
324
404
class NotWriteLocked(BzrError):
334
414
    _fmt = "Error in command line options"
335
415
 
336
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
 
337
473
class BadOptionValue(BzrError):
338
474
 
339
475
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
341
477
    def __init__(self, name, value):
342
478
        BzrError.__init__(self, name=name, value=value)
343
479
 
344
 
    
 
480
 
345
481
class StrictCommitFailed(BzrError):
346
482
 
347
483
    _fmt = "Commit refused because there are unknown files in the tree"
350
486
# XXX: Should be unified with TransportError; they seem to represent the
351
487
# same thing
352
488
# RBC 20060929: I think that unifiying with TransportError would be a mistake
353
 
# - this is finer than a TransportError - and more useful as such. It 
 
489
# - this is finer than a TransportError - and more useful as such. It
354
490
# differentiates between 'transport has failed' and 'operation on a transport
355
491
# has failed.'
356
492
class PathError(BzrError):
357
 
    
 
493
 
358
494
    _fmt = "Generic path error: %(path)r%(extra)s)"
359
495
 
360
496
    def __init__(self, path, extra=None):
380
516
    """Used when renaming and both source and dest exist."""
381
517
 
382
518
    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
383
 
            "%(extra)s")
 
519
            " (Use --after to tell bzr about a rename that has already"
 
520
            " happened)%(extra)s")
384
521
 
385
522
    def __init__(self, source, dest, extra=None):
386
523
        BzrError.__init__(self)
394
531
 
395
532
class NotADirectory(PathError):
396
533
 
397
 
    _fmt = "%(path)r is not a directory %(extra)s"
 
534
    _fmt = '"%(path)s" is not a directory %(extra)s'
398
535
 
399
536
 
400
537
class NotInWorkingDirectory(PathError):
401
538
 
402
 
    _fmt = "%(path)r is not in the working directory %(extra)s"
 
539
    _fmt = '"%(path)s" is not in the working directory %(extra)s'
403
540
 
404
541
 
405
542
class DirectoryNotEmpty(PathError):
406
543
 
407
 
    _fmt = "Directory not empty: %(path)r%(extra)s"
408
 
 
409
 
 
410
 
class ReadingCompleted(BzrError):
411
 
    
 
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):
 
553
 
412
554
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
413
555
            "called upon it - the request has been completed and no more "
414
556
            "data may be read.")
415
557
 
416
 
    internal_error = True
417
 
 
418
558
    def __init__(self, request):
419
559
        self.request = request
420
560
 
421
561
 
422
562
class ResourceBusy(PathError):
423
563
 
424
 
    _fmt = "Device or resource busy: %(path)r%(extra)s"
 
564
    _fmt = 'Device or resource busy: "%(path)s"%(extra)s'
425
565
 
426
566
 
427
567
class PermissionDenied(PathError):
428
568
 
429
 
    _fmt = "Permission denied: %(path)r%(extra)s"
 
569
    _fmt = 'Permission denied: "%(path)s"%(extra)s'
430
570
 
431
571
 
432
572
class InvalidURL(PathError):
433
573
 
434
 
    _fmt = "Invalid url supplied to transport: %(path)r%(extra)s"
 
574
    _fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
435
575
 
436
576
 
437
577
class InvalidURLJoin(PathError):
438
578
 
439
 
    _fmt = "Invalid URL join request: %(args)s%(extra)s"
440
 
 
441
 
    def __init__(self, msg, base, args):
442
 
        PathError.__init__(self, base, msg)
443
 
        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
444
608
 
445
609
 
446
610
class UnknownHook(BzrError):
461
625
        PathError.__init__(self, url, extra=extra)
462
626
 
463
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 UnstackableLocationError(BzrError):
 
640
 
 
641
    _fmt = "The branch '%(branch_url)s' cannot be stacked on '%(target_url)s'."
 
642
 
 
643
    def __init__(self, branch_url, target_url):
 
644
        BzrError.__init__(self)
 
645
        self.branch_url = branch_url
 
646
        self.target_url = target_url
 
647
 
 
648
 
 
649
class UnstackableRepositoryFormat(BzrError):
 
650
 
 
651
    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
 
652
        "You will need to upgrade the repository to permit branch stacking.")
 
653
 
 
654
    def __init__(self, format, url):
 
655
        BzrError.__init__(self)
 
656
        self.format = format
 
657
        self.url = url
 
658
 
 
659
 
464
660
class ReadError(PathError):
465
 
    
 
661
 
466
662
    _fmt = """Error reading from %(path)r."""
467
663
 
468
664
 
469
665
class ShortReadvError(PathError):
470
666
 
471
 
    _fmt = ("readv() read %(actual)s bytes rather than %(length)s bytes"
472
 
            " at %(offset)s for %(path)s%(extra)s")
 
667
    _fmt = ('readv() read %(actual)s bytes rather than %(length)s bytes'
 
668
            ' at %(offset)s for "%(path)s"%(extra)s')
473
669
 
474
670
    internal_error = True
475
671
 
480
676
        self.actual = actual
481
677
 
482
678
 
483
 
class PathNotChild(BzrError):
 
679
class PathNotChild(PathError):
484
680
 
485
 
    _fmt = "Path %(path)r is not a child of path %(base)r%(extra)s"
 
681
    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
486
682
 
487
683
    internal_error = True
488
684
 
498
694
 
499
695
class InvalidNormalization(PathError):
500
696
 
501
 
    _fmt = "Path %(path)r is not unicode normalized"
 
697
    _fmt = 'Path "%(path)s" is not unicode normalized'
502
698
 
503
699
 
504
700
# TODO: This is given a URL; we try to unescape it but doing that from inside
505
701
# the exception object is a bit undesirable.
506
 
# TODO: Probably this behavior of should be a common superclass 
 
702
# TODO: Probably this behavior of should be a common superclass
507
703
class NotBranchError(PathError):
508
704
 
509
 
    _fmt = "Not a branch: %(path)s"
 
705
    _fmt = 'Not a branch: "%(path)s"%(detail)s.'
510
706
 
511
 
    def __init__(self, path):
 
707
    def __init__(self, path, detail=None, bzrdir=None):
512
708
       import bzrlib.urlutils as urlutils
513
 
       self.path = urlutils.unescape_for_display(path, 'ascii')
 
709
       path = urlutils.unescape_for_display(path, 'ascii')
 
710
       if detail is not None:
 
711
           detail = ': ' + detail
 
712
       self.detail = detail
 
713
       self.bzrdir = bzrdir
 
714
       PathError.__init__(self, path=path)
 
715
 
 
716
    def _format(self):
 
717
        # XXX: Ideally self.detail would be a property, but Exceptions in
 
718
        # Python 2.4 have to be old-style classes so properties don't work.
 
719
        # Instead we override _format.
 
720
        if self.detail is None:
 
721
            if self.bzrdir is not None:
 
722
                try:
 
723
                    self.bzrdir.open_repository()
 
724
                except NoRepositoryPresent:
 
725
                    self.detail = ''
 
726
                else:
 
727
                    self.detail = ': location is a repository'
 
728
            else:
 
729
                self.detail = ''
 
730
        return PathError._format(self)
514
731
 
515
732
 
516
733
class NoSubmitBranch(PathError):
524
741
 
525
742
class AlreadyBranchError(PathError):
526
743
 
527
 
    _fmt = "Already a branch: %(path)s."
 
744
    _fmt = 'Already a branch: "%(path)s".'
528
745
 
529
746
 
530
747
class BranchExistsWithoutWorkingTree(PathError):
531
748
 
532
 
    _fmt = "Directory contains a branch, but no working tree \
533
 
(use bzr checkout if you wish to build a working tree): %(path)s"
 
749
    _fmt = 'Directory contains a branch, but no working tree \
 
750
(use bzr checkout if you wish to build a working tree): "%(path)s"'
534
751
 
535
752
 
536
753
class AtomicFileAlreadyClosed(PathError):
537
754
 
538
 
    _fmt = ("'%(function)s' called on an AtomicFile after it was closed:"
539
 
            " %(path)s")
 
755
    _fmt = ('"%(function)s" called on an AtomicFile after it was closed:'
 
756
            ' "%(path)s"')
540
757
 
541
758
    def __init__(self, path, function):
542
759
        PathError.__init__(self, path=path, extra=None)
545
762
 
546
763
class InaccessibleParent(PathError):
547
764
 
548
 
    _fmt = ("Parent not accessible given base %(base)s and"
549
 
            " relative path %(path)s")
 
765
    _fmt = ('Parent not accessible given base "%(base)s" and'
 
766
            ' relative path "%(path)s"')
550
767
 
551
768
    def __init__(self, path, base):
552
769
        PathError.__init__(self, path)
555
772
 
556
773
class NoRepositoryPresent(BzrError):
557
774
 
558
 
    _fmt = "No repository present: %(path)r"
 
775
    _fmt = 'No repository present: "%(path)s"'
559
776
    def __init__(self, bzrdir):
560
777
        BzrError.__init__(self)
561
778
        self.path = bzrdir.transport.clone('..').base
563
780
 
564
781
class FileInWrongBranch(BzrError):
565
782
 
566
 
    _fmt = "File %(path)s in not in branch %(branch_base)s."
 
783
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
567
784
 
568
785
    def __init__(self, branch, path):
569
786
        BzrError.__init__(self)
578
795
 
579
796
 
580
797
class UnknownFormatError(BzrError):
581
 
    
582
 
    _fmt = "Unknown branch format: %(format)r"
 
798
 
 
799
    _fmt = "Unknown %(kind)s format: %(format)r"
 
800
 
 
801
    def __init__(self, format, kind='branch'):
 
802
        self.kind = kind
 
803
        self.format = format
583
804
 
584
805
 
585
806
class IncompatibleFormat(BzrError):
586
 
    
 
807
 
587
808
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
588
809
 
589
810
    def __init__(self, format, bzrdir_format):
593
814
 
594
815
 
595
816
class IncompatibleRepositories(BzrError):
596
 
 
597
 
    _fmt = "Repository %(target)s is not compatible with repository"\
598
 
        " %(source)s"
599
 
 
600
 
    def __init__(self, source, target):
601
 
        BzrError.__init__(self, target=target, source=source)
 
817
    """Report an error that two repositories are not compatible.
 
818
 
 
819
    Note that the source and target repositories are permitted to be strings:
 
820
    this exception is thrown from the smart server and may refer to a
 
821
    repository the client hasn't opened.
 
822
    """
 
823
 
 
824
    _fmt = "%(target)s\n" \
 
825
            "is not compatible with\n" \
 
826
            "%(source)s\n" \
 
827
            "%(details)s"
 
828
 
 
829
    def __init__(self, source, target, details=None):
 
830
        if details is None:
 
831
            details = "(no details)"
 
832
        BzrError.__init__(self, target=target, source=source, details=details)
602
833
 
603
834
 
604
835
class IncompatibleRevision(BzrError):
605
 
    
 
836
 
606
837
    _fmt = "Revision is not compatible with %(repo_format)s"
607
838
 
608
839
    def __init__(self, repo_format):
613
844
class AlreadyVersionedError(BzrError):
614
845
    """Used when a path is expected not to be versioned, but it is."""
615
846
 
616
 
    _fmt = "%(context_info)s%(path)s is already versioned"
 
847
    _fmt = "%(context_info)s%(path)s is already versioned."
617
848
 
618
849
    def __init__(self, path, context_info=None):
619
850
        """Construct a new AlreadyVersionedError.
634
865
class NotVersionedError(BzrError):
635
866
    """Used when a path is expected to be versioned, but it is not."""
636
867
 
637
 
    _fmt = "%(context_info)s%(path)s is not versioned"
 
868
    _fmt = "%(context_info)s%(path)s is not versioned."
638
869
 
639
870
    def __init__(self, path, context_info=None):
640
871
        """Construct a new NotVersionedError.
691
922
        BzrError.__init__(self, filename=filename, kind=kind)
692
923
 
693
924
 
 
925
class BadFilenameEncoding(BzrError):
 
926
 
 
927
    _fmt = ('Filename %(filename)r is not valid in your current filesystem'
 
928
            ' encoding %(fs_encoding)s')
 
929
 
 
930
    def __init__(self, filename, fs_encoding):
 
931
        BzrError.__init__(self)
 
932
        self.filename = filename
 
933
        self.fs_encoding = fs_encoding
 
934
 
 
935
 
694
936
class ForbiddenControlFileError(BzrError):
695
937
 
696
 
    _fmt = "Cannot operate on %(filename)s because it is a control file"
697
 
 
698
 
 
699
 
class LockError(BzrError):
 
938
    _fmt = 'Cannot operate on "%(filename)s" because it is a control file'
 
939
 
 
940
 
 
941
class LockError(InternalBzrError):
700
942
 
701
943
    _fmt = "Lock error: %(msg)s"
702
944
 
703
 
    internal_error = True
704
 
 
705
945
    # All exceptions from the lock/unlock functions should be from
706
946
    # this exception class.  They will be translated as necessary. The
707
947
    # original exception is available as e.original_error
709
949
    # New code should prefer to raise specific subclasses
710
950
    def __init__(self, message):
711
951
        # Python 2.5 uses a slot for StandardError.message,
712
 
        # so use a different variable name
713
 
        # so it is exposed in self.__dict__
 
952
        # so use a different variable name.  We now work around this in
 
953
        # BzrError.__str__, but this member name is kept for compatability.
714
954
        self.msg = message
715
955
 
716
956
 
751
991
        self.obj = obj
752
992
 
753
993
 
754
 
class ReadOnlyLockError(LockError):
755
 
 
756
 
    _fmt = "Cannot acquire write lock on %(fname)s. %(msg)s"
757
 
 
758
 
    def __init__(self, fname, msg):
 
994
class LockFailed(LockError):
 
995
 
 
996
    internal_error = False
 
997
 
 
998
    _fmt = "Cannot lock %(lock)s: %(why)s"
 
999
 
 
1000
    def __init__(self, lock, why):
759
1001
        LockError.__init__(self, '')
760
 
        self.fname = fname
761
 
        self.msg = msg
 
1002
        self.lock = lock
 
1003
        self.why = why
762
1004
 
763
1005
 
764
1006
class OutSideTransaction(BzrError):
788
1030
 
789
1031
class UnlockableTransport(LockError):
790
1032
 
 
1033
    internal_error = False
 
1034
 
791
1035
    _fmt = "Cannot lock: transport is read only: %(transport)s"
792
1036
 
793
1037
    def __init__(self, transport):
796
1040
 
797
1041
class LockContention(LockError):
798
1042
 
799
 
    _fmt = "Could not acquire lock %(lock)s"
 
1043
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
800
1044
    # TODO: show full url for lock, combining the transport and relative
801
1045
    # bits?
802
1046
 
803
1047
    internal_error = False
804
1048
 
805
 
    def __init__(self, lock):
 
1049
    def __init__(self, lock, msg=''):
806
1050
        self.lock = lock
 
1051
        self.msg = msg
807
1052
 
808
1053
 
809
1054
class LockBroken(LockError):
844
1089
 
845
1090
    _fmt = "The object %(obj)s does not support token specifying a token when locking."
846
1091
 
847
 
    internal_error = True
848
 
 
849
1092
    def __init__(self, obj):
850
1093
        self.obj = obj
851
1094
 
876
1119
        BzrError.__init__(self, files=files, files_str=files_str)
877
1120
 
878
1121
 
 
1122
class BadCommitMessageEncoding(BzrError):
 
1123
 
 
1124
    _fmt = 'The specified commit message contains characters unsupported by '\
 
1125
        'the current encoding.'
 
1126
 
 
1127
 
879
1128
class UpgradeReadonly(BzrError):
880
1129
 
881
1130
    _fmt = "Upgrade URL cannot work with readonly URLs."
895
1144
    _fmt = "Commit refused because there are unknowns in the tree."
896
1145
 
897
1146
 
898
 
class NoSuchRevision(BzrError):
899
 
 
900
 
    _fmt = "Branch %(branch)s has no revision %(revision)s"
901
 
 
902
 
    internal_error = True
 
1147
class NoSuchRevision(InternalBzrError):
 
1148
 
 
1149
    _fmt = "%(branch)s has no revision %(revision)s"
903
1150
 
904
1151
    def __init__(self, branch, revision):
 
1152
        # 'branch' may sometimes be an internal object like a KnitRevisionStore
905
1153
        BzrError.__init__(self, branch=branch, revision=revision)
906
1154
 
907
1155
 
908
 
class NotLeftParentDescendant(BzrError):
909
 
 
910
 
    _fmt = ("Revision %(old_revision)s is not the left parent of"
911
 
            " %(new_revision)s, but branch %(branch_location)s expects this")
912
 
 
913
 
    internal_error = True
914
 
 
915
 
    def __init__(self, branch, old_revision, new_revision):
916
 
        BzrError.__init__(self, branch_location=branch.base,
917
 
                          old_revision=old_revision,
918
 
                          new_revision=new_revision)
 
1156
class RangeInChangeOption(BzrError):
 
1157
 
 
1158
    _fmt = "Option --change does not accept revision ranges"
919
1159
 
920
1160
 
921
1161
class NoSuchRevisionSpec(BzrError):
928
1168
 
929
1169
class NoSuchRevisionInTree(NoSuchRevision):
930
1170
    """When using Tree.revision_tree, and the revision is not accessible."""
931
 
    
932
 
    _fmt = "The revision id %(revision_id)s is not present in the tree %(tree)s."
 
1171
 
 
1172
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
933
1173
 
934
1174
    def __init__(self, tree, revision_id):
935
1175
        BzrError.__init__(self)
970
1210
class DivergedBranches(BzrError):
971
1211
 
972
1212
    _fmt = ("These branches have diverged."
973
 
            " Use the merge command to reconcile them.")
974
 
 
975
 
    internal_error = False
 
1213
            " Use the missing command to see how.\n"
 
1214
            "Use the merge command to reconcile them.")
976
1215
 
977
1216
    def __init__(self, branch1, branch2):
978
1217
        self.branch1 = branch1
979
1218
        self.branch2 = branch2
980
1219
 
981
1220
 
982
 
class NotLefthandHistory(BzrError):
 
1221
class NotLefthandHistory(InternalBzrError):
983
1222
 
984
1223
    _fmt = "Supplied history does not follow left-hand parents"
985
1224
 
986
 
    internal_error = True
987
 
 
988
1225
    def __init__(self, history):
989
1226
        BzrError.__init__(self, history=history)
990
1227
 
994
1231
    _fmt = ("Branches have no common ancestor, and"
995
1232
            " no merge base revision was specified.")
996
1233
 
997
 
    internal_error = False
 
1234
 
 
1235
class CannotReverseCherrypick(BzrError):
 
1236
 
 
1237
    _fmt = ('Selected merge cannot perform reverse cherrypicks.  Try merge3'
 
1238
            ' or diff3.')
998
1239
 
999
1240
 
1000
1241
class NoCommonAncestor(BzrError):
1001
 
    
 
1242
 
1002
1243
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1003
1244
 
1004
1245
    def __init__(self, revision_a, revision_b):
1024
1265
            not_ancestor_id=not_ancestor_id)
1025
1266
 
1026
1267
 
1027
 
class InstallFailed(BzrError):
1028
 
 
1029
 
    def __init__(self, revisions):
1030
 
        revision_str = ", ".join(str(r) for r in revisions)
1031
 
        msg = "Could not install revisions:\n%s" % revision_str
1032
 
        BzrError.__init__(self, msg)
1033
 
        self.revisions = revisions
1034
 
 
1035
 
 
1036
1268
class AmbiguousBase(BzrError):
1037
1269
 
1038
1270
    def __init__(self, bases):
1039
 
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
1040
 
                DeprecationWarning)
 
1271
        symbol_versioning.warn("BzrError AmbiguousBase has been deprecated "
 
1272
            "as of bzrlib 0.8.", DeprecationWarning, stacklevel=2)
1041
1273
        msg = ("The correct base is unclear, because %s are all equally close"
1042
1274
                % ", ".join(bases))
1043
1275
        BzrError.__init__(self, msg)
1044
1276
        self.bases = bases
1045
1277
 
1046
1278
 
1047
 
class NoCommits(BzrError):
 
1279
class NoCommits(BranchError):
1048
1280
 
1049
1281
    _fmt = "Branch %(branch)s has no commits."
1050
1282
 
1051
 
    def __init__(self, branch):
1052
 
        BzrError.__init__(self, branch=branch)
1053
 
 
1054
1283
 
1055
1284
class UnlistableStore(BzrError):
1056
1285
 
1067
1296
 
1068
1297
class BoundBranchOutOfDate(BzrError):
1069
1298
 
1070
 
    _fmt = ("Bound branch %(branch)s is out of date"
1071
 
            " with master branch %(master)s.")
 
1299
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
 
1300
            " %(master)s.")
1072
1301
 
1073
1302
    def __init__(self, branch, master):
1074
1303
        BzrError.__init__(self)
1075
1304
        self.branch = branch
1076
1305
        self.master = master
1077
1306
 
1078
 
        
 
1307
 
1079
1308
class CommitToDoubleBoundBranch(BzrError):
1080
1309
 
1081
1310
    _fmt = ("Cannot commit to branch %(branch)s."
1111
1340
 
1112
1341
class WeaveError(BzrError):
1113
1342
 
1114
 
    _fmt = "Error in processing weave: %(message)s"
 
1343
    _fmt = "Error in processing weave: %(msg)s"
1115
1344
 
1116
 
    def __init__(self, message=None):
 
1345
    def __init__(self, msg=None):
1117
1346
        BzrError.__init__(self)
1118
 
        self.message = message
 
1347
        self.msg = msg
1119
1348
 
1120
1349
 
1121
1350
class WeaveRevisionAlreadyPresent(WeaveError):
1150
1379
 
1151
1380
class WeaveParentMismatch(WeaveError):
1152
1381
 
1153
 
    _fmt = "Parents are mismatched between two revisions."
1154
 
    
 
1382
    _fmt = "Parents are mismatched between two revisions. %(message)s"
 
1383
 
1155
1384
 
1156
1385
class WeaveInvalidChecksum(WeaveError):
1157
1386
 
1183
1412
 
1184
1413
 
1185
1414
class VersionedFileError(BzrError):
1186
 
    
 
1415
 
1187
1416
    _fmt = "Versioned file error"
1188
1417
 
1189
1418
 
1190
1419
class RevisionNotPresent(VersionedFileError):
1191
 
    
1192
 
    _fmt = "Revision {%(revision_id)s} not present in %(file_id)s."
 
1420
 
 
1421
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1193
1422
 
1194
1423
    def __init__(self, revision_id, file_id):
1195
1424
        VersionedFileError.__init__(self)
1198
1427
 
1199
1428
 
1200
1429
class RevisionAlreadyPresent(VersionedFileError):
1201
 
    
1202
 
    _fmt = "Revision {%(revision_id)s} already present in %(file_id)s."
 
1430
 
 
1431
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1203
1432
 
1204
1433
    def __init__(self, revision_id, file_id):
1205
1434
        VersionedFileError.__init__(self)
1207
1436
        self.file_id = file_id
1208
1437
 
1209
1438
 
1210
 
class KnitError(BzrError):
1211
 
    
 
1439
class VersionedFileInvalidChecksum(VersionedFileError):
 
1440
 
 
1441
    _fmt = "Text did not match its checksum: %(message)s"
 
1442
 
 
1443
 
 
1444
class KnitError(InternalBzrError):
 
1445
 
1212
1446
    _fmt = "Knit error"
1213
1447
 
1214
 
    internal_error = True
1215
 
 
1216
 
 
1217
 
class KnitHeaderError(KnitError):
1218
 
 
1219
 
    _fmt = "Knit header error: %(badline)r unexpected for file %(filename)s"
1220
 
 
1221
 
    def __init__(self, badline, filename):
1222
 
        KnitError.__init__(self)
1223
 
        self.badline = badline
1224
 
        self.filename = filename
1225
 
 
1226
1448
 
1227
1449
class KnitCorrupt(KnitError):
1228
1450
 
1234
1456
        self.how = how
1235
1457
 
1236
1458
 
 
1459
class SHA1KnitCorrupt(KnitCorrupt):
 
1460
 
 
1461
    _fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "
 
1462
        "match expected sha-1. key %(key)s expected sha %(expected)s actual "
 
1463
        "sha %(actual)s")
 
1464
 
 
1465
    def __init__(self, filename, actual, expected, key, content):
 
1466
        KnitError.__init__(self)
 
1467
        self.filename = filename
 
1468
        self.actual = actual
 
1469
        self.expected = expected
 
1470
        self.key = key
 
1471
        self.content = content
 
1472
 
 
1473
 
 
1474
class KnitDataStreamIncompatible(KnitError):
 
1475
    # Not raised anymore, as we can convert data streams.  In future we may
 
1476
    # need it again for more exotic cases, so we're keeping it around for now.
 
1477
 
 
1478
    _fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."
 
1479
 
 
1480
    def __init__(self, stream_format, target_format):
 
1481
        self.stream_format = stream_format
 
1482
        self.target_format = target_format
 
1483
 
 
1484
 
 
1485
class KnitDataStreamUnknown(KnitError):
 
1486
    # Indicates a data stream we don't know how to handle.
 
1487
 
 
1488
    _fmt = "Cannot parse knit data stream of format \"%(stream_format)s\"."
 
1489
 
 
1490
    def __init__(self, stream_format):
 
1491
        self.stream_format = stream_format
 
1492
 
 
1493
 
 
1494
class KnitHeaderError(KnitError):
 
1495
 
 
1496
    _fmt = 'Knit header error: %(badline)r unexpected for file "%(filename)s".'
 
1497
 
 
1498
    def __init__(self, badline, filename):
 
1499
        KnitError.__init__(self)
 
1500
        self.badline = badline
 
1501
        self.filename = filename
 
1502
 
1237
1503
class KnitIndexUnknownMethod(KnitError):
1238
1504
    """Raised when we don't understand the storage method.
1239
1505
 
1240
1506
    Currently only 'fulltext' and 'line-delta' are supported.
1241
1507
    """
1242
 
    
 
1508
 
1243
1509
    _fmt = ("Knit index %(filename)s does not have a known method"
1244
1510
            " in options: %(options)r")
1245
1511
 
1249
1515
        self.options = options
1250
1516
 
1251
1517
 
 
1518
class RetryWithNewPacks(BzrError):
 
1519
    """Raised when we realize that the packs on disk have changed.
 
1520
 
 
1521
    This is meant as more of a signaling exception, to trap between where a
 
1522
    local error occurred and the code that can actually handle the error and
 
1523
    code that can retry appropriately.
 
1524
    """
 
1525
 
 
1526
    internal_error = True
 
1527
 
 
1528
    _fmt = ("Pack files have changed, reload and retry. context: %(context)s"
 
1529
            " %(orig_error)s")
 
1530
 
 
1531
    def __init__(self, context, reload_occurred, exc_info):
 
1532
        """create a new RetryWithNewPacks error.
 
1533
 
 
1534
        :param reload_occurred: Set to True if we know that the packs have
 
1535
            already been reloaded, and we are failing because of an in-memory
 
1536
            cache miss. If set to True then we will ignore if a reload says
 
1537
            nothing has changed, because we assume it has already reloaded. If
 
1538
            False, then a reload with nothing changed will force an error.
 
1539
        :param exc_info: The original exception traceback, so if there is a
 
1540
            problem we can raise the original error (value from sys.exc_info())
 
1541
        """
 
1542
        BzrError.__init__(self)
 
1543
        self.reload_occurred = reload_occurred
 
1544
        self.exc_info = exc_info
 
1545
        self.orig_error = exc_info[1]
 
1546
        # TODO: The global error handler should probably treat this by
 
1547
        #       raising/printing the original exception with a bit about
 
1548
        #       RetryWithNewPacks also not being caught
 
1549
 
 
1550
 
 
1551
class RetryAutopack(RetryWithNewPacks):
 
1552
    """Raised when we are autopacking and we find a missing file.
 
1553
 
 
1554
    Meant as a signaling exception, to tell the autopack code it should try
 
1555
    again.
 
1556
    """
 
1557
 
 
1558
    internal_error = True
 
1559
 
 
1560
    _fmt = ("Pack files have changed, reload and try autopack again."
 
1561
            " context: %(context)s %(orig_error)s")
 
1562
 
 
1563
 
1252
1564
class NoSuchExportFormat(BzrError):
1253
 
    
 
1565
 
1254
1566
    _fmt = "Export format %(format)r not supported"
1255
1567
 
1256
1568
    def __init__(self, format):
1259
1571
 
1260
1572
 
1261
1573
class TransportError(BzrError):
1262
 
    
 
1574
 
1263
1575
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1264
1576
 
1265
1577
    def __init__(self, msg=None, orig_error=None):
1274
1586
        BzrError.__init__(self)
1275
1587
 
1276
1588
 
1277
 
class TooManyConcurrentRequests(BzrError):
 
1589
class TooManyConcurrentRequests(InternalBzrError):
1278
1590
 
1279
1591
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
1280
1592
            " Be sure to finish_writing and finish_reading on the"
1281
1593
            " currently open request.")
1282
1594
 
1283
 
    internal_error = True
1284
 
 
1285
1595
    def __init__(self, medium):
1286
1596
        self.medium = medium
1287
1597
 
1294
1604
        self.details = details
1295
1605
 
1296
1606
 
 
1607
class UnexpectedProtocolVersionMarker(TransportError):
 
1608
 
 
1609
    _fmt = "Received bad protocol version marker: %(marker)r"
 
1610
 
 
1611
    def __init__(self, marker):
 
1612
        self.marker = marker
 
1613
 
 
1614
 
 
1615
class UnknownSmartMethod(InternalBzrError):
 
1616
 
 
1617
    _fmt = "The server does not recognise the '%(verb)s' request."
 
1618
 
 
1619
    def __init__(self, verb):
 
1620
        self.verb = verb
 
1621
 
 
1622
 
 
1623
class SmartMessageHandlerError(InternalBzrError):
 
1624
 
 
1625
    _fmt = ("The message handler raised an exception:\n"
 
1626
            "%(traceback_text)s")
 
1627
 
 
1628
    def __init__(self, exc_info):
 
1629
        import traceback
 
1630
        self.exc_type, self.exc_value, self.exc_tb = exc_info
 
1631
        self.exc_info = exc_info
 
1632
        traceback_strings = traceback.format_exception(
 
1633
                self.exc_type, self.exc_value, self.exc_tb)
 
1634
        self.traceback_text = ''.join(traceback_strings)
 
1635
 
 
1636
 
1297
1637
# A set of semi-meaningful errors which can be thrown
1298
1638
class TransportNotPossible(TransportError):
1299
1639
 
1324
1664
            self.port = ':%s' % port
1325
1665
 
1326
1666
 
 
1667
# XXX: This is also used for unexpected end of file, which is different at the
 
1668
# TCP level from "connection reset".
1327
1669
class ConnectionReset(TransportError):
1328
1670
 
1329
1671
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1331
1673
 
1332
1674
class InvalidRange(TransportError):
1333
1675
 
1334
 
    _fmt = "Invalid range access in %(path)s at %(offset)s."
1335
 
    
1336
 
    def __init__(self, path, offset):
1337
 
        TransportError.__init__(self, ("Invalid range access in %s at %d"
1338
 
                                       % (path, offset)))
 
1676
    _fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
 
1677
 
 
1678
    def __init__(self, path, offset, msg=None):
 
1679
        TransportError.__init__(self, msg)
1339
1680
        self.path = path
1340
1681
        self.offset = offset
1341
1682
 
1352
1693
class InvalidHttpRange(InvalidHttpResponse):
1353
1694
 
1354
1695
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1355
 
    
 
1696
 
1356
1697
    def __init__(self, path, range, msg):
1357
1698
        self.range = range
1358
1699
        InvalidHttpResponse.__init__(self, path, msg)
1361
1702
class InvalidHttpContentType(InvalidHttpResponse):
1362
1703
 
1363
1704
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1364
 
    
 
1705
 
1365
1706
    def __init__(self, path, ctype, msg):
1366
1707
        self.ctype = ctype
1367
1708
        InvalidHttpResponse.__init__(self, path, msg)
1371
1712
 
1372
1713
    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1373
1714
 
1374
 
    def __init__(self, source, target, is_permament=False, qual_proto=None):
 
1715
    def __init__(self, source, target, is_permanent=False):
1375
1716
        self.source = source
1376
1717
        self.target = target
1377
 
        if is_permament:
 
1718
        if is_permanent:
1378
1719
            self.permanently = ' permanently'
1379
1720
        else:
1380
1721
            self.permanently = ''
1381
 
        self.is_permament = is_permament
1382
 
        self._qualified_proto = qual_proto
1383
1722
        TransportError.__init__(self)
1384
1723
 
1385
 
    def _requalify_url(self, url):
1386
 
        """Restore the qualified proto in front of the url"""
1387
 
        # When this exception is raised, source and target are in
1388
 
        # user readable format. But some transports may use a
1389
 
        # different proto (http+urllib:// will present http:// to
1390
 
        # the user. If a qualified proto is specified, the code
1391
 
        # trapping the exception can get the qualified urls to
1392
 
        # properly handle the redirection themself (creating a
1393
 
        # new transport object from the target url for example).
1394
 
        # But checking that the scheme of the original and
1395
 
        # redirected urls are the same can be tricky. (see the
1396
 
        # FIXME in BzrDir.open_from_transport for the unique use
1397
 
        # case so far).
1398
 
        if self._qualified_proto is None:
1399
 
            return url
1400
 
 
1401
 
        # The TODO related to NotBranchError mention that doing
1402
 
        # that kind of manipulation on the urls may not be the
1403
 
        # exception object job. On the other hand, this object is
1404
 
        # the interface between the code and the user so
1405
 
        # presenting the urls in different ways is indeed its
1406
 
        # job...
1407
 
        import urlparse
1408
 
        proto, netloc, path, query, fragment = urlparse.urlsplit(url)
1409
 
        return urlparse.urlunsplit((self._qualified_proto, netloc, path,
1410
 
                                   query, fragment))
1411
 
 
1412
 
    def get_source_url(self):
1413
 
        return self._requalify_url(self.source)
1414
 
 
1415
 
    def get_target_url(self):
1416
 
        return self._requalify_url(self.target)
1417
 
 
1418
1724
 
1419
1725
class TooManyRedirections(TransportError):
1420
1726
 
1421
1727
    _fmt = "Too many redirections"
1422
1728
 
 
1729
 
1423
1730
class ConflictsInTree(BzrError):
1424
1731
 
1425
1732
    _fmt = "Working tree has conflicts."
1431
1738
        if filename is None:
1432
1739
            filename = ""
1433
1740
        message = "Error(s) parsing config file %s:\n%s" % \
1434
 
            (filename, ('\n'.join(e.message for e in errors)))
 
1741
            (filename, ('\n'.join(e.msg for e in errors)))
1435
1742
        BzrError.__init__(self, message)
1436
1743
 
1437
1744
 
1446
1753
 
1447
1754
class SigningFailed(BzrError):
1448
1755
 
1449
 
    _fmt = "Failed to gpg sign data with command %(command_line)r"
 
1756
    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'
1450
1757
 
1451
1758
    def __init__(self, command_line):
1452
1759
        BzrError.__init__(self, command_line=command_line)
1454
1761
 
1455
1762
class WorkingTreeNotRevision(BzrError):
1456
1763
 
1457
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
 
1764
    _fmt = ("The working tree for %(basedir)s has changed since"
1458
1765
            " the last commit, but weave merge requires that it be"
1459
1766
            " unchanged")
1460
1767
 
1477
1784
        self.graph = graph
1478
1785
 
1479
1786
 
1480
 
class WritingCompleted(BzrError):
 
1787
class WritingCompleted(InternalBzrError):
1481
1788
 
1482
1789
    _fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1483
1790
            "called upon it - accept bytes may not be called anymore.")
1484
1791
 
1485
 
    internal_error = True
1486
 
 
1487
1792
    def __init__(self, request):
1488
1793
        self.request = request
1489
1794
 
1490
1795
 
1491
 
class WritingNotComplete(BzrError):
 
1796
class WritingNotComplete(InternalBzrError):
1492
1797
 
1493
1798
    _fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1494
1799
            "called upon it - until the write phase is complete no "
1495
1800
            "data may be read.")
1496
1801
 
1497
 
    internal_error = True
1498
 
 
1499
1802
    def __init__(self, request):
1500
1803
        self.request = request
1501
1804
 
1509
1812
        self.filename = filename
1510
1813
 
1511
1814
 
1512
 
class MediumNotConnected(BzrError):
 
1815
class MediumNotConnected(InternalBzrError):
1513
1816
 
1514
1817
    _fmt = """The medium '%(medium)s' is not connected."""
1515
1818
 
1516
 
    internal_error = True
1517
 
 
1518
1819
    def __init__(self, medium):
1519
1820
        self.medium = medium
1520
1821
 
1526
1827
 
1527
1828
class NoBundleFound(BzrError):
1528
1829
 
1529
 
    _fmt = "No bundle was found in %(filename)s"
 
1830
    _fmt = 'No bundle was found in "%(filename)s".'
1530
1831
 
1531
1832
    def __init__(self, filename):
1532
1833
        BzrError.__init__(self)
1596
1897
        self.root_trans_id = transform.root
1597
1898
 
1598
1899
 
1599
 
class BzrBadParameter(BzrError):
 
1900
class BzrBadParameter(InternalBzrError):
1600
1901
 
1601
1902
    _fmt = "Bad parameter: %(param)r"
1602
1903
 
1603
 
    internal_error = True
1604
 
 
1605
1904
    # This exception should never be thrown, but it is a base class for all
1606
1905
    # parameter-to-function errors.
1607
1906
 
1630
1929
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
1631
1930
 
1632
1931
    def __init__(self, from_path='', to_path='', extra=None):
 
1932
        from bzrlib.osutils import splitpath
1633
1933
        BzrError.__init__(self)
1634
1934
        if extra:
1635
1935
            self.extra = ': ' + str(extra)
1639
1939
        has_from = len(from_path) > 0
1640
1940
        has_to = len(to_path) > 0
1641
1941
        if has_from:
1642
 
            self.from_path = osutils.splitpath(from_path)[-1]
 
1942
            self.from_path = splitpath(from_path)[-1]
1643
1943
        else:
1644
1944
            self.from_path = ''
1645
1945
 
1646
1946
        if has_to:
1647
 
            self.to_path = osutils.splitpath(to_path)[-1]
 
1947
            self.to_path = splitpath(to_path)[-1]
1648
1948
        else:
1649
1949
            self.to_path = ''
1650
1950
 
1669
1969
class BzrRemoveChangedFilesError(BzrError):
1670
1970
    """Used when user is trying to remove changed files."""
1671
1971
 
1672
 
    _fmt = ("Can't remove changed or unknown files:\n%(changes_as_text)s"
 
1972
    _fmt = ("Can't safely remove modified or unknown files:\n"
 
1973
        "%(changes_as_text)s"
1673
1974
        "Use --keep to not delete them, or --force to delete them regardless.")
1674
1975
 
1675
1976
    def __init__(self, tree_delta):
1732
2033
 
1733
2034
class BadConversionTarget(BzrError):
1734
2035
 
1735
 
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
 
2036
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
 
2037
            "    %(problem)s"
1736
2038
 
1737
 
    def __init__(self, problem, format):
 
2039
    def __init__(self, problem, format, from_format=None):
1738
2040
        BzrError.__init__(self)
1739
2041
        self.problem = problem
1740
2042
        self.format = format
 
2043
        self.from_format = from_format or '(unspecified)'
 
2044
 
 
2045
 
 
2046
class NoDiffFound(BzrError):
 
2047
 
 
2048
    _fmt = 'Could not find an appropriate Differ for file "%(path)s"'
 
2049
 
 
2050
    def __init__(self, path):
 
2051
        BzrError.__init__(self, path)
 
2052
 
 
2053
 
 
2054
class ExecutableMissing(BzrError):
 
2055
 
 
2056
    _fmt = "%(exe_name)s could not be found on this machine"
 
2057
 
 
2058
    def __init__(self, exe_name):
 
2059
        BzrError.__init__(self, exe_name=exe_name)
1741
2060
 
1742
2061
 
1743
2062
class NoDiff(BzrError):
1753
2072
    _fmt = "Diff3 is not installed on this machine."
1754
2073
 
1755
2074
 
 
2075
class ExistingContent(BzrError):
 
2076
    # Added in bzrlib 0.92, used by VersionedFile.add_lines.
 
2077
 
 
2078
    _fmt = "The content being inserted is already present."
 
2079
 
 
2080
 
1756
2081
class ExistingLimbo(BzrError):
1757
2082
 
1758
2083
    _fmt = """This tree contains left-over files from a failed operation.
1759
2084
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1760
2085
    keep, and delete it when you are done."""
1761
 
    
 
2086
 
1762
2087
    def __init__(self, limbo_dir):
1763
2088
       BzrError.__init__(self)
1764
2089
       self.limbo_dir = limbo_dir
1765
2090
 
1766
2091
 
 
2092
class ExistingPendingDeletion(BzrError):
 
2093
 
 
2094
    _fmt = """This tree contains left-over files from a failed operation.
 
2095
    Please examine %(pending_deletion)s to see if it contains any files you
 
2096
    wish to keep, and delete it when you are done."""
 
2097
 
 
2098
    def __init__(self, pending_deletion):
 
2099
       BzrError.__init__(self, pending_deletion=pending_deletion)
 
2100
 
 
2101
 
1767
2102
class ImmortalLimbo(BzrError):
1768
2103
 
1769
 
    _fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
 
2104
    _fmt = """Unable to delete transform temporary directory %(limbo_dir)s.
1770
2105
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1771
2106
    keep, and delete it when you are done."""
1772
2107
 
1775
2110
       self.limbo_dir = limbo_dir
1776
2111
 
1777
2112
 
 
2113
class ImmortalPendingDeletion(BzrError):
 
2114
 
 
2115
    _fmt = ("Unable to delete transform temporary directory "
 
2116
    "%(pending_deletion)s.  Please examine %(pending_deletion)s to see if it "
 
2117
    "contains any files you wish to keep, and delete it when you are done.")
 
2118
 
 
2119
    def __init__(self, pending_deletion):
 
2120
       BzrError.__init__(self, pending_deletion=pending_deletion)
 
2121
 
 
2122
 
1778
2123
class OutOfDateTree(BzrError):
1779
2124
 
1780
 
    _fmt = "Working tree is out of date, please run 'bzr update'."
 
2125
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
1781
2126
 
1782
 
    def __init__(self, tree):
 
2127
    def __init__(self, tree, more=None):
 
2128
        if more is None:
 
2129
            more = ''
 
2130
        else:
 
2131
            more = ' ' + more
1783
2132
        BzrError.__init__(self)
1784
2133
        self.tree = tree
 
2134
        self.more = more
1785
2135
 
1786
2136
 
1787
2137
class PublicBranchOutOfDate(BzrError):
1807
2157
    _fmt = "Format error in conflict listings"
1808
2158
 
1809
2159
 
 
2160
class CorruptDirstate(BzrError):
 
2161
 
 
2162
    _fmt = ("Inconsistency in dirstate file %(dirstate_path)s.\n"
 
2163
            "Error: %(description)s")
 
2164
 
 
2165
    def __init__(self, dirstate_path, description):
 
2166
        BzrError.__init__(self)
 
2167
        self.dirstate_path = dirstate_path
 
2168
        self.description = description
 
2169
 
 
2170
 
1810
2171
class CorruptRepository(BzrError):
1811
2172
 
1812
2173
    _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
1817
2178
        self.repo_path = repo.bzrdir.root_transport.base
1818
2179
 
1819
2180
 
 
2181
class InconsistentDelta(BzrError):
 
2182
    """Used when we get a delta that is not valid."""
 
2183
 
 
2184
    _fmt = ("An inconsistent delta was supplied involving %(path)r,"
 
2185
            " %(file_id)r\nreason: %(reason)s")
 
2186
 
 
2187
    def __init__(self, path, file_id, reason):
 
2188
        BzrError.__init__(self)
 
2189
        self.path = path
 
2190
        self.file_id = file_id
 
2191
        self.reason = reason
 
2192
 
 
2193
 
 
2194
class InconsistentDeltaDelta(InconsistentDelta):
 
2195
    """Used when we get a delta that is not valid."""
 
2196
 
 
2197
    _fmt = ("An inconsistent delta was supplied: %(delta)r"
 
2198
            "\nreason: %(reason)s")
 
2199
 
 
2200
    def __init__(self, delta, reason):
 
2201
        BzrError.__init__(self)
 
2202
        self.delta = delta
 
2203
        self.reason = reason
 
2204
 
 
2205
 
1820
2206
class UpgradeRequired(BzrError):
1821
2207
 
1822
2208
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
1826
2212
        self.path = path
1827
2213
 
1828
2214
 
 
2215
class RepositoryUpgradeRequired(UpgradeRequired):
 
2216
 
 
2217
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
 
2218
 
 
2219
 
 
2220
class RichRootUpgradeRequired(UpgradeRequired):
 
2221
 
 
2222
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
 
2223
           " a format which supports rich roots.")
 
2224
 
 
2225
 
1829
2226
class LocalRequiresBoundBranch(BzrError):
1830
2227
 
1831
2228
    _fmt = "Cannot perform local-only commits on unbound branches."
1832
2229
 
1833
2230
 
1834
 
class MissingProgressBarFinish(BzrError):
1835
 
 
1836
 
    _fmt = "A nested progress bar was not 'finished' correctly."
1837
 
 
1838
 
 
1839
 
class InvalidProgressBarType(BzrError):
1840
 
 
1841
 
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
1842
 
            " is not a supported type Select one of: %(valid_types)s")
1843
 
 
1844
 
    def __init__(self, bar_type, valid_types):
1845
 
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1846
 
 
1847
 
 
1848
2231
class UnsupportedOperation(BzrError):
1849
2232
 
1850
2233
    _fmt = ("The method %(mname)s is not supported on"
1867
2250
 
1868
2251
 
1869
2252
class BinaryFile(BzrError):
1870
 
    
 
2253
 
1871
2254
    _fmt = "File is binary but should be text."
1872
2255
 
1873
2256
 
1893
2276
 
1894
2277
 
1895
2278
class NotABundle(BzrError):
1896
 
    
 
2279
 
1897
2280
    _fmt = "Not a bzr revision-bundle: %(text)r"
1898
2281
 
1899
2282
    def __init__(self, text):
1901
2284
        self.text = text
1902
2285
 
1903
2286
 
1904
 
class BadBundle(BzrError): 
1905
 
    
 
2287
class BadBundle(BzrError):
 
2288
 
1906
2289
    _fmt = "Bad bzr revision-bundle: %(text)r"
1907
2290
 
1908
2291
    def __init__(self, text):
1910
2293
        self.text = text
1911
2294
 
1912
2295
 
1913
 
class MalformedHeader(BadBundle): 
1914
 
    
 
2296
class MalformedHeader(BadBundle):
 
2297
 
1915
2298
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
1916
2299
 
1917
2300
 
1918
 
class MalformedPatches(BadBundle): 
1919
 
    
 
2301
class MalformedPatches(BadBundle):
 
2302
 
1920
2303
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
1921
2304
 
1922
2305
 
1923
 
class MalformedFooter(BadBundle): 
1924
 
    
 
2306
class MalformedFooter(BadBundle):
 
2307
 
1925
2308
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
1926
2309
 
1927
2310
 
1928
2311
class UnsupportedEOLMarker(BadBundle):
1929
 
    
1930
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
 
2312
 
 
2313
    _fmt = "End of line marker was not \\n in bzr revision-bundle"
1931
2314
 
1932
2315
    def __init__(self):
1933
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
 
2316
        # XXX: BadBundle's constructor assumes there's explanatory text,
1934
2317
        # but for this there is not
1935
2318
        BzrError.__init__(self)
1936
2319
 
1937
2320
 
1938
2321
class IncompatibleBundleFormat(BzrError):
1939
 
    
 
2322
 
1940
2323
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
1941
2324
 
1942
2325
    def __init__(self, bundle_format, other):
1946
2329
 
1947
2330
 
1948
2331
class BadInventoryFormat(BzrError):
1949
 
    
 
2332
 
1950
2333
    _fmt = "Root class for inventory serialization errors"
1951
2334
 
1952
2335
 
1963
2346
    _fmt = """This operation requires rich root data storage"""
1964
2347
 
1965
2348
 
1966
 
class NoSmartMedium(BzrError):
 
2349
class NoSmartMedium(InternalBzrError):
1967
2350
 
1968
2351
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
1969
2352
 
1970
 
    internal_error = True
1971
 
 
1972
2353
    def __init__(self, transport):
1973
2354
        self.transport = transport
1974
2355
 
1975
2356
 
1976
 
class NoSmartServer(NotBranchError):
1977
 
 
1978
 
    _fmt = "No smart server available at %(url)s"
1979
 
 
1980
 
    def __init__(self, url):
1981
 
        self.url = url
1982
 
 
1983
 
 
1984
2357
class UnknownSSH(BzrError):
1985
2358
 
1986
2359
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
1996
2369
            " Please set BZR_SSH environment variable.")
1997
2370
 
1998
2371
 
 
2372
class GhostRevisionsHaveNoRevno(BzrError):
 
2373
    """When searching for revnos, if we encounter a ghost, we are stuck"""
 
2374
 
 
2375
    _fmt = ("Could not determine revno for {%(revision_id)s} because"
 
2376
            " its ancestry shows a ghost at {%(ghost_revision_id)s}")
 
2377
 
 
2378
    def __init__(self, revision_id, ghost_revision_id):
 
2379
        self.revision_id = revision_id
 
2380
        self.ghost_revision_id = ghost_revision_id
 
2381
 
 
2382
 
1999
2383
class GhostRevisionUnusableHere(BzrError):
2000
2384
 
2001
2385
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2005
2389
        self.revision_id = revision_id
2006
2390
 
2007
2391
 
2008
 
class IllegalUseOfScopeReplacer(BzrError):
 
2392
class IllegalUseOfScopeReplacer(InternalBzrError):
2009
2393
 
2010
2394
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
2011
2395
            " %(msg)s%(extra)s")
2012
2396
 
2013
 
    internal_error = True
2014
 
 
2015
2397
    def __init__(self, name, msg, extra=None):
2016
2398
        BzrError.__init__(self)
2017
2399
        self.name = name
2022
2404
            self.extra = ''
2023
2405
 
2024
2406
 
2025
 
class InvalidImportLine(BzrError):
 
2407
class InvalidImportLine(InternalBzrError):
2026
2408
 
2027
2409
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
2028
2410
 
2029
 
    internal_error = True
2030
 
 
2031
2411
    def __init__(self, text, msg):
2032
2412
        BzrError.__init__(self)
2033
2413
        self.text = text
2034
2414
        self.msg = msg
2035
2415
 
2036
2416
 
2037
 
class ImportNameCollision(BzrError):
 
2417
class ImportNameCollision(InternalBzrError):
2038
2418
 
2039
2419
    _fmt = ("Tried to import an object to the same name as"
2040
2420
            " an existing object. %(name)s")
2041
2421
 
2042
 
    internal_error = True
2043
 
 
2044
2422
    def __init__(self, name):
2045
2423
        BzrError.__init__(self)
2046
2424
        self.name = name
2059
2437
        " branch location."
2060
2438
 
2061
2439
 
 
2440
class IllegalMergeDirectivePayload(BzrError):
 
2441
    """A merge directive contained something other than a patch or bundle"""
 
2442
 
 
2443
    _fmt = "Bad merge directive payload %(start)r"
 
2444
 
 
2445
    def __init__(self, start):
 
2446
        BzrError(self)
 
2447
        self.start = start
 
2448
 
 
2449
 
 
2450
class PatchVerificationFailed(BzrError):
 
2451
    """A patch from a merge directive could not be verified"""
 
2452
 
 
2453
    _fmt = "Preview patch does not match requested changes."
 
2454
 
 
2455
 
2062
2456
class PatchMissing(BzrError):
2063
2457
    """Raise a patch type was specified but no patch supplied"""
2064
2458
 
2065
 
    _fmt = "patch_type was %(patch_type)s, but no patch was supplied."
 
2459
    _fmt = "Patch_type was %(patch_type)s, but no patch was supplied."
2066
2460
 
2067
2461
    def __init__(self, patch_type):
2068
2462
        BzrError.__init__(self)
2069
2463
        self.patch_type = patch_type
2070
2464
 
2071
2465
 
 
2466
class TargetNotBranch(BzrError):
 
2467
    """A merge directive's target branch is required, but isn't a branch"""
 
2468
 
 
2469
    _fmt = ("Your branch does not have all of the revisions required in "
 
2470
            "order to merge this merge directive and the target "
 
2471
            "location specified in the merge directive is not a branch: "
 
2472
            "%(location)s.")
 
2473
 
 
2474
    def __init__(self, location):
 
2475
        BzrError.__init__(self)
 
2476
        self.location = location
 
2477
 
 
2478
 
2072
2479
class UnsupportedInventoryKind(BzrError):
2073
 
    
 
2480
 
2074
2481
    _fmt = """Unsupported entry kind %(kind)s"""
2075
2482
 
2076
2483
    def __init__(self, kind):
2079
2486
 
2080
2487
class BadSubsumeSource(BzrError):
2081
2488
 
2082
 
    _fmt = """Can't subsume %(other_tree)s into %(tree)s.  %(reason)s"""
 
2489
    _fmt = "Can't subsume %(other_tree)s into %(tree)s. %(reason)s"
2083
2490
 
2084
2491
    def __init__(self, tree, other_tree, reason):
2085
2492
        self.tree = tree
2088
2495
 
2089
2496
 
2090
2497
class SubsumeTargetNeedsUpgrade(BzrError):
2091
 
    
 
2498
 
2092
2499
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2093
2500
 
2094
2501
    def __init__(self, other_tree):
2095
2502
        self.other_tree = other_tree
2096
2503
 
2097
2504
 
2098
 
class BadReferenceTarget(BzrError):
2099
 
 
2100
 
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s.  %(reason)s"
2101
 
 
2102
 
    internal_error = True
 
2505
class BadReferenceTarget(InternalBzrError):
 
2506
 
 
2507
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
 
2508
           "%(reason)s"
2103
2509
 
2104
2510
    def __init__(self, tree, other_tree, reason):
2105
2511
        self.tree = tree
2118
2524
class TagsNotSupported(BzrError):
2119
2525
 
2120
2526
    _fmt = ("Tags not supported by %(branch)s;"
2121
 
            " you may be able to use bzr upgrade --dirstate-tags.")
 
2527
            " you may be able to use bzr upgrade.")
2122
2528
 
2123
2529
    def __init__(self, branch):
2124
2530
        self.branch = branch
2125
2531
 
2126
 
        
 
2532
 
2127
2533
class TagAlreadyExists(BzrError):
2128
2534
 
2129
2535
    _fmt = "Tag %(tag_name)s already exists."
2134
2540
 
2135
2541
class MalformedBugIdentifier(BzrError):
2136
2542
 
2137
 
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
 
2543
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
 
2544
            'See "bzr help bugs" for more information on this feature.')
2138
2545
 
2139
2546
    def __init__(self, bug_id, reason):
2140
2547
        self.bug_id = bug_id
2141
2548
        self.reason = reason
2142
2549
 
2143
2550
 
 
2551
class InvalidBugTrackerURL(BzrError):
 
2552
 
 
2553
    _fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
 
2554
            "contain {id}: %(url)s")
 
2555
 
 
2556
    def __init__(self, abbreviation, url):
 
2557
        self.abbreviation = abbreviation
 
2558
        self.url = url
 
2559
 
 
2560
 
2144
2561
class UnknownBugTrackerAbbreviation(BzrError):
2145
2562
 
2146
2563
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
2151
2568
        self.branch = branch
2152
2569
 
2153
2570
 
 
2571
class InvalidLineInBugsProperty(BzrError):
 
2572
 
 
2573
    _fmt = ("Invalid line in bugs property: '%(line)s'")
 
2574
 
 
2575
    def __init__(self, line):
 
2576
        self.line = line
 
2577
 
 
2578
 
 
2579
class InvalidBugStatus(BzrError):
 
2580
 
 
2581
    _fmt = ("Invalid bug status: '%(status)s'")
 
2582
 
 
2583
    def __init__(self, status):
 
2584
        self.status = status
 
2585
 
 
2586
 
2154
2587
class UnexpectedSmartServerResponse(BzrError):
2155
2588
 
2156
2589
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2159
2592
        self.response_tuple = response_tuple
2160
2593
 
2161
2594
 
 
2595
class ErrorFromSmartServer(BzrError):
 
2596
    """An error was received from a smart server.
 
2597
 
 
2598
    :seealso: UnknownErrorFromSmartServer
 
2599
    """
 
2600
 
 
2601
    _fmt = "Error received from smart server: %(error_tuple)r"
 
2602
 
 
2603
    internal_error = True
 
2604
 
 
2605
    def __init__(self, error_tuple):
 
2606
        self.error_tuple = error_tuple
 
2607
        try:
 
2608
            self.error_verb = error_tuple[0]
 
2609
        except IndexError:
 
2610
            self.error_verb = None
 
2611
        self.error_args = error_tuple[1:]
 
2612
 
 
2613
 
 
2614
class UnknownErrorFromSmartServer(BzrError):
 
2615
    """An ErrorFromSmartServer could not be translated into a typical bzrlib
 
2616
    error.
 
2617
 
 
2618
    This is distinct from ErrorFromSmartServer so that it is possible to
 
2619
    distinguish between the following two cases:
 
2620
      - ErrorFromSmartServer was uncaught.  This is logic error in the client
 
2621
        and so should provoke a traceback to the user.
 
2622
      - ErrorFromSmartServer was caught but its error_tuple could not be
 
2623
        translated.  This is probably because the server sent us garbage, and
 
2624
        should not provoke a traceback.
 
2625
    """
 
2626
 
 
2627
    _fmt = "Server sent an unexpected error: %(error_tuple)r"
 
2628
 
 
2629
    internal_error = False
 
2630
 
 
2631
    def __init__(self, error_from_smart_server):
 
2632
        """Constructor.
 
2633
 
 
2634
        :param error_from_smart_server: An ErrorFromSmartServer instance.
 
2635
        """
 
2636
        self.error_from_smart_server = error_from_smart_server
 
2637
        self.error_tuple = error_from_smart_server.error_tuple
 
2638
 
 
2639
 
2162
2640
class ContainerError(BzrError):
2163
2641
    """Base class of container errors."""
2164
2642
 
2166
2644
class UnknownContainerFormatError(ContainerError):
2167
2645
 
2168
2646
    _fmt = "Unrecognised container format: %(container_format)r"
2169
 
    
 
2647
 
2170
2648
    def __init__(self, container_format):
2171
2649
        self.container_format = container_format
2172
2650
 
2175
2653
 
2176
2654
    _fmt = "Unexpected end of container stream"
2177
2655
 
2178
 
    internal_error = False
2179
 
 
2180
2656
 
2181
2657
class UnknownRecordTypeError(ContainerError):
2182
2658
 
2204
2680
 
2205
2681
class DuplicateRecordNameError(ContainerError):
2206
2682
 
2207
 
    _fmt = "Container has multiple records with the same name: \"%(name)s\""
 
2683
    _fmt = "Container has multiple records with the same name: %(name)s"
2208
2684
 
2209
2685
    def __init__(self, name):
2210
2686
        self.name = name
2211
2687
 
2212
2688
 
2213
 
class NoDestinationAddress(BzrError):
 
2689
class NoDestinationAddress(InternalBzrError):
2214
2690
 
2215
2691
    _fmt = "Message does not have a destination address."
2216
2692
 
2217
 
    internal_error = True
 
2693
 
 
2694
class RepositoryDataStreamError(BzrError):
 
2695
 
 
2696
    _fmt = "Corrupt or incompatible data stream: %(reason)s"
 
2697
 
 
2698
    def __init__(self, reason):
 
2699
        self.reason = reason
2218
2700
 
2219
2701
 
2220
2702
class SMTPError(BzrError):
2223
2705
 
2224
2706
    def __init__(self, error):
2225
2707
        self.error = error
 
2708
 
 
2709
 
 
2710
class NoMessageSupplied(BzrError):
 
2711
 
 
2712
    _fmt = "No message supplied."
 
2713
 
 
2714
 
 
2715
class NoMailAddressSpecified(BzrError):
 
2716
 
 
2717
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
 
2718
 
 
2719
 
 
2720
class UnknownMailClient(BzrError):
 
2721
 
 
2722
    _fmt = "Unknown mail client: %(mail_client)s"
 
2723
 
 
2724
    def __init__(self, mail_client):
 
2725
        BzrError.__init__(self, mail_client=mail_client)
 
2726
 
 
2727
 
 
2728
class MailClientNotFound(BzrError):
 
2729
 
 
2730
    _fmt = "Unable to find mail client with the following names:"\
 
2731
        " %(mail_command_list_string)s"
 
2732
 
 
2733
    def __init__(self, mail_command_list):
 
2734
        mail_command_list_string = ', '.join(mail_command_list)
 
2735
        BzrError.__init__(self, mail_command_list=mail_command_list,
 
2736
                          mail_command_list_string=mail_command_list_string)
 
2737
 
 
2738
class SMTPConnectionRefused(SMTPError):
 
2739
 
 
2740
    _fmt = "SMTP connection to %(host)s refused"
 
2741
 
 
2742
    def __init__(self, error, host):
 
2743
        self.error = error
 
2744
        self.host = host
 
2745
 
 
2746
 
 
2747
class DefaultSMTPConnectionRefused(SMTPConnectionRefused):
 
2748
 
 
2749
    _fmt = "Please specify smtp_server.  No server at default %(host)s."
 
2750
 
 
2751
 
 
2752
class BzrDirError(BzrError):
 
2753
 
 
2754
    def __init__(self, bzrdir):
 
2755
        import bzrlib.urlutils as urlutils
 
2756
        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,
 
2757
                                                    'ascii')
 
2758
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
 
2759
 
 
2760
 
 
2761
class UnsyncedBranches(BzrDirError):
 
2762
 
 
2763
    _fmt = ("'%(display_url)s' is not in sync with %(target_url)s.  See"
 
2764
            " bzr help sync-for-reconfigure.")
 
2765
 
 
2766
    def __init__(self, bzrdir, target_branch):
 
2767
        BzrDirError.__init__(self, bzrdir)
 
2768
        import bzrlib.urlutils as urlutils
 
2769
        self.target_url = urlutils.unescape_for_display(target_branch.base,
 
2770
                                                        'ascii')
 
2771
 
 
2772
 
 
2773
class AlreadyBranch(BzrDirError):
 
2774
 
 
2775
    _fmt = "'%(display_url)s' is already a branch."
 
2776
 
 
2777
 
 
2778
class AlreadyTree(BzrDirError):
 
2779
 
 
2780
    _fmt = "'%(display_url)s' is already a tree."
 
2781
 
 
2782
 
 
2783
class AlreadyCheckout(BzrDirError):
 
2784
 
 
2785
    _fmt = "'%(display_url)s' is already a checkout."
 
2786
 
 
2787
 
 
2788
class AlreadyLightweightCheckout(BzrDirError):
 
2789
 
 
2790
    _fmt = "'%(display_url)s' is already a lightweight checkout."
 
2791
 
 
2792
 
 
2793
class AlreadyUsingShared(BzrDirError):
 
2794
 
 
2795
    _fmt = "'%(display_url)s' is already using a shared repository."
 
2796
 
 
2797
 
 
2798
class AlreadyStandalone(BzrDirError):
 
2799
 
 
2800
    _fmt = "'%(display_url)s' is already standalone."
 
2801
 
 
2802
 
 
2803
class AlreadyWithTrees(BzrDirError):
 
2804
 
 
2805
    _fmt = ("Shared repository '%(display_url)s' already creates "
 
2806
            "working trees.")
 
2807
 
 
2808
 
 
2809
class AlreadyWithNoTrees(BzrDirError):
 
2810
 
 
2811
    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
 
2812
            "working trees.")
 
2813
 
 
2814
 
 
2815
class ReconfigurationNotSupported(BzrDirError):
 
2816
 
 
2817
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
 
2818
 
 
2819
 
 
2820
class NoBindLocation(BzrDirError):
 
2821
 
 
2822
    _fmt = "No location could be found to bind to at %(display_url)s."
 
2823
 
 
2824
 
 
2825
class UncommittedChanges(BzrError):
 
2826
 
 
2827
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
 
2828
            ' (See bzr status).%(more)s')
 
2829
 
 
2830
    def __init__(self, tree, more=None):
 
2831
        if more is None:
 
2832
            more = ''
 
2833
        else:
 
2834
            more = ' ' + more
 
2835
        import bzrlib.urlutils as urlutils
 
2836
        display_url = urlutils.unescape_for_display(
 
2837
            tree.bzrdir.root_transport.base, 'ascii')
 
2838
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
 
2839
 
 
2840
 
 
2841
class MissingTemplateVariable(BzrError):
 
2842
 
 
2843
    _fmt = 'Variable {%(name)s} is not available.'
 
2844
 
 
2845
    def __init__(self, name):
 
2846
        self.name = name
 
2847
 
 
2848
 
 
2849
class NoTemplate(BzrError):
 
2850
 
 
2851
    _fmt = 'No template specified.'
 
2852
 
 
2853
 
 
2854
class UnableCreateSymlink(BzrError):
 
2855
 
 
2856
    _fmt = 'Unable to create symlink %(path_str)son this platform'
 
2857
 
 
2858
    def __init__(self, path=None):
 
2859
        path_str = ''
 
2860
        if path:
 
2861
            try:
 
2862
                path_str = repr(str(path))
 
2863
            except UnicodeEncodeError:
 
2864
                path_str = repr(path)
 
2865
            path_str += ' '
 
2866
        self.path_str = path_str
 
2867
 
 
2868
 
 
2869
class UnsupportedTimezoneFormat(BzrError):
 
2870
 
 
2871
    _fmt = ('Unsupported timezone format "%(timezone)s", '
 
2872
            'options are "utc", "original", "local".')
 
2873
 
 
2874
    def __init__(self, timezone):
 
2875
        self.timezone = timezone
 
2876
 
 
2877
 
 
2878
class CommandAvailableInPlugin(StandardError):
 
2879
 
 
2880
    internal_error = False
 
2881
 
 
2882
    def __init__(self, cmd_name, plugin_metadata, provider):
 
2883
 
 
2884
        self.plugin_metadata = plugin_metadata
 
2885
        self.cmd_name = cmd_name
 
2886
        self.provider = provider
 
2887
 
 
2888
    def __str__(self):
 
2889
 
 
2890
        _fmt = ('"%s" is not a standard bzr command. \n'
 
2891
                'However, the following official plugin provides this command: %s\n'
 
2892
                'You can install it by going to: %s'
 
2893
                % (self.cmd_name, self.plugin_metadata['name'],
 
2894
                    self.plugin_metadata['url']))
 
2895
 
 
2896
        return _fmt
 
2897
 
 
2898
 
 
2899
class NoPluginAvailable(BzrError):
 
2900
    pass
 
2901
 
 
2902
 
 
2903
class UnableEncodePath(BzrError):
 
2904
 
 
2905
    _fmt = ('Unable to encode %(kind)s path %(path)r in '
 
2906
            'user encoding %(user_encoding)s')
 
2907
 
 
2908
    def __init__(self, path, kind):
 
2909
        from bzrlib.osutils import get_user_encoding
 
2910
        self.path = path
 
2911
        self.kind = kind
 
2912
        self.user_encoding = osutils.get_user_encoding()
 
2913
 
 
2914
 
 
2915
class NoSuchAlias(BzrError):
 
2916
 
 
2917
    _fmt = ('The alias "%(alias_name)s" does not exist.')
 
2918
 
 
2919
    def __init__(self, alias_name):
 
2920
        BzrError.__init__(self, alias_name=alias_name)
 
2921
 
 
2922
 
 
2923
class DirectoryLookupFailure(BzrError):
 
2924
    """Base type for lookup errors."""
 
2925
 
 
2926
    pass
 
2927
 
 
2928
 
 
2929
class InvalidLocationAlias(DirectoryLookupFailure):
 
2930
 
 
2931
    _fmt = '"%(alias_name)s" is not a valid location alias.'
 
2932
 
 
2933
    def __init__(self, alias_name):
 
2934
        DirectoryLookupFailure.__init__(self, alias_name=alias_name)
 
2935
 
 
2936
 
 
2937
class UnsetLocationAlias(DirectoryLookupFailure):
 
2938
 
 
2939
    _fmt = 'No %(alias_name)s location assigned.'
 
2940
 
 
2941
    def __init__(self, alias_name):
 
2942
        DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
 
2943
 
 
2944
 
 
2945
class CannotBindAddress(BzrError):
 
2946
 
 
2947
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
 
2948
 
 
2949
    def __init__(self, host, port, orig_error):
 
2950
        # nb: in python2.4 socket.error doesn't have a useful repr
 
2951
        BzrError.__init__(self, host=host, port=port,
 
2952
            orig_error=repr(orig_error.args))
 
2953
 
 
2954
 
 
2955
class UnknownRules(BzrError):
 
2956
 
 
2957
    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
 
2958
 
 
2959
    def __init__(self, unknowns):
 
2960
        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
 
2961
 
 
2962
 
 
2963
class HookFailed(BzrError):
 
2964
    """Raised when a pre_change_branch_tip hook function fails anything other
 
2965
    than TipChangeRejected.
 
2966
 
 
2967
    Note that this exception is no longer raised, and the import is only left
 
2968
    to be nice to code which might catch it in a plugin.
 
2969
    """
 
2970
 
 
2971
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
 
2972
            "%(traceback_text)s%(exc_value)s")
 
2973
 
 
2974
    def __init__(self, hook_stage, hook_name, exc_info, warn=True):
 
2975
        if warn:
 
2976
            symbol_versioning.warn("BzrError HookFailed has been deprecated "
 
2977
                "as of bzrlib 2.1.", DeprecationWarning, stacklevel=2)
 
2978
        import traceback
 
2979
        self.hook_stage = hook_stage
 
2980
        self.hook_name = hook_name
 
2981
        self.exc_info = exc_info
 
2982
        self.exc_type = exc_info[0]
 
2983
        self.exc_value = exc_info[1]
 
2984
        self.exc_tb = exc_info[2]
 
2985
        self.traceback_text = ''.join(traceback.format_tb(self.exc_tb))
 
2986
 
 
2987
 
 
2988
class TipChangeRejected(BzrError):
 
2989
    """A pre_change_branch_tip hook function may raise this to cleanly and
 
2990
    explicitly abort a change to a branch tip.
 
2991
    """
 
2992
 
 
2993
    _fmt = u"Tip change rejected: %(msg)s"
 
2994
 
 
2995
    def __init__(self, msg):
 
2996
        self.msg = msg
 
2997
 
 
2998
 
 
2999
class ShelfCorrupt(BzrError):
 
3000
 
 
3001
    _fmt = "Shelf corrupt."
 
3002
 
 
3003
 
 
3004
class NoSuchShelfId(BzrError):
 
3005
 
 
3006
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
 
3007
 
 
3008
    def __init__(self, shelf_id):
 
3009
        BzrError.__init__(self, shelf_id=shelf_id)
 
3010
 
 
3011
 
 
3012
class InvalidShelfId(BzrError):
 
3013
 
 
3014
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
 
3015
 
 
3016
    def __init__(self, invalid_id):
 
3017
        BzrError.__init__(self, invalid_id=invalid_id)
 
3018
 
 
3019
 
 
3020
class JailBreak(BzrError):
 
3021
 
 
3022
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
 
3023
 
 
3024
    def __init__(self, url):
 
3025
        BzrError.__init__(self, url=url)
 
3026
 
 
3027
 
 
3028
class UserAbort(BzrError):
 
3029
 
 
3030
    _fmt = 'The user aborted the operation.'
 
3031
 
 
3032
 
 
3033
class MustHaveWorkingTree(BzrError):
 
3034
 
 
3035
    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
 
3036
 
 
3037
    def __init__(self, format, url):
 
3038
        BzrError.__init__(self, format=format, url=url)
 
3039
 
 
3040
 
 
3041
class NoSuchView(BzrError):
 
3042
    """A view does not exist.
 
3043
    """
 
3044
 
 
3045
    _fmt = u"No such view: %(view_name)s."
 
3046
 
 
3047
    def __init__(self, view_name):
 
3048
        self.view_name = view_name
 
3049
 
 
3050
 
 
3051
class ViewsNotSupported(BzrError):
 
3052
    """Views are not supported by a tree format.
 
3053
    """
 
3054
 
 
3055
    _fmt = ("Views are not supported by %(tree)s;"
 
3056
            " use 'bzr upgrade' to change your tree to a later format.")
 
3057
 
 
3058
    def __init__(self, tree):
 
3059
        self.tree = tree
 
3060
 
 
3061
 
 
3062
class FileOutsideView(BzrError):
 
3063
 
 
3064
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
 
3065
            '%(view_str)s')
 
3066
 
 
3067
    def __init__(self, file_name, view_files):
 
3068
        self.file_name = file_name
 
3069
        self.view_str = ", ".join(view_files)
 
3070
 
 
3071
 
 
3072
class UnresumableWriteGroup(BzrError):
 
3073
 
 
3074
    _fmt = ("Repository %(repository)s cannot resume write group "
 
3075
            "%(write_groups)r: %(reason)s")
 
3076
 
 
3077
    internal_error = True
 
3078
 
 
3079
    def __init__(self, repository, write_groups, reason):
 
3080
        self.repository = repository
 
3081
        self.write_groups = write_groups
 
3082
        self.reason = reason
 
3083
 
 
3084
 
 
3085
class UnsuspendableWriteGroup(BzrError):
 
3086
 
 
3087
    _fmt = ("Repository %(repository)s cannot suspend a write group.")
 
3088
 
 
3089
    internal_error = True
 
3090
 
 
3091
    def __init__(self, repository):
 
3092
        self.repository = repository
 
3093
 
 
3094
 
 
3095
class LossyPushToSameVCS(BzrError):
 
3096
 
 
3097
    _fmt = ("Lossy push not possible between %(source_branch)r and "
 
3098
            "%(target_branch)r that are in the same VCS.")
 
3099
 
 
3100
    internal_error = True
 
3101
 
 
3102
    def __init__(self, source_branch, target_branch):
 
3103
        self.source_branch = source_branch
 
3104
        self.target_branch = target_branch
 
3105
 
 
3106
 
 
3107
class NoRoundtrippingSupport(BzrError):
 
3108
 
 
3109
    _fmt = ("Roundtripping is not supported between %(source_branch)r and "
 
3110
            "%(target_branch)r.")
 
3111
 
 
3112
    internal_error = True
 
3113
 
 
3114
    def __init__(self, source_branch, target_branch):
 
3115
        self.source_branch = source_branch
 
3116
        self.target_branch = target_branch
 
3117
 
 
3118
 
 
3119
class FileTimestampUnavailable(BzrError):
 
3120
 
 
3121
    _fmt = "The filestamp for %(path)s is not available."
 
3122
 
 
3123
    internal_error = True
 
3124
 
 
3125
    def __init__(self, path):
 
3126
        self.path = path