/// <summary>
/// Initializes a new instance of the <see cref="SerializableFileRequestOptions"/> class.
/// </summary>
/// <param name="info">Serialization information.</param>
/// <param name="context">Streaming context.</param>
private SerializableFileRequestOptions(SerializationInfo info, StreamingContext context)
: base(info, context)
{
bool? disableContentMD5Validation = (bool?)info.GetValue(DisableContentMD5ValidationName, typeof(bool?));
TimeSpan? maximumExecutionTime = (TimeSpan?)info.GetValue(MaximumExecutionTimeName, typeof(TimeSpan?));
TimeSpan? serverTimeout = (TimeSpan?)info.GetValue(ServerTimeoutName, typeof(TimeSpan?));
bool? storeFileContentMD5 = (bool?)info.GetValue(StoreFileContentMD5Name, typeof(bool?));
bool? useTransactionalMD5 = (bool?)info.GetValue(UseTransactionalMD5Name, typeof(bool?));
if (null != disableContentMD5Validation
|| null != maximumExecutionTime
|| null != serverTimeout
|| null != storeFileContentMD5
|| null != useTransactionalMD5)
{
this.fileRequestOptions = Transfer_RequestOptions.DefaultFileRequestOptions;
this.fileRequestOptions.DisableContentMD5Validation = disableContentMD5Validation;
this.fileRequestOptions.MaximumExecutionTime = maximumExecutionTime;
this.fileRequestOptions.ServerTimeout = serverTimeout;
this.fileRequestOptions.StoreFileContentMD5 = storeFileContentMD5;
this.fileRequestOptions.UseTransactionalMD5 = useTransactionalMD5;
}
else
{
this.fileRequestOptions = null;
}
}
/// <inheritdoc />
public override Stream FileOpen(Database db, FileAccess fileAccess, ref string errorMessage, FileMode fileMode = FileMode.Open, bool excusiveAccess = false, int waitOverride = -1, bool signalError = true)
{
if (waitOverride == -1)
waitOverride = WaitForLockMilliseconds;
if (db.FileStream != null && ((db.FileStream.CanRead == false && fileAccess == FileAccess.Read) ||
(db.FileStream.CanWrite == false && (excusiveAccess || fileAccess == FileAccess.ReadWrite))))
{
db.FileStream.Dispose();
db.FileStream = null;
}
if (db.FileStream == null)
if (excusiveAccess)
{
CloudFile cloudFile = m_databaseDir.GetFileReference(db.FileInfo.Name);
FileRequestOptions fileRequestOptions = new FileRequestOptions();
fileRequestOptions.ServerTimeout = TimeSpan.FromMilliseconds(waitOverride);
fileRequestOptions.ParallelOperationThreadCount = 1;
if (fileAccess == FileAccess.Read)
db.FileStream = cloudFile.OpenRead(null, fileRequestOptions);
else
db.FileStream = cloudFile.OpenWrite(s_initialFileSize, null, fileRequestOptions);
//db.FileInfo, fileAccess, ref errorMessage, FileShare.None, fileMode, waitOverride, UseExternalStorageApi, signalError);
}
else
{
CloudFile cloudFile = m_databaseDir.GetFileReference(db.FileInfo.Name);
FileRequestOptions fileRequestOptions = new FileRequestOptions();
fileRequestOptions.ServerTimeout = TimeSpan.FromMilliseconds(waitOverride);
if (fileAccess == FileAccess.Read)
db.FileStream = cloudFile.OpenRead(null, fileRequestOptions);
else
db.FileStream = cloudFile.OpenWrite(s_initialFileSize, null, fileRequestOptions);
}
return db.FileStream;
}
public virtual ICancellableAsyncResult BeginOpenRead(AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
StorageAsyncResult<Stream> storageAsyncResult = new StorageAsyncResult<Stream>(callback, state);
operationContext = operationContext ?? new OperationContext();
ICancellableAsyncResult result = this.BeginFetchAttributes(
accessCondition,
options,
operationContext,
ar =>
{
try
{
this.EndFetchAttributes(ar);
storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously);
AccessCondition streamAccessCondition = AccessCondition.CloneConditionWithETag(accessCondition, this.Properties.ETag);
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient, false);
storageAsyncResult.Result = new FileReadStream(this, streamAccessCondition, modifiedOptions, operationContext);
storageAsyncResult.OnComplete();
}
catch (Exception e)
{
storageAsyncResult.OnComplete(e);
}
},
null /* state */);
storageAsyncResult.CancelDelegate = result.Cancel;
return storageAsyncResult;
}
public virtual void Create(FileRequestOptions requestOptions = null, OperationContext operationContext = null)
{
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(requestOptions, this.ServiceClient);
Executor.ExecuteSync(
this.CreateDirectoryImpl(modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext);
}
public virtual Stream OpenRead(AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null)
{
operationContext = operationContext ?? new OperationContext();
this.FetchAttributes(accessCondition, options, operationContext);
AccessCondition streamAccessCondition = AccessCondition.CloneConditionWithETag(accessCondition, this.Properties.ETag);
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient, false);
return new FileReadStream(this, streamAccessCondition, modifiedOptions, operationContext);
}
public static async Task<string> DownloadTextAsync(CloudFile file, Encoding encoding, AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null)
{
using (MemoryStream stream = new MemoryStream())
{
await file.DownloadToStreamAsync(stream, accessCondition, options, operationContext);
return encoding.GetString(stream.ToArray(), 0, (int)stream.Length);
}
}
public IAsyncAction CreateAsync(FileRequestOptions options, OperationContext operationContext)
{
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient);
return AsyncInfo.Run(async (token) => await Executor.ExecuteAsyncNullReturn(
this.CreateDirectoryImpl(modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
token));
}
public virtual Task CreateAsync(FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient);
return Task.Run(async() => await Executor.ExecuteAsyncNullReturn(
this.CreateDirectoryImpl(modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
cancellationToken), cancellationToken);
}
public virtual ICancellableAsyncResult BeginCreate(FileRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient);
return Executor.BeginExecuteAsync(
this.CreateDirectoryImpl(modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
callback,
state);
}
public static async Task UploadTextAsync(CloudFile file, string text, Encoding encoding, AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null)
{
byte[] textAsBytes = encoding.GetBytes(text);
using (MemoryStream stream = new MemoryStream())
{
stream.Write(textAsBytes, 0, textAsBytes.Length);
stream.Seek(0, SeekOrigin.Begin);
file.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2;
await file.UploadFromStreamAsync(stream, accessCondition, options, operationContext);
}
}
public IAsyncOperation<IRandomAccessStreamWithContentType> OpenReadAsync(AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
{
operationContext = operationContext ?? new OperationContext();
return AsyncInfo.Run<IRandomAccessStreamWithContentType>(async (token) =>
{
await this.FetchAttributesAsync(accessCondition, options, operationContext);
AccessCondition streamAccessCondition = AccessCondition.CloneConditionWithETag(accessCondition, this.Properties.ETag);
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient, false);
return new FileReadStreamHelper(this, streamAccessCondition, modifiedOptions, operationContext);
});
}
public Task FetchShareAttributesAsync(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
if (this.availableShareNames.Contains(share.Name))
{
return TaskEx.FromResult(true);
}
else
{
throw new MockupException("ShareNotExist");
}
}
public virtual Task<Stream> OpenReadAsync(AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
operationContext = operationContext ?? new OperationContext();
return Task.Run<Stream>(async () =>
{
await this.FetchAttributesAsync(accessCondition, options, operationContext);
AccessCondition streamAccessCondition = AccessCondition.CloneConditionWithETag(accessCondition, this.Properties.ETag);
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient, false);
return new FileReadStream(this, streamAccessCondition, modifiedOptions, operationContext);
}, cancellationToken);
}
public static async Task<IEnumerable<IListFileItem>> ListFilesAndDirectoriesAsync(CloudFileDirectory directory, int? maxResults, FileRequestOptions options, OperationContext operationContext)
{
List<IListFileItem> results = new List<IListFileItem>();
FileContinuationToken token = null;
do
{
FileResultSegment resultSegment = await directory.ListFilesAndDirectoriesSegmentedAsync(maxResults, token, options, operationContext);
results.AddRange(resultSegment.Results);
token = resultSegment.ContinuationToken;
}
while (token != null);
return results;
}
public void WindowsPhoneDoesNotSupportMD5()
{
FileRequestOptions options = new FileRequestOptions();
Assert.ThrowsException<NotSupportedException>(
() => options.DisableContentMD5Validation = false,
"MD5 flags should not work on Windows Phone");
Assert.ThrowsException<NotSupportedException>(
() => options.UseTransactionalMD5 = true,
"MD5 flags should not work on Windows Phone");
Assert.ThrowsException<NotSupportedException>(
() => options.StoreFileContentMD5 = true,
"MD5 flags should not work on Windows Phone");
}
public async Task EnumerateFilesAndDirectoriesAsync(CloudFileDirectory directory, Action<IListFileItem> enumerationAction, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
FileContinuationToken continuationToken = null;
do
{
var segment = await directory.ListFilesAndDirectoriesSegmentedAsync(null, continuationToken, options, operationContext, token);
foreach (var item in segment.Results)
{
enumerationAction(item);
}
continuationToken = segment.ContinuationToken;
}
while (continuationToken != null);
}
public Task EnumerateFilesAndDirectoriesAsync(CloudFileDirectory directory, Action<IListFileItem> enumerationAction, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
IListFileItem[] enumerationItems;
if (this.enumerationResults.TryGetValue(directory.Name, out enumerationItems))
{
foreach (var item in enumerationItems)
{
enumerationAction(item);
}
return TaskEx.FromResult(true);
}
else
{
throw new MockupException("DirectoryNotFound");
}
}
public async Task FileStoreContentMD5TestAsync()
{
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
StoreFileContentMD5 = false,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
StoreFileContentMD5 = true,
};
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file4");
using (Stream stream = new MemoryStream())
{
await file.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
await file.FetchAttributesAsync();
Assert.IsNotNull(file.Properties.ContentMD5);
file = share.GetRootDirectoryReference().GetFileReference("file5");
using (Stream stream = new MemoryStream())
{
await file.UploadFromStreamAsync(stream, null, optionsWithNoMD5, null);
}
await file.FetchAttributesAsync();
Assert.IsNull(file.Properties.ContentMD5);
file = share.GetRootDirectoryReference().GetFileReference("file6");
using (Stream stream = new MemoryStream())
{
await file.UploadFromStreamAsync(stream);
}
await file.FetchAttributesAsync();
Assert.IsNull(file.Properties.ContentMD5);
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FileReadStreamBase"/> class.
/// </summary>
/// <param name="file">File reference to read from</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the access conditions for the file. If <c>null</c>, no condition is used.</param>
/// <param name="options">An <see cref="FileRequestOptions"/> object that specifies additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
protected FileReadStreamBase(CloudFile file, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
{
if (options.UseTransactionalMD5.Value)
{
CommonUtility.AssertInBounds("StreamMinimumReadSizeInBytes", file.StreamMinimumReadSizeInBytes, 1, Constants.MaxRangeGetContentMD5Size);
}
this.file = file;
this.fileProperties = new FileProperties(file.Properties);
this.currentOffset = 0;
this.streamMinimumReadSizeInBytes = this.file.StreamMinimumReadSizeInBytes;
this.internalBuffer = new MultiBufferMemoryStream(file.ServiceClient.BufferManager);
this.accessCondition = accessCondition;
this.options = options;
this.operationContext = operationContext;
this.fileMD5 = (this.options.DisableContentMD5Validation.Value || string.IsNullOrEmpty(this.fileProperties.ContentMD5)) ? null : new MD5Wrapper();
this.lastException = null;
}
public IAsyncOperation<bool> CreateIfNotExistsAsync(FileRequestOptions options, OperationContext operationContext)
{
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient);
operationContext = operationContext ?? new OperationContext();
return AsyncInfo.Run(async (token) =>
{
bool exists = await this.ExistsAsync(modifiedOptions, operationContext).AsTask(token);
if (exists)
{
return false;
}
try
{
await this.CreateAsync(modifiedOptions, operationContext).AsTask(token);
return true;
}
catch (Exception)
{
if (operationContext.LastResult.HttpStatusCode == (int)HttpStatusCode.Conflict)
{
StorageExtendedErrorInformation extendedInfo = operationContext.LastResult.ExtendedErrorInformation;
if ((extendedInfo == null) ||
(extendedInfo.ErrorCode == FileErrorCodeStrings.ShareAlreadyExists))
{
return false;
}
else
{
throw;
}
}
else
{
throw;
}
}
});
}
/// <summary>
/// Initializes a new instance of the FileWriteStreamBase class for a file.
/// </summary>
/// <param name="file">File reference to write to.</param>
/// <param name="fileSize">Size of the file.</param>
/// <param name="createNew">Use <c>true</c> if the file is newly created, <c>false</c> otherwise.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the access conditions for the file. If <c>null</c>, no condition is used.</param>
/// <param name="options">An <see cref="FileRequestOptions"/> object that specifies additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
protected FileWriteStreamBase(CloudFile file, long fileSize, bool createNew, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
: base()
{
this.internalBuffer = new MultiBufferMemoryStream(file.ServiceClient.BufferManager);
this.currentOffset = 0;
this.accessCondition = accessCondition;
this.options = options;
this.operationContext = operationContext;
this.noPendingWritesEvent = new CounterEvent();
this.fileMD5 = this.options.StoreFileContentMD5.Value ? new MD5Wrapper() : null;
this.rangeMD5 = this.options.UseTransactionalMD5.Value ? new MD5Wrapper() : null;
this.parallelOperationSemaphore = new AsyncSemaphore(options.ParallelOperationThreadCount.Value);
this.lastException = null;
this.committed = false;
this.disposed = false;
this.currentFileOffset = 0;
this.file = file;
this.fileSize = fileSize;
this.streamWriteSizeInBytes = file.StreamWriteSizeInBytes;
this.newFile = createNew;
}
public IAsyncOperation<bool> CreateIfNotExistsAsync(FileRequestOptions options, OperationContext operationContext)
{
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient);
return AsyncInfo.Run(async (token) =>
{
bool exists = await Executor.ExecuteAsync(
this.ExistsImpl(modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
token);
if (exists)
{
return false;
}
try
{
await Executor.ExecuteAsync(
this.CreateDirectoryImpl(modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
token);
return true;
}
catch (StorageException e)
{
if ((e.RequestInformation.ExtendedErrorInformation != null) &&
(e.RequestInformation.ExtendedErrorInformation.ErrorCode == FileErrorCodeStrings.ResourceAlreadyExists))
{
return false;
}
else
{
throw;
}
}
});
}
public Task FetchDirectoryAttributesAsync(CloudFileDirectory directory, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
return(directory.FetchAttributesAsync(accessCondition, options, operationContext, token));
}
public Task AbortCopyAsync(CloudFile file, string copyId, AccessCondition accessCondition, FileRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
return(file.AbortCopyAsync(copyId, accessCondition, requestOptions, operationContext, cancellationToken));
}
public void SetShareProperties(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
{
share.SetProperties(accessCondition, options, operationContext);
}
public Task FetchShareAttributesAsync(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
return(share.FetchAttributesAsync(accessCondition, options, operationContext, token));
}
internal static ExecutionState <NullType> CreateTemporaryExecutionState(FileRequestOptions options)
{
throw new System.NotImplementedException();
}
public async Task <string> DownloadTextAsync(AccessCondition accessCondition, FileRequestOptions fileRequestOptions, OperationContext operationContext, CancellationToken token)
{
return(await cloudFileImplementation.DownloadTextAsync(accessCondition, fileRequestOptions, operationContext, token));
}
public void SetSharePermissions(CloudFileShare share, FileSharePermissions permissions,
AccessCondition accessCondition = null,
FileRequestOptions options = null, OperationContext operationContext = null)
{
throw new NotImplementedException();
}
public Task FetchShareAttributesAsync(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
if (this.availableShareNames.Contains(share.Name))
{
return(Task.FromResult(true));
}
else
{
throw new MockupException("ShareNotExist");
}
}
public Task EnumerateFilesAndDirectoriesAsync(CloudFileDirectory directory, Action <IListFileItem> enumerationAction, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
IListFileItem[] enumerationItems;
if (this.enumerationResults.TryGetValue(directory.Name, out enumerationItems))
{
foreach (var item in enumerationItems)
{
enumerationAction(item);
}
return(Task.FromResult(true));
}
else
{
throw new MockupException("DirectoryNotFound");
}
}
public void SetShareProperties(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
{
throw new NotImplementedException();
}
public void FetchShareAttributes(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
{
throw new NotImplementedException();
}
public Task AbortCopyAsync(CloudFile file, string copyId, AccessCondition accessCondition, FileRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task FetchDirectoryAttributesAsync(CloudFileDirectory directory, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
if (this.availableDirectoryNames.Contains(directory.Name))
{
return(Task.FromResult(true));
}
else
{
throw new MockupException("DirectoryNotFound");
}
}
public Task<bool> DirectoryExistsAsync(CloudFileDirectory directory, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return directory.ExistsAsync(options, operationContext, cancellationToken);
}
public Task CreateShareAsync(CloudFileShare share, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return share.CreateAsync(options, operationContext, cancellationToken);
}
public Task FetchShareAttributesAsync(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
return share.FetchAttributesAsync(accessCondition, options, operationContext, token);
}
public Task <bool> ExistsAsync(FileRequestOptions options, OperationContext operationContext)
{
return(cloudFileImplementation.ExistsAsync(options, operationContext, CancellationToken.None));
}
public void SetSharePermissions(CloudFileShare share, FileSharePermissions permissions,
AccessCondition accessCondition = null,
FileRequestOptions options = null, OperationContext operationContext = null)
{
share.SetPermissions(permissions, accessCondition, options, operationContext);
}
public Task <string> DownloadTextAsync(AccessCondition accessCondition, FileRequestOptions fileRequestOptions, OperationContext operationContext)
{
return(DownloadTextAsync(accessCondition, fileRequestOptions, operationContext, CancellationToken.None));
}
public Task DeleteFileAsync(CloudFile file, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return(Task.FromResult(true));
}
public async Task EnumerateSharesAsync(string prefix, ShareListingDetails detailsIncluded, Action <CloudFileShare> enumerationAction, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
FileContinuationToken continuationToken = null;
do
{
var segment = await this.Client.ListSharesSegmentedAsync(prefix, detailsIncluded, null, continuationToken, options, operationContext, token);
foreach (var item in segment.Results)
{
enumerationAction(item);
}
continuationToken = segment.ContinuationToken;
}while (continuationToken != null);
}
public Task CreateDirectoryAsync(CloudFileDirectory directory, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return(Task.FromResult(true));
}
public async Task EnumerateFilesAndDirectoriesAsync(CloudFileDirectory directory, Action <IListFileItem> enumerationAction, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
FileContinuationToken continuationToken = null;
do
{
var segment = await directory.ListFilesAndDirectoriesSegmentedAsync(null, continuationToken, options, operationContext, token);
foreach (var item in segment.Results)
{
enumerationAction(item);
}
continuationToken = segment.ContinuationToken;
}while (continuationToken != null);
}
public Task DeleteShareAsync(CloudFileShare share, DeleteShareSnapshotsOption deleteShareSnapshotsOption, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return(Task.FromResult(true));
}
public void FetchShareAttributes(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
{
share.FetchAttributes(accessCondition, options, operationContext);
}
public Task EnumerateSharesAsync(string prefix, ShareListingDetails detailsIncluded, Action <CloudFileShare> enumerationAction, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
foreach (var shareName in this.availableShareNames)
{
if (shareName.StartsWith(prefix))
{
enumerationAction(this.client.GetShareReference(shareName));
}
}
return(Task.FromResult(true));
}
public Task CreateShareAsync(CloudFileShare share, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return(Task.FromResult(share));
}
public Task DeleteFileAsync(CloudFile file, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return file.DeleteAsync(accessCondition, options, operationContext, cancellationToken);
}
public Task CreateDirectoryAsync(CloudFileDirectory directory, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return directory.CreateAsync(options, operationContext, cancellationToken);
}
public Task <bool> FileExistsAsync(CloudFile file, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return(Task.FromResult(true));
}
public Task<bool> FileExistsAsync(CloudFile file, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return file.ExistsAsync(options, operationContext, cancellationToken);
}
public async Task <bool> ExistsAsync(FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
return(await cloudFileImplementation.ExistsAsync(options, operationContext, token));
}
public Task DeleteDirectoryAsync(CloudFileDirectory directory, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return directory.DeleteAsync(accessCondition, options, operationContext, cancellationToken);
}
public Task <FileSharePermissions> GetSharePermissionsAsync(CloudFileShare share, AccessCondition accessCondition,
FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
private void GenerateFile(FileNode fileNode, CloudFile cloudFile, string parentPath)
{
this.CheckFileNode(fileNode);
string tempFileName = Guid.NewGuid().ToString();
string localFilePath = Path.Combine(parentPath, tempFileName);
DMLibDataHelper.CreateLocalFile(fileNode, localFilePath);
FileRequestOptions storeMD5Options = new FileRequestOptions()
{
RetryPolicy = DMLibTestConstants.DefaultRetryPolicy,
StoreFileContentMD5 = true,
MaximumExecutionTime = DMLibTestConstants.DefaultExecutionTimeOut
};
cloudFile.UploadFromFile(localFilePath, options: storeMD5Options);
if (null != fileNode.MD5 ||
null != fileNode.ContentType ||
null != fileNode.CacheControl ||
null != fileNode.ContentDisposition ||
null != fileNode.ContentEncoding ||
null != fileNode.ContentLanguage)
{
// set user defined MD5 to cloud file
cloudFile.Properties.ContentMD5 = fileNode.MD5;
cloudFile.Properties.ContentType = fileNode.ContentType;
cloudFile.Properties.CacheControl = fileNode.CacheControl;
cloudFile.Properties.ContentDisposition = fileNode.ContentDisposition;
cloudFile.Properties.ContentEncoding = fileNode.ContentEncoding;
cloudFile.Properties.ContentLanguage = fileNode.ContentLanguage;
cloudFile.SetProperties(options: HelperConst.DefaultFileOptions);
}
if (null != fileNode.SMBAttributes)
{
cloudFile.Properties.NtfsAttributes = fileNode.SMBAttributes;
cloudFile.Properties.CreationTime = fileNode.CreationTime;
cloudFile.Properties.LastWriteTime = fileNode.LastWriteTime;
cloudFile.SetProperties(options: HelperConst.DefaultFileOptions);
}
if (null != fileNode.PortableSDDL)
{
cloudFile.FilePermission = fileNode.PortableSDDL;
cloudFile.SetProperties(options: HelperConst.DefaultFileOptions);
}
if (null != fileNode.Metadata && fileNode.Metadata.Count > 0)
{
cloudFile.Metadata.Clear();
foreach (var metaData in fileNode.Metadata)
{
cloudFile.Metadata.Add(metaData);
}
cloudFile.SetMetadata(options: HelperConst.DefaultFileOptions);
}
this.BuildFileNode(cloudFile, fileNode);
}
public Task <bool> DirectoryExistsAsync(CloudFileDirectory directory, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return(Task.FromResult(this.availableDirectoryNames.Contains(directory.Name)));
}
public async Task EnumerateSharesAsync(string prefix, ShareListingDetails detailsIncluded, Action<CloudFileShare> enumerationAction, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
FileContinuationToken continuationToken = null;
do
{
var segment = await this.Client.ListSharesSegmentedAsync(prefix, detailsIncluded, null, continuationToken, options, operationContext, token);
foreach (var item in segment.Results)
{
enumerationAction(item);
}
continuationToken = segment.ContinuationToken;
}
while (continuationToken != null);
}
public FileSharePermissions GetSharePermissions(CloudFileShare share, AccessCondition accessCondition = null,
FileRequestOptions options = null, OperationContext operationContext = null)
{
return(share.GetPermissions(accessCondition, options, operationContext));
}
