/// <summary>
/// Handle an incoming message and queue/invoke appropriate handler
/// </summary>
/// <param name="message"></param>
/// <param name="targetActivation"></param>
public void HandleIncomingRequest(Message message, ActivationData targetActivation)
{
lock (targetActivation)
{
if (targetActivation.Grain.IsGrain && message.IsUsingInterfaceVersions)
{
var request = ((InvokeMethodRequest)message.GetDeserializedBody(this.serializationManager));
var compatibilityDirector = compatibilityDirectorManager.GetDirector(request.InterfaceId);
var currentVersion = catalog.GrainTypeManager.GetLocalSupportedVersion(request.InterfaceId);
if (!compatibilityDirector.IsCompatible(request.InterfaceVersion, currentVersion))
{
catalog.DeactivateActivationOnIdle(targetActivation);
}
}
if (targetActivation.State == ActivationState.Invalid || targetActivation.State == ActivationState.Deactivating)
{
ProcessRequestToInvalidActivation(message, targetActivation.Address, targetActivation.ForwardingAddress, "HandleIncomingRequest");
return;
}
// Now we can actually scheduler processing of this request
targetActivation.RecordRunning(message);
MessagingProcessingStatisticsGroup.OnDispatcherMessageProcessedOk(message);
scheduler.QueueWorkItem(new InvokeWorkItem(targetActivation, message, this, this.invokeWorkItemLogger), targetActivation.SchedulingContext);
}
}
private void ReceiveResponse(Message message, ActivationData targetActivation)
{
lock (targetActivation)
{
if (targetActivation.State == ActivationState.Invalid || targetActivation.State == ActivationState.FailedToActivate)
{
_messagingTrace.OnDispatcherReceiveInvalidActivation(message, targetActivation.State);
return;
}
MessagingProcessingStatisticsGroup.OnDispatcherMessageProcessedOk(message);
_catalog.RuntimeClient.ReceiveResponse(message);
}
}
/// <summary>
/// Handle an incoming message and queue/invoke appropriate handler
/// </summary>
/// <param name="message"></param>
/// <param name="targetActivation"></param>
public void HandleIncomingRequest(Message message, ActivationData targetActivation)
{
lock (targetActivation)
{
if (targetActivation.State == ActivationState.Invalid)
{
ProcessRequestToInvalidActivation(message, targetActivation.Address, targetActivation.ForwardingAddress, "HandleIncomingRequest");
return;
}
// Now we can actually scheduler processing of this request
targetActivation.RecordRunning(message);
MessagingProcessingStatisticsGroup.OnDispatcherMessageProcessedOk(message);
scheduler.QueueWorkItem(new InvokeWorkItem(targetActivation, message, this), targetActivation.SchedulingContext);
}
}
private void ReceiveResponse(Message message, ActivationData targetActivation)
{
lock (targetActivation)
{
if (targetActivation.State == ActivationState.Invalid || targetActivation.State == ActivationState.FailedToActivate)
{
logger.Warn((int)ErrorCode.Dispatcher_Receive_InvalidActivation,
"Response received for {State} activation {Message}", targetActivation.State, message);
MessagingProcessingStatisticsGroup.OnDispatcherMessageProcessedError(message, "Invalid");
return;
}
MessagingProcessingStatisticsGroup.OnDispatcherMessageProcessedOk(message);
if (Transport.TryDeliverToProxy(message))
{
return;
}
this.catalog.RuntimeClient.ReceiveResponse(message);
}
}
private void ReceiveResponse(Message message, ActivationData targetActivation)
{
lock (targetActivation)
{
if (targetActivation.State == ActivationState.Invalid)
{
logger.Warn(ErrorCode.Dispatcher_Receive_InvalidActivation,
"Response received for invalid activation {0}", message);
MessagingProcessingStatisticsGroup.OnDispatcherMessageProcessedError(message, "Ivalid");
return;
}
MessagingProcessingStatisticsGroup.OnDispatcherMessageProcessedOk(message);
if (Transport.TryDeliverToProxy(message))
{
return;
}
RuntimeClient.Current.ReceiveResponse(message);
}
}
/// <summary>
/// Handle an incoming message and queue/invoke appropriate handler
/// </summary>
/// <param name="message"></param>
/// <param name="targetActivation"></param>
public void HandleIncomingRequest(Message message, ActivationData targetActivation)
{
lock (targetActivation)
{
if (targetActivation.State == ActivationState.Invalid || targetActivation.State == ActivationState.FailedToActivate)
{
ProcessRequestToInvalidActivation(
message,
targetActivation.Address,
targetActivation.ForwardingAddress,
"HandleIncomingRequest",
rejectMessages: targetActivation.State == ActivationState.FailedToActivate);
return;
}
if (targetActivation.Grain.IsLegacyGrain() && message.IsUsingInterfaceVersions)
{
var request = (InvokeMethodRequest)message.BodyObject;
var compatibilityDirector = compatibilityDirectorManager.GetDirector(request.InterfaceId);
var currentVersion = this.grainTypeManager.GetLocalSupportedVersion(request.InterfaceId);
if (!compatibilityDirector.IsCompatible(request.InterfaceVersion, currentVersion))
{
catalog.DeactivateActivationOnIdle(targetActivation);
ProcessRequestToInvalidActivation(
message,
targetActivation.Address,
targetActivation.ForwardingAddress,
"HandleIncomingRequest - Incompatible request");
return;
}
}
// Now we can actually scheduler processing of this request
targetActivation.RecordRunning(message, message.IsAlwaysInterleave);
MessagingProcessingStatisticsGroup.OnDispatcherMessageProcessedOk(message);
this.messagingTrace.OnScheduleMessage(message);
scheduler.QueueWorkItem(new InvokeWorkItem(targetActivation, message, this, this.invokeWorkItemLogger));
}
}
/// <summary>
/// Handle an incoming message and queue/invoke appropriate handler
/// </summary>
/// <param name="message"></param>
/// <param name="targetActivation"></param>
public void HandleIncomingRequest(Message message, ActivationData targetActivation)
{
lock (targetActivation)
{
if (targetActivation.State == ActivationState.Invalid || targetActivation.State == ActivationState.FailedToActivate)
{
_dispatcher.ProcessRequestToInvalidActivation(
message,
targetActivation.Address,
targetActivation.ForwardingAddress,
"HandleIncomingRequest",
rejectMessages: targetActivation.State == ActivationState.FailedToActivate);
return;
}
if (message.InterfaceVersion > 0)
{
var compatibilityDirector = _compatibilityDirectorManager.GetDirector(message.InterfaceType);
var currentVersion = _versionManifest.GetLocalVersion(message.InterfaceType);
if (!compatibilityDirector.IsCompatible(message.InterfaceVersion, currentVersion))
{
_catalog.DeactivateActivationOnIdle(targetActivation);
_dispatcher.ProcessRequestToInvalidActivation(
message,
targetActivation.Address,
targetActivation.ForwardingAddress,
"HandleIncomingRequest - Incompatible request");
return;
}
}
// Now we can actually scheduler processing of this request
targetActivation.RecordRunning(message, message.IsAlwaysInterleave);
MessagingProcessingStatisticsGroup.OnDispatcherMessageProcessedOk(message);
_messagingTrace.OnScheduleMessage(message);
_scheduler.QueueWorkItem(new InvokeWorkItem(targetActivation, message, _catalog.RuntimeClient, this));
}
}
/// <summary>
/// Handle an incoming message and queue/invoke appropriate handler
/// </summary>
/// <param name="message"></param>
/// <param name="targetActivation"></param>
public void HandleIncomingRequest(Message message, ActivationData targetActivation)
{
lock (targetActivation)
{
if (targetActivation.State == ActivationState.Invalid)
{
ProcessRequestToInvalidActivation(message, targetActivation.Address, targetActivation.ForwardingAddress, "HandleIncomingRequest");
return;
}
// Now we can actually scheduler processing of this request
targetActivation.RecordRunning(message);
var context = new SchedulingContext(targetActivation);
if (Message.WriteMessagingTraces)
{
message.AddTimestamp(Message.LifecycleTag.EnqueueWorkItem);
}
MessagingProcessingStatisticsGroup.OnDispatcherMessageProcessedOk(message);
Scheduler.QueueWorkItem(new InvokeWorkItem(targetActivation, message, context), context);
}
}