public async Task Lookup(IOrleansQueryResultStream <V> result, K key)
{
this.Logger.Trace($"Streamed index lookup called for key = {key}");
if (!(this.State.IndexStatus == IndexStatus.Available))
{
throw LogException("Index is not still available", IndexingErrorCode.IndexingIndexIsNotReadyYet_GrainBucket1);
}
if (this.State.IndexMap.TryGetValue(key, out HashIndexSingleBucketEntry <V> entry))
{
if (!entry.IsTentative)
{
await result.OnNextBatchAsync(entry.Values);
}
await result.OnCompletedAsync();
}
else if (this.State.NextBucket != null)
{
await GetNextBucket().Lookup(result, key);
}
else
{
await result.OnCompletedAsync();
}
}
public async Task Lookup(IOrleansQueryResultStream <V> result, K key)
{
if (getLogger().IsVerbose)
{
getLogger().Verbose("Streamed index lookup called for key = {0}", key);
}
if (!(State.IndexStatus == IndexStatus.Available))
{
var e = new Exception(string.Format("Index is not still available."));
GetLogger().Error((int)ErrorCode.IndexingIndexIsNotReadyYet_GrainBucket1, "Index is not still available.", e);
throw e;
}
HashIndexSingleBucketEntry <V> entry;
if (State.IndexMap.TryGetValue(key, out entry) && !entry.isTentative())
{
await result.OnNextBatchAsync(entry.Values);
await result.OnCompletedAsync();
}
else if (State.NextBucket != null)
{
await GetNextBucket().Lookup(result, key);
}
else
{
await result.OnCompletedAsync();
}
}
async Task IndexInterface.Lookup(IOrleansQueryResultStream <IIndexableGrain> result, object key)
{
if (logger.IsVerbose)
{
logger.Verbose("Streamed index lookup called for key = {0}", key);
}
//get all silos
Dictionary <SiloAddress, SiloStatus> hosts = await SiloUtils.GetHosts(true);
ISet <Task <IOrleansQueryResult <IIndexableGrain> > > queriesToSilos = GetResultQueries(hosts, key);
//TODO: After fixing the problem with OrleansStream, this part is not needed anymore
while (queriesToSilos.Count > 0)
{
// Identify the first task that completes.
Task <IOrleansQueryResult <IIndexableGrain> > firstFinishedTask = await Task.WhenAny(queriesToSilos);
// ***Remove the selected task from the list so that you don't
// process it more than once.
queriesToSilos.Remove(firstFinishedTask);
// Await the completed task.
IOrleansQueryResult <IIndexableGrain> partialResult = await firstFinishedTask;
await result.OnNextBatchAsync(partialResult);
}
await result.OnCompletedAsync();
}
=> Task.FromResult(true); // The index is maintained by the underlying _grainStorage, when the grain's WriteStateAsync is called
public async Task Lookup(IOrleansQueryResultStream <V> result, K key)
{
var res = await LookupGrainReferences(key);
await result.OnNextBatchAsync(res);
await result.OnCompletedAsync();
}
public Task Lookup(IOrleansQueryResultStream <V> result, K key)
{
logger.Trace($"Streamed index lookup called for key = {key}");
BucketT targetBucket = GetGrain(IndexUtils.GetIndexGrainPrimaryKey(typeof(V), this._indexName) + "_" + GetBucketIndexFromHashCode(key));
return(targetBucket.Lookup(result, key));
}
public Task Lookup(IOrleansQueryResultStream <V> result, K key)
{
logger.Trace($"Streamed index lookup called for key = {key}");
var keyHash = GetBucketIndexFromHashCode(key);
BucketT targetBucket = this.GetBucketGrain(keyHash);
return(targetBucket.Lookup(result, key));
}
public Task LookupAsync(IOrleansQueryResultStream <V> result, K key)
{
logger.Trace($"Streamed index lookup called for key = {key}");
var keyHash = GetBucketIndexFromHashCode(key);
BucketT targetBucket = this.GetBucketGrain(keyHash);
return(isTransactional ? ((ITransactionalLookupIndex <K, V>)targetBucket).LookupTransactionalAsync(result, key)
: targetBucket.LookupAsync(result, key));
}
public Task Lookup(IOrleansQueryResultStream <V> result, K key)
{
if (logger.IsVerbose)
{
logger.Verbose("Streamed index lookup called for key = {0}", key);
}
BucketT targetBucket = RuntimeClient.Current.InternalGrainFactory.GetGrain <BucketT>(
IndexUtils.GetIndexGrainID(typeof(V), _indexName) + "_" + key.GetHashCode()
);
return(targetBucket.Lookup(result, key));
}
public async Task LookupAsync(IOrleansQueryResultStream <V> result, K key)
{
logger.Trace($"Streamed index lookup called for key = {key}");
if (!(state.IndexStatus == IndexStatus.Available))
{
throw LogException($"ParentIndex {_parentIndexName}: Index is not still available.", IndexingErrorCode.IndexingIndexIsNotReadyYet_GrainServiceBucket1);
}
if (state.IndexMap.TryGetValue(key, out HashIndexSingleBucketEntry <V> entry) && !entry.IsTentative)
{
await result.OnNextAsync(entry.Values.ToBatch());
await result.OnCompletedAsync();
}
else
{
await result.OnCompletedAsync();
}
}
// Accept a queryResult instance which we shall observe public OrleansQueryResultStreamCaster(IOrleansQueryResultStream <FromTP> stream) => this._stream = stream;
public Task LookupAsync(IOrleansQueryResultStream <V> result, K key) => ((IIndexInterface)this).LookupAsync(result.Cast <IIndexableGrain>(), key);
Task IndexInterface.Lookup(IOrleansQueryResultStream <IIndexableGrain> result, object key)
{
return(Lookup(result.Cast <V>(), (K)key));
}
public Task Lookup(IOrleansQueryResultStream <V> result, K key)
{
return(((IndexInterface)this).Lookup(result.Cast <IIndexableGrain>(), key));
}
public Task LookupTransactionalAsync(IOrleansQueryResultStream <IIndexableGrain> result, object key) => ((IIndexInterface <K, V>) this).LookupAsync(result, key);
public Task LookupTransactionalAsync(IOrleansQueryResultStream <V> result, K key) => this.LookupAsync(result, key);
Task IIndexInterface.LookupAsync(IOrleansQueryResultStream <IIndexableGrain> result, object key) => this.LookupAsync(result.Cast <V>(), (K)key);
