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(); }