~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

• browse files at revision 4306
• compare with another revision
• download diff
• download tarball
• view history from revision 4306

• reverse the comparison (4306 to 6005)
• stop comparing with revision 6005

Show diffs side-by-side

added

removed

bzrlib/errors.py

1

 

# Copyright (C) 2005-2011 Canonical Ltd

 

1

# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd

2

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

54

54

    Base class for errors raised by bzrlib.

55

55

 

56

56

    :cvar internal_error: if True this was probably caused by a bzr bug and

57

 

        should be displayed with a traceback; if False (or absent) this was

58

 

        probably a user or environment error and they don't need the gory

59

 

        details.  (That can be overridden by -Derror on the command line.)

 

57

    should be displayed with a traceback; if False (or absent) this was

 

58

    probably a user or environment error and they don't need the gory details.

 

59

    (That can be overridden by -Derror on the command line.)

60

60

 

61

61

    :cvar _fmt: Format string to display the error; this is expanded

62

 

        by the instance's dict.

 

62

    by the instance's dict.

63

63

    """

64

64

 

65

65

    internal_error = False

304

304

class RootMissing(InternalBzrError):

305

305

 

306

306

    _fmt = ("The root entry of a tree must be the first entry supplied to "

307

 

        "the commit builder.")

 

307

        "record_entry_contents.")

308

308

 

309

309

 

310

310

class NoPublicBranch(BzrError):

636

636

        self.url = url

637

637

 

638

638

 

639

 

class UnstackableLocationError(BzrError):

640

 

 

641

 

    _fmt = "The branch '%(branch_url)s' cannot be stacked on '%(target_url)s'."

642

 

 

643

 

    def __init__(self, branch_url, target_url):

644

 

        BzrError.__init__(self)

645

 

        self.branch_url = branch_url

646

 

        self.target_url = target_url

647

 

 

648

 

 

649

639

class UnstackableRepositoryFormat(BzrError):

650

640

 

651

641

    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "

680

670

 

681

671

    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'

682

672

 

683

 

    internal_error = False

 

673

    internal_error = True

684

674

 

685

675

    def __init__(self, path, base, extra=None):

686

676

        BzrError.__init__(self)

702

692

# TODO: Probably this behavior of should be a common superclass

703

693

class NotBranchError(PathError):

704

694

 

705

 

    _fmt = 'Not a branch: "%(path)s"%(detail)s.'

 

695

    _fmt = 'Not a branch: "%(path)s".'

706

696

 

707

 

    def __init__(self, path, detail=None, bzrdir=None):

 

697

    def __init__(self, path):

708

698

       import bzrlib.urlutils as urlutils

709

 

       path = urlutils.unescape_for_display(path, 'ascii')

710

 

       if detail is not None:

711

 

           detail = ': ' + detail

712

 

       self.detail = detail

713

 

       self.bzrdir = bzrdir

714

 

       PathError.__init__(self, path=path)

715

 

 

716

 

    def __repr__(self):

717

 

        return '<%s %r>' % (self.__class__.__name__, self.__dict__)

718

 

 

719

 

    def _format(self):

720

 

        # XXX: Ideally self.detail would be a property, but Exceptions in

721

 

        # Python 2.4 have to be old-style classes so properties don't work.

722

 

        # Instead we override _format.

723

 

        if self.detail is None:

724

 

            if self.bzrdir is not None:

725

 

                try:

726

 

                    self.bzrdir.open_repository()

727

 

                except NoRepositoryPresent:

728

 

                    self.detail = ''

729

 

                except Exception:

730

 

                    # Just ignore unexpected errors.  Raising arbitrary errors

731

 

                    # during str(err) can provoke strange bugs.  Concretely

732

 

                    # Launchpad's codehosting managed to raise NotBranchError

733

 

                    # here, and then get stuck in an infinite loop/recursion

734

 

                    # trying to str() that error.  All this error really cares

735

 

                    # about that there's no working repository there, and if

736

 

                    # open_repository() fails, there probably isn't.

737

 

                    self.detail = ''

738

 

                else:

739

 

                    self.detail = ': location is a repository'

740

 

            else:

741

 

                self.detail = ''

742

 

        return PathError._format(self)

 

699

       self.path = urlutils.unescape_for_display(path, 'ascii')

743

700

 

744

701

 

745

702

class NoSubmitBranch(PathError):

794

751

 

795

752

    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'

796

753

 

797

 

    # use PathNotChild instead

798

 

    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 3, 0)))

799

754

    def __init__(self, branch, path):

800

755

        BzrError.__init__(self)

801

756

        self.branch = branch

828

783

 

829

784

 

830

785

class IncompatibleRepositories(BzrError):

831

 

    """Report an error that two repositories are not compatible.

832

 

 

833

 

    Note that the source and target repositories are permitted to be strings:

834

 

    this exception is thrown from the smart server and may refer to a

835

 

    repository the client hasn't opened.

836

 

    """

837

786

 

838

787

    _fmt = "%(target)s\n" \

839

788

            "is not compatible with\n" \

864

813

        """Construct a new AlreadyVersionedError.

865

814

 

866

815

        :param path: This is the path which is versioned,

867

 

            which should be in a user friendly form.

 

816

        which should be in a user friendly form.

868

817

        :param context_info: If given, this is information about the context,

869

 

            which could explain why this is expected to not be versioned.

 

818

        which could explain why this is expected to not be versioned.

870

819

        """

871

820

        BzrError.__init__(self)

872

821

        self.path = path

885

834

        """Construct a new NotVersionedError.

886

835

 

887

836

        :param path: This is the path which is not versioned,

888

 

            which should be in a user friendly form.

 

837

        which should be in a user friendly form.

889

838

        :param context_info: If given, this is information about the context,

890

 

            which could explain why this is expected to be versioned.

 

839

        which could explain why this is expected to be versioned.

891

840

        """

892

841

        BzrError.__init__(self)

893

842

        self.path = path

961

910

    # original exception is available as e.original_error

962

911

    #

963

912

    # New code should prefer to raise specific subclasses

964

 

    def __init__(self, msg):

965

 

        self.msg = msg

 

913

    def __init__(self, message):

 

914

        # Python 2.5 uses a slot for StandardError.message,

 

915

        # so use a different variable name.  We now work around this in

 

916

        # BzrError.__str__, but this member name is kept for compatability.

 

917

        self.msg = message

966

918

 

967

919

 

968

920

class LockActive(LockError):

1052

1004

class LockContention(LockError):

1053

1005

 

1054

1006

    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'

 

1007

    # TODO: show full url for lock, combining the transport and relative

 

1008

    # bits?

1055

1009

 

1056

1010

    internal_error = False

1057

1011

 

1084

1038

        self.target = target

1085

1039

 

1086

1040

 

1087

 

class LockCorrupt(LockError):

1088

 

 

1089

 

    _fmt = ("Lock is apparently held, but corrupted: %(corruption_info)s\n"

1090

 

            "Use 'bzr break-lock' to clear it")

1091

 

 

1092

 

    internal_error = False

1093

 

 

1094

 

    def __init__(self, corruption_info, file_data=None):

1095

 

        self.corruption_info = corruption_info

1096

 

        self.file_data = file_data

1097

 

 

1098

 

 

1099

1041

class LockNotHeld(LockError):

1100

1042

 

1101

1043

    _fmt = "Lock not held: %(lock)s"

1140

1082

        BzrError.__init__(self, files=files, files_str=files_str)

1141

1083

 

1142

1084

 

1143

 

class ExcludesUnsupported(BzrError):

1144

 

 

1145

 

    _fmt = ('Excluding paths during commit is not supported by '

1146

 

            'repository at %(repository)r.')

1147

 

 

1148

 

    def __init__(self, repository):

1149

 

        BzrError.__init__(self, repository=repository)

1150

 

 

1151

 

 

1152

1085

class BadCommitMessageEncoding(BzrError):

1153

1086

 

1154

1087

    _fmt = 'The specified commit message contains characters unsupported by '\

1209

1142

 

1210

1143

class InvalidRevisionSpec(BzrError):

1211

1144

 

1212

 

    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"

1213

 

            " %(branch_url)s%(extra)s")

 

1145

    _fmt = ("Requested revision: %(spec)r does not exist in branch:"

 

1146

            " %(branch)s%(extra)s")

1214

1147

 

1215

1148

    def __init__(self, spec, branch, extra=None):

1216

1149

        BzrError.__init__(self, branch=branch, spec=spec)

1217

 

        self.branch_url = getattr(branch, 'user_url', str(branch))

1218

1150

        if extra:

1219

1151

            self.extra = '\n' + str(extra)

1220

1152

        else:

1241

1173

class DivergedBranches(BzrError):

1242

1174

 

1243

1175

    _fmt = ("These branches have diverged."

1244

 

            " Use the missing command to see how.\n"

1245

 

            "Use the merge command to reconcile them.")

 

1176

            " Use the merge command to reconcile them.")

1246

1177

 

1247

1178

    def __init__(self, branch1, branch2):

1248

1179

        self.branch1 = branch1

1296

1227

            not_ancestor_id=not_ancestor_id)

1297

1228

 

1298

1229

 

 

1230

class InstallFailed(BzrError):

 

1231

 

 

1232

    def __init__(self, revisions):

 

1233

        revision_str = ", ".join(str(r) for r in revisions)

 

1234

        msg = "Could not install revisions:\n%s" % revision_str

 

1235

        BzrError.__init__(self, msg)

 

1236

        self.revisions = revisions

 

1237

 

 

1238

 

1299

1239

class AmbiguousBase(BzrError):

1300

1240

 

1301

1241

    def __init__(self, bases):

1302

 

        symbol_versioning.warn("BzrError AmbiguousBase has been deprecated "

1303

 

            "as of bzrlib 0.8.", DeprecationWarning, stacklevel=2)

 

1242

        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",

 

1243

                DeprecationWarning)

1304

1244

        msg = ("The correct base is unclear, because %s are all equally close"

1305

1245

                % ", ".join(bases))

1306

1246

        BzrError.__init__(self, msg)

1328

1268

class BoundBranchOutOfDate(BzrError):

1329

1269

 

1330

1270

    _fmt = ("Bound branch %(branch)s is out of date with master branch"

1331

 

            " %(master)s.%(extra_help)s")

 

1271

            " %(master)s.")

1332

1272

 

1333

1273

    def __init__(self, branch, master):

1334

1274

        BzrError.__init__(self)

1335

1275

        self.branch = branch

1336

1276

        self.master = master

1337

 

        self.extra_help = ''

1338

1277

 

1339

1278

 

1340

1279

class CommitToDoubleBoundBranch(BzrError):

1411

1350

 

1412

1351

class WeaveParentMismatch(WeaveError):

1413

1352

 

1414

 

    _fmt = "Parents are mismatched between two revisions. %(msg)s"

 

1353

    _fmt = "Parents are mismatched between two revisions. %(message)s"

1415

1354

 

1416

1355

 

1417

1356

class WeaveInvalidChecksum(WeaveError):

1418

1357

 

1419

 

    _fmt = "Text did not match its checksum: %(msg)s"

 

1358

    _fmt = "Text did not match it's checksum: %(message)s"

1420

1359

 

1421

1360

 

1422

1361

class WeaveTextDiffers(WeaveError):

1470

1409

 

1471

1410

class VersionedFileInvalidChecksum(VersionedFileError):

1472

1411

 

1473

 

    _fmt = "Text did not match its checksum: %(msg)s"

 

1412

    _fmt = "Text did not match its checksum: %(message)s"

1474

1413

 

1475

1414

 

1476

1415

class KnitError(InternalBzrError):

1715

1654

 

1716

1655

class InvalidHttpResponse(TransportError):

1717

1656

 

1718

 

    _fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"

 

1657

    _fmt = "Invalid http response for %(path)s: %(msg)s"

1719

1658

 

1720

1659

    def __init__(self, path, msg, orig_error=None):

1721

1660

        self.path = path

1722

 

        if orig_error is None:

1723

 

            orig_error = ''

1724

 

        else:

1725

 

            # This is reached for obscure and unusual errors so we want to

1726

 

            # preserve as much info as possible to ease debug.

1727

 

            orig_error = ': %r' % (orig_error,)

1728

1661

        TransportError.__init__(self, msg, orig_error=orig_error)

1729

1662

 

1730

1663

 

1770

1703

    _fmt = "Working tree has conflicts."

1771

1704

 

1772

1705

 

1773

 

class ConfigContentError(BzrError):

1774

 

 

1775

 

    _fmt = "Config file %(filename)s is not UTF-8 encoded\n"

1776

 

 

1777

 

    def __init__(self, filename):

1778

 

        BzrError.__init__(self)

1779

 

        self.filename = filename

1780

 

 

1781

 

 

1782

1706

class ParseConfigError(BzrError):

1783

1707

 

1784

 

    _fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"

1785

 

 

1786

1708

    def __init__(self, errors, filename):

1787

 

        BzrError.__init__(self)

1788

 

        self.filename = filename

1789

 

        self.errors = '\n'.join(e.msg for e in errors)

 

1709

        if filename is None:

 

1710

            filename = ""

 

1711

        message = "Error(s) parsing config file %s:\n%s" % \

 

1712

            (filename, ('\n'.join(e.msg for e in errors)))

 

1713

        BzrError.__init__(self, message)

1790

1714

 

1791

1715

 

1792

1716

class NoEmailInUsername(BzrError):

1800

1724

 

1801

1725

class SigningFailed(BzrError):

1802

1726

 

1803

 

    _fmt = 'Failed to GPG sign data with command "%(command_line)s"'

 

1727

    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'

1804

1728

 

1805

1729

    def __init__(self, command_line):

1806

1730

        BzrError.__init__(self, command_line=command_line)

1807

1731

 

1808

1732

 

1809

 

class SignatureVerificationFailed(BzrError):

1810

 

 

1811

 

    _fmt = 'Failed to verify GPG signature data with error "%(error)s"'

1812

 

 

1813

 

    def __init__(self, error):

1814

 

        BzrError.__init__(self, error=error)

1815

 

 

1816

 

 

1817

 

class DependencyNotPresent(BzrError):

1818

 

 

1819

 

    _fmt = 'Unable to import library "%(library)s": %(error)s'

1820

 

 

1821

 

    def __init__(self, library, error):

1822

 

        BzrError.__init__(self, library=library, error=error)

1823

 

 

1824

 

 

1825

 

class GpgmeNotInstalled(DependencyNotPresent):

1826

 

 

1827

 

    _fmt = 'python-gpgme is not installed, it is needed to verify signatures'

1828

 

 

1829

 

    def __init__(self, error):

1830

 

        DependencyNotPresent.__init__(self, 'gpgme', error)

1831

 

 

1832

 

 

1833

1733

class WorkingTreeNotRevision(BzrError):

1834

1734

 

1835

1735

    _fmt = ("The working tree for %(basedir)s has changed since"

1995

1895

    _fmt = "Moving the root directory is not supported at this time"

1996

1896

 

1997

1897

 

1998

 

class TransformRenameFailed(BzrError):

1999

 

 

2000

 

    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"

2001

 

 

2002

 

    def __init__(self, from_path, to_path, why, errno):

2003

 

        self.from_path = from_path

2004

 

        self.to_path = to_path

2005

 

        self.why = why

2006

 

        self.errno = errno

2007

 

 

2008

 

 

2009

1898

class BzrMoveFailedError(BzrError):

2010

1899

 

2011

 

    _fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"

2012

 

        "%(_has_extra)s%(extra)s")

 

1900

    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"

2013

1901

 

2014

1902

    def __init__(self, from_path='', to_path='', extra=None):

2015

1903

        from bzrlib.osutils import splitpath

2016

1904

        BzrError.__init__(self)

2017

1905

        if extra:

2018

 

            self.extra, self._has_extra = extra, ': '

 

1906

            self.extra = ': ' + str(extra)

2019

1907

        else:

2020

 

            self.extra = self._has_extra = ''

 

1908

            self.extra = ''

2021

1909

 

2022

1910

        has_from = len(from_path) > 0

2023

1911

        has_to = len(to_path) > 0

2044

1932

 

2045

1933

class BzrRenameFailedError(BzrMoveFailedError):

2046

1934

 

2047

 

    _fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"

2048

 

        "%(_has_extra)s%(extra)s")

 

1935

    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"

2049

1936

 

2050

1937

    def __init__(self, from_path, to_path, extra=None):

2051

1938

        BzrMoveFailedError.__init__(self, from_path, to_path, extra)

2052

1939

 

2053

 

 

2054

1940

class BzrRemoveChangedFilesError(BzrError):

2055

1941

    """Used when user is trying to remove changed files."""

2056

1942

 

2059

1945

        "Use --keep to not delete them, or --force to delete them regardless.")

2060

1946

 

2061

1947

    def __init__(self, tree_delta):

2062

 

        symbol_versioning.warn(symbol_versioning.deprecated_in((2, 3, 0)) %

2063

 

            "BzrRemoveChangedFilesError", DeprecationWarning, stacklevel=2)

2064

1948

        BzrError.__init__(self)

2065

1949

        self.changes_as_text = tree_delta.get_changes_as_text()

2066

1950

        #self.paths_as_string = '\n'.join(changed_files)

2074

1958

 

2075

1959

class BzrBadParameterMissing(BzrBadParameter):

2076

1960

 

2077

 

    _fmt = "Parameter %(param)s is required but not present."

 

1961

    _fmt = "Parameter $(param)s is required but not present."

2078

1962

 

2079

1963

 

2080

1964

class BzrBadParameterUnicode(BzrBadParameter):

2088

1972

    _fmt = "Parameter %(param)s contains a newline."

2089

1973

 

2090

1974

 

 

1975

class DependencyNotPresent(BzrError):

 

1976

 

 

1977

    _fmt = 'Unable to import library "%(library)s": %(error)s'

 

1978

 

 

1979

    def __init__(self, library, error):

 

1980

        BzrError.__init__(self, library=library, error=error)

 

1981

 

 

1982

 

2091

1983

class ParamikoNotPresent(DependencyNotPresent):

2092

1984

 

2093

1985

    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"

2112

2004

 

2113

2005

class BadConversionTarget(BzrError):

2114

2006

 

2115

 

    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \

2116

 

            "    %(problem)s"

 

2007

    _fmt = "Cannot convert to format %(format)s.  %(problem)s"

2117

2008

 

2118

 

    def __init__(self, problem, format, from_format=None):

 

2009

    def __init__(self, problem, format):

2119

2010

        BzrError.__init__(self)

2120

2011

        self.problem = problem

2121

2012

        self.format = format

2122

 

        self.from_format = from_format or '(unspecified)'

2123

2013

 

2124

2014

 

2125

2015

class NoDiffFound(BzrError):

2201

2091

 

2202

2092

class OutOfDateTree(BzrError):

2203

2093

 

2204

 

    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"

 

2094

    _fmt = "Working tree is out of date, please run 'bzr update'."

2205

2095

 

2206

 

    def __init__(self, tree, more=None):

2207

 

        if more is None:

2208

 

            more = ''

2209

 

        else:

2210

 

            more = ' ' + more

 

2096

    def __init__(self, tree):

2211

2097

        BzrError.__init__(self)

2212

2098

        self.tree = tree

2213

 

        self.more = more

2214

2099

 

2215

2100

 

2216

2101

class PublicBranchOutOfDate(BzrError):

2254

2139

 

2255

2140

    def __init__(self, repo):

2256

2141

        BzrError.__init__(self)

2257

 

        self.repo_path = repo.user_url

 

2142

        self.repo_path = repo.bzrdir.root_transport.base

2258

2143

 

2259

2144

 

2260

2145

class InconsistentDelta(BzrError):

2270

2155

        self.reason = reason

2271

2156

 

2272

2157

 

2273

 

class InconsistentDeltaDelta(InconsistentDelta):

2274

 

    """Used when we get a delta that is not valid."""

2275

 

 

2276

 

    _fmt = ("An inconsistent delta was supplied: %(delta)r"

2277

 

            "\nreason: %(reason)s")

2278

 

 

2279

 

    def __init__(self, delta, reason):

2280

 

        BzrError.__init__(self)

2281

 

        self.delta = delta

2282

 

        self.reason = reason

2283

 

 

2284

 

 

2285

2158

class UpgradeRequired(BzrError):

2286

2159

 

2287

2160

    _fmt = "To use this feature you must upgrade your branch at %(path)s."

2296

2169

    _fmt = "To use this feature you must upgrade your repository at %(path)s."

2297

2170

 

2298

2171

 

2299

 

class RichRootUpgradeRequired(UpgradeRequired):

2300

 

 

2301

 

    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"

2302

 

           " a format which supports rich roots.")

2303

 

 

2304

 

 

2305

2172

class LocalRequiresBoundBranch(BzrError):

2306

2173

 

2307

2174

    _fmt = "Cannot perform local-only commits on unbound branches."

2308

2175

 

2309

2176

 

 

2177

class InvalidProgressBarType(BzrError):

 

2178

 

 

2179

    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"

 

2180

            " is not a supported type Select one of: %(valid_types)s")

 

2181

 

 

2182

    def __init__(self, bar_type, valid_types):

 

2183

        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)

 

2184

 

 

2185

 

2310

2186

class UnsupportedOperation(BzrError):

2311

2187

 

2312

2188

    _fmt = ("The method %(mname)s is not supported on"

2696

2572

 

2697

2573

    This is distinct from ErrorFromSmartServer so that it is possible to

2698

2574

    distinguish between the following two cases:

2699

 

 

2700

 

    - ErrorFromSmartServer was uncaught.  This is logic error in the client

2701

 

      and so should provoke a traceback to the user.

2702

 

    - ErrorFromSmartServer was caught but its error_tuple could not be

2703

 

      translated.  This is probably because the server sent us garbage, and

2704

 

      should not provoke a traceback.

 

2575

      - ErrorFromSmartServer was uncaught.  This is logic error in the client

 

2576

        and so should provoke a traceback to the user.

 

2577

      - ErrorFromSmartServer was caught but its error_tuple could not be

 

2578

        translated.  This is probably because the server sent us garbage, and

 

2579

        should not provoke a traceback.

2705

2580

    """

2706

2581

 

2707

2582

    _fmt = "Server sent an unexpected error: %(error_tuple)r"

2833

2708

 

2834

2709

    def __init__(self, bzrdir):

2835

2710

        import bzrlib.urlutils as urlutils

2836

 

        display_url = urlutils.unescape_for_display(bzrdir.user_url,

 

2711

        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,

2837

2712

                                                    'ascii')

2838

2713

        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)

2839

2714

 

2904

2779

 

2905

2780

class UncommittedChanges(BzrError):

2906

2781

 

2907

 

    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'

2908

 

            ' (See bzr status).%(more)s')

 

2782

    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'

2909

2783

 

2910

 

    def __init__(self, tree, more=None):

2911

 

        if more is None:

2912

 

            more = ''

2913

 

        else:

2914

 

            more = ' ' + more

 

2784

    def __init__(self, tree):

2915

2785

        import bzrlib.urlutils as urlutils

2916

 

        user_url = getattr(tree, "user_url", None)

2917

 

        if user_url is None:

2918

 

            display_url = str(tree)

2919

 

        else:

2920

 

            display_url = urlutils.unescape_for_display(user_url, 'ascii')

2921

 

        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)

2922

 

 

2923

 

 

2924

 

class ShelvedChanges(UncommittedChanges):

2925

 

 

2926

 

    _fmt = ('Working tree "%(display_url)s" has shelved changes'

2927

 

            ' (See bzr shelve --list).%(more)s')

 

2786

        display_url = urlutils.unescape_for_display(

 

2787

            tree.bzrdir.root_transport.base, 'ascii')

 

2788

        BzrError.__init__(self, tree=tree, display_url=display_url)

2928

2789

 

2929

2790

 

2930

2791

class MissingTemplateVariable(BzrError):

3001

2862

        self.user_encoding = osutils.get_user_encoding()

3002

2863

 

3003

2864

 

3004

 

class NoSuchConfig(BzrError):

3005

 

 

3006

 

    _fmt = ('The "%(config_id)s" configuration does not exist.')

3007

 

 

3008

 

    def __init__(self, config_id):

3009

 

        BzrError.__init__(self, config_id=config_id)

3010

 

 

3011

 

 

3012

 

class NoSuchConfigOption(BzrError):

3013

 

 

3014

 

    _fmt = ('The "%(option_name)s" configuration option does not exist.')

3015

 

 

3016

 

    def __init__(self, option_name):

3017

 

        BzrError.__init__(self, option_name=option_name)

3018

 

 

3019

 

 

3020

2865

class NoSuchAlias(BzrError):

3021

2866

 

3022

2867

    _fmt = ('The alias "%(alias_name)s" does not exist.')

3052

2897

    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'

3053

2898

 

3054

2899

    def __init__(self, host, port, orig_error):

3055

 

        # nb: in python2.4 socket.error doesn't have a useful repr

3056

2900

        BzrError.__init__(self, host=host, port=port,

3057

 

            orig_error=repr(orig_error.args))

 

2901

            orig_error=orig_error[1])

3058

2902

 

3059

2903

 

3060

2904

class UnknownRules(BzrError):

3068

2912

class HookFailed(BzrError):

3069

2913

    """Raised when a pre_change_branch_tip hook function fails anything other

3070

2914

    than TipChangeRejected.

3071

 

 

3072

 

    Note that this exception is no longer raised, and the import is only left

3073

 

    to be nice to code which might catch it in a plugin.

3074

2915

    """

3075

2916

 

3076

2917

    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"

3077

2918

            "%(traceback_text)s%(exc_value)s")

3078

2919

 

3079

 

    def __init__(self, hook_stage, hook_name, exc_info, warn=True):

3080

 

        if warn:

3081

 

            symbol_versioning.warn("BzrError HookFailed has been deprecated "

3082

 

                "as of bzrlib 2.1.", DeprecationWarning, stacklevel=2)

 

2920

    def __init__(self, hook_stage, hook_name, exc_info):

3083

2921

        import traceback

3084

2922

        self.hook_stage = hook_stage

3085

2923

        self.hook_name = hook_name

3106

2944

    _fmt = "Shelf corrupt."

3107

2945

 

3108

2946

 

3109

 

class DecompressCorruption(BzrError):

3110

 

 

3111

 

    _fmt = "Corruption while decompressing repository file%(orig_error)s"

3112

 

 

3113

 

    def __init__(self, orig_error=None):

3114

 

        if orig_error is not None:

3115

 

            self.orig_error = ", %s" % (orig_error,)

3116

 

        else:

3117

 

            self.orig_error = ""

3118

 

        BzrError.__init__(self)

3119

 

 

3120

 

 

3121

2947

class NoSuchShelfId(BzrError):

3122

2948

 

3123

2949

    _fmt = 'No changes are shelved with id "%(shelf_id)d".'

3207

3033

 

3208

3034

    def __init__(self, repository):

3209

3035

        self.repository = repository

3210

 

 

3211

 

 

3212

 

class LossyPushToSameVCS(BzrError):

3213

 

 

3214

 

    _fmt = ("Lossy push not possible between %(source_branch)r and "

3215

 

            "%(target_branch)r that are in the same VCS.")

3216

 

 

3217

 

    internal_error = True

3218

 

 

3219

 

    def __init__(self, source_branch, target_branch):

3220

 

        self.source_branch = source_branch

3221

 

        self.target_branch = target_branch

3222

 

 

3223

 

 

3224

 

class NoRoundtrippingSupport(BzrError):

3225

 

 

3226

 

    _fmt = ("Roundtripping is not supported between %(source_branch)r and "

3227

 

            "%(target_branch)r.")

3228

 

 

3229

 

    internal_error = True

3230

 

 

3231

 

    def __init__(self, source_branch, target_branch):

3232

 

        self.source_branch = source_branch

3233

 

        self.target_branch = target_branch

3234

 

 

3235

 

 

3236

 

class FileTimestampUnavailable(BzrError):

3237

 

 

3238

 

    _fmt = "The filestamp for %(path)s is not available."

3239

 

 

3240

 

    internal_error = True

3241

 

 

3242

 

    def __init__(self, path):

3243

 

        self.path = path

3244

 

 

3245

 

 

3246

 

class NoColocatedBranchSupport(BzrError):

3247

 

 

3248

 

    _fmt = ("%(bzrdir)r does not support co-located branches.")

3249

 

 

3250

 

    def __init__(self, bzrdir):

3251

 

        self.bzrdir = bzrdir

3252

 

 

3253

 

 

3254

 

class NoWhoami(BzrError):

3255

 

 

3256

 

    _fmt = ('Unable to determine your name.\n'

3257

 

        "Please, set your name with the 'whoami' command.\n"

3258

 

        'E.g. bzr whoami "Your Name <name@example.com>"')

3259

 

 

3260

 

 

3261

 

class InvalidPattern(BzrError):

3262

 

 

3263

 

    _fmt = ('Invalid pattern(s) found. %(msg)s')

3264

 

 

3265

 

    def __init__(self, msg):

3266

 

        self.msg = msg

3267

 

 

3268

 

 

3269

 

class RecursiveBind(BzrError):

3270

 

 

3271

 

    _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '

3272

 

        'Please use `bzr unbind` to fix.')

3273

 

 

3274

 

    def __init__(self, branch_url):

3275

 

        self.branch_url = branch_url

3276

 

 

3277

 

 

3278

 

# FIXME: I would prefer to define the config related exception classes in

3279

 

# config.py but the lazy import mechanism proscribes this -- vila 20101222

3280

 

class OptionExpansionLoop(BzrError):

3281

 

 

3282

 

    _fmt = 'Loop involving %(refs)r while expanding "%(string)s".'

3283

 

 

3284

 

    def __init__(self, string, refs):

3285

 

        self.string = string

3286

 

        self.refs = '->'.join(refs)

3287

 

 

3288

 

 

3289

 

class ExpandingUnknownOption(BzrError):

3290

 

 

3291

 

    _fmt = 'Option %(name)s is not defined while expanding "%(string)s".'

3292

 

 

3293

 

    def __init__(self, name, string):

3294

 

        self.name = name

3295

 

        self.string = string

3296

 

 

3297

 

 

3298

 

class NoCompatibleInter(BzrError):

3299

 

 

3300

 

    _fmt = ('No compatible object available for operations from %(source)r '

3301

 

            'to %(target)r.')

3302

 

 

3303

 

    def __init__(self, source, target):

3304

 

        self.source = source

3305

 

        self.target = target

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1