public static IIndexWorkflowQueue GetIndexWorkflowQueueFromGrainHashCode(SiloIndexManager siloIndexManager, Type grainInterfaceType, int grainHashCode, SiloAddress siloAddress)
{
int queueSeqNum = StorageProviderUtils.PositiveHash(grainHashCode, siloIndexManager.NumWorkflowQueuesPerInterface);
var grainReference = CreateGrainServiceGrainReference(siloIndexManager, grainInterfaceType, queueSeqNum, siloAddress);
return(siloIndexManager.GetGrainService <IIndexWorkflowQueue>(grainReference));
}
internal IndexWorkflowQueueGrainService(SiloIndexManager siloIndexManager, Type grainInterfaceType, int queueSequenceNumber, bool isDefinedAsFaultTolerantGrain)
: base(IndexWorkflowQueueBase.CreateIndexWorkflowQueueGrainReference(siloIndexManager, grainInterfaceType, queueSequenceNumber, siloIndexManager.SiloAddress).GrainIdentity,
siloIndexManager.Silo, siloIndexManager.LoggerFactory)
{
_base = new IndexWorkflowQueueBase(siloIndexManager, grainInterfaceType, queueSequenceNumber, siloIndexManager.SiloAddress, isDefinedAsFaultTolerantGrain,
() => base.GetGrainReference()); // lazy is needed because the runtime isn't attached until Registered
}
internal static async Task RegisterIndexWorkflowQueues(SiloIndexManager sim, Type grainInterfaceType, Type grainClassType, bool isFaultTolerant)
{
for (int i = 0; i < sim.NumWorkflowQueuesPerInterface; ++i)
{
await sim.Silo.AddGrainService(new IndexWorkflowQueueGrainService(sim, grainInterfaceType, i, isFaultTolerant));
await sim.Silo.AddGrainService(new IndexWorkflowQueueHandlerGrainService(sim, grainInterfaceType, i, isFaultTolerant));
}
}
internal static async Task RegisterIndexWorkflowQueues(SiloIndexManager siloIndexManager, Type iGrainType, Type grainImplType)
{
for (int i = 0; i < IndexWorkflowQueueBase.NUM_AVAILABLE_INDEX_WORKFLOW_QUEUES; ++i)
{
bool isAssignable = typeof(IIndexableGrainFaultTolerant).IsAssignableFrom(grainImplType);
await siloIndexManager.Silo.AddGrainService(new IndexWorkflowQueueGrainService(siloIndexManager, iGrainType, i, isAssignable));
await siloIndexManager.Silo.AddGrainService(new IndexWorkflowQueueHandlerGrainService(siloIndexManager, iGrainType, i, isAssignable));
}
}
public ActiveHashIndexPartitionedPerSiloBucketImplGrainService(SiloIndexManager siloIndexManager, Type grainInterfaceType, string parentIndexName)
: base(GetGrainIdentity(siloIndexManager, grainInterfaceType, parentIndexName), siloIndexManager.Silo, siloIndexManager.LoggerFactory)
{
this.state = new HashIndexBucketState <K, V>
{
IndexMap = new Dictionary <K, HashIndexSingleBucketEntry <V> >(),
IndexStatus = IndexStatus.Available
};
_parentIndexName = parentIndexName;
this.siloIndexManager = siloIndexManager;
this.logger = siloIndexManager.LoggerFactory.CreateLoggerWithFullCategoryName <ActiveHashIndexPartitionedPerSiloBucketImplGrainService>();
}
internal IndexWorkflowQueueHandlerBase(SiloIndexManager siloIndexManager, Type grainInterfaceType, int queueSeqNum, SiloAddress silo,
bool isDefinedAsFaultTolerantGrain, Func <GrainReference> parentFunc)
{
_grainInterfaceType = grainInterfaceType;
_queueSeqNum = queueSeqNum;
_isDefinedAsFaultTolerantGrain = isDefinedAsFaultTolerantGrain;
_hasAnyTotalIndex = false;
__grainIndexes = null;
__workflowQueue = null;
_silo = silo;
_siloIndexManager = siloIndexManager;
_lazyParent = new Lazy <GrainReference>(parentFunc, true);
}
public ActiveHashIndexPartitionedPerSiloBucketImplGrainService(SiloIndexManager siloIndexManager, string parentIndexName, GrainReference grainReference)
: base(grainReference.GrainIdentity, siloIndexManager.Silo, siloIndexManager.LoggerFactory)
{
state = new HashIndexBucketState <K, V>
{
IndexMap = new Dictionary <K, HashIndexSingleBucketEntry <V> >(),
IndexStatus = IndexStatus.Available
//, IsUnique = false; //a per-silo index cannot check for uniqueness
};
_parentIndexName = parentIndexName;
this.siloIndexManager = siloIndexManager;
this.logger = siloIndexManager.LoggerFactory.CreateLoggerWithFullCategoryName <ActiveHashIndexPartitionedPerSiloBucketImplGrainService>();
}
/// <summary>
/// An extension method to intercept the calls to DirectApplyIndexUpdate on an Index,
/// so that for a PerSilo index, it can obtain the GrainService of that index on the silo of the indexed grain.
/// </summary>
internal static Task <bool> ApplyIndexUpdate(this IIndexInterface index, SiloIndexManager siloIndexManager,
IIndexableGrain updatedGrain, Immutable <IMemberUpdate> update,
IndexMetaData idxMetaData, SiloAddress siloAddress = null)
{
if (index is IActiveHashIndexPartitionedPerSilo)
{
var bucketInCurrentSilo = siloIndexManager.GetGrainService <IActiveHashIndexPartitionedPerSiloBucket>(
GetAHashIndexPartitionedPerSiloGrainReference(siloIndexManager,
IndexUtils.GetIndexNameFromIndexGrain((IAddressable)index), index.GetType().GetGenericArguments()[1],
siloAddress
));
return(bucketInCurrentSilo.DirectApplyIndexUpdate(updatedGrain, update, idxMetaData.IsUniqueIndex, idxMetaData /*, siloAddress*/));
}
return(index.DirectApplyIndexUpdate(updatedGrain, update, idxMetaData.IsUniqueIndex, idxMetaData, siloAddress));
}
internal IndexWorkflowQueueBase(SiloIndexManager siloIndexManager, Type grainInterfaceType, int queueSequenceNumber, SiloAddress silo,
bool isDefinedAsFaultTolerantGrain, Func <GrainReference> parentFunc)
{
queueState = new IndexWorkflowQueueState(silo);
_grainInterfaceType = grainInterfaceType;
_queueSeqNum = queueSequenceNumber;
_workflowRecordsTail = null;
__grainStorage = null;
__handler = null;
_isHandlerWorkerIdle = 1;
_isDefinedAsFaultTolerantGrain = isDefinedAsFaultTolerantGrain;
_writeLock = new AsyncLock();
_writeRequestIdGen = 0;
_pendingWriteRequests = new HashSet <int>();
_silo = silo;
SiloIndexManager = siloIndexManager;
_lazyParent = new Lazy <GrainReference>(parentFunc, true);
}
internal IndexWorkflowQueueBase(SiloIndexManager siloIndexManager, Type grainInterfaceType, int queueSequenceNumber, SiloAddress silo,
bool isDefinedAsFaultTolerantGrain, Func <GrainReference> parentFunc, GrainReference recoveryGrainReference = null)
{
queueState = new IndexWorkflowQueueState();
_grainInterfaceType = grainInterfaceType;
_queueSeqNum = queueSequenceNumber;
_grainTypeName = "Orleans.Indexing.IndexWorkflowQueue-" + IndexUtils.GetFullTypeName(_grainInterfaceType);
_workflowRecordsTail = null;
__handler = null;
_isHandlerWorkerIdle = 1;
_isDefinedAsFaultTolerantGrain = isDefinedAsFaultTolerantGrain;
this._recoveryGrainReference = recoveryGrainReference;
_writeLock = new AsyncLock();
_writeRequestIdGen = 0;
_pendingWriteRequests = new HashSet <int>();
_silo = silo;
SiloIndexManager = siloIndexManager;
_lazyParent = new Lazy <GrainReference>(parentFunc, true);
}
private static GrainReference GetAHashIndexPartitionedPerSiloGrainReference(SiloIndexManager siloIndexManager, string indexName, Type grainInterfaceType, SiloAddress siloAddress)
=> siloIndexManager.MakeGrainServiceGrainReference(IndexingConstants.HASH_INDEX_PARTITIONED_PER_SILO_BUCKET_GRAIN_SERVICE_TYPE_CODE,
IndexUtils.GetIndexGrainPrimaryKey(grainInterfaceType, indexName), siloAddress);
private static GrainReference GetGrainReference(SiloIndexManager siloIndexManager, string indexName, SiloAddress siloAddress = null) => ActiveHashIndexPartitionedPerSiloBucketImplGrainService.GetGrainReference(siloIndexManager, typeof(V), indexName, siloAddress);
internal static SiloIndexManager GetSiloIndexManager(ref SiloIndexManager siloIndexManager, IServiceProvider serviceProvider) => siloIndexManager ?? (siloIndexManager = GetSiloIndexManager(serviceProvider));
/// <summary> /// This method extends GrainFactory by adding a new GetGrain method to it that can get the runtime type of the grain interface along /// with its primary key, and return the grain casted to an interface that the given grainInterfaceType extends it. /// /// The main use-case is when you want to get a grain whose type is unknown at compile time, and also SuperOutputGrainInterfaceType /// is non-generic, while outputGrainInterfaceType is a generic type. /// </summary> /// <param name="siloIndexManager">the Index manager for this silo</param> /// <param name="grainPrimaryKey">the primary key of the grain</param> /// <param name="grainInterfaceType">the runtime type of the grain interface</param> /// <param name="outputGrainInterfaceType">the type of grain interface that should be returned</param> /// <returns></returns> public static IGrain GetGrain(this SiloIndexManager siloIndexManager, string grainPrimaryKey, Type grainInterfaceType, Type outputGrainInterfaceType) => siloIndexManager.GetGrain(grainPrimaryKey, grainInterfaceType, outputGrainInterfaceType);
/// <summary>
/// Converts this grain to the grain interface identified by grainInterfaceType.
///
/// Finally, it casts it to the type provided as TGrainInterface. The caller should make sure that grainInterfaceType extends TGrainInterface.
/// </summary>
/// <typeparam name="TGrainInterface">output grain interface type, which grainInterfaceType extends it</typeparam>
/// <param name="grain">the target grain to be casted</param>
/// <param name="siloIndexManager">the Index manager for this silo</param>
/// <param name="grainInterfaceType">the grain implementation type</param>
/// <returns>A strongly typed <c>GrainReference</c> of grain interface type <paramref name="grainInterfaceType"/> cast to TGrainInterface.</returns>
/// <returns></returns>
internal static TGrainInterface AsReference <TGrainInterface>(this IAddressable grain, SiloIndexManager siloIndexManager, Type grainInterfaceType) where TGrainInterface : IGrain
=> (grain != null)
? (TGrainInterface)siloIndexManager.GrainReferenceRuntime.Convert(grain.AsWeaklyTypedReference(), grainInterfaceType)
: throw new ArgumentNullException("grain", "Cannot pass null as an argument to AsReference");
internal ApplicationPartsIndexableGrainLoader(IndexManager indexManager)
{
this.indexManager = indexManager;
this.siloIndexManager = indexManager as SiloIndexManager;
this.logger = this.indexManager.LoggerFactory.CreateLoggerWithFullCategoryName <ApplicationPartsIndexableGrainLoader>();
}
public static GrainReference CreateIndexWorkflowQueueGrainReference(SiloIndexManager siloIndexManager, Type grainInterfaceType, int queueSeqNum, SiloAddress siloAddress) => CreateGrainServiceGrainReference(siloIndexManager, grainInterfaceType, queueSeqNum, siloAddress);
public IndexFactory(IndexManager im, IGrainFactory gf)
{
this.indexManager = im;
this.siloIndexManager = im as SiloIndexManager;
this.grainFactory = gf;
}
public static GrainReference CreateIndexWorkflowQueueHandlerGrainReference(SiloIndexManager siloIndexManager, Type grainInterfaceType, int queueSeqNum, SiloAddress siloAddress)
=> siloIndexManager.MakeGrainServiceGrainReference(IndexingConstants.INDEX_WORKFLOW_QUEUE_HANDLER_GRAIN_SERVICE_TYPE_CODE,
IndexWorkflowQueueBase.CreateIndexWorkflowQueuePrimaryKey(grainInterfaceType, queueSeqNum), siloAddress);
private static IGrainIdentity GetGrainIdentity(SiloIndexManager siloIndexManager, Type grainInterfaceType, string indexName) => GetGrainReference(siloIndexManager, grainInterfaceType, indexName).GrainIdentity;
/// <summary>
/// Converts this grain to a specific grain interface.
/// </summary>
/// <typeparam name="TGrainInterface">The type of the grain interface.</typeparam>
/// <param name="grain">The grain to convert.</param>
/// <param name="siloIndexManager">the Index manager for this silo</param>
/// <returns>A strongly typed <c>GrainReference</c> of grain interface type TGrainInterface.</returns>
internal static TGrainInterface AsReference <TGrainInterface>(this IAddressable grain, SiloIndexManager siloIndexManager) where TGrainInterface : IGrain
=> (grain != null)
? grain.Cast <TGrainInterface>()
: throw new ArgumentNullException("grain", "Cannot pass null as an argument to AsReference");
internal static Task InitPerSilo(SiloIndexManager siloIndexManager, string indexName, bool isUnique) => siloIndexManager.Silo.AddGrainService(new ActiveHashIndexPartitionedPerSiloBucketImplGrainService(siloIndexManager, indexName, GetGrainReference(siloIndexManager, indexName)));
private static GrainReference GetGrainReference(SiloIndexManager siloIndexManager, string indexName, SiloAddress siloAddress = null)
=> siloIndexManager.MakeGrainServiceGrainReference(IndexingConstants.HASH_INDEX_PARTITIONED_PER_SILO_BUCKET_GRAIN_SERVICE_TYPE_CODE,
IndexUtils.GetIndexGrainPrimaryKey(typeof(V), indexName), siloAddress ?? siloIndexManager.SiloAddress);
/// <summary>
/// This method extends GrainFactory by adding a new GetGrain method to it that can get the runtime type of the grain interface along
/// with its primary key, and return the grain casted to an interface that the given grainInterfaceType extends it.
///
/// The main use-case is when you want to get a grain whose type is unknown at compile time.
/// </summary>
/// <typeparam name="OutputGrainInterfaceType">The output type of the grain</typeparam>
/// <param name="siloIndexManager">the Index manager for this silo</param>
/// <param name="grainPrimaryKey">the primary key of the grain</param>
/// <param name="grainInterfaceType">the runtime type of the grain interface</param>
/// <returns>the requested grain with the given grainID and grainInterfaceType</returns>
public static OutputGrainInterfaceType GetGrain <OutputGrainInterfaceType>(this SiloIndexManager siloIndexManager, Guid grainPrimaryKey, Type grainInterfaceType)
where OutputGrainInterfaceType : IGrain
=> siloIndexManager.GetGrain <OutputGrainInterfaceType>(grainPrimaryKey, grainInterfaceType);