private AzureTableQuery(CT.CloudTable table, IEncryptor decryptor, string filter, int?take) { _table = table; _decryptor = decryptor; _filter = filter; _take = take; }
public SensorAccess() { credentials = new StorageCredentials(_accountName, _key); storageAccount = new CloudStorageAccount(credentials, true); tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("AccelerometerTable"); }
public RegistrationKeyStorage(string connectionString) { var account = CloudStorageAccount.Parse(connectionString); var tableClient = account.CreateCloudTableClient(); _registrationKeysTable = tableClient.GetTableReference("RegistrationKeys"); _registrationKeysTable.CreateIfNotExists(); }
public TableElementViewModel(CloudTable table) { if (table == null) throw new ArgumentNullException(nameof(table)); _table = table; }
public Crawler() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["StorageConnectionString"]); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("crawlertable"); table.CreateIfNotExists(); datatable = tableClient.GetTableReference("datatable"); datatable.CreateIfNotExists(); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); urlQueue = queueClient.GetQueueReference("urlqueue"); urlQueue.CreateIfNotExists(); adminQueue = queueClient.GetQueueReference("adminqueue"); adminQueue.CreateIfNotExists(); alreadyVisitedUrls = new HashSet<String>(); disallowedUrls = new HashSet<String>(); errorUrls = new HashSet<String>(); tableSize = 0; totalUrls = 0; counter = 1; compareDate = DateTime.ParseExact("2015-04-01", "yyyy-MM-dd", CultureInfo.InvariantCulture); //Regex to check for valid html document rgx = new Regex(@"^[a-zA-Z0-9\-]+.?(htm|html)?$"); }
public LogSaver(string connectionString) { var account = CloudStorageAccount.Parse(connectionString); var client = account.CreateCloudTableClient(); _table = client.GetTableReference(TableName); _table.CreateIfNotExists(); }
protected override void Initialize(HttpControllerContext controllerContext) { base.Initialize(controllerContext); storageAccount = CloudStorageAccount.Parse("UseDevelopmentStorage=true"); var tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("people"); }
public StorageController() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); this.table = tableClient.GetTableReference(StorageController.TableName); this.table.CreateIfNotExists(); }
public StatusController() { var storage = ControllerUtil.CreateStorageAccount(); _testResultStorage = new TestResultStorage(storage); _testCacheStats = new TestCacheStats(_testResultStorage, storage.CreateCloudTableClient()); _testRunTable = storage.CreateCloudTableClient().GetTableReference(AzureConstants.TableNames.TestRunData); }
/// <summary> /// Constructor /// </summary> /// <param name="storageConnectionString">Storage account connection string</param> /// <param name="azureTablePrefix">The repository stores data in two tables called httprequestbycorrelationid and httprequestbydatedescending, if this parameter is not null and not whitespace then it is used as a prefix for those table names.</param> /// <param name="granularity">The level of granularity for data in the partition. On a low traffic site hourly or even daily can be useful, whereas busy sites minute or second are more useful.</param> public AzureHttpLoggerRepository(string storageConnectionString, string azureTablePrefix, LogByDateGranularityEnum granularity) { if (string.IsNullOrWhiteSpace(storageConnectionString)) throw new ArgumentNullException(nameof(storageConnectionString)); if (azureTablePrefix == null) { azureTablePrefix = ""; } CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnectionString); CloudTableClient client = storageAccount.CreateCloudTableClient(); _byCorrelationIdTable = client.GetTableReference(string.Concat(azureTablePrefix, RequestByCorrelationIdTableName)); _byDateTimeDescendingTable = client.GetTableReference(string.Concat(azureTablePrefix, RequestByDateTimeDescendingTableName)); _byCorrelationIdTable.CreateIfNotExists(); _byDateTimeDescendingTable.CreateIfNotExists(); switch (granularity) { case LogByDateGranularityEnum.Hour: _granularPartitionKeyFormat = "yyyy-MM-dd hh"; break; case LogByDateGranularityEnum.Day: _granularPartitionKeyFormat = "yyyy-MM-dd"; break; case LogByDateGranularityEnum.Minute: _granularPartitionKeyFormat = "yyyy-MM-dd hh:mm"; break; case LogByDateGranularityEnum.Second: _granularPartitionKeyFormat = "yyyy-MM-dd hh:mm:ss"; break; } }
private async Task ContactTableStorage() { CloudStorageAccount account = CloudStorageAccount.Parse(_storageConfig.TableConnectionString); CloudTableClient tableClient = account.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference(_storageConfig.MetadataTableName); await table.CreateIfNotExistsAsync(); }
//******************* //* * //* InitForInsert * //* * //******************* // Initialize dialog for inserting new records. public void InitForInsert(CloudTable table, Dictionary<String, bool> tableColumnNames) { this.IsAddNew = true; this.Table = table; this.Title = "Insert New Entity"; this.CmdInsertUpdateEntity.Content = new TextBlock() { Text = "Insert Entity" }; this.Heading.Text = "Enter fields and values for a new entity."; if (tableColumnNames != null) { foreach (KeyValuePair<String, bool> col in tableColumnNames) { switch(col.Key) { case "PartitionKey": case "RowKey": case "Timestamp": break; default: AddFieldRow(col.Key, "String", String.Empty); break; } } } }
public override bool OnStart() { ServicePointManager.DefaultConnectionLimit = Environment.ProcessorCount; // Read storage account configuration settings ConfigureDiagnostics(); Trace.TraceInformation("Initializing storage account in worker role B"); var storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); // Initialize queue storage Trace.TraceInformation("Creating queue client."); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); sendEmailQueue = queueClient.GetQueueReference("azuremailqueue"); subscribeQueue = queueClient.GetQueueReference("azuremailsubscribequeue"); // Initialize blob storage CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); blobContainer = blobClient.GetContainerReference("azuremailblobcontainer"); // Initialize table storage var tableClient = storageAccount.CreateCloudTableClient(); mailingListTable = tableClient.GetTableReference("mailinglist"); messageTable = tableClient.GetTableReference("message"); messagearchiveTable = tableClient.GetTableReference("messagearchive"); Trace.TraceInformation("WorkerB: Creating blob container, queue, tables, if they don't exist."); blobContainer.CreateIfNotExists(); sendEmailQueue.CreateIfNotExists(); subscribeQueue.CreateIfNotExists(); this.messageTable.CreateIfNotExists(); this.mailingListTable.CreateIfNotExists(); this.messagearchiveTable.CreateIfNotExists(); return base.OnStart(); }
public BatchInsertTests() { var account = Util.GetStorageAccount(); var client = account.CreateCloudTableClient(); _table = client.GetTableReference("BatchOperationTests"); _table.CreateIfNotExists(); }
public AzureTableStorageStatusTraceListener(String initializeData) : base(initializeData) { string connectionString = null; string tableName = "status"; if (initializeData != null) { foreach (String keyValuePair in initializeData.Split(',')) { String[] parts = keyValuePair.Split('*'); if (parts.Length == 2) { if (parts[0].Equals("tablestorage", StringComparison.InvariantCultureIgnoreCase)) { connectionString = parts[1].Trim(); } else if (parts[0].Equals("table", StringComparison.InvariantCultureIgnoreCase)) { tableName = parts[1].Trim(); } } } } if (String.IsNullOrWhiteSpace(connectionString)) { throw new ArgumentNullException("tablestorage", "The initializeData string must specify the Azure table storage connection string in the tablestorage field."); } this._storageAccount = CloudStorageAccount.Parse(connectionString); this._tableClient = this._storageAccount.CreateCloudTableClient(); this._table = this._tableClient.GetTableReference(tableName); this._table.CreateIfNotExists(); }
public Task OpenAsync(PartitionContext context) { /*client = new HttpClient(); client.DefaultRequestHeaders.Add("X-ZUMO-APPLICATION", APP_KEY_MOBILE_SERVICES); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); return Task.FromResult<object>(null);*/ var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); var tableClient = storageAccount.CreateCloudTableClient(); sensorLogTable = tableClient.GetTableReference("SensorLog"); //sensorLogTable = tableClient.GetTableReference("SensorLog" + context.Lease.PartitionId); // 閾値の取得 if (thresholdTempWarning == null) { var sensorConfigTable = tableClient.GetTableReference("SensorConfig"); var query = new TableQuery<SensorConfig>(); var configData = sensorConfigTable.ExecuteQuery(query); foreach (SensorConfig config in configData) { if (config.PartitionKey == "TemperatureWarning") { thresholdTempWarning = config.Threshold; System.Console.WriteLine("ThresholdTempWarning: " + thresholdTempWarning); } else if (config.PartitionKey == "TemperatureDanger") { thresholdTempDanger = config.Threshold; System.Console.WriteLine("ThresholdTempDanger: " + thresholdTempDanger); } } } return sensorLogTable.CreateIfNotExistsAsync(); }
public void EnsureConfigurationIsCurrent(string connectionString, string tableName) { if (string.IsNullOrWhiteSpace(connectionString)) return; if (string.IsNullOrWhiteSpace(tableName)) return; // if connection string or table name have changed, invalidate // the existing connection if (_connectionString != connectionString || _tableName != tableName) { Trace.TraceInformation("NLog.Extensions.AzureTableStorage connection information has changed."); Trace.TraceInformation("NLog.Extensions.AzureTableStorage will (re)initialize."); _cloudTable = null; } // _cloudTable may be null for two reasons: 1) it hasn't been initialized yet and 2) it was // cleared because connection information changed if(_cloudTable == null) { // re-initialize the storage manager. the target will now log to the newly specified // storage account and table Initialize(connectionString, tableName); } }
public AzureTableStorageEventSource Initialize(string connectionString) { var client = GetTableClient(connectionString); _table = client.GetTableReference("EventSource"); _table.CreateIfNotExists(); return this; }
async Task<CommandResult> DoInsert(CloudTable table, long n, Func<long, EntityNk[]> entityFactory) { var batchOperation = new TableBatchOperation(); foreach (var e in entityFactory(n)) { batchOperation.Insert(e); } var cresult = new CommandResult { Start = DateTime.UtcNow.Ticks }; var cbt = 0L; var context = GetOperationContext((t) => cbt = t); try { var results = await table.ExecuteBatchAsync(batchOperation, operationContext: context); cresult.Elapsed = cbt; } catch (Exception ex) { cresult.Elapsed = -1; Console.Error.WriteLine("Error DoInsert {0} {1}", n, ex.ToString()); } return cresult; }
public IEnumerable<CommandResult> Run(CloudTable table, int numberOfProcess, int parallelism = 0) { if (parallelism == 0) parallelism = System.Environment.ProcessorCount * 3; if(parallelism == 1) return Run(table, new Tuple<int, int>(0, numberOfProcess)); var sizeOfWorkload = numberOfProcess / parallelism + (numberOfProcess % parallelism == 0 ? 0 : 1); var chunker = Partitioner.Create(0, numberOfProcess, sizeOfWorkload); var results = new ConcurrentQueue<IList<CommandResult>>(); // Loop over the workload partitions in parallel. Parallel.ForEach(chunker, new ParallelOptions { MaxDegreeOfParallelism = parallelism }, (range) => results.Enqueue(Run(table, range)) ); var ret = new List<CommandResult>(); foreach (var l in results) ret.AddRange(l); return ret; #if BUG return results.Aggregate<IEnumerable<CommandResult>>((f, s) => { return f.Concat(s).AsEnumerable(); }); #endif }
public static void Main() { // string connectionString = //ConfigurationManager.ConnectionStrings["RootManageSharedAccessKey"].ConnectionString; // Action<BrokeredMessage> callback = x => // { // }; // var clients = new List<SubscriptionClient>(); // for (int i = 0; i < 5; i++) // { // var client = TopicClient.CreateFromConnectionString(connectionString, "signalr_topic_push_" + i); // client. // client.OnMessage(callback); // clients.Add(client); // } // Console.ReadLine(); //var ctx = GlobalHost.ConnectionManager.GetHubContext<yourhub>(); //ctx.Clients.Client(connectionId).< your method > var cloudStorage = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["DataStorage"].ConnectionString); var tableClient = cloudStorage.CreateCloudTableClient(); _tickEvents = tableClient.GetTableReference("tickevents"); _tickEvents.CreateIfNotExists(); var host = new JobHost(); var cancelToken = new WebJobsShutdownWatcher().Token; _eventHubClient = EventHubClient.CreateFromConnectionString(ConfigurationManager.ConnectionStrings["IotHubConnection"].ConnectionString, iotHubD2cEndpoint); var d2CPartitions = _eventHubClient.GetRuntimeInformation().PartitionIds; Task.WaitAll(d2CPartitions.Select(partition => ListenForEvent(host, partition, cancelToken)).ToArray(), cancelToken); host.RunAndBlock(); }
internal ConcurrencyConflictException(CloudTable table, Partition partition, string details) : base("Concurrent write detected for partition '{1}' which resides in table '{0}' located at {2}. See details below.\n{3}", table, partition, table.StorageUri, details) { Table = table; Partition = partition; }
public Batch(CloudTable table, List<TableEntity> entities, bool merge) { Entities = entities; Table = table; Merge = merge; TableBatchManager.LogInfo("Batch created"); }
protected RepositoryBase(string table) { var storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); var tableClient = storageAccount.CreateCloudTableClient(); _table = tableClient.GetTableReference(table); _table.CreateIfNotExists(); }
public AzureTableStorageProjectionMetaDataRepository Initialize(string connectionString) { var client = GetTableClient(connectionString); _table = client.GetTableReference("ProjectionMetaData"); _table.CreateIfNotExists(); return this; }
static VerificationLogger() { CloudStorageAccount storageAccount = CloudStorageAccount.DevelopmentStorageAccount; CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("MultiHostedEndpointsOutput"); table.CreateIfNotExists(); }
protected CloudCoreStoredTable(string accountSonnectionString = "") { SetAccount(accountSonnectionString); cloudTableClient = cloudStorageAccount.CreateCloudTableClient(); cloudTable = cloudTableClient.GetTableReference(GetType().Name.Replace("Entity", "").Replace("Table", "").ToLower()); cloudTable.CreateIfNotExists(); }
public StorageTableAccessor(CloudStorageAccount storageAccount) { CloudTableClient tableClient = new CloudTableClient(storageAccount.TableStorageUri, storageAccount.Credentials); this.table = tableClient.GetTableReference(messageTableName); this.table.CreateIfNotExists(); ReadFirstEntry(); }
static NDIAzureTableController() { _storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); _tableClient = _storageAccount.CreateCloudTableClient(); _table = _tableClient.GetTableReference("ndiparams"); _retrieveOperation = TableOperation.Retrieve("VidParams", "LastVideo"); }
private void CreateTableClient(IConfigurationProvider configurationProvider) { string accountConnectionString = configurationProvider.GetValue("StorageAccountConnectionString"); string sasToken = configurationProvider.GetValue("StorageAccountSasToken"); if (string.IsNullOrWhiteSpace(sasToken) && string.IsNullOrWhiteSpace(accountConnectionString)) { throw new ConfigurationErrorsException( "Configuration must specify either the storage account connection string ('StorageAccountConnectionString' parameter) or SAS token ('StorageAccountSasToken' paramteter)"); } string storageTableName = configurationProvider.GetValue("StorageTableName"); if (string.IsNullOrWhiteSpace(storageTableName)) { throw new ConfigurationErrorsException("Configuration must specify the target storage name ('storageTableName' parameter)"); } CloudStorageAccount storageAccount = string.IsNullOrWhiteSpace(sasToken) ? CloudStorageAccount.Parse(accountConnectionString) : new CloudStorageAccount(new StorageCredentials(sasToken), useHttps: true); this.cloudTable = storageAccount.CreateCloudTableClient().GetTableReference(storageTableName); try { this.cloudTable.CreateIfNotExists(); } catch (Exception e) { this.ReportListenerProblem("Could not ensure that destination Azure storage table exists" + Environment.NewLine + e.ToString()); throw; } }
public HomeController() { storageAccount = CloudStorageAccount.Parse( ConfigurationManager.AppSettings["StorageConnectionString"]); tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("fouramigos"); table.CreateIfNotExists(); blobClient = storageAccount.CreateCloudBlobClient(); container = blobClient.GetContainerReference("fouramigos"); container.CreateIfNotExists(); BlobContainerPermissions permissions = container.GetPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; container.SetPermissions(permissions); //lägga till nya //var tablemodels = new TableModel("Brutus", "Uggla") { Location = "T4", Description="Uggla i träd", Type="Foto" }; //var tablemodels1 = new TableModel("brutus", "Örn") { Location = "T4", Description="Örn som flyger", Type = "Foto" }; //var opreation = TableOperation.Insert(tablemodels); //var operation2 = TableOperation.Insert(tablemodels1); //table.Execute(opreation); //table.Execute(operation2); }
public AuditAzureTableProvider() { try { _account = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["AzureStorageConnectionString"]); _client = _account.CreateCloudTableClient(); } catch (Exception exp) { throw new Exception("Error retreiving reference to Azure Storage Account", exp); } try { _client = _account.CreateCloudTableClient(); } catch (Exception exp) { throw new Exception("Error creating Azure Table Client Object", exp); } try { _vmAuditTable = _client.GetTableReference("VMAudits"); } catch (Exception exp) { throw new Exception("Error retreiving reference to Azure Table Object", exp); } }
public static async Task <IActionResult> UpdateTodo( [HttpTrigger(AuthorizationLevel.Anonymous, "put", Route = "todo/{id}")] HttpRequest req, [Table("todos", Connection = "AzureWebJobsStorage")] Microsoft.WindowsAzure.Storage.Table.CloudTable todoTable, ILogger log, string id) { log.LogInformation($"Updating todo item with Id {id}"); string requestBody = await new StreamReader(req.Body).ReadToEndAsync(); var updated = JsonConvert.DeserializeObject <TodoUpdateModel>(requestBody); var findOperation = Microsoft.WindowsAzure.Storage.Table.TableOperation.Retrieve <TodoTableEntity>("TODO", id); var findResult = await todoTable.ExecuteAsync(findOperation); if (findResult == null) { return(new NotFoundResult()); } var existingRow = (TodoTableEntity)findResult.Result; existingRow.IsCompleted = updated.IsCompleted; if (!string.IsNullOrEmpty(updated.TaskDescription)) { existingRow.TaskDescription = updated.TaskDescription; } var replaceOperation = Microsoft.WindowsAzure.Storage.Table.TableOperation.Replace(existingRow); await todoTable.ExecuteAsync(replaceOperation); return(new OkObjectResult(existingRow.ToTodo())); }
static async Task <Microsoft.WindowsAzure.Storage.Table.CloudTable> GetTable(string tableName) { CloudStorageAccount storageAccount = CloudStorageAccount.Parse( Constants.StorageConnection); Microsoft.WindowsAzure.Storage.Table.CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); Microsoft.WindowsAzure.Storage.Table.CloudTable table = tableClient.GetTableReference(tableName); await table.CreateIfNotExistsAsync(); return(table); }
public static async Task <IActionResult> GetTodos( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "todo")] HttpRequest req, [Table("todos", Connection = "AzureWebJobsStorage")] Microsoft.WindowsAzure.Storage.Table.CloudTable todoTable, ILogger log) { log.LogInformation("Getting list of todo item"); var query = new Microsoft.WindowsAzure.Storage.Table.TableQuery <TodoTableEntity>(); var segment = await todoTable.ExecuteQuerySegmentedAsync(query, null); return(new OkObjectResult(segment.Select(Mappings.ToTodo))); }
public async Task SaveBench(WalkToSave entityToSave) { CloudStorageAccount account = CloudStorageAccount.Parse(_storageConfig.TableConnectionString); CloudTableClient tableClient = account.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference(_storageConfig.MetadataTableName); await table.CreateIfNotExistsAsync(); var result = await InsertEntity(table, entityToSave); if (result.HttpStatusCode != (int)HttpStatusCode.NoContent) { throw new ApplicationException("Failed to insert entity in database."); } }
private async Task <TableResult> InsertEntity(CloudTable table, WalkToSave entityToSave) { // Create an entity and set properties var lens = new WalkToSave(entityToSave.SubmitterName, entityToSave.WalkName) { Description = entityToSave.Description, Location = entityToSave.Location, SubmitterName = entityToSave.SubmitterName, WalkName = entityToSave.WalkName, Url = entityToSave.Url }; // Add the entity TableOperation insertOrMerge = TableOperation.InsertOrMerge(lens); return(await table.ExecuteAsync(insertOrMerge)); }
public static async Task <IActionResult> DeleteTodo( [HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "todo/{id}")] HttpRequest req, [Table("todos", Connection = "AzureWebJobsStorage")] Microsoft.WindowsAzure.Storage.Table.CloudTable todoTable, ILogger log, string id) { var deleteOperation = Microsoft.WindowsAzure.Storage.Table.TableOperation.Delete( new Microsoft.WindowsAzure.Storage.Table.TableEntity() { PartitionKey = "TODO", RowKey = id, ETag = "*" }); try { var deletedResult = await todoTable.ExecuteAsync(deleteOperation); } catch (StorageException e) when(e.RequestInformation.HttpStatusCode == 404) { return(new NotFoundResult()); } return(new OkResult()); }
private async Task CreateTableClientAsync() { //var connectionString = ConfigurationManager.ConnectionStrings["TemperatureTableStorage"].ConnectionString; //var storageAccount = CloudStorageAccount.Parse(connectionString); //var tableClient = storageAccount.CreateCloudTableClient(); //var table = tableClient.GetTableReference("Temperature"); //Application ID: c684f0d9-3358-47e0-a19b-d8bc5029b97c //Key: AccessKey 7W05xPogJ5Ryn1D8rX+6TnwyX5h3EyLHihlKV8MSZiM= CloudTable table; lock (_sync) { if (_cached_table == null) { try { var connectionString = Config.GetConnectionString("TemperatureTableStorage"); var storageAccount = CloudStorageAccount.Parse(connectionString); var tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("Temperature"); } catch (Exception ex) { _cached_table = null; return; } } else { return; } } await table.CreateIfNotExistsAsync(); lock (_sync) { if (_cached_table == null) { _cached_table = table; } } }
public async Task <List <WalkToSave> > GetAllEntities() { CloudStorageAccount account = CloudStorageAccount.Parse(_storageConfig.TableConnectionString); CloudTableClient tableClient = account.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference(_storageConfig.MetadataTableName); await table.CreateIfNotExistsAsync(); var query = new TableQuery <WalkToSave>(); var entities = new List <WalkToSave>(); TableContinuationToken token = null; TableQuerySegment <WalkToSave> resultSegment = null; do { resultSegment = await table.ExecuteQuerySegmentedAsync <WalkToSave>(query, token); entities.AddRange(resultSegment.Results.OfType <WalkToSave>()); token = resultSegment.ContinuationToken; }while (token != null); return(entities); }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req, ILogger log, ExecutionContext context) { string Path = req.Query["Path"].ToString(); var sas = "https://adsgofasttransientstg.blob.core.windows.net/" + Path + "?"; foreach (var i in req.Query) { if (i.Key != "Path" && i.Key != "TargetSystemUidInPHI") { sas += "&" + i.Key + "=" + i.Value; } } var cloudBlockBlob = new Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob(new Uri(sas)); await cloudBlockBlob.UploadTextAsync("Hello World"); //Write to Filelist table so that downstream tasks can be triggered efficiently var _storageCredentials = new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials("?sv=2018-03-28&tn=Filelist&sig=MFbvVgbNLs3UjqAPfU%2BYwQqxcTYwCPnNKCwCUp4XRmo%3D&se=2021-09-06T23%3A15%3A57Z&sp=au"); var SourceStorageAccount = new Microsoft.WindowsAzure.Storage.CloudStorageAccount(storageCredentials: _storageCredentials, accountName: "adsgofasttransientstg", endpointSuffix: "core.windows.net", useHttps: true); var client = SourceStorageAccount.CreateCloudTableClient(); Microsoft.WindowsAzure.Storage.Table.CloudTable table = client.GetTableReference("Filelist"); var _dict = new Dictionary <string, EntityProperty>(); _dict.Add("FilePath", new EntityProperty(Path)); var _tableEntity = new DynamicTableEntity(DateTime.UtcNow.ToString("yyyy-MM-dd hh:mm"), Guid.NewGuid().ToString(), null, _dict); var _tableOperation = TableOperation.Insert(_tableEntity); try { await table.ExecuteAsync(_tableOperation); } catch (Microsoft.WindowsAzure.Storage.StorageException ex) { } return(new OkObjectResult(new { })); }
// Writes to Azure Table Storage // Note: Azure Table Storage will not write records that are longer than 64Kb public static void WriteToBlobStorageTable(WindowsAzureTable.CloudTable cloudTable, string category, string documentName, string ocrResult, string keyPhraseResult, string distinctKeyPhraseString, string entities, string distinctEntitiesString, int pages, string uri, string documentType, long documentSizeInBytes, PIIResult piiResultV2, List <CognitiveServiceClasses.PII.Entity> piiResultV3, List <BingEntityData> bingEntityDataResult, SentimentV3Response sentimentV3Prediction, CognitiveServicesApiCalls cognitiveServicesApiCalls) { ocrResult = ocrResult.Trim(); keyPhraseResult = keyPhraseResult.Trim(); var entityTaxonomies = (bingEntityDataResult is null) ? string.Empty : string.Join(" ;;;; ", bingEntityDataResult.Select(a => a.Taxony).ToArray()); var size = ocrResult.Length * sizeof(char); var keyPhraseResultSize = keyPhraseResult.Length * sizeof(char); var distinctKeyPhraseResultSize = distinctKeyPhraseString.Length * sizeof(char); var entitiesSize = entities.Length * sizeof(char); var entityTaxonomiesSize = entityTaxonomies.Length * sizeof(char); // Only for Table Storage API (CosmosDB can handle large values) if (size > 63999) { var lengthToTake = Convert.ToInt32(Math.Round((double)(32000 * 1.0 / size) * ocrResult.Length, 0)); ocrResult = ocrResult.Substring(0, Math.Min(ocrResult.Length, lengthToTake)); } if (keyPhraseResultSize > 31999) { var lengthToTake = Convert.ToInt32(Math.Round((double)(32000 * 1.0 / size) * keyPhraseResult.Length, 0)); keyPhraseResult = keyPhraseResult.Substring(0, Math.Min(keyPhraseResult.Length, lengthToTake)); } if (distinctKeyPhraseResultSize > 31999) { var lengthToTake = Convert.ToInt32(Math.Round((double)(32000 * 1.0 / size) * distinctKeyPhraseString.Length, 0)); distinctKeyPhraseString = keyPhraseResult.Substring(0, Math.Min(distinctKeyPhraseString.Length, lengthToTake)); } if (entitiesSize > 31999) { var lengthToTake = Convert.ToInt32(Math.Round((double)(32000 * 1.0 / size) * entities.Length, 0)); entities = keyPhraseResult.Substring(0, Math.Min(entities.Length, lengthToTake)); } if (entityTaxonomiesSize > 31999) { var lengthToTake = Convert.ToInt32(Math.Round((double)(32000 * 1.0 / size) * entityTaxonomies.Length, 0)); entityTaxonomies = keyPhraseResult.Substring(0, Math.Min(entityTaxonomies.Length, lengthToTake)); } // Create a new customer entity. var document = new DocumentEntity(category, documentName); document.CognitiveServicesApiCallsApiCallCount = cognitiveServicesApiCalls.ApiCallCount; document.CognitiveServicesApiCallsApiCallV2Count = cognitiveServicesApiCalls.ApiCallV2Count; document.CognitiveServicesApiCallsApiCallV3Count = cognitiveServicesApiCalls.ApiCallV3Count; document.CognitiveServicesApiCallsTotalCount = cognitiveServicesApiCalls.TotalCount; document.OcrResult = ocrResult.Trim(); document.TextAnalyticsKeyPhraseResult = keyPhraseResult; document.TextAnalyticsDistinctKeyPhraseResult = distinctKeyPhraseString; document.TextAnalyticsEntitiesResult = entities; document.TextAnalyticsDistinctEntititesResult = new string(distinctEntitiesString.Take(31999).ToArray()); document.TextAnalyticsEntitiesTaxonomiesResult = entityTaxonomies; document.TextSize = size; document.Pages = pages; document.Uri = uri; document.DocumentType = documentType; document.DocumentSizeInBytes = documentSizeInBytes; if (piiResultV2.Addresses != null) { document.PIIEmailsCount = piiResultV2.Emails.Count; document.PIIAddressesCount = piiResultV2.Addresses.Count; document.PIIPhoneNumbersCount = piiResultV2.PhoneNumbers.Count; document.PIISSNSCount = piiResultV2.SSNs.Count; } if (sentimentV3Prediction.Documents != null) { document.SentimentAnalysis = "Positive: " + sentimentV3Prediction.Documents[0].DocumentScores.Positive + ", Neutral: " + sentimentV3Prediction.Documents[0].DocumentScores.Neutral + ", Negative: " + sentimentV3Prediction.Documents[0].DocumentScores.Negative; } // Create the TableOperation object that inserts the customer entity. var insertOperation = WindowsAzureTable.TableOperation.InsertOrReplace(document); // Execute the insert operation. cloudTable.Execute(insertOperation); }
private static RESTCommand <TableQuerySegment <RESULT_TYPE> > QueryImpl <T, RESULT_TYPE>(TableQuery <T> query, TableContinuationToken token, CloudTableClient client, CloudTable table, EntityResolver <RESULT_TYPE> resolver, TableRequestOptions requestOptions) { requestOptions.AssertPolicyIfRequired(); // If encryption policy is set, then add the encryption metadata column to Select columns in order to be able to decrypt properties. if (requestOptions.EncryptionPolicy != null && query.SelectColumns != null && query.SelectColumns.Count() > 0) { query.SelectColumns.Add(Constants.EncryptionConstants.TableEncryptionKeyDetails); query.SelectColumns.Add(Constants.EncryptionConstants.TableEncryptionPropertyDetails); } UriQueryBuilder builder = query.GenerateQueryBuilder(requestOptions.ProjectSystemProperties); if (token != null) { token.ApplyToUriQueryBuilder(builder); } StorageUri tempUri = NavigationHelper.AppendPathToUri(client.StorageUri, table.Name); RESTCommand <TableQuerySegment <RESULT_TYPE> > queryCmd = new RESTCommand <TableQuerySegment <RESULT_TYPE> >(client.Credentials, tempUri); requestOptions.ApplyToStorageCommand(queryCmd); queryCmd.CommandLocationMode = CommonUtility.GetListingLocationMode(token); queryCmd.RetrieveResponseStream = true; queryCmd.SignRequest = client.AuthenticationHandler.SignRequest; queryCmd.Builder = builder; queryCmd.ParseError = StorageExtendedErrorInformation.ReadFromStreamUsingODataLib; queryCmd.BuildRequestDelegate = (uri, queryBuilder, timeout, useVersionHeader, ctx) => TableOperationHttpWebRequestFactory.BuildRequestForTableQuery(uri, queryBuilder, timeout, useVersionHeader, ctx, requestOptions.PayloadFormat.Value); queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp != null ? resp.StatusCode : HttpStatusCode.Unused, null /* retVal */, cmd, ex); queryCmd.PostProcessResponse = (cmd, resp, ctx) => { ResultSegment <RESULT_TYPE> resSeg = TableOperationHttpResponseParsers.TableQueryPostProcessGeneric <RESULT_TYPE, T>(cmd.ResponseStream, resolver.Invoke, resp, requestOptions, ctx, client.AccountName); if (resSeg.ContinuationToken != null) { resSeg.ContinuationToken.TargetLocation = cmd.CurrentResult.TargetLocation; } return(new TableQuerySegment <RESULT_TYPE>(resSeg)); }; return(queryCmd); }
public void CloudTableExistsAPM() { CloudTableClient tableClient = GenerateCloudTableClient(); string tableName = GenerateRandomTableName(); CloudTable tableRef = tableClient.GetTableReference(tableName); try { using (ManualResetEvent evt = new ManualResetEvent(false)) { IAsyncResult result = null; tableRef.BeginExists((res) => { result = res; evt.Set(); }, null); evt.WaitOne(); // Table should not have been deleted as it doesnt exist Assert.IsFalse(tableRef.EndExists(result)); } tableRef.Create(); using (ManualResetEvent evt = new ManualResetEvent(false)) { IAsyncResult result = null; tableRef.BeginExists((res) => { result = res; evt.Set(); }, null); evt.WaitOne(); // Table should not have been deleted as it doesnt exist Assert.IsTrue(tableRef.EndExists(result)); } tableRef.Delete(); using (ManualResetEvent evt = new ManualResetEvent(false)) { IAsyncResult result = null; tableRef.BeginExists((res) => { result = res; evt.Set(); }, null); evt.WaitOne(); // Table should not have been deleted as it doesnt exist Assert.IsFalse(tableRef.EndExists(result)); } } finally { tableRef.DeleteIfExists(); } }
internal TableQuerySegment <TResult> ExecuteQuerySegmentedInternal <TResult>(TableContinuationToken token, CloudTableClient client, CloudTable table, EntityResolver <TResult> resolver, TableRequestOptions requestOptions, OperationContext operationContext) { CommonUtility.AssertNotNullOrEmpty("tableName", table.Name); CommonUtility.AssertNotNull("resolver", resolver); TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client); operationContext = operationContext ?? new OperationContext(); RESTCommand <TableQuerySegment <TResult> > cmdToExecute = QueryImpl(this, token, client, table, resolver, modifiedOptions); return(Executor.ExecuteSync(cmdToExecute, modifiedOptions.RetryPolicy, operationContext)); }
internal ICancellableAsyncResult BeginExecuteQuerySegmentedInternal <TResult>(TableContinuationToken token, CloudTableClient client, CloudTable table, EntityResolver <TResult> resolver, TableRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state) { CommonUtility.AssertNotNullOrEmpty("tableName", table.Name); CommonUtility.AssertNotNull("resolver", resolver); TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client); operationContext = operationContext ?? new OperationContext(); return(Executor.BeginExecuteAsync( QueryImpl(this, token, client, table, resolver, modifiedOptions), modifiedOptions.RetryPolicy, operationContext, callback, state)); }
private static void ExecuteQueryAndAssertResults(CloudTable table, string filter, int expectedResults) { Assert.AreEqual(expectedResults, ExecuteQuery(table, new TableQuery <ComplexEntity>().Where(filter)).Count()); }
internal IEnumerable <TResult> ExecuteInternal <TResult>(CloudTableClient client, CloudTable table, EntityResolver <TResult> resolver, TableRequestOptions requestOptions, OperationContext operationContext) { CommonUtility.AssertNotNullOrEmpty("tableName", table.Name); CommonUtility.AssertNotNull("resolver", resolver); TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client); operationContext = operationContext ?? new OperationContext(); IEnumerable <TResult> enumerable = CommonUtility.LazyEnumerable <TResult>( (continuationToken) => { TableQuerySegment <TResult> seg = #if SYNC this.ExecuteQuerySegmentedInternal((TableContinuationToken)continuationToken, client, table, resolver, modifiedOptions, operationContext); #else this.EndExecuteQuerySegmentedInternal <TResult>(this.BeginExecuteQuerySegmentedInternal((TableContinuationToken)continuationToken, client, table, resolver, modifiedOptions, operationContext, null /* callback */, null /* state */)); #endif return(new ResultSegment <TResult>(seg.Results) { ContinuationToken = seg.ContinuationToken }); }, this.takeCount.HasValue ? this.takeCount.Value : long.MaxValue); return(enumerable); }
private static RESTCommand <TableQuerySegment <RESULT_TYPE> > QueryImpl <RESULT_TYPE>(TableQuery query, TableContinuationToken token, CloudTableClient client, CloudTable table, EntityResolver <RESULT_TYPE> resolver, TableRequestOptions requestOptions) { UriQueryBuilder builder = query.GenerateQueryBuilder(requestOptions.ProjectSystemProperties); if (token != null) { token.ApplyToUriQueryBuilder(builder); } StorageUri tempUri = NavigationHelper.AppendPathToUri(client.StorageUri, table.Name); RESTCommand <TableQuerySegment <RESULT_TYPE> > queryCmd = new RESTCommand <TableQuerySegment <RESULT_TYPE> >(client.Credentials, tempUri); requestOptions.ApplyToStorageCommand(queryCmd); queryCmd.CommandLocationMode = CommonUtility.GetListingLocationMode(token); queryCmd.RetrieveResponseStream = true; queryCmd.SignRequest = client.AuthenticationHandler.SignRequest; queryCmd.Builder = builder; queryCmd.ParseError = ODataErrorHelper.ReadFromStreamUsingODataLib; queryCmd.BuildRequestDelegate = (uri, queryBuilder, timeout, useVersionHeader, ctx) => TableOperationHttpWebRequestFactory.BuildRequestForTableQuery(uri, queryBuilder, timeout, useVersionHeader, ctx, requestOptions.PayloadFormat.Value); queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp != null ? resp.StatusCode : HttpStatusCode.Unused, null /* retVal */, cmd, ex); queryCmd.PostProcessResponse = (cmd, resp, ctx) => { ResultSegment <RESULT_TYPE> resSeg = TableOperationHttpResponseParsers.TableQueryPostProcessGeneric <RESULT_TYPE, DynamicTableEntity>(cmd.ResponseStream, resolver.Invoke, resp, requestOptions, ctx, client.AccountName); if (resSeg.ContinuationToken != null) { resSeg.ContinuationToken.TargetLocation = cmd.CurrentResult.TargetLocation; } return(new TableQuerySegment <RESULT_TYPE>(resSeg)); }; return(queryCmd); }
public async Task TableGenericQueryOnSupportedTypesAsync() { CloudTableClient client = GenerateCloudTableClient(); CloudTable table = client.GetTableReference(GenerateRandomTableName()); await table.CreateAsync(); try { // Setup TableBatchOperation batch = new TableBatchOperation(); string pk = Guid.NewGuid().ToString(); ComplexEntity middleRef = null; for (int m = 0; m < 100; m++) { ComplexEntity complexEntity = new ComplexEntity(pk, string.Format("{0:0000}", m)); complexEntity.String = string.Format("{0:0000}", m); complexEntity.Binary = new byte[] { 0x01, 0x02, (byte)m }; complexEntity.BinaryPrimitive = new byte[] { 0x01, 0x02, (byte)m }; complexEntity.Bool = m % 2 == 0 ? true : false; complexEntity.BoolPrimitive = m % 2 == 0 ? true : false; complexEntity.Double = m + ((double)m / 100); complexEntity.DoublePrimitive = m + ((double)m / 100); complexEntity.Int32 = m; complexEntity.IntegerPrimitive = m; complexEntity.Int64 = (long)int.MaxValue + m; complexEntity.LongPrimitive = (long)int.MaxValue + m; complexEntity.Guid = Guid.NewGuid(); batch.Insert(complexEntity); if (m == 50) { middleRef = complexEntity; } // Add delay to make times unique await Task.Delay(100); } await table.ExecuteBatchAsync(batch); // 1. Filter on String ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterCondition("String", QueryComparisons.GreaterThanOrEqual, "0050"), 50); // 2. Filter on Guid ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForGuid("Guid", QueryComparisons.Equal, middleRef.Guid), 1); // 3. Filter on Long ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForLong("Int64", QueryComparisons.GreaterThanOrEqual, middleRef.LongPrimitive), 50); ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForLong("LongPrimitive", QueryComparisons.GreaterThanOrEqual, middleRef.LongPrimitive), 50); // 4. Filter on Double ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForDouble("Double", QueryComparisons.GreaterThanOrEqual, middleRef.Double), 50); ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForDouble("DoublePrimitive", QueryComparisons.GreaterThanOrEqual, middleRef.DoublePrimitive), 50); // 5. Filter on Integer ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForInt("Int32", QueryComparisons.GreaterThanOrEqual, middleRef.Int32), 50); ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForInt("IntegerPrimitive", QueryComparisons.GreaterThanOrEqual, middleRef.IntegerPrimitive), 50); // 6. Filter on Date ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForDate("DateTimeOffset", QueryComparisons.GreaterThanOrEqual, middleRef.DateTimeOffset), 50); // 7. Filter on Boolean ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForBool("Bool", QueryComparisons.Equal, middleRef.Bool), 50); ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForBool("BoolPrimitive", QueryComparisons.Equal, middleRef.BoolPrimitive), 50); // 8. Filter on Binary ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.Equal, middleRef.Binary), 1); ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive", QueryComparisons.Equal, middleRef.BinaryPrimitive), 1); // 9. Filter on Binary GTE ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.GreaterThanOrEqual, middleRef.Binary), 50); ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive", QueryComparisons.GreaterThanOrEqual, middleRef.BinaryPrimitive), 50); // 10. Complex Filter on Binary GTE ExecuteQueryAndAssertResults(table, TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, middleRef.PartitionKey), TableOperators.And, TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.GreaterThanOrEqual, middleRef.Binary)), 50); ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive", QueryComparisons.GreaterThanOrEqual, middleRef.BinaryPrimitive), 50); } finally { table.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task TableGetSetPermissionTestAsync() { CloudTableClient tableClient = GenerateCloudTableClient(); CloudTable table = tableClient.GetTableReference("T" + Guid.NewGuid().ToString("N")); try { await table.CreateAsync(); await table.ExecuteAsync(TableOperation.Insert(new BaseEntity("PK", "RK"))); TablePermissions expectedPermissions; TablePermissions testPermissions; // Test new table permissions. expectedPermissions = new TablePermissions(); testPermissions = await table.GetPermissionsAsync(); AssertPermissionsEqual(expectedPermissions, testPermissions); // Test setting empty permissions. await table.SetPermissionsAsync(expectedPermissions); await Task.Delay(30 * 1000); testPermissions = await table.GetPermissionsAsync(); AssertPermissionsEqual(expectedPermissions, testPermissions); // Add a policy, check setting and getting. expectedPermissions.SharedAccessPolicies.Add(Guid.NewGuid().ToString(), new SharedAccessTablePolicy { Permissions = SharedAccessTablePermissions.Query, SharedAccessStartTime = DateTimeOffset.Now - TimeSpan.FromHours(1), SharedAccessExpiryTime = DateTimeOffset.Now + TimeSpan.FromHours(1) }); await table.SetPermissionsAsync(expectedPermissions); await Task.Delay(30 * 1000); testPermissions = await table.GetPermissionsAsync(); AssertPermissionsEqual(expectedPermissions, testPermissions); // Add a policy, check setting and getting. expectedPermissions.SharedAccessPolicies.Add(Guid.NewGuid().ToString(), new SharedAccessTablePolicy { Permissions = SharedAccessTablePermissions.Delete | SharedAccessTablePermissions.Add, SharedAccessStartTime = DateTimeOffset.Now + TimeSpan.FromHours(1), SharedAccessExpiryTime = DateTimeOffset.Now + TimeSpan.FromDays(1) }); await table.SetPermissionsAsync(expectedPermissions); await Task.Delay(30 * 1000); testPermissions = await table.GetPermissionsAsync(); AssertPermissionsEqual(expectedPermissions, testPermissions); // Add a null policy, check setting and getting. expectedPermissions.SharedAccessPolicies.Add(Guid.NewGuid().ToString(), new SharedAccessTablePolicy { Permissions = SharedAccessTablePermissions.None, }); await table.SetPermissionsAsync(expectedPermissions); await Task.Delay(30 * 1000); testPermissions = await table.GetPermissionsAsync(); AssertPermissionsEqual(expectedPermissions, testPermissions); // Add a policy, check setting and getting. expectedPermissions.SharedAccessPolicies.Add(Guid.NewGuid().ToString(), new SharedAccessTablePolicy { Permissions = SharedAccessTablePermissions.Add | SharedAccessTablePermissions.Query | SharedAccessTablePermissions.Update | SharedAccessTablePermissions.Delete, SharedAccessStartTime = DateTimeOffset.Now + TimeSpan.FromDays(0.5), SharedAccessExpiryTime = DateTimeOffset.Now + TimeSpan.FromDays(1) }); await table.SetPermissionsAsync(expectedPermissions); await Task.Delay(30 * 1000); testPermissions = await table.GetPermissionsAsync(); AssertPermissionsEqual(expectedPermissions, testPermissions); // Add a policy, check setting and getting. expectedPermissions.SharedAccessPolicies.Add(Guid.NewGuid().ToString(), new SharedAccessTablePolicy { Permissions = SharedAccessTablePermissions.Update, SharedAccessStartTime = DateTimeOffset.Now + TimeSpan.FromHours(6), SharedAccessExpiryTime = DateTimeOffset.Now + TimeSpan.FromHours(6.5) }); await table.SetPermissionsAsync(expectedPermissions); await Task.Delay(30 * 1000); testPermissions = await table.GetPermissionsAsync(); AssertPermissionsEqual(expectedPermissions, testPermissions); } finally { table.DeleteIfExistsAsync().AsTask().Wait(); } }
internal static RESTCommand <IList <TableResult> > BatchImpl(TableBatchOperation batch, CloudTableClient client, CloudTable table, TableRequestOptions requestOptions) { RESTCommand <IList <TableResult> > batchCmd = new RESTCommand <IList <TableResult> >(client.Credentials, client.StorageUri); requestOptions.ApplyToStorageCommand(batchCmd); List <TableResult> results = new List <TableResult>(); batchCmd.CommandLocationMode = batch.ContainsWrites ? CommandLocationMode.PrimaryOnly : CommandLocationMode.PrimaryOrSecondary; batchCmd.RetrieveResponseStream = true; batchCmd.SignRequest = client.AuthenticationHandler.SignRequest; batchCmd.ParseError = ODataErrorHelper.ReadFromStreamUsingODataLib; batchCmd.BuildRequestDelegate = (uri, builder, timeout, useVersionHeader, ctx) => { Tuple <HttpWebRequest, Stream> res = TableOperationHttpWebRequestFactory.BuildRequestForTableBatchOperation(uri, builder, client.BufferManager, timeout, table.Name, batch, useVersionHeader, ctx, requestOptions, client.AccountName); batchCmd.SendStream = res.Item2; return(res.Item1); }; batchCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp != null ? resp.StatusCode : HttpStatusCode.Unused, results, cmd, ex); batchCmd.PostProcessResponse = (cmd, resp, ctx) => TableOperationHttpResponseParsers.TableBatchOperationPostProcess(results, batch, cmd, resp, ctx, requestOptions, client.AccountName); batchCmd.RecoveryAction = (cmd, ex, ctx) => results.Clear(); return(batchCmd); }
public AzureTableQuery(CT.CloudTable table, IEncryptor decryptor) : this(table, decryptor, null, null) { }
public TableQueryProvider(CloudTable table) { this.Table = table; }