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