refactor: delete adapters.py

Signed-off-by: jiwangCHEN <hyper1char@gmail.com>

Author: jiwangCHEN

oras/copy/__init__.py

@@ -24,9 +24,9 @@
     ReferenceFetcher    - Fetch by reference (resolve + fetch in one call)
     Mounter             - Cross-repo blob mounting
 
-Adapters:
-    RegistryTarget      - Adapts Registry + container to Target/ReferencePusher/Mounter
-    LayoutTarget        - Adapts Layout directory to Target (full read/write)
+Concrete adapters that bridge this engine to a registry or an OCI layout
+live with the types they adapt: :class:`oras.provider.RegistryTarget` and
+:class:`oras.layout.layout.LayoutTarget`.
 """
 
 __author__ = "The ORAS Authors"
@@ -47,7 +47,6 @@
     TagResolver,
     Target,
 )
-from oras.copy.adapters import LayoutTarget, RegistryTarget
 from oras.copy.copy import copy
 from oras.copy.errors import CopyError, CopyErrorOrigin
 from oras.copy.graph import SkipNode
@@ -81,7 +80,4 @@
     "ReferencePusher",
     "ReferenceFetcher",
     "Mounter",
-    # Adapters
-    "RegistryTarget",
-    "LayoutTarget",
 ]

oras/copy/adapters.py

@@ -80,6 +80,32 @@ def _upload_blob_url(self) -> str:
         """Build full upload blob URL."""
         return f"{self._registry.prefix}://{self._container.upload_blob_url()}"
 
+    def _put_manifest(
+        self, reference: str, data: bytes, media_type: str, record: bool
+    ) -> "requests.Response":
+        """PUT manifest bytes to a reference (tag or digest).
+
+        Shared by :meth:`push` (manifest branch), :meth:`tag`, and
+        :meth:`push_reference`. When ``record`` is True the response is stored
+        on ``last_manifest_response`` so callers like ``Registry.push`` can
+        return the real upload response instead of issuing a follow-up GET.
+        """
+        url = self._manifest_url(reference)
+        headers = {"Content-Type": media_type}
+        response = self._registry.do_request(
+            url, "PUT", data=data, headers=headers
+        )
+        if record:
+            self.last_manifest_response = response
+        self._registry._check_200_response(response)
+        return response
+
+    def _head_manifest(self, reference: str) -> "requests.Response":
+        """Issue a HEAD for a manifest reference with a broad Accept header."""
+        url = self._manifest_url(reference)
+        headers = {"Accept": _ACCEPT_ALL_MANIFESTS}
+        return self._registry.do_request(url, "HEAD", headers=headers)
+
     def fetch(self, desc: Descriptor) -> BinaryIO:
         """Fetch content for a descriptor. Routes blob vs manifest."""
         if is_manifest(desc):
@@ -96,24 +122,16 @@ def fetch(self, desc: Descriptor) -> BinaryIO:
     def exists(self, desc: Descriptor) -> bool:
         """Check if content exists. Routes blob vs manifest."""
         if is_manifest(desc):
-            url = self._manifest_url(desc["digest"])
-            headers = {"Accept": _ACCEPT_ALL_MANIFESTS}
-            response = self._registry.do_request(url, "HEAD", headers=headers)
-            return response.status_code == 200
-        else:
-            return self._registry.blob_exists(desc, self._container)
+            return self._head_manifest(desc["digest"]).status_code == 200
+        return self._registry.blob_exists(desc, self._container)
 
     def push(self, desc: Descriptor, content: BinaryIO) -> None:
         """Push content for a descriptor. Routes blob vs manifest."""
         if is_manifest(desc):
             data = content.read()
-            url = self._manifest_url(desc["digest"])
-            headers = {"Content-Type": desc.get("mediaType", "")}
-            response = self._registry.do_request(
-                url, "PUT", data=data, headers=headers
+            self._put_manifest(
+                desc["digest"], data, desc.get("mediaType", ""), record=True
             )
-            self.last_manifest_response = response
-            self._registry._check_200_response(response)
         else:
             tmp = None
             try:
@@ -146,20 +164,14 @@ def push(self, desc: Descriptor, content: BinaryIO) -> None:
 
     def tag(self, desc: Descriptor, reference: str) -> None:
         """Tag a descriptor with a reference by re-uploading the manifest."""
-        rc = self.fetch(desc)
-        data = rc.read()
-        url = self._manifest_url(reference)
-        headers = {"Content-Type": desc.get("mediaType", "")}
-        response = self._registry.do_request(
-            url, "PUT", data=data, headers=headers
+        data = self.fetch(desc).read()
+        self._put_manifest(
+            reference, data, desc.get("mediaType", ""), record=False
         )
-        self._registry._check_200_response(response)
 
     def resolve(self, reference: str) -> Descriptor:
         """Resolve a reference to a descriptor via HEAD request."""
-        url = self._manifest_url(reference)
-        headers = {"Accept": _ACCEPT_ALL_MANIFESTS}
-        response = self._registry.do_request(url, "HEAD", headers=headers)
+        response = self._head_manifest(reference)
         self._registry._check_200_response(response)
         return {
             "mediaType": response.headers.get("Content-Type", ""),
@@ -172,13 +184,9 @@ def push_reference(
     ) -> None:
         """Atomic push + tag: PUT manifest bytes to the reference URL."""
         data = content.read()
-        url = self._manifest_url(reference)
-        headers = {"Content-Type": desc.get("mediaType", "")}
-        response = self._registry.do_request(
-            url, "PUT", data=data, headers=headers
+        self._put_manifest(
+            reference, data, desc.get("mediaType", ""), record=True
         )
-        self.last_manifest_response = response
-        self._registry._check_200_response(response)
 
     def mount(
         self,

oras/layout/layout.py

@@ -5,8 +5,13 @@
 __license__ = "Apache-2.0"
 
 import json
+import os
 import pathlib
-from typing import TYPE_CHECKING
+import re
+import shutil
+import tempfile
+import threading
+from typing import TYPE_CHECKING, BinaryIO
 
 import jsonschema
 import requests
@@ -22,12 +27,15 @@
 from oras.utils.fileio import read_json, write_json
 
 if TYPE_CHECKING:
-    from oras.copy.adapters import LayoutTarget
     from oras.copy.descriptor import Descriptor
     from oras.copy.options import CopyOptions
     from oras.provider import Registry
 
 
+_VALID_DIGEST_RE = re.compile(r"^[a-z0-9]+:[a-f0-9]+$")
+
+
+
 def NewLayout(path: str, validate: bool = True) -> Layout:
     """
     Courtesy function to create a Layout from a path on disk.
@@ -530,10 +538,8 @@ def as_target(self) -> LayoutTarget:
         :func:`oras.copy.copy` as either source or destination.
 
         :return: a Target adapter wrapping this layout
-        :rtype: oras.copy.adapters.LayoutTarget
+        :rtype: oras.layout.layout.LayoutTarget
         """
-        from oras.copy.adapters import LayoutTarget
-
         return LayoutTarget(self)
 
     def copy_to_registry(
@@ -568,7 +574,7 @@ def copy_to_registry(
         """
         from oras.container import Container
         from oras.copy import copy as copy_fn
-        from oras.copy.adapters import LayoutTarget, RegistryTarget
+        from oras.provider import RegistryTarget
 
         src = LayoutTarget(self)
         dst = RegistryTarget(provider, target, opts)
@@ -605,7 +611,7 @@ def copy_from_registry(
         """
         from oras.container import Container
         from oras.copy import copy as copy_fn
-        from oras.copy.adapters import LayoutTarget, RegistryTarget
+        from oras.provider import RegistryTarget
 
         src = RegistryTarget(provider, source, opts)
         dst = LayoutTarget(self)
@@ -709,3 +715,150 @@ def pull_from_registry(
         logger.debug(
             f"Successfully pulled {target} to OCI layout at {self._oci_layout_path}"
         )
+
+
+class LayoutTarget:
+    """
+    Adapts a :class:`Layout` directory into the copy engine's Target protocol.
+
+    Provides full read/write access to the OCI layout's content-addressable
+    blobs and manages references via the layout's index.json annotations.
+
+    Implements Target (fetch, exists, push, tag, resolve), so it can serve
+    as both source and destination in :func:`oras.copy.copy`.
+    """
+
+    def __init__(self, layout: Layout):
+        self._layout = layout
+        self._index_lock = threading.Lock()
+
+    @staticmethod
+    def _validate_digest(digest: str) -> None:
+        if not _VALID_DIGEST_RE.match(digest):
+            raise ValueError(f"invalid digest format: {digest!r}")
+
+    def _ensure_initialized(self) -> None:
+        """Create OCI layout structure (oci-layout, index.json, blobs/) if missing."""
+        layout_dir = pathlib.Path(self._layout._oci_layout_path)
+        layout_dir.mkdir(parents=True, exist_ok=True)
+        (layout_dir / oras.defaults.oci_blobs_dir).mkdir(exist_ok=True)
+
+        oci_layout_path = layout_dir / oras.defaults.oci_layout_file
+        if not oci_layout_path.exists():
+            write_json(
+                {"imageLayoutVersion": oras.defaults.oci_layout_version_pin},
+                str(oci_layout_path),
+            )
+
+        index_path = layout_dir / oras.defaults.oci_image_index_file
+        if not index_path.exists():
+            write_json(
+                {
+                    "schemaVersion": oras.defaults.oci_index_schema_version,
+                    "manifests": [],
+                },
+                str(index_path),
+            )
+
+    def fetch(self, desc: Descriptor) -> BinaryIO:
+        """Fetch blob content by digest, returning an open file handle."""
+        digest = desc["digest"]
+        self._validate_digest(digest)
+        path = self._layout.digest_to_blob_path(digest)
+        return open(path, "rb")
+
+    def exists(self, desc: Descriptor) -> bool:
+        """Check if a blob exists on disk."""
+        digest = desc["digest"]
+        self._validate_digest(digest)
+        path = self._layout.digest_to_blob_path(digest)
+        return path.exists()
+
+    def push(self, desc: Descriptor, content: BinaryIO) -> None:
+        """Write blob content to the layout (content-addressed, deduplicated).
+
+        Matching oras-go's Store.Push: skips silently if the blob already
+        exists (same digest), otherwise writes atomically via a temp file +
+        rename so concurrent writers never observe a partial blob.
+        """
+        digest = desc["digest"]
+        self._validate_digest(digest)
+
+        self._ensure_initialized()
+
+        path = self._layout.digest_to_blob_path(digest)
+        if path.exists():
+            return  # already present — deduplicate silently
+
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        tmp_fd, tmp_name = tempfile.mkstemp(dir=str(path.parent))
+        try:
+            # Stream rather than buffer: large blobs must not be fully
+            # materialized in memory.
+            with os.fdopen(tmp_fd, "wb") as f:
+                shutil.copyfileobj(content, f)
+            os.replace(tmp_name, str(path))
+        except Exception:
+            try:
+                os.unlink(tmp_name)
+            except OSError:
+                pass
+            raise
+
+    def tag(self, desc: Descriptor, reference: str) -> None:
+        """Update index.json to associate the descriptor with a reference tag.
+
+        Matching oras-go's Store.Tag: finds an existing index.json entry for
+        this reference and replaces it, or appends a new one.
+        Thread-safe via _index_lock.
+        """
+        self._ensure_initialized()
+
+        layout_dir = pathlib.Path(self._layout._oci_layout_path)
+        index_path = layout_dir / oras.defaults.oci_image_index_file
+
+        new_entry = {
+            "mediaType": desc.get("mediaType", ""),
+            "digest": desc["digest"],
+            "size": desc.get("size", 0),
+            "annotations": {oras.defaults.oci_ref_name_annotation: reference},
+        }
+
+        with self._index_lock:
+            index_data = read_json(str(index_path))
+            manifests = index_data.setdefault("manifests", [])
+
+            for i, entry in enumerate(manifests):
+                if (
+                    entry.get("annotations", {}).get(
+                        oras.defaults.oci_ref_name_annotation
+                    )
+                    == reference
+                ):
+                    manifests[i] = new_entry
+                    break
+            else:
+                manifests.append(new_entry)
+
+            write_json(index_data, str(index_path))
+
+    def resolve(self, reference: str) -> Descriptor:
+        """Resolve a reference tag to a descriptor via index.json."""
+        layout_dir = pathlib.Path(self._layout._oci_layout_path)
+        index_path = layout_dir / oras.defaults.oci_image_index_file
+        index_data = read_json(str(index_path))
+        for entry in index_data.get("manifests", []):
+            annotations = entry.get("annotations", {})
+            if (
+                annotations.get(oras.defaults.oci_ref_name_annotation)
+                == reference
+            ):
+                return {
+                    "mediaType": entry.get("mediaType", ""),
+                    "digest": entry.get("digest", ""),
+                    "size": entry.get("size", 0),
+                }
+        raise FileNotFoundError(
+            f"Reference not found in layout index: {reference}"
+        )