public async Task <IEnumerable <IGrain> > GetActiveGrains(Type grainType) { string grainTypeName = TypeCodeMapper.GetImplementation(grainType).GrainClass; IEnumerable <Tuple <GrainId, string, int> > activeGrainList = await GetGrainActivations(); IEnumerable <IGrain> filteredList = activeGrainList.Where(s => s.Item2.Equals(grainTypeName)).Select(s => GrainFactory.GetGrain <IIndexableGrain>(s.Item1.GetPrimaryKey(), grainType)); return(filteredList.ToList()); }
public static async Task <IEnumerable <T> > GetActiveGrains <T>(IGrainFactory gf, params SiloAddress[] hostsIds) where T : IGrain { string grainTypeName = TypeCodeMapper.GetImplementation(typeof(T)).GrainClass; IEnumerable <Tuple <GrainId, string, int> > activeGrainList = await GetGrainActivations(hostsIds); IEnumerable <T> filteredList = activeGrainList.Where(s => s.Item2.Equals(grainTypeName)).Select(s => gf.GetGrain <T>(s.Item1.GetPrimaryKey(), typeof(T))); return(filteredList.ToList()); }
/// <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 that its type /// is unknown at compile time, and also SuperOutputGrainInterfaceType /// is non-generic, while outputGrainInterfaceType is a generic type. /// </summary> /// <typeparam name="SuperOutputGrainInterfaceType">The output type of /// the grain</typeparam> /// <param name="gf">the grainFactory instance that this method /// is extending its functionality</param> /// <param name="grainID">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 IGrainFactory gf, string grainID, Type grainInterfaceType, Type outputGrainInterfaceType) { Type interfaceType = grainInterfaceType; GrainClassData implementation; var grainTypeResolver = RuntimeClient.Current.GrainTypeResolver; grainTypeResolver.TryGetGrainClassData(interfaceType, out implementation, ""); var grainId = TypeCodeMapper.ComposeGrainId(implementation, grainID, interfaceType); return((IGrain)((GrainFactory)gf).Cast(((GrainFactory)gf).MakeGrainReferenceFromType(interfaceType, grainId), outputGrainInterfaceType)); }
/// <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 that its type /// is unknown at compile time. /// </summary> /// <typeparam name="OutputGrainInterfaceType">The output type of /// the grain</typeparam> /// <param name="gf">the grainFactory instance that this method /// is extending its functionality</param> /// <param name="grainID">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 IGrainFactory gf, Guid grainID, Type grainInterfaceType) where OutputGrainInterfaceType : IGrain { Type interfaceType = grainInterfaceType; GrainClassData implementation; var grainTypeResolver = RuntimeClient.Current.GrainTypeResolver; grainTypeResolver.TryGetGrainClassData(interfaceType, out implementation, ""); var grainId = TypeCodeMapper.ComposeGrainId(implementation, grainID, interfaceType); return(((GrainFactory)gf).Cast <OutputGrainInterfaceType>(((GrainFactory)gf).MakeGrainReferenceFromType(interfaceType, grainId))); }
private void EnsureStorageProvider() { if (_storageProvider == null) { var implementation = TypeCodeMapper.GetImplementation(typeof(V)); Type implType; if (implementation == null || (grainImplClass = implementation.GrainClass) == null || !TypeUtils.TryResolveType(grainImplClass, out implType)) { throw new Exception("The grain implementation class " + implementation.GrainClass + " for grain interface " + TypeUtils.GetFullName(typeof(V)) + " was not resolved."); } _storageProvider = InsideRuntimeClient.Current.Catalog.SetupStorageProvider(implType); } }
private void EnsureGrainStorage() { if (_grainStorage == null) { var implementation = TypeCodeMapper.GetImplementation(this.SiloIndexManager.GrainTypeResolver, typeof(V)); if (implementation == null || (_grainClassName = implementation.GrainClass) == null || !this.SiloIndexManager.CachedTypeResolver.TryResolveType(_grainClassName, out Type grainClassType)) { throw new IndexException($"The grain implementation class {implementation.GrainClass} for grain" + " interface {IndexUtils.GetFullTypeName(typeof(V))} was not resolved."); } _grainStorage = grainClassType.GetGrainStorage(this.SiloIndexManager.ServiceProvider); } }
private void EnsureGrainStorage() { if (_grainStorage == null) { var implementation = TypeCodeMapper.GetImplementation(this.SiloIndexManager.GrainTypeResolver, typeof(V)); if (implementation == null || (grainImplClass = implementation.GrainClass) == null || !this.SiloIndexManager.CachedTypeResolver.TryResolveType(grainImplClass, out Type implType)) { throw new IndexException($"The grain implementation class {implementation.GrainClass} for grain" + " interface {IndexUtils.GetFullTypeName(typeof(V))} was not resolved."); } _grainStorage = implType.GetGrainStorage(this.SiloIndexManager.ServiceProvider); bool isFaultTolerant = ApplicationPartsIndexableGrainLoader.IsSubclassOfRawGenericType(typeof(IndexableGrain <,>), implType); _indexedFieldPrefix = isFaultTolerant ? "UserState." : string.Empty; } }
/// <summary> /// This is a helper method for creating an index on a field of an actor. /// </summary> /// <param name="gf">The current instance of IGrainFactory</param> /// <param name="idxType">The type of index to be created</param> /// <param name="indexName">The index name to be created</param> /// <param name="isUniqueIndex">Determines whether this is a unique index that needs to be created</param> /// <param name="isEager">Determines whether updates to this index should be applied eagerly or not</param> /// <param name="maxEntriesPerBucket">Determines the maximum number of entries in /// each bucket of a distributed index, if this index type is a distributed one.</param> /// <param name="indexedProperty">the PropertyInfo object for the indexed field. /// This object helps in creating a default instance of IndexUpdateGenerator.</param> /// <returns>A triple that consists of: /// 1) the index object (that implements IndexInterface /// 2) the IndexMetaData object for this index, and /// 3) the IndexUpdateGenerator instance for this index. /// This triple is untyped, because IndexInterface, IndexMetaData /// and IndexUpdateGenerator types are not visible in the core project.</returns> internal static Tuple <object, object, object> CreateIndex(this IGrainFactory gf, Type idxType, string indexName, bool isUniqueIndex, bool isEager, int maxEntriesPerBucket, PropertyInfo indexedProperty) { Type iIndexType = idxType.GetGenericType(typeof(IndexInterface <,>)); if (iIndexType != null) { Type[] indexTypeArgs = iIndexType.GetGenericArguments(); Type keyType = indexTypeArgs[0]; Type grainType = indexTypeArgs[1]; IndexInterface index; if (typeof(IGrain).IsAssignableFrom(idxType)) { index = (IndexInterface)gf.GetGrain(IndexUtils.GetIndexGrainID(grainType, indexName), idxType, idxType); Type idxImplType = TypeUtils.ResolveType(TypeCodeMapper.GetImplementation(idxType).GrainClass); if (idxImplType.IsGenericTypeDefinition) { idxImplType = idxImplType.MakeGenericType(iIndexType.GetGenericArguments()); } MethodInfo initPerSilo; if ((initPerSilo = idxImplType.GetMethod("InitPerSilo", BindingFlags.Static | BindingFlags.Public)) != null) { var initPerSiloMethod = (Action <Silo, string, bool>)Delegate.CreateDelegate( typeof(Action <Silo, string, bool>), initPerSilo); initPerSiloMethod(Silo.CurrentSilo, indexName, isUniqueIndex); } } else if (idxType.IsClass) { index = (IndexInterface)Activator.CreateInstance(idxType, indexName, isUniqueIndex); } else { throw new Exception(string.Format("{0} is neither a grain nor a class. Index \"{1}\" cannot be created.", idxType, indexName)); } return(Tuple.Create((object)index, (object)new IndexMetaData(idxType, isUniqueIndex, isEager, maxEntriesPerBucket), (object)CreateIndexUpdateGenFromProperty(indexedProperty))); } else { throw new NotSupportedException(string.Format("Adding an index that does not implement IndexInterface<K,V> is not supported yet. Your requested index ({0}) is invalid.", idxType.ToString())); } }
/// <summary> /// This is a helper method for creating an index on a field of an actor. /// </summary> /// <param name="idxType">The type of index to be created</param> /// <param name="indexName">The index name to be created</param> /// <param name="isUniqueIndex">Determines whether this is a unique index that needs to be created</param> /// <param name="isEager">Determines whether updates to this index should be applied eagerly or not</param> /// <param name="maxEntriesPerBucket">Determines the maximum number of entries in /// each bucket of a distributed index, if this index type is a distributed one.</param> /// <param name="indexedProperty">the PropertyInfo object for the indexed field. /// This object helps in creating a default instance of IndexUpdateGenerator.</param> /// <returns>An <see cref="IndexInfo"/> for the specified idxType and indexName.</returns> internal async Task <IndexInfo> CreateIndex(Type idxType, string indexName, bool isUniqueIndex, bool isEager, int maxEntriesPerBucket, PropertyInfo indexedProperty) { Type iIndexType = idxType.GetGenericType(typeof(IIndexInterface <,>)); if (iIndexType == null) { throw new NotSupportedException(string.Format("Adding an index that does not implement IndexInterface<K,V> is not supported yet. Your requested index ({0}) is invalid.", idxType.ToString())); } Type[] indexTypeArgs = iIndexType.GetGenericArguments(); Type keyType = indexTypeArgs[0]; Type grainType = indexTypeArgs[1]; IIndexInterface index; if (typeof(IGrain).IsAssignableFrom(idxType)) { // This must call the static Silo methods because we may not be InSilo. index = (IIndexInterface)Silo.GetGrain(this.grainFactory, IndexUtils.GetIndexGrainPrimaryKey(grainType, indexName), idxType, idxType); if (this.IsInSilo) { var idxImplType = this.indexManager.CachedTypeResolver.ResolveType( TypeCodeMapper.GetImplementation(this.siloIndexManager.GrainTypeResolver, idxType).GrainClass); if (idxImplType.IsGenericTypeDefinition) { idxImplType = idxImplType.MakeGenericType(iIndexType.GetGenericArguments()); } var initPerSiloMethodInfo = idxImplType.GetMethod("InitPerSilo", BindingFlags.Static | BindingFlags.NonPublic); if (initPerSiloMethodInfo != null) // Static method so cannot use an interface { var initPerSiloMethod = (Func <SiloIndexManager, string, bool, Task>)Delegate.CreateDelegate(typeof(Func <SiloIndexManager, string, bool, Task>), initPerSiloMethodInfo); await initPerSiloMethod(this.siloIndexManager, indexName, isUniqueIndex); } } } else { index = idxType.IsClass ? (IIndexInterface)Activator.CreateInstance(idxType, this.indexManager.ServiceProvider, indexName, isUniqueIndex) : throw new IndexException(string.Format("{0} is neither a grain nor a class. Index \"{1}\" cannot be created.", idxType, indexName)); } return(new IndexInfo(index, new IndexMetaData(idxType, isUniqueIndex, isEager, maxEntriesPerBucket), CreateIndexUpdateGenFromProperty(indexedProperty))); }
/// <summary> /// Determines whether the index grain is a stateless worker /// or not. This piece of information can impact the relationship /// between index handlers and the index. /// </summary> /// <returns>the result of whether the current index is /// a stateless worker or not</returns> public bool IsIndexStatelessWorker() { return(IsStatelessWorker(Type.GetType(TypeCodeMapper.GetImplementation(_indexType).GrainClass))); }