feat : created interfaces

Oras/Exceptions/AlreadyExistsException.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Oras.Exceptions
+{
+    /// <summary>
+    /// AlreadyExistsException is thrown when a resource already exists.
+    /// </summary>
+    public class AlreadyExistsException : Exception
+    {
+        public AlreadyExistsException()
+        {
+        }
+
+        public AlreadyExistsException(string message)
+            : base(message)
+        {
+        }
+
+        public AlreadyExistsException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}

Oras/Exceptions/InvalidDigestException.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Oras.Exceptions
+{
+    /// <summary>
+    /// InvalidDigestException is thrown when a digest is invalid.
+    /// </summary>
+    public class InvalidDigestException : Exception
+    {
+        public InvalidDigestException()
+        {
+        }
+
+        public InvalidDigestException(string message)
+            : base(message)
+        {
+        }
+
+        public InvalidDigestException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}

Oras/Exceptions/InvalidReferenceException.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Oras.Exceptions
+{
+    /// <summary>
+    /// InvalidReferenceException is thrown when the reference is invlid
+    /// </summary>
+    public class InvalidReferenceException : Exception
+    {
+        public InvalidReferenceException()
+        {
+        }
+
+        public InvalidReferenceException(string message)
+            : base(message)
+        {
+        }
+
+        public InvalidReferenceException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}

Oras/Exceptions/MissingReferenceException.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Oras.Exceptions
+{
+    /// <summary>
+    /// MissingReferenceException is thrown when a reference is missing.
+    /// </summary>
+    public class MissingReferenceException : Exception
+    {
+        public MissingReferenceException()
+        {
+        }
+
+        public MissingReferenceException(string message)
+            : base(message)
+        {
+        }
+
+        public MissingReferenceException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}

Oras/Exceptions/NotFoundException.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Oras.Exceptions
+{
+    /// <summary>
+    /// NotFoundException is thrown when a resource is not found.
+    /// </summary>
+    public class NotFoundException : Exception
+    {
+        public NotFoundException()
+        {
+        }
+
+        public NotFoundException(string message)
+            : base(message)
+        {
+        }
+
+        public NotFoundException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}

Oras/Exceptions/SizeExceedsLimitException.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Oras.Exceptions
+{
+    /// <summary>
+    /// SizeExceedsLimitException is thrown when a size exceeds the limit.
+    /// </summary>
+    public class SizeExceedsLimitException : Exception
+    {
+        public SizeExceedsLimitException()
+        {
+        }
+
+        public SizeExceedsLimitException(string message)
+            : base(message)
+        {
+        }
+
+        public SizeExceedsLimitException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}

Oras/Exceptions/UnsupportedException.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Oras.Exceptions
+{
+    /// <summary>
+    /// UnsupportedException is thrown when a feature is not supported.
+    /// </summary>
+    public class UnsupportedException : Exception
+    {
+        public UnsupportedException()
+        {
+        }
+
+        public UnsupportedException(string message)
+            : base(message)
+        {
+        }
+
+        public UnsupportedException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}

Oras/Exceptions/UnsupportedVersionException.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Oras.Exceptions
+{
+    public class UnsupportedVersionException : Exception
+    {
+        /// <summary>
+        /// UnsupportedVersionException is thrown when a version is not supported
+        /// </summary>
+        public UnsupportedVersionException()
+        {
+        }
+
+        public UnsupportedVersionException(string message)
+            : base(message)
+        {
+        }
+
+        public UnsupportedVersionException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}

Oras/Interfaces/IReadOnlyStorage.cs

@@ -0,0 +1,29 @@
+using Oras.Models;
+using System.Threading;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Oras.Interfaces
+{
+    /// <summary>
+    /// IReadOnlyStorage represents a read-only Storage.
+    /// </summary>
+    public interface IReadOnlyStorage
+    {
+        /// <summary>
+        /// ExistsAsync returns true if the described content exists.
+        /// </summary>
+        /// <param name="target"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<bool> ExistsAsync(Descriptor target, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// FetchAsync fetches the content identified by the descriptor.
+        /// </summary>
+        /// <param name="target"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<Stream> FetchAsync(Descriptor target, CancellationToken cancellationToken = default);
+    }
+}

Oras/Interfaces/IReadOnlyTarget.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Oras.Interfaces
+{
+    /// <summary>
+    /// IReadOnlyTarget represents a read-only Target.
+    /// </summary>
+    public interface IReadOnlyTarget : IReadOnlyStorage, IResolver
+    {
+    }
+}

Oras/Interfaces/IResolver.cs

@@ -0,0 +1,23 @@
+using Oras.Models;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using System.Threading;
+
+namespace Oras.Interfaces
+{
+    /// <summary>
+    /// IResolver resolves reference tags.
+    /// </summary>
+    public interface IResolver
+    {
+        /// <summary>
+        /// ResolveAsync resolves the reference to a descriptor.
+        /// </summary>
+        /// <param name="reference"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<Descriptor> ResolveAsync(string reference, CancellationToken cancellationToken = default);
+    }
+}

Oras/Interfaces/IStorage.cs

@@ -0,0 +1,28 @@
+using Oras.Models;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Oras.Interfaces
+{
+    /// <summary>
+    /// IStorage represents a content-addressable storage (CAS) where contents are accessed via Descriptors.
+    /// The storage is designed to handle blobs of large sizes.
+    /// </summary>
+    public interface IStorage : IReadOnlyStorage
+    {
+        /// <summary>
+        /// PushAsync pushes the content, matching the expected descriptor.
+        /// </summary>
+        /// <param name="expected"></param>
+        /// <param name="content"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task PushAsync(Descriptor expected, Stream content, CancellationToken cancellationToken = default);
+    }
+
+}

Oras/Interfaces/ITagResolver.cs

@@ -0,0 +1,25 @@
+using Oras.Models;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using System.Threading;
+using Oras.Models;
+
+namespace Oras.Interfaces
+{
+    /// <summary>
+    /// ITagResolver provides reference tag indexing services.
+    /// </summary>
+    public interface ITagResolver : IResolver
+    {
+        /// <summary>
+        /// TagAsync tags the descriptor with the reference.
+        /// </summary>
+        /// <param name="descriptor"></param>
+        /// <param name="reference"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task TagAsync(Descriptor descriptor, string reference, CancellationToken cancellationToken = default);
+    }
+}

Oras/Interfaces/ITarget.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Oras.Interfaces
+{
+    /// <summary>
+    /// Target is a CAS with generic tags
+    /// </summary>
+    public interface ITarget : IStorage, ITagResolver
+    {
+    }
+}