Push blob to OCI layout

Signed-off-by: Valentin Delaye <[email protected]>

Author: jonesbusy

src/main/java/land/oras/ContainerRef.java

@@ -141,10 +141,7 @@ public ContainerRef withDigest(String digest) {
         return new ContainerRef(registry, getNamespace(), repository, tag, digest);
     }
 
-    /**
-     * Get the algorithm for this container ref
-     * @return The algorithm
-     */
+    @Override
     public SupportedAlgorithm getAlgorithm() {
         // Default if not set
         if (digest == null) {

src/main/java/land/oras/LayoutRef.java

@@ -23,6 +23,7 @@
 import java.nio.file.Path;
 import java.util.regex.Pattern;
 import land.oras.exception.OrasException;
+import land.oras.utils.SupportedAlgorithm;
 import org.jspecify.annotations.NullMarked;
 
 /**
@@ -68,4 +69,14 @@ public static LayoutRef parse(String name) {
         String tag = matcher.group(2) != null ? matcher.group(2) : matcher.group(3); // Tag or digest
         return new LayoutRef(path, tag);
     }
+
+    @Override
+    public SupportedAlgorithm getAlgorithm() {
+        // Default if not set
+        if (tag == null) {
+            return SupportedAlgorithm.getDefault();
+        }
+        // See https://github.com/opencontainers/image-spec/blob/main/descriptor.md#digests
+        return SupportedAlgorithm.fromDigest(tag);
+    }
 }

src/main/java/land/oras/OCI.java

@@ -22,7 +22,10 @@
 
 import java.io.InputStream;
 import java.nio.file.Path;
+import java.util.Map;
 import org.jspecify.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Abstract class for OCI operation on remote registry or layout
@@ -31,6 +34,11 @@
  */
 public abstract sealed class OCI<T extends Ref> permits Registry, OCILayout {
 
+    /**
+     * The logger
+     */
+    protected static final Logger LOG = LoggerFactory.getLogger(OCI.class);
+
     /**
      * Default constructor
      */
@@ -69,6 +77,28 @@ public Manifest pushArtifact(T ref, ArtifactType artifactType, Annotations annot
         return pushArtifact(ref, artifactType, annotations, Config.empty(), paths);
     }
 
+    /**
+     * Push a blob from file
+     * @param ref The ref
+     * @param blob The blob
+     * @return The layer
+     */
+    public Layer pushBlob(T ref, Path blob) {
+        return pushBlob(ref, blob, Map.of());
+    }
+
+    /**
+     * Push config
+     * @param ref The ref
+     * @param config The config
+     * @return The config
+     */
+    public Config pushConfig(T ref, Config config) {
+        Layer layer = pushBlob(ref, config.getDataBytes());
+        LOG.debug("Config pushed: {}", layer.getDigest());
+        return config;
+    }
+
     /**
      * Push an artifact
      * @param ref The container
@@ -109,4 +139,21 @@ public abstract Manifest pushArtifact(
      * @return The input stream
      */
     public abstract InputStream fetchBlob(T ref);
+
+    /**
+     * Push a blob from file
+     * @param ref The container
+     * @param blob The blob
+     * @param annotations The annotations
+     * @return The layer
+     */
+    public abstract Layer pushBlob(T ref, Path blob, Map<String, String> annotations);
+
+    /**
+     * Push the blob for the given layer
+     * @param ref The container ref
+     * @param data The data
+     * @return The layer
+     */
+    public abstract Layer pushBlob(T ref, byte[] data);
 }

src/main/java/land/oras/OCILayout.java

@@ -31,19 +31,12 @@
 import land.oras.utils.JsonUtils;
 import land.oras.utils.SupportedAlgorithm;
 import org.jspecify.annotations.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * Index from an OCI layout
  */
 public final class OCILayout extends OCI<LayoutRef> {
 
-    /**
-     * The logger
-     */
-    private static final Logger LOG = LoggerFactory.getLogger(OCILayout.class);
-
     private final String imageLayoutVersion = "1.0.0";
 
     /**
@@ -120,6 +113,41 @@ public InputStream fetchBlob(LayoutRef ref) {
         }
     }
 
+    @Override
+    public Layer pushBlob(LayoutRef ref, Path blob, Map<String, String> annotations) {
+        ensureDigest(ref);
+        ensureMinimalLayout();
+        Path blobPath = getBlobPath(ref);
+        String digest = ref.getAlgorithm().digest(blob);
+        ensureAlgorithmPath(digest);
+        LOG.debug("Digest: {}", digest);
+        try {
+            if (Files.exists(blobPath)) {
+                LOG.debug("Blob already exists: {}", blobPath);
+                return Layer.fromFile(blobPath).withAnnotations(annotations);
+            }
+            Files.copy(blob, blobPath);
+            return Layer.fromFile(blobPath).withAnnotations(annotations);
+        } catch (IOException e) {
+            throw new OrasException("Failed to push blob", e);
+        }
+    }
+
+    @Override
+    public Layer pushBlob(LayoutRef ref, byte[] data) {
+        ensureDigest(ref);
+        ensureMinimalLayout();
+        String digest = ref.getAlgorithm().digest(data);
+        ensureAlgorithmPath(digest);
+        try {
+            Path path = Files.createTempFile("oras", "blob");
+            Files.write(path, data);
+            return pushBlob(ref, path, Map.of());
+        } catch (IOException e) {
+            throw new OrasException("Failed to push blob to OCI layout", e);
+        }
+    }
+
     private void setPath(Path path) {
         this.path = path;
     }
@@ -158,6 +186,31 @@ public void copy(Registry registry, ContainerRef containerRef) {
         copy(registry, containerRef, false);
     }
 
+    private void ensureMinimalLayout() {
+        try {
+            Files.createDirectories(getBlobPath());
+            if (!Files.exists(getOciLayoutPath())) {
+                Files.writeString(getOciLayoutPath(), toJson());
+            }
+            if (!Files.exists(getIndexPath())) {
+                Files.writeString(getIndexPath(), Index.fromManifests(List.of()).toJson());
+            }
+        } catch (IOException e) {
+            throw new OrasException("Failed to create layout", e);
+        }
+    }
+
+    private void ensureAlgorithmPath(String digest) {
+        Path prefixDirectory = getBlobAlgorithmPath(digest);
+        try {
+            if (!Files.exists(prefixDirectory)) {
+                Files.createDirectory(prefixDirectory);
+            }
+        } catch (IOException e) {
+            throw new OrasException("Failed to create algorithm path", e);
+        }
+    }
+
     /**
      * Copy the container ref from registry into oci-layout
      * @param registry The registry
@@ -168,13 +221,7 @@ public void copy(Registry registry, ContainerRef containerRef, boolean recursive
 
         try {
 
-            // Create blobs directory if needed
-            Files.createDirectories(getBlobPath());
-
-            // Write oci layout JSON
-            if (!Files.exists(getOciLayoutPath())) {
-                Files.writeString(getOciLayoutPath(), toJson());
-            }
+            ensureMinimalLayout();
 
             Map<String, String> headers = registry.getHeaders(containerRef);
             String contentType = headers.get(Const.CONTENT_TYPE_HEADER.toLowerCase());
@@ -235,10 +282,7 @@ else if (registry.isIndexMediaType(contentType)) {
             for (Layer layer : registry.collectLayers(containerRef, contentType, true)) {
                 try (InputStream is = registry.fetchBlob(containerRef.withDigest(layer.getDigest()))) {
 
-                    Path prefixDirectory = getBlobAlgorithmPath(layer.getDigest());
-                    if (!Files.exists(prefixDirectory)) {
-                        Files.createDirectory(prefixDirectory);
-                    }
+                    ensureAlgorithmPath(layer.getDigest());
 
                     Path blobFile = getBlobPath(layer);
 
@@ -256,6 +300,15 @@ else if (registry.isIndexMediaType(contentType)) {
         }
     }
 
+    private void ensureDigest(LayoutRef ref) {
+        if (ref.getTag() == null) {
+            throw new OrasException("Missing ref");
+        }
+        if (!SupportedAlgorithm.isSupported(ref.getTag())) {
+            throw new OrasException("Unsupported digest: %s".formatted(ref.getTag()));
+        }
+    }
+
     private Path getOciLayoutPath() {
         return path.resolve(Const.OCI_LAYOUT_FILE);
     }

src/main/java/land/oras/Ref.java

@@ -20,6 +20,7 @@
 
 package land.oras;
 
+import land.oras.utils.SupportedAlgorithm;
 import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 
@@ -48,4 +49,10 @@ protected Ref(String tag) {
     public @Nullable String getTag() {
         return tag;
     }
+
+    /**
+     * Get the algorithm
+     * @return The algorithm
+     */
+    public abstract SupportedAlgorithm getAlgorithm();
 }

src/main/java/land/oras/Registry.java

@@ -45,20 +45,13 @@
 import land.oras.utils.SupportedAlgorithm;
 import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * A registry is the main entry point for interacting with a container registry
  */
 @NullMarked
 public final class Registry extends OCI<ContainerRef> {
 
-    /**
-     * The logger
-     */
-    private static final Logger LOG = LoggerFactory.getLogger(Registry.class);
-
     /**
      * The HTTP client
      */
@@ -398,23 +391,7 @@ public Manifest attachArtifact(
                 manifest);
     }
 
-    /**
-     * Push a blob from file
-     * @param containerRef The container
-     * @param blob The blob
-     * @return The layer
-     */
-    public Layer pushBlob(ContainerRef containerRef, Path blob) {
-        return pushBlob(containerRef, blob, Map.of());
-    }
-
-    /**
-     * Push a blob from file
-     * @param containerRef The container
-     * @param blob The blob
-     * @param annotations The annotations
-     * @return The layer
-     */
+    @Override
     public Layer pushBlob(ContainerRef containerRef, Path blob, Map<String, String> annotations) {
         String digest = containerRef.getAlgorithm().digest(blob);
         LOG.debug("Digest: {}", digest);
@@ -465,25 +442,7 @@ public Layer pushBlob(ContainerRef containerRef, Path blob, Map<String, String>
         return Layer.fromFile(blob).withAnnotations(annotations);
     }
 
-    /**
-     * Push config
-     * @param containerRef The container
-     * @param config The config
-     * @return The config
-     */
-    public Config pushConfig(ContainerRef containerRef, Config config) {
-        Layer layer = pushBlob(containerRef, config.getDataBytes());
-        LOG.debug("Config pushed: {}", layer.getDigest());
-        return config;
-    }
-
-    /**
-     * Push the blob for the given layer in a single post request. Might not be supported by all registries
-     * Fallback to POST/then PUT (end-4a) if not supported
-     * @param containerRef The container ref
-     * @param data The data
-     * @return The layer
-     */
+    @Override
     public Layer pushBlob(ContainerRef containerRef, byte[] data) {
         String digest = containerRef.getAlgorithm().digest(data);
         if (hasBlob(containerRef.withDigest(digest))) {

src/test/java/land/oras/LayoutRefTest.java

@@ -62,4 +62,14 @@ void shouldParseFolderNameOnly() {
     void shouldFailWithInvalidRef() {
         assertThrows(OrasException.class, () -> LayoutRef.parse(""));
     }
+
+    @Test
+    void shouldGetAlgorithm() {
+        LayoutRef layoutRef = LayoutRef.parse("foo");
+        assertEquals("sha256", layoutRef.getAlgorithm().getPrefix());
+        layoutRef = LayoutRef.parse("foo@sha256:12345");
+        assertEquals("sha256", layoutRef.getAlgorithm().getPrefix());
+        layoutRef = LayoutRef.parse("foo@sha512:12345");
+        assertEquals("sha512", layoutRef.getAlgorithm().getPrefix());
+    }
 }