private static TableResult GetTableResultFromDocument(TableOperation operation, Document response, OperationContext context, TableRequestOptions requestOptions, string sessionToken, double requestCharge)
{
var responseETag = EtagHelper.ConvertFromBackEndETagFormat(response.ETag);
response.SetPropertyValue("_etag", responseETag);
TableResult tableResult = new TableResult();
tableResult.Etag = response.ETag;
tableResult.HttpStatusCode = GetSuccessStatusCodeFromOperationType(operation.OperationType);
tableResult.SessionToken = sessionToken;
tableResult.RequestCharge = requestCharge;
if (operation.OperationType != TableOperationType.Retrieve)
{
operation.Entity.ETag = response.ETag;
tableResult.Result = operation.Entity;
}
else if (operation.RetrieveResolver != null)
{
tableResult.Result = operation.RetrieveResolver(response.GetPropertyValue <string>("$pk"), response.Id, response.Timestamp, EntityTranslator.GetEntityPropertiesFromDocument(response, operation.SelectColumns), response.ETag);
}
else
{
tableResult.Result = EntityHelpers.GetEntityFromDocument(response, context, operation.SelectColumns);
}
return(tableResult);
}
public void GivenIBuildAnEtagFromDiscriminatorAndAListOfEtags(string discriminator, Table table)
{
string[] etags = table.Rows.Select(x => x[0]).ToArray();
string result = EtagHelper.BuildEtag(discriminator, etags);
this.StoreGeneratedEtag(result);
}
private static TableResult GetTableResultFromResponse(TableOperation operation, ResourceResponse <Document> response, OperationContext context, TableRequestOptions options, List <string> selectColumns, string sessionToken)
{
TableResult tableResult = new TableResult();
tableResult.Etag = EtagHelper.ConvertFromBackEndETagFormat(response.ResponseHeaders["ETag"]);
tableResult.HttpStatusCode = (int)response.StatusCode;
tableResult.SessionToken = sessionToken;
tableResult.RequestCharge = response.RequestCharge;
if (operation.Entity != null && !string.IsNullOrEmpty(tableResult.Etag))
{
operation.Entity.ETag = tableResult.Etag;
}
if (operation.OperationType == TableOperationType.InsertOrReplace || operation.OperationType == TableOperationType.Replace || !operation.EchoContent)
{
tableResult.HttpStatusCode = 204;
}
if (operation.OperationType != TableOperationType.Retrieve)
{
if (operation.OperationType != TableOperationType.Delete)
{
tableResult.Result = operation.Entity;
ITableEntity tableEntity = tableResult.Result as ITableEntity;
if (tableEntity != null)
{
if (tableResult.Etag != null)
{
tableEntity.ETag = tableResult.Etag;
}
tableEntity.Timestamp = response.Resource.Timestamp;
}
}
}
else if (response.Resource != null)
{
if (operation.RetrieveResolver == null)
{
tableResult.Result = EntityHelpers.GetEntityFromResourceStream(response.ResponseStream, context, operation.SelectColumns);
}
else
{
EntityHelpers.GetPropertiesFromResourceStream(response.ResponseStream, operation.SelectColumns, out IDictionary <string, EntityProperty> entityProperties, out IDictionary <string, EntityProperty> documentDBProperties);
if (options.ProjectSystemProperties.Value)
{
EdmConverter.ValidateDocumentDBProperties(documentDBProperties);
EntityProperty entityProperty = documentDBProperties["$pk"];
EntityProperty entityProperty2 = documentDBProperties["$id"];
EntityProperty entityProperty3 = documentDBProperties["_etag"];
EntityProperty entityProperty4 = documentDBProperties["_ts"];
string arg = EtagHelper.ConvertFromBackEndETagFormat(entityProperty3.StringValue);
DateTime dateTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(entityProperty4.DoubleValue.Value);
tableResult.Result = operation.RetrieveResolver(entityProperty.StringValue, entityProperty2.StringValue, dateTime, entityProperties, arg);
}
else
{
tableResult.Result = operation.RetrieveResolver(null, null, default(DateTimeOffset), entityProperties, null);
}
}
}
return(tableResult);
}
public async Task <bool> UpsertRow(string deploymentId, MembershipEntry entry, string etag, TableVersion tableVersion)
{
try
{
var subDocument = MembershipBase.Create <DeploymentMembership>(entry);
var memberKey = $"Members.{BuildKey(entry.SiloAddress)}";
var etagCheck =
etag == null?
Filter.Not(Filter.Exists(memberKey)) :
Filter.Eq($"{memberKey}.Etag", etag);
var result = await Collection.UpdateOneAsync(
Filter.And(
Filter.Eq(x => x.DeploymentId, deploymentId),
Filter.Eq(x => x.VersionEtag, tableVersion.VersionEtag),
etagCheck),
Update
.Set(memberKey, subDocument)
.Set(x => x.Version, tableVersion.Version)
.Set(x => x.VersionEtag, EtagHelper.CreateNew()),
Upsert);
return(true);
}
catch (MongoException ex)
{
if (ex.IsDuplicateKey())
{
return(false);
}
throw;
}
}
private async Task UpsertWorkflowInstanceCoreAsync(WorkflowInstance workflowInstance)
{
string serializedInstance = JsonConvert.SerializeObject(workflowInstance, this.serializerSettingsProvider.Instance);
string newetag = EtagHelper.BuildEtag(nameof(SqlWorkflowInstanceStore), serializedInstance);
DataTable interests = BuildInterests(workflowInstance.Interests);
using SqlConnection connection = await this.connectionFactory().ConfigureAwait(false);
using SqlCommand command = connection.CreateCommand();
command.Parameters.Add("@workflowInstanceId", SqlDbType.NVarChar, 50).Value = workflowInstance.Id;
command.Parameters.Add("@etag", SqlDbType.NVarChar, 50).Value = workflowInstance.ETag ?? (object)DBNull.Value;
command.Parameters.Add("@newetag", SqlDbType.NVarChar, 50).Value = newetag;
command.Parameters.Add("@serializedInstance", SqlDbType.NVarChar, -1).Value = serializedInstance;
command.Parameters.AddWithValue("@interests", interests);
SqlParameter returnValue = command.Parameters.Add("@returnValue", SqlDbType.Int);
returnValue.Direction = ParameterDirection.ReturnValue;
command.CommandText = "UpsertWorkflowInstance";
command.CommandType = CommandType.StoredProcedure;
await connection.OpenAsync().ConfigureAwait(false);
await command.ExecuteNonQueryAsync().ConfigureAwait(false);
if ((int)returnValue.Value == 409)
{
throw new WorkflowInstanceConflictException($"The workflow instance with id {workflowInstance.Id} was already modified.");
}
workflowInstance.ETag = newetag;
}
private async Task <FileOperationResult <IImage> > GetImageFileOperation(string type, string regionUrn, Guid id, int?width, int?height, Func <Task <FileOperationResult <IImage> > > action, EntityTagHeaderValue etag = null)
{
try
{
var sw = Stopwatch.StartNew();
var sizeHash = (width ?? 0) + (height ?? 0);
var result = await CacheManager.GetAsync($"urn:{type}_by_id_operation:{id}:{sizeHash}", action, regionUrn);
if (!result.IsSuccess)
{
return(new FileOperationResult <IImage>(result.IsNotFoundResult, result.Messages));
}
if (result.ETag == etag && etag != null)
{
return(new FileOperationResult <IImage>(OperationMessages.NotModified));
}
var force = width.HasValue || height.HasValue;
var newWidth = width ?? Configuration.MaximumImageSize.Width;
var newHeight = height ?? Configuration.MaximumImageSize.Height;
if (result?.Data?.Bytes != null)
{
var resized = ImageHelper.ResizeImage(result?.Data?.Bytes, newWidth, newHeight, force);
if (resized != null)
{
result.Data.Bytes = resized.Item2;
result.ETag = EtagHelper.GenerateETag(HttpEncoder, result.Data.Bytes);
result.LastModified = DateTime.UtcNow;
if (resized.Item1)
{
Logger.LogTrace($"{type}: Resized [{id}], Width [{ newWidth}], Height [{ newHeight}], Forced [{ force }]");
}
}
else
{
Logger.LogTrace($"{type}: Image [{id}] Request returned Null Image, Forced [{ force }]");
}
}
sw.Stop();
return(new FileOperationResult <IImage>(result.Messages)
{
Data = result.Data,
ETag = result.ETag,
LastModified = result.LastModified,
ContentType = result.ContentType,
Errors = result?.Errors,
IsSuccess = result?.IsSuccess ?? false,
OperationTime = sw.ElapsedMilliseconds
});
}
catch (Exception ex)
{
Logger.LogError(ex, $"GetImageFileOperation Error, Type [{type}], id [{id}]");
}
return(new FileOperationResult <IImage>("System Error"));
}
dynamic GetAllGroups(string classifier, string classifierFilter)
{
using (var session = Store.OpenSession())
{
var results = GroupFetcher.GetGroups(session, classifier, classifierFilter);
return(Negotiate.WithModel(results)
.WithDeterministicEtag(EtagHelper.CalculateEtag(results)));
}
}
async Task <dynamic> GetAllGroups(string classifier, string classifierFilter)
{
using (var session = Store.OpenAsyncSession())
{
var results = await GroupFetcher.GetGroups(session, classifier, classifierFilter).ConfigureAwait(false);
return(Negotiate.WithModel(results)
.WithDeterministicEtag(EtagHelper.CalculateEtag(results)));
}
}
public void RetryStartTime_changed_should_change_etag()
{
var group = new GroupOperation();
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.OperationStartTime = DateTime.UtcNow;
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public void RetryProgress_changed_should_change_etag()
{
var group = new RetryGroup();
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.RetryProgress = 0.01;
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public void NeedUserAcknowledgement_changed_should_change_etag()
{
var group = new RetryGroup();
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.NeedUserAcknowledgement = true;
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public void RetryCompletionTime_changed_should_change_etag()
{
var group = new RetryGroup();
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.RetryCompletionTime = DateTime.UtcNow;
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public void Changing_item_count_should_change_etag()
{
var data = new RetryGroup[0];
var knownEtag = EtagHelper.CalculateEtag(data);
var group = new RetryGroup();
data = new[] { group };
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public void Id_changed_should_change_etag()
{
var group = new GroupOperation {
Id = "old"
};
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.Id = "new";
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public void RetryStatus_changed_should_change_etag()
{
var group = new GroupOperation {
OperationStatus = RetryState.Waiting.ToString()
};
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.OperationStatus = RetryState.Preparing.ToString();
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public void Count_changed_should_change_etag()
{
var group = new GroupOperation {
Count = 1
};
var data = new[] { group };
var knownEtag = EtagHelper.CalculateEtag(data);
group.Count = 2;
var newEtag = EtagHelper.CalculateEtag(data);
Assert.AreNotEqual(knownEtag, newEtag);
}
public async Task <HttpResponseMessage> GetArchiveMessageGroups([FromUri] string classifierFilter = null, string classifier = "Exception Type and Stack Trace")
{
using (var session = store.OpenAsyncSession())
{
var groups = session.Query <FailureGroupView, ArchivedGroupsViewIndex>().Where(v => v.Type == classifier);
var results = await groups.OrderByDescending(x => x.Last)
.Take(200) // only show 200 groups
.ToListAsync()
.ConfigureAwait(false);
return(Negotiator.FromModel(Request, results)
.WithDeterministicEtag(EtagHelper.CalculateEtag(results)));
}
}
public async Task <HttpResponseMessage> GetAllGroups([FromUri] string classifierFilter = null, string classifier = "Exception Type and Stack Trace")
{
if (classifierFilter == "undefined")
{
classifierFilter = null;
}
using (var session = store.OpenAsyncSession())
{
var results = await groupFetcher.GetGroups(session, classifier, classifierFilter).ConfigureAwait(false);
return(Negotiator.FromModel(Request, results)
.WithDeterministicEtag(EtagHelper.CalculateEtag(results)));
}
}
private async Task <FileOperationResult <Image> > GetImageFileOperation(string type, string regionUrn, Guid id,
int?width, int?height, Func <Task <FileOperationResult <Image> > > action, EntityTagHeaderValue etag = null)
{
try
{
var sw = Stopwatch.StartNew();
var result = (await CacheManager.GetAsync($"urn:{type}_by_id_operation:{id}", action, regionUrn))
.Adapt <FileOperationResult <Image> >();
if (!result.IsSuccess)
{
return(new FileOperationResult <Image>(result.IsNotFoundResult, result.Messages));
}
if (result.ETag == etag)
{
return(new FileOperationResult <Image>(OperationMessages.NotModified));
}
if ((width.HasValue || height.HasValue) && result?.Data?.Bytes != null)
{
result.Data.Bytes = ImageHelper.ResizeImage(result?.Data?.Bytes, width.Value, height.Value);
result.ETag = EtagHelper.GenerateETag(HttpEncoder, result.Data.Bytes);
result.LastModified = DateTime.UtcNow;
if (width.Value != Configuration.ThumbnailImageSize.Width ||
height.Value != Configuration.ThumbnailImageSize.Height)
{
Logger.LogTrace($"{type}: Resized [{id}], Width [{width.Value}], Height [{height.Value}]");
}
}
sw.Stop();
return(new FileOperationResult <Image>(result.Messages)
{
Data = result.Data,
ETag = result.ETag,
LastModified = result.LastModified,
ContentType = result.ContentType,
Errors = result?.Errors,
IsSuccess = result?.IsSuccess ?? false,
OperationTime = sw.ElapsedMilliseconds
});
}
catch (Exception ex)
{
Logger.LogError(ex, $"GetImageFileOperation Error, Type [{type}], id [{id}]");
}
return(new FileOperationResult <Image>("System Error"));
}
private FileOperationResult <Image> GenerateFileOperationResult(Guid id, data.Image image, EntityTagHeaderValue etag = null, string contentType = "image/jpeg")
{
var imageEtag = EtagHelper.GenerateETag(this.HttpEncoder, image.Bytes);
if (EtagHelper.CompareETag(this.HttpEncoder, etag, imageEtag))
{
return(new FileOperationResult <Image>(OperationMessages.NotModified));
}
if (!image?.Bytes?.Any() ?? false)
{
return(new FileOperationResult <Image>(string.Format("ImageById Not Set [{0}]", id)));
}
return(new FileOperationResult <Image>(image?.Bytes?.Any() ?? false ? OperationMessages.OkMessage : OperationMessages.NoImageDataFound)
{
IsSuccess = true,
Data = image.Adapt <Image>(),
ContentType = contentType,
LastModified = (image.LastUpdated ?? image.CreatedDate),
ETag = imageEtag
});
}
internal static async Task <TableQuerySegment <TResult> > QueryDocumentsAsync <TResult>(int?maxItemCount, string filterString, IList <string> selectColumns, TableContinuationToken token, CloudTableClient client, CloudTable table, EntityResolver <TResult> resolver, TableRequestOptions requestOptions, OperationContext operationContext, bool isLinqExpression, IList <OrderByItem> orderByItems, string tombstoneKey)
{
ValidateContinuationToken(token);
selectColumns = ((selectColumns != null) ? new List <string>(selectColumns) : null);
Dictionary <string, bool> selectedSystemProperties = new Dictionary <string, bool>();
string sqlQuery = QueryTranslator.GetSqlQuery(GetSelectList(selectColumns, requestOptions, out selectedSystemProperties), filterString, isLinqExpression, isTableQuery: false, orderByItems, tombstoneKey, enableTimestampQuery: true);
FeedOptions defaultFeedOptions = GetDefaultFeedOptions(requestOptions);
if (maxItemCount.HasValue)
{
defaultFeedOptions.MaxItemCount = maxItemCount;
}
defaultFeedOptions.SessionToken = requestOptions.SessionToken;
defaultFeedOptions.RequestContinuation = token?.NextRowKey;
FeedResponse <Document> feedResponse = await client.DocumentClient.CreateDocumentQuery <Document>(table.GetCollectionUri(), sqlQuery, defaultFeedOptions).AsDocumentQuery().ExecuteNextAsync <Document>();
operationContext.RequestResults.Add(feedResponse.ToRequestResult());
List <TResult> list = new List <TResult>();
foreach (Document item in feedResponse)
{
var itemETag = EtagHelper.ConvertFromBackEndETagFormat(item.ETag);
item.SetPropertyValue("_etag", itemETag);
IDictionary <string, EntityProperty> entityPropertiesFromDocument = EntityTranslator.GetEntityPropertiesFromDocument(item, selectColumns);
list.Add(resolver(selectedSystemProperties["PartitionKey"] ? item.GetPropertyValue <string>("$pk") : null, selectedSystemProperties["RowKey"] ? item.GetPropertyValue <string>("$id") : null, selectedSystemProperties["Timestamp"] ? ((DateTimeOffset)item.Timestamp) : default(DateTimeOffset), entityPropertiesFromDocument, selectedSystemProperties["Etag"] ? item.ETag : null));
}
TableQuerySegment <TResult> tableQuerySegment = new TableQuerySegment <TResult>(list);
if (!string.IsNullOrEmpty(feedResponse.ResponseContinuation))
{
tableQuerySegment.ContinuationToken = new TableContinuationToken
{
NextRowKey = feedResponse.ResponseContinuation
};
}
tableQuerySegment.RequestCharge = feedResponse.RequestCharge;
return(tableQuerySegment);
}
public void GivenIBuildAnEtagFromDiscriminatorAndEtag(string discriminator, string etag)
{
string result = EtagHelper.BuildEtag(discriminator, etag);
this.StoreGeneratedEtag(result);
}
private static async Task <TableResult> HandleDeleteAsync(TableOperation operation, CloudTableClient client, CloudTable table, TableRequestOptions options, OperationContext context, CancellationToken cancellationToken)
{
if (operation.IsTableEntity)
{
string stringValue = ((DynamicTableEntity)operation.Entity).Properties["TableName"].StringValue;
Uri documentCollectionUri = UriFactory.CreateDocumentCollectionUri("TablesDB", stringValue);
return(EntityHelpers.GetTableResultFromResponse(await client.DocumentClient.DeleteDocumentCollectionAsync(documentCollectionUri), context));
}
RequestOptions requestOptions = GetRequestOptions(operation, options);
ResourceResponse <Document> resourceResponse = await DocumentEntityCollectionBaseHelpers.HandleEntityDeleteAsync(table.Name, operation.PartitionKey, operation.RowKey, EtagHelper.ConvertToBackEndETagFormat(operation.ETag), client.DocumentClient, requestOptions, cancellationToken);
return(GetTableResultFromResponse(operation, resourceResponse, context, options, operation.SelectColumns, resourceResponse.SessionToken));
}
private static async Task <TableResult> HandleMergeAsync(TableOperation operation, CloudTableClient client, CloudTable table, TableRequestOptions options, OperationContext context, CancellationToken cancellationToken)
{
Document documentFromEntity = EntityHelpers.GetDocumentFromEntity(operation.Entity, context, options);
RequestOptions requestOptions = GetRequestOptions(operation, options);
StoredProcedureResponse <string> storedProcedureResponse = await DocumentEntityCollectionBaseHelpers.HandleEntityMergeAsync(table.Name, operation.OperationType, operation.PartitionKey, EtagHelper.ConvertToBackEndETagFormat(operation.ETag), client.DocumentClient, documentFromEntity, requestOptions, cancellationToken);
Document response = JsonConvert.DeserializeObject <List <Document> >(storedProcedureResponse.Response).FirstOrDefault();
return(GetTableResultFromDocument(operation, response, context, options, storedProcedureResponse.SessionToken, storedProcedureResponse.RequestCharge));
}
private static async Task <TableResult> HandleReplaceAsync(TableOperation operation, CloudTableClient client, CloudTable table, TableRequestOptions options, OperationContext context, CancellationToken cancellationToken)
{
Document documentFromEntity = EntityHelpers.GetDocumentFromEntity(operation.Entity, context, options);
RequestOptions requestOptions = GetRequestOptions(operation, options);
ResourceResponse <Document> resourceResponse = await DocumentEntityCollectionBaseHelpers.HandleEntityReplaceOnlyAsync(table.Name, operation.PartitionKey, operation.RowKey, EtagHelper.ConvertToBackEndETagFormat(operation.ETag), client.DocumentClient, documentFromEntity, requestOptions, cancellationToken);
return(GetTableResultFromResponse(operation, resourceResponse, context, options, operation.SelectColumns, resourceResponse.SessionToken));
}
internal static async Task <TResult> ExecuteBatchOperationAsync <TResult>(TableBatchOperation batch, CloudTableClient client, CloudTable table, TableRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken) where TResult : class
{
TableOperationType currentOperationType = batch.First().OperationType;
batch.First();
try
{
List <Document> list = new List <Document>();
List <TableOperationType> list2 = new List <TableOperationType>();
List <string> list3 = new List <string>();
foreach (TableOperation item2 in batch)
{
currentOperationType = item2.OperationType;
Document item = (item2.OperationType != TableOperationType.Retrieve) ? EntityHelpers.GetDocumentFromEntity(item2.Entity, operationContext, requestOptions) : EntityTranslator.GetDocumentWithPartitionAndRowKey(item2.RetrievePartitionKey, item2.RetrieveRowKey);
list.Add(item);
list2.Add(item2.OperationType);
list3.Add((item2.Entity == null) ? string.Empty : EtagHelper.ConvertToBackEndETagFormat(item2.Entity.ETag));
}
RequestOptions requestOptions2 = GetRequestOptions(batch.batchPartitionKey, requestOptions);
Uri storedProcedureUri = UriFactory.CreateStoredProcedureUri("TablesDB", table.Name, "__.sys.tablesBatchOperation");
StoredProcedureResponse <string> storedProcedureResponse = await table.ServiceClient.DocumentClient.ExecuteStoredProcedureAsync <string>(storedProcedureUri, requestOptions2, new object[3]
{
list.ToArray(),
list2.ToArray(),
list3.ToArray()
});
JArray jArray = JArray.Parse(storedProcedureResponse.Response);
TableBatchResult tableBatchResult = new TableBatchResult();
tableBatchResult.RequestCharge = storedProcedureResponse.RequestCharge;
for (int i = 0; i < jArray.Count; i++)
{
tableBatchResult.Add(GetTableResultFromDocument(batch[i], jArray[i].ToObject <Document>(), operationContext, requestOptions, storedProcedureResponse.SessionToken, 0.0));
}
return(tableBatchResult as TResult);
}
catch (Exception ex)
{
DocumentClientException ex2 = ex as DocumentClientException;
if (ex2 != null && ex2.StatusCode == HttpStatusCode.BadRequest && ex2.Message.Contains("Resource Not Found") && currentOperationType == TableOperationType.Retrieve)
{
TableBatchResult tableBatchResult2 = new TableBatchResult();
tableBatchResult2.Add(new TableResult
{
Etag = null,
HttpStatusCode = 404,
Result = null
});
tableBatchResult2.RequestCharge = ex2.RequestCharge;
return(tableBatchResult2 as TResult);
}
TableErrorResult tableErrorResult = ex.TranslateDocumentErrorForStoredProcs(null, batch.Count);
RequestResult requestResult = GenerateRequestResult(tableErrorResult.ExtendedErroMessage, tableErrorResult.HttpStatusCode, tableErrorResult.ExtendedErrorCode, tableErrorResult.ExtendedErroMessage, tableErrorResult.ServiceRequestID, tableErrorResult.RequestCharge);
StorageException ex3 = new StorageException(requestResult, requestResult.ExtendedErrorInformation.ErrorMessage, ex);
if (ex2 != null)
{
PopulateOperationContextForBatchOperations(operationContext, ex3, ex2.ActivityId);
}
throw ex3;
}
}
