Merge lp:~jelmer/brz/move-errors into lp:brz

[Jelmer Vernooij]

Move some more errors.

Move some more errors.

[Jelmer Vernooij (jelmer)]

review: Approve

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/1000/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/1013/

[lp:~jelmer/brz/move-errors]

7610. By Jelmer Vernooij on 2022-07-16

Move some more errors.

Merged from https://code.launchpad.net/~jelmer/brz/move-errors/+merge/426962

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2022-01-21 17:19:24 +0000
+++ breezy/builtins.py	2022-07-16 17:54:02 +0000
@@ -162,7 +162,7 @@
         # Perhaps it's a colocated branch?
         return control_dir.open_branch(
             location, possible_transports=possible_transports)
-    except (errors.NotBranchError, errors.NoColocatedBranchSupport):
+    except (errors.NotBranchError, controldir.NoColocatedBranchSupport):
         this_url = _get_branch_location(control_dir)
         return Branch.open(
             urlutils.join(

=== modified file 'breezy/bzr/groupcompress.py'
--- breezy/bzr/groupcompress.py	2022-01-09 13:12:27 +0000
+++ breezy/bzr/groupcompress.py	2022-07-16 17:54:02 +0000
@@ -1513,7 +1513,7 @@
                     remaining_keys.discard(content_factory.key)
                     yield content_factory
                 return
-            except errors.RetryWithNewPacks as e:
+            except pack_repo.RetryWithNewPacks as e:
                 self._access.reload_or_raise(e)
 
     def _find_from_fallback(self, missing):

=== modified file 'breezy/bzr/knit.py'
--- breezy/bzr/knit.py	2022-01-21 17:19:24 +0000
+++ breezy/bzr/knit.py	2022-07-16 17:54:02 +0000
@@ -1398,7 +1398,7 @@
                     (record_details, index_memo, next) = position_map[key]
                     raw_record_map[key] = data, record_details, next
                 return raw_record_map
-            except errors.RetryWithNewPacks as e:
+            except pack_repo.RetryWithNewPacks as e:
                 self._access.reload_or_raise(e)
 
     @classmethod
@@ -1507,7 +1507,7 @@
                     remaining_keys.discard(content_factory.key)
                     yield content_factory
                 return
-            except errors.RetryWithNewPacks as e:
+            except pack_repo.RetryWithNewPacks as e:
                 self._access.reload_or_raise(e)
 
     def _get_remaining_record_stream(self, keys, ordering,
@@ -1891,7 +1891,7 @@
                     for line in line_iterator:
                         yield line, key
                 done = True
-            except errors.RetryWithNewPacks as e:
+            except pack_repo.RetryWithNewPacks as e:
                 self._access.reload_or_raise(e)
         # If there are still keys we've not yet found, we look in the fallback
         # vfs, and hope to find them there.  Note that if the keys are found
@@ -3464,7 +3464,7 @@
                     num_lines = len(text)  # bad assumption
                     yield sub_key, text, num_lines
                 return
-            except errors.RetryWithNewPacks as e:
+            except pack_repo.RetryWithNewPacks as e:
                 self._vf._access.reload_or_raise(e)
                 # The cached build_details are no longer valid
                 self._all_build_details.clear()

=== modified file 'breezy/bzr/pack.py'
--- breezy/bzr/pack.py	2020-02-18 01:57:45 +0000
+++ breezy/bzr/pack.py	2022-07-16 17:54:02 +0000
@@ -32,6 +32,55 @@
 _whitespace_re = re.compile(b'[\t\n\x0b\x0c\r ]')
 
 
+class ContainerError(errors.BzrError):
+    """Base class of container errors."""
+
+
+class UnknownContainerFormatError(ContainerError):
+
+    _fmt = "Unrecognised container format: %(container_format)r"
+
+    def __init__(self, container_format):
+        self.container_format = container_format
+
+
+class UnexpectedEndOfContainerError(ContainerError):
+
+    _fmt = "Unexpected end of container stream"
+
+
+class UnknownRecordTypeError(ContainerError):
+
+    _fmt = "Unknown record type: %(record_type)r"
+
+    def __init__(self, record_type):
+        self.record_type = record_type
+
+
+class InvalidRecordError(ContainerError):
+
+    _fmt = "Invalid record: %(reason)s"
+
+    def __init__(self, reason):
+        self.reason = reason
+
+
+class ContainerHasExcessDataError(ContainerError):
+
+    _fmt = "Container has data after end marker: %(excess)r"
+
+    def __init__(self, excess):
+        self.excess = excess
+
+
+class DuplicateRecordNameError(ContainerError):
+
+    _fmt = "Container has multiple records with the same name: %(name)s"
+
+    def __init__(self, name):
+        self.name = name.decode("utf-8")
+
+
 def _check_name(name):
     """Do some basic checking of 'name'.
 
@@ -42,7 +91,7 @@
     :seealso: _check_name_encoding
     """
     if _whitespace_re.search(name) is not None:
-        raise errors.InvalidRecordError("%r is not a valid name." % (name,))
+        raise InvalidRecordError("%r is not a valid name." % (name,))
 
 
 def _check_name_encoding(name):
@@ -56,7 +105,7 @@
     try:
         name.decode('utf-8')
     except UnicodeDecodeError as e:
-        raise errors.InvalidRecordError(str(e))
+        raise InvalidRecordError(str(e))
 
 
 class ContainerSerialiser(object):
@@ -245,7 +294,7 @@
     def _read_line(self):
         line = self._source.readline()
         if not line.endswith(b'\n'):
-            raise errors.UnexpectedEndOfContainerError()
+            raise UnexpectedEndOfContainerError()
         return line.rstrip(b'\n')
 
 
@@ -313,15 +362,15 @@
             elif record_kind == b'':
                 # End of stream encountered, but no End Marker record seen, so
                 # this container is incomplete.
-                raise errors.UnexpectedEndOfContainerError()
+                raise UnexpectedEndOfContainerError()
             else:
                 # Unknown record type.
-                raise errors.UnknownRecordTypeError(record_kind)
+                raise UnknownRecordTypeError(record_kind)
 
     def _read_format(self):
         format = self._read_line()
         if format != FORMAT_ONE:
-            raise errors.UnknownContainerFormatError(format)
+            raise UnknownContainerFormatError(format)
 
     def validate(self):
         """Validate this container and its records.
@@ -343,11 +392,11 @@
                 # risk that the same unicode string has been encoded two
                 # different ways.
                 if name_tuple in all_names:
-                    raise errors.DuplicateRecordNameError(name_tuple[0])
+                    raise DuplicateRecordNameError(name_tuple[0])
                 all_names.add(name_tuple)
         excess_bytes = self.reader_func(1)
         if excess_bytes != b'':
-            raise errors.ContainerHasExcessDataError(excess_bytes)
+            raise ContainerHasExcessDataError(excess_bytes)
 
 
 class BytesRecordReader(BaseReader):
@@ -368,7 +417,7 @@
         try:
             length = int(length_line)
         except ValueError:
-            raise errors.InvalidRecordError(
+            raise InvalidRecordError(
                 "%r is not a valid length." % (length_line,))
 
         # Read the list of names.
@@ -393,7 +442,7 @@
         self._remaining_length -= length_to_read
         bytes = self.reader_func(length_to_read)
         if len(bytes) != length_to_read:
-            raise errors.UnexpectedEndOfContainerError()
+            raise UnexpectedEndOfContainerError()
         return bytes
 
     def validate(self):
@@ -470,7 +519,7 @@
         line = self._consume_line()
         if line is not None:
             if line != FORMAT_ONE:
-                raise errors.UnknownContainerFormatError(line)
+                raise UnknownContainerFormatError(line)
             self._state_handler = self._state_expecting_record_type
 
     def _state_expecting_record_type(self):
@@ -483,7 +532,7 @@
                 self.finished = True
                 self._state_handler = self._state_expecting_nothing
             else:
-                raise errors.UnknownRecordTypeError(record_type)
+                raise UnknownRecordTypeError(record_type)
 
     def _state_expecting_length(self):
         line = self._consume_line()
@@ -491,7 +540,7 @@
             try:
                 self._current_record_length = int(line)
             except ValueError:
-                raise errors.InvalidRecordError(
+                raise InvalidRecordError(
                     "%r is not a valid length." % (line,))
             self._state_handler = self._state_expecting_name
 

=== modified file 'breezy/bzr/pack_repo.py'
--- breezy/bzr/pack_repo.py	2021-05-24 01:06:31 +0000
+++ breezy/bzr/pack_repo.py	2022-07-16 17:54:02 +0000
@@ -70,6 +70,53 @@
     )
 
 
+class RetryWithNewPacks(errors.BzrError):
+    """Raised when we realize that the packs on disk have changed.
+
+    This is meant as more of a signaling exception, to trap between where a
+    local error occurred and the code that can actually handle the error and
+    code that can retry appropriately.
+    """
+
+    internal_error = True
+
+    _fmt = ("Pack files have changed, reload and retry. context: %(context)s"
+            " %(orig_error)s")
+
+    def __init__(self, context, reload_occurred, exc_info):
+        """create a new RetryWithNewPacks error.
+
+        :param reload_occurred: Set to True if we know that the packs have
+            already been reloaded, and we are failing because of an in-memory
+            cache miss. If set to True then we will ignore if a reload says
+            nothing has changed, because we assume it has already reloaded. If
+            False, then a reload with nothing changed will force an error.
+        :param exc_info: The original exception traceback, so if there is a
+            problem we can raise the original error (value from sys.exc_info())
+        """
+        errors.BzrError.__init__(self)
+        self.context = context
+        self.reload_occurred = reload_occurred
+        self.exc_info = exc_info
+        self.orig_error = exc_info[1]
+        # TODO: The global error handler should probably treat this by
+        #       raising/printing the original exception with a bit about
+        #       RetryWithNewPacks also not being caught
+
+
+class RetryAutopack(RetryWithNewPacks):
+    """Raised when we are autopacking and we find a missing file.
+
+    Meant as a signaling exception, to tell the autopack code it should try
+    again.
+    """
+
+    internal_error = True
+
+    _fmt = ("Pack files have changed, reload and try autopack again."
+            " context: %(context)s %(orig_error)s")
+
+
 class PackCommitBuilder(VersionedFileCommitBuilder):
     """Subclass of VersionedFileCommitBuilder to add texts with pack semantics.
 
@@ -876,7 +923,7 @@
         while True:
             try:
                 return self._do_autopack()
-            except errors.RetryAutopack:
+            except RetryAutopack:
                 # If we get a RetryAutopack exception, we should abort the
                 # current action, and retry.
                 pass
@@ -936,7 +983,7 @@
                                   reload_func=reload_func)
             try:
                 result = packer.pack()
-            except errors.RetryWithNewPacks:
+            except RetryWithNewPacks:
                 # An exception is propagating out of this context, make sure
                 # this packer has cleaned up. Packer() doesn't set its new_pack
                 # state into the RepositoryPackCollection object, so we only
@@ -1476,7 +1523,7 @@
             # Re-raise the original exception, because something went missing
             # and a restart didn't find it
             raise
-        raise errors.RetryAutopack(self.repo, False, sys.exc_info())
+        raise RetryAutopack(self.repo, False, sys.exc_info())
 
     def _restart_pack_operations(self):
         """Reload the pack names list, and restart the autopack code."""
@@ -1928,7 +1975,7 @@
                                      _serializer=self._serializer)
 
 
-class RetryPackOperations(errors.RetryWithNewPacks):
+class RetryPackOperations(RetryWithNewPacks):
     """Raised when we are packing and we find a missing file.
 
     Meant as a signaling exception, to tell the RepositoryPackCollection.pack
@@ -2044,9 +2091,9 @@
                     # If we don't have a _reload_func there is nothing that can
                     # be done
                     raise
-                raise errors.RetryWithNewPacks(index,
-                                               reload_occurred=True,
-                                               exc_info=sys.exc_info())
+                raise RetryWithNewPacks(index,
+                                        reload_occurred=True,
+                                        exc_info=sys.exc_info())
             try:
                 reader = pack.make_readv_reader(transport, path, offsets)
                 for names, read_func in reader.iter_records():
@@ -2056,9 +2103,9 @@
                 # missing on disk, we need to trigger a reload, and start over.
                 if self._reload_func is None:
                     raise
-                raise errors.RetryWithNewPacks(transport.abspath(path),
-                                               reload_occurred=False,
-                                               exc_info=sys.exc_info())
+                raise RetryWithNewPacks(transport.abspath(path),
+                                        reload_occurred=False,
+                                        exc_info=sys.exc_info())
 
     def set_writer(self, writer, index, transport_packname):
         """Set a writer to use for adding data."""

=== modified file 'breezy/bzr/remote.py'
--- breezy/bzr/remote.py	2022-01-03 20:29:28 +0000
+++ breezy/bzr/remote.py	2022-07-16 17:54:02 +0000
@@ -70,6 +70,33 @@
 _DEFAULT_SEARCH_DEPTH = 100
 
 
+class UnknownErrorFromSmartServer(errors.BzrError):
+    """An ErrorFromSmartServer could not be translated into a typical breezy
+    error.
+
+    This is distinct from ErrorFromSmartServer so that it is possible to
+    distinguish between the following two cases:
+
+     - ErrorFromSmartServer was uncaught.  This is logic error in the client
+       and so should provoke a traceback to the user.
+     - ErrorFromSmartServer was caught but its error_tuple could not be
+       translated.  This is probably because the server sent us garbage, and
+       should not provoke a traceback.
+    """
+
+    _fmt = "Server sent an unexpected error: %(error_tuple)r"
+
+    internal_error = False
+
+    def __init__(self, error_from_smart_server):
+        """Constructor.
+
+        :param error_from_smart_server: An ErrorFromSmartServer instance.
+        """
+        self.error_from_smart_server = error_from_smart_server
+        self.error_tuple = error_from_smart_server.error_tuple
+
+
 class _RpcHelper(object):
     """Mixin class that helps with issuing RPCs."""
 
@@ -567,7 +594,7 @@
         except errors.UnknownSmartMethod:
             medium._remember_remote_is_before((1, 13))
             return self._vfs_cloning_metadir(require_stacking=require_stacking)
-        except errors.UnknownErrorFromSmartServer as err:
+        except UnknownErrorFromSmartServer as err:
             if err.error_tuple != (b'BranchReference',):
                 raise
             # We need to resolve the branch reference to determine the
@@ -641,7 +668,7 @@
         if name is None:
             name = self._get_selected_branch()
         if name != "":
-            raise errors.NoColocatedBranchSupport(self)
+            raise controldir.NoColocatedBranchSupport(self)
         # as per meta1 formats - just delegate to the format object which may
         # be parameterised.
         real_branch = self._format.get_branch_format().initialize(self,
@@ -669,7 +696,7 @@
         if name is None:
             name = self._get_selected_branch()
         if name != "":
-            raise errors.NoColocatedBranchSupport(self)
+            raise controldir.NoColocatedBranchSupport(self)
         path = self._path_for_remote_call(self._client)
         try:
             if name != "":
@@ -741,7 +768,7 @@
         if name is None:
             name = self._get_selected_branch()
         if name != "":
-            raise errors.NoColocatedBranchSupport(self)
+            raise controldir.NoColocatedBranchSupport(self)
         self._ensure_real()
         return self._real_bzrdir.set_branch_reference(target_branch, name=name)
 
@@ -750,7 +777,7 @@
         if name is None:
             name = self._get_selected_branch()
         if name != "":
-            raise errors.NoColocatedBranchSupport(self)
+            raise controldir.NoColocatedBranchSupport(self)
         response = self._get_branch_reference()
         if response[0] == 'ref':
             return response[1].decode('utf-8')
@@ -820,7 +847,7 @@
         if name is None:
             name = self._get_selected_branch()
         if name != "":
-            raise errors.NoColocatedBranchSupport(self)
+            raise controldir.NoColocatedBranchSupport(self)
         if unsupported:
             raise NotImplementedError(
                 'unsupported flag support not implemented yet.')
@@ -1395,7 +1422,7 @@
         except errors.UnknownSmartMethod:
             self._client._medium._remember_remote_is_before((1, 17))
             return self._get_rev_id_for_revno_vfs(revno, known_pair)
-        except errors.UnknownErrorFromSmartServer as e:
+        except UnknownErrorFromSmartServer as e:
             # Older versions of Bazaar/Breezy (<< 3.0.0) would raise a
             # ValueError instead of returning revno-outofbounds
             if len(e.error_tuple) < 3:
@@ -3145,7 +3172,7 @@
                     verb, args, search_bytes)
             except errors.UnknownSmartMethod:
                 medium._remember_remote_is_before(version)
-            except errors.UnknownErrorFromSmartServer as e:
+            except UnknownErrorFromSmartServer as e:
                 if isinstance(search, vf_search.EverythingResult):
                     error_verb = e.error_from_smart_server.error_verb
                     if error_verb == b'BadSearch':
@@ -3313,7 +3340,7 @@
         path = a_controldir._path_for_remote_call(a_controldir._client)
         if name != "":
             # XXX JRV20100304: Support creating colocated branches
-            raise errors.NoColocatedBranchSupport(self)
+            raise controldir.NoColocatedBranchSupport(self)
         verb = b'BzrDir.create_branch'
         try:
             response = a_controldir._call(verb, path, network_name)
@@ -4033,7 +4060,7 @@
             except errors.UnknownSmartMethod:
                 self._ensure_real()
                 return self._real_branch.revision_id_to_dotted_revno(revision_id)
-            except errors.UnknownErrorFromSmartServer as e:
+            except UnknownErrorFromSmartServer as e:
                 # Deal with older versions of bzr/brz that didn't explicitly
                 # wrap GhostRevisionsHaveNoRevno.
                 if e.error_tuple[1] == b'GhostRevisionsHaveNoRevno':
@@ -4426,7 +4453,7 @@
     try:
         translator = no_context_error_translators.get(err.error_verb)
     except KeyError:
-        raise errors.UnknownErrorFromSmartServer(err)
+        raise UnknownErrorFromSmartServer(err)
     else:
         raise translator(err)
 

=== modified file 'breezy/bzr/smart/medium.py'
--- breezy/bzr/smart/medium.py	2020-02-18 01:57:45 +0000
+++ breezy/bzr/smart/medium.py	2022-07-16 17:54:02 +0000
@@ -1179,6 +1179,16 @@
         pass
 
 
+class TooManyConcurrentRequests(errors.InternalBzrError):
+
+    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
+            " Be sure to finish_writing and finish_reading on the"
+            " currently open request.")
+
+    def __init__(self, medium):
+        self.medium = medium
+
+
 class SmartClientStreamMediumRequest(SmartClientMediumRequest):
     """A SmartClientMediumRequest that works with an SmartClientStreamMedium."""
 
@@ -1190,7 +1200,7 @@
         # and the setting/unsetting of _current_request likewise moved into
         # that class : but its unneeded overhead for now. RBC 20060922
         if self._medium._current_request is not None:
-            raise errors.TooManyConcurrentRequests(self._medium)
+            raise TooManyConcurrentRequests(self._medium)
         self._medium._current_request = self
 
     def _accept_bytes(self, bytes):

=== modified file 'breezy/bzr/smart/protocol.py'
--- breezy/bzr/smart/protocol.py	2021-08-18 22:38:08 +0000
+++ breezy/bzr/smart/protocol.py	2022-07-16 17:54:02 +0000
@@ -52,6 +52,21 @@
 RESPONSE_VERSION_THREE = REQUEST_VERSION_THREE = MESSAGE_VERSION_THREE
 
 
+class SmartMessageHandlerError(errors.InternalBzrError):
+
+    _fmt = ("The message handler raised an exception:\n"
+            "%(traceback_text)s")
+
+    def __init__(self, exc_info):
+        import traceback
+        # GZ 2010-08-10: Cycle with exc_tb/exc_info affects at least one test
+        self.exc_type, self.exc_value, self.exc_tb = exc_info
+        self.exc_info = exc_info
+        traceback_strings = traceback.format_exception(
+            self.exc_type, self.exc_value, self.exc_tb)
+        self.traceback_text = ''.join(traceback_strings)
+
+
 def _recv_tuple(from_file):
     req_line = from_file.readline()
     return _decode_tuple(req_line)
@@ -916,7 +931,7 @@
             _StatefulDecoder.accept_bytes(self, bytes)
         except KeyboardInterrupt:
             raise
-        except errors.SmartMessageHandlerError as exception:
+        except SmartMessageHandlerError as exception:
             # We do *not* set self.decoding_failed here.  The message handler
             # has raised an error, but the decoder is still able to parse bytes
             # and determine when this message ends.
@@ -1008,7 +1023,7 @@
         try:
             self.message_handler.headers_received(decoded)
         except:
-            raise errors.SmartMessageHandlerError(sys.exc_info())
+            raise SmartMessageHandlerError(sys.exc_info())
 
     def _state_accept_expecting_message_part(self):
         message_part_kind = self._extract_single_byte()
@@ -1030,7 +1045,7 @@
         try:
             self.message_handler.byte_part_received(byte)
         except:
-            raise errors.SmartMessageHandlerError(sys.exc_info())
+            raise SmartMessageHandlerError(sys.exc_info())
 
     def _state_accept_expecting_bytes(self):
         # XXX: this should not buffer whole message part, but instead deliver
@@ -1040,7 +1055,7 @@
         try:
             self.message_handler.bytes_part_received(prefixed_bytes)
         except:
-            raise errors.SmartMessageHandlerError(sys.exc_info())
+            raise SmartMessageHandlerError(sys.exc_info())
 
     def _state_accept_expecting_structure(self):
         structure = self._extract_prefixed_bencoded_data()
@@ -1048,7 +1063,7 @@
         try:
             self.message_handler.structure_part_received(structure)
         except:
-            raise errors.SmartMessageHandlerError(sys.exc_info())
+            raise SmartMessageHandlerError(sys.exc_info())
 
     def done(self):
         self.unused_data = self._get_in_buffer()
@@ -1057,7 +1072,7 @@
         try:
             self.message_handler.end_received()
         except:
-            raise errors.SmartMessageHandlerError(sys.exc_info())
+            raise SmartMessageHandlerError(sys.exc_info())
 
     def _state_accept_reading_unused(self):
         self.unused_data += self._get_in_buffer()

=== modified file 'breezy/bzr/tests/test_bzrdir.py'
--- breezy/bzr/tests/test_bzrdir.py	2021-12-25 16:33:03 +0000
+++ breezy/bzr/tests/test_bzrdir.py	2022-07-16 17:54:02 +0000
@@ -50,7 +50,6 @@
 from ..fullhistory import BzrBranchFormat5
 from ...errors import (
     NotBranchError,
-    NoColocatedBranchSupport,
     UnknownFormatError,
     UnsupportedFormatError,
     )
@@ -229,7 +228,7 @@
     def create_branch(self, name=None):
         """See ControlDir.create_branch."""
         if name is not None:
-            raise NoColocatedBranchSupport(self)
+            raise controldir.NoColocatedBranchSupport(self)
         return SampleBranch(self)
 
     def create_workingtree(self):

=== modified file 'breezy/bzr/tests/test_knit.py'
--- breezy/bzr/tests/test_knit.py	2020-06-10 02:56:53 +0000
+++ breezy/bzr/tests/test_knit.py	2022-07-16 17:54:02 +0000
@@ -492,7 +492,7 @@
         try:
             raise _TestException('foobar')
         except _TestException as e:
-            retry_exc = errors.RetryWithNewPacks(None, reload_occurred=False,
+            retry_exc = pack_repo.RetryWithNewPacks(None, reload_occurred=False,
                                                  exc_info=sys.exc_info())
         # GZ 2010-08-10: Cycle with exc_info affects 3 tests
         return retry_exc
@@ -546,7 +546,7 @@
         # Note that the index key has changed from 'foo' to 'bar'
         access = pack_repo._DirectPackAccess({'bar': (transport, 'packname')},
                                              reload_func=reload_func)
-        e = self.assertListRaises(errors.RetryWithNewPacks,
+        e = self.assertListRaises(pack_repo.RetryWithNewPacks,
                                   access.get_raw_records, memos)
         # Because a key was passed in which does not match our index list, we
         # assume that the listing was already reloaded
@@ -570,7 +570,7 @@
         access = pack_repo._DirectPackAccess(
             {'foo': (transport, 'different-packname')},
             reload_func=reload_func)
-        e = self.assertListRaises(errors.RetryWithNewPacks,
+        e = self.assertListRaises(pack_repo.RetryWithNewPacks,
                                   access.get_raw_records, memos)
         # The file has gone missing, so we assume we need to reload
         self.assertFalse(e.reload_occurred)
@@ -603,7 +603,7 @@
         self.assertEqual([b'12345'],
                          list(access.get_raw_records(memos[1:2])))
         # A multiple offset readv() will fail mid-way through
-        e = self.assertListRaises(errors.RetryWithNewPacks,
+        e = self.assertListRaises(pack_repo.RetryWithNewPacks,
                                   access.get_raw_records, memos)
         # The file has gone missing, so we assume we need to reload
         self.assertFalse(e.reload_occurred)
@@ -2671,3 +2671,14 @@
                  }
         for record in generator.get_record_stream():
             self.assertEqual(kinds[record.key], record.storage_kind)
+
+
+class TestErrors(TestCase):
+
+    def test_retry_with_new_packs(self):
+        fake_exc_info = ('{exc type}', '{exc value}', '{exc traceback}')
+        error = pack_repo.RetryWithNewPacks(
+            '{context}', reload_occurred=False, exc_info=fake_exc_info)
+        self.assertEqual(
+            'Pack files have changed, reload and retry. context: '
+            '{context} {exc value}', str(error))

=== modified file 'breezy/bzr/tests/test_pack.py'
--- breezy/bzr/tests/test_pack.py	2020-06-10 23:47:24 +0000
+++ breezy/bzr/tests/test_pack.py	2022-07-16 17:54:02 +0000
@@ -18,7 +18,7 @@
 
 from io import BytesIO
 
-from ... import errors, tests
+from ... import tests
 from .. import (
     pack,
     )
@@ -63,7 +63,7 @@
     def test_bytes_record_whitespace_in_name_part(self):
         serialiser = pack.ContainerSerialiser()
         self.assertRaises(
-            errors.InvalidRecordError,
+            pack.InvalidRecordError,
             serialiser.bytes_record, b'bytes', [(b'bad name',)])
 
     def test_bytes_record_header(self):
@@ -214,7 +214,7 @@
         """
         self.writer.begin()
         self.assertRaises(
-            errors.InvalidRecordError,
+            pack.InvalidRecordError,
             self.writer.add_bytes_record, [b'abc'], len(b'abc'), names=[(b'bad name', )])
 
     def test_add_bytes_records_add_to_records_written(self):
@@ -257,7 +257,7 @@
         """Unrecognised container formats raise UnknownContainerFormatError."""
         reader = self.get_reader_for(b"unknown format\n")
         self.assertRaises(
-            errors.UnknownContainerFormatError, reader.iter_records)
+            pack.UnknownContainerFormatError, reader.iter_records)
 
     def test_unexpected_end_of_container(self):
         """Containers that don't end with an End Marker record should cause
@@ -267,7 +267,7 @@
             b"Bazaar pack format 1 (introduced in 0.18)\n")
         iterator = reader.iter_records()
         self.assertRaises(
-            errors.UnexpectedEndOfContainerError, next, iterator)
+            pack.UnexpectedEndOfContainerError, next, iterator)
 
     def test_unknown_record_type(self):
         """Unknown record types cause UnknownRecordTypeError to be raised."""
@@ -275,7 +275,7 @@
             b"Bazaar pack format 1 (introduced in 0.18)\nX")
         iterator = reader.iter_records()
         self.assertRaises(
-            errors.UnknownRecordTypeError, next, iterator)
+            pack.UnknownRecordTypeError, next, iterator)
 
     def test_container_with_one_unnamed_record(self):
         """Read a container with one Bytes record.
@@ -318,8 +318,8 @@
         for input in inputs:
             reader = self.get_reader_for(input)
             self.assertRaises(
-                (errors.UnexpectedEndOfContainerError,
-                 errors.UnknownContainerFormatError),
+                (pack.UnexpectedEndOfContainerError,
+                 pack.UnknownContainerFormatError),
                 reader.validate)
 
     def test_validate_bad_record_marker(self):
@@ -328,7 +328,7 @@
         """
         reader = self.get_reader_for(
             b"Bazaar pack format 1 (introduced in 0.18)\nX")
-        self.assertRaises(errors.UnknownRecordTypeError, reader.validate)
+        self.assertRaises(pack.UnknownRecordTypeError, reader.validate)
 
     def test_validate_data_after_end_marker(self):
         """validate raises ContainerHasExcessDataError if there are any bytes
@@ -337,7 +337,7 @@
         reader = self.get_reader_for(
             b"Bazaar pack format 1 (introduced in 0.18)\nEcrud")
         self.assertRaises(
-            errors.ContainerHasExcessDataError, reader.validate)
+            pack.ContainerHasExcessDataError, reader.validate)
 
     def test_validate_no_end_marker(self):
         """validate raises UnexpectedEndOfContainerError if there's no end of
@@ -347,7 +347,7 @@
         reader = self.get_reader_for(
             b"Bazaar pack format 1 (introduced in 0.18)\n")
         self.assertRaises(
-            errors.UnexpectedEndOfContainerError, reader.validate)
+            pack.UnexpectedEndOfContainerError, reader.validate)
 
     def test_validate_duplicate_name(self):
         """validate raises DuplicateRecordNameError if the same name occurs
@@ -358,13 +358,13 @@
             b"B0\nname\n\n"
             b"B0\nname\n\n"
             b"E")
-        self.assertRaises(errors.DuplicateRecordNameError, reader.validate)
+        self.assertRaises(pack.DuplicateRecordNameError, reader.validate)
 
     def test_validate_undecodeable_name(self):
         """Names that aren't valid UTF-8 cause validate to fail."""
         reader = self.get_reader_for(
             b"Bazaar pack format 1 (introduced in 0.18)\nB0\n\xcc\n\nE")
-        self.assertRaises(errors.InvalidRecordError, reader.validate)
+        self.assertRaises(pack.InvalidRecordError, reader.validate)
 
 
 class TestBytesRecordReader(tests.TestCase):
@@ -419,7 +419,7 @@
         InvalidRecordError.
         """
         reader = self.get_reader_for(b"not a number\n")
-        self.assertRaises(errors.InvalidRecordError, reader.read)
+        self.assertRaises(pack.InvalidRecordError, reader.read)
 
     def test_early_eof(self):
         """Tests for premature EOF occuring during parsing Bytes records with
@@ -440,7 +440,7 @@
             try:
                 names, read_bytes = reader.read()
                 read_bytes(None)
-            except errors.UnexpectedEndOfContainerError:
+            except pack.UnexpectedEndOfContainerError:
                 pass
             else:
                 self.fail(
@@ -450,59 +450,59 @@
     def test_initial_eof(self):
         """EOF before any bytes read at all."""
         reader = self.get_reader_for(b"")
-        self.assertRaises(errors.UnexpectedEndOfContainerError, reader.read)
+        self.assertRaises(pack.UnexpectedEndOfContainerError, reader.read)
 
     def test_eof_after_length(self):
         """EOF after reading the length and before reading name(s)."""
         reader = self.get_reader_for(b"123\n")
-        self.assertRaises(errors.UnexpectedEndOfContainerError, reader.read)
+        self.assertRaises(pack.UnexpectedEndOfContainerError, reader.read)
 
     def test_eof_during_name(self):
         """EOF during reading a name."""
         reader = self.get_reader_for(b"123\nname")
-        self.assertRaises(errors.UnexpectedEndOfContainerError, reader.read)
+        self.assertRaises(pack.UnexpectedEndOfContainerError, reader.read)
 
     def test_read_invalid_name_whitespace(self):
         """Names must have no whitespace."""
         # A name with a space.
         reader = self.get_reader_for(b"0\nbad name\n\n")
-        self.assertRaises(errors.InvalidRecordError, reader.read)
+        self.assertRaises(pack.InvalidRecordError, reader.read)
 
         # A name with a tab.
         reader = self.get_reader_for(b"0\nbad\tname\n\n")
-        self.assertRaises(errors.InvalidRecordError, reader.read)
+        self.assertRaises(pack.InvalidRecordError, reader.read)
 
         # A name with a vertical tab.
         reader = self.get_reader_for(b"0\nbad\vname\n\n")
-        self.assertRaises(errors.InvalidRecordError, reader.read)
+        self.assertRaises(pack.InvalidRecordError, reader.read)
 
     def test_validate_whitespace_in_name(self):
         """Names must have no whitespace."""
         reader = self.get_reader_for(b"0\nbad name\n\n")
-        self.assertRaises(errors.InvalidRecordError, reader.validate)
+        self.assertRaises(pack.InvalidRecordError, reader.validate)
 
     def test_validate_interrupted_prelude(self):
         """EOF during reading a record's prelude causes validate to fail."""
         reader = self.get_reader_for(b"")
         self.assertRaises(
-            errors.UnexpectedEndOfContainerError, reader.validate)
+            pack.UnexpectedEndOfContainerError, reader.validate)
 
     def test_validate_interrupted_body(self):
         """EOF during reading a record's body causes validate to fail."""
         reader = self.get_reader_for(b"1\n\n")
         self.assertRaises(
-            errors.UnexpectedEndOfContainerError, reader.validate)
+            pack.UnexpectedEndOfContainerError, reader.validate)
 
     def test_validate_unparseable_length(self):
         """An unparseable record length causes validate to fail."""
         reader = self.get_reader_for(b"\n\n")
         self.assertRaises(
-            errors.InvalidRecordError, reader.validate)
+            pack.InvalidRecordError, reader.validate)
 
     def test_validate_undecodeable_name(self):
         """Names that aren't valid UTF-8 cause validate to fail."""
         reader = self.get_reader_for(b"0\n\xcc\n\n")
-        self.assertRaises(errors.InvalidRecordError, reader.validate)
+        self.assertRaises(pack.InvalidRecordError, reader.validate)
 
     def test_read_max_length(self):
         """If the max_length passed to the callable returned by read is not
@@ -704,7 +704,7 @@
         """
         parser = self.make_parser_expecting_bytes_record()
         self.assertRaises(
-            errors.InvalidRecordError, parser.accept_bytes, b"not a number\n")
+            pack.InvalidRecordError, parser.accept_bytes, b"not a number\n")
 
     def test_incomplete_record(self):
         """If the bytes seen so far don't form a complete record, then there
@@ -723,7 +723,7 @@
         """Assert that parsing the given bytes raises InvalidRecordError."""
         parser = self.make_parser_expecting_bytes_record()
         self.assertRaises(
-            errors.InvalidRecordError, parser.accept_bytes, data)
+            pack.InvalidRecordError, parser.accept_bytes, data)
 
     def test_read_invalid_name_whitespace(self):
         """Names must have no whitespace."""
@@ -742,3 +742,47 @@
         parser.accept_bytes(b"6\n\nabcdef")
         self.assertEqual([([], b'abcdef')], parser.read_pending_records())
         self.assertEqual([], parser.read_pending_records())
+
+
+class TestErrors(tests.TestCase):
+
+    def test_unknown_container_format(self):
+        """Test the formatting of UnknownContainerFormatError."""
+        e = pack.UnknownContainerFormatError('bad format string')
+        self.assertEqual(
+            "Unrecognised container format: 'bad format string'",
+            str(e))
+
+    def test_unexpected_end_of_container(self):
+        """Test the formatting of UnexpectedEndOfContainerError."""
+        e = pack.UnexpectedEndOfContainerError()
+        self.assertEqual(
+            "Unexpected end of container stream", str(e))
+
+    def test_unknown_record_type(self):
+        """Test the formatting of UnknownRecordTypeError."""
+        e = pack.UnknownRecordTypeError("X")
+        self.assertEqual(
+            "Unknown record type: 'X'",
+            str(e))
+
+    def test_invalid_record(self):
+        """Test the formatting of InvalidRecordError."""
+        e = pack.InvalidRecordError("xxx")
+        self.assertEqual(
+            "Invalid record: xxx",
+            str(e))
+
+    def test_container_has_excess_data(self):
+        """Test the formatting of ContainerHasExcessDataError."""
+        e = pack.ContainerHasExcessDataError("excess bytes")
+        self.assertEqual(
+            "Container has data after end marker: 'excess bytes'",
+            str(e))
+
+    def test_duplicate_record_name_error(self):
+        """Test the formatting of DuplicateRecordNameError."""
+        e = pack.DuplicateRecordNameError(b"n\xc3\xa5me")
+        self.assertEqual(
+            u"Container has multiple records with the same name: n\xe5me",
+            str(e))

=== modified file 'breezy/bzr/tests/test_remote.py'
--- breezy/bzr/tests/test_remote.py	2021-08-18 22:38:08 +0000
+++ breezy/bzr/tests/test_remote.py	2022-07-16 17:54:02 +0000
@@ -65,6 +65,7 @@
     RemoteBzrDirFormat,
     RemoteRepository,
     RemoteRepositoryFormat,
+    UnknownErrorFromSmartServer,
     )
 from .. import groupcompress_repo, knitpack_repo
 from ...revision import (
@@ -1918,7 +1919,7 @@
         client._calls = []
 
         err = self.assertRaises(
-            errors.UnknownErrorFromSmartServer,
+            UnknownErrorFromSmartServer,
             branch.set_last_revision_info, 123, b'revid')
         self.assertEqual((b'UnexpectedError',), err.error_tuple)
         branch.unlock()
@@ -2940,7 +2941,7 @@
         transport_path = 'sinhala'
         repo, client = self.setup_fake_client_and_repository(transport_path)
         client.add_error_response(b'AnUnexpectedError')
-        e = self.assertRaises(errors.UnknownErrorFromSmartServer,
+        e = self.assertRaises(UnknownErrorFromSmartServer,
                               repo._get_revision_graph, revid)
         self.assertEqual((b'AnUnexpectedError',), e.error_tuple)
 
@@ -3950,7 +3951,7 @@
         err = errors.ErrorFromSmartServer(
             (b'error', b"list index out of range"))
         translated_error = self.translateErrorFromSmartServer(err)
-        expected_error = errors.UnknownErrorFromSmartServer(err)
+        expected_error = UnknownErrorFromSmartServer(err)
         self.assertEqual(expected_error, translated_error)
 
     # GZ 2011-03-02: TODO test generic non-ascii error string
@@ -3958,7 +3959,7 @@
     def test_generic_KeyError(self):
         err = errors.ErrorFromSmartServer((b'error', b'KeyError', b"1"))
         translated_error = self.translateErrorFromSmartServer(err)
-        expected_error = errors.UnknownErrorFromSmartServer(err)
+        expected_error = UnknownErrorFromSmartServer(err)
         self.assertEqual(expected_error, translated_error)
 
     def test_RevnoOutOfBounds(self):
@@ -3983,7 +3984,7 @@
         error_tuple = (b'An unknown error tuple',)
         server_error = errors.ErrorFromSmartServer(error_tuple)
         translated_error = self.translateErrorFromSmartServer(server_error)
-        expected_error = errors.UnknownErrorFromSmartServer(server_error)
+        expected_error = UnknownErrorFromSmartServer(server_error)
         self.assertEqual(expected_error, translated_error)
 
     def test_context_missing_a_key(self):
@@ -4543,3 +4544,13 @@
         result = branch._get_all_reference_info()
         self.assertFinished(client)
         self.assertEqual({b'file-id': ('https://www.example.com/', None)}, result)
+
+
+class TestErrors(tests.TestCase):
+
+    def test_untranslateable_error_from_smart_server(self):
+        error_tuple = ('error', 'tuple')
+        orig_err = errors.ErrorFromSmartServer(error_tuple)
+        err = UnknownErrorFromSmartServer(orig_err)
+        self.assertEqual(
+            "Server sent an unexpected error: ('error', 'tuple')", str(err))

=== modified file 'breezy/bzr/tests/test_smart.py'
--- breezy/bzr/tests/test_smart.py	2022-07-14 21:40:03 +0000
+++ breezy/bzr/tests/test_smart.py	2022-07-16 17:54:02 +0000
@@ -2848,3 +2848,4 @@
         self.assertEqual(
             [[b'some/path', b'http://www.example.com/', b'']],
             bencode.bdecode(response.body))
+

=== modified file 'breezy/bzr/tests/test_smart_transport.py'
--- breezy/bzr/tests/test_smart_transport.py	2022-05-02 11:39:09 +0000
+++ breezy/bzr/tests/test_smart_transport.py	2022-07-16 17:54:02 +0000
@@ -42,6 +42,7 @@
 from .. import (
     bzrdir,
     )
+from ..remote import UnknownErrorFromSmartServer
 from ..smart import (
     client,
     medium,
@@ -695,7 +696,7 @@
         client_medium = medium.SmartSimplePipesClientMedium(
             None, output, 'base')
         client_medium._current_request = "a"
-        self.assertRaises(errors.TooManyConcurrentRequests,
+        self.assertRaises(medium.TooManyConcurrentRequests,
                           medium.SmartClientStreamMediumRequest, client_medium)
 
     def test_finished_read_clears_current_request(self):
@@ -764,7 +765,7 @@
         client_medium._socket = client_sock
         client_medium._connected = True
         req = client_medium.get_request()
-        self.assertRaises(errors.TooManyConcurrentRequests,
+        self.assertRaises(medium.TooManyConcurrentRequests,
                           client_medium.get_request)
         client_medium.reset()
         # The stream should be reset, marked as disconnected, though ready for
@@ -1363,7 +1364,7 @@
         self.addCleanup(smart_server.stop_server)
         t = remote.RemoteTCPTransport(smart_server.get_url())
         self.addCleanup(t.disconnect)
-        err = self.assertRaises(errors.UnknownErrorFromSmartServer,
+        err = self.assertRaises(UnknownErrorFromSmartServer,
                                 t.get, 'something')
         self.assertContainsRe(str(err), 'some random exception')
 
@@ -4341,3 +4342,28 @@
         r = t._redirected_to('http://www.example.com/foo',
                              'bzr://www.example.com/foo')
         self.assertNotEqual(type(r), type(t))
+
+
+class TestErrors(tests.TestCase):
+    def test_too_many_concurrent_requests(self):
+        error = medium.TooManyConcurrentRequests("a medium")
+        self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
+                             "request limit. Be sure to finish_writing and finish_reading on "
+                             "the currently open request.",
+                             str(error))
+
+    def test_smart_message_handler_error(self):
+        # Make an exc_info tuple.
+        try:
+            raise Exception("example error")
+        except Exception:
+            err = protocol.SmartMessageHandlerError(sys.exc_info())
+        # GZ 2010-11-08: Should not store exc_info in exception instances.
+        try:
+            self.assertStartsWith(
+                str(err), "The message handler raised an exception:\n")
+            self.assertEndsWith(str(err), "Exception: example error\n")
+        finally:
+            del err
+
+

=== modified file 'breezy/config.py'
--- breezy/config.py	2022-07-09 20:31:42 +0000
+++ breezy/config.py	2022-07-16 17:54:02 +0000
@@ -227,6 +227,14 @@
         errors.BzrError.__init__(self, option_name=option_name)
 
 
+class NoSuchAlias(errors.BzrError):
+
+    _fmt = ('The alias "%(alias_name)s" does not exist.')
+
+    def __init__(self, alias_name):
+        errors.BzrError.__init__(self, alias_name=alias_name)
+
+
 def signature_policy_from_unicode(signature_string):
     """Convert a string to a signing policy."""
     if signature_string.lower() == 'check-available':
@@ -1048,7 +1056,7 @@
             self.reload()
             aliases = self._get_parser().get('ALIASES')
             if not aliases or alias_name not in aliases:
-                raise errors.NoSuchAlias(alias_name)
+                raise NoSuchAlias(alias_name)
             del aliases[alias_name]
             self._write_config_file()
 

=== modified file 'breezy/controldir.py'
--- breezy/controldir.py	2022-07-09 20:29:40 +0000
+++ breezy/controldir.py	2022-07-16 17:54:02 +0000
@@ -67,6 +67,14 @@
         errors.BzrError.__init__(self, branch=branch)
 
 
+class NoColocatedBranchSupport(errors.BzrError):
+
+    _fmt = ("%(controldir)r does not support co-located branches.")
+
+    def __init__(self, controldir):
+        self.controldir = controldir
+
+
 class ControlComponent(object):
     """Abstract base class for control directory components.
 
@@ -275,7 +283,7 @@
           reference branch, or None for regular branches.
         """
         if name is not None:
-            raise errors.NoColocatedBranchSupport(self)
+            raise NoColocatedBranchSupport(self)
         return None
 
     def set_branch_reference(self, target_branch, name=None):

=== modified file 'breezy/errors.py'
--- breezy/errors.py	2022-07-09 20:29:40 +0000
+++ breezy/errors.py	2022-07-16 17:54:02 +0000
@@ -1086,53 +1086,6 @@
     _fmt = "Text did not match its checksum: %(msg)s"
 
 
-class RetryWithNewPacks(BzrError):
-    """Raised when we realize that the packs on disk have changed.
-
-    This is meant as more of a signaling exception, to trap between where a
-    local error occurred and the code that can actually handle the error and
-    code that can retry appropriately.
-    """
-
-    internal_error = True
-
-    _fmt = ("Pack files have changed, reload and retry. context: %(context)s"
-            " %(orig_error)s")
-
-    def __init__(self, context, reload_occurred, exc_info):
-        """create a new RetryWithNewPacks error.
-
-        :param reload_occurred: Set to True if we know that the packs have
-            already been reloaded, and we are failing because of an in-memory
-            cache miss. If set to True then we will ignore if a reload says
-            nothing has changed, because we assume it has already reloaded. If
-            False, then a reload with nothing changed will force an error.
-        :param exc_info: The original exception traceback, so if there is a
-            problem we can raise the original error (value from sys.exc_info())
-        """
-        BzrError.__init__(self)
-        self.context = context
-        self.reload_occurred = reload_occurred
-        self.exc_info = exc_info
-        self.orig_error = exc_info[1]
-        # TODO: The global error handler should probably treat this by
-        #       raising/printing the original exception with a bit about
-        #       RetryWithNewPacks also not being caught
-
-
-class RetryAutopack(RetryWithNewPacks):
-    """Raised when we are autopacking and we find a missing file.
-
-    Meant as a signaling exception, to tell the autopack code it should try
-    again.
-    """
-
-    internal_error = True
-
-    _fmt = ("Pack files have changed, reload and try autopack again."
-            " context: %(context)s %(orig_error)s")
-
-
 class NoSuchExportFormat(BzrError):
 
     _fmt = "Export format %(format)r not supported"
@@ -1158,16 +1111,6 @@
         BzrError.__init__(self)
 
 
-class TooManyConcurrentRequests(InternalBzrError):
-
-    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
-            " Be sure to finish_writing and finish_reading on the"
-            " currently open request.")
-
-    def __init__(self, medium):
-        self.medium = medium
-
-
 class SmartProtocolError(TransportError):
 
     _fmt = "Generic bzr smart protocol error: %(details)s"
@@ -1192,21 +1135,6 @@
         self.verb = verb
 
 
-class SmartMessageHandlerError(InternalBzrError):
-
-    _fmt = ("The message handler raised an exception:\n"
-            "%(traceback_text)s")
-
-    def __init__(self, exc_info):
-        import traceback
-        # GZ 2010-08-10: Cycle with exc_tb/exc_info affects at least one test
-        self.exc_type, self.exc_value, self.exc_tb = exc_info
-        self.exc_info = exc_info
-        traceback_strings = traceback.format_exception(
-            self.exc_type, self.exc_value, self.exc_tb)
-        self.traceback_text = ''.join(traceback_strings)
-
-
 # A set of semi-meaningful errors which can be thrown
 class TransportNotPossible(TransportError):
 
@@ -1559,11 +1487,6 @@
         DependencyNotPresent.__init__(self, 'paramiko', error)
 
 
-class PointlessMerge(BzrError):
-
-    _fmt = "Nothing to merge."
-
-
 class UninitializableFormat(BzrError):
 
     _fmt = "Format %(format)s cannot be initialised by this version of brz."
@@ -2023,82 +1946,6 @@
         self.error_args = error_tuple[1:]
 
 
-class UnknownErrorFromSmartServer(BzrError):
-    """An ErrorFromSmartServer could not be translated into a typical breezy
-    error.
-
-    This is distinct from ErrorFromSmartServer so that it is possible to
-    distinguish between the following two cases:
-
-     - ErrorFromSmartServer was uncaught.  This is logic error in the client
-       and so should provoke a traceback to the user.
-     - ErrorFromSmartServer was caught but its error_tuple could not be
-       translated.  This is probably because the server sent us garbage, and
-       should not provoke a traceback.
-    """
-
-    _fmt = "Server sent an unexpected error: %(error_tuple)r"
-
-    internal_error = False
-
-    def __init__(self, error_from_smart_server):
-        """Constructor.
-
-        :param error_from_smart_server: An ErrorFromSmartServer instance.
-        """
-        self.error_from_smart_server = error_from_smart_server
-        self.error_tuple = error_from_smart_server.error_tuple
-
-
-class ContainerError(BzrError):
-    """Base class of container errors."""
-
-
-class UnknownContainerFormatError(ContainerError):
-
-    _fmt = "Unrecognised container format: %(container_format)r"
-
-    def __init__(self, container_format):
-        self.container_format = container_format
-
-
-class UnexpectedEndOfContainerError(ContainerError):
-
-    _fmt = "Unexpected end of container stream"
-
-
-class UnknownRecordTypeError(ContainerError):
-
-    _fmt = "Unknown record type: %(record_type)r"
-
-    def __init__(self, record_type):
-        self.record_type = record_type
-
-
-class InvalidRecordError(ContainerError):
-
-    _fmt = "Invalid record: %(reason)s"
-
-    def __init__(self, reason):
-        self.reason = reason
-
-
-class ContainerHasExcessDataError(ContainerError):
-
-    _fmt = "Container has data after end marker: %(excess)r"
-
-    def __init__(self, excess):
-        self.excess = excess
-
-
-class DuplicateRecordNameError(ContainerError):
-
-    _fmt = "Container has multiple records with the same name: %(name)s"
-
-    def __init__(self, name):
-        self.name = name.decode("utf-8")
-
-
 class RepositoryDataStreamError(BzrError):
 
     _fmt = "Corrupt or incompatible data stream: %(reason)s"
@@ -2159,14 +2006,6 @@
         self.user_encoding = get_user_encoding()
 
 
-class NoSuchAlias(BzrError):
-
-    _fmt = ('The alias "%(alias_name)s" does not exist.')
-
-    def __init__(self, alias_name):
-        BzrError.__init__(self, alias_name=alias_name)
-
-
 class CannotBindAddress(BzrError):
 
     _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
@@ -2248,14 +2087,6 @@
         self.target_branch = target_branch
 
 
-class NoColocatedBranchSupport(BzrError):
-
-    _fmt = ("%(controldir)r does not support co-located branches.")
-
-    def __init__(self, controldir):
-        self.controldir = controldir
-
-
 class RecursiveBind(BzrError):
 
     _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '

=== modified file 'breezy/git/refs.py'
--- breezy/git/refs.py	2020-02-18 01:57:45 +0000
+++ breezy/git/refs.py	2022-07-16 17:54:02 +0000
@@ -26,6 +26,7 @@
     )
 
 from .. import (
+    controldir,
     errors,
     osutils,
     revision as _mod_revision,
@@ -132,7 +133,7 @@
     def _get_revid_by_branch_name(self, branch_name):
         try:
             branch = self.dir.open_branch(branch_name)
-        except errors.NoColocatedBranchSupport:
+        except controldir.NoColocatedBranchSupport:
             if branch_name in ("HEAD", "master"):
                 branch = self.dir.open_branch()
             else:

=== modified file 'breezy/plugins/weave_fmt/branch.py'
--- breezy/plugins/weave_fmt/branch.py	2021-12-25 14:55:24 +0000
+++ breezy/plugins/weave_fmt/branch.py	2022-07-16 17:54:02 +0000
@@ -17,6 +17,7 @@
 """Weave-era branch implementations."""
 
 from ... import (
+    controldir as _mod_controldir,
     errors,
     lockable_files,
     )
@@ -196,7 +197,7 @@
         if name is None:
             name = a_controldir._get_selected_branch()
         if name != "":
-            raise errors.NoColocatedBranchSupport(self)
+            raise _mod_controldir.NoColocatedBranchSupport(self)
         if not _found:
             # we are being called directly and must probe.
             raise NotImplementedError

=== modified file 'breezy/plugins/weave_fmt/bzrdir.py'
--- breezy/plugins/weave_fmt/bzrdir.py	2020-05-06 02:13:25 +0000
+++ breezy/plugins/weave_fmt/bzrdir.py	2022-07-16 17:54:02 +0000
@@ -27,6 +27,7 @@
     ControlDir,
     Converter,
     MustHaveWorkingTree,
+    NoColocatedBranchSupport,
     format_registry,
     )
 from ... import (
@@ -841,7 +842,7 @@
     def get_branch_transport(self, branch_format, name=None):
         """See BzrDir.get_branch_transport()."""
         if name:
-            raise errors.NoColocatedBranchSupport(self)
+            raise NoColocatedBranchSupport(self)
         if branch_format is None:
             return self.transport
         try:
@@ -923,7 +924,7 @@
     def set_branch_reference(self, target_branch, name=None):
         from ...bzr.branch import BranchReferenceFormat
         if name is not None:
-            raise errors.NoColocatedBranchSupport(self)
+            raise NoColocatedBranchSupport(self)
         raise errors.IncompatibleFormat(BranchReferenceFormat, self._format)
 
 

=== modified file 'breezy/tests/per_controldir_colo/test_unsupported.py'
--- breezy/tests/per_controldir_colo/test_unsupported.py	2018-11-18 19:48:57 +0000
+++ breezy/tests/per_controldir_colo/test_unsupported.py	2022-07-16 17:54:02 +0000
@@ -21,6 +21,7 @@
 """
 
 from breezy import (
+    controldir,
     errors,
     tests,
     )
@@ -53,28 +54,28 @@
         # Colocated branches should not be supported *or*
         # destroy_branch should not be supported at all
         self.assertRaises(
-            (errors.NoColocatedBranchSupport, errors.UnsupportedOperation),
+            (controldir.NoColocatedBranchSupport, errors.UnsupportedOperation),
             branch.controldir.destroy_branch, 'colo')
 
     def test_create_colo_branch(self):
         made_control = self.make_controldir_with_repo()
-        self.assertRaises(errors.NoColocatedBranchSupport,
+        self.assertRaises(controldir.NoColocatedBranchSupport,
                           made_control.create_branch, "colo")
 
     def test_open_branch(self):
         made_control = self.make_controldir_with_repo()
-        self.assertRaises(errors.NoColocatedBranchSupport,
+        self.assertRaises(controldir.NoColocatedBranchSupport,
                           made_control.open_branch, name="colo")
 
     def test_get_branch_reference(self):
         made_control = self.make_controldir_with_repo()
-        self.assertRaises(errors.NoColocatedBranchSupport,
+        self.assertRaises(controldir.NoColocatedBranchSupport,
                           made_control.get_branch_reference, "colo")
 
     def test_set_branch_reference(self):
         referenced = self.make_branch('referenced')
         made_control = self.make_controldir_with_repo()
-        self.assertRaises(errors.NoColocatedBranchSupport,
+        self.assertRaises(controldir.NoColocatedBranchSupport,
                           made_control.set_branch_reference, referenced, name="colo")
 
     def test_get_branches(self):

=== modified file 'breezy/tests/per_workingtree/test_merge_from_branch.py'
--- breezy/tests/per_workingtree/test_merge_from_branch.py	2021-03-14 20:18:53 +0000
+++ breezy/tests/per_workingtree/test_merge_from_branch.py	2022-07-16 17:54:02 +0000
@@ -24,6 +24,7 @@
     errors,
     merge,
     )
+from breezy.workingtree import PointlessMerge
 from breezy.tests import per_workingtree
 
 
@@ -95,7 +96,7 @@
         tree_a.commit('deleted file')
         self.build_tree_contents([('tree_b/file', b'text-b')])
         tree_b.commit('changed file')
-        self.assertRaises(errors.PointlessMerge, tree_a.merge_from_branch,
+        self.assertRaises(PointlessMerge, tree_a.merge_from_branch,
                           tree_b.branch, from_revision=tree_b.branch.last_revision())
         tree_a.merge_from_branch(tree_b.branch, from_revision=rev1)
         tree_a.lock_read()

=== modified file 'breezy/tests/test_errors.py'
--- breezy/tests/test_errors.py	2021-11-13 13:06:59 +0000
+++ breezy/tests/test_errors.py	2022-07-16 17:54:02 +0000
@@ -166,13 +166,6 @@
                              str(error))
         self.assertFalse(error.internal_error)
 
-    def test_too_many_concurrent_requests(self):
-        error = errors.TooManyConcurrentRequests("a medium")
-        self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
-                             "request limit. Be sure to finish_writing and finish_reading on "
-                             "the currently open request.",
-                             str(error))
-
     def test_unstackable_location(self):
         error = errors.UnstackableLocationError('foo', 'bar')
         self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
@@ -293,47 +286,6 @@
             "Could not understand response from smart server: ('not yes',)",
             str(e))
 
-    def test_unknown_container_format(self):
-        """Test the formatting of UnknownContainerFormatError."""
-        e = errors.UnknownContainerFormatError('bad format string')
-        self.assertEqual(
-            "Unrecognised container format: 'bad format string'",
-            str(e))
-
-    def test_unexpected_end_of_container(self):
-        """Test the formatting of UnexpectedEndOfContainerError."""
-        e = errors.UnexpectedEndOfContainerError()
-        self.assertEqual(
-            "Unexpected end of container stream", str(e))
-
-    def test_unknown_record_type(self):
-        """Test the formatting of UnknownRecordTypeError."""
-        e = errors.UnknownRecordTypeError("X")
-        self.assertEqual(
-            "Unknown record type: 'X'",
-            str(e))
-
-    def test_invalid_record(self):
-        """Test the formatting of InvalidRecordError."""
-        e = errors.InvalidRecordError("xxx")
-        self.assertEqual(
-            "Invalid record: xxx",
-            str(e))
-
-    def test_container_has_excess_data(self):
-        """Test the formatting of ContainerHasExcessDataError."""
-        e = errors.ContainerHasExcessDataError("excess bytes")
-        self.assertEqual(
-            "Container has data after end marker: 'excess bytes'",
-            str(e))
-
-    def test_duplicate_record_name_error(self):
-        """Test the formatting of DuplicateRecordNameError."""
-        e = errors.DuplicateRecordNameError(b"n\xc3\xa5me")
-        self.assertEqual(
-            u"Container has multiple records with the same name: n\xe5me",
-            str(e))
-
     def test_check_error(self):
         e = errors.BzrCheckError('example check failure')
         self.assertEqual(
@@ -384,27 +336,6 @@
         self.assertEqual(
             "Error received from smart server: ('error', 'tuple')", str(err))
 
-    def test_untranslateable_error_from_smart_server(self):
-        error_tuple = ('error', 'tuple')
-        orig_err = errors.ErrorFromSmartServer(error_tuple)
-        err = errors.UnknownErrorFromSmartServer(orig_err)
-        self.assertEqual(
-            "Server sent an unexpected error: ('error', 'tuple')", str(err))
-
-    def test_smart_message_handler_error(self):
-        # Make an exc_info tuple.
-        try:
-            raise Exception("example error")
-        except Exception:
-            err = errors.SmartMessageHandlerError(sys.exc_info())
-        # GZ 2010-11-08: Should not store exc_info in exception instances.
-        try:
-            self.assertStartsWith(
-                str(err), "The message handler raised an exception:\n")
-            self.assertEndsWith(str(err), "Exception: example error\n")
-        finally:
-            del err
-
     def test_unresumable_write_group(self):
         repo = "dummy repo"
         wg_tokens = ['token']
@@ -439,14 +370,6 @@
                'Please use `brz unbind` to fix.')
         self.assertEqualDiff(msg, str(error))
 
-    def test_retry_with_new_packs(self):
-        fake_exc_info = ('{exc type}', '{exc value}', '{exc traceback}')
-        error = errors.RetryWithNewPacks(
-            '{context}', reload_occurred=False, exc_info=fake_exc_info)
-        self.assertEqual(
-            'Pack files have changed, reload and retry. context: '
-            '{context} {exc value}', str(error))
-
 
 class PassThroughError(errors.BzrError):
 

=== modified file 'breezy/tests/test_foreign.py'
--- breezy/tests/test_foreign.py	2020-02-18 03:11:01 +0000
+++ breezy/tests/test_foreign.py	2022-07-16 17:54:02 +0000
@@ -326,7 +326,7 @@
         if name is None:
             name = self._get_selected_branch()
         if name != "":
-            raise errors.NoColocatedBranchSupport(self)
+            raise controldir.NoColocatedBranchSupport(self)
         return self._format.get_branch_format().open(self, _found=True)
 
     def cloning_metadir(self, stacked=False):

=== modified file 'breezy/tests/test_merge.py'
--- breezy/tests/test_merge.py	2022-07-02 15:30:16 +0000
+++ breezy/tests/test_merge.py	2022-07-16 17:54:02 +0000
@@ -44,7 +44,7 @@
     TestCaseWithTransport,
     test_merge_core,
     )
-from ..workingtree import WorkingTree
+from ..workingtree import WorkingTree, PointlessMerge
 
 
 class TestMerge(TestCaseWithTransport):
@@ -54,7 +54,7 @@
         wt = self.make_branch_and_tree('.')
         rev_a = wt.commit("lala!")
         self.assertEqual([rev_a], wt.get_parent_ids())
-        self.assertRaises(errors.PointlessMerge, wt.merge_from_branch,
+        self.assertRaises(PointlessMerge, wt.merge_from_branch,
                           wt.branch)
         self.assertEqual([rev_a], wt.get_parent_ids())
         return wt

=== modified file 'breezy/workingtree.py'
--- breezy/workingtree.py	2022-07-09 20:29:40 +0000
+++ breezy/workingtree.py	2022-07-16 17:54:02 +0000
@@ -75,6 +75,11 @@
     _fmt = "This format does not support shelving changes."
 
 
+class PointlessMerge(errors.BzrError):
+
+    _fmt = "Nothing to merge."
+
+
 class WorkingTree(mutabletree.MutableTree, ControlComponent):
     """Working copy tree.
 
@@ -683,7 +688,7 @@
             else:
                 merger.set_base_revision(from_revision, branch)
             if merger.base_rev_id == merger.other_rev_id:
-                raise errors.PointlessMerge
+                raise PointlessMerge()
             merger.backup_files = False
             if merge_type is None:
                 merger.merge_type = Merge3Merger