public async Task <IActorResponseMessage> InvokeAsync(
IActorRequestMessage remotingRequestMessage,
string methodName,
CancellationToken cancellationToken)
{
return(await this.daprInteractor.InvokeActorMethodWithRemotingAsync(this.serializersManager, remotingRequestMessage, cancellationToken));
}
/// <summary>
/// Answers a <see cref="IActorRequestMessage{TResponseMessageType}"/> to the <see cref="IActorRef"/> sender
/// with the expected <typeparamref name="TResponseMessageType"/>.
/// </summary>
/// <typeparam name="TResponseMessageType"></typeparam>
/// <param name="request">The request to response to.</param>
/// <param name="sender">The sender (target) to answer.</param>
/// <param name="response">The response message.</param>
public static void Answer <TResponseMessageType>(this IActorRequestMessage <TResponseMessageType> request, IActorRef sender, TResponseMessageType response)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (sender == null)
{
throw new ArgumentNullException(nameof(sender));
}
sender.Tell(response);
}
public async Task <IActorResponseMessage> InvokeActorMethodWithRemotingAsync(ActorMessageSerializersManager serializersManager, IActorRequestMessage remotingRequestRequestMessage, CancellationToken cancellationToken = default)
{
var requestMessageHeader = remotingRequestRequestMessage.GetHeader();
var actorId = requestMessageHeader.ActorId.ToString();
var methodName = requestMessageHeader.MethodName;
var actorType = requestMessageHeader.ActorType;
var interfaceId = requestMessageHeader.InterfaceId;
var serializedHeader = serializersManager.GetHeaderSerializer()
.SerializeRequestHeader(remotingRequestRequestMessage.GetHeader());
var msgBodySeriaizer = serializersManager.GetRequestMessageBodySerializer(interfaceId);
var serializedMsgBody = msgBodySeriaizer.Serialize(remotingRequestRequestMessage.GetBody());
// Send Request
var relativeUrl = string.Format(CultureInfo.InvariantCulture, Constants.ActorMethodRelativeUrlFormat, actorType, actorId, methodName);
var requestId = Guid.NewGuid().ToString();
HttpRequestMessage RequestFunc()
{
var request = new HttpRequestMessage()
{
Method = HttpMethod.Put,
};
if (serializedMsgBody != null)
{
request.Content = new ByteArrayContent(serializedMsgBody);
request.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/octet-stream; charset=utf-8");
}
request.Headers.Add(Constants.RequestHeaderName, Encoding.UTF8.GetString(serializedHeader, 0, serializedHeader.Length));
return(request);
}
var retval = await this.SendAsync(RequestFunc, relativeUrl, requestId, cancellationToken);
IActorResponseMessageHeader actorResponseMessageHeader = null;
if (retval != null && retval.Headers != null)
{
if (retval.Headers.TryGetValues(Constants.ErrorResponseHeaderName, out IEnumerable <string> headerValues))
{
var header = headerValues.First();
// DeSerialize Actor Response Message Header
actorResponseMessageHeader =
serializersManager.GetHeaderSerializer()
.DeserializeResponseHeaders(
new MemoryStream(Encoding.ASCII.GetBytes(header)));
}
}
// Get the http response message body content and extract out expected actor response message body
IActorResponseMessageBody actorResponseMessageBody = null;
if (retval != null && retval.Content != null)
{
var responseMessageBody = await retval.Content.ReadAsStreamAsync();
// Deserialize Actor Response Message Body
// Deserialize to RemoteException when there is response header otherwise normal path
var responseBodySerializer = serializersManager.GetResponseMessageBodySerializer(interfaceId);
// actorResponseMessageHeader is not null, it means there is remote exception
if (actorResponseMessageHeader != null)
{
var isDeserialzied =
RemoteException.ToException(
responseMessageBody,
out var remoteMethodException);
if (isDeserialzied)
{
throw new ActorMethodInvocationException(
"Remote Actor Method Exception",
remoteMethodException,
false /* non transient */);
}
else
{
throw new ServiceException(remoteMethodException.GetType().FullName, string.Format(
CultureInfo.InvariantCulture,
SR.ErrorDeserializationFailure,
remoteMethodException.ToString()));
}
}
actorResponseMessageBody = responseBodySerializer.Deserialize(responseMessageBody);
}
return(new ActorResponseMessage(actorResponseMessageHeader, actorResponseMessageBody));
}
/// <summary>
/// Sends the specified <see cref="actorReference"/> a request message that implements <see cref="IActorRequestMessage{TResponseMessageType}"/>.
/// Will async await upon a response of Type <typeparamref name="TResponseType"/>.
/// </summary>
/// <typeparam name="TResponseType">The response message type.</typeparam>
/// <param name="actorReference">Actor target.</param>
/// <param name="message">The message to send.</param>
/// <param name="token">Cancel token.</param>
/// <returns>The response.</returns>
public static async Task <TResponseType> RequestAsync <TResponseType>(this IActorRef actorReference, IActorRequestMessage <TResponseType> message, CancellationToken token = default)
{
if (actorReference == null)
{
throw new ArgumentNullException(nameof(actorReference));
}
return(await actorReference
.Ask <TResponseType>(message, token));
}
public static void AnswerSuccess <TModelType, TResponseCodeType>(this IActorRequestMessage <ResponseModel <TModelType, TResponseCodeType> > request, IActorRef sender, TModelType response)
where TResponseCodeType : Enum
where TModelType : class
{
request.Answer(sender, new ResponseModel <TModelType, TResponseCodeType>(response));
}
