public LocalHT() { AHAddress addr = new AHAddress(new RNGCryptoServiceProvider()); Node brunetNode = new StructuredNode(addr); RpcManager rpc = RpcManager.GetInstance(brunetNode); this._ts = new TableServer(brunetNode); this._node = brunetNode; #if FUSE_DEBUG //Having some init data isn't bad string key = FuseDhtUtil.GenDhtKey("testbasedir", "testkey1", "ipop_ns"); this.Put(key, "testvalue1", 5000); this.Put(key, "testvalue2", 3000); #endif }
public void Init() { Console.WriteLine("Initializing..."); ArrayList RemoteTA = new ArrayList(); for(int i = 0; i < network_size; i++) { RemoteTA.Add(TransportAddressFactory.CreateInstance("brunet.udp://127.0.0.1:" + (base_port + i))); } for(int i = 0; i < network_size; i++) { Address addr = (Address) new AHAddress(new RNGCryptoServiceProvider()); Node node = new StructuredNode((AHAddress) addr, brunet_namespace); nodes.Add(addr, node); node.AddEdgeListener(new UdpEdgeListener(base_port + i)); node.RemoteTAs = RemoteTA; tables[addr] = new TableServer(node); (new Thread(node.Connect)).Start(); // if(i < network_size / ((Dht)dhts.GetByIndex(i)).DEGREE) { // ((Dht)dhts.GetByIndex(i)).debug = true; // } } default_dht = new Dht((Node) nodes.GetByIndex(0), degree); }
/** <summary>A default Dht client provides a DEGREE of 1 and a sychronous wait time of up to 60 seconds.</summary> <param name ="node">The node to provide service for.</param> */ public Dht(Node node) { this.node = node; _rpc = RpcManager.GetInstance(node); _table = new TableServer(node); DEGREE = 1; MAJORITY = 1; DELAY = 60000; }
/** <summary>Begins a new transfer state to the neighbor connected via con. </summary> <param name="con">The connection to the neigbhor we will be transferring data to.</param> <param name="ts">The table server we're providing the transfer for. C# does not allow sub-class objects to have access to their parent objects member variables, so we pass it in like this.</param> <remarks> Step 1: Get all the keys between me and my new neighbor. Step 2: Get all values for those keys, we copy so that we don't worry about changes to the dht during this interaction. This is only a pointer copy and since we let the OS deal with removing the contents of an entry, we don't need to make copies of the actual entry. Step 3: Generate another list of keys of up to max parallel transfers and begin transferring, that way we do not need to lock access to the entry enumerator until non-constructor puts. Step 4: End constructor, results from puts, cause the next entry to be sent. */ public TransferState(Connection con, TableServer ts) { this._ts = ts; this._con = con; // Get all keys between me and my new neighbor LinkedList<MemBlock> keys; lock(_ts._sync) { keys = _ts._data.GetKeysBetween((AHAddress) _ts._node.Address, (AHAddress) _con.Address); } if(Dht.DhtLog.Enabled) { ProtocolLog.Write(Dht.DhtLog, String.Format( "Starting transfer from {0} to {1}", _ts._node.Address, _con.Address)); } int total_entries = 0; /* Get all values for those keys, we copy so that we don't worry about * changes to the dht during this interaction. This is only a pointer * copy and since we let the OS deal with removing the contents of an * entry, we don't need to make copies of the actual entry. */ foreach(MemBlock key in keys) { Entry[] entries; lock(_ts._sync) { LinkedList<Entry> llentries = _ts._data.GetEntries(key); if(llentries == null) { continue; } entries = new Entry[llentries.Count]; total_entries += llentries.Count; llentries.CopyTo(entries, 0); } key_entries.AddLast(entries); } if(Dht.DhtLog.Enabled) { ProtocolLog.Write(Dht.DhtLog, String.Format( "Total keys: {0}, total entries: {1}.", key_entries.Count, total_entries)); } _entry_enumerator = GetEntryEnumerator(); /* Here we generate another list of keys that we would like to * this is done here, so that we can lock up the _entry_enumerator * only during this stage and not during the RpcManager.Invoke */ LinkedList<Entry> local_entries = new LinkedList<Entry>(); for(int i = 0; i < MAX_PARALLEL_TRANSFERS && _entry_enumerator.MoveNext(); i++) { local_entries.AddLast((Entry) _entry_enumerator.Current); } foreach(Entry ent in local_entries) { Channel queue = new Channel(); queue.CloseAfterEnqueue(); queue.CloseEvent += this.NextTransfer; int ttl = (int) (ent.EndTime - DateTime.UtcNow).TotalSeconds; try { _ts._rpc.Invoke(_con.Edge, queue, "dht.PutHandler", ent.Key, ent.Value, ttl, false); } catch { if(_con.Edge.IsClosed) { _interrupted = true; Done(); break; } } } }