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