code.grnet.gr Git - pithos-ms-client/blob - trunk/Pithos.Network/ICloudClient.cs

   1 #region
   2 /* -----------------------------------------------------------------------
   3  * <copyright file="ICloudClient.cs" company="GRNet">
   4  *
   5  * Copyright 2011-2012 GRNET S.A. All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or
   8  * without modification, are permitted provided that the following
   9  * conditions are met:
  10  *
  11  *   1. Redistributions of source code must retain the above
  12  *      copyright notice, this list of conditions and the following
  13  *      disclaimer.
  14  *
  15  *   2. Redistributions in binary form must reproduce the above
  16  *      copyright notice, this list of conditions and the following
  17  *      disclaimer in the documentation and/or other materials
  18  *      provided with the distribution.
  19  *
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
  22  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  23  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  24  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
  25  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  28  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  * The views and conclusions contained in the software and
  35  * documentation are those of the authors and should not be
  36  * interpreted as representing official policies, either expressed
  37  * or implied, of GRNET S.A.
  38  * </copyright>
  39  * -----------------------------------------------------------------------
  40  */
  41 #endregion
  42 using System;
  43 using System.Collections.Generic;
  44 using System.Diagnostics.Contracts;
  45 using System.Net;
  46 using System.Threading;
  47 using System.Threading.Tasks;
  48 using Pithos.Interfaces;
  49
  50 namespace Pithos.Network
  51 {
  52     [ContractClass(typeof(ICloudClientContract))]
  53     public interface ICloudClient
  54     {
  55
  56         string ApiKey { get; set; }
  57         string UserName { get; set; }
  58         Uri StorageUrl { get; set; }
  59
  60         string Token { get; set; }
  61
  62         bool UsePithos { get; set; }
  63         AccountInfo Authenticate();
  64         //WebProxy Proxy { get; set; }
  65         double DownloadPercentLimit { get; set; }
  66         double UploadPercentLimit { get; set; }
  67         string AuthenticationUrl { get; set; }
  68
  69         #region Container operations
  70
  71         IList<ContainerInfo> ListContainers(string account);
  72         IList<ObjectInfo> ListObjects(string account, string container, DateTime? since = null);
  73         IList<ObjectInfo> ListObjects(string account, string container, string folder, DateTime? since = null);
  74         bool ContainerExists(string account, string container);
  75         ContainerInfo GetContainerInfo(string account, string container);
  76         void CreateContainer(string account, string container);
  77         void DeleteContainer(string account, string container);
  78         #endregion
  79
  80         #region Object operations
  81         Task GetObject(string account, string container, string objectName, string fileName,CancellationToken cancellationToken);
  82         Task PutObject(string account, string container, string objectName, string fileName, string hash = null, string contentType = "application/octet-stream");
  83         void DeleteObject(string account, string container, string objectName);
  84         //void DeleteObject(string container, string objectName, string account = null);
  85         void MoveObject(string account, string sourceContainer, string oldObjectName, string targetContainer, string newObjectName);
  86         bool ObjectExists(string account, string container, string objectName);
  87         ObjectInfo GetObjectInfo(string account, string container, string objectName);
  88         void CreateFolder(string account, string container, string folder);
  89         #endregion
  90
  91         #region Hashmap operations
  92         Task<TreeHash> GetHashMap(string account, string container, string objectName);
  93         Task<IList<string>> PutHashMap(string account, string container, string objectName, TreeHash hash);
  94         Task PostBlock(string account, string container, byte[] block, int offset, int count,CancellationToken token);
  95         Task<byte[]> GetBlock(string account, string container, Uri relativeUrl, long start, long? end,CancellationToken cancellationToken);
  96         #endregion
  97
  98         #region Sharing operations
  99         IList<ObjectInfo> ListSharedObjects(DateTime? since);
 100         void ShareObject(string account, string container, string objectName, string shareTo, bool read, bool write);
 101
 102         #endregion
 103
 104         AccountInfo GetAccountPolicies(AccountInfo accountInfo);
 105
 106         void UpdateMetadata(ObjectInfo objectInfo);
 107
 108         void UpdateMetadata(ContainerInfo Container);
 109         IList<ShareAccountInfo> ListSharingAccounts(DateTime? since=null);
 110     }
 111
 112
 113     [ContractClassFor(typeof(ICloudClient))]
 114     public abstract class ICloudClientContract:ICloudClient
 115     {
 116
 117         public string ApiKey { get; set; }
 118         public string UserName { get; set; }
 119         public Uri StorageUrl { get; set; }
 120         public string Token { get; set; }
 121
 122         public double DownloadPercentLimit { get; set; }
 123         public double UploadPercentLimit { get; set; }
 124
 125         public string AuthenticationUrl { get; set; }
 126
 127         public bool UsePithos { get; set; }
 128
 129         public AccountInfo Authenticate()
 130         {
 131             Contract.Requires<ArgumentNullException>(!String.IsNullOrWhiteSpace(ApiKey), "ApiKey must be filled before calling Authenticate");
 132             Contract.Requires<ArgumentNullException>(!String.IsNullOrWhiteSpace(UserName), "UserName must be filled before calling Authenticate");
 133
 134             return default(AccountInfo);
 135         }
 136
 137         public IList<ContainerInfo> ListContainers(string account)
 138         {
 139             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 140             Contract.Requires(StorageUrl!=null);
 141
 142             return default(IList<ContainerInfo>);
 143         }
 144
 145         public IList<ObjectInfo> ListSharedObjects(DateTime? since)
 146         {
 147
 148
 149             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 150             Contract.Requires(StorageUrl != null);
 151
 152             return default(IList<ObjectInfo>);
 153         }
 154
 155         public void ShareObject(string account, string container, string objectName, string shareTo, bool read, bool write)
 156         {
 157
 158             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 159             Contract.Requires(StorageUrl != null);
 160             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 161             Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
 162             Contract.Requires(!String.IsNullOrWhiteSpace(account));
 163             Contract.Requires(!String.IsNullOrWhiteSpace(shareTo));
 164
 165         }
 166
 167         public AccountInfo GetAccountPolicies(AccountInfo accountInfo)
 168         {
 169             Contract.Requires(accountInfo!=null);
 170
 171             return default(AccountInfo);
 172         }
 173
 174         public void UpdateMetadata(ObjectInfo objectInfo)
 175         {
 176             Contract.Requires(objectInfo!=null);
 177
 178             return ;
 179         }
 180
 181         public void UpdateMetadata(ContainerInfo objectInfo)
 182         {
 183             Contract.Requires(objectInfo!=null);
 184
 185             return ;
 186         }
 187
 188         public IList<ShareAccountInfo> ListSharingAccounts(DateTime? since = new DateTime?())
 189         {
 190             return default(IList<ShareAccountInfo>);
 191         }
 192
 193
 194         public IList<ObjectInfo> ListObjects(string account, string container, DateTime? since = null)
 195         {
 196
 197             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 198             Contract.Requires(StorageUrl != null);
 199             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 200
 201             return default(IList<ObjectInfo>);
 202         }
 203
 204         public IList<ObjectInfo> ListObjects(string account, string container, string folder, DateTime? since = null)
 205         {
 206
 207             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 208             Contract.Requires(StorageUrl != null);
 209             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 210             //Contract.Requires(!String.IsNullOrWhiteSpace(folder));
 211
 212             return default(IList<ObjectInfo>);
 213         }
 214
 215         public bool ContainerExists(string account, string container)
 216         {
 217
 218             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 219             Contract.Requires(StorageUrl!=null);
 220             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 221
 222             return default(bool);
 223         }
 224
 225         public ContainerInfo GetContainerInfo(string account, string container)
 226         {
 227
 228             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 229             Contract.Requires(StorageUrl!=null);
 230             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 231
 232             return default(ContainerInfo);
 233         }
 234
 235         public void CreateContainer(string account, string container)
 236         {
 237
 238             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 239             Contract.Requires(StorageUrl!=null);
 240             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 241         }
 242
 243         public void DeleteContainer(string account, string container)
 244         {
 245
 246             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 247             Contract.Requires(StorageUrl!=null);
 248             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 249         }
 250
 251         public Task GetObject(string account, string container, string objectName, string fileName,CancellationToken cancellationToken)
 252         {
 253
 254             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 255             Contract.Requires(StorageUrl!=null);
 256             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 257             Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
 258
 259             return default(Task);
 260         }
 261
 262         public Task PutObject(string account, string container, string objectName, string fileName, string hash = null, string contentType = "application/octet-stream")
 263         {
 264
 265             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 266             Contract.Requires(StorageUrl!=null);
 267             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 268             Contract.Requires(!String.IsNullOrWhiteSpace(fileName));
 269             Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
 270             Contract.Requires(!String.IsNullOrWhiteSpace(contentType));
 271
 272             return default(Task);
 273         }
 274
 275         public void DeleteObject(string account, string container, string objectName)
 276         {
 277
 278             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 279             Contract.Requires(StorageUrl!=null);
 280             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 281             Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
 282         }
 283
 284         public void MoveObject(string account, string sourceContainer, string oldObjectName, string targetContainer, string newObjectName)
 285         {
 286
 287             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 288             Contract.Requires(StorageUrl!=null);
 289             Contract.Requires(!String.IsNullOrWhiteSpace(sourceContainer));
 290             Contract.Requires(!String.IsNullOrWhiteSpace(oldObjectName));
 291             Contract.Requires(!String.IsNullOrWhiteSpace(targetContainer));
 292             Contract.Requires(!String.IsNullOrWhiteSpace(newObjectName));
 293         }
 294
 295         public bool ObjectExists(string account, string container, string objectName)
 296         {
 297
 298             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 299             Contract.Requires(StorageUrl!=null);
 300             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 301             Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
 302
 303             return default(bool);
 304         }
 305
 306         public ObjectInfo GetObjectInfo(string account, string container, string objectName)
 307         {
 308
 309             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 310             Contract.Requires(StorageUrl!=null);
 311             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 312             Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
 313
 314             return default(ObjectInfo);
 315         }
 316
 317         public void CreateFolder(string account, string container, string folder)
 318         {
 319
 320             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 321             Contract.Requires(StorageUrl != null);
 322             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 323             Contract.Requires(!String.IsNullOrWhiteSpace(folder));
 324         }
 325
 326         public Task<TreeHash> GetHashMap(string account, string container, string objectName)
 327         {
 328
 329             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 330             Contract.Requires(StorageUrl != null);
 331             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 332             Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
 333
 334             return default(Task<TreeHash>);
 335         }
 336
 337         public Task<IList<string>> PutHashMap(string account, string container, string objectName, TreeHash hash)
 338         {
 339
 340             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 341             Contract.Requires(StorageUrl != null);
 342             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 343             Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
 344             Contract.Requires(hash != null);
 345
 346             return default(Task<IList<string>>);
 347         }
 348
 349         public Task PostBlock(string account, string container, byte[] block, int offset, int count,CancellationToken token)
 350         {
 351
 352             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 353             Contract.Requires(StorageUrl != null);
 354             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 355             Contract.Requires(block != null);
 356             Contract.Requires(offset>=0);
 357             Contract.Requires(offset < block.Length);
 358             Contract.Requires(count>=0);
 359             Contract.Requires(count <= block.Length);
 360
 361             return default(Task);
 362         }
 363
 364         public Task<byte[]> GetBlock(string account, string container, Uri relativeUrl, long start, long? end,CancellationToken cancellationToken)
 365         {
 366
 367             Contract.Requires(!String.IsNullOrWhiteSpace(Token));
 368             Contract.Requires(StorageUrl != null);
 369             Contract.Requires(!String.IsNullOrWhiteSpace(container));
 370             Contract.Requires(relativeUrl!=null);
 371             Contract.Requires(start>=0);
 372             Contract.Requires(end==null || end>=0);
 373
 374             return default(Task<byte[]>);
 375         }
 376
 377     }
 378 }