//Methods:
protected PathELManager(EdgeListener el, bool thread) {
_el = el;
_sync = new object();
_edges = new List<Edge>();
_unannounced = new Dictionary<Edge, PathEdge>();
_pel_map = new Dictionary<string, PathEdgeListener>();
//Use the reqrep protocol with a special prefix:
_rrm = new ReqrepManager("PathELManager:" + el.ToString(), PType.Protocol.Pathing);
_rrm.Subscribe(this, null);
Rpc = new RpcManager(_rrm);
Rpc.AddHandler("sys:pathing", this);
_el.EdgeEvent += HandleEdge;
_running = true;
if(thread) {
_timer_thread = new Thread(
delegate() {
int counter = 0;
int max_counter = EDGE_PERIOD / 1000;
while(_running) {
Thread.Sleep(1000);
ReqrepTimeoutChecker();
if(++counter == max_counter) {
counter = 0;
EdgeTimeoutChecker();
}
}
}
);
_timer_thread.IsBackground = true;
_timer_thread.Start();
}
}
public BrunetRpc() {
_rrm = new ReqrepManager("BrunetRpc");
_rrm.Subscribe(this, null);
Rpc = new RpcManager(_rrm);
IPHandler = new IPHandler();
IPHandler.Subscribe(this, null);
_running = 1;
_timer = new Thread(TimerThread);
_timer.IsBackground = true;
_timer.Start();
}
public SymphonySecurityOverlord(Node node, RSACryptoServiceProvider rsa,
CertificateHandler ch, ReqrepManager rrman) :
base(rsa, ch, rrman)
{
_ch.AddCertificateVerification(new SymphonyVerification(node.ConnectionTable));
_node = node;
_address_to_sa = new Dictionary<Address, SecurityAssociation>();
_sa_to_address = new Dictionary<SecurityAssociation, Address>();
lock(_sync) {
_node.Rpc.AddHandler("Security", this);
}
}
public ProtocolSecurityOverlord(Node node,
RSACryptoServiceProvider rsa,
ReqrepManager rrman,
CertificateHandler ch) :
base(rsa, rrman, ch)
{
_node = node;
_address_to_sa = new Dictionary<Address, SecurityAssociation>();
_sa_to_address = new Dictionary<SecurityAssociation, Address>();
lock(_sync) {
_node.Rpc.AddHandler("Security", this);
}
}
public void HandleError(ReqrepManager man, int message_number,
ReqrepManager.ReqrepError err, ISender ret_path, object state) {
_rrman.StopRequest(message_number, this);
RpcManager my_rpc = System.Threading.Interlocked.Exchange(ref _rpc, null);
if( my_rpc != null ) {
//We have not sent any reply yet:
my_rpc.SendResult( _req_state,
new Exception(String.Format("Error: {0} from: {1}", err, ret_path)));
}
}
public bool HandleReply(ReqrepManager man, ReqrepManager.ReqrepType rt,
int mid,
PType prot,
MemBlock payload, ISender returnpath,
ReqrepManager.Statistics statistics,
object state) {
DateTime reply_time = DateTime.UtcNow;
ListDictionary res_dict = new ListDictionary();
AHSender ah_rp = returnpath as AHSender;
if( ah_rp != null ) {
res_dict["target"] = ah_rp.Destination.ToString();
}
//Here are the number of microseconds
res_dict["musec"] = (int)( 1000.0 * ((reply_time - _start_time).TotalMilliseconds) );
//Send the RPC result now;
RpcManager my_rpc = System.Threading.Interlocked.Exchange(ref _rpc, null);
if( my_rpc != null ) {
//We have not sent any reply yet:
my_rpc.SendResult(_req_state, res_dict);
}
return false;
}
public EchoSendHandler(Node n, ISender dest, object req_state) {
_rrman = n.Rrm;
_rpc = n.Rpc;
_req_state = req_state;
_dest = dest;
}
/**
* Static method to create ReqrepManager objects
* @param context the object that this manager works for
*/
public static ReqrepManager GetInstance(string context) {
lock(_inst_tab_sync) {
var inst = _instance_table.GetValue(context);
if(null == inst) {
//This puts the item into _instance_table:
inst = new ReqrepManager(context);
}
return inst;
}
}
public RpcResult(ISender ret_path, object res, ReqrepManager.Statistics stats) {
_ret_path = ret_path;
_result = res;
_statistics = stats;
}
/**
* When an error comes in, this handles it
*/
public void HandleError(ReqrepManager man, int message_number,
ReqrepManager.ReqrepError err, ISender ret_path, object state)
{
Exception x = null;
RpcRequestState rs = (RpcRequestState) state;
Channel bq = rs.Results;
switch(err) {
case ReqrepManager.ReqrepError.NoHandler:
x = new AdrException(-32601, "No RPC Handler on remote host");
break;
case ReqrepManager.ReqrepError.HandlerFailure:
x = new AdrException(-32603, "The remote RPC System had a problem");
break;
case ReqrepManager.ReqrepError.Timeout:
//In this case we close the Channel:
if( bq != null ) { bq.Close(); }
break;
case ReqrepManager.ReqrepError.Send:
if( rs.RpcTarget is Edge ) {
Edge e = (Edge)rs.RpcTarget;
//This definitely won't get any more responses:
if( e.IsClosed && bq != null ) { bq.Close(); }
}
//We had some problem sending, but ignore it for now
break;
}
if( x != null && (bq != null) ) {
RpcResult res = new RpcResult(ret_path, x);
bq.Enqueue(res);
}
}
/**
* Implements the IReplyHandler (also provides some light-weight statistics)
*/
public bool HandleReply(ReqrepManager man, ReqrepManager.ReqrepType rt,
int mid, PType prot, MemBlock payload, ISender ret_path,
ReqrepManager.Statistics statistics, object state)
{
RpcRequestState rs = (RpcRequestState) state;
//ISender target = rs.RpcTarget;
Channel bq = rs.Results;
if( bq != null ) {
object data = AdrConverter.Deserialize(payload);
RpcResult res = new RpcResult(ret_path, data, statistics);
//handle possible exception:
try {
bq.Enqueue(res);
//Keep listening unless the queue is closed
return (!bq.Closed);
}
catch(System.InvalidOperationException) {
//The queue is closed, stop listening for more results:
return false;
}
}
else {
//If they didn't even pass us a queue, I guess they didn't want to
//listen too long
return false;
}
}
public RpcManager(ReqrepManager rrm) {
_sync = new Object();
_rrman = rrm;
_method_cache = new Cache(CACHE_SIZE);
_method_handlers = new Hashtable();
}
/**
* Static method to create ReqrepManager objects
* @param context the object that this manager works for
*/
public static ReqrepManager GetInstance(object context) {
lock(_inst_tab_sync) {
ReqrepManager inst;
if( !_instance_table.TryGetValue(context, out inst)) {
//This puts the item into _instance_table:
inst = new ReqrepManager(context);
}
return inst;
}
}
protected MockRpcManager(ReqrepManager rrm) : base(rrm) { }
public RpcManager(ReqrepManager rrm) {
_sync = new Object();
_rrman = rrm;
_method_cache = new Cache(CACHE_SIZE);
_method_handlers = new Hashtable();
#if DAVID_ASYNC_INVOKE
_rpc_command = new BlockingQueue();
_rpc_thread = new Thread(RpcCommandRun);
_rpc_thread.IsBackground = true;
_rpc_thread.Start();
#endif
}