← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-11-04 18:51:39 UTC
  • mfrom: (2961.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20071104185139-kaio3sneodg2kp71
Authentication ring implementation (read-only)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
93
93
            for key, value in kwds.items():
94
94
                setattr(self, key, value)
95
95
 
96
 
    def _format(self):
 
96
    def __str__(self):
97
97
        s = getattr(self, '_preformatted_string', None)
98
98
        if s is not None:
99
 
            # contains a preformatted message
100
 
            return s
 
99
            # contains a preformatted message; must be cast to plain str
 
100
            return str(s)
101
101
        try:
102
102
            fmt = self._get_format_string()
103
103
            if fmt:
108
108
                s = fmt % d
109
109
                # __str__() should always return a 'str' object
110
110
                # never a 'unicode' object.
 
111
                if isinstance(s, unicode):
 
112
                    return s.encode('utf8')
111
113
                return s
112
114
        except (AttributeError, TypeError, NameError, ValueError, KeyError), e:
113
115
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
116
118
                   getattr(self, '_fmt', None),
117
119
                   e)
118
120
 
119
 
    def __unicode__(self):
120
 
        u = self._format()
121
 
        if isinstance(u, str):
122
 
            # Try decoding the str using the default encoding.
123
 
            u = unicode(u)
124
 
        elif not isinstance(u, unicode):
125
 
            # Try to make a unicode object from it, because __unicode__ must
126
 
            # return a unicode object.
127
 
            u = unicode(u)
128
 
        return u
129
 
    
130
 
    def __str__(self):
131
 
        s = self._format()
132
 
        if isinstance(s, unicode):
133
 
            s = s.encode('utf8')
134
 
        else:
135
 
            # __str__ must return a str.
136
 
            s = str(s)
137
 
        return s
138
 
 
139
121
    def _get_format_string(self):
140
122
        """Return format string for this exception or None"""
141
123
        fmt = getattr(self, '_fmt', None)
153
135
               getattr(self, '_fmt', None),
154
136
               )
155
137
 
156
 
    def __eq__(self, other):
157
 
        if self.__class__ != other.__class__:
158
 
            return NotImplemented
159
 
        return self.__dict__ == other.__dict__
160
 
 
161
138
 
162
139
class InternalBzrError(BzrError):
163
140
    """Base class for errors that are internal in nature.
208
185
    _fmt = "The tree builder is already building a tree."
209
186
 
210
187
 
211
 
class BranchError(BzrError):
212
 
    """Base class for concrete 'errors about a branch'."""
213
 
 
214
 
    def __init__(self, branch):
215
 
        BzrError.__init__(self, branch=branch)
216
 
 
217
 
 
218
188
class BzrCheckError(InternalBzrError):
219
189
    
220
190
    _fmt = "Internal check failed: %(message)s"
224
194
        self.message = message
225
195
 
226
196
 
227
 
class DirstateCorrupt(BzrError):
228
 
 
229
 
    _fmt = "The dirstate file (%(state)s) appears to be corrupt: %(msg)s"
230
 
 
231
 
    def __init__(self, state, msg):
232
 
        BzrError.__init__(self)
233
 
        self.state = state
234
 
        self.msg = msg
235
 
 
236
 
 
237
197
class DisabledMethod(InternalBzrError):
238
198
 
239
199
    _fmt = "The smart server method '%(class_name)s' is disabled."
292
252
        self.revision_id = revision_id
293
253
        self.branch = branch
294
254
 
295
 
 
296
255
class ReservedId(BzrError):
297
256
 
298
257
    _fmt = "Reserved revision-id {%(revision_id)s}"
307
266
        "record_entry_contents.")
308
267
 
309
268
 
310
 
class NoPublicBranch(BzrError):
311
 
 
312
 
    _fmt = 'There is no public branch set for "%(branch_url)s".'
313
 
 
314
 
    def __init__(self, branch):
315
 
        import bzrlib.urlutils as urlutils
316
 
        public_location = urlutils.unescape_for_display(branch.base, 'ascii')
317
 
        BzrError.__init__(self, branch_url=public_location)
318
 
 
319
 
 
320
269
class NoHelpTopic(BzrError):
321
270
 
322
271
    _fmt = ("No help could be found for '%(topic)s'. "
345
294
        BzrError.__init__(self, repository=repository, file_id=file_id)
346
295
 
347
296
 
348
 
class NotStacked(BranchError):
349
 
 
350
 
    _fmt = "The branch '%(branch)s' is not stacked."
351
 
 
352
 
 
353
297
class InventoryModified(InternalBzrError):
354
298
 
355
299
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
399
343
    # are not intended to be caught anyway.  UI code need not subclass
400
344
    # BzrCommandError, and non-UI code should not throw a subclass of
401
345
    # BzrCommandError.  ADHB 20051211
 
346
    def __init__(self, msg):
 
347
        # Object.__str__() must return a real string
 
348
        # returning a Unicode string is a python error.
 
349
        if isinstance(msg, unicode):
 
350
            self.msg = msg.encode('utf8')
 
351
        else:
 
352
            self.msg = msg
 
353
 
 
354
    def __str__(self):
 
355
        return self.msg
402
356
 
403
357
 
404
358
class NotWriteLocked(BzrError):
516
470
    """Used when renaming and both source and dest exist."""
517
471
 
518
472
    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
519
 
            " (Use --after to tell bzr about a rename that has already"
520
 
            " happened)%(extra)s")
 
473
            "%(extra)s")
521
474
 
522
475
    def __init__(self, source, dest, extra=None):
523
476
        BzrError.__init__(self)
544
497
    _fmt = 'Directory not empty: "%(path)s"%(extra)s'
545
498
 
546
499
 
547
 
class HardLinkNotSupported(PathError):
548
 
 
549
 
    _fmt = 'Hard-linking "%(path)s" is not supported'
550
 
 
551
 
 
552
500
class ReadingCompleted(InternalBzrError):
553
501
    
554
502
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
576
524
 
577
525
class InvalidURLJoin(PathError):
578
526
 
579
 
    _fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"
580
 
 
581
 
    def __init__(self, reason, base, join_args):
582
 
        self.reason = reason
583
 
        self.base = base
584
 
        self.join_args = join_args
585
 
        PathError.__init__(self, base, reason)
586
 
 
587
 
 
588
 
class InvalidRebaseURLs(PathError):
589
 
 
590
 
    _fmt = "URLs differ by more than path: %(from_)r and %(to)r"
591
 
 
592
 
    def __init__(self, from_, to):
593
 
        self.from_ = from_
594
 
        self.to = to
595
 
        PathError.__init__(self, from_, 'URLs differ by more than path.')
596
 
 
597
 
 
598
 
class UnavailableRepresentation(InternalBzrError):
599
 
 
600
 
    _fmt = ("The encoding '%(wanted)s' is not available for key %(key)s which "
601
 
        "is encoded as '%(native)s'.")
602
 
 
603
 
    def __init__(self, key, wanted, native):
604
 
        InternalBzrError.__init__(self)
605
 
        self.wanted = wanted
606
 
        self.native = native
607
 
        self.key = key
 
527
    _fmt = 'Invalid URL join request: "%(args)s"%(extra)s'
 
528
 
 
529
    def __init__(self, msg, base, args):
 
530
        PathError.__init__(self, base, msg)
 
531
        self.args = [base] + list(args)
608
532
 
609
533
 
610
534
class UnknownHook(BzrError):
625
549
        PathError.__init__(self, url, extra=extra)
626
550
 
627
551
 
628
 
class UnstackableBranchFormat(BzrError):
629
 
 
630
 
    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
631
 
        "You will need to upgrade the branch to permit branch stacking.")
632
 
 
633
 
    def __init__(self, format, url):
634
 
        BzrError.__init__(self)
635
 
        self.format = format
636
 
        self.url = url
637
 
 
638
 
 
639
 
class UnstackableRepositoryFormat(BzrError):
640
 
 
641
 
    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
642
 
        "You will need to upgrade the repository to permit branch stacking.")
643
 
 
644
 
    def __init__(self, format, url):
645
 
        BzrError.__init__(self)
646
 
        self.format = format
647
 
        self.url = url
648
 
 
649
 
 
650
552
class ReadError(PathError):
651
553
    
652
554
    _fmt = """Error reading from %(path)r."""
749
651
 
750
652
class FileInWrongBranch(BzrError):
751
653
 
752
 
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
 
654
    _fmt = 'File "%(path)s" in not in branch %(branch_base)s.'
753
655
 
754
656
    def __init__(self, branch, path):
755
657
        BzrError.__init__(self)
765
667
 
766
668
class UnknownFormatError(BzrError):
767
669
    
768
 
    _fmt = "Unknown %(kind)s format: %(format)r"
769
 
 
770
 
    def __init__(self, format, kind='branch'):
771
 
        self.kind = kind
772
 
        self.format = format
 
670
    _fmt = "Unknown branch format: %(format)r"
773
671
 
774
672
 
775
673
class IncompatibleFormat(BzrError):
784
682
 
785
683
class IncompatibleRepositories(BzrError):
786
684
 
787
 
    _fmt = "%(target)s\n" \
788
 
            "is not compatible with\n" \
789
 
            "%(source)s\n" \
790
 
            "%(details)s"
 
685
    _fmt = "Repository %(target)s is not compatible with repository"\
 
686
        " %(source)s"
791
687
 
792
 
    def __init__(self, source, target, details=None):
793
 
        if details is None:
794
 
            details = "(no details)"
795
 
        BzrError.__init__(self, target=target, source=source, details=details)
 
688
    def __init__(self, source, target):
 
689
        BzrError.__init__(self, target=target, source=source)
796
690
 
797
691
 
798
692
class IncompatibleRevision(BzrError):
885
779
        BzrError.__init__(self, filename=filename, kind=kind)
886
780
 
887
781
 
888
 
class BadFilenameEncoding(BzrError):
889
 
 
890
 
    _fmt = ('Filename %(filename)r is not valid in your current filesystem'
891
 
            ' encoding %(fs_encoding)s')
892
 
 
893
 
    def __init__(self, filename, fs_encoding):
894
 
        BzrError.__init__(self)
895
 
        self.filename = filename
896
 
        self.fs_encoding = fs_encoding
897
 
 
898
 
 
899
782
class ForbiddenControlFileError(BzrError):
900
783
 
901
784
    _fmt = 'Cannot operate on "%(filename)s" because it is a control file'
954
837
        self.obj = obj
955
838
 
956
839
 
 
840
class ReadOnlyLockError(LockError):
 
841
 
 
842
    _fmt = "Cannot acquire write lock on %(fname)s. %(msg)s"
 
843
 
 
844
    @symbol_versioning.deprecated_method(symbol_versioning.zero_ninetytwo)
 
845
    def __init__(self, fname, msg):
 
846
        LockError.__init__(self, '')
 
847
        self.fname = fname
 
848
        self.msg = msg
 
849
 
 
850
 
957
851
class LockFailed(LockError):
958
852
 
959
853
    internal_error = False
1115
1009
        BzrError.__init__(self, branch=branch, revision=revision)
1116
1010
 
1117
1011
 
 
1012
# zero_ninetyone: this exception is no longer raised and should be removed
 
1013
class NotLeftParentDescendant(InternalBzrError):
 
1014
 
 
1015
    _fmt = ("Revision %(old_revision)s is not the left parent of"
 
1016
            " %(new_revision)s, but branch %(branch_location)s expects this")
 
1017
 
 
1018
    def __init__(self, branch, old_revision, new_revision):
 
1019
        BzrError.__init__(self, branch_location=branch.base,
 
1020
                          old_revision=old_revision,
 
1021
                          new_revision=new_revision)
 
1022
 
 
1023
 
1118
1024
class RangeInChangeOption(BzrError):
1119
1025
 
1120
1026
    _fmt = "Option --change does not accept revision ranges"
1193
1099
            " no merge base revision was specified.")
1194
1100
 
1195
1101
 
1196
 
class CannotReverseCherrypick(BzrError):
1197
 
 
1198
 
    _fmt = ('Selected merge cannot perform reverse cherrypicks.  Try merge3'
1199
 
            ' or diff3.')
1200
 
 
1201
 
 
1202
1102
class NoCommonAncestor(BzrError):
1203
1103
    
1204
1104
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1246
1146
        self.bases = bases
1247
1147
 
1248
1148
 
1249
 
class NoCommits(BranchError):
 
1149
class NoCommits(BzrError):
1250
1150
 
1251
1151
    _fmt = "Branch %(branch)s has no commits."
1252
1152
 
 
1153
    def __init__(self, branch):
 
1154
        BzrError.__init__(self, branch=branch)
 
1155
 
1253
1156
 
1254
1157
class UnlistableStore(BzrError):
1255
1158
 
1427
1330
 
1428
1331
 
1429
1332
class KnitDataStreamIncompatible(KnitError):
1430
 
    # Not raised anymore, as we can convert data streams.  In future we may
1431
 
    # need it again for more exotic cases, so we're keeping it around for now.
1432
1333
 
1433
1334
    _fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."
1434
1335
 
1437
1338
        self.target_format = target_format
1438
1339
        
1439
1340
 
1440
 
class KnitDataStreamUnknown(KnitError):
1441
 
    # Indicates a data stream we don't know how to handle.
1442
 
 
1443
 
    _fmt = "Cannot parse knit data stream of format \"%(stream_format)s\"."
1444
 
 
1445
 
    def __init__(self, stream_format):
1446
 
        self.stream_format = stream_format
1447
 
        
1448
 
 
1449
1341
class KnitHeaderError(KnitError):
1450
1342
 
1451
1343
    _fmt = 'Knit header error: %(badline)r unexpected for file "%(filename)s".'
1513
1405
        self.details = details
1514
1406
 
1515
1407
 
1516
 
class UnexpectedProtocolVersionMarker(TransportError):
1517
 
 
1518
 
    _fmt = "Received bad protocol version marker: %(marker)r"
1519
 
 
1520
 
    def __init__(self, marker):
1521
 
        self.marker = marker
1522
 
 
1523
 
 
1524
 
class UnknownSmartMethod(InternalBzrError):
1525
 
 
1526
 
    _fmt = "The server does not recognise the '%(verb)s' request."
1527
 
 
1528
 
    def __init__(self, verb):
1529
 
        self.verb = verb
1530
 
 
1531
 
 
1532
 
class SmartMessageHandlerError(InternalBzrError):
1533
 
 
1534
 
    _fmt = "The message handler raised an exception: %(exc_value)s."
1535
 
 
1536
 
    def __init__(self, exc_info):
1537
 
        self.exc_type, self.exc_value, self.tb = exc_info
1538
 
        
1539
 
 
1540
1408
# A set of semi-meaningful errors which can be thrown
1541
1409
class TransportNotPossible(TransportError):
1542
1410
 
1574
1442
 
1575
1443
class InvalidRange(TransportError):
1576
1444
 
1577
 
    _fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
1578
 
 
1579
 
    def __init__(self, path, offset, msg=None):
1580
 
        TransportError.__init__(self, msg)
 
1445
    _fmt = "Invalid range access in %(path)s at %(offset)s."
 
1446
    
 
1447
    def __init__(self, path, offset):
 
1448
        TransportError.__init__(self, ("Invalid range access in %s at %d"
 
1449
                                       % (path, offset)))
1581
1450
        self.path = path
1582
1451
        self.offset = offset
1583
1452
 
1594
1463
class InvalidHttpRange(InvalidHttpResponse):
1595
1464
 
1596
1465
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1597
 
 
 
1466
    
1598
1467
    def __init__(self, path, range, msg):
1599
1468
        self.range = range
1600
1469
        InvalidHttpResponse.__init__(self, path, msg)
1603
1472
class InvalidHttpContentType(InvalidHttpResponse):
1604
1473
 
1605
1474
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1606
 
 
 
1475
    
1607
1476
    def __init__(self, path, ctype, msg):
1608
1477
        self.ctype = ctype
1609
1478
        InvalidHttpResponse.__init__(self, path, msg)
1975
1844
        self.format = format
1976
1845
 
1977
1846
 
1978
 
class NoDiffFound(BzrError):
1979
 
 
1980
 
    _fmt = 'Could not find an appropriate Differ for file "%(path)s"'
1981
 
 
1982
 
    def __init__(self, path):
1983
 
        BzrError.__init__(self, path)
1984
 
 
1985
 
 
1986
 
class ExecutableMissing(BzrError):
1987
 
 
1988
 
    _fmt = "%(exe_name)s could not be found on this machine"
1989
 
 
1990
 
    def __init__(self, exe_name):
1991
 
        BzrError.__init__(self, exe_name=exe_name)
1992
 
 
1993
 
 
1994
1847
class NoDiff(BzrError):
1995
1848
 
1996
1849
    _fmt = "Diff is not installed on this machine: %(msg)s"
2044
1897
 
2045
1898
class ImmortalPendingDeletion(BzrError):
2046
1899
 
2047
 
    _fmt = ("Unable to delete transform temporary directory "
2048
 
    "%(pending_deletion)s.  Please examine %(pending_deletion)s to see if it "
2049
 
    "contains any files you wish to keep, and delete it when you are done.")
 
1900
    _fmt = """Unable to delete transform temporary directory
 
1901
    %(pending_deletion)s.  Please examine %(pending_deletions)s to see if it
 
1902
    contains any files you wish to keep, and delete it when you are done."""
2050
1903
 
2051
1904
    def __init__(self, pending_deletion):
2052
1905
       BzrError.__init__(self, pending_deletion=pending_deletion)
2084
1937
    _fmt = "Format error in conflict listings"
2085
1938
 
2086
1939
 
2087
 
class CorruptDirstate(BzrError):
2088
 
 
2089
 
    _fmt = ("Inconsistency in dirstate file %(dirstate_path)s.\n"
2090
 
            "Error: %(description)s")
2091
 
 
2092
 
    def __init__(self, dirstate_path, description):
2093
 
        BzrError.__init__(self)
2094
 
        self.dirstate_path = dirstate_path
2095
 
        self.description = description
2096
 
 
2097
 
 
2098
1940
class CorruptRepository(BzrError):
2099
1941
 
2100
1942
    _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
2105
1947
        self.repo_path = repo.bzrdir.root_transport.base
2106
1948
 
2107
1949
 
2108
 
class InconsistentDelta(BzrError):
2109
 
    """Used when we get a delta that is not valid."""
2110
 
 
2111
 
    _fmt = ("An inconsistent delta was supplied involving %(path)r,"
2112
 
            " %(file_id)r\nreason: %(reason)s")
2113
 
 
2114
 
    def __init__(self, path, file_id, reason):
2115
 
        BzrError.__init__(self)
2116
 
        self.path = path
2117
 
        self.file_id = file_id
2118
 
        self.reason = reason
2119
 
 
2120
 
 
2121
1950
class UpgradeRequired(BzrError):
2122
1951
 
2123
1952
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
2127
1956
        self.path = path
2128
1957
 
2129
1958
 
2130
 
class RepositoryUpgradeRequired(UpgradeRequired):
2131
 
 
2132
 
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
2133
 
 
2134
 
 
2135
1959
class LocalRequiresBoundBranch(BzrError):
2136
1960
 
2137
1961
    _fmt = "Cannot perform local-only commits on unbound branches."
2281
2105
 
2282
2106
    _fmt = "No smart server available at %(url)s"
2283
2107
 
2284
 
    @symbol_versioning.deprecated_method(symbol_versioning.one_four)
2285
2108
    def __init__(self, url):
2286
2109
        self.url = url
2287
2110
 
2301
2124
            " Please set BZR_SSH environment variable.")
2302
2125
 
2303
2126
 
2304
 
class GhostRevisionsHaveNoRevno(BzrError):
2305
 
    """When searching for revnos, if we encounter a ghost, we are stuck"""
2306
 
 
2307
 
    _fmt = ("Could not determine revno for {%(revision_id)s} because"
2308
 
            " its ancestry shows a ghost at {%(ghost_revision_id)s}")
2309
 
 
2310
 
    def __init__(self, revision_id, ghost_revision_id):
2311
 
        self.revision_id = revision_id
2312
 
        self.ghost_revision_id = ghost_revision_id
2313
 
 
2314
 
        
2315
2127
class GhostRevisionUnusableHere(BzrError):
2316
2128
 
2317
2129
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2395
2207
        self.patch_type = patch_type
2396
2208
 
2397
2209
 
2398
 
class TargetNotBranch(BzrError):
2399
 
    """A merge directive's target branch is required, but isn't a branch"""
2400
 
 
2401
 
    _fmt = ("Your branch does not have all of the revisions required in "
2402
 
            "order to merge this merge directive and the target "
2403
 
            "location specified in the merge directive is not a branch: "
2404
 
            "%(location)s.")
2405
 
 
2406
 
    def __init__(self, location):
2407
 
        BzrError.__init__(self)
2408
 
        self.location = location
2409
 
 
2410
 
 
2411
2210
class UnsupportedInventoryKind(BzrError):
2412
2211
    
2413
2212
    _fmt = """Unsupported entry kind %(kind)s"""
2456
2255
class TagsNotSupported(BzrError):
2457
2256
 
2458
2257
    _fmt = ("Tags not supported by %(branch)s;"
2459
 
            " you may be able to use bzr upgrade.")
 
2258
            " you may be able to use bzr upgrade --dirstate-tags.")
2460
2259
 
2461
2260
    def __init__(self, branch):
2462
2261
        self.branch = branch
2479
2278
        self.reason = reason
2480
2279
 
2481
2280
 
2482
 
class InvalidBugTrackerURL(BzrError):
2483
 
 
2484
 
    _fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
2485
 
            "contain {id}: %(url)s")
2486
 
 
2487
 
    def __init__(self, abbreviation, url):
2488
 
        self.abbreviation = abbreviation
2489
 
        self.url = url
2490
 
 
2491
 
 
2492
2281
class UnknownBugTrackerAbbreviation(BzrError):
2493
2282
 
2494
2283
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
2507
2296
        self.response_tuple = response_tuple
2508
2297
 
2509
2298
 
2510
 
class ErrorFromSmartServer(BzrError):
2511
 
 
2512
 
    _fmt = "Error received from smart server: %(error_tuple)r"
2513
 
 
2514
 
    internal_error = True
2515
 
 
2516
 
    def __init__(self, error_tuple):
2517
 
        self.error_tuple = error_tuple
2518
 
        try:
2519
 
            self.error_verb = error_tuple[0]
2520
 
        except IndexError:
2521
 
            self.error_verb = None
2522
 
        self.error_args = error_tuple[1:]
2523
 
 
2524
 
 
2525
2299
class ContainerError(BzrError):
2526
2300
    """Base class of container errors."""
2527
2301
 
2597
2371
    _fmt = "No message supplied."
2598
2372
 
2599
2373
 
2600
 
class NoMailAddressSpecified(BzrError):
2601
 
 
2602
 
    _fmt = "No mail-to address specified."
2603
 
 
2604
 
 
2605
2374
class UnknownMailClient(BzrError):
2606
2375
 
2607
2376
    _fmt = "Unknown mail client: %(mail_client)s"
2643
2412
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
2644
2413
 
2645
2414
 
2646
 
class UnsyncedBranches(BzrDirError):
2647
 
 
2648
 
    _fmt = ("'%(display_url)s' is not in sync with %(target_url)s.  See"
2649
 
            " bzr help sync-for-reconfigure.")
2650
 
 
2651
 
    def __init__(self, bzrdir, target_branch):
2652
 
        BzrDirError.__init__(self, bzrdir)
2653
 
        import bzrlib.urlutils as urlutils
2654
 
        self.target_url = urlutils.unescape_for_display(target_branch.base,
2655
 
                                                        'ascii')
2656
 
 
2657
 
 
2658
2415
class AlreadyBranch(BzrDirError):
2659
2416
 
2660
2417
    _fmt = "'%(display_url)s' is already a branch."
2670
2427
    _fmt = "'%(display_url)s' is already a checkout."
2671
2428
 
2672
2429
 
2673
 
class AlreadyLightweightCheckout(BzrDirError):
2674
 
 
2675
 
    _fmt = "'%(display_url)s' is already a lightweight checkout."
2676
 
 
2677
 
 
2678
 
class AlreadyUsingShared(BzrDirError):
2679
 
 
2680
 
    _fmt = "'%(display_url)s' is already using a shared repository."
2681
 
 
2682
 
 
2683
 
class AlreadyStandalone(BzrDirError):
2684
 
 
2685
 
    _fmt = "'%(display_url)s' is already standalone."
2686
 
 
2687
 
 
2688
2430
class ReconfigurationNotSupported(BzrDirError):
2689
2431
 
2690
2432
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
2704
2446
        display_url = urlutils.unescape_for_display(
2705
2447
            tree.bzrdir.root_transport.base, 'ascii')
2706
2448
        BzrError.__init__(self, tree=tree, display_url=display_url)
2707
 
 
2708
 
 
2709
 
class MissingTemplateVariable(BzrError):
2710
 
 
2711
 
    _fmt = 'Variable {%(name)s} is not available.'
2712
 
 
2713
 
    def __init__(self, name):
2714
 
        self.name = name
2715
 
 
2716
 
 
2717
 
class NoTemplate(BzrError):
2718
 
 
2719
 
    _fmt = 'No template specified.'
2720
 
 
2721
 
 
2722
 
class UnableCreateSymlink(BzrError):
2723
 
 
2724
 
    _fmt = 'Unable to create symlink %(path_str)son this platform'
2725
 
 
2726
 
    def __init__(self, path=None):
2727
 
        path_str = ''
2728
 
        if path:
2729
 
            try:
2730
 
                path_str = repr(str(path))
2731
 
            except UnicodeEncodeError:
2732
 
                path_str = repr(path)
2733
 
            path_str += ' '
2734
 
        self.path_str = path_str
2735
 
 
2736
 
 
2737
 
class UnsupportedTimezoneFormat(BzrError):
2738
 
 
2739
 
    _fmt = ('Unsupported timezone format "%(timezone)s", '
2740
 
            'options are "utc", "original", "local".')
2741
 
 
2742
 
    def __init__(self, timezone):
2743
 
        self.timezone = timezone
2744
 
 
2745
 
 
2746
 
class CommandAvailableInPlugin(StandardError):
2747
 
    
2748
 
    internal_error = False
2749
 
 
2750
 
    def __init__(self, cmd_name, plugin_metadata, provider):
2751
 
        
2752
 
        self.plugin_metadata = plugin_metadata
2753
 
        self.cmd_name = cmd_name
2754
 
        self.provider = provider
2755
 
 
2756
 
    def __str__(self):
2757
 
 
2758
 
        _fmt = ('"%s" is not a standard bzr command. \n' 
2759
 
                'However, the following official plugin provides this command: %s\n'
2760
 
                'You can install it by going to: %s'
2761
 
                % (self.cmd_name, self.plugin_metadata['name'], 
2762
 
                    self.plugin_metadata['url']))
2763
 
 
2764
 
        return _fmt
2765
 
 
2766
 
 
2767
 
class NoPluginAvailable(BzrError):
2768
 
    pass    
2769
 
 
2770
 
 
2771
 
class NotATerminal(BzrError):
2772
 
 
2773
 
    _fmt = 'Unable to ask for a password without real terminal.'
2774
 
 
2775
 
 
2776
 
class UnableEncodePath(BzrError):
2777
 
 
2778
 
    _fmt = ('Unable to encode %(kind)s path %(path)r in '
2779
 
            'user encoding %(user_encoding)s')
2780
 
 
2781
 
    def __init__(self, path, kind):
2782
 
        self.path = path
2783
 
        self.kind = kind
2784
 
        self.user_encoding = osutils.get_user_encoding()
2785
 
 
2786
 
 
2787
 
class NoSuchAlias(BzrError):
2788
 
 
2789
 
    _fmt = ('The alias "%(alias_name)s" does not exist.')
2790
 
 
2791
 
    def __init__(self, alias_name):
2792
 
        BzrError.__init__(self, alias_name=alias_name)
2793
 
 
2794
 
 
2795
 
class DirectoryLookupFailure(BzrError):
2796
 
    """Base type for lookup errors."""
2797
 
 
2798
 
    pass
2799
 
 
2800
 
 
2801
 
class InvalidLocationAlias(DirectoryLookupFailure):
2802
 
 
2803
 
    _fmt = '"%(alias_name)s" is not a valid location alias.'
2804
 
 
2805
 
    def __init__(self, alias_name):
2806
 
        DirectoryLookupFailure.__init__(self, alias_name=alias_name)
2807
 
 
2808
 
 
2809
 
class UnsetLocationAlias(DirectoryLookupFailure):
2810
 
 
2811
 
    _fmt = 'No %(alias_name)s location assigned.'
2812
 
 
2813
 
    def __init__(self, alias_name):
2814
 
        DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
2815
 
 
2816
 
 
2817
 
class CannotBindAddress(BzrError):
2818
 
 
2819
 
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
2820
 
 
2821
 
    def __init__(self, host, port, orig_error):
2822
 
        BzrError.__init__(self, host=host, port=port,
2823
 
            orig_error=orig_error[1])
2824
 
 
2825
 
 
2826
 
class UnknownRules(BzrError):
2827
 
 
2828
 
    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
2829
 
 
2830
 
    def __init__(self, unknowns):
2831
 
        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
2832
 
 
2833
 
 
2834
 
class HookFailed(BzrError):
2835
 
    """Raised when a pre_change_branch_tip hook function fails anything other
2836
 
    than TipChangeRejected.
2837
 
    """
2838
 
 
2839
 
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
2840
 
            "%(traceback_text)s%(exc_value)s")
2841
 
 
2842
 
    def __init__(self, hook_stage, hook_name, exc_info):
2843
 
        import traceback
2844
 
        self.hook_stage = hook_stage
2845
 
        self.hook_name = hook_name
2846
 
        self.exc_info = exc_info
2847
 
        self.exc_type = exc_info[0]
2848
 
        self.exc_value = exc_info[1]
2849
 
        self.exc_tb = exc_info[2]
2850
 
        self.traceback_text = ''.join(traceback.format_tb(self.exc_tb))
2851
 
 
2852
 
 
2853
 
class TipChangeRejected(BzrError):
2854
 
    """A pre_change_branch_tip hook function may raise this to cleanly and
2855
 
    explicitly abort a change to a branch tip.
2856
 
    """
2857
 
    
2858
 
    _fmt = u"Tip change rejected: %(msg)s"
2859
 
 
2860
 
    def __init__(self, msg):
2861
 
        self.msg = msg
2862