/// <summary>Constructor</summary>
/// <param name="queryOperationResponse">The response for the Load operation. null when the operation didn't succeed.</param>
/// <param name="error"><see cref="Exception"/> which represents the error if the Load operation failed. null if the operation
/// didn't fail.</param>
/// <param name="cancelled">True, if the LoadAsync operation was cancelled, False otherwise.</param>
/// <remarks>This constructor doesn't allow creation of canceled event args.</remarks>
internal LoadCompletedEventArgs(
QueryOperationResponse queryOperationResponse,
Exception error,
bool cancelled)
: base(error, cancelled, null)
{
this.queryOperationResponse = queryOperationResponse;
}
/// <summary>
/// Extracts the server error message from a client side query exception.
/// </summary>
/// <param name="response">The QueryOperationResponse to extract error message from.</param>
/// <returns>The server error message.</returns>
public static string ExtractServerErrorMessage(QueryOperationResponse response)
{
string contentType = response.Headers[HttpHeaders.ContentType];
var innerException = response.Error as DataServiceClientException;
ExceptionUtilities.Assert(innerException != null, "No inner exception on query exception");
return GetErrorMessage(innerException, contentType);
}
private void GetPhotosFromService(MergeOption mergeOption)
{
// Set the merge option.
context.MergeOption = mergeOption;
try
{
// Define a query that returns a feed with all PhotoInfo objects.
var query = context.PhotoInfo;
// Create a new collection for binding based on the executed query.
trackedPhotos = new DataServiceCollection <PhotoInfo>(query);
// Load all pages of the response into the binding collection.
while (trackedPhotos.Continuation != null)
{
trackedPhotos.Load(
context.Execute <PhotoInfo>(trackedPhotos.Continuation.NextLinkUri));
}
// Bind the root StackPanel element to the collection;
// related object binding paths are defined in the XAML.
LayoutRoot.DataContext = trackedPhotos;
if (trackedPhotos.Count == 0)
{
MessageBox.Show("Data could not be returned from the data service.");
}
// Select the first photo in the collection.
photoComboBox.SelectedIndex = 0;
// Enable the buttons.
photoDetails.IsEnabled = true;
addPhoto.IsEnabled = true;
deletePhoto.IsEnabled = true;
}
catch (DataServiceQueryException ex)
{
string errorMessage = string.Empty;
// Get the response from the request.
QueryOperationResponse response = ex.Response;
// If we have a 404, the URI may be incorrect.
if (response.StatusCode == 404)
{
errorMessage = string.Format("Make sure that the service URI '{0}' is correct.",
svcUri.ToString());
}
else
{
// Get the error message from the response.
errorMessage = response.Error.Message;
}
// Display the message.
MessageBox.Show(errorMessage,
string.Format("Error Status Code: {0}", response.StatusCode));
}
catch (InvalidOperationException ex)
{
MessageBox.Show(ex.Message);
}
finally
{
// Reset the merge option to the default.
context.MergeOption = MergeOption.AppendOnly;
}
}
/// <summary>
/// Translates the data service exception.
/// </summary>
/// <param name="e">The exception.</param>
/// <param name="reqResult">The request result.</param>
/// <param name="parseError">The delegate used to parse the error to get extended error information.</param>
/// <returns>
/// The translated exception.
/// </returns>
internal static StorageException TranslateDataServiceException(Exception e, RequestResult reqResult, Func <Stream, IDictionary <string, string>, StorageExtendedErrorInformation> parseError)
{
try
{
// The exception thrown is based on whether it is a change/query operation.
DataServiceRequestException dsre = FindInnerExceptionOfType <DataServiceRequestException>(e);
DataServiceQueryException dsqe = FindInnerExceptionOfType <DataServiceQueryException>(e);
if (dsre == null && dsqe == null)
{
InvalidOperationException ioe = TableUtilities.FindInnerExceptionOfType <InvalidOperationException>(e);
if (ioe != null && !(ioe is WebException) && string.CompareOrdinal(ioe.Source, "Microsoft.Data.Services.Client") == 0 && ioe.Message.Contains("type is not compatible with the expected"))
{
return(new StorageException(reqResult, e.Message, e)
{
IsRetryable = false
});
}
return(null);
}
else if (dsre != null)
{
DataServiceResponse response = dsre.Response;
// Get the batch status code first in case batch does not contain any responses.
reqResult.HttpStatusCode = response.BatchStatusCode;
IDictionary <string, string> headers;
foreach (OperationResponse operationResponse in response)
{
reqResult.HttpStatusCode = operationResponse.StatusCode;
// The exception thrown will contain the first error in the group of requests.
if (reqResult.HttpStatusCode >= 300)
{
headers = operationResponse.Headers;
// Strip off the extra exception type at the beginning.
string innerException = dsre.InnerException.ToString().Replace("System.Data.Services.Client.DataServiceClientException: ", string.Empty);
using (Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(innerException)))
{
reqResult.ExtendedErrorInformation = parseError(stream, headers);
}
break;
}
}
return(new StorageException(
reqResult,
reqResult.ExtendedErrorInformation != null ? reqResult.ExtendedErrorInformation.ErrorCode : dsre.Message,
dsre));
}
else
{
QueryOperationResponse response = dsqe.Response;
reqResult.HttpStatusCode = response.StatusCode;
string innerException = dsqe.InnerException.Message;
using (Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(innerException)))
{
reqResult.ExtendedErrorInformation = parseError(stream, response.Headers);
}
return(new StorageException(
reqResult,
reqResult.ExtendedErrorInformation != null ? reqResult.ExtendedErrorInformation.ErrorCode : dsqe.Message,
dsqe));
}
}
catch (Exception)
{
return(new StorageException(reqResult, e.Message, e));
}
}
public void QueryRowCountNotFoundException()
{
var baseQuery = ctx.CreateQuery <northwindClient.Customers>("Customer");
var inlineQuery = baseQuery.IncludeTotalCount();
string countNotPresentMsg = DataServicesClientResourceUtil.GetString("MaterializeFromAtom_CountNotPresent");
string resourceNotFoundCustomerMsg = DataServicesResourceUtil.GetString("RequestUriProcessor_ResourceNotFound", "Customer");
string resourceNotFoundVar1Msg = DataServicesResourceUtil.GetString("RequestUriProcessor_ResourceNotFound", "VAR1");
for (int i = 0; i < 2; ++i)
{
ctx.IgnoreResourceNotFoundException = (i == 0);
// case 1: $count=inline, 404 exception gives empty set
try
{
QueryOperationResponse <northwindClient.Customers> qor = (QueryOperationResponse <northwindClient.Customers>)inlineQuery.Execute();
Assert.AreEqual(i, 0);
// client count:
Assert.AreEqual(qor.Count(), 0);
// server count should fail:
long count = qor.TotalCount;
Assert.Fail("Server count failed to throw on 404");
}
catch (DataServiceQueryException ex)
{
Assert.AreEqual(i, 1);
Assert.IsNotNull(ex.InnerException);
Assert.IsTrue(ex.InnerException.Message.Contains(resourceNotFoundCustomerMsg));
}
catch (InvalidOperationException ex)
{
Assert.AreEqual(i, 0);
Assert.AreEqual(countNotPresentMsg, ex.Message);
}
// case 2: $count=value, 404 exception
try
{
long count = baseQuery.LongCount();
Assert.Fail("Server count failed to throw on 404");
}
catch (DataServiceQueryException ex)
{
Assert.IsNotNull(ex.InnerException);
Assert.IsTrue(ex.InnerException.Message.Contains(resourceNotFoundCustomerMsg));
}
// case 3: custom URI on context
try
{
QueryOperationResponse <northwindClient.Customers> qor = (QueryOperationResponse <northwindClient.Customers>)ctx.Execute <northwindClient.Customers>("/VAR1?$count=true");
Assert.AreEqual(i, 0);
// client count:
Assert.AreEqual(qor.Count(), 0);
// server count should fail:
long count = qor.TotalCount;
Assert.Fail("Server count failed to throw on 404");
}
catch (DataServiceQueryException ex)
{
Assert.AreEqual(i, 1);
Assert.IsNotNull(ex.InnerException);
Assert.IsTrue(ex.InnerException.Message.Contains(resourceNotFoundVar1Msg));
}
catch (InvalidOperationException ex)
{
Assert.AreEqual(i, 0);
Assert.AreEqual(countNotPresentMsg, ex.Message);
}
// case 4: $count=inline, ASYNC, 404 exception gives empty set
bool asyncComplete = false;
inlineQuery.BeginExecute(ar =>
{
try
{
QueryOperationResponse <northwindClient.Customers> qor = (QueryOperationResponse <northwindClient.Customers>)inlineQuery.EndExecute(ar);
Assert.AreEqual(qor.Count(), 0);
long count = qor.TotalCount;
Assert.Fail("Server count failed to throw on 404");
}
catch (DataServiceQueryException ex)
{
Assert.AreEqual(i, 1);
Assert.IsNotNull(ex.InnerException);
Assert.IsNotNull(ex.InnerException.InnerException);
Assert.IsTrue(ex.InnerException.InnerException.Message.Contains(resourceNotFoundCustomerMsg));
}
catch (InvalidOperationException ex)
{
Assert.AreEqual(i, 0);
Assert.AreEqual(countNotPresentMsg, ex.Message);
}
finally
{
asyncComplete = true;
}
}, null);
while (!asyncComplete)
{
Thread.Sleep(10);
}
}
}
[Ignore] // Remove Atom
// [TestMethod]
public void LoadPropertyRemoveElementUnChangedSource()
{
MergeOption original = this.context.MergeOption;
try
{
foreach (MergeOption mo in new[] { MergeOption.OverwriteChanges, MergeOption.PreserveChanges })
{
foreach (bool usePaging in new[] { false, true })
{
using (CustomDataContext.CreateChangeScope())
using (OpenWebDataServiceHelper.PageSizeCustomizer.Restore())
{
OpenWebDataServiceHelper.PageSizeCustomizer.Value = (config, type) => { config.SetEntitySetPageSize("Orders", usePaging ? 1 : 5); };
Customer c = new Customer()
{
ID = 0
};
Customer c2 = new Customer()
{
ID = 2
};
Order o = new Order()
{
ID = 102
};
this.context.MergeOption = mo;
this.context.AttachTo("Customers", c);
this.context.AttachTo("Customers", c2);
this.context.AttachTo("Orders", o);
this.context.AddLink(c, "Orders", o);
this.context.SetLink(o, "Customer", c);
this.context.SaveChanges();
if (usePaging)
{
DataServiceQueryContinuation continuation = null;
do
{
QueryOperationResponse response = this.context.LoadProperty(c, "Orders", continuation);
continuation = response.GetContinuation();
}while (continuation != null);
}
else
{
this.context.LoadProperty(c, "Orders");
}
this.context.LoadProperty(o, "Customer");
if (c.Orders != null)
{
Assert.IsTrue(c.Orders.Contains(o));
}
if (o.Customer != null)
{
Assert.IsTrue(o.Customer.ID == c.ID);
}
// Remove the link
this.context.DeleteLink(c, "Orders", o);
this.context.SetLink(o, "Customer", c2);
this.context.SaveChanges();
if (usePaging)
{
DataServiceQueryContinuation continuation = null;
do
{
QueryOperationResponse response = this.context.LoadProperty(c, "Orders", continuation);
continuation = response.GetContinuation();
}while (continuation != null);
}
else
{
this.context.LoadProperty(c, "Orders");
}
this.context.LoadProperty(o, "Customer");
if (c.Orders != null)
{
Assert.IsFalse(c.Orders.Contains(o));
}
if (o.Customer != null)
{
Assert.IsFalse(o.Customer.ID == c.ID);
}
}
this.ClearContext();
}
}
}
finally
{
this.context.MergeOption = original;
}
}
public static void InitRequest <T, INTERMEDIATE_TYPE>(ExecutionState <T> executionState)
{
try
{
executionState.Init();
// 0. Begin Request
TableExecutor.StartRequestAttempt(executionState);
if (TableExecutor.CheckTimeout <T>(executionState, false))
{
TableExecutor.EndOperation <T, INTERMEDIATE_TYPE>(executionState);
return;
}
lock (executionState.CancellationLockerObject)
{
if (TableExecutor.CheckCancellation(executionState))
{
TableExecutor.EndOperation <T, INTERMEDIATE_TYPE>(executionState);
return;
}
TableCommand <T, INTERMEDIATE_TYPE> tableCommandRef = executionState.Cmd as TableCommand <T, INTERMEDIATE_TYPE>;
// Execute Call
Logger.LogInformational(executionState.OperationContext, SR.TraceStartRequestAsync, tableCommandRef.Context.BaseUri);
tableCommandRef.Begin(
(res) =>
{
executionState.UpdateCompletedSynchronously(res.CompletedSynchronously);
INTERMEDIATE_TYPE tResult = default(INTERMEDIATE_TYPE);
try
{
tResult = tableCommandRef.End(res);
executionState.Result = tableCommandRef.ParseResponse(tResult, executionState.Cmd.CurrentResult, tableCommandRef);
if (executionState.Req != null)
{
DataServiceResponse dataServiceResponse = tResult as DataServiceResponse;
QueryOperationResponse queryResponse = tResult as QueryOperationResponse;
if (dataServiceResponse != null)
{
if (dataServiceResponse.IsBatchResponse)
{
// Attempt to populate response headers
if (executionState.Req != null)
{
SetExecutionStateCommandResult(executionState, dataServiceResponse);
Logger.LogInformational(executionState.OperationContext, SR.TraceResponse, executionState.Cmd.CurrentResult.HttpStatusCode, executionState.Cmd.CurrentResult.ServiceRequestID, executionState.Cmd.CurrentResult.ContentMd5, executionState.Cmd.CurrentResult.Etag);
}
}
else
{
int index = 0;
foreach (OperationResponse operationResponse in dataServiceResponse)
{
// Attempt to populate response headers
if (executionState.Req != null)
{
SetStorageCmdRequestResults(executionState.Cmd.RequestResults.ElementAt(index), operationResponse);
Logger.LogInformational(executionState.OperationContext, SR.TraceResponse, executionState.Cmd.RequestResults.ElementAt(index).HttpStatusCode, executionState.Cmd.RequestResults.ElementAt(index).ServiceRequestID, executionState.Cmd.RequestResults.ElementAt(index).ContentMd5, executionState.Cmd.RequestResults.ElementAt(index).Etag);
index++;
}
}
}
}
else if (queryResponse != null)
{
// Attempt to populate response headers
if (executionState.Req != null)
{
SetStorageCmdRequestResults(executionState.Cmd.CurrentResult, queryResponse);
Logger.LogInformational(executionState.OperationContext, SR.TraceResponse, executionState.Cmd.CurrentResult.HttpStatusCode, executionState.Cmd.CurrentResult.ServiceRequestID, executionState.Cmd.CurrentResult.ContentMd5, executionState.Cmd.CurrentResult.Etag);
}
}
}
}
catch (Exception ex)
{
Logger.LogWarning(executionState.OperationContext, SR.TraceGenericError, ex.Message);
lock (executionState.CancellationLockerObject)
{
if (executionState.CancelRequested)
{
// Ignore DSC exception if request was canceled.
return;
}
}
// Store exception and invoke callback here. All operations in this try would be non-retryable by default
if (executionState.ExceptionRef == null || !(executionState.ExceptionRef is StorageException))
{
executionState.ExceptionRef = ExecutorBase.TranslateDataServiceExceptionBasedOnParseError(ex, executionState.Cmd.CurrentResult, executionState.Cmd.ParseDataServiceError);
}
try
{
executionState.Result = tableCommandRef.ParseResponse(tResult, executionState.Cmd.CurrentResult, tableCommandRef);
// clear exception
executionState.ExceptionRef = null;
}
catch (Exception parseEx)
{
Logger.LogWarning(executionState.OperationContext, SR.TraceGenericError, ex.Message);
executionState.ExceptionRef = parseEx;
}
}
finally
{
EndOperation <T, INTERMEDIATE_TYPE>(executionState);
}
},
null);
if (tableCommandRef.Context != null)
{
executionState.CancelDelegate = tableCommandRef.Context.InternalCancel;
}
}
}
catch (Exception ex)
{
Logger.LogWarning(executionState.OperationContext, SR.TraceGenericError, ex.Message);
// Store exception and invoke callback here. All operations in this try would be non-retryable by default
if (executionState.ExceptionRef == null || !(executionState.ExceptionRef is StorageException))
{
executionState.ExceptionRef = ExecutorBase.TranslateDataServiceExceptionBasedOnParseError(ex, executionState.Cmd.CurrentResult, executionState.Cmd.ParseDataServiceError);
}
executionState.OnComplete();
}
}
internal static void PreprocessObjectToWrite(ref object objectToWrite, ObjectGraphInfo info)
{
if (objectToWrite is DataServiceQuery)
{
objectToWrite = ((DataServiceQuery)objectToWrite).Execute();
}
if (objectToWrite is QueryOperationResponse)
{
QueryOperationResponse qor = (QueryOperationResponse)objectToWrite;
if (qor.GetType().IsGenericType&& (qor.GetType().GetGenericTypeDefinition() == typeof(QueryOperationResponse <>)))
{
objectToWrite = Util.VerticalRun(new object[] { new QueryOperationResponseWrapper(true, qor), new QueryOperationResponseWrapper(false, qor) });
}
}
else if (objectToWrite is QueryOperationResponseWrapper)
{
QueryOperationResponseWrapper wrapper = (QueryOperationResponseWrapper)objectToWrite;
if (wrapper.Enumerate)
{
objectToWrite = wrapper.Qor;
}
else
{
DataServiceQueryContinuation continuation = wrapper.Qor.GetContinuation();
if (!((continuation == null) || wrapper.ElementType.Name.Contains <char>('<')))
{
Uri nextLinkUri = continuation.NextLinkUri;
objectToWrite = new Hyperlinq(QueryLanguage.Expression, "Execute<" + wrapper.ElementType.Name + "> (new Uri (\"" + nextLinkUri.ToString() + "\"))", "Next Page");
}
else
{
objectToWrite = info.DisplayNothingToken;
}
}
}
else
{
DataServiceQueryException exception = objectToWrite as DataServiceQueryException;
if ((exception != null) && (exception.InnerException is DataServiceClientException))
{
DataServiceClientException innerException = (DataServiceClientException)exception.InnerException;
try
{
XElement element = XElement.Parse(innerException.Message);
if (element.Name.LocalName == "error")
{
XNamespace namespace2 = element.Name.Namespace;
string str = (string)element.Element((XName)(namespace2 + "message"));
if (!string.IsNullOrEmpty(str))
{
str = str.Trim();
if (str.EndsWith("cannot be used in a query"))
{
str = str + " predicate";
}
if (!str.EndsWith("."))
{
str = str + ".";
}
Util.Highlight(str + " See exception below for more details.").Dump <object>();
}
}
}
catch
{
}
}
}
}
public QueryOperationResponseWrapper(bool enumerate, QueryOperationResponse qor)
{
this.Enumerate = enumerate;
this.Qor = qor;
}
// Creator - should be faster than Activator.CreateInstance
public static PagedCollection <TElement, TConcrete> Create(DataServiceContextWrapper context,
QueryOperationResponse <TConcrete> qor)
{
return(new PagedCollection <TElement, TConcrete>(context, qor));
}
public QueryOperationResponseWrapper(QueryOperationResponse qr)
: base(qr)
{
this._QueryResponse = qr;
}
/// <summary>Constructor</summary>
/// <param name="queryOperationResponse">The response for the Load operation. null when the operation didn't succeed.</param>
/// <param name="error"><see cref="Exception"/> which represents the error if the Load operation failed. null if the operation
/// didn't fail.</param>
/// <remarks>This constructor doesn't allow creation of canceled event args.</remarks>
internal LoadCompletedEventArgs(QueryOperationResponse queryOperationResponse, Exception error)
: this(queryOperationResponse, error, false)
{
}
/// <remarks></remarks>
private IEnumerable <CloudEntity <T> > GetInternal <T>(TableServiceContext context, string tableName, Maybe <string> filter)
{
string continuationRowKey = null;
string continuationPartitionKey = null;
var stopwatch = Stopwatch.StartNew();
context.MergeOption = MergeOption.AppendOnly;
context.ResolveType = ResolveFatEntityType;
do
{
var query = context.CreateQuery <FatEntity>(tableName);
if (filter.HasValue)
{
query = query.AddQueryOption("$filter", filter.Value);
}
if (null != continuationRowKey)
{
query = query.AddQueryOption(NextRowKeyToken, continuationRowKey)
.AddQueryOption(NextPartitionKeyToken, continuationPartitionKey);
}
QueryOperationResponse response = null;
FatEntity[] fatEntities = null;
Retry.Do(_policies.TransientTableErrorBackOff(), CancellationToken.None, () =>
{
try
{
response = query.Execute() as QueryOperationResponse;
fatEntities = ((IEnumerable <FatEntity>)response).ToArray();
}
catch (DataServiceQueryException ex)
{
// if the table does not exist, there is nothing to return
var errorCode = RetryPolicies.GetErrorCode(ex);
if (TableErrorCodeStrings.TableNotFound == errorCode ||
StorageErrorCodeStrings.ResourceNotFound == errorCode)
{
fatEntities = new FatEntity[0];
return;
}
throw;
}
});
NotifySucceeded(StorageOperationType.TableQuery, stopwatch);
foreach (var fatEntity in fatEntities)
{
var etag = context.Entities.First(e => e.Entity == fatEntity).ETag;
context.Detach(fatEntity);
yield return(FatEntity.Convert <T>(fatEntity, _serializer, etag));
}
Debug.Assert(context.Entities.Count == 0);
if (null != response && response.Headers.ContainsKey(ContinuationNextRowKeyToken))
{
continuationRowKey = response.Headers[ContinuationNextRowKeyToken];
continuationPartitionKey = response.Headers[ContinuationNextPartitionKeyToken];
stopwatch.Restart();
}
else
{
continuationRowKey = null;
continuationPartitionKey = null;
}
} while (null != continuationRowKey);
}
public QueryOperationResponseWrapper(bool enumerate, QueryOperationResponse qor)
{
this.Enumerate = enumerate;
this.Qor = qor;
}
private void RunPositiveFunctionTest(ODataFormat format, TestCase testCase)
{
// All of the functions tests use the PlaybackService since the WCF Data Services server doesn't support functions
// The PlaybackService itself will not automatically turn Metadata into an absolute URI, so set that to false on all tests.
// The tests also use absolute URIs for Target, so suppress that as well.
testCase.AddBaseUriToMetadata = false;
testCase.AddBaseUriToTarget = false;
using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
using (PlaybackService.ProcessRequestOverride.Restore())
{
request.ServiceType = typeof(AstoriaUnitTests.Stubs.PlaybackService);
request.StartService();
var payloadBuilder = testCase.ResponsePayloadBuilder;
PlaybackService.ProcessRequestOverride.Value = (req) =>
{
string contentType;
if (format == ODataFormat.Json)
{
contentType = UnitTestsUtil.JsonLightMimeType;
payloadBuilder.Metadata = request.BaseUri + "/$metadata#TestService.CustomerEntities/$entity";
}
else
{
contentType = UnitTestsUtil.AtomFormat;
}
req.SetResponseStreamAsText(PayloadGenerator.Generate(payloadBuilder, format));
req.ResponseHeaders.Add("Content-Type", contentType);
req.SetResponseStatusCode(200);
return(req);
};
testCase.AddBaseUriStringToExpectedDescriptors(request.ServiceRoot.OriginalString, format);
Uri uri = new Uri(request.ServiceRoot + "/" + testCase.RequestUriString);
DataServiceContext ctx = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
ctx.EnableAtom = true;
if (format == ODataFormat.Json)
{
string serviceEdmx = GetServiceEdmxWithOperations(payloadBuilder);
JsonLightTestUtil.ConfigureContextForJsonLight(ctx, serviceEdmx);
}
QueryOperationResponse <CustomerEntity> qor = (QueryOperationResponse <CustomerEntity>)ctx.Execute <CustomerEntity>(uri);
Assert.IsNotNull(qor);
Assert.IsNull(qor.Error);
IEnumerator <CustomerEntity> entities = qor.GetEnumerator();
int expectedDescriptorsPerEntity = 0;
while (entities.MoveNext())
{
CustomerEntity c = entities.Current;
EntityDescriptor ed = ctx.GetEntityDescriptor(c);
IEnumerable <OperationDescriptor> actualDescriptors = ed.OperationDescriptors;
TestEquality(actualDescriptors, testCase.GetExpectedDescriptors(format)[expectedDescriptorsPerEntity++]);
}
}
}
internal LoadCompletedEventArgs(QueryOperationResponse queryOperationResponse, Exception error)
: base(error, false, null)
{
this.queryOperationResponse = queryOperationResponse;
}
public static T ExecuteSync <T, INTERMEDIATE_TYPE>(TableCommand <T, INTERMEDIATE_TYPE> cmd, IRetryPolicy policy, OperationContext operationContext)
{
// Note all code below will reference state, not params directly, this will allow common code with async executor
ExecutionState <T> executionState = new ExecutionState <T>(cmd, policy, operationContext);
TableExecutor.AcquireContext(cmd.Context, executionState);
bool shouldRetry = false;
TimeSpan delay = TimeSpan.Zero;
try
{
// Enter Retryable Section of execution
do
{
executionState.Init();
// 0. Begin Request
TableExecutor.StartRequestAttempt(executionState);
TableExecutor.CheckTimeout <T>(executionState, true);
try
{
INTERMEDIATE_TYPE tempResult = default(INTERMEDIATE_TYPE);
try
{
Logger.LogInformational(executionState.OperationContext, SR.TraceStartRequestSync, cmd.Context.BaseUri);
tempResult = cmd.ExecuteFunc();
executionState.Result = cmd.ParseResponse(tempResult, executionState.Cmd.CurrentResult, cmd);
DataServiceResponse dataServiceResponse = tempResult as DataServiceResponse;
QueryOperationResponse queryResponse = tempResult as QueryOperationResponse;
if (dataServiceResponse != null)
{
if (dataServiceResponse.IsBatchResponse)
{
// Attempt to populate response headers
if (executionState.Req != null)
{
SetExecutionStateCommandResult(executionState, dataServiceResponse);
Logger.LogInformational(executionState.OperationContext, SR.TraceResponse, executionState.Cmd.CurrentResult.HttpStatusCode, executionState.Cmd.CurrentResult.ServiceRequestID, executionState.Cmd.CurrentResult.ContentMd5, executionState.Cmd.CurrentResult.Etag);
}
}
else
{
int index = 0;
foreach (OperationResponse operationResponse in dataServiceResponse)
{
// Attempt to populate response headers
if (executionState.Req != null)
{
SetStorageCmdRequestResults(executionState.Cmd.RequestResults.ElementAt(index), operationResponse);
Logger.LogInformational(executionState.OperationContext, SR.TraceResponse, executionState.Cmd.RequestResults.ElementAt(index).HttpStatusCode, executionState.Cmd.RequestResults.ElementAt(index).ServiceRequestID, executionState.Cmd.RequestResults.ElementAt(index).ContentMd5, executionState.Cmd.RequestResults.ElementAt(index).Etag);
index++;
}
}
}
}
else if (queryResponse != null)
{
// Attempt to populate response headers
if (executionState.Req != null)
{
SetStorageCmdRequestResults(executionState.Cmd.CurrentResult, queryResponse);
Logger.LogInformational(executionState.OperationContext, SR.TraceResponse, executionState.Cmd.CurrentResult.HttpStatusCode, executionState.Cmd.CurrentResult.ServiceRequestID, executionState.Cmd.CurrentResult.ContentMd5, executionState.Cmd.CurrentResult.Etag);
}
}
}
catch (Exception ex)
{
Logger.LogWarning(executionState.OperationContext, SR.TraceGenericError, ex.Message);
// Store exception and invoke callback here. All operations in this try would be non-retryable by default
if (executionState.ExceptionRef == null || !(executionState.ExceptionRef is StorageException))
{
executionState.ExceptionRef = ExecutorBase.TranslateDataServiceExceptionBasedOnParseError(ex, executionState.Cmd.CurrentResult, executionState.Cmd.ParseDataServiceError);
}
executionState.Result = cmd.ParseResponse(tempResult, executionState.Cmd.CurrentResult, cmd);
// clear exception
executionState.ExceptionRef = null;
}
TableExecutor.FinishRequestAttempt(executionState);
Logger.LogInformational(executionState.OperationContext, SR.TraceSuccess);
return(executionState.Result);
}
catch (Exception e)
{
TableExecutor.FinishRequestAttempt(executionState);
StorageException translatedException = ExecutorBase.TranslateDataServiceExceptionBasedOnParseError(e, executionState.Cmd.CurrentResult, executionState.Cmd.ParseDataServiceError);
executionState.ExceptionRef = translatedException;
Logger.LogInformational(executionState.OperationContext, SR.TraceRetryCheck, executionState.RetryCount, executionState.Cmd.CurrentResult.HttpStatusCode, translatedException.IsRetryable ? "yes" : "no", translatedException.Message);
shouldRetry = false;
if (translatedException.IsRetryable && (executionState.RetryPolicy != null))
{
shouldRetry = executionState.RetryPolicy.ShouldRetry(
executionState.RetryCount++,
executionState.Cmd.CurrentResult.HttpStatusCode,
executionState.ExceptionRef,
out delay,
executionState.OperationContext);
if ((delay < TimeSpan.Zero) || (delay > Constants.MaximumRetryBackoff))
{
delay = Constants.MaximumRetryBackoff;
}
}
}
if (!shouldRetry || (executionState.OperationExpiryTime.HasValue && (DateTime.Now + delay).CompareTo(executionState.OperationExpiryTime.Value) > 0))
{
Logger.LogError(executionState.OperationContext, shouldRetry ? SR.TraceRetryDecisionTimeout : SR.TraceRetryDecisionPolicy, executionState.ExceptionRef.Message);
throw executionState.ExceptionRef;
}
else
{
if (executionState.Cmd.RecoveryAction != null)
{
// I.E. Rewind stream etc.
executionState.Cmd.RecoveryAction(executionState.Cmd, executionState.ExceptionRef, executionState.OperationContext);
}
Logger.LogInformational(executionState.OperationContext, SR.TraceRetryDelay, (int)delay.TotalMilliseconds);
if (delay > TimeSpan.Zero)
{
Thread.Sleep(delay);
}
Logger.LogInformational(executionState.OperationContext, SR.TraceRetry);
}
}while (shouldRetry);
// should never get here, either return, or throw;
throw new NotImplementedException(SR.InternalStorageError);
}
finally
{
ReleaseContext(cmd.Context);
}
}
/// <summary>Initializes a new instance of the <see cref="T:Microsoft.OData.Client.DataServiceQueryException" /> class. </summary>
/// <param name="message">The string value that contains the error message.</param>
/// <param name="innerException">The inner exception object.</param>
/// <param name="response">The <see cref="T:Microsoft.OData.Client.QueryOperationResponse" /> object.</param>
public DataServiceQueryException(string message, Exception innerException, QueryOperationResponse response)
: base(message, innerException)
{
this.response = response;
}
private static long GetTotalCount(QueryOperationResponse<V2FeedPackage> response, PackageMetadata[] packageMetadatas)
{
// TotalCount may be missing. When this is the case, we default
// to the number of package meta's we got.
try
{
return response.TotalCount;
}
catch (InvalidOperationException)
{
return packageMetadatas.Length;
}
}
