private string GetActorMethodName(ActorMessageHeaders actorMessageHeaders)
{
if (actorMessageHeaders == null)
{
return(null);
}
try
{
var methodName = "-";
var lookup = HashUtil.Combine(actorMessageHeaders.InterfaceId, actorMessageHeaders.MethodId);
if (ActorMethodMap.ContainsKey(lookup))
{
methodName = ActorMethodMap[lookup];
return(methodName);
}
methodName = _actorMethodDispatcher.GetMethodDispatcherMapName(
actorMessageHeaders.InterfaceId, actorMessageHeaders.MethodId);
ActorMethodMap[lookup] = methodName;
return(methodName);
}
catch (Exception ex)
{
// ignored
//_logger?.FailedToGetActorMethodName(actorMessageHeaders, ex);
}
return(null);
}
internal Task UnsubscribeAsync(int eventInterfaceId, Guid subscriberId)
{
var headers = new ActorMessageHeaders
{
ActorId = this.actorId,
InterfaceId = ActorEventSubscription.InterfaceId,
MethodId = ActorEventSubscription.UnSubscribeMethodId,
};
var serviceMessageHeaders = headers.ToServiceMessageHeaders();
serviceMessageHeaders.InterfaceId = ActorEventSubscription.InterfaceId;
serviceMessageHeaders.MethodId = ActorEventSubscription.UnSubscribeMethodId;
var msgBody = new ActorMessageBody()
{
Value = new EventSubscriptionRequestBody()
{
eventInterfaceId = eventInterfaceId,
subscriptionId = subscriberId
}
};
var msgBodyBytes = SerializationUtility.Serialize(ActorEventSubscription.Serializer, msgBody);
return(this.InvokeWithRetryAsync(
client => client.RequestResponseAsync(serviceMessageHeaders, msgBodyBytes),
CancellationToken.None));
}
private static ActorMessageHeaders GetActorMessageHeaders(ServiceRemotingMessageHeaders messageHeaders)
{
ActorMessageHeaders actorMessageHeaders = null;
if (ActorMessageHeaders.TryFromServiceMessageHeaders(messageHeaders, out actorMessageHeaders))
{
}
return(actorMessageHeaders);
}
internal Task <byte[]> InvokeAsync(ActorMessageHeaders headers, byte[] requestMsgBody, CancellationToken cancellationToken)
{
var serviceMessageHeaders = headers.ToServiceMessageHeaders();
serviceMessageHeaders.InterfaceId = ActorMessageDispatch.InterfaceId;
return(this.InvokeAsync(
serviceMessageHeaders,
requestMsgBody,
cancellationToken));
}
private Task <byte[]> OnDispatch(
ActorMessageHeaders actorMessageHeaders,
byte[] requestBodyBytes,
CancellationToken cancellationToken)
{
return(this.actorService.ActorManager.InvokeAsync(
actorMessageHeaders.ActorId,
actorMessageHeaders.InterfaceId,
actorMessageHeaders.MethodId,
actorMessageHeaders.CallContext,
requestBodyBytes,
cancellationToken));
}
internal override Task <byte[]> InvokeAsync(
int interfaceId,
int methodId,
byte[] requestMsgBodyBytes,
CancellationToken cancellationToken)
{
var actorMsgHeaders = new ActorMessageHeaders()
{
ActorId = this.servicePartitionClient.ActorId,
InterfaceId = interfaceId,
MethodId = methodId,
CallContext = GetCallContext()
};
return(this.servicePartitionClient.InvokeAsync(actorMsgHeaders, requestMsgBodyBytes, cancellationToken));
}
private async Task <byte[]> HandleSubscriptionRequestsAsync(
IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestMsgBodyBytes)
{
ActorMessageHeaders actorMessageHeaders;
if (!ActorMessageHeaders.TryFromServiceMessageHeaders(messageHeaders, out actorMessageHeaders))
{
//This can only happen if there is issue in our product code like Message Corruption or changing headers format.
ReleaseAssert.Failfast("ActorMessageHeaders Deserialization failed");
}
if (actorMessageHeaders.MethodId == ActorEventSubscription.SubscribeMethodId)
{
var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes);
var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value;
await this.actorService.ActorManager.SubscribeAsync(
actorMessageHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
new ActorEventSubscriberProxy(
castedRequestMsgBody.subscriptionId,
requestContext.GetCallbackClient()));
return(null);
}
if (actorMessageHeaders.MethodId == ActorEventSubscription.UnSubscribeMethodId)
{
var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes);
var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value;
await this.actorService.ActorManager.UnsubscribeAsync(
actorMessageHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
castedRequestMsgBody.subscriptionId);
return(null);
}
throw new MissingMethodException(string.Format(CultureInfo.CurrentCulture, Actors.SR.ErrorInvalidMethodId, actorMessageHeaders.MethodId));
}
private async Task <byte[]> HandleSubscriptionRequests(
IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestMsgBodyBytes)
{
ActorMessageHeaders actorMessageHeaders;
if (!ActorMessageHeaders.TryFromServiceMessageHeaders(messageHeaders, out actorMessageHeaders))
{
throw new SerializationException(Actors.SR.ErrorActorMessageHeadersDeserializationFailed);
}
if (actorMessageHeaders.MethodId == ActorEventSubscription.SubscribeMethodId)
{
var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes);
var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value;
await this.actorService.ActorManager.SubscribeAsync(
actorMessageHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
new ActorEventSubscriberProxy(
castedRequestMsgBody.subscriptionId,
requestContext.GetCallbackClient()));
return(null);
}
if (actorMessageHeaders.MethodId == ActorEventSubscription.UnSubscribeMethodId)
{
var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes);
var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value;
await this.actorService.ActorManager.UnsubscribeAsync(
actorMessageHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
castedRequestMsgBody.subscriptionId);
return(null);
}
throw new MissingMethodException(string.Format(CultureInfo.CurrentCulture, Actors.SR.ErrorInvalidMethodId, actorMessageHeaders.MethodId));
}
private async Task <byte[]> HandleActorMethodDispatchAsync(
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestMsgBodyBytes)
{
var startTime = DateTime.UtcNow;
ActorMessageHeaders actorMessageHeaders;
if (!ActorMessageHeaders.TryFromServiceMessageHeaders(messageHeaders, out actorMessageHeaders))
{
throw new SerializationException(Actors.SR.ErrorActorMessageHeadersDeserializationFailed);
}
if (this.IsCancellationRequest(messageHeaders))
{
await this.cancellationHelper.CancelRequestAsync(
actorMessageHeaders.InterfaceId,
actorMessageHeaders.MethodId,
messageHeaders.InvocationId);
return(null);
}
else
{
byte[] retVal;
this.actorService.ActorManager.DiagnosticsEventManager.ActorRequestProcessingStart();
try
{
retVal = await this.cancellationHelper.DispatchRequest(
actorMessageHeaders.InterfaceId,
actorMessageHeaders.MethodId,
messageHeaders.InvocationId,
cancellationToken => this.OnDispatch(actorMessageHeaders, requestMsgBodyBytes, cancellationToken));
}
finally
{
this.actorService.ActorManager.DiagnosticsEventManager.ActorRequestProcessingFinish(startTime);
}
return(retVal);
}
}
public void OneWayMessage(ServiceRemotingMessageHeaders serviceMessageHeaders, byte[] requestBody)
{
ActorMessageHeaders actorHeaders;
if (!ActorMessageHeaders.TryFromServiceMessageHeaders(serviceMessageHeaders, out actorHeaders))
{
return;
}
ActorMethodDispatcherBase eventDispatcher;
if ((this.eventIdToDispatchersMap == null) ||
(!this.eventIdToDispatchersMap.TryGetValue(actorHeaders.InterfaceId, out eventDispatcher)))
{
return;
}
SubscriptionInfo info;
if (!this.subscriptionIdToInfoMap.TryGetValue(actorHeaders.ActorId.GetGuidId(), out info))
{
return;
}
if (info.Subscriber.EventId != actorHeaders.InterfaceId)
{
return;
}
try
{
var eventMsgBody = eventDispatcher.DeserializeRequestMessageBody(requestBody);
eventDispatcher.Dispatch(info.Subscriber.Instance, actorHeaders.MethodId, eventMsgBody);
}
catch
{
// ignored
}
}
public void FailedToGetActorMethodName(ActorMessageHeaders actorMessageHeaders, Exception ex)
{
throw new NotImplementedException();
}
public void RecieveActorMessageFailed(Uri requestUri, string actorMethodName, ActorMessageHeaders actorMessageHeaders,
CustomServiceRequestHeader customServiceRequestHeader, Exception ex)
{
throw new NotImplementedException();
}
public IDisposable RecieveActorMessage(Uri requestUri, string actorMethodName, ActorMessageHeaders actorMessageHeaders,
CustomServiceRequestHeader customServiceRequestHeader)
{
throw new NotImplementedException();
}
private Task <byte[]> RequestActorResponseAsync(ServiceRemotingMessageHeaders messageHeaders, ActorMessageHeaders actorMessageHeaders, CustomServiceRequestHeader customServiceRequestHeader, byte[] requestBody)
{
var methodName = GetActorMethodName(actorMessageHeaders);
using (Logger.CallActor(ServiceUri, methodName, actorMessageHeaders, customServiceRequestHeader))
{
try
{
var result = this.InnerClient.RequestResponseAsync(messageHeaders, requestBody);
return(result);
}
catch (Exception ex)
{
Logger.CallActorFailed(ServiceUri, methodName, actorMessageHeaders, customServiceRequestHeader, ex);
throw;
}
}
}
