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