private void Init(TOptions options)
{
Application.AddDefines(options.Defines);
var projName = Assembly.GetEntryAssembly().GetName().Name.Replace(".", " - ");
var componentName = GetComponentName(options);
Console.Title = string.Format("{0}, {1}", projName, componentName);
string logsDirectory = Path.GetFullPath(options.Log.IsNotEmptyString() ? options.Log : GetLogsDirectory(options));
LogManager.Init(componentName, logsDirectory, Locations.DefaultConfigurationDirectory);
Log.Info("\n{0,-25} {1} ({2}/{3}, {4})\n"
+ "{5,-25} {6} ({7})\n"
+ "{8,-25} {9} ({10}-bit)\n"
+ "{11,-25} {12}\n"
+ "{13,-25} {14}\n\n"
+ "{15}",
"ES VERSION:", VersionInfo.Version, VersionInfo.Branch, VersionInfo.Hashtag, VersionInfo.Timestamp,
"OS:", OS.OsFlavor, Environment.OSVersion,
"RUNTIME:", OS.GetRuntimeVersion(), Marshal.SizeOf(typeof(IntPtr)) * 8,
"GC:", GC.MaxGeneration == 0 ? "NON-GENERATION (PROBABLY BOEHM)" : string.Format("{0} GENERATIONS", GC.MaxGeneration + 1),
"LOGS:", LogManager.LogsDirectory,
EventStoreOptions.DumpOptions());
if (options.WhatIf)
{
Application.Exit(ExitCode.Success, "WhatIf option specified");
}
}
public void should_use_the_supplied_argument()
{
var args = new[] { "--log=~/customLogDirectory" };
var testArgs = EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix);
Assert.AreEqual("~/customLogDirectory", testArgs.Log);
}
private void Init(TOptions options)
{
Application.AddDefines(options.Defines);
var projName = Assembly.GetEntryAssembly().GetName().Name.Replace(".", " - ");
var componentName = GetComponentName(options);
Console.Title = string.Format("{0}, {1}", projName, componentName);
string logsDirectory = Path.GetFullPath(options.Log.IsNotEmptyString() ? options.Log : GetLogsDirectory(options));
bool structuredLog = GetIsStructuredLog(options);
LogManager.Init(componentName, logsDirectory, structuredLog, Locations.DefaultConfigurationDirectory);
Log.Info("\n{description,-25} {version} ({branch}/{hashtag}, {timestamp})", "ES VERSION:", VersionInfo.Version, VersionInfo.Branch, VersionInfo.Hashtag, VersionInfo.Timestamp);
Log.Info("{description,-25} {osFlavor} ({osVersion})", "OS:", OS.OsFlavor, Environment.OSVersion);
Log.Info("{description,-25} {osRuntimeVersion} ({architecture}-bit)", "RUNTIME:", OS.GetRuntimeVersion(), Marshal.SizeOf(typeof(IntPtr)) * 8);
Log.Info("{description,-25} {maxGeneration}", "GC:", GC.MaxGeneration == 0 ? "NON-GENERATION (PROBABLY BOEHM)" : string.Format("{0} GENERATIONS", GC.MaxGeneration + 1));
Log.Info("{description,-25} {logsDirectory}", "LOGS:", LogManager.LogsDirectory);
if (!structuredLog)
{
Log.Info("{esOptions}", EventStoreOptions.DumpOptions());
}
else
{
Log.Info("{@esOptions}", EventStoreOptions.DumpOptionsStructured());
}
if (options.WhatIf)
{
Application.Exit(ExitCode.Success, "WhatIf option specified");
}
}
public void should_warn_the_user_about_unknown_argument_when_from_command_line()
{
var args = new string[] { "-unknown-option", "true" };
var optionException = Assert.Throws <OptionException>(() => { EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix); });
Assert.True(optionException.Message.Contains("unknownoption"));
}
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(options =>
{
options.AddPolicy("CorsPolicy",
builder => builder.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader()
.AllowCredentials());
});
services.AddMvcCore().AddApiExplorer().AddJsonFormatters();
services.AddSwaggerGen(c =>
c.SwaggerDoc("v1", new Info {
Title = "Voting API", Version = "v1"
})
);
services.AddEasyEventSourcing(
EventStoreOptions.Create(
Configuration["EVENT_STORE"],
Configuration["EVENT_STORE_MANAGER_HOST"],
Configuration["STREAM_NAME"]),
ReflectionHelper.DomainAssembly);
services.AddWebSocketManager();
services.AddSingleton <VotingReadModelService>();
}
public void should_use_the_argument_over_the_config_file_value()
{
var args = new string[] { "-config", "TestConfigs/test_config.yaml", "-log", "~/customLogsDirectory" };
var testArgs = EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix);
Assert.AreEqual("~/customLogsDirectory", testArgs.Log);
}
public void should_warn_the_user_about_unknown_argument_when_from_config_file()
{
var args = new string[] { "-config", "TestConfigs/test_config_with_unknown_option.yaml" };
var optionException = Assert.Throws <OptionException>(() => { EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix); });
Assert.True(optionException.Message.Contains("UnknownOption"));
}
private void Init(TOptions options)
{
Application.AddDefines(options.Defines);
var projName = Assembly.GetEntryAssembly().GetName().Name.Replace(".", " - ");
var componentName = GetComponentName(options);
Console.Title = $"{projName}, {componentName}";
string logsDirectory =
Path.GetFullPath(options.Log.IsNotEmptyString() ? options.Log : GetLogsDirectory(options));
EventStoreLoggerConfiguration.Initialize(logsDirectory, componentName);
Log.Information("\n{description,-25} {version} ({branch}/{hashtag}, {timestamp})", "ES VERSION:",
VersionInfo.Version, VersionInfo.Branch, VersionInfo.Hashtag, VersionInfo.Timestamp);
Log.Information("{description,-25} {osFlavor} ({osVersion})", "OS:", OS.OsFlavor, Environment.OSVersion);
Log.Information("{description,-25} {osRuntimeVersion} ({architecture}-bit)", "RUNTIME:",
OS.GetRuntimeVersion(),
Marshal.SizeOf(typeof(IntPtr)) * 8);
Log.Information("{description,-25} {maxGeneration}", "GC:",
GC.MaxGeneration == 0
? "NON-GENERATION (PROBABLY BOEHM)"
: $"{GC.MaxGeneration + 1} GENERATIONS");
Log.Information("{description,-25} {logsDirectory}", "LOGS:", logsDirectory);
Log.Information(EventStoreOptions.DumpOptions());
if (options.WhatIf)
{
Application.Exit(ExitCode.Success, "WhatIf option specified");
}
}
protected ProgramBase(string[] args)
{
Application.RegisterExitAction(Exit);
try {
var options = EventStoreOptions.Parse <TOptions>(args, Opts.EnvPrefix,
Path.Combine(Locations.DefaultConfigurationDirectory, DefaultFiles.DefaultConfigFile),
MutateEffectiveOptions);
if (options.Help)
{
Console.WriteLine("Options:");
Console.WriteLine(EventStoreOptions.GetUsage <TOptions>());
_skipRun = true;
}
else if (options.Version)
{
Console.WriteLine("EventStore version {0} ({1}/{2}, {3})",
VersionInfo.Version, VersionInfo.Branch, VersionInfo.Hashtag, VersionInfo.Timestamp);
_skipRun = true;
}
else
{
PreInit(options);
Init(options);
Create(options);
_startupSource.SetResult(true);
}
} catch (OptionException exc) {
Console.Error.WriteLine("Error while parsing options:");
Console.Error.WriteLine(FormatExceptionMessage(exc));
Console.Error.WriteLine();
Console.Error.WriteLine("Options:");
Console.Error.WriteLine(EventStoreOptions.GetUsage <TOptions>());
_startupSource.SetException(exc);
} catch (ApplicationInitializationException ex) {
var msg = String.Format("Application initialization error: {0}", FormatExceptionMessage(ex));
if (LogManager.Initialized)
{
Log.FatalException(ex, msg);
}
else
{
Console.Error.WriteLine(msg);
}
_startupSource.SetException(ex);
} catch (Exception ex) {
var msg = "Unhandled exception while starting application:";
if (LogManager.Initialized)
{
Log.FatalException(ex, msg);
}
else
{
Console.Error.WriteLine(msg);
Console.Error.WriteLine(FormatExceptionMessage(ex));
}
_startupSource.SetException(ex);
} finally {
Log.Flush();
}
}
public void with_config()
{
var configFile = HelperExtensions.GetFilePathFromAssembly("TestConfigs/invalid_format_config.yaml");
var args = new string[] { "-config", configFile };
Assert.Throws <OptionException>(() => { EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix); });
}
protected EventStoreHostedService(string[] args)
{
try {
Options = EventStoreOptions.Parse <TOptions>(args, Opts.EnvPrefix,
Path.Combine(Locations.DefaultConfigurationDirectory, DefaultFiles.DefaultConfigFile),
MutateEffectiveOptions);
if (Options.Help)
{
Console.WriteLine("Options:");
Console.WriteLine(EventStoreOptions.GetUsage <TOptions>());
_skipRun = true;
}
else if (Options.Version)
{
Console.WriteLine("EventStore version {0} ({1}/{2}, {3})",
VersionInfo.Version, VersionInfo.Branch, VersionInfo.Hashtag, VersionInfo.Timestamp);
_skipRun = true;
}
else
{
PreInit(Options);
Init(Options);
Create(Options);
}
} catch (OptionException exc) {
Console.Error.WriteLine("Error while parsing options:");
Console.Error.WriteLine(FormatExceptionMessage(exc));
Console.Error.WriteLine();
Console.Error.WriteLine("Options:");
Console.Error.WriteLine(EventStoreOptions.GetUsage <TOptions>());
throw;
}
}
public UserController(IOptions <EventStoreOptions> eventStoreOptions, IHttpClientFactory httpClientfactory, DaprClient daprClient)
{
_eventStoreOptions = eventStoreOptions.Value;
_httpClientFactory = httpClientfactory;
_evtStoreBaseUrl = $"http://{_eventStoreOptions.Host}:{_eventStoreOptions.Port}/eventstores/{_eventStoreOptions.Name}/entities";
_daprClient = daprClient;
}
public EventStoreOptionsBuilder(
[NotNull] EventStoreOptions options)
{
Check.NotNull(options, nameof(options));
Options = options;
}
public void should_use_the_defaults()
{
var args = new string[] { };
var testArgs = EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix);
Assert.AreEqual("~/logs", testArgs.Log);
}
public void should_use_the_config_file_value()
{
var args = new string[] { "-config", "TestConfigs/test_config.yaml" };
var testArgs = EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix);
Assert.AreEqual("~/logDirectoryFromConfigFile", testArgs.Log);
}
private static void AssertDefaultEventStoreOptions(EventStoreOptions sut)
{
Assert.Equal(sut.ConnectionString, "tcp://*****:*****@localhost:1113");
Assert.Equal(sut.ManagerHost, "localhost:2113");
Assert.Equal(sut.Credentials.Password, "changeit");
Assert.Equal(sut.Credentials.Username, "admin");
}
public static ISopiBuilder AddDomainEventStore(this ISopiBuilder builder,
Action <EventStoreOptions> configureOptions)
{
var opt = new EventStoreOptions();
configureOptions.Invoke(opt);
builder.Services.AddEventStoreConnection(configureOptions);
builder.Services.PostConfigure <SopiOptions>(c =>
{
c.DomainEventStore = SopiOptions.DomainEventStoreEventStore;
});
//var options = new EventStoreOptions();
//configureOptions(options);
//builder.GetHealthChecksBuilder()
// .Add(new HealthCheckRegistration(
// "eventstore",
// provider => new SopiEventStoreHealthCheck(provider.GetRequiredService<EventStoreConnectionProvider>()),
// null,
// null));
return(builder);
}
public void should_be_able_to_parse_the_option_ignoring_casing()
{
var args = new string[] { "-config", "TestConfigs/test_config_with_incorrectly_cased_option.yaml" };
var options = EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix);
Assert.AreEqual("~/gesLogs", options.Log);
Assert.AreEqual(ProjectionType.All, options.RunProjections);
}
private static async Task CreateSubscription(IEventStoreConnection conn, EventStoreOptions options)
{
var settings = PersistentSubscriptionSettings.Create()
.ResolveLinkTos()
.StartFromCurrent();
await conn.CreatePersistentSubscriptionAsync(options.Subscription.stream, options.Subscription.group, settings, options.Credentials);
}
public void should_not_require_equals_in_method()
{
var args = new[] { "--log", "./customLogDirectory", "--run-projections", "all" };
var testArgs = EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix);
Assert.AreEqual("./customLogDirectory", testArgs.Log);
Assert.AreEqual(ProjectionType.All, testArgs.RunProjections);
}
public Startup(ILoggerFactory loggerFactory)
{
var builder = new ConfigurationBuilder().AddEnvironmentVariables();
Configuration = builder.Build();
loggerFactory.AddConsole();
EventStoreOptions = EventStoreOptions.Create(Configuration);
}
public void should_use_the_environment_variable_over_the_default_value()
{
Environment.SetEnvironmentVariable(String.Format("{0}HTTP_PORT", Opts.EnvPrefix), "2111");
var args = new string[] { };
var testArgs = EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix);
Assert.AreEqual(2111, testArgs.HttpPort);
}
public void with_environment_variable()
{
Environment.SetEnvironmentVariable(Opts.EnvPrefix + "HTTP_PORT", "invalid_format");
var args = new string[] { };
Assert.Throws <OptionException>(() => { EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix); });
Environment.SetEnvironmentVariable(Opts.EnvPrefix + "HTTP_PORT", null);
}
public void should_use_the_config_file_value()
{
var configFile = HelperExtensions.GetFilePathFromAssembly("TestConfigs/test_config.yaml");
var args = new string[] { "-config", configFile };
var testArgs = EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix);
Assert.AreEqual("~/logDirectoryFromConfigFile", testArgs.Log);
}
public void should_inform_the_user_of_the_incorrectly_cased_option()
{
var args = new string[] { "-config", "TestConfigs/test_config_with_incorrectly_cased_option.yaml" };
var optionException = Assert.Throws <OptionException>(() => { EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix); });
Assert.That(optionException.Message.Contains("log should be Log"));
Assert.That(optionException.Message.Contains("runProjections should be RunProjections"));
}
public DynamoDbEventStore(IAmazonDynamoDB dynamoDb, EventStoreOptions options)
{
_context = new DynamoDBContext(dynamoDb);
_configuration = new DynamoDBOperationConfig()
{
OverrideTableName = options.StoreName
};
}
private void AddEventStore(IServiceCollection services)
{
var options = EventStoreOptions.Create(Configuration);
services.AddSingleton(EventStoreConnectionFactory.Create(options.ConnectionString));
services.AddSingleton(new EventTypeResolver(ReflectionHelper.MessagesAssembly));
services.AddTransient <IRepository, EventStoreRepository>();
}
public void should_use_the_config_value_over_the_environment_variable()
{
Environment.SetEnvironmentVariable(String.Format("{0}HTTP_PORT", Opts.EnvPrefix), "2111");
var args = new string[] { "-config", "TestConfigs/test_config.yaml" };
var testArgs = EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix);
Assert.AreEqual(2115, testArgs.HttpPort);
}
public void should_use_the_command_line_argument()
{
Environment.SetEnvironmentVariable(String.Format("{0}HTTP_PORT", Opts.EnvPrefix), "2111");
var args = new string[] { "-config", "TestConfigs/test_config.yaml", "-httpPort", "2115" };
var testArgs = EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix);
Assert.AreEqual(2115, testArgs.HttpPort);
Environment.SetEnvironmentVariable(String.Format("{0}HTTP_PORT", Opts.EnvPrefix), String.Empty);
}
public void should_not_contain_the_unknown_option_in_the_dumping_of_the_options_environment_variable()
{
Environment.SetEnvironmentVariable(String.Format("{0}UNKNOWN_OPTION", Opts.EnvPrefix), "true");
var args = new string[] { };
EventStoreOptions.Parse <TestArgs>(args, Opts.EnvPrefix);
Assert.False(EventStoreOptions.DumpOptions().Contains(String.Format("{0}UNKNOWN_OPTION", Opts.EnvPrefix)));
}
