public InsideRuntimeClient(
Dispatcher dispatcher,
Catalog catalog,
ILocalGrainDirectory directory,
ClusterConfiguration config,
IConsistentRingProvider ring,
GrainTypeManager typeManager,
TypeMetadataCache typeMetadataCache,
Func<ISiloStatusOracle> siloStatusOracle,
OrleansTaskScheduler scheduler)
{
this.dispatcher = dispatcher;
MySilo = catalog.LocalSilo;
this.directory = directory;
ConsistentRingProvider = ring;
Catalog = catalog;
disposables = new List<IDisposable>();
callbacks = new ConcurrentDictionary<CorrelationId, CallbackData>();
Config = config;
config.OnConfigChange("Globals/Message", () => ResponseTimeout = Config.Globals.ResponseTimeout);
RuntimeClient.Current = this;
this.typeManager = typeManager;
this.Scheduler = scheduler;
this.siloStatusOracle = new Lazy<ISiloStatusOracle>(siloStatusOracle);
this.ConcreteGrainFactory = new GrainFactory(this, typeMetadataCache);
RuntimeClient.Current = this;
}
public GrainReferenceRuntime(
IRuntimeClient runtimeClient,
IGrainCancellationTokenRuntime cancellationTokenRuntime,
SerializationManager serializationManager,
IEnumerable <IOutgoingGrainCallFilter> outgoingCallFilters,
TypeMetadataCache typeMetadataCache)
{
this.grainReferenceMethodCache = new InterfaceToImplementationMappingCache();
this.sendRequestDelegate = SendRequest;
this.RuntimeClient = runtimeClient;
this.cancellationTokenRuntime = cancellationTokenRuntime;
this.GrainReferenceFactory = new GrainReferenceFactory(typeMetadataCache, this);
this.serializationManager = serializationManager;
this.filters = outgoingCallFilters.ToArray();
}
public InsideRuntimeClient(
ILocalSiloDetails siloDetails,
GrainTypeManager typeManager,
TypeMetadataCache typeMetadataCache,
OrleansTaskScheduler scheduler,
IServiceProvider serviceProvider,
MessageFactory messageFactory,
ITransactionAgent transactionAgent,
ILoggerFactory loggerFactory,
IOptions <SiloMessagingOptions> messagingOptions,
IGrainCancellationTokenRuntime cancellationTokenRuntime,
IOptions <SchedulingOptions> schedulerOptions,
ApplicationRequestsStatisticsGroup appRequestStatistics,
MessagingTrace messagingTrace)
{
this.ServiceProvider = serviceProvider;
this.MySilo = siloDetails.SiloAddress;
this.disposables = new List <IDisposable>();
this.callbacks = new ConcurrentDictionary <CorrelationId, CallbackData>();
this.typeManager = typeManager;
this.messageFactory = messageFactory;
this.transactionAgent = transactionAgent;
this.Scheduler = scheduler;
this.ConcreteGrainFactory = new GrainFactory(this, typeMetadataCache);
this.logger = loggerFactory.CreateLogger <InsideRuntimeClient>();
this.invokeExceptionLogger = loggerFactory.CreateLogger($"{typeof(Grain).FullName}.InvokeException");
this.loggerFactory = loggerFactory;
this.messagingOptions = messagingOptions.Value;
this.cancellationTokenRuntime = cancellationTokenRuntime;
this.appRequestStatistics = appRequestStatistics;
this.messagingTrace = messagingTrace;
this.schedulingOptions = schedulerOptions.Value;
this.sharedCallbackData = new SharedCallbackData(
msg => this.UnregisterCallback(msg.Id),
this.loggerFactory.CreateLogger <CallbackData>(),
this.messagingOptions,
this.appRequestStatistics,
this.messagingOptions.ResponseTimeout);
this.systemSharedCallbackData = new SharedCallbackData(
msg => this.UnregisterCallback(msg.Id),
this.loggerFactory.CreateLogger <CallbackData>(),
this.messagingOptions,
this.appRequestStatistics,
this.messagingOptions.SystemResponseTimeout);
}
public InsideRuntimeClient(
ILocalSiloDetails siloDetails,
ClusterConfiguration config,
GrainTypeManager typeManager,
TypeMetadataCache typeMetadataCache,
OrleansTaskScheduler scheduler,
IServiceProvider serviceProvider,
SerializationManager serializationManager,
MessageFactory messageFactory,
IEnumerable <IGrainCallFilter> registeredInterceptors,
Factory <ITransactionAgent> transactionAgent,
ILoggerFactory loggerFactory,
IOptions <SiloMessagingOptions> messagingOptions,
IGrainCancellationTokenRuntime cancellationTokenRuntime)
{
this.ServiceProvider = serviceProvider;
this.SerializationManager = serializationManager;
MySilo = siloDetails.SiloAddress;
disposables = new List <IDisposable>();
callbacks = new ConcurrentDictionary <CorrelationId, CallbackData>();
Config = config;
config.OnConfigChange("Globals/Message", () => ResponseTimeout = Config.Globals.ResponseTimeout);
this.typeManager = typeManager;
this.messageFactory = messageFactory;
this.transactionAgent = new Lazy <ITransactionAgent>(() => transactionAgent());
this.Scheduler = scheduler;
this.ConcreteGrainFactory = new GrainFactory(this, typeMetadataCache);
tryResendMessage = msg => this.Dispatcher.TryResendMessage(msg);
unregisterCallback = msg => UnRegisterCallback(msg.Id);
this.siloInterceptors = new List <IGrainCallFilter>(registeredInterceptors);
this.logger = loggerFactory.CreateLogger <InsideRuntimeClient>();
this.invokeExceptionLogger = loggerFactory.CreateLogger($"{typeof(Grain).FullName}.InvokeException");
this.loggerFactory = loggerFactory;
this.messagingOptions = messagingOptions.Value;
this.callbackDataLogger = new LoggerWrapper <CallbackData>(loggerFactory);
this.timerLogger = loggerFactory.CreateLogger <SafeTimer>();
this.cancellationTokenRuntime = cancellationTokenRuntime;
}
public InsideRuntimeClient(
ILocalSiloDetails siloDetails,
ClusterConfiguration config,
GrainTypeManager typeManager,
TypeMetadataCache typeMetadataCache,
OrleansTaskScheduler scheduler,
IServiceProvider serviceProvider,
SerializationManager serializationManager,
MessageFactory messageFactory)
{
this.ServiceProvider = serviceProvider;
this.SerializationManager = serializationManager;
MySilo = siloDetails.SiloAddress;
disposables = new List <IDisposable>();
callbacks = new ConcurrentDictionary <CorrelationId, CallbackData>();
Config = config;
config.OnConfigChange("Globals/Message", () => ResponseTimeout = Config.Globals.ResponseTimeout);
this.typeManager = typeManager;
this.messageFactory = messageFactory;
this.Scheduler = scheduler;
this.ConcreteGrainFactory = new GrainFactory(this, typeMetadataCache);
tryResendMessage = msg => this.Dispatcher.TryResendMessage(msg);
unregisterCallback = msg => UnRegisterCallback(msg.Id);
}
public OutsideRuntimeClient(ClientConfiguration cfg, bool secondary = false)
{
this.typeCache = new TypeMetadataCache();
this.assemblyProcessor = new AssemblyProcessor(this.typeCache);
this.grainFactory = new GrainFactory(this, this.typeCache);
if (cfg == null)
{
Console.WriteLine("An attempt to create an OutsideRuntimeClient with null ClientConfiguration object.");
throw new ArgumentException("OutsideRuntimeClient was attempted to be created with null ClientConfiguration object.", "cfg");
}
this.config = cfg;
if (!LogManager.IsInitialized) LogManager.Initialize(config);
StatisticsCollector.Initialize(config);
SerializationManager.Initialize(cfg.SerializationProviders, cfg.FallbackSerializationProvider);
this.assemblyProcessor.Initialize();
logger = LogManager.GetLogger("OutsideRuntimeClient", LoggerType.Runtime);
appLogger = LogManager.GetLogger("Application", LoggerType.Application);
BufferPool.InitGlobalBufferPool(config);
this.handshakeClientId = GrainId.NewClientId();
try
{
LoadAdditionalAssemblies();
callbacks = new ConcurrentDictionary<CorrelationId, CallbackData>();
localObjects = new ConcurrentDictionary<GuidId, LocalObjectData>();
if (!secondary)
{
UnobservedExceptionsHandlerClass.SetUnobservedExceptionHandler(UnhandledException);
}
AppDomain.CurrentDomain.DomainUnload += CurrentDomain_DomainUnload;
// Ensure SerializationManager static constructor is called before AssemblyLoad event is invoked
SerializationManager.GetDeserializer(typeof(String));
clientProviderRuntime = new ClientProviderRuntime(grainFactory, null);
statisticsProviderManager = new StatisticsProviderManager("Statistics", clientProviderRuntime);
var statsProviderName = statisticsProviderManager.LoadProvider(config.ProviderConfigurations)
.WaitForResultWithThrow(initTimeout);
if (statsProviderName != null)
{
config.StatisticsProviderName = statsProviderName;
}
responseTimeout = Debugger.IsAttached ? Constants.DEFAULT_RESPONSE_TIMEOUT : config.ResponseTimeout;
var localAddress = ClusterConfiguration.GetLocalIPAddress(config.PreferredFamily, config.NetInterface);
// Client init / sign-on message
logger.Info(ErrorCode.ClientInitializing, string.Format(
"{0} Initializing OutsideRuntimeClient on {1} at {2} Client Id = {3} {0}",
BARS, config.DNSHostName, localAddress, handshakeClientId));
string startMsg = string.Format("{0} Starting OutsideRuntimeClient with runtime Version='{1}' in AppDomain={2}",
BARS, RuntimeVersion.Current, PrintAppDomainDetails());
startMsg = string.Format("{0} Config= " + Environment.NewLine + " {1}", startMsg, config);
logger.Info(ErrorCode.ClientStarting, startMsg);
if (TestOnlyThrowExceptionDuringInit)
{
throw new InvalidOperationException("TestOnlyThrowExceptionDuringInit");
}
config.CheckGatewayProviderSettings();
var generation = -SiloAddress.AllocateNewGeneration(); // Client generations are negative
var gatewayListProvider = GatewayProviderFactory.CreateGatewayListProvider(config)
.WithTimeout(initTimeout).Result;
transport = new ProxiedMessageCenter(config, localAddress, generation, handshakeClientId, gatewayListProvider);
if (StatisticsCollector.CollectThreadTimeTrackingStats)
{
incomingMessagesThreadTimeTracking = new ThreadTrackingStatistic("ClientReceiver");
}
}
catch (Exception exc)
{
if (logger != null) logger.Error(ErrorCode.Runtime_Error_100319, "OutsideRuntimeClient constructor failed.", exc);
ConstructorReset();
throw;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AssemblyProcessor"/> class.
/// </summary>
/// <param name="typeCache">
/// The type cache.
/// </param>
public AssemblyProcessor(TypeMetadataCache typeCache)
{
this.logger = LogManager.GetLogger("AssemblyProcessor");
this.typeCache = typeCache;
}
/// <summary>
/// Initializes a new instance of the <see cref="AssemblyProcessor"/> class.
/// </summary>
/// <param name="typeCache">
/// The type cache.
/// </param>
/// <param name="codeGeneratorManager">
/// The code generator.
/// </param>
public AssemblyProcessor(TypeMetadataCache typeCache, CodeGeneratorManager codeGeneratorManager)
{
this.logger = LogManager.GetLogger("AssemblyProcessor");
this.typeCache = typeCache;
this.codeGeneratorManager = codeGeneratorManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="AssemblyProcessor"/> class.
/// </summary>
/// <param name="typeCache">
/// The type cache.
/// </param>
public AssemblyProcessor(TypeMetadataCache typeCache)
{
this.logger = LogManager.GetLogger("AssemblyProcessor");
this.typeCache = typeCache;
}
