← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-01-13 05:14:24 UTC
  • mfrom: (3936.1.3 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090113051424-nrk3zkfe09h46i9y
(mbp) merge 1.11 and advance to 1.12

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
 
608
 
 
609
 
 
610
class UnknownHook(BzrError):
 
611
 
 
612
    _fmt = "The %(type)s hook '%(hook)s' is unknown in this version of bzrlib."
 
613
 
 
614
    def __init__(self, hook_type, hook_name):
 
615
        BzrError.__init__(self)
 
616
        self.type = hook_type
 
617
        self.hook = hook_name
406
618
 
407
619
 
408
620
class UnsupportedProtocol(PathError):
413
625
        PathError.__init__(self, url, extra=extra)
414
626
 
415
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
 
416
655
class ShortReadvError(PathError):
417
656
 
418
 
    _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')
419
659
 
420
660
    internal_error = True
421
661
 
426
666
        self.actual = actual
427
667
 
428
668
 
429
 
class PathNotChild(BzrError):
 
669
class PathNotChild(PathError):
430
670
 
431
 
    _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'
432
672
 
433
673
    internal_error = True
434
674
 
444
684
 
445
685
class InvalidNormalization(PathError):
446
686
 
447
 
    _fmt = "Path %(path)r is not unicode normalized"
 
687
    _fmt = 'Path "%(path)s" is not unicode normalized'
448
688
 
449
689
 
450
690
# TODO: This is given a URL; we try to unescape it but doing that from inside
452
692
# TODO: Probably this behavior of should be a common superclass 
453
693
class NotBranchError(PathError):
454
694
 
455
 
    _fmt = "Not a branch: %(path)s"
 
695
    _fmt = 'Not a branch: "%(path)s".'
456
696
 
457
697
    def __init__(self, path):
458
698
       import bzrlib.urlutils as urlutils
459
699
       self.path = urlutils.unescape_for_display(path, 'ascii')
460
700
 
461
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
 
462
711
class AlreadyBranchError(PathError):
463
712
 
464
 
    _fmt = "Already a branch: %(path)s."
 
713
    _fmt = 'Already a branch: "%(path)s".'
465
714
 
466
715
 
467
716
class BranchExistsWithoutWorkingTree(PathError):
468
717
 
469
 
    _fmt = "Directory contains a branch, but no working tree \
470
 
(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"'
471
720
 
472
721
 
473
722
class AtomicFileAlreadyClosed(PathError):
474
723
 
475
 
    _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"')
476
726
 
477
727
    def __init__(self, path, function):
478
728
        PathError.__init__(self, path=path, extra=None)
481
731
 
482
732
class InaccessibleParent(PathError):
483
733
 
484
 
    _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"')
485
736
 
486
737
    def __init__(self, path, base):
487
738
        PathError.__init__(self, path)
490
741
 
491
742
class NoRepositoryPresent(BzrError):
492
743
 
493
 
    _fmt = "No repository present: %(path)r"
 
744
    _fmt = 'No repository present: "%(path)s"'
494
745
    def __init__(self, bzrdir):
495
746
        BzrError.__init__(self)
496
747
        self.path = bzrdir.transport.clone('..').base
498
749
 
499
750
class FileInWrongBranch(BzrError):
500
751
 
501
 
    _fmt = "File %(path)s in not in branch %(branch_base)s."
 
752
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
502
753
 
503
754
    def __init__(self, branch, path):
504
755
        BzrError.__init__(self)
508
759
 
509
760
 
510
761
class UnsupportedFormatError(BzrError):
511
 
    
512
 
    _fmt = "Unsupported branch format: %(format)s"
 
762
 
 
763
    _fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
513
764
 
514
765
 
515
766
class UnknownFormatError(BzrError):
516
767
    
517
 
    _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
518
773
 
519
774
 
520
775
class IncompatibleFormat(BzrError):
527
782
        self.bzrdir = bzrdir_format
528
783
 
529
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
 
530
798
class IncompatibleRevision(BzrError):
531
799
    
532
800
    _fmt = "Revision is not compatible with %(repo_format)s"
539
807
class AlreadyVersionedError(BzrError):
540
808
    """Used when a path is expected not to be versioned, but it is."""
541
809
 
542
 
    _fmt = "%(context_info)s%(path)s is already versioned"
 
810
    _fmt = "%(context_info)s%(path)s is already versioned."
543
811
 
544
812
    def __init__(self, path, context_info=None):
545
 
        """Construct a new NotVersionedError.
 
813
        """Construct a new AlreadyVersionedError.
546
814
 
547
815
        :param path: This is the path which is versioned,
548
816
        which should be in a user friendly form.
560
828
class NotVersionedError(BzrError):
561
829
    """Used when a path is expected to be versioned, but it is not."""
562
830
 
563
 
    _fmt = "%(context_info)s%(path)s is not versioned"
 
831
    _fmt = "%(context_info)s%(path)s is not versioned."
564
832
 
565
833
    def __init__(self, path, context_info=None):
566
834
        """Construct a new NotVersionedError.
611
879
 
612
880
class BadFileKindError(BzrError):
613
881
 
614
 
    _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
615
897
 
616
898
 
617
899
class ForbiddenControlFileError(BzrError):
618
900
 
619
 
    _fmt = "Cannot operate on %(filename)s because it is a control file"
620
 
 
621
 
 
622
 
class LockError(BzrError):
623
 
 
624
 
    _fmt = "Lock error: %(message)s"
625
 
 
626
 
    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"
627
907
 
628
908
    # All exceptions from the lock/unlock functions should be from
629
909
    # this exception class.  They will be translated as necessary. The
631
911
    #
632
912
    # New code should prefer to raise specific subclasses
633
913
    def __init__(self, message):
634
 
        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
 
918
 
 
919
 
 
920
class LockActive(LockError):
 
921
 
 
922
    _fmt = "The lock for '%(lock_description)s' is in use and cannot be broken."
 
923
 
 
924
    internal_error = False
 
925
 
 
926
    def __init__(self, lock_description):
 
927
        self.lock_description = lock_description
635
928
 
636
929
 
637
930
class CommitNotPossible(LockError):
654
947
 
655
948
    _fmt = "A write attempt was made in a read only transaction on %(obj)s"
656
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
 
657
953
    def __init__(self, obj):
658
954
        self.obj = obj
659
955
 
660
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
 
661
969
class OutSideTransaction(BzrError):
662
970
 
663
 
    _fmt = "A transaction related operation was attempted after the transaction finished."
 
971
    _fmt = ("A transaction related operation was attempted after"
 
972
            " the transaction finished.")
664
973
 
665
974
 
666
975
class ObjectNotLocked(LockError):
684
993
 
685
994
class UnlockableTransport(LockError):
686
995
 
 
996
    internal_error = False
 
997
 
687
998
    _fmt = "Cannot lock: transport is read only: %(transport)s"
688
999
 
689
1000
    def __init__(self, transport):
692
1003
 
693
1004
class LockContention(LockError):
694
1005
 
695
 
    _fmt = "Could not acquire lock %(lock)s"
 
1006
    _fmt = 'Could not acquire lock "%(lock)s"'
696
1007
    # TODO: show full url for lock, combining the transport and relative
697
1008
    # bits?
698
1009
 
699
1010
    internal_error = False
700
 
    
 
1011
 
701
1012
    def __init__(self, lock):
702
1013
        self.lock = lock
703
1014
 
704
1015
 
705
1016
class LockBroken(LockError):
706
1017
 
707
 
    _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!")
708
1020
 
709
1021
    internal_error = False
710
1022
 
714
1026
 
715
1027
class LockBreakMismatch(LockError):
716
1028
 
717
 
    _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")
718
1031
 
719
1032
    internal_error = False
720
1033
 
734
1047
        self.lock = lock
735
1048
 
736
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
 
737
1069
class PointlessCommit(BzrError):
738
1070
 
739
1071
    _fmt = "No changes to commit"
740
1072
 
741
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
 
742
1090
class UpgradeReadonly(BzrError):
743
1091
 
744
1092
    _fmt = "Upgrade URL cannot work with readonly URLs."
758
1106
    _fmt = "Commit refused because there are unknowns in the tree."
759
1107
 
760
1108
 
761
 
class NoSuchRevision(BzrError):
762
 
 
763
 
    _fmt = "Branch %(branch)s has no revision %(revision)s"
764
 
 
765
 
    internal_error = True
 
1109
class NoSuchRevision(InternalBzrError):
 
1110
 
 
1111
    _fmt = "%(branch)s has no revision %(revision)s"
766
1112
 
767
1113
    def __init__(self, branch, revision):
 
1114
        # 'branch' may sometimes be an internal object like a KnitRevisionStore
768
1115
        BzrError.__init__(self, branch=branch, revision=revision)
769
1116
 
770
1117
 
 
1118
class RangeInChangeOption(BzrError):
 
1119
 
 
1120
    _fmt = "Option --change does not accept revision ranges"
 
1121
 
 
1122
 
771
1123
class NoSuchRevisionSpec(BzrError):
772
1124
 
773
1125
    _fmt = "No namespace registered for string: %(spec)r"
776
1128
        BzrError.__init__(self, spec=spec)
777
1129
 
778
1130
 
 
1131
class NoSuchRevisionInTree(NoSuchRevision):
 
1132
    """When using Tree.revision_tree, and the revision is not accessible."""
 
1133
    
 
1134
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
 
1135
 
 
1136
    def __init__(self, tree, revision_id):
 
1137
        BzrError.__init__(self)
 
1138
        self.tree = tree
 
1139
        self.revision_id = revision_id
 
1140
 
 
1141
 
779
1142
class InvalidRevisionSpec(BzrError):
780
1143
 
781
 
    _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")
782
1146
 
783
1147
    def __init__(self, spec, branch, extra=None):
784
1148
        BzrError.__init__(self, branch=branch, spec=spec)
793
1157
    _fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"
794
1158
 
795
1159
 
 
1160
class AppendRevisionsOnlyViolation(BzrError):
 
1161
 
 
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".')
 
1165
 
 
1166
    def __init__(self, location):
 
1167
       import bzrlib.urlutils as urlutils
 
1168
       location = urlutils.unescape_for_display(location, 'ascii')
 
1169
       BzrError.__init__(self, location=location)
 
1170
 
 
1171
 
796
1172
class DivergedBranches(BzrError):
797
 
    
798
 
    _fmt = "These branches have diverged.  Use the merge command to reconcile them."""
799
1173
 
800
 
    internal_error = False
 
1174
    _fmt = ("These branches have diverged."
 
1175
            " Use the merge command to reconcile them.")
801
1176
 
802
1177
    def __init__(self, branch1, branch2):
803
1178
        self.branch1 = branch1
804
1179
        self.branch2 = branch2
805
1180
 
806
1181
 
 
1182
class NotLefthandHistory(InternalBzrError):
 
1183
 
 
1184
    _fmt = "Supplied history does not follow left-hand parents"
 
1185
 
 
1186
    def __init__(self, history):
 
1187
        BzrError.__init__(self, history=history)
 
1188
 
 
1189
 
807
1190
class UnrelatedBranches(BzrError):
808
1191
 
809
 
    _fmt = "Branches have no common ancestor, and no merge base revision was specified."
810
 
 
811
 
    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.')
812
1200
 
813
1201
 
814
1202
class NoCommonAncestor(BzrError):
822
1210
 
823
1211
class NoCommonRoot(BzrError):
824
1212
 
825
 
    _fmt = "Revisions are not derived from the same root: " \
826
 
           "%(revision_a)s %(revision_b)s."
 
1213
    _fmt = ("Revisions are not derived from the same root: "
 
1214
           "%(revision_a)s %(revision_b)s.")
827
1215
 
828
1216
    def __init__(self, revision_a, revision_b):
829
1217
        BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
852
1240
    def __init__(self, bases):
853
1241
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
854
1242
                DeprecationWarning)
855
 
        msg = "The correct base is unclear, because %s are all equally close" %\
856
 
            ", ".join(bases)
 
1243
        msg = ("The correct base is unclear, because %s are all equally close"
 
1244
                % ", ".join(bases))
857
1245
        BzrError.__init__(self, msg)
858
1246
        self.bases = bases
859
1247
 
860
1248
 
861
 
class NoCommits(BzrError):
 
1249
class NoCommits(BranchError):
862
1250
 
863
1251
    _fmt = "Branch %(branch)s has no commits."
864
1252
 
865
 
    def __init__(self, branch):
866
 
        BzrError.__init__(self, branch=branch)
867
 
 
868
1253
 
869
1254
class UnlistableStore(BzrError):
870
1255
 
881
1266
 
882
1267
class BoundBranchOutOfDate(BzrError):
883
1268
 
884
 
    _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.")
885
1271
 
886
1272
    def __init__(self, branch, master):
887
1273
        BzrError.__init__(self)
891
1277
        
892
1278
class CommitToDoubleBoundBranch(BzrError):
893
1279
 
894
 
    _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.")
895
1282
 
896
1283
    def __init__(self, branch, master, remote):
897
1284
        BzrError.__init__(self)
911
1298
 
912
1299
class BoundBranchConnectionFailure(BzrError):
913
1300
 
914
 
    _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")
915
1303
 
916
1304
    def __init__(self, branch, target, error):
917
1305
        BzrError.__init__(self)
922
1310
 
923
1311
class WeaveError(BzrError):
924
1312
 
925
 
    _fmt = "Error in processing weave: %(message)s"
 
1313
    _fmt = "Error in processing weave: %(msg)s"
926
1314
 
927
 
    def __init__(self, message=None):
 
1315
    def __init__(self, msg=None):
928
1316
        BzrError.__init__(self)
929
 
        self.message = message
 
1317
        self.msg = msg
930
1318
 
931
1319
 
932
1320
class WeaveRevisionAlreadyPresent(WeaveError):
961
1349
 
962
1350
class WeaveParentMismatch(WeaveError):
963
1351
 
964
 
    _fmt = "Parents are mismatched between two revisions."
 
1352
    _fmt = "Parents are mismatched between two revisions. %(message)s"
965
1353
    
966
1354
 
967
1355
class WeaveInvalidChecksum(WeaveError):
971
1359
 
972
1360
class WeaveTextDiffers(WeaveError):
973
1361
 
974
 
    _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")
975
1364
 
976
1365
    def __init__(self, revision_id, weave_a, weave_b):
977
1366
        WeaveError.__init__(self)
982
1371
 
983
1372
class WeaveTextDiffers(WeaveError):
984
1373
 
985
 
    _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")
986
1376
 
987
1377
    def __init__(self, revision_id, weave_a, weave_b):
988
1378
        WeaveError.__init__(self)
998
1388
 
999
1389
class RevisionNotPresent(VersionedFileError):
1000
1390
    
1001
 
    _fmt = "Revision {%(revision_id)s} not present in %(file_id)s."
 
1391
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1002
1392
 
1003
1393
    def __init__(self, revision_id, file_id):
1004
1394
        VersionedFileError.__init__(self)
1008
1398
 
1009
1399
class RevisionAlreadyPresent(VersionedFileError):
1010
1400
    
1011
 
    _fmt = "Revision {%(revision_id)s} already present in %(file_id)s."
 
1401
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1012
1402
 
1013
1403
    def __init__(self, revision_id, file_id):
1014
1404
        VersionedFileError.__init__(self)
1016
1406
        self.file_id = file_id
1017
1407
 
1018
1408
 
1019
 
class KnitError(BzrError):
 
1409
class VersionedFileInvalidChecksum(VersionedFileError):
 
1410
 
 
1411
    _fmt = "Text did not match its checksum: %(message)s"
 
1412
 
 
1413
 
 
1414
class KnitError(InternalBzrError):
1020
1415
    
1021
1416
    _fmt = "Knit error"
1022
1417
 
1023
 
    internal_error = True
1024
 
 
1025
 
 
1026
 
class KnitHeaderError(KnitError):
1027
 
 
1028
 
    _fmt = "Knit header error: %(badline)r unexpected for file %(filename)s"
1029
 
 
1030
 
    def __init__(self, badline, filename):
1031
 
        KnitError.__init__(self)
1032
 
        self.badline = badline
1033
 
        self.filename = filename
1034
 
 
1035
1418
 
1036
1419
class KnitCorrupt(KnitError):
1037
1420
 
1043
1426
        self.how = how
1044
1427
 
1045
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
 
1046
1473
class KnitIndexUnknownMethod(KnitError):
1047
1474
    """Raised when we don't understand the storage method.
1048
1475
 
1058
1485
        self.options = options
1059
1486
 
1060
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
 
1061
1534
class NoSuchExportFormat(BzrError):
1062
1535
    
1063
1536
    _fmt = "Export format %(format)r not supported"
1083
1556
        BzrError.__init__(self)
1084
1557
 
1085
1558
 
1086
 
class TooManyConcurrentRequests(BzrError):
1087
 
 
1088
 
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit. "
1089
 
            "Be sure to finish_writing and finish_reading on the "
1090
 
            "current request that is open.")
1091
 
 
1092
 
    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.")
1093
1564
 
1094
1565
    def __init__(self, medium):
1095
1566
        self.medium = medium
1103
1574
        self.details = details
1104
1575
 
1105
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
 
1106
1607
# A set of semi-meaningful errors which can be thrown
1107
1608
class TransportNotPossible(TransportError):
1108
1609
 
1140
1641
 
1141
1642
class InvalidRange(TransportError):
1142
1643
 
1143
 
    _fmt = "Invalid range access in %(path)s at %(offset)s."
1144
 
    
1145
 
    def __init__(self, path, offset):
1146
 
        TransportError.__init__(self, ("Invalid range access in %s at %d"
1147
 
                                       % (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)
1148
1648
        self.path = path
1149
1649
        self.offset = offset
1150
1650
 
1161
1661
class InvalidHttpRange(InvalidHttpResponse):
1162
1662
 
1163
1663
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1164
 
    
 
1664
 
1165
1665
    def __init__(self, path, range, msg):
1166
1666
        self.range = range
1167
1667
        InvalidHttpResponse.__init__(self, path, msg)
1170
1670
class InvalidHttpContentType(InvalidHttpResponse):
1171
1671
 
1172
1672
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1173
 
    
 
1673
 
1174
1674
    def __init__(self, path, ctype, msg):
1175
1675
        self.ctype = ctype
1176
1676
        InvalidHttpResponse.__init__(self, path, msg)
1177
1677
 
1178
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
 
1179
1698
class ConflictsInTree(BzrError):
1180
1699
 
1181
1700
    _fmt = "Working tree has conflicts."
1187
1706
        if filename is None:
1188
1707
            filename = ""
1189
1708
        message = "Error(s) parsing config file %s:\n%s" % \
1190
 
            (filename, ('\n'.join(e.message for e in errors)))
 
1709
            (filename, ('\n'.join(e.msg for e in errors)))
1191
1710
        BzrError.__init__(self, message)
1192
1711
 
1193
1712
 
1202
1721
 
1203
1722
class SigningFailed(BzrError):
1204
1723
 
1205
 
    _fmt = "Failed to gpg sign data with command %(command_line)r"
 
1724
    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'
1206
1725
 
1207
1726
    def __init__(self, command_line):
1208
1727
        BzrError.__init__(self, command_line=command_line)
1220
1739
 
1221
1740
class CantReprocessAndShowBase(BzrError):
1222
1741
 
1223
 
    _fmt = "Can't reprocess and show base, because reprocessing obscures " \
1224
 
           "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")
1225
1744
 
1226
1745
 
1227
1746
class GraphCycleError(BzrError):
1233
1752
        self.graph = graph
1234
1753
 
1235
1754
 
1236
 
class WritingCompleted(BzrError):
 
1755
class WritingCompleted(InternalBzrError):
1237
1756
 
1238
1757
    _fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1239
1758
            "called upon it - accept bytes may not be called anymore.")
1240
1759
 
1241
 
    internal_error = True
1242
 
 
1243
1760
    def __init__(self, request):
1244
1761
        self.request = request
1245
1762
 
1246
1763
 
1247
 
class WritingNotComplete(BzrError):
 
1764
class WritingNotComplete(InternalBzrError):
1248
1765
 
1249
1766
    _fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1250
1767
            "called upon it - until the write phase is complete no "
1251
1768
            "data may be read.")
1252
1769
 
1253
 
    internal_error = True
1254
 
 
1255
1770
    def __init__(self, request):
1256
1771
        self.request = request
1257
1772
 
1265
1780
        self.filename = filename
1266
1781
 
1267
1782
 
1268
 
class MediumNotConnected(BzrError):
 
1783
class MediumNotConnected(InternalBzrError):
1269
1784
 
1270
1785
    _fmt = """The medium '%(medium)s' is not connected."""
1271
1786
 
1272
 
    internal_error = True
1273
 
 
1274
1787
    def __init__(self, medium):
1275
1788
        self.medium = medium
1276
1789
 
1277
1790
 
1278
1791
class MustUseDecorated(Exception):
1279
 
    
1280
 
    _fmt = """A decorating function has requested its original command be used."""
1281
 
    
 
1792
 
 
1793
    _fmt = "A decorating function has requested its original command be used."
 
1794
 
1282
1795
 
1283
1796
class NoBundleFound(BzrError):
1284
1797
 
1285
 
    _fmt = "No bundle was found in %(filename)s"
 
1798
    _fmt = 'No bundle was found in "%(filename)s".'
1286
1799
 
1287
1800
    def __init__(self, filename):
1288
1801
        BzrError.__init__(self)
1301
1814
 
1302
1815
class MissingText(BzrError):
1303
1816
 
1304
 
    _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")
1305
1819
 
1306
1820
    def __init__(self, branch, text_revision, file_id):
1307
1821
        BzrError.__init__(self)
1311
1825
        self.file_id = file_id
1312
1826
 
1313
1827
 
 
1828
class DuplicateFileId(BzrError):
 
1829
 
 
1830
    _fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"
 
1831
 
 
1832
    def __init__(self, file_id, entry):
 
1833
        BzrError.__init__(self)
 
1834
        self.file_id = file_id
 
1835
        self.entry = entry
 
1836
 
 
1837
 
1314
1838
class DuplicateKey(BzrError):
1315
1839
 
1316
1840
    _fmt = "Key %(key)s is already present in map"
1317
1841
 
1318
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
 
1319
1851
class MalformedTransform(BzrError):
1320
1852
 
1321
1853
    _fmt = "Tree transform is malformed %(conflicts)r"
1333
1865
        self.root_trans_id = transform.root
1334
1866
 
1335
1867
 
1336
 
class BzrBadParameter(BzrError):
 
1868
class BzrBadParameter(InternalBzrError):
1337
1869
 
1338
1870
    _fmt = "Bad parameter: %(param)r"
1339
1871
 
1365
1897
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
1366
1898
 
1367
1899
    def __init__(self, from_path='', to_path='', extra=None):
 
1900
        from bzrlib.osutils import splitpath
1368
1901
        BzrError.__init__(self)
1369
1902
        if extra:
1370
1903
            self.extra = ': ' + str(extra)
1374
1907
        has_from = len(from_path) > 0
1375
1908
        has_to = len(to_path) > 0
1376
1909
        if has_from:
1377
 
            self.from_path = osutils.splitpath(from_path)[-1]
 
1910
            self.from_path = splitpath(from_path)[-1]
1378
1911
        else:
1379
1912
            self.from_path = ''
1380
1913
 
1381
1914
        if has_to:
1382
 
            self.to_path = osutils.splitpath(to_path)[-1]
 
1915
            self.to_path = splitpath(to_path)[-1]
1383
1916
        else:
1384
1917
            self.to_path = ''
1385
1918
 
1401
1934
    def __init__(self, from_path, to_path, extra=None):
1402
1935
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1403
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
 
1404
1950
 
1405
1951
class BzrBadParameterNotString(BzrBadParameter):
1406
1952
 
1414
1960
 
1415
1961
class BzrBadParameterUnicode(BzrBadParameter):
1416
1962
 
1417
 
    _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.")
1418
1965
 
1419
1966
 
1420
1967
class BzrBadParameterContainsNewline(BzrBadParameter):
1462
2009
        self.format = format
1463
2010
 
1464
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
 
1465
2028
class NoDiff(BzrError):
1466
2029
 
1467
2030
    _fmt = "Diff is not installed on this machine: %(msg)s"
1475
2038
    _fmt = "Diff3 is not installed on this machine."
1476
2039
 
1477
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
 
1478
2047
class ExistingLimbo(BzrError):
1479
2048
 
1480
2049
    _fmt = """This tree contains left-over files from a failed operation.
1486
2055
       self.limbo_dir = limbo_dir
1487
2056
 
1488
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
 
1489
2068
class ImmortalLimbo(BzrError):
1490
2069
 
1491
 
    _fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
 
2070
    _fmt = """Unable to delete transform temporary directory %(limbo_dir)s.
1492
2071
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1493
2072
    keep, and delete it when you are done."""
1494
2073
 
1497
2076
       self.limbo_dir = limbo_dir
1498
2077
 
1499
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
 
1500
2089
class OutOfDateTree(BzrError):
1501
2090
 
1502
2091
    _fmt = "Working tree is out of date, please run 'bzr update'."
1506
2095
        self.tree = tree
1507
2096
 
1508
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
 
1509
2111
class MergeModifiedFormatError(BzrError):
1510
2112
 
1511
2113
    _fmt = "Error in merge modified format"
1516
2118
    _fmt = "Format error in conflict listings"
1517
2119
 
1518
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
 
1519
2132
class CorruptRepository(BzrError):
1520
2133
 
1521
 
    _fmt = """An error has been detected in the repository %(repo_path)s.
1522
 
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.")
1523
2136
 
1524
2137
    def __init__(self, repo):
1525
2138
        BzrError.__init__(self)
1526
2139
        self.repo_path = repo.bzrdir.root_transport.base
1527
2140
 
1528
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
 
1529
2155
class UpgradeRequired(BzrError):
1530
2156
 
1531
2157
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
1535
2161
        self.path = path
1536
2162
 
1537
2163
 
 
2164
class RepositoryUpgradeRequired(UpgradeRequired):
 
2165
 
 
2166
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
 
2167
 
 
2168
 
1538
2169
class LocalRequiresBoundBranch(BzrError):
1539
2170
 
1540
2171
    _fmt = "Cannot perform local-only commits on unbound branches."
1547
2178
 
1548
2179
class InvalidProgressBarType(BzrError):
1549
2180
 
1550
 
    _fmt = """Environment variable BZR_PROGRESS_BAR='%(bar_type)s is not a supported type
1551
 
Select one of: %(valid_types)s"""
 
2181
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
 
2182
            " is not a supported type Select one of: %(valid_types)s")
1552
2183
 
1553
2184
    def __init__(self, bar_type, valid_types):
1554
2185
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1556
2187
 
1557
2188
class UnsupportedOperation(BzrError):
1558
2189
 
1559
 
    _fmt = "The method %(mname)s is not supported on objects of type %(tname)s."
 
2190
    _fmt = ("The method %(mname)s is not supported on"
 
2191
            " objects of type %(tname)s.")
1560
2192
 
1561
2193
    def __init__(self, method, method_self):
1562
2194
        self.method = method
1569
2201
 
1570
2202
 
1571
2203
class NonAsciiRevisionId(UnsupportedOperation):
1572
 
    """Raised when a commit is attempting to set a non-ascii revision id but cant."""
 
2204
    """Raised when a commit is attempting to set a non-ascii revision id
 
2205
       but cant.
 
2206
    """
1573
2207
 
1574
2208
 
1575
2209
class BinaryFile(BzrError):
1588
2222
 
1589
2223
class TestamentMismatch(BzrError):
1590
2224
 
1591
 
    _fmt = """Testament did not match expected value.  
1592
 
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured 
 
2225
    _fmt = """Testament did not match expected value.
 
2226
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
1593
2227
       {%(measured)s}"""
1594
2228
 
1595
2229
    def __init__(self, revision_id, expected, measured):
1664
2298
        BadInventoryFormat.__init__(self, msg=msg)
1665
2299
 
1666
2300
 
1667
 
class NoSmartMedium(BzrError):
 
2301
class RootNotRich(BzrError):
 
2302
 
 
2303
    _fmt = """This operation requires rich root data storage"""
 
2304
 
 
2305
 
 
2306
class NoSmartMedium(InternalBzrError):
1668
2307
 
1669
2308
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
1670
2309
 
1676
2315
 
1677
2316
    _fmt = "No smart server available at %(url)s"
1678
2317
 
 
2318
    @symbol_versioning.deprecated_method(symbol_versioning.one_four)
1679
2319
    def __init__(self, url):
1680
2320
        self.url = url
1681
2321
 
1689
2329
        self.vendor = vendor
1690
2330
 
1691
2331
 
 
2332
class SSHVendorNotFound(BzrError):
 
2333
 
 
2334
    _fmt = ("Don't know how to handle SSH connections."
 
2335
            " Please set BZR_SSH environment variable.")
 
2336
 
 
2337
 
 
2338
class GhostRevisionsHaveNoRevno(BzrError):
 
2339
    """When searching for revnos, if we encounter a ghost, we are stuck"""
 
2340
 
 
2341
    _fmt = ("Could not determine revno for {%(revision_id)s} because"
 
2342
            " its ancestry shows a ghost at {%(ghost_revision_id)s}")
 
2343
 
 
2344
    def __init__(self, revision_id, ghost_revision_id):
 
2345
        self.revision_id = revision_id
 
2346
        self.ghost_revision_id = ghost_revision_id
 
2347
 
 
2348
        
1692
2349
class GhostRevisionUnusableHere(BzrError):
1693
2350
 
1694
2351
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
1698
2355
        self.revision_id = revision_id
1699
2356
 
1700
2357
 
1701
 
class IllegalUseOfScopeReplacer(BzrError):
1702
 
 
1703
 
    _fmt = "ScopeReplacer object %(name)r was used incorrectly: %(msg)s%(extra)s"
1704
 
 
1705
 
    internal_error = True
 
2358
class IllegalUseOfScopeReplacer(InternalBzrError):
 
2359
 
 
2360
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
 
2361
            " %(msg)s%(extra)s")
1706
2362
 
1707
2363
    def __init__(self, name, msg, extra=None):
1708
2364
        BzrError.__init__(self)
1714
2370
            self.extra = ''
1715
2371
 
1716
2372
 
1717
 
class InvalidImportLine(BzrError):
 
2373
class InvalidImportLine(InternalBzrError):
1718
2374
 
1719
2375
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
1720
2376
 
1721
 
    internal_error = True
1722
 
 
1723
2377
    def __init__(self, text, msg):
1724
2378
        BzrError.__init__(self)
1725
2379
        self.text = text
1726
2380
        self.msg = msg
1727
2381
 
1728
2382
 
1729
 
class ImportNameCollision(BzrError):
1730
 
 
1731
 
    _fmt = "Tried to import an object to the same name as an existing object. %(name)s"
 
2383
class ImportNameCollision(InternalBzrError):
 
2384
 
 
2385
    _fmt = ("Tried to import an object to the same name as"
 
2386
            " an existing object. %(name)s")
 
2387
 
 
2388
    def __init__(self, name):
 
2389
        BzrError.__init__(self)
 
2390
        self.name = name
 
2391
 
 
2392
 
 
2393
class NotAMergeDirective(BzrError):
 
2394
    """File starting with %(firstline)r is not a merge directive"""
 
2395
    def __init__(self, firstline):
 
2396
        BzrError.__init__(self, firstline=firstline)
 
2397
 
 
2398
 
 
2399
class NoMergeSource(BzrError):
 
2400
    """Raise if no merge source was specified for a merge directive"""
 
2401
 
 
2402
    _fmt = "A merge directive must provide either a bundle or a public"\
 
2403
        " branch location."
 
2404
 
 
2405
 
 
2406
class IllegalMergeDirectivePayload(BzrError):
 
2407
    """A merge directive contained something other than a patch or bundle"""
 
2408
 
 
2409
    _fmt = "Bad merge directive payload %(start)r"
 
2410
 
 
2411
    def __init__(self, start):
 
2412
        BzrError(self)
 
2413
        self.start = start
 
2414
 
 
2415
 
 
2416
class PatchVerificationFailed(BzrError):
 
2417
    """A patch from a merge directive could not be verified"""
 
2418
 
 
2419
    _fmt = "Preview patch does not match requested changes."
 
2420
 
 
2421
 
 
2422
class PatchMissing(BzrError):
 
2423
    """Raise a patch type was specified but no patch supplied"""
 
2424
 
 
2425
    _fmt = "Patch_type was %(patch_type)s, but no patch was supplied."
 
2426
 
 
2427
    def __init__(self, patch_type):
 
2428
        BzrError.__init__(self)
 
2429
        self.patch_type = patch_type
 
2430
 
 
2431
 
 
2432
class TargetNotBranch(BzrError):
 
2433
    """A merge directive's target branch is required, but isn't a branch"""
 
2434
 
 
2435
    _fmt = ("Your branch does not have all of the revisions required in "
 
2436
            "order to merge this merge directive and the target "
 
2437
            "location specified in the merge directive is not a branch: "
 
2438
            "%(location)s.")
 
2439
 
 
2440
    def __init__(self, location):
 
2441
        BzrError.__init__(self)
 
2442
        self.location = location
 
2443
 
 
2444
 
 
2445
class UnsupportedInventoryKind(BzrError):
 
2446
    
 
2447
    _fmt = """Unsupported entry kind %(kind)s"""
 
2448
 
 
2449
    def __init__(self, kind):
 
2450
        self.kind = kind
 
2451
 
 
2452
 
 
2453
class BadSubsumeSource(BzrError):
 
2454
 
 
2455
    _fmt = "Can't subsume %(other_tree)s into %(tree)s. %(reason)s"
 
2456
 
 
2457
    def __init__(self, tree, other_tree, reason):
 
2458
        self.tree = tree
 
2459
        self.other_tree = other_tree
 
2460
        self.reason = reason
 
2461
 
 
2462
 
 
2463
class SubsumeTargetNeedsUpgrade(BzrError):
 
2464
    
 
2465
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
 
2466
 
 
2467
    def __init__(self, other_tree):
 
2468
        self.other_tree = other_tree
 
2469
 
 
2470
 
 
2471
class BadReferenceTarget(InternalBzrError):
 
2472
 
 
2473
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
 
2474
           "%(reason)s"
 
2475
 
 
2476
    def __init__(self, tree, other_tree, reason):
 
2477
        self.tree = tree
 
2478
        self.other_tree = other_tree
 
2479
        self.reason = reason
 
2480
 
 
2481
 
 
2482
class NoSuchTag(BzrError):
 
2483
 
 
2484
    _fmt = "No such tag: %(tag_name)s"
 
2485
 
 
2486
    def __init__(self, tag_name):
 
2487
        self.tag_name = tag_name
 
2488
 
 
2489
 
 
2490
class TagsNotSupported(BzrError):
 
2491
 
 
2492
    _fmt = ("Tags not supported by %(branch)s;"
 
2493
            " you may be able to use bzr upgrade.")
 
2494
 
 
2495
    def __init__(self, branch):
 
2496
        self.branch = branch
 
2497
 
 
2498
        
 
2499
class TagAlreadyExists(BzrError):
 
2500
 
 
2501
    _fmt = "Tag %(tag_name)s already exists."
 
2502
 
 
2503
    def __init__(self, tag_name):
 
2504
        self.tag_name = tag_name
 
2505
 
 
2506
 
 
2507
class MalformedBugIdentifier(BzrError):
 
2508
 
 
2509
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
 
2510
 
 
2511
    def __init__(self, bug_id, reason):
 
2512
        self.bug_id = bug_id
 
2513
        self.reason = reason
 
2514
 
 
2515
 
 
2516
class InvalidBugTrackerURL(BzrError):
 
2517
 
 
2518
    _fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
 
2519
            "contain {id}: %(url)s")
 
2520
 
 
2521
    def __init__(self, abbreviation, url):
 
2522
        self.abbreviation = abbreviation
 
2523
        self.url = url
 
2524
 
 
2525
 
 
2526
class UnknownBugTrackerAbbreviation(BzrError):
 
2527
 
 
2528
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
 
2529
            "on %(branch)s")
 
2530
 
 
2531
    def __init__(self, abbreviation, branch):
 
2532
        self.abbreviation = abbreviation
 
2533
        self.branch = branch
 
2534
 
 
2535
 
 
2536
class UnexpectedSmartServerResponse(BzrError):
 
2537
 
 
2538
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
 
2539
 
 
2540
    def __init__(self, response_tuple):
 
2541
        self.response_tuple = response_tuple
 
2542
 
 
2543
 
 
2544
class ErrorFromSmartServer(BzrError):
 
2545
    """An error was received from a smart server.
 
2546
 
 
2547
    :seealso: UnknownErrorFromSmartServer
 
2548
    """
 
2549
 
 
2550
    _fmt = "Error received from smart server: %(error_tuple)r"
1732
2551
 
1733
2552
    internal_error = True
1734
2553
 
1735
 
    def __init__(self, name):
1736
 
        BzrError.__init__(self)
1737
 
        self.name = name
 
2554
    def __init__(self, error_tuple):
 
2555
        self.error_tuple = error_tuple
 
2556
        try:
 
2557
            self.error_verb = error_tuple[0]
 
2558
        except IndexError:
 
2559
            self.error_verb = None
 
2560
        self.error_args = error_tuple[1:]
 
2561
 
 
2562
 
 
2563
class UnknownErrorFromSmartServer(BzrError):
 
2564
    """An ErrorFromSmartServer could not be translated into a typical bzrlib
 
2565
    error.
 
2566
 
 
2567
    This is distinct from ErrorFromSmartServer so that it is possible to
 
2568
    distinguish between the following two cases:
 
2569
      - ErrorFromSmartServer was uncaught.  This is logic error in the client
 
2570
        and so should provoke a traceback to the user.
 
2571
      - ErrorFromSmartServer was caught but its error_tuple could not be
 
2572
        translated.  This is probably because the server sent us garbage, and
 
2573
        should not provoke a traceback.
 
2574
    """
 
2575
 
 
2576
    _fmt = "Server sent an unexpected error: %(error_tuple)r"
 
2577
 
 
2578
    internal_error = False
 
2579
 
 
2580
    def __init__(self, error_from_smart_server):
 
2581
        """Constructor.
 
2582
 
 
2583
        :param error_from_smart_server: An ErrorFromSmartServer instance.
 
2584
        """
 
2585
        self.error_from_smart_server = error_from_smart_server
 
2586
        self.error_tuple = error_from_smart_server.error_tuple
 
2587
        
 
2588
 
 
2589
class ContainerError(BzrError):
 
2590
    """Base class of container errors."""
 
2591
 
 
2592
 
 
2593
class UnknownContainerFormatError(ContainerError):
 
2594
 
 
2595
    _fmt = "Unrecognised container format: %(container_format)r"
 
2596
    
 
2597
    def __init__(self, container_format):
 
2598
        self.container_format = container_format
 
2599
 
 
2600
 
 
2601
class UnexpectedEndOfContainerError(ContainerError):
 
2602
 
 
2603
    _fmt = "Unexpected end of container stream"
 
2604
 
 
2605
 
 
2606
class UnknownRecordTypeError(ContainerError):
 
2607
 
 
2608
    _fmt = "Unknown record type: %(record_type)r"
 
2609
 
 
2610
    def __init__(self, record_type):
 
2611
        self.record_type = record_type
 
2612
 
 
2613
 
 
2614
class InvalidRecordError(ContainerError):
 
2615
 
 
2616
    _fmt = "Invalid record: %(reason)s"
 
2617
 
 
2618
    def __init__(self, reason):
 
2619
        self.reason = reason
 
2620
 
 
2621
 
 
2622
class ContainerHasExcessDataError(ContainerError):
 
2623
 
 
2624
    _fmt = "Container has data after end marker: %(excess)r"
 
2625
 
 
2626
    def __init__(self, excess):
 
2627
        self.excess = excess
 
2628
 
 
2629
 
 
2630
class DuplicateRecordNameError(ContainerError):
 
2631
 
 
2632
    _fmt = "Container has multiple records with the same name: %(name)s"
 
2633
 
 
2634
    def __init__(self, name):
 
2635
        self.name = name
 
2636
 
 
2637
 
 
2638
class NoDestinationAddress(InternalBzrError):
 
2639
 
 
2640
    _fmt = "Message does not have a destination address."
 
2641
 
 
2642
 
 
2643
class RepositoryDataStreamError(BzrError):
 
2644
 
 
2645
    _fmt = "Corrupt or incompatible data stream: %(reason)s"
 
2646
 
 
2647
    def __init__(self, reason):
 
2648
        self.reason = reason
 
2649
 
 
2650
 
 
2651
class SMTPError(BzrError):
 
2652
 
 
2653
    _fmt = "SMTP error: %(error)s"
 
2654
 
 
2655
    def __init__(self, error):
 
2656
        self.error = error
 
2657
 
 
2658
 
 
2659
class NoMessageSupplied(BzrError):
 
2660
 
 
2661
    _fmt = "No message supplied."
 
2662
 
 
2663
 
 
2664
class NoMailAddressSpecified(BzrError):
 
2665
 
 
2666
    _fmt = "No mail-to address specified."
 
2667
 
 
2668
 
 
2669
class UnknownMailClient(BzrError):
 
2670
 
 
2671
    _fmt = "Unknown mail client: %(mail_client)s"
 
2672
 
 
2673
    def __init__(self, mail_client):
 
2674
        BzrError.__init__(self, mail_client=mail_client)
 
2675
 
 
2676
 
 
2677
class MailClientNotFound(BzrError):
 
2678
 
 
2679
    _fmt = "Unable to find mail client with the following names:"\
 
2680
        " %(mail_command_list_string)s"
 
2681
 
 
2682
    def __init__(self, mail_command_list):
 
2683
        mail_command_list_string = ', '.join(mail_command_list)
 
2684
        BzrError.__init__(self, mail_command_list=mail_command_list,
 
2685
                          mail_command_list_string=mail_command_list_string)
 
2686
 
 
2687
class SMTPConnectionRefused(SMTPError):
 
2688
 
 
2689
    _fmt = "SMTP connection to %(host)s refused"
 
2690
 
 
2691
    def __init__(self, error, host):
 
2692
        self.error = error
 
2693
        self.host = host
 
2694
 
 
2695
 
 
2696
class DefaultSMTPConnectionRefused(SMTPConnectionRefused):
 
2697
 
 
2698
    _fmt = "Please specify smtp_server.  No server at default %(host)s."
 
2699
 
 
2700
 
 
2701
class BzrDirError(BzrError):
 
2702
 
 
2703
    def __init__(self, bzrdir):
 
2704
        import bzrlib.urlutils as urlutils
 
2705
        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,
 
2706
                                                    'ascii')
 
2707
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
 
2708
 
 
2709
 
 
2710
class UnsyncedBranches(BzrDirError):
 
2711
 
 
2712
    _fmt = ("'%(display_url)s' is not in sync with %(target_url)s.  See"
 
2713
            " bzr help sync-for-reconfigure.")
 
2714
 
 
2715
    def __init__(self, bzrdir, target_branch):
 
2716
        BzrDirError.__init__(self, bzrdir)
 
2717
        import bzrlib.urlutils as urlutils
 
2718
        self.target_url = urlutils.unescape_for_display(target_branch.base,
 
2719
                                                        'ascii')
 
2720
 
 
2721
 
 
2722
class AlreadyBranch(BzrDirError):
 
2723
 
 
2724
    _fmt = "'%(display_url)s' is already a branch."
 
2725
 
 
2726
 
 
2727
class AlreadyTree(BzrDirError):
 
2728
 
 
2729
    _fmt = "'%(display_url)s' is already a tree."
 
2730
 
 
2731
 
 
2732
class AlreadyCheckout(BzrDirError):
 
2733
 
 
2734
    _fmt = "'%(display_url)s' is already a checkout."
 
2735
 
 
2736
 
 
2737
class AlreadyLightweightCheckout(BzrDirError):
 
2738
 
 
2739
    _fmt = "'%(display_url)s' is already a lightweight checkout."
 
2740
 
 
2741
 
 
2742
class AlreadyUsingShared(BzrDirError):
 
2743
 
 
2744
    _fmt = "'%(display_url)s' is already using a shared repository."
 
2745
 
 
2746
 
 
2747
class AlreadyStandalone(BzrDirError):
 
2748
 
 
2749
    _fmt = "'%(display_url)s' is already standalone."
 
2750
 
 
2751
 
 
2752
class ReconfigurationNotSupported(BzrDirError):
 
2753
 
 
2754
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
 
2755
 
 
2756
 
 
2757
class NoBindLocation(BzrDirError):
 
2758
 
 
2759
    _fmt = "No location could be found to bind to at %(display_url)s."
 
2760
 
 
2761
 
 
2762
class UncommittedChanges(BzrError):
 
2763
 
 
2764
    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'
 
2765
 
 
2766
    def __init__(self, tree):
 
2767
        import bzrlib.urlutils as urlutils
 
2768
        display_url = urlutils.unescape_for_display(
 
2769
            tree.bzrdir.root_transport.base, 'ascii')
 
2770
        BzrError.__init__(self, tree=tree, display_url=display_url)
 
2771
 
 
2772
 
 
2773
class MissingTemplateVariable(BzrError):
 
2774
 
 
2775
    _fmt = 'Variable {%(name)s} is not available.'
 
2776
 
 
2777
    def __init__(self, name):
 
2778
        self.name = name
 
2779
 
 
2780
 
 
2781
class NoTemplate(BzrError):
 
2782
 
 
2783
    _fmt = 'No template specified.'
 
2784
 
 
2785
 
 
2786
class UnableCreateSymlink(BzrError):
 
2787
 
 
2788
    _fmt = 'Unable to create symlink %(path_str)son this platform'
 
2789
 
 
2790
    def __init__(self, path=None):
 
2791
        path_str = ''
 
2792
        if path:
 
2793
            try:
 
2794
                path_str = repr(str(path))
 
2795
            except UnicodeEncodeError:
 
2796
                path_str = repr(path)
 
2797
            path_str += ' '
 
2798
        self.path_str = path_str
 
2799
 
 
2800
 
 
2801
class UnsupportedTimezoneFormat(BzrError):
 
2802
 
 
2803
    _fmt = ('Unsupported timezone format "%(timezone)s", '
 
2804
            'options are "utc", "original", "local".')
 
2805
 
 
2806
    def __init__(self, timezone):
 
2807
        self.timezone = timezone
 
2808
 
 
2809
 
 
2810
class CommandAvailableInPlugin(StandardError):
 
2811
    
 
2812
    internal_error = False
 
2813
 
 
2814
    def __init__(self, cmd_name, plugin_metadata, provider):
 
2815
        
 
2816
        self.plugin_metadata = plugin_metadata
 
2817
        self.cmd_name = cmd_name
 
2818
        self.provider = provider
 
2819
 
 
2820
    def __str__(self):
 
2821
 
 
2822
        _fmt = ('"%s" is not a standard bzr command. \n' 
 
2823
                'However, the following official plugin provides this command: %s\n'
 
2824
                'You can install it by going to: %s'
 
2825
                % (self.cmd_name, self.plugin_metadata['name'], 
 
2826
                    self.plugin_metadata['url']))
 
2827
 
 
2828
        return _fmt
 
2829
 
 
2830
 
 
2831
class NoPluginAvailable(BzrError):
 
2832
    pass    
 
2833
 
 
2834
 
 
2835
class NotATerminal(BzrError):
 
2836
 
 
2837
    _fmt = 'Unable to ask for a password without real terminal.'
 
2838
 
 
2839
 
 
2840
class UnableEncodePath(BzrError):
 
2841
 
 
2842
    _fmt = ('Unable to encode %(kind)s path %(path)r in '
 
2843
            'user encoding %(user_encoding)s')
 
2844
 
 
2845
    def __init__(self, path, kind):
 
2846
        from bzrlib.osutils import get_user_encoding
 
2847
        self.path = path
 
2848
        self.kind = kind
 
2849
        self.user_encoding = osutils.get_user_encoding()
 
2850
 
 
2851
 
 
2852
class NoSuchAlias(BzrError):
 
2853
 
 
2854
    _fmt = ('The alias "%(alias_name)s" does not exist.')
 
2855
 
 
2856
    def __init__(self, alias_name):
 
2857
        BzrError.__init__(self, alias_name=alias_name)
 
2858
 
 
2859
 
 
2860
class DirectoryLookupFailure(BzrError):
 
2861
    """Base type for lookup errors."""
 
2862
 
 
2863
    pass
 
2864
 
 
2865
 
 
2866
class InvalidLocationAlias(DirectoryLookupFailure):
 
2867
 
 
2868
    _fmt = '"%(alias_name)s" is not a valid location alias.'
 
2869
 
 
2870
    def __init__(self, alias_name):
 
2871
        DirectoryLookupFailure.__init__(self, alias_name=alias_name)
 
2872
 
 
2873
 
 
2874
class UnsetLocationAlias(DirectoryLookupFailure):
 
2875
 
 
2876
    _fmt = 'No %(alias_name)s location assigned.'
 
2877
 
 
2878
    def __init__(self, alias_name):
 
2879
        DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
 
2880
 
 
2881
 
 
2882
class CannotBindAddress(BzrError):
 
2883
 
 
2884
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
 
2885
 
 
2886
    def __init__(self, host, port, orig_error):
 
2887
        BzrError.__init__(self, host=host, port=port,
 
2888
            orig_error=orig_error[1])
 
2889
 
 
2890
 
 
2891
class UnknownRules(BzrError):
 
2892
 
 
2893
    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
 
2894
 
 
2895
    def __init__(self, unknowns):
 
2896
        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
 
2897
 
 
2898
 
 
2899
class HookFailed(BzrError):
 
2900
    """Raised when a pre_change_branch_tip hook function fails anything other
 
2901
    than TipChangeRejected.
 
2902
    """
 
2903
 
 
2904
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
 
2905
            "%(traceback_text)s%(exc_value)s")
 
2906
 
 
2907
    def __init__(self, hook_stage, hook_name, exc_info):
 
2908
        import traceback
 
2909
        self.hook_stage = hook_stage
 
2910
        self.hook_name = hook_name
 
2911
        self.exc_info = exc_info
 
2912
        self.exc_type = exc_info[0]
 
2913
        self.exc_value = exc_info[1]
 
2914
        self.exc_tb = exc_info[2]
 
2915
        self.traceback_text = ''.join(traceback.format_tb(self.exc_tb))
 
2916
 
 
2917
 
 
2918
class TipChangeRejected(BzrError):
 
2919
    """A pre_change_branch_tip hook function may raise this to cleanly and
 
2920
    explicitly abort a change to a branch tip.
 
2921
    """
 
2922
    
 
2923
    _fmt = u"Tip change rejected: %(msg)s"
 
2924
 
 
2925
    def __init__(self, msg):
 
2926
        self.msg = msg
 
2927
 
 
2928
 
 
2929
class ShelfCorrupt(BzrError):
 
2930
 
 
2931
    _fmt = "Shelf corrupt."
 
2932
 
 
2933
 
 
2934
class NoSuchShelfId(BzrError):
 
2935
 
 
2936
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
 
2937
 
 
2938
    def __init__(self, shelf_id):
 
2939
        BzrError.__init__(self, shelf_id=shelf_id)
 
2940
 
 
2941
 
 
2942
class UserAbort(BzrError):
 
2943
 
 
2944
    _fmt = 'The user aborted the operation.'