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