public TableStorageSiteUrlRepository(IStorageQueueConfiguration configuration)
{
_storageAccount = CloudStorageAccount.Parse(configuration.GetConnectionString());
_tableClient = _storageAccount.CreateCloudTableClient();
_tableClient.GetTableReference(_tableName);
_tableClient.GetTableReference(_tableName).CreateIfNotExists();
_tableContext = _tableClient.GetTableServiceContext();
}
public StorageWrapper()
{
_storageAccount = CloudStorageAccount.Parse(
RoleEnvironment.GetConfigurationSettingValue(_connectionStringName)
);
_tableClient = _storageAccount.CreateCloudTableClient();
_tableClient.GetTableReference(_tableName);
_tableClient.GetTableReference(_tableName).CreateIfNotExists();
_tableContext = _tableClient.GetTableServiceContext();
}
/// <summary>
/// Initializes a new instance of the <see cref="AzureTableStorageErrorLog"/> class
/// using a dictionary of configured settings.
/// </summary>
public AzureTableStorageErrorLog(IDictionary config)
{
if (config == null)
throw new ArgumentNullException("config");
var connectionString = ElmahHelper.GetConnectionString(config);
//
// If there is no connection string to use then throw an
// exception to abort construction.
//
if (connectionString.Length == 0)
throw new ApplicationException("Connection string is missing for the Azure Table Storage error log.");
var cloudStorageAccount = CloudStorageAccount.Parse(connectionString);
var tableClient = cloudStorageAccount.CreateCloudTableClient();
_tableContext = tableClient.GetTableServiceContext();
_cloudTable = tableClient.GetTableReference(TableName);
_cloudTable.CreateIfNotExists();
//
// Set the application name as this implementation provides
// per-application isolation over a single store.
//
var appName = config.Find("applicationName", string.Empty);
if (appName.Length > MaxAppNameLength)
{
throw new ApplicationException(string.Format(
"Application name is too long. Maximum length allowed is {0} characters.",
MaxAppNameLength.ToString("N0")));
}
ApplicationName = appName;
}
private static void SaveBatchWithRetries(TableServiceContext client)
{
var tableRequestOptions = new TableRequestOptions
{
RetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 10)
};
client.SaveChangesWithRetries(SaveChangesOptions.Batch,
tableRequestOptions);
}
/// <summary>
/// Actually flushes the appender internally.
/// </summary>
private void FlushInternal()
{
lock (_flushLock)
{
if (_isFlushing)
return;
_isFlushing = true;
}
try
{
// Logmarker needed?
if (DateTime.UtcNow > _nextLogmarkerTime)
{
_nextLogmarkerTime = DateTime.UtcNow.AddMinutes(LogmarkerIntervalInMinutes);
_logger.Info("Logmarker...");
}
// Create the context if we need to
if (context == null || _refreshOptions)
{
_refreshOptions = false;
_logger.Debug("Creating a new TableServiceContext...");
CloudTableClient tableClient = StorageAccount.CreateCloudTableClient();
tableClient.RetryPolicy = new LinearRetry(TimeSpan.FromMinutes(1), 3);
CloudTable table = tableClient.GetTableReference(TableName);
table.CreateIfNotExists();
context = tableClient.GetTableServiceContext();
}
// Clear the queue, add objects to context
while (true)
{
WadTableEntity entity;
lock (_logEntities)
{
if (_logEntities.Count == 0)
break;
entity = _logEntities.Dequeue();
}
context.AddObject(TableName, entity);
}
// Save the changes (i/o operation)
context.SaveChangesWithRetries();
}
finally
{
lock (_flushLock)
{
_isFlushing = false;
}
}
}
/// <summary>
/// Forces a flush of the logentities collected in the appender to the table storage.
/// </summary>
public void Flush()
{
try
{
FlushInternal();
}
catch (Exception ex)
{
_logger.Error("Error transferring logs to storage", ex);
context = null;
try
{
// Besides the usual retry policy on the datacontext, we notice that every now and then saving to table storage fails due to, which
// seems like, a faulted state of the datacontext. Hence this manual retry as the datacontext will have been cleared and will
// be recreated on the next attempt.
FlushInternal();
}
catch (Exception ex2)
{
_logger.Error("Error transferring logs to storage (again)", ex2);
context = null;
}
}
}
public void SingleEntityInsertDeleteFail()
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
// Delete Entity that does not exits
ComplexEntity deleteEntity = new ComplexEntity("insert test", "foo");
ctx.AttachTo(currentTable.Name, deleteEntity, "*");
ctx.DeleteObject(deleteEntity);
OperationContext opContext = new OperationContext();
try
{
ctx.SaveChangesWithRetries(SaveChangesOptions.None, null, opContext);
Assert.Fail();
}
catch (StorageException)
{
TestHelper.ValidateResponse(opContext, 1, (int)HttpStatusCode.NotFound, new string[] { "ResourceNotFound" }, "The specified resource does not exist.");
}
ctx = tableClient.GetTableServiceContext();
TableServiceContext ctx2 = tableClient.GetTableServiceContext();
// Insert Entity
ComplexEntity insertEntity = new ComplexEntity("insert test", "foo");
ctx.AddObject(currentTable.Name, insertEntity);
ctx.SaveChangesWithRetries();
// Update Entity
ComplexEntity retrievedEntity = (from ent in ctx2.CreateQuery <ComplexEntity>(currentTable.Name)
where ent.PartitionKey == insertEntity.PartitionKey &&
ent.RowKey == insertEntity.RowKey
select ent).AsTableServiceQuery(ctx2).Execute().FirstOrDefault();
retrievedEntity.String = "updated value";
ctx2.UpdateObject(retrievedEntity);
ctx2.SaveChangesWithRetries();
// Now delete old reference with stale etag and validate exception
ctx.DeleteObject(insertEntity);
opContext = new OperationContext();
try
{
ctx.SaveChangesWithRetries(SaveChangesOptions.None, null, opContext);
Assert.Fail();
}
catch (StorageException)
{
TestHelper.ValidateResponse(opContext,
1,
(int)HttpStatusCode.PreconditionFailed,
new string[] { "UpdateConditionNotSatisfied", "ConditionNotMet" },
new string[] { "The update condition specified in the request was not satisfied.", "The condition specified using HTTP conditional header(s) is not met." });
}
}
public TableServiceQuery(IQueryable <TElement> query, TableServiceContext context)
{
this.Query = query as DataServiceQuery <TElement>;
this.Context = context;
this.IgnoreResourceNotFoundException = false;
}
public void SingleEntityInsertOrReplaceAPM()
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
TableServiceContext queryContext = tableClient.GetTableServiceContext();
queryContext.MergeOption = MergeOption.NoTracking;
// Insert Entity
BaseEntity baseEntity = new BaseEntity("insert test", "foo");
// Insert Or Merge with no pre-existing entity
MergeEntity insertOrReplaceEntity = new MergeEntity(baseEntity.PartitionKey, baseEntity.RowKey);
insertOrReplaceEntity.Randomize();
ctx.AttachTo(currentTable.Name, insertOrReplaceEntity, null);
ctx.UpdateObject(insertOrReplaceEntity);
using (ManualResetEvent evt = new ManualResetEvent(false))
{
IAsyncResult asyncRes = null;
ctx.BeginSaveChangesWithRetries(
SaveChangesOptions.ReplaceOnUpdate,
(res) =>
{
asyncRes = res;
evt.Set();
},
null);
evt.WaitOne();
ctx.EndSaveChangesWithRetries(asyncRes);
}
ctx.Detach(insertOrReplaceEntity);
// Retrieve Entity & Verify Contents
UnionEnitity retrievedEntity = (from ent in queryContext.CreateQuery <UnionEnitity>(currentTable.Name)
where ent.PartitionKey == baseEntity.PartitionKey &&
ent.RowKey == baseEntity.RowKey
select ent).AsTableServiceQuery(queryContext).Execute().FirstOrDefault();
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(null, retrievedEntity.A);
Assert.AreEqual(null, retrievedEntity.B);
Assert.AreEqual(null, retrievedEntity.C);
Assert.AreEqual(insertOrReplaceEntity.D, retrievedEntity.D);
Assert.AreEqual(insertOrReplaceEntity.E, retrievedEntity.E);
Assert.AreEqual(insertOrReplaceEntity.F, retrievedEntity.F);
BaseEntity replacedEntity = new BaseEntity("insert test", "foo");
replacedEntity.Randomize();
ctx.AttachTo(currentTable.Name, replacedEntity, null);
ctx.UpdateObject(replacedEntity);
using (ManualResetEvent evt = new ManualResetEvent(false))
{
IAsyncResult asyncRes = null;
ctx.BeginSaveChangesWithRetries(SaveChangesOptions.ReplaceOnUpdate, (res) =>
{
asyncRes = res;
evt.Set();
}, null);
evt.WaitOne();
ctx.EndSaveChangesWithRetries(asyncRes);
}
// Retrieve Entity & Verify
retrievedEntity = (from ent in queryContext.CreateQuery <UnionEnitity>(currentTable.Name)
where ent.PartitionKey == baseEntity.PartitionKey &&
ent.RowKey == baseEntity.RowKey
select ent).AsTableServiceQuery(queryContext).Execute().FirstOrDefault();
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(replacedEntity.A, retrievedEntity.A);
Assert.AreEqual(replacedEntity.B, retrievedEntity.B);
Assert.AreEqual(replacedEntity.C, retrievedEntity.C);
Assert.AreEqual(null, retrievedEntity.D);
Assert.AreEqual(null, retrievedEntity.E);
Assert.AreEqual(null, retrievedEntity.F);
}
public void TableServiceContextConcurrencyAllowsOnlySingleOperationAtOnce()
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext tableContext = tableClient.GetTableServiceContext();
// insert entities to query against
for (int i = 0; i < 5; i++)
{
for (int m = 0; m < 100; m++)
{
BaseEntity ent = new BaseEntity("testpartition" + i, m.ToString());
ent.Randomize();
ent.A = ent.RowKey;
tableContext.AddObject(currentTable.Name, ent);
}
tableContext.SaveChangesWithRetries(SaveChangesOptions.Batch);
}
List <OperationContext> opContexts = new List <OperationContext>();
object lockerObj = new object();
DateTime start = DateTime.Now;
int threadsRunning = 0;
Exception lastEx = null;
// Start 10 simultaneous threads to query entities associated with same context.
for (int j = 0; j < 10; j++)
{
opContexts.Add(new OperationContext());
Thread newThread = new Thread((arg) =>
{
Interlocked.Increment(ref threadsRunning);
try
{
lock (lockerObj)
{
Monitor.Wait(lockerObj);
}
TableServiceQuery <BaseEntity> query = (from ent in tableContext.CreateQuery <BaseEntity>(currentTable.Name)
select ent).AsTableServiceQuery(tableContext);
Debug.WriteLine(String.Format("Thread {0} start operation @ {1}", Thread.CurrentThread.ManagedThreadId, (DateTime.Now - start).TotalMilliseconds));
try
{
query.Execute(null, arg as OperationContext).ToList();
}
catch (Exception)
{
// no op, expected to have some exceptions
}
Debug.WriteLine(String.Format("Thread {0} end operation @ {1}", Thread.CurrentThread.ManagedThreadId, (DateTime.Now - start).TotalMilliseconds));
}
catch (Exception ex)
{
lastEx = ex;
}
finally
{
Interlocked.Decrement(ref threadsRunning);
}
});
newThread.Start(opContexts[j]);
}
// Wait for all threads to start
while (Interlocked.CompareExchange(ref threadsRunning, 10, 10) < 10)
{
Thread.Sleep(200);
}
// pulse all threads
lock (lockerObj)
{
Monitor.PulseAll(lockerObj);
}
// Wait for all threads to complete
while (Interlocked.CompareExchange(ref threadsRunning, -1, 0) > -1)
{
Thread.Sleep(200);
}
if (lastEx != null)
{
throw lastEx;
}
foreach (OperationContext opContext in opContexts)
{
if (opContext.LastResult == null || opContext.LastResult.StartTime == null || opContext.LastResult.EndTime == null)
{
continue;
}
TestHelper.AssertNAttempts(opContext, 1);
RequestResult currRes = opContext.LastResult;
// Make sure this results start time does not occur in between any other results start & end time
IEnumerable <RequestResult> overlappingResults = (from ctx in opContexts
where ctx.LastResult != null && ctx.LastResult != currRes &&
ctx.LastResult.StartTime != null && ctx.LastResult.EndTime != null &&
ctx.LastResult.StartTime.Ticks <currRes.StartTime.Ticks &&
ctx.LastResult.EndTime.Ticks> currRes.StartTime.Ticks
select ctx.LastResult);
Assert.AreEqual(overlappingResults.Count(), 0, "Detected overlapping query");
}
}
public static TableServiceQuery <TElement> AsTableServiceQuery <TElement>(this IQueryable <TElement> query, TableServiceContext context)
{
return(new TableServiceQuery <TElement>(query as DataServiceQuery <TElement>, context));
}
/// <summary>
/// Setup azure table context.
/// </summary>
private void SetupStorageContext()
{
//validate table name
ValidateTableProperties(TableName, "Table name", TableResource.TableConfigurationError, TableNameRegularExpression);
// Create the table client.
TableClient = _account.CreateCloudTableClient();
//Create table service context.
Context = new TableServiceContext(TableClient);
ArgumentValidator.ValidateNonNullReference(Context, "Table name", TableResource.TableConfigurationError);
if (Context != null)
{
try
{
//Gets a reference to the specified table name.
Table = TableClient.GetTableReference(TableName.ToLower());
//Create the table if it doesn't exist.
//Table.CreateIfNotExists();
}
catch (TableStorageException storageException)
{
throw new Exception(TableResource.TableConfigurationError, storageException);
}
catch (Exception)
{
throw new Exception(TableResource.TableConfigurationError);
}
}
}
// Perform table storage operations.
private static void TestTableStorage()
{
string storageConnectionString = ConfigurationManager.ConnectionStrings["Storage"].ConnectionString;
TableHelper TableHelper = new TableHelper(storageConnectionString);
try
{
Separator();
List<CloudTable> tables;
Console.Write("List tables ");
if (TableHelper.ListTables(out tables))
{
Console.WriteLine("true");
if (tables != null)
{
foreach (CloudTable tableName in tables)
{
Console.Write(tableName.Name + " ");
}
Console.WriteLine();
}
}
else
{
Console.WriteLine("false");
}
Separator();
Console.Write("Create table ");
if (TableHelper.CreateTable("sampletable"))
{
Console.WriteLine("true");
}
else
{
Console.WriteLine("false");
}
Separator();
Console.Write("Insert entity ");
if (TableHelper.InsertEntity("sampletable",
new Contact("USA", "Pallmann") { LastName = "Pallmann", FirstName = "David", Email = "*****@*****.**", Country = "USA" }))
{
Console.WriteLine("true");
}
else
{
Console.WriteLine("false");
}
Separator();
Console.Write("Insert entity ");
if (TableHelper.InsertEntity("sampletable",
new Contact("USA", "Smith") { LastName = "Smith", FirstName = "John", Email = "*****@*****.**", Country = "USA" }))
{
Console.WriteLine("true");
}
else
{
Console.WriteLine("false");
}
Separator();
Console.Write("Insert entity ");
if (TableHelper.InsertEntity("sampletable",
new Contact("USA", "Jones") { LastName = "Jones", FirstName = "Tom", Email = "*****@*****.**", Country = "USA" }))
{
Console.WriteLine("true");
}
else
{
Console.WriteLine("false");
}
Separator();
Console.Write("Insert entity ");
if (TableHelper.InsertEntity("sampletable",
new Contact("USA", "Peters") { LastName = "Peters", FirstName = "Sally", Email = "*****@*****.**", Country = "USA" }))
{
Console.WriteLine("true");
}
else
{
Console.WriteLine("false");
}
Separator();
Console.Write("Update entity ");
if (TableHelper.ReplaceUpdateEntity("sampletable", "USA", "Pallmann",
new Contact("USA", "Pallmann") { LastName = "Pallmann", FirstName = "David", Email = "*****@*****.**", Country = "USA" }))
{
Console.WriteLine("true");
}
else
{
Console.WriteLine("false");
}
Separator();
Console.Write("Replace Update entity ");
if (TableHelper.ReplaceUpdateEntity("sampletable", "USA", "Peters",
new Contact("USA", "Peters") { LastName = "Peters", FirstName = "Sally", Country = "USA" }))
{
Console.WriteLine("true");
}
else
{
Console.WriteLine("false");
}
Separator();
Console.Write("Merge Update entity ");
if (TableHelper.MergeUpdateEntity("sampletable", "USA", "Peters",
new MiniContact("USA", "Peters") { LastName = "Peters", FirstName = "Sally", Email = "*****@*****.**" }))
{
Console.WriteLine("true");
}
else
{
Console.WriteLine("false");
}
Separator();
Contact contact = null;
Console.Write("Get entity ");
if (TableHelper.GetEntity<Contact>("sampletable", "USA", "Pallmann", out contact))
{
Console.WriteLine("true");
if (contact != null)
{
Console.WriteLine("Contact.LastName: " + contact.LastName);
Console.WriteLine("Contact.FirstName: " + contact.FirstName);
Console.WriteLine("Contact.Email: " + contact.Email);
Console.WriteLine("Contact.Phone: " + contact.Phone);
Console.WriteLine("Contact.Country: " + contact.Country);
}
else
{
Console.WriteLine("Contact <NULL>");
}
}
else
{
Console.WriteLine("false");
}
Separator();
Console.Write("Query entities ");
TableServiceContext tableServiceContext = new TableServiceContext(TableHelper.TableClient);
IEnumerable<Contact> entities = TableHelper.QueryEntities<Contact>("sampletable").Where(e => e.PartitionKey == "USA").AsTableServiceQuery<Contact>(tableServiceContext);
if (entities != null)
{
Console.WriteLine("true");
foreach (Contact contact1 in entities)
{
Console.WriteLine("Contact.LastName: " + contact1.LastName);
Console.WriteLine("Contact.FirstName: " + contact1.FirstName);
Console.WriteLine("Contact.Email: " + contact1.Email);
Console.WriteLine("Contact.Phone: " + contact1.Phone);
Console.WriteLine("Contact.Country: " + contact1.Country);
Console.WriteLine();
}
}
else
{
Console.WriteLine("<NULL>");
}
//Console.Write("Query entities ");
//var query = (
// from Contact c
// in TableHelper.QueryEntities<Contact>("sampletable")
// where c.PartitionKey == "USA"
// select c
// ).AsTableServiceQuery<Contact>();
//IEnumerable<Contact> entities = query.ToList();
//if (entities != null)
//{
// Console.WriteLine("true");
// foreach (Contact contact1 in entities)
// {
// Console.WriteLine("Contact.LastName: " + contact1.LastName);
// Console.WriteLine("Contact.FirstName: " + contact1.FirstName);
// Console.WriteLine("Contact.Email: " + contact1.Email);
// Console.WriteLine("Contact.Phone: " + contact1.Phone);
// Console.WriteLine("Contact.Country: " + contact1.Country);
// Console.WriteLine();
// }
//}
//else
//{
// Console.WriteLine("<NULL>");
//}
Separator();
Console.Write("Delete entity ");
if (TableHelper.DeleteEntity<Contact>("sampletable", "USA", "Smith"))
{
Console.WriteLine("true");
}
else
{
Console.WriteLine("false");
}
////Separator();
////Console.Write("Delete table ");
////if (TableHelper.DeleteTable("sampletable"))
////{
//// Console.WriteLine("true");
////}
////else
////{
//// Console.WriteLine("false");
////}
}
catch (Exception ex)
{
Console.WriteLine("EXCEPTION " + ex.ToString());
}
}
