public PackageAssemblyLoader(NuGetFramework runtimeFramework, IAssemblyLoadContextAccessor loadContextAccessor, IEnumerable <Library> libraries, PackagePathResolver pathResolver) { Log = RuntimeLogging.Logger <PackageAssemblyLoader>(); _loadContextAccessor = loadContextAccessor; _assemblyLookupTable = InitializeAssemblyLookupTable(libraries, runtimeFramework, pathResolver); }
internal RuntimeHost(RuntimeHostBuilder builder) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (builder.Project == null) { throw new ArgumentException($"{nameof(RuntimeHostBuilder)} does not contain a valid Project", nameof(builder)); } Log = RuntimeLogging.Logger <RuntimeHost>(); Project = builder.Project; GlobalSettings = builder.GlobalSettings; _loaderFactories = builder.Loaders; Services = builder.Services; // Load properties from the mutable RuntimeHostBuilder into // immutable copies on this object TargetFramework = builder.TargetFramework; // Copy the dependency providers so the user can't fiddle with them without our knowledge var list = new List <IDependencyProvider>(builder.DependencyProviders); DependencyProviders = list; }
/// <summary> /// Create a <see cref="RuntimeHostBuilder"/> for the project in the specified /// <paramref name="projectDirectory"/>, using the default configuration. /// </summary> /// <remarks> /// This method will throw if the project.json file cannot be found in the /// specified folder. If a project.lock.json file is present in the directory /// it will be loaded. /// </remarks> /// <param name="projectDirectory">The directory of the project to host</param> public static RuntimeHostBuilder ForProjectDirectory(string projectDirectory, NuGetFramework runtimeFramework, IServiceProvider services) { if (string.IsNullOrEmpty(projectDirectory)) { throw new ArgumentNullException(nameof(projectDirectory)); } if (runtimeFramework == null) { throw new ArgumentNullException(nameof(runtimeFramework)); } var log = RuntimeLogging.Logger <RuntimeHostBuilder>(); var hostBuilder = new RuntimeHostBuilder(); // Load the Project var projectResolver = new PackageSpecResolver(projectDirectory); PackageSpec packageSpec; if (projectResolver.TryResolvePackageSpec(GetProjectName(projectDirectory), out packageSpec)) { log.LogVerbose($"Loaded project {packageSpec.Name}"); hostBuilder.Project = new Project(packageSpec); } hostBuilder.GlobalSettings = projectResolver.GlobalSettings; // Load the Lock File if present LockFile lockFile; if (TryReadLockFile(projectDirectory, out lockFile)) { log.LogVerbose($"Loaded lock file"); hostBuilder.LockFile = lockFile; } // Set the framework and other components hostBuilder.TargetFramework = runtimeFramework; hostBuilder.Services = services; hostBuilder.PackagePathResolver = new PackagePathResolver( ResolveRepositoryPath(hostBuilder.GlobalSettings), GetCachePaths()); log.LogVerbose("Registering PackageSpecReferenceDependencyProvider"); hostBuilder.DependencyProviders.Add(new PackageSpecReferenceDependencyProvider(projectResolver)); if (hostBuilder.LockFile != null) { log.LogVerbose("Registering LockFileDependencyProvider"); hostBuilder.DependencyProviders.Add(new LockFileDependencyProvider(hostBuilder.LockFile)); } log.LogVerbose("Registering ReferenceAssemblyDependencyProvider"); var referenceResolver = new FrameworkReferenceResolver(); hostBuilder.DependencyProviders.Add(new ReferenceAssemblyDependencyProvider(referenceResolver)); // GAC resolver goes here! :) return(hostBuilder); }
public ReferenceAssemblyDependencyProvider(IFrameworkReferenceResolver frameworkReferenceResolver) { Log = RuntimeLogging.Logger <ReferenceAssemblyDependencyProvider>(); FrameworkResolver = frameworkReferenceResolver; }
public FrameworkReferenceResolver() { Log = RuntimeLogging.Logger <FrameworkReferenceResolver>(); PopulateCache(); }
public Task<int> Main(string[] args) { ILogger log = null; try { ApplicationHostOptions options; string[] programArgs; int exitCode; bool shouldExit = ParseArgs(args, out options, out programArgs, out exitCode); if (shouldExit) { return Task.FromResult(exitCode); } string traceConfig = string.IsNullOrEmpty(options.Trace) ? Environment.GetEnvironmentVariable(EnvironmentNames.Trace) : options.Trace; // Initialize logging RuntimeLogging.Initialize(traceConfig, ConfigureLogging); // "Program" is a terrible name for a logger and this is the only logger in // this namespace :). log = RuntimeLogging.Logger("Microsoft.Framework.ApplicationHost"); log.LogInformation("Application Host Starting"); // Construct the necessary context for hosting the application var builder = RuntimeHostBuilder.ForProjectDirectory( options.ApplicationBaseDirectory, NuGetFramework.Parse(_environment.RuntimeFramework.FullName), _serviceProvider); // Configure assembly loading builder.Loaders.Add(new ProjectAssemblyLoaderFactory( new LibraryExporter( builder.TargetFramework, builder.PackagePathResolver))); builder.Loaders.Add(new PackageAssemblyLoaderFactory(builder.PackagePathResolver)); if (builder.Project == null) { // Failed to load the project Console.Error.WriteLine("Unable to find a project.json file."); return Task.FromResult(3); } // Boot the runtime var host = builder.Build(); // Get the project and print some information from it log.LogInformation($"Project: {host.Project.Name} ({host.Project.BaseDirectory})"); // Determine the command to be executed var command = string.IsNullOrEmpty(options.ApplicationName) ? "run" : options.ApplicationName; string replacementCommand; if (host.Project.Commands.TryGetValue(command, out replacementCommand)) { var replacementArgs = CommandGrammar.Process( replacementCommand, GetVariable).ToArray(); options.ApplicationName = replacementArgs.First(); programArgs = replacementArgs.Skip(1).Concat(programArgs).ToArray(); } if (string.IsNullOrEmpty(options.ApplicationName) || string.Equals(options.ApplicationName, "run", StringComparison.Ordinal)) { options.ApplicationName = host.Project.EntryPoint ?? host.Project.Name; } log.LogInformation($"Executing '{options.ApplicationName}' '{string.Join(" ", programArgs)}'"); return host.ExecuteApplication( _loaderContainer, _loadContextAccessor, options.ApplicationName, programArgs); } catch (Exception ex) { if (log != null) { log.LogError($"{ex.GetType().FullName} {ex.Message}", ex); } Console.Error.WriteLine($"Error loading project: {ex.Message}"); return Task.FromResult(1); } }