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