public CompilationEngine(
CompilationCache compilationCache,
CompilationEngineContext context)
{
_context = context;
RootLibraryExporter = new LibraryExporter(_context.LibraryManager, this, _context.TargetFramework, _context.Configuration);
_compilerLoadContext = new Lazy<IAssemblyLoadContext>(() =>
{
var factory = (IAssemblyLoadContextFactory)_context.Services.GetService(typeof(IAssemblyLoadContextFactory));
// Ensure this compilation engine is in the service provider
var services = new ServiceProvider(_context.Services);
services.Add(typeof(ICompilationEngine), this);
return factory.Create(services);
});
CompilationCache = compilationCache;
// Register compiler services
// TODO(anurse): Switch to project factory model to avoid needing to do this.
_context.AddService(typeof(ICache), CompilationCache.Cache);
_context.AddService(typeof(ICacheContextAccessor), CompilationCache.CacheContextAccessor);
_context.AddService(typeof(INamedCacheDependencyProvider), CompilationCache.NamedCacheDependencyProvider);
_context.AddService(typeof(IFileWatcher), context.FileWatcher);
}
public static ServiceProvider CreateTestServices(
IServiceProvider applicationServices,
Project project,
ReportingChannel channel)
{
var services = new ServiceProvider(applicationServices);
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new TestHostLoggerProvider(channel));
services.Add(typeof(ILoggerFactory), loggerFactory);
var libraryExporter = applicationServices.GetRequiredService<ILibraryExporter>();
var export = libraryExporter.GetExport(project.Name);
var projectReference = export.MetadataReferences
.OfType<IMetadataProjectReference>()
.Where(r => r.Name == project.Name)
.FirstOrDefault();
services.Add(
typeof(ISourceInformationProvider),
new SourceInformationProvider(projectReference, loggerFactory.CreateLogger<SourceInformationProvider>()));
services.Add(typeof(ITestDiscoverySink), new TestDiscoverySink(channel));
services.Add(typeof(ITestExecutionSink), new TestExecutionSink(channel));
return services;
}
public void NonRegisteredServicesCanBeIEnumerableResolved()
{
var serviceProvider = new ServiceProvider();
var serviceList = (IEnumerable<IService>)serviceProvider.GetService(typeof(IEnumerable<IService>));
Assert.NotNull(serviceList);
Assert.False(serviceList.Any(), "The serviceList should have no elements.");
}
public DefaultHost(DefaultHostOptions options,
IAssemblyLoadContextAccessor loadContextAccessor)
{
_projectDirectory = Path.GetFullPath(options.ApplicationBaseDirectory);
_targetFramework = options.TargetFramework;
_loadContextAccessor = loadContextAccessor;
_runtimeEnvironment = PlatformServices.Default.Runtime;
_serviceProvider = new ServiceProvider();
Initialize(options, loadContextAccessor);
}
public CompilationEngineContext(LibraryManager libraryManager, IProjectGraphProvider projectGraphProvider, IFileWatcher fileWatcher, IServiceProvider services, FrameworkName targetFramework, string configuration)
{
LibraryManager = libraryManager;
ProjectGraphProvider = projectGraphProvider;
FileWatcher = fileWatcher;
TargetFramework = targetFramework;
Configuration = configuration;
_services = new ServiceProvider(services);
}
public IProjectCompiler GetCompiler(TypeInformation provider, IAssemblyLoadContext loadContext)
{
// TODO: Optimize the default compiler case by using the default load context directly
var services = new ServiceProvider(_context.Services);
services.Add(typeof(IAssemblyLoadContext), loadContext);
var assembly = loadContext.Load(provider.AssemblyName);
var type = assembly.GetType(provider.TypeName);
return (IProjectCompiler)ActivatorUtilities.CreateInstance(services, type);
}
public DefaultHost(RuntimeOptions options,
IServiceProvider hostServices,
IAssemblyLoadContextAccessor loadContextAccessor,
IFileWatcher fileWatcher)
{
_projectDirectory = Path.GetFullPath(options.ApplicationBaseDirectory);
_targetFramework = options.TargetFramework;
_loadContextAccessor = loadContextAccessor;
_runtimeEnvironment = (IRuntimeEnvironment)hostServices.GetService(typeof(IRuntimeEnvironment));
_serviceProvider = new ServiceProvider(hostServices);
Initialize(options, hostServices, loadContextAccessor, fileWatcher);
}
public void RegisteredServicesCanBeIEnumerableResolved()
{
var serviceProvider = new ServiceProvider();
var service = new Service();
serviceProvider.Add(typeof(IService), service);
var serviceList = (IEnumerable<IService>)serviceProvider.GetService(typeof(IEnumerable<IService>));
Assert.NotNull(serviceList);
var enumerator = serviceList.GetEnumerator();
Assert.True(enumerator.MoveNext(), "The serviceList should have 1 element");
Assert.Same(service, enumerator.Current);
Assert.False(enumerator.MoveNext(), "The serviceList should have 1 element");
}
private async Task OpenChannel(int port, string hostId)
{
var contexts = new Dictionary<int, ApplicationContext>();
var services = new ServiceProvider(_services);
var protocolManager = new ProtocolManager(maxVersion: 2);
// This fixes the mono incompatibility but ties it to ipv4 connections
var listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, port));
listenSocket.Listen(10);
Console.WriteLine($"Process ID {Process.GetCurrentProcess().Id}");
Console.WriteLine("Listening on port {0}", port);
for (; ;)
{
var acceptSocket = await AcceptAsync(listenSocket);
Console.WriteLine("Client accepted {0}", acceptSocket.LocalEndPoint);
var stream = new NetworkStream(acceptSocket);
var queue = new ProcessingQueue(stream);
var connection = new ConnectionContext(
contexts,
services,
queue,
protocolManager,
hostId);
queue.OnReceive += message =>
{
// Enumerates all project contexts and return them to the
// sender
if (message.MessageType == "EnumerateProjectContexts")
{
WriteProjectContexts(message, queue, contexts);
}
else
{
// Otherwise it's a context specific message
connection.OnReceive(message);
}
};
queue.Start();
}
}
public ServiceManifest(ServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
}
public Task<int> RunAsync(List<string> args, IRuntimeEnvironment env, string appBase, FrameworkName targetFramework)
{
var accessor = LoadContextAccessor.Instance;
var container = new LoaderContainer();
LoadContext.InitializeDefaultContext(new DefaultLoadContext(container));
var disposable = container.AddLoader(new PathBasedAssemblyLoader(accessor, _searchPaths));
try
{
var name = args[0];
var programArgs = new string[args.Count - 1];
args.CopyTo(1, programArgs, 0, programArgs.Length);
var assembly = accessor.Default.Load(name);
if (assembly == null)
{
return Task.FromResult(1);
}
#if DNX451
string applicationBaseDirectory = appBase;
// Set the app domain variable so that AppContext.BaseDirectory works on .NET Framework (and hopefully mono)
AppDomain.CurrentDomain.SetData("APP_CONTEXT_BASE_DIRECTORY", applicationBaseDirectory);
#else
var applicationBaseDirectory = AppContext.BaseDirectory;
#endif
var configuration = Environment.GetEnvironmentVariable("TARGET_CONFIGURATION") ?? Environment.GetEnvironmentVariable(EnvironmentNames.Configuration) ?? "Debug";
Logger.TraceInformation($"[{nameof(Bootstrapper)}] Runtime Framework: {targetFramework}");
var applicationEnvironment = new HostApplicationEnvironment(applicationBaseDirectory,
targetFramework,
configuration,
assembly);
CallContextServiceLocator.Locator = new ServiceProviderLocator();
var serviceProvider = new ServiceProvider();
serviceProvider.Add(typeof(IAssemblyLoaderContainer), container);
serviceProvider.Add(typeof(IAssemblyLoadContextAccessor), accessor);
serviceProvider.Add(typeof(IApplicationEnvironment), applicationEnvironment);
serviceProvider.Add(typeof(IRuntimeEnvironment), env);
CallContextServiceLocator.Locator.ServiceProvider = serviceProvider;
PlatformServices.SetDefault(
PlatformServices.Create(
basePlatformServices: null,
application: applicationEnvironment,
runtime: env,
container: container,
accessor: accessor));
#if DNX451
if (RuntimeEnvironmentHelper.IsMono)
{
// Setting this value because of a Execution Context bug in older versions of Mono
AppDomain.CurrentDomain.SetData("DNX_SERVICEPROVIDER", serviceProvider);
}
#endif
var task = EntryPointExecutor.Execute(assembly, programArgs, serviceProvider);
return task.ContinueWith((t, state) =>
{
// Dispose the host
((IDisposable)state).Dispose();
return t.GetAwaiter().GetResult();
}, disposable);
}
catch
{
disposable.Dispose();
throw;
}
}
private static void OpenChannel(int port, string hostId)
{
var contexts = new Dictionary<int, ApplicationContext>();
var protocolManager = new ProtocolManager(maxVersion: 3);
// REVIEW: Should these be on a shared context object that flows?
var applicationEnvironment = PlatformServices.Default.Application;
var runtimeEnvironment = PlatformServices.Default.Runtime;
var loadContextAccessor = PlatformServices.Default.AssemblyLoadContextAccessor;
var compilationEngine = new CompilationEngine(new CompilationEngineContext(applicationEnvironment, runtimeEnvironment, loadContextAccessor.Default, new CompilationCache()));
var frameworkResolver = new FrameworkReferenceResolver();
var services = new ServiceProvider();
services.Add(typeof(IApplicationEnvironment), PlatformServices.Default.Application);
services.Add(typeof(IRuntimeEnvironment), PlatformServices.Default.Runtime);
services.Add(typeof(IAssemblyLoadContextAccessor), PlatformServices.Default.AssemblyLoadContextAccessor);
services.Add(typeof(IAssemblyLoaderContainer), PlatformServices.Default.AssemblyLoaderContainer);
services.Add(typeof(ILibraryManager), PlatformServices.Default.LibraryManager);
// This fixes the mono incompatibility but ties it to ipv4 connections
var listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, port));
listenSocket.Listen(10);
Console.WriteLine($"Process ID {Process.GetCurrentProcess().Id}");
Console.WriteLine("Listening on port {0}", port);
while (true)
{
var acceptSocket = listenSocket.Accept();
Console.WriteLine("Client accepted {0}", acceptSocket.LocalEndPoint);
var stream = new NetworkStream(acceptSocket);
var queue = new ProcessingQueue(stream);
var connection = new ConnectionContext(
contexts,
services,
applicationEnvironment,
runtimeEnvironment,
loadContextAccessor,
frameworkResolver,
queue,
protocolManager,
compilationEngine,
hostId);
queue.OnReceive += message =>
{
// Enumerates all project contexts and return them to the
// sender
if (message.MessageType == "EnumerateProjectContexts")
{
WriteProjectContexts(message, queue, contexts);
}
else
{
// Otherwise it's a context specific message
connection.OnReceive(message);
}
};
queue.Start();
}
}
public ServiceManifest(ServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
}
