public Task Start(CancellationToken cancellationToken) => _webHost.StartAsync(cancellationToken);
/// <inheritdoc /> public Task StartAsync(CancellationToken cancellationToken = default(CancellationToken)) => _host.StartAsync(cancellationToken);
public static async Task Main(string[] args) { string mode = Environment.GetEnvironmentVariable("PTDASYNCALL_MODE") ?? "inspect"; bool doSynchronizations = mode == "sync"; string sfAppDir = Environment.GetEnvironmentVariable("SF_APP_DIR") ?? "../../SIL.XForge.Scripture"; string sfProjectIdsSubset = Environment.GetEnvironmentVariable("SYNC_SET"); string sfAdminRequestValues = Environment.GetEnvironmentVariable("SF_PROJECT_ADMINS"); Directory.SetCurrentDirectory(sfAppDir); IWebHostBuilder builder = CreateWebHostBuilder(args); IWebHost webHost = builder.Build(); Logger = webHost.Services.GetService <IProgramLogger>(); Logger.Log($"Starting. Will sync: {doSynchronizations}"); HashSet <string> projectSubset = null; try { if (sfProjectIdsSubset != null) { projectSubset = new HashSet <string>(sfProjectIdsSubset.Split(' ')); } } catch { Logger.Log($"There was a problem parsing the SYNC_SET SF project ids " + $"environment variable. Rethrowing."); throw; } Dictionary <string, string> sfAdminsToUse = null; try { if (sfAdminRequestValues != null) { sfAdminsToUse = new Dictionary <string, string>(); foreach (string sfAdminRequest in sfAdminRequestValues.Split(' ')) { string[] request = sfAdminRequest.Split(':'); sfAdminsToUse.Add(request[0], request[1]); } } } catch { Logger.Log($"There was a problem parsing SF_PROJECT_ADMINS. Rethrowing."); throw; } try { await webHost.StartAsync(); } catch (HttpRequestException) { Logger.Log("There was an error starting the program before getting to the inspection or migration. " + "Maybe the SF server is running on this machine and needs shut down? Rethrowing."); throw; } ISyncAllService tool = webHost.Services.GetService <ISyncAllService>(); await tool.SynchronizeAllProjectsAsync(doSynchronizations, projectSubset, sfAdminsToUse); await webHost.StopAsync(); Logger.Log("Done."); }
public ServerFixture WithDownstreamApi(RequestDelegate mockServerHandler) { _downstreamApiHost = HostMockApi(mockServerHandler); _downstreamApiHost.StartAsync(); return(this); }
public static async Task Start() { if (KestrelWebHost != null) { return; } Logger.Log("Starting Kestrel IPC server...", Enums.LogLevels.Trace); IWebHostBuilder builder = new WebHostBuilder(); string absoluteConfigDirectory = Path.Combine(Directory.GetCurrentDirectory(), Constants.ConfigDirectory); builder.ConfigureLogging(logging => logging.SetMinimumLevel(Core.Config.Debug ? LogLevel.Trace : LogLevel.Warning)); if (File.Exists(Path.Combine(absoluteConfigDirectory, Constants.KestrelConfigurationFile))) { builder.UseConfiguration(new ConfigurationBuilder().SetBasePath(absoluteConfigDirectory).AddJsonFile(Constants.KestrelConfigurationFile, false, true).Build()); builder.UseKestrel((builderContext, options) => options.Configure(builderContext.Configuration.GetSection("Kestrel"))); if (Helpers.IsNullOrEmpty(Core.Config.KestrelServerUrl)) { builder.UseUrls("http://localhost:9090"); } else { builder.UseUrls(Core.Config.KestrelServerUrl); } builder.ConfigureLogging((hostingContext, logging) => logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"))); } else { builder.UseKestrel(); if (Helpers.IsNullOrEmpty(Core.Config.KestrelServerUrl)) { builder.UseUrls("http://localhost:9090/"); } else { builder.UseUrls(Core.Config.KestrelServerUrl); } } builder.UseNLog(); builder.UseStartup <Startup>(); IWebHost kestrelWebHost = builder.Build(); try { await kestrelWebHost.StartAsync().ConfigureAwait(false); } catch (Exception e) { Logger.Log(e); kestrelWebHost.Dispose(); IsServerOnline = false; return; } KestrelWebHost = kestrelWebHost; IsServerOnline = true; if (Helpers.IsNullOrEmpty(Core.Config.KestrelServerUrl)) { Logger.Log($"Kestrel server is running at http://localhost:9090/"); } else { Logger.Log($"Kestrel server is running at {Core.Config.KestrelServerUrl}"); } }
public async Task InitializeAsync() => await _host.StartAsync().ConfigureAwait(false);
public Task Run() { Host = new WebHostBuilder() .UseKestrel(op => { if (_ip.Equals("localhost", StringComparison.CurrentCultureIgnoreCase)) { op.ListenLocalhost(_port); } else { op.Listen(IPAddress.Parse(_ip), _port); } }) .Configure(app => { app.Run(http => { return(Task.Run(() => { var req = http.Request; var resp = http.Response; var method = http.Request.Method; var path = req.Path; var cacheKey = $"Request:{method}-{path}"; ConsoleUtil.WriteToConsole(cacheKey); //cors var corsResult = CorsHandler.Handler(_corsOption, http); if (corsResult != null) { return corsResult; } _handlersCache.TryGetValue(cacheKey, out HttpHandler handler); if (handler == null) { handler = _handlers.FirstOrDefault( h => h.Method == method && PathUtil.IsMatch(path, h.Path)); if (handler != null) { _handlersCache.TryAdd(cacheKey, handler); } } if (handler != null) { try { return handler.Handler(new Request(req, handler.Path), new Response(resp)); } catch (Exception e) { ConsoleUtil.WriteToConsole(e.ToString()); resp.StatusCode = (int)HttpStatusCode.InternalServerError; ConsoleUtil.WriteToConsole( $"Response:{resp.StatusCode} {HttpStatusCode.InternalServerError}"); return resp.WriteAsync("InternalServerError"); } } resp.StatusCode = (int)HttpStatusCode.NotFound; ConsoleUtil.WriteToConsole($"Response:{resp.StatusCode} {HttpStatusCode.NotFound}"); return resp.WriteAsync("NotFound"); })); }); }) .Build(); var task = Host.StartAsync(); ConsoleUtil.WriteToConsole($"AServer listening {_ip}:{_port} now ."); return(task); }
public Task StartAsync(CancellationToken cancellationToken = default(CancellationToken)) { return(webHost.StartAsync(cancellationToken)); }
public Task StartAsync(CancellationToken cancellationToken) { _logger.LogInformation("App started successfully {appName} ({version}) [{env}]", _appInfo.Name, _appInfo.Version, _appInfo.Environment); return(_host.StartAsync(cancellationToken)); }
/// <summary> /// Start web server on separate thread /// </summary> public async Task StartAsync(CancellationToken cancellationToken = default) { await webHost.StartAsync(cancellationToken).ConfigureAwait(false); }
public Task Start() => _host.StartAsync();
public async Task Start(CancellationToken cancellationToken) { if (_log.IsDebugEnabled) { _log.DebugFormat("Configuring Web Host: {0}", _configuration.HostAddress); } IPHostEntry entries = await Dns.GetHostEntryAsync(_configuration.Settings.Host).ConfigureAwait(false); IWebHost BuildWebHost(params string[] args) { return(WebHost.CreateDefaultBuilder(args) .Configure(Configure) .UseKestrel(options => { foreach (var ipAddress in entries.AddressList) { options.Listen(ipAddress, HostSettings.Port); } // options.Listen(IPAddress.Loopback, 5001, listenOptions => // { // listenOptions.UseHttps("testCert.pfx", "testPassword"); // }); }) .Build()); } if (_log.IsDebugEnabled) { _log.DebugFormat("Building Web Host: {0}", _configuration.HostAddress); } _webHost = BuildWebHost(); if (_log.IsDebugEnabled) { _log.DebugFormat("Starting Web Host: {0}", _configuration.HostAddress); } try { await _webHost.StartAsync(cancellationToken).ConfigureAwait(false); if (_log.IsDebugEnabled) { _log.DebugFormat("Started Web Host: {0}", _configuration.HostAddress); } } catch (Exception exception) { if (_log.IsErrorEnabled) { _log.Error($"Fault Starting Web Host: {_configuration.HostAddress}", exception); } throw; } _started = true; }
public override async Task StartAsync(CancellationToken token) { await base.StartAsync(token).ConfigureAwait(false); await host.StartAsync(token).ConfigureAwait(false); }
/// <summary> /// Opens a connection using the parameters resolved by the referenced connection /// resolver and creates a REST server(service) using the set options and parameters. /// </summary> /// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param> public virtual async Task OpenAsync(string correlationId) { if (IsOpen()) { return; } var connection = await _connectionResolver.ResolveAsync(correlationId); var credential = connection.GetSection("credential"); var protocol = connection.Protocol; var host = connection.Host; var port = connection.Port; _address = protocol + "://" + host + ":" + port; try { var builder = new WebHostBuilder() .UseKestrel(options => { // Convert localhost to IP Address if (host == "localhost") { host = IPAddress.Loopback.ToString(); } if (protocol == "https") { var sslPfxFile = credential.GetAsNullableString("ssl_pfx_file"); var sslPassword = credential.GetAsNullableString("ssl_password"); options.Listen(IPAddress.Parse(host), port, listenOptions => { listenOptions.UseHttps(sslPfxFile, sslPassword); }); } else { options.Listen(IPAddress.Parse(host), port); } }) .ConfigureServices(ConfigureServices) .Configure(ConfigureApplication) .UseContentRoot(Directory.GetCurrentDirectory()); _server = builder.Build(); _logger.Info(correlationId, "Opened REST service at {0}", _address); await _server.StartAsync(); } catch (Exception ex) { if (_server != null) { _server.Dispose(); _server = null; } throw new ConnectionException(correlationId, "CANNOT_CONNECT", "Opening REST service failed") .WithCause(ex).WithDetails("url", _address); } }
internal async Task StartAsync() => await _host.StartAsync();
public Task Run() { string url = String.Format("http://{0}:{1}", _ip, _port); var urls = new List <string>(); if (!_urls.Any()) { urls.Add(url); } else { urls = _urls.ToList(); } Host = new WebHostBuilder() .UseUrls(urls.ToArray()) .UseKestrel() .Configure(app => { app.Run(http => { return(Task.Run(() => { var req = http.Request; var resp = http.Response; var method = http.Request.Method; var path = req.Path; var cacheKey = $"Request:{method}-{path}"; ConsoleUtil.DebugConsole(cacheKey); //cors var corsResult = CorsHandler.Handler(_corsOption, http); if (corsResult != null) { return corsResult; } _handlersCache.TryGetValue(cacheKey, out HttpHandler handler); if (handler == null) { handler = _handlers.FirstOrDefault( h => h.Method.Equals(method, StringComparison.OrdinalIgnoreCase) && PathUtil.IsMatch(path, h.Path)); if (handler != null) { _handlersCache.TryAdd(cacheKey, handler); } } if (handler != null) { try { return handler.Handler(new Request(req, handler.Path), new Response(resp)); } catch (Exception e) { Console.WriteLine(e.ToString()); resp.StatusCode = (int)HttpStatusCode.InternalServerError; Console.WriteLine( $"Response:{resp.StatusCode} {HttpStatusCode.InternalServerError}"); return resp.WriteAsync("InternalServerError"); } } resp.StatusCode = (int)HttpStatusCode.NotFound; Console.WriteLine($"Response:{resp.StatusCode} {HttpStatusCode.NotFound}"); return resp.WriteAsync("NotFound"); })); }); }) .Build(); var task = Host.StartAsync(); urls.ForEach(u => { Console.WriteLine($"AServer listen on {u} ."); }); return(task); }
public void Initialized(InitializedContext context) { // 在本地地址上启动Web服务,可以根据需求改变端口 _webHost.StartAsync("http://localhost:8080", _mahuaApi.GetSourceContainer()); }
internal Task StartAsync() => host.StartAsync();
/// <summary> /// Defines the entry point of the application. /// </summary> /// <param name="args">The arguments.</param> public static async Task Main(string[] args) { const string siteDir = "/var/lib/scriptureforge"; string syncDir = Path.Combine(siteDir, "sync"); bool doWrite = (args.Length >= 1 ? args[0] : string.Empty) == "run"; MigrationsDisabled = !doWrite; string sfAppDir = args.Length >= 2 ? args[1] : string.Empty; if (string.IsNullOrWhiteSpace(sfAppDir)) { // This calculated from "web-xforge\src\Migrations\SourceTargetSplitting\bin\Debug\netcoreapp3.1" sfAppDir = Environment.GetEnvironmentVariable("SF_APP_DIR") ?? "../../../../../SIL.XForge.Scripture"; } Log("Split Source and Target Projects."); Log(string.Empty); if (!Directory.Exists(siteDir)) { Log($"Site folder doesn't exist: {siteDir}"); Environment.Exit(1); } if (!Directory.Exists(syncDir)) { Log($"Sync folder doesn't exist: {syncDir}"); Environment.Exit(1); } if (!doWrite) { Log("Test Mode ONLY - no files are changed. Run `SourceTargetSplitting run` to change files."); Log(string.Empty); } // Set up the web host, and start the real time server Log("Starting Scripture Forge Server..."); Directory.SetCurrentDirectory(sfAppDir); IWebHostBuilder builder = CreateWebHostBuilder(args); IWebHost webHost = builder.Build(); try { await webHost.StartAsync(); } catch (HttpRequestException) { Log("There was an error starting the program before getting to the migration" + " part. Maybe the SF server is running and needs shut down? Rethrowing."); throw; } // The following serializer is required for serializing TextData BsonSerializer.RegisterSerializer(new JTokenSerializer()); // Get the object migrator objectMigrator = webHost.Services.GetService <ObjectMigrator>(); // Set up the scripture text collections objectMigrator.TargetScrTextCollection.Initialize(syncDir); if (!doWrite) { objectMigrator.SourceScrTextCollection.Initialize(syncDir); } // Migrate the files, and get a list of source mappings so we can migrate the database objects await MigrateFilesAsync(syncDir, doWrite); // Migrate the database objects await objectMigrator.MigrateObjectsAsync(doWrite); // Migrate the chapter and book permissions await objectMigrator.MigrateChapterAndBookPermissions(doWrite); // Stop the web host and real time server Log("Stopping Scripture Forge Server..."); await webHost.StopAsync(); Log(string.Empty); Log("Finished Migration."); }
public virtual async Task InitializeAsync() { await _node.StartAsync(true); await _host.StartAsync(); }
internal static async Task Start() { if (KestrelWebHost != null) { return; } ASF.ArchiLogger.LogGenericInfo(Strings.IPCStarting); // The order of dependency injection matters, pay attention to it IWebHostBuilder builder = new WebHostBuilder(); string customDirectory = Path.Combine(Directory.GetCurrentDirectory(), SharedInfo.WebsiteDirectory); if (Directory.Exists(customDirectory)) { WebsiteDirectory = customDirectory; } // Set default directories builder.UseContentRoot(SharedInfo.HomeDirectory); builder.UseWebRoot(WebsiteDirectory); // Check if custom config is available string absoluteConfigDirectory = Path.Combine(Directory.GetCurrentDirectory(), SharedInfo.ConfigDirectory); // Firstly initialize settings that user is free to override builder.ConfigureLogging(logging => logging.SetMinimumLevel(Debugging.IsUserDebugging ? LogLevel.Trace : LogLevel.Warning)); // Now conditionally initialize settings that are not possible to override if (File.Exists(Path.Combine(absoluteConfigDirectory, ConfigurationFile))) { // Set up custom config to be used builder.UseConfiguration(new ConfigurationBuilder().SetBasePath(absoluteConfigDirectory).AddJsonFile(ConfigurationFile, false, true).Build()); // Use custom config for Kestrel and Logging configuration builder.UseKestrel((builderContext, options) => options.Configure(builderContext.Configuration.GetSection("Kestrel"))); builder.ConfigureLogging((hostingContext, logging) => logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"))); } else { // Use ASF defaults for Kestrel builder.UseKestrel(options => options.ListenLocalhost(1242)); } // Enable NLog integration for logging builder.UseNLog(); // Specify Startup class for IPC builder.UseStartup <Startup>(); // Init history logger for /Api/Log usage Logging.InitHistoryLogger(); // Start the server IWebHost kestrelWebHost = builder.Build(); try { await kestrelWebHost.StartAsync().ConfigureAwait(false); } catch (Exception e) { ASF.ArchiLogger.LogGenericException(e); kestrelWebHost.Dispose(); return; } KestrelWebHost = kestrelWebHost; ASF.ArchiLogger.LogGenericInfo(Strings.IPCReady); }
public Task StartAsync(CancellationToken cancellationToken = new CancellationToken()) { return(_webHost.StartAsync(cancellationToken)); }
public async Task StartAsync(CancellationToken cancellationToken = default) { await _internalWebHost.StartAsync(cancellationToken); }
public async Task StartAsync(CancellationToken cancellationToken) { await _host.StartAsync(); }
private Task StartWebHostAsync(AppSettings settings) { _webHost = WebHostFactory.CreateWebHost(settings, Port); return(_webHost.StartAsync()); }
protected override Task Start() { return(Task.WhenAll(_node.StartAsync(false), _host.StartAsync())); }
public Task StartAsync(CancellationToken cancellationToken) => host.StartAsync(cancellationToken);
public void Initialized(InitializedContext context) { _webHost.StartAsync("http://localhost:65238", _mahuaApi.GetSourceContainer()); }
public static async Task SetupAsync(TestContext context) { apiHost = ApiHostBuilder.Build(); await apiHost.StartAsync(); }
public Task StartAsync(CancellationToken cancellationToken) { _host.StartAsync(); return(Task.CompletedTask); }