/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 breezy/errors.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-08 23:30:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170608233031-3qavls2o7a1pqllj
Update imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
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:
96
96
                # never a 'unicode' object.
97
97
                return s
98
98
        except Exception as e:
99
 
            err = 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))
113
133
        fmt = getattr(self, '_fmt', None)
114
134
        if fmt is not None:
115
135
            from breezy.i18n import gettext
116
 
            return gettext(fmt)  # _fmt strings should be ascii
 
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 breezy.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 'brz 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"
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 breezy."
 
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 breezy.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 breezy.urlutils as urlutils
 
700
       self.path = urlutils.unescape_for_display(branch.base, 'ascii')
501
701
 
502
702
 
503
703
class AlreadyControlDirError(PathError):
530
730
(use brz checkout if you wish to build a working tree): "%(path)s"'
531
731
 
532
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
 
741
 
 
742
 
533
743
class InaccessibleParent(PathError):
534
744
 
535
745
    _fmt = ('Parent not accessible given base "%(base)s" and'
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):
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:
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 breezy.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)
1306
 
 
1307
 
 
1308
1689
class InvalidHttpRange(InvalidHttpResponse):
1309
1690
 
1310
1691
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1360
1741
    _fmt = "Working tree has conflicts."
1361
1742
 
1362
1743
 
 
1744
class ConfigContentError(BzrError):
 
1745
 
 
1746
    _fmt = "Config file %(filename)s is not UTF-8 encoded\n"
 
1747
 
 
1748
    def __init__(self, filename):
 
1749
        BzrError.__init__(self)
 
1750
        self.filename = filename
 
1751
 
 
1752
 
 
1753
class ParseConfigError(BzrError):
 
1754
 
 
1755
    _fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
 
1756
 
 
1757
    def __init__(self, errors, filename):
 
1758
        BzrError.__init__(self)
 
1759
        self.filename = filename
 
1760
        self.errors = '\n'.join(e.msg for e in errors)
 
1761
 
 
1762
 
 
1763
class ConfigOptionValueError(BzrError):
 
1764
 
 
1765
    _fmt = ('Bad value "%(value)s" for option "%(name)s".\n'
 
1766
            'See ``brz help %(name)s``')
 
1767
 
 
1768
    def __init__(self, name, value):
 
1769
        BzrError.__init__(self, name=name, value=value)
 
1770
 
 
1771
 
 
1772
class NoEmailInUsername(BzrError):
 
1773
 
 
1774
    _fmt = "%(username)r does not seem to contain a reasonable email address"
 
1775
 
 
1776
    def __init__(self, username):
 
1777
        BzrError.__init__(self)
 
1778
        self.username = username
 
1779
 
 
1780
 
 
1781
class SigningFailed(BzrError):
 
1782
 
 
1783
    _fmt = 'Failed to GPG sign data with command "%(command_line)s"'
 
1784
 
 
1785
    def __init__(self, command_line):
 
1786
        BzrError.__init__(self, command_line=command_line)
 
1787
 
 
1788
 
 
1789
class SignatureVerificationFailed(BzrError):
 
1790
 
 
1791
    _fmt = 'Failed to verify GPG signature data with error "%(error)s"'
 
1792
 
 
1793
    def __init__(self, error):
 
1794
        BzrError.__init__(self, error=error)
 
1795
 
 
1796
 
1363
1797
class DependencyNotPresent(BzrError):
1364
1798
 
1365
1799
    _fmt = 'Unable to import library "%(library)s": %(error)s'
1368
1802
        BzrError.__init__(self, library=library, error=error)
1369
1803
 
1370
1804
 
 
1805
class GpgmeNotInstalled(DependencyNotPresent):
 
1806
 
 
1807
    _fmt = 'python-gpgme is not installed, it is needed to verify signatures'
 
1808
 
 
1809
    def __init__(self, error):
 
1810
        DependencyNotPresent.__init__(self, 'gpgme', error)
 
1811
 
 
1812
 
1371
1813
class WorkingTreeNotRevision(BzrError):
1372
1814
 
1373
1815
    _fmt = ("The working tree for %(basedir)s has changed since"
1378
1820
        BzrError.__init__(self, basedir=tree.basedir)
1379
1821
 
1380
1822
 
 
1823
class CantReprocessAndShowBase(BzrError):
 
1824
 
 
1825
    _fmt = ("Can't reprocess and show base, because reprocessing obscures "
 
1826
           "the relationship of conflicting lines to the base")
 
1827
 
 
1828
 
1381
1829
class GraphCycleError(BzrError):
1382
1830
 
1383
1831
    _fmt = "Cycle in graph %(graph)r"
1460
1908
        self.file_id = file_id
1461
1909
 
1462
1910
 
 
1911
class DuplicateFileId(BzrError):
 
1912
 
 
1913
    _fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"
 
1914
 
 
1915
    def __init__(self, file_id, entry):
 
1916
        BzrError.__init__(self)
 
1917
        self.file_id = file_id
 
1918
        self.entry = entry
 
1919
 
 
1920
 
1463
1921
class DuplicateKey(BzrError):
1464
1922
 
1465
1923
    _fmt = "Key %(key)s is already present in map"
1473
1931
        self.prefix = prefix
1474
1932
 
1475
1933
 
 
1934
class MalformedTransform(InternalBzrError):
 
1935
 
 
1936
    _fmt = "Tree transform is malformed %(conflicts)r"
 
1937
 
 
1938
 
 
1939
class NoFinalPath(BzrError):
 
1940
 
 
1941
    _fmt = ("No final name for trans_id %(trans_id)r\n"
 
1942
            "file-id: %(file_id)r\n"
 
1943
            "root trans-id: %(root_trans_id)r\n")
 
1944
 
 
1945
    def __init__(self, trans_id, transform):
 
1946
        self.trans_id = trans_id
 
1947
        self.file_id = transform.final_file_id(trans_id)
 
1948
        self.root_trans_id = transform.root
 
1949
 
 
1950
 
1476
1951
class BzrBadParameter(InternalBzrError):
1477
1952
 
1478
1953
    _fmt = "Bad parameter: %(param)r"
1490
1965
    _fmt = "Parameter %(param)s is neither unicode nor utf8."
1491
1966
 
1492
1967
 
 
1968
class ReusingTransform(BzrError):
 
1969
 
 
1970
    _fmt = "Attempt to reuse a transform that has already been applied."
 
1971
 
 
1972
 
 
1973
class CantMoveRoot(BzrError):
 
1974
 
 
1975
    _fmt = "Moving the root directory is not supported at this time"
 
1976
 
 
1977
 
 
1978
class TransformRenameFailed(BzrError):
 
1979
 
 
1980
    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
 
1981
 
 
1982
    def __init__(self, from_path, to_path, why, errno):
 
1983
        self.from_path = from_path
 
1984
        self.to_path = to_path
 
1985
        self.why = why
 
1986
        self.errno = errno
 
1987
 
 
1988
 
1493
1989
class BzrMoveFailedError(BzrError):
1494
1990
 
1495
1991
    _fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
1496
 
            "%(_has_extra)s%(extra)s")
 
1992
        "%(_has_extra)s%(extra)s")
1497
1993
 
1498
1994
    def __init__(self, from_path='', to_path='', extra=None):
1499
1995
        from breezy.osutils import splitpath
1529
2025
class BzrRenameFailedError(BzrMoveFailedError):
1530
2026
 
1531
2027
    _fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
1532
 
            "%(_has_extra)s%(extra)s")
 
2028
        "%(_has_extra)s%(extra)s")
1533
2029
 
1534
2030
    def __init__(self, from_path, to_path, extra=None):
1535
2031
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1581
2077
class BadConversionTarget(BzrError):
1582
2078
 
1583
2079
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
1584
 
        "    %(problem)s"
 
2080
            "    %(problem)s"
1585
2081
 
1586
2082
    def __init__(self, problem, format, from_format=None):
1587
2083
        BzrError.__init__(self)
1619
2115
    _fmt = "Diff3 is not installed on this machine."
1620
2116
 
1621
2117
 
 
2118
class ExistingContent(BzrError):
 
2119
    # Added in breezy 0.92, used by VersionedFile.add_lines.
 
2120
 
 
2121
    _fmt = "The content being inserted is already present."
 
2122
 
 
2123
 
1622
2124
class ExistingLimbo(BzrError):
1623
2125
 
1624
2126
    _fmt = """This tree contains left-over files from a failed operation.
1626
2128
    keep, and delete it when you are done."""
1627
2129
 
1628
2130
    def __init__(self, limbo_dir):
1629
 
        BzrError.__init__(self)
1630
 
        self.limbo_dir = limbo_dir
 
2131
       BzrError.__init__(self)
 
2132
       self.limbo_dir = limbo_dir
1631
2133
 
1632
2134
 
1633
2135
class ExistingPendingDeletion(BzrError):
1637
2139
    wish to keep, and delete it when you are done."""
1638
2140
 
1639
2141
    def __init__(self, pending_deletion):
1640
 
        BzrError.__init__(self, pending_deletion=pending_deletion)
 
2142
       BzrError.__init__(self, pending_deletion=pending_deletion)
 
2143
 
 
2144
 
 
2145
class ImmortalLimbo(BzrError):
 
2146
 
 
2147
    _fmt = """Unable to delete transform temporary directory %(limbo_dir)s.
 
2148
    Please examine %(limbo_dir)s to see if it contains any files you wish to
 
2149
    keep, and delete it when you are done."""
 
2150
 
 
2151
    def __init__(self, limbo_dir):
 
2152
       BzrError.__init__(self)
 
2153
       self.limbo_dir = limbo_dir
1641
2154
 
1642
2155
 
1643
2156
class ImmortalPendingDeletion(BzrError):
1644
2157
 
1645
2158
    _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.")
 
2159
    "%(pending_deletion)s.  Please examine %(pending_deletion)s to see if it "
 
2160
    "contains any files you wish to keep, and delete it when you are done.")
1648
2161
 
1649
2162
    def __init__(self, pending_deletion):
1650
 
        BzrError.__init__(self, pending_deletion=pending_deletion)
 
2163
       BzrError.__init__(self, pending_deletion=pending_deletion)
1651
2164
 
1652
2165
 
1653
2166
class OutOfDateTree(BzrError):
1687
2200
    _fmt = "Format error in conflict listings"
1688
2201
 
1689
2202
 
 
2203
class CorruptDirstate(BzrError):
 
2204
 
 
2205
    _fmt = ("Inconsistency in dirstate file %(dirstate_path)s.\n"
 
2206
            "Error: %(description)s")
 
2207
 
 
2208
    def __init__(self, dirstate_path, description):
 
2209
        BzrError.__init__(self)
 
2210
        self.dirstate_path = dirstate_path
 
2211
        self.description = description
 
2212
 
 
2213
 
1690
2214
class CorruptRepository(BzrError):
1691
2215
 
1692
2216
    _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
1739
2263
class RichRootUpgradeRequired(UpgradeRequired):
1740
2264
 
1741
2265
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
1742
 
            " a format which supports rich roots.")
 
2266
           " a format which supports rich roots.")
1743
2267
 
1744
2268
 
1745
2269
class LocalRequiresBoundBranch(BzrError):
1758
2282
        self.tname = type(method_self).__name__
1759
2283
 
1760
2284
 
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)
 
2285
class CannotSetRevisionId(UnsupportedOperation):
 
2286
    """Raised when a commit is attempting to set a revision id but cant."""
1767
2287
 
1768
2288
 
1769
2289
class NonAsciiRevisionId(UnsupportedOperation):
1772
2292
    """
1773
2293
 
1774
2294
 
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
2295
class GhostTagsNotSupported(BzrError):
1783
2296
 
1784
2297
    _fmt = "Ghost tags not supported by format %(format)r."
1866
2379
        self.other = other
1867
2380
 
1868
2381
 
 
2382
class BadInventoryFormat(BzrError):
 
2383
 
 
2384
    _fmt = "Root class for inventory serialization errors"
 
2385
 
 
2386
 
 
2387
class UnexpectedInventoryFormat(BadInventoryFormat):
 
2388
 
 
2389
    _fmt = "The inventory was not in the expected format:\n %(msg)s"
 
2390
 
 
2391
    def __init__(self, msg):
 
2392
        BadInventoryFormat.__init__(self, msg=msg)
 
2393
 
 
2394
 
1869
2395
class RootNotRich(BzrError):
1870
2396
 
1871
2397
    _fmt = """This operation requires rich root data storage"""
1914
2440
        self.revision_id = revision_id
1915
2441
 
1916
2442
 
 
2443
class IllegalUseOfScopeReplacer(InternalBzrError):
 
2444
 
 
2445
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
 
2446
            " %(msg)s%(extra)s")
 
2447
 
 
2448
    def __init__(self, name, msg, extra=None):
 
2449
        BzrError.__init__(self)
 
2450
        self.name = name
 
2451
        self.msg = msg
 
2452
        if extra:
 
2453
            self.extra = ': ' + str(extra)
 
2454
        else:
 
2455
            self.extra = ''
 
2456
 
 
2457
 
 
2458
class InvalidImportLine(InternalBzrError):
 
2459
 
 
2460
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
 
2461
 
 
2462
    def __init__(self, text, msg):
 
2463
        BzrError.__init__(self)
 
2464
        self.text = text
 
2465
        self.msg = msg
 
2466
 
 
2467
 
 
2468
class ImportNameCollision(InternalBzrError):
 
2469
 
 
2470
    _fmt = ("Tried to import an object to the same name as"
 
2471
            " an existing object. %(name)s")
 
2472
 
 
2473
    def __init__(self, name):
 
2474
        BzrError.__init__(self)
 
2475
        self.name = name
 
2476
 
 
2477
 
1917
2478
class NotAMergeDirective(BzrError):
1918
2479
    """File starting with %(firstline)r is not a merge directive"""
1919
 
 
1920
2480
    def __init__(self, firstline):
1921
2481
        BzrError.__init__(self, firstline=firstline)
1922
2482
 
1928
2488
        " branch location."
1929
2489
 
1930
2490
 
 
2491
class IllegalMergeDirectivePayload(BzrError):
 
2492
    """A merge directive contained something other than a patch or bundle"""
 
2493
 
 
2494
    _fmt = "Bad merge directive payload %(start)r"
 
2495
 
 
2496
    def __init__(self, start):
 
2497
        BzrError(self)
 
2498
        self.start = start
 
2499
 
 
2500
 
1931
2501
class PatchVerificationFailed(BzrError):
1932
2502
    """A patch from a merge directive could not be verified"""
1933
2503
 
1957
2527
        self.location = location
1958
2528
 
1959
2529
 
 
2530
class UnsupportedInventoryKind(BzrError):
 
2531
 
 
2532
    _fmt = """Unsupported entry kind %(kind)s"""
 
2533
 
 
2534
    def __init__(self, kind):
 
2535
        self.kind = kind
 
2536
 
 
2537
 
1960
2538
class BadSubsumeSource(BzrError):
1961
2539
 
1962
2540
    _fmt = "Can't subsume %(other_tree)s into %(tree)s. %(reason)s"
1975
2553
        self.other_tree = other_tree
1976
2554
 
1977
2555
 
 
2556
class BadReferenceTarget(InternalBzrError):
 
2557
 
 
2558
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
 
2559
           "%(reason)s"
 
2560
 
 
2561
    def __init__(self, tree, other_tree, reason):
 
2562
        self.tree = tree
 
2563
        self.other_tree = other_tree
 
2564
        self.reason = reason
 
2565
 
 
2566
 
1978
2567
class NoSuchTag(BzrError):
1979
2568
 
1980
2569
    _fmt = "No such tag: %(tag_name)s"
1986
2575
class TagsNotSupported(BzrError):
1987
2576
 
1988
2577
    _fmt = ("Tags not supported by %(branch)s;"
1989
 
            " you may be able to use 'brz upgrade %(branch_url)s'.")
 
2578
            " you may be able to use brz upgrade.")
1990
2579
 
1991
2580
    def __init__(self, branch):
1992
2581
        self.branch = branch
1993
 
        self.branch_url = branch.user_url
1994
2582
 
1995
2583
 
1996
2584
class TagAlreadyExists(BzrError):
2001
2589
        self.tag_name = tag_name
2002
2590
 
2003
2591
 
 
2592
class MalformedBugIdentifier(BzrError):
 
2593
 
 
2594
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
 
2595
            'See "brz help bugs" for more information on this feature.')
 
2596
 
 
2597
    def __init__(self, bug_id, reason):
 
2598
        self.bug_id = bug_id
 
2599
        self.reason = reason
 
2600
 
 
2601
 
 
2602
class InvalidBugTrackerURL(BzrError):
 
2603
 
 
2604
    _fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
 
2605
            "contain {id}: %(url)s")
 
2606
 
 
2607
    def __init__(self, abbreviation, url):
 
2608
        self.abbreviation = abbreviation
 
2609
        self.url = url
 
2610
 
 
2611
 
 
2612
class UnknownBugTrackerAbbreviation(BzrError):
 
2613
 
 
2614
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
 
2615
            "on %(branch)s")
 
2616
 
 
2617
    def __init__(self, abbreviation, branch):
 
2618
        self.abbreviation = abbreviation
 
2619
        self.branch = branch
 
2620
 
 
2621
 
 
2622
class InvalidLineInBugsProperty(BzrError):
 
2623
 
 
2624
    _fmt = ("Invalid line in bugs property: '%(line)s'")
 
2625
 
 
2626
    def __init__(self, line):
 
2627
        self.line = line
 
2628
 
 
2629
 
 
2630
class InvalidBugStatus(BzrError):
 
2631
 
 
2632
    _fmt = ("Invalid bug status: '%(status)s'")
 
2633
 
 
2634
    def __init__(self, status):
 
2635
        self.status = status
 
2636
 
 
2637
 
2004
2638
class UnexpectedSmartServerResponse(BzrError):
2005
2639
 
2006
2640
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2104
2738
        self.name = name.decode("utf-8")
2105
2739
 
2106
2740
 
 
2741
class NoDestinationAddress(InternalBzrError):
 
2742
 
 
2743
    _fmt = "Message does not have a destination address."
 
2744
 
 
2745
 
2107
2746
class RepositoryDataStreamError(BzrError):
2108
2747
 
2109
2748
    _fmt = "Corrupt or incompatible data stream: %(reason)s"
2112
2751
        self.reason = reason
2113
2752
 
2114
2753
 
 
2754
class SMTPError(BzrError):
 
2755
 
 
2756
    _fmt = "SMTP error: %(error)s"
 
2757
 
 
2758
    def __init__(self, error):
 
2759
        self.error = error
 
2760
 
 
2761
 
 
2762
class NoMessageSupplied(BzrError):
 
2763
 
 
2764
    _fmt = "No message supplied."
 
2765
 
 
2766
 
 
2767
class NoMailAddressSpecified(BzrError):
 
2768
 
 
2769
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
 
2770
 
 
2771
 
 
2772
class MailClientNotFound(BzrError):
 
2773
 
 
2774
    _fmt = "Unable to find mail client with the following names:"\
 
2775
        " %(mail_command_list_string)s"
 
2776
 
 
2777
    def __init__(self, mail_command_list):
 
2778
        mail_command_list_string = ', '.join(mail_command_list)
 
2779
        BzrError.__init__(self, mail_command_list=mail_command_list,
 
2780
                          mail_command_list_string=mail_command_list_string)
 
2781
 
 
2782
class SMTPConnectionRefused(SMTPError):
 
2783
 
 
2784
    _fmt = "SMTP connection to %(host)s refused"
 
2785
 
 
2786
    def __init__(self, error, host):
 
2787
        self.error = error
 
2788
        self.host = host
 
2789
 
 
2790
 
 
2791
class DefaultSMTPConnectionRefused(SMTPConnectionRefused):
 
2792
 
 
2793
    _fmt = "Please specify smtp_server.  No server at default %(host)s."
 
2794
 
 
2795
 
 
2796
class BzrDirError(BzrError):
 
2797
 
 
2798
    def __init__(self, bzrdir):
 
2799
        import breezy.urlutils as urlutils
 
2800
        display_url = urlutils.unescape_for_display(bzrdir.user_url,
 
2801
                                                    'ascii')
 
2802
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
 
2803
 
 
2804
 
 
2805
class UnsyncedBranches(BzrDirError):
 
2806
 
 
2807
    _fmt = ("'%(display_url)s' is not in sync with %(target_url)s.  See"
 
2808
            " brz help sync-for-reconfigure.")
 
2809
 
 
2810
    def __init__(self, bzrdir, target_branch):
 
2811
        BzrDirError.__init__(self, bzrdir)
 
2812
        import breezy.urlutils as urlutils
 
2813
        self.target_url = urlutils.unescape_for_display(target_branch.base,
 
2814
                                                        'ascii')
 
2815
 
 
2816
 
 
2817
class AlreadyBranch(BzrDirError):
 
2818
 
 
2819
    _fmt = "'%(display_url)s' is already a branch."
 
2820
 
 
2821
 
 
2822
class AlreadyTree(BzrDirError):
 
2823
 
 
2824
    _fmt = "'%(display_url)s' is already a tree."
 
2825
 
 
2826
 
 
2827
class AlreadyCheckout(BzrDirError):
 
2828
 
 
2829
    _fmt = "'%(display_url)s' is already a checkout."
 
2830
 
 
2831
 
 
2832
class AlreadyLightweightCheckout(BzrDirError):
 
2833
 
 
2834
    _fmt = "'%(display_url)s' is already a lightweight checkout."
 
2835
 
 
2836
 
 
2837
class AlreadyUsingShared(BzrDirError):
 
2838
 
 
2839
    _fmt = "'%(display_url)s' is already using a shared repository."
 
2840
 
 
2841
 
 
2842
class AlreadyStandalone(BzrDirError):
 
2843
 
 
2844
    _fmt = "'%(display_url)s' is already standalone."
 
2845
 
 
2846
 
 
2847
class AlreadyWithTrees(BzrDirError):
 
2848
 
 
2849
    _fmt = ("Shared repository '%(display_url)s' already creates "
 
2850
            "working trees.")
 
2851
 
 
2852
 
 
2853
class AlreadyWithNoTrees(BzrDirError):
 
2854
 
 
2855
    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
 
2856
            "working trees.")
 
2857
 
 
2858
 
 
2859
class ReconfigurationNotSupported(BzrDirError):
 
2860
 
 
2861
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
 
2862
 
 
2863
 
 
2864
class NoBindLocation(BzrDirError):
 
2865
 
 
2866
    _fmt = "No location could be found to bind to at %(display_url)s."
 
2867
 
 
2868
 
2115
2869
class UncommittedChanges(BzrError):
2116
2870
 
2117
2871
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
2152
2906
            ' (See brz shelve --list).%(more)s')
2153
2907
 
2154
2908
 
 
2909
class MissingTemplateVariable(BzrError):
 
2910
 
 
2911
    _fmt = 'Variable {%(name)s} is not available.'
 
2912
 
 
2913
    def __init__(self, name):
 
2914
        self.name = name
 
2915
 
 
2916
 
 
2917
class NoTemplate(BzrError):
 
2918
 
 
2919
    _fmt = 'No template specified.'
 
2920
 
 
2921
 
 
2922
class UnableCreateSymlink(BzrError):
 
2923
 
 
2924
    _fmt = 'Unable to create symlink %(path_str)son this platform'
 
2925
 
 
2926
    def __init__(self, path=None):
 
2927
        path_str = ''
 
2928
        if path:
 
2929
            try:
 
2930
                path_str = repr(str(path))
 
2931
            except UnicodeEncodeError:
 
2932
                path_str = repr(path)
 
2933
            path_str += ' '
 
2934
        self.path_str = path_str
 
2935
 
 
2936
 
 
2937
class UnsupportedTimezoneFormat(BzrError):
 
2938
 
 
2939
    _fmt = ('Unsupported timezone format "%(timezone)s", '
 
2940
            'options are "utc", "original", "local".')
 
2941
 
 
2942
    def __init__(self, timezone):
 
2943
        self.timezone = timezone
 
2944
 
 
2945
 
 
2946
class CommandAvailableInPlugin(Exception):
 
2947
 
 
2948
    internal_error = False
 
2949
 
 
2950
    def __init__(self, cmd_name, plugin_metadata, provider):
 
2951
 
 
2952
        self.plugin_metadata = plugin_metadata
 
2953
        self.cmd_name = cmd_name
 
2954
        self.provider = provider
 
2955
 
 
2956
    def __str__(self):
 
2957
 
 
2958
        _fmt = ('"%s" is not a standard brz command. \n'
 
2959
                'However, the following official plugin provides this command: %s\n'
 
2960
                'You can install it by going to: %s'
 
2961
                % (self.cmd_name, self.plugin_metadata['name'],
 
2962
                    self.plugin_metadata['url']))
 
2963
 
 
2964
        return _fmt
 
2965
 
 
2966
 
 
2967
class NoPluginAvailable(BzrError):
 
2968
    pass
 
2969
 
 
2970
 
2155
2971
class UnableEncodePath(BzrError):
2156
2972
 
2157
2973
    _fmt = ('Unable to encode %(kind)s path %(path)r in '
2164
2980
        self.user_encoding = get_user_encoding()
2165
2981
 
2166
2982
 
 
2983
class NoSuchConfig(BzrError):
 
2984
 
 
2985
    _fmt = ('The "%(config_id)s" configuration does not exist.')
 
2986
 
 
2987
    def __init__(self, config_id):
 
2988
        BzrError.__init__(self, config_id=config_id)
 
2989
 
 
2990
 
 
2991
class NoSuchConfigOption(BzrError):
 
2992
 
 
2993
    _fmt = ('The "%(option_name)s" configuration option does not exist.')
 
2994
 
 
2995
    def __init__(self, option_name):
 
2996
        BzrError.__init__(self, option_name=option_name)
 
2997
 
 
2998
 
2167
2999
class NoSuchAlias(BzrError):
2168
3000
 
2169
3001
    _fmt = ('The alias "%(alias_name)s" does not exist.')
2172
3004
        BzrError.__init__(self, alias_name=alias_name)
2173
3005
 
2174
3006
 
 
3007
class DirectoryLookupFailure(BzrError):
 
3008
    """Base type for lookup errors."""
 
3009
 
 
3010
    pass
 
3011
 
 
3012
 
 
3013
class InvalidLocationAlias(DirectoryLookupFailure):
 
3014
 
 
3015
    _fmt = '"%(alias_name)s" is not a valid location alias.'
 
3016
 
 
3017
    def __init__(self, alias_name):
 
3018
        DirectoryLookupFailure.__init__(self, alias_name=alias_name)
 
3019
 
 
3020
 
 
3021
class UnsetLocationAlias(DirectoryLookupFailure):
 
3022
 
 
3023
    _fmt = 'No %(alias_name)s location assigned.'
 
3024
 
 
3025
    def __init__(self, alias_name):
 
3026
        DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
 
3027
 
 
3028
 
2175
3029
class CannotBindAddress(BzrError):
2176
3030
 
2177
3031
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
2179
3033
    def __init__(self, host, port, orig_error):
2180
3034
        # nb: in python2.4 socket.error doesn't have a useful repr
2181
3035
        BzrError.__init__(self, host=host, port=port,
2182
 
                          orig_error=repr(orig_error.args))
 
3036
            orig_error=repr(orig_error.args))
 
3037
 
 
3038
 
 
3039
class UnknownRules(BzrError):
 
3040
 
 
3041
    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
 
3042
 
 
3043
    def __init__(self, unknowns):
 
3044
        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
2183
3045
 
2184
3046
 
2185
3047
class TipChangeRejected(BzrError):
2193
3055
        self.msg = msg
2194
3056
 
2195
3057
 
 
3058
class ShelfCorrupt(BzrError):
 
3059
 
 
3060
    _fmt = "Shelf corrupt."
 
3061
 
 
3062
 
 
3063
class DecompressCorruption(BzrError):
 
3064
 
 
3065
    _fmt = "Corruption while decompressing repository file%(orig_error)s"
 
3066
 
 
3067
    def __init__(self, orig_error=None):
 
3068
        if orig_error is not None:
 
3069
            self.orig_error = ", %s" % (orig_error,)
 
3070
        else:
 
3071
            self.orig_error = ""
 
3072
        BzrError.__init__(self)
 
3073
 
 
3074
 
 
3075
class NoSuchShelfId(BzrError):
 
3076
 
 
3077
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
 
3078
 
 
3079
    def __init__(self, shelf_id):
 
3080
        BzrError.__init__(self, shelf_id=shelf_id)
 
3081
 
 
3082
 
 
3083
class InvalidShelfId(BzrError):
 
3084
 
 
3085
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
 
3086
 
 
3087
    def __init__(self, invalid_id):
 
3088
        BzrError.__init__(self, invalid_id=invalid_id)
 
3089
 
 
3090
 
2196
3091
class JailBreak(BzrError):
2197
3092
 
2198
3093
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
2206
3101
    _fmt = 'The user aborted the operation.'
2207
3102
 
2208
3103
 
 
3104
class MustHaveWorkingTree(BzrError):
 
3105
 
 
3106
    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
 
3107
 
 
3108
    def __init__(self, format, url):
 
3109
        BzrError.__init__(self, format=format, url=url)
 
3110
 
 
3111
 
 
3112
class NoSuchView(BzrError):
 
3113
    """A view does not exist.
 
3114
    """
 
3115
 
 
3116
    _fmt = u"No such view: %(view_name)s."
 
3117
 
 
3118
    def __init__(self, view_name):
 
3119
        self.view_name = view_name
 
3120
 
 
3121
 
 
3122
class ViewsNotSupported(BzrError):
 
3123
    """Views are not supported by a tree format.
 
3124
    """
 
3125
 
 
3126
    _fmt = ("Views are not supported by %(tree)s;"
 
3127
            " use 'brz upgrade' to change your tree to a later format.")
 
3128
 
 
3129
    def __init__(self, tree):
 
3130
        self.tree = tree
 
3131
 
 
3132
 
 
3133
class FileOutsideView(BzrError):
 
3134
 
 
3135
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
 
3136
            '%(view_str)s')
 
3137
 
 
3138
    def __init__(self, file_name, view_files):
 
3139
        self.file_name = file_name
 
3140
        self.view_str = ", ".join(view_files)
 
3141
 
 
3142
 
2209
3143
class UnresumableWriteGroup(BzrError):
2210
3144
 
2211
3145
    _fmt = ("Repository %(repository)s cannot resume write group "
2253
3187
        self.target_branch = target_branch
2254
3188
 
2255
3189
 
 
3190
class FileTimestampUnavailable(BzrError):
 
3191
 
 
3192
    _fmt = "The filestamp for %(path)s is not available."
 
3193
 
 
3194
    internal_error = True
 
3195
 
 
3196
    def __init__(self, path):
 
3197
        self.path = path
 
3198
 
 
3199
 
2256
3200
class NoColocatedBranchSupport(BzrError):
2257
3201
 
2258
 
    _fmt = ("%(controldir)r does not support co-located branches.")
2259
 
 
2260
 
    def __init__(self, controldir):
2261
 
        self.controldir = controldir
 
3202
    _fmt = ("%(bzrdir)r does not support co-located branches.")
 
3203
 
 
3204
    def __init__(self, bzrdir):
 
3205
        self.bzrdir = bzrdir
 
3206
 
 
3207
 
 
3208
class NoWhoami(BzrError):
 
3209
 
 
3210
    _fmt = ('Unable to determine your name.\n'
 
3211
        "Please, set your name with the 'whoami' command.\n"
 
3212
        'E.g. brz whoami "Your Name <name@example.com>"')
 
3213
 
 
3214
 
 
3215
class InvalidPattern(BzrError):
 
3216
 
 
3217
    _fmt = ('Invalid pattern(s) found. %(msg)s')
 
3218
 
 
3219
    def __init__(self, msg):
 
3220
        self.msg = msg
2262
3221
 
2263
3222
 
2264
3223
class RecursiveBind(BzrError):
2265
3224
 
2266
3225
    _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
2267
 
            'Please use `brz unbind` to fix.')
 
3226
        'Please use `brz unbind` to fix.')
2268
3227
 
2269
3228
    def __init__(self, branch_url):
2270
3229
        self.branch_url = branch_url
2271
3230
 
2272
3231
 
 
3232
# FIXME: I would prefer to define the config related exception classes in
 
3233
# config.py but the lazy import mechanism proscribes this -- vila 20101222
 
3234
class OptionExpansionLoop(BzrError):
 
3235
 
 
3236
    _fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
 
3237
 
 
3238
    def __init__(self, string, refs):
 
3239
        self.string = string
 
3240
        self.refs = '->'.join(refs)
 
3241
 
 
3242
 
 
3243
class ExpandingUnknownOption(BzrError):
 
3244
 
 
3245
    _fmt = 'Option "%(name)s" is not defined while expanding "%(string)s".'
 
3246
 
 
3247
    def __init__(self, name, string):
 
3248
        self.name = name
 
3249
        self.string = string
 
3250
 
 
3251
 
 
3252
class IllegalOptionName(BzrError):
 
3253
 
 
3254
    _fmt = 'Option "%(name)s" is not allowed.'
 
3255
 
 
3256
    def __init__(self, name):
 
3257
        self.name = name
 
3258
 
 
3259
 
 
3260
class NoCompatibleInter(BzrError):
 
3261
 
 
3262
    _fmt = ('No compatible object available for operations from %(source)r '
 
3263
            'to %(target)r.')
 
3264
 
 
3265
    def __init__(self, source, target):
 
3266
        self.source = source
 
3267
        self.target = target
 
3268
 
 
3269
 
 
3270
class HpssVfsRequestNotAllowed(BzrError):
 
3271
 
 
3272
    _fmt = ("VFS requests over the smart server are not allowed. Encountered: "
 
3273
            "%(method)s, %(arguments)s.")
 
3274
 
 
3275
    def __init__(self, method, arguments):
 
3276
        self.method = method
 
3277
        self.arguments = arguments
 
3278
 
 
3279
 
2273
3280
class UnsupportedKindChange(BzrError):
2274
3281
 
2275
3282
    _fmt = ("Kind change from %(from_kind)s to %(to_kind)s for "
2282
3289
        self.format = format
2283
3290
 
2284
3291
 
2285
 
class ChangesAlreadyStored(CommandError):
 
3292
class MissingFeature(BzrError):
 
3293
 
 
3294
    _fmt = ("Missing feature %(feature)s not provided by this "
 
3295
            "version of Bazaar or any plugin.")
 
3296
 
 
3297
    def __init__(self, feature):
 
3298
        self.feature = feature
 
3299
 
 
3300
 
 
3301
class PatchSyntax(BzrError):
 
3302
    """Base class for patch syntax errors."""
 
3303
 
 
3304
 
 
3305
class BinaryFiles(BzrError):
 
3306
 
 
3307
    _fmt = 'Binary files section encountered.'
 
3308
 
 
3309
    def __init__(self, orig_name, mod_name):
 
3310
        self.orig_name = orig_name
 
3311
        self.mod_name = mod_name
 
3312
 
 
3313
 
 
3314
class MalformedPatchHeader(PatchSyntax):
 
3315
 
 
3316
    _fmt = "Malformed patch header.  %(desc)s\n%(line)r"
 
3317
 
 
3318
    def __init__(self, desc, line):
 
3319
        self.desc = desc
 
3320
        self.line = line
 
3321
 
 
3322
 
 
3323
class MalformedHunkHeader(PatchSyntax):
 
3324
 
 
3325
    _fmt = "Malformed hunk header.  %(desc)s\n%(line)r"
 
3326
 
 
3327
    def __init__(self, desc, line):
 
3328
        self.desc = desc
 
3329
        self.line = line
 
3330
 
 
3331
 
 
3332
class MalformedLine(PatchSyntax):
 
3333
 
 
3334
    _fmt = "Malformed line.  %(desc)s\n%(line)r"
 
3335
 
 
3336
    def __init__(self, desc, line):
 
3337
        self.desc = desc
 
3338
        self.line = line
 
3339
 
 
3340
 
 
3341
class PatchConflict(BzrError):
 
3342
 
 
3343
    _fmt = ('Text contents mismatch at line %(line_no)d.  Original has '
 
3344
            '"%(orig_line)s", but patch says it should be "%(patch_line)s"')
 
3345
 
 
3346
    def __init__(self, line_no, orig_line, patch_line):
 
3347
        self.line_no = line_no
 
3348
        self.orig_line = orig_line.rstrip('\n')
 
3349
        self.patch_line = patch_line.rstrip('\n')
 
3350
 
 
3351
 
 
3352
class FeatureAlreadyRegistered(BzrError):
 
3353
 
 
3354
    _fmt = 'The feature %(feature)s has already been registered.'
 
3355
 
 
3356
    def __init__(self, feature):
 
3357
        self.feature = feature
 
3358
 
 
3359
 
 
3360
class ChangesAlreadyStored(BzrCommandError):
2286
3361
 
2287
3362
    _fmt = ('Cannot store uncommitted changes because this branch already'
2288
3363
            ' 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])