public InsideRuntimeClient(
Dispatcher dispatcher,
Catalog catalog,
ILocalGrainDirectory directory,
SiloAddress silo,
ClusterConfiguration config,
IConsistentRingProvider ring,
GrainTypeManager typeManager,
GrainFactory grainFactory,
InsideRcManager rcManager)
{
this.dispatcher = dispatcher;
MySilo = silo;
this.directory = directory;
ConsistentRingProvider = ring;
Catalog = catalog;
disposables = new List <IDisposable>();
callbacks = new ConcurrentDictionary <CorrelationId, CallbackData>();
Config = config;
config.OnConfigChange("Globals/Message", () => ResponseTimeout = Config.Globals.ResponseTimeout);
RuntimeClient.Current = this;
this.typeManager = typeManager;
this.InternalGrainFactory = grainFactory;
this.RcManager = rcManager;
this.InsideRcManager = rcManager;
}
internal InsideRcManagerSystem(InsideRcManager insideRcManager, Silo silo) : base(Constants.ReactiveCacheManagerId, silo.SiloAddress)
{
InsideRcManager = insideRcManager;
}
public void StartQuery <T>(object activationKey, IAddressable target, InvokeMethodRequest request, IGrainMethodInvoker invoker, Message message, bool refresh = false)
{
InsideRcManager.CreateAndStartSummary <T>(activationKey, target, request, invoker, message, refresh);
}
/// <summary>
/// Handles the an InvokeMethodRequest message on given target.
/// </summary>
/// <remarks>
/// Options when we receive a InvokeMethodRequest
/// ----------------------------------------------
/// 1) Intercepted RPC
/// 2) Request to start a reactive computation for this method invocation
/// 3) KeepAlive request of the reactive computation for this method invocation
/// 4) Normal Application RPC
/// 5) System RPC
/// </remarks>
/// <returns></returns>
internal async Task Invoke(IAddressable target, IInvokable invokable, Message message)
{
try
{
// Don't process messages that have already timed out
if (message.IsExpired)
{
message.DropExpiredMessage(MessagingStatisticsGroup.Phase.Invoke);
return;
}
RequestContext.Import(message.RequestContextData);
if (Config.Globals.PerformDeadlockDetection && !message.TargetGrain.IsSystemTarget)
{
UpdateDeadlockInfoInRequestContext(new RequestInvocationHistory(message));
// RequestContext is automatically saved in the msg upon send and propagated to the next hop
// in RuntimeClient.CreateMessage -> RequestContext.ExportToMessage(message);
}
object resultObject;
try
{
var request = (InvokeMethodRequest)message.BodyObject;
if (request.Arguments != null)
{
CancellationSourcesExtension.RegisterCancellationTokens(target, request, logger);
}
// Get the invoker for this invocation
IGrainMethodInvoker invoker = GetGrainMethodInvoker(target, invokable, message, request);
// Check whether this call should be intercepted
var siloWideInterceptor = SiloProviderRuntime.Instance.GetInvokeInterceptor();
var grainWithInterceptor = target as IGrainInvokeInterceptor;
// Silo-wide interceptors do not operate on system targets.
var hasSiloWideInterceptor = siloWideInterceptor != null && target is IGrain;
var hasGrainLevelInterceptor = grainWithInterceptor != null;
// Normal Application Call = an application call made from grain to grain or from client to grain.
// Some system-related calls such as the IReminderTable are encoded as Application messages, therefore we needed this check.
var NormalApplicationCall = message.Category == Message.Categories.Application && message.TargetGrain.IsGrain && (message.SendingGrain.IsGrain || message.SendingGrain.IsClient);
// 1) If the target has a grain-level interceptor or there is a silo-level interceptor, intercept the
// call.
if (hasGrainLevelInterceptor || hasSiloWideInterceptor)
{
resultObject = await InvokeWithInterceptors(target, request, invoker, hasSiloWideInterceptor, siloWideInterceptor, hasGrainLevelInterceptor, grainWithInterceptor);
}
else if (NormalApplicationCall)
{
// 2) Request to start a reactive computation for this method invocation
if (message.IsRcExecute())
{
HandleReactiveComputationExecute(target, request, message, invoker);
return; // Does not expect a return (OneWay Message)
}
// 3) Refresh Reactive Computation Subscription
else if (message.IsRcKeepAlive())
{
HandleReactiveComputationExecute(target, request, message, invoker, true);
return; // Does not expect a return (OneWay Message)
}
// 4) Normal application RPC call
else
{
// Invoke the method
resultObject = await invoker.Invoke(target, request);
// Check if there are any active reactive computations in this grain that require recomputation after this call
InsideRcManager.RecomputeSummaries();
}
}
// 5) System RPC call
else
{
resultObject = await invoker.Invoke(target, request);
}
}
catch (Exception exc1)
{
if (invokeExceptionLogger.IsVerbose || message.Direction == Message.Directions.OneWay)
{
invokeExceptionLogger.Warn(ErrorCode.GrainInvokeException,
"Exception during Grain method call of message: " + message, exc1);
}
if (message.Direction != Message.Directions.OneWay)
{
SafeSendExceptionResponse(message, exc1);
}
return;
}
if (message.Direction == Message.Directions.OneWay)
{
return;
}
SafeSendResponse(message, resultObject);
}
catch (Exception exc2)
{
logger.Warn(ErrorCode.Runtime_Error_100329, "Exception during Invoke of message: " + message, exc2);
if (message.Direction != Message.Directions.OneWay)
{
SafeSendExceptionResponse(message, exc2);
}
}
}
