// adds a node to the pool
protected static void add_node(bool output) {
AHAddress address = new AHAddress(new RNGCryptoServiceProvider());
Node node = new StructuredNode(address, brunet_namespace);
NodeMapping nm = new NodeMapping();
nm.Node = node;
nodes.Add((Address) address, nm);
nm.Port = TakenPorts.Count;
while(TakenPorts.Contains(nm.Port)) {
nm.Port = rand.Next(0, 65535);
}
TAAuthorizer auth = null;
if(broken != 0) {
auth = new BrokenTAAuth(broken);
}
EdgeListener el = new FunctionEdgeListener(nm.Port, 0, auth, true);
node.AddEdgeListener(el);
if(broken != 0) {
el = new TunnelEdgeListener(node);
node.AddEdgeListener(el);
}
ArrayList RemoteTAs = new ArrayList();
for(int i = 0; i < 5 && i < TakenPorts.Count; i++) {
int rport = (int) TakenPorts.GetByIndex(rand.Next(0, TakenPorts.Count));
RemoteTAs.Add(TransportAddressFactory.CreateInstance("brunet.function://127.0.0.1:" + rport));
}
node.RemoteTAs = RemoteTAs;
TakenPorts[nm.Port] = nm.Port;
if(output) {
Console.WriteLine("Adding: " + nm.Node.Address);
}
node.Connect();
network_size++;
}
/**
<summary>Creates a Brunet.Node, the resulting node will be available in
the class as _node.</summary>
<remarks>The steps to creating a node are first constructing it with a
namespace, optionally adding local ip addresses to bind to, specifying
local end points, specifying remote end points, and finally registering
the dht.</remarks>
*/
public virtual void CreateNode() {
AHAddress address = (AHAddress) AddressParser.Parse(_node_config.NodeAddress);
_node = new StructuredNode(address, _node_config.BrunetNamespace);
IEnumerable addresses = IPAddresses.GetIPAddresses(_node_config.DevicesToBind);
Brunet.EdgeListener el = null;
foreach(NodeConfig.EdgeListener item in _node_config.EdgeListeners) {
int port = item.port;
if (item.type =="tcp") {
try {
el = new TcpEdgeListener(port, addresses);
}
catch {
el = new TcpEdgeListener(0, addresses);
}
}
else if (item.type == "udp") {
try {
el = new UdpEdgeListener(port, addresses);
}
catch {
el = new UdpEdgeListener(0, addresses);
}
}
else {
throw new Exception("Unrecognized transport: " + item.type);
}
_node.AddEdgeListener(el);
}
el = new TunnelEdgeListener(_node);
_node.AddEdgeListener(el);
ArrayList RemoteTAs = null;
if(_node_config.RemoteTAs != null) {
RemoteTAs = new ArrayList();
foreach(String ta in _node_config.RemoteTAs) {
RemoteTAs.Add(TransportAddressFactory.CreateInstance(ta));
}
_node.RemoteTAs = RemoteTAs;
}
try {
if (_node_config.NCService.Enabled) {
_ncservice = new NCService(_node, _node_config.NCService.Checkpoint);
if (_node_config.NCService.OptimizeShortcuts) {
_node.Sco.TargetSelector = new VivaldiTargetSelector(_node, _ncservice);
}
}
} catch {}
_dht = new Dht(_node, 3, 20);
}
// adds a node to the pool
protected static void add_node(bool output) {
AHAddress address = new AHAddress(new RNGCryptoServiceProvider());
Node node = new StructuredNode(address, brunet_namespace);
NodeMapping nm = new NodeMapping();
nm.Node = node;
nodes.Add((Address) address, nm);
nm.Port = TakenPorts.Count;
while(TakenPorts.Contains(nm.Port)) {
nm.Port = rand.Next(0, 65535);
}
TAAuthorizer auth = null;
if(broken != 0) {
auth = new BrokenTAAuth(broken);
}
EdgeListener el = new SimulationEdgeListener(nm.Port, 0, auth, true);
if(secure_edges || secure_senders) {
byte[] blob = SEKey.ExportCspBlob(true);
RSACryptoServiceProvider rsa_copy = new RSACryptoServiceProvider();
rsa_copy.ImportCspBlob(blob);
CertificateMaker cm = new CertificateMaker("United States", "UFL",
"ACIS", "David Wolinsky", "*****@*****.**", rsa_copy,
address.ToString());
Certificate cert = cm.Sign(CACert, SEKey);
CertificateHandler ch = new CertificateHandler();
ch.AddCACertificate(CACert.X509);
ch.AddSignedCertificate(cert.X509);
BrunetSecurityOverlord so = new BrunetSecurityOverlord(node, rsa_copy, node.Rrm, ch);
so.Subscribe(node, null);
node.GetTypeSource(SecurityOverlord.Security).Subscribe(so, null);
nm.BSO = so;
node.HeartBeatEvent += so.Heartbeat;
}
if(secure_edges) {
el = new SecureEdgeListener(el, nm.BSO);
}
node.AddEdgeListener(el);
if(broken != 0) {
el = new TunnelEdgeListener(node);
node.AddEdgeListener(el);
}
ArrayList RemoteTAs = new ArrayList();
for(int i = 0; i < 5 && i < TakenPorts.Count; i++) {
int rport = (int) TakenPorts.GetByIndex(rand.Next(0, TakenPorts.Count));
RemoteTAs.Add(TransportAddressFactory.CreateInstance("brunet.function://127.0.0.1:" + rport));
}
node.RemoteTAs = RemoteTAs;
TakenPorts[nm.Port] = nm.Port;
if(output) {
Console.WriteLine("Adding: " + nm.Node.Address);
}
node.Connect();
network_size++;
}
/**
<summary>Creates a Brunet.Node, the resulting node will be available in
the class as _node.</summary>
<remarks>The steps to creating a node are first constructing it with a
namespace, optionally adding local ip addresses to bind to, specifying
local end points, specifying remote end points, and finally registering
the dht.</remarks>
*/
public virtual void CreateNode(string type) {
NodeConfig node_config = null;
StructuredNode current_node = null;
AHAddress address = null;
if (type == "cache") {
node_config = _c_node_config;
address = (AHAddress) AddressParser.Parse(node_config.NodeAddress);
current_node = new StructuredNode(address, node_config.BrunetNamespace);
}
else if ( type == "query" ) {
node_config = _q_node_config;
address = (AHAddress) AddressParser.Parse(node_config.NodeAddress);
current_node = new StructuredNode(address, node_config.BrunetNamespace);
}
else {
throw new Exception("Unrecognized node type: " + type);
}
IEnumerable addresses = IPAddresses.GetIPAddresses(node_config.DevicesToBind);
Brunet.EdgeListener el = null;
foreach(NodeConfig.EdgeListener item in node_config.EdgeListeners) {
int port = item.port;
if (item.type =="tcp") {
try {
el = new TcpEdgeListener(port, addresses);
}
catch {
el = new TcpEdgeListener(0, addresses);
}
}
else if (item.type == "udp") {
try {
el = new UdpEdgeListener(port, addresses);
}
catch {
el = new UdpEdgeListener(0, addresses);
}
}
else {
throw new Exception("Unrecognized transport: " + item.type);
}
current_node.AddEdgeListener(el);
}
el = new TunnelEdgeListener(current_node);
current_node.AddEdgeListener(el);
ArrayList RemoteTAs = null;
if(node_config.RemoteTAs != null) {
RemoteTAs = new ArrayList();
foreach(String ta in node_config.RemoteTAs) {
RemoteTAs.Add(TransportAddressFactory.CreateInstance(ta));
}
current_node.RemoteTAs = RemoteTAs;
}
try {
if (node_config.NCService.Enabled) {
if (type == "cache") {
_c_ncservice = new NCService(current_node, node_config.NCService.Checkpoint);
if (node_config.NCService.OptimizeShortcuts) {
current_node.Sco.TargetSelector = new VivaldiTargetSelector(current_node, _c_ncservice);
}
}
else {
_q_ncservice = new NCService(current_node, node_config.NCService.Checkpoint);
if (node_config.NCService.OptimizeShortcuts) {
current_node.Sco.TargetSelector = new VivaldiTargetSelector(current_node, _q_ncservice);
}
}
}
} catch {}
if (type == "cache") {
_c_dht = new Dht(current_node, 3, 20);
_cs = new CacheList(current_node);
current_node.MapReduce.SubscribeTask(new MapReduceCache(current_node,_cs));
current_node.MapReduce.SubscribeTask(new MapReduceCrawl(current_node));
_c_node = current_node;
}
else {
_q_dht = new Dht(current_node, 3, 20);
CacheList q_cs = new CacheList(current_node);
current_node.MapReduce.SubscribeTask(new MapReduceQuery(current_node,_cs));
current_node.MapReduce.SubscribeTask(new MapReduceCrawl(current_node));
_q_node = current_node;
}
}
/**
* Constructor for the tunnel edge.
* @param cb reference to the tunnel edge listener.
* @param is_in is the edge inbound.
* @param n local node.
* @param target address of the tunnel edge target node.
* @param forwarders current list of forwarders (addresses) for the tunnel edge.
* @param id local id.
* @param remoteid remote id.
*/
public TunnelEdge(TunnelEdgeListener cb, bool is_in, Node n,
Address target, ArrayList forwarders, int id, int remoteid)
: base(null, is_in)
{
_tel = cb;
_is_connected = false;
_node = n;
_target = target;
#if TUNNEL_DEBUG
Console.Error.WriteLine("Constructing: {0}", this);
#endif
//track forwarding addresses
_forwarders = new ArrayList();
_acquire_summary = new ArrayList();
_lost_summary = new ArrayList();
//track forwarding edges
_packet_senders = new ArrayList();
_id = id;
_remote_id = remoteid;
_last_sender_idx = 0;
//create a tunnel header.
_tun_header = GetTunnelHeader(ID, RemoteID, _node.Address, _target);
//This doesn't require us to hold the lock on the connection table
IEnumerable struct_cons = n.ConnectionTable.GetConnections(ConnectionType.Structured);
foreach(Connection c in struct_cons) {
if( forwarders.Contains(c.Address) && (c.Edge.TAType != TAType)) {
//This is a connection we can use:
_forwarders.Add(c.Address);
_packet_senders.Add(c.Edge);
}
}
_localta = new TunnelTransportAddress(_node.Address, _forwarders);
_remoteta = new TunnelTransportAddress(target, _forwarders);
lock(_sync) {
_last_sync_dt = DateTime.UtcNow; //we just synchronized now.
_node.ConnectionTable.DisconnectionEvent += new EventHandler(DisconnectHandler);
_node.ConnectionTable.ConnectionEvent += new EventHandler(ConnectHandler);
_node.HeartBeatEvent += new EventHandler(SynchronizeEdge);
}
#if TUNNEL_DEBUG
Console.Error.WriteLine("Constructed: {0}", this);
#endif
}