protected override void ApplyConfiguration() { base.ApplyConfiguration(); IServer server = _serviceProvider.GetRequiredService <IServer>(); IServerAddressesFeature addresses = server.Features.Get <IServerAddressesFeature>(); foreach (string address in addresses.Addresses) { if (!address.StartsWith("http", StringComparison.OrdinalIgnoreCase)) { // IIS hosting can populate Addresses with net.tcp/net.pipe/net.msmq addresses // if the site has those bindings continue; } var fixedUri = FixUri(address); // ASP.NET Core assumes all listeners are http. Other transports such as NetTcp will already be populated // in the base addresses so filter them out. bool skip = false; foreach (var baseAddress in InternalBaseAddresses) { if (baseAddress.Port == fixedUri.Port) // Already added with a different protocol { skip = true; break; } } if (!skip) { AddBaseAddress(FixUri(address)); } } }
public DebugInfoPageMiddleware(RequestDelegate next, IServerAddressesFeature serverAddresses, IHostingEnvironment hostingEnv, Scenarios scenarios) { _next = next; _hostingEnv = hostingEnv; _scenarios = scenarios; _serverAddresses = serverAddresses; }
public void Start <TContext>(IHttpApplication <TContext> application) { IServerAddressesFeature addressFeatures = this.Features.Get <IServerAddressesFeature>(); foreach (string address in addressFeatures.Addresses) { this.Listener.Prefixes.Add(address.TrimEnd('/') + "/"); } this.Listener.Start(); while (true) { HttpListenerContext httpListenerContext = this.Listener.GetContext(); HttpListenerContextFeature feature = new HttpListenerContextFeature(httpListenerContext, this.Listener); IFeatureCollection contextFeatures = new FeatureCollection() .Set <IHttpRequestFeature>(feature) .Set <IHttpResponseFeature>(feature); TContext context = application.CreateContext(contextFeatures); application.ProcessRequestAsync(context) .ContinueWith(_ => httpListenerContext.Response.Close()) .ContinueWith(_ => application.DisposeContext(context, _.Exception)); } }
public static async Task BindAsync(IServerAddressesFeature addresses, KestrelServerOptions serverOptions, ILogger logger, IDefaultHttpsProvider defaultHttpsProvider, Func <ListenOptions, Task> createBinding) { var listenOptions = serverOptions.ListenOptions; var strategy = CreateStrategy( listenOptions.ToArray(), addresses.Addresses.ToArray(), addresses.PreferHostingUrls); var context = new AddressBindContext { Addresses = addresses.Addresses, ListenOptions = listenOptions, ServerOptions = serverOptions, Logger = logger, DefaultHttpsProvider = defaultHttpsProvider ?? UnconfiguredDefaultHttpsProvider.Instance, CreateBinding = createBinding }; // reset options. The actual used options and addresses will be populated // by the address binding feature listenOptions.Clear(); addresses.Addresses.Clear(); await strategy.BindAsync(context).ConfigureAwait(false); }
public KestrelServer(IOptions <KestrelServerOptions> options, IApplicationLifetime applicationLifetime, ILoggerFactory loggerFactory) { if (options == null) { throw new ArgumentNullException(nameof(options)); } if (applicationLifetime == null) { throw new ArgumentNullException(nameof(applicationLifetime)); } if (loggerFactory == null) { throw new ArgumentNullException(nameof(loggerFactory)); } Options = options.Value ?? new KestrelServerOptions(); _applicationLifetime = applicationLifetime; _logger = loggerFactory.CreateLogger(typeof(KestrelServer).GetTypeInfo().Assembly.FullName); Features = new FeatureCollection(); var componentFactory = new HttpComponentFactory(Options); Features.Set <IHttpComponentFactory>(componentFactory); _serverAddresses = new ServerAddressesFeature(); Features.Set <IServerAddressesFeature>(_serverAddresses); }
private void BuildResponse_Default(HttpContext context, IServerAddressesFeature serverAddressesFeature) { try { bool hasForm = context.Request.HasFormContentType && context.Request.Form.Count > 0; context.Response.ContentType = "text/html"; context.Response.WriteAsync("<!DOCTYPE html><html lang=\"en\"><head><title></title></head><body><p>Hosted by Kestrel</p>"); if (serverAddressesFeature != null) { context.Response.WriteAsync("<p>Listening on the following addresses: " + string.Join(", ", serverAddressesFeature.Addresses) + "</p>"); } context.Response.WriteAsync($"<p>Request URL: {context.Request.GetDisplayUrl()}<p>"); if (hasForm && context.Request.Form.Count > 0) { context.Response.WriteAsync("<p>Form submitted! (POST)"); foreach (string key in context.Request.Form.Keys) { context.Response.WriteAsync($"<br> - Field [{key}]: '{context.Request.Form[key]}'"); } context.Response.WriteAsync("<br></p>"); } context.Response.WriteAsync($"<p>Number of total requests: {countRequests}</p>"); context.Response.WriteAsync("</body></html>"); } catch (Exception exception) { BackEnd.WriteResponseError(context, exception.Message); } }
private static string[] GetTestUrls(IServerAddressesFeature addressesFeature) { return(addressesFeature.Addresses .Select(a => a.Replace("://+", "://localhost")) .Select(a => a.EndsWith("/") ? a : a + "/") .ToArray()); }
public static async Task BindAsync(IServerAddressesFeature addresses, List <ListenOptions> listenOptions, ILogger logger, Func <ListenOptions, Task> createBinding) { var strategy = CreateStrategy( listenOptions.ToArray(), addresses.Addresses.ToArray(), addresses.PreferHostingUrls); var context = new AddressBindContext { Addresses = addresses.Addresses, ListenOptions = listenOptions, Logger = logger, CreateBinding = createBinding }; // reset options. The actual used options and addresses will be populated // by the address binding feature listenOptions.Clear(); addresses.Addresses.Clear(); await strategy.BindAsync(context).ConfigureAwait(false); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); app.UseBrowserLink(); } else { app.UseExceptionHandler("/Home/Error"); } IServerAddressesFeature addresses = app.ServerFeatures[typeof(IServerAddressesFeature)] as IServerAddressesFeature; var address = addresses.Addresses.First(); address = address + "Neeo"; app.UseNEEO(address); app.UseStaticFiles(); app.UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); }); }
private async void DoWork(object state) { if (!ExistsApp()) { Console.WriteLine("WebAPI2CLI: waiting to have app"); return; } serverAddresses = app.ServerFeatures.Get <IServerAddressesFeature>(); if (serverAddresses == null) { Console.WriteLine("WebAPI2CLI: waiting to have server adresses"); return; } _timer.Dispose(); exec = new Executor(configuration, serverAddresses, api, app.ApplicationServices); await exec.Execute(); if (!ShouldStay()) { Environment.Exit(0); } }
/// <summary> /// Initializes a new instance of the <see cref="Executor"/> class. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="serverAddresses">The server addresses.</param> /// <param name="api">The API.</param> /// <param name="serviceProvider">The service provider.</param> public Executor(IConfiguration configuration, IServerAddressesFeature serverAddresses, IApiDescriptionGroupCollectionProvider api, IServiceProvider serviceProvider) { this.serverAddresses = serverAddresses; this.api = api; this.serviceProvider = serviceProvider; this.configuration = configuration; }
private static void RegisterServices( IApplicationBuilder builder, IHostApplicationLifetime lifetime, IConsulClient consulClient, ILogger <IApplicationBuilder> logger) { var registrations = new List <AgentServiceRegistration>(); // Get discoverable services IEnumerable <DiscoverableServiceAttribute?> serviceDetails = AppDomain.CurrentDomain.GetAssemblies() .Where(ass => !ass.GlobalAssemblyCache) .SelectMany(ass => ass .GetTypes() .SelectMany(type => type.GetCustomAttributes <DiscoverableServiceAttribute>()) .Where(ds => ds != null)); // Get server IP address if (builder.Properties["server.Features"] is FeatureCollection features) { IServerAddressesFeature addresses = features.Get <IServerAddressesFeature>(); foreach (string address in addresses.Addresses) { var uri = new Uri(address); string hostAddress = $"{uri.Scheme}://{uri.Host}"; foreach (DiscoverableServiceAttribute?service in serviceDetails) { // Register service with consul string serviceId = $"{service!.ServiceName}-{service!.ServiceType}"; logger.LogDebug($"Registering service '{serviceId}' with Consul using address {hostAddress}:{uri.Port}"); var registration = new AgentServiceRegistration() { ID = serviceId, Name = service !.ServiceName, Address = hostAddress, Port = uri.Port, Tags = service.Tags.Prepend(service !.ServiceType).ToArray() }; registrations.Add(registration); consulClient.Agent.ServiceDeregister(registration.ID).Wait(); consulClient.Agent.ServiceRegister(registration).Wait(); } } } if (registrations.Any()) { logger.LogInformation($"Registered {registrations.Count} services with Consul"); lifetime.ApplicationStopping.Register(() => { foreach (AgentServiceRegistration registration in registrations) { consulClient.Agent.ServiceDeregister(registration.ID).Wait(); } logger.LogInformation("Unregistered from Consul"); }); } } }
private void EnsureBaseAddresses() { if (_serverAddresses != null) { foreach (var addr in _serverAddresses.Addresses) { var uri = new Uri(addr); bool skip = false; foreach (var baseAddress in InternalBaseAddresses) { if (baseAddress.Port == uri.Port && baseAddress.Scheme != uri.Scheme) { // ASP.NET Core adds net.tcp uri's as http{s} uri's skip = true; break; } } if (!skip && !InternalBaseAddresses.Contains(uri)) { InternalBaseAddresses.Add(uri); } } if (_serverAddresses.Addresses.Count > 0) { // It was populated by ASP.NET Core so can skip re-adding in future. _serverAddresses = null; } } }
// For testing internal SimpleServer(ServiceContext serviceContext) { ServiceContext = serviceContext; Features = new FeatureCollection(); _serverAddresses = new ServerAddressesFeature(); Features.Set(_serverAddresses); }
/// <summary> /// Initializes the HttpsRedirectionMiddleware /// </summary> /// <param name="next"></param> /// <param name="options"></param> /// <param name="config"></param> /// <param name="loggerFactory"></param> /// <param name="serverAddressesFeature">The</param> public HttpsRedirectionMiddleware(RequestDelegate next, IOptions <HttpsRedirectionOptions> options, IConfiguration config, ILoggerFactory loggerFactory, IServerAddressesFeature serverAddressesFeature) : this(next, options, config, loggerFactory) { _serverAddressesFeature = serverAddressesFeature ?? throw new ArgumentNullException(nameof(serverAddressesFeature)); }
public static void Main(string[] args) { _webHost = CreateWebHostBuilder(args).Build(); IServerAddressesFeature serverAddressesFeature = _webHost.ServerFeatures.Get <IServerAddressesFeature>(); _webHost.Run(); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { _serverAddressesFeature = app.ServerFeatures.Get <IServerAddressesFeature>(); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseExceptionHandler("/Demo/Error"); } app.UseResponseCompression(); app.UseStaticFiles(); // app.UseCookiePolicy(); app.UseResponseCaching(); app.UseRouting(); app.UseAuthentication(); app.UseAuthorization(); /* * app.Use((context, next) => * { * var endpointFeature = context.Features[typeof(IEndpointFeature)] as IEndpointFeature; * var endpoint = endpointFeature?.Endpoint; * * if (endpoint != null) * { * var metadataCollection = endpoint?.Metadata; * var pattern = (endpoint as RouteEndpoint)?.RoutePattern?.RawText; * * Console.WriteLine("Name: " + endpoint.DisplayName); * Console.WriteLine($"Route Pattern: {pattern}"); * Console.WriteLine("Metadata Types: " + string.Join(", ", metadataCollection)); * } * return next(); * }); */ app.UseEndpoints(route => { route.MapHub <QuotesHub>("/quotes"); route.MapControllerRoute( name: "default", pattern: "{controller=Demo}/{action=Index}/{id?}", defaults: new { controller = "Demo", action = "Index" } ); }); }
public ServiceHostObjectModel(IServiceProvider serviceProvider, IServer server, IServiceBuilder serviceBuilder, ILogger <ServiceHostObjectModel <TService> > logger) { _serviceProvider = serviceProvider; _serverAddresses = server.Features.Get <IServerAddressesFeature>(); _logger = logger; InitializeBaseAddresses(serviceBuilder); InitializeDescription(new UriSchemeKeyedCollection(serviceBuilder.BaseAddresses.ToArray())); }
public GatewayClient(IServer server, EndpointDataSource endpointDataSource, IOptions <ServiceOptions> options) { _serverAddresses = server.Features.Get <IServerAddressesFeature>(); _endpointDataSource = endpointDataSource; GrpcClientFactory.AllowUnencryptedHttp2 = true; var http = GrpcChannel.ForAddress(options.Value.GatewayAddress); _gateway = http.CreateGrpcService <IGatewayService>(); }
private static void PrintRuntimeInfo(IWebHostEnvironment environment, IServerAddressesFeature serverAddressesFeature) { var addresses = serverAddressesFeature.Addresses; Console.WriteLine($"Content: {environment.WebRootPath}"); foreach (var address in addresses) { Console.WriteLine($"Listening: {address}"); } }
public DevicesController( ILogger <DevicesController> logger, IServerAddressesFeature serverAddresses, IDevicesService <TDevices> devicesService, IMapper mapper ) { _logger = logger; _serverAddresses = serverAddresses; _devicesService = devicesService; _mapper = mapper; }
public SensorsController( ILogger <SensorsController> logger, IServerAddressesFeature serverAddresses, ISensorService <TSensors> sensorService, IMapper mapper ) { _logger = logger; _serverAddresses = serverAddresses; _sensorService = sensorService; _mapper = mapper; }
private static void PrintSwaggerUrl(IServerAddressesFeature serverAddressFeature) { if (serverAddressFeature == null) { return; } foreach (var address in serverAddressFeature.Addresses) { Console.WriteLine($"Swagger Open API is available on: {address}/swagger"); } }
public ProjectsController( ILogger <ProjectsController> logger, IServerAddressesFeature serverAddresses, IProjectsService <TProjects> projectsService, IMapper mapper ) { _logger = logger; _serverAddresses = serverAddresses; _projectsService = projectsService; _mapper = mapper; }
public CaddyFastCgiServer( FastCgiServer fastCgiServer, IOptions <FastCgiServerOptions> fastCgiOptions, IOptions <CaddyServerOptions> caddyOptions) { this.fastCgiServer = fastCgiServer; this.fastCgiOptions = fastCgiOptions; this.caddyOptions = caddyOptions; serverAddresses = new ServerAddressesFeature(); Features.Set(serverAddresses); caddyfilePath = Path.Combine(Environment.CurrentDirectory, "Caddyfile"); }
/// <summary> /// 开始监听来自网络的HTTP请求。HTTP请求一旦抵达,我们会调用HttpListener的GetContext方法得到表示原始HTTP上下文的HttpListenerContext对象, /// 并根据它创建一个类型为HttpListenerContextFeature的特性对象,该对象分别采用类型IHttpRequestFeature和IHttpResponseFeature注册到创建的FeatureCollection对象上 /// </summary> /// <typeparam name="TContext"></typeparam> /// <param name="application"></param> public void Run <TContext>(IHttpApplication <TContext> application) where TContext : Context { IServerAddressesFeature addressFeatures = this.Features.Get <IServerAddressesFeature>(); // 添加监视地址 foreach (string address in addressFeatures.Addresses) { Listener.Prefixes.Add(address.TrimEnd('/') + "/"); } this.Listener.Start(); this.Listener.BeginGetContext(GetServerCallback <TContext>, application); // 用异步方式监听HTTP请求 }
/// <summary> /// Returns first value in <see cref="IServerAddressesFeature.Addresses"/>. /// </summary> /// <param name="feature"></param> /// <returns></returns> public static string GetLaunchUrl(this IServerAddressesFeature feature) { if (feature == null) { return(null); } if (feature.Addresses != null && feature.Addresses.Count > 0) { return(feature.Addresses.FirstOrDefault()); } return(null); }
public AccountController( ILogger <AccountController> logger, IServerAddressesFeature serverAddresses, IAuthenticationService authenticationService, ISysUserServices <TSysUsers> userServices, IMapper mapper ) { _logger = logger; _serverAddresses = serverAddresses; _authenticationService = authenticationService; _userServices = userServices; _mapper = mapper; }
public SensorService ( IAIOTCloudContext context, IServerAddressesFeature serverAddresses, IAuthenticationService authenticationService, ILogger <SensorService> logger, IMapper mapper ) { _logger = logger; _context = context; _serverAddresses = serverAddresses; _authenticationService = authenticationService; _mapper = mapper; }
// For testing internal KestrelServer(ITransportFactory transportFactory, ServiceContext serviceContext) { if (transportFactory == null) { throw new ArgumentNullException(nameof(transportFactory)); } _transportFactory = transportFactory; ServiceContext = serviceContext; Features = new FeatureCollection(); _serverAddresses = new ServerAddressesFeature(); Features.Set(_serverAddresses); HttpCharacters.Initialize(); }