public ApplicationHostContext(IServiceProvider serviceProvider,
string projectDirectory,
string packagesDirectory,
string configuration,
FrameworkName targetFramework)
{
ProjectDirectory = projectDirectory;
RootDirectory = Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
FrameworkReferenceResolver = new FrameworkReferenceResolver();
_serviceProvider = new ServiceProvider(serviceProvider);
PackagesDirectory = packagesDirectory ?? NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(FrameworkReferenceResolver);
NuGetDependencyProvider = new NuGetDependencyResolver(PackagesDirectory, FrameworkReferenceResolver);
var gacDependencyResolver = new GacDependencyResolver();
ProjectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
UnresolvedDependencyProvider = new UnresolvedDependencyProvider();
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDepencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
NuGetDependencyProvider,
UnresolvedDependencyProvider
});
UnresolvedDependencyProvider.AttemptedProviders = DependencyWalker.DependencyProviders;
var compositeDependencyExporter = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ProjectLibraryExportProvider(ProjectResolver, ServiceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
NuGetDependencyProvider
});
// Default services
_serviceProvider.Add(typeof(ILibraryExportProvider), compositeDependencyExporter);
_serviceProvider.Add(typeof(IProjectResolver), ProjectResolver);
_serviceProvider.Add(typeof(IFileWatcher), NoopWatcher.Instance);
_serviceProvider.Add(typeof(NuGetDependencyResolver), NuGetDependencyProvider);
_serviceProvider.Add(typeof(ProjectReferenceDependencyProvider), ProjectDepencyProvider);
_serviceProvider.Add(typeof(ILibraryManager), new LibraryManager(targetFramework, configuration, DependencyWalker, compositeDependencyExporter));
}
public ModuleLoaderContext(IServiceProvider serviceProvider,
string projectDirectory) {
ProjectDirectory = projectDirectory;
RootDirectory = Microsoft.Framework.Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
// A new project resolver is required. you cannot reuse the one from the
// parent service provider as that will be for the parent context.
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(new FrameworkReferenceResolver());
// Need to pass through package directory incase you download a package from the gallary, this needs to know about it
var nuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository(
NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory)));
var gacDependencyResolver = new GacDependencyResolver();
var projectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileFormat.LockFileName);
if (File.Exists(projectLockJsonPath)) {
var lockFileFormat = new LockFileFormat();
var lockFile = lockFileFormat.Read(projectLockJsonPath);
nuGetDependencyProvider.ApplyLockFile(lockFile);
}
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
projectDepencyProvider,
nuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ModuleProjectLibraryExportProvider(
ProjectResolver, serviceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
nuGetDependencyProvider
});
}
public ApplicationHostContext(IServiceProvider serviceProvider,
string projectDirectory,
string packagesDirectory,
string configuration,
FrameworkName targetFramework,
ICache cache,
ICacheContextAccessor cacheContextAccessor,
INamedCacheDependencyProvider namedCacheDependencyProvider,
IAssemblyLoadContextFactory loadContextFactory = null)
{
ProjectDirectory = projectDirectory;
Configuration = configuration;
RootDirectory = Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
FrameworkReferenceResolver = new FrameworkReferenceResolver();
_serviceProvider = new ServiceProvider(serviceProvider);
PackagesDirectory = packagesDirectory ?? NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(FrameworkReferenceResolver);
NuGetDependencyProvider = new NuGetDependencyResolver(PackagesDirectory, RootDirectory);
var gacDependencyResolver = new GacDependencyResolver();
ProjectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDepencyProvider,
NuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ProjectLibraryExportProvider(ProjectResolver, ServiceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
NuGetDependencyProvider
});
LibraryManager = new LibraryManager(targetFramework, configuration, DependencyWalker,
LibraryExportProvider, cache);
AssemblyLoadContextFactory = loadContextFactory ?? new RuntimeLoadContextFactory(ServiceProvider);
namedCacheDependencyProvider = namedCacheDependencyProvider ?? NamedCacheDependencyProvider.Empty;
// Default services
_serviceProvider.Add(typeof(IApplicationEnvironment), new ApplicationEnvironment(Project, targetFramework, configuration));
_serviceProvider.Add(typeof(IFileWatcher), NoopWatcher.Instance);
_serviceProvider.Add(typeof(ILibraryManager), LibraryManager);
// Not exposed to the application layer
_serviceProvider.Add(typeof(ILibraryExportProvider), LibraryExportProvider, includeInManifest: false);
_serviceProvider.Add(typeof(IProjectResolver), ProjectResolver, includeInManifest: false);
_serviceProvider.Add(typeof(NuGetDependencyResolver), NuGetDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(ProjectReferenceDependencyProvider), ProjectDepencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(ICache), cache, includeInManifest: false);
_serviceProvider.Add(typeof(ICacheContextAccessor), cacheContextAccessor, includeInManifest: false);
_serviceProvider.Add(typeof(INamedCacheDependencyProvider), namedCacheDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(IAssemblyLoadContextFactory), AssemblyLoadContextFactory, includeInManifest: false);
var compilerOptionsProvider = new CompilerOptionsProvider(ProjectResolver);
_serviceProvider.Add(typeof(ICompilerOptionsProvider), compilerOptionsProvider);
}
public ApplicationHostContext(IServiceProvider serviceProvider,
string projectDirectory,
string packagesDirectory,
string configuration,
FrameworkName targetFramework,
ICache cache,
ICacheContextAccessor cacheContextAccessor,
INamedCacheDependencyProvider namedCacheDependencyProvider,
IAssemblyLoadContextFactory loadContextFactory = null,
bool skipLockFileValidation = false)
{
ProjectDirectory = projectDirectory;
Configuration = configuration;
RootDirectory = Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
FrameworkReferenceResolver = new FrameworkReferenceResolver();
_serviceProvider = new ServiceProvider(serviceProvider);
PackagesDirectory = packagesDirectory ?? NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(FrameworkReferenceResolver);
NuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository(PackagesDirectory));
var gacDependencyResolver = new GacDependencyResolver();
ProjectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
var projectName = PathUtility.GetDirectoryName(ProjectDirectory);
Project project;
if (ProjectResolver.TryResolveProject(projectName, out project))
{
Project = project;
}
else
{
throw new InvalidOperationException(
string.Format("Unable to resolve project '{0}' from {1}", projectName, ProjectDirectory));
}
var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileReader.LockFileName);
var lockFileExists = File.Exists(projectLockJsonPath);
var validLockFile = false;
if (lockFileExists)
{
var lockFileReader = new LockFileReader();
var lockFile = lockFileReader.Read(projectLockJsonPath);
validLockFile = lockFile.IsValidForProject(Project);
if (validLockFile || skipLockFileValidation)
{
NuGetDependencyProvider.ApplyLockFile(lockFile);
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDepencyProvider,
NuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
}
}
if ((!validLockFile && !skipLockFileValidation) || !lockFileExists)
{
// We don't add NuGetDependencyProvider to DependencyWalker
// It will leave all NuGet packages unresolved and give error message asking users to run "dnu restore"
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDepencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
}
LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ProjectLibraryExportProvider(ProjectResolver, ServiceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
NuGetDependencyProvider
});
LibraryManager = new LibraryManager(targetFramework, configuration, DependencyWalker,
LibraryExportProvider, cache);
AssemblyLoadContextFactory = loadContextFactory ?? new RuntimeLoadContextFactory(ServiceProvider);
namedCacheDependencyProvider = namedCacheDependencyProvider ?? NamedCacheDependencyProvider.Empty;
// Default services
_serviceProvider.Add(typeof(IApplicationEnvironment), new ApplicationEnvironment(Project, targetFramework, configuration));
_serviceProvider.Add(typeof(ILibraryManager), LibraryManager);
_serviceProvider.TryAdd(typeof(IFileWatcher), NoopWatcher.Instance);
// Not exposed to the application layer
_serviceProvider.Add(typeof(ILibraryExportProvider), LibraryExportProvider, includeInManifest: false);
_serviceProvider.Add(typeof(IProjectResolver), ProjectResolver, includeInManifest: false);
_serviceProvider.Add(typeof(NuGetDependencyResolver), NuGetDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(ProjectReferenceDependencyProvider), ProjectDepencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(ICache), cache, includeInManifest: false);
_serviceProvider.Add(typeof(ICacheContextAccessor), cacheContextAccessor, includeInManifest: false);
_serviceProvider.Add(typeof(INamedCacheDependencyProvider), namedCacheDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(IAssemblyLoadContextFactory), AssemblyLoadContextFactory, includeInManifest: false);
var compilerOptionsProvider = new CompilerOptionsProvider(ProjectResolver);
_serviceProvider.Add(typeof(ICompilerOptionsProvider), compilerOptionsProvider);
}
private void EmitProjectWrapper(XElement projectElement)
{
var projectFile = Path.GetFullPath(projectElement.Attribute("projectFile").Value);
// Name of the wrapper project is output assembly name, instead of .csproj file name
var outputAssemblyPath = GetOutputAssemblyPath(projectElement);
outputAssemblyPath = GetConfigAgnosticAssemblyPath(outputAssemblyPath);
var projectName = Path.GetFileNameWithoutExtension(outputAssemblyPath);
var projectDir = Path.GetDirectoryName(projectFile);
var rootDir = ProjectResolver.ResolveRootDirectory(projectDir);
var wrapRoot = Path.Combine(rootDir, WrapRootName);
string targetProjectJson;
if (InPlace)
{
targetProjectJson = Path.Combine(projectDir, Runtime.Project.ProjectFileName);
}
else
{
var projectResolver = new ProjectResolver(projectDir, rootDir);
targetProjectJson = LocateExistingProject(projectResolver, projectName);
if (string.IsNullOrEmpty(targetProjectJson))
{
AddWrapFolderToGlobalJson(rootDir);
targetProjectJson = Path.Combine(wrapRoot, projectName, Runtime.Project.ProjectFileName);
}
}
var targetFramework = GetTargetFramework(projectElement);
Reports.Information.WriteLine("Wrapping project '{0}' for '{1}'", projectName, targetFramework);
Reports.Information.WriteLine(" Source {0}", projectFile.Bold());
Reports.Information.WriteLine(" Target {0}", targetProjectJson.Bold());
var projectJson = LoadOrCreateProjectJson(targetProjectJson);
var relativeCsProjectPath = PathUtility.GetRelativePath(targetProjectJson, projectFile, PathSeparator);
AddWrappedProjectPath(projectJson, relativeCsProjectPath, targetFramework);
// Add 'assembly' and 'pdb' to 'bin' section of the target framework
var relativeAssemblyPath = PathUtility.GetRelativePath(targetProjectJson, outputAssemblyPath, PathSeparator);
var relativePdbPath = Path.ChangeExtension(relativeAssemblyPath, ".pdb");
Reports.Information.WriteLine(" Adding bin paths for '{0}'", targetFramework);
Reports.Information.WriteLine(" Assembly: {0}", relativeAssemblyPath.Bold());
Reports.Information.WriteLine(" Pdb: {0}", relativePdbPath.Bold());
AddFrameworkBinPaths(projectJson, targetFramework, relativeAssemblyPath, relativePdbPath);
var nugetPackages = ResolveNuGetPackages(projectDir);
var nugetPackagePaths = nugetPackages.Select(x => x.Path);
// Add nuget dependency to 'dependencies' section of the target framework
foreach (var package in nugetPackages)
{
Reports.Information.WriteLine(" Adding package dependency '{0}.{1}'",
package.Identity, package.Version);
AddNuGetDependency(projectJson, package, targetFramework);
}
// Add dependency projects to 'dependencies' section of the target framework
foreach (var itemElement in GetItemsByType(projectElement, type: "ProjectReference"))
{
var referenceProjectName = GetMetadataValue(itemElement, "Name");
var outputName = GetReferenceProjectOutputName(projectElement, referenceProjectName);
Reports.Information.WriteLine(" Adding project dependency '{0}.{1}'",
outputName, WrapperProjectVersion);
AddProjectDependency(projectJson, outputName, targetFramework);
}
// Create wrapper projects for assembly references
// and add wrapper projects as project references
foreach (var itemElement in GetItemsByType(projectElement, type: "ReferencePath"))
{
if (IsAssemblyFromProjectReference(itemElement) ||
IsFrameworkAssembly(itemElement) ||
IsAssemblyFromNuGetPackage(itemElement, nugetPackagePaths))
{
continue;
}
// This assembly becomes a project reference
var assemblyPath = itemElement.Attribute("evaluated").Value;
var assemblyProjectName = Path.GetFileNameWithoutExtension(assemblyPath);
EmitAssemblyWrapper(wrapRoot, targetFramework, assemblyPath, isSubProcedure: true);
Reports.Information.WriteLine(" Adding project dependency '{0}.{1}'",
assemblyProjectName, WrapperProjectVersion);
AddProjectDependency(projectJson, assemblyProjectName, targetFramework);
AddWrapFolderToGlobalJson(rootDir);
}
PathUtility.EnsureParentDirectory(targetProjectJson);
File.WriteAllText(targetProjectJson, projectJson.ToString());
AddToGlobalJsonSources(rootDir, Path.GetDirectoryName(targetProjectJson));
Reports.Information.WriteLine();
}
private void WriteGlobalJson()
{
var rootDirectory = ProjectResolver.ResolveRootDirectory(_project.ProjectDirectory);
var projectResolver = new ProjectResolver(_project.ProjectDirectory, rootDirectory);
var packagesDir = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
var pathResolver = new DefaultPackagePathResolver(packagesDir);
var dependenciesObj = new JObject();
// Generate SHAs for all package dependencies
foreach (var deploymentPackage in Packages)
{
var library = deploymentPackage.Library;
var shaFilePath = pathResolver.GetHashPath(library.Name, library.Version);
if (!File.Exists(shaFilePath))
{
throw new FileNotFoundException("Expected SHA file doesn't exist", shaFilePath);
}
var sha = File.ReadAllText(shaFilePath);
var shaObj = new JObject();
shaObj["version"] = library.Version.ToString();
shaObj["sha"] = sha;
dependenciesObj[library.Name] = shaObj;
}
// If "--no-source" is specified, project dependencies are packed to packages
// So we also generate SHAs for them in this case
foreach (var deploymentProject in Projects)
{
Runtime.Project project;
if (!projectResolver.TryResolveProject(deploymentProject.Name, out project))
{
throw new Exception("TODO: unable to resolve project named " + deploymentProject.Name);
}
var shaFilePath = pathResolver.GetHashPath(project.Name, project.Version);
if (!File.Exists(shaFilePath))
{
// This project is not packed to a package
continue;
}
var sha = File.ReadAllText(shaFilePath);
var shaObj = new JObject();
shaObj.Add(new JProperty("version", project.Version.ToString()));
shaObj.Add(new JProperty("sha", sha));
dependenciesObj.Add(new JProperty(project.Name, shaObj));
}
var rootObject = default(JObject);
if (GlobalSettings.HasGlobalFile(rootDirectory))
{
rootObject = JObject.Parse(File.ReadAllText(Path.Combine(
rootDirectory,
GlobalSettings.GlobalFileName)));
}
else
{
rootObject = new JObject();
}
var applicationRoot = Path.Combine(OutputPath, BundleRoot.AppRootName);
rootObject["dependencies"] = dependenciesObj;
rootObject["packages"] = PathUtility.GetRelativePath(
PathUtility.EnsureTrailingForwardSlash(applicationRoot),
TargetPackagesPath, separator: '/');
File.WriteAllText(Path.Combine(applicationRoot, GlobalSettings.GlobalFileName),
rootObject.ToString());
}
