/**
* @param e Edge to close
* @param cm message to send to other node
* This method is used if we want to use a particular CloseMessage
* If not, we can use the method with the same name with one fewer
* parameters
*/
public void GracefullyClose(Edge e, string message)
{
/**
* Close any connection on this edge, and
* put the edge into the list of unconnected edges
*/
_connection_table.Disconnect(e);
ListDictionary close_info = new ListDictionary();
string reason = message;
if (reason != String.Empty)
{
close_info["reason"] = reason;
}
ProtocolLog.WriteIf(ProtocolLog.EdgeClose, String.Format(
"GracefulCLose - " + e + ": " + reason));
var results = new BCon.Channel(1);
EventHandler close_eh = delegate(object o, EventArgs args) {
e.Close();
};
results.CloseEvent += close_eh;
try {
_rpc.Invoke(e, results, "sys:link.Close", close_info);
}
catch { Close(e); }
}
static void TraceRoute(IList nodes)
{
Random my_r = new Random();
int idx0 = my_r.Next(0, nodes.Count);
int idx1 = my_r.Next(0, nodes.Count);
Node n0 = (Node)nodes[idx0];
Node n1 = (Node)nodes[idx1];
RpcManager pinger = n0.Rpc;
Channel results = new Channel();
Console.WriteLine("Traceroute: {0} -> {1}", n0.Address, n1.Address);
results.EnqueueEvent += delegate(object q, EventArgs a) {
object result = results.Dequeue();
RpcResult r = (RpcResult)result;
IList data = (IList)r.Result;
int hop = 0;
foreach (IDictionary d in data)
{
Console.WriteLine("Hop: {0} :: {1}\n :: {2}", hop, d["node"], d["next_con"]);
hop++;
}
};
try {
pinger.Invoke(n0, results, "trace.GetRouteTo", n1.Address.ToString());
}
catch (Exception x) {
Console.WriteLine("Exception: {0}", x);
}
}
/**
* Compute candidate scores for a shortcut connection.
* @param start address computed by the SCO.
* @param range nunber of candidate nodes.
* @param cb callback function when candidate scores are available.
* @param current current selection of the optimal in the provided range.
*/
public override void ComputeCandidates(Address start, int range, TargetSelectorDelegate cb, Address current)
{
Channel q = null;
RequestState rs = null;
lock (_sync) {
#if VTS_DEBUG
Console.Error.WriteLine("VTS local: {0}, start: {1}, range: {2}, count: {3}", _node.Address, start, range, _num_requests);
#endif
if (_num_requests == MAX_REQUESTS)
{
return; //do nothing and return;
}
_num_requests++;
q = new Channel();
rs = new RequestState(start, range, cb, current);
_channel_to_state[q] = rs;
}
//create a new request state
ISender s = new ForwardingSender(_node,
start,
AHHeader.Options.Greedy,
new DirectionalAddress(DirectionalAddress.Direction.Left),
(short)range,
AHHeader.Options.Path
);
q.EnqueueEvent += new EventHandler(EnqueueHandler);
q.CloseEvent += new EventHandler(CloseHandler);
RpcManager rpc = _node.Rpc;
rpc.Invoke(s, q, "ncserver.EchoVivaldiState", new object[] {});
}
public override void Start()
{
//Make sure the Node is listening to this node
try {
//This will throw an exception if _e is already closed:
_e.CloseEvent += this.CloseHandler;
//_e must not be closed, let's start listening to it:
_e.Subscribe(_node, _e);
/* Make the call */
Channel results = new Channel();
results.CloseAfterEnqueue();
results.CloseEvent += this.LinkCloseHandler;
RpcManager rpc = _node.Rpc;
if (ProtocolLog.LinkDebug.Enabled)
{
ProtocolLog.Write(ProtocolLog.LinkDebug,
String.Format("LPS target: {0} Invoking Start() over edge: {1}", _linker.Target, _e));
}
rpc.Invoke(_e, results, "sys:link.Start", MakeLM().ToDictionary());
}
catch (Exception e) {
//The Edge must have closed, move on to the next TA
if (ProtocolLog.LinkDebug.Enabled)
{
ProtocolLog.Write(ProtocolLog.LinkDebug,
String.Format("LPS target: {0} Start() over edge: {1}, hit exception: {2}",
_linker.Target, _e, e));
}
Finish(Result.MoveToNextTA);
}
}
override public void Start()
{
ProtocolLog.WriteIf(ProtocolLog.LinkDebug,
String.Format("{0}: Starting Connector: {1}, {2}",
_local_node.Address, _sender, State));
AbortCheck ac = _abort.Value;
if (ac != null)
{
if (ac(this))
{
//We are no longer needed:
QueueCloseHandler(null, null);
return;
}
}
RpcManager rpc = _local_node.Rpc;
Channel results = new Channel();
results.EnqueueEvent += this.EnqueueHandler;
results.CloseEvent += this.QueueCloseHandler;
try {
rpc.Invoke(_sender, results, "sys:ctm.ConnectTo", _ctm.ToDictionary());
}
catch {
//Looks like the _sender had some problem:
QueueCloseHandler(null, null);
}
}
protected void FriendPing(string address)
{
Address addr = AddressParser.Parse(address);
Channel q = new Channel();
q.CloseAfterEnqueue();
q.CloseEvent += delegate(object obj, EventArgs eargs) {
try {
RpcResult res = (RpcResult)q.Dequeue();
string result = (string)res.Result;
string[] parts = result.Split(DELIM);
string dht_key = parts[0];
string response = parts[1];
if (response == "online")
{
SocialUser friend = _friends[dht_key];
friend.Time = DateTime.Now.ToString();
}
ProtocolLog.Write(SocialLog.SVPNLog, "PING FRIEND REPLY: " +
result);
} catch (Exception e) {
ProtocolLog.Write(SocialLog.SVPNLog, e.Message);
ProtocolLog.Write(SocialLog.SVPNLog, "PING FRIEND FAILURE: " +
address);
}
};
ISender sender = new AHExactSender(_node, addr);
_rpc.Invoke(sender, q, "SocialVPN.FriendPing", _local_user.DhtKey);
}
static void Ping(IList nodes)
{
Random my_r = new Random();
int idx0 = my_r.Next(0, nodes.Count);
int idx1 = my_r.Next(0, nodes.Count);
Node n0 = (Node)nodes[idx0];
Node n1 = (Node)nodes[idx1];
RpcManager pinger = n0.Rpc;
Channel results = new Channel();
results.EnqueueEvent += delegate(object q, EventArgs a) {
object result = results.Dequeue();
RpcResult r = (RpcResult)result;
try {
IDictionary data = (IDictionary)r.Result;
Console.WriteLine("target: {0}, rtt: {1}", data["target"], data["musec"]);
}
catch (Exception x) {
Console.WriteLine("target: {0}, Exception: {1}", n1.Address, x);
}
};
Console.WriteLine("Pinging: {0} -> {1}", n0.Address, n1.Address);
try {
pinger.Invoke(n0, results, "trace.GetRttTo", n1.Address.ToString());
}
catch (Exception x) {
Console.WriteLine("Exception: {0}", x);
}
}
public void Test()
{
Channel q = new Channel(1);
rpc.Invoke(null, q, "test.test");
RpcResult res = (RpcResult)q.Dequeue();
bool val = (bool)res.Result;
Assert.IsTrue(val, "Reflection Test");
}
private object[] Proxy(ISender sender, int maxResultsToWait, string method, object[] args)
{
BlockingQueue q = new BlockingQueue(maxResultsToWait);
args = AdrXmlRpcConverter.XmlRpc2AdrParams(args);
_rpc.Invoke(sender, q, method, args);
ArrayList allValues = new ArrayList();
int counter = 0;
ISender rsSender = null;
try {
do
{
rsSender = null; //Reset it before the following:
RpcResult rpcRs = (RpcResult)q.Dequeue();
rsSender = rpcRs.ResultSender; //get it before exception thrown
object val = rpcRs.Result;
Debug.WriteLine(string.Format("Original Result: {0}", val));
object xmlrpc_val = AdrXmlRpcConverter.Adr2XmlRpc(val); //conversion in here
counter++;
allValues.Add(xmlrpc_val);
} while (maxResultsToWait < 0 ? true : (counter < maxResultsToWait));
} catch (Exception e) {
Debug.WriteLine(e);
string s = string.Empty;
if (e is AdrException)
{
if (rsSender != null)
{
s = AdrXmlRpcConverter.Adr2XmlRpc(rsSender) as string;
}
}
if (e is InvalidOperationException)
{
/*
* this is what we expect at the end of Dequeuing, so just return what we've gotten so far
* it could be an empty array
*/
return(allValues.ToArray());
}
Exception new_e = AdrXmlRpcConverter.Adr2XmlRpc(e) as Exception;
throw new Exception(new_e.Message +
(s.Equals(string.Empty) ? string.Empty : string.Format("thrown by: {0}", s)));
} finally {
if (!q.Closed)
{
q.Close();
}
}
return(allValues.ToArray());
}
/// <summary>Seek TAs.</summary>
protected override void SeekTAs(DateTime now)
{
Channel queue = new Channel();
queue.EnqueueEvent += HandleSeekTAs;
try {
ISender mcs = _iphandler.CreateMulticastSender();
_rpc.Invoke(mcs, queue, RPC_CLASS + ".SeekTAs", _realm);
} catch (SendException) {
/*
* On planetlab, it is not uncommon to have a node that does not allow
* Multicast, and it will throw an exception here. We just ignore this
* information for now. If we don't the heartbeatevent in the node
* will not execute properly.
*/
}
}
private async void Start()
{
while (listener.IsListening)
{
try
{
HttpListenerContext context = await listener.GetContextAsync();
var requestContent = new StreamReader(context.Request.InputStream).ReadToEnd();
Result <object, RpcError> result;
MethodCallContext? call = null;
try
{
call = MethodCallContext.FromJson(requestContent);
if (call.JsonRpcVersion != RpcManager.JsonRpcVersion)
{
result = new Result <object, RpcError>(
new InvalidRequest($"Incompatible RPC versions call {call.JsonRpcVersion} vs current {RpcManager.JsonRpcVersion}"));
}
else
{
result = RpcManager.Invoke(call.MethodName, call.Params.ToArray());
}
}
catch (Exception e)
{
result = new Result <object, RpcError>((ParseError)e);
}
var response = RpcResponse.ToJson(RpcManager.JsonRpcVersion, result, call == null ? 0 : call.Id);
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(response);
context.Response.ContentLength64 = buffer.Length;
context.Response.OutputStream.Write(buffer, 0, buffer.Length);
context.Response.OutputStream.Close(); // Must close output stream
}
catch (ObjectDisposedException)
{
return;
}
}
}
/**
* Used to request other nodes existence
*/
protected void Announce()
{
Channel queue = new Channel();
queue.EnqueueEvent += HandleGetInformation;
try {
ISender mcs = _node.IPHandler.CreateMulticastSender();
_rpc.Invoke(mcs, queue, "LocalCO.GetInformation");
}
catch (SendException) {
/*
* On planetlab, it is not uncommon to have a node that
* does not allow Multicast, and it will throw an exception
* here. We just ignore this information for now. If we don't
* the heartbeatevent in the node will not execute properly.
*/
}
}
protected void SendRpcMessage(Address addr, string method,
string query, bool secure)
{
DateTime sent = DateTime.Now;
#if !SVPN_NUNIT
string meth_call = RPCID + "." + method;
Channel q = new Channel();
q.CloseAfterEnqueue();
q.CloseEvent += delegate(object obj, EventArgs eargs) {
try {
RpcResult res = (RpcResult)q.Dequeue();
string result = (string)res.Result;
if (method == "Ping")
{
DateTime recv = DateTime.Now;
_times = _times.InsertIntoNew(result, recv);
TimeSpan rtt = recv - sent;
_ssm.UpdateLatency(result, rtt.TotalMilliseconds);
}
ProtocolLog.WriteIf(SocialLog.SVPNLog,
String.Format("RPC {0} {1} {2}", addr.ToString(), method,
query));
} catch (Exception e) {
ProtocolLog.WriteIf(SocialLog.SVPNLog, e.ToString());
}
};
ISender sender;
if (!secure)
{
sender = new AHExactSender(_node.Node, addr);
}
else
{
sender = _node.Bso.GetSecureSender(addr);
}
_rpc.Invoke(sender, q, meth_call, _node.Address, query);
#endif
}
/*** Gracefully close this connection, if it is not already disconnected.
* Idempotent (calling it twice is the same as once).
* @return the old state, new state pair.
*/
public Pair <ConnectionState, ConnectionState> Close(RpcManager rpc, string reason)
{
var old_new = Abort();
if (old_new.First.Disconnected != true)
{
//Now try to tell the other node:
var close_info = new ListDictionary();
if (reason != String.Empty)
{
close_info["reason"] = reason;
}
Edge e = old_new.Second.Edge;
var results = new Channel(1);
//Either the RPC call times out, or we get a response.
results.CloseEvent += delegate(object o, EventArgs args) {
e.Close();
};
try { rpc.Invoke(e, results, "sys:link.Close", close_info); }
catch { e.Close(); }
}
return(old_new);
}
/**
* When we get a response to the sys:link method, this handled
* is called
*/
protected void LinkCloseHandler(object q, EventArgs args)
{
try {
Channel resq = (Channel)q;
//If the Channel is empty this will throw an exception:
RpcResult res = (RpcResult)resq.Dequeue();
/* Here's the LinkMessage response */
LinkMessage lm = new LinkMessage((IDictionary)res.Result);
/**
* This will set our LinkMessageReply variable. It can
* only be set once, so all future sets will fail. It
* will also make sure we have the lock on the target.
* If we don't, that will throw an exception
*/
SetAndCheckLinkReply(lm);
//If we got here, we have our response and the Lock on _target_address
StatusMessage sm = _node.GetStatus(_contype, lm.Local.Address);
/* Make the call */
Channel results = new Channel();
results.CloseAfterEnqueue();
results.CloseEvent += this.StatusCloseHandler;
RpcManager rpc = _node.Rpc;
if (ProtocolLog.LinkDebug.Enabled)
{
ProtocolLog.Write(ProtocolLog.LinkDebug,
String.Format(
"LPS target: {0} Invoking GetStatus() over edge: {1}",
_linker.Target, _e));
}
/*
* This could throw an exception if the Edge is closed
*/
rpc.Invoke(_e, results, "sys:link.GetStatus", sm.ToDictionary());
}
catch (AdrException x) {
/*
* This happens when the RPC call has some kind of issue,
* first we check for common error conditions:
*/
_x.Value = x;
Finish(GetResultForErrorCode(x.Code));
}
catch (ConnectionExistsException x) {
/* We already have a connection */
_x.Value = x;
Finish(Result.ProtocolError);
}
catch (CTLockException x) {
//This is thrown when ConnectionTable cannot lock. Lets try again:
_x.Value = x;
Finish(Result.RetryThisTA);
}
catch (LinkException x) {
_x.Value = x;
if (x.IsCritical)
{
Finish(Result.MoveToNextTA);
}
else
{
Finish(Result.RetryThisTA);
}
}
catch (InvalidOperationException) {
//The queue never got anything
Finish(Result.MoveToNextTA);
}
catch (EdgeException) {
//The Edge is goofy, let's move on:
Finish(Result.MoveToNextTA);
}
catch (Exception x) {
//The protocol was not followed correctly by the other node, fail
_x.Value = x;
Finish(Result.RetryThisTA);
}
}
/**
* This starts a linking operation on the given edge
*/
public IDictionary Start(IDictionary link_message, ISender edge)
{
if (ProtocolLog.LinkDebug.Enabled)
{
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format(
"{0} -start- sys:link.Start", _node.Address));
}
Edge from = GetEdge(edge);
LinkMessage lm = new LinkMessage(link_message);
if (ProtocolLog.LinkDebug.Enabled)
{
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format(
"{0} -args- sys:link.Start({1},{2})", _node.Address, lm, from));
}
CphState cph = new CphState(from, lm);
lock ( _sync ) {
if (!_edge_to_cphstate.ContainsKey(from))
{
_edge_to_cphstate[from] = cph;
}
else
{
throw new AdrException((int)ErrorMessage.ErrorCode.InProgress,
"Already have a link in progress on this edge");
}
}
ErrorMessage err = null;
if (CanConnect(cph, out err))
{
try {
//If the CloseEvent was already called, this throws an exception
from.CloseEvent += this.CloseHandler;
}
catch {
CloseHandler(from, null);
throw new AdrException((int)ErrorMessage.ErrorCode.EdgeClosed,
"Edge Closed after receiving message");
}
}
else
{
lock ( _sync ) {
_edge_to_cphstate.Remove(from);
}
}
//Now we prepare our response
LinkMessage lm_resp = null;
if (err == null)
{
//We send a response:
NodeInfo n_info = NodeInfo.CreateInstance(_node.Address, from.LocalTA);
NodeInfo remote_info = NodeInfo.CreateInstance(null, from.RemoteTA);
System.Collections.Specialized.StringDictionary attrs =
new System.Collections.Specialized.StringDictionary();
attrs["type"] = String.Intern(lm.ConTypeString);
attrs["realm"] = String.Intern(_node.Realm);
lm_resp = new LinkMessage(attrs, n_info, remote_info, lm.Token);
}
else
{
if (err.Ec == ErrorMessage.ErrorCode.AlreadyConnected)
{
/**
* When we send the ErrorCode.AlreadyConnected,
* we could have a stale connection, lets try pinging
* the other node, if they are there, but have lost
* the Edge, this may trigger the edge to close, causing
* us to remove the Connection.
* @todo consider putting this address on a "fast track"
* to removal if we don't hear from it soon
*/
ConnectionTable tab = _node.ConnectionTable;
Connection c = tab.GetConnection(lm.ConnectionType,
lm.Local.Address);
if (c != null)
{
RpcManager rpc = _node.Rpc;
rpc.Invoke(c.Edge, null, "sys:link.Ping", String.Empty);
}
}
}
if (err != null)
{
throw new AdrException((int)err.Ec, err.Message);
}
if (ProtocolLog.LinkDebug.Enabled)
{
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format(
"{0} -end- sys:link.Start()->{1}", _node.Address, lm_resp));
}
return(lm_resp.ToDictionary());
}
protected void GenTreeHandler(object chano, EventArgs args)
{
if (LogEnabled)
{
ProtocolLog.Write(ProtocolLog.MapReduce,
String.Format("MapReduce: {0}, GenTreeHandler", _node.Address));
}
Channel gtchan = (Channel)chano;
MapReduceInfo[] children;
object gtchan_result = null;
try {
gtchan_result = gtchan.Dequeue();
children = (MapReduceInfo[])gtchan_result;
}
catch (Exception x) {
//We could fail to return (queue is empty), or get a bad result
Exception rx = gtchan_result as Exception;
if (rx != null)
{
x = rx; //x should have been a bad cast
}
if (LogEnabled)
{
ProtocolLog.Write(ProtocolLog.MapReduce,
String.Format("MapReduce: {0}, GenTreeHandler exception ({1})", _node.Address, x));
}
HandleException(null, x);
return;
}
//The usual transactional bit:
State state = _state;
State old_state;
State new_state;
do
{
old_state = state;
new_state = old_state.UpdateTree(children);
state = Interlocked.CompareExchange <State>(ref _state, new_state, old_state);
}while(state != old_state);
if (new_state.Done)
{
//We don't need to start calling our children
if (LogEnabled)
{
ProtocolLog.Write(ProtocolLog.MapReduce,
String.Format("MapReduce: {0}, done on GenTreeHandler", _node.Address));
}
SendResult(new_state.ReduceResult);
return;
}
//Now we need to start calling our children:
foreach (MapReduceInfo mri in children)
{
Channel child_q = new Channel(1, mri);
child_q.CloseEvent += this.ChildCallback;
try {
if (LogEnabled)
{
ProtocolLog.Write(ProtocolLog.MapReduce,
String.Format("MapReduce: {0}, calling child ({1})", _node.Address, mri.Sender.ToUri()));
}
_rpc.Invoke(mri.Sender, child_q, "mapreduce.Start", mri.Args.ToHashtable());
}
catch (Exception x) {
if (LogEnabled)
{
ProtocolLog.Write(ProtocolLog.MapReduce,
String.Format("MapReduce: {0}, child ({1}) call threw: {2}.", _node.Address, mri.Sender.ToUri(), x));
}
HandleException(mri.Sender, x);
}
}
}
public void BenchmarkFragPing(int fsize, int reps) {
List<int> mu_sec_pings = new List<int>();
Random my_r = new Random();
ArrayList nodes = null;
lock(_sync) {
//Make a copy
nodes = new ArrayList(_node_list);
}
Stack<Action> pings = new Stack<Action>();
for(int i = 0; i < reps; i++) {
int idx0 = my_r.Next(0, nodes.Count);
int idx1 = my_r.Next(0, nodes.Count);
Node n0 = (Node)nodes[idx0];
Node n1 = (Node)nodes[idx1];
Action ping = delegate() {
RpcManager pinger = n0.Rpc;
Channel results = new Channel(1, new WriteOnce<DateTime>());
results.CloseEvent += delegate(object q, EventArgs a) {
try {
results.Dequeue();
TimeSpan rttts = DateTime.UtcNow - ((WriteOnce<DateTime>)results.State).Value;
mu_sec_pings.Add((int)(1000 * rttts.TotalMilliseconds));
}
catch(Exception x) {
Console.WriteLine("target: {0}, Exception: {1}", n1.Address, x);
}
if( pings.Count > 0 ) {
var next = pings.Pop();
next();
}
else {
double ave_rtt = 0;
foreach(int s in mu_sec_pings) {
ave_rtt += (double)s;
}
ave_rtt /= mu_sec_pings.Count;
double var = 0;
foreach(int s in mu_sec_pings) {
var += (ave_rtt - (double)s) * (ave_rtt - (double)s);
}
var /= mu_sec_pings.Count;
var stdev = Math.Sqrt(var);
mu_sec_pings.Sort();
var median = mu_sec_pings[ mu_sec_pings.Count / 2];
Console.WriteLine("Average: {0} Median: {1} Stdev: {2} Samples: {3} Reps: {4}",
ave_rtt, median, stdev, mu_sec_pings.Count, reps);
}
};
try {
var sender = new FragmentingSender(1400, new AHExactSender(n0, n1.Address));
var data = new byte[fsize];
my_r.NextBytes(data);
((WriteOnce<DateTime>)results.State).Value = DateTime.UtcNow;
pinger.Invoke(sender, results, "sys:link.Ping", data);
}
catch(Exception x) {
Console.WriteLine("Exception: {0}", x);
if( pings.Count > 0 ) {
var next = pings.Pop();
next();
}
else {
double ave_rtt = 0;
foreach(int s in mu_sec_pings) {
ave_rtt += (double)s;
}
ave_rtt /= mu_sec_pings.Count;
double var = 0;
foreach(int s in mu_sec_pings) {
var += (ave_rtt - (double)s) * (ave_rtt - (double)s);
}
var /= mu_sec_pings.Count;
var stdev = Math.Sqrt(var);
mu_sec_pings.Sort();
var median = mu_sec_pings[ mu_sec_pings.Count / 2];
Console.WriteLine("Average: {0} Median: {1} Stdev: {2} Samples: {3} Reps: {4}",
ave_rtt, median, stdev, mu_sec_pings.Count, reps);
}
}
};
pings.Push(ping);
}
//Now pop off the first one and go:
var first = pings.Pop();
first();
}
public static void Main(string [] args)
{
if (args.Length < 1)
{
Console.WriteLine("please specify the number edge protocol.");
Environment.Exit(0);
}
if (args.Length < 2)
{
Console.WriteLine("please specify the number of p2p nodes.");
Environment.Exit(0);
}
if (args.Length < 3)
{
Console.WriteLine("please specify the number of missing edges.");
Environment.Exit(0);
}
string proto = "function";
try {
proto = args[0].Trim();
} catch (Exception) {}
bool tunnel = false;
int base_port = 54000;
int network_size = Int32.Parse(args[1]);
int missing_count = Int32.Parse(args[2]);
try {
tunnel = args[3].Trim().Equals("tunnel");
} catch (Exception) {}
Console.WriteLine("use tunnel edges: {0}", tunnel);
Random rand = new Random();
ArrayList missing_edges = new ArrayList();
for (int i = 0; i < missing_count; i++)
{
int idx = -1;
int left, right;
do
{
idx = rand.Next(0, network_size);
left = (idx + 1) % network_size;
if (idx == 0)
{
right = network_size - 1;
}
else
{
right = idx - 1;
}
} while (missing_edges.Contains(idx));// ||
//missing_edges.Contains(left) ||
//missing_edges.Contains(right));
Console.WriteLine("Will drop a left edge on idx {0}: ", idx);
missing_edges.Add(idx);
}
//
// Sort missing edges.
//
missing_edges.Sort();
SortedList dist = new SortedList();
//
// Compute the average distance between missing edges.
//
if (missing_count > 1)
{
for (int i = 0; i < missing_count; i++)
{
int idx = (int)missing_edges[i];
int idx_next;
int d;
if (i == missing_count - 1)
{
idx_next = (int)missing_edges[0];
d = (network_size - 1) - idx + idx_next;
}
else
{
idx_next = (int)missing_edges[i + 1];
d = idx_next - idx - 1;
}
if (!dist.Contains(d))
{
dist[d] = 0;
}
else
{
int c = (int)dist[d];
dist[d] = c + 1;
}
}
}
double sum = 0.0;
int num = 0;
Console.WriteLine("distribution of missing edges separation");
foreach (DictionaryEntry de in dist)
{
int k = (int)de.Key;
int c = (int)de.Value;
Console.WriteLine("{0} {1}", k, c);
sum = sum + k * c;
num = num + c;
}
Console.WriteLine("average separation: {0}", (double)sum / num);
string brunet_namespace = "testing";
Console.WriteLine("Initializing...");
var RemoteTA = new List <TransportAddress>();
for (int i = 0; i < network_size; i++)
{
if (proto.Equals("udp"))
{
RemoteTA.Add(TransportAddressFactory.CreateInstance("brunet.udp://localhost:" + (base_port + i)));
}
else if (proto.Equals("function"))
{
RemoteTA.Add(TransportAddressFactory.CreateInstance("brunet.function://localhost:" + (base_port + i)));
}
}
for (int i = 0; i < network_size; i++)
{
AHAddress address = new AHAddress(new RNGCryptoServiceProvider());
Node node = new StructuredNode(address, brunet_namespace);
_sorted_node_list.Add((Address)address, node);
_node_list.Add(node);
RouteTestHandler test_handler = new RouteTestHandler();
node.GetTypeSource(new PType(routing_test)).Subscribe(test_handler, address.ToMemBlock());
RpcManager rpc_man = node.Rpc;
rpc_man.AddHandler("rpc_routing_test", new RpcRoutingTestHandler(node));
}
for (int i = 0; i < network_size; i++)
{
Node node = (Node)_sorted_node_list.GetByIndex(i);
Console.WriteLine("Configuring node: {0} ", node.Address);
TAAuthorizer ta_auth = null;
if (missing_edges.Contains(i))
{
int remote_port;
if (i == network_size - 1)
{
remote_port = base_port;
}
else
{
remote_port = base_port + i + 1;
}
PortTAAuthorizer port_auth = new PortTAAuthorizer(remote_port);
Console.WriteLine("Adding a port TA authorizer at: {0} for remote port: {1}", base_port + i, remote_port);
ArrayList arr_tas = new ArrayList();
arr_tas.Add(port_auth);
arr_tas.Add(new ConstantAuthorizer(TAAuthorizer.Decision.Allow));
ta_auth = new SeriesTAAuthorizer(arr_tas);
}
if (proto.Equals("udp"))
{
node.AddEdgeListener(new UdpEdgeListener(base_port + i, null, ta_auth));
}
else if (proto.Equals("function"))
{
node.AddEdgeListener(new FunctionEdgeListener(base_port + i, -1.00, ta_auth));
}
if (tunnel)
{
Console.WriteLine("Adding a tunnel edge listener");
node.AddEdgeListener(new Relay.RelayEdgeListener(node));
}
_node_to_port[node] = base_port + i;
node.RemoteTAs = RemoteTA;
}
//start nodes one by one.
for (int i = 0; i < network_size; i++)
{
Node node = (Node)_node_list[i];
Console.WriteLine("Starting node: {0}, {1}", i, node.Address);
node.Connect();
Console.WriteLine("Going to sleep for 2 seconds.");
System.Threading.Thread.Sleep(2000);
}
//wait for 300000 more seconds
Console.WriteLine("Going to sleep for 300000 seconds.");
System.Threading.Thread.Sleep(300000);
bool complete = CheckStatus();
int count = 0;
//
// Send a large number of packets as exact packets to random destinations
// and make sure exact routing is perfect.
//
for (int i = 0; i < network_size; i++)
{
for (int j = 0; j < network_size; j++)
{
int src_idx = i;
int dest_idx = j;
Node src_node = (Node)_sorted_node_list.GetByIndex(src_idx);
Node dest_node = (Node)_sorted_node_list.GetByIndex(dest_idx);
//Console.WriteLine("{0} -> {1}", src_idx, dest_idx);
Address dest_address = (Address)dest_node.Address;
ISender s = new AHExactSender(src_node, dest_address);
MemBlock p = dest_address.ToMemBlock();
s.Send(new CopyList(new PType(routing_test), p));
_sent++;
//System.Threading.Thread.Sleep(10);
s.Send(new CopyList(new PType(routing_test), p));
_sent++;
//System.Threading.Thread.Sleep(10);
}
}
//wait for 10 more seconds
Console.WriteLine("Going to sleep for 10 seconds.");
System.Threading.Thread.Sleep(10000);
Console.WriteLine("Final statistics");
lock (_class_lock) {
Console.WriteLine("Sent: {0}, Received: {1}, Wrongly routed: {2}",
_sent, _received, _wrongly_routed);
}
int missing_rpcs = 0;
int correct_rpcs = 0;
int incorrect_rpcs = 0;
Hashtable queue_to_address = new Hashtable();
for (int i = 0; i < network_size; i++)
{
for (int j = 0; j < network_size; j++)
{
int src_idx = i;
int dest_idx = j;
Node src_node = (Node)_sorted_node_list.GetByIndex(src_idx);
Node dest_node = (Node)_sorted_node_list.GetByIndex(dest_idx);
//Console.WriteLine("{0} -> {1}", src_idx, dest_idx);
Address dest_address = (Address)dest_node.Address;
ISender s = new AHExactSender(src_node, dest_address);
RpcManager rpc_man = src_node.Rpc;
Channel q = new Channel();
lock (_class_lock) {
queue_to_address[q] = dest_address;
}
q.CloseAfterEnqueue();
q.CloseEvent += delegate(object o, EventArgs cargs) {
lock (_class_lock) {
Channel qu = (Channel)o;
if (qu.Count == 0)
{
missing_rpcs++;
}
queue_to_address.Remove(qu);
}
};
q.EnqueueEvent += delegate(object o, EventArgs cargs) {
lock (_class_lock) {
Channel qu = (Channel)o;
RpcResult rpc_reply = (RpcResult)qu.Peek();
byte [] result = (byte[])rpc_reply.Result;
Address target = new AHAddress(result);
if (target.Equals(queue_to_address[qu]))
{
correct_rpcs++;
}
else
{
incorrect_rpcs++;
}
}
};
rpc_man.Invoke(s, q, "rpc_routing_test.GetIdentification", new object[] {});
}
}
//wait for 10 more seconds
while (true)
{
int c = -1;
lock (_class_lock) {
c = incorrect_rpcs + missing_rpcs + correct_rpcs;
}
if (c < network_size * network_size)
{
Console.WriteLine("Going to sleep for 10 seconds.");
System.Threading.Thread.Sleep(10000);
}
else
{
break;
}
}
Console.WriteLine("Final statistics");
Console.WriteLine("correct rpcs: {0}, incorrect rpcs: {1}, missing rpcs: {2}",
correct_rpcs, incorrect_rpcs, missing_rpcs);
System.Environment.Exit(1);
}
public void BenchmarkPing(int reps)
{
List <int> mu_sec_pings = new List <int>();
Random my_r = new Random();
ArrayList nodes = null;
lock (_sync) {
//Make a copy
nodes = new ArrayList(_node_list);
}
Stack <Action> pings = new Stack <Action>();
for (int i = 0; i < reps; i++)
{
int idx0 = my_r.Next(0, nodes.Count);
int idx1 = my_r.Next(0, nodes.Count);
Node n0 = (Node)nodes[idx0];
Node n1 = (Node)nodes[idx1];
Action ping = delegate() {
RpcManager pinger = n0.Rpc;
Channel results = new Channel(1);
results.CloseEvent += delegate(object q, EventArgs a) {
try {
object result = results.Dequeue();
RpcResult r = (RpcResult)result;
IDictionary data = (IDictionary)r.Result;
int rtt = (int)data["musec"];
//Console.WriteLine("target: {0}, rtt: {1}", data["target"], data["musec"]);
mu_sec_pings.Add(rtt);
}
catch (Exception x) {
Console.WriteLine("target: {0}, Exception: {1}", n1.Address, x);
}
if (pings.Count > 0)
{
var next = pings.Pop();
next();
}
else
{
double ave_rtt = 0;
foreach (int s in mu_sec_pings)
{
ave_rtt += (double)s;
}
ave_rtt /= mu_sec_pings.Count;
double var = 0;
foreach (int s in mu_sec_pings)
{
var += (ave_rtt - (double)s) * (ave_rtt - (double)s);
}
var /= mu_sec_pings.Count;
var stdev = Math.Sqrt(var);
mu_sec_pings.Sort();
var median = mu_sec_pings[mu_sec_pings.Count / 2];
Console.WriteLine("Average: {0} Median: {1} Stdev: {2} Samples: {3} Reps: {4}",
ave_rtt, median, stdev, mu_sec_pings.Count, reps);
}
};
try {
pinger.Invoke(n0, results, "trace.GetRttTo", n1.Address.ToString());
}
catch (Exception x) {
Console.WriteLine("Exception: {0}", x);
if (pings.Count > 0)
{
var next = pings.Pop();
next();
}
else
{
double ave_rtt = 0;
foreach (int s in mu_sec_pings)
{
ave_rtt += (double)s;
}
ave_rtt /= mu_sec_pings.Count;
double var = 0;
foreach (int s in mu_sec_pings)
{
var += (ave_rtt - (double)s) * (ave_rtt - (double)s);
}
var /= mu_sec_pings.Count;
var stdev = Math.Sqrt(var);
mu_sec_pings.Sort();
var median = mu_sec_pings[mu_sec_pings.Count / 2];
Console.WriteLine("Average: {0} Median: {1} Stdev: {2} Samples: {3} Reps: {4}",
ave_rtt, median, stdev, mu_sec_pings.Count, reps);
}
}
};
pings.Push(ping);
}
//Now pop off the first one and go:
var first = pings.Pop();
first();
}