public GrainTypeManager(
ILocalSiloDetails siloDetails,
IApplicationPartManager applicationPartManager,
PlacementStrategy defaultPlacementStrategy,
SerializationManager serializationManager,
ILogger <GrainTypeManager> logger,
IOptions <GrainClassOptions> grainClassOptions)
{
var localTestMode = siloDetails.SiloAddress.Endpoint.Address.Equals(IPAddress.Loopback);
this.logger = logger;
this.defaultPlacementStrategy = defaultPlacementStrategy;
this.serializationManager = serializationManager;
grainInterfaceMap = new GrainInterfaceMap(localTestMode, this.defaultPlacementStrategy);
ClusterGrainInterfaceMap = grainInterfaceMap;
GrainTypeResolver = grainInterfaceMap.GetGrainTypeResolver();
grainInterfaceMapsBySilo = new Dictionary <SiloAddress, GrainInterfaceMap>();
var grainClassFeature = applicationPartManager.CreateAndPopulateFeature <GrainClassFeature>();
this.grainTypes = CreateGrainTypeMap(grainClassFeature, grainClassOptions.Value);
var grainInterfaceFeature = applicationPartManager.CreateAndPopulateFeature <GrainInterfaceFeature>();
this.invokers = CreateInvokerMap(grainInterfaceFeature);
this.InitializeInterfaceMap();
}
// used for testing to (carefully!) allow two clients in the same process
internal void StartInternal()
{
transport.Start();
LogManager.MyIPEndPoint = transport.MyAddress.Endpoint; // transport.MyAddress is only set after transport is Started.
CurrentActivationAddress = ActivationAddress.NewActivationAddress(transport.MyAddress, handshakeClientId);
ClientStatistics = new ClientStatisticsManager(config);
listeningCts = new CancellationTokenSource();
var ct = listeningCts.Token;
listenForMessages = true;
// Keeping this thread handling it very simple for now. Just queue task on thread pool.
Task.Factory.StartNew(() =>
{
try
{
RunClientMessagePump(ct);
}
catch (Exception exc)
{
logger.Error(ErrorCode.Runtime_Error_100326, "RunClientMessagePump has thrown exception", exc);
}
}
);
grainInterfaceMap = transport.GetTypeCodeMap(grainFactory).Result;
ClientStatistics.Start(statisticsProviderManager, transport, clientId)
.WaitWithThrow(initTimeout);
StreamingInitialize();
}
internal static GrainClassData GetImplementation(IGrainTypeResolver grainTypeResolver, string grainImplementationClassName)
{
GrainClassData implementation;
if (!grainTypeResolver.TryGetGrainClassData(grainImplementationClassName, out implementation))
{
throw new ArgumentException(string.Format("Cannot find an implementation grain class: {0}. Make sure the grain assembly was correctly deployed and loaded in the silo.", grainImplementationClassName));
}
return(implementation);
}
internal static int GetImplementationTypeCode(string grainImplementationClassName)
{
int typeCode;
IGrainTypeResolver grainTypeResolver = RuntimeClient.Current.GrainTypeResolver;
if (!grainTypeResolver.TryGetGrainTypeCode(grainImplementationClassName, out typeCode))
{
throw new ArgumentException(String.Format("Cannot find a type code for an implementation grain class: {0}. Make sure the grain assembly was correctly deployed and loaded in the silo.", grainImplementationClassName));
}
return(typeCode);
}
internal static GrainClassData GetImplementation(IGrainTypeResolver grainTypeResolver, Type interfaceType, string grainClassNamePrefix = null)
{
GrainClassData implementation;
if (!grainTypeResolver.TryGetGrainClassData(interfaceType, out implementation, grainClassNamePrefix))
{
var loadedAssemblies = grainTypeResolver.GetLoadedGrainAssemblies();
throw new ArgumentException(
String.Format("Cannot find an implementation class for grain interface: {0}{2}. Make sure the grain assembly was correctly deployed and loaded in the silo.{1}",
interfaceType,
String.IsNullOrEmpty(loadedAssemblies) ? String.Empty : String.Format(" Loaded grain assemblies: {0}", loadedAssemblies),
String.IsNullOrEmpty(grainClassNamePrefix) ? String.Empty : ", grainClassNamePrefix=" + grainClassNamePrefix));
}
return implementation;
}
internal static GrainClassData GetImplementation(IGrainTypeResolver grainTypeResolver, Type interfaceType, string grainClassNamePrefix = null)
{
GrainClassData implementation;
if (!grainTypeResolver.TryGetGrainClassData(interfaceType, out implementation, grainClassNamePrefix))
{
var loadedAssemblies = grainTypeResolver.GetLoadedGrainAssemblies();
throw new ArgumentException(
String.Format("Cannot find an implementation class for grain interface: {0}{2}. Make sure the grain assembly was correctly deployed and loaded in the silo.{1}",
interfaceType,
String.IsNullOrEmpty(loadedAssemblies) ? String.Empty : String.Format(" Loaded grain assemblies: {0}", loadedAssemblies),
String.IsNullOrEmpty(grainClassNamePrefix) ? String.Empty : ", grainClassNamePrefix=" + grainClassNamePrefix));
}
return(implementation);
}
internal static int GetImplementationTypeCode(Type interfaceType, string grainClassNamePrefix = null)
{
int typeCode;
IGrainTypeResolver grainTypeResolver = RuntimeClient.Current.GrainTypeResolver;
if (!grainTypeResolver.TryGetGrainTypeCode(interfaceType, out typeCode, grainClassNamePrefix))
{
var loadedAssemblies = grainTypeResolver.GetLoadedGrainAssemblies();
throw new ArgumentException(
String.Format("Cannot find a type code for an implementation class for grain interface: {0}{2}. Make sure the grain assembly was correctly deployed and loaded in the silo.{1}",
interfaceType,
String.IsNullOrEmpty(loadedAssemblies) ? String.Empty : String.Format(" Loaded grain assemblies: {0}", loadedAssemblies),
String.IsNullOrEmpty(grainClassNamePrefix) ? String.Empty : ", grainClassNamePrefix=" + grainClassNamePrefix));
}
return(typeCode);
}
// used for testing to (carefully!) allow two clients in the same process
private async Task StartInternal()
{
await this.gatewayListProvider.InitializeGatewayListProvider(config, LogManager.GetLogger(gatewayListProvider.GetType().Name))
.WithTimeout(initTimeout);
var generation = -SiloAddress.AllocateNewGeneration(); // Client generations are negative
transport = ActivatorUtilities.CreateInstance <ProxiedMessageCenter>(this.ServiceProvider, localAddress, generation, handshakeClientId);
transport.Start();
LogManager.MyIPEndPoint = transport.MyAddress.Endpoint; // transport.MyAddress is only set after transport is Started.
CurrentActivationAddress = ActivationAddress.NewActivationAddress(transport.MyAddress, handshakeClientId);
listeningCts = new CancellationTokenSource();
var ct = listeningCts.Token;
listenForMessages = true;
// Keeping this thread handling it very simple for now. Just queue task on thread pool.
Task.Run(
() =>
{
while (listenForMessages && !ct.IsCancellationRequested)
{
try
{
RunClientMessagePump(ct);
}
catch (Exception exc)
{
logger.Error(ErrorCode.Runtime_Error_100326, "RunClientMessagePump has thrown exception", exc);
}
}
},
ct).Ignore();
grainInterfaceMap = await transport.GetTypeCodeMap(this.InternalGrainFactory);
await ClientStatistics.Start(statisticsProviderManager, transport, clientId)
.WithTimeout(initTimeout);
await StreamingInitialize();
}
private void RebuildFullGrainInterfaceMap()
{
var newClusterGrainInterfaceMap = new GrainInterfaceMap(false, this.defaultPlacementStrategy);
var newSupportedSilosByTypeCode = new Dictionary <int, List <SiloAddress> >();
var newSupportedSilosByInterface = new Dictionary <int, Dictionary <ushort, List <SiloAddress> > >();
foreach (var kvp in grainInterfaceMapsBySilo)
{
newClusterGrainInterfaceMap.AddMap(kvp.Value);
foreach (var supportedInterface in kvp.Value.SupportedInterfaces)
{
var ifaceId = supportedInterface.InterfaceId;
var version = supportedInterface.InterfaceVersion;
var supportedSilosByVersion = newSupportedSilosByInterface.GetValueOrAddNew(ifaceId);
var supportedSilosForVersion = supportedSilosByVersion.GetValueOrAddNew(version);
supportedSilosForVersion.Add(kvp.Key);
}
foreach (var grainClassData in kvp.Value.SupportedGrainClassData)
{
var grainType = grainClassData.GrainTypeCode;
var supportedSilos = newSupportedSilosByTypeCode.GetValueOrAddNew(grainType);
supportedSilos.Add(kvp.Key);
}
}
foreach (var silos in newSupportedSilosByTypeCode.Values)
{
// We need to sort this so the list of silos returned will
// be the same accross all silos in the cluster
silos.Sort();
}
ClusterGrainInterfaceMap = newClusterGrainInterfaceMap;
GrainTypeResolver = ClusterGrainInterfaceMap.GetGrainTypeResolver();
supportedSilosByTypeCode = newSupportedSilosByTypeCode;
supportedSilosByInterface = newSupportedSilosByInterface;
}
// used for testing to (carefully!) allow two clients in the same process
private async Task StartInternal()
{
await this.gatewayListProvider.InitializeGatewayListProvider()
.WithTimeout(initTimeout, $"gatewayListProvider.InitializeGatewayListProvider failed due to timeout {initTimeout}");
var generation = -SiloAddress.AllocateNewGeneration(); // Client generations are negative
transport = ActivatorUtilities.CreateInstance <ClientMessageCenter>(this.ServiceProvider, localAddress, generation, handshakeClientId);
transport.Start();
CurrentActivationAddress = ActivationAddress.NewActivationAddress(transport.MyAddress, handshakeClientId);
listeningCts = new CancellationTokenSource();
var ct = listeningCts.Token;
listenForMessages = true;
// Keeping this thread handling it very simple for now. Just queue task on thread pool.
Task.Run(
() =>
{
while (listenForMessages && !ct.IsCancellationRequested)
{
try
{
RunClientMessagePump(ct);
}
catch (Exception exc)
{
logger.Error(ErrorCode.Runtime_Error_100326, "RunClientMessagePump has thrown exception", exc);
}
}
},
ct).Ignore();
grainTypeResolver = await transport.GetGrainTypeResolver(this.InternalGrainFactory);
ClientStatistics.Start(transport, clientId);
await StreamingInitialize();
}
internal void Start()
{
grainInterfaceMap = typeManager.GetTypeCodeMap();
}
// used for testing to (carefully!) allow two clients in the same process
internal void StartInternal()
{
transport.Start();
LogManager.MyIPEndPoint = transport.MyAddress.Endpoint; // transport.MyAddress is only set after transport is Started.
CurrentActivationAddress = ActivationAddress.NewActivationAddress(transport.MyAddress, handshakeClientId);
ClientStatistics = new ClientStatisticsManager(config);
listeningCts = new CancellationTokenSource();
var ct = listeningCts.Token;
listenForMessages = true;
// Keeping this thread handling it very simple for now. Just queue task on thread pool.
Task.Factory.StartNew(() =>
{
try
{
RunClientMessagePump(ct);
}
catch(Exception exc)
{
logger.Error(ErrorCode.Runtime_Error_100326, "RunClientMessagePump has thrown exception", exc);
}
}
);
grainInterfaceMap = transport.GetTypeCodeMap(grainFactory).Result;
ClientStatistics.Start(statisticsProviderManager, transport, clientId)
.WaitWithThrow(initTimeout);
StreamingInitialize();
}
internal static GrainClassData GetImplementation(IGrainTypeResolver grainTypeResolver, Type grainImplementationClass) => (grainTypeResolver.TryGetGrainClassData(grainImplementationClass, out GrainClassData implementation, ""))
internal void Start()
{
grainInterfaceMap = typeManager.GetTypeCodeMap();
}
