public SimulationEdgeListener(int id, double loss_prob, TAAuthorizer ta_auth, bool use_delay) : this(id, loss_prob, ta_auth, use_delay, TransportAddress.TAType.S, new PublicNat(TransportAddressFactory.CreateInstance( String.Format("b.{0}://{1}", TransportAddress.TATypeToString(TransportAddress.TAType.S), id)))) { }
virtual public NodeInfo GetNodeInfo(int max_local, TAAuthorizer ta_auth) { ArrayList l = new ArrayList(this.LocalTAs); if (ta_auth != null) { ArrayList ta_authed = new ArrayList(); foreach (TransportAddress ta in l) { if (ta_auth.Authorize(ta) != TAAuthorizer.Decision.Deny) { ta_authed.Add(ta); } } l = ta_authed; } if (l.Count > max_local) { int rm_count = l.Count - max_local; l.RemoveRange(max_local, rm_count); } return(NodeInfo.CreateInstance(this.Address, l)); }
/// <summary>Return the SimulationEdgeListener.</summary> protected virtual EdgeListener CreateEdgeListener(int id) { TAAuthorizer auth = null; if (_broken != 0 && id > 0) { auth = new BrokenTAAuth(_broken); } return(new SimulationEdgeListener(id, _parameters.DropRate, auth, true)); }
protected void SetTAAuth() { // Setup a TAAuth for the given range so we don't try to form Edges over IPOP IPAddress ip = IPAddress.Parse(_dhcp_config.IPBase); int netmask = CalculateNetmaskCidr(_dhcp_config.Netmask); TAAuthorizer ip_auth = new NetmaskTAAuthorizer(ip, netmask, TAAuthorizer.Decision.Deny, TAAuthorizer.Decision.None); foreach (EdgeListener el in AppNode.Node.EdgeListenerList) { TAAuthorizer current_auth = el.TAAuth; TAAuthorizer[] series_auth = new TAAuthorizer[] { ip_auth, current_auth }; el.TAAuth = new SeriesTAAuthorizer(series_auth); } }
public SimulationEdgeListener(int id, double loss_prob, TAAuthorizer ta_auth, bool use_delay, TransportAddress.TAType type, INat nat) { _edges = new Dictionary <Edge, Edge>(); _use_delay = use_delay; LocalID = id; _ploss_prob = loss_prob; if (ta_auth == null) { _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow); } else { _ta_auth = ta_auth; } _ta_type = type; Nat = nat; _is_started = false; }
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); }
/** * @param port the local port to bind to * @param local_tas an IEnumerable object which gives the list of local * IPs. This is consulted every time LocalTAs is accessed, so it can * change as new interfaces are added * @param ta_auth the TAAuthorizer for packets incoming */ public UdpEdgeListener(int port, IEnumerable local_config_ips, TAAuthorizer ta_auth) { _s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); ipep = new IPEndPoint(IPAddress.Any, port); _s.Bind(ipep); _port = port = ((IPEndPoint) (_s.LocalEndPoint)).Port; /** * We get all the IPAddresses for this computer */ if( local_config_ips == null ) { _tas = TransportAddressFactory.CreateForLocalHost(TransportAddress.TAType.Udp, _port); } else { _tas = TransportAddressFactory.Create(TransportAddress.TAType.Udp, _port, local_config_ips); } _nat_hist = null; _nat_tas = new NatTAs( _tas, _nat_hist ); _ta_auth = ta_auth; if( _ta_auth == null ) { //Always authorize in this case: _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow); } //We start out expecting around 30 edges with //a load factor of 0.15 (to make edge lookup fast) _id_ht = new Hashtable(30, 0.15f); _remote_id_ht = new Hashtable(); _sync = new object(); _running = 0; _isstarted = 0; ///@todo, we need a system for using the cryographic RNG _rand = new Random(); _send_handler = this; _listen_finished_event = new ManualResetEvent(false); _listen_thread = new Thread( new ThreadStart(this.ListenThread) ); }
protected void SetTAAuth() { // Setup a TAAuth for the given range so we don't try to form Edges over IPOP IPAddress ip = IPAddress.Parse(_dhcp_config.IPBase); int netmask = CalculateNetmaskCidr(_dhcp_config.Netmask); TAAuthorizer ip_auth = new NetmaskTAAuthorizer(ip, netmask, TAAuthorizer.Decision.Deny, TAAuthorizer.Decision.None); foreach(EdgeListener el in AppNode.Node.EdgeListenerList) { TAAuthorizer current_auth = el.TAAuth; TAAuthorizer[] series_auth = new TAAuthorizer[] {ip_auth, current_auth}; el.TAAuth = new SeriesTAAuthorizer(series_auth); } }
virtual public NodeInfo GetNodeInfo(int max_local, TAAuthorizer ta_auth) { var l = new List<TransportAddress>(LocalTAs); if(ta_auth != null) { var ta_authed = new List<TransportAddress>(); foreach(TransportAddress ta in l) { if(ta_auth.Authorize(ta) != TAAuthorizer.Decision.Deny) { ta_authed.Add(ta); } } l = ta_authed; } if( l.Count > max_local ) { int rm_count = l.Count - max_local; l.RemoveRange( max_local, rm_count ); } return NodeInfo.CreateInstance( this.Address, l); }
public FunctionEdgeListener(int id, double loss_prob, TAAuthorizer ta_auth) { _listener_id = id; _ploss_prob = loss_prob; if (ta_auth == null) { _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow); } else { _ta_auth = ta_auth; } _tas = new ArrayList(); _tas.Add(TransportAddressFactory.CreateInstance("brunet.function://localhost:" + _listener_id.ToString()) ); _queue = new BC.LFBlockingQueue<FQEntry>(); _queue_thread = new Thread(new ThreadStart(StartQueueProcessing)); }