Synnefo » Pithos MS Client

using System;

using System.Collections.Generic;

using System.Diagnostics.Contracts;

using System.Threading.Tasks;

using Pithos.Interfaces;

namespace Pithos.Network

{

    [ContractClass(typeof(ICloudClientContract))]

    public interface ICloudClient

    {

        string ApiKey { get; set; }

        string UserName { get; set; }

        Uri StorageUrl { get; set; }

        string Token { get; set; }

        bool UsePithos { get; set; }

        void Authenticate(string userName,string apiKey);

        Uri Proxy { get; set; }

        double DownloadPercentLimit { get; set; }

        double UploadPercentLimit { get; set; }

        string AuthenticationUrl { get; set; }

        #region Container operations

        IList<ContainerInfo> ListContainers(string account=null);

        IList<ObjectInfo> ListObjects(string account, string container, DateTime? since = null);

        IList<ObjectInfo> ListObjects(string account, string container, string folder, DateTime? since = null);

        bool ContainerExists(string account, string container);

        ContainerInfo GetContainerInfo(string account, string container);

        void CreateContainer(string account, string container);

        void DeleteContainer(string account, string container);

        #endregion

        #region Object operations        

        Task GetObject(string account, string container, string objectName, string fileName);

        Task PutObject(string account, string container, string objectName, string fileName, string hash = null);

        void DeleteObject(string account, string container, string objectName, string trashContainer);

        //void DeleteObject(string container, string objectName, string account = null);

        void MoveObject(string account, string sourceContainer, string oldObjectName, string targetContainer, string newObjectName);

        bool ObjectExists(string account, string container, string objectName);

        ObjectInfo GetObjectInfo(string account, string container, string objectName);

        void CreateFolder(string account, string container, string folder);

        #endregion

        #region Hashmap operations        

        Task<TreeHash> GetHashMap(string account, string container, string objectName);

        Task<IList<string>> PutHashMap(string account, string container, string objectName, TreeHash hash);

        Task PostBlock(string account, string container, byte[] block, int offset, int count);

        Task<byte[]> GetBlock(string account, string container, Uri relativeUrl, long start, long? end);

        #endregion

        #region Sharing operations        

        IList<ObjectInfo> ListSharedObjects(DateTime? since);

        void ShareObject(string account, string container, string objectName, string shareTo, bool read, bool write);

        #endregion

    }

    [ContractClassFor(typeof(ICloudClient))]

    public abstract class ICloudClientContract:ICloudClient

    {

        public string ApiKey { get; set; }

        public string UserName { get; set; }

        public Uri StorageUrl { get; set; }

        public string Token { get; set; }

        public Uri Proxy { get; set; }

        public double DownloadPercentLimit { get; set; }

        public double UploadPercentLimit { get; set; }

        public string AuthenticationUrl { get; set; }

        public bool UsePithos { get; set; }

        public void Authenticate(string userName, string apiKey)

        {

            Contract.Requires<ArgumentNullException>(!String.IsNullOrWhiteSpace(apiKey), "ApiKey must be filled before calling Authenticate");

            Contract.Requires<ArgumentNullException>(!String.IsNullOrWhiteSpace(userName), "UserName must be filled before calling Authenticate");

            Contract.Ensures(apiKey==ApiKey);

            Contract.Ensures(userName==UserName);

            Contract.Ensures(StorageUrl!=null);

            Contract.Ensures(!String.IsNullOrWhiteSpace(Token));

        }

        public IList<ContainerInfo> ListContainers(string account=null)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl!=null);            

            return default(IList<ContainerInfo>);

        }

        public IList<ObjectInfo> ListSharedObjects(DateTime? since)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl != null);

            return default(IList<ObjectInfo>);

        }

        public void ShareObject(string account, string container, string objectName, string shareTo, bool read, bool write)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl != null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));

            Contract.Requires(!String.IsNullOrWhiteSpace(account));

            Contract.Requires(!String.IsNullOrWhiteSpace(shareTo));

        }

        public IList<ObjectInfo> ListObjects(string account, string container, DateTime? since = null)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl != null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            return default(IList<ObjectInfo>);

        }

        public IList<ObjectInfo> ListObjects(string account, string container, string folder, DateTime? since = null)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl != null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(!String.IsNullOrWhiteSpace(folder));

            return default(IList<ObjectInfo>);

        }

        public bool ContainerExists(string account, string container)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl!=null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            return default(bool);

        }

        public ContainerInfo GetContainerInfo(string account, string container)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl!=null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            return default(ContainerInfo);

        }

        public void CreateContainer(string account, string container)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl!=null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

        }

        public void DeleteContainer(string account, string container)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl!=null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

        }

        public Task GetObject(string account, string container, string objectName, string fileName)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl!=null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));

            return default(Task);

        }

        public Task PutObject(string account, string container, string objectName, string fileName, string hash = null)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl!=null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(!String.IsNullOrWhiteSpace(fileName));                        

            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));

            return default(Task);

        }

        public void DeleteObject(string account, string container, string objectName, string trashContainer)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl!=null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));

            Contract.Requires(!String.IsNullOrWhiteSpace(trashContainer));

        }

        public void DeleteObject(string container, string objectName, string account = null)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl!=null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));            

        }

        public void MoveObject(string account, string sourceContainer, string oldObjectName, string targetContainer, string newObjectName)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl!=null);

            Contract.Requires(!String.IsNullOrWhiteSpace(sourceContainer));

            Contract.Requires(!String.IsNullOrWhiteSpace(oldObjectName));

            Contract.Requires(!String.IsNullOrWhiteSpace(targetContainer));

            Contract.Requires(!String.IsNullOrWhiteSpace(newObjectName));

        }

        public bool ObjectExists(string account, string container, string objectName)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl!=null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));

            return default(bool);

        }

        public ObjectInfo GetObjectInfo(string account, string container, string objectName)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl!=null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));

            return default(ObjectInfo);

        }

        public void CreateFolder(string account, string container, string folder)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl != null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(!String.IsNullOrWhiteSpace(folder));            

        }

        public Task<TreeHash> GetHashMap(string account, string container, string objectName)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl != null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));

            return default(Task<TreeHash>);

        }

        public Task<IList<string>> PutHashMap(string account, string container, string objectName, TreeHash hash)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl != null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));

            Contract.Requires(hash != null);

            return default(Task<IList<string>>);

        }

        public Task PostBlock(string account, string container, byte[] block, int offset, int count)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl != null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(block != null);

            Contract.Requires(offset>=0);

            Contract.Requires(offset < block.Length);

            Contract.Requires(count>=0);

            Contract.Requires(count <= block.Length);

            return default(Task);

        }

        public Task<byte[]> GetBlock(string account, string container, Uri relativeUrl, long start, long? end)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(StorageUrl != null);

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(relativeUrl!=null);

            Contract.Requires(start>=0);

            Contract.Requires(end==null || end>=0);

            return default(Task<byte[]>);

        }

    }

}