/**
* Add friend by retreiving certificate from DHT.
* @param key the DHT key for friend's certificate.
*/
public void AddDhtFriend(string key)
{
if (key == _local_user.DhtKey || _friends.ContainsKey(key))
{
if (key != _local_user.DhtKey)
{
_srh.PingFriend(_friends[key]);
}
return;
}
Channel q = new Channel();
q.CloseAfterEnqueue();
q.CloseEvent += delegate(Object o, EventArgs eargs) {
try {
DhtGetResult dgr = (DhtGetResult)q.Dequeue();
byte[] certData = dgr.value;
AddCertificate(certData, key);
ProtocolLog.Write(SocialLog.SVPNLog, "ADD DHT SUCCESS: " +
key);
} catch (Exception e) {
ProtocolLog.Write(SocialLog.SVPNLog, e.Message);
ProtocolLog.Write(SocialLog.SVPNLog, "ADD DHT FAILURE: " +
key);
}
};
this.Dht.AsGet(key, q);
}
/// <summary>
/// Does bulk Brunet DHT gets by calling the bulk DHT operation API of its
/// XML-RPC interface.
/// </summary>
/// <returns>Null if not all the pieces are successfully retrieved and parsed.</returns>
/// <exception cref="Exception">Parsing errors.</exception>
private MemBlock GetFragsInBulk(byte[] base_key, int piece_num,
out int largest_age, out int smallest_ttl)
{
largest_age = 0;
smallest_ttl = Int32.MaxValue;
MemBlock fragments = new MemBlock();
byte[][] keys = new byte[piece_num][];
for (int i = 0; i < piece_num; i++)
{
byte[] piece_key = BuildFragmentKey(base_key, i);
keys[i] = piece_key;
}
DhtGetResult[] dgrs = _dht.BulkGet(keys);
for (int i = 0; i < dgrs.Length; i++)
{
DhtGetResult dgr = dgrs[i];
if (dgr == null)
{
Logger.WriteLineIf(LogLevel.Error, _log_props,
string.Format("Piece #{0} is null. Retrying...", i));
dgr = GetWithRetries(keys[i], 2);
if (dgr == null)
{
Logger.WriteLineIf(LogLevel.Error, _log_props,
string.Format("Piece #{0} is null after retries. Skipping " +
"further parsing and returning...", i));
return(null);
}
}
FingerprintedData fpd;
try {
fpd =
(FingerprintedData)DictionaryData.CreateDictionaryData(dgr.value);
} catch (Exception ex) {
Logger.WriteLineIf(LogLevel.Error, _log_props,
ex);
throw ex;
}
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("Piece #{0} retrieved and successfully parsed", i));
RegularData rd = fpd.InnerData as RegularData;
fragments = MemBlock.Concat(fragments, MemBlock.Reference(rd.PayLoad));
if (smallest_ttl > dgr.ttl)
{
smallest_ttl = dgr.ttl;
}
if (largest_age < dgr.age)
{
largest_age = dgr.age;
}
//Now it's safe to say, this attempt succeeded.
}
return(fragments);
}
/// <summary>
/// Gets the first data item of the given name and possibly gets the
/// indicated pieces from DHT.
/// </summary>
/// <param name="getPieces">Whether to get pieces if the data at the
/// specified DHT name is a FragmentationInfo</param>
public DhtGetResult GetOneDatum(byte[] key, bool getPieces,
OneDatumMode mode)
{
DhtGetResult[] results = _dht.Get(key);
DhtGetResult ret;
if (results.Length == 0)
{
ret = null;
}
else
{
DhtGetResult dgr;
if (mode == OneDatumMode.FirstOne)
{
dgr = results[0];
}
else if (mode == OneDatumMode.LastOne)
{
dgr = results[results.Length - 1];
}
else
{
throw new NotImplementedException(
"This OneDatumMode not implemented.");
}
DictionaryData dd = null;
try {
dd = DictionaryData.CreateDictionaryData(dgr.value);
} catch (Exception ex) {
// Not an error in this case. Log with verbose level.
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
ex);
}
if (dd != null && dd is FragmentationInfo)
{
FragmentationInfo frag_info = dd as FragmentationInfo;
BrunetDhtEntry bde = null;
try {
bde = GetFragments(frag_info) as BrunetDhtEntry;
RegularData rd = (RegularData)DictionaryData.CreateDictionaryData(
bde.Value);
//Only 1 entry (if any) in this array
ret = new DhtGetResult(rd.PayLoad, bde.Age, bde.Ttl);
} catch (Exception ex) {
Logger.WriteLineIf(LogLevel.Error, _log_props, string.Format("Can't get fragments."), ex);
ret = null;
}
}
else
{
ret = dgr;
}
}
return(ret);
}
public void OnDhtGetReturns(IAsyncResult result)
{
AsyncResult ar = (AsyncResult)result;
AsyncFragsOpState agfs = (AsyncFragsOpState)ar.AsyncState;
BrunetDhtGetOp op = (BrunetDhtGetOp)ar.AsyncDelegate;
AsyncGetFragsGlobalState global_state =
(AsyncGetFragsGlobalState)agfs.GlobalState;
AsyncOpState piece_state = agfs.PieceState;
DhtGetResult[] returns = op.EndInvoke(ar);
if (returns != null && returns.Length > 0)
{
// We only need the first one.
DhtGetResult dgr = returns[0];
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("Get succeeded for piece: {0}",
Encoding.UTF8.GetString(piece_state.Key)));
lock (global_state.SyncRoot) {
byte[] piece_key = piece_state.Key;
int piece_indx = BrunetDht.GetPieceIndexFromFragmentKey(piece_key);
global_state.Fragments[piece_indx] = dgr;
global_state.OpSuccCount++;
if ((global_state.Concurrency > 1 && global_state.OpSuccCount %
global_state.Concurrency == 0) || global_state.OpSuccCount ==
global_state.ExpectedPositiveReturnNum)
{
// put concurrently and a batch finishes.
global_state.BatchFinishedEvent.Set();
}
if (global_state.OpSuccCount == global_state.ExpectedPositiveReturnNum)
{
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("All pieces of {0} successfully got. Firing GetStoppedEvent",
Encoding.UTF8.GetString(global_state.BaseKey)));
global_state.Returns.Enqueue(new GetFragsStoppedEventArgs(global_state.Fragments));
}
}
}
else
{
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("Get failed for piece: {0}. Firing GetStoppedEvent",
Encoding.UTF8.GetString(piece_state.Key)));
//No retry at this level currently, stop put operation.
lock (global_state.SyncRoot) {
global_state.Returns.Enqueue(new PutFragsStoppedEventArgs(piece_state));
}
}
}
/// <returns>Null if nothing got after retries</returns>
private DhtGetResult GetWithRetries(byte[] key, int retries)
{
bool succ = false;
DhtGetResult ret = null;
string key_string = Encoding.UTF8.GetString(key);
int retires_local = retries;
for (; !succ && retires_local > 0; retires_local--)
{
if (retires_local < retries)
{
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("Retrying..."));
}
DhtGetResult[] results = _dht.Get(key);
if (results.Length > 0)
{
succ = true;
ret = results[0];
}
}
if (retires_local <= 0)
{
Logger.WriteLineIf(LogLevel.Error, _log_props,
string.Format("Retries exhausted when getting {0}",
key_string));
}
else
{
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("{0} successfully got.",
key_string));
}
return(ret);
}
/// <returns>The memblock assembled from pieces. Null if operation failed.</returns>
private MemBlock GetFragsSequentially(byte[] base_key, int piece_num,
out int largest_age, out int smallest_ttl)
{
largest_age = 0;
smallest_ttl = Int32.MaxValue;
MemBlock fragments = new MemBlock();
for (int i = 0; i < piece_num; i++)
{
byte[] piece_key = BuildFragmentKey(base_key, i);
bool succ = false; //set to false iff bad things happen
int retries = 3; //After that we fail the operation
for (; !succ && retries > 0; retries--)
{
if (retries == 3)
{
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("Getting: {0}", piece_key));
}
else
{
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("Retrying..."));
}
try {
DhtGetResult[] dgrs = _dht.Get(piece_key);
//It should have only one entry. If not, just let the the exception caught
//and retry.
DhtGetResult dgr = dgrs[0];
FingerprintedData fpd =
(FingerprintedData)DictionaryData.CreateDictionaryData(dgr.value);
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("Piece {0} retrieved and successfully parsed", piece_key));
RegularData rd = fpd.InnerData as RegularData;
fragments = MemBlock.Concat(fragments, MemBlock.Reference(rd.PayLoad));
if (smallest_ttl > dgr.ttl)
{
smallest_ttl = dgr.ttl;
}
if (largest_age < dgr.age)
{
largest_age = dgr.age;
}
//Now it's safe to say, this attempt succeeded.
succ = true;
} catch (Exception ex) {
Logger.WriteLineIf(LogLevel.Error, _log_props,
ex);
succ = false;
}
} //if succ then we are good
if (retries <= 0)
{
//Quit because retries exhausted.
throw new Exception(string.Format("Retries exhausted when retrieving "
+ "and deserializing piece : {0}", piece_key));
}
else
{
Logger.WriteLineIf(LogLevel.Verbose, _log_props, string.Format(
"Done with piece {0}",
Encoding.UTF8.GetString(piece_key)));
}
}
return(fragments);
}
/// <summary>
/// Concurrenly gets the fragments from DHT.
/// </summary>
/// <returns>The fragments</returns>
private MemBlock GetFragsConcurrently(byte[] baseKey, int pieceNum,
out int largestAge, out int smallestTtl)
{
// First set the int values to be invalid.
smallestTtl = Int32.MaxValue;
largestAge = 0;
int max_enqueues = 1;
BlockingQueue bq_result = new BlockingQueue(max_enqueues);
AsyncGetFragsGlobalState global_state =
new AsyncGetFragsGlobalState(pieceNum, baseKey, bq_result);
int concurrency_degree = Concurrency;
global_state.Concurrency = concurrency_degree;
for (int i = 0; i < pieceNum; i++)
{
int index = i;
byte[] piece_key = BuildFragmentKey(baseKey, i);
string piece_key_string = Encoding.UTF8.GetString(piece_key);
// piece state
AsyncOpState aps = new AsyncOpState(piece_key);
AsyncFragsOpState afos = new AsyncFragsOpState(global_state, aps);
// async get, one instance of IDht per get because thread safty not guaranteed
IDht proxy = DhtServiceClient.GetXmlRpcDhtClient(_svc_uri.Port);
BrunetDhtClientOperations brdht_ops = new BrunetDhtClientOperations(
proxy);
lock (global_state.SyncRoot) {
brdht_ops.BeginGetWithCallback(piece_key,
new AsyncCallback(this.OnDhtGetReturns), afos);
}
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("Get piece {0} from DHT began (asynchronously)",
piece_key_string));
if ((concurrency_degree > 1 && (index + 1) % concurrency_degree == 0) ||
index == pieceNum - 1)
{
// Stop to wait for batch finish or all finish
global_state.BatchFinishedEvent.WaitOne();
if (concurrency_degree > 1)
{
Logger.WriteLineIf(LogLevel.Verbose, _log_props,
string.Format("Batch {0} finished. Moving on",
(int)((index + 1) / concurrency_degree)));
}
}
}
//block here until result comes
GetFragsStoppedEventArgs stop_args =
(GetFragsStoppedEventArgs)bq_result.Dequeue();
//All results have returned.
MemBlock ret = new MemBlock();
if (stop_args.IsSuccessful)
{
// We successfully got everything but aren't sure whether they are
// correct. Now parse them.
for (int i = 0; i < global_state.Fragments.Length; i++)
{
try {
DhtGetResult dgr = global_state.Fragments[i];
FingerprintedData fpd =
(FingerprintedData)DictionaryData.CreateDictionaryData(dgr.value);
RegularData rd = fpd.InnerData as RegularData;
// This piece is OK.
ret = MemBlock.Concat(ret, MemBlock.Reference(rd.PayLoad));
if (smallestTtl > dgr.ttl)
{
smallestTtl = dgr.ttl;
}
if (largestAge < dgr.age)
{
largestAge = dgr.age;
}
//Now it's safe to say, this attempt succeeded.
} catch (Exception) {
Logger.WriteLineIf(LogLevel.Error, _log_props,
string.Format("Parsing Piece failed at index {0}", i));
throw;
}
}
return(ret);
}
return(null);
}
