public Cluster(ActorSystemImpl system)
{
System = system;
_settings = new ClusterSettings(system.Settings.Config, system.Name);
var provider = system.Provider as ClusterActorRefProvider;
if (provider == null)
{
throw new ConfigurationException(
String.Format("ActorSystem {0} needs to have a 'ClusterActorRefProvider' enabled in the configuration, currently uses {1}",
system,
system.Provider.GetType().FullName));
}
_selfUniqueAddress = new UniqueAddress(provider.Transport.DefaultAddress, AddressUidExtension.Uid(system));
_log = Logging.GetLogger(system, "Cluster");
LogInfo("Starting up...");
_failureDetector = new DefaultFailureDetectorRegistry <Address>(() => FailureDetectorLoader.Load(_settings.FailureDetectorImplementationClass, _settings.FailureDetectorConfig,
system));
_scheduler = CreateScheduler(system);
//create supervisor for daemons under path "/system/cluster"
_clusterDaemons = system.SystemActorOf(Props.Create(() => new ClusterDaemon(_settings)).WithDeploy(Deploy.Local), "cluster");
//TODO: Pretty sure this is bad and will at least throw aggregateexception possibly worse.
_clusterCore = GetClusterCoreRef().Result;
_readView = new ClusterReadView(this);
}
private void AddLogger(ActorSystemImpl system, Type loggerType, LogLevel logLevel, string loggingBusName, TimeSpan timeout)
{
var loggerName = CreateLoggerName(loggerType);
var logger = system.SystemActorOf(Props.Create(loggerType).WithDispatcher(system.Settings.LoggersDispatcher), loggerName);
var askTask = logger.Ask(new InitializeLogger(this), timeout);
object response = null;
try
{
response = askTask.Result;
}
catch (TaskCanceledException)
{
Publish(new Warning(loggingBusName, GetType(),
string.Format("Logger {0} [{2}] did not respond within {1} to InitializeLogger(bus)", loggerName, timeout, loggerType.FullName)));
}
if (!(response is LoggerInitialized))
{
throw new LoggerInitializationException($"Logger {loggerName} [{loggerType.FullName}] did not respond with LoggerInitialized, sent instead {response}");
}
_loggers.Add(logger);
SubscribeLogLevelAndAbove(logLevel, logger);
Publish(new Debug(loggingBusName, GetType(), $"Logger {loggerName} [{loggerType.Name}] started"));
}
/// <summary>
/// Initializes a new instance of the <see cref="Cluster"/> class.
/// </summary>
/// <param name="system">The actor system that hosts the cluster.</param>
/// <exception cref="ConfigurationException">
/// This exception is thrown if the <paramref name="system"/> does not have a <see cref="ClusterActorRefProvider"/> enabled in the configuration.
/// </exception>
public Cluster(ActorSystemImpl system)
{
System = system;
Settings = new ClusterSettings(system.Settings.Config, system.Name);
if (!(system.Provider is IClusterActorRefProvider provider))
{
throw new ConfigurationException(
$"ActorSystem {system} needs to have a 'IClusterActorRefProvider' enabled in the configuration, currently uses {system.Provider.GetType().FullName}");
}
SelfUniqueAddress = new UniqueAddress(provider.Transport.DefaultAddress, AddressUidExtension.Uid(system));
_log = Logging.GetLogger(system, "Cluster");
CurrentInfoLogger = new InfoLogger(_log, Settings, SelfAddress);
LogInfo("Starting up...");
var clusterCoreTaskSource = new TaskCompletionSource <IActorRef>();
_clusterCoreTask = clusterCoreTaskSource.Task;
FailureDetector = new DefaultFailureDetectorRegistry <Address>(() => FailureDetectorLoader.Load(Settings.FailureDetectorImplementationClass, Settings.FailureDetectorConfig,
system));
Scheduler = CreateScheduler(system);
// it has to be lazy - otherwise if downing provider will init a cluster itself, it will deadlock
_downingProvider = new Lazy <IDowningProvider>(() => Akka.Cluster.DowningProvider.Load(Settings.DowningProviderType, system), LazyThreadSafetyMode.ExecutionAndPublication);
//create supervisor for daemons under path "/system/cluster"
_clusterDaemons = system.SystemActorOf(Props.Create(() => new ClusterDaemon(Settings)).WithDeploy(Deploy.Local), "cluster");
_readView = new ClusterReadView(this);
// force the underlying system to start
_ = Task.Run(async() =>
{
try
{
_clusterCore = await _clusterDaemons.Ask <IActorRef>(new InternalClusterAction.GetClusterCoreRef(this), System.Settings.CreationTimeout).ConfigureAwait(false);
clusterCoreTaskSource.SetResult(_clusterCore);
system.RegisterOnTermination(Shutdown);
LogInfo("Started up successfully");
}
catch (Exception ex)
{
_log.Error(ex, "Failed to startup Cluster. You can try to increase 'akka.actor.creation-timeout'.");
Shutdown();
System.DeadLetters.Tell(ex); //don't re-throw the error. Just log it.
_clusterCore = System.DeadLetters;
clusterCoreTaskSource.SetResult(_clusterCore);
}
});
}
/// <summary>
/// TBD
/// </summary>
/// <param name="system">TBD</param>
/// <returns>TBD</returns>
protected virtual IActorRef CreateRemoteWatcher(ActorSystemImpl system)
{
var failureDetector = CreateRemoteWatcherFailureDetector(system);
return(system.SystemActorOf(RemoteSettings.ConfigureDispatcher(
Akka.Remote.RemoteWatcher.Props(
failureDetector,
RemoteSettings.WatchHeartBeatInterval,
RemoteSettings.WatchUnreachableReaperInterval,
RemoteSettings.WatchHeartbeatExpectedResponseAfter)), "remote-watcher"));
}
protected override IActorRef CreateRemoteWatcher(ActorSystemImpl system)
{
// make sure Cluster extension is initialized/loaded from init thread
Cluster.Get(system);
var failureDetector = CreateRemoteWatcherFailureDetector(system);
return system.SystemActorOf(ClusterRemoteWatcher.Props(
failureDetector,
RemoteSettings.WatchHeartBeatInterval,
RemoteSettings.WatchUnreachableReaperInterval,
RemoteSettings.WatchHeartbeatExpectedResponseAfter), "remote-watcher");
}
protected override IActorRef CreateRemoteWatcher(ActorSystemImpl system)
{
// make sure Cluster extension is initialized/loaded from init thread
Cluster.Get(system);
var failureDetector = CreateRemoteWatcherFailureDetector(system);
return(system.SystemActorOf(ClusterRemoteWatcher.Props(
failureDetector,
RemoteSettings.WatchHeartBeatInterval,
RemoteSettings.WatchUnreachableReaperInterval,
RemoteSettings.WatchHeartbeatExpectedResponseAfter), "remote-watcher"));
}
/// <summary>
/// Adds the logger.
/// </summary>
/// <param name="system">The system.</param>
/// <param name="actorClass">The actor class.</param>
/// <param name="logLevel">The log level.</param>
/// <param name="logName">Name of the log.</param>
/// <returns>Task.</returns>
private async Task <ActorRef> AddLogger(ActorSystemImpl system, Type actorClass, LogLevel logLevel, string logName)
{
//TODO: remove the newguid stuff
string name = "log" + system.Name + "-" + SimpleName(actorClass);
ActorRef actor;
try
{
actor = system.SystemActorOf(Props.Create(actorClass), name);
}
catch
{
//HACK: the EventStreamSpec tries to start up loggers for a new EventBus
//when doing so, this logger is already started and the name reserved.
//we need to examine how this is dealt with in akka.
name = name + Guid.NewGuid();
actor = system.SystemActorOf(Props.Create(actorClass), name);
}
await actor.Ask(new InitializeLogger(this));
return(actor);
}
/// <summary>
/// Starts the loggers defined in the system configuration.
/// </summary>
/// <param name="system">The system that the loggers need to start monitoring.</param>
/// <exception cref="ConfigurationException">
/// This exception is thrown if the logger specified in the <paramref name="system"/> configuration could not be found or loaded.
/// </exception>
/// <exception cref="LoggerInitializationException">
/// This exception is thrown if the logger doesn't respond with a <see cref="LoggerInitialized"/> message when initialized.
/// </exception>
internal void StartDefaultLoggers(ActorSystemImpl system)
{
var logName = SimpleName(this) + "(" + system.Name + ")";
var logLevel = Logging.LogLevelFor(system.Settings.LogLevel);
var loggerTypes = system.Settings.Loggers;
var timeout = system.Settings.LoggerStartTimeout;
var shouldRemoveStandardOutLogger = true;
foreach (var strLoggerType in loggerTypes)
{
var loggerType = Type.GetType(strLoggerType);
if (loggerType == null)
{
throw new ConfigurationException($@"Logger specified in config cannot be found: ""{strLoggerType}""");
}
if (loggerType == typeof(StandardOutLogger))
{
shouldRemoveStandardOutLogger = false;
continue;
}
try
{
AddLogger(system, loggerType, logLevel, logName, timeout);
}
catch (Exception e)
{
throw new ConfigurationException($"Logger [{strLoggerType}] specified in config cannot be loaded: {e}", e);
}
}
LogLevel = logLevel;
if (system.Settings.DebugUnhandledMessage)
{
var forwarder = system.SystemActorOf(Props.Create(typeof(UnhandledMessageForwarder)), "UnhandledMessageForwarder");
Subscribe(forwarder, typeof(UnhandledMessage));
}
if (shouldRemoveStandardOutLogger)
{
Publish(new Debug(logName, GetType(), "StandardOutLogger being removed"));
Unsubscribe(Logging.StandardOutLogger);
}
Publish(new Debug(logName, GetType(), "Default Loggers started"));
}
public virtual void Init(ActorSystemImpl system)
{
_system = system;
_local.Init(system);
_remotingTerminator =
_system.SystemActorOf(
RemoteSettings.ConfigureDispatcher(Props.Create(() => new RemotingTerminator(_local.SystemGuardian))),
"remoting-terminator");
_remotingTerminator.Tell(RemoteInternals);
Transport.Start();
_remoteWatcher = CreateRemoteWatcher(system);
}
public Cluster(ActorSystemImpl system)
{
System = system;
Settings = new ClusterSettings(system.Settings.Config, system.Name);
var provider = system.Provider as ClusterActorRefProvider;
if (provider == null)
{
throw new ConfigurationException(
String.Format("ActorSystem {0} needs to have a 'ClusterActorRefProvider' enabled in the configuration, currently uses {1}",
system,
system.Provider.GetType().FullName));
}
SelfUniqueAddress = new UniqueAddress(provider.Transport.DefaultAddress, AddressUidExtension.Uid(system));
_log = Logging.GetLogger(system, "Cluster");
LogInfo("Starting up...");
_failureDetector = new DefaultFailureDetectorRegistry <Address>(() => FailureDetectorLoader.Load(Settings.FailureDetectorImplementationClass, Settings.FailureDetectorConfig,
system));
_scheduler = CreateScheduler(system);
// it has to be lazy - otherwise if downing provider will init a cluster itself, it will deadlock
_downingProvider = new Lazy <IDowningProvider>(() => Akka.Cluster.DowningProvider.Load(Settings.DowningProviderType, system), LazyThreadSafetyMode.ExecutionAndPublication);
//create supervisor for daemons under path "/system/cluster"
_clusterDaemons = system.SystemActorOf(Props.Create(() => new ClusterDaemon(Settings)).WithDeploy(Deploy.Local), "cluster");
_readView = new ClusterReadView(this);
// force the underlying system to start
_clusterCore = GetClusterCoreRef().Result;
system.RegisterOnTermination(Shutdown);
LogInfo("Started up successfully");
}
/// <inheritdoc/>
public virtual void Init(ActorSystemImpl system)
{
_system = system;
_local.Init(system);
_actorRefResolveThreadLocalCache = ActorRefResolveThreadLocalCache.For(system);
_actorPathThreadLocalCache = ActorPathThreadLocalCache.For(system);
_remotingTerminator =
_system.SystemActorOf(
RemoteSettings.ConfigureDispatcher(Props.Create(() => new RemotingTerminator(_local.SystemGuardian))),
"remoting-terminator");
_internals = CreateInternals();
_remotingTerminator.Tell(RemoteInternals);
Transport.Start();
_remoteWatcher = CreateRemoteWatcher(system);
_remoteDeploymentWatcher = CreateRemoteDeploymentWatcher(system);
}
private void AddLogger(ActorSystemImpl system, Type loggerType, LogLevel logLevel, string loggingBusName, TimeSpan timeout)
{
var loggerName = CreateLoggerName(loggerType);
var logger = system.SystemActorOf(Props.Create(loggerType), loggerName);
var askTask = logger.Ask(new InitializeLogger(this));
if (!askTask.Wait(timeout))
{
Publish(new Warning(loggingBusName, GetType(),
string.Format("Logger {0} [{2}] did not respond within {1} to InitializeLogger(bus)", loggerName, timeout, loggerType.FullName)));
}
else
{
var response = askTask.Result;
if (!(response is LoggerInitialized))
{
throw new LoggerInitializationException(string.Format("Logger {0} [{2}] did not respond with LoggerInitialized, sent instead {1}", loggerName, response, loggerType.FullName));
}
_loggers.Add(logger);
SubscribeLogLevelAndAbove(logLevel, logger);
Publish(new Debug(loggingBusName, GetType(), string.Format("Logger {0} [{1}] started", loggerName, loggerType.Name)));
}
}
/// <summary>
/// TBD
/// </summary>
/// <param name="system">TBD</param>
/// <param name="eventStream">TBD</param>
/// <param name="debug">TBD</param>
public void Start(ActorSystemImpl system, EventStream eventStream, bool debug)
{
system.SystemActorOf(Props.Create <EventStreamUnsubscriber>(eventStream, system, debug),
string.Format("EventStreamUnsubscriber-{0}", _unsubscribersCounter.IncrementAndGet()));
}
/// <summary>
/// TBD
/// </summary>
/// <param name="system">TBD</param>
/// <returns>TBD</returns>
protected virtual IActorRef CreateRemoteDeploymentWatcher(ActorSystemImpl system)
{
return(system.SystemActorOf(RemoteSettings.ConfigureDispatcher(Props.Create <RemoteDeploymentWatcher>()),
"remote-deployment-watcher"));
}
/// <summary>
/// Starts the loggers defined in the system configuration.
/// </summary>
/// <param name="system">The system that the loggers need to start monitoring.</param>
/// <exception cref="ConfigurationException">
/// This exception is thrown if the logger specified in the <paramref name="system"/> configuration could not be found or loaded.
/// </exception>
/// <exception cref="LoggerInitializationException">
/// This exception is thrown if the logger doesn't respond with a <see cref="LoggerInitialized"/> message when initialized.
/// </exception>
internal void StartDefaultLoggers(ActorSystemImpl system)
{
var logName = SimpleName(this) + "(" + system.Name + ")";
var logLevel = Logging.LogLevelFor(system.Settings.LogLevel);
var loggerTypes = system.Settings.Loggers;
var timeout = system.Settings.LoggerStartTimeout;
var asyncStart = system.Settings.LoggerAsyncStart;
var shouldRemoveStandardOutLogger = true;
foreach (var strLoggerType in loggerTypes)
{
var loggerType = Type.GetType(strLoggerType);
if (loggerType == null)
{
throw new ConfigurationException($@"Logger specified in config cannot be found: ""{strLoggerType}""");
}
if (loggerType == typeof(StandardOutLogger))
{
shouldRemoveStandardOutLogger = false;
continue;
}
if (asyncStart)
{
// Not awaiting for result, and not depending on current thread context
Task.Run(() => AddLogger(system, loggerType, logLevel, logName, timeout))
.ContinueWith(t =>
{
if (t.Exception != null)
{
Console.WriteLine($"Logger [{strLoggerType}] specified in config cannot be loaded: {t.Exception}");
}
});
}
else
{
try
{
AddLogger(system, loggerType, logLevel, logName, timeout);
}
catch (Exception ex)
{
throw new ConfigurationException($"Logger [{strLoggerType}] specified in config cannot be loaded: {ex}", ex);
}
}
}
LogLevel = logLevel;
if (system.Settings.DebugUnhandledMessage)
{
var forwarder = system.SystemActorOf(Props.Create(typeof(UnhandledMessageForwarder)), "UnhandledMessageForwarder");
Subscribe(forwarder, typeof(UnhandledMessage));
}
if (shouldRemoveStandardOutLogger)
{
Publish(new Debug(logName, GetType(), "StandardOutLogger being removed"));
Unsubscribe(Logging.StandardOutLogger);
}
Publish(new Debug(logName, GetType(), "Default Loggers started"));
}
public void Start(ActorSystemImpl system, EventStream eventStream, bool debug)
{
system.SystemActorOf(Props.Create<EventStreamUnsubscriber>(eventStream, system, debug),
string.Format("EventStreamUnsubscriber-{0}", _unsubscribersCounter.IncrementAndGet()));
}
