Synnefo » Pithos MS Client

#region

/* -----------------------------------------------------------------------

 * <copyright file="ICloudClient.cs" company="GRNet">

 * 

 * Copyright 2011-2012 GRNET S.A. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or

 * without modification, are permitted provided that the following

 * conditions are met:

 *

 *   1. Redistributions of source code must retain the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer.

 *

 *   2. Redistributions in binary form must reproduce the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer in the documentation and/or other materials

 *      provided with the distribution.

 *

 *

 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 *

 * The views and conclusions contained in the software and

 * documentation are those of the authors and should not be

 * interpreted as representing official policies, either expressed

 * or implied, of GRNET S.A.

 * </copyright>

 * -----------------------------------------------------------------------

 */

#endregion

using System;

using System.Collections.Generic;

using System.Diagnostics.Contracts;

using System.Net;

using System.Threading;

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; }

        AccountInfo Authenticate();

        //WebProxy Proxy { get; set; }

        double DownloadPercentLimit { get; set; }

        double UploadPercentLimit { get; set; }

        string AuthenticationUrl { get; set; }

        #region Container operations

        IList<ContainerInfo> ListContainers(string account);

        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,CancellationToken cancellationToken);

        Task PutObject(string account, string container, string objectName, string fileName, string hash = null, string contentType = "application/octet-stream");

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

        //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,CancellationToken cancellationToken);

        #endregion

        #region Sharing operations        

        IList<ObjectInfo> ListSharedObjects(DateTime? since);

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

        #endregion

        AccountInfo GetAccountPolicies(AccountInfo accountInfo);

        void UpdateMetadata(ObjectInfo objectInfo);

        void UpdateMetadata(ContainerInfo Container);

        IList<ShareAccountInfo> ListSharingAccounts(DateTime? since=null);

    }

    [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 double DownloadPercentLimit { get; set; }

        public double UploadPercentLimit { get; set; }

        public string AuthenticationUrl { get; set; }

        public bool UsePithos { get; set; }

        public AccountInfo Authenticate()

        {

            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");

            return default(AccountInfo);

        }

        public IList<ContainerInfo> ListContainers(string account)

        {

            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 AccountInfo GetAccountPolicies(AccountInfo accountInfo)

        {

            Contract.Requires(accountInfo!=null);

            return default(AccountInfo);

        }

        public void UpdateMetadata(ObjectInfo objectInfo)

        {

            Contract.Requires(objectInfo!=null);

            return ;

        }

        public void UpdateMetadata(ContainerInfo objectInfo)

        {

            Contract.Requires(objectInfo!=null);

            return ;

        }

        public IList<ShareAccountInfo> ListSharingAccounts(DateTime? since = new DateTime?())

        {

            return default(IList<ShareAccountInfo>);

        }

        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,CancellationToken cancellationToken)

        {

            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, string contentType = "application/octet-stream")

        {

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

            Contract.Requires(StorageUrl!=null);

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

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

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

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

            return default(Task);

        }

        public void DeleteObject(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));            

        }

        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,CancellationToken cancellationToken)

        {

            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[]>);

        }

    }

}