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