public Pair <Data, Enum> Remove(Number640 key, IPublicKey publicKey, bool returnData)
{
var rangeLock = Lock(key);
try
{
if (!CanClaimDomain(key.LocationAndDomainKey, publicKey))
{
return(new Pair <Data, Enum>(null, PutStatus.FailedSecurity));
}
if (!CanClaimEntry(key.LocationAndDomainAndContentKey, publicKey))
{
return(new Pair <Data, Enum>(null, PutStatus.FailedSecurity));
}
if (!_backend.Contains(key))
{
return(new Pair <Data, Enum>(null, PutStatus.NotFound));
}
_backend.RemoveTimeout(key);
return(new Pair <Data, Enum>(_backend.Remove(key, returnData), PutStatus.Ok));
}
finally
{
rangeLock.Unlock();
}
}
public SortedDictionary <Number640, Data> Get(Number640 from, Number640 to, SimpleBloomFilter <Number160> contentKeyBloomFilter,
SimpleBloomFilter <Number160> versionKeyBloomFilter, SimpleBloomFilter <Number160> contentBloomFilter, int limit,
bool ascending, bool isBloomFilterAnd)
{
var rLock = RangeLock.Lock(from, to);
try
{
var tmp = _backend.SubMap(from, to, limit, ascending);
foreach (var kvp in tmp.ToList()) // iterate over copy
{
// remove from original
if (kvp.Value.HasPrepareFlag)
{
tmp.Remove(kvp.Key);
continue;
}
if (isBloomFilterAnd)
{
if (!contentKeyBloomFilter.Contains(kvp.Key.ContentKey))
{
tmp.Remove(kvp.Key);
continue;
}
if (!versionKeyBloomFilter.Contains(kvp.Key.VersionKey))
{
tmp.Remove(kvp.Key);
continue;
}
if (!contentBloomFilter.Contains(kvp.Value.Hash))
{
tmp.Remove(kvp.Key);
}
}
else
{
if (contentKeyBloomFilter.Contains(kvp.Key.ContentKey))
{
tmp.Remove(kvp.Key);
continue;
}
if (versionKeyBloomFilter.Contains(kvp.Key.VersionKey))
{
tmp.Remove(kvp.Key);
continue;
}
if (contentBloomFilter.Contains(kvp.Value.Hash))
{
tmp.Remove(kvp.Key);
}
}
}
return(tmp);
}
finally
{
rLock.Unlock();
}
}
private bool IsEmpty(Number160 locationKey)
{
var from = new Number640(locationKey, Number160.Zero, Number160.Zero, Number160.Zero);
var to = new Number640(locationKey, Number160.MaxValue, Number160.MaxValue, Number160.MaxValue);
var tmp = _backend.SubMap(from, to, 1, false);
return(tmp.Count == 0);
}
/// <summary>
/// Searches for one content key.
/// </summary>
/// <param name="locationKey">The location key.</param>
/// <param name="domainKey">The domain key.</param>
/// <param name="contentKey">For Get() and Remove(), one can provide a content key
/// and the remote peer indicates if this key is on that peer.</param>
public SearchValues(Number160 locationKey, Number160 domainKey, Number160 contentKey)
{
LocationKey = locationKey;
DomainKey = domainKey;
ContentKey = contentKey;
KeyBloomFilter = null;
ContentBloomFilter = null;
From = null;
To = null;
}
private Data GetInternal(Number640 key)
{
var data = _backend.Get(key);
if (data != null && !data.HasPrepareFlag)
{
return(data);
}
return(null);
}
/// <summary>
/// Searches for multiple content keys. There may be false positives.
/// </summary>
/// <param name="locationKey">The location key.</param>
/// <param name="domainKey">The domain key.</param>
/// <param name="keyBloomFilter">For Get() and Remove() one can provide a bloom filter of
/// content keys and the remote peer indicates if those keys are on that peer.</param>
public SearchValues(Number160 locationKey, Number160 domainKey, SimpleBloomFilter <Number160> keyBloomFilter)
{
LocationKey = locationKey;
DomainKey = domainKey;
ContentKey = null;
KeyBloomFilter = keyBloomFilter;
ContentBloomFilter = null;
From = null;
To = null;
}
public SearchValues(Number160 locationKey, Number160 domainKey, Number640 from, Number640 to)
{
LocationKey = locationKey;
DomainKey = domainKey;
ContentKey = null;
KeyBloomFilter = null;
ContentBloomFilter = null;
From = from;
To = to;
}
/// <summary>
/// Searches for one content key.
/// </summary>
/// <param name="locationKey">The location key.</param>
/// <param name="domainKey">The domain key.</param>
/// <param name="contentKey">For Get() and Remove(), one can provide a content key
/// and the remote peer indicates if this key is on that peer.</param>
public SearchValues(Number160 locationKey, Number160 domainKey, Number160 contentKey)
{
LocationKey = locationKey;
DomainKey = domainKey;
ContentKey = contentKey;
KeyBloomFilter = null;
ContentBloomFilter = null;
From = null;
To = null;
}
public SearchValues(Number160 locationKey, Number160 domainKey, Number640 from, Number640 to)
{
LocationKey = locationKey;
DomainKey = domainKey;
ContentKey = null;
KeyBloomFilter = null;
ContentBloomFilter = null;
From = from;
To = to;
}
public Data Get(Number640 key)
{
var rangeLock = Lock(key);
try
{
return(GetInternal(key));
}
finally
{
rangeLock.Unlock();
}
}
public bool Contains(Number640 key)
{
var rangeLock = Lock(key);
try
{
return(_backend.Contains(key));
}
finally
{
rangeLock.Unlock();
}
}
public Enum Put(Number640 key, Data newData, IPublicKey publicKey, bool putIfAbsent, bool domainProtection,
bool sendSelf)
{
var dataMap = new SortedDictionary <Number640, Data>();
dataMap.Add(key, newData);
var putStatus = PutAll(dataMap, publicKey, putIfAbsent, domainProtection, sendSelf);
var retVal = putStatus[key];
if (retVal == null)
{
return(PutStatus.Failed);
}
return(retVal);
}
public SortedDictionary <Number640, Data> GetLatestVersion(Number640 key)
{
var rangeLock = Lock(key.LocationAndDomainAndContentKey);
try
{
var tmp = _backend.SubMap(key.MinVersionKey, key.MaxVersionKey, -1, true);
RemovePrepared(tmp);
return(GetLatestInternal(tmp));
}
finally
{
rangeLock.Unlock();
}
}
public Enum UpdateMeta(IPublicKey publicKey, Number640 key, Data newData)
{
var rangeLock = Lock(key);
try
{
if (!SecurityEntryCheck(key.LocationAndDomainAndContentKey, publicKey, newData.PublicKey,
newData.IsProtectedEntry))
{
return(PutStatus.FailedSecurity);
}
var data = _backend.Get(key);
var changed = false;
if (data != null && newData.PublicKey != null)
{
data.SetPublicKey(newData.PublicKey);
changed = true;
}
if (data != null && newData.IsSigned)
{
data.SetSignature(newData.Signature);
changed = true;
}
if (data != null)
{
data.SetValidFromMillis(newData.ValidFromMillis);
data.SetTtlSeconds(newData.TtlSeconds);
changed = true;
}
if (changed)
{
long expiration = data.ExpirationMillis;
// handle timeout
_backend.AddTimeout(key, expiration);
_backend.Put(key, data);
return(PutStatus.Ok);
}
else
{
return(PutStatus.NotFound);
}
}
finally
{
rangeLock.Unlock();
}
}
public SortedDictionary <Number640, Data> Get(Number640 from, Number640 to, int limit, bool ascending)
{
var rLock = RangeLock.Lock(from, to);
try
{
var tmp = _backend.SubMap(from, to, limit, ascending);
RemovePrepared(tmp);
return(tmp);
}
finally
{
rLock.Unlock();
}
}
public DigestInfo Digest(Number320 locationAndDomainKey, SimpleBloomFilter <Number160> keyBloomFilter, SimpleBloomFilter <Number160> contentBloomFilter, int limit, bool ascending, bool isBloomFilterAnd)
{
var digestInfo = new DigestInfo();
var rLock = Lock(locationAndDomainKey);
try {
var from = new Number640(locationAndDomainKey, Number160.Zero, Number160.Zero);
var to = new Number640(locationAndDomainKey, Number160.MaxValue, Number160.MaxValue);
var tmp = _backend.SubMap(from, to, limit, ascending);
foreach (var kvp in tmp)
{
if (isBloomFilterAnd)
{
if (keyBloomFilter == null || keyBloomFilter.Contains(kvp.Key.ContentKey))
{
if (contentBloomFilter == null || contentBloomFilter.Contains(kvp.Value.Hash))
{
if (!kvp.Value.HasPrepareFlag)
{
digestInfo.Put(kvp.Key, kvp.Value.BasedOnSet);
}
}
}
}
else
{
if (keyBloomFilter == null || !keyBloomFilter.Contains(kvp.Key.ContentKey))
{
if (contentBloomFilter == null || !contentBloomFilter.Contains(kvp.Value.Hash))
{
if (!kvp.Value.HasPrepareFlag)
{
digestInfo.Put(kvp.Key, kvp.Value.BasedOnSet);
}
}
}
}
}
return(digestInfo);
}
finally
{
rLock.Unlock();
}
}
public SortedDictionary <Number640, byte> RemoveReturnStatus(Number640 from, Number640 to, IPublicKey publicKey)
{
var rLock = RangeLock.Lock(from, to);
try
{
var tmp = _backend.SubMap(from, to, -1, true);
var result = new SortedDictionary <Number640, byte>();
foreach (var key in tmp.Keys)
{
var pair = Remove(key, publicKey, false);
result.Put(key, (byte)Convert.ToInt32(pair.Element1)); // TODO check if works
}
return(result);
}
finally
{
rLock.Unlock();
}
}
private static void DeletePredecessors(Number640 key, IDictionary <Number640, Data> sortedMap)
{
var toRemove = new List <Number640>();
toRemove.Add(key);
while (toRemove.Count != 0)
{
var version = sortedMap.Remove2(toRemove.RemoveAt2(0));
// check if version has been already deleted
// check if version is initial version
if (version != null && version.BasedOnSet.Count != 0)
{
foreach (var basedOnKey in version.BasedOnSet)
{
toRemove.Add(new Number640(key.LocationAndDomainAndContentKey, basedOnKey));
}
}
}
}
public DigestInfo Digest(Number640 from, Number640 to, int limit, bool ascending)
{
var digestInfo = new DigestInfo();
var rLock = RangeLock.Lock(from, to);
try
{
var tmp = _backend.SubMap(from, to, limit, ascending);
foreach (var kvp in tmp)
{
if (!kvp.Value.HasPrepareFlag)
{
digestInfo.Put(kvp.Key, kvp.Value.BasedOnSet);
}
}
return(digestInfo);
}
finally
{
rLock.Unlock();
}
}
public Enum PutConfirm(IPublicKey publicKey, Number640 key, Data newData)
{
var rangeLock = Lock(key);
try
{
if (!SecurityEntryCheck(key.LocationAndDomainAndContentKey, publicKey, newData.PublicKey, newData.IsProtectedEntry))
{
return(PutStatus.FailedSecurity);
}
var data = _backend.Get(key);
if (data != null)
{
// remove prepare flag
data.SetHasPreparaFlag(false);
data.SetValidFromMillis(newData.ValidFromMillis);
data.SetTtlSeconds(newData.TtlSeconds);
var expiration = data.ExpirationMillis;
// handle timeout
_backend.AddTimeout(key, expiration);
_backend.Put(key, data);
return(PutStatus.Ok);
}
else
{
return(PutStatus.NotFound);
}
}
finally
{
rangeLock.Unlock();
}
// TODO: Java: check for FORKS!
}
public SortedDictionary <Number640, Data> RemoveReturnData(Number640 from, Number640 to, IPublicKey publicKey)
{
var rLock = RangeLock.Lock(from, to);
try
{
var tmp = _backend.SubMap(from, to, -1, true);
foreach (var key in tmp.Keys)
{
// fail fast, as soon as we want to remove 1 domain that we cannot, abort
if (!CanClaimDomain(key.LocationAndDomainKey, publicKey))
{
return(null);
}
if (!CanClaimEntry(key.LocationAndDomainAndContentKey, publicKey))
{
return(null);
}
}
var result = _backend.Remove(from, to, true);
foreach (var kvp in result)
{
var data = kvp.Value;
if (data.PublicKey == null || data.PublicKey.Equals(publicKey))
{
_backend.RemoveTimeout(kvp.Key);
}
}
return(result);
}
finally
{
rLock.Unlock();
}
}
public DigestInfo Digest(Number640 from, Number640 to, int limit, bool ascending)
{
var digestInfo = new DigestInfo();
var rLock = RangeLock.Lock(from, to);
try
{
var tmp = _backend.SubMap(from, to, limit, ascending);
foreach (var kvp in tmp)
{
if (!kvp.Value.HasPrepareFlag)
{
digestInfo.Put(kvp.Key, kvp.Value.BasedOnSet);
}
}
return digestInfo;
}
finally
{
rLock.Unlock();
}
}
public void Put(Number640 key, sbyte value)
{
KeysMap.Add(key, value);
}
private RangeLock <Number640> .Range Lock(Number640 min, Number640 max)
{
return(RangeLock.Lock(min, max));
}
/// <summary>
/// Looks for a route to the given peer address.
/// </summary>
/// <param name="peerAddresses">Nodes that should be asked first for a route.</param>
/// <param name="routingBuilder"></param>
/// <param name="type"></param>
/// <param name="cc"></param>
/// <returns>A task object that is set to complete if the route has been found.</returns>
private TcsRouting Routing(ICollection<PeerAddress> peerAddresses, RoutingBuilder routingBuilder,
Message.Message.MessageType type, ChannelCreator cc)
{
try
{
if (peerAddresses == null)
{
throw new ArgumentException("Some nodes/addresses need to be specified.");
}
bool randomSearch = routingBuilder.LocationKey == null;
IComparer<PeerAddress> comparer;
if (randomSearch)
{
comparer = _peerBean.PeerMap.CreateComparer();
}
else
{
comparer = PeerMap.CreateComparer(routingBuilder.LocationKey);
}
var queueToAsk = new SortedSet<PeerAddress>(comparer);
var alreadyAsked = new SortedSet<PeerAddress>(comparer);
// As presented by Kazuyuki Shudo at AIMS 2009, it is better to ask random
// peers with the data than ask peers that are ordered by distance.
// -> this balances load
var directHits = new SortedDictionary<PeerAddress, DigestInfo>(comparer);
var potentialHits = new SortedSet<PeerAddress>(comparer);
// fill initially
queueToAsk.AddAll(peerAddresses);
alreadyAsked.Add(_peerBean.ServerPeerAddress);
potentialHits.Add(_peerBean.ServerPeerAddress);
// domain key can be null if we bootstrap
if (type == Message.Message.MessageType.Request2
&& routingBuilder.DomainKey != null
&& !randomSearch
&& _peerBean.DigestStorage != null)
{
Number640 from;
Number640 to;
if (routingBuilder.From != null && routingBuilder.To != null)
{
from = routingBuilder.From;
to = routingBuilder.To;
}
else if (routingBuilder.ContentKey == null)
{
from = new Number640(routingBuilder.LocationKey, routingBuilder.DomainKey, Number160.Zero, Number160.Zero);
to = new Number640(routingBuilder.LocationKey, routingBuilder.DomainKey, Number160.MaxValue, Number160.MaxValue);
}
else
{
from = new Number640(routingBuilder.LocationKey, routingBuilder.DomainKey, routingBuilder.ContentKey, Number160.Zero);
to = new Number640(routingBuilder.LocationKey, routingBuilder.DomainKey, routingBuilder.ContentKey, Number160.MaxValue);
}
var digestBean = _peerBean.DigestStorage.Digest(from, to, -1, true);
if (digestBean.Size > 0)
{
directHits.Add(_peerBean.ServerPeerAddress, digestBean);
}
}
else if (type == Message.Message.MessageType.Request3
&& !randomSearch
&& _peerBean.DigestTracker != null)
{
var digestInfo = _peerBean.DigestTracker.Digest(routingBuilder.LocationKey, routingBuilder.DomainKey,
routingBuilder.ContentKey);
// we always put ourselfs to the tracker list, so we need to check
// if we know also other peers on our trackers
if (digestInfo.Size > 0)
{
directHits.Add(_peerBean.ServerPeerAddress, digestInfo);
}
}
var tcsRouting = new TcsRouting();
if (peerAddresses.Count == 0)
{
tcsRouting.SetNeighbors(directHits, potentialHits, alreadyAsked, routingBuilder.IsBootstrap, false);
}
else
{
// If a peer bootstraps to itself, then the size of peer addresses is 1
// and it contains itself. Check for that because we need to know if we
// are routing, bootstrapping and bootstrapping to ourselfs, to return
// the correct status for the task.
var isRoutingOnlyToSelf = peerAddresses.Count == 1 &&
peerAddresses.First().Equals(_peerBean.ServerPeerAddress);
var routingMechanism = routingBuilder.CreateRoutingMechanism(tcsRouting);
routingMechanism.SetQueueToAsk(queueToAsk);
routingMechanism.SetPotentialHits(potentialHits);
routingMechanism.SetDirectHits(directHits);
routingMechanism.SetAlreadyAsked(alreadyAsked);
routingBuilder.SetIsRoutingOnlyToSelf(isRoutingOnlyToSelf);
RoutingRec(routingBuilder, routingMechanism, type, cc);
}
return tcsRouting;
}
catch (Exception ex)
{
Logger.Error("An exception occurred during routing.", ex);
throw;
}
}
public Enum Put(Number640 key, Data newData, IPublicKey publicKey, bool putIfAbsent, bool domainProtection,
bool sendSelf)
{
var dataMap = new SortedDictionary<Number640, Data>();
dataMap.Add(key, newData);
var putStatus = PutAll(dataMap, publicKey, putIfAbsent, domainProtection, sendSelf);
var retVal = putStatus[key];
if(retVal == null)
{
return PutStatus.Failed;
}
return retVal;
}
public Pair<Data, Enum> Remove(Number640 key, IPublicKey publicKey, bool returnData)
{
var rangeLock = Lock(key);
try
{
if (!CanClaimDomain(key.LocationAndDomainKey, publicKey))
{
return new Pair<Data, Enum>(null, PutStatus.FailedSecurity);
}
if (!CanClaimEntry(key.LocationAndDomainAndContentKey, publicKey))
{
return new Pair<Data, Enum>(null, PutStatus.FailedSecurity);
}
if (!_backend.Contains(key))
{
return new Pair<Data, Enum>(null, PutStatus.NotFound);
}
_backend.RemoveTimeout(key);
return new Pair<Data, Enum>(_backend.Remove(key, returnData), PutStatus.Ok);
}
finally
{
rangeLock.Unlock();
}
}
private Data GetInternal(Number640 key)
{
var data = _backend.Get(key);
if (data != null && !data.HasPrepareFlag)
{
return data;
}
return null;
}
public override void HandleResponse(Message.Message requestMessage, PeerConnection peerConnection, bool sign, IResponder responder)
{
if (requestMessage.KeyList.Count < 2)
{
throw new ArgumentException("At least location and domain keys are needed.");
}
if (!(requestMessage.Type == Message.Message.MessageType.Request1
|| requestMessage.Type == Message.Message.MessageType.Request2
|| requestMessage.Type == Message.Message.MessageType.Request3
|| requestMessage.Type == Message.Message.MessageType.Request4)
&& (requestMessage.Command == Rpc.Commands.Neighbor.GetNr()))
{
throw new ArgumentException("Message content is wrong for this handler.");
}
Number160 locationKey = requestMessage.Key(0);
Number160 domainKey = requestMessage.Key(1);
var neighbors = GetNeighbors(locationKey, NeighborSize);
if (neighbors == null)
{
// return empty neighbor set
var response = CreateResponseMessage(requestMessage, Message.Message.MessageType.NotFound);
response.SetNeighborSet(new NeighborSet(-1, new Collection<PeerAddress>()));
responder.Response(response);
return;
}
// create response message and set neighbors
var responseMessage = CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok);
Logger.Debug("Found the following neighbors: {0}.", Convenient.ToString(neighbors));
var neighborSet = new NeighborSet(NeighborLimit, neighbors);
responseMessage.SetNeighborSet(neighborSet);
Number160 contentKey = requestMessage.Key(2);
var keyBloomFilter = requestMessage.BloomFilter(0);
var contentBloomFilter = requestMessage.BloomFilter(1);
var keyCollection = requestMessage.KeyCollection(0);
// it is important to set an integer if a value is present
bool isDigest = requestMessage.Type != Message.Message.MessageType.Request1;
if (isDigest)
{
if (requestMessage.Type == Message.Message.MessageType.Request2)
{
DigestInfo digestInfo;
if (PeerBean.DigestStorage == null)
{
// no storage to search
digestInfo = new DigestInfo();
}
else if (contentKey != null && locationKey != null && domainKey != null)
{
var locationAndDomainKey = new Number320(locationKey, domainKey);
var from = new Number640(locationAndDomainKey, contentKey, Number160.Zero);
var to = new Number640(locationAndDomainKey, contentKey, Number160.MaxValue);
digestInfo = PeerBean.DigestStorage.Digest(from, to, -1, true);
}
else if ((keyBloomFilter != null || contentBloomFilter != null) && locationKey != null && domainKey != null)
{
var locationAndDomainKey = new Number320(locationKey, domainKey);
digestInfo = PeerBean.DigestStorage.Digest(locationAndDomainKey, keyBloomFilter,
contentBloomFilter, -1, true, true);
}
else if (keyCollection != null && keyCollection.Keys.Count == 2)
{
var enumerator = keyCollection.Keys.GetEnumerator();
var from = enumerator.MoveNext() ? enumerator.Current : null; // TODO works correctly?
var to = enumerator.MoveNext() ? enumerator.Current : null;
digestInfo = PeerBean.DigestStorage.Digest(from, to, -1, true);
}
else if (locationKey != null && domainKey != null)
{
var locationAndDomainKey = new Number320(locationKey, domainKey);
var from = new Number640(locationAndDomainKey, Number160.Zero, Number160.Zero);
var to = new Number640(locationAndDomainKey, Number160.MaxValue, Number160.MaxValue);
digestInfo = PeerBean.DigestStorage.Digest(from, to, -1, true);
}
else
{
Logger.Warn("Did not search for anything.");
digestInfo = new DigestInfo();
}
responseMessage.SetIntValue(digestInfo.Size);
responseMessage.SetKey(digestInfo.KeyDigest);
responseMessage.SetKey(digestInfo.ContentDigest);
}
else if (requestMessage.Type == Message.Message.MessageType.Request3)
{
DigestInfo digestInfo;
if (PeerBean.DigestTracker == null)
{
// no tracker to search
digestInfo = new DigestInfo();
}
else
{
digestInfo = PeerBean.DigestTracker.Digest(locationKey, domainKey, contentKey);
if (digestInfo.Size == 0)
{
Logger.Debug("No entry found on peer {0}.", requestMessage.Recipient);
}
}
responseMessage.SetIntValue(digestInfo.Size);
}
else if (requestMessage.Type == Message.Message.MessageType.Request4)
{
lock (PeerBean.PeerStatusListeners)
{
foreach (var listener in PeerBean.PeerStatusListeners)
{
listener.PeerFailed(requestMessage.Sender,
new PeerException(PeerException.AbortCauseEnum.Shutdown, "shutdown"));
}
}
}
}
responder.Response(responseMessage);
}
/// <summary>
/// Searhces for content key and values with a bloom filter. There may be false positives.
/// </summary>
/// <param name="locationKey">The location key.</param>
/// <param name="domainKey">The domain key.</param>
/// <param name="keyBloomFilter">For Get() and Remove() one can provide a bloom filter of
/// content keys and the remote peer indicates if those keys are on that peer.</param>
/// <param name="contentBloomFilter">For Get() and Remove() one can provide a bloom filter of
/// content values and the remote peer indicates if those keys are on that peer.</param>
public SearchValues(Number160 locationKey, Number160 domainKey, SimpleBloomFilter<Number160> keyBloomFilter,
SimpleBloomFilter<Number160> contentBloomFilter)
{
LocationKey = locationKey;
DomainKey = domainKey;
ContentKey = null;
KeyBloomFilter = keyBloomFilter;
ContentBloomFilter = contentBloomFilter;
From = null;
To = null;
}
public SortedDictionary<Number640, byte> RemoveReturnStatus(Number640 from, Number640 to, IPublicKey publicKey)
{
var rLock = RangeLock.Lock(from, to);
try
{
var tmp = _backend.SubMap(from, to, -1, true);
var result = new SortedDictionary<Number640, byte>();
foreach (var key in tmp.Keys)
{
var pair = Remove(key, publicKey, false);
result.Put(key, (byte) Convert.ToInt32(pair.Element1)); // TODO check if works
}
return result;
}
finally
{
rLock.Unlock();
}
}
public override void HandleResponse(Message.Message requestMessage, PeerConnection peerConnection, bool sign, IResponder responder)
{
if (requestMessage.KeyList.Count < 2)
{
throw new ArgumentException("At least location and domain keys are needed.");
}
if (!(requestMessage.Type == Message.Message.MessageType.Request1 ||
requestMessage.Type == Message.Message.MessageType.Request2 ||
requestMessage.Type == Message.Message.MessageType.Request3 ||
requestMessage.Type == Message.Message.MessageType.Request4) &&
(requestMessage.Command == Rpc.Commands.Neighbor.GetNr()))
{
throw new ArgumentException("Message content is wrong for this handler.");
}
Number160 locationKey = requestMessage.Key(0);
Number160 domainKey = requestMessage.Key(1);
var neighbors = GetNeighbors(locationKey, NeighborSize);
if (neighbors == null)
{
// return empty neighbor set
var response = CreateResponseMessage(requestMessage, Message.Message.MessageType.NotFound);
response.SetNeighborSet(new NeighborSet(-1, new Collection <PeerAddress>()));
responder.Response(response);
return;
}
// create response message and set neighbors
var responseMessage = CreateResponseMessage(requestMessage, Message.Message.MessageType.Ok);
Logger.Debug("Found the following neighbors: {0}.", Convenient.ToString(neighbors));
var neighborSet = new NeighborSet(NeighborLimit, neighbors);
responseMessage.SetNeighborSet(neighborSet);
Number160 contentKey = requestMessage.Key(2);
var keyBloomFilter = requestMessage.BloomFilter(0);
var contentBloomFilter = requestMessage.BloomFilter(1);
var keyCollection = requestMessage.KeyCollection(0);
// it is important to set an integer if a value is present
bool isDigest = requestMessage.Type != Message.Message.MessageType.Request1;
if (isDigest)
{
if (requestMessage.Type == Message.Message.MessageType.Request2)
{
DigestInfo digestInfo;
if (PeerBean.DigestStorage == null)
{
// no storage to search
digestInfo = new DigestInfo();
}
else if (contentKey != null && locationKey != null && domainKey != null)
{
var locationAndDomainKey = new Number320(locationKey, domainKey);
var from = new Number640(locationAndDomainKey, contentKey, Number160.Zero);
var to = new Number640(locationAndDomainKey, contentKey, Number160.MaxValue);
digestInfo = PeerBean.DigestStorage.Digest(from, to, -1, true);
}
else if ((keyBloomFilter != null || contentBloomFilter != null) && locationKey != null && domainKey != null)
{
var locationAndDomainKey = new Number320(locationKey, domainKey);
digestInfo = PeerBean.DigestStorage.Digest(locationAndDomainKey, keyBloomFilter,
contentBloomFilter, -1, true, true);
}
else if (keyCollection != null && keyCollection.Keys.Count == 2)
{
var enumerator = keyCollection.Keys.GetEnumerator();
var from = enumerator.MoveNext() ? enumerator.Current : null; // TODO works correctly?
var to = enumerator.MoveNext() ? enumerator.Current : null;
digestInfo = PeerBean.DigestStorage.Digest(from, to, -1, true);
}
else if (locationKey != null && domainKey != null)
{
var locationAndDomainKey = new Number320(locationKey, domainKey);
var from = new Number640(locationAndDomainKey, Number160.Zero, Number160.Zero);
var to = new Number640(locationAndDomainKey, Number160.MaxValue, Number160.MaxValue);
digestInfo = PeerBean.DigestStorage.Digest(from, to, -1, true);
}
else
{
Logger.Warn("Did not search for anything.");
digestInfo = new DigestInfo();
}
responseMessage.SetIntValue(digestInfo.Size);
responseMessage.SetKey(digestInfo.KeyDigest);
responseMessage.SetKey(digestInfo.ContentDigest);
}
else if (requestMessage.Type == Message.Message.MessageType.Request3)
{
DigestInfo digestInfo;
if (PeerBean.DigestTracker == null)
{
// no tracker to search
digestInfo = new DigestInfo();
}
else
{
digestInfo = PeerBean.DigestTracker.Digest(locationKey, domainKey, contentKey);
if (digestInfo.Size == 0)
{
Logger.Debug("No entry found on peer {0}.", requestMessage.Recipient);
}
}
responseMessage.SetIntValue(digestInfo.Size);
}
else if (requestMessage.Type == Message.Message.MessageType.Request4)
{
lock (PeerBean.PeerStatusListeners)
{
foreach (var listener in PeerBean.PeerStatusListeners)
{
listener.PeerFailed(requestMessage.Sender,
new PeerException(PeerException.AbortCauseEnum.Shutdown, "shutdown"));
}
}
}
}
responder.Response(responseMessage);
}
private RangeLock<Number640>.Range Lock(Number640 number640)
{
return RangeLock.Lock(number640, number640);
}
private RangeLock<Number640>.Range Lock(Number640 min, Number640 max)
{
return RangeLock.Lock(min, max);
}
public DigestInfo Digest(Number320 locationAndDomainKey, SimpleBloomFilter<Number160> keyBloomFilter, SimpleBloomFilter<Number160> contentBloomFilter, int limit, bool ascending, bool isBloomFilterAnd)
{
var digestInfo = new DigestInfo();
var rLock = Lock(locationAndDomainKey);
try {
var from = new Number640(locationAndDomainKey, Number160.Zero, Number160.Zero);
var to = new Number640(locationAndDomainKey, Number160.MaxValue, Number160.MaxValue);
var tmp = _backend.SubMap(from, to, limit, ascending);
foreach (var kvp in tmp)
{
if (isBloomFilterAnd)
{
if (keyBloomFilter == null || keyBloomFilter.Contains(kvp.Key.ContentKey))
{
if (contentBloomFilter == null || contentBloomFilter.Contains(kvp.Value.Hash))
{
if (!kvp.Value.HasPrepareFlag)
{
digestInfo.Put(kvp.Key, kvp.Value.BasedOnSet);
}
}
}
}
else
{
if (keyBloomFilter == null || !keyBloomFilter.Contains(kvp.Key.ContentKey))
{
if (contentBloomFilter == null || !contentBloomFilter.Contains(kvp.Value.Hash))
{
if (!kvp.Value.HasPrepareFlag)
{
digestInfo.Put(kvp.Key, kvp.Value.BasedOnSet);
}
}
}
}
}
return digestInfo;
}
finally
{
rLock.Unlock();
}
}
public SortedDictionary<Number640, Data> GetLatestVersion(Number640 key)
{
var rangeLock = Lock(key.LocationAndDomainAndContentKey);
try
{
var tmp = _backend.SubMap(key.MinVersionKey, key.MaxVersionKey, -1, true);
RemovePrepared(tmp);
return GetLatestInternal(tmp);
}
finally
{
rangeLock.Unlock();
}
}
public SortedDictionary<Number640, Data> Get(Number640 from, Number640 to, int limit, bool ascending)
{
var rLock = RangeLock.Lock(from, to);
try
{
var tmp = _backend.SubMap(from, to, limit, ascending);
RemovePrepared(tmp);
return tmp;
}
finally
{
rLock.Unlock();
}
}
public DigestBuilder SetFrom(Number640 from)
{
From = from;
return(this);
}
public Data Get(Number640 key)
{
var rangeLock = Lock(key);
try
{
return GetInternal(key);
}
finally
{
rangeLock.Unlock();
}
}
public DigestBuilder SetTo(Number640 to)
{
To = to;
return(this);
}
public IDictionary <Number640, Enum> PutAll(SortedDictionary <Number640, Data> dataMap, IPublicKey publicKey, bool putIfAbsent, bool domainProtection,
bool sendSelf)
{
if (dataMap.Count == 0)
{
return(Convenient.EmptyDictionary <Number640, Enum>());
}
var min = dataMap.First().Key; // TODO check if correct
var max = dataMap.Last().Key;
var retVal = new Dictionary <Number640, Enum>();
var keysToCheck = new HashSet <Number480>();
var rangeLock = Lock(min, max);
try
{
foreach (var kvp in dataMap)
{
var key = kvp.Key;
keysToCheck.Add(key.LocationAndDomainAndContentKey);
var newData = kvp.Value;
if (!SecurityDomainCheck(key.LocationAndDomainKey, publicKey, publicKey, domainProtection))
{
retVal.Add(key, PutStatus.FailedSecurity);
continue;
}
// We need this check in case we did not use the encoder/deconder,
// which is the case if we send the message to ourself. In that
// case, the public key of the data is never set to the message
// publick key, if the publick key of the data was null.
IPublicKey dataKey;
if (sendSelf && newData.PublicKey == null)
{
dataKey = publicKey;
}
else
{
dataKey = newData.PublicKey;
}
if (!SecurityEntryCheck(key.LocationAndDomainAndContentKey, publicKey, dataKey, newData.IsProtectedEntry))
{
retVal.Add(key, PutStatus.FailedSecurity);
continue;
}
var contains = _backend.Contains(key);
if (contains)
{
if (putIfAbsent)
{
retVal.Add(key, PutStatus.FailedNotAbsent);
continue;
}
var oldData = _backend.Get(key);
if (oldData.IsDeleted)
{
retVal.Add(key, PutStatus.Deleted);
continue;
}
if (!oldData.BasedOnSet.Equals(newData.BasedOnSet))
{
retVal.Add(key, PutStatus.VersionFork);
continue;
}
}
var oldData2 = _backend.Put(key, newData);
long expiration = newData.ExpirationMillis;
// handle timeout
_backend.AddTimeout(key, expiration);
if (newData.HasPrepareFlag)
{
retVal.Add(key, PutStatus.OkPrepared);
}
else
{
if (newData.Equals(oldData2))
{
retVal.Add(key, PutStatus.OkUnchanged);
}
else
{
retVal.Add(key, PutStatus.Ok);
}
}
}
//now check for forks
foreach (var key in keysToCheck)
{
var minVersion = new Number640(key, Number160.Zero);
var maxVersion = new Number640(key, Number160.MaxValue);
var tmp = _backend.SubMap(minVersion, maxVersion, -1, true);
var heads = GetLatestInternal(tmp);
if (heads.Count > 1)
{
foreach (var fork in heads.Keys)
{
if (retVal.ContainsKey(fork))
{
retVal.Add(fork, PutStatus.VersionFork);
}
}
}
}
return(retVal);
}
finally
{
rangeLock.Unlock();
}
}
public SortedDictionary<Number640, Data> RemoveReturnData(Number640 from, Number640 to, IPublicKey publicKey)
{
var rLock = RangeLock.Lock(from, to);
try
{
var tmp = _backend.SubMap(from, to, -1, true);
foreach (var key in tmp.Keys)
{
// fail fast, as soon as we want to remove 1 domain that we cannot, abort
if (!CanClaimDomain(key.LocationAndDomainKey, publicKey))
{
return null;
}
if (!CanClaimEntry(key.LocationAndDomainAndContentKey, publicKey))
{
return null;
}
}
var result = _backend.Remove(from, to, true);
foreach (var kvp in result)
{
var data = kvp.Value;
if (data.PublicKey == null || data.PublicKey.Equals(publicKey))
{
_backend.RemoveTimeout(kvp.Key);
}
}
return result;
}
finally
{
rLock.Unlock();
}
}
public IDictionary<Number640, Enum> PutAll(SortedDictionary<Number640, Data> dataMap, IPublicKey publicKey, bool putIfAbsent, bool domainProtection,
bool sendSelf)
{
if (dataMap.Count == 0)
{
return Convenient.EmptyDictionary<Number640, Enum>();
}
var min = dataMap.First().Key; // TODO check if correct
var max = dataMap.Last().Key;
var retVal = new Dictionary<Number640, Enum>();
var keysToCheck = new HashSet<Number480>();
var rangeLock = Lock(min, max);
try
{
foreach (var kvp in dataMap)
{
var key = kvp.Key;
keysToCheck.Add(key.LocationAndDomainAndContentKey);
var newData = kvp.Value;
if (!SecurityDomainCheck(key.LocationAndDomainKey, publicKey, publicKey, domainProtection))
{
retVal.Add(key, PutStatus.FailedSecurity);
continue;
}
// We need this check in case we did not use the encoder/deconder,
// which is the case if we send the message to ourself. In that
// case, the public key of the data is never set to the message
// publick key, if the publick key of the data was null.
IPublicKey dataKey;
if (sendSelf && newData.PublicKey == null)
{
dataKey = publicKey;
}
else
{
dataKey = newData.PublicKey;
}
if (!SecurityEntryCheck(key.LocationAndDomainAndContentKey, publicKey, dataKey, newData.IsProtectedEntry))
{
retVal.Add(key, PutStatus.FailedSecurity);
continue;
}
var contains = _backend.Contains(key);
if (contains)
{
if(putIfAbsent)
{
retVal.Add(key, PutStatus.FailedNotAbsent);
continue;
}
var oldData = _backend.Get(key);
if(oldData.IsDeleted)
{
retVal.Add(key, PutStatus.Deleted);
continue;
}
if(!oldData.BasedOnSet.Equals(newData.BasedOnSet))
{
retVal.Add(key, PutStatus.VersionFork);
continue;
}
}
var oldData2 = _backend.Put(key, newData);
long expiration = newData.ExpirationMillis;
// handle timeout
_backend.AddTimeout(key, expiration);
if(newData.HasPrepareFlag)
{
retVal.Add(key, PutStatus.OkPrepared);
}
else
{
if(newData.Equals(oldData2))
{
retVal.Add(key, PutStatus.OkUnchanged);
}
else
{
retVal.Add(key, PutStatus.Ok);
}
}
}
//now check for forks
foreach (var key in keysToCheck)
{
var minVersion = new Number640(key, Number160.Zero);
var maxVersion = new Number640(key, Number160.MaxValue);
var tmp = _backend.SubMap(minVersion, maxVersion, -1, true);
var heads = GetLatestInternal(tmp);
if(heads.Count > 1)
{
foreach (var fork in heads.Keys)
{
if(retVal.ContainsKey(fork))
{
retVal.Add(fork, PutStatus.VersionFork);
}
}
}
}
return retVal;
}
finally
{
rangeLock.Unlock();
}
}
public SortedDictionary<Number640, Data> Get(Number640 from, Number640 to, SimpleBloomFilter<Number160> contentKeyBloomFilter,
SimpleBloomFilter<Number160> versionKeyBloomFilter, SimpleBloomFilter<Number160> contentBloomFilter, int limit,
bool ascending, bool isBloomFilterAnd)
{
var rLock = RangeLock.Lock(from, to);
try
{
var tmp = _backend.SubMap(from, to, limit, ascending);
foreach (var kvp in tmp.ToList()) // iterate over copy
{
// remove from original
if (kvp.Value.HasPrepareFlag)
{
tmp.Remove(kvp.Key);
continue;
}
if (isBloomFilterAnd)
{
if (!contentKeyBloomFilter.Contains(kvp.Key.ContentKey))
{
tmp.Remove(kvp.Key);
continue;
}
if (!versionKeyBloomFilter.Contains(kvp.Key.VersionKey))
{
tmp.Remove(kvp.Key);
continue;
}
if (!contentBloomFilter.Contains(kvp.Value.Hash))
{
tmp.Remove(kvp.Key);
}
}
else
{
if (contentKeyBloomFilter.Contains(kvp.Key.ContentKey))
{
tmp.Remove(kvp.Key);
continue;
}
if (versionKeyBloomFilter.Contains(kvp.Key.VersionKey))
{
tmp.Remove(kvp.Key);
continue;
}
if (contentBloomFilter.Contains(kvp.Value.Hash))
{
tmp.Remove(kvp.Key);
}
}
}
return tmp;
}
finally
{
rLock.Unlock();
}
}
private bool DecodePayload(AlternativeCompositeByteBuf buffer)
{
Logger.Debug("About to pass message {0} to {1}. Buffer to read: {2}.", Message, Message.SenderSocket, buffer.ReadableBytes);
if (!Message.HasContent())
{
return true;
}
int size;
IPublicKey receivedPublicKey;
while (_contentTypes.Count > 0)
{
Message.Content content = _contentTypes.Peek();
Logger.Debug("Go for content: {0}.", content);
switch (content)
{
case Message.Content.Integer:
if (buffer.ReadableBytes < Utils.Utils.IntegerByteSize)
{
return false;
}
Message.SetIntValue(buffer.ReadInt());
LastContent = _contentTypes.Dequeue();
break;
case Message.Content.Long:
if (buffer.ReadableBytes < Utils.Utils.LongByteSize)
{
return false;
}
Message.SetLongValue(buffer.ReadLong());
LastContent = _contentTypes.Dequeue();
break;
case Message.Content.Key:
if (buffer.ReadableBytes < Number160.ByteArraySize)
{
return false;
}
var keyBytes = new sbyte[Number160.ByteArraySize];
buffer.ReadBytes(keyBytes);
Message.SetKey(new Number160(keyBytes));
LastContent = _contentTypes.Dequeue();
break;
case Message.Content.BloomFilter:
if (buffer.ReadableBytes < Utils.Utils.ShortByteSize)
{
return false;
}
size = buffer.GetUShort(buffer.ReaderIndex);
if (buffer.ReadableBytes < size)
{
return false;
}
Message.SetBloomFilter(new SimpleBloomFilter<Number160>(buffer));
LastContent = _contentTypes.Dequeue();
break;
case Message.Content.SetNeighbors:
if (_neighborSize == -1 && buffer.ReadableBytes < Utils.Utils.ByteByteSize)
{
return false;
}
if (_neighborSize == -1)
{
_neighborSize = buffer.ReadByte();
}
if (_neighborSet == null)
{
_neighborSet = new NeighborSet(-1, new List<PeerAddress>(_neighborSize));
}
for (int i = _neighborSet.Size; i < _neighborSize; i++)
{
if (buffer.ReadableBytes < Utils.Utils.ShortByteSize)
{
return false;
}
int header = buffer.GetUShort(buffer.ReaderIndex);
size = PeerAddress.CalculateSize(header);
if (buffer.ReadableBytes < size)
{
return false;
}
var pa = new PeerAddress(buffer);
_neighborSet.Add(pa);
}
Message.SetNeighborSet(_neighborSet);
LastContent = _contentTypes.Dequeue();
_neighborSize = -1; // TODO why here? not in prepareFinish()?
_neighborSet = null;
break;
case Message.Content.SetPeerSocket:
if (_peerSocketAddressSize == -1 && buffer.ReadableBytes < Utils.Utils.ByteByteSize)
{
return false;
}
if (_peerSocketAddressSize == -1)
{
_peerSocketAddressSize = buffer.ReadUByte();
}
if (_peerSocketAddresses == null)
{
_peerSocketAddresses = new List<PeerSocketAddress>(_peerSocketAddressSize);
}
for (int i = _peerSocketAddresses.Count; i < _peerSocketAddressSize; i++)
{
if (buffer.ReadableBytes < Utils.Utils.ByteByteSize)
{
return false;
}
int header = buffer.GetUByte(buffer.ReaderIndex);
bool isIPv4 = header == 0; // TODO check if works
size = PeerSocketAddress.Size(isIPv4);
if (buffer.ReadableBytes < size + Utils.Utils.ByteByteSize)
{
return false;
}
// skip the ipv4/ipv6 header
buffer.SkipBytes(1);
_peerSocketAddresses.Add(PeerSocketAddress.Create(buffer, isIPv4));
}
Message.SetPeerSocketAddresses(_peerSocketAddresses);
LastContent = _contentTypes.Dequeue();
_peerSocketAddressSize = -1; // TODO why here? not in prepareFinish()?
_peerSocketAddresses = null;
break;
case Message.Content.SetKey640:
if (_keyCollectionSize == -1 && buffer.ReadableBytes < Utils.Utils.IntegerByteSize)
{
return false;
}
if (_keyCollectionSize == -1)
{
_keyCollectionSize = buffer.ReadInt();
}
if (_keyCollection == null)
{
_keyCollection = new KeyCollection(new List<Number640>(_keyCollectionSize));
}
for (int i = _keyCollection.Size; i < _keyCollectionSize; i++)
{
if (buffer.ReadableBytes < 4 * Number160.ByteArraySize)
{
return false;
}
var me = new sbyte[Number160.ByteArraySize];
buffer.ReadBytes(me);
var locationKey = new Number160(me);
buffer.ReadBytes(me);
var domainKey = new Number160(me);
buffer.ReadBytes(me);
var contentKey = new Number160(me);
buffer.ReadBytes(me);
var versionKey = new Number160(me);
_keyCollection.Add(new Number640(locationKey, domainKey, contentKey, versionKey));
}
Message.SetKeyCollection(_keyCollection);
LastContent = _contentTypes.Dequeue();
_keyCollectionSize = -1; // TODO why here? not in prepareFinish()?
_keyCollection = null;
break;
case Message.Content.MapKey640Data:
if (_mapSize == -1 && buffer.ReadableBytes < Utils.Utils.IntegerByteSize)
{
return false;
}
if (_mapSize == -1)
{
_mapSize = buffer.ReadInt();
}
if (_dataMap == null)
{
_dataMap = new DataMap(new Dictionary<Number640, Data>(2 * _mapSize));
}
if (_data != null)
{
if (!_data.DecodeBuffer(buffer))
{
return false;
}
if (!_data.DecodeDone(buffer, Message.PublicKey(0), _signatureFactory))
{
return false;
}
_data = null; // TODO why here? not in prepareFinish()?
_key = null;
}
for (int i = _dataMap.Size; i < _mapSize; i++)
{
if (_key == null)
{
if (buffer.ReadableBytes < 4 * Number160.ByteArraySize)
{
return false;
}
var me = new sbyte[Number160.ByteArraySize];
buffer.ReadBytes(me);
var locationKey = new Number160(me);
buffer.ReadBytes(me);
var domainKey = new Number160(me);
buffer.ReadBytes(me);
var contentKey = new Number160(me);
buffer.ReadBytes(me);
var versionKey = new Number160(me);
_key = new Number640(locationKey, domainKey, contentKey, versionKey);
}
_data = Data.DeocdeHeader(buffer, _signatureFactory);
if (_data == null)
{
return false;
}
_dataMap.BackingDataMap.Add(_key, _data);
if (!_data.DecodeBuffer(buffer))
{
return false;
}
if (!_data.DecodeDone(buffer, Message.PublicKey(0), _signatureFactory))
{
return false;
}
// if we have signed the message, set the public key anyway, but only if we indicated so
if (Message.IsSign && Message.PublicKey(0) != null && _data.HasPublicKey
&& (_data.PublicKey == null || _data.PublicKey == PeerBuilder.EmptyPublicKey))
// TODO check empty key condition
{
_data.SetPublicKey(Message.PublicKey(0));
}
_data = null; // TODO why here? not in prepareFinish()?
_key = null;
}
Message.SetDataMap(_dataMap);
LastContent = _contentTypes.Dequeue();
_mapSize = -1; // TODO why here? not in prepareFinish()?
_dataMap = null;
break;
case Message.Content.MapKey640Keys:
if (_keyMap640KeysSize == -1 && buffer.ReadableBytes < Utils.Utils.IntegerByteSize)
{
return false;
}
if (_keyMap640KeysSize == -1)
{
_keyMap640KeysSize = buffer.ReadInt();
}
if (_keyMap640Keys == null)
{
_keyMap640Keys = new KeyMap640Keys(new SortedDictionary<Number640, ICollection<Number160>>());
// TODO check TreeMap equivalent
}
const int meta = 4 * Number160.ByteArraySize;
for (int i = _keyMap640Keys.Size; i < _keyMap640KeysSize; i++)
{
if (buffer.ReadableBytes < meta + Utils.Utils.ByteByteSize)
{
return false;
}
size = buffer.GetUByte(buffer.ReaderIndex + meta);
if (buffer.ReadableBytes <
meta + Utils.Utils.ByteByteSize + (size * Number160.ByteArraySize))
{
return false;
}
var me = new sbyte[Number160.ByteArraySize];
buffer.ReadBytes(me);
var locationKey = new Number160(me);
buffer.ReadBytes(me);
var domainKey = new Number160(me);
buffer.ReadBytes(me);
var contentKey = new Number160(me);
buffer.ReadBytes(me);
var versionKey = new Number160(me);
int numBasedOn = buffer.ReadByte();
var value = new HashSet<Number160>();
for (int j = 0; j < numBasedOn; j++)
{
buffer.ReadBytes(me);
var basedOnKey = new Number160(me);
value.Add(basedOnKey);
}
_keyMap640Keys.Put(new Number640(locationKey, domainKey, contentKey, versionKey), value);
}
Message.SetKeyMap640Keys(_keyMap640Keys);
LastContent = _contentTypes.Dequeue();
_keyMap640KeysSize = -1; // TODO why here? not in prepareFinish()?
_keyMap640Keys = null;
break;
case Message.Content.MapKey640Byte:
if (_keyMapByteSize == -1 && buffer.ReadableBytes < Utils.Utils.IntegerByteSize)
{
return false;
}
if (_keyMapByteSize == -1)
{
_keyMapByteSize = buffer.ReadInt();
}
if (_keyMapByte == null)
{
_keyMapByte = new KeyMapByte(new Dictionary<Number640, sbyte>(2 * _keyMapByteSize));
}
for (int i = _keyMapByte.Size; i < _keyMapByteSize; i++)
{
if (buffer.ReadableBytes < 4 * Number160.ByteArraySize + 1)
{
return false;
}
var me = new sbyte[Number160.ByteArraySize];
buffer.ReadBytes(me);
var locationKey = new Number160(me);
buffer.ReadBytes(me);
var domainKey = new Number160(me);
buffer.ReadBytes(me);
var contentKey = new Number160(me);
buffer.ReadBytes(me);
var versionKey = new Number160(me);
sbyte value = buffer.ReadByte();
_keyMapByte.Put(new Number640(locationKey, domainKey, contentKey, versionKey), value);
}
Message.SetKeyMapByte(_keyMapByte);
LastContent = _contentTypes.Dequeue();
_keyMapByteSize = -1; // TODO why here? not in prepareFinish()?
_keyMapByte = null;
break;
case Message.Content.ByteBuffer:
if (_bufferSize == -1 && buffer.ReadableBytes < Utils.Utils.IntegerByteSize)
{
return false;
}
if (_bufferSize == -1)
{
_bufferSize = buffer.ReadInt();
}
if (_buffer == null)
{
_buffer = new DataBuffer();
}
int already = _buffer.AlreadyTransferred;
int remaining = _bufferSize - already;
// already finished
if (remaining != 0)
{
int read = _buffer.TransferFrom(buffer, remaining);
if (read != remaining)
{
Logger.Debug(
"Still looking for data. Indicating that its not finished yet. Already Transferred = {0}, Size = {1}.",
_buffer.AlreadyTransferred, _bufferSize);
return false;
}
}
ByteBuf buf2 = AlternativeCompositeByteBuf.CompBuffer(_buffer.ToByteBufs());
Message.SetBuffer(new Buffer(buf2, _bufferSize));
LastContent = _contentTypes.Dequeue();
_bufferSize = -1;
_buffer = null;
break;
case Message.Content.SetTrackerData:
if (_trackerDataSize == -1 && buffer.ReadableBytes < Utils.Utils.ByteByteSize)
{
return false;
}
if (_trackerDataSize == -1)
{
_trackerDataSize = buffer.ReadUByte();
}
if (_trackerData == null)
{
_trackerData = new TrackerData(new Dictionary<PeerAddress, Data>(2 * _trackerDataSize));
}
if (_currentTrackerData != null)
{
if (!_currentTrackerData.DecodeBuffer(buffer))
{
return false;
}
if (!_currentTrackerData.DecodeDone(buffer, Message.PublicKey(0), _signatureFactory))
{
return false;
}
_currentTrackerData = null;
}
for (int i = _trackerData.Size; i < _trackerDataSize; i++)
{
if (buffer.ReadableBytes < Utils.Utils.ShortByteSize)
{
return false;
}
int header = buffer.GetUShort(buffer.ReaderIndex);
size = PeerAddress.CalculateSize(header);
if (buffer.ReadableBytes < Utils.Utils.ShortByteSize)
{
return false;
}
var pa = new PeerAddress(buffer);
_currentTrackerData = Data.DeocdeHeader(buffer, _signatureFactory);
if (_currentTrackerData == null)
{
return false;
}
_trackerData.PeerAddresses.Add(pa, _currentTrackerData);
if (Message.IsSign)
{
_currentTrackerData.SetPublicKey(Message.PublicKey(0));
}
if (!_currentTrackerData.DecodeBuffer(buffer))
{
return false;
}
if (!_currentTrackerData.DecodeDone(buffer, Message.PublicKey(0), _signatureFactory))
{
return false;
}
_currentTrackerData = null; // TODO why here?
}
Message.SetTrackerData(_trackerData);
LastContent = _contentTypes.Dequeue();
_trackerDataSize = -1;
_trackerData = null;
break;
case Message.Content.PublicKey: // fall-through
case Message.Content.PublicKeySignature:
receivedPublicKey = _signatureFactory.DecodePublicKey(buffer);
if (content == Message.Content.PublicKeySignature)
{
if (receivedPublicKey == PeerBuilder.EmptyPublicKey) // TODO check if works
{
// TODO throw InvalidKeyException
throw new SystemException("The public key cannot be empty.");
}
}
if (receivedPublicKey == null)
{
return false;
}
Message.SetPublicKey(receivedPublicKey);
LastContent = _contentTypes.Dequeue();
break;
default:
break;
}
}
if (Message.IsSign)
{
var signatureEncode = _signatureFactory.SignatureCodec;
size = signatureEncode.SignatureSize;
if (buffer.ReadableBytes < size)
{
return false;
}
signatureEncode.Read(buffer);
Message.SetReceivedSignature(signatureEncode);
}
return true;
}
public bool Contains(Number640 key)
{
var rangeLock = Lock(key);
try
{
return _backend.Contains(key);
}
finally
{
rangeLock.Unlock();
}
}
private RangeLock <Number640> .Range Lock(Number640 number640)
{
return(RangeLock.Lock(number640, number640));
}
private static void DeletePredecessors(Number640 key, IDictionary<Number640, Data> sortedMap)
{
var toRemove = new List<Number640>();
toRemove.Add(key);
while(toRemove.Count != 0)
{
var version = sortedMap.Remove2(toRemove.RemoveAt2(0));
// check if version has been already deleted
// check if version is initial version
if (version != null && version.BasedOnSet.Count != 0)
{
foreach (var basedOnKey in version.BasedOnSet)
{
toRemove.Add(new Number640(key.LocationAndDomainAndContentKey, basedOnKey));
}
}
}
}
public Enum UpdateMeta(IPublicKey publicKey, Number640 key, Data newData)
{
var rangeLock = Lock(key);
try
{
if (!SecurityEntryCheck(key.LocationAndDomainAndContentKey, publicKey, newData.PublicKey,
newData.IsProtectedEntry))
{
return PutStatus.FailedSecurity;
}
var data = _backend.Get(key);
var changed = false;
if (data != null && newData.PublicKey != null)
{
data.SetPublicKey(newData.PublicKey);
changed = true;
}
if (data != null && newData.IsSigned)
{
data.SetSignature(newData.Signature);
changed = true;
}
if (data != null)
{
data.SetValidFromMillis(newData.ValidFromMillis);
data.SetTtlSeconds(newData.TtlSeconds);
changed = true;
}
if (changed)
{
long expiration = data.ExpirationMillis;
// handle timeout
_backend.AddTimeout(key, expiration);
_backend.Put(key, data);
return PutStatus.Ok;
} else
{
return PutStatus.NotFound;
}
}
finally
{
rangeLock.Unlock();
}
}
private bool IsEmpty(Number160 locationKey)
{
var from = new Number640(locationKey, Number160.Zero, Number160.Zero, Number160.Zero);
var to = new Number640(locationKey, Number160.MaxValue, Number160.MaxValue, Number160.MaxValue);
var tmp = _backend.SubMap(from, to, 1, false);
return tmp.Count == 0;
}
/// <summary>
/// Stores a key and the hash of the content for further processing.
/// </summary>
/// <param name="key">The key of the content.</param>
/// <param name="basedOnSet">The hash of the content.</param>
public void Put(Number640 key, ICollection <Number160> basedOnSet)
{
_mapDigests.Add(key, basedOnSet);
}
public Enum PutConfirm(IPublicKey publicKey, Number640 key, Data newData)
{
var rangeLock = Lock(key);
try
{
if (!SecurityEntryCheck(key.LocationAndDomainAndContentKey, publicKey, newData.PublicKey, newData.IsProtectedEntry))
{
return PutStatus.FailedSecurity;
}
var data = _backend.Get(key);
if (data != null)
{
// remove prepare flag
data.SetHasPreparaFlag(false);
data.SetValidFromMillis(newData.ValidFromMillis);
data.SetTtlSeconds(newData.TtlSeconds);
var expiration = data.ExpirationMillis;
// handle timeout
_backend.AddTimeout(key, expiration);
_backend.Put(key, data);
return PutStatus.Ok;
} else {
return PutStatus.NotFound;
}
}
finally
{
rangeLock.Unlock();
}
// TODO: Java: check for FORKS!
}
public RemoveBuilder SetFrom(Number640 from)
{
DomainKey = from.DomainKey;
From = from;
return(this);
}
public RemoveBuilder SetTo(Number640 to)
{
DomainKey = to.DomainKey;
To = to;
return(this);
}
/// <summary>
/// Looks for a route to the given peer address.
/// </summary>
/// <param name="peerAddresses">Nodes that should be asked first for a route.</param>
/// <param name="routingBuilder"></param>
/// <param name="type"></param>
/// <param name="cc"></param>
/// <returns>A task object that is set to complete if the route has been found.</returns>
private TcsRouting Routing(ICollection <PeerAddress> peerAddresses, RoutingBuilder routingBuilder,
Message.Message.MessageType type, ChannelCreator cc)
{
try
{
if (peerAddresses == null)
{
throw new ArgumentException("Some nodes/addresses need to be specified.");
}
bool randomSearch = routingBuilder.LocationKey == null;
IComparer <PeerAddress> comparer;
if (randomSearch)
{
comparer = _peerBean.PeerMap.CreateComparer();
}
else
{
comparer = PeerMap.CreateComparer(routingBuilder.LocationKey);
}
var queueToAsk = new SortedSet <PeerAddress>(comparer);
var alreadyAsked = new SortedSet <PeerAddress>(comparer);
// As presented by Kazuyuki Shudo at AIMS 2009, it is better to ask random
// peers with the data than ask peers that are ordered by distance.
// -> this balances load
var directHits = new SortedDictionary <PeerAddress, DigestInfo>(comparer);
var potentialHits = new SortedSet <PeerAddress>(comparer);
// fill initially
queueToAsk.AddAll(peerAddresses);
alreadyAsked.Add(_peerBean.ServerPeerAddress);
potentialHits.Add(_peerBean.ServerPeerAddress);
// domain key can be null if we bootstrap
if (type == Message.Message.MessageType.Request2 &&
routingBuilder.DomainKey != null &&
!randomSearch &&
_peerBean.DigestStorage != null)
{
Number640 from;
Number640 to;
if (routingBuilder.From != null && routingBuilder.To != null)
{
from = routingBuilder.From;
to = routingBuilder.To;
}
else if (routingBuilder.ContentKey == null)
{
from = new Number640(routingBuilder.LocationKey, routingBuilder.DomainKey, Number160.Zero, Number160.Zero);
to = new Number640(routingBuilder.LocationKey, routingBuilder.DomainKey, Number160.MaxValue, Number160.MaxValue);
}
else
{
from = new Number640(routingBuilder.LocationKey, routingBuilder.DomainKey, routingBuilder.ContentKey, Number160.Zero);
to = new Number640(routingBuilder.LocationKey, routingBuilder.DomainKey, routingBuilder.ContentKey, Number160.MaxValue);
}
var digestBean = _peerBean.DigestStorage.Digest(from, to, -1, true);
if (digestBean.Size > 0)
{
directHits.Add(_peerBean.ServerPeerAddress, digestBean);
}
}
else if (type == Message.Message.MessageType.Request3 &&
!randomSearch &&
_peerBean.DigestTracker != null)
{
var digestInfo = _peerBean.DigestTracker.Digest(routingBuilder.LocationKey, routingBuilder.DomainKey,
routingBuilder.ContentKey);
// we always put ourselfs to the tracker list, so we need to check
// if we know also other peers on our trackers
if (digestInfo.Size > 0)
{
directHits.Add(_peerBean.ServerPeerAddress, digestInfo);
}
}
var tcsRouting = new TcsRouting();
if (peerAddresses.Count == 0)
{
tcsRouting.SetNeighbors(directHits, potentialHits, alreadyAsked, routingBuilder.IsBootstrap, false);
}
else
{
// If a peer bootstraps to itself, then the size of peer addresses is 1
// and it contains itself. Check for that because we need to know if we
// are routing, bootstrapping and bootstrapping to ourselfs, to return
// the correct status for the task.
var isRoutingOnlyToSelf = peerAddresses.Count == 1 &&
peerAddresses.First().Equals(_peerBean.ServerPeerAddress);
var routingMechanism = routingBuilder.CreateRoutingMechanism(tcsRouting);
routingMechanism.SetQueueToAsk(queueToAsk);
routingMechanism.SetPotentialHits(potentialHits);
routingMechanism.SetDirectHits(directHits);
routingMechanism.SetAlreadyAsked(alreadyAsked);
routingBuilder.SetIsRoutingOnlyToSelf(isRoutingOnlyToSelf);
RoutingRec(routingBuilder, routingMechanism, type, cc);
}
return(tcsRouting);
}
catch (Exception ex)
{
Logger.Error("An exception occurred during routing.", ex);
throw;
}
}
public void SetRange(Number640 from, Number640 to)
{
From = from;
To = to;
}
