← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: v.ladeuil+lp at free
  • Date: 2007-05-15 17:40:32 UTC
  • mto: (2485.8.44 bzr.connection.sharing)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070515174032-qzdkangpv29l9e7g
Add a test that check that init connect only once. It fails.

* __init__.py:
(test_suite): Register the new test class.

* test_init.py: 
(InstrumentedTransport): A transport that can track connections.
(TransportHooks): Transport specific hooks.
(TestInit): Iniit command behavior tests.

* ftp.py:
(FtpTransport.__init__): Mark place that need fixing regarding
transport connection sharing

* builtins.py:
(cmd_init.run): Mark places that need fixing regarding transport
connection sharing.

Show diffs side-by-side

added added

removed removed

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