public void EnvDefaultsToDevelopmentConfigValueIfSpecified()
{
var vals = new Dictionary<string, string>
{
{ "ASPNET_ENV", "Staging" }
};
var config = new Configuration()
.Add(new MemoryConfigurationSource(vals));
var context = new HostingContext
{
ServerFactory = this,
Configuration = config
};
var engine = new HostingEngine();
using (engine.Start(context))
{
Assert.Equal("Staging", context.EnvironmentName);
var env = context.ApplicationServices.GetRequiredService<IHostingEnvironment>();
Assert.Equal("Staging", env.EnvironmentName);
}
}
public IDisposable Start(HostingContext context)
{
EnsureContextDefaults(context);
EnsureApplicationServices(context);
EnsureBuilder(context);
EnsureServerFactory(context);
InitalizeServerFactory(context);
EnsureApplicationDelegate(context);
var contextFactory = context.ApplicationServices.GetRequiredService<IHttpContextFactory>();
var contextAccessor = context.ApplicationServices.GetRequiredService<IHttpContextAccessor>();
var server = context.ServerFactory.Start(context.Server,
features =>
{
var httpContext = contextFactory.CreateHttpContext(features);
contextAccessor.HttpContext = httpContext;
return context.ApplicationDelegate(httpContext);
});
return new Disposable(() =>
{
_appLifetime.NotifyStopping();
server.Dispose();
_appLifetime.NotifyStopped();
});
}
public Task<int> Main(string[] args)
{
//Add command line configuration source to read command line parameters.
var config = new Configuration();
config.AddCommandLine(args);
var serviceCollection = new ServiceCollection();
serviceCollection.Add(HostingServices.GetDefaultServices(config));
var services = serviceCollection.BuildServiceProvider(_hostServiceProvider);
var context = new HostingContext()
{
Services = services,
Configuration = config,
ServerName = "Microsoft.AspNet.Server.WebListener",
ApplicationName = "BugTracker"
};
var engine = services.GetService<IHostingEngine>();
if (engine == null)
{
throw new Exception("TODO: IHostingEngine service not available exception");
}
using (engine.Start(context))
{
Console.WriteLine("Started the server..");
Console.WriteLine("Press any key to stop the server");
Console.ReadLine();
}
return Task.FromResult(0);
}
// REVIEW: we can configure services via AppStartup or via hostContext.Services
public TestServer(IConfiguration config, IServiceProvider serviceProvider, Action<IApplicationBuilder> configureApp, ConfigureServicesDelegate configureServices)
{
var hostContext = new HostingContext()
{
ApplicationName = "Test App",
Configuration = config,
ServerFactory = this,
StartupMethods = new StartupMethods(configureApp, configureServices)
};
_appInstance = new HostingEngine(serviceProvider).Start(hostContext);
}
public void ApplicationNameDefaultsToApplicationEnvironmentName()
{
var context = new HostingContext
{
ServerFactory = this
};
var engine = new HostingEngine();
using (engine.Start(context))
{
Assert.Equal("Microsoft.AspNet.Hosting.Tests", context.ApplicationName);
}
}
public void EnvDefaultsToDevelopmentIfNoConfig()
{
var context = new HostingContext
{
ServerFactory = this
};
var engine = new HostingEngine();
using (engine.Start(context))
{
Assert.Equal("Development", context.EnvironmentName);
var env = context.ApplicationServices.GetRequiredService<IHostingEnvironment>();
Assert.Equal("Development", env.EnvironmentName);
}
}
public void Main(string[] args)
{
var config = new Configuration();
if (File.Exists(HostingIniFile))
{
config.AddIniFile(HostingIniFile);
}
config.AddEnvironmentVariables();
config.AddCommandLine(args);
var context = new HostingContext()
{
Configuration = config,
ServerFactoryLocation = config.Get("server"),
ApplicationName = config.Get("app")
};
var engine = new HostingEngine(_serviceProvider);
var serverShutdown = engine.Start(context);
var loggerFactory = context.ApplicationServices.GetRequiredService<ILoggerFactory>();
var appShutdownService = context.ApplicationServices.GetRequiredService<IApplicationShutdown>();
var shutdownHandle = new ManualResetEvent(false);
appShutdownService.ShutdownRequested.Register(() =>
{
try
{
serverShutdown.Dispose();
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger<Program>();
logger.LogError("Dispose threw an exception.", ex);
}
shutdownHandle.Set();
});
var ignored = Task.Run(() =>
{
Console.WriteLine("Started");
Console.ReadLine();
appShutdownService.RequestShutdown();
});
shutdownHandle.WaitOne();
}
public static IServiceProvider CreateServiceProvider(Action<IServiceCollection> configure)
{
var context = new HostingContext
{
ServerFactory = new ServerFactory(),
StartupMethods = new StartupMethods(
_ => { },
services =>
{
services.AddSignalR();
configure(services);
return services.BuildServiceProvider();
})
};
var engine = new HostingEngine().Start(context);
return context.ApplicationServices;
}
private static DbContext TryCreateContextFromStartup(Type type)
{
#if DNX451 || DNXCORE50
try
{
var context = new HostingContext
{
ServerFactory = new ServerFactory(),
};
var instance = new HostingEngine().Start(context);
return context.ApplicationServices.GetService(type) as DbContext;
}
catch
{
}
#endif
return null;
}
public IDisposable Start(HostingContext context)
{
EnsureBuilder(context);
EnsureServerFactory(context);
InitalizeServerFactory(context);
EnsureApplicationDelegate(context);
var applicationLifetime = (ApplicationLifetime)context.Services.GetRequiredService <IApplicationLifetime>();
var pipeline = new PipelineInstance(_httpContextFactory, context.ApplicationDelegate);
var server = context.ServerFactory.Start(context.Server, pipeline.Invoke);
return(new Disposable(() =>
{
applicationLifetime.SignalStopping();
server.Dispose();
pipeline.Dispose();
applicationLifetime.SignalStopped();
}));
}
public static IDisposable Start()
{
var serviceCollection = new ServiceCollection();
serviceCollection.Add(HostingServices.GetDefaultServices());
var context = new HostingContext
{
Services = serviceCollection.BuildServiceProvider()
};
var engine = context.Services.GetService <IHostingEngine>();
if (engine == null)
{
throw new Exception("TODO: IHostingEngine service not available exception");
}
return(engine.Start(context));
}
public Task<int> Main(string[] args)
{
//Add command line configuration source to read command line parameters.
var config = new Configuration();
config.AddCommandLine(args);
var context = new HostingContext()
{
Configuration = config,
ServerFactoryLocation = "Microsoft.AspNet.Server.WebListener",
ApplicationName = "MusicStore"
};
using (new HostingEngine().Start(context))
{
Console.WriteLine("Started the server..");
Console.WriteLine("Press any key to stop the server");
Console.ReadLine();
}
return Task.FromResult(0);
}
public void HostingEngineCanBeStarted()
{
var services = HostingServices.Create().BuildServiceProvider();
var engine = services.GetRequiredService <IHostingEngine>();
var context = new HostingContext
{
ServerFactory = this,
Services = services,
ApplicationName = "Microsoft.AspNet.Hosting.Tests"
};
var engineStart = engine.Start(context);
Assert.NotNull(engineStart);
Assert.Equal(1, _startInstances.Count);
Assert.Equal(0, _startInstances[0].DisposeCalls);
engineStart.Dispose();
Assert.Equal(1, _startInstances[0].DisposeCalls);
}
public void Main(string[] args)
{
var applicationRoot = Directory.GetCurrentDirectory();
var serverPort = 2000;
var logLevel = LogLevel.Information;
var hostPID = -1;
var transportType = TransportType.Http;
var enumerator = args.GetEnumerator();
while (enumerator.MoveNext())
{
var arg = (string)enumerator.Current;
if (arg == "-s")
{
enumerator.MoveNext();
applicationRoot = Path.GetFullPath((string)enumerator.Current);
}
else if (arg == "-p")
{
enumerator.MoveNext();
serverPort = int.Parse((string)enumerator.Current);
}
else if (arg == "-v")
{
logLevel = LogLevel.Verbose;
}
else if (arg == "--hostPID")
{
enumerator.MoveNext();
hostPID = int.Parse((string)enumerator.Current);
}
else if (arg == "--stdio")
{
transportType = TransportType.Stdio;
}
}
Environment = new OmnisharpEnvironment(applicationRoot, serverPort, hostPID, logLevel, transportType);
var config = new Configuration()
.AddCommandLine(new[] { "--server.urls", "http://localhost:" + serverPort });
var serviceCollection = HostingServices.Create(_serviceProvider, config);
serviceCollection.AddSingleton<ISharedTextWriter, SharedConsoleWriter>();
var services = serviceCollection.BuildServiceProvider();
var hostingEnv = services.GetRequiredService<IHostingEnvironment>();
var appEnv = services.GetRequiredService<IApplicationEnvironment>();
var context = new HostingContext()
{
Services = services,
Configuration = config,
ServerName = "Kestrel",
ApplicationName = appEnv.ApplicationName,
EnvironmentName = hostingEnv.EnvironmentName,
};
if (transportType == TransportType.Stdio)
{
context.ServerName = null;
context.ServerFactory = new Stdio.StdioServerFactory(Console.In, services.GetRequiredService<ISharedTextWriter>());
}
var engine = services.GetRequiredService<IHostingEngine>();
var appShutdownService = services.GetRequiredService<IApplicationShutdown>();
var shutdownHandle = new ManualResetEvent(false);
var serverShutdown = engine.Start(context);
appShutdownService.ShutdownRequested.Register(() =>
{
serverShutdown.Dispose();
shutdownHandle.Set();
});
#if ASPNETCORE50
var ignored = Task.Run(() =>
{
Console.WriteLine("Started");
Console.ReadLine();
appShutdownService.RequestShutdown();
});
#else
Console.CancelKeyPress += (sender, e) =>
{
appShutdownService.RequestShutdown();
};
#endif
if (hostPID != -1)
{
try
{
var hostProcess = Process.GetProcessById(hostPID);
hostProcess.EnableRaisingEvents = true;
hostProcess.OnExit(() => appShutdownService.RequestShutdown());
}
catch
{
// If the process dies before we get here then request shutdown
// immediately
appShutdownService.RequestShutdown();
}
}
shutdownHandle.WaitOne();
}
public void IsEnvironment_Extension_Is_Case_Insensitive()
{
var context = new HostingContext
{
ServerFactory = this
};
var engine = new HostingEngine();
using (engine.Start(context))
{
var env = context.ApplicationServices.GetRequiredService<IHostingEnvironment>();
Assert.True(env.IsEnvironment("Development"));
Assert.True(env.IsEnvironment("developMent"));
}
}
private IServiceCollection CreateHostingServices(HostingContext context)
{
var services = Import(_fallbackServices);
services.TryAdd(ServiceDescriptor.Transient<IServerLoader, ServerLoader>());
services.TryAdd(ServiceDescriptor.Transient<IApplicationBuilderFactory, ApplicationBuilderFactory>());
services.TryAdd(ServiceDescriptor.Transient<IHttpContextFactory, HttpContextFactory>());
// TODO: Do we expect this to be provide by the runtime eventually?
services.AddLogging();
services.TryAdd(ServiceDescriptor.Singleton<IHttpContextAccessor, HttpContextAccessor>());
// Apply user services
services.Add(context.Services);
// Jamming in app lifetime and hosting env since these must not be replaceable
services.AddInstance<IApplicationLifetime>(_appLifetime);
services.AddInstance<IHostingEnvironment>(_hostingEnvironment);
// Conjure up a RequestServices
services.AddTransient<IStartupFilter, AutoRequestServicesStartupFilter>();
return services;
}
public void MapPath_Facts(string virtualPath, string expectedSuffix)
{
var context = new HostingContext
{
ServerFactory = this
};
var engine = new HostingEngine();
using (engine.Start(context))
{
var env = context.ApplicationServices.GetRequiredService<IHostingEnvironment>();
var mappedPath = env.MapPath(virtualPath);
expectedSuffix = expectedSuffix.Replace('/', Path.DirectorySeparatorChar);
Assert.Equal(Path.Combine(env.WebRootPath, expectedSuffix), mappedPath);
}
}
private void InitalizeServerFactory(HostingContext context)
{
if (context.Server == null)
{
context.Server = context.ServerFactory.Initialize(context.Configuration);
}
if (context.Builder.Server == null)
{
context.Builder.Server = context.Server;
}
}
private void EnsureStartupMethods(HostingContext context)
{
if (context.StartupMethods != null)
{
return;
}
var diagnosticMessages = new List<string>();
context.StartupMethods = ApplicationStartup.LoadStartupMethods(
_fallbackServices,
context.ApplicationName,
context.EnvironmentName,
diagnosticMessages);
if (context.StartupMethods == null)
{
throw new ArgumentException(
diagnosticMessages.Aggregate("Failed to find an entry point for the web application.", (a, b) => a + "\r\n" + b),
nameof(context));
}
}
private void EnsureServerFactory(HostingContext context)
{
if (context.ServerFactory != null)
{
return;
}
if (_serverLoader == null)
{
_serverLoader = context.ApplicationServices.GetRequiredService<IServerLoader>();
}
context.ServerFactory = _serverLoader.LoadServerFactory(context.ServerFactoryLocation);
}
private void EnsureContextDefaults(HostingContext context)
{
if (context.ApplicationName == null)
{
context.ApplicationName = _applicationEnvironment.ApplicationName;
}
if (context.EnvironmentName == null)
{
context.EnvironmentName = context.Configuration?.Get(EnvironmentKey) ?? HostingEnvironment.DefaultEnvironmentName;
}
_hostingEnvironment.EnvironmentName = context.EnvironmentName;
if (context.WebRootPath != null)
{
_hostingEnvironment.WebRootPath = context.WebRootPath;
}
}
private void EnsureBuilder(HostingContext context)
{
if (context.Builder != null)
{
return;
}
if (_builderFactory == null)
{
_builderFactory = context.ApplicationServices.GetRequiredService<IApplicationBuilderFactory>();
}
context.Builder = _builderFactory.CreateBuilder();
context.Builder.ApplicationServices = context.ApplicationServices;
}
private void EnsureApplicationServices(HostingContext context)
{
if (context.ApplicationServices != null)
{
return;
}
EnsureStartupMethods(context);
context.ApplicationServices = context.StartupMethods.ConfigureServicesDelegate(CreateHostingServices(context));
}
private void EnsureApplicationDelegate(HostingContext context)
{
if (context.ApplicationDelegate != null)
{
return;
}
// REVIEW: should we call EnsureApplicationServices?
var startupFilters = context.ApplicationServices.GetService<IEnumerable<IStartupFilter>>();
var configure = context.StartupMethods.ConfigureDelegate;
foreach (var filter in startupFilters)
{
configure = filter.Configure(context.Builder, configure);
}
configure(context.Builder);
context.ApplicationDelegate = context.Builder.Build();
}
public void WebRootCanBeResolvedFromTheProjectJson()
{
var context = new HostingContext
{
ServerFactory = this
};
var engineStart = new HostingEngine().Start(context);
var env = context.ApplicationServices.GetRequiredService<IHostingEnvironment>();
Assert.Equal(Path.GetFullPath("testroot"), env.WebRootPath);
Assert.True(env.WebRootFileProvider.GetFileInfo("TextFile.txt").Exists);
}
public void HostingEngineCanBeStarted()
{
var context = new HostingContext
{
ServerFactory = this,
ApplicationName = "Microsoft.AspNet.Hosting.Tests"
};
var engineStart = new HostingEngine().Start(context);
Assert.NotNull(engineStart);
Assert.Equal(1, _startInstances.Count);
Assert.Equal(0, _startInstances[0].DisposeCalls);
engineStart.Dispose();
Assert.Equal(1, _startInstances[0].DisposeCalls);
}
public void Main(string[] args)
{
var config = new Configuration();
if (File.Exists(HostingIniFile))
{
config.AddIniFile(HostingIniFile);
}
config.AddEnvironmentVariables();
config.AddCommandLine(args);
var appEnv = _serviceProvider.GetRequiredService <IApplicationEnvironment>();
var hostingEnv = new HostingEnvironment()
{
EnvironmentName = config.Get(EnvironmentKey) ?? DefaultEnvironmentName,
WebRoot = HostingUtilities.GetWebRoot(appEnv.ApplicationBasePath),
};
var serviceCollection = new ServiceCollection();
serviceCollection.Add(HostingServices.GetDefaultServices(config));
serviceCollection.AddInstance <IHostingEnvironment>(hostingEnv);
// The application name is a "good enough" mechanism to identify this application
// on the machine and to prevent subkeys from being shared across multiple applications
// by default.
serviceCollection.Configure <DataProtectionOptions>(options =>
{
options.ApplicationDiscriminator = appEnv.ApplicationName;
});
var services = serviceCollection.BuildServiceProvider(_serviceProvider);
var context = new HostingContext()
{
Services = services,
Configuration = config,
ServerName = config.Get("server"), // TODO: Key names
ApplicationName = config.Get("app") // TODO: Key names
?? appEnv.ApplicationName,
EnvironmentName = hostingEnv.EnvironmentName,
};
var engine = services.GetRequiredService <IHostingEngine>();
var appShutdownService = _serviceProvider.GetRequiredService <IApplicationShutdown>();
var shutdownHandle = new ManualResetEvent(false);
var serverShutdown = engine.Start(context);
appShutdownService.ShutdownRequested.Register(() =>
{
serverShutdown.Dispose();
shutdownHandle.Set();
});
var ignored = Task.Run(() =>
{
Console.WriteLine("Started");
Console.ReadLine();
appShutdownService.RequestShutdown();
});
shutdownHandle.WaitOne();
}