private static IEventStoreConnection CreateEventStoreConnection(Serilog.ILogger logger, string connectionString, string connectionName)
{
var connectionSettings = ConnectionSettings.Create()
.KeepReconnecting()
.SetReconnectionDelayTo(TimeSpan.FromSeconds(3))
.KeepRetrying()
.PerformOnAnyNode()
.PreferRandomNode()
.UseCustomLogger(new SerilogEventStoreLogger(logger));
var connection = EventStoreConnection
.Create(connectionString, connectionSettings, connectionName);
connection
.Connected += (sender, args)
=> logger.Information("Connected to Event Store {ConnectionName}", connectionName);
connection.Closed += (sender, args)
=> logger.Information("Connection to Event Store {ConnectionName} closed", connectionName);
connection.Reconnecting += (sender, args)
=> logger.Information("Attempting to connect to Event Store {ConnectionName}", connectionName);
connection.ConnectAsync().GetAwaiter().GetResult();
return(connection);
}
public static IHostBuilder UseSerilog(this IHostBuilder builder,
Serilog.ILogger logger = null, bool dispose = false)
{
builder.ConfigureServices((context, collection) =>
collection.AddSingleton <ILoggerFactory>(services => new SerilogLoggerFactory(logger, dispose)));
return(builder);
}
private readonly PerformanceCounter _totalMemCounter; //doesn't work on mono
public PerfCounterHelper(ILogger log)
{
_log = log;
_totalCpuCounter = CreatePerfCounter("Processor", "% Processor Time", "_Total");
_totalMemCounter = CreatePerfCounter("Memory", "Available Bytes");
}
public static DiskIo GetDiskIo(int procId, Serilog.ILogger logger)
{
try {
return(OS.IsUnix ? GetOnUnix(procId, logger) : GetOnWindows(logger));
} catch (Exception exc) {
Log.Debug("Getting disk IO error: {e}.", exc.Message);
return(null);
}
}
public StreamJoinCoordinator(IEventStoreFacade connection,
Serilog.ILogger logger, IServiceProvider serviceProvider)
{
this._connection = connection;
_logger = logger;
_serviceProvider = serviceProvider;
_readyPastCatchupReceivers = 0;
}
protected EventReaderBasedProjectionProcessingStrategy(
string name, ProjectionVersion projectionVersion, ProjectionConfig projectionConfig,
IQuerySources sourceDefinition, Serilog.ILogger logger, ReaderSubscriptionDispatcher subscriptionDispatcher)
: base(name, projectionVersion, logger)
{
_projectionConfig = projectionConfig;
_sourceDefinition = sourceDefinition;
_subscriptionDispatcher = subscriptionDispatcher;
_isBiState = sourceDefinition.IsBiState;
}
public ReplicatingConsumer(IAmazonKinesis kinesis, KinesisSettings kinesisSettings, DittoSettings dittoSettings, ILogger logger, string streamName, string groupName)
{
_kinesis = kinesis ?? throw new ArgumentNullException(nameof(kinesis));
_kinesisSettings = kinesisSettings ?? throw new ArgumentNullException(nameof(kinesisSettings));
_dittoSettings = dittoSettings ?? throw new ArgumentNullException(nameof(dittoSettings));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
StreamName = streamName ?? throw new ArgumentNullException(nameof(streamName));
GroupName = groupName ?? throw new ArgumentNullException(nameof(groupName));
}
public EventStoreHub(IHubContext <EventStoreHub> context,
ISessionManager sessionManager,
Serilog.ILogger logger,
IClientSessionRegister register, IServiceProvider serviceProvider)
{
_context = context;
_sessionManager = sessionManager;
_logger = logger;
_register = register;
_serviceProvider = serviceProvider;
}
public SystemStatsHelper(ILogger log, ICheckpoint writerCheckpoint, string dbPath, long collectIntervalMs)
{
Ensure.NotNull(log, "log");
Ensure.NotNull(writerCheckpoint, "writerCheckpoint");
_log = log;
_writerCheckpoint = writerCheckpoint;
_perfCounter = new PerfCounterHelper(_log);
_eventCountersHelper = new EventCountersHelper(collectIntervalMs);
_hostStat = new HostStat.HostStat();
_dbPath = dbPath;
}
// http://stackoverflow.com/questions/3633286/understanding-the-counters-in-proc-pid-io
private static DiskIo GetOnUnix(int procId, Serilog.ILogger log)
{
var procIoFile = string.Format("/proc/{0}/io", procId);
if (!File.Exists(procIoFile)) // if no procfs exists/is mounted -- just don't return stats
{
return(null);
}
var procIoStr = File.ReadAllText(procIoFile);
return(ParseOnUnix(procIoStr, log));
}
public async Task Configure(IEventStoreFacade connection, IEventHandlerDispatcher dispatcher, Serilog.ILogger logger)
{
_logger = logger;
_logger.Information("Subscribed for {eventName} for local projections. (with EventDispatcher)", typeof(TEvent).Name);
var stream = $"$et-{typeof(TEvent).Name}";
this._dispatcher = dispatcher;
// Should we wait for the subscription? - or should we re-subscribe
await connection.SubscribeToStreamAsync(stream, OnReadEvent, true);
}
public AggregateEventStream(IEventStoreFacade connection,
IEventConverter eventConverter,
IEventDataFactory eventDataFactory,
IEventMetadataFactory <TAggregate> metadataFactory,
IAggregateSchema <TAggregate> aggregateSchema, Serilog.ILogger logger)
{
_connection = connection;
_eventConverter = eventConverter;
_eventDataFactory = eventDataFactory;
_metadataFactory = metadataFactory;
_aggregateSchema = aggregateSchema;
_logger = logger;
}
protected EventSubscriptionBasedProjectionProcessingPhase(
IPublisher publisher,
IPublisher inputQueue,
ICoreProjectionForProcessingPhase coreProjection,
Guid projectionCorrelationId,
ICoreProjectionCheckpointManager checkpointManager,
ProjectionConfig projectionConfig,
string projectionName,
ILogger logger,
CheckpointTag zeroCheckpointTag,
PartitionStateCache partitionStateCache,
IResultWriter resultWriter,
Action updateStatistics,
ReaderSubscriptionDispatcher subscriptionDispatcher,
IReaderStrategy readerStrategy,
bool useCheckpoints,
bool stopOnEof,
bool orderedPartitionProcessing,
bool isBiState,
IEmittedStreamsTracker emittedStreamsTracker,
bool enableContentTypeValidation)
{
_publisher = publisher;
_inputQueue = inputQueue;
_coreProjection = coreProjection;
_projectionCorrelationId = projectionCorrelationId;
_checkpointManager = checkpointManager;
_projectionConfig = projectionConfig;
_projectionName = projectionName;
_logger = logger;
_zeroCheckpointTag = zeroCheckpointTag;
_partitionStateCache = partitionStateCache;
_resultWriter = resultWriter;
_updateStatistics = updateStatistics;
_processingQueue = new CoreProjectionQueue(publisher,
projectionConfig.PendingEventsThreshold,
orderedPartitionProcessing);
_processingQueue.EnsureTickPending += EnsureTickPending;
_subscriptionDispatcher = subscriptionDispatcher;
_readerStrategy = readerStrategy;
_useCheckpoints = useCheckpoints;
_stopOnEof = stopOnEof;
_isBiState = isBiState;
_progressResultWriter = new ProgressResultWriter(this, _resultWriter);
_inutQueueEnvelope = new PublishEnvelope(_inputQueue);
_emittedStreamsTracker = emittedStreamsTracker;
_enableContentTypeValidation = enableContentTypeValidation;
}
public static EsDriveInfo FromDirectory(string path, Serilog.ILogger log)
{
try {
if (OS.IsUnix)
{
return(GetEsDriveInfoUnix(path, log));
}
var driveName = Directory.GetDirectoryRoot(path);
var drive = new DriveInfo(driveName);
var esDrive = new EsDriveInfo(drive.Name, drive.TotalSize, drive.AvailableFreeSpace);
return(esDrive);
} catch (Exception ex) {
log.Debug("Error while reading drive info for path {path}. Message: {e}.", path, ex.Message);
return(null);
}
}
public ProjectionCheckpoint(
IPublisher publisher,
IODispatcher ioDispatcher,
ProjectionVersion projectionVersion,
ClaimsPrincipal runAs,
IProjectionCheckpointManager readyHandler,
CheckpointTag from,
PositionTagger positionTagger,
int maxWriteBatchLength,
int maximumAllowedWritesInFlight,
ILogger logger = null)
{
if (publisher == null)
{
throw new ArgumentNullException("publisher");
}
if (ioDispatcher == null)
{
throw new ArgumentNullException("ioDispatcher");
}
if (readyHandler == null)
{
throw new ArgumentNullException("readyHandler");
}
if (positionTagger == null)
{
throw new ArgumentNullException("positionTagger");
}
if (from.CommitPosition < from.PreparePosition)
{
throw new ArgumentException("from");
}
//NOTE: fromCommit can be equal fromPrepare on 0 position. Is it possible anytime later? Ignoring for now.
_maximumAllowedWritesInFlight = maximumAllowedWritesInFlight;
_publisher = publisher;
_ioDispatcher = ioDispatcher;
_projectionVersion = projectionVersion;
_runAs = runAs;
_readyHandler = readyHandler;
_positionTagger = positionTagger;
_from = _last = from;
_maxWriteBatchLength = maxWriteBatchLength;
_logger = logger;
_writeQueueIds = Enumerable.Range(0, _maximumAllowedWritesInFlight).Select(x => Guid.NewGuid()).ToArray();
}
internal static DiskIo ParseOnUnix(string procIoStr, Serilog.ILogger log)
{
ulong readBytes, writtenBytes, readOps, writeOps;
try {
var dict = procIoStr.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Split(':'))
.ToDictionary(s => s[0].Trim(), s => s[1].Trim());
readBytes = ulong.Parse(dict["read_bytes"]);
writtenBytes = ulong.Parse(dict["write_bytes"]);
readOps = ulong.Parse(dict["syscr"]);
writeOps = ulong.Parse(dict["syscw"]);
} catch (Exception ex) {
log.Information(ex, "Could not parse Linux stats.");
return(null);
}
return(new DiskIo(readBytes, writtenBytes, readOps, writeOps));
}
public LoginViewModel(
IScreen hostScreen = null,
IAccountApiService accountApiService = null,
IDialogService dialogService = null,
IAppUserModelService appUserModelService = null,
IUserApiService userApiService = null,
ILogger logger = null)
{
_accountApiService = accountApiService ?? Locator.Current.GetService <IAccountApiService>();
_dialogService = dialogService ?? Locator.Current.GetService <IDialogService>();
_appUserModelService = appUserModelService ?? Locator.Current.GetService <IAppUserModelService>();
_userApiService = userApiService ?? Locator.Current.GetService <IUserApiService>();
_logger = logger ?? Locator.Current.GetService <ILogger>();
GoToRegisterCommand = ReactiveCommand.CreateFromTask(GoToRegister);
var validateLoginDetailsObservable = this.WhenAnyValue(vm => vm.Username, vm => vm.Password,
(un, pw) => SetIsUsernameValid(un) && SetIsPasswordValid(pw)).StartWith(false);
validateLoginDetailsObservable.ToProperty(this, vm => vm.CanSubmit, out _canSubmitPropertyHelper);
LoginCommand = ReactiveCommand.CreateFromTask(Login, validateLoginDetailsObservable);
}
public CommandProcessorContext(Client client, ILogger log, ManualResetEventSlim doneEvent)
{
Client = client;
Log = log;
_doneEvent = doneEvent;
}
public EventStoreSubscriber(IEventStoreFacade connection, IEventHandlerDispatcher dispatcher, ILogger logger)
{
this._connection = connection;
this._dispatcher = dispatcher;
this._logger = logger;
}
public ClientApiLoggerBridge(ILogger log)
{
Ensure.NotNull(log, "log");
_log = log;
}
public CommandsProcessor(ILogger log)
{
_log = log;
}
public CoreProjection(
ProjectionProcessingStrategy projectionProcessingStrategy,
ProjectionVersion version,
Guid projectionCorrelationId,
IPublisher inputQueue,
Guid workerId,
ClaimsPrincipal runAs,
IPublisher publisher,
IODispatcher ioDispatcher,
ReaderSubscriptionDispatcher subscriptionDispatcher,
ILogger logger,
ProjectionNamesBuilder namingBuilder,
CoreProjectionCheckpointWriter coreProjectionCheckpointWriter,
PartitionStateCache partitionStateCache,
string effectiveProjectionName,
ITimeProvider timeProvider)
{
if (publisher == null)
{
throw new ArgumentNullException("publisher");
}
if (ioDispatcher == null)
{
throw new ArgumentNullException("ioDispatcher");
}
if (subscriptionDispatcher == null)
{
throw new ArgumentNullException("subscriptionDispatcher");
}
_projectionProcessingStrategy = projectionProcessingStrategy;
_projectionCorrelationId = projectionCorrelationId;
_inputQueue = inputQueue;
_workerId = workerId;
_runAs = runAs;
_name = effectiveProjectionName;
_version = version;
_stopOnEof = projectionProcessingStrategy.GetStopOnEof();
_logger = logger ?? Serilog.Log.ForContext <CoreProjection>();
_publisher = publisher;
_ioDispatcher = ioDispatcher;
_partitionStateCache = partitionStateCache;
_requiresRootPartition = projectionProcessingStrategy.GetRequiresRootPartition();
var useCheckpoints = projectionProcessingStrategy.GetUseCheckpoints();
_coreProjectionCheckpointWriter = coreProjectionCheckpointWriter;
_projectionProcessingPhases = projectionProcessingStrategy.CreateProcessingPhases(
publisher,
inputQueue,
projectionCorrelationId,
partitionStateCache,
UpdateStatistics,
this,
namingBuilder,
timeProvider,
ioDispatcher,
coreProjectionCheckpointWriter);
//NOTE: currently assuming the first checkpoint manager to be able to load any state
_checkpointReader = new CoreProjectionCheckpointReader(
publisher,
_projectionCorrelationId,
ioDispatcher,
namingBuilder.MakeCheckpointStreamName(),
_version,
useCheckpoints);
_enrichStatistics = projectionProcessingStrategy.EnrichStatistics;
GoToState(State.Initial);
}
public IgniteLauncher(string rootPath, ILogger logger, LogLevel minLogLevel)
{
this.rootPath = rootPath;
this.logger = logger;
this.minLogLevel = minLogLevel;
}
public MyLogger(Serilog.ILogger logger)
{
_logger = logger;
}
public Status(ILogger log)
{
Ensure.NotNull(log, "log");
_log = log;
}
