public async Task Retrieve(IEnumerable <byte[]> keys, RetrieveCallback cb)
{
var shardCount = await GetShardCount();
var servers = await GetShardServers();
if (servers == null)
{
await RetrieveEntities(keys.Select(m => new ScalableEntity(m, null).SetPartition(shardCount)), cb);
}
else
{
bool running = true;
var shards = keys.Select(m => new ScalableEntity(m, null).SetPartition(shardCount)).ToLookup(m => m.Partition);
List <Task> pending = new List <Task>();
foreach (var shard in shards)
{
pending.Add(servers[shard.Key].RetrieveEntities(shard, m => {
if (!running)
{
return(false);
}
if (!cb(m))
{
running = false;
return(false);
}
return(true);
}));
}
await Task.WhenAll(pending);
}
}
protected override Task RetrieveRange(byte[] start, byte[] end, RetrieveCallback cb)
{
AzureOperationHandle rangeRetrieve = new AzureOperationHandle(null, OpType.RangeRetrieve)
{
StartRange = start, EndRange = end, callback = cb
};
lock (evt)
{
if (!pendingOperations.ContainsKey(0))
{
pendingOperations.Add(0, new List <AzureOperationHandle>());
}
pendingOperations[0].Add(rangeRetrieve);
evt.Set();
}
return(rangeRetrieve.Task.Task);
}
public async Task Retrieve(byte[] start, byte[] end, RetrieveCallback cb)
{
var shardCount = await GetShardCount();
var servers = await GetShardServers();
if (servers == null)
{
await RetrieveRange(start, end, cb);
}
else
{
bool running = true;
int a = 0;
int b = (int)shardCount;
if (start != null)
{
a = (int)(start.LinearHash() % shardCount);
}
if (end != null)
{
b = (int)(end.LinearHash() % shardCount) + 1;
}
List <Task> pending = new List <Task>();
for (int i = a; i < b; i++)
{
pending.Add(servers[i].RetrieveRange(start, end, m => {
if (!running)
{
return(false);
}
if (!cb(m))
{
running = false;
return(false);
}
return(true);
}));
}
await Task.WhenAll(pending);
}
}
protected override Task RetrieveRange(byte[] start, byte[] end, RetrieveCallback cb)
{
TaskCompletionSource <bool> tsktsktsktsk = new TaskCompletionSource <bool>();
List <ScalableEntity> entities = new List <ScalableEntity>();
lock (db)
{
int startIdx = 0;
if (start != null)
{
int found = Array.BinarySearch(index, start, new ByteComparer());
if (found < 0)
{
startIdx = ~found;
}
else
{
startIdx = found + 1; //exclusive search
}
}
for (int i = startIdx; i < indexLen; i++)
{
byte[] key = index[i];
if (end != null)
{
if (ByteComparer.instance.Compare(key, end) >= 0)
{
break;
}
}
entities.Add(new ScalableEntity(key, db[key]));
}
}
cb(entities);
tsktsktsktsk.SetResult(true);
return(tsktsktsktsk.Task);
}
protected override Task RetrieveEntities(IEnumerable <ScalableEntity> entities, RetrieveCallback cb)
{
throw new NotImplementedException();
}
protected override Task RetrieveRange(byte[] start, byte[] end, RetrieveCallback cb)
{
throw new NotImplementedException();
}
protected override Task RetrieveEntities(IEnumerable <ScalableEntity> entities, RetrieveCallback cb)
{
TaskCompletionSource <bool> src = new TaskCompletionSource <bool>();
List <ScalableEntity> retval = new List <ScalableEntity>();
lock (db)
{
foreach (var iable in entities)
{
if (db.ContainsKey(iable.Key))
{
var found = db[iable.Key];
byte[] newkey = new byte[iable.Key.Length];
byte[] newvalue = new byte[found.Length];
Buffer.BlockCopy(iable.Key, 0, newkey, 0, newkey.Length);
Buffer.BlockCopy(found, 0, newvalue, 0, newvalue.Length);
retval.Add(new ScalableEntity(newkey, newvalue));
}
}
}
if (retval.Any())
{
cb(retval);
}
src.SetResult(true);
return(src.Task);
}
protected abstract Task RetrieveRange(byte[] start, byte[] end, RetrieveCallback cb);
protected abstract Task RetrieveEntities(IEnumerable <ScalableEntity> entities, RetrieveCallback cb);
protected override async Task RetrieveEntities(IEnumerable <ScalableEntity> entities, RetrieveCallback cb)
{
List <AzureOperationHandle> ops = null;
ops = entities.Select(m => new AzureOperationHandle(m.SetPartition(optimal_shard_size), OpType.Retrieve)
{
callback = cb
}).ToList();
lock (evt)
{
foreach (var iable in ops)
{
if (!pendingOperations.ContainsKey(iable.Entity.Partition))
{
pendingOperations.Add(iable.Entity.Partition, new List <AzureOperationHandle>());
}
pendingOperations[iable.Entity.Partition].Add(iable);
}
evt.Set();
}
await Task.WhenAll(ops.Select(m => m.Task.Task));
}
