public async Task CanGetVersionViaHttpTransport() { var host = new WebHostBuilder() .ConfigureServices(services => { services.AddSingleton <ILoggerFactory>(LoggerFactory); services.AddHwiServer(); }) .Configure(app => { app.UseHwiServer(); }) .UseKestrel(kestrel => { kestrel.Listen(IPAddress.Loopback, 0); }) .UseStartup <Startup>() .Build(); try { await host.StartAsync(); var address = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses.First(); var version = await new HwiClient(Network.Main) { Transport = new HttpTransport(address) }.GetVersionAsync(); Logger.LogInformation(version.ToString()); } finally { await host.StopAsync(); } }
internal static void Main(string[] args) { using (IWebHost webHost = new WebHostBuilder() // Use the Kestrel server, listen on port 1234 .UseKestrel(o => o.ListenAnyIP(1234)) .UseSetting(WebHostDefaults.SuppressStatusMessagesKey, "True") // Set the internal web host logging .ConfigureLogging(b => b.AddConsole().SetMinimumLevel(LogLevel.Debug)) // Add MVC service and logging service to make logging dependency injection available to the MVC controllers .ConfigureServices(s => s.AddLogging().AddMvc()) // Add MVC to the request pipeline .Configure(b => b.UseMvc()) .Build()) { // Startup // Run the web host, the resulting task completes when the web host is stopped Task webHostRunTask = webHost.RunAsync(); // Running while (!sShutdown) { // Do other stuff with the main thread if (!sShutdown) { Thread.Sleep(1000); } } // Shutdown // On shutdown, stop the web host gracefully webHost.StopAsync(); // And wait for the task to complete that denotes it has shutdown webHostRunTask.Wait(); } }
public static async Task RunDevToolsProxyAsync(ProxyOptions options, string[] args, ILoggerFactory loggerFactory, CancellationToken token) { string proxyUrl = $"http://127.0.0.1:{options.DevToolsProxyPort}"; IWebHost host = new WebHostBuilder() .UseSetting("UseIISIntegration", false.ToString()) .UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseStartup <Startup>() .ConfigureServices(services => { services.AddSingleton(loggerFactory); services.AddLogging(configure => configure.AddSimpleConsole().AddFilter(null, LogLevel.Information)); services.AddSingleton(Options.Create(options)); services.AddRouting(); }) .ConfigureAppConfiguration((hostingContext, config) => { config.AddCommandLine(args); }) .UseUrls(proxyUrl) .Build(); if (token.CanBeCanceled) { token.Register(async() => await host.StopAsync()); } await host.RunAsync(token); }
public static string Start(EditorSessionManager mgr, CancellationToken cancel, int port = 0) { var host = new WebHostBuilder() .UseKestrel() .UseUrls($"http://localhost:{port}/") .UseStartup <Startup>() .UseContentRoot(Directory.GetCurrentDirectory()) .ConfigureServices(sc => sc.AddSingleton(mgr)) .Build(); host.Start(); var addr = host.ServerFeatures.Get <IServerAddressesFeature>(); Log.Message($"Web listening on {string.Join(", ", addr.Addresses)}"); cancel.Register(() => { host.StopAsync().Wait(); }); return(addr.Addresses.First()); }
public static IApplicationBuilder UseBranchWithServices <TStartup>(this IApplicationBuilder app, string url, IConfiguration configuration) where TStartup : class { var feature = app.ServerFeatures; var webHostBuilder = new WebHostBuilder() .UseContentRoot(Directory.GetCurrentDirectory()) .UseConfiguration(configuration) .UseParentServiceProvider(app.ApplicationServices, configuration) .UseFakeServer(feature) .UseStartup <TStartup>() .Build(); var lifetime = app.ApplicationServices.GetRequiredService <IHostApplicationLifetime>(); var r2 = lifetime.ApplicationStopping.Register(() => webHostBuilder.StopAsync().GetAwaiter().GetResult()); Func <HttpContext, Task> branchDelegate = async ctx => { var server = webHostBuilder.Services.GetRequiredService <FakeServer>(); var nestedFactory = webHostBuilder.Services.GetRequiredService <IServiceScopeFactory>(); using (var nestedScope = nestedFactory.CreateScope()) { ctx.RequestServices = new BranchedServiceProvider(ctx.RequestServices, nestedScope.ServiceProvider); await server.Process(ctx); } }; webHostBuilder.Start(); return(app.Map(url, builder => { builder.Use(async(context, next) => { var keepAlive = r2; await branchDelegate(context); }); })); }
public static async Task Main(string[] args) { var host = new WebHostBuilder() .UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseModularStartup <Startup>() .UseUrls(Environment.GetEnvironmentVariable("ASPNETCORE_URLS") ?? "http://localhost:5000/") .Build(); await host.StartAsync(); Console.WriteLine("Press Enter"); Console.ReadLine(); using var container = GetContainer(); var runner = container.Resolve <IConsoleRunner>(); var result = await runner.Run(args); Environment.ExitCode = result; await host.StopAsync(); }
static void Main(string[] args) { DotBPE.Rpc.Environment.SetLogger(new DotBPE.Rpc.Logging.ConsoleLogger()); // 启动HTTP服务 var urls = "http://127.0.0.1:6200"; var webHost = new WebHostBuilder() .UseKestrel() .UseUrls(urls) .UseStartup <Startup>() .Build(); webHost.StartAsync().Wait(); Console.WriteLine("running http server listen {0}", urls); // RPC Server string ip = "127.0.0.1"; int port = 6201; var rpcHost = new RpcHostBuilder() .UseServer(ip, 6201) .UseStartup <DotBPEStartup>() .Build(); rpcHost.StartAsync().Wait(); Console.WriteLine("running server on {0}:{1}", ip, port); Console.WriteLine("press any key to shutdown"); Console.ReadKey(); webHost.StopAsync().Wait(); Console.WriteLine("http server is shutdown"); rpcHost.ShutdownAsync().Wait(); Console.WriteLine("dotbpe server is shutdown"); }
static void Main(string[] args) { var cmd = new CommandLineApplication { Name = "Arashi.Aoi", Description = "ArashiDNS.Aoi - Lightweight DNS over HTTPS Server" + Environment.NewLine + $"Copyright (c) {DateTime.Now.Year} Milkey Tan. Code released under the Mozilla Public License 2.0" + Environment.NewLine + "https://github.com/mili-tan/ArashiDNS.Aoi/blob/master/CREDITS.md" }; cmd.HelpOption("-?|-h|--help"); var ipOption = cmd.Option <string>("-l|--listen <IPEndPoint>", "Set server listening address and port <127.0.0.1:2020>", CommandOptionType.SingleValue); var upOption = cmd.Option <string>("-u|--upstream <IPAddress>", "Set upstream origin DNS server IP address <8.8.8.8>", CommandOptionType.SingleValue); var buOption = cmd.Option <string>("-b|--backupstream <IPAddress>", "Set backup upstream DNS server IP address <8.8.8.8>", CommandOptionType.SingleValue); var timeoutOption = cmd.Option <int>("-t|--timeout <Timeout(ms)>", "Set timeout for query to upstream DNS server <500>", CommandOptionType.SingleValue); var retriesOption = cmd.Option <int>("-r|--retries <Int>", "Set number of retries for query to upstream DNS server <5>", CommandOptionType.SingleValue); var perfixOption = cmd.Option <string>("-p|--perfix <PerfixString>", "Set your DNS over HTTPS server query prefix </dns-query>", CommandOptionType.SingleValue); var cacheOption = cmd.Option("-c|--cache:<Type>", "Local query cache settings [full/flexible/none]", CommandOptionType.SingleOrNoValue); var logOption = cmd.Option("--log:<Type>", "Console log output settings [full/dns/none]", CommandOptionType.SingleOrNoValue); var chinaListOption = cmd.Option("-cn|--chinalist", "Set enable ChinaList", CommandOptionType.NoValue); var tcpOption = cmd.Option("--tcp", "Set enable upstream DNS query using TCP only", CommandOptionType.NoValue); var httpsOption = cmd.Option("-s|--https", "Set enable HTTPS", CommandOptionType.NoValue); var pfxOption = cmd.Option <string>("-pfx|--pfxfile <FilePath>", "Set your pfx certificate file path <./cert.pfx>", CommandOptionType.SingleOrNoValue); var pfxPassOption = cmd.Option <string>("-pass|--pfxpass <Password>", "Set your pfx certificate password <password>", CommandOptionType.SingleOrNoValue); var pemOption = cmd.Option <string>("-pem|--pemfile <FilePath>", "Set your pem certificate file path <./cert.pem>", CommandOptionType.SingleOrNoValue); var keyOption = cmd.Option <string>("-key|--keyfile <FilePath>", "Set your pem certificate key file path <./cert.key>", CommandOptionType.SingleOrNoValue); var syncmmdbOption = cmd.Option <string>("--syncmmdb", "Sync MaxMind GeoLite2 DB", CommandOptionType.NoValue); var synccnlsOption = cmd.Option <string>("--synccnls", "Sync China White List", CommandOptionType.NoValue); var noecsOption = cmd.Option("--noecs", "Set force disable active EDNS Client Subnet", CommandOptionType.NoValue); var transidOption = cmd.Option("--transid", "Set enable DNS Transaction ID", CommandOptionType.NoValue); var showOption = cmd.Option("--show", "Show current active configuration", CommandOptionType.NoValue); var saveOption = cmd.Option("--save", "Save active configuration to config.json file", CommandOptionType.NoValue); var loadOption = cmd.Option <string>("--load:<FilePath>", "Load existing configuration from config.json file [./config.json]", CommandOptionType.SingleOrNoValue); var loadcnOption = cmd.Option <string>("--loadcn:<FilePath>", "Load existing configuration from cnlist.json file [./cnlist.json]", CommandOptionType.SingleOrNoValue); var testOption = cmd.Option("-e|--test", "Exit after passing the test", CommandOptionType.NoValue); var ipipOption = cmd.Option("--ipip", string.Empty, CommandOptionType.NoValue); var rankOption = cmd.Option("--rank", string.Empty, CommandOptionType.NoValue); var adminOption = cmd.Option("--admin", string.Empty, CommandOptionType.NoValue); var noUpdateOption = cmd.Option("-nu|--noupdate", string.Empty, CommandOptionType.NoValue); ipipOption.ShowInHelpText = false; adminOption.ShowInHelpText = false; synccnlsOption.ShowInHelpText = false; noUpdateOption.ShowInHelpText = false; chinaListOption.ShowInHelpText = false; loadcnOption.ShowInHelpText = false; if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { pemOption.ShowInHelpText = false; keyOption.ShowInHelpText = false; } cmd.OnExecute(() => { if (loadOption.HasValue()) { Config = JsonConvert.DeserializeObject <AoiConfig>( string.IsNullOrWhiteSpace(loadOption.Value()) ? File.ReadAllText("config.json") : File.ReadAllText(loadOption.Value())); } if (loadcnOption.HasValue()) { DNSChinaConfig.Config = JsonConvert.DeserializeObject <DNSChinaConfig>( string.IsNullOrWhiteSpace(loadcnOption.Value()) ? File.ReadAllText("cnlist.json") : File.ReadAllText(loadcnOption.Value())); } Console.WriteLine(cmd.Description); var ipEndPoint = ipOption.HasValue() ? IPEndPoint.Parse(ipOption.Value()) : httpsOption.HasValue() ? new IPEndPoint(IPAddress.Loopback, 443) : new IPEndPoint(IPAddress.Loopback, 2020); if ((File.Exists("/.dockerenv") || Environment.GetEnvironmentVariables().Contains("ARASHI_RUNNING_IN_CONTAINER") || Environment.GetEnvironmentVariables().Contains("ARASHI_ANY")) && !ipOption.HasValue()) { ipEndPoint.Address = IPAddress.Any; } if (Environment.GetEnvironmentVariables().Contains("PORT") && !ipOption.HasValue()) { try { if (string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("PORT"))) { throw new Exception(); } ipEndPoint.Port = Convert.ToInt32(Environment.GetEnvironmentVariable("PORT")); } catch (Exception) { Console.WriteLine("Failed to get $PORT Environment Variable"); } } try { if (Dns.GetHostAddresses(Dns.GetHostName()).All(ip => IPAddress.IsLoopback(ip) || ip.AddressFamily == AddressFamily.InterNetworkV6)) { Config.UpStream = "2001:4860:4860::8888"; Config.BackUpStream = "2001:4860:4860::8844"; Console.WriteLine("May run on IPv6 single stack network"); } } catch (Exception e) { Console.WriteLine(e); } try { if (PortIsUse(53) && LocalDnsIsOk() && !upOption.HasValue()) { Config.UpStream = IPAddress.Loopback.ToString(); Console.WriteLine("Use localhost:53 dns server as upstream"); } } catch (Exception e) { Console.WriteLine(e); } if (upOption.HasValue()) { Config.UpStream = upOption.Value(); } if (buOption.HasValue()) { Config.BackUpStream = buOption.Value(); } if (timeoutOption.HasValue()) { Config.TimeOut = timeoutOption.ParsedValue; } if (retriesOption.HasValue()) { Config.Retries = retriesOption.ParsedValue; } if (perfixOption.HasValue()) { Config.QueryPerfix = "/" + perfixOption.Value().Trim('/').Trim('\\'); } Config.CacheEnable = cacheOption.HasValue(); Config.ChinaListEnable = chinaListOption.HasValue(); Config.RankEnable = rankOption.HasValue(); Config.LogEnable = logOption.HasValue(); Config.OnlyTcpEnable = tcpOption.HasValue(); Config.EcsEnable = !noecsOption.HasValue(); Config.UseAdminRoute = adminOption.HasValue(); Config.UseIpRoute = ipipOption.HasValue(); Config.TransIdEnable = transidOption.HasValue(); if (logOption.HasValue() && !string.IsNullOrWhiteSpace(logOption.Value())) { var val = logOption.Value().ToLower().Trim(); if (val == "full") { Config.FullLogEnable = true; } else if (val is "none" or "null" or "off") { Config.LogEnable = false; } } if (cacheOption.HasValue() && !string.IsNullOrWhiteSpace(cacheOption.Value())) { var val = cacheOption.Value().ToLower().Trim(); if (val == "full") { Config.GeoCacheEnable = false; } else if (val is "none" or "null" or "off") { Config.CacheEnable = false; } } if (Config.CacheEnable && Config.GeoCacheEnable || syncmmdbOption.HasValue() || Config.RankEnable) { var setupBasePath = AppDomain.CurrentDomain.SetupInformation.ApplicationBase; Console.WriteLine( "This product includes GeoLite2 data created by MaxMind, available from https://www.maxmind.com"); if (syncmmdbOption.HasValue()) { if (File.Exists(setupBasePath + "GeoLite2-ASN.mmdb")) { File.Delete(setupBasePath + "GeoLite2-ASN.mmdb"); } if (File.Exists(setupBasePath + "GeoLite2-City.mmdb")) { File.Delete(setupBasePath + "GeoLite2-City.mmdb"); } } if (!noUpdateOption.HasValue()) { var timer = new Timer(100) { Enabled = true, AutoReset = true }; timer.Elapsed += (_, _) => { timer.Interval = 3600000 * 24; GetFileUpdate("GeoLite2-ASN.mmdb", Config.MaxmindAsnDbUrl); GetFileUpdate("GeoLite2-City.mmdb", Config.MaxmindCityDbUrl); }; } } if (synccnlsOption.HasValue()) { var cnListPath = AppDomain.CurrentDomain.SetupInformation.ApplicationBase + "China_WhiteList.List"; if (File.Exists(cnListPath)) { File.Delete(cnListPath); } var timer = new Timer(100) { Enabled = true, AutoReset = true }; timer.Elapsed += (_, _) => { timer.Interval = 3600000 * 24; GetFileUpdate("China_WhiteList.List", DNSChinaConfig.Config.ChinaListUrl); Task.Run(() => { while (true) { if (File.Exists(cnListPath)) { DNSChina.ChinaList = File.ReadAllLines(cnListPath).ToList() .ConvertAll(DomainName.Parse); break; } Thread.Sleep(1000); } }); }; } else if (File.Exists(AppDomain.CurrentDomain.SetupInformation.ApplicationBase + "China_WhiteList.List")) { GetFileUpdate("China_WhiteList.List", DNSChinaConfig.Config.ChinaListUrl); } if (Config.UseAdminRoute) { Console.WriteLine( $"Access Get AdminToken : /dns-admin/set-token?t={Config.AdminToken}"); } var host = new WebHostBuilder() .UseKestrel() .UseContentRoot(AppDomain.CurrentDomain.SetupInformation.ApplicationBase) .ConfigureLogging(configureLogging => { if (Config.LogEnable && Config.FullLogEnable) { configureLogging.AddConsole(); } }) .ConfigureServices(services => services.AddRouting()) .ConfigureKestrel(options => { options.Limits.MaxRequestBodySize = 1024; options.Listen(ipEndPoint, listenOptions => { listenOptions.Protocols = HttpProtocols.Http1AndHttp2; if (!httpsOption.HasValue()) { return; } if (!pfxOption.HasValue() && !pemOption.HasValue()) { listenOptions.UseHttps(); } if (pfxOption.HasValue()) { if (pfxPassOption.HasValue()) { listenOptions.UseHttps(pfxOption.Value(), pfxPassOption.Value()); } else { listenOptions.UseHttps(pfxOption.Value()); } } if (pemOption.HasValue() && keyOption.HasValue()) { listenOptions.UseHttps(X509Certificate2.CreateFromPem( File.ReadAllText(pemOption.Value()), File.ReadAllText(keyOption.Value()))); } }); }) .UseStartup <Startup>() .Build(); if (testOption.HasValue()) { Task.Run(() => { for (var i = 0; i < 100; i++) { if (PortIsUse(ipEndPoint.Port)) { host.StopAsync().Wait(5000); } } Environment.Exit(0); }); } if (saveOption.HasValue()) { File.WriteAllText("config.json", JsonConvert.SerializeObject(Config, Formatting.Indented)); if (Config.ChinaListEnable) { File.WriteAllText("cnlist.json", JsonConvert.SerializeObject(DNSChinaConfig.Config, Formatting.Indented)); } Console.WriteLine("Configuration Saved."); } if (showOption.HasValue()) { Console.WriteLine(JsonConvert.SerializeObject(Config, Formatting.Indented)); } host.Run(); }); try { if (File.Exists("/.dockerenv") || Environment.GetEnvironmentVariables().Contains("DOTNET_RUNNING_IN_CONTAINER") || Environment.GetEnvironmentVariables().Contains("ARASHI_RUNNING_IN_CONTAINER")) { Console.WriteLine("ArashiDNS Running in Docker Container"); } if (Environment.GetEnvironmentVariables().Contains("ARASHI_VAR")) { if (string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("ARASHI_VAR"))) { throw new Exception(); } cmd.Execute(Environment.GetEnvironmentVariable("ARASHI_VAR").Split(' ')); } else { cmd.Execute(args); } } catch (Exception e) { Console.WriteLine(e); cmd.Execute(); } }
private async Task <int> OnExecuteAsync(CommandLineApplication app) { if (string.IsNullOrEmpty(Url) && string.IsNullOrEmpty(RemotePageLocation) && !HelloWorld) { app.ShowHelp(); return(0); } Console.WriteLine(HostFolder); Directory.CreateDirectory(HostFolder); Directory.CreateDirectory("output"); await InstallNPMPackage(HostFolder, "requirejs"); await InstallNPMPackage(HostFolder, "puppeteer"); await InstallNPMPackage(HostFolder, "websocket"); await InstallNPMPackage(HostFolder, "isomorphic-fetch"); await InstallNPMPackage(HostFolder, "earthml-temply-headless"); var engine = new RazorLightEngineBuilder() .UseEmbeddedResourcesProject(typeof(Program)) .UseMemoryCachingProvider() .Build(); Console.WriteLine(string.Join(" ", app.RemainingArguments)); var args = new JObject(); for (var j = 0; j < app.RemainingArguments.Count; j += 2) { args[app.RemainingArguments[j].Trim('-')] = app.RemainingArguments[j + 1]; } IWebHost host = new WebHostBuilder() .UseKestrel() .Configure(appbuilder => { appbuilder.Use(async(context, next) => { Console.WriteLine(context.Request.Path); if (context.Request.Path == "/installDependencies") { var dps = JToken.Parse(await new StreamReader(context.Request.Body).ReadToEndAsync()); foreach (JProperty dependency in dps.SelectToken("$.dependencies")) { await InstallNPMPackage(HostFolder, dependency.Name, dependency.Value.ToString()); } context.Response.StatusCode = 200; return; } if (context.Request.Path == "/hello-world") { await context.Response.WriteAsync(@"<html><head><script src=""node_modules/requirejs/require.js""></script></head><body><script type=""text/javascript"">require.config({paths:{'earthml-temply-headless':'node_modules/earthml-temply-headless/artifacts/src'}}); require(['earthml-temply-headless/remotepage/remotepage'],(RemotePageModule)=>{console.log(RemotePageModule);let rp = new RemotePageModule.RemotePage(); rp.helloWorld(); })</script></body></html>"); return; } if (context.Request.Path == "/") { try { string result = await engine.CompileRenderAsync("GenericRemoteHost.cshtml", new { Name = "John Doe" }); await context.Response.WriteAsync(result); } catch (Exception ex) { Console.WriteLine(ex); } return; } await next(); Console.WriteLine($"{context.Request.Path} {context.Response.StatusCode}"); }); foreach (var volumne in Volumes) { appbuilder.Map(volumne.Split(':').Last(), (b) => { b.Use(async(ctx, next) => { await next(); Console.WriteLine($"{ctx.Request.Path} {ctx.Response.StatusCode}"); }); b.UseStaticFiles(new StaticFileOptions { FileProvider = new PhysicalFileProvider(string.Join(":", volumne.Split(':').Reverse().Skip(1).Reverse())) }); }); } //appbuilder.Map("/appinsight", (b) => //{ // b.UseStaticFiles(new StaticFileOptions { FileProvider = new Microsoft.Extensions.FileProviders.PhysicalFileProvider(@"C:\dev\EarthML\EarthML.TemplyHeadless\samples\ApplicationInsightsGraphGenerator\wwwroot") }); //}); //appbuilder.Map("/AscendRegistration", (b) => //{ // b.UseStaticFiles(new StaticFileOptions { FileProvider = new Microsoft.Extensions.FileProviders.PhysicalFileProvider(@"C:\dev\Ascend\AscendRecording\AscendRecording\www\libs\AscendRegistration") }); //}); //appbuilder.Map("/node_modules/earthml-temply-headless/artifacts/src", (b) => //{ // b.UseStaticFiles(new StaticFileOptions { FileProvider = new PhysicalFileProvider("C:/dev/EarthML/EarthML.TemplyHeadless/src/EarthML.TemplyHeadless/artifacts/src") }); //}); appbuilder.UseStaticFiles(new StaticFileOptions { FileProvider = new PhysicalFileProvider(HostFolder) }); }) .Build(); await host.StartAsync();; if (HelloWorld) { Url = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses .Select(a => a.Replace("://+", "://localhost").Replace("[::]", "127.0.0.1")).FirstOrDefault() + "/hello-world"; } if (!string.IsNullOrEmpty(RemotePageLocation)) { Url = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses .Select(a => a.Replace("://+", "://localhost").Replace("[::]", "127.0.0.1")).FirstOrDefault() + $"?remote-main={RemotePageMain}&remote-location={WebUtility.UrlEncode(RemotePageLocation)}"; } { var services = new ServiceCollection(); services.AddNodeServices(a => { // a.ProjectPath = Directory.GetCurrentDirectory(); // Set any properties that you want on 'options' here }); var serviceProvider = services.BuildServiceProvider(); var options = new NodeServicesOptions(serviceProvider) { ProjectPath = HostFolder, InvocationTimeoutMilliseconds = 60000 * 10, WatchFileExtensions = new string[] { } }; var _nodeServices = NodeServicesFactory.CreateNodeServices(options); try { var data = await RequireJS.RunAsync <object, JToken>(_nodeServices, HostFolder, "earthml-temply-headless/Headless/headless", new { url = Url, headlessHost = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses .Select(a => a.Replace("://+", "://localhost").Replace("[::]", "127.0.0.1")).FirstOrDefault(), headless = true, size = new { width = Width, height = Height }, data = args, inputPrefix = InputFolder, outputPrefix = OutputFolder }); Console.WriteLine(data.ToString()); }catch (Exception ex) { Console.WriteLine(ex); await Task.Delay(60000); } } if (host != null) { await host.StopAsync(); } return(0); }
public static async Task Main(string[] args) { var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Development"; var isDevelopment = "Development".Equals(environment, StringComparison.OrdinalIgnoreCase); var config = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddInMemoryCollection(new Dictionary <string, string> // add default settings, that will be overridden by commandline { { "Id", "Webapp" }, { "Version", "1.0.0" }, { "ClusterId", "rrod-cluster" }, { "ServiceId", "rrod" } }) .AddCommandLine(args) .AddJsonFile("Webapp.settings.json", optional: true, reloadOnChange: true) .AddJsonFile($"Webapp.settings.{environment}.json", optional: true, reloadOnChange: true) .AddJsonFile("/run/config/Webapp.settings.json", optional: true, reloadOnChange: true) .AddDockerSecrets("/run/secrets", optional: true) .AddUserSecrets <Program>(optional: true) .AddEnvironmentVariables("RROD_") .Build(); var loggerFactory = new LoggerFactory() .AddConsole(config.GetSection("Logging")) .AddDebug(); var logger = loggerFactory.CreateLogger <Program>(); logger.LogWarning($"Starting Webapp in {environment} environment..."); foreach (var provider in config.Providers) { logger.LogInformation($"Config Provider {provider.GetType().Name}: {provider.GetChildKeys(Enumerable.Empty<string>(), null).Count()} settings"); } // ServicePointManager.CheckCertificateRevocationList = false; ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12; ServicePointManager.DefaultConnectionLimit = 20; int attempt = 0; int initializeAttemptsBeforeFailing = 7; IClusterClient clusterClient = null; while (true) { // Initialize orleans client clusterClient = new ClientBuilder() .ConfigureServices((context, services) => { // services.AddOptions(); services.AddSingleton <ILoggerFactory>(loggerFactory); // services.AddSingleton<IConfiguration>(config); services.Configure <ClusterOptions>(config); }) .AddAzureQueueStreams <AzureQueueDataAdapterV2>("Default", builder => builder.Configure(options => options.ConnectionString = config.GetConnectionString("DataConnectionString"))) .ConfigureApplicationParts(parts => { parts.AddApplicationPart(typeof(ICounterGrain).Assembly).WithReferences(); parts.AddApplicationPart(typeof(AzureQueueDataAdapterV2).Assembly).WithReferences(); }) .UseAzureStorageClustering(options => options.ConnectionString = config.GetConnectionString("DataConnectionString")) .Build(); try { await clusterClient.Connect().ConfigureAwait(false); logger.LogInformation("Client successfully connected to silo host"); break; } catch (OrleansException) { attempt++; logger.LogWarning($"Attempt {attempt} of {initializeAttemptsBeforeFailing} failed to initialize the Orleans client."); if (clusterClient != null) { clusterClient.Dispose(); clusterClient = null; } if (attempt > initializeAttemptsBeforeFailing) { throw; } // Wait 4 seconds before retrying await Task.Delay(TimeSpan.FromSeconds(4)); } } var endpoints = config.GetSection("Http:Endpoints") .GetChildren() .ToDictionary(section => section.Key, section => { var endpoint = new EndpointConfiguration(); section.Bind(endpoint); return(endpoint); }); // if so, start a listener to respond to Acme (Let's Encrypt) requests, using a response received via an Orleans Cache Grain var hasHttps = endpoints.Any(endpoint => endpoint.Value.Scheme.Equals("https", StringComparison.InvariantCultureIgnoreCase)); var needPort80 = endpoints.Any(endpoint => (endpoint.Value.Port ?? (endpoint.Value.Scheme.Equals("https", StringComparison.InvariantCultureIgnoreCase) ? 443 : 80)) == 80); var certs = new Dictionary <string, X509Certificate2>(); var acmeOptions = new AcmeOptions { AcmeSettings = config.GetSection(nameof(AcmeSettings)).Get <AcmeSettings>(), GetChallengeResponse = async(challenge) => { var cacheGrain = clusterClient.GetGrain <ICacheGrain <string> >(challenge); var response = await cacheGrain.Get(); return(response.Value); }, SetChallengeResponse = async(challenge, response) => { var cacheGrain = clusterClient.GetGrain <ICacheGrain <string> >(challenge); await cacheGrain.Set(new Immutable <string>(response), TimeSpan.FromHours(2)); }, StoreCertificate = async(string domainName, byte[] certData) => { var certGrain = clusterClient.GetGrain <ICertGrain>(domainName); await certGrain.UpdateCertificate(certData); }, RetrieveCertificate = async(domainName) => { var certGrain = clusterClient.GetGrain <ICertGrain>(domainName); var certData = await certGrain.GetCertificate(); return(certData.Value); } }; if (hasHttps) { logger.LogWarning($"At least one https endpoint is present. Initialize Acme endpoint."); var acmeHost = new WebHostBuilder() .UseEnvironment(environment) .UseConfiguration(config) .ConfigureServices(services => { services.AddSingleton <IClusterClient>(clusterClient); services.AddSingleton <ILoggerFactory>(loggerFactory); services.Configure <AcmeSettings>(config.GetSection(nameof(AcmeSettings))); // Register a certitificate manager, supplying methods to store and retreive certificates and acme challenge responses services.AddAcmeCertificateManager(acmeOptions); }) // .UseUrls("http://*:80") .PreferHostingUrls(false) .UseKestrel(options => { options.Listen(IPAddress.Any, 80); }) .Configure(app => { app.UseAcmeResponse(); }) .Build(); try { await acmeHost.StartAsync().ConfigureAwait(false); } catch (Exception e) { logger.LogError("Error: can't start web listener for acme certificate renewal, probably the web address is in use by another process. Exception message is: " + e.Message); logger.LogError("Ignoring noncritical error (stop W3SVC or Skype to fix this), continuing..."); } var certificateManager = acmeHost.Services.GetRequiredService <ICertificateManager>(); // var certificateManager = new AcmeCertificateManager(Options.Create(acmeOptions)); foreach (var endpoint in endpoints) { var endpointConfig = endpoint.Value; bool isHttpsEndpoint = endpointConfig.Scheme.Equals("https", StringComparison.InvariantCultureIgnoreCase); var port = endpointConfig.Port ?? (isHttpsEndpoint ? 443 : 80); X509Certificate2 certificate = null; if (isHttpsEndpoint) { try { var domains = new List <string> { endpointConfig.Domain } .Concat(endpointConfig.Domains) .Where(ep => !string.IsNullOrEmpty(ep)) .Distinct() .ToArray(); logger.LogInformation($"Getting certificate for domain {domains.First()} on port {port}"); // Request a new certificate with Let's Encrypt and store it for next time try { certificate = await certificateManager.GetCertificate(domains); } catch (Exception e) { logger.LogCritical(e, $"Exception getting certificate for domain {domains.First()}. PfxPassword configured incorrectly?"); } if (certificate == null) { // It didn't work - create a temporary certificate so that we can still start with an untrusted certificate logger.LogCritical($"Error getting certificate for domain {domains.First()} (endpoint '{endpoint.Key}'). Creating self-signed temporary certificate..."); certificate = CertHelper.BuildTlsSelfSignedServer(domains); } certs.Add(domains.First(), certificate); logger.LogInformation($"Certificate for domain {domains.First()}: {certificate != null}"); } catch (Exception e) { logger.LogCritical($"Kestrel startup: Exception getting certificate. {e.Message}"); } } } if (needPort80) { await acmeHost.StopAsync(); } } var webHost = new WebHostBuilder() .UseEnvironment(environment) .UseConfiguration(config) .ConfigureServices(services => { // services.AddSingleton<IConfiguration>(config); services.AddSingleton <IClusterClient>(clusterClient); services.AddSingleton <ILoggerFactory>(loggerFactory); services.Configure <AcmeSettings>(config.GetSection(nameof(AcmeSettings))); services.AddAcmeCertificateManager(acmeOptions); }) .UseContentRoot(Directory.GetCurrentDirectory()) // .UseUrls(listenUrls.ToArray()) .PreferHostingUrls(false) .Configure(app => { app.UseAcmeResponse(); }) .UseStartup <Startup>() .UseKestrel(options => { foreach (var endpoint in endpoints) { var endpointConfig = endpoint.Value; bool isHttpsEndpoint = endpointConfig.Scheme.Equals("https", StringComparison.InvariantCultureIgnoreCase); var port = endpointConfig.Port ?? (isHttpsEndpoint ? 443 : 80); var ipAddresses = new List <IPAddress>(); var hosts = new List <string> { endpointConfig.Host } .Concat(endpointConfig.Hosts) .Where(ep => !string.IsNullOrEmpty(ep)) .Distinct(); foreach (var host in hosts) { if (host == "localhost") { ipAddresses.Add(IPAddress.IPv6Loopback); ipAddresses.Add(IPAddress.Loopback); } else if (IPAddress.TryParse(host, out var address)) { ipAddresses.Add(address); } else { logger.LogError($"Error parsing endpoint host: {host}"); } } foreach (var address in ipAddresses) { options.Listen(address, port, listenOptions => { if (isHttpsEndpoint) { var domains = new List <string> { endpointConfig.Domain } .Concat(endpointConfig.Domains) .Where(ep => !string.IsNullOrEmpty(ep)) .Distinct() .ToArray(); if (certs.TryGetValue(domains.First(), out var certificate)) { logger.LogInformation($"Kestrel config: Listen on address {address.ToString()}:{port}, certificate {(certificate == null ? "NULL" : certificate.Subject.ToString())}"); listenOptions.UseHttps(certificate); listenOptions.NoDelay = false; // listenOptions.UseConnectionLogging(); } else { logger.LogError($"No certificate for domain: {domains.First()}"); } } }); } } }) .Build(); await webHost.RunAsync(); }
public static async Task Main(string[] args) { string[] salutations = { "Have a nice day!", "Thank you for using PlayFab Multiplayer Servers", "Check out our docs at aka.ms/playfabdocs!", "Have a question? Check our community at community.playfab.com" }; Console.WriteLine(salutations[new Random().Next(salutations.Length)]); string debuggingUrl = "https://github.com/PlayFab/gsdkSamples/blob/master/Debugging.md"; Console.WriteLine($"Check this page for debugging tips: {debuggingUrl}"); // lcow stands for Linux Containers On Windows => https://docs.microsoft.com/en-us/virtualization/windowscontainers/deploy-containers/linux-containers Globals.GameServerEnvironment = args.Contains("-lcow") && RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? GameServerEnvironment.Linux : GameServerEnvironment.Windows; // LocalMultiplayerAgent is running only on Windows for the time being MultiplayerSettings settings = JsonConvert.DeserializeObject <MultiplayerSettings>(File.ReadAllText("MultiplayerSettings.json")); settings.SetDefaultsIfNotSpecified(); MultiplayerSettingsValidator validator = new MultiplayerSettingsValidator(settings); if (!validator.IsValid()) { Console.WriteLine("The specified settings are invalid. Please correct them and re-run the agent."); Environment.Exit(1); } string vmId = $"xcloudwusu4uyz5daouzl:{settings.Region}:{Guid.NewGuid()}:tvmps_{Guid.NewGuid():N}{Guid.NewGuid():N}_d"; Console.WriteLine($"TitleId: {settings.TitleId}"); Console.WriteLine($"BuildId: {settings.BuildId}"); Console.WriteLine($"VmId: {vmId}"); Globals.Settings = settings; string rootOutputFolder = Path.Combine(settings.OutputFolder, "PlayFabVmAgentOutput", DateTime.Now.ToString("s").Replace(':', '-')); Console.WriteLine($"Root output folder: {rootOutputFolder}"); VmDirectories vmDirectories = new VmDirectories(rootOutputFolder); Globals.VmConfiguration = new VmConfiguration(settings.AgentListeningPort, vmId, vmDirectories); if (Globals.GameServerEnvironment == GameServerEnvironment.Linux && RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { Globals.AdaptFolderPathsForLinuxContainersOnWindows(); // Linux Containers on Windows requires special folder mapping } Directory.CreateDirectory(rootOutputFolder); Directory.CreateDirectory(vmDirectories.GameLogsRootFolderVm); Directory.CreateDirectory(Globals.VmConfiguration.VmDirectories.CertificateRootFolderVm); IWebHost host = new WebHostBuilder() .UseKestrel() .UseUrls($"http://*:{settings.AgentListeningPort}") .UseContentRoot(Directory.GetCurrentDirectory()) .UseStartup <Startup>() .Build(); await host.StartAsync(); Console.WriteLine($"Local Multiplayer Agent is listening on port {settings.AgentListeningPort}"); Globals.SessionConfig = settings.SessionConfig ?? new SessionConfig() { SessionId = Guid.NewGuid() }; Console.WriteLine($"{string.Join(", ", Globals.SessionConfig.InitialPlayers)}"); await new MultiplayerServerManager(SystemOperations.Default, Globals.VmConfiguration, Globals.MultiLogger, SessionHostRunnerFactory.Instance) .CreateAndStartContainerWaitForExit(settings.ToSessionHostsStartInfo()); await host.StopAsync(); }
static void Main(string[] args) { var currentDir = Directory.GetCurrentDirectory(); var theFile = Path.Combine(currentDir, "settings.json"); // création du fichier settings.json avec les valeurs par défaut if (!File.Exists(theFile)) { MainGame.Settings = new Settings(); string json = Newtonsoft.Json.JsonConvert.SerializeObject(MainGame.Settings, Newtonsoft.Json.Formatting.Indented); File.WriteAllText(theFile, json); } var prm = Newtonsoft.Json.JsonConvert.DeserializeObject <Settings>(File.ReadAllText(theFile)); MainGame.Settings = prm; if (MainGame.Settings.MapName != "") { MainGame.LoadMap(MainGame.Settings.MapName); } else { MainGame.InitNewMap(); } var host = new WebHostBuilder() .UseKestrel() .UseStartup <Startup>() .ConfigureKestrel((context, options) => { options.ListenAnyIP(MainGame.Settings.ServerPort); }) .Build(); host.Start(); //Start server non-blocking ShowHelp(); bool exit = false; while (!exit) { Console.Write(">"); var key = Console.ReadKey(true); switch (key.KeyChar.ToString().ToLower()) { case "h": ShowHelp(); break; case "e": Console.WriteLine("Exit program"); if (MainGame.AllBot.Count > 0) { Console.WriteLine("Not possible, at least 1 BOT is in arena."); } else { if (MainGame.AllViewer.Count > 0) { Console.WriteLine("Not possible, at least 1 VIEWER is working."); } else { exit = true; } } break; case "g": Console.WriteLine("GO!"); MainGame.RunSimulator(); break; case "s": Console.WriteLine("Stop"); MainGame.StopSimulator(); break; case "x": // debug stuff to view shield foreach (OneBot x in MainGame.AllBot) { x.bot.ShieldLevel++; if (x.bot.ShieldLevel > 10) { x.bot.ShieldLevel = 0; } MainGame.ViewerPlayerShield(x.bot.X, x.bot.Y, x.bot.ShieldLevel); } break; case "w": // debug stuff to view cloak foreach (OneBot x in MainGame.AllBot) { x.bot.CloakLevel++; if (x.bot.CloakLevel > 10) { x.bot.CloakLevel = 0; } MainGame.ViewerPlayerCloak(x.bot.X, x.bot.Y, x.bot.CloakLevel); } break; } } host.StopAsync(); }