public override void HandleAfter(Context context)
{
InnerHandler.HandleAfter(context);
// Disable reponse validation
if (context.ClientConfig.SkipResponseValidation)
{
return;
}
try
{
CheckOtherHeaders(context);
// Header['authorization'] is not neccessarily available
// when HttpStatusCode.Forbidden happens.
if (context.HttpResponseStatusCode != HttpStatusCode.Forbidden)
{
CheckAuthorization(context);
}
}
catch (OTSClientException e)
{
// re-throw the exception with additonal information
throw new OTSClientException(
String.Format("{0} HTTP Status: {1}.", e.Message, context.HttpResponseStatusCode),
context.HttpResponseStatusCode
);
}
}
public override void HandleAfter(Context context)
{
InnerHandler.HandleAfter(context);
IMessage message;
context.OTSReponse = DecoderMap[context.APIName](context.HttpResponseBody, out message);
LogEncodedMessage(context, message);
}
public override void HandleAfter(Context context)
{
OTSServerException exception;
InnerHandler.HandleAfter(context);
var statusCode = context.HttpResponseStatusCode;
if ((int)statusCode >= 200 && (int)statusCode < 300)
{
return;
}
var builder = PB.Error.CreateBuilder();
string errorCode = null, errorMessage = null;
try
{
builder.MergeFrom(context.HttpResponseBody);
var message = builder.Build();
errorCode = message.Code;
errorMessage = message.Message;
} catch (Google.ProtocolBuffers.InvalidProtocolBufferException) {
throwOTSServerException(context);
} catch (Google.ProtocolBuffers.UninitializedMessageException) {
throwOTSServerException(context);
}
string requestID;
if (context.HttpResponseHeaders.ContainsKey("x-ots-requestid"))
{
requestID = context.HttpResponseHeaders["x-ots-requestid"];
}
else
{
requestID = null;
}
exception = new OTSServerException(
context.APIName,
statusCode,
errorCode,
errorMessage,
requestID
);
if (context.ClientConfig.OTSErrorLogHandler != null)
{
context.ClientConfig.OTSErrorLogHandler.Invoke(exception.ToString());
}
throw exception;
}
public override void HandleAfter(Context context)
{
var retryPolicy = context.ClientConfig.RetryPolicy;
while (true)
{
OTSException exceptionForRetry = null;
try
{
InnerHandler.HandleAfter(context);
}
catch (OTSClientException exception)
{
exceptionForRetry = exception;
}
catch (OTSServerException exception)
{
exceptionForRetry = exception;
}
if (OTSClientTestHelper.RetryTimesAndBackOffRecordSwith)
{
if (OTSClientTestHelper.RetryExceptions.Count() > OTSClientTestHelper.RetryTimes)
{
exceptionForRetry = OTSClientTestHelper.RetryExceptions[OTSClientTestHelper.RetryTimes];
}
}
if (ShouldRetry(retryPolicy, context, exceptionForRetry))
{
int retryDelay = retryPolicy.DelayBeforeNextRetry(context, exceptionForRetry);
Thread.Sleep(retryDelay);
ResetRetry(context);
context.RetryTimes += 1;
if (OTSClientTestHelper.RetryTimesAndBackOffRecordSwith)
{
OTSClientTestHelper.RetryTimes += 1;
OTSClientTestHelper.RetryDelays.Add(retryDelay);
}
continue;
}
if (exceptionForRetry != null)
{
throw exceptionForRetry;
}
// TODO handle retry in BatchWriteRow & BatchGetRow
return;
}
}
public override void HandleAfter(Context context)
{
InnerHandler.HandleAfter(context);
}
