refactor!: modernize copy

Signed-off-by: Shiwei Zhang <[email protected]>

src/OrasProject.Oras/Content/MemoryGraph.cs

@@ -34,7 +34,7 @@ public Task<IEnumerable<Descriptor>> GetPredecessorsAsync(Descriptor node, Cance
         var key = node.BasicDescriptor;
         if (_predecessors.TryGetValue(key, out var predecessors))
         {
-            return Task.FromResult<IEnumerable<Descriptor>> (predecessors.Values);
+            return Task.FromResult<IEnumerable<Descriptor>>(predecessors.Values);
         }
         return Task.FromResult<IEnumerable<Descriptor>>(Array.Empty<Descriptor>());
     }

src/OrasProject.Oras/Extensions.cs

@@ -0,0 +1,73 @@
+// Copyright The ORAS Authors.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using OrasProject.Oras.Oci;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using static OrasProject.Oras.Content.Extensions;
+
+namespace OrasProject.Oras;
+
+public static class Extensions
+{
+
+    /// <summary>
+    /// Copy copies a rooted directed acyclic graph (DAG) with the tagged root node
+    /// in the source Target to the destination Target.
+    /// The destination reference will be the same as the source reference if the
+    /// destination reference is left blank.
+    /// Returns the descriptor of the root node on successful copy.
+    /// </summary>
+    /// <param name="src"></param>
+    /// <param name="srcRef"></param>
+    /// <param name="dst"></param>
+    /// <param name="dstRef"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    /// <exception cref="Exception"></exception>
+    public static async Task<Descriptor> CopyAsync(this ITarget src, string srcRef, ITarget dst, string dstRef, CancellationToken cancellationToken = default)
+    {
+        if (string.IsNullOrEmpty(dstRef))
+        {
+            dstRef = srcRef;
+        }
+        var root = await src.ResolveAsync(srcRef, cancellationToken).ConfigureAwait(false);
+        await src.CopyGraphAsync(dst, root, cancellationToken).ConfigureAwait(false);
+        await dst.TagAsync(root, dstRef, cancellationToken).ConfigureAwait(false);
+        return root;
+    }
+
+    public static async Task CopyGraphAsync(this ITarget src, ITarget dst, Descriptor node, CancellationToken cancellationToken)
+    {
+        // check if node exists in target
+        if (await dst.ExistsAsync(node, cancellationToken).ConfigureAwait(false))
+        {
+            return;
+        }
+
+        // retrieve successors
+        var successors = await src.GetSuccessorsAsync(node, cancellationToken).ConfigureAwait(false);
+        // obtain data stream
+        var dataStream = await src.FetchAsync(node, cancellationToken).ConfigureAwait(false);
+        // check if the node has successors
+        if (successors != null)
+        {
+            foreach (var childNode in successors)
+            {
+                await src.CopyGraphAsync(dst, childNode, cancellationToken).ConfigureAwait(false);
+            }
+        }
+        await dst.PushAsync(node, dataStream, cancellationToken).ConfigureAwait(false);
+    }
+}

src/OrasProject.Oras/ITarget.cs

@@ -9,8 +9,8 @@
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
-// limitations under the License.
-
+// limitations under the License.
+
 using OrasProject.Oras.Content;
 
 namespace OrasProject.Oras;

tests/OrasProject.Oras.Tests/CopyTest.cs

@@ -70,7 +70,7 @@ public async Task CanCopyBetweenMemoryTargetsWithTaggedNode()
             var reference = "foobar";
             await sourceTarget.TagAsync(root, reference, cancellationToken);
             var destinationTarget = new MemoryTarget();
-            var gotDesc = await Copy.CopyAsync(sourceTarget, reference, destinationTarget, "", cancellationToken);
+            var gotDesc = await sourceTarget.CopyAsync(reference, destinationTarget, "", cancellationToken);
             Assert.Equal(gotDesc, root);
             Assert.Equal(await destinationTarget.ResolveAsync(reference, cancellationToken), root);
 
@@ -130,7 +130,7 @@ public async Task CanCopyBetweenMemoryTargets()
             }
             var root = descs[3];
             var destinationTarget = new MemoryTarget();
-            await Copy.CopyGraphAsync(sourceTarget, destinationTarget, root, cancellationToken);
+            await sourceTarget.CopyGraphAsync(destinationTarget, root, cancellationToken);
             for (var i = 0; i < descs.Count; i++)
             {
                 Assert.True(await destinationTarget.ExistsAsync(descs[i], cancellationToken));

tests/OrasProject.Oras.Tests/RemoteTest/RepositoryTest.cs

@@ -2103,7 +2103,7 @@ public async Task CopyFromRepositoryToMemory()
 
             var dst = new MemoryTarget();
             var tagName = "latest";
-            var desc = await Copy.CopyAsync(src, tagName, dst, tagName, CancellationToken.None);
+            var desc = await src.CopyAsync(tagName, dst, tagName, CancellationToken.None);
         }
 
         [Fact]