Remove bazaar crate

breezy/bzr/__init__.py

@@ -27,12 +27,12 @@
 
 from typing import TYPE_CHECKING
 
+from bzrformats._bzr_rs import hashcache, rio
 from catalogus import pyutils
 from dromedary import errors as transport_errors
 from dromedary.errors import NoSuchFile
 
 from .. import config, controldir, errors, registry
-from .._bzr_rs import hashcache, rio
 from ..branch import format_registry as branch_format_registry
 from ..repository import format_registry as repository_format_registry
 from ..workingtree import format_registry as workingtree_format_registry

breezy/bzr/fetch.py

@@ -123,6 +123,12 @@ def _fetch_everything_for_search(self, search):
         with ui.ui_factory.nested_progress_bar() as pb:
             pb.update("Get stream source")
             source = self.from_repository._get_source(self.to_repository._format)
+            # A stacked target cannot store a text delta whose basis lives
+            # only in a fallback (ResumedPack._check_references rejects it).
+            # Ask the source for self-contained texts so the stream never
+            # carries such deltas.
+            if self.to_repository._fallback_repositories:
+                source._stream_self_contained_texts = True
             stream = source.get_stream(search)
             from_format = self.from_repository._format
             pb.update("Inserting stream")

breezy/bzr/groupcompress_repo.py

@@ -819,7 +819,7 @@ def _check_new_inventories(self):
         #     entries too.
         # And all this should be independent of any fallback repository.
         problems = []
-        key_deps = self.repo.revisions._index._key_dependencies
+        key_deps = self.repo.revisions._index.key_dependencies
         new_revisions_keys = key_deps.get_new_keys()
         no_fallback_inv_index = self.repo.inventories._index
         no_fallback_chk_bytes_index = self.repo.chk_bytes._index
@@ -1411,8 +1411,13 @@ def _get_parent_id_basename_to_file_id_pages():
     def _get_text_stream(self):
         # Note: We know we don't have to handle adding root keys, because both
         # the source and target are the identical network name.
+        # A stacked target cannot store a delta whose basis lives only in a
+        # fallback, so emit delta closures when asked for a self-contained
+        # stream.
         text_stream = self.from_repository.texts.get_record_stream(
-            self._text_keys, self._text_fetch_order, False
+            self._text_keys,
+            self._text_fetch_order,
+            self._stream_self_contained_texts,
         )
         return ("texts", text_stream)
 

breezy/bzr/knitpack_repo.py

@@ -655,8 +655,13 @@ def _filtered_inv_stream():
     def _get_text_stream(self):
         # Note: We know we don't have to handle adding root keys, because both
         # the source and target are the identical network name.
+        # A stacked target cannot store a text delta whose basis lives only
+        # in a fallback, so emit delta closures when asked for a
+        # self-contained stream.
         text_stream = self.from_repository.texts.get_record_stream(
-            self._text_keys, self._text_fetch_order, False
+            self._text_keys,
+            self._text_fetch_order,
+            self._stream_self_contained_texts,
         )
         return ("texts", text_stream)
 

breezy/bzr/pack_repo.py

@@ -1192,13 +1192,13 @@ def _start_write_group(self):
         )
         if self.chk_index is not None:
             self.chk_index.add_writable_index(self._new_pack.chk_index, self._new_pack)
-            self.repo.chk_bytes._index._add_callback = self.chk_index.add_callback
+            self.repo.chk_bytes._index.set_add_callback(self.chk_index.add_callback)
             self._new_pack.chk_index.set_optimize(combine_backing_indices=False)
 
-        self.repo.inventories._index._add_callback = self.inventory_index.add_callback
-        self.repo.revisions._index._add_callback = self.revision_index.add_callback
-        self.repo.signatures._index._add_callback = self.signature_index.add_callback
-        self.repo.texts._index._add_callback = self.text_index.add_callback
+        self.repo.inventories._index.set_add_callback(self.inventory_index.add_callback)
+        self.repo.revisions._index.set_add_callback(self.revision_index.add_callback)
+        self.repo.signatures._index.set_add_callback(self.signature_index.add_callback)
+        self.repo.texts._index.set_add_callback(self.text_index.add_callback)
 
     def _abort_write_group(self):
         # FIXME: just drop the transient index.
@@ -1379,7 +1379,7 @@ def _all_revision_ids(self):
             return [key[0] for key in self.revisions.keys()]
 
     def _abort_write_group(self):
-        self.revisions._index._key_dependencies.clear()
+        self.revisions._index.clear_key_dependencies()
         self._pack_collection._abort_write_group()
 
     def _make_parents_provider(self):
@@ -1401,7 +1401,7 @@ def _start_write_group(self):
 
     def _commit_write_group(self):
         hint = self._pack_collection._commit_write_group()
-        self.revisions._index._key_dependencies.clear()
+        self.revisions._index.clear_key_dependencies()
         # The commit may have added keys that were previously cached as
         # missing, so reset the cache.
         self._unstacked_provider.disable_cache()
@@ -1416,7 +1416,7 @@ def suspend_write_group(self):
         """
         # XXX check self._write_group is self.get_transaction()?
         tokens = self._pack_collection._suspend_write_group()
-        self.revisions._index._key_dependencies.clear()
+        self.revisions._index.clear_key_dependencies()
         self._write_group = None
         return tokens
 

breezy/bzr/remote.py

@@ -4457,6 +4457,11 @@ def get_stream(self, search):
             and self.to_format._fetch_order == "topological"
         ):
             return self._real_stream(self.from_repository, search)
+        if self._stream_self_contained_texts:
+            # The smart get_stream verb cannot be told to emit delta
+            # closures, so generate the stream through the VFS source,
+            # which honours _stream_self_contained_texts.
+            return self._real_stream(self.from_repository, search)
         sources = []
         seen = set()
         repos = [self.from_repository]
@@ -4541,6 +4546,7 @@ def _real_stream(self, repo, search):
         if isinstance(source, RemoteStreamSource):
             repo._ensure_real()
             source = repo._real_repository._get_source(self.to_format)
+        source._stream_self_contained_texts = self._stream_self_contained_texts
         return source.get_stream(search)
 
     def _get_stream(self, repo, search):

breezy/bzr/smart/http.py

@@ -58,14 +58,16 @@ def remote_path_from_transport(self, transport):
 
     def send_http_smart_request(self, bytes):
         """POST ``bytes`` as a smart request body and return the response body."""
+        from io import BytesIO
+
         try:
             t = self._http_transport_ref()
-            code, body_filelike = t._post(bytes)
+            code, body = t._post(".bzr/smart", bytes)
             if code != 200:
                 raise UnexpectedHttpStatus(t._remote_path(".bzr/smart"), code)
         except (InvalidHttpResponse, ConnectionResetError) as e:
             raise SmartProtocolError(str(e)) from e
-        return body_filelike
+        return BytesIO(body)
 
     def _report_activity(self, bytes, direction):
         # Does nothing; the underlying plain HTTP transport will report the

breezy/bzr/smart/protocol.py

@@ -24,13 +24,13 @@
 from collections import deque
 from io import BytesIO
 
+from bzrformats._bzr_rs import smart as _smart_rs
 from dromedary import errors as transport_errors
 from fastbencode import bdecode_as_tuple, bencode
 
 import breezy
 
 from ... import debug, errors, osutils
-from ..._bzr_rs import smart as _smart_rs
 from ...trace import log_exception_quietly, mutter
 from . import message, request
 

breezy/bzr/tests/per_pack_repository.py

@@ -694,29 +694,29 @@ def make_write_ready_repo(self):
 
     def test_missing_inventories_compression_parent_prevents_commit(self):
         repo = self.make_write_ready_repo()
-        key = ("junk",)
-        repo.inventories._index._missing_compression_parents.add(key)
+        key = (b"junk",)
+        repo.inventories._index.add_missing_compression_parent(key)
         self.assertRaises(BzrCheckError, repo.commit_write_group)
         self.assertRaises(BzrCheckError, repo.commit_write_group)
 
     def test_missing_revisions_compression_parent_prevents_commit(self):
         repo = self.make_write_ready_repo()
-        key = ("junk",)
-        repo.revisions._index._missing_compression_parents.add(key)
+        key = (b"junk",)
+        repo.revisions._index.add_missing_compression_parent(key)
         self.assertRaises(BzrCheckError, repo.commit_write_group)
         self.assertRaises(BzrCheckError, repo.commit_write_group)
 
     def test_missing_signatures_compression_parent_prevents_commit(self):
         repo = self.make_write_ready_repo()
-        key = ("junk",)
-        repo.signatures._index._missing_compression_parents.add(key)
+        key = (b"junk",)
+        repo.signatures._index.add_missing_compression_parent(key)
         self.assertRaises(BzrCheckError, repo.commit_write_group)
         self.assertRaises(BzrCheckError, repo.commit_write_group)
 
     def test_missing_text_compression_parent_prevents_commit(self):
         repo = self.make_write_ready_repo()
-        key = ("some", "junk")
-        repo.texts._index._missing_compression_parents.add(key)
+        key = (b"some", b"junk")
+        repo.texts._index.add_missing_compression_parent(key)
         self.assertRaises(BzrCheckError, repo.commit_write_group)
         self.assertRaises(BzrCheckError, repo.commit_write_group)
 
@@ -1054,7 +1054,7 @@ def test_key_dependencies_cleared_on_abort(self):
                 [(b"B-id",)], "unordered", True
             )
             target_repo.revisions.insert_record_stream(stream)
-            key_refs = target_repo.revisions._index._key_dependencies
+            key_refs = target_repo.revisions._index.key_dependencies
             self.assertEqual([(b"B-id",)], sorted(key_refs.get_referrers()))
         finally:
             target_repo.abort_write_group()
@@ -1068,7 +1068,7 @@ def test_key_dependencies_cleared_on_suspend(self):
                 [(b"B-id",)], "unordered", True
             )
             target_repo.revisions.insert_record_stream(stream)
-            key_refs = target_repo.revisions._index._key_dependencies
+            key_refs = target_repo.revisions._index.key_dependencies
             self.assertEqual([(b"B-id",)], sorted(key_refs.get_referrers()))
         finally:
             target_repo.suspend_write_group()
@@ -1094,7 +1094,7 @@ def test_key_dependencies_cleared_on_commit(self):
                 [(b"B-id",)], "unordered", True
             )
             target_repo.revisions.insert_record_stream(stream)
-            key_refs = target_repo.revisions._index._key_dependencies
+            key_refs = target_repo.revisions._index.key_dependencies
             self.assertEqual([(b"B-id",)], sorted(key_refs.get_referrers()))
         finally:
             target_repo.commit_write_group()