/**
<summary>Creates an Information object for the node and type of service
provider.</summary>
<param name="node">The node where the service is to be provided</param>
<param name="type">The name of the application providing service (example:
BasicNode)</param>
*/
public Information(StructuredNode node, String type) {
UserData = new Hashtable();
_type = type;
_node = node;
_rpc = RpcManager.GetInstance(node);
_rpc.AddHandler("Information", this);
}
/// <summary>Initiates a RpcProxyHandler instance. It uses reflection for rpc call.
/// Thus, it does not have to inherit IRpcHanler.This instance keeps Entry
/// to keep track of key, value, and ttl</summary>
/// <param name="node">node which is currently connected.</param>
/// <param name="dht">IDht instance</param>
public RpcDhtProxy(IDht dht, Node node)
{
_entries = new Dictionary<MemBlock, Dictionary<MemBlock, Entry>>();
_rpc = node.Rpc;
_dht = dht;
_sync = new Object();
_rpc.AddHandler("RpcDhtProxy", this);
}
public SocialRpcHandler(StructuredNode node, SocialUser localUser,
Dictionary<string, SocialUser> friends)
{
_node = node;
_rpc = node.Rpc;
_rpc.AddHandler("SocialVPN", this);
_local_user = localUser;
_friends = friends;
}
public LocalConnectionOverlord(Node node) {
_sync = new Object();
_allow_localcons = false;
_active = false;
_local_addresses = new List<AHAddress>();
_node = node;
lock(_sync) {
_rpc = RpcManager.GetInstance(node);
_rpc.AddHandler("LocalCO", this);
_node.HeartBeatEvent += CheckConnection;
_node.StateChangeEvent += StateChangeHandler;
_node.ConnectionTable.ConnectionEvent += ConnectHandler;
_node.ConnectionTable.DisconnectionEvent += DisconnectHandler;
_last_announce_call = DateTime.MinValue;
_last_activate_call = DateTime.MinValue;
}
}
/**
* Installs the network coordinate service on a given node.
* NCService instance can be installed on atmost one node.
* Each node is allowed to have only one NCService instance.
* @param node node for installing the service instance.
* @param InitialPoint a starting place for the NCService to use
*/
public NCService(Node node, Point InitialPoint) {
_sync = new object();
_node = null;
_last_sample_instant = DateTime.MinValue;
_samples = new Hashtable();
_vivaldi_state = new VivaldiState();
_vivaldi_state.WeightedError = INITIAL_WEIGHTED_ERROR;
_vivaldi_state.Position = new Point();
_vivaldi_state.DistanceDelta = 0.0f;
if(InitialPoint == null) {
InitialPoint = new Point();
}
_vivaldi_state.Position = InitialPoint;
if(node != null) {
_node = node;
#if NC_DEBUG
Console.Error.WriteLine("[NCService] {0} Starting an instance of NCService.", node.Address);
#endif
lock(_sync) {
_rpc = _node.Rpc;
_rpc.AddHandler("ncserver", this);
_node.HeartBeatEvent += GetNextSample;
}
}
}
public MRpcMTestReflection()
{
rpc = new MockRpcManager();
rpc.AddHandler("test", this);
}
/**
* Constructor.
* @param node the p2p node.
* @param localUser the local user object.
* @param friends the list of friends.
*/
public SocialRpcHandler(StructuredNode node, SocialUser localUser,
Dictionary<string, SocialUser> friends,
BlockingQueue queue, SocialDnsManager sdm)
{
_node = node;
_rpc = node.Rpc;
_rpc.AddHandler("SocialVPN", this);
_local_user = localUser;
_friends = friends;
_queue = queue;
_sdm = sdm;
}
/// <summary>
/// Constructor for the class, it initializes various objects
/// </summary>
/// <param name="node">Takes in a structured node</param>
public RpcAddressResolverAndDNS(StructuredNode node, DHCPServer dhcp, MemBlock local_ip)
: base(MemBlock.Reference(dhcp.BaseIP), MemBlock.Reference(dhcp.Netmask))
{
_node = node;
_rpc = _node.Rpc;
_dns_a = new Hashtable();
_dns_ptr = new Hashtable();
_ip_addr = new Hashtable();
_addr_ip = new Hashtable();
_blocked_addrs = new Hashtable();
mcast_addr = new ArrayList();
_dhcp = dhcp;
_local_ip = local_ip;
_rpc.AddHandler("RpcIpopNode", this);
}
/**
<summary>Creates a new TableServer object and registers it to the "dht"
handler in the node's RpcManager.</summary>
<param name="node">The node the dht is to serve from.</param>
*/
public TableServer(Node node) {
_sync = new Object();
_transfer_sync = new Object();
_node = node;
_rpc = RpcManager.GetInstance(node);
_data = new TableServerData(_node);
lock(_transfer_sync) {
node.ConnectionTable.ConnectionEvent += this.ConnectionHandler;
node.ConnectionTable.DisconnectionEvent += this.ConnectionHandler;
_node.StateChangeEvent += StateChangeHandler;
}
_rpc.AddHandler("dht", this);
}
