public ActorMessageEnvelope <T> ConvertTo <T>()
{
var envelope = new ActorMessageEnvelope <T>();
envelope.CopyFrom(this);
return(envelope);
}
public void OnSyncMessage <P>(ActorIdentity remoteActor, ActorMessageEnvelope <P> response)
{
if (response == null ||
string.IsNullOrWhiteSpace(response.CorrelationID))
{
throw new InvalidOperationException("Invalid or empty message CorrelationID.");
}
BlockingCallbackHolder callback = null;
if (_callbacks.TryRemove(response.CorrelationID, out callback) &&
callback != null)
{
var action = callback.Action as Action <ActorMessageEnvelope <P> >;
if (action != null)
{
action.Invoke(response);
}
try
{
callback.Waiter.Set();
}
catch (ObjectDisposedException) { }
}
}
public ActorMessageEnvelope <P> SendMessage <R, P>(string remoteActorType, ActorMessageEnvelope <R> request, TimeSpan timeout)
{
ActorMessageEnvelope <P> response = default(ActorMessageEnvelope <P>);
Action <ActorMessageEnvelope <P> > callback = (r) => { response = r; };
try
{
ManualResetEvent waiter = new ManualResetEvent(false);
_callbacks.Add(request.MessageID, new BlockingCallbackHolder(request.MessageID, waiter, callback));
this.BeginSend(remoteActorType, request.ToBytes(this.Encoder));
if (!waiter.WaitOne(timeout))
{
_log.ErrorFormat("Timeout when waiting message [{0}] after {1} seconds.",
request.MessageType, timeout.TotalSeconds);
}
waiter.Reset();
waiter.Dispose();
BlockingCallbackHolder throwAway = null;
_callbacks.TryRemove(request.MessageID, out throwAway);
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
}
return(response);
}
public static void HandledBy <T>(this ActorMessageEnvelope envelope, object handlerFrom, Type messageType, IActorMessageDecoder decoder, T state, Func <string, string> getHandlerName) where T : class
{
HandledBy <T>(envelope, handlerFrom, messageType, decoder, state,
(object o) =>
{
return(o.GetType().GetMethod(getHandlerName(envelope.MessageType), BindingFlags.NonPublic | BindingFlags.Instance));
});
}
public void BeginBroadcast <T>(IEnumerable <string> remoteActorTypes, T message)
{
var envelope = new ActorMessageEnvelope <T>()
{
Message = message,
};
this.BeginBroadcast(remoteActorTypes, envelope);
}
public void BeginBroadcast <T>(string remoteActorType, T message)
{
var envelope = new ActorMessageEnvelope <T>()
{
Message = message,
};
this.BeginBroadcast <T>(remoteActorType, envelope);
}
public void BeginReply <T>(string channelIdentifier, T message)
{
var envelope = new ActorMessageEnvelope <T>()
{
Message = message,
};
this.BeginReply <T>(channelIdentifier, envelope);
}
public void Send <T>(string remoteActorType, T message)
{
var envelope = new ActorMessageEnvelope <T>()
{
Message = message,
};
this.Send <T>(remoteActorType, envelope);
}
public void BeginSend <T>(ActorIdentity remoteActor, T message)
{
var envelope = new ActorMessageEnvelope <T>()
{
Message = message,
};
this.BeginSend <T>(remoteActor, envelope);
}
public P Send <R, P>(string remoteActorType, R request, TimeSpan timeout)
{
var envelope = new ActorMessageEnvelope <R>()
{
Message = request,
};
return(this.Send <R, P>(remoteActorType, envelope, timeout).Message);
}
public void CopyFrom <T>(ActorMessageEnvelope <T> source)
{
this.MessageID = source.MessageID;
this.MessageTime = source.MessageTime;
this.CorrelationID = source.CorrelationID;
this.CorrelationTime = source.CorrelationTime;
this.MessageType = source.MessageType;
}
public void CopyFrom(ActorMessageEnvelope source)
{
this.MessageID = source.MessageID;
this.MessageTime = source.MessageTime;
this.CorrelationID = source.CorrelationID;
this.CorrelationTime = source.CorrelationTime;
this.SourceEndpoint = source.SourceEndpoint == null ? null : source.SourceEndpoint.Clone();
this.TargetEndpoint = source.TargetEndpoint == null ? null : source.TargetEndpoint.Clone();
this.MessageType = source.MessageType;
}
private void OnInvokeMethodRequest(ActorSender sender, ActorMessageEnvelope <InvokeMethodRequest> request)
{
request.Message.Deserialize(_methodFixture.ArgumentDecoder);
var message = InvokeMethod(request.Message);
message.Serialize(_methodFixture.ArgumentEncoder);
var response = new ActorMessageEnvelope <InvokeMethodResponse>()
{
CorrelationID = request.MessageID,
CorrelationTime = request.MessageTime,
Message = message,
};
this.BeginReply(sender.ChannelIdentifier, response);
}
protected override void DoHandleMessage(ActorIdentity remoteActor, ActorMessageEnvelope envelope)
{
if (GetAdmissibleMessageHandleStrategy(envelope.MessageType).IsRequestResponseModel)
{
envelope.HandledBy(this.Actor, GetAdmissibleMessageType(envelope.MessageType), this.Actor.Decoder, remoteActor,
(object o) =>
{
return(o
.GetType()
.GetMethod("OnSyncMessage")
.MakeGenericMethod(GetAdmissibleMessageType(envelope.MessageType)));
});
}
else
{
base.DoHandleMessage(remoteActor, envelope);
}
}
protected override void DoHandleMessage(ActorSender sender, ActorMessageEnvelope envelope)
{
if (GetAdmissibleMessageHandleStrategy(envelope.MessageType).IsOneWay)
{
base.DoHandleMessage(sender, envelope);
}
else
{
envelope.HandledBy(this.Actor, GetAdmissibleMessageType(envelope.MessageType), this.Actor.Decoder, sender,
(object o) =>
{
return(o
.GetType()
.GetMethod("OnSyncMessage")
.MakeGenericMethod(GetAdmissibleMessageType(envelope.MessageType)));
});
}
}
public static void HandledBy <T>(this ActorMessageEnvelope envelope, object handlerFrom, Type messageType, IActorMessageDecoder decoder, T state, Func <object, MethodInfo> getHandlerMethod) where T : class
{
var instantiateMethod = typeof(ActorMessageEnvelopeExtensions)
.GetMethod("Instantiate", new Type[] { typeof(ActorMessageEnvelope), typeof(IActorMessageDecoder) })
.MakeGenericMethod(messageType);
var instantiatedEnvelope = instantiateMethod.Invoke(null, new object[] { envelope, decoder });
try
{
var messageHandlerMethod = getHandlerMethod(handlerFrom);
messageHandlerMethod.Invoke(handlerFrom, new object[] { state, instantiatedEnvelope });
}
catch (Exception ex)
{
_log.ErrorFormat("HandledBy, MessageType[{0}], ErrorMessage[{1}].", messageType.Name, ex);
throw;
}
}
protected override void DoHandleMessage(ActorIdentity remoteActor, ActorMessageEnvelope envelope)
{
if (IsRateLimited)
{
_rateLimiter.Wait();
try
{
base.DoHandleMessage(remoteActor, envelope);
}
finally
{
_rateLimiter.Release();
}
}
else
{
base.DoHandleMessage(remoteActor, envelope);
}
}
public void HandleMessage(ActorIdentity remoteActor, ActorMessageEnvelope envelope)
{
if (!GetAdmissibleMessageHandleStrategy(envelope.MessageType).IsHandledInSeparateThread)
{
DoHandleMessage(remoteActor, envelope);
}
else
{
Task.Run(() =>
{
try
{
DoHandleMessage(remoteActor, envelope);
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
}
});
}
}
public virtual void HandleMessage(ActorSender sender, ActorMessageEnvelope envelope)
{
if (GetAdmissibleMessageHandleStrategy(envelope.MessageType).IsAsyncPattern)
{
Task.Factory.StartNew(() =>
{
try
{
DoHandleMessage(sender, envelope);
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
}
},
TaskCreationOptions.PreferFairness);
}
else
{
DoHandleMessage(sender, envelope);
}
}
public void HandleMessage(ActorIdentity remoteActor, ActorMessageEnvelope envelope)
{
if (!GetAdmissibleMessageHandleStrategy(envelope.MessageType).IsHandledInSeparateThread)
{
DoHandleMessage(remoteActor, envelope);
}
else
{
Task.Factory.StartNew(() =>
{
try
{
DoHandleMessage(remoteActor, envelope);
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
}
},
TaskCreationOptions.PreferFairness);
}
}
public void BeginSend <T>(ActorIdentity remoteActor, ActorMessageEnvelope <T> message)
{
BeginSend(remoteActor, message.ToBytes(this.Encoder));
}
protected virtual void DoHandleMessage(ActorSender sender, ActorMessageEnvelope envelope)
{
envelope.HandledBy(this, GetAdmissibleMessageType(envelope.MessageType), this.Actor.Decoder, sender);
}
public virtual bool CanHandleMessage(ActorMessageEnvelope envelope)
{
return(_admissibleMessages.ContainsKey(envelope.MessageType));
}
public static void HandledBy <T>(this ActorMessageEnvelope envelope, object handlerFrom, Type messageType, IActorMessageDecoder decoder, T state) where T : class
{
HandledBy <T>(envelope, handlerFrom, messageType, decoder, state, (string s) => { return(@"On" + s); });
}
public static void HandledBy(this ActorMessageEnvelope envelope, object handlerFrom, Type messageType, IActorMessageDecoder decoder)
{
HandledBy(envelope, handlerFrom, messageType, decoder, (string s) => { return(@"On" + s); });
}
public static byte[] ToBytes <T>(this ActorMessageEnvelope <T> envelope, IActorMessageEncoder encoder)
{
return(ToBytes(Marshal(envelope, encoder), encoder));
}
public static byte[] ToBytes(this ActorMessageEnvelope envelope, IActorMessageEncoder encoder)
{
return(encoder.EncodeMessage(envelope));
}
public void Send <T>(string remoteActorType, ActorMessageEnvelope <T> message)
{
BeginSend(remoteActorType, message.ToBytes(this.Encoder));
}
public IAsyncResult BeginSend <T>(string remoteActorType, string remoteActorName, ActorMessageEnvelope <T> message, AsyncCallback callback, object state)
{
return(BeginSend(remoteActorType, remoteActorName, message.ToBytes(this.Encoder), callback, state));
}
public IAsyncResult BeginSend <T>(ActorIdentity remoteActor, ActorMessageEnvelope <T> message, AsyncCallback callback, object state)
{
return(BeginSend(remoteActor, message.ToBytes(this.Encoder), callback, state));
}
