~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

News entries for recent merge from John.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Canonical
2
 
#
 
1
# (C) 2005 Canonical
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Exceptions for bzr, and reporting of them.
18
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
19
Exceptions are caught at a high level to report errors to the user, and
32
20
might also be caught inside the program.  Therefore it needs to be
33
21
possible to convert them to a meaningful string, and also for them to be
44
32
>>> try:
45
33
...   raise NotBranchError(path='/foo/bar')
46
34
... except:
47
 
...   print '%s.%s' % (sys.exc_type.__module__, sys.exc_type.__name__)
 
35
...   print sys.exc_type
48
36
...   print sys.exc_value
49
 
...   path = getattr(sys.exc_value, 'path', None)
50
 
...   if path is not None:
51
 
...     print path
 
37
...   print sys.exc_value.path
52
38
bzrlib.errors.NotBranchError
53
39
Not a branch: /foo/bar
54
40
/foo/bar
56
42
Therefore:
57
43
 
58
44
 * 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.
 
45
   usefully distinguished.
 
46
 
 
47
 * the printable form of an exception is generated by the base class
 
48
   __str__ method
 
49
 
 
50
Exception strings should start with a capital letter and not have a final
 
51
fullstop.
67
52
"""
68
53
 
69
 
from warnings import warn
70
 
 
71
 
from bzrlib.patches import (PatchSyntax, 
72
 
                            PatchConflict, 
73
 
                            MalformedPatchHeader,
74
 
                            MalformedHunkHeader,
75
 
                            MalformedLine,)
76
 
 
77
 
 
78
54
# based on Scott James Remnant's hct error classes
79
55
 
80
56
# TODO: is there any value in providing the .args field used by standard
88
64
# TODO: Convert all the other error classes here to BzrNewError, and eliminate
89
65
# the old one.
90
66
 
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
67
 
96
68
class BzrError(StandardError):
97
 
    
98
 
    is_user_error = True
99
 
 
100
69
    def __str__(self):
101
70
        # XXX: Should we show the exception class in 
102
71
        # exceptions that don't provide their own message?  
120
89
    # base classes should override the docstring with their human-
121
90
    # readable explanation
122
91
 
123
 
    def __init__(self, *args, **kwds):
124
 
        # XXX: Use the underlying BzrError to always generate the args attribute
125
 
        # if it doesn't exist.  We can't use super here, because exceptions are
126
 
        # old-style classes in python2.4 (but new in 2.5).  --bmc, 20060426
127
 
        BzrError.__init__(self, *args)
 
92
    def __init__(self, **kwds):
128
93
        for key, value in kwds.items():
129
94
            setattr(self, key, value)
130
95
 
131
96
    def __str__(self):
132
97
        try:
133
 
            # __str__() should always return a 'str' object
134
 
            # never a 'unicode' object.
135
 
            s = self.__doc__ % self.__dict__
136
 
            if isinstance(s, unicode):
137
 
                return s.encode('utf8')
138
 
            return s
139
 
        except (TypeError, NameError, ValueError, KeyError), e:
140
 
            return 'Unprintable exception %s(%r): %s' \
141
 
                % (self.__class__.__name__,
142
 
                   self.__dict__, str(e))
143
 
 
144
 
 
145
 
class AlreadyBuilding(BzrNewError):
146
 
    """The tree builder is already building a tree."""
 
98
            return self.__doc__ % self.__dict__
 
99
        except (NameError, ValueError, KeyError), e:
 
100
            return 'Unprintable exception %s: %s' \
 
101
                % (self.__class__.__name__, str(e))
147
102
 
148
103
 
149
104
class BzrCheckError(BzrNewError):
150
105
    """Internal check failed: %(message)s"""
151
 
 
152
 
    is_user_error = False
153
 
 
154
106
    def __init__(self, message):
155
107
        BzrNewError.__init__(self)
156
108
        self.message = message
158
110
 
159
111
class InvalidEntryName(BzrNewError):
160
112
    """Invalid entry name: %(name)s"""
161
 
 
162
 
    is_user_error = False
163
 
 
164
113
    def __init__(self, name):
165
114
        BzrNewError.__init__(self)
166
115
        self.name = name
175
124
 
176
125
class InvalidRevisionId(BzrNewError):
177
126
    """Invalid revision-id {%(revision_id)s} in %(branch)s"""
178
 
 
179
127
    def __init__(self, revision_id, branch):
180
 
        # branch can be any string or object with __str__ defined
181
128
        BzrNewError.__init__(self)
182
129
        self.revision_id = revision_id
183
130
        self.branch = branch
184
131
 
185
132
 
186
 
class NoSuchId(BzrNewError):
187
 
    """The file id %(file_id)s is not present in the tree %(tree)s."""
188
 
    
189
 
    def __init__(self, tree, file_id):
190
 
        BzrNewError.__init__(self)
191
 
        self.file_id = file_id
192
 
        self.tree = tree
193
 
 
194
 
 
195
133
class NoWorkingTree(BzrNewError):
196
 
    """No WorkingTree exists for %(base)s."""
 
134
    """No WorkingTree exists for %s(base)."""
197
135
    
198
136
    def __init__(self, base):
199
137
        BzrNewError.__init__(self)
200
138
        self.base = base
201
139
 
202
140
 
203
 
class NotBuilding(BzrNewError):
204
 
    """Not currently building a tree."""
205
 
 
206
 
 
207
 
class NotLocalUrl(BzrNewError):
208
 
    """%(url)s is not a local path."""
209
 
    
210
 
    def __init__(self, url):
211
 
        BzrNewError.__init__(self)
212
 
        self.url = url
213
 
 
214
 
 
215
 
class BzrCommandError(BzrNewError):
216
 
    """Error from user command"""
217
 
 
218
 
    is_user_error = True
219
 
 
220
 
    # Error from malformed user command; please avoid raising this as a
221
 
    # generic exception not caused by user input.
222
 
    #
223
 
    # I think it's a waste of effort to differentiate between errors that
224
 
    # are not intended to be caught anyway.  UI code need not subclass
225
 
    # BzrCommandError, and non-UI code should not throw a subclass of
226
 
    # BzrCommandError.  ADHB 20051211
227
 
    def __init__(self, msg):
228
 
        # Object.__str__() must return a real string
229
 
        # returning a Unicode string is a python error.
230
 
        if isinstance(msg, unicode):
231
 
            self.msg = msg.encode('utf8')
232
 
        else:
233
 
            self.msg = msg
234
 
 
 
141
class BzrCommandError(BzrError):
 
142
    # Error from malformed user command
 
143
    # This is being misused as a generic exception
 
144
    # pleae subclass. RBC 20051030
235
145
    def __str__(self):
236
 
        return self.msg
 
146
        return self.args[0]
237
147
 
238
148
 
239
149
class BzrOptionError(BzrCommandError):
240
 
    """Error in command line options"""
 
150
    """Some missing or otherwise incorrect option was supplied."""
241
151
 
242
152
    
243
 
class StrictCommitFailed(BzrNewError):
244
 
    """Commit refused because there are unknown files in the tree"""
245
 
 
246
 
 
247
 
# XXX: Should be unified with TransportError; they seem to represent the
248
 
# same thing
 
153
class StrictCommitFailed(Exception):
 
154
    """Commit refused because there are unknowns in the tree."""
 
155
 
 
156
 
249
157
class PathError(BzrNewError):
250
158
    """Generic path error: %(path)r%(extra)s)"""
251
 
 
252
159
    def __init__(self, path, extra=None):
253
160
        BzrNewError.__init__(self)
254
161
        self.path = path
266
173
    """File exists: %(path)r%(extra)s"""
267
174
 
268
175
 
269
 
class DirectoryNotEmpty(PathError):
270
 
    """Directory not empty: %(path)r%(extra)s"""
271
 
 
272
 
 
273
 
class ResourceBusy(PathError):
274
 
    """Device or resource busy: %(path)r%(extra)s"""
275
 
 
276
 
 
277
176
class PermissionDenied(PathError):
278
177
    """Permission denied: %(path)r%(extra)s"""
279
178
 
280
179
 
281
 
class InvalidURL(PathError):
282
 
    """Invalid url supplied to transport: %(path)r%(extra)s"""
283
 
 
284
 
 
285
 
class InvalidURLJoin(PathError):
286
 
    """Invalid URL join request: %(args)s%(extra)s"""
287
 
 
288
 
    def __init__(self, msg, base, args):
289
 
        PathError.__init__(self, base, msg)
290
 
        self.args = [base] + list(args)
291
 
 
292
 
 
293
 
class UnsupportedProtocol(PathError):
294
 
    """Unsupported protocol for url "%(path)s"%(extra)s"""
295
 
 
296
 
    def __init__(self, url, extra):
297
 
        PathError.__init__(self, url, extra=extra)
298
 
 
299
 
 
300
 
class ShortReadvError(PathError):
301
 
    """readv() read %(actual)s bytes rather than %(length)s bytes at %(offset)s for %(path)s%(extra)s"""
302
 
 
303
 
    is_user_error = False
304
 
 
305
 
    def __init__(self, path, offset, length, actual, extra=None):
306
 
        PathError.__init__(self, path, extra=extra)
307
 
        self.offset = offset
308
 
        self.length = length
309
 
        self.actual = actual
310
 
 
311
 
 
312
180
class PathNotChild(BzrNewError):
313
181
    """Path %(path)r is not a child of path %(base)r%(extra)s"""
314
 
 
315
 
    is_user_error = False
316
 
 
317
182
    def __init__(self, path, base, extra=None):
318
183
        BzrNewError.__init__(self)
319
184
        self.path = path
324
189
            self.extra = ''
325
190
 
326
191
 
327
 
class InvalidNormalization(PathError):
328
 
    """Path %(path)r is not unicode normalized"""
329
 
 
330
 
 
331
 
# TODO: This is given a URL; we try to unescape it but doing that from inside
332
 
# the exception object is a bit undesirable.
333
 
# TODO: Probably this behavior of should be a common superclass 
334
 
class NotBranchError(PathError):
 
192
class NotBranchError(BzrNewError):
335
193
    """Not a branch: %(path)s"""
336
 
 
337
194
    def __init__(self, path):
338
 
       import bzrlib.urlutils as urlutils
339
 
       self.path = urlutils.unescape_for_display(path, 'ascii')
340
 
 
341
 
 
342
 
class AlreadyBranchError(PathError):
343
 
    """Already a branch: %(path)s."""
344
 
 
345
 
 
346
 
class BranchExistsWithoutWorkingTree(PathError):
347
 
    """Directory contains a branch, but no working tree \
348
 
(use bzr checkout if you wish to build a working tree): %(path)s"""
349
 
 
350
 
 
351
 
class AtomicFileAlreadyClosed(PathError):
352
 
    """'%(function)s' called on an AtomicFile after it was closed: %(path)s"""
353
 
 
354
 
    def __init__(self, path, function):
355
 
        PathError.__init__(self, path=path, extra=None)
356
 
        self.function = function
357
 
 
358
 
 
359
 
class InaccessibleParent(PathError):
360
 
    """Parent not accessible given base %(base)s and relative path %(path)s"""
361
 
 
362
 
    def __init__(self, path, base):
363
 
        PathError.__init__(self, path)
364
 
        self.base = base
365
 
 
366
 
 
367
 
class NoRepositoryPresent(BzrNewError):
368
 
    """No repository present: %(path)r"""
369
 
    def __init__(self, bzrdir):
370
195
        BzrNewError.__init__(self)
371
 
        self.path = bzrdir.transport.clone('..').base
 
196
        self.path = path
372
197
 
373
198
 
374
199
class FileInWrongBranch(BzrNewError):
375
200
    """File %(path)s in not in branch %(branch_base)s."""
376
 
 
377
201
    def __init__(self, branch, path):
378
202
        BzrNewError.__init__(self)
379
203
        self.branch = branch
381
205
        self.path = path
382
206
 
383
207
 
384
 
class UnsupportedFormatError(BzrNewError):
385
 
    """Unsupported branch format: %(format)s"""
386
 
 
387
 
 
388
 
class UnknownFormatError(BzrNewError):
389
 
    """Unknown branch format: %(format)r"""
390
 
 
391
 
 
392
 
class IncompatibleFormat(BzrNewError):
393
 
    """Format %(format)s is not compatible with .bzr version %(bzrdir)s."""
394
 
 
395
 
    def __init__(self, format, bzrdir_format):
396
 
        BzrNewError.__init__(self)
397
 
        self.format = format
398
 
        self.bzrdir = bzrdir_format
399
 
 
400
 
 
401
 
class IncompatibleRevision(BzrNewError):
402
 
    """Revision is not compatible with %(repo_format)s"""
403
 
 
404
 
    def __init__(self, repo_format):
405
 
        BzrNewError.__init__(self)
406
 
        self.repo_format = repo_format
 
208
class UnsupportedFormatError(BzrError):
 
209
    """Specified path is a bzr branch that we cannot read."""
 
210
    def __str__(self):
 
211
        return 'unsupported branch format: %s' % self.args[0]
407
212
 
408
213
 
409
214
class NotVersionedError(BzrNewError):
413
218
        self.path = path
414
219
 
415
220
 
416
 
class PathsNotVersionedError(BzrNewError):
417
 
    # used when reporting several paths are not versioned
418
 
    """Path(s) are not versioned: %(paths_as_string)s"""
419
 
 
420
 
    def __init__(self, paths):
421
 
        from bzrlib.osutils import quotefn
422
 
        BzrNewError.__init__(self)
423
 
        self.paths = paths
424
 
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
425
 
 
426
 
 
427
 
class PathsDoNotExist(BzrNewError):
428
 
    """Path(s) do not exist: %(paths_as_string)s"""
429
 
 
430
 
    # used when reporting that paths are neither versioned nor in the working
431
 
    # tree
432
 
 
433
 
    def __init__(self, paths):
434
 
        # circular import
435
 
        from bzrlib.osutils import quotefn
436
 
        BzrNewError.__init__(self)
437
 
        self.paths = paths
438
 
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
439
 
 
440
 
 
441
 
class BadFileKindError(BzrNewError):
442
 
    """Cannot operate on %(filename)s of unsupported kind %(kind)s"""
443
 
 
444
 
 
445
 
class ForbiddenControlFileError(BzrNewError):
446
 
    """Cannot operate on %(filename)s because it is a control file"""
447
 
 
448
 
 
449
 
class LockError(BzrNewError):
450
 
    """Lock error: %(message)s"""
 
221
class BadFileKindError(BzrError):
 
222
    """Specified file is of a kind that cannot be added.
 
223
 
 
224
    (For example a symlink or device file.)"""
 
225
 
 
226
 
 
227
class ForbiddenFileError(BzrError):
 
228
    """Cannot operate on a file because it is a control file."""
 
229
 
 
230
 
 
231
class LockError(Exception):
 
232
    """Lock error"""
451
233
    # All exceptions from the lock/unlock functions should be from
452
234
    # this exception class.  They will be translated as necessary. The
453
235
    # original exception is available as e.original_error
454
 
    #
455
 
    # New code should prefer to raise specific subclasses
456
 
    def __init__(self, message):
457
 
        self.message = message
458
236
 
459
237
 
460
238
class CommitNotPossible(LockError):
461
239
    """A commit was attempted but we do not have a write lock open."""
462
 
    def __init__(self):
463
 
        pass
464
240
 
465
241
 
466
242
class AlreadyCommitted(LockError):
467
243
    """A rollback was requested, but is not able to be accomplished."""
468
 
    def __init__(self):
469
 
        pass
470
244
 
471
245
 
472
246
class ReadOnlyError(LockError):
473
 
    """A write attempt was made in a read only transaction on %(obj)s"""
474
 
    def __init__(self, obj):
475
 
        self.obj = obj
476
 
 
477
 
 
478
 
class OutSideTransaction(BzrNewError):
479
 
    """A transaction related operation was attempted after the transaction finished."""
480
 
 
481
 
 
482
 
class ObjectNotLocked(LockError):
483
 
    """%(obj)r is not locked"""
484
 
 
485
 
    is_user_error = False
486
 
 
487
 
    # this can indicate that any particular object is not locked; see also
488
 
    # LockNotHeld which means that a particular *lock* object is not held by
489
 
    # the caller -- perhaps they should be unified.
490
 
    def __init__(self, obj):
491
 
        self.obj = obj
492
 
 
493
 
 
494
 
class ReadOnlyObjectDirtiedError(ReadOnlyError):
495
 
    """Cannot change object %(obj)r in read only transaction"""
496
 
    def __init__(self, obj):
497
 
        self.obj = obj
498
 
 
499
 
 
500
 
class UnlockableTransport(LockError):
501
 
    """Cannot lock: transport is read only: %(transport)s"""
502
 
    def __init__(self, transport):
503
 
        self.transport = transport
504
 
 
505
 
 
506
 
class LockContention(LockError):
507
 
    """Could not acquire lock %(lock)s"""
508
 
    # TODO: show full url for lock, combining the transport and relative bits?
509
 
    def __init__(self, lock):
510
 
        self.lock = lock
511
 
 
512
 
 
513
 
class LockBroken(LockError):
514
 
    """Lock was broken while still open: %(lock)s - check storage consistency!"""
515
 
    def __init__(self, lock):
516
 
        self.lock = lock
517
 
 
518
 
 
519
 
class LockBreakMismatch(LockError):
520
 
    """Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)r, wanted to break %(target)r"""
521
 
    def __init__(self, lock, holder, target):
522
 
        self.lock = lock
523
 
        self.holder = holder
524
 
        self.target = target
525
 
 
526
 
 
527
 
class LockNotHeld(LockError):
528
 
    """Lock not held: %(lock)s"""
529
 
    def __init__(self, lock):
530
 
        self.lock = lock
 
247
    """A write attempt was made in a read only transaction."""
531
248
 
532
249
 
533
250
class PointlessCommit(BzrNewError):
534
251
    """No changes to commit"""
535
252
 
536
 
 
537
 
class UpgradeReadonly(BzrNewError):
538
 
    """Upgrade URL cannot work with readonly URL's."""
539
 
 
540
 
 
541
 
class UpToDateFormat(BzrNewError):
542
 
    """The branch format %(format)s is already at the most recent format."""
543
 
 
544
 
    def __init__(self, format):
545
 
        BzrNewError.__init__(self)
546
 
        self.format = format
547
 
 
548
 
 
549
253
class StrictCommitFailed(Exception):
550
254
    """Commit refused because there are unknowns in the tree."""
551
255
 
552
 
 
553
 
class NoSuchRevision(BzrNewError):
554
 
    """Branch %(branch)s has no revision %(revision)s"""
555
 
 
556
 
    is_user_error = False
557
 
 
 
256
class NoSuchRevision(BzrError):
558
257
    def __init__(self, branch, revision):
559
 
        BzrNewError.__init__(self, branch=branch, revision=revision)
560
 
 
561
 
 
562
 
class NoSuchRevisionSpec(BzrNewError):
563
 
    """No namespace registered for string: %(spec)r"""
564
 
 
565
 
    def __init__(self, spec):
566
 
        BzrNewError.__init__(self, spec=spec)
567
 
 
568
 
 
569
 
class InvalidRevisionSpec(BzrNewError):
570
 
    """Requested revision: '%(spec)s' does not exist in branch:
571
 
%(branch)s%(extra)s"""
572
 
 
573
 
    def __init__(self, spec, branch, extra=None):
574
 
        BzrNewError.__init__(self, branch=branch, spec=spec)
575
 
        if extra:
576
 
            self.extra = '\n' + str(extra)
577
 
        else:
578
 
            self.extra = ''
 
258
        self.branch = branch
 
259
        self.revision = revision
 
260
        msg = "Branch %s has no revision %s" % (branch, revision)
 
261
        BzrError.__init__(self, msg)
579
262
 
580
263
 
581
264
class HistoryMissing(BzrError):
586
269
                          % (branch, object_type, object_id))
587
270
 
588
271
 
589
 
class DivergedBranches(BzrNewError):
590
 
    "These branches have diverged.  Use the merge command to reconcile them."""
591
 
 
592
 
    is_user_error = True
593
 
 
 
272
class DivergedBranches(BzrError):
594
273
    def __init__(self, branch1, branch2):
 
274
        BzrError.__init__(self, "These branches have diverged.")
595
275
        self.branch1 = branch1
596
276
        self.branch2 = branch2
597
277
 
598
278
 
599
 
class UnrelatedBranches(BzrNewError):
600
 
    "Branches have no common ancestor, and no merge base revision was specified."
601
 
 
602
 
    is_user_error = True
603
 
 
604
 
 
605
 
class NoCommonAncestor(BzrNewError):
606
 
    "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
607
 
 
 
279
class UnrelatedBranches(BzrCommandError):
 
280
    def __init__(self):
 
281
        msg = "Branches have no common ancestor, and no base revision"\
 
282
            " specified."
 
283
        BzrCommandError.__init__(self, msg)
 
284
 
 
285
class NoCommonAncestor(BzrError):
608
286
    def __init__(self, revision_a, revision_b):
609
 
        self.revision_a = revision_a
610
 
        self.revision_b = revision_b
611
 
 
 
287
        msg = "Revisions have no common ancestor: %s %s." \
 
288
            % (revision_a, revision_b) 
 
289
        BzrError.__init__(self, msg)
612
290
 
613
291
class NoCommonRoot(BzrError):
614
292
    def __init__(self, revision_a, revision_b):
616
294
            % (revision_a, revision_b) 
617
295
        BzrError.__init__(self, msg)
618
296
 
619
 
 
620
 
 
621
297
class NotAncestor(BzrError):
622
298
    def __init__(self, rev_id, not_ancestor_id):
623
299
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
636
312
 
637
313
class AmbiguousBase(BzrError):
638
314
    def __init__(self, bases):
639
 
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
640
 
                DeprecationWarning)
641
 
        msg = "The correct base is unclear, because %s are all equally close" %\
 
315
        msg = "The correct base is unclear, becase %s are all equally close" %\
642
316
            ", ".join(bases)
643
317
        BzrError.__init__(self, msg)
644
318
        self.bases = bases
645
319
 
646
 
 
647
 
class NoCommits(BzrNewError):
648
 
    """Branch %(branch)s has no commits."""
649
 
 
 
320
class NoCommits(BzrError):
650
321
    def __init__(self, branch):
651
 
        BzrNewError.__init__(self, branch=branch)
652
 
 
 
322
        msg = "Branch %s has no commits." % branch
 
323
        BzrError.__init__(self, msg)
653
324
 
654
325
class UnlistableStore(BzrError):
655
326
    def __init__(self, store):
656
327
        BzrError.__init__(self, "Store %s is not listable" % store)
657
328
 
658
 
 
659
 
 
660
329
class UnlistableBranch(BzrError):
661
330
    def __init__(self, br):
662
331
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
663
332
 
664
333
 
665
 
class BoundBranchOutOfDate(BzrNewError):
666
 
    """Bound branch %(branch)s is out of date with master branch %(master)s."""
667
 
    def __init__(self, branch, master):
668
 
        BzrNewError.__init__(self)
669
 
        self.branch = branch
670
 
        self.master = master
671
 
 
672
 
        
673
 
class CommitToDoubleBoundBranch(BzrNewError):
674
 
    """Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."""
675
 
    def __init__(self, branch, master, remote):
676
 
        BzrNewError.__init__(self)
677
 
        self.branch = branch
678
 
        self.master = master
679
 
        self.remote = remote
680
 
 
681
 
 
682
 
class OverwriteBoundBranch(BzrNewError):
683
 
    """Cannot pull --overwrite to a branch which is bound %(branch)s"""
684
 
    def __init__(self, branch):
685
 
        BzrNewError.__init__(self)
686
 
        self.branch = branch
687
 
 
688
 
 
689
 
class BoundBranchConnectionFailure(BzrNewError):
690
 
    """Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"""
691
 
    def __init__(self, branch, target, error):
692
 
        BzrNewError.__init__(self)
693
 
        self.branch = branch
694
 
        self.target = target
695
 
        self.error = error
696
 
 
697
 
 
698
334
class WeaveError(BzrNewError):
699
335
    """Error in processing weave: %(message)s"""
700
 
 
701
336
    def __init__(self, message=None):
702
337
        BzrNewError.__init__(self)
703
338
        self.message = message
706
341
class WeaveRevisionAlreadyPresent(WeaveError):
707
342
    """Revision {%(revision_id)s} already present in %(weave)s"""
708
343
    def __init__(self, revision_id, weave):
709
 
 
710
344
        WeaveError.__init__(self)
711
345
        self.revision_id = revision_id
712
346
        self.weave = weave
714
348
 
715
349
class WeaveRevisionNotPresent(WeaveError):
716
350
    """Revision {%(revision_id)s} not present in %(weave)s"""
717
 
 
718
351
    def __init__(self, revision_id, weave):
719
352
        WeaveError.__init__(self)
720
353
        self.revision_id = revision_id
723
356
 
724
357
class WeaveFormatError(WeaveError):
725
358
    """Weave invariant violated: %(what)s"""
726
 
 
727
359
    def __init__(self, what):
728
360
        WeaveError.__init__(self)
729
361
        self.what = what
733
365
    """Parents are mismatched between two revisions."""
734
366
    
735
367
 
736
 
class WeaveInvalidChecksum(WeaveError):
737
 
    """Text did not match it's checksum: %(message)s"""
738
 
 
739
 
 
740
 
class WeaveTextDiffers(WeaveError):
741
 
    """Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
742
 
 
743
 
    def __init__(self, revision_id, weave_a, weave_b):
744
 
        WeaveError.__init__(self)
745
 
        self.revision_id = revision_id
746
 
        self.weave_a = weave_a
747
 
        self.weave_b = weave_b
748
 
 
749
 
 
750
 
class WeaveTextDiffers(WeaveError):
751
 
    """Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
752
 
 
753
 
    def __init__(self, revision_id, weave_a, weave_b):
754
 
        WeaveError.__init__(self)
755
 
        self.revision_id = revision_id
756
 
        self.weave_a = weave_a
757
 
        self.weave_b = weave_b
758
 
 
759
 
 
760
 
class VersionedFileError(BzrNewError):
761
 
    """Versioned file error."""
762
 
 
763
 
 
764
 
class RevisionNotPresent(VersionedFileError):
765
 
    """Revision {%(revision_id)s} not present in %(file_id)s."""
766
 
 
767
 
    def __init__(self, revision_id, file_id):
768
 
        VersionedFileError.__init__(self)
769
 
        self.revision_id = revision_id
770
 
        self.file_id = file_id
771
 
 
772
 
 
773
 
class RevisionAlreadyPresent(VersionedFileError):
774
 
    """Revision {%(revision_id)s} already present in %(file_id)s."""
775
 
 
776
 
    def __init__(self, revision_id, file_id):
777
 
        VersionedFileError.__init__(self)
778
 
        self.revision_id = revision_id
779
 
        self.file_id = file_id
780
 
 
781
 
 
782
 
class KnitError(BzrNewError):
783
 
    """Knit error"""
784
 
 
785
 
 
786
 
class KnitHeaderError(KnitError):
787
 
    """Knit header error: %(badline)r unexpected"""
788
 
 
789
 
    def __init__(self, badline):
790
 
        KnitError.__init__(self)
791
 
        self.badline = badline
792
 
 
793
 
 
794
 
class KnitCorrupt(KnitError):
795
 
    """Knit %(filename)s corrupt: %(how)s"""
796
 
 
797
 
    def __init__(self, filename, how):
798
 
        KnitError.__init__(self)
799
 
        self.filename = filename
800
 
        self.how = how
801
 
 
802
 
 
803
368
class NoSuchExportFormat(BzrNewError):
804
369
    """Export format %(format)r not supported"""
805
370
    def __init__(self, format):
807
372
        self.format = format
808
373
 
809
374
 
810
 
class TransportError(BzrNewError):
811
 
    """Transport error: %(msg)s %(orig_error)s"""
812
 
 
 
375
class TransportError(BzrError):
 
376
    """All errors thrown by Transport implementations should derive
 
377
    from this class.
 
378
    """
813
379
    def __init__(self, msg=None, orig_error=None):
814
380
        if msg is None and orig_error is not None:
815
381
            msg = str(orig_error)
816
 
        if orig_error is None:
817
 
            orig_error = ''
818
 
        if msg is None:
819
 
            msg =  ''
 
382
        BzrError.__init__(self, msg)
820
383
        self.msg = msg
821
384
        self.orig_error = orig_error
822
 
        BzrNewError.__init__(self)
823
 
 
824
 
 
825
 
class SmartProtocolError(TransportError):
826
 
    """Generic bzr smart protocol error: %(details)s"""
827
 
 
828
 
    def __init__(self, details):
829
 
        self.details = details
830
 
 
831
385
 
832
386
# A set of semi-meaningful errors which can be thrown
833
387
class TransportNotPossible(TransportError):
834
 
    """Transport operation not possible: %(msg)s %(orig_error)s"""
 
388
    """This is for transports where a specific function is explicitly not
 
389
    possible. Such as pushing files to an HTTP server.
 
390
    """
 
391
    pass
835
392
 
836
393
 
837
394
class ConnectionError(TransportError):
838
 
    """Connection error: %(msg)s %(orig_error)s"""
 
395
    """A connection problem prevents file retrieval.
 
396
    This does not indicate whether the file exists or not; it indicates that a
 
397
    precondition for requesting the file was not met.
 
398
    """
 
399
    def __init__(self, msg=None, orig_error=None):
 
400
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
839
401
 
840
402
 
841
403
class ConnectionReset(TransportError):
842
 
    """Connection closed: %(msg)s %(orig_error)s"""
843
 
 
844
 
 
845
 
class InvalidRange(TransportError):
846
 
    """Invalid range access in %(path)s at %(offset)s."""
847
 
    
848
 
    def __init__(self, path, offset):
849
 
        TransportError.__init__(self, ("Invalid range access in %s at %d"
850
 
                                       % (path, offset)))
851
 
        self.path = path
852
 
        self.offset = offset
853
 
 
854
 
 
855
 
class InvalidHttpResponse(TransportError):
856
 
    """Invalid http response for %(path)s: %(msg)s"""
857
 
 
858
 
    def __init__(self, path, msg, orig_error=None):
859
 
        self.path = path
860
 
        TransportError.__init__(self, msg, orig_error=orig_error)
861
 
 
862
 
 
863
 
class InvalidHttpRange(InvalidHttpResponse):
864
 
    """Invalid http range "%(range)s" for %(path)s: %(msg)s"""
865
 
    
866
 
    def __init__(self, path, range, msg):
867
 
        self.range = range
868
 
        InvalidHttpResponse.__init__(self, path, msg)
869
 
 
870
 
 
871
 
class InvalidHttpContentType(InvalidHttpResponse):
872
 
    """Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s"""
873
 
    
874
 
    def __init__(self, path, ctype, msg):
875
 
        self.ctype = ctype
876
 
        InvalidHttpResponse.__init__(self, path, msg)
877
 
 
 
404
    """The connection has been closed."""
 
405
    pass
878
406
 
879
407
class ConflictsInTree(BzrError):
880
408
    def __init__(self):
881
409
        BzrError.__init__(self, "Working tree has conflicts.")
882
410
 
883
 
 
884
411
class ParseConfigError(BzrError):
885
412
    def __init__(self, errors, filename):
886
413
        if filename is None:
889
416
            (filename, ('\n'.join(e.message for e in errors)))
890
417
        BzrError.__init__(self, message)
891
418
 
892
 
 
893
419
class SigningFailed(BzrError):
894
420
    def __init__(self, command_line):
895
421
        BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
896
422
                               % command_line)
897
423
 
898
 
 
899
424
class WorkingTreeNotRevision(BzrError):
900
425
    def __init__(self, tree):
901
426
        BzrError.__init__(self, "The working tree for %s has changed since"
902
427
                          " last commit, but weave merge requires that it be"
903
428
                          " unchanged." % tree.basedir)
904
429
 
905
 
 
906
430
class CantReprocessAndShowBase(BzrNewError):
907
431
    """Can't reprocess and show base.
908
432
Reprocessing obscures relationship of conflicting lines to base."""
909
433
 
910
 
 
911
434
class GraphCycleError(BzrNewError):
912
435
    """Cycle in graph %(graph)r"""
913
436
    def __init__(self, graph):
914
437
        BzrNewError.__init__(self)
915
438
        self.graph = graph
916
439
 
917
 
 
918
440
class NotConflicted(BzrNewError):
919
441
    """File %(filename)s is not conflicted."""
920
 
 
921
442
    def __init__(self, filename):
922
443
        BzrNewError.__init__(self)
923
444
        self.filename = filename
924
445
 
925
 
 
926
446
class MustUseDecorated(Exception):
927
447
    """A decorating function has requested its original command be used.
928
448
    
929
449
    This should never escape bzr, so does not need to be printable.
930
450
    """
931
451
 
932
 
 
933
 
class NoBundleFound(BzrNewError):
934
 
    """No bundle was found in %(filename)s"""
935
 
    def __init__(self, filename):
936
 
        BzrNewError.__init__(self)
937
 
        self.filename = filename
938
 
 
939
 
 
940
 
class BundleNotSupported(BzrNewError):
941
 
    """Unable to handle bundle version %(version)s: %(msg)s"""
942
 
    def __init__(self, version, msg):
943
 
        BzrNewError.__init__(self)
944
 
        self.version = version
945
 
        self.msg = msg
946
 
 
947
 
 
948
452
class MissingText(BzrNewError):
949
453
    """Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
950
 
 
951
454
    def __init__(self, branch, text_revision, file_id):
952
 
        BzrNewError.__init__(self)
953
455
        self.branch = branch
954
456
        self.base = branch.base
955
457
        self.text_revision = text_revision
956
458
        self.file_id = file_id
957
 
 
958
 
 
959
 
class DuplicateKey(BzrNewError):
960
 
    """Key %(key)s is already present in map"""
961
 
 
962
 
 
963
 
class MalformedTransform(BzrNewError):
964
 
    """Tree transform is malformed %(conflicts)r"""
965
 
 
966
 
 
967
 
class BzrBadParameter(BzrNewError):
968
 
    """A bad parameter : %(param)s is not usable.
969
 
    
970
 
    This exception should never be thrown, but it is a base class for all
971
 
    parameter-to-function errors.
972
 
    """
973
 
    def __init__(self, param):
974
 
        BzrNewError.__init__(self)
975
 
        self.param = param
976
 
 
977
 
 
978
 
class BzrBadParameterNotUnicode(BzrBadParameter):
979
 
    """Parameter %(param)s is neither unicode nor utf8."""
980
 
 
981
 
 
982
 
class ReusingTransform(BzrNewError):
983
 
    """Attempt to reuse a transform that has already been applied."""
984
 
 
985
 
 
986
 
class CantMoveRoot(BzrNewError):
987
 
    """Moving the root directory is not supported at this time"""
988
 
 
989
 
 
990
 
class BzrBadParameterNotString(BzrBadParameter):
991
 
    """Parameter %(param)s is not a string or unicode string."""
992
 
 
993
 
 
994
 
class BzrBadParameterMissing(BzrBadParameter):
995
 
    """Parameter $(param)s is required but not present."""
996
 
 
997
 
 
998
 
class BzrBadParameterUnicode(BzrBadParameter):
999
 
    """Parameter %(param)s is unicode but only byte-strings are permitted."""
1000
 
 
1001
 
 
1002
 
class BzrBadParameterContainsNewline(BzrBadParameter):
1003
 
    """Parameter %(param)s contains a newline."""
1004
 
 
1005
 
 
1006
 
class DependencyNotPresent(BzrNewError):
1007
 
    """Unable to import library "%(library)s": %(error)s"""
1008
 
 
1009
 
    def __init__(self, library, error):
1010
 
        BzrNewError.__init__(self, library=library, error=error)
1011
 
 
1012
 
 
1013
 
class ParamikoNotPresent(DependencyNotPresent):
1014
 
    """Unable to import paramiko (required for sftp support): %(error)s"""
1015
 
 
1016
 
    def __init__(self, error):
1017
 
        DependencyNotPresent.__init__(self, 'paramiko', error)
1018
 
 
1019
 
 
1020
 
class PointlessMerge(BzrNewError):
1021
 
    """Nothing to merge."""
1022
 
 
1023
 
 
1024
 
class UninitializableFormat(BzrNewError):
1025
 
    """Format %(format)s cannot be initialised by this version of bzr."""
1026
 
 
1027
 
    def __init__(self, format):
1028
 
        BzrNewError.__init__(self)
1029
 
        self.format = format
1030
 
 
1031
 
 
1032
 
class BadConversionTarget(BzrNewError):
1033
 
    """Cannot convert to format %(format)s.  %(problem)s"""
1034
 
 
1035
 
    def __init__(self, problem, format):
1036
 
        BzrNewError.__init__(self)
1037
 
        self.problem = problem
1038
 
        self.format = format
1039
 
 
1040
 
 
1041
 
class NoDiff(BzrNewError):
1042
 
    """Diff is not installed on this machine: %(msg)s"""
1043
 
 
1044
 
    def __init__(self, msg):
1045
 
        BzrNewError.__init__(self, msg=msg)
1046
 
 
1047
 
 
1048
 
class NoDiff3(BzrNewError):
1049
 
    """Diff3 is not installed on this machine."""
1050
 
 
1051
 
 
1052
 
class ExistingLimbo(BzrNewError):
1053
 
    """This tree contains left-over files from a failed operation.
1054
 
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1055
 
    keep, and delete it when you are done.
1056
 
    """
1057
 
    def __init__(self, limbo_dir):
1058
 
       BzrNewError.__init__(self)
1059
 
       self.limbo_dir = limbo_dir
1060
 
 
1061
 
 
1062
 
class ImmortalLimbo(BzrNewError):
1063
 
    """Unable to delete transform temporary directory $(limbo_dir)s.
1064
 
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1065
 
    keep, and delete it when you are done.
1066
 
    """
1067
 
    def __init__(self, limbo_dir):
1068
 
       BzrNewError.__init__(self)
1069
 
       self.limbo_dir = limbo_dir
1070
 
 
1071
 
 
1072
 
class OutOfDateTree(BzrNewError):
1073
 
    """Working tree is out of date, please run 'bzr update'."""
1074
 
 
1075
 
    def __init__(self, tree):
1076
 
        BzrNewError.__init__(self)
1077
 
        self.tree = tree
1078
 
 
1079
 
 
1080
 
class MergeModifiedFormatError(BzrNewError):
1081
 
    """Error in merge modified format"""
1082
 
 
1083
 
 
1084
 
class ConflictFormatError(BzrNewError):
1085
 
    """Format error in conflict listings"""
1086
 
 
1087
 
 
1088
 
class CorruptRepository(BzrNewError):
1089
 
    """An error has been detected in the repository %(repo_path)s.
1090
 
Please run bzr reconcile on this repository."""
1091
 
 
1092
 
    def __init__(self, repo):
1093
 
        BzrNewError.__init__(self)
1094
 
        self.repo_path = repo.bzrdir.root_transport.base
1095
 
 
1096
 
 
1097
 
class UpgradeRequired(BzrNewError):
1098
 
    """To use this feature you must upgrade your branch at %(path)s."""
1099
 
 
1100
 
    def __init__(self, path):
1101
 
        BzrNewError.__init__(self)
1102
 
        self.path = path
1103
 
 
1104
 
 
1105
 
class LocalRequiresBoundBranch(BzrNewError):
1106
 
    """Cannot perform local-only commits on unbound branches."""
1107
 
 
1108
 
 
1109
 
class MissingProgressBarFinish(BzrNewError):
1110
 
    """A nested progress bar was not 'finished' correctly."""
1111
 
 
1112
 
 
1113
 
class InvalidProgressBarType(BzrNewError):
1114
 
    """Environment variable BZR_PROGRESS_BAR='%(bar_type)s is not a supported type
1115
 
Select one of: %(valid_types)s"""
1116
 
 
1117
 
    def __init__(self, bar_type, valid_types):
1118
 
        BzrNewError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1119
 
 
1120
 
 
1121
 
class UnsupportedOperation(BzrNewError):
1122
 
    """The method %(mname)s is not supported on objects of type %(tname)s."""
1123
 
    def __init__(self, method, method_self):
1124
 
        self.method = method
1125
 
        self.mname = method.__name__
1126
 
        self.tname = type(method_self).__name__
1127
 
 
1128
 
 
1129
 
class BinaryFile(BzrNewError):
1130
 
    """File is binary but should be text."""
1131
 
 
1132
 
 
1133
 
class IllegalPath(BzrNewError):
1134
 
    """The path %(path)s is not permitted on this platform"""
1135
 
 
1136
 
    def __init__(self, path):
1137
 
        BzrNewError.__init__(self)
1138
 
        self.path = path
1139
 
 
1140
 
 
1141
 
class TestamentMismatch(BzrNewError):
1142
 
    """Testament did not match expected value.  
1143
 
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured 
1144
 
       {%(measured)s}
1145
 
    """
1146
 
    def __init__(self, revision_id, expected, measured):
1147
 
        self.revision_id = revision_id
1148
 
        self.expected = expected
1149
 
        self.measured = measured
1150
 
 
1151
 
 
1152
 
class NotABundle(BzrNewError):
1153
 
    """Not a bzr revision-bundle: %(text)r"""
1154
 
 
1155
 
    def __init__(self, text):
1156
 
        BzrNewError.__init__(self)
1157
 
        self.text = text
1158
 
 
1159
 
 
1160
 
class BadBundle(BzrNewError): 
1161
 
    """Bad bzr revision-bundle: %(text)r"""
1162
 
 
1163
 
    def __init__(self, text):
1164
 
        BzrNewError.__init__(self)
1165
 
        self.text = text
1166
 
 
1167
 
 
1168
 
class MalformedHeader(BadBundle): 
1169
 
    """Malformed bzr revision-bundle header: %(text)r"""
1170
 
 
1171
 
    def __init__(self, text):
1172
 
        BzrNewError.__init__(self)
1173
 
        self.text = text
1174
 
 
1175
 
 
1176
 
class MalformedPatches(BadBundle): 
1177
 
    """Malformed patches in bzr revision-bundle: %(text)r"""
1178
 
 
1179
 
    def __init__(self, text):
1180
 
        BzrNewError.__init__(self)
1181
 
        self.text = text
1182
 
 
1183
 
 
1184
 
class MalformedFooter(BadBundle): 
1185
 
    """Malformed footer in bzr revision-bundle: %(text)r"""
1186
 
 
1187
 
    def __init__(self, text):
1188
 
        BzrNewError.__init__(self)
1189
 
        self.text = text
1190
 
 
1191
 
 
1192
 
class UnsupportedEOLMarker(BadBundle):
1193
 
    """End of line marker was not \\n in bzr revision-bundle"""    
1194
 
 
1195
 
    def __init__(self):
1196
 
        BzrNewError.__init__(self)
1197
 
 
1198
 
 
1199
 
class IncompatibleFormat(BzrNewError):
1200
 
    """Bundle format %(bundle_format)s is incompatible with %(other)s"""
1201
 
 
1202
 
    def __init__(self, bundle_format, other):
1203
 
        BzrNewError.__init__(self)
1204
 
        self.bundle_format = bundle_format
1205
 
        self.other = other
1206
 
 
1207
 
 
1208
 
class BadInventoryFormat(BzrNewError):
1209
 
    """Root class for inventory serialization errors"""
1210
 
 
1211
 
 
1212
 
class UnexpectedInventoryFormat(BadInventoryFormat):
1213
 
    """The inventory was not in the expected format:\n %(msg)s"""
1214
 
 
1215
 
    def __init__(self, msg):
1216
 
        BadInventoryFormat.__init__(self, msg=msg)
1217
 
 
1218
 
 
1219
 
class NoSmartServer(NotBranchError):
1220
 
    """No smart server available at %(url)s"""
1221
 
 
1222
 
    def __init__(self, url):
1223
 
        self.url = url
1224
 
 
1225
 
 
1226
 
class UnknownSSH(BzrNewError):
1227
 
    """Unrecognised value for BZR_SSH environment variable: %(vendor)s"""
1228
 
 
1229
 
    def __init__(self, vendor):
1230
 
        BzrNewError.__init__(self)
1231
 
        self.vendor = vendor
1232
 
 
1233
 
 
1234
 
class GhostRevisionUnusableHere(BzrNewError):
1235
 
    """Ghost revision {%(revision_id)s} cannot be used here."""
1236
 
 
1237
 
    def __init__(self, revision_id):
1238
 
        BzrNewError.__init__(self)
1239
 
        self.revision_id = revision_id
1240
 
 
1241
 
 
1242
 
class IllegalUseOfScopeReplacer(BzrNewError):
1243
 
    """ScopeReplacer object %(name)r was used incorrectly: %(msg)s%(extra)s"""
1244
 
 
1245
 
    is_user_error = False
1246
 
 
1247
 
    def __init__(self, name, msg, extra=None):
1248
 
        BzrNewError.__init__(self)
1249
 
        self.name = name
1250
 
        self.msg = msg
1251
 
        if extra:
1252
 
            self.extra = ': ' + str(extra)
1253
 
        else:
1254
 
            self.extra = ''
1255
 
 
1256
 
 
1257
 
class InvalidImportLine(BzrNewError):
1258
 
    """Not a valid import statement: %(msg)\n%(text)s"""
1259
 
 
1260
 
    is_user_error = False
1261
 
 
1262
 
    def __init__(self, text, msg):
1263
 
        BzrNewError.__init__(self)
1264
 
        self.text = text
1265
 
        self.msg = msg
1266
 
 
1267
 
 
1268
 
class ImportNameCollision(BzrNewError):
1269
 
    """Tried to import an object to the same name as an existing object. %(name)s"""
1270
 
 
1271
 
    is_user_error = False
1272
 
 
1273
 
    def __init__(self, name):
1274
 
        BzrNewError.__init__(self)
1275
 
        self.name = name