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 2000.3.7
- compare with another revision
- compare with revision 0.200.1036
- download diff
- download tarball
- view history from revision 2000.3.7
- Committer: v.ladeuil+lp at free
- Date: 2006-11-30 14:11:41 UTC
- mfrom: (2156 +trunk)
- mto: (2157.1.1 bzr.dev) (2172.3.1 bzr.73948)
- mto: This revision was merged to the branch mainline in revision 2157.
- Revision ID: v.ladeuil+lp@free.fr-20061130141141-dw2q0etk307ypkdv
Merge bzr.dev
- files added:
- bzrlib/debug.py
- files modified:
- .bzrignore
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
msg = "Could not install revisions:\n%s" % " ,".join(revisions)
753
revision_str = ", ".join(str(r) for r in revisions)
754
msg = "Could not install revisions:\n%s" % revision_str
659
755
BzrError.__init__(self, msg)
660
756
self.revisions = revisions
661
757
662
758
663
759
class AmbiguousBase(BzrError):
760
664
761
def __init__(self, bases):
665
762
warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
666
763
DeprecationWarning)
670
767
self.bases = bases
671
768
672
769
673
class NoCommits(BzrNewError):
674
"""Branch %(branch)s has no commits."""
770
class NoCommits(BzrError):
771
772
_fmt = "Branch %(branch)s has no commits."
675
773
676
774
def __init__(self, branch):
677
BzrNewError.__init__(self, branch=branch)
775
BzrError.__init__(self, branch=branch)
678
776
679
777
680
778
class UnlistableStore(BzrError):
779
681
780
def __init__(self, store):
682
781
BzrError.__init__(self, "Store %s is not listable" % store)
683
782
684
783
685
784
686
785
class UnlistableBranch(BzrError):
786
687
787
def __init__(self, br):
688
788
BzrError.__init__(self, "Stores for branch %s are not listable" % br)
689
789
690
790
691
class BoundBranchOutOfDate(BzrNewError):
692
"""Bound branch %(branch)s is out of date with master branch %(master)s."""
791
class BoundBranchOutOfDate(BzrError):
792
793
_fmt = "Bound branch %(branch)s is out of date with master branch %(master)s."
794
693
795
def __init__(self, branch, master):
694
BzrNewError.__init__(self)
796
BzrError.__init__(self)
695
797
self.branch = branch
696
798
self.master = master
697
799
698
800
699
class CommitToDoubleBoundBranch(BzrNewError):
700
"""Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."""
801
class CommitToDoubleBoundBranch(BzrError):
802
803
_fmt = "Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."
804
701
805
def __init__(self, branch, master, remote):
702
BzrNewError.__init__(self)
806
BzrError.__init__(self)
703
807
self.branch = branch
704
808
self.master = master
705
809
self.remote = remote
706
810
707
811
708
class OverwriteBoundBranch(BzrNewError):
709
"""Cannot pull --overwrite to a branch which is bound %(branch)s"""
812
class OverwriteBoundBranch(BzrError):
813
814
_fmt = "Cannot pull --overwrite to a branch which is bound %(branch)s"
815
710
816
def __init__(self, branch):
711
BzrNewError.__init__(self)
817
BzrError.__init__(self)
712
818
self.branch = branch
713
819
714
820
715
class BoundBranchConnectionFailure(BzrNewError):
716
"""Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"""
821
class BoundBranchConnectionFailure(BzrError):
822
823
_fmt = "Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"
824
717
825
def __init__(self, branch, target, error):
718
BzrNewError.__init__(self)
826
BzrError.__init__(self)
719
827
self.branch = branch
720
828
self.target = target
721
829
self.error = error
722
830
723
831
724
class WeaveError(BzrNewError):
725
"""Error in processing weave: %(message)s"""
832
class WeaveError(BzrError):
833
834
_fmt = "Error in processing weave: %(message)s"
726
835
727
836
def __init__(self, message=None):
728
BzrNewError.__init__(self)
837
BzrError.__init__(self)
729
838
self.message = message
730
839
731
840
732
841
class WeaveRevisionAlreadyPresent(WeaveError):
733
"""Revision {%(revision_id)s} already present in %(weave)s"""
842
843
_fmt = "Revision {%(revision_id)s} already present in %(weave)s"
844
734
845
def __init__(self, revision_id, weave):
735
846
736
847
WeaveError.__init__(self)
739
850
740
851
741
852
class WeaveRevisionNotPresent(WeaveError):
742
"""Revision {%(revision_id)s} not present in %(weave)s"""
853
854
_fmt = "Revision {%(revision_id)s} not present in %(weave)s"
743
855
744
856
def __init__(self, revision_id, weave):
745
857
WeaveError.__init__(self)
748
860
749
861
750
862
class WeaveFormatError(WeaveError):
751
"""Weave invariant violated: %(what)s"""
863
864
_fmt = "Weave invariant violated: %(what)s"
752
865
753
866
def __init__(self, what):
754
867
WeaveError.__init__(self)
756
869
757
870
758
871
class WeaveParentMismatch(WeaveError):
759
"""Parents are mismatched between two revisions."""
872
873
_fmt = "Parents are mismatched between two revisions."
760
874
761
875
762
876
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."""
877
878
_fmt = "Text did not match it's checksum: %(message)s"
879
880
881
class WeaveTextDiffers(WeaveError):
882
883
_fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"
884
885
def __init__(self, revision_id, weave_a, weave_b):
886
WeaveError.__init__(self)
887
self.revision_id = revision_id
888
self.weave_a = weave_a
889
self.weave_b = weave_b
890
891
892
class WeaveTextDiffers(WeaveError):
893
894
_fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"
895
896
def __init__(self, revision_id, weave_a, weave_b):
897
WeaveError.__init__(self)
898
self.revision_id = revision_id
899
self.weave_a = weave_a
900
self.weave_b = weave_b
901
902
903
class VersionedFileError(BzrError):
904
905
_fmt = "Versioned file error"
788
906
789
907
790
908
class RevisionNotPresent(VersionedFileError):
791
"""Revision {%(revision_id)s} not present in %(file_id)s."""
909
910
_fmt = "Revision {%(revision_id)s} not present in %(file_id)s."
792
911
793
912
def __init__(self, revision_id, file_id):
794
913
VersionedFileError.__init__(self)
797
916
798
917
799
918
class RevisionAlreadyPresent(VersionedFileError):
800
"""Revision {%(revision_id)s} already present in %(file_id)s."""
919
920
_fmt = "Revision {%(revision_id)s} already present in %(file_id)s."
801
921
802
922
def __init__(self, revision_id, file_id):
803
923
VersionedFileError.__init__(self)
805
925
self.file_id = file_id
806
926
807
927
808
class KnitError(BzrNewError):
809
"""Knit error"""
928
class KnitError(BzrError):
929
930
_fmt = "Knit error"
810
931
811
932
812
933
class KnitHeaderError(KnitError):
813
"""Knit header error: %(badline)r unexpected"""
934
935
_fmt = "Knit header error: %(badline)r unexpected"
814
936
815
937
def __init__(self, badline):
816
938
KnitError.__init__(self)
818
940
819
941
820
942
class KnitCorrupt(KnitError):
821
"""Knit %(filename)s corrupt: %(how)s"""
943
944
_fmt = "Knit %(filename)s corrupt: %(how)s"
822
945
823
946
def __init__(self, filename, how):
824
947
KnitError.__init__(self)
826
949
self.how = how
827
950
828
951
829
class NoSuchExportFormat(BzrNewError):
830
"""Export format %(format)r not supported"""
952
class NoSuchExportFormat(BzrError):
953
954
_fmt = "Export format %(format)r not supported"
831
955
832
956
def __init__(self, format):
833
BzrNewError.__init__(self)
957
BzrError.__init__(self)
834
958
self.format = format
835
959
836
960
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"""
961
class TransportError(BzrError):
962
963
_fmt = "Transport error: %(msg)s %(orig_error)s"
848
964
849
965
def __init__(self, msg=None, orig_error=None):
850
966
if msg is None and orig_error is not None:
855
971
msg = ''
856
972
self.msg = msg
857
973
self.orig_error = orig_error
858
BzrNewError.__init__(self)
974
BzrError.__init__(self)
975
976
977
class TooManyConcurrentRequests(BzrError):
978
979
_fmt = ("The medium '%(medium)s' has reached its concurrent request limit. "
980
"Be sure to finish_writing and finish_reading on the "
981
"current request that is open.")
982
983
internal_error = True
984
985
def __init__(self, medium):
986
self.medium = medium
859
987
860
988
861
989
class SmartProtocolError(TransportError):
862
"""Generic bzr smart protocol error: %(details)s"""
990
991
_fmt = "Generic bzr smart protocol error: %(details)s"
863
992
864
993
def __init__(self, details):
865
994
self.details = details
867
996
868
997
# A set of semi-meaningful errors which can be thrown
869
998
class TransportNotPossible(TransportError):
870
"""Transport operation not possible: %(msg)s %(orig_error)s"""
999
1000
_fmt = "Transport operation not possible: %(msg)s %(orig_error)s"
871
1001
872
1002
873
1003
class ConnectionError(TransportError):
874
"""Connection error: %(msg)s %(orig_error)s"""
1004
1005
_fmt = "Connection error: %(msg)s %(orig_error)s"
1006
1007
1008
class SocketConnectionError(ConnectionError):
1009
1010
_fmt = "%(msg)s %(host)s%(port)s%(orig_error)s"
1011
1012
def __init__(self, host, port=None, msg=None, orig_error=None):
1013
if msg is None:
1014
msg = 'Failed to connect to'
1015
if orig_error is None:
1016
orig_error = ''
1017
else:
1018
orig_error = '; ' + str(orig_error)
1019
ConnectionError.__init__(self, msg=msg, orig_error=orig_error)
1020
self.host = host
1021
if port is None:
1022
self.port = ''
1023
else:
1024
self.port = ':%s' % port
875
1025
876
1026
877
1027
class ConnectionReset(TransportError):
878
"""Connection closed: %(msg)s %(orig_error)s"""
1028
1029
_fmt = "Connection closed: %(msg)s %(orig_error)s"
879
1030
880
1031
881
1032
class InvalidRange(TransportError):
882
"""Invalid range access in %(path)s at %(offset)s."""
1033
1034
_fmt = "Invalid range access in %(path)s at %(offset)s."
883
1035
884
1036
def __init__(self, path, offset):
885
1037
TransportError.__init__(self, ("Invalid range access in %s at %d"
889
1041
890
1042
891
1043
class InvalidHttpResponse(TransportError):
892
"""Invalid http response for %(path)s: %(msg)s"""
1044
1045
_fmt = "Invalid http response for %(path)s: %(msg)s"
893
1046
894
1047
def __init__(self, path, msg, orig_error=None):
895
1048
self.path = path
897
1050
898
1051
899
1052
class InvalidHttpRange(InvalidHttpResponse):
900
"""Invalid http range "%(range)s" for %(path)s: %(msg)s"""
1053
1054
_fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
901
1055
902
1056
def __init__(self, path, range, msg):
903
1057
self.range = range
905
1059
906
1060
907
1061
class InvalidHttpContentType(InvalidHttpResponse):
908
"""Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s"""
1062
1063
_fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
909
1064
910
1065
def __init__(self, path, ctype, msg):
911
1066
self.ctype = ctype
913
1068
914
1069
915
1070
class ConflictsInTree(BzrError):
916
def __init__(self):
917
BzrError.__init__(self, "Working tree has conflicts.")
1071
1072
_fmt = "Working tree has conflicts."
918
1073
919
1074
920
1075
class ParseConfigError(BzrError):
1076
921
1077
def __init__(self, errors, filename):
922
1078
if filename is None:
923
1079
filename = ""
926
1082
BzrError.__init__(self, message)
927
1083
928
1084
929
class NoEmailInUsername(BzrNewError):
930
"""%(username)r does not seem to contain a reasonable email address"""
1085
class NoEmailInUsername(BzrError):
1086
1087
_fmt = "%(username)r does not seem to contain a reasonable email address"
931
1088
932
1089
def __init__(self, username):
933
BzrNewError.__init__(self)
1090
BzrError.__init__(self)
934
1091
self.username = username
935
1092
936
1093
937
1094
class SigningFailed(BzrError):
1095
1096
_fmt = "Failed to gpg sign data with command %(command_line)r"
1097
938
1098
def __init__(self, command_line):
939
BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
940
% command_line)
1099
BzrError.__init__(self, command_line=command_line)
941
1100
942
1101
943
1102
class WorkingTreeNotRevision(BzrError):
1103
1104
_fmt = ("The working tree for %(basedir)s has changed since"
1105
" the last commit, but weave merge requires that it be"
1106
" unchanged")
1107
944
1108
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"""
1109
BzrError.__init__(self, basedir=tree.basedir)
1110
1111
1112
class CantReprocessAndShowBase(BzrError):
1113
1114
_fmt = "Can't reprocess and show base, because reprocessing obscures " \
1115
"the relationship of conflicting lines to the base"
1116
1117
1118
class GraphCycleError(BzrError):
1119
1120
_fmt = "Cycle in graph %(graph)r"
1121
977
1122
def __init__(self, graph):
978
BzrNewError.__init__(self)
1123
BzrError.__init__(self)
979
1124
self.graph = graph
980
1125
981
1126
982
class NotConflicted(BzrNewError):
983
"""File %(filename)s is not conflicted."""
1127
class WritingCompleted(BzrError):
1128
1129
_fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1130
"called upon it - accept bytes may not be called anymore.")
1131
1132
internal_error = True
1133
1134
def __init__(self, request):
1135
self.request = request
1136
1137
1138
class WritingNotComplete(BzrError):
1139
1140
_fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1141
"called upon it - until the write phase is complete no "
1142
"data may be read.")
1143
1144
internal_error = True
1145
1146
def __init__(self, request):
1147
self.request = request
1148
1149
1150
class NotConflicted(BzrError):
1151
1152
_fmt = "File %(filename)s is not conflicted."
984
1153
985
1154
def __init__(self, filename):
986
BzrNewError.__init__(self)
1155
BzrError.__init__(self)
987
1156
self.filename = filename
988
1157
989
1158
990
class MediumNotConnected(BzrNewError):
991
"""The medium '%(medium)s' is not connected."""
1159
class MediumNotConnected(BzrError):
1160
1161
_fmt = """The medium '%(medium)s' is not connected."""
1162
1163
internal_error = True
992
1164
993
1165
def __init__(self, medium):
994
BzrNewError.__init__(self)
995
1166
self.medium = medium
996
1167
997
1168
998
1169
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"""
1170
1171
_fmt = """A decorating function has requested its original command be used."""
1172
1173
1174
class NoBundleFound(BzrError):
1175
1176
_fmt = "No bundle was found in %(filename)s"
1177
1007
1178
def __init__(self, filename):
1008
BzrNewError.__init__(self)
1179
BzrError.__init__(self)
1009
1180
self.filename = filename
1010
1181
1011
1182
1012
class BundleNotSupported(BzrNewError):
1013
"""Unable to handle bundle version %(version)s: %(msg)s"""
1183
class BundleNotSupported(BzrError):
1184
1185
_fmt = "Unable to handle bundle version %(version)s: %(msg)s"
1186
1014
1187
def __init__(self, version, msg):
1015
BzrNewError.__init__(self)
1188
BzrError.__init__(self)
1016
1189
self.version = version
1017
1190
self.msg = msg
1018
1191
1019
1192
1020
class MissingText(BzrNewError):
1021
"""Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
1193
class MissingText(BzrError):
1194
1195
_fmt = "Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"
1022
1196
1023
1197
def __init__(self, branch, text_revision, file_id):
1024
BzrNewError.__init__(self)
1198
BzrError.__init__(self)
1025
1199
self.branch = branch
1026
1200
self.base = branch.base
1027
1201
self.text_revision = text_revision
1028
1202
self.file_id = file_id
1029
1203
1030
1204
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
"""
1205
class DuplicateKey(BzrError):
1206
1207
_fmt = "Key %(key)s is already present in map"
1208
1209
1210
class MalformedTransform(BzrError):
1211
1212
_fmt = "Tree transform is malformed %(conflicts)r"
1213
1214
1215
class NoFinalPath(BzrError):
1216
1217
_fmt = ("No final name for trans_id %(trans_id)r\n"
1218
"file-id: %(file_id)r\n"
1219
"root trans-id: %(root_trans_id)r\n")
1044
1220
1045
1221
def __init__(self, trans_id, transform):
1046
1222
self.trans_id = trans_id
1048
1224
self.root_trans_id = transform.root
1049
1225
1050
1226
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
"""
1227
class BzrBadParameter(BzrError):
1228
1229
_fmt = "Bad parameter: %(param)r"
1230
1231
# This exception should never be thrown, but it is a base class for all
1232
# parameter-to-function errors.
1233
1057
1234
def __init__(self, param):
1058
BzrNewError.__init__(self)
1235
BzrError.__init__(self)
1059
1236
self.param = param
1060
1237
1061
1238
1062
1239
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"""
1240
1241
_fmt = "Parameter %(param)s is neither unicode nor utf8."
1242
1243
1244
class ReusingTransform(BzrError):
1245
1246
_fmt = "Attempt to reuse a transform that has already been applied."
1247
1248
1249
class CantMoveRoot(BzrError):
1250
1251
_fmt = "Moving the root directory is not supported at this time"
1072
1252
1073
1253
1074
1254
class BzrBadParameterNotString(BzrBadParameter):
1075
"""Parameter %(param)s is not a string or unicode string."""
1255
1256
_fmt = "Parameter %(param)s is not a string or unicode string."
1076
1257
1077
1258
1078
1259
class BzrBadParameterMissing(BzrBadParameter):
1079
"""Parameter $(param)s is required but not present."""
1260
1261
_fmt = "Parameter $(param)s is required but not present."
1080
1262
1081
1263
1082
1264
class BzrBadParameterUnicode(BzrBadParameter):
1083
"""Parameter %(param)s is unicode but only byte-strings are permitted."""
1265
1266
_fmt = "Parameter %(param)s is unicode but only byte-strings are permitted."
1084
1267
1085
1268
1086
1269
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"""
1270
1271
_fmt = "Parameter %(param)s contains a newline."
1272
1273
1274
class DependencyNotPresent(BzrError):
1275
1276
_fmt = 'Unable to import library "%(library)s": %(error)s'
1092
1277
1093
1278
def __init__(self, library, error):
1094
BzrNewError.__init__(self, library=library, error=error)
1279
BzrError.__init__(self, library=library, error=error)
1095
1280
1096
1281
1097
1282
class ParamikoNotPresent(DependencyNotPresent):
1098
"""Unable to import paramiko (required for sftp support): %(error)s"""
1283
1284
_fmt = "Unable to import paramiko (required for sftp support): %(error)s"
1099
1285
1100
1286
def __init__(self, error):
1101
1287
DependencyNotPresent.__init__(self, 'paramiko', error)
1102
1288
1103
1289
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."""
1290
class PointlessMerge(BzrError):
1291
1292
_fmt = "Nothing to merge."
1293
1294
1295
class UninitializableFormat(BzrError):
1296
1297
_fmt = "Format %(format)s cannot be initialised by this version of bzr."
1110
1298
1111
1299
def __init__(self, format):
1112
BzrNewError.__init__(self)
1300
BzrError.__init__(self)
1113
1301
self.format = format
1114
1302
1115
1303
1116
class BadConversionTarget(BzrNewError):
1117
"""Cannot convert to format %(format)s. %(problem)s"""
1304
class BadConversionTarget(BzrError):
1305
1306
_fmt = "Cannot convert to format %(format)s. %(problem)s"
1118
1307
1119
1308
def __init__(self, problem, format):
1120
BzrNewError.__init__(self)
1309
BzrError.__init__(self)
1121
1310
self.problem = problem
1122
1311
self.format = format
1123
1312
1124
1313
1125
class NoDiff(BzrNewError):
1126
"""Diff is not installed on this machine: %(msg)s"""
1314
class NoDiff(BzrError):
1315
1316
_fmt = "Diff is not installed on this machine: %(msg)s"
1127
1317
1128
1318
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'."""
1319
BzrError.__init__(self, msg=msg)
1320
1321
1322
class NoDiff3(BzrError):
1323
1324
_fmt = "Diff3 is not installed on this machine."
1325
1326
1327
class ExistingLimbo(BzrError):
1328
1329
_fmt = """This tree contains left-over files from a failed operation.
1330
Please examine %(limbo_dir)s to see if it contains any files you wish to
1331
keep, and delete it when you are done."""
1332
1333
def __init__(self, limbo_dir):
1334
BzrError.__init__(self)
1335
self.limbo_dir = limbo_dir
1336
1337
1338
class ImmortalLimbo(BzrError):
1339
1340
_fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
1341
Please examine %(limbo_dir)s to see if it contains any files you wish to
1342
keep, and delete it when you are done."""
1343
1344
def __init__(self, limbo_dir):
1345
BzrError.__init__(self)
1346
self.limbo_dir = limbo_dir
1347
1348
1349
class OutOfDateTree(BzrError):
1350
1351
_fmt = "Working tree is out of date, please run 'bzr update'."
1158
1352
1159
1353
def __init__(self, tree):
1160
BzrNewError.__init__(self)
1354
BzrError.__init__(self)
1161
1355
self.tree = tree
1162
1356
1163
1357
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.
1358
class MergeModifiedFormatError(BzrError):
1359
1360
_fmt = "Error in merge modified format"
1361
1362
1363
class ConflictFormatError(BzrError):
1364
1365
_fmt = "Format error in conflict listings"
1366
1367
1368
class CorruptRepository(BzrError):
1369
1370
_fmt = """An error has been detected in the repository %(repo_path)s.
1174
1371
Please run bzr reconcile on this repository."""
1175
1372
1176
1373
def __init__(self, repo):
1177
BzrNewError.__init__(self)
1374
BzrError.__init__(self)
1178
1375
self.repo_path = repo.bzrdir.root_transport.base
1179
1376
1180
1377
1181
class UpgradeRequired(BzrNewError):
1182
"""To use this feature you must upgrade your branch at %(path)s."""
1378
class UpgradeRequired(BzrError):
1379
1380
_fmt = "To use this feature you must upgrade your branch at %(path)s."
1183
1381
1184
1382
def __init__(self, path):
1185
BzrNewError.__init__(self)
1383
BzrError.__init__(self)
1186
1384
self.path = path
1187
1385
1188
1386
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
1387
class LocalRequiresBoundBranch(BzrError):
1388
1389
_fmt = "Cannot perform local-only commits on unbound branches."
1390
1391
1392
class MissingProgressBarFinish(BzrError):
1393
1394
_fmt = "A nested progress bar was not 'finished' correctly."
1395
1396
1397
class InvalidProgressBarType(BzrError):
1398
1399
_fmt = """Environment variable BZR_PROGRESS_BAR='%(bar_type)s is not a supported type
1199
1400
Select one of: %(valid_types)s"""
1200
1401
1201
1402
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."""
1403
BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1404
1405
1406
class UnsupportedOperation(BzrError):
1407
1408
_fmt = "The method %(mname)s is not supported on objects of type %(tname)s."
1409
1207
1410
def __init__(self, method, method_self):
1208
1411
self.method = method
1209
1412
self.mname = method.__name__
1210
1413
self.tname = type(method_self).__name__
1211
1414
1212
1415
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"""
1416
class BinaryFile(BzrError):
1417
1418
_fmt = "File is binary but should be text."
1419
1420
1421
class IllegalPath(BzrError):
1422
1423
_fmt = "The path %(path)s is not permitted on this platform"
1219
1424
1220
1425
def __init__(self, path):
1221
BzrNewError.__init__(self)
1426
BzrError.__init__(self)
1222
1427
self.path = path
1223
1428
1224
1429
1225
class TestamentMismatch(BzrNewError):
1226
"""Testament did not match expected value.
1430
class TestamentMismatch(BzrError):
1431
1432
_fmt = """Testament did not match expected value.
1227
1433
For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
1228
{%(measured)s}
1229
"""
1434
{%(measured)s}"""
1435
1230
1436
def __init__(self, revision_id, expected, measured):
1231
1437
self.revision_id = revision_id
1232
1438
self.expected = expected
1233
1439
self.measured = measured
1234
1440
1235
1441
1236
class NotABundle(BzrNewError):
1237
"""Not a bzr revision-bundle: %(text)r"""
1442
class NotABundle(BzrError):
1443
1444
_fmt = "Not a bzr revision-bundle: %(text)r"
1238
1445
1239
1446
def __init__(self, text):
1240
BzrNewError.__init__(self)
1447
BzrError.__init__(self)
1241
1448
self.text = text
1242
1449
1243
1450
1244
class BadBundle(BzrNewError):
1245
"""Bad bzr revision-bundle: %(text)r"""
1451
class BadBundle(BzrError):
1452
1453
_fmt = "Bad bzr revision-bundle: %(text)r"
1246
1454
1247
1455
def __init__(self, text):
1248
BzrNewError.__init__(self)
1456
BzrError.__init__(self)
1249
1457
self.text = text
1250
1458
1251
1459
1252
1460
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
1461
1462
_fmt = "Malformed bzr revision-bundle header: %(text)r"
1258
1463
1259
1464
1260
1465
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
1466
1467
_fmt = "Malformed patches in bzr revision-bundle: %(text)r"
1266
1468
1267
1469
1268
1470
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
1471
1472
_fmt = "Malformed footer in bzr revision-bundle: %(text)r"
1274
1473
1275
1474
1276
1475
class UnsupportedEOLMarker(BadBundle):
1277
"""End of line marker was not \\n in bzr revision-bundle"""
1476
1477
_fmt = "End of line marker was not \\n in bzr revision-bundle"
1278
1478
1279
1479
def __init__(self):
1280
BzrNewError.__init__(self)
1281
1282
1283
class IncompatibleFormat(BzrNewError):
1284
"""Bundle format %(bundle_format)s is incompatible with %(other)s"""
1480
# XXX: BadBundle's constructor assumes there's explanatory text,
1481
# but for this there is not
1482
BzrError.__init__(self)
1483
1484
1485
class IncompatibleBundleFormat(BzrError):
1486
1487
_fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
1285
1488
1286
1489
def __init__(self, bundle_format, other):
1287
BzrNewError.__init__(self)
1490
BzrError.__init__(self)
1288
1491
self.bundle_format = bundle_format
1289
1492
self.other = other
1290
1493
1291
1494
1292
class BadInventoryFormat(BzrNewError):
1293
"""Root class for inventory serialization errors"""
1495
class BadInventoryFormat(BzrError):
1496
1497
_fmt = "Root class for inventory serialization errors"
1294
1498
1295
1499
1296
1500
class UnexpectedInventoryFormat(BadInventoryFormat):
1297
"""The inventory was not in the expected format:\n %(msg)s"""
1501
1502
_fmt = "The inventory was not in the expected format:\n %(msg)s"
1298
1503
1299
1504
def __init__(self, msg):
1300
1505
BadInventoryFormat.__init__(self, msg=msg)
1301
1506
1302
1507
1303
class NoSmartMedium(BzrNewError):
1304
"""The transport '%(transport)s' cannot tunnel the smart protocol."""
1508
class NoSmartMedium(BzrError):
1509
1510
_fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
1305
1511
1306
1512
def __init__(self, transport):
1307
BzrNewError.__init__(self)
1308
1513
self.transport = transport
1309
1514
1310
1515
1311
1516
class NoSmartServer(NotBranchError):
1312
"""No smart server available at %(url)s"""
1517
1518
_fmt = "No smart server available at %(url)s"
1313
1519
1314
1520
def __init__(self, url):
1315
1521
self.url = url
1316
1522
1317
1523
1318
class UnknownSSH(BzrNewError):
1319
"""Unrecognised value for BZR_SSH environment variable: %(vendor)s"""
1524
class UnknownSSH(BzrError):
1525
1526
_fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
1320
1527
1321
1528
def __init__(self, vendor):
1322
BzrNewError.__init__(self)
1529
BzrError.__init__(self)
1323
1530
self.vendor = vendor
1324
1531
1325
1532
1326
class GhostRevisionUnusableHere(BzrNewError):
1327
"""Ghost revision {%(revision_id)s} cannot be used here."""
1533
class GhostRevisionUnusableHere(BzrError):
1534
1535
_fmt = "Ghost revision {%(revision_id)s} cannot be used here."
1328
1536
1329
1537
def __init__(self, revision_id):
1330
BzrNewError.__init__(self)
1538
BzrError.__init__(self)
1331
1539
self.revision_id = revision_id
1332
1540
1333
1541
1334
class IllegalUseOfScopeReplacer(BzrNewError):
1335
"""ScopeReplacer object %(name)r was used incorrectly: %(msg)s%(extra)s"""
1336
1337
is_user_error = False
1542
class IllegalUseOfScopeReplacer(BzrError):
1543
1544
_fmt = "ScopeReplacer object %(name)r was used incorrectly: %(msg)s%(extra)s"
1545
1546
internal_error = True
1338
1547
1339
1548
def __init__(self, name, msg, extra=None):
1340
BzrNewError.__init__(self)
1549
BzrError.__init__(self)
1341
1550
self.name = name
1342
1551
self.msg = msg
1343
1552
if extra:
1346
1555
self.extra = ''
1347
1556
1348
1557
1349
class InvalidImportLine(BzrNewError):
1350
"""Not a valid import statement: %(msg)\n%(text)s"""
1351
1352
is_user_error = False
1558
class InvalidImportLine(BzrError):
1559
1560
_fmt = "Not a valid import statement: %(msg)\n%(text)s"
1561
1562
internal_error = True
1353
1563
1354
1564
def __init__(self, text, msg):
1355
BzrNewError.__init__(self)
1565
BzrError.__init__(self)
1356
1566
self.text = text
1357
1567
self.msg = msg
1358
1568
1359
1569
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
1570
class ImportNameCollision(BzrError):
1571
1572
_fmt = "Tried to import an object to the same name as an existing object. %(name)s"
1573
1574
internal_error = True
1364
1575
1365
1576
def __init__(self, name):
1366
BzrNewError.__init__(self)
1577
BzrError.__init__(self)
1367
1578
self.name = name
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0