Statistics
| Branch: | Revision:

root / trunk / Pithos.Network / ICloudClient.cs @ aba9e6d9

History | View | Annotate | Download (12.3 kB)

1
using System;
2
using System.Collections.Generic;
3
using System.Diagnostics.Contracts;
4
using System.Threading.Tasks;
5
using Pithos.Interfaces;
6

    
7
namespace Pithos.Network
8
{
9
    [ContractClass(typeof(ICloudClientContract))]
10
    public interface ICloudClient
11
    {
12

    
13
        string ApiKey { get; set; }
14
        string UserName { get; set; }
15
        Uri StorageUrl { get; set; }
16

    
17
        string Token { get; set; }
18

    
19
        bool UsePithos { get; set; }
20
        AccountInfo Authenticate();
21
        Uri Proxy { get; set; }
22
        double DownloadPercentLimit { get; set; }
23
        double UploadPercentLimit { get; set; }
24
        string AuthenticationUrl { get; set; }
25

    
26
        #region Container operations
27

    
28
        IList<ContainerInfo> ListContainers(string account);
29
        IList<ObjectInfo> ListObjects(string account, string container, DateTime? since = null);
30
        IList<ObjectInfo> ListObjects(string account, string container, string folder, DateTime? since = null);
31
        bool ContainerExists(string account, string container);
32
        ContainerInfo GetContainerInfo(string account, string container);
33
        void CreateContainer(string account, string container);
34
        void DeleteContainer(string account, string container);
35
        #endregion
36

    
37
        #region Object operations        
38
        Task GetObject(string account, string container, string objectName, string fileName);
39
        Task PutObject(string account, string container, string objectName, string fileName, string hash = null);
40
        void DeleteObject(string account, string container, string objectName);
41
        //void DeleteObject(string container, string objectName, string account = null);
42
        void MoveObject(string account, string sourceContainer, string oldObjectName, string targetContainer, string newObjectName);
43
        bool ObjectExists(string account, string container, string objectName);
44
        ObjectInfo GetObjectInfo(string account, string container, string objectName);
45
        void CreateFolder(string account, string container, string folder);
46
        #endregion
47

    
48
        #region Hashmap operations        
49
        Task<TreeHash> GetHashMap(string account, string container, string objectName);
50
        Task<IList<string>> PutHashMap(string account, string container, string objectName, TreeHash hash);
51
        Task PostBlock(string account, string container, byte[] block, int offset, int count);
52
        Task<byte[]> GetBlock(string account, string container, Uri relativeUrl, long start, long? end);
53
        #endregion
54

    
55
        #region Sharing operations        
56
        IList<ObjectInfo> ListSharedObjects(DateTime? since);
57
        void ShareObject(string account, string container, string objectName, string shareTo, bool read, bool write);
58

    
59
        #endregion
60

    
61
        AccountInfo GetAccountPolicies(AccountInfo accountInfo);
62

    
63
        void UpdateMetadata(ObjectInfo objectInfo);
64
    }
65

    
66

    
67
    [ContractClassFor(typeof(ICloudClient))]
68
    public abstract class ICloudClientContract:ICloudClient
69
    {
70

    
71
        public string ApiKey { get; set; }
72
        public string UserName { get; set; }
73
        public Uri StorageUrl { get; set; }
74
        public string Token { get; set; }
75

    
76
        public Uri Proxy { get; set; }
77
        public double DownloadPercentLimit { get; set; }
78
        public double UploadPercentLimit { get; set; }
79

    
80
        public string AuthenticationUrl { get; set; }
81

    
82
        public bool UsePithos { get; set; }
83

    
84
        public AccountInfo Authenticate()
85
        {
86
            Contract.Requires<ArgumentNullException>(!String.IsNullOrWhiteSpace(ApiKey), "ApiKey must be filled before calling Authenticate");
87
            Contract.Requires<ArgumentNullException>(!String.IsNullOrWhiteSpace(UserName), "UserName must be filled before calling Authenticate");
88

    
89
            return default(AccountInfo);
90
        }
91

    
92
        public IList<ContainerInfo> ListContainers(string account)
93
        {
94
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
95
            Contract.Requires(StorageUrl!=null);            
96

    
97
            return default(IList<ContainerInfo>);
98
        }
99

    
100
        public IList<ObjectInfo> ListSharedObjects(DateTime? since)
101
        {
102

    
103
            
104
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
105
            Contract.Requires(StorageUrl != null);
106

    
107
            return default(IList<ObjectInfo>);
108
        }
109

    
110
        public void ShareObject(string account, string container, string objectName, string shareTo, bool read, bool write)
111
        {
112
            
113
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
114
            Contract.Requires(StorageUrl != null);
115
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
116
            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
117
            Contract.Requires(!String.IsNullOrWhiteSpace(account));
118
            Contract.Requires(!String.IsNullOrWhiteSpace(shareTo));
119
   
120
        }
121

    
122
        public AccountInfo GetAccountPolicies(AccountInfo accountInfo)
123
        {
124
            Contract.Requires(accountInfo!=null);
125

    
126
            return default(AccountInfo);
127
        }
128

    
129
        public void UpdateMetadata(ObjectInfo objectInfo)
130
        {
131
            Contract.Requires(objectInfo!=null);
132

    
133
            return ;
134
        }
135

    
136

    
137
        public IList<ObjectInfo> ListObjects(string account, string container, DateTime? since = null)
138
        {
139
            
140
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
141
            Contract.Requires(StorageUrl != null);
142
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
143

    
144
            return default(IList<ObjectInfo>);
145
        }
146

    
147
        public IList<ObjectInfo> ListObjects(string account, string container, string folder, DateTime? since = null)
148
        {
149
            
150
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
151
            Contract.Requires(StorageUrl != null);
152
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
153
            Contract.Requires(!String.IsNullOrWhiteSpace(folder));
154

    
155
            return default(IList<ObjectInfo>);
156
        }
157

    
158
        public bool ContainerExists(string account, string container)
159
        {
160
            
161
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
162
            Contract.Requires(StorageUrl!=null);
163
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
164

    
165
            return default(bool);
166
        }
167

    
168
        public ContainerInfo GetContainerInfo(string account, string container)
169
        {
170
            
171
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
172
            Contract.Requires(StorageUrl!=null);
173
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
174

    
175
            return default(ContainerInfo);
176
        }
177

    
178
        public void CreateContainer(string account, string container)
179
        {
180
            
181
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
182
            Contract.Requires(StorageUrl!=null);
183
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
184
        }
185

    
186
        public void DeleteContainer(string account, string container)
187
        {
188
            
189
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
190
            Contract.Requires(StorageUrl!=null);
191
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
192
        }
193

    
194
        public Task GetObject(string account, string container, string objectName, string fileName)
195
        {
196
            
197
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
198
            Contract.Requires(StorageUrl!=null);
199
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
200
            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
201

    
202
            return default(Task);
203
        }
204

    
205
        public Task PutObject(string account, string container, string objectName, string fileName, string hash = null)
206
        {
207
            
208
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
209
            Contract.Requires(StorageUrl!=null);
210
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
211
            Contract.Requires(!String.IsNullOrWhiteSpace(fileName));                        
212
            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
213

    
214
            return default(Task);
215
        }
216

    
217
        public void DeleteObject(string account, string container, string objectName)
218
        {
219
            
220
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
221
            Contract.Requires(StorageUrl!=null);
222
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
223
            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));            
224
        }
225

    
226
        public void MoveObject(string account, string sourceContainer, string oldObjectName, string targetContainer, string newObjectName)
227
        {
228
            
229
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
230
            Contract.Requires(StorageUrl!=null);
231
            Contract.Requires(!String.IsNullOrWhiteSpace(sourceContainer));
232
            Contract.Requires(!String.IsNullOrWhiteSpace(oldObjectName));
233
            Contract.Requires(!String.IsNullOrWhiteSpace(targetContainer));
234
            Contract.Requires(!String.IsNullOrWhiteSpace(newObjectName));
235
        }
236

    
237
        public bool ObjectExists(string account, string container, string objectName)
238
        {
239
            
240
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
241
            Contract.Requires(StorageUrl!=null);
242
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
243
            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
244

    
245
            return default(bool);
246
        }
247

    
248
        public ObjectInfo GetObjectInfo(string account, string container, string objectName)
249
        {
250
            
251
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
252
            Contract.Requires(StorageUrl!=null);
253
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
254
            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
255

    
256
            return default(ObjectInfo);
257
        }
258

    
259
        public void CreateFolder(string account, string container, string folder)
260
        {
261
            
262
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
263
            Contract.Requires(StorageUrl != null);
264
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
265
            Contract.Requires(!String.IsNullOrWhiteSpace(folder));            
266
        }
267

    
268
        public Task<TreeHash> GetHashMap(string account, string container, string objectName)
269
        {
270
            
271
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
272
            Contract.Requires(StorageUrl != null);
273
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
274
            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
275

    
276
            return default(Task<TreeHash>);
277
        }
278

    
279
        public Task<IList<string>> PutHashMap(string account, string container, string objectName, TreeHash hash)
280
        {
281
            
282
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
283
            Contract.Requires(StorageUrl != null);
284
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
285
            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
286
            Contract.Requires(hash != null);
287

    
288
            return default(Task<IList<string>>);
289
        }
290

    
291
        public Task PostBlock(string account, string container, byte[] block, int offset, int count)
292
        {
293
            
294
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
295
            Contract.Requires(StorageUrl != null);
296
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
297
            Contract.Requires(block != null);
298
            Contract.Requires(offset>=0);
299
            Contract.Requires(offset < block.Length);
300
            Contract.Requires(count>=0);
301
            Contract.Requires(count <= block.Length);
302
            
303
            return default(Task);
304
        }
305

    
306
        public Task<byte[]> GetBlock(string account, string container, Uri relativeUrl, long start, long? end)
307
        {
308
            
309
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
310
            Contract.Requires(StorageUrl != null);
311
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
312
            Contract.Requires(relativeUrl!=null);
313
            Contract.Requires(start>=0);
314
            Contract.Requires(end==null || end>=0);
315

    
316
            return default(Task<byte[]>);
317
        }
318

    
319
    }
320
}