~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Martin Pool
  • Date: 2005-07-18 13:38:13 UTC
  • Revision ID: mbp@sourcefrog.net-20050718133813-4343f0cde39537de
- refactor member names in Weave code

Show diffs side-by-side

added added

removed removed

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