private void CheckAlertWriteError(string operation, object data1, string data2, Exception exc)
{
HttpStatusCode httpStatusCode;
string restStatus;
if (AzureStorageUtils.EvaluateException(exc, out httpStatusCode, out restStatus) && AzureStorageUtils.IsContentionError(httpStatusCode))
{
// log at Verbose, since failure on conditional is not not an error. Will analyze and warn later, if required.
if (Logger.IsVerbose)
{
Logger.Verbose(ErrorCode.AzureTable_13,
String.Format("Intermediate Azure table write error {0} to table {1} data1 {2} data2 {3}",
operation, TableName, (data1 ?? "null"), (data2 ?? "null")), exc);
}
}
else
{
Logger.Error(ErrorCode.AzureTable_14,
string.Format("Azure table access write error {0} to table {1} entry {2}", operation, TableName, data1), exc);
}
}
/// <summary>
/// Insert (create new) row entry
/// </summary>
/// <param name="siloEntry">Silo Entry to be written</param>
internal async Task <bool> TryCreateTableVersionEntryAsync()
{
try
{
var versionRow = await storage.ReadSingleTableEntryAsync(DeploymentId, SiloInstanceTableEntry.TABLE_VERSION_ROW);
if (versionRow != null && versionRow.Item1 != null)
{
return(false);
}
SiloInstanceTableEntry entry = CreateTableVersionEntry(0);
await storage.CreateTableEntryAsync(entry);
return(true);
}
catch (Exception exc)
{
HttpStatusCode httpStatusCode;
string restStatus;
if (!AzureStorageUtils.EvaluateException(exc, out httpStatusCode, out restStatus))
{
throw;
}
if (logger.IsVerbose2)
{
logger.Verbose2("InsertSiloEntryConditionally failed with httpStatusCode={0}, restStatus={1}", httpStatusCode, restStatus);
}
if (AzureStorageUtils.IsContentionError(httpStatusCode))
{
return(false);
}
throw;
}
}
/// <summary>
/// Read data entries and their corresponding eTags from the Azure table.
/// </summary>
/// <param name="predicate">Predicate function to use for querying the table and filtering the results.</param>
/// <returns>Enumeration of entries in the table which match the query condition.</returns>
internal async Task <IEnumerable <Tuple <T, string> > > ReadTableEntriesAndEtagsAsync(Expression <Func <T, bool> > predicate)
{
const string operation = "ReadTableEntriesAndEtags";
var startTime = DateTime.UtcNow;
try
{
TableServiceContext svc = tableOperationsClient.GetDataServiceContext();
// Improve performance when table name differs from class name
// http://www.gtrifonov.com/2011/06/15/improving-performance-for-windows-azure-tables/
svc.ResolveType = ResolveEntityType;
//IQueryable<T> query = svc.CreateQuery<T>(TableName).Where(predicate);
CloudTableQuery <T> cloudTableQuery = svc.CreateQuery <T>(TableName).Where(predicate).AsTableServiceQuery(); // turn IQueryable into CloudTableQuery
try
{
Func <Task <List <T> > > executeQueryHandleContinuations = async() =>
{
// Read table with continuation token
// http://convective.wordpress.com/2013/11/03/queries-in-the-windows-azure-storage-client-library-v2-1/
// 1) First wrong sync way to read:
// List<T> queryResults = query.ToList(); // ToList will actually execute the query and add entities to svc. However, this will not handle continuation tokens.
// 2) Second correct sync way to read:
// http://convective.wordpress.com/2010/02/06/queries-in-azure-tables/
// CloudTableQuery.Execute will properly retrieve all the records from a table through the automatic handling of continuation tokens:
Task <ResultSegment <T> > firstSegmentPromise = Task <ResultSegment <T> > .Factory.FromAsync(
cloudTableQuery.BeginExecuteSegmented,
cloudTableQuery.EndExecuteSegmented,
null);
// 3) Third wrong async way to read:
// return firstSegmentPromise;
// 4) Forth correct async way to read - handles continuation tokens:
var list = new List <T>();
Task <ResultSegment <T> > nextSegmentAsync = firstSegmentPromise;
while (true)
{
ResultSegment <T> resultSegment = await nextSegmentAsync;
var capture = resultSegment.Results;
if (capture != null) // don't call Count or Any or anything else that can potentialy cause multiple evaluations of the IEnumerable
{
list.AddRange(capture);
}
if (!resultSegment.HasMoreResults)
{
// All data was read successfully if we got to here
break;
}
// ask to read the next segment
nextSegmentAsync = Task <ResultSegment <T> > .Factory.FromAsync(
resultSegment.BeginGetNext,
resultSegment.EndGetNext,
null);
}
return(list);
};
IBackoffProvider backoff = new FixedBackoff(AzureTableDefaultPolicies.PauseBetweenTableOperationRetries);
List <T> results = await AsyncExecutorWithRetries.ExecuteWithRetries(
counter => executeQueryHandleContinuations(),
AzureTableDefaultPolicies.MaxTableOperationRetries,
(exc, counter) => AzureStorageUtils.AnalyzeReadException(exc.GetBaseException(), counter, TableName, Logger),
AzureTableDefaultPolicies.TableOperationTimeout,
backoff);
// Data was read successfully if we got to here
return(PairEntitiesWithEtags(svc, results));
}
catch (Exception exc)
{
// Out of retries...
var errorMsg = string.Format("Failed to read Azure storage table {0}: {1}", TableName, exc.Message);
if (!AzureStorageUtils.TableStorageDataNotFound(exc))
{
Logger.Warn(ErrorCode.AzureTable_09, errorMsg, exc);
}
throw new OrleansException(errorMsg, exc);
}
}
finally
{
CheckAlertSlowAccess(startTime, operation);
}
}
private void CheckAlertWriteError(string operation, object data1, string data2, Exception exc)
{
HttpStatusCode httpStatusCode;
string restStatus;
if (AzureStorageUtils.EvaluateException(exc, out httpStatusCode, out restStatus) && AzureStorageUtils.IsContentionError(httpStatusCode))
{
// log at Verbose, since failure on conditional is not not an error. Will analyze and warn later, if required.
if (Logger.IsEnabled(LogLevel.Debug))
{
Logger.Debug(ErrorCode.AzureTable_13,
$"Intermediate Azure table write error {operation} to table {TableName} data1 {(data1 ?? "null")} data2 {(data2 ?? "null")}", exc);
}
}
else
{
Logger.Error(ErrorCode.AzureTable_14,
$"Azure table access write error {operation} to table {TableName} entry {data1}", exc);
}
}