~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Martin Pool
  • Date: 2006-06-15 05:36:34 UTC
  • mto: This revision was merged to the branch mainline in revision 1797.
  • Revision ID: mbp@sourcefrog.net-20060615053634-4fd52ba691855659
Clean up many exception classes.

Errors indicating a user error are now shown with is_user_error on the
exception; use this rather than hardcoding a list of exceptions that should be
handled this way.

Exceptions now inherit from BzrNewException where possible to use consistent
formatting method.

Remove rather obsolete docstring test on Branch.missing_revisions.

Remove dead code from find_merge_base.


Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#! /usr/bin/env python
2
 
# -*- coding: UTF-8 -*-
 
1
# Copyright (C) 2005, 2006 Canonical
3
2
 
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
15
14
# along with this program; if not, write to the Free Software
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
 
18
 
 
19
 
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
20
 
__author__ = "Martin Pool <mbp@canonical.com>"
21
 
 
22
 
 
23
 
######################################################################
24
 
# exceptions 
 
17
"""Exceptions for bzr, and reporting of them.
 
18
 
 
19
There are 3 different classes of error:
 
20
 
 
21
 * KeyboardInterrupt, and OSError with EPIPE - the program terminates 
 
22
   with an appropriate short message
 
23
 
 
24
 * User errors, indicating a problem caused by the user such as a bad URL.
 
25
   These are printed in a short form.
 
26
 
 
27
 * Internal unexpected errors, including most Python builtin errors
 
28
   and some raised from inside bzr.  These are printed with a full 
 
29
   traceback and an invitation to report the bug.
 
30
 
 
31
Exceptions are caught at a high level to report errors to the user, and
 
32
might also be caught inside the program.  Therefore it needs to be
 
33
possible to convert them to a meaningful string, and also for them to be
 
34
interrogated by the program.
 
35
 
 
36
Exceptions are defined such that the arguments given to the constructor
 
37
are stored in the object as properties of the same name.  When the
 
38
object is printed as a string, the doc string of the class is used as
 
39
a format string with the property dictionary available to it.
 
40
 
 
41
This means that exceptions can used like this:
 
42
 
 
43
>>> import sys
 
44
>>> try:
 
45
...   raise NotBranchError(path='/foo/bar')
 
46
... except:
 
47
...   print sys.exc_type
 
48
...   print sys.exc_value
 
49
...   path = getattr(sys.exc_value, 'path', None)
 
50
...   if path is not None:
 
51
...     print path
 
52
bzrlib.errors.NotBranchError
 
53
Not a branch: /foo/bar
 
54
/foo/bar
 
55
 
 
56
Therefore:
 
57
 
 
58
 * create a new exception class for any class of error that can be
 
59
   usefully distinguished.  If no callers are likely to want to catch
 
60
   one but not another, don't worry about them.
 
61
 
 
62
 * the __str__ method should generate something useful; BzrError provides
 
63
   a good default implementation
 
64
 
 
65
Exception strings should start with a capital letter and should not have a
 
66
final fullstop.
 
67
"""
 
68
 
 
69
from warnings import warn
 
70
 
 
71
from bzrlib.patches import (PatchSyntax, 
 
72
                            PatchConflict, 
 
73
                            MalformedPatchHeader,
 
74
                            MalformedHunkHeader,
 
75
                            MalformedLine,)
 
76
 
 
77
 
 
78
# based on Scott James Remnant's hct error classes
 
79
 
 
80
# TODO: is there any value in providing the .args field used by standard
 
81
# python exceptions?   A list of values with no names seems less useful 
 
82
# to me.
 
83
 
 
84
# TODO: Perhaps convert the exception to a string at the moment it's 
 
85
# constructed to make sure it will succeed.  But that says nothing about
 
86
# exceptions that are never raised.
 
87
 
 
88
# TODO: Convert all the other error classes here to BzrNewError, and eliminate
 
89
# the old one.
 
90
 
 
91
# TODO: The pattern (from hct) of using classes docstrings as message
 
92
# templates is cute but maybe not such a great idea - perhaps should have a
 
93
# separate static message_template.
 
94
 
 
95
 
25
96
class BzrError(StandardError):
26
 
    pass
27
 
 
28
 
class BzrCheckError(BzrError):
29
 
    pass
30
 
 
31
 
 
32
 
class BzrCommandError(BzrError):
 
97
    
 
98
    is_user_error = True
 
99
    
 
100
    def __str__(self):
 
101
        # XXX: Should we show the exception class in 
 
102
        # exceptions that don't provide their own message?  
 
103
        # maybe it should be done at a higher level
 
104
        ## n = self.__class__.__name__ + ': '
 
105
        n = ''
 
106
        if len(self.args) == 1:
 
107
            return str(self.args[0])
 
108
        elif len(self.args) == 2:
 
109
            # further explanation or suggestions
 
110
            try:
 
111
                return n + '\n  '.join([self.args[0]] + self.args[1])
 
112
            except TypeError:
 
113
                return n + "%r" % self
 
114
        else:
 
115
            return n + `self.args`
 
116
 
 
117
 
 
118
class BzrNewError(BzrError):
 
119
    """bzr error"""
 
120
    # base classes should override the docstring with their human-
 
121
    # readable explanation
 
122
 
 
123
    def __init__(self, **kwds):
 
124
        for key, value in kwds.items():
 
125
            setattr(self, key, value)
 
126
 
 
127
    def __str__(self):
 
128
        try:
 
129
            return self.__doc__ % self.__dict__
 
130
        except (NameError, ValueError, KeyError), e:
 
131
            return 'Unprintable exception %s: %s' \
 
132
                % (self.__class__.__name__, str(e))
 
133
 
 
134
 
 
135
class BzrCheckError(BzrNewError):
 
136
    """Internal check failed: %(message)s"""
 
137
 
 
138
    is_user_error = False
 
139
 
 
140
    def __init__(self, message):
 
141
        BzrNewError.__init__(self)
 
142
        self.message = message
 
143
 
 
144
 
 
145
class InvalidEntryName(BzrNewError):
 
146
    """Invalid entry name: %(name)s"""
 
147
 
 
148
    is_user_error = False
 
149
 
 
150
    def __init__(self, name):
 
151
        BzrNewError.__init__(self)
 
152
        self.name = name
 
153
 
 
154
 
 
155
class InvalidRevisionNumber(BzrNewError):
 
156
    """Invalid revision number %(revno)d"""
 
157
    def __init__(self, revno):
 
158
        BzrNewError.__init__(self)
 
159
        self.revno = revno
 
160
 
 
161
 
 
162
class InvalidRevisionId(BzrNewError):
 
163
    """Invalid revision-id {%(revision_id)s} in %(branch)s"""
 
164
    def __init__(self, revision_id, branch):
 
165
        # branch can be any string or object with __str__ defined
 
166
        BzrNewError.__init__(self)
 
167
        self.revision_id = revision_id
 
168
        self.branch = branch
 
169
 
 
170
 
 
171
class NoWorkingTree(BzrNewError):
 
172
    """No WorkingTree exists for %(base)s."""
 
173
    
 
174
    def __init__(self, base):
 
175
        BzrNewError.__init__(self)
 
176
        self.base = base
 
177
 
 
178
 
 
179
class NotLocalUrl(BzrNewError):
 
180
    """%(url)s is not a local path."""
 
181
    
 
182
    def __init__(self, url):
 
183
        BzrNewError.__init__(self)
 
184
        self.url = url
 
185
 
 
186
 
 
187
class BzrCommandError(BzrNewError):
 
188
    """Error from user command"""
 
189
    is_user_error = True
33
190
    # Error from malformed user command
34
 
    pass
35
 
 
36
 
 
37
 
def bailout(msg, explanation=[]):
38
 
    ex = BzrError(msg, explanation)
39
 
    import trace
40
 
    trace._tracefile.write('* raising %s\n' % ex)
41
 
    raise ex
42
 
 
 
191
    # This is being misused as a generic exception
 
192
    # pleae subclass. RBC 20051030
 
193
    #
 
194
    # I think it's a waste of effort to differentiate between errors that
 
195
    # are not intended to be caught anyway.  UI code need not subclass
 
196
    # BzrCommandError, and non-UI code should not throw a subclass of
 
197
    # BzrCommandError.  ADHB 20051211
 
198
    def __init__(self, msg):
 
199
        self.msg = msg
 
200
 
 
201
    def __str__(self):
 
202
        return self.msg
 
203
 
 
204
 
 
205
class StrictCommitFailed(BzrNewError):
 
206
    """Commit refused because there are unknowns in the tree."""
 
207
 
 
208
 
 
209
# XXX: Should be unified with TransportError; they seem to represent the
 
210
# same thing
 
211
class PathError(BzrNewError):
 
212
    """Generic path error: %(path)r%(extra)s)"""
 
213
 
 
214
    def __init__(self, path, extra=None):
 
215
        BzrNewError.__init__(self)
 
216
        self.path = path
 
217
        if extra:
 
218
            self.extra = ': ' + str(extra)
 
219
        else:
 
220
            self.extra = ''
 
221
 
 
222
 
 
223
class NoSuchFile(PathError):
 
224
    """No such file: %(path)s%(extra)s"""
 
225
 
 
226
 
 
227
class FileExists(PathError):
 
228
    """File exists: %(path)s%(extra)s"""
 
229
 
 
230
 
 
231
class DirectoryNotEmpty(PathError):
 
232
    """Directory not empty: %(path)s%(extra)s"""
 
233
 
 
234
 
 
235
class ResourceBusy(PathError):
 
236
    """Device or resource busy: %(path)s%(extra)s"""
 
237
 
 
238
 
 
239
class PermissionDenied(PathError):
 
240
    """Permission denied: %(path)s%(extra)s"""
 
241
 
 
242
 
 
243
class PathNotChild(BzrNewError):
 
244
    """Path %(path)s is not a child of path %(base)s%(extra)s"""
 
245
 
 
246
    is_user_error = False
 
247
 
 
248
    def __init__(self, path, base, extra=None):
 
249
        BzrNewError.__init__(self)
 
250
        self.path = path
 
251
        self.base = base
 
252
        if extra:
 
253
            self.extra = ': ' + str(extra)
 
254
        else:
 
255
            self.extra = ''
 
256
 
 
257
 
 
258
class NotBranchError(PathError):
 
259
    """Not a branch: %(path)s"""
 
260
 
 
261
 
 
262
class AlreadyBranchError(PathError):
 
263
    """Already a branch: %(path)s."""
 
264
 
 
265
 
 
266
class BranchExistsWithoutWorkingTree(PathError):
 
267
    """Directory contains a branch, but no working tree \
 
268
(use bzr checkout if you wish to build a working tree): %(path)s"""
 
269
 
 
270
 
 
271
class NoRepositoryPresent(BzrNewError):
 
272
    """No repository present: %(path)s"""
 
273
    def __init__(self, bzrdir):
 
274
        BzrNewError.__init__(self)
 
275
        self.path = bzrdir.transport.clone('..').base
 
276
 
 
277
 
 
278
class FileInWrongBranch(BzrNewError):
 
279
    """File %(path)s in not in branch %(branch_base)s."""
 
280
 
 
281
    def __init__(self, branch, path):
 
282
        BzrNewError.__init__(self)
 
283
        self.branch = branch
 
284
        self.branch_base = branch.base
 
285
        self.path = path
 
286
 
 
287
 
 
288
class UnsupportedFormatError(BzrNewError):
 
289
    """Unsupported branch format: %(format)s"""
 
290
 
 
291
 
 
292
class UnknownFormatError(BzrNewError):
 
293
    """Unknown branch format: %(format)s"""
 
294
 
 
295
 
 
296
class IncompatibleFormat(BzrNewError):
 
297
    """Format %(format)s is not compatible with .bzr version %(bzrdir)s."""
 
298
 
 
299
    def __init__(self, format, bzrdir_format):
 
300
        BzrNewError.__init__(self)
 
301
        self.format = format
 
302
        self.bzrdir = bzrdir_format
 
303
 
 
304
 
 
305
class NotVersionedError(BzrNewError):
 
306
    """%(path)s is not versioned"""
 
307
    def __init__(self, path):
 
308
        BzrNewError.__init__(self)
 
309
        self.path = path
 
310
 
 
311
 
 
312
class PathsNotVersionedError(BzrNewError):
 
313
    # used when reporting several paths are not versioned
 
314
    """Path(s) are not versioned: %(paths_as_string)s"""
 
315
 
 
316
    def __init__(self, paths):
 
317
        from bzrlib.osutils import quotefn
 
318
        BzrNewError.__init__(self)
 
319
        self.paths = paths
 
320
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
 
321
 
 
322
 
 
323
class PathsDoNotExist(BzrNewError):
 
324
    """Path(s) do not exist: %(paths_as_string)s"""
 
325
 
 
326
    # used when reporting that paths are neither versioned nor in the working
 
327
    # tree
 
328
 
 
329
    def __init__(self, paths):
 
330
        # circular import
 
331
        from bzrlib.osutils import quotefn
 
332
        BzrNewError.__init__(self)
 
333
        self.paths = paths
 
334
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
 
335
 
 
336
 
 
337
class BadFileKindError(BzrError):
 
338
    """Specified file is of a kind that cannot be added.
 
339
 
 
340
    (For example a symlink or device file.)"""
 
341
 
 
342
 
 
343
class ForbiddenFileError(BzrError):
 
344
    """Cannot operate on a file because it is a control file."""
 
345
 
 
346
 
 
347
class LockError(BzrNewError):
 
348
    """Lock error: %(message)s"""
 
349
    # All exceptions from the lock/unlock functions should be from
 
350
    # this exception class.  They will be translated as necessary. The
 
351
    # original exception is available as e.original_error
 
352
    #
 
353
    # New code should prefer to raise specific subclasses
 
354
    def __init__(self, message):
 
355
        self.message = message
 
356
 
 
357
 
 
358
class CommitNotPossible(LockError):
 
359
    """A commit was attempted but we do not have a write lock open."""
 
360
    def __init__(self):
 
361
        pass
 
362
 
 
363
 
 
364
class AlreadyCommitted(LockError):
 
365
    """A rollback was requested, but is not able to be accomplished."""
 
366
    def __init__(self):
 
367
        pass
 
368
 
 
369
 
 
370
class ReadOnlyError(LockError):
 
371
    """A write attempt was made in a read only transaction on %(obj)s"""
 
372
    def __init__(self, obj):
 
373
        self.obj = obj
 
374
 
 
375
 
 
376
class OutSideTransaction(BzrNewError):
 
377
    """A transaction related operation was attempted after the transaction finished."""
 
378
 
 
379
 
 
380
class ObjectNotLocked(LockError):
 
381
    """%(obj)s is not locked"""
 
382
    is_user_error = False
 
383
    # this can indicate that any particular object is not locked; see also
 
384
    # LockNotHeld which means that a particular *lock* object is not held by
 
385
    # the caller -- perhaps they should be unified.
 
386
    def __init__(self, obj):
 
387
        self.obj = obj
 
388
 
 
389
 
 
390
class ReadOnlyObjectDirtiedError(ReadOnlyError):
 
391
    """Cannot change object %(obj)s in read only transaction"""
 
392
    def __init__(self, obj):
 
393
        self.obj = obj
 
394
 
 
395
 
 
396
class UnlockableTransport(LockError):
 
397
    """Cannot lock: transport is read only: %(transport)s"""
 
398
    def __init__(self, transport):
 
399
        self.transport = transport
 
400
 
 
401
 
 
402
class LockContention(LockError):
 
403
    """Could not acquire lock %(lock)s"""
 
404
    # TODO: show full url for lock, combining the transport and relative bits?
 
405
    def __init__(self, lock):
 
406
        self.lock = lock
 
407
 
 
408
 
 
409
class LockBroken(LockError):
 
410
    """Lock was broken while still open: %(lock)s - check storage consistency!"""
 
411
    def __init__(self, lock):
 
412
        self.lock = lock
 
413
 
 
414
 
 
415
class LockBreakMismatch(LockError):
 
416
    """Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)s, wanted to break %(target)r"""
 
417
    def __init__(self, lock, holder, target):
 
418
        self.lock = lock
 
419
        self.holder = holder
 
420
        self.target = target
 
421
 
 
422
 
 
423
class LockNotHeld(LockError):
 
424
    """Lock not held: %(lock)s"""
 
425
    def __init__(self, lock):
 
426
        self.lock = lock
 
427
 
 
428
 
 
429
class PointlessCommit(BzrNewError):
 
430
    """No changes to commit"""
 
431
 
 
432
 
 
433
class UpgradeReadonly(BzrNewError):
 
434
    """Upgrade URL cannot work with readonly URL's."""
 
435
 
 
436
 
 
437
class UpToDateFormat(BzrNewError):
 
438
    """The branch format %(format)s is already at the most recent format."""
 
439
 
 
440
    def __init__(self, format):
 
441
        BzrNewError.__init__(self)
 
442
        self.format = format
 
443
 
 
444
 
 
445
 
 
446
class StrictCommitFailed(Exception):
 
447
    """Commit refused because there are unknowns in the tree."""
 
448
 
 
449
 
 
450
class NoSuchRevision(BzrNewError):
 
451
    """Branch %(branch)s has no revision %(revision)s"""
 
452
 
 
453
    is_user_error = False
 
454
 
 
455
    def __init__(self, branch, revision):
 
456
        self.branch = branch
 
457
        self.revision = revision
 
458
 
 
459
 
 
460
class DivergedBranches(BzrNewError):
 
461
    "These branches have diverged.  Use the merge command to reconcile them."""
 
462
 
 
463
    is_user_error = True
 
464
 
 
465
    def __init__(self, branch1, branch2):
 
466
        self.branch1 = branch1
 
467
        self.branch2 = branch2
 
468
 
 
469
 
 
470
class UnrelatedBranches(BzrNewError):
 
471
    "Branches have no common ancestor, and no merge base revision was specified."
 
472
 
 
473
    is_user_error = True
 
474
 
 
475
 
 
476
class NoCommonAncestor(BzrNewError):
 
477
    "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
 
478
 
 
479
    def __init__(self, revision_a, revision_b):
 
480
        self.revision_a = revision_a
 
481
        self.revision_b = revision_b
 
482
 
 
483
 
 
484
class NoCommonRoot(BzrError):
 
485
    def __init__(self, revision_a, revision_b):
 
486
        msg = "Revisions are not derived from the same root: %s %s." \
 
487
            % (revision_a, revision_b) 
 
488
        BzrError.__init__(self, msg)
 
489
 
 
490
 
 
491
 
 
492
class NotAncestor(BzrError):
 
493
    def __init__(self, rev_id, not_ancestor_id):
 
494
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
 
495
                                                        rev_id)
 
496
        BzrError.__init__(self, msg)
 
497
        self.rev_id = rev_id
 
498
        self.not_ancestor_id = not_ancestor_id
 
499
 
 
500
 
 
501
class InstallFailed(BzrError):
 
502
    def __init__(self, revisions):
 
503
        msg = "Could not install revisions:\n%s" % " ,".join(revisions)
 
504
        BzrError.__init__(self, msg)
 
505
        self.revisions = revisions
 
506
 
 
507
 
 
508
class AmbiguousBase(BzrError):
 
509
    def __init__(self, bases):
 
510
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
 
511
                DeprecationWarning)
 
512
        msg = "The correct base is unclear, becase %s are all equally close" %\
 
513
            ", ".join(bases)
 
514
        BzrError.__init__(self, msg)
 
515
        self.bases = bases
 
516
 
 
517
 
 
518
class NoCommits(BzrError):
 
519
    def __init__(self, branch):
 
520
        msg = "Branch %s has no commits." % branch
 
521
        BzrError.__init__(self, msg)
 
522
 
 
523
 
 
524
class UnlistableStore(BzrError):
 
525
    def __init__(self, store):
 
526
        BzrError.__init__(self, "Store %s is not listable" % store)
 
527
 
 
528
 
 
529
 
 
530
class UnlistableBranch(BzrError):
 
531
    def __init__(self, br):
 
532
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
 
533
 
 
534
 
 
535
class BoundBranchOutOfDate(BzrNewError):
 
536
    """Bound branch %(branch)s is out of date with master branch %(master)s."""
 
537
    def __init__(self, branch, master):
 
538
        BzrNewError.__init__(self)
 
539
        self.branch = branch
 
540
        self.master = master
 
541
 
 
542
        
 
543
class CommitToDoubleBoundBranch(BzrNewError):
 
544
    """Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."""
 
545
    def __init__(self, branch, master, remote):
 
546
        BzrNewError.__init__(self)
 
547
        self.branch = branch
 
548
        self.master = master
 
549
        self.remote = remote
 
550
 
 
551
 
 
552
class OverwriteBoundBranch(BzrNewError):
 
553
    """Cannot pull --overwrite to a branch which is bound %(branch)s"""
 
554
    def __init__(self, branch):
 
555
        BzrNewError.__init__(self)
 
556
        self.branch = branch
 
557
 
 
558
 
 
559
class BoundBranchConnectionFailure(BzrNewError):
 
560
    """Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"""
 
561
    def __init__(self, branch, target, error):
 
562
        BzrNewError.__init__(self)
 
563
        self.branch = branch
 
564
        self.target = target
 
565
        self.error = error
 
566
 
 
567
 
 
568
class WeaveError(BzrNewError):
 
569
    """Error in processing weave: %(message)s"""
 
570
 
 
571
    def __init__(self, message=None):
 
572
        BzrNewError.__init__(self)
 
573
        self.message = message
 
574
 
 
575
 
 
576
class WeaveRevisionAlreadyPresent(WeaveError):
 
577
    """Revision {%(revision_id)s} already present in %(weave)s"""
 
578
    def __init__(self, revision_id, weave):
 
579
 
 
580
        WeaveError.__init__(self)
 
581
        self.revision_id = revision_id
 
582
        self.weave = weave
 
583
 
 
584
 
 
585
class WeaveRevisionNotPresent(WeaveError):
 
586
    """Revision {%(revision_id)s} not present in %(weave)s"""
 
587
 
 
588
    def __init__(self, revision_id, weave):
 
589
        WeaveError.__init__(self)
 
590
        self.revision_id = revision_id
 
591
        self.weave = weave
 
592
 
 
593
 
 
594
class WeaveFormatError(WeaveError):
 
595
    """Weave invariant violated: %(what)s"""
 
596
 
 
597
    def __init__(self, what):
 
598
        WeaveError.__init__(self)
 
599
        self.what = what
 
600
 
 
601
 
 
602
class WeaveParentMismatch(WeaveError):
 
603
    """Parents are mismatched between two revisions."""
 
604
    
 
605
 
 
606
class WeaveInvalidChecksum(WeaveError):
 
607
    """Text did not match it's checksum: %(message)s"""
 
608
 
 
609
 
 
610
class WeaveTextDiffers(WeaveError):
 
611
    """Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
 
612
 
 
613
    def __init__(self, revision_id, weave_a, weave_b):
 
614
        WeaveError.__init__(self)
 
615
        self.revision_id = revision_id
 
616
        self.weave_a = weave_a
 
617
        self.weave_b = weave_b
 
618
 
 
619
 
 
620
class WeaveTextDiffers(WeaveError):
 
621
    """Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
 
622
 
 
623
    def __init__(self, revision_id, weave_a, weave_b):
 
624
        WeaveError.__init__(self)
 
625
        self.revision_id = revision_id
 
626
        self.weave_a = weave_a
 
627
        self.weave_b = weave_b
 
628
 
 
629
 
 
630
class VersionedFileError(BzrNewError):
 
631
    """Versioned file error."""
 
632
 
 
633
 
 
634
class RevisionNotPresent(VersionedFileError):
 
635
    """Revision {%(revision_id)s} not present in %(file_id)s."""
 
636
 
 
637
    def __init__(self, revision_id, file_id):
 
638
        VersionedFileError.__init__(self)
 
639
        self.revision_id = revision_id
 
640
        self.file_id = file_id
 
641
 
 
642
 
 
643
class RevisionAlreadyPresent(VersionedFileError):
 
644
    """Revision {%(revision_id)s} already present in %(file_id)s."""
 
645
 
 
646
    def __init__(self, revision_id, file_id):
 
647
        VersionedFileError.__init__(self)
 
648
        self.revision_id = revision_id
 
649
        self.file_id = file_id
 
650
 
 
651
 
 
652
class KnitError(BzrNewError):
 
653
    """Knit error"""
 
654
 
 
655
 
 
656
class KnitHeaderError(KnitError):
 
657
    """Knit header error: %(badline)r unexpected"""
 
658
 
 
659
    def __init__(self, badline):
 
660
        KnitError.__init__(self)
 
661
        self.badline = badline
 
662
 
 
663
 
 
664
class KnitCorrupt(KnitError):
 
665
    """Knit %(filename)s corrupt: %(how)s"""
 
666
 
 
667
    def __init__(self, filename, how):
 
668
        KnitError.__init__(self)
 
669
        self.filename = filename
 
670
        self.how = how
 
671
 
 
672
 
 
673
class NoSuchExportFormat(BzrNewError):
 
674
    """Export format %(format)r not supported"""
 
675
    def __init__(self, format):
 
676
        BzrNewError.__init__(self)
 
677
        self.format = format
 
678
 
 
679
 
 
680
class TransportError(BzrError):
 
681
    """All errors thrown by Transport implementations should derive
 
682
    from this class.
 
683
    """
 
684
    def __init__(self, msg=None, orig_error=None):
 
685
        if msg is None and orig_error is not None:
 
686
            msg = str(orig_error)
 
687
        BzrError.__init__(self, msg)
 
688
        self.msg = msg
 
689
        self.orig_error = orig_error
 
690
 
 
691
 
 
692
# A set of semi-meaningful errors which can be thrown
 
693
class TransportNotPossible(TransportError):
 
694
    """This is for transports where a specific function is explicitly not
 
695
    possible. Such as pushing files to an HTTP server.
 
696
    """
 
697
    pass
 
698
 
 
699
 
 
700
class ConnectionError(TransportError):
 
701
    """A connection problem prevents file retrieval.
 
702
    This does not indicate whether the file exists or not; it indicates that a
 
703
    precondition for requesting the file was not met.
 
704
    """
 
705
    def __init__(self, msg=None, orig_error=None):
 
706
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
 
707
 
 
708
 
 
709
class ConnectionReset(TransportError):
 
710
    """The connection has been closed."""
 
711
    pass
 
712
 
 
713
 
 
714
class ConflictsInTree(BzrError):
 
715
    def __init__(self):
 
716
        BzrError.__init__(self, "Working tree has conflicts.")
 
717
 
 
718
 
 
719
class ParseConfigError(BzrError):
 
720
    def __init__(self, errors, filename):
 
721
        if filename is None:
 
722
            filename = ""
 
723
        message = "Error(s) parsing config file %s:\n%s" % \
 
724
            (filename, ('\n'.join(e.message for e in errors)))
 
725
        BzrError.__init__(self, message)
 
726
 
 
727
 
 
728
class SigningFailed(BzrError):
 
729
    def __init__(self, command_line):
 
730
        BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
 
731
                               % command_line)
 
732
 
 
733
 
 
734
class WorkingTreeNotRevision(BzrError):
 
735
    def __init__(self, tree):
 
736
        BzrError.__init__(self, "The working tree for %s has changed since"
 
737
                          " last commit, but weave merge requires that it be"
 
738
                          " unchanged." % tree.basedir)
 
739
 
 
740
 
 
741
class CantReprocessAndShowBase(BzrNewError):
 
742
    """Can't reprocess and show base.
 
743
Reprocessing obscures relationship of conflicting lines to base."""
 
744
 
 
745
 
 
746
class GraphCycleError(BzrNewError):
 
747
    """Cycle in graph %(graph)r"""
 
748
    def __init__(self, graph):
 
749
        BzrNewError.__init__(self)
 
750
        self.graph = graph
 
751
 
 
752
 
 
753
class NotConflicted(BzrNewError):
 
754
    """File %(filename)s is not conflicted."""
 
755
 
 
756
    def __init__(self, filename):
 
757
        BzrNewError.__init__(self)
 
758
        self.filename = filename
 
759
 
 
760
 
 
761
class MustUseDecorated(Exception):
 
762
    """A decorating function has requested its original command be used.
 
763
    
 
764
    This should never escape bzr, so does not need to be printable.
 
765
    """
 
766
 
 
767
 
 
768
class NoBundleFound(BzrNewError):
 
769
    """No bundle was found in %(filename)s"""
 
770
    def __init__(self, filename):
 
771
        BzrNewError.__init__(self)
 
772
        self.filename = filename
 
773
 
 
774
 
 
775
class BundleNotSupported(BzrNewError):
 
776
    """Unable to handle bundle version %(version)s: %(msg)s"""
 
777
    def __init__(self, version, msg):
 
778
        BzrNewError.__init__(self)
 
779
        self.version = version
 
780
        self.msg = msg
 
781
 
 
782
 
 
783
class MissingText(BzrNewError):
 
784
    """Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
 
785
 
 
786
    def __init__(self, branch, text_revision, file_id):
 
787
        BzrNewError.__init__(self)
 
788
        self.branch = branch
 
789
        self.base = branch.base
 
790
        self.text_revision = text_revision
 
791
        self.file_id = file_id
 
792
 
 
793
 
 
794
class DuplicateKey(BzrNewError):
 
795
    """Key %(key)s is already present in map"""
 
796
 
 
797
 
 
798
class MalformedTransform(BzrNewError):
 
799
    """Tree transform is malformed %(conflicts)r"""
 
800
 
 
801
 
 
802
class BzrBadParameter(BzrNewError):
 
803
    """A bad parameter : %(param)s is not usable.
 
804
    
 
805
    This exception should never be thrown, but it is a base class for all
 
806
    parameter-to-function errors.
 
807
    """
 
808
    def __init__(self, param):
 
809
        BzrNewError.__init__(self)
 
810
        self.param = param
 
811
 
 
812
 
 
813
class BzrBadParameterNotUnicode(BzrBadParameter):
 
814
    """Parameter %(param)s is neither unicode nor utf8."""
 
815
 
 
816
 
 
817
class ReusingTransform(BzrNewError):
 
818
    """Attempt to reuse a transform that has already been applied."""
 
819
 
 
820
 
 
821
class CantMoveRoot(BzrNewError):
 
822
    """Moving the root directory is not supported at this time"""
 
823
 
 
824
 
 
825
class BzrBadParameterNotString(BzrBadParameter):
 
826
    """Parameter %(param)s is not a string or unicode string."""
 
827
 
 
828
 
 
829
class BzrBadParameterMissing(BzrBadParameter):
 
830
    """Parameter $(param)s is required but not present."""
 
831
 
 
832
 
 
833
class BzrBadParameterUnicode(BzrBadParameter):
 
834
    """Parameter %(param)s is unicode but only byte-strings are permitted."""
 
835
 
 
836
 
 
837
class BzrBadParameterContainsNewline(BzrBadParameter):
 
838
    """Parameter %(param)s contains a newline."""
 
839
 
 
840
 
 
841
class DependencyNotPresent(BzrNewError):
 
842
    """Unable to import library "%(library)s": %(error)s"""
 
843
 
 
844
    def __init__(self, library, error):
 
845
        BzrNewError.__init__(self, library=library, error=error)
 
846
 
 
847
 
 
848
class ParamikoNotPresent(DependencyNotPresent):
 
849
    """Unable to import paramiko (required for sftp support): %(error)s"""
 
850
 
 
851
    def __init__(self, error):
 
852
        DependencyNotPresent.__init__(self, 'paramiko', error)
 
853
 
 
854
 
 
855
class UninitializableFormat(BzrNewError):
 
856
    """Format %(format)s cannot be initialised by this version of bzr."""
 
857
 
 
858
    def __init__(self, format):
 
859
        BzrNewError.__init__(self)
 
860
        self.format = format
 
861
 
 
862
 
 
863
class NoDiff3(BzrNewError):
 
864
    """Diff3 is not installed on this machine."""
 
865
 
 
866
 
 
867
class ExistingLimbo(BzrNewError):
 
868
    """This tree contains left-over files from a failed operation.
 
869
    Please examine %(limbo_dir)s to see if it contains any files you wish to
 
870
    keep, and delete it when you are done.
 
871
    """
 
872
    def __init__(self, limbo_dir):
 
873
       BzrNewError.__init__(self)
 
874
       self.limbo_dir = limbo_dir
 
875
 
 
876
 
 
877
class ImmortalLimbo(BzrNewError):
 
878
    """Unable to delete transform temporary directory $(limbo_dir)s.
 
879
    Please examine %(limbo_dir)s to see if it contains any files you wish to
 
880
    keep, and delete it when you are done.
 
881
    """
 
882
    def __init__(self, limbo_dir):
 
883
       BzrNewError.__init__(self)
 
884
       self.limbo_dir = limbo_dir
 
885
 
 
886
 
 
887
class OutOfDateTree(BzrNewError):
 
888
    """Working tree is out of date, please run 'bzr update'."""
 
889
 
 
890
    def __init__(self, tree):
 
891
        BzrNewError.__init__(self)
 
892
        self.tree = tree
 
893
 
 
894
 
 
895
class MergeModifiedFormatError(BzrNewError):
 
896
    """Error in merge modified format"""
 
897
 
 
898
 
 
899
class ConflictFormatError(BzrNewError):
 
900
    """Format error in conflict listings"""
 
901
 
 
902
 
 
903
class CorruptRepository(BzrNewError):
 
904
    """An error has been detected in the repository %(repo_path)s.
 
905
Please run bzr reconcile on this repository."""
 
906
 
 
907
    def __init__(self, repo):
 
908
        BzrNewError.__init__(self)
 
909
        self.repo_path = repo.bzrdir.root_transport.base
 
910
 
 
911
 
 
912
class UpgradeRequired(BzrNewError):
 
913
    """To use this feature you must upgrade your branch at %(path)s."""
 
914
 
 
915
    def __init__(self, path):
 
916
        BzrNewError.__init__(self)
 
917
        self.path = path
 
918
 
 
919
 
 
920
class LocalRequiresBoundBranch(BzrNewError):
 
921
    """Cannot perform local-only commits on unbound branches."""
 
922
 
 
923
 
 
924
class MissingProgressBarFinish(BzrNewError):
 
925
    """A nested progress bar was not 'finished' correctly."""
 
926
 
 
927
 
 
928
class UnsupportedOperation(BzrNewError):
 
929
    """The method %(mname)s is not supported on objects of type %(tname)s."""
 
930
    def __init__(self, method, method_self):
 
931
        self.method = method
 
932
        self.mname = method.__name__
 
933
        self.tname = type(method_self).__name__
 
934
 
 
935
 
 
936
class BinaryFile(BzrNewError):
 
937
    """File is binary but should be text."""
 
938
 
 
939
 
 
940
class IllegalPath(BzrNewError):
 
941
    """The path %(path)s is not permitted on this platform"""
 
942
 
 
943
    def __init__(self, path):
 
944
        BzrNewError.__init__(self)
 
945
        self.path = path
 
946
 
 
947
 
 
948
class TestamentMismatch(BzrNewError):
 
949
    """Testament did not match expected value.  
 
950
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured 
 
951
       {%(measured)s}
 
952
    """
 
953
    def __init__(self, revision_id, expected, measured):
 
954
        self.revision_id = revision_id
 
955
        self.expected = expected
 
956
        self.measured = measured
 
957
 
 
958
 
 
959
class BadBundle(Exception): pass
 
960
 
 
961
 
 
962
class MalformedHeader(BadBundle): pass
 
963
 
 
964
 
 
965
class MalformedPatches(BadBundle): pass
 
966
 
 
967
 
 
968
class MalformedFooter(BadBundle): pass