public Task DeleteMessage(CloudQueueMessage message, QueueRequestOptions options = null, OperationContext operationContext = null, CancellationToken? cancellationToken = null)
{
return AsyncTaskUtil.RunAsyncCancellable(
_inner.BeginDeleteMessage(message, options, operationContext, null, null),
_inner.EndDeleteMessage,
cancellationToken);
}
public Task Create(QueueRequestOptions options = null, OperationContext operationContext = null, CancellationToken? cancellationToken = null)
{
return AsyncTaskUtil.RunAsyncCancellable(
_inner.BeginCreate(options, operationContext, null, null),
_inner.EndCreate,
cancellationToken);
}
public Task<bool> DeleteIfExists(QueueRequestOptions options = null, OperationContext operationContext = null, CancellationToken? cancellationToken = null)
{
return AsyncTaskUtil.RunAsyncCancellable<bool>(
_inner.BeginDeleteIfExists(options, operationContext, null, null),
_inner.EndDeleteIfExists,
cancellationToken);
}
IDictionary<string, EntityProperty> ITableEntity.WriteEntity(OperationContext operationContext)
{
return new Dictionary<string, EntityProperty>
{
{ "SerializedError", EntityProperty.GeneratePropertyForString(this.SerializedError) }
};
}
public Task AddMessage(CloudQueueMessage message, TimeSpan? timeToLive = null, TimeSpan? initialVisibilityDelay = null, QueueRequestOptions options = null, OperationContext operationContext = null, CancellationToken? cancellationToken = null)
{
return AsyncTaskUtil.RunAsyncCancellable(
_inner.BeginAddMessage(message, timeToLive, initialVisibilityDelay, options, operationContext, null, null),
_inner.EndAddMessage,
cancellationToken);
}
public void TableGenericQueryEnumerateTwice()
{
TableQuery<BaseEntity> query = new TableQuery<BaseEntity>();
OperationContext opContext = new OperationContext();
IEnumerable<BaseEntity> enumerable = currentTable.ExecuteQuery(query);
List<BaseEntity> firstIteration = new List<BaseEntity>();
List<BaseEntity> secondIteration = new List<BaseEntity>();
foreach (BaseEntity ent in enumerable)
{
Assert.IsTrue(ent.PartitionKey.StartsWith("tables_batch"));
ent.Validate();
firstIteration.Add(ent);
}
foreach (BaseEntity ent in enumerable)
{
Assert.IsTrue(ent.PartitionKey.StartsWith("tables_batch"));
ent.Validate();
secondIteration.Add(ent);
}
Assert.AreEqual(firstIteration.Count, secondIteration.Count);
for (int m = 0; m < firstIteration.Count; m++)
{
Assert.AreEqual(firstIteration[m].PartitionKey, secondIteration[m].PartitionKey);
Assert.AreEqual(firstIteration[m].RowKey, secondIteration[m].RowKey);
Assert.AreEqual(firstIteration[m].Timestamp, secondIteration[m].Timestamp);
Assert.AreEqual(firstIteration[m].ETag, secondIteration[m].ETag);
firstIteration[m].Validate();
}
}
private Task<BlobResultSegment> ListBlobsSegmented(string prefix, bool useFlatBlobListing, BlobListingDetails blobListingDetails, int? maxResults, BlobContinuationToken continuationToken, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken = default(CancellationToken))
{
return AsyncTaskUtil.RunAsyncCancellable<BlobResultSegment>(
_inner.BeginListBlobsSegmented(prefix, useFlatBlobListing, blobListingDetails, maxResults, continuationToken, options, operationContext, null, null),
_inner.EndListBlobsSegmented,
cancellationToken);
}
private Task<ContainerResultSegment> ListContainersSegmented(string prefix, ContainerListingDetails detailsIncluded, int? maxResults, BlobContinuationToken continuationToken, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken = default(CancellationToken))
{
return AsyncTaskUtil.RunAsyncCancellable<ContainerResultSegment>(
_inner.BeginListContainersSegmented(prefix, detailsIncluded, maxResults, continuationToken, options, operationContext, null, null),
_inner.EndListContainersSegmented,
cancellationToken);
}
// GET: /Subscribe/
public async Task<ActionResult> Index(string id, string listName)
{
// We get to this method when they click on the Confirm link in the
// email that's sent to them after the subscribe service method is called.
TableRequestOptions reqOptions = new TableRequestOptions()
{
MaximumExecutionTime = TimeSpan.FromSeconds(1.5),
RetryPolicy = new LinearRetry(TimeSpan.FromSeconds(3), 3)
};
string filter = TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, listName),
TableOperators.And,
TableQuery.GenerateFilterCondition("SubscriberGUID", QueryComparisons.Equal, id));
var query = new TableQuery<Subscriber>().Where(filter);
TableContinuationToken token = null;
OperationContext ctx = new OperationContext() { ClientRequestID = "" };
TableQuerySegment<Subscriber> currentSegment = null;
currentSegment = await mailingListTable.ExecuteQuerySegmentedAsync(query, token, reqOptions, ctx);
var subscriber = currentSegment.Results.ToList().Single();
//subscriberTableRow.Status = "Verified";
subscriber.Verified = true;
var replaceOperation = TableOperation.Merge(subscriber);
mailingListTable.Execute(replaceOperation);
var newSubscriber = new SubscribeVM();
newSubscriber.EmailAddress = subscriber.EmailAddress;
var mailingList = await FindRowAsync(subscriber.ListName, "mailinglist");
newSubscriber.ListDescription = mailingList.Description;
return View(newSubscriber);
}
/// <summary>
/// Generates a web request to return the user-defined metadata for this container.
/// </summary>
/// <param name="uri">The absolute URI to the container.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage GetMetadata(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder();
HttpRequestMessage request = HttpRequestMessageFactory.GetMetadata(uri, timeout, containerBuilder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return request;
}
public Task<ServiceProperties> GetServiceProperties(BlobRequestOptions requestOptions = null, OperationContext operationContext = null, CancellationToken cancellationToken = default(CancellationToken))
{
return AsyncTaskUtil.RunAsyncCancellable<ServiceProperties>(
_inner.BeginGetServiceProperties(requestOptions, operationContext, null, null),
_inner.EndGetServiceProperties,
cancellationToken);
}
/// <summary>
/// Generates a web request to return the user-defined metadata for this container.
/// </summary>
/// <param name="uri">The absolute URI to the container.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static StorageRequestMessage GetMetadata(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
{
UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder();
StorageRequestMessage request = HttpRequestMessageFactory.GetMetadata(uri, timeout, containerBuilder, content, operationContext, canonicalizer, credentials);
request.ApplyAccessCondition(accessCondition);
return request;
}
public void WriteEntityContactMessage()
{
var msg = new ContactMessage
{
From = new Contact
{
ContactId = "A",
DisplayName = "Bob"
},
To = new Contact
{
ContactId = "B",
DisplayName = "Jane"
},
MessageBody = "Test"
};
var context = new OperationContext();
var proxy = new TableEntityProxy<ContactMessage>(msg);
var props = proxy.WriteEntity(context);
Assert.AreEqual("A", props["FromContactId"].StringValue);
Assert.AreEqual("Bob", props["FromDisplayName"].StringValue);
Assert.AreEqual("B", props["ToContactId"].StringValue);
Assert.AreEqual("Jane", props["ToDisplayName"].StringValue);
}
//
// GET: /MailingList/
public async Task<ActionResult> Index()
{
List<MailingList> lists = new List<MailingList>();
try
{
// This code gets all rows; for a production app implement paging
// to avoid executing an unbounded query that might return too many rows.
var query = new TableQuery<MailingList>().Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, "mailinglist"));
TableContinuationToken token = null;
OperationContext ctx = new OperationContext();
TableQuerySegment<MailingList> currentSegment = null;
while (currentSegment == null || currentSegment.ContinuationToken != null)
{
currentSegment = await mailingListTable.ExecuteQuerySegmentedAsync(query, token, webUIRetryPolicy, ctx);
lists.AddRange(currentSegment.Results);
token = currentSegment.ContinuationToken;
}
}
catch (StorageException se)
{
ViewBag.errorMessage = "Timeout error, try again. ";
Trace.TraceError(se.Message);
return View("Error");
}
return View(lists);
}
/// <summary>
/// Generates a web request to return the properties and user-defined metadata for this directory.
/// </summary>
/// <param name="uri">The absolute URI to the directory.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage GetProperties(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder directoryBuilder = GetDirectoryUriQueryBuilder();
HttpRequestMessage request = HttpRequestMessageFactory.GetProperties(uri, timeout, directoryBuilder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return request;
}
public void ReadEntity(IDictionary<string, EntityProperty> properties, OperationContext operationContext)
{
foreach (var item in properties)
{
SetProperProperty(item.Key, item.Value.PropertyAsObject);
}
}
/// <summary>
/// Sends the given <see cref="TransportMessage"/> to the queue with the specified globally addressable name
/// </summary>
public async Task Send(string destinationAddress, TransportMessage message, ITransactionContext context)
{
context.OnCommitted(async () =>
{
var headers = message.Headers.Clone();
var queue = GetQueue(destinationAddress);
var messageId = Guid.NewGuid().ToString();
var popReceipt = Guid.NewGuid().ToString();
var timeToBeReceivedOrNull = GetTimeToBeReceivedOrNull(headers);
var queueVisibilityDelayOrNull = GetQueueVisibilityDelayOrNull(headers);
var cloudQueueMessage = Serialize(messageId, popReceipt, headers, message.Body);
try
{
var options = new QueueRequestOptions {RetryPolicy = new ExponentialRetry()};
var operationContext = new OperationContext();
await queue.AddMessageAsync(cloudQueueMessage, timeToBeReceivedOrNull, queueVisibilityDelayOrNull, options, operationContext);
}
catch (Exception exception)
{
throw new RebusApplicationException(exception, $"Could not send message with ID {cloudQueueMessage.Id} to '{destinationAddress}'");
}
});
}
public override void ReadEntity(IDictionary<string,EntityProperty> properties, OperationContext operationContext)
{
base.ReadEntity(properties, operationContext);
try
{
if ((this.EncryptionVersion.HasValue && this.EncryptionVersion.Value > 0))
{
AzureTableCrypto.Get().DecryptObject(this.EncryptionVersion.Value, this);
}
}
catch (FormatException fe)
{
//FormatException gets thrown when the data is not properly Base-64 encoded
throw new AzureTableCryptoDecryptionException(this, "Error decrypting table service entity", fe);
}
catch (CryptographicException ce)
{
throw new AzureTableCryptoDecryptionException(this, "Error decrypting table service entity", ce);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
public Task SetServiceProperties(ServiceProperties properties, BlobRequestOptions requestOptions = null, OperationContext operationContext = null, CancellationToken cancellationToken = default(CancellationToken))
{
return AsyncTaskUtil.RunAsyncCancellable(
_inner.BeginSetServiceProperties(properties, requestOptions, operationContext, null, null),
_inner.EndSetServiceProperties,
cancellationToken);
}
public BlobResultSegment ListBlobsSegmented(string prefix, bool useFlatListing, BlobListingDetails blobListingDetails,
int? maxResults, BlobContinuationToken continuationToken, BlobRequestOptions blobRequestOptions,
OperationContext operationContext)
{
return _client.ListBlobsSegmented(prefix, useFlatListing, blobListingDetails, maxResults, continuationToken,
blobRequestOptions, operationContext);
}
/// <summary>
/// Constructs a web request to delete the share and all of the files within it.
/// </summary>
/// <param name="uri">The absolute URI to the share.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Delete(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder shareBuilder = GetShareUriQueryBuilder();
HttpRequestMessage request = HttpRequestMessageFactory.Delete(uri, timeout, shareBuilder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return request;
}
/// <summary>
/// Generates a web request to return the user-defined metadata for this share.
/// </summary>
/// <param name="uri">The absolute URI to the share.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <param name="useVersionHeader">A flag indicating whether to set the x-ms-version HTTP header.</param>
/// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpWebRequest GetMetadata(Uri uri, int? timeout, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
{
UriQueryBuilder shareBuilder = GetShareUriQueryBuilder();
HttpWebRequest request = HttpWebRequestFactory.GetMetadata(uri, timeout, shareBuilder, useVersionHeader, operationContext);
request.ApplyAccessCondition(accessCondition);
return request;
}
public override IDictionary<string, EntityProperty> WriteEntity(OperationContext operationContext)
{
string serializedHistoryEvent = JsonConvert.SerializeObject(HistoryEvent,
new JsonSerializerSettings
{
Formatting = Formatting.Indented,
TypeNameHandling = TypeNameHandling.Objects
});
// replace with a generic event with the truncated history so at least we have some record
// note that this makes the history stored in the instance store unreplayable. so any replay logic
// that we build will have to especially check for this event and flag the orchestration as unplayable if it sees this event
if (!string.IsNullOrEmpty(serializedHistoryEvent) &&
serializedHistoryEvent.Length > FrameworkConstants.MaxStringLengthForAzureTableColumn)
{
serializedHistoryEvent = JsonConvert.SerializeObject(new GenericEvent(HistoryEvent.EventId,
serializedHistoryEvent.Substring(0, FrameworkConstants.MaxStringLengthForAzureTableColumn) + " ....(truncated)..]"),
new JsonSerializerSettings
{
Formatting = Formatting.Indented,
TypeNameHandling = TypeNameHandling.Objects
});
}
var retVals = new Dictionary<string, EntityProperty>();
retVals.Add("InstanceId", new EntityProperty(InstanceId));
retVals.Add("ExecutionId", new EntityProperty(ExecutionId));
retVals.Add("TaskTimeStamp", new EntityProperty(TaskTimeStamp));
retVals.Add("SequenceNumber", new EntityProperty(SequenceNumber));
retVals.Add("HistoryEvent", new EntityProperty(serializedHistoryEvent));
return retVals;
}
public List<ICatalogJob> GetAllCatalogJob(string organization)
{
string tableName = NameHelper.GetCatalogJobTableName(organization);
tableName = TableDataAccess.ValidateTableName(tableName);
TableDataAccess tableDataAccess = new TableDataAccess(TableClient);
CloudTable table = tableDataAccess.GetTable(tableName);
if (table == null)
return null;
TableQuery<CatalogEntity> query = new TableQuery<CatalogEntity>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, organization));
query.TakeCount = 100;
TableRequestOptions a = new TableRequestOptions();
OperationContext c = new OperationContext();
var queryResult = table.ExecuteQuery(query);
List<ICatalogJob> result = new List<ICatalogJob>(queryResult.Count());
foreach (CatalogEntity entity in queryResult)
{
CatalogEntity.SetOtherByPartitionRowKeys(entity);
result.Add(entity);
}
return result;
}
public static async Task<ReadOnlyCollection<IListBlobItem>> ListBlobsSegmentedAsync(
this CloudBlobDirectory container,
bool useFlatBlobListing,
int pageSize,
BlobListingDetails details,
BlobRequestOptions options,
OperationContext operationContext,
IProgress<IEnumerable<IListBlobItem>> progress = null,
CancellationToken cancellationToken = default(CancellationToken)) {
options = options ?? new BlobRequestOptions();
var results = new List<IListBlobItem>();
BlobContinuationToken continuation = null;
BlobResultSegment segment;
do {
segment = await Task.Factory.FromAsync(
(cb, state) => container.BeginListBlobsSegmented(useFlatBlobListing, details, pageSize, continuation, options, operationContext, cb, state).WithCancellation(cancellationToken),
ar => container.EndListBlobsSegmented(ar),
null);
if (progress != null) {
progress.Report(segment.Results);
}
results.AddRange(segment.Results);
continuation = segment.ContinuationToken;
} while (continuation != null);
return new ReadOnlyCollection<IListBlobItem>(results);
}
/// <summary>
/// Constructs a web request to delete the directory and all of the files within it.
/// </summary>
/// <param name="uri">The absolute URI to the directory.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <param name="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</param>
/// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param>
/// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
public static HttpWebRequest Delete(Uri uri, int? timeout, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
{
UriQueryBuilder directoryBuilder = GetDirectoryUriQueryBuilder();
HttpWebRequest request = HttpWebRequestFactory.Delete(uri, directoryBuilder, timeout, useVersionHeader, operationContext);
request.ApplyAccessCondition(accessCondition);
return request;
}
/// <summary>
/// Constructs a web request to delete the container and all of the blobs within it.
/// </summary>
/// <param name="uri">The absolute URI to the container.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpWebRequest Delete(Uri uri, int? timeout, AccessCondition accessCondition, OperationContext operationContext)
{
UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder();
HttpWebRequest request = HttpWebRequestFactory.Delete(uri, containerBuilder, timeout, operationContext);
request.ApplyAccessCondition(accessCondition);
return request;
}
public override void ReadEntity(IDictionary<string, EntityProperty> properties, OperationContext operationContext)
{
base.ReadEntity(properties, operationContext);
foreach (var item in properties)
{
if (item.Key == "snooze")
{
_isSnoozed = item.Value.PropertyType == EdmType.String ? bool.Parse(item.Value.StringValue) : item.Value.BooleanValue.Value;
continue;
}
var cp = int.Parse(item.Key.Substring(3));
if (item.Key.StartsWith("res"))
{
SetResistanceScore(cp, item.Value.PropertyType == EdmType.String ? int.Parse(item.Value.StringValue) : item.Value.Int32Value.Value);
}
else if (item.Key.StartsWith("enl"))
{
SetEnlightenedScore(cp, item.Value.PropertyType == EdmType.String ? int.Parse(item.Value.StringValue) : item.Value.Int32Value.Value);
}
else if (item.Key.StartsWith("kud"))
{
SetKudos(cp, item.Value.StringValue);
}
}
}
/// <summary>
/// Constructs a web request to delete the share and all of the files within it.
/// </summary>
/// <param name="uri">The absolute URI to the share.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static StorageRequestMessage Delete(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
{
UriQueryBuilder shareBuilder = GetShareUriQueryBuilder();
StorageRequestMessage request = HttpRequestMessageFactory.Delete(uri, timeout, shareBuilder, content, operationContext, canonicalizer, credentials);
request.ApplyAccessCondition(accessCondition);
return request;
}
public AzureStorageProvider(AzureProviderOptions options)
{
_blobClient = CloudStorageAccount
.Parse(options.ConnectionString)
.CreateCloudBlobClient(); ;
_requestOptions = new BlobRequestOptions();
_context = new OperationContext();
}
/// <summary>
/// Whether the blob is exists or not
/// </summary>
/// <param name="blob">An CloudBlob object</param>
/// <param name="options">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <returns>True if the specific blob exists, otherwise return false</returns>
public bool DoesBlobExist(CloudBlob blob, BlobRequestOptions options, XSCL.OperationContext operationContext)
{
if (null == blob)
{
return(false);
}
else
{
try
{
return(blob.ExistsAsync(options, operationContext).Result);
}
catch (AggregateException e) when(e.InnerException is XSCL.StorageException)
{
throw e.InnerException;
}
}
}
/// <summary>
/// List the blobs segmented in specified containers
/// </summary>
/// <param name="container">A cloudblobcontainer object</param>
/// <param name="prefix">Blob prefix</param>
/// <param name="useFlatBlobListing">Use flat blob listing(whether treat "container/" as directory)</param>
/// <param name="blobListingDetails">Blob listing details</param>
/// <param name="options">Blob request option</param>
/// <param name="operationContext">Operation context</param>
public Task <BlobResultSegment> ListBlobsSegmentedAsync(CloudBlobContainer container, string prefix, bool useFlatBlobListing, BlobListingDetails blobListingDetails, int?maxResults, BlobContinuationToken currentToken, BlobRequestOptions options, XSCL.OperationContext operationContext, CancellationToken cancellationToken)
{
return(container.ListBlobsSegmentedAsync(prefix, useFlatBlobListing, blobListingDetails, maxResults, currentToken, options, operationContext, cancellationToken));
}
/// List part of blobs.
/// </summary>
/// <param name="prefix">Blob prefix</param>
/// <param name="useFlatBlobListing">Use flat blob listing</param>
/// <param name="blobListingDetails">Blob listing details.</param>
/// <param name="maxResults">Max results.</param>
/// <param name="currentToken">Current token.</param>
/// <param name="options">Request options</param>
/// <param name="operationContext">Operation Context.</param>
/// <returns>BlobResultSegment object</returns>
public BlobResultSegment ListBlobsSegmented(CloudBlobContainer container, string prefix, bool useFlatBlobListing,
BlobListingDetails blobListingDetails, int?maxResults, BlobContinuationToken currentToken, BlobRequestOptions options, XSCL.OperationContext operationContext)
{
try
{
return(container.ListBlobsSegmentedAsync(prefix, useFlatBlobListing, blobListingDetails, maxResults, currentToken, options, operationContext).Result);
}
catch (AggregateException e) when(e.InnerException is XSCL.StorageException)
{
throw e.InnerException;
}
}
/// <summary>
/// Delete container
/// </summary>
/// <param name="container">A cloudblobcontainer object</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="options">Blob request option</param>
/// <param name="operationContext">Operation context</param>
public void DeleteContainer(CloudBlobContainer container, AccessCondition accessCondition, BlobRequestOptions options, XSCL.OperationContext operationContext)
{
try
{
Task.Run(() => container.DeleteAsync(accessCondition, options, operationContext)).Wait();
}
catch (AggregateException e) when(e.InnerException is XSCL.StorageException)
{
throw e.InnerException;
}
}
/// <summary>
/// Fetch blob attributes
/// </summary>
/// <param name="accessCondition">Access condition</param>
/// <param name="options">Blob request options</param>
/// <param name="operationContext">An object that represents the context for the current operation.</param>
public void FetchBlobAttributes(CloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, XSCL.OperationContext operationContext)
{
try
{
Task.Run(() => blob.FetchAttributesAsync(accessCondition, options, operationContext)).Wait();
}
catch (AggregateException e) when(e.InnerException is XSCL.StorageException)
{
throw e.InnerException;
}
}
/// <summary>
/// Get a list of cloudblobcontainer in azure
/// </summary>
/// <param name="prefix">Container prefix</param>
/// <param name="detailsIncluded">Container listing details</param>
/// <param name="options">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <returns>An enumerable collection of cloudblobcontainer</returns>
public IEnumerable <CloudBlobContainer> ListContainers(string prefix, ContainerListingDetails detailsIncluded, BlobRequestOptions options, XSCL.OperationContext operationContext)
{
//https://ahmet.im/blog/azure-listblobssegmentedasync-listcontainerssegmentedasync-how-to/
BlobContinuationToken continuationToken = null;
var results = new List <CloudBlobContainer>();
do
{
try
{
var response = BlobClient.ListContainersSegmentedAsync(prefix, detailsIncluded, null, continuationToken, options, operationContext).Result;
continuationToken = response.ContinuationToken;
results.AddRange(response.Results);
}
catch (AggregateException e) when(e.InnerException is XSCL.StorageException)
{
throw e.InnerException;
}
} while (continuationToken != null);
return(results);
}
/// <summary>
/// Set service properties
/// </summary>
/// <param name="account">Cloud storage account</param>
/// <param name="type">Service type</param>
/// <param name="properties">Service properties</param>
/// <param name="options">Request options</param>
/// <param name="operationContext">Operation context</param>
public void SetStorageServiceProperties(StorageServiceType type, XSCLProtocol.ServiceProperties properties, IRequestOptions options, XSCL.OperationContext operationContext)
{
XSCL.CloudStorageAccount account = StorageContext.StorageAccount;
try
{
switch (type)
{
case StorageServiceType.Blob:
Task.Run(() => account.CreateCloudBlobClient().SetServicePropertiesAsync(properties, (BlobRequestOptions)options, operationContext)).Wait();
break;
case StorageServiceType.Queue:
Task.Run(() => account.CreateCloudQueueClient().SetServicePropertiesAsync(properties, (QueueRequestOptions)options, operationContext)).Wait();
break;
case StorageServiceType.File:
if (null != properties.Logging)
{
throw new InvalidOperationException(Resources.FileNotSupportLogging);
}
FileServiceProperties fileServiceProperties = new FileServiceProperties();
fileServiceProperties.Cors = properties.Cors;
fileServiceProperties.HourMetrics = properties.HourMetrics;
fileServiceProperties.MinuteMetrics = properties.MinuteMetrics;
Task.Run(() => account.CreateCloudFileClient().SetServicePropertiesAsync(fileServiceProperties, (FileRequestOptions)options, operationContext)).Wait();
break;
default:
throw new ArgumentException(Resources.InvalidStorageServiceType, "type");
}
}
catch (AggregateException e) when(e.InnerException is XSCL.StorageException)
{
throw e.InnerException;
}
}
/// <summary>
/// Return a task that asynchronously abort the blob copy operation
/// </summary>
/// <param name="blob">CloudBlob object</param>
/// <param name="abortCopyId">Copy id</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="abortRequestOption">Blob request options</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return a task that asynchronously abort the blob copy operation</returns>
public Task AbortCopyAsync(CloudBlob blob, string copyId, AccessCondition accessCondition, BlobRequestOptions requestOptions, XSCL.OperationContext operationContext, CancellationToken cancellationToken)
{
return(blob.AbortCopyAsync(copyId, accessCondition, requestOptions, operationContext, cancellationToken));
}
/// <summary>
/// Return a task that asynchronously start copy operation to a PageBlob with PremiumPageBlobTier.
/// </summary>
/// <param name="blob">CloudPageBlob object</param>
/// <param name="source">Uri to copying source</param>
/// <param name="premiumPageBlobTier">The PremiumPageBlobTier of Destination blob</param>
/// <param name="sourceAccessCondition">Access condition to source if it's file/blob in azure.</param>
/// <param name="destAccessCondition">Access condition to Destination blob.</param>
/// <param name="options">Blob request options</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return copy id if succeeded.</returns>
public Task <string> StartCopyAsync(CloudPageBlob blob, Uri source, PremiumPageBlobTier premiumPageBlobTier, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, BlobRequestOptions options, XSCL.OperationContext operationContext, CancellationToken cancellationToken)
{
return(blob.StartCopyAsync(new CloudPageBlob(source), premiumPageBlobTier, sourceAccessCondition, destAccessCondition, options, operationContext, cancellationToken));
}
/// <summary>
/// Return a task that asynchronously create a container if it doesn't exist.
/// </summary>
/// <param name="container">CloudBlobContainer object</param>
/// <param name="accessType">Blob container public access type</param>
/// <param name="requestOptions">Blob request options</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return a task that asynchronously create a container if it doesn't exist.</returns>
public Task <bool> CreateContainerIfNotExistsAsync(CloudBlobContainer container, BlobContainerPublicAccessType accessType, BlobRequestOptions requestOptions, XSCL.OperationContext operationContext, CancellationToken cancellationToken)
{
return(container.CreateIfNotExistsAsync(accessType, requestOptions, operationContext, cancellationToken));
}
/// <summary>
/// Return a task that asynchronously delete the specified container.
/// </summary>
/// <param name="container">CloudBlobContainer object</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="requestOptions">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return a task that asynchronously delete the specified container.</returns>
public Task DeleteContainerAsync(CloudBlobContainer container, AccessCondition accessCondition, BlobRequestOptions requestOptions, XSCL.OperationContext operationContext, CancellationToken cancellationToken)
{
return(container.DeleteAsync(accessCondition, requestOptions, operationContext, cancellationToken));
}
/// <summary>
/// Delete azure blob
/// </summary>
/// <param name="blob">Cloudblob object</param>
/// <param name="deleteSnapshotsOption">Delete snapshots option</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="operationContext">Operation context</param>
/// <returns>An enumerable collection of CloudBlob</returns>
public void DeleteCloudBlob(CloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, XSCL.OperationContext operationContext)
{
try
{
Task.Run(() => blob.DeleteAsync(deleteSnapshotsOption, accessCondition, options, operationContext)).Wait();
}
catch (AggregateException e) when(e.InnerException is XSCL.StorageException)
{
throw e.InnerException;
}
}
void ITableEntity.ReadEntity(IDictionary <string, EntityProperty> properties, Microsoft.WindowsAzure.Storage.OperationContext operationContext)
{
// This can occasionally fail because someone didn't finish creating the entity yet.
EntityProperty value;
if (properties.TryGetValue("SerializedError", out value))
{
Error = ErrorXml.DecodeString(value.StringValue);
}
else
{
Error = new Error
{
ApplicationName = "TableErrorLog",
StatusCode = 999,
HostName = Environment.MachineName,
Time = DateTime.UtcNow,
Type = typeof(Exception).FullName,
Detail = "Error Log Entry is Corrupted/Missing in Table Store"
};
return;
}
if (properties.TryGetValue("Detail", out value))
{
Error.Detail = value.StringValue;
}
if (properties.TryGetValue("WebHostHtmlMessage", out value))
{
Error.WebHostHtmlMessage = value.StringValue;
}
}
/// <summary>
/// Return a task that asynchronously check whether the specified container exists.
/// </summary>
/// <param name="container">CloudBlobContainer object</param>
/// <param name="requestOptions">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>A task object that asynchronously check whether the specified container exists </returns>
public Task <bool> DoesContainerExistAsync(CloudBlobContainer container, BlobRequestOptions requestOptions, XSCL.OperationContext operationContext, CancellationToken cancellationToken)
{
return(container.ExistsAsync(requestOptions, operationContext, cancellationToken));
}
/// <summary>
/// Get a list of cloudblobcontainer in azure
/// </summary>
/// <param name="prefix">Container prefix</param>
/// <param name="detailsIncluded">Container listing details</param>
/// <param name="options">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <returns>An enumerable collection of cloudblobcontainer</returns>
public ContainerResultSegment ListContainersSegmented(string prefix, ContainerListingDetails detailsIncluded, int?maxResults, BlobContinuationToken currentToken, BlobRequestOptions options, XSCL.OperationContext operationContext)
{
try
{
return(this.BlobClient.ListContainersSegmentedAsync(prefix, detailsIncluded, maxResults, currentToken, options, operationContext).Result);
}
catch (AggregateException e) when(e.InnerException is XSCL.StorageException)
{
throw e.InnerException;
}
}
/// <summary>
/// Return a task that asynchronously set the container permission
/// </summary>
/// <param name="container">CloudBlobContainer object</param>
/// <param name="permissions">Container permission</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="requestOptions">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">cancellation token</param>
/// <returns>Return a task that asynchronously set the container permission</returns>
public Task SetContainerPermissionsAsync(CloudBlobContainer container, BlobContainerPermissions permissions, AccessCondition accessCondition, BlobRequestOptions requestOptions, XSCL.OperationContext operationContext, CancellationToken cancellationToken)
{
return(container.SetPermissionsAsync(permissions, accessCondition, requestOptions, operationContext, cancellationToken));
}
/// <summary>
/// Return a task that asynchronously start copy operation to a blob.
/// </summary>
/// <param name="blob">CloudBlob object</param>
/// <param name="source">Uri to copying source</param>
/// <param name="sourceAccessCondition">Access condition to source if it's file/blob in azure.</param>
/// <param name="destAccessCondition">Access condition to Destination blob.</param>
/// <param name="options">Blob request options</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return copy id if succeeded.</returns>
public Task <string> StartCopyAsync(CloudBlob blob, Uri source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, BlobRequestOptions options, XSCL.OperationContext operationContext, CancellationToken cancellationToken)
{
return(blob.StartCopyAsync(source, sourceAccessCondition, destAccessCondition, options, operationContext, cancellationToken));
}
/// <summary>
/// List all blobs in specified containers
/// </summary>
/// <param name="container">A cloudblobcontainer object</param>
/// <param name="prefix">Blob prefix</param>
/// <param name="useFlatBlobListing">Use flat blob listing(whether treat "container/" as directory)</param>
/// <param name="blobListingDetails">Blob listing details</param>
/// <param name="options">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <returns>An enumerable collection of CloudBlob</returns>
public IEnumerable <IListBlobItem> ListBlobs(CloudBlobContainer container, string prefix, bool useFlatBlobListing, BlobListingDetails blobListingDetails, BlobRequestOptions options, XSCL.OperationContext operationContext)
{
//https://ahmet.im/blog/azure-listblobssegmentedasync-listcontainerssegmentedasync-how-to/
BlobContinuationToken continuationToken = null;
var results = new List <IListBlobItem>();
do
{
var response = container.ListBlobsSegmentedAsync(prefix, useFlatBlobListing, blobListingDetails, null, continuationToken, options, operationContext).Result;
continuationToken = response.ContinuationToken;
results.AddRange(response.Results);
} while (continuationToken != null);
return(results);
}
/// <summary>
/// Return a task that asynchronously start Incremental copy operation to a page blob.
/// </summary>
/// <param name="blob">Dest CloudPageBlob object</param>
/// <param name="source">Source Page Blob snapshot</param>
/// <param name="destAccessCondition">Access condition to Destination blob.</param>
/// <param name="options">Blob request options</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return copy id if succeeded.</returns>
public Task <string> StartIncrementalCopyAsync(CloudPageBlob blob, CloudPageBlob source, AccessCondition destAccessCondition, BlobRequestOptions options, XSCL.OperationContext operationContext, CancellationToken cancellationToken)
{
return(blob.StartIncrementalCopyAsync(source, destAccessCondition, options, operationContext, cancellationToken));
}
/// <summary>
/// Set container permissions
/// </summary>
/// <param name="container">A cloudblobcontainer object</param>
/// <param name="permissions">The container's permission</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="options">Blob request option</param>
/// <param name="operationContext">Operation context</param>
public void SetContainerPermissions(CloudBlobContainer container, BlobContainerPermissions permissions, AccessCondition accessCondition, BlobRequestOptions options, XSCL.OperationContext operationContext)
{
try
{
Task.Run(() => container.SetPermissionsAsync(permissions, accessCondition, options, operationContext)).Wait();
}
catch (AggregateException e) when(e.InnerException is XSCL.StorageException)
{
throw e.InnerException;
}
}
/// <summary>
/// Return a task that asynchronously delete the specified blob
/// </summary>
/// <param name="blob">CloudBlob object</param>
/// <param name="deleteSnapshotsOption">Snapshot delete option</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="requestOptions">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return a task that asynchronously delete the specified blob</returns>
public Task DeleteCloudBlobAsync(CloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions requestOptions, XSCL.OperationContext operationContext, CancellationToken cancellationToken)
{
return(blob.DeleteAsync(deleteSnapshotsOption, accessCondition, requestOptions, operationContext, cancellationToken));
}
/// <summary>
/// Get the service properties
/// </summary>
/// <param name="account">Cloud storage account</param>
/// <param name="type">Service type</param>
/// <param name="options">Request options</param>
/// <param name="operationContext">Operation context</param>
/// <returns>The service properties of the specified service type</returns>
public XSCLProtocol.ServiceProperties GetStorageServiceProperties(StorageServiceType type, IRequestOptions options, XSCL.OperationContext operationContext)
{
XSCL.CloudStorageAccount account = StorageContext.StorageAccount;
try
{
switch (type)
{
case StorageServiceType.Blob:
return(account.CreateCloudBlobClient().GetServicePropertiesAsync((BlobRequestOptions)options, operationContext).Result);
case StorageServiceType.Queue:
return(account.CreateCloudQueueClient().GetServicePropertiesAsync((QueueRequestOptions)options, operationContext).Result);
case StorageServiceType.File:
FileServiceProperties fileServiceProperties = account.CreateCloudFileClient().GetServicePropertiesAsync((FileRequestOptions)options, operationContext).Result;
XSCLProtocol.ServiceProperties sp = new XSCLProtocol.ServiceProperties();
sp.Clean();
sp.Cors = fileServiceProperties.Cors;
sp.HourMetrics = fileServiceProperties.HourMetrics;
sp.MinuteMetrics = fileServiceProperties.MinuteMetrics;
return(sp);
default:
throw new ArgumentException(Resources.InvalidStorageServiceType, "type");
}
}
catch (AggregateException e) when(e.InnerException is XSCL.StorageException)
{
throw e.InnerException;
}
}
/// <summary>
/// Get blob reference with properties and meta data from server
/// </summary>
/// <param name="container">A cloudblobcontainer object</param>
/// <param name="blobName">Blob name</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="options">Blob request options</param>
/// <param name="operationContext">Operation context</param>
/// <returns>Return an CloudBlob if the specific blob exists on azure, otherwise return null</returns>
public CloudBlob GetBlobReferenceFromServer(CloudBlobContainer container, string blobName, AccessCondition accessCondition, BlobRequestOptions options, XSCL.OperationContext operationContext, DateTimeOffset?SnapshotTime = null)
{
try
{
CloudBlob blob = Util.GetBlobReferenceFromServer(container, blobName, accessCondition, options, operationContext, SnapshotTime);
return(blob);
}
catch (XSCL.StorageException e)
{
if (e.IsNotFoundException())
{
return(null);
}
else
{
throw;
}
}
}
/// <summary>
/// Return a task that asynchronously check whether the specified blob exists.
/// </summary>
/// <param name="blob">CloudBlob object</param>
/// <param name="options">Blob request options</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>A task object that asynchronously check whether the specified blob exists.</returns>
public Task <bool> DoesBlobExistAsync(CloudBlob blob, BlobRequestOptions options, XSCL.OperationContext operationContext, CancellationToken cmdletCancellationToken)
{
return(blob.ExistsAsync(options, operationContext, cmdletCancellationToken));
}
/// <summary>
/// Return a task that asynchronously set blob meta data
/// </summary>
/// <param name="blob">CloudBlob object</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="options">Blob request options</param>
/// <param name="operationContext">An object that represents the context for the current operation.</param>
public Task SetBlobMetadataAsync(CloudBlob blob, AccessCondition accessCondition,
BlobRequestOptions options, XSCL.OperationContext operationContext, CancellationToken cmdletCancellationToken)
{
return(blob.SetMetadataAsync(accessCondition, options, operationContext, cmdletCancellationToken));
}
/// <summary>
/// Return a task that asynchronously set block blob Tier
/// </summary>
/// <param name="blob">CloudBlockBlob object</param>
/// <param name="tier">block blob Tier</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="options">Blob request options</param>
/// <param name="operationContext">An object that represents the context for the current operation.</param>
public Task SetPageBlobTierAsync(CloudPageBlob blob, PremiumPageBlobTier tier, BlobRequestOptions options, XSCL.OperationContext operationContext, CancellationToken cmdletCancellationToken)
{
return(blob.SetPremiumBlobTierAsync(tier, options, operationContext, cmdletCancellationToken));
}
/// <summary>
/// Return a task that asynchronously get the blob reference from server
/// </summary>
/// <param name="container">CloudBlobContainer object</param>
/// <param name="blobName">Blob name</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="options">Blob request options</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>A task object that asynchronously get the blob reference from server</returns>
public async Task <CloudBlob> GetBlobReferenceFromServerAsync(CloudBlobContainer container, string blobName, AccessCondition accessCondition, BlobRequestOptions options, XSCL.OperationContext operationContext, CancellationToken cancellationToken)
{
try
{
CloudBlob blob = container.GetBlobReference(blobName);
await blob.FetchAttributesAsync(accessCondition, options, operationContext, cancellationToken).ConfigureAwait(false);
return(Util.GetCorrespondingTypeBlobReference(blob));
}
catch (XSCL.StorageException e)
{
if (e.IsNotFoundException())
{
return(null);
}
else
{
throw;
}
}
}
/// <summary>
/// Set blob meta data
/// </summary>
/// <param name="blob">ICloud blob object</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="options">Blob request options</param>
/// <param name="operationContext">An object that represents the context for the current operation.</param>
public void SetBlobMetadata(CloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, XSCL.OperationContext operationContext)
{
try
{
Task.Run(() => blob.SetMetadataAsync(accessCondition, options, operationContext)).Wait();
}
catch (AggregateException e) when(e.InnerException is XSCL.StorageException)
{
throw e.InnerException;
}
}
/// <summary>
/// Abort copy operation on specified blob
/// </summary>
/// <param name="blob">CloudBlob object</param>
/// <param name="copyId">Copy id</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="options">Blob request options</param>
/// <param name="operationContext">Operation context</param>
public void AbortCopy(CloudBlob blob, string copyId, AccessCondition accessCondition, BlobRequestOptions options, XSCL.OperationContext operationContext)
{
try
{
Task.Run(() => blob.AbortCopyAsync(copyId, accessCondition, options, operationContext)).Wait();
}
catch (XSCL.StorageException e)
{
if (e.IsSuccessfulResponse())
{
//The abort operation is successful, although get an exception
return;
}
else
{
throw;
}
}
catch (AggregateException e) when(e.InnerException is XSCL.StorageException)
{
if (((XSCL.StorageException)e.InnerException).IsSuccessfulResponse())
{
//The abort operation is successful, although get an exception
return;
}
else
{
throw e.InnerException;
}
}
}
/// <summary>
/// Return a task that asynchronously fetch blob attributes
/// </summary>
/// <param name="blob">ICloud blob object</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="options">Blob request options</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return a task that asynchronously fetch blob attributes</returns>
public Task FetchBlobAttributesAsync(CloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, XSCL.OperationContext operationContext, CancellationToken cancellationToken)
{
return(blob.FetchAttributesAsync(accessCondition, options, operationContext, cancellationToken));
}
