/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Aaron Bentley
  • Date: 2007-01-17 16:32:40 UTC
  • mto: This revision was merged to the branch mainline in revision 2240.
  • Revision ID: abentley@panoramicfeedback.com-20070117163240-lj6ttc8m57mdrsj0
Zap trailing whitespace

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Exceptions for bzr, and reporting of them.
 
18
"""
 
19
 
 
20
 
 
21
from bzrlib import symbol_versioning
 
22
from bzrlib.patches import (PatchSyntax, 
 
23
                            PatchConflict, 
 
24
                            MalformedPatchHeader,
 
25
                            MalformedHunkHeader,
 
26
                            MalformedLine,)
 
27
 
 
28
 
 
29
# TODO: is there any value in providing the .args field used by standard
 
30
# python exceptions?   A list of values with no names seems less useful 
 
31
# to me.
 
32
 
 
33
# TODO: Perhaps convert the exception to a string at the moment it's 
 
34
# constructed to make sure it will succeed.  But that says nothing about
 
35
# exceptions that are never raised.
 
36
 
 
37
# TODO: selftest assertRaises should probably also check that every error
 
38
# raised can be formatted as a string successfully, and without giving
 
39
# 'unprintable'.
 
40
 
 
41
 
 
42
class BzrError(StandardError):
 
43
    """
 
44
    Base class for errors raised by bzrlib.
 
45
 
 
46
    :cvar internal_error: if true (or absent) this was probably caused by a
 
47
    bzr bug and should be displayed with a traceback; if False this was
 
48
    probably a user or environment error and they don't need the gory details.
 
49
    (That can be overridden by -Derror on the command line.)
 
50
 
 
51
    :cvar _fmt: Format string to display the error; this is expanded
 
52
    by the instance's dict.
 
53
    """
 
54
    
 
55
    internal_error = False
 
56
 
 
57
    def __init__(self, msg=None, **kwds):
 
58
        """Construct a new BzrError.
 
59
 
 
60
        There are two alternative forms for constructing these objects.
 
61
        Either a preformatted string may be passed, or a set of named
 
62
        arguments can be given.  The first is for generic "user" errors which
 
63
        are not intended to be caught and so do not need a specific subclass.
 
64
        The second case is for use with subclasses that provide a _fmt format
 
65
        string to print the arguments.  
 
66
 
 
67
        Keyword arguments are taken as parameters to the error, which can 
 
68
        be inserted into the format string template.  It's recommended 
 
69
        that subclasses override the __init__ method to require specific 
 
70
        parameters.
 
71
 
 
72
        :param msg: If given, this is the literal complete text for the error,
 
73
        not subject to expansion.
 
74
        """
 
75
        StandardError.__init__(self)
 
76
        if msg is not None:
 
77
            # I was going to deprecate this, but it actually turns out to be
 
78
            # quite handy - mbp 20061103.
 
79
            self._preformatted_string = msg
 
80
        else:
 
81
            self._preformatted_string = None
 
82
            for key, value in kwds.items():
 
83
                setattr(self, key, value)
 
84
 
 
85
    def __str__(self):
 
86
        s = getattr(self, '_preformatted_string', None)
 
87
        if s is not None:
 
88
            # contains a preformatted message; must be cast to plain str
 
89
            return str(s)
 
90
        try:
 
91
            fmt = self._get_format_string()
 
92
            if fmt:
 
93
                s = fmt % self.__dict__
 
94
                # __str__() should always return a 'str' object
 
95
                # never a 'unicode' object.
 
96
                if isinstance(s, unicode):
 
97
                    return s.encode('utf8')
 
98
                return s
 
99
        except (AttributeError, TypeError, NameError, ValueError, KeyError), e:
 
100
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%s' \
 
101
                % (self.__class__.__name__,
 
102
                   self.__dict__,
 
103
                   getattr(self, '_fmt', None),
 
104
                   str(e))
 
105
 
 
106
    def _get_format_string(self):
 
107
        """Return format string for this exception or None"""
 
108
        fmt = getattr(self, '_fmt', None)
 
109
        if fmt is not None:
 
110
            return fmt
 
111
        fmt = getattr(self, '__doc__', None)
 
112
        if fmt is not None:
 
113
            symbol_versioning.warn("%s uses its docstring as a format, "
 
114
                    "it should use _fmt instead" % self.__class__.__name__,
 
115
                    DeprecationWarning)
 
116
            return fmt
 
117
        return 'Unprintable exception %s: dict=%r, fmt=%r' \
 
118
            % (self.__class__.__name__,
 
119
               self.__dict__,
 
120
               getattr(self, '_fmt', None),
 
121
               )
 
122
 
 
123
 
 
124
class BzrNewError(BzrError):
 
125
    """Deprecated error base class."""
 
126
    # base classes should override the docstring with their human-
 
127
    # readable explanation
 
128
 
 
129
    def __init__(self, *args, **kwds):
 
130
        # XXX: Use the underlying BzrError to always generate the args attribute
 
131
        # if it doesn't exist.  We can't use super here, because exceptions are
 
132
        # old-style classes in python2.4 (but new in 2.5).  --bmc, 20060426
 
133
        symbol_versioning.warn('BzrNewError was deprecated in bzr 0.13; '
 
134
             'please convert %s to use BzrError instead' 
 
135
             % self.__class__.__name__,
 
136
             DeprecationWarning,
 
137
             stacklevel=2)
 
138
        BzrError.__init__(self, *args)
 
139
        for key, value in kwds.items():
 
140
            setattr(self, key, value)
 
141
 
 
142
    def __str__(self):
 
143
        try:
 
144
            # __str__() should always return a 'str' object
 
145
            # never a 'unicode' object.
 
146
            s = self.__doc__ % self.__dict__
 
147
            if isinstance(s, unicode):
 
148
                return s.encode('utf8')
 
149
            return s
 
150
        except (TypeError, NameError, ValueError, KeyError), e:
 
151
            return 'Unprintable exception %s(%r): %s' \
 
152
                % (self.__class__.__name__,
 
153
                   self.__dict__, str(e))
 
154
 
 
155
 
 
156
class AlreadyBuilding(BzrError):
 
157
    
 
158
    _fmt = "The tree builder is already building a tree."
 
159
 
 
160
 
 
161
class BzrCheckError(BzrError):
 
162
    
 
163
    _fmt = "Internal check failed: %(message)s"
 
164
 
 
165
    internal_error = True
 
166
 
 
167
    def __init__(self, message):
 
168
        BzrError.__init__(self)
 
169
        self.message = message
 
170
 
 
171
 
 
172
class InvalidEntryName(BzrError):
 
173
    
 
174
    _fmt = "Invalid entry name: %(name)s"
 
175
 
 
176
    internal_error = True
 
177
 
 
178
    def __init__(self, name):
 
179
        BzrError.__init__(self)
 
180
        self.name = name
 
181
 
 
182
 
 
183
class InvalidRevisionNumber(BzrError):
 
184
    
 
185
    _fmt = "Invalid revision number %(revno)s"
 
186
 
 
187
    def __init__(self, revno):
 
188
        BzrError.__init__(self)
 
189
        self.revno = revno
 
190
 
 
191
 
 
192
class InvalidRevisionId(BzrError):
 
193
 
 
194
    _fmt = "Invalid revision-id {%(revision_id)s} in %(branch)s"
 
195
 
 
196
    def __init__(self, revision_id, branch):
 
197
        # branch can be any string or object with __str__ defined
 
198
        BzrError.__init__(self)
 
199
        self.revision_id = revision_id
 
200
        self.branch = branch
 
201
 
 
202
 
 
203
class NoSuchId(BzrError):
 
204
 
 
205
    _fmt = "The file id %(file_id)s is not present in the tree %(tree)s."
 
206
    
 
207
    def __init__(self, tree, file_id):
 
208
        BzrError.__init__(self)
 
209
        self.file_id = file_id
 
210
        self.tree = tree
 
211
 
 
212
 
 
213
class InventoryModified(BzrError):
 
214
 
 
215
    _fmt = ("The current inventory for the tree %(tree)r has been modified, "
 
216
            "so a clean inventory cannot be read without data loss.")
 
217
 
 
218
    internal_error = True
 
219
 
 
220
    def __init__(self, tree):
 
221
        self.tree = tree
 
222
 
 
223
 
 
224
class NoWorkingTree(BzrError):
 
225
 
 
226
    _fmt = "No WorkingTree exists for %(base)s."
 
227
    
 
228
    def __init__(self, base):
 
229
        BzrError.__init__(self)
 
230
        self.base = base
 
231
 
 
232
 
 
233
class NotBuilding(BzrError):
 
234
 
 
235
    _fmt = "Not currently building a tree."
 
236
 
 
237
 
 
238
class NotLocalUrl(BzrError):
 
239
 
 
240
    _fmt = "%(url)s is not a local path."
 
241
 
 
242
    def __init__(self, url):
 
243
        self.url = url
 
244
 
 
245
 
 
246
class WorkingTreeAlreadyPopulated(BzrError):
 
247
 
 
248
    _fmt = """Working tree already populated in %(base)s"""
 
249
 
 
250
    internal_error = True
 
251
 
 
252
    def __init__(self, base):
 
253
        self.base = base
 
254
 
 
255
class BzrCommandError(BzrError):
 
256
    """Error from user command"""
 
257
 
 
258
    internal_error = False
 
259
 
 
260
    # Error from malformed user command; please avoid raising this as a
 
261
    # generic exception not caused by user input.
 
262
    #
 
263
    # I think it's a waste of effort to differentiate between errors that
 
264
    # are not intended to be caught anyway.  UI code need not subclass
 
265
    # BzrCommandError, and non-UI code should not throw a subclass of
 
266
    # BzrCommandError.  ADHB 20051211
 
267
    def __init__(self, msg):
 
268
        # Object.__str__() must return a real string
 
269
        # returning a Unicode string is a python error.
 
270
        if isinstance(msg, unicode):
 
271
            self.msg = msg.encode('utf8')
 
272
        else:
 
273
            self.msg = msg
 
274
 
 
275
    def __str__(self):
 
276
        return self.msg
 
277
 
 
278
 
 
279
class NotWriteLocked(BzrError):
 
280
 
 
281
    _fmt = """%(not_locked)r is not write locked but needs to be."""
 
282
 
 
283
    def __init__(self, not_locked):
 
284
        self.not_locked = not_locked
 
285
 
 
286
 
 
287
class BzrOptionError(BzrCommandError):
 
288
 
 
289
    _fmt = "Error in command line options"
 
290
 
 
291
 
 
292
class BadOptionValue(BzrError):
 
293
 
 
294
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
 
295
 
 
296
    def __init__(self, name, value):
 
297
        BzrError.__init__(self, name=name, value=value)
 
298
 
 
299
    
 
300
class StrictCommitFailed(BzrError):
 
301
 
 
302
    _fmt = "Commit refused because there are unknown files in the tree"
 
303
 
 
304
 
 
305
# XXX: Should be unified with TransportError; they seem to represent the
 
306
# same thing
 
307
class PathError(BzrError):
 
308
    
 
309
    _fmt = "Generic path error: %(path)r%(extra)s)"
 
310
 
 
311
    def __init__(self, path, extra=None):
 
312
        BzrError.__init__(self)
 
313
        self.path = path
 
314
        if extra:
 
315
            self.extra = ': ' + str(extra)
 
316
        else:
 
317
            self.extra = ''
 
318
 
 
319
 
 
320
class NoSuchFile(PathError):
 
321
 
 
322
    _fmt = "No such file: %(path)r%(extra)s"
 
323
 
 
324
 
 
325
class FileExists(PathError):
 
326
 
 
327
    _fmt = "File exists: %(path)r%(extra)s"
 
328
 
 
329
 
 
330
class DirectoryNotEmpty(PathError):
 
331
 
 
332
    _fmt = "Directory not empty: %(path)r%(extra)s"
 
333
 
 
334
 
 
335
class ReadingCompleted(BzrError):
 
336
    
 
337
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
 
338
            "called upon it - the request has been completed and no more "
 
339
            "data may be read.")
 
340
 
 
341
    internal_error = True
 
342
 
 
343
    def __init__(self, request):
 
344
        self.request = request
 
345
 
 
346
 
 
347
class ResourceBusy(PathError):
 
348
 
 
349
    _fmt = "Device or resource busy: %(path)r%(extra)s"
 
350
 
 
351
 
 
352
class PermissionDenied(PathError):
 
353
 
 
354
    _fmt = "Permission denied: %(path)r%(extra)s"
 
355
 
 
356
 
 
357
class InvalidURL(PathError):
 
358
 
 
359
    _fmt = "Invalid url supplied to transport: %(path)r%(extra)s"
 
360
 
 
361
 
 
362
class InvalidURLJoin(PathError):
 
363
 
 
364
    _fmt = "Invalid URL join request: %(args)s%(extra)s"
 
365
 
 
366
    def __init__(self, msg, base, args):
 
367
        PathError.__init__(self, base, msg)
 
368
        self.args = [base] + list(args)
 
369
 
 
370
 
 
371
class UnsupportedProtocol(PathError):
 
372
 
 
373
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
 
374
 
 
375
    def __init__(self, url, extra):
 
376
        PathError.__init__(self, url, extra=extra)
 
377
 
 
378
 
 
379
class ShortReadvError(PathError):
 
380
 
 
381
    _fmt = "readv() read %(actual)s bytes rather than %(length)s bytes at %(offset)s for %(path)s%(extra)s"
 
382
 
 
383
    internal_error = True
 
384
 
 
385
    def __init__(self, path, offset, length, actual, extra=None):
 
386
        PathError.__init__(self, path, extra=extra)
 
387
        self.offset = offset
 
388
        self.length = length
 
389
        self.actual = actual
 
390
 
 
391
 
 
392
class PathNotChild(BzrError):
 
393
 
 
394
    _fmt = "Path %(path)r is not a child of path %(base)r%(extra)s"
 
395
 
 
396
    internal_error = True
 
397
 
 
398
    def __init__(self, path, base, extra=None):
 
399
        BzrError.__init__(self)
 
400
        self.path = path
 
401
        self.base = base
 
402
        if extra:
 
403
            self.extra = ': ' + str(extra)
 
404
        else:
 
405
            self.extra = ''
 
406
 
 
407
 
 
408
class InvalidNormalization(PathError):
 
409
 
 
410
    _fmt = "Path %(path)r is not unicode normalized"
 
411
 
 
412
 
 
413
# TODO: This is given a URL; we try to unescape it but doing that from inside
 
414
# the exception object is a bit undesirable.
 
415
# TODO: Probably this behavior of should be a common superclass 
 
416
class NotBranchError(PathError):
 
417
 
 
418
    _fmt = "Not a branch: %(path)s"
 
419
 
 
420
    def __init__(self, path):
 
421
       import bzrlib.urlutils as urlutils
 
422
       self.path = urlutils.unescape_for_display(path, 'ascii')
 
423
 
 
424
 
 
425
class AlreadyBranchError(PathError):
 
426
 
 
427
    _fmt = "Already a branch: %(path)s."
 
428
 
 
429
 
 
430
class BranchExistsWithoutWorkingTree(PathError):
 
431
 
 
432
    _fmt = "Directory contains a branch, but no working tree \
 
433
(use bzr checkout if you wish to build a working tree): %(path)s"
 
434
 
 
435
 
 
436
class AtomicFileAlreadyClosed(PathError):
 
437
 
 
438
    _fmt = "'%(function)s' called on an AtomicFile after it was closed: %(path)s"
 
439
 
 
440
    def __init__(self, path, function):
 
441
        PathError.__init__(self, path=path, extra=None)
 
442
        self.function = function
 
443
 
 
444
 
 
445
class InaccessibleParent(PathError):
 
446
 
 
447
    _fmt = "Parent not accessible given base %(base)s and relative path %(path)s"
 
448
 
 
449
    def __init__(self, path, base):
 
450
        PathError.__init__(self, path)
 
451
        self.base = base
 
452
 
 
453
 
 
454
class NoRepositoryPresent(BzrError):
 
455
 
 
456
    _fmt = "No repository present: %(path)r"
 
457
    def __init__(self, bzrdir):
 
458
        BzrError.__init__(self)
 
459
        self.path = bzrdir.transport.clone('..').base
 
460
 
 
461
 
 
462
class FileInWrongBranch(BzrError):
 
463
 
 
464
    _fmt = "File %(path)s in not in branch %(branch_base)s."
 
465
 
 
466
    def __init__(self, branch, path):
 
467
        BzrError.__init__(self)
 
468
        self.branch = branch
 
469
        self.branch_base = branch.base
 
470
        self.path = path
 
471
 
 
472
 
 
473
class UnsupportedFormatError(BzrError):
 
474
    
 
475
    _fmt = "Unsupported branch format: %(format)s"
 
476
 
 
477
 
 
478
class UnknownFormatError(BzrError):
 
479
    
 
480
    _fmt = "Unknown branch format: %(format)r"
 
481
 
 
482
 
 
483
class IncompatibleFormat(BzrError):
 
484
    
 
485
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
 
486
 
 
487
    def __init__(self, format, bzrdir_format):
 
488
        BzrError.__init__(self)
 
489
        self.format = format
 
490
        self.bzrdir = bzrdir_format
 
491
 
 
492
 
 
493
class IncompatibleRevision(BzrError):
 
494
    
 
495
    _fmt = "Revision is not compatible with %(repo_format)s"
 
496
 
 
497
    def __init__(self, repo_format):
 
498
        BzrError.__init__(self)
 
499
        self.repo_format = repo_format
 
500
 
 
501
 
 
502
class NotVersionedError(BzrError):
 
503
 
 
504
    _fmt = "%(path)s is not versioned"
 
505
 
 
506
    def __init__(self, path):
 
507
        BzrError.__init__(self)
 
508
        self.path = path
 
509
 
 
510
 
 
511
class PathsNotVersionedError(BzrError):
 
512
    # used when reporting several paths are not versioned
 
513
 
 
514
    _fmt = "Path(s) are not versioned: %(paths_as_string)s"
 
515
 
 
516
    def __init__(self, paths):
 
517
        from bzrlib.osutils import quotefn
 
518
        BzrError.__init__(self)
 
519
        self.paths = paths
 
520
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
 
521
 
 
522
 
 
523
class PathsDoNotExist(BzrError):
 
524
 
 
525
    _fmt = "Path(s) do not exist: %(paths_as_string)s"
 
526
 
 
527
    # used when reporting that paths are neither versioned nor in the working
 
528
    # tree
 
529
 
 
530
    def __init__(self, paths):
 
531
        # circular import
 
532
        from bzrlib.osutils import quotefn
 
533
        BzrError.__init__(self)
 
534
        self.paths = paths
 
535
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
 
536
 
 
537
 
 
538
class BadFileKindError(BzrError):
 
539
 
 
540
    _fmt = "Cannot operate on %(filename)s of unsupported kind %(kind)s"
 
541
 
 
542
 
 
543
class ForbiddenControlFileError(BzrError):
 
544
 
 
545
    _fmt = "Cannot operate on %(filename)s because it is a control file"
 
546
 
 
547
 
 
548
class LockError(BzrError):
 
549
 
 
550
    _fmt = "Lock error: %(message)s"
 
551
 
 
552
    internal_error = True
 
553
 
 
554
    # All exceptions from the lock/unlock functions should be from
 
555
    # this exception class.  They will be translated as necessary. The
 
556
    # original exception is available as e.original_error
 
557
    #
 
558
    # New code should prefer to raise specific subclasses
 
559
    def __init__(self, message):
 
560
        self.message = message
 
561
 
 
562
 
 
563
class CommitNotPossible(LockError):
 
564
 
 
565
    _fmt = "A commit was attempted but we do not have a write lock open."
 
566
 
 
567
    def __init__(self):
 
568
        pass
 
569
 
 
570
 
 
571
class AlreadyCommitted(LockError):
 
572
 
 
573
    _fmt = "A rollback was requested, but is not able to be accomplished."
 
574
 
 
575
    def __init__(self):
 
576
        pass
 
577
 
 
578
 
 
579
class ReadOnlyError(LockError):
 
580
 
 
581
    _fmt = "A write attempt was made in a read only transaction on %(obj)s"
 
582
 
 
583
    def __init__(self, obj):
 
584
        self.obj = obj
 
585
 
 
586
 
 
587
class OutSideTransaction(BzrError):
 
588
 
 
589
    _fmt = "A transaction related operation was attempted after the transaction finished."
 
590
 
 
591
 
 
592
class ObjectNotLocked(LockError):
 
593
 
 
594
    _fmt = "%(obj)r is not locked"
 
595
 
 
596
    # this can indicate that any particular object is not locked; see also
 
597
    # LockNotHeld which means that a particular *lock* object is not held by
 
598
    # the caller -- perhaps they should be unified.
 
599
    def __init__(self, obj):
 
600
        self.obj = obj
 
601
 
 
602
 
 
603
class ReadOnlyObjectDirtiedError(ReadOnlyError):
 
604
 
 
605
    _fmt = "Cannot change object %(obj)r in read only transaction"
 
606
 
 
607
    def __init__(self, obj):
 
608
        self.obj = obj
 
609
 
 
610
 
 
611
class UnlockableTransport(LockError):
 
612
 
 
613
    _fmt = "Cannot lock: transport is read only: %(transport)s"
 
614
 
 
615
    def __init__(self, transport):
 
616
        self.transport = transport
 
617
 
 
618
 
 
619
class LockContention(LockError):
 
620
 
 
621
    _fmt = "Could not acquire lock %(lock)s"
 
622
    # TODO: show full url for lock, combining the transport and relative
 
623
    # bits?
 
624
 
 
625
    internal_error = False
 
626
    
 
627
    def __init__(self, lock):
 
628
        self.lock = lock
 
629
 
 
630
 
 
631
class LockBroken(LockError):
 
632
 
 
633
    _fmt = "Lock was broken while still open: %(lock)s - check storage consistency!"
 
634
 
 
635
    internal_error = False
 
636
 
 
637
    def __init__(self, lock):
 
638
        self.lock = lock
 
639
 
 
640
 
 
641
class LockBreakMismatch(LockError):
 
642
 
 
643
    _fmt = "Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)r, wanted to break %(target)r"
 
644
 
 
645
    internal_error = False
 
646
 
 
647
    def __init__(self, lock, holder, target):
 
648
        self.lock = lock
 
649
        self.holder = holder
 
650
        self.target = target
 
651
 
 
652
 
 
653
class LockNotHeld(LockError):
 
654
 
 
655
    _fmt = "Lock not held: %(lock)s"
 
656
 
 
657
    internal_error = False
 
658
 
 
659
    def __init__(self, lock):
 
660
        self.lock = lock
 
661
 
 
662
 
 
663
class PointlessCommit(BzrError):
 
664
 
 
665
    _fmt = "No changes to commit"
 
666
 
 
667
 
 
668
class UpgradeReadonly(BzrError):
 
669
 
 
670
    _fmt = "Upgrade URL cannot work with readonly URLs."
 
671
 
 
672
 
 
673
class UpToDateFormat(BzrError):
 
674
 
 
675
    _fmt = "The branch format %(format)s is already at the most recent format."
 
676
 
 
677
    def __init__(self, format):
 
678
        BzrError.__init__(self)
 
679
        self.format = format
 
680
 
 
681
 
 
682
class StrictCommitFailed(Exception):
 
683
 
 
684
    _fmt = "Commit refused because there are unknowns in the tree."
 
685
 
 
686
 
 
687
class NoSuchRevision(BzrError):
 
688
 
 
689
    _fmt = "Branch %(branch)s has no revision %(revision)s"
 
690
 
 
691
    internal_error = True
 
692
 
 
693
    def __init__(self, branch, revision):
 
694
        BzrError.__init__(self, branch=branch, revision=revision)
 
695
 
 
696
 
 
697
class NoSuchRevisionSpec(BzrError):
 
698
 
 
699
    _fmt = "No namespace registered for string: %(spec)r"
 
700
 
 
701
    def __init__(self, spec):
 
702
        BzrError.__init__(self, spec=spec)
 
703
 
 
704
 
 
705
class InvalidRevisionSpec(BzrError):
 
706
 
 
707
    _fmt = "Requested revision: %(spec)r does not exist in branch: %(branch)s%(extra)s"
 
708
 
 
709
    def __init__(self, spec, branch, extra=None):
 
710
        BzrError.__init__(self, branch=branch, spec=spec)
 
711
        if extra:
 
712
            self.extra = '\n' + str(extra)
 
713
        else:
 
714
            self.extra = ''
 
715
 
 
716
 
 
717
class HistoryMissing(BzrError):
 
718
 
 
719
    _fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"
 
720
 
 
721
 
 
722
class DivergedBranches(BzrError):
 
723
    
 
724
    _fmt = "These branches have diverged.  Use the merge command to reconcile them."""
 
725
 
 
726
    internal_error = False
 
727
 
 
728
    def __init__(self, branch1, branch2):
 
729
        self.branch1 = branch1
 
730
        self.branch2 = branch2
 
731
 
 
732
 
 
733
class UnrelatedBranches(BzrError):
 
734
 
 
735
    _fmt = "Branches have no common ancestor, and no merge base revision was specified."
 
736
 
 
737
    internal_error = False
 
738
 
 
739
 
 
740
class NoCommonAncestor(BzrError):
 
741
    
 
742
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
 
743
 
 
744
    def __init__(self, revision_a, revision_b):
 
745
        self.revision_a = revision_a
 
746
        self.revision_b = revision_b
 
747
 
 
748
 
 
749
class NoCommonRoot(BzrError):
 
750
 
 
751
    _fmt = "Revisions are not derived from the same root: " \
 
752
           "%(revision_a)s %(revision_b)s."
 
753
 
 
754
    def __init__(self, revision_a, revision_b):
 
755
        BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
 
756
 
 
757
 
 
758
class NotAncestor(BzrError):
 
759
 
 
760
    _fmt = "Revision %(rev_id)s is not an ancestor of %(not_ancestor_id)s"
 
761
 
 
762
    def __init__(self, rev_id, not_ancestor_id):
 
763
        BzrError.__init__(self, rev_id=rev_id,
 
764
            not_ancestor_id=not_ancestor_id)
 
765
 
 
766
 
 
767
class InstallFailed(BzrError):
 
768
 
 
769
    def __init__(self, revisions):
 
770
        revision_str = ", ".join(str(r) for r in revisions)
 
771
        msg = "Could not install revisions:\n%s" % revision_str
 
772
        BzrError.__init__(self, msg)
 
773
        self.revisions = revisions
 
774
 
 
775
 
 
776
class AmbiguousBase(BzrError):
 
777
 
 
778
    def __init__(self, bases):
 
779
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
 
780
                DeprecationWarning)
 
781
        msg = "The correct base is unclear, because %s are all equally close" %\
 
782
            ", ".join(bases)
 
783
        BzrError.__init__(self, msg)
 
784
        self.bases = bases
 
785
 
 
786
 
 
787
class NoCommits(BzrError):
 
788
 
 
789
    _fmt = "Branch %(branch)s has no commits."
 
790
 
 
791
    def __init__(self, branch):
 
792
        BzrError.__init__(self, branch=branch)
 
793
 
 
794
 
 
795
class UnlistableStore(BzrError):
 
796
 
 
797
    def __init__(self, store):
 
798
        BzrError.__init__(self, "Store %s is not listable" % store)
 
799
 
 
800
 
 
801
 
 
802
class UnlistableBranch(BzrError):
 
803
 
 
804
    def __init__(self, br):
 
805
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
 
806
 
 
807
 
 
808
class BoundBranchOutOfDate(BzrError):
 
809
 
 
810
    _fmt = "Bound branch %(branch)s is out of date with master branch %(master)s."
 
811
 
 
812
    def __init__(self, branch, master):
 
813
        BzrError.__init__(self)
 
814
        self.branch = branch
 
815
        self.master = master
 
816
 
 
817
        
 
818
class CommitToDoubleBoundBranch(BzrError):
 
819
 
 
820
    _fmt = "Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."
 
821
 
 
822
    def __init__(self, branch, master, remote):
 
823
        BzrError.__init__(self)
 
824
        self.branch = branch
 
825
        self.master = master
 
826
        self.remote = remote
 
827
 
 
828
 
 
829
class OverwriteBoundBranch(BzrError):
 
830
 
 
831
    _fmt = "Cannot pull --overwrite to a branch which is bound %(branch)s"
 
832
 
 
833
    def __init__(self, branch):
 
834
        BzrError.__init__(self)
 
835
        self.branch = branch
 
836
 
 
837
 
 
838
class BoundBranchConnectionFailure(BzrError):
 
839
 
 
840
    _fmt = "Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"
 
841
 
 
842
    def __init__(self, branch, target, error):
 
843
        BzrError.__init__(self)
 
844
        self.branch = branch
 
845
        self.target = target
 
846
        self.error = error
 
847
 
 
848
 
 
849
class WeaveError(BzrError):
 
850
 
 
851
    _fmt = "Error in processing weave: %(message)s"
 
852
 
 
853
    def __init__(self, message=None):
 
854
        BzrError.__init__(self)
 
855
        self.message = message
 
856
 
 
857
 
 
858
class WeaveRevisionAlreadyPresent(WeaveError):
 
859
 
 
860
    _fmt = "Revision {%(revision_id)s} already present in %(weave)s"
 
861
 
 
862
    def __init__(self, revision_id, weave):
 
863
 
 
864
        WeaveError.__init__(self)
 
865
        self.revision_id = revision_id
 
866
        self.weave = weave
 
867
 
 
868
 
 
869
class WeaveRevisionNotPresent(WeaveError):
 
870
 
 
871
    _fmt = "Revision {%(revision_id)s} not present in %(weave)s"
 
872
 
 
873
    def __init__(self, revision_id, weave):
 
874
        WeaveError.__init__(self)
 
875
        self.revision_id = revision_id
 
876
        self.weave = weave
 
877
 
 
878
 
 
879
class WeaveFormatError(WeaveError):
 
880
 
 
881
    _fmt = "Weave invariant violated: %(what)s"
 
882
 
 
883
    def __init__(self, what):
 
884
        WeaveError.__init__(self)
 
885
        self.what = what
 
886
 
 
887
 
 
888
class WeaveParentMismatch(WeaveError):
 
889
 
 
890
    _fmt = "Parents are mismatched between two revisions."
 
891
    
 
892
 
 
893
class WeaveInvalidChecksum(WeaveError):
 
894
 
 
895
    _fmt = "Text did not match it's checksum: %(message)s"
 
896
 
 
897
 
 
898
class WeaveTextDiffers(WeaveError):
 
899
 
 
900
    _fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"
 
901
 
 
902
    def __init__(self, revision_id, weave_a, weave_b):
 
903
        WeaveError.__init__(self)
 
904
        self.revision_id = revision_id
 
905
        self.weave_a = weave_a
 
906
        self.weave_b = weave_b
 
907
 
 
908
 
 
909
class WeaveTextDiffers(WeaveError):
 
910
 
 
911
    _fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"
 
912
 
 
913
    def __init__(self, revision_id, weave_a, weave_b):
 
914
        WeaveError.__init__(self)
 
915
        self.revision_id = revision_id
 
916
        self.weave_a = weave_a
 
917
        self.weave_b = weave_b
 
918
 
 
919
 
 
920
class VersionedFileError(BzrError):
 
921
    
 
922
    _fmt = "Versioned file error"
 
923
 
 
924
 
 
925
class RevisionNotPresent(VersionedFileError):
 
926
    
 
927
    _fmt = "Revision {%(revision_id)s} not present in %(file_id)s."
 
928
 
 
929
    def __init__(self, revision_id, file_id):
 
930
        VersionedFileError.__init__(self)
 
931
        self.revision_id = revision_id
 
932
        self.file_id = file_id
 
933
 
 
934
 
 
935
class RevisionAlreadyPresent(VersionedFileError):
 
936
    
 
937
    _fmt = "Revision {%(revision_id)s} already present in %(file_id)s."
 
938
 
 
939
    def __init__(self, revision_id, file_id):
 
940
        VersionedFileError.__init__(self)
 
941
        self.revision_id = revision_id
 
942
        self.file_id = file_id
 
943
 
 
944
 
 
945
class KnitError(BzrError):
 
946
    
 
947
    _fmt = "Knit error"
 
948
 
 
949
    internal_error = True
 
950
 
 
951
 
 
952
class KnitHeaderError(KnitError):
 
953
 
 
954
    _fmt = "Knit header error: %(badline)r unexpected for file %(filename)s"
 
955
 
 
956
    def __init__(self, badline, filename):
 
957
        KnitError.__init__(self)
 
958
        self.badline = badline
 
959
        self.filename = filename
 
960
 
 
961
 
 
962
class KnitCorrupt(KnitError):
 
963
 
 
964
    _fmt = "Knit %(filename)s corrupt: %(how)s"
 
965
 
 
966
    def __init__(self, filename, how):
 
967
        KnitError.__init__(self)
 
968
        self.filename = filename
 
969
        self.how = how
 
970
 
 
971
 
 
972
class KnitIndexUnknownMethod(KnitError):
 
973
    """Raised when we don't understand the storage method.
 
974
 
 
975
    Currently only 'fulltext' and 'line-delta' are supported.
 
976
    """
 
977
    
 
978
    _fmt = ("Knit index %(filename)s does not have a known method"
 
979
            " in options: %(options)r")
 
980
 
 
981
    def __init__(self, filename, options):
 
982
        KnitError.__init__(self)
 
983
        self.filename = filename
 
984
        self.options = options
 
985
 
 
986
 
 
987
class NoSuchExportFormat(BzrError):
 
988
    
 
989
    _fmt = "Export format %(format)r not supported"
 
990
 
 
991
    def __init__(self, format):
 
992
        BzrError.__init__(self)
 
993
        self.format = format
 
994
 
 
995
 
 
996
class TransportError(BzrError):
 
997
    
 
998
    _fmt = "Transport error: %(msg)s %(orig_error)s"
 
999
 
 
1000
    def __init__(self, msg=None, orig_error=None):
 
1001
        if msg is None and orig_error is not None:
 
1002
            msg = str(orig_error)
 
1003
        if orig_error is None:
 
1004
            orig_error = ''
 
1005
        if msg is None:
 
1006
            msg =  ''
 
1007
        self.msg = msg
 
1008
        self.orig_error = orig_error
 
1009
        BzrError.__init__(self)
 
1010
 
 
1011
 
 
1012
class TooManyConcurrentRequests(BzrError):
 
1013
 
 
1014
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit. "
 
1015
            "Be sure to finish_writing and finish_reading on the "
 
1016
            "current request that is open.")
 
1017
 
 
1018
    internal_error = True
 
1019
 
 
1020
    def __init__(self, medium):
 
1021
        self.medium = medium
 
1022
 
 
1023
 
 
1024
class SmartProtocolError(TransportError):
 
1025
 
 
1026
    _fmt = "Generic bzr smart protocol error: %(details)s"
 
1027
 
 
1028
    def __init__(self, details):
 
1029
        self.details = details
 
1030
 
 
1031
 
 
1032
# A set of semi-meaningful errors which can be thrown
 
1033
class TransportNotPossible(TransportError):
 
1034
 
 
1035
    _fmt = "Transport operation not possible: %(msg)s %(orig_error)s"
 
1036
 
 
1037
 
 
1038
class ConnectionError(TransportError):
 
1039
 
 
1040
    _fmt = "Connection error: %(msg)s %(orig_error)s"
 
1041
 
 
1042
 
 
1043
class SocketConnectionError(ConnectionError):
 
1044
 
 
1045
    _fmt = "%(msg)s %(host)s%(port)s%(orig_error)s"
 
1046
 
 
1047
    def __init__(self, host, port=None, msg=None, orig_error=None):
 
1048
        if msg is None:
 
1049
            msg = 'Failed to connect to'
 
1050
        if orig_error is None:
 
1051
            orig_error = ''
 
1052
        else:
 
1053
            orig_error = '; ' + str(orig_error)
 
1054
        ConnectionError.__init__(self, msg=msg, orig_error=orig_error)
 
1055
        self.host = host
 
1056
        if port is None:
 
1057
            self.port = ''
 
1058
        else:
 
1059
            self.port = ':%s' % port
 
1060
 
 
1061
 
 
1062
class ConnectionReset(TransportError):
 
1063
 
 
1064
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
 
1065
 
 
1066
 
 
1067
class InvalidRange(TransportError):
 
1068
 
 
1069
    _fmt = "Invalid range access in %(path)s at %(offset)s."
 
1070
    
 
1071
    def __init__(self, path, offset):
 
1072
        TransportError.__init__(self, ("Invalid range access in %s at %d"
 
1073
                                       % (path, offset)))
 
1074
        self.path = path
 
1075
        self.offset = offset
 
1076
 
 
1077
 
 
1078
class InvalidHttpResponse(TransportError):
 
1079
 
 
1080
    _fmt = "Invalid http response for %(path)s: %(msg)s"
 
1081
 
 
1082
    def __init__(self, path, msg, orig_error=None):
 
1083
        self.path = path
 
1084
        TransportError.__init__(self, msg, orig_error=orig_error)
 
1085
 
 
1086
 
 
1087
class InvalidHttpRange(InvalidHttpResponse):
 
1088
 
 
1089
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
 
1090
    
 
1091
    def __init__(self, path, range, msg):
 
1092
        self.range = range
 
1093
        InvalidHttpResponse.__init__(self, path, msg)
 
1094
 
 
1095
 
 
1096
class InvalidHttpContentType(InvalidHttpResponse):
 
1097
 
 
1098
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
 
1099
    
 
1100
    def __init__(self, path, ctype, msg):
 
1101
        self.ctype = ctype
 
1102
        InvalidHttpResponse.__init__(self, path, msg)
 
1103
 
 
1104
 
 
1105
class ConflictsInTree(BzrError):
 
1106
 
 
1107
    _fmt = "Working tree has conflicts."
 
1108
 
 
1109
 
 
1110
class ParseConfigError(BzrError):
 
1111
 
 
1112
    def __init__(self, errors, filename):
 
1113
        if filename is None:
 
1114
            filename = ""
 
1115
        message = "Error(s) parsing config file %s:\n%s" % \
 
1116
            (filename, ('\n'.join(e.message for e in errors)))
 
1117
        BzrError.__init__(self, message)
 
1118
 
 
1119
 
 
1120
class NoEmailInUsername(BzrError):
 
1121
 
 
1122
    _fmt = "%(username)r does not seem to contain a reasonable email address"
 
1123
 
 
1124
    def __init__(self, username):
 
1125
        BzrError.__init__(self)
 
1126
        self.username = username
 
1127
 
 
1128
 
 
1129
class SigningFailed(BzrError):
 
1130
 
 
1131
    _fmt = "Failed to gpg sign data with command %(command_line)r"
 
1132
 
 
1133
    def __init__(self, command_line):
 
1134
        BzrError.__init__(self, command_line=command_line)
 
1135
 
 
1136
 
 
1137
class WorkingTreeNotRevision(BzrError):
 
1138
 
 
1139
    _fmt = ("The working tree for %(basedir)s has changed since" 
 
1140
            " the last commit, but weave merge requires that it be"
 
1141
            " unchanged")
 
1142
 
 
1143
    def __init__(self, tree):
 
1144
        BzrError.__init__(self, basedir=tree.basedir)
 
1145
 
 
1146
 
 
1147
class CantReprocessAndShowBase(BzrError):
 
1148
 
 
1149
    _fmt = "Can't reprocess and show base, because reprocessing obscures " \
 
1150
           "the relationship of conflicting lines to the base"
 
1151
 
 
1152
 
 
1153
class GraphCycleError(BzrError):
 
1154
 
 
1155
    _fmt = "Cycle in graph %(graph)r"
 
1156
 
 
1157
    def __init__(self, graph):
 
1158
        BzrError.__init__(self)
 
1159
        self.graph = graph
 
1160
 
 
1161
 
 
1162
class WritingCompleted(BzrError):
 
1163
 
 
1164
    _fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
 
1165
            "called upon it - accept bytes may not be called anymore.")
 
1166
 
 
1167
    internal_error = True
 
1168
 
 
1169
    def __init__(self, request):
 
1170
        self.request = request
 
1171
 
 
1172
 
 
1173
class WritingNotComplete(BzrError):
 
1174
 
 
1175
    _fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
 
1176
            "called upon it - until the write phase is complete no "
 
1177
            "data may be read.")
 
1178
 
 
1179
    internal_error = True
 
1180
 
 
1181
    def __init__(self, request):
 
1182
        self.request = request
 
1183
 
 
1184
 
 
1185
class NotConflicted(BzrError):
 
1186
 
 
1187
    _fmt = "File %(filename)s is not conflicted."
 
1188
 
 
1189
    def __init__(self, filename):
 
1190
        BzrError.__init__(self)
 
1191
        self.filename = filename
 
1192
 
 
1193
 
 
1194
class MediumNotConnected(BzrError):
 
1195
 
 
1196
    _fmt = """The medium '%(medium)s' is not connected."""
 
1197
 
 
1198
    internal_error = True
 
1199
 
 
1200
    def __init__(self, medium):
 
1201
        self.medium = medium
 
1202
 
 
1203
 
 
1204
class MustUseDecorated(Exception):
 
1205
    
 
1206
    _fmt = """A decorating function has requested its original command be used."""
 
1207
    
 
1208
 
 
1209
class NoBundleFound(BzrError):
 
1210
 
 
1211
    _fmt = "No bundle was found in %(filename)s"
 
1212
 
 
1213
    def __init__(self, filename):
 
1214
        BzrError.__init__(self)
 
1215
        self.filename = filename
 
1216
 
 
1217
 
 
1218
class BundleNotSupported(BzrError):
 
1219
 
 
1220
    _fmt = "Unable to handle bundle version %(version)s: %(msg)s"
 
1221
 
 
1222
    def __init__(self, version, msg):
 
1223
        BzrError.__init__(self)
 
1224
        self.version = version
 
1225
        self.msg = msg
 
1226
 
 
1227
 
 
1228
class MissingText(BzrError):
 
1229
 
 
1230
    _fmt = "Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"
 
1231
 
 
1232
    def __init__(self, branch, text_revision, file_id):
 
1233
        BzrError.__init__(self)
 
1234
        self.branch = branch
 
1235
        self.base = branch.base
 
1236
        self.text_revision = text_revision
 
1237
        self.file_id = file_id
 
1238
 
 
1239
 
 
1240
class DuplicateKey(BzrError):
 
1241
 
 
1242
    _fmt = "Key %(key)s is already present in map"
 
1243
 
 
1244
 
 
1245
class MalformedTransform(BzrError):
 
1246
 
 
1247
    _fmt = "Tree transform is malformed %(conflicts)r"
 
1248
 
 
1249
 
 
1250
class NoFinalPath(BzrError):
 
1251
 
 
1252
    _fmt = ("No final name for trans_id %(trans_id)r\n"
 
1253
            "file-id: %(file_id)r\n"
 
1254
            "root trans-id: %(root_trans_id)r\n")
 
1255
 
 
1256
    def __init__(self, trans_id, transform):
 
1257
        self.trans_id = trans_id
 
1258
        self.file_id = transform.final_file_id(trans_id)
 
1259
        self.root_trans_id = transform.root
 
1260
 
 
1261
 
 
1262
class BzrBadParameter(BzrError):
 
1263
 
 
1264
    _fmt = "Bad parameter: %(param)r"
 
1265
 
 
1266
    # This exception should never be thrown, but it is a base class for all
 
1267
    # parameter-to-function errors.
 
1268
 
 
1269
    def __init__(self, param):
 
1270
        BzrError.__init__(self)
 
1271
        self.param = param
 
1272
 
 
1273
 
 
1274
class BzrBadParameterNotUnicode(BzrBadParameter):
 
1275
 
 
1276
    _fmt = "Parameter %(param)s is neither unicode nor utf8."
 
1277
 
 
1278
 
 
1279
class ReusingTransform(BzrError):
 
1280
 
 
1281
    _fmt = "Attempt to reuse a transform that has already been applied."
 
1282
 
 
1283
 
 
1284
class CantMoveRoot(BzrError):
 
1285
 
 
1286
    _fmt = "Moving the root directory is not supported at this time"
 
1287
 
 
1288
 
 
1289
class BzrBadParameterNotString(BzrBadParameter):
 
1290
 
 
1291
    _fmt = "Parameter %(param)s is not a string or unicode string."
 
1292
 
 
1293
 
 
1294
class BzrBadParameterMissing(BzrBadParameter):
 
1295
 
 
1296
    _fmt = "Parameter $(param)s is required but not present."
 
1297
 
 
1298
 
 
1299
class BzrBadParameterUnicode(BzrBadParameter):
 
1300
 
 
1301
    _fmt = "Parameter %(param)s is unicode but only byte-strings are permitted."
 
1302
 
 
1303
 
 
1304
class BzrBadParameterContainsNewline(BzrBadParameter):
 
1305
 
 
1306
    _fmt = "Parameter %(param)s contains a newline."
 
1307
 
 
1308
 
 
1309
class DependencyNotPresent(BzrError):
 
1310
 
 
1311
    _fmt = 'Unable to import library "%(library)s": %(error)s'
 
1312
 
 
1313
    def __init__(self, library, error):
 
1314
        BzrError.__init__(self, library=library, error=error)
 
1315
 
 
1316
 
 
1317
class ParamikoNotPresent(DependencyNotPresent):
 
1318
 
 
1319
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
 
1320
 
 
1321
    def __init__(self, error):
 
1322
        DependencyNotPresent.__init__(self, 'paramiko', error)
 
1323
 
 
1324
 
 
1325
class PointlessMerge(BzrError):
 
1326
 
 
1327
    _fmt = "Nothing to merge."
 
1328
 
 
1329
 
 
1330
class UninitializableFormat(BzrError):
 
1331
 
 
1332
    _fmt = "Format %(format)s cannot be initialised by this version of bzr."
 
1333
 
 
1334
    def __init__(self, format):
 
1335
        BzrError.__init__(self)
 
1336
        self.format = format
 
1337
 
 
1338
 
 
1339
class BadConversionTarget(BzrError):
 
1340
 
 
1341
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
 
1342
 
 
1343
    def __init__(self, problem, format):
 
1344
        BzrError.__init__(self)
 
1345
        self.problem = problem
 
1346
        self.format = format
 
1347
 
 
1348
 
 
1349
class NoDiff(BzrError):
 
1350
 
 
1351
    _fmt = "Diff is not installed on this machine: %(msg)s"
 
1352
 
 
1353
    def __init__(self, msg):
 
1354
        BzrError.__init__(self, msg=msg)
 
1355
 
 
1356
 
 
1357
class NoDiff3(BzrError):
 
1358
 
 
1359
    _fmt = "Diff3 is not installed on this machine."
 
1360
 
 
1361
 
 
1362
class ExistingLimbo(BzrError):
 
1363
 
 
1364
    _fmt = """This tree contains left-over files from a failed operation.
 
1365
    Please examine %(limbo_dir)s to see if it contains any files you wish to
 
1366
    keep, and delete it when you are done."""
 
1367
    
 
1368
    def __init__(self, limbo_dir):
 
1369
       BzrError.__init__(self)
 
1370
       self.limbo_dir = limbo_dir
 
1371
 
 
1372
 
 
1373
class ImmortalLimbo(BzrError):
 
1374
 
 
1375
    _fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
 
1376
    Please examine %(limbo_dir)s to see if it contains any files you wish to
 
1377
    keep, and delete it when you are done."""
 
1378
 
 
1379
    def __init__(self, limbo_dir):
 
1380
       BzrError.__init__(self)
 
1381
       self.limbo_dir = limbo_dir
 
1382
 
 
1383
 
 
1384
class OutOfDateTree(BzrError):
 
1385
 
 
1386
    _fmt = "Working tree is out of date, please run 'bzr update'."
 
1387
 
 
1388
    def __init__(self, tree):
 
1389
        BzrError.__init__(self)
 
1390
        self.tree = tree
 
1391
 
 
1392
 
 
1393
class MergeModifiedFormatError(BzrError):
 
1394
 
 
1395
    _fmt = "Error in merge modified format"
 
1396
 
 
1397
 
 
1398
class ConflictFormatError(BzrError):
 
1399
 
 
1400
    _fmt = "Format error in conflict listings"
 
1401
 
 
1402
 
 
1403
class CorruptRepository(BzrError):
 
1404
 
 
1405
    _fmt = """An error has been detected in the repository %(repo_path)s.
 
1406
Please run bzr reconcile on this repository."""
 
1407
 
 
1408
    def __init__(self, repo):
 
1409
        BzrError.__init__(self)
 
1410
        self.repo_path = repo.bzrdir.root_transport.base
 
1411
 
 
1412
 
 
1413
class UpgradeRequired(BzrError):
 
1414
 
 
1415
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
 
1416
 
 
1417
    def __init__(self, path):
 
1418
        BzrError.__init__(self)
 
1419
        self.path = path
 
1420
 
 
1421
 
 
1422
class LocalRequiresBoundBranch(BzrError):
 
1423
 
 
1424
    _fmt = "Cannot perform local-only commits on unbound branches."
 
1425
 
 
1426
 
 
1427
class MissingProgressBarFinish(BzrError):
 
1428
 
 
1429
    _fmt = "A nested progress bar was not 'finished' correctly."
 
1430
 
 
1431
 
 
1432
class InvalidProgressBarType(BzrError):
 
1433
 
 
1434
    _fmt = """Environment variable BZR_PROGRESS_BAR='%(bar_type)s is not a supported type
 
1435
Select one of: %(valid_types)s"""
 
1436
 
 
1437
    def __init__(self, bar_type, valid_types):
 
1438
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
 
1439
 
 
1440
 
 
1441
class UnsupportedOperation(BzrError):
 
1442
 
 
1443
    _fmt = "The method %(mname)s is not supported on objects of type %(tname)s."
 
1444
 
 
1445
    def __init__(self, method, method_self):
 
1446
        self.method = method
 
1447
        self.mname = method.__name__
 
1448
        self.tname = type(method_self).__name__
 
1449
 
 
1450
 
 
1451
class CannotSetRevisionId(UnsupportedOperation):
 
1452
    """Raised when a commit is attempting to set a revision id but cant."""
 
1453
 
 
1454
 
 
1455
class NonAsciiRevisionId(UnsupportedOperation):
 
1456
    """Raised when a commit is attempting to set a non-ascii revision id but cant."""
 
1457
 
 
1458
 
 
1459
class BinaryFile(BzrError):
 
1460
    
 
1461
    _fmt = "File is binary but should be text."
 
1462
 
 
1463
 
 
1464
class IllegalPath(BzrError):
 
1465
 
 
1466
    _fmt = "The path %(path)s is not permitted on this platform"
 
1467
 
 
1468
    def __init__(self, path):
 
1469
        BzrError.__init__(self)
 
1470
        self.path = path
 
1471
 
 
1472
 
 
1473
class TestamentMismatch(BzrError):
 
1474
 
 
1475
    _fmt = """Testament did not match expected value.  
 
1476
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured 
 
1477
       {%(measured)s}"""
 
1478
 
 
1479
    def __init__(self, revision_id, expected, measured):
 
1480
        self.revision_id = revision_id
 
1481
        self.expected = expected
 
1482
        self.measured = measured
 
1483
 
 
1484
 
 
1485
class NotABundle(BzrError):
 
1486
    
 
1487
    _fmt = "Not a bzr revision-bundle: %(text)r"
 
1488
 
 
1489
    def __init__(self, text):
 
1490
        BzrError.__init__(self)
 
1491
        self.text = text
 
1492
 
 
1493
 
 
1494
class BadBundle(BzrError): 
 
1495
    
 
1496
    _fmt = "Bad bzr revision-bundle: %(text)r"
 
1497
 
 
1498
    def __init__(self, text):
 
1499
        BzrError.__init__(self)
 
1500
        self.text = text
 
1501
 
 
1502
 
 
1503
class MalformedHeader(BadBundle): 
 
1504
    
 
1505
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
 
1506
 
 
1507
 
 
1508
class MalformedPatches(BadBundle): 
 
1509
    
 
1510
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
 
1511
 
 
1512
 
 
1513
class MalformedFooter(BadBundle): 
 
1514
    
 
1515
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
 
1516
 
 
1517
 
 
1518
class UnsupportedEOLMarker(BadBundle):
 
1519
    
 
1520
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
 
1521
 
 
1522
    def __init__(self):
 
1523
        # XXX: BadBundle's constructor assumes there's explanatory text, 
 
1524
        # but for this there is not
 
1525
        BzrError.__init__(self)
 
1526
 
 
1527
 
 
1528
class IncompatibleBundleFormat(BzrError):
 
1529
    
 
1530
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
 
1531
 
 
1532
    def __init__(self, bundle_format, other):
 
1533
        BzrError.__init__(self)
 
1534
        self.bundle_format = bundle_format
 
1535
        self.other = other
 
1536
 
 
1537
 
 
1538
class BadInventoryFormat(BzrError):
 
1539
    
 
1540
    _fmt = "Root class for inventory serialization errors"
 
1541
 
 
1542
 
 
1543
class UnexpectedInventoryFormat(BadInventoryFormat):
 
1544
 
 
1545
    _fmt = "The inventory was not in the expected format:\n %(msg)s"
 
1546
 
 
1547
    def __init__(self, msg):
 
1548
        BadInventoryFormat.__init__(self, msg=msg)
 
1549
 
 
1550
 
 
1551
class NoSmartMedium(BzrError):
 
1552
 
 
1553
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
 
1554
 
 
1555
    def __init__(self, transport):
 
1556
        self.transport = transport
 
1557
 
 
1558
 
 
1559
class NoSmartServer(NotBranchError):
 
1560
 
 
1561
    _fmt = "No smart server available at %(url)s"
 
1562
 
 
1563
    def __init__(self, url):
 
1564
        self.url = url
 
1565
 
 
1566
 
 
1567
class UnknownSSH(BzrError):
 
1568
 
 
1569
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
 
1570
 
 
1571
    def __init__(self, vendor):
 
1572
        BzrError.__init__(self)
 
1573
        self.vendor = vendor
 
1574
 
 
1575
 
 
1576
class GhostRevisionUnusableHere(BzrError):
 
1577
 
 
1578
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
 
1579
 
 
1580
    def __init__(self, revision_id):
 
1581
        BzrError.__init__(self)
 
1582
        self.revision_id = revision_id
 
1583
 
 
1584
 
 
1585
class IllegalUseOfScopeReplacer(BzrError):
 
1586
 
 
1587
    _fmt = "ScopeReplacer object %(name)r was used incorrectly: %(msg)s%(extra)s"
 
1588
 
 
1589
    internal_error = True
 
1590
 
 
1591
    def __init__(self, name, msg, extra=None):
 
1592
        BzrError.__init__(self)
 
1593
        self.name = name
 
1594
        self.msg = msg
 
1595
        if extra:
 
1596
            self.extra = ': ' + str(extra)
 
1597
        else:
 
1598
            self.extra = ''
 
1599
 
 
1600
 
 
1601
class InvalidImportLine(BzrError):
 
1602
 
 
1603
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
 
1604
 
 
1605
    internal_error = True
 
1606
 
 
1607
    def __init__(self, text, msg):
 
1608
        BzrError.__init__(self)
 
1609
        self.text = text
 
1610
        self.msg = msg
 
1611
 
 
1612
 
 
1613
class ImportNameCollision(BzrError):
 
1614
 
 
1615
    _fmt = "Tried to import an object to the same name as an existing object. %(name)s"
 
1616
 
 
1617
    internal_error = True
 
1618
 
 
1619
    def __init__(self, name):
 
1620
        BzrError.__init__(self)
 
1621
        self.name = name