/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
1
 
# Copyright (C) 2005-2013, 2016 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""Exceptions for bzr, and reporting of them.
18
18
"""
19
19
 
 
20
from __future__ import absolute_import
20
21
 
21
22
# TODO: is there any value in providing the .args field used by standard
22
23
# python exceptions?   A list of values with no names seems less useful
31
32
# 'unprintable'.
32
33
 
33
34
 
34
 
# return codes from the brz program
 
35
# return codes from the bzr program
35
36
EXIT_OK = 0
36
37
EXIT_ERROR = 3
37
38
EXIT_INTERNAL_ERROR = 4
38
39
 
39
40
 
40
 
class BzrError(Exception):
 
41
class BzrError(StandardError):
41
42
    """
42
 
    Base class for errors raised by breezy.
 
43
    Base class for errors raised by bzrlib.
43
44
 
44
 
    :cvar internal_error: if True this was probably caused by a brz bug and
 
45
    :cvar internal_error: if True this was probably caused by a bzr bug and
45
46
        should be displayed with a traceback; if False (or absent) this was
46
47
        probably a user or environment error and they don't need the gory
47
48
        details.  (That can be overridden by -Derror on the command line.)
71
72
           not subject to expansion. 'msg' is used instead of 'message' because
72
73
           python evolved and, in 2.6, forbids the use of 'message'.
73
74
        """
74
 
        Exception.__init__(self)
 
75
        StandardError.__init__(self)
75
76
        if msg is not None:
76
77
            # I was going to deprecate this, but it actually turns out to be
77
78
            # quite handy - mbp 20061103.
86
87
        if s is not None:
87
88
            # contains a preformatted message
88
89
            return s
89
 
        err = None
90
90
        try:
91
91
            fmt = self._get_format_string()
92
92
            if fmt:
95
95
                # __str__() should always return a 'str' object
96
96
                # never a 'unicode' object.
97
97
                return s
98
 
        except Exception as e:
99
 
            err = e
 
98
        except Exception, e:
 
99
            pass # just bind to 'e' for formatting below
 
100
        else:
 
101
            e = None
100
102
        return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
101
103
            % (self.__class__.__name__,
102
104
               self.__dict__,
103
105
               getattr(self, '_fmt', None),
104
 
               err)
105
 
 
106
 
    __str__ = _format
 
106
               e)
 
107
 
 
108
    def __unicode__(self):
 
109
        u = self._format()
 
110
        if isinstance(u, str):
 
111
            # Try decoding the str using the default encoding.
 
112
            u = unicode(u)
 
113
        elif not isinstance(u, unicode):
 
114
            # Try to make a unicode object from it, because __unicode__ must
 
115
            # return a unicode object.
 
116
            u = unicode(u)
 
117
        return u
 
118
 
 
119
    def __str__(self):
 
120
        s = self._format()
 
121
        if isinstance(s, unicode):
 
122
            s = s.encode('utf8')
 
123
        else:
 
124
            # __str__ must return a str.
 
125
            s = str(s)
 
126
        return s
107
127
 
108
128
    def __repr__(self):
109
129
        return '%s(%s)' % (self.__class__.__name__, str(self))
112
132
        """Return format string for this exception or None"""
113
133
        fmt = getattr(self, '_fmt', None)
114
134
        if fmt is not None:
115
 
            from breezy.i18n import gettext
116
 
            return gettext(fmt)  # _fmt strings should be ascii
 
135
            from bzrlib.i18n import gettext
 
136
            return gettext(unicode(fmt)) # _fmt strings should be ascii
117
137
 
118
138
    def __eq__(self, other):
119
139
        if self.__class__ is not other.__class__:
120
140
            return NotImplemented
121
141
        return self.__dict__ == other.__dict__
122
142
 
123
 
    def __hash__(self):
124
 
        return id(self)
125
 
 
126
143
 
127
144
class InternalBzrError(BzrError):
128
145
    """Base class for errors that are internal in nature.
135
152
    internal_error = True
136
153
 
137
154
 
 
155
class AlreadyBuilding(BzrError):
 
156
 
 
157
    _fmt = "The tree builder is already building a tree."
 
158
 
 
159
 
138
160
class BranchError(BzrError):
139
161
    """Base class for concrete 'errors about a branch'."""
140
162
 
151
173
        self.msg = msg
152
174
 
153
175
 
154
 
class IncompatibleVersion(BzrError):
155
 
 
156
 
    _fmt = 'API %(api)s is not compatible; one of versions %(wanted)r '\
157
 
           'is required, but current version is %(current)r.'
158
 
 
159
 
    def __init__(self, api, wanted, current):
 
176
class DirstateCorrupt(BzrError):
 
177
 
 
178
    _fmt = "The dirstate file (%(state)s) appears to be corrupt: %(msg)s"
 
179
 
 
180
    def __init__(self, state, msg):
 
181
        BzrError.__init__(self)
 
182
        self.state = state
 
183
        self.msg = msg
 
184
 
 
185
 
 
186
class DisabledMethod(InternalBzrError):
 
187
 
 
188
    _fmt = "The smart server method '%(class_name)s' is disabled."
 
189
 
 
190
    def __init__(self, class_name):
 
191
        BzrError.__init__(self)
 
192
        self.class_name = class_name
 
193
 
 
194
 
 
195
class IncompatibleAPI(BzrError):
 
196
 
 
197
    _fmt = 'The API for "%(api)s" is not compatible with "%(wanted)s". '\
 
198
        'It supports versions "%(minimum)s" to "%(current)s".'
 
199
 
 
200
    def __init__(self, api, wanted, minimum, current):
160
201
        self.api = api
161
202
        self.wanted = wanted
 
203
        self.minimum = minimum
162
204
        self.current = current
163
205
 
164
206
 
171
213
        self.transport = transport
172
214
 
173
215
 
 
216
class InvalidEntryName(InternalBzrError):
 
217
 
 
218
    _fmt = "Invalid entry name: %(name)s"
 
219
 
 
220
    def __init__(self, name):
 
221
        BzrError.__init__(self)
 
222
        self.name = name
 
223
 
 
224
 
174
225
class InvalidRevisionNumber(BzrError):
175
226
 
176
227
    _fmt = "Invalid revision number %(revno)s"
202
253
class RootMissing(InternalBzrError):
203
254
 
204
255
    _fmt = ("The root entry of a tree must be the first entry supplied to "
205
 
            "the commit builder.")
 
256
        "the commit builder.")
206
257
 
207
258
 
208
259
class NoPublicBranch(BzrError):
210
261
    _fmt = 'There is no public branch set for "%(branch_url)s".'
211
262
 
212
263
    def __init__(self, branch):
213
 
        from . import urlutils
 
264
        import bzrlib.urlutils as urlutils
214
265
        public_location = urlutils.unescape_for_display(branch.base, 'ascii')
215
266
        BzrError.__init__(self, branch_url=public_location)
216
267
 
217
268
 
 
269
class NoHelpTopic(BzrError):
 
270
 
 
271
    _fmt = ("No help could be found for '%(topic)s'. "
 
272
        "Please use 'bzr help topics' to obtain a list of topics.")
 
273
 
 
274
    def __init__(self, topic):
 
275
        self.topic = topic
 
276
 
 
277
 
218
278
class NoSuchId(BzrError):
219
279
 
220
280
    _fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
225
285
        self.tree = tree
226
286
 
227
287
 
 
288
class NoSuchIdInRepository(NoSuchId):
 
289
 
 
290
    _fmt = ('The file id "%(file_id)s" is not present in the repository'
 
291
            ' %(repository)r')
 
292
 
 
293
    def __init__(self, repository, file_id):
 
294
        BzrError.__init__(self, repository=repository, file_id=file_id)
 
295
 
 
296
 
228
297
class NotStacked(BranchError):
229
298
 
230
299
    _fmt = "The branch '%(branch)s' is not stacked."
231
300
 
232
301
 
 
302
class InventoryModified(InternalBzrError):
 
303
 
 
304
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
 
305
            " so a clean inventory cannot be read without data loss.")
 
306
 
 
307
    def __init__(self, tree):
 
308
        self.tree = tree
 
309
 
 
310
 
233
311
class NoWorkingTree(BzrError):
234
312
 
235
313
    _fmt = 'No WorkingTree exists for "%(base)s".'
239
317
        self.base = base
240
318
 
241
319
 
 
320
class NotBuilding(BzrError):
 
321
 
 
322
    _fmt = "Not currently building a tree."
 
323
 
 
324
 
242
325
class NotLocalUrl(BzrError):
243
326
 
244
327
    _fmt = "%(url)s is not a local path."
255
338
        self.base = base
256
339
 
257
340
 
258
 
class NoWhoami(BzrError):
259
 
 
260
 
    _fmt = ('Unable to determine your name.\n'
261
 
            "Please, set your name with the 'whoami' command.\n"
262
 
            'E.g. brz whoami "Your Name <name@example.com>"')
263
 
 
264
 
 
265
 
class CommandError(BzrError):
 
341
class BzrCommandError(BzrError):
266
342
    """Error from user command"""
267
343
 
268
344
    # Error from malformed user command; please avoid raising this as a
270
346
    #
271
347
    # I think it's a waste of effort to differentiate between errors that
272
348
    # are not intended to be caught anyway.  UI code need not subclass
273
 
    # CommandError, and non-UI code should not throw a subclass of
274
 
    # CommandError.  ADHB 20051211
275
 
 
276
 
 
277
 
# Provide the old name as backup, for the moment.
278
 
BzrCommandError = CommandError
 
349
    # BzrCommandError, and non-UI code should not throw a subclass of
 
350
    # BzrCommandError.  ADHB 20051211
279
351
 
280
352
 
281
353
class NotWriteLocked(BzrError):
286
358
        self.not_locked = not_locked
287
359
 
288
360
 
 
361
class BzrOptionError(BzrCommandError):
 
362
 
 
363
    _fmt = "Error in command line options"
 
364
 
 
365
 
 
366
class BadIndexFormatSignature(BzrError):
 
367
 
 
368
    _fmt = "%(value)s is not an index of type %(_type)s."
 
369
 
 
370
    def __init__(self, value, _type):
 
371
        BzrError.__init__(self)
 
372
        self.value = value
 
373
        self._type = _type
 
374
 
 
375
 
 
376
class BadIndexData(BzrError):
 
377
 
 
378
    _fmt = "Error in data for index %(value)s."
 
379
 
 
380
    def __init__(self, value):
 
381
        BzrError.__init__(self)
 
382
        self.value = value
 
383
 
 
384
 
 
385
class BadIndexDuplicateKey(BzrError):
 
386
 
 
387
    _fmt = "The key '%(key)s' is already in index '%(index)s'."
 
388
 
 
389
    def __init__(self, key, index):
 
390
        BzrError.__init__(self)
 
391
        self.key = key
 
392
        self.index = index
 
393
 
 
394
 
 
395
class BadIndexKey(BzrError):
 
396
 
 
397
    _fmt = "The key '%(key)s' is not a valid key."
 
398
 
 
399
    def __init__(self, key):
 
400
        BzrError.__init__(self)
 
401
        self.key = key
 
402
 
 
403
 
 
404
class BadIndexOptions(BzrError):
 
405
 
 
406
    _fmt = "Could not parse options for index %(value)s."
 
407
 
 
408
    def __init__(self, value):
 
409
        BzrError.__init__(self)
 
410
        self.value = value
 
411
 
 
412
 
 
413
class BadIndexValue(BzrError):
 
414
 
 
415
    _fmt = "The value '%(value)s' is not a valid value."
 
416
 
 
417
    def __init__(self, value):
 
418
        BzrError.__init__(self)
 
419
        self.value = value
 
420
 
 
421
 
 
422
class BadOptionValue(BzrError):
 
423
 
 
424
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
 
425
 
 
426
    def __init__(self, name, value):
 
427
        BzrError.__init__(self, name=name, value=value)
 
428
 
 
429
 
289
430
class StrictCommitFailed(BzrError):
290
431
 
291
432
    _fmt = "Commit refused because there are unknown files in the tree"
324
465
    """Used when renaming and both source and dest exist."""
325
466
 
326
467
    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
327
 
            " (Use --after to tell brz about a rename that has already"
 
468
            " (Use --after to tell bzr about a rename that has already"
328
469
            " happened)%(extra)s")
329
470
 
330
471
    def __init__(self, source, dest, extra=None):
377
518
    _fmt = 'Permission denied: "%(path)s"%(extra)s'
378
519
 
379
520
 
 
521
class InvalidURL(PathError):
 
522
 
 
523
    _fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
 
524
 
 
525
 
 
526
class InvalidURLJoin(PathError):
 
527
 
 
528
    _fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"
 
529
 
 
530
    def __init__(self, reason, base, join_args):
 
531
        self.reason = reason
 
532
        self.base = base
 
533
        self.join_args = join_args
 
534
        PathError.__init__(self, base, reason)
 
535
 
 
536
 
 
537
class InvalidRebaseURLs(PathError):
 
538
 
 
539
    _fmt = "URLs differ by more than path: %(from_)r and %(to)r"
 
540
 
 
541
    def __init__(self, from_, to):
 
542
        self.from_ = from_
 
543
        self.to = to
 
544
        PathError.__init__(self, from_, 'URLs differ by more than path.')
 
545
 
 
546
 
 
547
class UnavailableRepresentation(InternalBzrError):
 
548
 
 
549
    _fmt = ("The encoding '%(wanted)s' is not available for key %(key)s which "
 
550
        "is encoded as '%(native)s'.")
 
551
 
 
552
    def __init__(self, key, wanted, native):
 
553
        InternalBzrError.__init__(self)
 
554
        self.wanted = wanted
 
555
        self.native = native
 
556
        self.key = key
 
557
 
 
558
 
 
559
class UnknownHook(BzrError):
 
560
 
 
561
    _fmt = "The %(type)s hook '%(hook)s' is unknown in this version of bzrlib."
 
562
 
 
563
    def __init__(self, hook_type, hook_name):
 
564
        BzrError.__init__(self)
 
565
        self.type = hook_type
 
566
        self.hook = hook_name
 
567
 
 
568
 
380
569
class UnsupportedProtocol(PathError):
381
570
 
382
571
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
385
574
        PathError.__init__(self, url, extra=extra)
386
575
 
387
576
 
 
577
class UnstackableBranchFormat(BzrError):
 
578
 
 
579
    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
 
580
        "You will need to upgrade the branch to permit branch stacking.")
 
581
 
 
582
    def __init__(self, format, url):
 
583
        BzrError.__init__(self)
 
584
        self.format = format
 
585
        self.url = url
 
586
 
 
587
 
388
588
class UnstackableLocationError(BzrError):
389
589
 
390
590
    _fmt = "The branch '%(branch_url)s' cannot be stacked on '%(target_url)s'."
398
598
class UnstackableRepositoryFormat(BzrError):
399
599
 
400
600
    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
401
 
            "You will need to upgrade the repository to permit branch stacking.")
 
601
        "You will need to upgrade the repository to permit branch stacking.")
402
602
 
403
603
    def __init__(self, format, url):
404
604
        BzrError.__init__(self)
453
653
 
454
654
    _fmt = 'Not a branch: "%(path)s"%(detail)s.'
455
655
 
456
 
    def __init__(self, path, detail=None, controldir=None):
457
 
        from . import urlutils
458
 
        path = urlutils.unescape_for_display(path, 'ascii')
459
 
        if detail is not None:
460
 
            detail = ': ' + detail
461
 
        self.detail = detail
462
 
        self.controldir = controldir
463
 
        PathError.__init__(self, path=path)
 
656
    def __init__(self, path, detail=None, bzrdir=None):
 
657
       import bzrlib.urlutils as urlutils
 
658
       path = urlutils.unescape_for_display(path, 'ascii')
 
659
       if detail is not None:
 
660
           detail = ': ' + detail
 
661
       self.detail = detail
 
662
       self.bzrdir = bzrdir
 
663
       PathError.__init__(self, path=path)
464
664
 
465
665
    def __repr__(self):
466
666
        return '<%s %r>' % (self.__class__.__name__, self.__dict__)
467
667
 
468
 
    def _get_format_string(self):
469
 
        # GZ 2017-06-08: Not the best place to lazy fill detail in.
 
668
    def _format(self):
 
669
        # XXX: Ideally self.detail would be a property, but Exceptions in
 
670
        # Python 2.4 have to be old-style classes so properties don't work.
 
671
        # Instead we override _format.
470
672
        if self.detail is None:
471
 
            self.detail = self._get_detail()
472
 
        return super(NotBranchError, self)._get_format_string()
473
 
 
474
 
    def _get_detail(self):
475
 
        if self.controldir is not None:
476
 
            try:
477
 
                self.controldir.open_repository()
478
 
            except NoRepositoryPresent:
479
 
                return ''
480
 
            except Exception as e:
481
 
                # Just ignore unexpected errors.  Raising arbitrary errors
482
 
                # during str(err) can provoke strange bugs.  Concretely
483
 
                # Launchpad's codehosting managed to raise NotBranchError
484
 
                # here, and then get stuck in an infinite loop/recursion
485
 
                # trying to str() that error.  All this error really cares
486
 
                # about that there's no working repository there, and if
487
 
                # open_repository() fails, there probably isn't.
488
 
                return ': ' + e.__class__.__name__
 
673
            if self.bzrdir is not None:
 
674
                try:
 
675
                    self.bzrdir.open_repository()
 
676
                except NoRepositoryPresent:
 
677
                    self.detail = ''
 
678
                except Exception:
 
679
                    # Just ignore unexpected errors.  Raising arbitrary errors
 
680
                    # during str(err) can provoke strange bugs.  Concretely
 
681
                    # Launchpad's codehosting managed to raise NotBranchError
 
682
                    # here, and then get stuck in an infinite loop/recursion
 
683
                    # trying to str() that error.  All this error really cares
 
684
                    # about that there's no working repository there, and if
 
685
                    # open_repository() fails, there probably isn't.
 
686
                    self.detail = ''
 
687
                else:
 
688
                    self.detail = ': location is a repository'
489
689
            else:
490
 
                return ': location is a repository'
491
 
        return ''
 
690
                self.detail = ''
 
691
        return PathError._format(self)
492
692
 
493
693
 
494
694
class NoSubmitBranch(PathError):
496
696
    _fmt = 'No submit branch available for branch "%(path)s"'
497
697
 
498
698
    def __init__(self, branch):
499
 
        from . import urlutils
500
 
        self.path = urlutils.unescape_for_display(branch.base, 'ascii')
 
699
       import bzrlib.urlutils as urlutils
 
700
       self.path = urlutils.unescape_for_display(branch.base, 'ascii')
501
701
 
502
702
 
503
703
class AlreadyControlDirError(PathError):
527
727
class BranchExistsWithoutWorkingTree(PathError):
528
728
 
529
729
    _fmt = 'Directory contains a branch, but no working tree \
530
 
(use brz checkout if you wish to build a working tree): "%(path)s"'
 
730
(use bzr checkout if you wish to build a working tree): "%(path)s"'
 
731
 
 
732
 
 
733
class AtomicFileAlreadyClosed(PathError):
 
734
 
 
735
    _fmt = ('"%(function)s" called on an AtomicFile after it was closed:'
 
736
            ' "%(path)s"')
 
737
 
 
738
    def __init__(self, path, function):
 
739
        PathError.__init__(self, path=path, extra=None)
 
740
        self.function = function
531
741
 
532
742
 
533
743
class InaccessibleParent(PathError):
543
753
class NoRepositoryPresent(BzrError):
544
754
 
545
755
    _fmt = 'No repository present: "%(path)s"'
546
 
 
547
 
    def __init__(self, controldir):
 
756
    def __init__(self, bzrdir):
548
757
        BzrError.__init__(self)
549
 
        self.path = controldir.transport.clone('..').base
 
758
        self.path = bzrdir.transport.clone('..').base
550
759
 
551
760
 
552
761
class UnsupportedFormatError(BzrError):
553
762
 
554
 
    _fmt = "Unsupported branch format: %(format)s\nPlease run 'brz upgrade'"
 
763
    _fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
555
764
 
556
765
 
557
766
class UnknownFormatError(BzrError):
565
774
 
566
775
class IncompatibleFormat(BzrError):
567
776
 
568
 
    _fmt = "Format %(format)s is not compatible with .bzr version %(controldir)s."
 
777
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
569
778
 
570
 
    def __init__(self, format, controldir_format):
 
779
    def __init__(self, format, bzrdir_format):
571
780
        BzrError.__init__(self)
572
781
        self.format = format
573
 
        self.controldir = controldir_format
 
782
        self.bzrdir = bzrdir_format
574
783
 
575
784
 
576
785
class ParseFormatError(BzrError):
594
803
    """
595
804
 
596
805
    _fmt = "%(target)s\n" \
597
 
        "is not compatible with\n" \
598
 
        "%(source)s\n" \
599
 
        "%(details)s"
 
806
            "is not compatible with\n" \
 
807
            "%(source)s\n" \
 
808
            "%(details)s"
600
809
 
601
810
    def __init__(self, source, target, details=None):
602
811
        if details is None:
661
870
    _fmt = "Path(s) are not versioned: %(paths_as_string)s"
662
871
 
663
872
    def __init__(self, paths):
664
 
        from breezy.osutils import quotefn
 
873
        from bzrlib.osutils import quotefn
665
874
        BzrError.__init__(self)
666
875
        self.paths = paths
667
876
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
676
885
 
677
886
    def __init__(self, paths, extra=None):
678
887
        # circular import
679
 
        from breezy.osutils import quotefn
 
888
        from bzrlib.osutils import quotefn
680
889
        BzrError.__init__(self)
681
890
        self.paths = paths
682
891
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
845
1054
class LockCorrupt(LockError):
846
1055
 
847
1056
    _fmt = ("Lock is apparently held, but corrupted: %(corruption_info)s\n"
848
 
            "Use 'brz break-lock' to clear it")
 
1057
            "Use 'bzr break-lock' to clear it")
849
1058
 
850
1059
    internal_error = False
851
1060
 
883
1092
        self.lock_token = lock_token
884
1093
 
885
1094
 
 
1095
class PointlessCommit(BzrError):
 
1096
 
 
1097
    _fmt = "No changes to commit"
 
1098
 
 
1099
 
 
1100
class CannotCommitSelectedFileMerge(BzrError):
 
1101
 
 
1102
    _fmt = 'Selected-file commit of merges is not supported yet:'\
 
1103
        ' files %(files_str)s'
 
1104
 
 
1105
    def __init__(self, files):
 
1106
        files_str = ', '.join(files)
 
1107
        BzrError.__init__(self, files=files, files_str=files_str)
 
1108
 
 
1109
 
 
1110
class ExcludesUnsupported(BzrError):
 
1111
 
 
1112
    _fmt = ('Excluding paths during commit is not supported by '
 
1113
            'repository at %(repository)r.')
 
1114
 
 
1115
    def __init__(self, repository):
 
1116
        BzrError.__init__(self, repository=repository)
 
1117
 
 
1118
 
 
1119
class BadCommitMessageEncoding(BzrError):
 
1120
 
 
1121
    _fmt = 'The specified commit message contains characters unsupported by '\
 
1122
        'the current encoding.'
 
1123
 
 
1124
 
886
1125
class UpgradeReadonly(BzrError):
887
1126
 
888
1127
    _fmt = "Upgrade URL cannot work with readonly URLs."
897
1136
        self.format = format
898
1137
 
899
1138
 
 
1139
class StrictCommitFailed(Exception):
 
1140
 
 
1141
    _fmt = "Commit refused because there are unknowns in the tree."
 
1142
 
 
1143
 
900
1144
class NoSuchRevision(InternalBzrError):
901
1145
 
902
1146
    _fmt = "%(branch)s has no revision %(revision)s"
930
1174
        self.revision_id = revision_id
931
1175
 
932
1176
 
 
1177
class InvalidRevisionSpec(BzrError):
 
1178
 
 
1179
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
 
1180
            " %(branch_url)s%(extra)s")
 
1181
 
 
1182
    def __init__(self, spec, branch, extra=None):
 
1183
        BzrError.__init__(self, branch=branch, spec=spec)
 
1184
        self.branch_url = getattr(branch, 'user_url', str(branch))
 
1185
        if extra:
 
1186
            self.extra = '\n' + str(extra)
 
1187
        else:
 
1188
            self.extra = ''
 
1189
 
 
1190
 
933
1191
class AppendRevisionsOnlyViolation(BzrError):
934
1192
 
935
1193
    _fmt = ('Operation denied because it would change the main history,'
936
 
            ' which is not permitted by the append_revisions_only setting on'
937
 
            ' branch "%(location)s".')
 
1194
           ' which is not permitted by the append_revisions_only setting on'
 
1195
           ' branch "%(location)s".')
938
1196
 
939
1197
    def __init__(self, location):
940
 
        import breezy.urlutils as urlutils
941
 
        location = urlutils.unescape_for_display(location, 'ascii')
942
 
        BzrError.__init__(self, location=location)
 
1198
       import bzrlib.urlutils as urlutils
 
1199
       location = urlutils.unescape_for_display(location, 'ascii')
 
1200
       BzrError.__init__(self, location=location)
943
1201
 
944
1202
 
945
1203
class DivergedBranches(BzrError):
985
1243
class NoCommonRoot(BzrError):
986
1244
 
987
1245
    _fmt = ("Revisions are not derived from the same root: "
988
 
            "%(revision_a)s %(revision_b)s.")
 
1246
           "%(revision_a)s %(revision_b)s.")
989
1247
 
990
1248
    def __init__(self, revision_a, revision_b):
991
1249
        BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
997
1255
 
998
1256
    def __init__(self, rev_id, not_ancestor_id):
999
1257
        BzrError.__init__(self, rev_id=rev_id,
1000
 
                          not_ancestor_id=not_ancestor_id)
 
1258
            not_ancestor_id=not_ancestor_id)
1001
1259
 
1002
1260
 
1003
1261
class NoCommits(BranchError):
1011
1269
        BzrError.__init__(self, "Store %s is not listable" % store)
1012
1270
 
1013
1271
 
 
1272
 
1014
1273
class UnlistableBranch(BzrError):
1015
1274
 
1016
1275
    def __init__(self, br):
1062
1321
        self.error = error
1063
1322
 
1064
1323
 
 
1324
class WeaveError(BzrError):
 
1325
 
 
1326
    _fmt = "Error in processing weave: %(msg)s"
 
1327
 
 
1328
    def __init__(self, msg=None):
 
1329
        BzrError.__init__(self)
 
1330
        self.msg = msg
 
1331
 
 
1332
 
 
1333
class WeaveRevisionAlreadyPresent(WeaveError):
 
1334
 
 
1335
    _fmt = "Revision {%(revision_id)s} already present in %(weave)s"
 
1336
 
 
1337
    def __init__(self, revision_id, weave):
 
1338
 
 
1339
        WeaveError.__init__(self)
 
1340
        self.revision_id = revision_id
 
1341
        self.weave = weave
 
1342
 
 
1343
 
 
1344
class WeaveRevisionNotPresent(WeaveError):
 
1345
 
 
1346
    _fmt = "Revision {%(revision_id)s} not present in %(weave)s"
 
1347
 
 
1348
    def __init__(self, revision_id, weave):
 
1349
        WeaveError.__init__(self)
 
1350
        self.revision_id = revision_id
 
1351
        self.weave = weave
 
1352
 
 
1353
 
 
1354
class WeaveFormatError(WeaveError):
 
1355
 
 
1356
    _fmt = "Weave invariant violated: %(what)s"
 
1357
 
 
1358
    def __init__(self, what):
 
1359
        WeaveError.__init__(self)
 
1360
        self.what = what
 
1361
 
 
1362
 
 
1363
class WeaveParentMismatch(WeaveError):
 
1364
 
 
1365
    _fmt = "Parents are mismatched between two revisions. %(msg)s"
 
1366
 
 
1367
 
 
1368
class WeaveInvalidChecksum(WeaveError):
 
1369
 
 
1370
    _fmt = "Text did not match its checksum: %(msg)s"
 
1371
 
 
1372
 
 
1373
class WeaveTextDiffers(WeaveError):
 
1374
 
 
1375
    _fmt = ("Weaves differ on text content. Revision:"
 
1376
            " {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
 
1377
 
 
1378
    def __init__(self, revision_id, weave_a, weave_b):
 
1379
        WeaveError.__init__(self)
 
1380
        self.revision_id = revision_id
 
1381
        self.weave_a = weave_a
 
1382
        self.weave_b = weave_b
 
1383
 
 
1384
 
 
1385
class WeaveTextDiffers(WeaveError):
 
1386
 
 
1387
    _fmt = ("Weaves differ on text content. Revision:"
 
1388
            " {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
 
1389
 
 
1390
    def __init__(self, revision_id, weave_a, weave_b):
 
1391
        WeaveError.__init__(self)
 
1392
        self.revision_id = revision_id
 
1393
        self.weave_a = weave_a
 
1394
        self.weave_b = weave_b
 
1395
 
 
1396
 
1065
1397
class VersionedFileError(BzrError):
1066
1398
 
1067
1399
    _fmt = "Versioned file error"
1092
1424
    _fmt = "Text did not match its checksum: %(msg)s"
1093
1425
 
1094
1426
 
 
1427
class KnitError(InternalBzrError):
 
1428
 
 
1429
    _fmt = "Knit error"
 
1430
 
 
1431
 
 
1432
class KnitCorrupt(KnitError):
 
1433
 
 
1434
    _fmt = "Knit %(filename)s corrupt: %(how)s"
 
1435
 
 
1436
    def __init__(self, filename, how):
 
1437
        KnitError.__init__(self)
 
1438
        self.filename = filename
 
1439
        self.how = how
 
1440
 
 
1441
 
 
1442
class SHA1KnitCorrupt(KnitCorrupt):
 
1443
 
 
1444
    _fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "
 
1445
        "match expected sha-1. key %(key)s expected sha %(expected)s actual "
 
1446
        "sha %(actual)s")
 
1447
 
 
1448
    def __init__(self, filename, actual, expected, key, content):
 
1449
        KnitError.__init__(self)
 
1450
        self.filename = filename
 
1451
        self.actual = actual
 
1452
        self.expected = expected
 
1453
        self.key = key
 
1454
        self.content = content
 
1455
 
 
1456
 
 
1457
class KnitDataStreamIncompatible(KnitError):
 
1458
    # Not raised anymore, as we can convert data streams.  In future we may
 
1459
    # need it again for more exotic cases, so we're keeping it around for now.
 
1460
 
 
1461
    _fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."
 
1462
 
 
1463
    def __init__(self, stream_format, target_format):
 
1464
        self.stream_format = stream_format
 
1465
        self.target_format = target_format
 
1466
 
 
1467
 
 
1468
class KnitDataStreamUnknown(KnitError):
 
1469
    # Indicates a data stream we don't know how to handle.
 
1470
 
 
1471
    _fmt = "Cannot parse knit data stream of format \"%(stream_format)s\"."
 
1472
 
 
1473
    def __init__(self, stream_format):
 
1474
        self.stream_format = stream_format
 
1475
 
 
1476
 
 
1477
class KnitHeaderError(KnitError):
 
1478
 
 
1479
    _fmt = 'Knit header error: %(badline)r unexpected for file "%(filename)s".'
 
1480
 
 
1481
    def __init__(self, badline, filename):
 
1482
        KnitError.__init__(self)
 
1483
        self.badline = badline
 
1484
        self.filename = filename
 
1485
 
 
1486
class KnitIndexUnknownMethod(KnitError):
 
1487
    """Raised when we don't understand the storage method.
 
1488
 
 
1489
    Currently only 'fulltext' and 'line-delta' are supported.
 
1490
    """
 
1491
 
 
1492
    _fmt = ("Knit index %(filename)s does not have a known method"
 
1493
            " in options: %(options)r")
 
1494
 
 
1495
    def __init__(self, filename, options):
 
1496
        KnitError.__init__(self)
 
1497
        self.filename = filename
 
1498
        self.options = options
 
1499
 
 
1500
 
1095
1501
class RetryWithNewPacks(BzrError):
1096
1502
    """Raised when we realize that the packs on disk have changed.
1097
1503
 
1158
1564
        if orig_error is None:
1159
1565
            orig_error = ''
1160
1566
        if msg is None:
1161
 
            msg = ''
 
1567
            msg =  ''
1162
1568
        self.msg = msg
1163
1569
        self.orig_error = orig_error
1164
1570
        BzrError.__init__(self)
1209
1615
        self.exc_type, self.exc_value, self.exc_tb = exc_info
1210
1616
        self.exc_info = exc_info
1211
1617
        traceback_strings = traceback.format_exception(
1212
 
            self.exc_type, self.exc_value, self.exc_tb)
 
1618
                self.exc_type, self.exc_value, self.exc_tb)
1213
1619
        self.traceback_text = ''.join(traceback_strings)
1214
1620
 
1215
1621
 
1280
1686
        TransportError.__init__(self, msg, orig_error=orig_error)
1281
1687
 
1282
1688
 
1283
 
class UnexpectedHttpStatus(InvalidHttpResponse):
1284
 
 
1285
 
    _fmt = "Unexpected HTTP status %(code)d for %(path)s"
1286
 
 
1287
 
    def __init__(self, path, code, msg=None):
1288
 
        self.path = path
1289
 
        self.code = code
1290
 
        self.msg = msg
1291
 
        full_msg = 'status code %d unexpected' % code
1292
 
        if msg is not None:
1293
 
            full_msg += ': ' + msg
1294
 
        InvalidHttpResponse.__init__(
1295
 
            self, path, full_msg)
1296
 
 
1297
 
 
1298
 
class BadHttpRequest(UnexpectedHttpStatus):
1299
 
 
1300
 
    _fmt = "Bad http request for %(path)s: %(reason)s"
1301
 
 
1302
 
    def __init__(self, path, reason):
1303
 
        self.path = path
1304
 
        self.reason = reason
1305
 
        TransportError.__init__(self, reason)
 
1689
class CertificateError(TransportError):
 
1690
 
 
1691
    _fmt = "Certificate error: %(error)s"
 
1692
 
 
1693
    def __init__(self, error):
 
1694
        self.error = error
1306
1695
 
1307
1696
 
1308
1697
class InvalidHttpRange(InvalidHttpResponse):
1360
1749
    _fmt = "Working tree has conflicts."
1361
1750
 
1362
1751
 
 
1752
class ConfigContentError(BzrError):
 
1753
 
 
1754
    _fmt = "Config file %(filename)s is not UTF-8 encoded\n"
 
1755
 
 
1756
    def __init__(self, filename):
 
1757
        BzrError.__init__(self)
 
1758
        self.filename = filename
 
1759
 
 
1760
 
 
1761
class ParseConfigError(BzrError):
 
1762
 
 
1763
    _fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
 
1764
 
 
1765
    def __init__(self, errors, filename):
 
1766
        BzrError.__init__(self)
 
1767
        self.filename = filename
 
1768
        self.errors = '\n'.join(e.msg for e in errors)
 
1769
 
 
1770
 
 
1771
class ConfigOptionValueError(BzrError):
 
1772
 
 
1773
    _fmt = ('Bad value "%(value)s" for option "%(name)s".\n'
 
1774
            'See ``bzr help %(name)s``')
 
1775
 
 
1776
    def __init__(self, name, value):
 
1777
        BzrError.__init__(self, name=name, value=value)
 
1778
 
 
1779
 
 
1780
class NoEmailInUsername(BzrError):
 
1781
 
 
1782
    _fmt = "%(username)r does not seem to contain a reasonable email address"
 
1783
 
 
1784
    def __init__(self, username):
 
1785
        BzrError.__init__(self)
 
1786
        self.username = username
 
1787
 
 
1788
 
 
1789
class SigningFailed(BzrError):
 
1790
 
 
1791
    _fmt = 'Failed to GPG sign data with command "%(command_line)s"'
 
1792
 
 
1793
    def __init__(self, command_line):
 
1794
        BzrError.__init__(self, command_line=command_line)
 
1795
 
 
1796
 
 
1797
class SignatureVerificationFailed(BzrError):
 
1798
 
 
1799
    _fmt = 'Failed to verify GPG signature data with error "%(error)s"'
 
1800
 
 
1801
    def __init__(self, error):
 
1802
        BzrError.__init__(self, error=error)
 
1803
 
 
1804
 
1363
1805
class DependencyNotPresent(BzrError):
1364
1806
 
1365
1807
    _fmt = 'Unable to import library "%(library)s": %(error)s'
1368
1810
        BzrError.__init__(self, library=library, error=error)
1369
1811
 
1370
1812
 
 
1813
class GpgmeNotInstalled(DependencyNotPresent):
 
1814
 
 
1815
    _fmt = 'python-gpgme is not installed, it is needed to verify signatures'
 
1816
 
 
1817
    def __init__(self, error):
 
1818
        DependencyNotPresent.__init__(self, 'gpgme', error)
 
1819
 
 
1820
 
1371
1821
class WorkingTreeNotRevision(BzrError):
1372
1822
 
1373
1823
    _fmt = ("The working tree for %(basedir)s has changed since"
1378
1828
        BzrError.__init__(self, basedir=tree.basedir)
1379
1829
 
1380
1830
 
 
1831
class CantReprocessAndShowBase(BzrError):
 
1832
 
 
1833
    _fmt = ("Can't reprocess and show base, because reprocessing obscures "
 
1834
           "the relationship of conflicting lines to the base")
 
1835
 
 
1836
 
1381
1837
class GraphCycleError(BzrError):
1382
1838
 
1383
1839
    _fmt = "Cycle in graph %(graph)r"
1460
1916
        self.file_id = file_id
1461
1917
 
1462
1918
 
 
1919
class DuplicateFileId(BzrError):
 
1920
 
 
1921
    _fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"
 
1922
 
 
1923
    def __init__(self, file_id, entry):
 
1924
        BzrError.__init__(self)
 
1925
        self.file_id = file_id
 
1926
        self.entry = entry
 
1927
 
 
1928
 
1463
1929
class DuplicateKey(BzrError):
1464
1930
 
1465
1931
    _fmt = "Key %(key)s is already present in map"
1473
1939
        self.prefix = prefix
1474
1940
 
1475
1941
 
 
1942
class MalformedTransform(InternalBzrError):
 
1943
 
 
1944
    _fmt = "Tree transform is malformed %(conflicts)r"
 
1945
 
 
1946
 
 
1947
class NoFinalPath(BzrError):
 
1948
 
 
1949
    _fmt = ("No final name for trans_id %(trans_id)r\n"
 
1950
            "file-id: %(file_id)r\n"
 
1951
            "root trans-id: %(root_trans_id)r\n")
 
1952
 
 
1953
    def __init__(self, trans_id, transform):
 
1954
        self.trans_id = trans_id
 
1955
        self.file_id = transform.final_file_id(trans_id)
 
1956
        self.root_trans_id = transform.root
 
1957
 
 
1958
 
1476
1959
class BzrBadParameter(InternalBzrError):
1477
1960
 
1478
1961
    _fmt = "Bad parameter: %(param)r"
1490
1973
    _fmt = "Parameter %(param)s is neither unicode nor utf8."
1491
1974
 
1492
1975
 
 
1976
class ReusingTransform(BzrError):
 
1977
 
 
1978
    _fmt = "Attempt to reuse a transform that has already been applied."
 
1979
 
 
1980
 
 
1981
class CantMoveRoot(BzrError):
 
1982
 
 
1983
    _fmt = "Moving the root directory is not supported at this time"
 
1984
 
 
1985
 
 
1986
class TransformRenameFailed(BzrError):
 
1987
 
 
1988
    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
 
1989
 
 
1990
    def __init__(self, from_path, to_path, why, errno):
 
1991
        self.from_path = from_path
 
1992
        self.to_path = to_path
 
1993
        self.why = why
 
1994
        self.errno = errno
 
1995
 
 
1996
 
1493
1997
class BzrMoveFailedError(BzrError):
1494
1998
 
1495
1999
    _fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
1496
 
            "%(_has_extra)s%(extra)s")
 
2000
        "%(_has_extra)s%(extra)s")
1497
2001
 
1498
2002
    def __init__(self, from_path='', to_path='', extra=None):
1499
 
        from breezy.osutils import splitpath
 
2003
        from bzrlib.osutils import splitpath
1500
2004
        BzrError.__init__(self)
1501
2005
        if extra:
1502
2006
            self.extra, self._has_extra = extra, ': '
1529
2033
class BzrRenameFailedError(BzrMoveFailedError):
1530
2034
 
1531
2035
    _fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
1532
 
            "%(_has_extra)s%(extra)s")
 
2036
        "%(_has_extra)s%(extra)s")
1533
2037
 
1534
2038
    def __init__(self, from_path, to_path, extra=None):
1535
2039
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1571
2075
 
1572
2076
class UninitializableFormat(BzrError):
1573
2077
 
1574
 
    _fmt = "Format %(format)s cannot be initialised by this version of brz."
 
2078
    _fmt = "Format %(format)s cannot be initialised by this version of bzr."
1575
2079
 
1576
2080
    def __init__(self, format):
1577
2081
        BzrError.__init__(self)
1581
2085
class BadConversionTarget(BzrError):
1582
2086
 
1583
2087
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
1584
 
        "    %(problem)s"
 
2088
            "    %(problem)s"
1585
2089
 
1586
2090
    def __init__(self, problem, format, from_format=None):
1587
2091
        BzrError.__init__(self)
1619
2123
    _fmt = "Diff3 is not installed on this machine."
1620
2124
 
1621
2125
 
 
2126
class ExistingContent(BzrError):
 
2127
    # Added in bzrlib 0.92, used by VersionedFile.add_lines.
 
2128
 
 
2129
    _fmt = "The content being inserted is already present."
 
2130
 
 
2131
 
1622
2132
class ExistingLimbo(BzrError):
1623
2133
 
1624
2134
    _fmt = """This tree contains left-over files from a failed operation.
1626
2136
    keep, and delete it when you are done."""
1627
2137
 
1628
2138
    def __init__(self, limbo_dir):
1629
 
        BzrError.__init__(self)
1630
 
        self.limbo_dir = limbo_dir
 
2139
       BzrError.__init__(self)
 
2140
       self.limbo_dir = limbo_dir
1631
2141
 
1632
2142
 
1633
2143
class ExistingPendingDeletion(BzrError):
1637
2147
    wish to keep, and delete it when you are done."""
1638
2148
 
1639
2149
    def __init__(self, pending_deletion):
1640
 
        BzrError.__init__(self, pending_deletion=pending_deletion)
 
2150
       BzrError.__init__(self, pending_deletion=pending_deletion)
 
2151
 
 
2152
 
 
2153
class ImmortalLimbo(BzrError):
 
2154
 
 
2155
    _fmt = """Unable to delete transform temporary directory %(limbo_dir)s.
 
2156
    Please examine %(limbo_dir)s to see if it contains any files you wish to
 
2157
    keep, and delete it when you are done."""
 
2158
 
 
2159
    def __init__(self, limbo_dir):
 
2160
       BzrError.__init__(self)
 
2161
       self.limbo_dir = limbo_dir
1641
2162
 
1642
2163
 
1643
2164
class ImmortalPendingDeletion(BzrError):
1644
2165
 
1645
2166
    _fmt = ("Unable to delete transform temporary directory "
1646
 
            "%(pending_deletion)s.  Please examine %(pending_deletion)s to see if it "
1647
 
            "contains any files you wish to keep, and delete it when you are done.")
 
2167
    "%(pending_deletion)s.  Please examine %(pending_deletion)s to see if it "
 
2168
    "contains any files you wish to keep, and delete it when you are done.")
1648
2169
 
1649
2170
    def __init__(self, pending_deletion):
1650
 
        BzrError.__init__(self, pending_deletion=pending_deletion)
 
2171
       BzrError.__init__(self, pending_deletion=pending_deletion)
1651
2172
 
1652
2173
 
1653
2174
class OutOfDateTree(BzrError):
1654
2175
 
1655
 
    _fmt = "Working tree is out of date, please run 'brz update'.%(more)s"
 
2176
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
1656
2177
 
1657
2178
    def __init__(self, tree, more=None):
1658
2179
        if more is None:
1670
2191
        '"%(revstring)s".'
1671
2192
 
1672
2193
    def __init__(self, public_location, revstring):
1673
 
        import breezy.urlutils as urlutils
 
2194
        import bzrlib.urlutils as urlutils
1674
2195
        public_location = urlutils.unescape_for_display(public_location,
1675
2196
                                                        'ascii')
1676
2197
        BzrError.__init__(self, public_location=public_location,
1687
2208
    _fmt = "Format error in conflict listings"
1688
2209
 
1689
2210
 
 
2211
class CorruptDirstate(BzrError):
 
2212
 
 
2213
    _fmt = ("Inconsistency in dirstate file %(dirstate_path)s.\n"
 
2214
            "Error: %(description)s")
 
2215
 
 
2216
    def __init__(self, dirstate_path, description):
 
2217
        BzrError.__init__(self)
 
2218
        self.dirstate_path = dirstate_path
 
2219
        self.description = description
 
2220
 
 
2221
 
1690
2222
class CorruptRepository(BzrError):
1691
2223
 
1692
2224
    _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
1693
 
            "Please run brz reconcile on this repository.")
 
2225
            "Please run bzr reconcile on this repository.")
1694
2226
 
1695
2227
    def __init__(self, repo):
1696
2228
        BzrError.__init__(self)
1739
2271
class RichRootUpgradeRequired(UpgradeRequired):
1740
2272
 
1741
2273
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
1742
 
            " a format which supports rich roots.")
 
2274
           " a format which supports rich roots.")
1743
2275
 
1744
2276
 
1745
2277
class LocalRequiresBoundBranch(BzrError):
1758
2290
        self.tname = type(method_self).__name__
1759
2291
 
1760
2292
 
1761
 
class FetchLimitUnsupported(UnsupportedOperation):
1762
 
 
1763
 
    fmt = ("InterBranch %(interbranch)r does not support fetching limits.")
1764
 
 
1765
 
    def __init__(self, interbranch):
1766
 
        BzrError.__init__(self, interbranch=interbranch)
 
2293
class CannotSetRevisionId(UnsupportedOperation):
 
2294
    """Raised when a commit is attempting to set a revision id but cant."""
1767
2295
 
1768
2296
 
1769
2297
class NonAsciiRevisionId(UnsupportedOperation):
1772
2300
    """
1773
2301
 
1774
2302
 
1775
 
class SharedRepositoriesUnsupported(UnsupportedOperation):
1776
 
    _fmt = "Shared repositories are not supported by %(format)r."
1777
 
 
1778
 
    def __init__(self, format):
1779
 
        BzrError.__init__(self, format=format)
1780
 
 
1781
 
 
1782
2303
class GhostTagsNotSupported(BzrError):
1783
2304
 
1784
2305
    _fmt = "Ghost tags not supported by format %(format)r."
1866
2387
        self.other = other
1867
2388
 
1868
2389
 
 
2390
class BadInventoryFormat(BzrError):
 
2391
 
 
2392
    _fmt = "Root class for inventory serialization errors"
 
2393
 
 
2394
 
 
2395
class UnexpectedInventoryFormat(BadInventoryFormat):
 
2396
 
 
2397
    _fmt = "The inventory was not in the expected format:\n %(msg)s"
 
2398
 
 
2399
    def __init__(self, msg):
 
2400
        BadInventoryFormat.__init__(self, msg=msg)
 
2401
 
 
2402
 
1869
2403
class RootNotRich(BzrError):
1870
2404
 
1871
2405
    _fmt = """This operation requires rich root data storage"""
1881
2415
 
1882
2416
class UnknownSSH(BzrError):
1883
2417
 
1884
 
    _fmt = "Unrecognised value for BRZ_SSH environment variable: %(vendor)s"
 
2418
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
1885
2419
 
1886
2420
    def __init__(self, vendor):
1887
2421
        BzrError.__init__(self)
1891
2425
class SSHVendorNotFound(BzrError):
1892
2426
 
1893
2427
    _fmt = ("Don't know how to handle SSH connections."
1894
 
            " Please set BRZ_SSH environment variable.")
 
2428
            " Please set BZR_SSH environment variable.")
1895
2429
 
1896
2430
 
1897
2431
class GhostRevisionsHaveNoRevno(BzrError):
1914
2448
        self.revision_id = revision_id
1915
2449
 
1916
2450
 
 
2451
class IllegalUseOfScopeReplacer(InternalBzrError):
 
2452
 
 
2453
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
 
2454
            " %(msg)s%(extra)s")
 
2455
 
 
2456
    def __init__(self, name, msg, extra=None):
 
2457
        BzrError.__init__(self)
 
2458
        self.name = name
 
2459
        self.msg = msg
 
2460
        if extra:
 
2461
            self.extra = ': ' + str(extra)
 
2462
        else:
 
2463
            self.extra = ''
 
2464
 
 
2465
 
 
2466
class InvalidImportLine(InternalBzrError):
 
2467
 
 
2468
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
 
2469
 
 
2470
    def __init__(self, text, msg):
 
2471
        BzrError.__init__(self)
 
2472
        self.text = text
 
2473
        self.msg = msg
 
2474
 
 
2475
 
 
2476
class ImportNameCollision(InternalBzrError):
 
2477
 
 
2478
    _fmt = ("Tried to import an object to the same name as"
 
2479
            " an existing object. %(name)s")
 
2480
 
 
2481
    def __init__(self, name):
 
2482
        BzrError.__init__(self)
 
2483
        self.name = name
 
2484
 
 
2485
 
1917
2486
class NotAMergeDirective(BzrError):
1918
2487
    """File starting with %(firstline)r is not a merge directive"""
1919
 
 
1920
2488
    def __init__(self, firstline):
1921
2489
        BzrError.__init__(self, firstline=firstline)
1922
2490
 
1928
2496
        " branch location."
1929
2497
 
1930
2498
 
 
2499
class IllegalMergeDirectivePayload(BzrError):
 
2500
    """A merge directive contained something other than a patch or bundle"""
 
2501
 
 
2502
    _fmt = "Bad merge directive payload %(start)r"
 
2503
 
 
2504
    def __init__(self, start):
 
2505
        BzrError(self)
 
2506
        self.start = start
 
2507
 
 
2508
 
1931
2509
class PatchVerificationFailed(BzrError):
1932
2510
    """A patch from a merge directive could not be verified"""
1933
2511
 
1957
2535
        self.location = location
1958
2536
 
1959
2537
 
 
2538
class UnsupportedInventoryKind(BzrError):
 
2539
 
 
2540
    _fmt = """Unsupported entry kind %(kind)s"""
 
2541
 
 
2542
    def __init__(self, kind):
 
2543
        self.kind = kind
 
2544
 
 
2545
 
1960
2546
class BadSubsumeSource(BzrError):
1961
2547
 
1962
2548
    _fmt = "Can't subsume %(other_tree)s into %(tree)s. %(reason)s"
1975
2561
        self.other_tree = other_tree
1976
2562
 
1977
2563
 
 
2564
class BadReferenceTarget(InternalBzrError):
 
2565
 
 
2566
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
 
2567
           "%(reason)s"
 
2568
 
 
2569
    def __init__(self, tree, other_tree, reason):
 
2570
        self.tree = tree
 
2571
        self.other_tree = other_tree
 
2572
        self.reason = reason
 
2573
 
 
2574
 
1978
2575
class NoSuchTag(BzrError):
1979
2576
 
1980
2577
    _fmt = "No such tag: %(tag_name)s"
1986
2583
class TagsNotSupported(BzrError):
1987
2584
 
1988
2585
    _fmt = ("Tags not supported by %(branch)s;"
1989
 
            " you may be able to use 'brz upgrade %(branch_url)s'.")
 
2586
            " you may be able to use bzr upgrade.")
1990
2587
 
1991
2588
    def __init__(self, branch):
1992
2589
        self.branch = branch
1993
 
        self.branch_url = branch.user_url
1994
2590
 
1995
2591
 
1996
2592
class TagAlreadyExists(BzrError):
2001
2597
        self.tag_name = tag_name
2002
2598
 
2003
2599
 
 
2600
class MalformedBugIdentifier(BzrError):
 
2601
 
 
2602
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
 
2603
            'See "bzr help bugs" for more information on this feature.')
 
2604
 
 
2605
    def __init__(self, bug_id, reason):
 
2606
        self.bug_id = bug_id
 
2607
        self.reason = reason
 
2608
 
 
2609
 
 
2610
class InvalidBugTrackerURL(BzrError):
 
2611
 
 
2612
    _fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
 
2613
            "contain {id}: %(url)s")
 
2614
 
 
2615
    def __init__(self, abbreviation, url):
 
2616
        self.abbreviation = abbreviation
 
2617
        self.url = url
 
2618
 
 
2619
 
 
2620
class UnknownBugTrackerAbbreviation(BzrError):
 
2621
 
 
2622
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
 
2623
            "on %(branch)s")
 
2624
 
 
2625
    def __init__(self, abbreviation, branch):
 
2626
        self.abbreviation = abbreviation
 
2627
        self.branch = branch
 
2628
 
 
2629
 
 
2630
class InvalidLineInBugsProperty(BzrError):
 
2631
 
 
2632
    _fmt = ("Invalid line in bugs property: '%(line)s'")
 
2633
 
 
2634
    def __init__(self, line):
 
2635
        self.line = line
 
2636
 
 
2637
 
 
2638
class InvalidBugStatus(BzrError):
 
2639
 
 
2640
    _fmt = ("Invalid bug status: '%(status)s'")
 
2641
 
 
2642
    def __init__(self, status):
 
2643
        self.status = status
 
2644
 
 
2645
 
2004
2646
class UnexpectedSmartServerResponse(BzrError):
2005
2647
 
2006
2648
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2029
2671
 
2030
2672
 
2031
2673
class UnknownErrorFromSmartServer(BzrError):
2032
 
    """An ErrorFromSmartServer could not be translated into a typical breezy
 
2674
    """An ErrorFromSmartServer could not be translated into a typical bzrlib
2033
2675
    error.
2034
2676
 
2035
2677
    This is distinct from ErrorFromSmartServer so that it is possible to
2104
2746
        self.name = name.decode("utf-8")
2105
2747
 
2106
2748
 
 
2749
class NoDestinationAddress(InternalBzrError):
 
2750
 
 
2751
    _fmt = "Message does not have a destination address."
 
2752
 
 
2753
 
2107
2754
class RepositoryDataStreamError(BzrError):
2108
2755
 
2109
2756
    _fmt = "Corrupt or incompatible data stream: %(reason)s"
2112
2759
        self.reason = reason
2113
2760
 
2114
2761
 
 
2762
class SMTPError(BzrError):
 
2763
 
 
2764
    _fmt = "SMTP error: %(error)s"
 
2765
 
 
2766
    def __init__(self, error):
 
2767
        self.error = error
 
2768
 
 
2769
 
 
2770
class NoMessageSupplied(BzrError):
 
2771
 
 
2772
    _fmt = "No message supplied."
 
2773
 
 
2774
 
 
2775
class NoMailAddressSpecified(BzrError):
 
2776
 
 
2777
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
 
2778
 
 
2779
 
 
2780
class MailClientNotFound(BzrError):
 
2781
 
 
2782
    _fmt = "Unable to find mail client with the following names:"\
 
2783
        " %(mail_command_list_string)s"
 
2784
 
 
2785
    def __init__(self, mail_command_list):
 
2786
        mail_command_list_string = ', '.join(mail_command_list)
 
2787
        BzrError.__init__(self, mail_command_list=mail_command_list,
 
2788
                          mail_command_list_string=mail_command_list_string)
 
2789
 
 
2790
class SMTPConnectionRefused(SMTPError):
 
2791
 
 
2792
    _fmt = "SMTP connection to %(host)s refused"
 
2793
 
 
2794
    def __init__(self, error, host):
 
2795
        self.error = error
 
2796
        self.host = host
 
2797
 
 
2798
 
 
2799
class DefaultSMTPConnectionRefused(SMTPConnectionRefused):
 
2800
 
 
2801
    _fmt = "Please specify smtp_server.  No server at default %(host)s."
 
2802
 
 
2803
 
 
2804
class BzrDirError(BzrError):
 
2805
 
 
2806
    def __init__(self, bzrdir):
 
2807
        import bzrlib.urlutils as urlutils
 
2808
        display_url = urlutils.unescape_for_display(bzrdir.user_url,
 
2809
                                                    'ascii')
 
2810
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
 
2811
 
 
2812
 
 
2813
class UnsyncedBranches(BzrDirError):
 
2814
 
 
2815
    _fmt = ("'%(display_url)s' is not in sync with %(target_url)s.  See"
 
2816
            " bzr help sync-for-reconfigure.")
 
2817
 
 
2818
    def __init__(self, bzrdir, target_branch):
 
2819
        BzrDirError.__init__(self, bzrdir)
 
2820
        import bzrlib.urlutils as urlutils
 
2821
        self.target_url = urlutils.unescape_for_display(target_branch.base,
 
2822
                                                        'ascii')
 
2823
 
 
2824
 
 
2825
class AlreadyBranch(BzrDirError):
 
2826
 
 
2827
    _fmt = "'%(display_url)s' is already a branch."
 
2828
 
 
2829
 
 
2830
class AlreadyTree(BzrDirError):
 
2831
 
 
2832
    _fmt = "'%(display_url)s' is already a tree."
 
2833
 
 
2834
 
 
2835
class AlreadyCheckout(BzrDirError):
 
2836
 
 
2837
    _fmt = "'%(display_url)s' is already a checkout."
 
2838
 
 
2839
 
 
2840
class AlreadyLightweightCheckout(BzrDirError):
 
2841
 
 
2842
    _fmt = "'%(display_url)s' is already a lightweight checkout."
 
2843
 
 
2844
 
 
2845
class AlreadyUsingShared(BzrDirError):
 
2846
 
 
2847
    _fmt = "'%(display_url)s' is already using a shared repository."
 
2848
 
 
2849
 
 
2850
class AlreadyStandalone(BzrDirError):
 
2851
 
 
2852
    _fmt = "'%(display_url)s' is already standalone."
 
2853
 
 
2854
 
 
2855
class AlreadyWithTrees(BzrDirError):
 
2856
 
 
2857
    _fmt = ("Shared repository '%(display_url)s' already creates "
 
2858
            "working trees.")
 
2859
 
 
2860
 
 
2861
class AlreadyWithNoTrees(BzrDirError):
 
2862
 
 
2863
    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
 
2864
            "working trees.")
 
2865
 
 
2866
 
 
2867
class ReconfigurationNotSupported(BzrDirError):
 
2868
 
 
2869
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
 
2870
 
 
2871
 
 
2872
class NoBindLocation(BzrDirError):
 
2873
 
 
2874
    _fmt = "No location could be found to bind to at %(display_url)s."
 
2875
 
 
2876
 
2115
2877
class UncommittedChanges(BzrError):
2116
2878
 
2117
2879
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
2118
 
            ' (See brz status).%(more)s')
 
2880
            ' (See bzr status).%(more)s')
2119
2881
 
2120
2882
    def __init__(self, tree, more=None):
2121
2883
        if more is None:
2122
2884
            more = ''
2123
2885
        else:
2124
2886
            more = ' ' + more
2125
 
        import breezy.urlutils as urlutils
 
2887
        import bzrlib.urlutils as urlutils
2126
2888
        user_url = getattr(tree, "user_url", None)
2127
2889
        if user_url is None:
2128
2890
            display_url = str(tree)
2137
2899
            ' changes.')
2138
2900
 
2139
2901
    def __init__(self, branch):
2140
 
        import breezy.urlutils as urlutils
 
2902
        import bzrlib.urlutils as urlutils
2141
2903
        user_url = getattr(branch, "user_url", None)
2142
2904
        if user_url is None:
2143
2905
            display_url = str(branch)
2149
2911
class ShelvedChanges(UncommittedChanges):
2150
2912
 
2151
2913
    _fmt = ('Working tree "%(display_url)s" has shelved changes'
2152
 
            ' (See brz shelve --list).%(more)s')
 
2914
            ' (See bzr shelve --list).%(more)s')
 
2915
 
 
2916
 
 
2917
class MissingTemplateVariable(BzrError):
 
2918
 
 
2919
    _fmt = 'Variable {%(name)s} is not available.'
 
2920
 
 
2921
    def __init__(self, name):
 
2922
        self.name = name
 
2923
 
 
2924
 
 
2925
class NoTemplate(BzrError):
 
2926
 
 
2927
    _fmt = 'No template specified.'
 
2928
 
 
2929
 
 
2930
class UnableCreateSymlink(BzrError):
 
2931
 
 
2932
    _fmt = 'Unable to create symlink %(path_str)son this platform'
 
2933
 
 
2934
    def __init__(self, path=None):
 
2935
        path_str = ''
 
2936
        if path:
 
2937
            try:
 
2938
                path_str = repr(str(path))
 
2939
            except UnicodeEncodeError:
 
2940
                path_str = repr(path)
 
2941
            path_str += ' '
 
2942
        self.path_str = path_str
 
2943
 
 
2944
 
 
2945
class UnsupportedTimezoneFormat(BzrError):
 
2946
 
 
2947
    _fmt = ('Unsupported timezone format "%(timezone)s", '
 
2948
            'options are "utc", "original", "local".')
 
2949
 
 
2950
    def __init__(self, timezone):
 
2951
        self.timezone = timezone
 
2952
 
 
2953
 
 
2954
class CommandAvailableInPlugin(StandardError):
 
2955
 
 
2956
    internal_error = False
 
2957
 
 
2958
    def __init__(self, cmd_name, plugin_metadata, provider):
 
2959
 
 
2960
        self.plugin_metadata = plugin_metadata
 
2961
        self.cmd_name = cmd_name
 
2962
        self.provider = provider
 
2963
 
 
2964
    def __str__(self):
 
2965
 
 
2966
        _fmt = ('"%s" is not a standard bzr command. \n'
 
2967
                'However, the following official plugin provides this command: %s\n'
 
2968
                'You can install it by going to: %s'
 
2969
                % (self.cmd_name, self.plugin_metadata['name'],
 
2970
                    self.plugin_metadata['url']))
 
2971
 
 
2972
        return _fmt
 
2973
 
 
2974
 
 
2975
class NoPluginAvailable(BzrError):
 
2976
    pass
2153
2977
 
2154
2978
 
2155
2979
class UnableEncodePath(BzrError):
2158
2982
            'user encoding %(user_encoding)s')
2159
2983
 
2160
2984
    def __init__(self, path, kind):
2161
 
        from breezy.osutils import get_user_encoding
 
2985
        from bzrlib.osutils import get_user_encoding
2162
2986
        self.path = path
2163
2987
        self.kind = kind
2164
2988
        self.user_encoding = get_user_encoding()
2165
2989
 
2166
2990
 
 
2991
class NoSuchConfig(BzrError):
 
2992
 
 
2993
    _fmt = ('The "%(config_id)s" configuration does not exist.')
 
2994
 
 
2995
    def __init__(self, config_id):
 
2996
        BzrError.__init__(self, config_id=config_id)
 
2997
 
 
2998
 
 
2999
class NoSuchConfigOption(BzrError):
 
3000
 
 
3001
    _fmt = ('The "%(option_name)s" configuration option does not exist.')
 
3002
 
 
3003
    def __init__(self, option_name):
 
3004
        BzrError.__init__(self, option_name=option_name)
 
3005
 
 
3006
 
2167
3007
class NoSuchAlias(BzrError):
2168
3008
 
2169
3009
    _fmt = ('The alias "%(alias_name)s" does not exist.')
2172
3012
        BzrError.__init__(self, alias_name=alias_name)
2173
3013
 
2174
3014
 
 
3015
class DirectoryLookupFailure(BzrError):
 
3016
    """Base type for lookup errors."""
 
3017
 
 
3018
    pass
 
3019
 
 
3020
 
 
3021
class InvalidLocationAlias(DirectoryLookupFailure):
 
3022
 
 
3023
    _fmt = '"%(alias_name)s" is not a valid location alias.'
 
3024
 
 
3025
    def __init__(self, alias_name):
 
3026
        DirectoryLookupFailure.__init__(self, alias_name=alias_name)
 
3027
 
 
3028
 
 
3029
class UnsetLocationAlias(DirectoryLookupFailure):
 
3030
 
 
3031
    _fmt = 'No %(alias_name)s location assigned.'
 
3032
 
 
3033
    def __init__(self, alias_name):
 
3034
        DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
 
3035
 
 
3036
 
2175
3037
class CannotBindAddress(BzrError):
2176
3038
 
2177
3039
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
2179
3041
    def __init__(self, host, port, orig_error):
2180
3042
        # nb: in python2.4 socket.error doesn't have a useful repr
2181
3043
        BzrError.__init__(self, host=host, port=port,
2182
 
                          orig_error=repr(orig_error.args))
 
3044
            orig_error=repr(orig_error.args))
 
3045
 
 
3046
 
 
3047
class UnknownRules(BzrError):
 
3048
 
 
3049
    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
 
3050
 
 
3051
    def __init__(self, unknowns):
 
3052
        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
2183
3053
 
2184
3054
 
2185
3055
class TipChangeRejected(BzrError):
2193
3063
        self.msg = msg
2194
3064
 
2195
3065
 
 
3066
class ShelfCorrupt(BzrError):
 
3067
 
 
3068
    _fmt = "Shelf corrupt."
 
3069
 
 
3070
 
 
3071
class DecompressCorruption(BzrError):
 
3072
 
 
3073
    _fmt = "Corruption while decompressing repository file%(orig_error)s"
 
3074
 
 
3075
    def __init__(self, orig_error=None):
 
3076
        if orig_error is not None:
 
3077
            self.orig_error = ", %s" % (orig_error,)
 
3078
        else:
 
3079
            self.orig_error = ""
 
3080
        BzrError.__init__(self)
 
3081
 
 
3082
 
 
3083
class NoSuchShelfId(BzrError):
 
3084
 
 
3085
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
 
3086
 
 
3087
    def __init__(self, shelf_id):
 
3088
        BzrError.__init__(self, shelf_id=shelf_id)
 
3089
 
 
3090
 
 
3091
class InvalidShelfId(BzrError):
 
3092
 
 
3093
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
 
3094
 
 
3095
    def __init__(self, invalid_id):
 
3096
        BzrError.__init__(self, invalid_id=invalid_id)
 
3097
 
 
3098
 
2196
3099
class JailBreak(BzrError):
2197
3100
 
2198
3101
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
2206
3109
    _fmt = 'The user aborted the operation.'
2207
3110
 
2208
3111
 
 
3112
class MustHaveWorkingTree(BzrError):
 
3113
 
 
3114
    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
 
3115
 
 
3116
    def __init__(self, format, url):
 
3117
        BzrError.__init__(self, format=format, url=url)
 
3118
 
 
3119
 
 
3120
class NoSuchView(BzrError):
 
3121
    """A view does not exist.
 
3122
    """
 
3123
 
 
3124
    _fmt = u"No such view: %(view_name)s."
 
3125
 
 
3126
    def __init__(self, view_name):
 
3127
        self.view_name = view_name
 
3128
 
 
3129
 
 
3130
class ViewsNotSupported(BzrError):
 
3131
    """Views are not supported by a tree format.
 
3132
    """
 
3133
 
 
3134
    _fmt = ("Views are not supported by %(tree)s;"
 
3135
            " use 'bzr upgrade' to change your tree to a later format.")
 
3136
 
 
3137
    def __init__(self, tree):
 
3138
        self.tree = tree
 
3139
 
 
3140
 
 
3141
class FileOutsideView(BzrError):
 
3142
 
 
3143
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
 
3144
            '%(view_str)s')
 
3145
 
 
3146
    def __init__(self, file_name, view_files):
 
3147
        self.file_name = file_name
 
3148
        self.view_str = ", ".join(view_files)
 
3149
 
 
3150
 
2209
3151
class UnresumableWriteGroup(BzrError):
2210
3152
 
2211
3153
    _fmt = ("Repository %(repository)s cannot resume write group "
2253
3195
        self.target_branch = target_branch
2254
3196
 
2255
3197
 
 
3198
class FileTimestampUnavailable(BzrError):
 
3199
 
 
3200
    _fmt = "The filestamp for %(path)s is not available."
 
3201
 
 
3202
    internal_error = True
 
3203
 
 
3204
    def __init__(self, path):
 
3205
        self.path = path
 
3206
 
 
3207
 
2256
3208
class NoColocatedBranchSupport(BzrError):
2257
3209
 
2258
 
    _fmt = ("%(controldir)r does not support co-located branches.")
2259
 
 
2260
 
    def __init__(self, controldir):
2261
 
        self.controldir = controldir
 
3210
    _fmt = ("%(bzrdir)r does not support co-located branches.")
 
3211
 
 
3212
    def __init__(self, bzrdir):
 
3213
        self.bzrdir = bzrdir
 
3214
 
 
3215
 
 
3216
class NoWhoami(BzrError):
 
3217
 
 
3218
    _fmt = ('Unable to determine your name.\n'
 
3219
        "Please, set your name with the 'whoami' command.\n"
 
3220
        'E.g. bzr whoami "Your Name <name@example.com>"')
 
3221
 
 
3222
 
 
3223
class InvalidPattern(BzrError):
 
3224
 
 
3225
    _fmt = ('Invalid pattern(s) found. %(msg)s')
 
3226
 
 
3227
    def __init__(self, msg):
 
3228
        self.msg = msg
2262
3229
 
2263
3230
 
2264
3231
class RecursiveBind(BzrError):
2265
3232
 
2266
3233
    _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
2267
 
            'Please use `brz unbind` to fix.')
 
3234
        'Please use `bzr unbind` to fix.')
2268
3235
 
2269
3236
    def __init__(self, branch_url):
2270
3237
        self.branch_url = branch_url
2271
3238
 
2272
3239
 
 
3240
# FIXME: I would prefer to define the config related exception classes in
 
3241
# config.py but the lazy import mechanism proscribes this -- vila 20101222
 
3242
class OptionExpansionLoop(BzrError):
 
3243
 
 
3244
    _fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
 
3245
 
 
3246
    def __init__(self, string, refs):
 
3247
        self.string = string
 
3248
        self.refs = '->'.join(refs)
 
3249
 
 
3250
 
 
3251
class ExpandingUnknownOption(BzrError):
 
3252
 
 
3253
    _fmt = 'Option "%(name)s" is not defined while expanding "%(string)s".'
 
3254
 
 
3255
    def __init__(self, name, string):
 
3256
        self.name = name
 
3257
        self.string = string
 
3258
 
 
3259
 
 
3260
class IllegalOptionName(BzrError):
 
3261
 
 
3262
    _fmt = 'Option "%(name)s" is not allowed.'
 
3263
 
 
3264
    def __init__(self, name):
 
3265
        self.name = name
 
3266
 
 
3267
 
 
3268
class NoCompatibleInter(BzrError):
 
3269
 
 
3270
    _fmt = ('No compatible object available for operations from %(source)r '
 
3271
            'to %(target)r.')
 
3272
 
 
3273
    def __init__(self, source, target):
 
3274
        self.source = source
 
3275
        self.target = target
 
3276
 
 
3277
 
 
3278
class HpssVfsRequestNotAllowed(BzrError):
 
3279
 
 
3280
    _fmt = ("VFS requests over the smart server are not allowed. Encountered: "
 
3281
            "%(method)s, %(arguments)s.")
 
3282
 
 
3283
    def __init__(self, method, arguments):
 
3284
        self.method = method
 
3285
        self.arguments = arguments
 
3286
 
 
3287
 
2273
3288
class UnsupportedKindChange(BzrError):
2274
3289
 
2275
3290
    _fmt = ("Kind change from %(from_kind)s to %(to_kind)s for "
2282
3297
        self.format = format
2283
3298
 
2284
3299
 
2285
 
class ChangesAlreadyStored(CommandError):
 
3300
class MissingFeature(BzrError):
 
3301
 
 
3302
    _fmt = ("Missing feature %(feature)s not provided by this "
 
3303
            "version of Bazaar or any plugin.")
 
3304
 
 
3305
    def __init__(self, feature):
 
3306
        self.feature = feature
 
3307
 
 
3308
 
 
3309
class PatchSyntax(BzrError):
 
3310
    """Base class for patch syntax errors."""
 
3311
 
 
3312
 
 
3313
class BinaryFiles(BzrError):
 
3314
 
 
3315
    _fmt = 'Binary files section encountered.'
 
3316
 
 
3317
    def __init__(self, orig_name, mod_name):
 
3318
        self.orig_name = orig_name
 
3319
        self.mod_name = mod_name
 
3320
 
 
3321
 
 
3322
class MalformedPatchHeader(PatchSyntax):
 
3323
 
 
3324
    _fmt = "Malformed patch header.  %(desc)s\n%(line)r"
 
3325
 
 
3326
    def __init__(self, desc, line):
 
3327
        self.desc = desc
 
3328
        self.line = line
 
3329
 
 
3330
 
 
3331
class MalformedHunkHeader(PatchSyntax):
 
3332
 
 
3333
    _fmt = "Malformed hunk header.  %(desc)s\n%(line)r"
 
3334
 
 
3335
    def __init__(self, desc, line):
 
3336
        self.desc = desc
 
3337
        self.line = line
 
3338
 
 
3339
 
 
3340
class MalformedLine(PatchSyntax):
 
3341
 
 
3342
    _fmt = "Malformed line.  %(desc)s\n%(line)r"
 
3343
 
 
3344
    def __init__(self, desc, line):
 
3345
        self.desc = desc
 
3346
        self.line = line
 
3347
 
 
3348
 
 
3349
class PatchConflict(BzrError):
 
3350
 
 
3351
    _fmt = ('Text contents mismatch at line %(line_no)d.  Original has '
 
3352
            '"%(orig_line)s", but patch says it should be "%(patch_line)s"')
 
3353
 
 
3354
    def __init__(self, line_no, orig_line, patch_line):
 
3355
        self.line_no = line_no
 
3356
        self.orig_line = orig_line.rstrip('\n')
 
3357
        self.patch_line = patch_line.rstrip('\n')
 
3358
 
 
3359
 
 
3360
class FeatureAlreadyRegistered(BzrError):
 
3361
 
 
3362
    _fmt = 'The feature %(feature)s has already been registered.'
 
3363
 
 
3364
    def __init__(self, feature):
 
3365
        self.feature = feature
 
3366
 
 
3367
 
 
3368
class ChangesAlreadyStored(BzrCommandError):
2286
3369
 
2287
3370
    _fmt = ('Cannot store uncommitted changes because this branch already'
2288
3371
            ' stores uncommitted changes.')
2289
 
 
2290
 
 
2291
 
class RevnoOutOfBounds(InternalBzrError):
2292
 
 
2293
 
    _fmt = ("The requested revision number %(revno)d is outside of the "
2294
 
            "expected boundaries (%(minimum)d <= %(maximum)d).")
2295
 
 
2296
 
    def __init__(self, revno, bounds):
2297
 
        InternalBzrError.__init__(
2298
 
            self, revno=revno, minimum=bounds[0], maximum=bounds[1])