public Message CreateRejectionResponse(RejectionTypes type, string info, OrleansException ex = null)
{
var response = CreateResponseMessage();
response.Result = ResponseTypes.Rejection;
response.RejectionType = type;
response.RejectionInfo = info;
response.BodyObject = ex;
if (logger.IsVerbose)
{
logger.Verbose("Creating {0} rejection with info '{1}' for {2} at:" + Environment.NewLine + "{3}", type, info, this, new System.Diagnostics.StackTrace(true));
}
return(response);
}
private static void ResponseCallback(Message message, TaskCompletionSource <object> context)
{
Response response;
if (message.Result != Message.ResponseTypes.Rejection)
{
try
{
response = (Response)message.BodyObject;
}
catch (Exception exc)
{
// catch the Deserialize exception and break the promise with it.
response = Response.ExceptionResponse(exc);
}
}
else
{
Exception rejection;
switch (message.RejectionType)
{
case Message.RejectionTypes.GatewayTooBusy:
rejection = new GatewayTooBusyException();
break;
case Message.RejectionTypes.DuplicateRequest:
return; // Ignore duplicates
default:
if (String.IsNullOrEmpty(message.RejectionInfo))
{
message.RejectionInfo = "Unable to send request - no rejection info available";
}
rejection = new OrleansException(message.RejectionInfo);
break;
}
response = Response.ExceptionResponse(rejection);
}
if (!response.ExceptionFlag)
{
context.TrySetResult(response.Data);
}
else
{
context.TrySetException(response.Exception);
}
}
public Message CreateRejectionResponse(RejectionTypes type, string info, OrleansException ex = null)
{
var response = CreateResponseMessage();
response.Result = ResponseTypes.Rejection;
response.RejectionType = type;
response.RejectionInfo = info;
response.BodyObject = ex;
if (logger.IsVerbose) logger.Verbose("Creating {0} rejection with info '{1}' for {2} at:" + Environment.NewLine + "{3}", type, info, this, Utils.GetStackTrace());
return response;
}
/// <summary>
/// Async method to cause write of the current grain state data into backing store.
/// </summary>
public async Task WriteStateAsync()
{
const string what = "WriteState";
Stopwatch sw = Stopwatch.StartNew();
GrainReference grainRef = baseGrain.GrainReference;
Exception errorOccurred;
try
{
await store.WriteStateAsync(grainTypeName, grainRef, grain.GrainState);
StorageStatisticsGroup.OnStorageWrite(store, grainTypeName, grainRef, sw.Elapsed);
errorOccurred = null;
}
catch (Exception exc)
{
errorOccurred = exc;
}
// Note, we can't do this inside catch block above, because await is not permitted there.
if (errorOccurred != null)
{
StorageStatisticsGroup.OnStorageWriteError(store, grainTypeName, grainRef);
string errMsgToLog = MakeErrorMsg(what, errorOccurred);
store.Log.Error((int) ErrorCode.StorageProvider_WriteFailed, errMsgToLog, errorOccurred);
errorOccurred = new OrleansException(errMsgToLog, errorOccurred);
#if REREAD_STATE_AFTER_WRITE_FAILED
// Force rollback to previously stored state
try
{
sw.Restart();
store.Log.Warn(ErrorCode.StorageProvider_ForceReRead, "Forcing re-read of last good state for grain Type={0}", grainTypeName);
await store.ReadStateAsync(grainTypeName, grainRef, grain.GrainState);
StorageStatisticsGroup.OnStorageRead(store, grainTypeName, grainRef, sw.Elapsed);
}
catch (Exception exc)
{
StorageStatisticsGroup.OnStorageReadError(store, grainTypeName, grainRef);
// Should we ignore this secondary error, and just return the original one?
errMsgToLog = MakeErrorMsg("re-read state from store after write error", exc);
errorOccurred = new OrleansException(errMsgToLog, exc);
}
#endif
}
sw.Stop();
if (errorOccurred != null)
{
throw errorOccurred;
}
}
public Message CreateRejectionResponse(Message request, Message.RejectionTypes type, string info, OrleansException ex = null)
{
var response = this.CreateResponseMessage(request);
response.Result = Message.ResponseTypes.Rejection;
response.RejectionType = type;
response.RejectionInfo = info;
response.BodyObject = ex;
if (this.logger.IsVerbose)
{
this.logger.Verbose("Creating {0} rejection with info '{1}' for {2} at:" + Environment.NewLine + "{3}", type, info, this, Utils.GetStackTrace());
}
return(response);
}
