public async Task <WebApplication> StartAsync()
{
var app = BuildWebApplication(_application, _args, Sink);
DashboardWebApplication = app;
_logger = app.Logger;
_lifetime = app.ApplicationLifetime;
_logger.LogInformation("Executing application from {Source}", _application.Source);
ConfigureApplication(app);
var configuration = app.Configuration;
_replicaRegistry = new ReplicaRegistry(_application.ContextDirectory, _logger);
_processor = CreateApplicationProcessor(_replicaRegistry, _args, _servicesToDebug, _logger, configuration);
await app.StartAsync();
_logger.LogInformation("Dashboard running on {Address}", app.Addresses.First());
try
{
await _processor.StartAsync(_application);
}
catch (Exception ex)
{
_logger.LogError(0, ex, "Failed to launch application");
}
return(app);
}
public async Task <WebApplication> StartAsync()
{
var app = BuildWebApplication(_application, _options, Sink);
DashboardWebApplication = app;
_logger = app.Logger;
_lifetime = app.ApplicationLifetime;
_logger.LogInformation("Executing application from {Source}", _application.Source);
ConfigureApplication(app);
_replicaRegistry = new ReplicaRegistry(_application.ContextDirectory, _logger);
_processor = CreateApplicationProcessor(_replicaRegistry, _options, _logger);
await app.StartAsync();
_logger.LogInformation("Dashboard running on {Address}", app.Addresses.First());
await _processor.StartAsync(_application);
if (_options.Dashboard)
{
OpenDashboard(app.Addresses.First());
}
return(app);
}
public async Task <IHost> StartAsync()
{
var app = BuildWebApplication(_application, _options, Sink);
DashboardWebApplication = app;
_logger = DashboardWebApplication.Services.GetRequiredService <ILogger <TyeHost> >();
_lifetime = app.Services.GetRequiredService <IHostApplicationLifetime>();
if (_computedPort != _options.Port && _computedPort != DefaultPort)
{
_logger.LogInformation("Default dashboard port {DefaultPort} has been reserved by the application or is in use, choosing random port.", DefaultPort);
}
_logger.LogInformation("Executing application from {Source}", _application.Source);
_replicaRegistry = new ReplicaRegistry(_application.ContextDirectory, _logger);
_processor = CreateApplicationProcessor(_replicaRegistry, _options, _logger);
await app.StartAsync();
_addresses = DashboardWebApplication.Services.GetRequiredService <IServer>().Features.Get <IServerAddressesFeature>()?.Addresses;
var dashboardAddress = _addresses?.FirstOrDefault();
if (dashboardAddress != null)
{
_logger.LogInformation("Dashboard running on {Address}", dashboardAddress);
}
else
{
_logger.LogWarning("Dashboard is not running");
}
try
{
await _processor.StartAsync(_application);
_logger.LogInformation($"Application {_application.Name} started successfully with Pid: {Process.GetCurrentProcess().Id}");
}
catch (TyeBuildException ex)
{
_logger.LogError(ex.Message);
_lifetime.StopApplication();
}
if (dashboardAddress != null && _options.Dashboard)
{
OpenDashboard(dashboardAddress);
}
return(app);
}
public BaseSubscribeToOneStreamEventStoreStream(
int streamPosition,
IConnectionStatusMonitor <IEventStoreConnection> connectionMonitor,
SubscribeToOneStreamFromStartOrLaterEventStoreStreamConfiguration subscribeToOneStreamEventStoreStreamConfiguration,
IEventTypeProvider eventTypeProvider,
Microsoft.Extensions.Logging.ILogger?logger = null,
IKillSwitch?killSwitch = null)
: base(connectionMonitor, subscribeToOneStreamEventStoreStreamConfiguration, eventTypeProvider, logger)
{
_volatileSubscribeToOneStreamEventStoreStreamConfiguration = subscribeToOneStreamEventStoreStreamConfiguration;
_streamPosition = streamPosition;
_killSwitch = killSwitch ?? new KillSwitch();
}
public EventStoreBus(IConnectionStatusMonitor <IEventStoreConnection> connectionStatusMonitor,
IEventStoreRepository eventStoreRepository,
ILoggerFactory?loggerFactory = null)
{
BusId = $"{nameof(EventStoreBus)}_{Guid.NewGuid()}";
_connectionStatusMonitor = connectionStatusMonitor;
_eventStoreRepository = eventStoreRepository;
_cleanUp = new CompositeDisposable();
_pendingCommands = new Dictionary <Guid, TaskCompletionSource <ICommandResponse> >();
_loggerFactory = loggerFactory;
_logger = loggerFactory?.CreateLogger(typeof(EventStoreBus));
}
public RabbitMqConnectionStatusMonitor(IRabbitMqConnection connection, ILoggerFactory?loggerFactory = null)
{
_rabbitMqConnection = connection;
_logger = loggerFactory?.CreateLogger(nameof(RabbitMqConnectionStatusMonitor));
_isConnected = new BehaviorSubject <bool>(false);
_rabbitMqConnection.Connect();
var blocked = Observable.FromEventPattern <ConnectionBlockedEventArgs>(h => connection.AutoRecoveringConnection.ConnectionBlocked += h, h => connection.AutoRecoveringConnection.ConnectionBlocked -= h).Select(e =>
{
_logger?.LogInformation($"AMQP connection blocked - {nameof(ShutdownEventArgs)} => {e.EventArgs?.ToJson()}");
return(ConnectionStatus.Disconnected);
});
var unblocked = Observable.FromEventPattern <EventArgs>(h => connection.AutoRecoveringConnection.ConnectionUnblocked += h, h => connection.AutoRecoveringConnection.ConnectionUnblocked -= h).Select(e =>
{
_logger?.LogInformation($"AMQP connection unblocked - {nameof(EventArgs)} => {e.EventArgs?.ToJson()}");
return(ConnectionStatus.Connected);
});
var shutdowned = Observable.FromEventPattern <ShutdownEventArgs>(h => connection.AutoRecoveringConnection.ConnectionShutdown += h, h => connection.AutoRecoveringConnection.ConnectionShutdown -= h).Select(e =>
{
_logger?.LogInformation($"AMQP connection shutdown - {nameof(ShutdownEventArgs)} => {e.EventArgs?.ToJson()}");
return(ConnectionStatus.Disconnected);
});
var closed = Observable.FromEventPattern <CallbackExceptionEventArgs>(h => connection.AutoRecoveringConnection.CallbackException += h, h => connection.AutoRecoveringConnection.CallbackException -= h).Select(e =>
{
_logger?.LogError(e.EventArgs.Exception, $"An exception occured in a callback process - {nameof(CallbackExceptionEventArgs)} => {e.EventArgs?.ToJson()}");
return(ConnectionStatus.ErrorOccurred);
});
var errorOccurred = Observable.FromEventPattern <EventArgs>(h => connection.AutoRecoveringConnection.RecoverySucceeded += h, h => connection.AutoRecoveringConnection.RecoverySucceeded -= h).Select(e =>
{
_logger?.LogInformation($"AMQP connection recovery success - {nameof(EventArgs)} => {e.EventArgs?.ToJson()}");
return(ConnectionStatus.Connected);
});
var connectionRecoveryError = Observable.FromEventPattern <ConnectionRecoveryErrorEventArgs>(h => connection.AutoRecoveringConnection.ConnectionRecoveryError += h, h => connection.AutoRecoveringConnection.ConnectionRecoveryError -= h).Select(e =>
{
_logger?.LogError(e.EventArgs.Exception, $"AMQP connection recovery error - {nameof(ConnectionRecoveryErrorEventArgs)} => {e.EventArgs?.ToJson()}");
return(ConnectionStatus.Disconnected);
});
_connectionInfoChanged = Observable.Merge(blocked, unblocked, shutdowned, closed, errorOccurred, connectionRecoveryError)
.Scan(ConnectionInfo.InitialConnected, UpdateConnectionInfo)
.StartWith(ConnectionInfo.InitialConnected)
.Do(connectionInfo =>
{
ConnectionInfo = connectionInfo;
_logger?.LogInformation($"{nameof(RabbitMqConnectionStatusMonitor)} => ConnectionInfo - {connectionInfo}");
_isConnected.OnNext(connectionInfo.Status == ConnectionStatus.Connected);
})
.Replay(1);
_cleanUp = _connectionInfoChanged.Connect();
}
public EventStoreConnectionStatusMonitor(IEventStoreConnection connection, ILoggerFactory?loggerFactory = null)
{
_eventStoreConnection = connection;
_logger = loggerFactory?.CreateLogger(nameof(EventStoreConnectionStatusMonitor));
_isConnected = new BehaviorSubject <bool>(false);
var connected = Observable.FromEventPattern <ClientConnectionEventArgs>(h => connection.Connected += h, h => connection.Connected -= h).Select(_ =>
{
return(ConnectionStatus.Connected);
});
var disconnected = Observable.FromEventPattern <ClientConnectionEventArgs>(h => connection.Disconnected += h, h => connection.Disconnected -= h).Select(arg =>
{
_logger?.LogInformation($"{nameof(EventStoreConnectionStatusMonitor)} => Connection lost - [{arg.EventArgs.RemoteEndPoint}]");
return(ConnectionStatus.Disconnected);
});
var reconnecting = Observable.FromEventPattern <ClientReconnectingEventArgs>(h => connection.Reconnecting += h, h => connection.Reconnecting -= h).Select(_ =>
{
return(ConnectionStatus.Connecting);
});
var closed = Observable.FromEventPattern <ClientClosedEventArgs>(h => connection.Closed += h, h => connection.Closed -= h).Select(arg =>
{
_logger?.LogInformation($"{nameof(EventStoreConnectionStatusMonitor)} => Connection closed - [{arg.EventArgs.Reason}]");
return(ConnectionStatus.Closed);
});
var errorOccurred = Observable.FromEventPattern <ClientErrorEventArgs>(h => connection.ErrorOccurred += h, h => connection.ErrorOccurred -= h).Select(arg =>
{
_logger?.LogError(arg.EventArgs.Exception, $"{nameof(EventStoreConnectionStatusMonitor)} => An error occured while connected to EventStore");
return(ConnectionStatus.ErrorOccurred);
});
var authenticationFailed = Observable.FromEventPattern <ClientAuthenticationFailedEventArgs>(h => connection.AuthenticationFailed += h, h => connection.AuthenticationFailed -= h).Select(arg =>
{
_logger?.LogError($"{nameof(EventStoreConnectionStatusMonitor)} => Authentication failed while connecting to EventStore - [{arg.EventArgs.Reason}]");
return(ConnectionStatus.AuthenticationFailed);
});
_connectionInfoChanged = Observable.Merge(connected, disconnected, reconnecting, closed, errorOccurred, authenticationFailed)
.Scan(ConnectionInfo.InitialDisconnected, UpdateConnectionInfo)
.StartWith(ConnectionInfo.InitialDisconnected)
.Do(connectionInfo =>
{
ConnectionInfo = connectionInfo;
_logger?.LogInformation($"{nameof(EventStoreConnectionStatusMonitor)} => ConnectionInfo - {connectionInfo}");
_isConnected.OnNext(connectionInfo.Status == ConnectionStatus.Connected);
})
.Replay(1);
_cleanUp = _connectionInfoChanged.Connect();
_eventStoreConnection.ConnectAsync().Wait();
}
