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