~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Wouter van Heyst
  • Date: 2007-01-18 18:37:21 UTC
  • mto: (2234.3.3 0.14)
  • mto: This revision was merged to the branch mainline in revision 2243.
  • Revision ID: larstiq@larstiq.dyndns.org-20070118183721-78uzxifyyyoqxja9
(Alexander Belchenko) add windows installer check for python2.5

Show diffs side-by-side

added added

removed removed

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