/// <summary>
/// Processes http status codes
/// </summary>
/// <param name="result"></param>
/// <returns>true if successful</returns>
public static bool GetResultFromTableResult(TableResult result)
{
//The request has succeeded
if (result.HttpStatusCode == (int)HttpStatusCode.OK
//The server has fulfilled the request but does not need to return an entity-body
|| result.HttpStatusCode == (int)HttpStatusCode.NoContent)
{
return true;
}
else
return false;
}
public async Task <T> ById(string partitionKey, string rowKey)
{
CT.TableOperation op = CT.TableOperation.Retrieve <FatEntity>(partitionKey, rowKey);
CT.TableResult result = await _table.ExecuteWrap(t => t.ExecuteAsync(op)).ConfigureAwait(false);
if (result.Result == null)
{
return(default(T));
}
return(ConvertFatEntity((FatEntity)result.Result));
}
private static RESTCommand <TableResult> ReplaceImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand <TableResult> replaceCmd = new RESTCommand <TableResult>(client.Credentials, operation.GenerateRequestURI(client.BaseUri, tableName));
replaceCmd.ApplyRequestOptions(requestOptions);
TableResult result = new TableResult()
{
Result = operation.Entity
};
replaceCmd.RetrieveResponseStream = false;
replaceCmd.SignRequest = client.AuthenticationHandler.SignRequest;
replaceCmd.BuildRequestDelegate = (uri, builder, timeout, ctx) =>
{
Tuple <HttpWebRequest, Stream> res = TableOperationHttpWebRequestFactory.BuildRequestForTableOperation(uri, builder, client.BufferManager, timeout, operation, ctx);
replaceCmd.SendStream = res.Item2;
return(res.Item1);
};
replaceCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd);
return(replaceCmd);
}
private static RESTCommand<TableResult> ReplaceImpl(TableOperation operation, CloudTableClient client, CloudTable table, TableRequestOptions requestOptions)
{
RESTCommand<TableResult> replaceCmd = new RESTCommand<TableResult>(client.Credentials, operation.GenerateRequestURI(client.StorageUri, table.Name));
requestOptions.ApplyToStorageCommand(replaceCmd);
TableResult result = new TableResult() { Result = operation.Entity };
replaceCmd.RetrieveResponseStream = false;
replaceCmd.SignRequest = client.AuthenticationHandler.SignRequest;
replaceCmd.ParseError = StorageExtendedErrorInformation.ReadFromStreamUsingODataLib;
replaceCmd.BuildRequestDelegate = (uri, builder, timeout, useVersionHeader, ctx) =>
{
Tuple<HttpWebRequest, Stream> res = TableOperationHttpWebRequestFactory.BuildRequestForTableOperation(uri, builder, client.BufferManager, timeout, operation, useVersionHeader, ctx, requestOptions, client.AccountName);
replaceCmd.SendStream = res.Item2;
return res.Item1;
};
replaceCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex);
return replaceCmd;
}
private async Task DoEscapeTestAsync(string data, bool useBatch, bool includeKey)
{
DynamicTableEntity ent = new DynamicTableEntity(includeKey ? "temp" + data : "temp", Guid.NewGuid().ToString());
ent.Properties.Add("foo", new EntityProperty(data));
// Insert
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Insert(ent);
await currentTable.ExecuteBatchAsync(batch);
}
else
{
await currentTable.ExecuteAsync(TableOperation.Insert(ent));
}
// Retrieve
TableResult res = null;
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Retrieve(ent.PartitionKey, ent.RowKey);
res = (await currentTable.ExecuteBatchAsync(batch))[0];
}
else
{
res = await currentTable.ExecuteAsync(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
}
// Check equality
DynamicTableEntity retrievedEntity = res.Result as DynamicTableEntity;
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
// Merge
ent.Properties.Add("foo2", new EntityProperty("bar2"));
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Merge(ent);
await currentTable.ExecuteBatchAsync(batch);
}
else
{
await currentTable.ExecuteAsync(TableOperation.Merge(ent));
}
// Retrieve
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Retrieve(ent.PartitionKey, ent.RowKey);
res = (await currentTable.ExecuteBatchAsync(batch))[0];
}
else
{
res = await currentTable.ExecuteAsync(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
}
retrievedEntity = res.Result as DynamicTableEntity;
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
// Replace
ent.Properties.Remove("foo2");
ent.Properties.Add("foo3", new EntityProperty("bar3"));
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Replace(ent);
await currentTable.ExecuteBatchAsync(batch);
}
else
{
await currentTable.ExecuteAsync(TableOperation.Replace(ent));
}
// Retrieve
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Retrieve(ent.PartitionKey, ent.RowKey);
res = (await currentTable.ExecuteBatchAsync(batch))[0];
}
else
{
res = await currentTable.ExecuteAsync(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
}
retrievedEntity = res.Result as DynamicTableEntity;
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
}
private static RESTCommand<TableResult> RetrieveImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand<TableResult> retrieveCmd = new RESTCommand<TableResult>(client.Credentials, operation.GenerateRequestURI(client.StorageUri, tableName));
requestOptions.ApplyToStorageCommand(retrieveCmd);
TableResult result = new TableResult();
retrieveCmd.CommandLocationMode = operation.isPrimaryOnlyRetrieve ? CommandLocationMode.PrimaryOnly : CommandLocationMode.PrimaryOrSecondary;
retrieveCmd.RetrieveResponseStream = true;
retrieveCmd.Handler = client.AuthenticationHandler;
retrieveCmd.BuildClient = HttpClientFactory.BuildHttpClient;
retrieveCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableOperation(cmd, uri, builder, serverTimeout, operation, client, cnt, ctx);
retrieveCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd, ctx);
retrieveCmd.PostProcessResponse = (cmd, resp, ctx) =>
Task.Run(async () =>
{
if (resp.StatusCode == HttpStatusCode.NotFound)
{
return result;
}
result = await TableOperationHttpResponseParsers.TableOperationPostProcess(result, operation, cmd, resp, ctx);
return result;
});
return retrieveCmd;
}
private static RESTCommand<TableResult> ReplaceImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand<TableResult> replaceCmd = new RESTCommand<TableResult>(client.Credentials, operation.GenerateRequestURI(client.StorageUri, tableName));
requestOptions.ApplyToStorageCommand(replaceCmd);
TableResult result = new TableResult() { Result = operation.Entity };
replaceCmd.RetrieveResponseStream = false;
replaceCmd.Handler = client.AuthenticationHandler;
replaceCmd.BuildClient = HttpClientFactory.BuildHttpClient;
replaceCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableOperation(cmd, uri, builder, serverTimeout, operation, client, cnt, ctx);
replaceCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd, ctx);
return replaceCmd;
}
/// <summary>
/// Virtual method whose implementation on a conctrete entity can be used to handle the results
/// of the save to Azure storage table, i.e. the <see cref="CloudTable"/> Execute command.
/// </summary>
/// <param name="tableResult"></param>
public virtual void AfterInsert(TableResult tableResult) { }
public async Task TableOperationsWithEmptyKeysAsync()
{
CloudTableClient tableClient = GenerateCloudTableClient();
// Insert Entity
DynamicTableEntity ent = new DynamicTableEntity()
{
PartitionKey = "", RowKey = ""
};
ent.Properties.Add("foo2", new EntityProperty("bar2"));
ent.Properties.Add("foo", new EntityProperty("bar"));
await currentTable.ExecuteAsync(TableOperation.Insert(ent));
// Retrieve Entity
TableResult result = await currentTable.ExecuteAsync(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"].StringValue, retrievedEntity.Properties["foo"].StringValue);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
Assert.AreEqual(ent.Properties["foo2"].StringValue, retrievedEntity.Properties["foo2"].StringValue);
Assert.AreEqual(ent.Properties["foo2"], retrievedEntity.Properties["foo2"]);
// InsertOrMerge
DynamicTableEntity insertOrMergeEntity = new DynamicTableEntity(ent.PartitionKey, ent.RowKey);
insertOrMergeEntity.Properties.Add("foo3", new EntityProperty("value"));
await currentTable.ExecuteAsync(TableOperation.InsertOrMerge(insertOrMergeEntity));
result = await currentTable.ExecuteAsync(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(insertOrMergeEntity.Properties["foo3"], retrievedEntity.Properties["foo3"]);
// InsertOrReplace
DynamicTableEntity insertOrReplaceEntity = new DynamicTableEntity(ent.PartitionKey, ent.RowKey);
insertOrReplaceEntity.Properties.Add("prop2", new EntityProperty("otherValue"));
await currentTable.ExecuteAsync(TableOperation.InsertOrReplace(insertOrReplaceEntity));
result = await currentTable.ExecuteAsync(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(1, retrievedEntity.Properties.Count);
Assert.AreEqual(insertOrReplaceEntity.Properties["prop2"], retrievedEntity.Properties["prop2"]);
// Merge
DynamicTableEntity mergeEntity = new DynamicTableEntity(retrievedEntity.PartitionKey, retrievedEntity.RowKey)
{
ETag = retrievedEntity.ETag
};
mergeEntity.Properties.Add("mergeProp", new EntityProperty("merged"));
await currentTable.ExecuteAsync(TableOperation.Merge(mergeEntity));
// Retrieve Entity & Verify Contents
result = await currentTable.ExecuteAsync(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(mergeEntity.Properties["mergeProp"], retrievedEntity.Properties["mergeProp"]);
// Replace
DynamicTableEntity replaceEntity = new DynamicTableEntity(ent.PartitionKey, ent.RowKey)
{
ETag = retrievedEntity.ETag
};
replaceEntity.Properties.Add("replaceProp", new EntityProperty("replace"));
await currentTable.ExecuteAsync(TableOperation.Replace(replaceEntity));
// Retrieve Entity & Verify Contents
result = await currentTable.ExecuteAsync(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(replaceEntity.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(replaceEntity.Properties["replaceProp"], retrievedEntity.Properties["replaceProp"]);
// Delete Entity
await currentTable.ExecuteAsync(TableOperation.Delete(retrievedEntity));
// Retrieve Entity
TableResult result2 = await currentTable.ExecuteAsync(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
Assert.IsNull(result2.Result);
}
private static RESTCommand<TableResult> RetrieveImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand<TableResult> retrieveCmd = new RESTCommand<TableResult>(client.Credentials, operation.GenerateRequestURI(client.StorageUri, tableName));
requestOptions.ApplyToStorageCommand(retrieveCmd);
TableResult result = new TableResult();
if (operation.SelectColumns != null && operation.SelectColumns.Count > 0)
{
retrieveCmd.Builder = operation.GenerateQueryBuilder(requestOptions.ProjectSystemProperties);
}
retrieveCmd.CommandLocationMode = operation.isPrimaryOnlyRetrieve ? CommandLocationMode.PrimaryOnly : CommandLocationMode.PrimaryOrSecondary;
retrieveCmd.RetrieveResponseStream = true;
retrieveCmd.ParseError = StorageExtendedErrorInformation.ReadFromStreamUsingODataLib;
retrieveCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableOperation(cmd, uri, builder, serverTimeout, operation, client, cnt, ctx, requestOptions.PayloadFormat.Value, client.GetCanonicalizer(), client.Credentials);
retrieveCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd, ctx);
retrieveCmd.PostProcessResponse = (cmd, resp, ctx) =>
Task.Run(async () =>
{
if (resp.StatusCode == HttpStatusCode.NotFound)
{
return result;
}
result = await TableOperationHttpResponseParsers.TableOperationPostProcess(result, operation, cmd, resp, ctx, requestOptions, client.AccountName);
return result;
});
return retrieveCmd;
}
private void DoEscapeTest(string data, bool useBatch, bool includeKey)
{
DynamicTableEntity ent = new DynamicTableEntity(includeKey ? "temp" + data : "temp", Guid.NewGuid().ToString());
ent.Properties.Add("foo", new EntityProperty(data));
// Insert
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Insert(ent);
currentTable.ExecuteBatch(batch);
}
else
{
currentTable.Execute(TableOperation.Insert(ent));
}
// Retrieve
TableResult res = null;
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Retrieve(ent.PartitionKey, ent.RowKey);
res = (currentTable.ExecuteBatch(batch))[0];
}
else
{
res = currentTable.Execute(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
}
// Check equality
DynamicTableEntity retrievedEntity = res.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
// Query using data filter
TableQuery query = new TableQuery();
query.Where(string.Format(
"(PartitionKey eq \'{0}\') and (RowKey eq \'{1}\') and (foo eq \'{2}\')",
ent.PartitionKey,
ent.RowKey,
data.Replace("\'", "\'\'")));
retrievedEntity = currentTable.ExecuteQuery(query).Single();
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
// Merge
ent.Properties.Add("foo2", new EntityProperty("bar2"));
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Merge(ent);
currentTable.ExecuteBatch(batch);
}
else
{
currentTable.Execute(TableOperation.Merge(ent));
}
// Retrieve
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Retrieve(ent.PartitionKey, ent.RowKey);
res = (currentTable.ExecuteBatch(batch))[0];
}
else
{
res = currentTable.Execute(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
}
retrievedEntity = res.Result as DynamicTableEntity;
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
// Replace
ent.Properties.Remove("foo2");
ent.Properties.Add("foo3", new EntityProperty("bar3"));
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Replace(ent);
currentTable.ExecuteBatch(batch);
}
else
{
currentTable.Execute(TableOperation.Replace(ent));
}
// Retrieve
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Retrieve(ent.PartitionKey, ent.RowKey);
res = (currentTable.ExecuteBatch(batch))[0];
}
else
{
res = currentTable.Execute(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
}
retrievedEntity = res.Result as DynamicTableEntity;
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
}
private static RESTCommand<TableResult> InsertImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand<TableResult> insertCmd = new RESTCommand<TableResult>(client.Credentials, operation.GenerateRequestURI(client.BaseUri, tableName));
requestOptions.ApplyToStorageCommand(insertCmd);
TableResult result = new TableResult() { Result = operation.Entity };
insertCmd.RetrieveResponseStream = true;
insertCmd.Handler = client.AuthenticationHandler;
insertCmd.BuildClient = HttpClientFactory.BuildHttpClient;
insertCmd.BuildRequest = (cmd, cnt, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableOperation(cmd.Uri, cmd.ServerTimeoutInSeconds, operation, ctx);
insertCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd, ctx);
insertCmd.PostProcessResponse = (cmd, resp, ex, ctx) =>
Task.Run(async () =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(
operation.OperationType == TableOperationType.Insert ? HttpStatusCode.Created : HttpStatusCode.NoContent,
resp,
result,
cmd,
ex,
ctx);
result = await TableOperationHttpResponseParsers.TableOperationPostProcess(result, operation, cmd, resp, ctx);
return result;
});
return insertCmd;
}
private static RESTCommand<TableResult> ReplaceImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand<TableResult> replaceCmd = new RESTCommand<TableResult>(client.Credentials, operation.GenerateRequestURI(client.BaseUri, tableName));
requestOptions.ApplyToStorageCommand(replaceCmd);
TableResult result = new TableResult() { Result = operation.Entity };
replaceCmd.RetrieveResponseStream = false;
replaceCmd.Handler = client.AuthenticationHandler;
replaceCmd.BuildClient = HttpClientFactory.BuildHttpClient;
replaceCmd.BuildRequest = (cmd, cnt, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableOperation(cmd.Uri, cmd.ServerTimeoutInSeconds, operation, ctx);
replaceCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd, ctx);
replaceCmd.PostProcessResponse = (cmd, resp, ex, ctx) =>
{
return Task.Factory.StartNew(() => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.NoContent, resp, result, cmd, ex, ctx));
};
return replaceCmd;
}
private static RESTCommand<TableResult> RetrieveImpl(TableOperation operation, CloudTableClient client, CloudTable table, TableRequestOptions requestOptions)
{
requestOptions.AssertPolicyIfRequired();
RESTCommand<TableResult> retrieveCmd = new RESTCommand<TableResult>(client.Credentials, operation.GenerateRequestURI(client.StorageUri, table.Name));
requestOptions.ApplyToStorageCommand(retrieveCmd);
TableResult result = new TableResult();
if (operation.SelectColumns != null && operation.SelectColumns.Count > 0)
{
// 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)
{
operation.SelectColumns.Add(Constants.EncryptionConstants.TableEncryptionKeyDetails);
operation.SelectColumns.Add(Constants.EncryptionConstants.TableEncryptionPropertyDetails);
}
retrieveCmd.Builder = operation.GenerateQueryBuilder(requestOptions.ProjectSystemProperties);
}
retrieveCmd.CommandLocationMode = operation.isPrimaryOnlyRetrieve ? CommandLocationMode.PrimaryOnly : CommandLocationMode.PrimaryOrSecondary;
retrieveCmd.RetrieveResponseStream = true;
retrieveCmd.SignRequest = client.AuthenticationHandler.SignRequest;
retrieveCmd.ParseError = StorageExtendedErrorInformation.ReadFromStreamUsingODataLib;
retrieveCmd.BuildRequestDelegate = (uri, builder, timeout, useVersionHeader, ctx) => TableOperationHttpWebRequestFactory.BuildRequestForTableOperation(uri, builder, client.BufferManager, timeout, operation, useVersionHeader, ctx, requestOptions, client.AccountName).Item1;
retrieveCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex);
retrieveCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
if (resp.StatusCode == HttpStatusCode.NotFound)
{
return result;
}
result = TableOperationHttpResponseParsers.TableOperationPostProcess(result, operation, cmd, resp, ctx, requestOptions, client.AccountName);
return result;
};
return retrieveCmd;
}
public TableResultExtensionsTests()
{
_result = new TableResult();
}
private static RESTCommand<TableResult> RetrieveImpl(TableOperation operation, CloudTableClient client, CloudTable table, TableRequestOptions requestOptions)
{
requestOptions.AssertPolicyIfRequired();
RESTCommand<TableResult> retrieveCmd = new RESTCommand<TableResult>(client.Credentials, operation.GenerateRequestURI(client.StorageUri, table.Name));
requestOptions.ApplyToStorageCommand(retrieveCmd);
TableResult result = new TableResult();
retrieveCmd.CommandLocationMode = operation.isPrimaryOnlyRetrieve ? CommandLocationMode.PrimaryOnly : CommandLocationMode.PrimaryOrSecondary;
retrieveCmd.RetrieveResponseStream = true;
retrieveCmd.SignRequest = client.AuthenticationHandler.SignRequest;
retrieveCmd.ParseError = StorageExtendedErrorInformation.ReadFromStreamUsingODataLib;
retrieveCmd.BuildRequestDelegate = (uri, builder, timeout, useVersionHeader, ctx) => TableOperationHttpWebRequestFactory.BuildRequestForTableOperation(uri, builder, client.BufferManager, timeout, operation, useVersionHeader, ctx, requestOptions, client.AccountName).Item1;
retrieveCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex);
retrieveCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
if (resp.StatusCode == HttpStatusCode.NotFound)
{
return result;
}
result = TableOperationHttpResponseParsers.TableOperationPostProcess(result, operation, cmd, resp, ctx, requestOptions, client.AccountName);
return result;
};
return retrieveCmd;
}
private static RESTCommand<TableResult> InsertImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand<TableResult> insertCmd = new RESTCommand<TableResult>(client.Credentials, operation.GenerateRequestURI(client.BaseUri, tableName));
insertCmd.ApplyRequestOptions(requestOptions);
TableResult result = new TableResult() { Result = operation.Entity };
insertCmd.RetrieveResponseStream = true;
insertCmd.Handler = client.AuthenticationHandler;
insertCmd.BuildClient = HttpClientFactory.BuildHttpClient;
insertCmd.BuildRequest = (cmd, cnt, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableOperation(cmd, cmd.ServerTimeoutInSeconds, operation, client, ctx);
insertCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd, ctx);
insertCmd.PostProcessResponse = (cmd, resp, ctx) => TableOperationHttpResponseParsers.TableOperationPostProcess(result, operation, cmd, resp, ctx);
return insertCmd;
}
public async Task TableSASNullAccessPolicyAsync()
{
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 = new TablePermissions();
// Add a policy
expectedPermissions.SharedAccessPolicies.Add(Guid.NewGuid().ToString(), new SharedAccessTablePolicy
{
Permissions = SharedAccessTablePermissions.Query | SharedAccessTablePermissions.Add,
SharedAccessStartTime = DateTimeOffset.Now - TimeSpan.FromHours(1),
SharedAccessExpiryTime = DateTimeOffset.Now + TimeSpan.FromHours(1)
});
await table.SetPermissionsAsync(expectedPermissions);
await Task.Delay(30 * 1000);
// Generate the sasToken the user should use
string sasToken = table.GetSharedAccessSignature(null, expectedPermissions.SharedAccessPolicies.First().Key, "AAAA", null, "AAAA", null);
CloudTable sasTable = new CloudTable(table.Uri, new StorageCredentials(sasToken));
await sasTable.ExecuteAsync(TableOperation.Insert(new DynamicTableEntity("AAAA", "foo")));
TableResult result = await sasTable.ExecuteAsync(TableOperation.Retrieve("AAAA", "foo"));
Assert.IsNotNull(result.Result);
// revoke table permissions
await table.SetPermissionsAsync(new TablePermissions());
await Task.Delay(30 * 1000);
OperationContext opContext = new OperationContext();
try
{
await sasTable.ExecuteAsync(TableOperation.Insert(new DynamicTableEntity("AAAA", "foo2")), null, opContext);
Assert.Fail();
}
catch (Exception)
{
Assert.AreEqual(opContext.LastResult.HttpStatusCode, (int)HttpStatusCode.Forbidden);
}
opContext = new OperationContext();
try
{
result = await sasTable.ExecuteAsync(TableOperation.Retrieve("AAAA", "foo"), null, opContext);
Assert.Fail();
}
catch (Exception)
{
Assert.AreEqual(opContext.LastResult.HttpStatusCode, (int)HttpStatusCode.Forbidden);
}
}
finally
{
table.DeleteIfExistsAsync().AsTask().Wait();
}
}
private static RESTCommand<TableResult> ReplaceImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand<TableResult> replaceCmd = new RESTCommand<TableResult>(client.Credentials, operation.GenerateRequestURI(client.StorageUri, tableName));
requestOptions.ApplyToStorageCommand(replaceCmd);
TableResult result = new TableResult() { Result = operation.Entity };
replaceCmd.RetrieveResponseStream = false;
replaceCmd.ParseError = StorageExtendedErrorInformation.ReadFromStreamUsingODataLib;
replaceCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableOperation(cmd, uri, builder, serverTimeout, operation, client, cnt, ctx, requestOptions.PayloadFormat.Value, client.GetCanonicalizer(), client.Credentials);
replaceCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd, ctx);
return replaceCmd;
}
private static StoreResult GetStoreResult(TableResult result)
{
if (result.IsSuccess())
{
return StoreResult.Success;
}
if (result.IsNotFound())
{
return StoreResult.NotFound;
}
if (result.IsConflict())
{
return StoreResult.Conflict;
}
if (result.IsServerError())
{
return StoreResult.InternalError;
}
return StoreResult.OperationError;
}
private static RESTCommand<TableResult> InsertImpl(TableOperation operation, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
RESTCommand<TableResult> insertCmd = new RESTCommand<TableResult>(client.Credentials, operation.GenerateRequestURI(client.StorageUri, tableName));
requestOptions.ApplyToStorageCommand(insertCmd);
TableResult result = new TableResult() { Result = operation.Entity };
insertCmd.RetrieveResponseStream = true;
insertCmd.Handler = client.AuthenticationHandler;
insertCmd.BuildClient = HttpClientFactory.BuildHttpClient;
insertCmd.ParseError = StorageExtendedErrorInformation.ReadFromStreamUsingODataLib;
insertCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableOperation(cmd, uri, builder, serverTimeout, operation, client, cnt, ctx, requestOptions.PayloadFormat.Value);
insertCmd.PreProcessResponse = (cmd, resp, ex, ctx) => TableOperationHttpResponseParsers.TableOperationPreProcess(result, operation, resp, ex, cmd, ctx);
insertCmd.PostProcessResponse = (cmd, resp, ctx) => TableOperationHttpResponseParsers.TableOperationPostProcess(result, operation, cmd, resp, ctx, requestOptions, client.AccountName);
return insertCmd;
}
