~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

Update news and readme

- better explanation of dependencies

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
 
#
 
1
# -*- coding: UTF-8 -*-
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
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
Exceptions are caught at a high level to report errors to the user, and
 
20
might also be caught inside the program.  Therefore it needs to be
 
21
possible to convert them to a meaningful string, and also for them to be
 
22
interrogated by the program.
 
23
 
 
24
Exceptions are defined such that the arguments given to the constructor
 
25
are stored in the object as properties of the same name.  When the
 
26
object is printed as a string, the doc string of the class is used as
 
27
a format string with the property dictionary available to it.
 
28
 
 
29
This means that exceptions can used like this:
 
30
 
 
31
>>> import sys
 
32
>>> try:
 
33
...   raise NotBranchError(path='/foo/bar')
 
34
... except:
 
35
...   print sys.exc_type
 
36
...   print sys.exc_value
 
37
...   print sys.exc_value.path
 
38
bzrlib.errors.NotBranchError
 
39
Not a branch: /foo/bar
 
40
/foo/bar
 
41
 
 
42
Therefore:
 
43
 
 
44
 * create a new exception class for any class of error that can be
 
45
   usefully distinguished.
 
46
 
 
47
 * the printable form of an exception is generated by the base class
 
48
   __str__ method
18
49
"""
19
50
 
20
 
 
21
 
from bzrlib import (
22
 
    osutils,
23
 
    symbol_versioning,
24
 
    )
25
 
from bzrlib.patches import (
26
 
    MalformedHunkHeader,
27
 
    MalformedLine,
28
 
    MalformedPatchHeader,
29
 
    PatchConflict,
30
 
    PatchSyntax,
31
 
    )
32
 
 
 
51
# based on Scott James Remnant's hct error classes
33
52
 
34
53
# TODO: is there any value in providing the .args field used by standard
35
54
# python exceptions?   A list of values with no names seems less useful 
39
58
# constructed to make sure it will succeed.  But that says nothing about
40
59
# exceptions that are never raised.
41
60
 
42
 
# TODO: selftest assertRaises should probably also check that every error
43
 
# raised can be formatted as a string successfully, and without giving
44
 
# 'unprintable'.
 
61
# TODO: Convert all the other error classes here to BzrNewError, and eliminate
 
62
# the old one.
45
63
 
46
64
 
47
65
class BzrError(StandardError):
48
 
    """
49
 
    Base class for errors raised by bzrlib.
50
 
 
51
 
    :cvar internal_error: if True this was probably caused by a bzr bug and
52
 
    should be displayed with a traceback; if False (or absent) this was
53
 
    probably a user or environment error and they don't need the gory details.
54
 
    (That can be overridden by -Derror on the command line.)
55
 
 
56
 
    :cvar _fmt: Format string to display the error; this is expanded
57
 
    by the instance's dict.
58
 
    """
59
 
    
60
 
    internal_error = False
61
 
 
62
 
    def __init__(self, msg=None, **kwds):
63
 
        """Construct a new BzrError.
64
 
 
65
 
        There are two alternative forms for constructing these objects.
66
 
        Either a preformatted string may be passed, or a set of named
67
 
        arguments can be given.  The first is for generic "user" errors which
68
 
        are not intended to be caught and so do not need a specific subclass.
69
 
        The second case is for use with subclasses that provide a _fmt format
70
 
        string to print the arguments.  
71
 
 
72
 
        Keyword arguments are taken as parameters to the error, which can 
73
 
        be inserted into the format string template.  It's recommended 
74
 
        that subclasses override the __init__ method to require specific 
75
 
        parameters.
76
 
 
77
 
        :param msg: If given, this is the literal complete text for the error,
78
 
        not subject to expansion.
79
 
        """
80
 
        StandardError.__init__(self)
81
 
        if msg is not None:
82
 
            # I was going to deprecate this, but it actually turns out to be
83
 
            # quite handy - mbp 20061103.
84
 
            self._preformatted_string = msg
 
66
    def __str__(self):
 
67
        # XXX: Should we show the exception class in 
 
68
        # exceptions that don't provide their own message?  
 
69
        # maybe it should be done at a higher level
 
70
        ## n = self.__class__.__name__ + ': '
 
71
        n = ''
 
72
        if len(self.args) == 1:
 
73
            return str(self.args[0])
 
74
        elif len(self.args) == 2:
 
75
            # further explanation or suggestions
 
76
            try:
 
77
                return n + '\n  '.join([self.args[0]] + self.args[1])
 
78
            except TypeError:
 
79
                return n + "%r" % self
85
80
        else:
86
 
            self._preformatted_string = None
87
 
            for key, value in kwds.items():
88
 
                setattr(self, key, value)
89
 
 
90
 
    def __str__(self):
91
 
        s = getattr(self, '_preformatted_string', None)
92
 
        if s is not None:
93
 
            # contains a preformatted message; must be cast to plain str
94
 
            return str(s)
95
 
        try:
96
 
            fmt = self._get_format_string()
97
 
            if fmt:
98
 
                s = fmt % self.__dict__
99
 
                # __str__() should always return a 'str' object
100
 
                # never a 'unicode' object.
101
 
                if isinstance(s, unicode):
102
 
                    return s.encode('utf8')
103
 
                return s
104
 
        except (AttributeError, TypeError, NameError, ValueError, KeyError), e:
105
 
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
106
 
                % (self.__class__.__name__,
107
 
                   self.__dict__,
108
 
                   getattr(self, '_fmt', None),
109
 
                   e)
110
 
 
111
 
    def _get_format_string(self):
112
 
        """Return format string for this exception or None"""
113
 
        fmt = getattr(self, '_fmt', None)
114
 
        if fmt is not None:
115
 
            return fmt
116
 
        fmt = getattr(self, '__doc__', None)
117
 
        if fmt is not None:
118
 
            symbol_versioning.warn("%s uses its docstring as a format, "
119
 
                    "it should use _fmt instead" % self.__class__.__name__,
120
 
                    DeprecationWarning)
121
 
            return fmt
122
 
        return 'Unprintable exception %s: dict=%r, fmt=%r' \
123
 
            % (self.__class__.__name__,
124
 
               self.__dict__,
125
 
               getattr(self, '_fmt', None),
126
 
               )
 
81
            return n + `self.args`
127
82
 
128
83
 
129
84
class BzrNewError(BzrError):
130
 
    """Deprecated error base class."""
 
85
    """bzr error"""
131
86
    # base classes should override the docstring with their human-
132
87
    # readable explanation
133
88
 
134
 
    def __init__(self, *args, **kwds):
135
 
        # XXX: Use the underlying BzrError to always generate the args
136
 
        # attribute if it doesn't exist.  We can't use super here, because
137
 
        # exceptions are old-style classes in python2.4 (but new in 2.5).
138
 
        # --bmc, 20060426
139
 
        symbol_versioning.warn('BzrNewError was deprecated in bzr 0.13; '
140
 
             'please convert %s to use BzrError instead'
141
 
             % self.__class__.__name__,
142
 
             DeprecationWarning,
143
 
             stacklevel=2)
144
 
        BzrError.__init__(self, *args)
 
89
    def __init__(self, **kwds):
145
90
        for key, value in kwds.items():
146
91
            setattr(self, key, value)
147
92
 
148
93
    def __str__(self):
149
94
        try:
150
 
            # __str__() should always return a 'str' object
151
 
            # never a 'unicode' object.
152
 
            s = self.__doc__ % self.__dict__
153
 
            if isinstance(s, unicode):
154
 
                return s.encode('utf8')
155
 
            return s
156
 
        except (TypeError, NameError, ValueError, KeyError), e:
157
 
            return 'Unprintable exception %s(%r): %r' \
158
 
                % (self.__class__.__name__,
159
 
                   self.__dict__, e)
160
 
 
161
 
 
162
 
class AlreadyBuilding(BzrError):
163
 
    
164
 
    _fmt = "The tree builder is already building a tree."
165
 
 
166
 
 
167
 
class BzrCheckError(BzrError):
168
 
    
169
 
    _fmt = "Internal check failed: %(message)s"
170
 
 
171
 
    internal_error = True
172
 
 
 
95
            return self.__doc__ % self.__dict__
 
96
        except (NameError, ValueError, KeyError), e:
 
97
            return 'Unprintable exception %s: %s' \
 
98
                % (self.__class__.__name__, str(e))
 
99
 
 
100
 
 
101
class BzrCheckError(BzrNewError):
 
102
    """Internal check failed: %(message)s"""
173
103
    def __init__(self, message):
174
 
        BzrError.__init__(self)
175
104
        self.message = message
176
105
 
177
106
 
178
 
class DisabledMethod(BzrError):
179
 
 
180
 
    _fmt = "The smart server method '%(class_name)s' is disabled."
181
 
 
182
 
    internal_error = True
183
 
 
184
 
    def __init__(self, class_name):
185
 
        BzrError.__init__(self)
186
 
        self.class_name = class_name
187
 
 
188
 
 
189
 
class IncompatibleAPI(BzrError):
190
 
 
191
 
    _fmt = 'The API for "%(api)s" is not compatible with "%(wanted)s". '\
192
 
        'It supports versions "%(minimum)s" to "%(current)s".'
193
 
 
194
 
    def __init__(self, api, wanted, minimum, current):
195
 
        self.api = api
196
 
        self.wanted = wanted
197
 
        self.minimum = minimum
198
 
        self.current = current
199
 
 
200
 
 
201
 
class InvalidEntryName(BzrError):
202
 
    
203
 
    _fmt = "Invalid entry name: %(name)s"
204
 
 
205
 
    internal_error = True
206
 
 
 
107
class InvalidEntryName(BzrNewError):
 
108
    """Invalid entry name: %(name)s"""
207
109
    def __init__(self, name):
208
 
        BzrError.__init__(self)
209
110
        self.name = name
210
111
 
211
112
 
212
 
class InvalidRevisionNumber(BzrError):
213
 
    
214
 
    _fmt = "Invalid revision number %(revno)s"
215
 
 
 
113
class InvalidRevisionNumber(BzrNewError):
 
114
    """Invalid revision number %(revno)d"""
216
115
    def __init__(self, revno):
217
 
        BzrError.__init__(self)
218
116
        self.revno = revno
219
117
 
220
118
 
221
 
class InvalidRevisionId(BzrError):
222
 
 
223
 
    _fmt = "Invalid revision-id {%(revision_id)s} in %(branch)s"
224
 
 
225
 
    def __init__(self, revision_id, branch):
226
 
        # branch can be any string or object with __str__ defined
227
 
        BzrError.__init__(self)
228
 
        self.revision_id = revision_id
229
 
        self.branch = branch
230
 
 
231
 
class ReservedId(BzrError):
232
 
 
233
 
    _fmt = "Reserved revision-id {%(revision_id)s}"
234
 
 
235
 
    def __init__(self, revision_id):
236
 
        self.revision_id = revision_id
237
 
 
238
 
 
239
 
class NoHelpTopic(BzrError):
240
 
 
241
 
    _fmt = ("No help could be found for '%(topic)s'. "
242
 
        "Please use 'bzr help topics' to obtain a list of topics.")
243
 
 
244
 
    def __init__(self, topic):
245
 
        self.topic = topic
246
 
 
247
 
 
248
 
class NoSuchId(BzrError):
249
 
 
250
 
    _fmt = "The file id %(file_id)s is not present in the tree %(tree)s."
251
 
    
252
 
    def __init__(self, tree, file_id):
253
 
        BzrError.__init__(self)
254
 
        self.file_id = file_id
255
 
        self.tree = tree
256
 
 
257
 
 
258
 
class InventoryModified(BzrError):
259
 
 
260
 
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
261
 
            " so a clean inventory cannot be read without data loss.")
262
 
 
263
 
    internal_error = True
264
 
 
265
 
    def __init__(self, tree):
266
 
        self.tree = tree
267
 
 
268
 
 
269
 
class NoWorkingTree(BzrError):
270
 
 
271
 
    _fmt = "No WorkingTree exists for %(base)s."
272
 
    
273
 
    def __init__(self, base):
274
 
        BzrError.__init__(self)
275
 
        self.base = base
276
 
 
277
 
 
278
 
class NotBuilding(BzrError):
279
 
 
280
 
    _fmt = "Not currently building a tree."
281
 
 
282
 
 
283
 
class NotLocalUrl(BzrError):
284
 
 
285
 
    _fmt = "%(url)s is not a local path."
286
 
 
287
 
    def __init__(self, url):
288
 
        self.url = url
289
 
 
290
 
 
291
 
class WorkingTreeAlreadyPopulated(BzrError):
292
 
 
293
 
    _fmt = """Working tree already populated in %(base)s"""
294
 
 
295
 
    internal_error = True
296
 
 
297
 
    def __init__(self, base):
298
 
        self.base = base
 
119
class InvalidRevisionId(BzrNewError):
 
120
    """Invalid revision-id"""
 
121
 
299
122
 
300
123
class BzrCommandError(BzrError):
301
 
    """Error from user command"""
302
 
 
303
 
    internal_error = False
304
 
 
305
 
    # Error from malformed user command; please avoid raising this as a
306
 
    # generic exception not caused by user input.
307
 
    #
308
 
    # I think it's a waste of effort to differentiate between errors that
309
 
    # are not intended to be caught anyway.  UI code need not subclass
310
 
    # BzrCommandError, and non-UI code should not throw a subclass of
311
 
    # BzrCommandError.  ADHB 20051211
312
 
    def __init__(self, msg):
313
 
        # Object.__str__() must return a real string
314
 
        # returning a Unicode string is a python error.
315
 
        if isinstance(msg, unicode):
316
 
            self.msg = msg.encode('utf8')
317
 
        else:
318
 
            self.msg = msg
319
 
 
 
124
    # Error from malformed user command
320
125
    def __str__(self):
321
 
        return self.msg
322
 
 
323
 
 
324
 
class NotWriteLocked(BzrError):
325
 
 
326
 
    _fmt = """%(not_locked)r is not write locked but needs to be."""
327
 
 
328
 
    def __init__(self, not_locked):
329
 
        self.not_locked = not_locked
330
 
 
331
 
 
332
 
class BzrOptionError(BzrCommandError):
333
 
 
334
 
    _fmt = "Error in command line options"
335
 
 
336
 
 
337
 
class BadOptionValue(BzrError):
338
 
 
339
 
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
340
 
 
341
 
    def __init__(self, name, value):
342
 
        BzrError.__init__(self, name=name, value=value)
343
 
 
344
 
    
345
 
class StrictCommitFailed(BzrError):
346
 
 
347
 
    _fmt = "Commit refused because there are unknown files in the tree"
348
 
 
349
 
 
350
 
# XXX: Should be unified with TransportError; they seem to represent the
351
 
# same thing
352
 
# RBC 20060929: I think that unifiying with TransportError would be a mistake
353
 
# - this is finer than a TransportError - and more useful as such. It 
354
 
# differentiates between 'transport has failed' and 'operation on a transport
355
 
# has failed.'
356
 
class PathError(BzrError):
357
 
    
358
 
    _fmt = "Generic path error: %(path)r%(extra)s)"
359
 
 
360
 
    def __init__(self, path, extra=None):
361
 
        BzrError.__init__(self)
362
 
        self.path = path
363
 
        if extra:
364
 
            self.extra = ': ' + str(extra)
365
 
        else:
366
 
            self.extra = ''
367
 
 
368
 
 
369
 
class NoSuchFile(PathError):
370
 
 
371
 
    _fmt = "No such file: %(path)r%(extra)s"
372
 
 
373
 
 
374
 
class FileExists(PathError):
375
 
 
376
 
    _fmt = "File exists: %(path)r%(extra)s"
377
 
 
378
 
 
379
 
class RenameFailedFilesExist(BzrError):
380
 
    """Used when renaming and both source and dest exist."""
381
 
 
382
 
    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
383
 
            "%(extra)s")
384
 
 
385
 
    def __init__(self, source, dest, extra=None):
386
 
        BzrError.__init__(self)
387
 
        self.source = str(source)
388
 
        self.dest = str(dest)
389
 
        if extra:
390
 
            self.extra = ' ' + str(extra)
391
 
        else:
392
 
            self.extra = ''
393
 
 
394
 
 
395
 
class NotADirectory(PathError):
396
 
 
397
 
    _fmt = "%(path)r is not a directory %(extra)s"
398
 
 
399
 
 
400
 
class NotInWorkingDirectory(PathError):
401
 
 
402
 
    _fmt = "%(path)r is not in the working directory %(extra)s"
403
 
 
404
 
 
405
 
class DirectoryNotEmpty(PathError):
406
 
 
407
 
    _fmt = "Directory not empty: %(path)r%(extra)s"
408
 
 
409
 
 
410
 
class ReadingCompleted(BzrError):
411
 
    
412
 
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
413
 
            "called upon it - the request has been completed and no more "
414
 
            "data may be read.")
415
 
 
416
 
    internal_error = True
417
 
 
418
 
    def __init__(self, request):
419
 
        self.request = request
420
 
 
421
 
 
422
 
class ResourceBusy(PathError):
423
 
 
424
 
    _fmt = "Device or resource busy: %(path)r%(extra)s"
425
 
 
426
 
 
427
 
class PermissionDenied(PathError):
428
 
 
429
 
    _fmt = "Permission denied: %(path)r%(extra)s"
430
 
 
431
 
 
432
 
class InvalidURL(PathError):
433
 
 
434
 
    _fmt = "Invalid url supplied to transport: %(path)r%(extra)s"
435
 
 
436
 
 
437
 
class InvalidURLJoin(PathError):
438
 
 
439
 
    _fmt = "Invalid URL join request: %(args)s%(extra)s"
440
 
 
441
 
    def __init__(self, msg, base, args):
442
 
        PathError.__init__(self, base, msg)
443
 
        self.args = [base] + list(args)
444
 
 
445
 
 
446
 
class UnknownHook(BzrError):
447
 
 
448
 
    _fmt = "The %(type)s hook '%(hook)s' is unknown in this version of bzrlib."
449
 
 
450
 
    def __init__(self, hook_type, hook_name):
451
 
        BzrError.__init__(self)
452
 
        self.type = hook_type
453
 
        self.hook = hook_name
454
 
 
455
 
 
456
 
class UnsupportedProtocol(PathError):
457
 
 
458
 
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
459
 
 
460
 
    def __init__(self, url, extra):
461
 
        PathError.__init__(self, url, extra=extra)
462
 
 
463
 
 
464
 
class ReadError(PathError):
465
 
    
466
 
    _fmt = """Error reading from %(path)r."""
467
 
 
468
 
 
469
 
class ShortReadvError(PathError):
470
 
 
471
 
    _fmt = ("readv() read %(actual)s bytes rather than %(length)s bytes"
472
 
            " at %(offset)s for %(path)s%(extra)s")
473
 
 
474
 
    internal_error = True
475
 
 
476
 
    def __init__(self, path, offset, length, actual, extra=None):
477
 
        PathError.__init__(self, path, extra=extra)
478
 
        self.offset = offset
479
 
        self.length = length
480
 
        self.actual = actual
481
 
 
482
 
 
483
 
class PathNotChild(BzrError):
484
 
 
485
 
    _fmt = "Path %(path)r is not a child of path %(base)r%(extra)s"
486
 
 
487
 
    internal_error = True
488
 
 
489
 
    def __init__(self, path, base, extra=None):
490
 
        BzrError.__init__(self)
491
 
        self.path = path
492
 
        self.base = base
493
 
        if extra:
494
 
            self.extra = ': ' + str(extra)
495
 
        else:
496
 
            self.extra = ''
497
 
 
498
 
 
499
 
class InvalidNormalization(PathError):
500
 
 
501
 
    _fmt = "Path %(path)r is not unicode normalized"
502
 
 
503
 
 
504
 
# TODO: This is given a URL; we try to unescape it but doing that from inside
505
 
# the exception object is a bit undesirable.
506
 
# TODO: Probably this behavior of should be a common superclass 
507
 
class NotBranchError(PathError):
508
 
 
509
 
    _fmt = "Not a branch: %(path)s"
510
 
 
 
126
        return self.args[0]
 
127
 
 
128
class StrictCommitFailed(Exception):
 
129
    """Commit refused because there are unknowns in the tree."""
 
130
 
 
131
class NotBranchError(BzrNewError):
 
132
    """Not a branch: %(path)s"""
511
133
    def __init__(self, path):
512
 
       import bzrlib.urlutils as urlutils
513
 
       self.path = urlutils.unescape_for_display(path, 'ascii')
514
 
 
515
 
 
516
 
class NoSubmitBranch(PathError):
517
 
 
518
 
    _fmt = 'No submit branch available for branch "%(path)s"'
519
 
 
520
 
    def __init__(self, branch):
521
 
       import bzrlib.urlutils as urlutils
522
 
       self.path = urlutils.unescape_for_display(branch.base, 'ascii')
523
 
 
524
 
 
525
 
class AlreadyBranchError(PathError):
526
 
 
527
 
    _fmt = "Already a branch: %(path)s."
528
 
 
529
 
 
530
 
class BranchExistsWithoutWorkingTree(PathError):
531
 
 
532
 
    _fmt = "Directory contains a branch, but no working tree \
533
 
(use bzr checkout if you wish to build a working tree): %(path)s"
534
 
 
535
 
 
536
 
class AtomicFileAlreadyClosed(PathError):
537
 
 
538
 
    _fmt = ("'%(function)s' called on an AtomicFile after it was closed:"
539
 
            " %(path)s")
540
 
 
541
 
    def __init__(self, path, function):
542
 
        PathError.__init__(self, path=path, extra=None)
543
 
        self.function = function
544
 
 
545
 
 
546
 
class InaccessibleParent(PathError):
547
 
 
548
 
    _fmt = ("Parent not accessible given base %(base)s and"
549
 
            " relative path %(path)s")
550
 
 
551
 
    def __init__(self, path, base):
552
 
        PathError.__init__(self, path)
553
 
        self.base = base
554
 
 
555
 
 
556
 
class NoRepositoryPresent(BzrError):
557
 
 
558
 
    _fmt = "No repository present: %(path)r"
559
 
    def __init__(self, bzrdir):
560
 
        BzrError.__init__(self)
561
 
        self.path = bzrdir.transport.clone('..').base
562
 
 
563
 
 
564
 
class FileInWrongBranch(BzrError):
565
 
 
566
 
    _fmt = "File %(path)s in not in branch %(branch_base)s."
567
 
 
568
 
    def __init__(self, branch, path):
569
 
        BzrError.__init__(self)
570
 
        self.branch = branch
571
 
        self.branch_base = branch.base
 
134
        BzrNewError.__init__(self)
572
135
        self.path = path
573
136
 
574
137
 
575
138
class UnsupportedFormatError(BzrError):
576
 
 
577
 
    _fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
578
 
 
579
 
 
580
 
class UnknownFormatError(BzrError):
581
 
    
582
 
    _fmt = "Unknown branch format: %(format)r"
583
 
 
584
 
 
585
 
class IncompatibleFormat(BzrError):
586
 
    
587
 
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
588
 
 
589
 
    def __init__(self, format, bzrdir_format):
590
 
        BzrError.__init__(self)
591
 
        self.format = format
592
 
        self.bzrdir = bzrdir_format
593
 
 
594
 
 
595
 
class IncompatibleRepositories(BzrError):
596
 
 
597
 
    _fmt = "Repository %(target)s is not compatible with repository"\
598
 
        " %(source)s"
599
 
 
600
 
    def __init__(self, source, target):
601
 
        BzrError.__init__(self, target=target, source=source)
602
 
 
603
 
 
604
 
class IncompatibleRevision(BzrError):
605
 
    
606
 
    _fmt = "Revision is not compatible with %(repo_format)s"
607
 
 
608
 
    def __init__(self, repo_format):
609
 
        BzrError.__init__(self)
610
 
        self.repo_format = repo_format
611
 
 
612
 
 
613
 
class AlreadyVersionedError(BzrError):
614
 
    """Used when a path is expected not to be versioned, but it is."""
615
 
 
616
 
    _fmt = "%(context_info)s%(path)s is already versioned"
617
 
 
618
 
    def __init__(self, path, context_info=None):
619
 
        """Construct a new AlreadyVersionedError.
620
 
 
621
 
        :param path: This is the path which is versioned,
622
 
        which should be in a user friendly form.
623
 
        :param context_info: If given, this is information about the context,
624
 
        which could explain why this is expected to not be versioned.
625
 
        """
626
 
        BzrError.__init__(self)
627
 
        self.path = path
628
 
        if context_info is None:
629
 
            self.context_info = ''
630
 
        else:
631
 
            self.context_info = context_info + ". "
632
 
 
633
 
 
634
 
class NotVersionedError(BzrError):
635
 
    """Used when a path is expected to be versioned, but it is not."""
636
 
 
637
 
    _fmt = "%(context_info)s%(path)s is not versioned"
638
 
 
639
 
    def __init__(self, path, context_info=None):
640
 
        """Construct a new NotVersionedError.
641
 
 
642
 
        :param path: This is the path which is not versioned,
643
 
        which should be in a user friendly form.
644
 
        :param context_info: If given, this is information about the context,
645
 
        which could explain why this is expected to be versioned.
646
 
        """
647
 
        BzrError.__init__(self)
648
 
        self.path = path
649
 
        if context_info is None:
650
 
            self.context_info = ''
651
 
        else:
652
 
            self.context_info = context_info + ". "
653
 
 
654
 
 
655
 
class PathsNotVersionedError(BzrError):
656
 
    """Used when reporting several paths which are not versioned"""
657
 
 
658
 
    _fmt = "Path(s) are not versioned: %(paths_as_string)s"
659
 
 
660
 
    def __init__(self, paths):
661
 
        from bzrlib.osutils import quotefn
662
 
        BzrError.__init__(self)
663
 
        self.paths = paths
664
 
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
665
 
 
666
 
 
667
 
class PathsDoNotExist(BzrError):
668
 
 
669
 
    _fmt = "Path(s) do not exist: %(paths_as_string)s%(extra)s"
670
 
 
671
 
    # used when reporting that paths are neither versioned nor in the working
672
 
    # tree
673
 
 
674
 
    def __init__(self, paths, extra=None):
675
 
        # circular import
676
 
        from bzrlib.osutils import quotefn
677
 
        BzrError.__init__(self)
678
 
        self.paths = paths
679
 
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
680
 
        if extra:
681
 
            self.extra = ': ' + str(extra)
682
 
        else:
683
 
            self.extra = ''
 
139
    """Specified path is a bzr branch that we cannot read."""
 
140
    def __str__(self):
 
141
        return 'unsupported branch format: %s' % self.args[0]
 
142
 
 
143
 
 
144
class NotVersionedError(BzrNewError):
 
145
    """%(path)s is not versioned"""
 
146
    def __init__(self, path):
 
147
        BzrNewError.__init__(self)
 
148
        self.path = path
684
149
 
685
150
 
686
151
class BadFileKindError(BzrError):
687
 
 
688
 
    _fmt = 'Cannot operate on "%(filename)s" of unsupported kind "%(kind)s"'
689
 
 
690
 
    def __init__(self, filename, kind):
691
 
        BzrError.__init__(self, filename=filename, kind=kind)
692
 
 
693
 
 
694
 
class ForbiddenControlFileError(BzrError):
695
 
 
696
 
    _fmt = "Cannot operate on %(filename)s because it is a control file"
697
 
 
698
 
 
699
 
class LockError(BzrError):
700
 
 
701
 
    _fmt = "Lock error: %(msg)s"
702
 
 
703
 
    internal_error = True
704
 
 
 
152
    """Specified file is of a kind that cannot be added.
 
153
 
 
154
    (For example a symlink or device file.)"""
 
155
 
 
156
 
 
157
class ForbiddenFileError(BzrError):
 
158
    """Cannot operate on a file because it is a control file."""
 
159
 
 
160
 
 
161
class LockError(Exception):
 
162
    """Lock error"""
705
163
    # All exceptions from the lock/unlock functions should be from
706
164
    # this exception class.  They will be translated as necessary. The
707
165
    # original exception is available as e.original_error
708
 
    #
709
 
    # New code should prefer to raise specific subclasses
710
 
    def __init__(self, message):
711
 
        # Python 2.5 uses a slot for StandardError.message,
712
 
        # so use a different variable name
713
 
        # so it is exposed in self.__dict__
714
 
        self.msg = message
715
 
 
716
 
 
717
 
class LockActive(LockError):
718
 
 
719
 
    _fmt = "The lock for '%(lock_description)s' is in use and cannot be broken."
720
 
 
721
 
    internal_error = False
722
 
 
723
 
    def __init__(self, lock_description):
724
 
        self.lock_description = lock_description
725
166
 
726
167
 
727
168
class CommitNotPossible(LockError):
728
 
 
729
 
    _fmt = "A commit was attempted but we do not have a write lock open."
730
 
 
731
 
    def __init__(self):
732
 
        pass
 
169
    """A commit was attempted but we do not have a write lock open."""
733
170
 
734
171
 
735
172
class AlreadyCommitted(LockError):
736
 
 
737
 
    _fmt = "A rollback was requested, but is not able to be accomplished."
738
 
 
739
 
    def __init__(self):
740
 
        pass
 
173
    """A rollback was requested, but is not able to be accomplished."""
741
174
 
742
175
 
743
176
class ReadOnlyError(LockError):
744
 
 
745
 
    _fmt = "A write attempt was made in a read only transaction on %(obj)s"
746
 
 
747
 
    # TODO: There should also be an error indicating that you need a write
748
 
    # lock and don't have any lock at all... mbp 20070226
749
 
 
750
 
    def __init__(self, obj):
751
 
        self.obj = obj
752
 
 
753
 
 
754
 
class ReadOnlyLockError(LockError):
755
 
 
756
 
    _fmt = "Cannot acquire write lock on %(fname)s. %(msg)s"
757
 
 
758
 
    def __init__(self, fname, msg):
759
 
        LockError.__init__(self, '')
760
 
        self.fname = fname
761
 
        self.msg = msg
762
 
 
763
 
 
764
 
class OutSideTransaction(BzrError):
765
 
 
766
 
    _fmt = ("A transaction related operation was attempted after"
767
 
            " the transaction finished.")
768
 
 
769
 
 
770
 
class ObjectNotLocked(LockError):
771
 
 
772
 
    _fmt = "%(obj)r is not locked"
773
 
 
774
 
    # this can indicate that any particular object is not locked; see also
775
 
    # LockNotHeld which means that a particular *lock* object is not held by
776
 
    # the caller -- perhaps they should be unified.
777
 
    def __init__(self, obj):
778
 
        self.obj = obj
779
 
 
780
 
 
781
 
class ReadOnlyObjectDirtiedError(ReadOnlyError):
782
 
 
783
 
    _fmt = "Cannot change object %(obj)r in read only transaction"
784
 
 
785
 
    def __init__(self, obj):
786
 
        self.obj = obj
787
 
 
788
 
 
789
 
class UnlockableTransport(LockError):
790
 
 
791
 
    _fmt = "Cannot lock: transport is read only: %(transport)s"
792
 
 
793
 
    def __init__(self, transport):
794
 
        self.transport = transport
795
 
 
796
 
 
797
 
class LockContention(LockError):
798
 
 
799
 
    _fmt = "Could not acquire lock %(lock)s"
800
 
    # TODO: show full url for lock, combining the transport and relative
801
 
    # bits?
802
 
 
803
 
    internal_error = False
804
 
 
805
 
    def __init__(self, lock):
806
 
        self.lock = lock
807
 
 
808
 
 
809
 
class LockBroken(LockError):
810
 
 
811
 
    _fmt = ("Lock was broken while still open: %(lock)s"
812
 
            " - check storage consistency!")
813
 
 
814
 
    internal_error = False
815
 
 
816
 
    def __init__(self, lock):
817
 
        self.lock = lock
818
 
 
819
 
 
820
 
class LockBreakMismatch(LockError):
821
 
 
822
 
    _fmt = ("Lock was released and re-acquired before being broken:"
823
 
            " %(lock)s: held by %(holder)r, wanted to break %(target)r")
824
 
 
825
 
    internal_error = False
826
 
 
827
 
    def __init__(self, lock, holder, target):
828
 
        self.lock = lock
829
 
        self.holder = holder
830
 
        self.target = target
831
 
 
832
 
 
833
 
class LockNotHeld(LockError):
834
 
 
835
 
    _fmt = "Lock not held: %(lock)s"
836
 
 
837
 
    internal_error = False
838
 
 
839
 
    def __init__(self, lock):
840
 
        self.lock = lock
841
 
 
842
 
 
843
 
class TokenLockingNotSupported(LockError):
844
 
 
845
 
    _fmt = "The object %(obj)s does not support token specifying a token when locking."
846
 
 
847
 
    internal_error = True
848
 
 
849
 
    def __init__(self, obj):
850
 
        self.obj = obj
851
 
 
852
 
 
853
 
class TokenMismatch(LockBroken):
854
 
 
855
 
    _fmt = "The lock token %(given_token)r does not match lock token %(lock_token)r."
856
 
 
857
 
    internal_error = True
858
 
 
859
 
    def __init__(self, given_token, lock_token):
860
 
        self.given_token = given_token
861
 
        self.lock_token = lock_token
862
 
 
863
 
 
864
 
class PointlessCommit(BzrError):
865
 
 
866
 
    _fmt = "No changes to commit"
867
 
 
868
 
 
869
 
class CannotCommitSelectedFileMerge(BzrError):
870
 
 
871
 
    _fmt = 'Selected-file commit of merges is not supported yet:'\
872
 
        ' files %(files_str)s'
873
 
 
874
 
    def __init__(self, files):
875
 
        files_str = ', '.join(files)
876
 
        BzrError.__init__(self, files=files, files_str=files_str)
877
 
 
878
 
 
879
 
class UpgradeReadonly(BzrError):
880
 
 
881
 
    _fmt = "Upgrade URL cannot work with readonly URLs."
882
 
 
883
 
 
884
 
class UpToDateFormat(BzrError):
885
 
 
886
 
    _fmt = "The branch format %(format)s is already at the most recent format."
887
 
 
888
 
    def __init__(self, format):
889
 
        BzrError.__init__(self)
890
 
        self.format = format
891
 
 
892
 
 
893
 
class StrictCommitFailed(Exception):
894
 
 
895
 
    _fmt = "Commit refused because there are unknowns in the tree."
 
177
    """A write attempt was made in a read only transaction."""
 
178
 
 
179
 
 
180
class PointlessCommit(BzrNewError):
 
181
    """No changes to commit"""
896
182
 
897
183
 
898
184
class NoSuchRevision(BzrError):
899
 
 
900
 
    _fmt = "Branch %(branch)s has no revision %(revision)s"
901
 
 
902
 
    internal_error = True
903
 
 
904
185
    def __init__(self, branch, revision):
905
 
        BzrError.__init__(self, branch=branch, revision=revision)
906
 
 
907
 
 
908
 
class NotLeftParentDescendant(BzrError):
909
 
 
910
 
    _fmt = ("Revision %(old_revision)s is not the left parent of"
911
 
            " %(new_revision)s, but branch %(branch_location)s expects this")
912
 
 
913
 
    internal_error = True
914
 
 
915
 
    def __init__(self, branch, old_revision, new_revision):
916
 
        BzrError.__init__(self, branch_location=branch.base,
917
 
                          old_revision=old_revision,
918
 
                          new_revision=new_revision)
919
 
 
920
 
 
921
 
class NoSuchRevisionSpec(BzrError):
922
 
 
923
 
    _fmt = "No namespace registered for string: %(spec)r"
924
 
 
925
 
    def __init__(self, spec):
926
 
        BzrError.__init__(self, spec=spec)
927
 
 
928
 
 
929
 
class NoSuchRevisionInTree(NoSuchRevision):
930
 
    """When using Tree.revision_tree, and the revision is not accessible."""
931
 
    
932
 
    _fmt = "The revision id %(revision_id)s is not present in the tree %(tree)s."
933
 
 
934
 
    def __init__(self, tree, revision_id):
935
 
        BzrError.__init__(self)
936
 
        self.tree = tree
937
 
        self.revision_id = revision_id
938
 
 
939
 
 
940
 
class InvalidRevisionSpec(BzrError):
941
 
 
942
 
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
943
 
            " %(branch)s%(extra)s")
944
 
 
945
 
    def __init__(self, spec, branch, extra=None):
946
 
        BzrError.__init__(self, branch=branch, spec=spec)
947
 
        if extra:
948
 
            self.extra = '\n' + str(extra)
949
 
        else:
950
 
            self.extra = ''
 
186
        self.branch = branch
 
187
        self.revision = revision
 
188
        msg = "Branch %s has no revision %s" % (branch, revision)
 
189
        BzrError.__init__(self, msg)
951
190
 
952
191
 
953
192
class HistoryMissing(BzrError):
954
 
 
955
 
    _fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"
956
 
 
957
 
 
958
 
class AppendRevisionsOnlyViolation(BzrError):
959
 
 
960
 
    _fmt = ('Operation denied because it would change the main history,'
961
 
           ' which is not permitted by the append_revisions_only setting on'
962
 
           ' branch "%(location)s".')
963
 
 
964
 
    def __init__(self, location):
965
 
       import bzrlib.urlutils as urlutils
966
 
       location = urlutils.unescape_for_display(location, 'ascii')
967
 
       BzrError.__init__(self, location=location)
 
193
    def __init__(self, branch, object_type, object_id):
 
194
        self.branch = branch
 
195
        BzrError.__init__(self,
 
196
                          '%s is missing %s {%s}'
 
197
                          % (branch, object_type, object_id))
968
198
 
969
199
 
970
200
class DivergedBranches(BzrError):
971
 
 
972
 
    _fmt = ("These branches have diverged."
973
 
            " Use the merge command to reconcile them.")
974
 
 
975
 
    internal_error = False
976
 
 
977
201
    def __init__(self, branch1, branch2):
 
202
        BzrError.__init__(self, "These branches have diverged.")
978
203
        self.branch1 = branch1
979
204
        self.branch2 = branch2
980
205
 
981
206
 
982
 
class NotLefthandHistory(BzrError):
983
 
 
984
 
    _fmt = "Supplied history does not follow left-hand parents"
985
 
 
986
 
    internal_error = True
987
 
 
988
 
    def __init__(self, history):
989
 
        BzrError.__init__(self, history=history)
990
 
 
991
 
 
992
 
class UnrelatedBranches(BzrError):
993
 
 
994
 
    _fmt = ("Branches have no common ancestor, and"
995
 
            " no merge base revision was specified.")
996
 
 
997
 
    internal_error = False
998
 
 
 
207
class UnrelatedBranches(BzrCommandError):
 
208
    def __init__(self):
 
209
        msg = "Branches have no common ancestor, and no base revision"\
 
210
            " specified."
 
211
        BzrCommandError.__init__(self, msg)
999
212
 
1000
213
class NoCommonAncestor(BzrError):
1001
 
    
1002
 
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1003
 
 
1004
214
    def __init__(self, revision_a, revision_b):
1005
 
        self.revision_a = revision_a
1006
 
        self.revision_b = revision_b
1007
 
 
 
215
        msg = "Revisions have no common ancestor: %s %s." \
 
216
            % (revision_a, revision_b) 
 
217
        BzrError.__init__(self, msg)
1008
218
 
1009
219
class NoCommonRoot(BzrError):
1010
 
 
1011
 
    _fmt = ("Revisions are not derived from the same root: "
1012
 
           "%(revision_a)s %(revision_b)s.")
1013
 
 
1014
220
    def __init__(self, revision_a, revision_b):
1015
 
        BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
1016
 
 
1017
 
 
1018
 
class NotAncestor(BzrError):
1019
 
 
1020
 
    _fmt = "Revision %(rev_id)s is not an ancestor of %(not_ancestor_id)s"
1021
 
 
1022
 
    def __init__(self, rev_id, not_ancestor_id):
1023
 
        BzrError.__init__(self, rev_id=rev_id,
1024
 
            not_ancestor_id=not_ancestor_id)
 
221
        msg = "Revisions are not derived from the same root: %s %s." \
 
222
            % (revision_a, revision_b) 
 
223
        BzrError.__init__(self, msg)
 
224
 
 
225
class NotAncestor(BzrError):
 
226
    def __init__(self, rev_id, not_ancestor_id):
 
227
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
 
228
                                                        rev_id)
 
229
        BzrError.__init__(self, msg)
 
230
        self.rev_id = rev_id
 
231
        self.not_ancestor_id = not_ancestor_id
 
232
 
 
233
 
 
234
class NotAncestor(BzrError):
 
235
    def __init__(self, rev_id, not_ancestor_id):
 
236
        self.rev_id = rev_id
 
237
        self.not_ancestor_id = not_ancestor_id
 
238
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
 
239
                                                        rev_id)
 
240
        BzrError.__init__(self, msg)
1025
241
 
1026
242
 
1027
243
class InstallFailed(BzrError):
1028
 
 
1029
244
    def __init__(self, revisions):
1030
 
        revision_str = ", ".join(str(r) for r in revisions)
1031
 
        msg = "Could not install revisions:\n%s" % revision_str
 
245
        msg = "Could not install revisions:\n%s" % " ,".join(revisions)
1032
246
        BzrError.__init__(self, msg)
1033
247
        self.revisions = revisions
1034
248
 
1035
249
 
1036
250
class AmbiguousBase(BzrError):
1037
 
 
1038
251
    def __init__(self, bases):
1039
 
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
1040
 
                DeprecationWarning)
1041
 
        msg = ("The correct base is unclear, because %s are all equally close"
1042
 
                % ", ".join(bases))
 
252
        msg = "The correct base is unclear, becase %s are all equally close" %\
 
253
            ", ".join(bases)
1043
254
        BzrError.__init__(self, msg)
1044
255
        self.bases = bases
1045
256
 
1046
 
 
1047
257
class NoCommits(BzrError):
1048
 
 
1049
 
    _fmt = "Branch %(branch)s has no commits."
1050
 
 
1051
258
    def __init__(self, branch):
1052
 
        BzrError.__init__(self, branch=branch)
1053
 
 
 
259
        msg = "Branch %s has no commits." % branch
 
260
        BzrError.__init__(self, msg)
1054
261
 
1055
262
class UnlistableStore(BzrError):
1056
 
 
1057
263
    def __init__(self, store):
1058
264
        BzrError.__init__(self, "Store %s is not listable" % store)
1059
265
 
1060
 
 
1061
 
 
1062
266
class UnlistableBranch(BzrError):
1063
 
 
1064
267
    def __init__(self, br):
1065
268
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
1066
269
 
1067
270
 
1068
 
class BoundBranchOutOfDate(BzrError):
1069
 
 
1070
 
    _fmt = ("Bound branch %(branch)s is out of date"
1071
 
            " with master branch %(master)s.")
1072
 
 
1073
 
    def __init__(self, branch, master):
1074
 
        BzrError.__init__(self)
1075
 
        self.branch = branch
1076
 
        self.master = master
1077
 
 
1078
 
        
1079
 
class CommitToDoubleBoundBranch(BzrError):
1080
 
 
1081
 
    _fmt = ("Cannot commit to branch %(branch)s."
1082
 
            " It is bound to %(master)s, which is bound to %(remote)s.")
1083
 
 
1084
 
    def __init__(self, branch, master, remote):
1085
 
        BzrError.__init__(self)
1086
 
        self.branch = branch
1087
 
        self.master = master
1088
 
        self.remote = remote
1089
 
 
1090
 
 
1091
 
class OverwriteBoundBranch(BzrError):
1092
 
 
1093
 
    _fmt = "Cannot pull --overwrite to a branch which is bound %(branch)s"
1094
 
 
1095
 
    def __init__(self, branch):
1096
 
        BzrError.__init__(self)
1097
 
        self.branch = branch
1098
 
 
1099
 
 
1100
 
class BoundBranchConnectionFailure(BzrError):
1101
 
 
1102
 
    _fmt = ("Unable to connect to target of bound branch %(branch)s"
1103
 
            " => %(target)s: %(error)s")
1104
 
 
1105
 
    def __init__(self, branch, target, error):
1106
 
        BzrError.__init__(self)
1107
 
        self.branch = branch
1108
 
        self.target = target
1109
 
        self.error = error
1110
 
 
1111
 
 
1112
 
class WeaveError(BzrError):
1113
 
 
1114
 
    _fmt = "Error in processing weave: %(message)s"
1115
 
 
1116
 
    def __init__(self, message=None):
1117
 
        BzrError.__init__(self)
1118
 
        self.message = message
1119
 
 
1120
 
 
1121
 
class WeaveRevisionAlreadyPresent(WeaveError):
1122
 
 
1123
 
    _fmt = "Revision {%(revision_id)s} already present in %(weave)s"
1124
 
 
1125
 
    def __init__(self, revision_id, weave):
1126
 
 
1127
 
        WeaveError.__init__(self)
1128
 
        self.revision_id = revision_id
1129
 
        self.weave = weave
1130
 
 
1131
 
 
1132
 
class WeaveRevisionNotPresent(WeaveError):
1133
 
 
1134
 
    _fmt = "Revision {%(revision_id)s} not present in %(weave)s"
1135
 
 
1136
 
    def __init__(self, revision_id, weave):
1137
 
        WeaveError.__init__(self)
1138
 
        self.revision_id = revision_id
1139
 
        self.weave = weave
1140
 
 
1141
 
 
1142
 
class WeaveFormatError(WeaveError):
1143
 
 
1144
 
    _fmt = "Weave invariant violated: %(what)s"
1145
 
 
1146
 
    def __init__(self, what):
1147
 
        WeaveError.__init__(self)
1148
 
        self.what = what
1149
 
 
1150
 
 
1151
 
class WeaveParentMismatch(WeaveError):
1152
 
 
1153
 
    _fmt = "Parents are mismatched between two revisions."
1154
 
    
1155
 
 
1156
 
class WeaveInvalidChecksum(WeaveError):
1157
 
 
1158
 
    _fmt = "Text did not match it's checksum: %(message)s"
1159
 
 
1160
 
 
1161
 
class WeaveTextDiffers(WeaveError):
1162
 
 
1163
 
    _fmt = ("Weaves differ on text content. Revision:"
1164
 
            " {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1165
 
 
1166
 
    def __init__(self, revision_id, weave_a, weave_b):
1167
 
        WeaveError.__init__(self)
1168
 
        self.revision_id = revision_id
1169
 
        self.weave_a = weave_a
1170
 
        self.weave_b = weave_b
1171
 
 
1172
 
 
1173
 
class WeaveTextDiffers(WeaveError):
1174
 
 
1175
 
    _fmt = ("Weaves differ on text content. Revision:"
1176
 
            " {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1177
 
 
1178
 
    def __init__(self, revision_id, weave_a, weave_b):
1179
 
        WeaveError.__init__(self)
1180
 
        self.revision_id = revision_id
1181
 
        self.weave_a = weave_a
1182
 
        self.weave_b = weave_b
1183
 
 
1184
 
 
1185
 
class VersionedFileError(BzrError):
1186
 
    
1187
 
    _fmt = "Versioned file error"
1188
 
 
1189
 
 
1190
 
class RevisionNotPresent(VersionedFileError):
1191
 
    
1192
 
    _fmt = "Revision {%(revision_id)s} not present in %(file_id)s."
1193
 
 
1194
 
    def __init__(self, revision_id, file_id):
1195
 
        VersionedFileError.__init__(self)
1196
 
        self.revision_id = revision_id
1197
 
        self.file_id = file_id
1198
 
 
1199
 
 
1200
 
class RevisionAlreadyPresent(VersionedFileError):
1201
 
    
1202
 
    _fmt = "Revision {%(revision_id)s} already present in %(file_id)s."
1203
 
 
1204
 
    def __init__(self, revision_id, file_id):
1205
 
        VersionedFileError.__init__(self)
1206
 
        self.revision_id = revision_id
1207
 
        self.file_id = file_id
1208
 
 
1209
 
 
1210
 
class KnitError(BzrError):
1211
 
    
1212
 
    _fmt = "Knit error"
1213
 
 
1214
 
    internal_error = True
1215
 
 
1216
 
 
1217
 
class KnitHeaderError(KnitError):
1218
 
 
1219
 
    _fmt = "Knit header error: %(badline)r unexpected for file %(filename)s"
1220
 
 
1221
 
    def __init__(self, badline, filename):
1222
 
        KnitError.__init__(self)
1223
 
        self.badline = badline
1224
 
        self.filename = filename
1225
 
 
1226
 
 
1227
 
class KnitCorrupt(KnitError):
1228
 
 
1229
 
    _fmt = "Knit %(filename)s corrupt: %(how)s"
1230
 
 
1231
 
    def __init__(self, filename, how):
1232
 
        KnitError.__init__(self)
1233
 
        self.filename = filename
1234
 
        self.how = how
1235
 
 
1236
 
 
1237
 
class KnitIndexUnknownMethod(KnitError):
1238
 
    """Raised when we don't understand the storage method.
1239
 
 
1240
 
    Currently only 'fulltext' and 'line-delta' are supported.
1241
 
    """
1242
 
    
1243
 
    _fmt = ("Knit index %(filename)s does not have a known method"
1244
 
            " in options: %(options)r")
1245
 
 
1246
 
    def __init__(self, filename, options):
1247
 
        KnitError.__init__(self)
1248
 
        self.filename = filename
1249
 
        self.options = options
1250
 
 
1251
 
 
1252
 
class NoSuchExportFormat(BzrError):
1253
 
    
1254
 
    _fmt = "Export format %(format)r not supported"
1255
 
 
1256
 
    def __init__(self, format):
1257
 
        BzrError.__init__(self)
1258
 
        self.format = format
1259
 
 
 
271
from bzrlib.weave import WeaveError, WeaveParentMismatch
1260
272
 
1261
273
class TransportError(BzrError):
1262
 
    
1263
 
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1264
 
 
 
274
    """All errors thrown by Transport implementations should derive
 
275
    from this class.
 
276
    """
1265
277
    def __init__(self, msg=None, orig_error=None):
1266
278
        if msg is None and orig_error is not None:
1267
279
            msg = str(orig_error)
1268
 
        if orig_error is None:
1269
 
            orig_error = ''
1270
 
        if msg is None:
1271
 
            msg =  ''
 
280
        BzrError.__init__(self, msg)
1272
281
        self.msg = msg
1273
282
        self.orig_error = orig_error
1274
 
        BzrError.__init__(self)
1275
 
 
1276
 
 
1277
 
class TooManyConcurrentRequests(BzrError):
1278
 
 
1279
 
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
1280
 
            " Be sure to finish_writing and finish_reading on the"
1281
 
            " currently open request.")
1282
 
 
1283
 
    internal_error = True
1284
 
 
1285
 
    def __init__(self, medium):
1286
 
        self.medium = medium
1287
 
 
1288
 
 
1289
 
class SmartProtocolError(TransportError):
1290
 
 
1291
 
    _fmt = "Generic bzr smart protocol error: %(details)s"
1292
 
 
1293
 
    def __init__(self, details):
1294
 
        self.details = details
1295
 
 
1296
283
 
1297
284
# A set of semi-meaningful errors which can be thrown
1298
285
class TransportNotPossible(TransportError):
1299
 
 
1300
 
    _fmt = "Transport operation not possible: %(msg)s %(orig_error)s"
1301
 
 
1302
 
 
1303
 
class ConnectionError(TransportError):
1304
 
 
1305
 
    _fmt = "Connection error: %(msg)s %(orig_error)s"
1306
 
 
1307
 
 
1308
 
class SocketConnectionError(ConnectionError):
1309
 
 
1310
 
    _fmt = "%(msg)s %(host)s%(port)s%(orig_error)s"
1311
 
 
1312
 
    def __init__(self, host, port=None, msg=None, orig_error=None):
1313
 
        if msg is None:
1314
 
            msg = 'Failed to connect to'
1315
 
        if orig_error is None:
1316
 
            orig_error = ''
1317
 
        else:
1318
 
            orig_error = '; ' + str(orig_error)
1319
 
        ConnectionError.__init__(self, msg=msg, orig_error=orig_error)
1320
 
        self.host = host
1321
 
        if port is None:
1322
 
            self.port = ''
1323
 
        else:
1324
 
            self.port = ':%s' % port
1325
 
 
 
286
    """This is for transports where a specific function is explicitly not
 
287
    possible. Such as pushing files to an HTTP server.
 
288
    """
 
289
    pass
 
290
 
 
291
class NonRelativePath(TransportError):
 
292
    """An absolute path was supplied, that could not be decoded into
 
293
    a relative path.
 
294
    """
 
295
    pass
 
296
 
 
297
class NoSuchFile(TransportError, IOError):
 
298
    """A get() was issued for a file that doesn't exist."""
 
299
 
 
300
    # XXX: Is multiple inheritance for exceptions really needed?
 
301
 
 
302
    def __str__(self):
 
303
        return 'no such file: ' + self.msg
 
304
 
 
305
    def __init__(self, msg=None, orig_error=None):
 
306
        import errno
 
307
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
 
308
        IOError.__init__(self, errno.ENOENT, self.msg)
 
309
 
 
310
class FileExists(TransportError, OSError):
 
311
    """An operation was attempted, which would overwrite an entry,
 
312
    but overwritting is not supported.
 
313
 
 
314
    mkdir() can throw this, but put() just overwites existing files.
 
315
    """
 
316
    # XXX: Is multiple inheritance for exceptions really needed?
 
317
    def __init__(self, msg=None, orig_error=None):
 
318
        import errno
 
319
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
 
320
        OSError.__init__(self, errno.EEXIST, self.msg)
 
321
 
 
322
class PermissionDenied(TransportError):
 
323
    """An operation cannot succeed because of a lack of permissions."""
 
324
    pass
1326
325
 
1327
326
class ConnectionReset(TransportError):
1328
 
 
1329
 
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1330
 
 
1331
 
 
1332
 
class InvalidRange(TransportError):
1333
 
 
1334
 
    _fmt = "Invalid range access in %(path)s at %(offset)s."
1335
 
    
1336
 
    def __init__(self, path, offset):
1337
 
        TransportError.__init__(self, ("Invalid range access in %s at %d"
1338
 
                                       % (path, offset)))
1339
 
        self.path = path
1340
 
        self.offset = offset
1341
 
 
1342
 
 
1343
 
class InvalidHttpResponse(TransportError):
1344
 
 
1345
 
    _fmt = "Invalid http response for %(path)s: %(msg)s"
1346
 
 
1347
 
    def __init__(self, path, msg, orig_error=None):
1348
 
        self.path = path
1349
 
        TransportError.__init__(self, msg, orig_error=orig_error)
1350
 
 
1351
 
 
1352
 
class InvalidHttpRange(InvalidHttpResponse):
1353
 
 
1354
 
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1355
 
    
1356
 
    def __init__(self, path, range, msg):
1357
 
        self.range = range
1358
 
        InvalidHttpResponse.__init__(self, path, msg)
1359
 
 
1360
 
 
1361
 
class InvalidHttpContentType(InvalidHttpResponse):
1362
 
 
1363
 
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1364
 
    
1365
 
    def __init__(self, path, ctype, msg):
1366
 
        self.ctype = ctype
1367
 
        InvalidHttpResponse.__init__(self, path, msg)
1368
 
 
1369
 
 
1370
 
class RedirectRequested(TransportError):
1371
 
 
1372
 
    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1373
 
 
1374
 
    def __init__(self, source, target, is_permament=False, qual_proto=None):
1375
 
        self.source = source
1376
 
        self.target = target
1377
 
        if is_permament:
1378
 
            self.permanently = ' permanently'
1379
 
        else:
1380
 
            self.permanently = ''
1381
 
        self.is_permament = is_permament
1382
 
        self._qualified_proto = qual_proto
1383
 
        TransportError.__init__(self)
1384
 
 
1385
 
    def _requalify_url(self, url):
1386
 
        """Restore the qualified proto in front of the url"""
1387
 
        # When this exception is raised, source and target are in
1388
 
        # user readable format. But some transports may use a
1389
 
        # different proto (http+urllib:// will present http:// to
1390
 
        # the user. If a qualified proto is specified, the code
1391
 
        # trapping the exception can get the qualified urls to
1392
 
        # properly handle the redirection themself (creating a
1393
 
        # new transport object from the target url for example).
1394
 
        # But checking that the scheme of the original and
1395
 
        # redirected urls are the same can be tricky. (see the
1396
 
        # FIXME in BzrDir.open_from_transport for the unique use
1397
 
        # case so far).
1398
 
        if self._qualified_proto is None:
1399
 
            return url
1400
 
 
1401
 
        # The TODO related to NotBranchError mention that doing
1402
 
        # that kind of manipulation on the urls may not be the
1403
 
        # exception object job. On the other hand, this object is
1404
 
        # the interface between the code and the user so
1405
 
        # presenting the urls in different ways is indeed its
1406
 
        # job...
1407
 
        import urlparse
1408
 
        proto, netloc, path, query, fragment = urlparse.urlsplit(url)
1409
 
        return urlparse.urlunsplit((self._qualified_proto, netloc, path,
1410
 
                                   query, fragment))
1411
 
 
1412
 
    def get_source_url(self):
1413
 
        return self._requalify_url(self.source)
1414
 
 
1415
 
    def get_target_url(self):
1416
 
        return self._requalify_url(self.target)
1417
 
 
1418
 
 
1419
 
class TooManyRedirections(TransportError):
1420
 
 
1421
 
    _fmt = "Too many redirections"
 
327
    """The connection has been closed."""
 
328
    pass
1422
329
 
1423
330
class ConflictsInTree(BzrError):
1424
 
 
1425
 
    _fmt = "Working tree has conflicts."
1426
 
 
1427
 
 
1428
 
class ParseConfigError(BzrError):
1429
 
 
1430
 
    def __init__(self, errors, filename):
1431
 
        if filename is None:
1432
 
            filename = ""
1433
 
        message = "Error(s) parsing config file %s:\n%s" % \
1434
 
            (filename, ('\n'.join(e.message for e in errors)))
1435
 
        BzrError.__init__(self, message)
1436
 
 
1437
 
 
1438
 
class NoEmailInUsername(BzrError):
1439
 
 
1440
 
    _fmt = "%(username)r does not seem to contain a reasonable email address"
1441
 
 
1442
 
    def __init__(self, username):
1443
 
        BzrError.__init__(self)
1444
 
        self.username = username
1445
 
 
 
331
    def __init__(self):
 
332
        BzrError.__init__(self, "Working tree has conflicts.")
1446
333
 
1447
334
class SigningFailed(BzrError):
1448
 
 
1449
 
    _fmt = "Failed to gpg sign data with command %(command_line)r"
1450
 
 
1451
335
    def __init__(self, command_line):
1452
 
        BzrError.__init__(self, command_line=command_line)
1453
 
 
1454
 
 
1455
 
class WorkingTreeNotRevision(BzrError):
1456
 
 
1457
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
1458
 
            " the last commit, but weave merge requires that it be"
1459
 
            " unchanged")
1460
 
 
1461
 
    def __init__(self, tree):
1462
 
        BzrError.__init__(self, basedir=tree.basedir)
1463
 
 
1464
 
 
1465
 
class CantReprocessAndShowBase(BzrError):
1466
 
 
1467
 
    _fmt = ("Can't reprocess and show base, because reprocessing obscures "
1468
 
           "the relationship of conflicting lines to the base")
1469
 
 
1470
 
 
1471
 
class GraphCycleError(BzrError):
1472
 
 
1473
 
    _fmt = "Cycle in graph %(graph)r"
1474
 
 
1475
 
    def __init__(self, graph):
1476
 
        BzrError.__init__(self)
1477
 
        self.graph = graph
1478
 
 
1479
 
 
1480
 
class WritingCompleted(BzrError):
1481
 
 
1482
 
    _fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1483
 
            "called upon it - accept bytes may not be called anymore.")
1484
 
 
1485
 
    internal_error = True
1486
 
 
1487
 
    def __init__(self, request):
1488
 
        self.request = request
1489
 
 
1490
 
 
1491
 
class WritingNotComplete(BzrError):
1492
 
 
1493
 
    _fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1494
 
            "called upon it - until the write phase is complete no "
1495
 
            "data may be read.")
1496
 
 
1497
 
    internal_error = True
1498
 
 
1499
 
    def __init__(self, request):
1500
 
        self.request = request
1501
 
 
1502
 
 
1503
 
class NotConflicted(BzrError):
1504
 
 
1505
 
    _fmt = "File %(filename)s is not conflicted."
1506
 
 
1507
 
    def __init__(self, filename):
1508
 
        BzrError.__init__(self)
1509
 
        self.filename = filename
1510
 
 
1511
 
 
1512
 
class MediumNotConnected(BzrError):
1513
 
 
1514
 
    _fmt = """The medium '%(medium)s' is not connected."""
1515
 
 
1516
 
    internal_error = True
1517
 
 
1518
 
    def __init__(self, medium):
1519
 
        self.medium = medium
1520
 
 
1521
 
 
1522
 
class MustUseDecorated(Exception):
1523
 
 
1524
 
    _fmt = "A decorating function has requested its original command be used."
1525
 
 
1526
 
 
1527
 
class NoBundleFound(BzrError):
1528
 
 
1529
 
    _fmt = "No bundle was found in %(filename)s"
1530
 
 
1531
 
    def __init__(self, filename):
1532
 
        BzrError.__init__(self)
1533
 
        self.filename = filename
1534
 
 
1535
 
 
1536
 
class BundleNotSupported(BzrError):
1537
 
 
1538
 
    _fmt = "Unable to handle bundle version %(version)s: %(msg)s"
1539
 
 
1540
 
    def __init__(self, version, msg):
1541
 
        BzrError.__init__(self)
1542
 
        self.version = version
1543
 
        self.msg = msg
1544
 
 
1545
 
 
1546
 
class MissingText(BzrError):
1547
 
 
1548
 
    _fmt = ("Branch %(base)s is missing revision"
1549
 
            " %(text_revision)s of %(file_id)s")
1550
 
 
1551
 
    def __init__(self, branch, text_revision, file_id):
1552
 
        BzrError.__init__(self)
1553
 
        self.branch = branch
1554
 
        self.base = branch.base
1555
 
        self.text_revision = text_revision
1556
 
        self.file_id = file_id
1557
 
 
1558
 
 
1559
 
class DuplicateFileId(BzrError):
1560
 
 
1561
 
    _fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"
1562
 
 
1563
 
    def __init__(self, file_id, entry):
1564
 
        BzrError.__init__(self)
1565
 
        self.file_id = file_id
1566
 
        self.entry = entry
1567
 
 
1568
 
 
1569
 
class DuplicateKey(BzrError):
1570
 
 
1571
 
    _fmt = "Key %(key)s is already present in map"
1572
 
 
1573
 
 
1574
 
class DuplicateHelpPrefix(BzrError):
1575
 
 
1576
 
    _fmt = "The prefix %(prefix)s is in the help search path twice."
1577
 
 
1578
 
    def __init__(self, prefix):
1579
 
        self.prefix = prefix
1580
 
 
1581
 
 
1582
 
class MalformedTransform(BzrError):
1583
 
 
1584
 
    _fmt = "Tree transform is malformed %(conflicts)r"
1585
 
 
1586
 
 
1587
 
class NoFinalPath(BzrError):
1588
 
 
1589
 
    _fmt = ("No final name for trans_id %(trans_id)r\n"
1590
 
            "file-id: %(file_id)r\n"
1591
 
            "root trans-id: %(root_trans_id)r\n")
1592
 
 
1593
 
    def __init__(self, trans_id, transform):
1594
 
        self.trans_id = trans_id
1595
 
        self.file_id = transform.final_file_id(trans_id)
1596
 
        self.root_trans_id = transform.root
1597
 
 
1598
 
 
1599
 
class BzrBadParameter(BzrError):
1600
 
 
1601
 
    _fmt = "Bad parameter: %(param)r"
1602
 
 
1603
 
    internal_error = True
1604
 
 
1605
 
    # This exception should never be thrown, but it is a base class for all
1606
 
    # parameter-to-function errors.
1607
 
 
1608
 
    def __init__(self, param):
1609
 
        BzrError.__init__(self)
1610
 
        self.param = param
1611
 
 
1612
 
 
1613
 
class BzrBadParameterNotUnicode(BzrBadParameter):
1614
 
 
1615
 
    _fmt = "Parameter %(param)s is neither unicode nor utf8."
1616
 
 
1617
 
 
1618
 
class ReusingTransform(BzrError):
1619
 
 
1620
 
    _fmt = "Attempt to reuse a transform that has already been applied."
1621
 
 
1622
 
 
1623
 
class CantMoveRoot(BzrError):
1624
 
 
1625
 
    _fmt = "Moving the root directory is not supported at this time"
1626
 
 
1627
 
 
1628
 
class BzrMoveFailedError(BzrError):
1629
 
 
1630
 
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
1631
 
 
1632
 
    def __init__(self, from_path='', to_path='', extra=None):
1633
 
        BzrError.__init__(self)
1634
 
        if extra:
1635
 
            self.extra = ': ' + str(extra)
1636
 
        else:
1637
 
            self.extra = ''
1638
 
 
1639
 
        has_from = len(from_path) > 0
1640
 
        has_to = len(to_path) > 0
1641
 
        if has_from:
1642
 
            self.from_path = osutils.splitpath(from_path)[-1]
1643
 
        else:
1644
 
            self.from_path = ''
1645
 
 
1646
 
        if has_to:
1647
 
            self.to_path = osutils.splitpath(to_path)[-1]
1648
 
        else:
1649
 
            self.to_path = ''
1650
 
 
1651
 
        self.operator = ""
1652
 
        if has_from and has_to:
1653
 
            self.operator = " =>"
1654
 
        elif has_from:
1655
 
            self.from_path = "from " + from_path
1656
 
        elif has_to:
1657
 
            self.operator = "to"
1658
 
        else:
1659
 
            self.operator = "file"
1660
 
 
1661
 
 
1662
 
class BzrRenameFailedError(BzrMoveFailedError):
1663
 
 
1664
 
    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
1665
 
 
1666
 
    def __init__(self, from_path, to_path, extra=None):
1667
 
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1668
 
 
1669
 
class BzrRemoveChangedFilesError(BzrError):
1670
 
    """Used when user is trying to remove changed files."""
1671
 
 
1672
 
    _fmt = ("Can't remove changed or unknown files:\n%(changes_as_text)s"
1673
 
        "Use --keep to not delete them, or --force to delete them regardless.")
1674
 
 
1675
 
    def __init__(self, tree_delta):
1676
 
        BzrError.__init__(self)
1677
 
        self.changes_as_text = tree_delta.get_changes_as_text()
1678
 
        #self.paths_as_string = '\n'.join(changed_files)
1679
 
        #self.paths_as_string = '\n'.join([quotefn(p) for p in changed_files])
1680
 
 
1681
 
 
1682
 
class BzrBadParameterNotString(BzrBadParameter):
1683
 
 
1684
 
    _fmt = "Parameter %(param)s is not a string or unicode string."
1685
 
 
1686
 
 
1687
 
class BzrBadParameterMissing(BzrBadParameter):
1688
 
 
1689
 
    _fmt = "Parameter $(param)s is required but not present."
1690
 
 
1691
 
 
1692
 
class BzrBadParameterUnicode(BzrBadParameter):
1693
 
 
1694
 
    _fmt = ("Parameter %(param)s is unicode but"
1695
 
            " only byte-strings are permitted.")
1696
 
 
1697
 
 
1698
 
class BzrBadParameterContainsNewline(BzrBadParameter):
1699
 
 
1700
 
    _fmt = "Parameter %(param)s contains a newline."
1701
 
 
1702
 
 
1703
 
class DependencyNotPresent(BzrError):
1704
 
 
1705
 
    _fmt = 'Unable to import library "%(library)s": %(error)s'
1706
 
 
1707
 
    def __init__(self, library, error):
1708
 
        BzrError.__init__(self, library=library, error=error)
1709
 
 
1710
 
 
1711
 
class ParamikoNotPresent(DependencyNotPresent):
1712
 
 
1713
 
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
1714
 
 
1715
 
    def __init__(self, error):
1716
 
        DependencyNotPresent.__init__(self, 'paramiko', error)
1717
 
 
1718
 
 
1719
 
class PointlessMerge(BzrError):
1720
 
 
1721
 
    _fmt = "Nothing to merge."
1722
 
 
1723
 
 
1724
 
class UninitializableFormat(BzrError):
1725
 
 
1726
 
    _fmt = "Format %(format)s cannot be initialised by this version of bzr."
1727
 
 
1728
 
    def __init__(self, format):
1729
 
        BzrError.__init__(self)
1730
 
        self.format = format
1731
 
 
1732
 
 
1733
 
class BadConversionTarget(BzrError):
1734
 
 
1735
 
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
1736
 
 
1737
 
    def __init__(self, problem, format):
1738
 
        BzrError.__init__(self)
1739
 
        self.problem = problem
1740
 
        self.format = format
1741
 
 
1742
 
 
1743
 
class NoDiff(BzrError):
1744
 
 
1745
 
    _fmt = "Diff is not installed on this machine: %(msg)s"
1746
 
 
1747
 
    def __init__(self, msg):
1748
 
        BzrError.__init__(self, msg=msg)
1749
 
 
1750
 
 
1751
 
class NoDiff3(BzrError):
1752
 
 
1753
 
    _fmt = "Diff3 is not installed on this machine."
1754
 
 
1755
 
 
1756
 
class ExistingLimbo(BzrError):
1757
 
 
1758
 
    _fmt = """This tree contains left-over files from a failed operation.
1759
 
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1760
 
    keep, and delete it when you are done."""
1761
 
    
1762
 
    def __init__(self, limbo_dir):
1763
 
       BzrError.__init__(self)
1764
 
       self.limbo_dir = limbo_dir
1765
 
 
1766
 
 
1767
 
class ImmortalLimbo(BzrError):
1768
 
 
1769
 
    _fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
1770
 
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1771
 
    keep, and delete it when you are done."""
1772
 
 
1773
 
    def __init__(self, limbo_dir):
1774
 
       BzrError.__init__(self)
1775
 
       self.limbo_dir = limbo_dir
1776
 
 
1777
 
 
1778
 
class OutOfDateTree(BzrError):
1779
 
 
1780
 
    _fmt = "Working tree is out of date, please run 'bzr update'."
1781
 
 
1782
 
    def __init__(self, tree):
1783
 
        BzrError.__init__(self)
1784
 
        self.tree = tree
1785
 
 
1786
 
 
1787
 
class PublicBranchOutOfDate(BzrError):
1788
 
 
1789
 
    _fmt = 'Public branch "%(public_location)s" lacks revision '\
1790
 
        '"%(revstring)s".'
1791
 
 
1792
 
    def __init__(self, public_location, revstring):
1793
 
        import bzrlib.urlutils as urlutils
1794
 
        public_location = urlutils.unescape_for_display(public_location,
1795
 
                                                        'ascii')
1796
 
        BzrError.__init__(self, public_location=public_location,
1797
 
                          revstring=revstring)
1798
 
 
1799
 
 
1800
 
class MergeModifiedFormatError(BzrError):
1801
 
 
1802
 
    _fmt = "Error in merge modified format"
1803
 
 
1804
 
 
1805
 
class ConflictFormatError(BzrError):
1806
 
 
1807
 
    _fmt = "Format error in conflict listings"
1808
 
 
1809
 
 
1810
 
class CorruptRepository(BzrError):
1811
 
 
1812
 
    _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
1813
 
            "Please run bzr reconcile on this repository.")
1814
 
 
1815
 
    def __init__(self, repo):
1816
 
        BzrError.__init__(self)
1817
 
        self.repo_path = repo.bzrdir.root_transport.base
1818
 
 
1819
 
 
1820
 
class UpgradeRequired(BzrError):
1821
 
 
1822
 
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
1823
 
 
1824
 
    def __init__(self, path):
1825
 
        BzrError.__init__(self)
1826
 
        self.path = path
1827
 
 
1828
 
 
1829
 
class LocalRequiresBoundBranch(BzrError):
1830
 
 
1831
 
    _fmt = "Cannot perform local-only commits on unbound branches."
1832
 
 
1833
 
 
1834
 
class MissingProgressBarFinish(BzrError):
1835
 
 
1836
 
    _fmt = "A nested progress bar was not 'finished' correctly."
1837
 
 
1838
 
 
1839
 
class InvalidProgressBarType(BzrError):
1840
 
 
1841
 
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
1842
 
            " is not a supported type Select one of: %(valid_types)s")
1843
 
 
1844
 
    def __init__(self, bar_type, valid_types):
1845
 
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1846
 
 
1847
 
 
1848
 
class UnsupportedOperation(BzrError):
1849
 
 
1850
 
    _fmt = ("The method %(mname)s is not supported on"
1851
 
            " objects of type %(tname)s.")
1852
 
 
1853
 
    def __init__(self, method, method_self):
1854
 
        self.method = method
1855
 
        self.mname = method.__name__
1856
 
        self.tname = type(method_self).__name__
1857
 
 
1858
 
 
1859
 
class CannotSetRevisionId(UnsupportedOperation):
1860
 
    """Raised when a commit is attempting to set a revision id but cant."""
1861
 
 
1862
 
 
1863
 
class NonAsciiRevisionId(UnsupportedOperation):
1864
 
    """Raised when a commit is attempting to set a non-ascii revision id
1865
 
       but cant.
1866
 
    """
1867
 
 
1868
 
 
1869
 
class BinaryFile(BzrError):
1870
 
    
1871
 
    _fmt = "File is binary but should be text."
1872
 
 
1873
 
 
1874
 
class IllegalPath(BzrError):
1875
 
 
1876
 
    _fmt = "The path %(path)s is not permitted on this platform"
1877
 
 
1878
 
    def __init__(self, path):
1879
 
        BzrError.__init__(self)
1880
 
        self.path = path
1881
 
 
1882
 
 
1883
 
class TestamentMismatch(BzrError):
1884
 
 
1885
 
    _fmt = """Testament did not match expected value.
1886
 
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
1887
 
       {%(measured)s}"""
1888
 
 
1889
 
    def __init__(self, revision_id, expected, measured):
1890
 
        self.revision_id = revision_id
1891
 
        self.expected = expected
1892
 
        self.measured = measured
1893
 
 
1894
 
 
1895
 
class NotABundle(BzrError):
1896
 
    
1897
 
    _fmt = "Not a bzr revision-bundle: %(text)r"
1898
 
 
1899
 
    def __init__(self, text):
1900
 
        BzrError.__init__(self)
1901
 
        self.text = text
1902
 
 
1903
 
 
1904
 
class BadBundle(BzrError): 
1905
 
    
1906
 
    _fmt = "Bad bzr revision-bundle: %(text)r"
1907
 
 
1908
 
    def __init__(self, text):
1909
 
        BzrError.__init__(self)
1910
 
        self.text = text
1911
 
 
1912
 
 
1913
 
class MalformedHeader(BadBundle): 
1914
 
    
1915
 
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
1916
 
 
1917
 
 
1918
 
class MalformedPatches(BadBundle): 
1919
 
    
1920
 
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
1921
 
 
1922
 
 
1923
 
class MalformedFooter(BadBundle): 
1924
 
    
1925
 
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
1926
 
 
1927
 
 
1928
 
class UnsupportedEOLMarker(BadBundle):
1929
 
    
1930
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
1931
 
 
1932
 
    def __init__(self):
1933
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
1934
 
        # but for this there is not
1935
 
        BzrError.__init__(self)
1936
 
 
1937
 
 
1938
 
class IncompatibleBundleFormat(BzrError):
1939
 
    
1940
 
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
1941
 
 
1942
 
    def __init__(self, bundle_format, other):
1943
 
        BzrError.__init__(self)
1944
 
        self.bundle_format = bundle_format
1945
 
        self.other = other
1946
 
 
1947
 
 
1948
 
class BadInventoryFormat(BzrError):
1949
 
    
1950
 
    _fmt = "Root class for inventory serialization errors"
1951
 
 
1952
 
 
1953
 
class UnexpectedInventoryFormat(BadInventoryFormat):
1954
 
 
1955
 
    _fmt = "The inventory was not in the expected format:\n %(msg)s"
1956
 
 
1957
 
    def __init__(self, msg):
1958
 
        BadInventoryFormat.__init__(self, msg=msg)
1959
 
 
1960
 
 
1961
 
class RootNotRich(BzrError):
1962
 
 
1963
 
    _fmt = """This operation requires rich root data storage"""
1964
 
 
1965
 
 
1966
 
class NoSmartMedium(BzrError):
1967
 
 
1968
 
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
1969
 
 
1970
 
    internal_error = True
1971
 
 
1972
 
    def __init__(self, transport):
1973
 
        self.transport = transport
1974
 
 
1975
 
 
1976
 
class NoSmartServer(NotBranchError):
1977
 
 
1978
 
    _fmt = "No smart server available at %(url)s"
1979
 
 
1980
 
    def __init__(self, url):
1981
 
        self.url = url
1982
 
 
1983
 
 
1984
 
class UnknownSSH(BzrError):
1985
 
 
1986
 
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
1987
 
 
1988
 
    def __init__(self, vendor):
1989
 
        BzrError.__init__(self)
1990
 
        self.vendor = vendor
1991
 
 
1992
 
 
1993
 
class SSHVendorNotFound(BzrError):
1994
 
 
1995
 
    _fmt = ("Don't know how to handle SSH connections."
1996
 
            " Please set BZR_SSH environment variable.")
1997
 
 
1998
 
 
1999
 
class GhostRevisionUnusableHere(BzrError):
2000
 
 
2001
 
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2002
 
 
2003
 
    def __init__(self, revision_id):
2004
 
        BzrError.__init__(self)
2005
 
        self.revision_id = revision_id
2006
 
 
2007
 
 
2008
 
class IllegalUseOfScopeReplacer(BzrError):
2009
 
 
2010
 
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
2011
 
            " %(msg)s%(extra)s")
2012
 
 
2013
 
    internal_error = True
2014
 
 
2015
 
    def __init__(self, name, msg, extra=None):
2016
 
        BzrError.__init__(self)
2017
 
        self.name = name
2018
 
        self.msg = msg
2019
 
        if extra:
2020
 
            self.extra = ': ' + str(extra)
2021
 
        else:
2022
 
            self.extra = ''
2023
 
 
2024
 
 
2025
 
class InvalidImportLine(BzrError):
2026
 
 
2027
 
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
2028
 
 
2029
 
    internal_error = True
2030
 
 
2031
 
    def __init__(self, text, msg):
2032
 
        BzrError.__init__(self)
2033
 
        self.text = text
2034
 
        self.msg = msg
2035
 
 
2036
 
 
2037
 
class ImportNameCollision(BzrError):
2038
 
 
2039
 
    _fmt = ("Tried to import an object to the same name as"
2040
 
            " an existing object. %(name)s")
2041
 
 
2042
 
    internal_error = True
2043
 
 
2044
 
    def __init__(self, name):
2045
 
        BzrError.__init__(self)
2046
 
        self.name = name
2047
 
 
2048
 
 
2049
 
class NotAMergeDirective(BzrError):
2050
 
    """File starting with %(firstline)r is not a merge directive"""
2051
 
    def __init__(self, firstline):
2052
 
        BzrError.__init__(self, firstline=firstline)
2053
 
 
2054
 
 
2055
 
class NoMergeSource(BzrError):
2056
 
    """Raise if no merge source was specified for a merge directive"""
2057
 
 
2058
 
    _fmt = "A merge directive must provide either a bundle or a public"\
2059
 
        " branch location."
2060
 
 
2061
 
 
2062
 
class PatchMissing(BzrError):
2063
 
    """Raise a patch type was specified but no patch supplied"""
2064
 
 
2065
 
    _fmt = "patch_type was %(patch_type)s, but no patch was supplied."
2066
 
 
2067
 
    def __init__(self, patch_type):
2068
 
        BzrError.__init__(self)
2069
 
        self.patch_type = patch_type
2070
 
 
2071
 
 
2072
 
class UnsupportedInventoryKind(BzrError):
2073
 
    
2074
 
    _fmt = """Unsupported entry kind %(kind)s"""
2075
 
 
2076
 
    def __init__(self, kind):
2077
 
        self.kind = kind
2078
 
 
2079
 
 
2080
 
class BadSubsumeSource(BzrError):
2081
 
 
2082
 
    _fmt = """Can't subsume %(other_tree)s into %(tree)s.  %(reason)s"""
2083
 
 
2084
 
    def __init__(self, tree, other_tree, reason):
2085
 
        self.tree = tree
2086
 
        self.other_tree = other_tree
2087
 
        self.reason = reason
2088
 
 
2089
 
 
2090
 
class SubsumeTargetNeedsUpgrade(BzrError):
2091
 
    
2092
 
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2093
 
 
2094
 
    def __init__(self, other_tree):
2095
 
        self.other_tree = other_tree
2096
 
 
2097
 
 
2098
 
class BadReferenceTarget(BzrError):
2099
 
 
2100
 
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s.  %(reason)s"
2101
 
 
2102
 
    internal_error = True
2103
 
 
2104
 
    def __init__(self, tree, other_tree, reason):
2105
 
        self.tree = tree
2106
 
        self.other_tree = other_tree
2107
 
        self.reason = reason
2108
 
 
2109
 
 
2110
 
class NoSuchTag(BzrError):
2111
 
 
2112
 
    _fmt = "No such tag: %(tag_name)s"
2113
 
 
2114
 
    def __init__(self, tag_name):
2115
 
        self.tag_name = tag_name
2116
 
 
2117
 
 
2118
 
class TagsNotSupported(BzrError):
2119
 
 
2120
 
    _fmt = ("Tags not supported by %(branch)s;"
2121
 
            " you may be able to use bzr upgrade --dirstate-tags.")
2122
 
 
2123
 
    def __init__(self, branch):
2124
 
        self.branch = branch
2125
 
 
2126
 
        
2127
 
class TagAlreadyExists(BzrError):
2128
 
 
2129
 
    _fmt = "Tag %(tag_name)s already exists."
2130
 
 
2131
 
    def __init__(self, tag_name):
2132
 
        self.tag_name = tag_name
2133
 
 
2134
 
 
2135
 
class MalformedBugIdentifier(BzrError):
2136
 
 
2137
 
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
2138
 
 
2139
 
    def __init__(self, bug_id, reason):
2140
 
        self.bug_id = bug_id
2141
 
        self.reason = reason
2142
 
 
2143
 
 
2144
 
class UnknownBugTrackerAbbreviation(BzrError):
2145
 
 
2146
 
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
2147
 
            "on %(branch)s")
2148
 
 
2149
 
    def __init__(self, abbreviation, branch):
2150
 
        self.abbreviation = abbreviation
2151
 
        self.branch = branch
2152
 
 
2153
 
 
2154
 
class UnexpectedSmartServerResponse(BzrError):
2155
 
 
2156
 
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2157
 
 
2158
 
    def __init__(self, response_tuple):
2159
 
        self.response_tuple = response_tuple
2160
 
 
2161
 
 
2162
 
class ContainerError(BzrError):
2163
 
    """Base class of container errors."""
2164
 
 
2165
 
 
2166
 
class UnknownContainerFormatError(ContainerError):
2167
 
 
2168
 
    _fmt = "Unrecognised container format: %(container_format)r"
2169
 
    
2170
 
    def __init__(self, container_format):
2171
 
        self.container_format = container_format
2172
 
 
2173
 
 
2174
 
class UnexpectedEndOfContainerError(ContainerError):
2175
 
 
2176
 
    _fmt = "Unexpected end of container stream"
2177
 
 
2178
 
    internal_error = False
2179
 
 
2180
 
 
2181
 
class UnknownRecordTypeError(ContainerError):
2182
 
 
2183
 
    _fmt = "Unknown record type: %(record_type)r"
2184
 
 
2185
 
    def __init__(self, record_type):
2186
 
        self.record_type = record_type
2187
 
 
2188
 
 
2189
 
class InvalidRecordError(ContainerError):
2190
 
 
2191
 
    _fmt = "Invalid record: %(reason)s"
2192
 
 
2193
 
    def __init__(self, reason):
2194
 
        self.reason = reason
2195
 
 
2196
 
 
2197
 
class ContainerHasExcessDataError(ContainerError):
2198
 
 
2199
 
    _fmt = "Container has data after end marker: %(excess)r"
2200
 
 
2201
 
    def __init__(self, excess):
2202
 
        self.excess = excess
2203
 
 
2204
 
 
2205
 
class DuplicateRecordNameError(ContainerError):
2206
 
 
2207
 
    _fmt = "Container has multiple records with the same name: \"%(name)s\""
2208
 
 
2209
 
    def __init__(self, name):
2210
 
        self.name = name
2211
 
 
2212
 
 
2213
 
class NoDestinationAddress(BzrError):
2214
 
 
2215
 
    _fmt = "Message does not have a destination address."
2216
 
 
2217
 
    internal_error = True
2218
 
 
2219
 
 
2220
 
class SMTPError(BzrError):
2221
 
 
2222
 
    _fmt = "SMTP error: %(error)s"
2223
 
 
2224
 
    def __init__(self, error):
2225
 
        self.error = error
 
336
        BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
 
337
                               % command_line)