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