Пример #1
0
        public static async Task <int> Main(string[] args)
        {
            try {
                var cts           = new CancellationTokenSource();
                var hostedService = new ClusterVNodeHostedService(args);

                var exitCodeSource = new TaskCompletionSource <int>();
                Application.RegisterExitAction(code => {
                    cts.Cancel();
                    exitCodeSource.SetResult(code);
                });
                Console.CancelKeyPress += delegate {
                    Application.Exit(0, "Cancelled.");
                };

                await CreateHostBuilder(hostedService, args)
                .RunConsoleAsync(options => options.SuppressStatusMessages = true, cts.Token);

                return(await exitCodeSource.Task);
            } catch (Exception ex) {
                Log.Fatal(ex, "Host terminated unexpectedly.");
                return(1);
            } finally {
                Log.CloseAndFlush();
            }
        }
Пример #2
0
 private static IHostBuilder CreateHostBuilder(ClusterVNodeHostedService hostedService, string[] args) =>
 new HostBuilder()
 .ConfigureHostConfiguration(builder =>
                             builder.AddEnvironmentVariables("DOTNET_").AddCommandLine(args ?? Array.Empty <string>()))
 .ConfigureAppConfiguration(builder =>
                            builder.AddEnvironmentVariables().AddCommandLine(args ?? Array.Empty <string>()))
 .ConfigureServices(services => services.AddSingleton <IHostedService>(hostedService))
 .ConfigureLogging(logging => logging.AddSerilog())
 .ConfigureWebHostDefaults(builder =>
                           builder.UseKestrel(server => {
     server.Listen(hostedService.Options.IntIp, hostedService.Options.IntHttpPort,
                   listenOptions => listenOptions.UseHttps(new HttpsConnectionAdapterOptions {
         ServerCertificate           = hostedService.Node.Certificate,
         ClientCertificateMode       = ClientCertificateMode.RequireCertificate,
         ClientCertificateValidation = (certificate, chain, sslPolicyErrors) => {
             var(isValid, error) = hostedService.Node.InternalClientCertificateValidator(certificate, chain,
                                                                                         sslPolicyErrors);
             if (!isValid && error != null)
             {
                 Log.Error("Client certificate validation error: {e}", error);
             }
             return(isValid);
         }
     }));
     server.Listen(hostedService.Options.ExtIp, hostedService.Options.ExtHttpPort,
                   listenOptions => listenOptions.UseHttps(hostedService.Node.Certificate));
 })
                           .ConfigureServices(services => hostedService.Node.Startup.ConfigureServices(services))
                           .Configure(hostedService.Node.Startup.Configure));
Пример #3
0
        public static async Task <int> Main(string[] args)
        {
            try {
                Serilog.Log.Logger = EventStoreLoggerConfiguration.ConsoleLog;
                var cts           = new CancellationTokenSource();
                var hostedService = new ClusterVNodeHostedService(args);

                var exitCodeSource = new TaskCompletionSource <int>();
                Application.RegisterExitAction(code => {
                    cts.Cancel();
                    exitCodeSource.SetResult(code);
                });
                Console.CancelKeyPress += delegate {
                    Application.Exit(0, "Cancelled.");
                };

                if (hostedService.Options.WhatIf)
                {
                    Log.Information("Exiting with exit code: 0.\nExit reason: WhatIf option specified");
                    return((int)ExitCode.Success);
                }

                await CreateHostBuilder(hostedService, args)
                .RunConsoleAsync(options => options.SuppressStatusMessages = true, cts.Token);

                return(await exitCodeSource.Task);
            } catch (Exception ex) {
                Log.Fatal(ex, "Host terminated unexpectedly.");
                return(1);
            } finally {
                Log.CloseAndFlush();
            }
        }
Пример #4
0
        public static async Task Run(ClusterVNodeHostedService hostedService, TaskCompletionSource <int> exitCodeSource, string[] args, CancellationToken token, ManualResetEventSlim signal)
        {
            try {
                await CreateHostBuilder(hostedService, args)
                .RunConsoleAsync(options => options.SuppressStatusMessages = true, token);

                await exitCodeSource.Task;
            } finally {
                signal.Set();
            }
        }
Пример #5
0
 private static IHostBuilder CreateHostBuilder(ClusterVNodeHostedService hostedService, string[] args) =>
 new HostBuilder()
 .ConfigureHostConfiguration(builder =>
                             builder.AddEnvironmentVariables("DOTNET_").AddCommandLine(args ?? Array.Empty <string>()))
 .ConfigureAppConfiguration(builder =>
                            builder.AddEnvironmentVariables().AddCommandLine(args ?? Array.Empty <string>()))
 .ConfigureServices(services => services.AddSingleton <IHostedService>(hostedService))
 .ConfigureLogging(logging => logging.AddSerilog())
 .ConfigureWebHostDefaults(builder =>
                           builder.UseKestrel(server => {
     server.Listen(hostedService.Options.IntIp, hostedService.Options.IntHttpPort);
     server.Listen(hostedService.Options.ExtIp, hostedService.Options.ExtHttpPort,
                   listenOptions => listenOptions.UseHttps(hostedService.Node.Certificate));
 })
                           .ConfigureServices(services => hostedService.Node.Startup.ConfigureServices(services))
                           .Configure(hostedService.Node.Startup.Configure));
Пример #6
0
        private static IHostBuilder CreateHostBuilder(ClusterVNodeHostedService hostedService, string[] args) =>
        new HostBuilder()
        .ConfigureHostConfiguration(builder =>
                                    builder.AddEnvironmentVariables("DOTNET_").AddCommandLine(args ?? Array.Empty <string>()))
        .ConfigureAppConfiguration(builder =>
                                   builder.AddEnvironmentVariables().AddCommandLine(args ?? Array.Empty <string>()))
        .ConfigureServices(services => services.AddSingleton <IHostedService>(hostedService))
        .ConfigureLogging(logging => logging.AddSerilog())
        .ConfigureWebHostDefaults(builder => builder
                                  .UseKestrel(server => {
            server.Limits.Http2.KeepAlivePingDelay =
                TimeSpan.FromMilliseconds(hostedService.Options.KeepAliveInterval);
            server.Limits.Http2.KeepAlivePingTimeout =
                TimeSpan.FromMilliseconds(hostedService.Options.KeepAliveTimeout);
            server.Listen(hostedService.Options.ExtIp, hostedService.Options.HttpPort,
                          listenOptions => {
                if (hostedService.Node.DisableHttps)
                {
                    listenOptions.Use(next =>
                                      new ClearTextHttpMultiplexingMiddleware(next).OnConnectAsync);
                }
                else
                {
                    listenOptions.UseHttps(new HttpsConnectionAdapterOptions {
                        ServerCertificateSelector = delegate {
                            return(hostedService.Node.CertificateSelector());
                        },
                        ClientCertificateMode       = ClientCertificateMode.AllowCertificate,
                        ClientCertificateValidation = (certificate, chain, sslPolicyErrors) => {
                            var(isValid, error) =
                                hostedService.Node.InternalClientCertificateValidator(certificate,
                                                                                      chain,
                                                                                      sslPolicyErrors);
                            if (!isValid && error != null)
                            {
                                Log.Error("Client certificate validation error: {e}", error);
                            }

                            return(isValid);
                        }
                    });
                }
            });
        })
                                  .ConfigureServices(services => hostedService.Node.Startup.ConfigureServices(services))
                                  .Configure(hostedService.Node.Startup.Configure));
Пример #7
0
        public static int Main(string[] args)
        {
            try {
                Serilog.Log.Logger = EventStoreLoggerConfiguration.ConsoleLog;
                var cts           = new CancellationTokenSource();
                var hostedService = new ClusterVNodeHostedService(args);
                if (hostedService.SkipRun)
                {
                    return(0);
                }

                var exitCodeSource = new TaskCompletionSource <int>();
                Application.RegisterExitAction(code => {
                    cts.Cancel();
                    exitCodeSource.SetResult(code);
                });
                Console.CancelKeyPress += delegate {
                    Application.Exit(0, "Cancelled.");
                };

                if (hostedService.Options.WhatIf)
                {
                    Log.Information("Exiting with exit code: 0.\nExit reason: WhatIf option specified");
                    return((int)ExitCode.Success);
                }

                var signal = new ManualResetEventSlim(false);
                using (hostedService) {
                    var t = Run(hostedService, exitCodeSource, args, cts.Token, signal);
                    // ReSharper disable once MethodSupportsCancellation
                    signal.Wait();
                }

                return(exitCodeSource.Task.Result);
            } catch (Exception ex) {
                Log.Fatal(ex, "Host terminated unexpectedly.");
                return(1);
            } finally {
                Log.CloseAndFlush();
            }
        }
Пример #8
0
        public static async Task <int> Main(string[] args)
        {
            ThreadPool.SetMaxThreads(1000, 1000);
            ClusterVNodeOptions options;
            var exitCodeSource = new TaskCompletionSource <int>();
            var cts            = new CancellationTokenSource();

            Log.Logger = EventStoreLoggerConfiguration.ConsoleLog;
            try {
                try {
                    options = ClusterVNodeOptions.FromConfiguration(args, Environment.GetEnvironmentVariables());
                } catch (Exception ex) {
                    Log.Fatal($"Error while parsing options: {ex.Message}");
                    Log.Information($"Options:{Environment.NewLine}{ClusterVNodeOptions.HelpText}");

                    return(1);
                }

                var logsDirectory = string.IsNullOrWhiteSpace(options.Log.Log)
                                        ? Locations.DefaultLogDirectory
                                        : options.Log.Log;
                EventStoreLoggerConfiguration.Initialize(logsDirectory, options.GetComponentName(),
                                                         options.Log.LogConsoleFormat,
                                                         options.Log.LogFileSize,
                                                         options.Log.LogFileInterval,
                                                         options.Log.LogFileRetentionCount,
                                                         options.Log.DisableLogFile,
                                                         options.Log.LogConfig);

                if (options.Application.Help)
                {
                    await Console.Out.WriteLineAsync(ClusterVNodeOptions.HelpText);

                    return(0);
                }

                if (options.Application.Version)
                {
                    await Console.Out.WriteLineAsync(VersionInfo.Text);

                    return(0);
                }

                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(options.DumpOptions());

                var deprecationWarnings = options.GetDeprecationWarnings();
                if (deprecationWarnings != null)
                {
                    Log.Warning($"DEPRECATED{Environment.NewLine}{deprecationWarnings}");
                }

                if (options.Application.Insecure)
                {
                    Log.Warning(
                        "\n==============================================================================================================\n" +
                        "INSECURE MODE IS ON. THIS MODE IS *NOT* RECOMMENDED FOR PRODUCTION USE.\n" +
                        "INSECURE MODE WILL DISABLE ALL AUTHENTICATION, AUTHORIZATION AND TRANSPORT SECURITY FOR ALL CLIENTS AND NODES.\n" +
                        "==============================================================================================================\n");
                }

                if (!options.Cluster.DiscoverViaDns && options.Cluster.GossipSeed.Length == 0 &&
                    options.Cluster.ClusterSize == 1)
                {
                    Log.Information(
                        "DNS discovery is disabled, but no gossip seed endpoints have been specified. Since "
                        + "the cluster size is set to 1, this may be intentional. Gossip seeds can be specified "
                        + "using the `GossipSeed` option.");
                }

                if (options.Application.WhatIf)
                {
                    return(0);
                }

                Application.RegisterExitAction(code => {
                    cts.Cancel();
                    exitCodeSource.SetResult(code);
                });

                Console.CancelKeyPress += delegate {
                    Application.Exit(0, "Cancelled.");
                };
                using (var hostedService = new ClusterVNodeHostedService(options)) {
                    using var signal = new ManualResetEventSlim(false);
                    _ = Run(hostedService, signal);
                    // ReSharper disable MethodSupportsCancellation
                    signal.Wait();
                    // ReSharper restore MethodSupportsCancellation
                }

                return(await exitCodeSource.Task);

                async Task Run(ClusterVNodeHostedService hostedService, ManualResetEventSlim signal)
                {
                    try {
                        await new HostBuilder()
                        .ConfigureHostConfiguration(builder =>
                                                    builder.AddEnvironmentVariables("DOTNET_").AddCommandLine(args))
                        .ConfigureAppConfiguration(builder =>
                                                   builder.AddEnvironmentVariables().AddCommandLine(args))
                        .ConfigureServices(services => services.AddSingleton <IHostedService>(hostedService))
                        .ConfigureLogging(logging => logging.AddSerilog())
                        .ConfigureServices(services => services.Configure <KestrelServerOptions>(
                                               EventStoreKestrelConfiguration.GetConfiguration()))
                        .ConfigureWebHostDefaults(builder => builder
                                                  .UseKestrel(server => {
                            server.Limits.Http2.KeepAlivePingDelay =
                                TimeSpan.FromMilliseconds(options.Grpc.KeepAliveInterval);
                            server.Limits.Http2.KeepAlivePingTimeout =
                                TimeSpan.FromMilliseconds(options.Grpc.KeepAliveTimeout);
                            server.Listen(options.Interface.ExtIp, options.Interface.HttpPort,
                                          listenOptions => {
                                if (hostedService.Node.DisableHttps)
                                {
                                    listenOptions.Use(next =>
                                                      new ClearTextHttpMultiplexingMiddleware(next).OnConnectAsync);
                                }
                                else
                                {
                                    listenOptions.UseHttps(new HttpsConnectionAdapterOptions {
                                        ServerCertificateSelector = delegate {
                                            return(hostedService.Node.CertificateSelector());
                                        },
                                        ClientCertificateMode       = ClientCertificateMode.AllowCertificate,
                                        ClientCertificateValidation = (certificate, chain, sslPolicyErrors) => {
                                            var(isValid, error) =
                                                hostedService.Node.InternalClientCertificateValidator(
                                                    certificate,
                                                    chain,
                                                    sslPolicyErrors);
                                            if (!isValid && error != null)
                                            {
                                                Log.Error("Client certificate validation error: {e}", error);
                                            }

                                            return(isValid);
                                        }
                                    });
                                }
                            });
                        })
                                                  .ConfigureServices(services => hostedService.Node.Startup.ConfigureServices(services))
                                                  .Configure(hostedService.Node.Startup.Configure))
                        .RunConsoleAsync(options => options.SuppressStatusMessages = true, cts.Token);
                    } catch (Exception ex) {
                        Log.Fatal("Error occurred during setup: {e}", ex);
                        exitCodeSource.TrySetResult(1);
                    } finally {
                        signal.Set();
                    }
                }
            } catch (InvalidConfigurationException ex) {
                Log.Fatal("Invalid Configuration: " + ex.Message);
                return(1);
            }
            catch (Exception ex) {
                Log.Fatal(ex, "Host terminated unexpectedly.");
                return(1);
            } finally {
                Log.CloseAndFlush();
            }
        }