public void HandleRpc(ISender caller, String method, IList arguments,
object request_state)
{
object result = new InvalidOperationException("Invalid method");
if (method.Equals("Enable") || method.Equals("Disable"))
{
if (arguments.Count < 2)
{
Rpc.SendResult(request_state, new Exception("Not enough arguments."));
return;
}
string option_type = arguments[0] as string;
string option_name = arguments[1] as string;
if (option_type == null || option_name == null)
{
Rpc.SendResult(request_state, new Exception("Expected a string."));
return;
}
if (option_type.Equals("BooleanSwitch"))
{
BooleanSwitch bs;
if (!TryGetBooleanSwitch(option_name, out bs))
{
Rpc.SendResult(request_state, new Exception("No such BooleanSwitch."));
return;
}
bs.Enabled = method.Equals("Enable");
result = true;
}
else if (option_type.Equals("Trace") && option_name.Equals("Console"))
{
if (method.Equals("Enable"))
{
Trace.Listeners.Add(Console);
}
else
{
Trace.Listeners.Remove(Console);
}
result = true;
}
else
{
result = new InvalidOperationException("Invalid method");
}
}
Rpc.SendResult(request_state, result);
}
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 void HandleRpc(ISender caller, string method, IList args, object rs)
{
object result = null;
if (method.Equals("SeekTAs"))
{
if (args.Count != 1)
{
throw new Exception("Not enough parameters");
}
else if (_realm.Equals(args[0]))
{
result = LocalTAsToString(20);
}
else
{
// We can't handle the request, let's send back an empty list
result = EMPTY_LIST;
}
}
else
{
throw new Exception("Invalid method");
}
_rpc.SendResult(rs, result);
}
public void HandleRpc(ISender caller, string meth, IList args, object state)
{
if (meth == "create")
{
Edge calling_edge = (Edge)((ReqrepManager.ReplyState)caller).ReturnPath;
string remote_path = (string)args[0];
string local_path = (string)args[1];
PathEdgeListener el = _pel_map[local_path];
if (el.IsStarted)
{
PathEdge npe = new PathEdge(this, calling_edge, local_path, remote_path);
lock ( _sync ) {
//We don't announce yet, wait till we get some data, which
//verifies that the other side has seen it.
_unannounced[calling_edge] = npe;
}
//So the new Edge has been announced.
Rpc.SendResult(state, true);
}
else
{
throw new Exception(
String.Format("PathEdgeListener({0}) not started", local_path));
}
}
else
{
throw new AdrException(-32601, "No Handler for method: " + meth);
}
}
/**
* Handles RPC calls.
* Note that AddXRHandler and RemoveXRHandler calls are only accepted when
* they are made by local Brunet node.
*/
public void HandleRpc(ISender caller, string method, IList args, object rs)
{
if (method.Equals("AddXRHandler") || method.Equals("RemoveXRHandler"))
{
ReqrepManager.ReplyState s = (ReqrepManager.ReplyState)caller;
ISender sender = s.ReturnPath;
if (Object.ReferenceEquals(_node, sender))
{
if (args.Count == 2)
{
if (method.Equals("AddXRHandler"))
{
this.AddXRHandler(args[0] as string, args[1] as string);
}
else
{
this.RemoveXRHandler(args[0] as string, args[1] as string);
}
_rpc.SendResult(rs, null);
return;
}
else
{
throw new ArgumentException("2 arguments expected");
}
}
else
{
throw new AdrException(-32602, "This operation is only accessible for local calls");
}
}
else
{
object result = null;
try {
Type type = this.GetType();
MethodInfo mi = type.GetMethod(method);
object[] arg_array = new object[args.Count];
args.CopyTo(arg_array, 0);
result = mi.Invoke(this, arg_array);
} catch (Exception e) {
result = new AdrException(-32602, e);
}
_rpc.SendResult(rs, result);
}
}
/**
* <summary>Implements IRpcHandler that is called by the RpcManager when an
* Rpc method requests any method with Information.*.</summary>
* <param name="caller">The remote caller</param>
* <param name="method">The name of the method called.</param>
* <param name="arguments">An IList of arguments supplied</param>
* <param name="request_state">Provides a return path back to the caller.
* </param>
*/
public void HandleRpc(ISender caller, String method, IList arguments,
object request_state)
{
object result = new InvalidOperationException("Invalid method");
if (method.Equals("Info"))
{
result = this.Info();
}
_rpc.SendResult(request_state, result);
}
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 void HandleRpc(ISender caller, string method, IList args,
object req_state)
{
object result = null;
try {
switch (method)
{
case "Ping":
result = HandlePing((string)args[0], (string)args[1]);
break;
case "AddCertRequest":
result = AddCertRequest((string)args[0], (string)args[1]);
break;
case "AddCertReply":
result = AddCertReply((string)args[0], (string)args[1]);
break;
case "SearchMapping":
result = _sdm.SearchMapping((string)args[0], (string)args[1],
this);
break;
case "AddTmpMapping":
result = _sdm.AddTmpMapping((string)args[0], (string)args[1]);
break;
case "GetStats":
result = _ssm.GetStats();
break;
case "GetNat":
result = _node.GetNatType();
break;
default:
result = new InvalidOperationException("Invalid Method");
break;
}
} catch (Exception e) {
result = e;
}
_rpc.SendResult(req_state, result);
}
/**
* Sends the result of the computation back.
* @return true if this is the first time this has been called
*/
protected bool SendResult(object result)
{
object old_res = Interlocked.CompareExchange(ref _result, result, State.DEFAULT_OBJ);
if (old_res == State.DEFAULT_OBJ)
{
if (LogEnabled)
{
ProtocolLog.Write(ProtocolLog.MapReduce,
String.Format("MapReduce: {0}, sending back result: {1}.", _node.Address, result));
}
_rpc.SendResult(_mr_request_state, result);
return(true);
}
else
{
return(false);
}
}
public void HandleRpc(ISender caller, string method, IList args, object rs)
{
object result = null;
try {
if (method.Equals("GetInformation"))
{
result = GetInformation();
}
else
{
throw new Exception("Invalid method");
}
}
catch (Exception e) {
result = new AdrException(-32602, e);
}
_rpc.SendResult(rs, result);
}
public void HandleRpc(ISender caller, string method, IList arguments,
object req_state)
{
object result = null;
try {
switch (method)
{
case "FriendPing":
result = FriendPingHandler((string)arguments[0]);
break;
default:
result = new InvalidOperationException("Invalid Method");
break;
}
} catch (Exception e) {
result = e;
ProtocolLog.Write(SocialLog.SVPNLog, e.Message);
ProtocolLog.Write(SocialLog.SVPNLog, "RPC HANDLER FAILURE: " +
method);
}
_rpc.SendResult(req_state, result);
}
/**
* This dispatches the particular methods this class provides.
* Currently, the only invokable method is:
* "Start".
*/
public void HandleRpc(ISender caller, string method, IList args, object req_state)
{
int part_idx = method.IndexOf(':');
if (part_idx == -1)
{
if (method == "Start")
{
IDictionary ht = (IDictionary)args[0];
MapReduceArgs mr_args = new MapReduceArgs(ht);
string task_name = mr_args.TaskName;
MapReduceTask task;
if (_name_to_task.TryGetValue(task_name, out task))
{
MapReduceComputation mr = new MapReduceComputation(_node, req_state, task, mr_args);
mr.Start();
}
else
{
throw new AdrException(-32608, "No mapreduce task with name: " + task_name);
}
}
else if (method == "AddHandler")
{
//Make sure this is local:
ISender tmp_call = caller;
bool islocal = tmp_call is Node;
while (!islocal && tmp_call is IWrappingSender)
{
tmp_call = ((IWrappingSender)tmp_call).WrappedSender;
islocal = tmp_call is Node;
}
if (!islocal)
{
throw new AdrException(-32601, "AddHandler only valid for local callers");
}
SubscribeTask(new RpcMapReduceTask(_node, (IDictionary)args[0]));
_rpc.SendResult(req_state, null);
}
else
{
throw new AdrException(-32601, "No Handler for method: " + method);
}
}
else
{
//This is a reference to a specific part of a task:
string part = method.Substring(0, part_idx);
string task_name = method.Substring(part_idx + 1);
MapReduceTask task;
if (false == _name_to_task.TryGetValue(task_name, out task))
{
throw new AdrException(-32608, "No mapreduce task with name: " + task_name);
}
if (part == "tree")
{
var mra = new MapReduceArgs((IDictionary)args[0]);
var tree_res = new Channel(1, req_state);
tree_res.CloseEvent += this.HandleTree;
task.GenerateTree(tree_res, mra);
}
else if (part == "reduce")
{
//Prepare the RpcResult:
var rres_d = (IDictionary)args[2];
ISender send = SenderFactory.CreateInstance(_node, (string)rres_d["sender"]);
var rres = new RpcResult(send, rres_d["result"]);
Channel reduce_res = new Channel(1, req_state);
reduce_res.CloseEvent += this.HandleReduce;
task.Reduce(reduce_res, args[0], args[1], rres);
}
else if (part == "map")
{
Channel map_res = new Channel(1, req_state);
map_res.CloseEvent += this.HandleMap;
task.Map(map_res, args[0]);
}
else
{
throw new AdrException(-32608,
String.Format("No mapreduce task({0}) part with name: {1}", task_name, part));
}
}
}
public void Start()
{
_rpc.SendResult(_rs, _result);
}
