| public GetInstallPath ( IPackage package ) : string | ||
| package | IPackage | |
| return | string | |
/// <summary>
/// This is a helper method for looking up directories that directly contains assemblies that would be loaded
/// given the published runtime framework. We should run crossgen on these folders
/// </summary>
private IEnumerable<string> ResolveOutputAssemblies(PublishRoot root)
{
var resolver = new DefaultPackagePathResolver(root.TargetPackagesPath);
if (root.PublishedLockFile == null)
{
return Enumerable.Empty<string>();
}
var directories = new HashSet<string>();
foreach (var target in root.PublishedLockFile.Targets)
{
foreach (var library in target.Libraries)
{
var packagesDir = resolver.GetInstallPath(library.Name, library.Version);
foreach (var path in library.RuntimeAssemblies)
{
var assemblyPath = CombinePath(packagesDir, path);
directories.Add(Path.GetDirectoryName(assemblyPath));
}
}
}
return directories;
}
internal static async Task InstallFromStream(Stream stream, Library library, string packagesDirectory,
SHA512 sha512)
{
var packagePathResolver = new DefaultPackagePathResolver(packagesDirectory);
var targetPath = packagePathResolver.GetInstallPath(library.Name, library.Version);
var targetNuspec = packagePathResolver.GetManifestFilePath(library.Name, library.Version);
var targetNupkg = packagePathResolver.GetPackageFilePath(library.Name, library.Version);
var hashPath = packagePathResolver.GetHashPath(library.Name, library.Version);
// Acquire the lock on a nukpg before we extract it to prevent the race condition when multiple
// processes are extracting to the same destination simultaneously
await ConcurrencyUtilities.ExecuteWithFileLocked(targetNupkg, async createdNewLock =>
{
// If this is the first process trying to install the target nupkg, go ahead
// After this process successfully installs the package, all other processes
// waiting on this lock don't need to install it again
if (createdNewLock)
{
Directory.CreateDirectory(targetPath);
using (var nupkgStream = new FileStream(targetNupkg, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite | FileShare.Delete))
{
await stream.CopyToAsync(nupkgStream);
nupkgStream.Seek(0, SeekOrigin.Begin);
ExtractPackage(targetPath, nupkgStream);
}
// Fixup the casing of the nuspec on disk to match what we expect
var nuspecFile = Directory.EnumerateFiles(targetPath, "*" + NuGet.Constants.ManifestExtension).Single();
if (!string.Equals(nuspecFile, targetNuspec, StringComparison.Ordinal))
{
Manifest manifest = null;
using (var nuspecStream = File.OpenRead(nuspecFile))
{
manifest = Manifest.ReadFrom(nuspecStream, validateSchema: false);
manifest.Metadata.Id = library.Name;
}
// Delete the previous nuspec file
File.Delete(nuspecFile);
// Write the new manifest
using (var targetNuspecStream = File.OpenWrite(targetNuspec))
{
manifest.Save(targetNuspecStream);
}
}
stream.Seek(0, SeekOrigin.Begin);
var nupkgSHA = Convert.ToBase64String(sha512.ComputeHash(stream));
File.WriteAllText(hashPath, nupkgSHA);
}
return 0;
});
}
public void Emit(PackRoot root)
{
var package = _nugetDependencyResolver.FindCandidate(
_libraryDescription.Identity.Name,
_libraryDescription.Identity.Version);
Console.WriteLine("Packing nupkg dependency {0} {1}", package.Id, package.Version);
var resolver = new DefaultPackagePathResolver(root.PackagesPath);
TargetPath = resolver.GetInstallPath(package.Id, package.Version);
if (Directory.Exists(TargetPath))
{
if (root.Overwrite)
{
root.Operations.Delete(TargetPath);
}
else
{
Console.WriteLine(" {0} already exists.", TargetPath);
return;
}
}
Console.WriteLine(" Target {0}", TargetPath);
var targetNupkgPath = resolver.GetPackageFilePath(package.Id, package.Version);
var hashPath = resolver.GetHashPath(package.Id, package.Version);
using (var sourceStream = package.GetStream())
{
using (var archive = new ZipArchive(sourceStream, ZipArchiveMode.Read))
{
root.Operations.ExtractNupkg(archive, TargetPath);
}
}
using (var sourceStream = package.GetStream())
{
using (var targetStream = new FileStream(targetNupkgPath, FileMode.Create, FileAccess.Write, FileShare.None))
{
sourceStream.CopyTo(targetStream);
}
sourceStream.Seek(0, SeekOrigin.Begin);
var sha512Bytes = SHA512.Create().ComputeHash(sourceStream);
File.WriteAllText(hashPath, Convert.ToBase64String(sha512Bytes));
}
}
public void Emit(PublishRoot root)
{
root.Reports.Quiet.WriteLine("Using {0} dependency {1}", _package.Type, Library);
var srcPackagePathResolver = new DefaultPackagePathResolver(root.SourcePackagesPath);
var targetPackagePathResolver = new DefaultPackagePathResolver(root.TargetPackagesPath);
var srcPackageDir = srcPackagePathResolver.GetInstallPath(
_package.Identity.Name,
_package.Identity.Version);
var targetPackageDir = targetPackagePathResolver.GetInstallPath(
_package.Identity.Name,
_package.Identity.Version);
root.Reports.Quiet.WriteLine(" Source {0}", srcPackageDir.Bold());
root.Reports.Quiet.WriteLine(" Target {0}", targetPackageDir);
root.Operations.Copy(srcPackageDir, targetPackageDir);
}
private bool EmitNupkg(PublishRoot root)
{
root.Reports.Quiet.WriteLine(" Packing nupkg from {0} dependency {1}",
_projectDescription.Type, _projectDescription.Identity.Name);
IsPackage = true;
var project = GetCurrentProject();
if (project == null)
{
return false;
}
var resolver = new DefaultPackagePathResolver(root.TargetPackagesPath);
var targetNupkg = resolver.GetPackageFileName(project.Name, project.Version);
TargetPath = resolver.GetInstallPath(project.Name, project.Version);
root.Reports.Quiet.WriteLine(" Source {0}", _projectDescription.Path.Bold());
root.Reports.Quiet.WriteLine(" Target {0}", TargetPath);
if (Directory.Exists(TargetPath))
{
root.Operations.Delete(TargetPath);
}
// If this is a wrapper project, we need to generate a lock file before building it
if (IsWrappingAssembly())
{
var success = Restore(root, publishProject: this, restoreDirectory: project.ProjectDirectory)
.GetAwaiter().GetResult();
if (!success)
{
return false;
}
}
// Generate nupkg from this project dependency
var buildOptions = new BuildOptions();
buildOptions.ProjectPatterns.Add(project.ProjectDirectory);
buildOptions.OutputDir = Path.Combine(project.ProjectDirectory, "bin");
buildOptions.Configurations.Add(root.Configuration);
buildOptions.GeneratePackages = true;
buildOptions.Reports = root.Reports.ShallowCopy();
if (root.Frameworks.Any())
{
// Make sure we only emit the nupkgs for the specified frameworks
// We need to pick actual project frameworks relevant to the publish
// but the project may not target exactly the right framework so we need
// to use a compatibility check.
foreach (var framework in root.Frameworks)
{
var selectedFramework = project.GetCompatibleTargetFramework(framework.Key);
if (selectedFramework == null)
{
root.Reports.WriteError($"Unable to build {project.Name}. It is not compatible with the requested target framework: {framework.Key}");
return false;
}
buildOptions.TargetFrameworks.Add(selectedFramework.FrameworkName, VersionUtility.GetShortFrameworkName(selectedFramework.FrameworkName));
}
}
// Mute "dnu pack" completely if it is invoked by "dnu publish --quiet"
buildOptions.Reports.Information = root.Reports.Quiet;
var buildManager = new BuildManager(root.HostServices, buildOptions);
if (!buildManager.Build())
{
return false;
}
// Extract the generated nupkg to target path
var srcNupkgPath = Path.Combine(buildOptions.OutputDir, root.Configuration, targetNupkg);
var srcSymbolsNupkgPath = Path.ChangeExtension(srcNupkgPath, "symbols.nupkg");
var options = new Packages.AddOptions
{
NuGetPackage = root.IncludeSymbols ? srcSymbolsNupkgPath : srcNupkgPath,
SourcePackages = root.TargetPackagesPath,
Reports = root.Reports
};
var packagesAddCommand = new Packages.AddCommand(options);
packagesAddCommand.Execute().GetAwaiter().GetResult();
// Copy content files (e.g. html, js and images) of main project into "root" folder of the exported package
var rootFolderPath = Path.Combine(TargetPath, "root");
var rootProjectJson = Path.Combine(rootFolderPath, Runtime.Project.ProjectFileName);
root.Operations.Delete(rootFolderPath);
CopyProject(root, project, rootFolderPath, includeSource: false);
UpdateWebRoot(root, rootFolderPath);
UpdateJson(rootProjectJson, jsonObj =>
{
// Update the project entrypoint
jsonObj["entryPoint"] = _projectDescription.Identity.Name;
// Set mark this as non loadable
jsonObj["loadable"] = false;
// Update the dependencies node to reference the main project
var deps = new JObject();
jsonObj["dependencies"] = deps;
deps[_projectDescription.Identity.Name] = _projectDescription.Identity.Version.ToString();
});
var appBase = Path.Combine(PublishRoot.AppRootName, "packages", resolver.GetPackageDirectory(_projectDescription.Identity.Name, _projectDescription.Identity.Version), "root");
_relativeAppBase = Path.Combine("..", appBase);
ApplicationBasePath = Path.Combine(root.OutputPath, appBase);
root.Reports.Quiet.WriteLine("Removing {0}", srcNupkgPath);
File.Delete(srcNupkgPath);
root.Reports.Quiet.WriteLine("Removing {0}", srcSymbolsNupkgPath);
File.Delete(srcSymbolsNupkgPath);
return true;
}
private bool PrunePackages(PublishRoot root)
{
var resolver = new DefaultPackagePathResolver(root.TargetPackagesPath);
// Special cases (for backwards compat)
var specialFolders = new List<string> {
"native",
"InteropAssemblies",
"redist",
"runtimes"
};
if (!root.NoSource)
{
// 'shared' folder is build time dependency, so we only copy it when deploying with source
specialFolders.Add("shared");
}
var lockFilePath = Path.GetFullPath(Path.Combine(ApplicationBasePath, LockFileFormat.LockFileName));
var format = new LockFileFormat();
root.LockFile = format.Read(lockFilePath);
var keep = new HashSet<string>();
foreach (var target in root.LockFile.Targets)
{
foreach (var library in target.Libraries)
{
var packagesDir = resolver.GetInstallPath(library.Name, library.Version);
var manifest = resolver.GetManifestFilePath(library.Name, library.Version);
keep.Add(manifest);
foreach (var path in library.RuntimeAssemblies)
{
keep.Add(CombinePath(packagesDir, path));
}
foreach (var path in library.CompileTimeAssemblies)
{
keep.Add(CombinePath(packagesDir, path));
}
foreach (var path in library.NativeLibraries)
{
keep.Add(CombinePath(packagesDir, path));
}
foreach (var path in library.ResourceAssemblies)
{
keep.Add(CombinePath(packagesDir, path));
}
foreach (var specialFolder in specialFolders)
{
var specialFolderPath = CombinePath(packagesDir, specialFolder);
if (!Directory.Exists(specialFolderPath))
{
continue;
}
keep.AddRange(Directory.EnumerateFiles(specialFolderPath, "*.*", SearchOption.AllDirectories));
}
}
}
foreach (var package in root.Packages)
{
var packageDir = resolver.GetInstallPath(package.Library.Name, package.Library.Version);
var packageFiles = Directory.EnumerateFiles(packageDir, "*.*", SearchOption.AllDirectories);
foreach (var file in packageFiles)
{
if (!keep.Contains(file))
{
File.Delete(file);
}
}
root.Operations.DeleteEmptyFolders(packageDir);
}
return true;
}
private static void CopyAspNetLoaderDll(PublishRoot root, string wwwRootOutPath)
{
// Tool dlls including AspNet.Loader.dll go to bin folder under public app folder
var wwwRootOutBinPath = Path.Combine(wwwRootOutPath, "bin");
// Check for an environment variable which can be used (generally in tests)
// to override where AspNet.Loader.dll is located.
var loaderPath = Environment.GetEnvironmentVariable(EnvironmentNames.AspNetLoaderPath);
if (string.IsNullOrEmpty(loaderPath))
{
// Copy Microsoft.AspNet.Loader.IIS.Interop/tools/*.dll into bin to support AspNet.Loader.dll
var package = root.Packages.SingleOrDefault(
x => string.Equals(x.Library.Name, "Microsoft.AspNet.Loader.IIS.Interop"));
if (package == null)
{
return;
}
var resolver = new DefaultPackagePathResolver(root.SourcePackagesPath);
var packagePath = resolver.GetInstallPath(package.Library.Name, package.Library.Version);
loaderPath = Path.Combine(packagePath, "tools");
}
if (!string.IsNullOrEmpty(loaderPath) && Directory.Exists(loaderPath))
{
foreach (var packageToolFile in Directory.EnumerateFiles(loaderPath, "*.dll").Select(Path.GetFileName))
{
// Create the bin folder only when we need to put something inside it
if (!Directory.Exists(wwwRootOutBinPath))
{
Directory.CreateDirectory(wwwRootOutBinPath);
}
// Copy to bin folder under public app folder
File.Copy(
Path.Combine(loaderPath, packageToolFile),
Path.Combine(wwwRootOutBinPath, packageToolFile),
overwrite: true);
}
}
}
private void Emit(BundleRoot root, IEnumerable<PackageAssembly> assemblies)
{
var resolver = new DefaultPackagePathResolver(root.TargetPackagesPath);
TargetPath = resolver.GetInstallPath(Library.Name, Library.Version);
root.Reports.Quiet.WriteLine(" Source: {0}", _libraryDescription.Path);
root.Reports.Quiet.WriteLine(" Target: {0}", TargetPath);
Directory.CreateDirectory(TargetPath);
// Copy nuspec
var nuspecName = resolver.GetManifestFileName(Library.Name, Library.Version);
root.Reports.Quiet.WriteLine(" File: {0}", nuspecName.Bold());
CopyFile(root, Path.Combine(_libraryDescription.Path, nuspecName), Path.Combine(TargetPath, nuspecName), root.Overwrite);
// Copy assemblies for current framework
foreach (var assembly in assemblies)
{
root.Reports.Quiet.WriteLine(" File: {0}", assembly.RelativePath.Bold());
var targetAssemblyPath = Path.Combine(TargetPath, assembly.RelativePath);
CopyFile(root, assembly.Path, targetAssemblyPath, root.Overwrite);
}
// Special cases
var specialFolders = new[] { "native", "InteropAssemblies", "redist", Path.Combine("lib", "contract") };
foreach (var folder in specialFolders)
{
var srcFolder = Path.Combine(_libraryDescription.Path, folder);
var targetFolder = Path.Combine(TargetPath, folder);
CopyFolder(root, srcFolder, targetFolder);
}
}
private bool EmitNupkg(PublishRoot root)
{
root.Reports.Quiet.WriteLine(" Packing nupkg from {0} dependency {1}",
_libraryDescription.Type, _libraryDescription.Identity.Name);
IsPackage = true;
var project = GetCurrentProject();
var resolver = new DefaultPackagePathResolver(root.TargetPackagesPath);
var targetNupkg = resolver.GetPackageFileName(project.Name, project.Version);
TargetPath = resolver.GetInstallPath(project.Name, project.Version);
root.Reports.Quiet.WriteLine(" Source {0}", _libraryDescription.Path.Bold());
root.Reports.Quiet.WriteLine(" Target {0}", TargetPath);
if (Directory.Exists(TargetPath))
{
root.Operations.Delete(TargetPath);
}
// Generate nupkg from this project dependency
var buildOptions = new BuildOptions();
buildOptions.ProjectDir = project.ProjectDirectory;
buildOptions.OutputDir = Path.Combine(project.ProjectDirectory, "bin");
buildOptions.Configurations.Add(root.Configuration);
buildOptions.Reports = root.Reports;
buildOptions.GeneratePackages = true;
var buildManager = new BuildManager(root.HostServices, buildOptions);
if (!buildManager.Build())
{
return false;
}
// Extract the generated nupkg to target path
var srcNupkgPath = Path.Combine(buildOptions.OutputDir, root.Configuration, targetNupkg);
var targetNupkgPath = resolver.GetPackageFilePath(project.Name, project.Version);
var hashFile = resolver.GetHashPath(project.Name, project.Version);
using (var sourceStream = new FileStream(srcNupkgPath, FileMode.Open, FileAccess.Read))
{
using (var archive = new ZipArchive(sourceStream, ZipArchiveMode.Read))
{
root.Operations.ExtractNupkg(archive, TargetPath);
}
}
using (var sourceStream = new FileStream(srcNupkgPath, FileMode.Open, FileAccess.Read))
{
using (var targetStream = new FileStream(targetNupkgPath, FileMode.Create, FileAccess.Write, FileShare.None))
{
sourceStream.CopyTo(targetStream);
}
sourceStream.Seek(0, SeekOrigin.Begin);
var sha512Bytes = SHA512.Create().ComputeHash(sourceStream);
File.WriteAllText(hashFile, Convert.ToBase64String(sha512Bytes));
}
// Copy content files (e.g. html, js and images) of main project into "root" folder of the exported package
var rootFolderPath = Path.Combine(TargetPath, "root");
var rootProjectJson = Path.Combine(rootFolderPath, Runtime.Project.ProjectFileName);
root.Operations.Delete(rootFolderPath);
CopyProject(root, project, rootFolderPath, includeSource: false);
UpdateWebRoot(root, rootFolderPath);
UpdateJson(rootProjectJson, jsonObj =>
{
// Update the project entrypoint
jsonObj["entryPoint"] = _libraryDescription.Identity.Name;
// Set mark this as non loadable
jsonObj["loadable"] = false;
// Update the dependencies node to reference the main project
var deps = new JObject();
jsonObj["dependencies"] = deps;
deps[_libraryDescription.Identity.Name] = _libraryDescription.Identity.Version.ToString();
});
_applicationBase = Path.Combine("..", PublishRoot.AppRootName, "packages", resolver.GetPackageDirectory(_libraryDescription.Identity.Name, _libraryDescription.Identity.Version), "root");
root.Reports.Quiet.WriteLine("Removing {0}", srcNupkgPath);
File.Delete(srcNupkgPath);
srcNupkgPath = Path.ChangeExtension(srcNupkgPath, "symbols.nupkg");
root.Reports.Quiet.WriteLine("Removing {0}", srcNupkgPath);
File.Delete(srcNupkgPath);
return true;
}
private void Emit(PublishRoot root, IEnumerable<PackageAssembly> assemblies)
{
var resolver = new DefaultPackagePathResolver(root.TargetPackagesPath);
TargetPath = resolver.GetInstallPath(Library.Name, Library.Version);
root.Reports.Quiet.WriteLine(" Source: {0}", _libraryDescription.Path);
root.Reports.Quiet.WriteLine(" Target: {0}", TargetPath);
Directory.CreateDirectory(TargetPath);
// Copy nuspec
var nuspecName = resolver.GetManifestFileName(Library.Name, Library.Version);
root.Reports.Quiet.WriteLine(" File: {0}", nuspecName.Bold());
CopyFile(root, Path.Combine(_libraryDescription.Path, nuspecName), Path.Combine(TargetPath, nuspecName));
// Copy assemblies for current framework
foreach (var assembly in assemblies)
{
root.Reports.Quiet.WriteLine(" File: {0}", assembly.RelativePath.Bold());
var targetAssemblyPath = Path.Combine(TargetPath, assembly.RelativePath);
CopyFile(root, assembly.Path, targetAssemblyPath);
}
// Special cases
var specialFolders = new List<string> { "native", "InteropAssemblies", "redist",
Path.Combine("lib", "contract") };
if (!root.NoSource)
{
// 'shared' folder is build time dependency, so we only copy it when deploying with source
specialFolders.Add("shared");
}
foreach (var folder in specialFolders)
{
var srcFolder = Path.Combine(_libraryDescription.Path, folder);
var targetFolder = Path.Combine(TargetPath, folder);
CopyFolder(root, srcFolder, targetFolder);
}
}
private static void CopyAspNetLoaderDll(BundleRoot root, string wwwRootOutPath)
{
// Tool dlls including AspNet.Loader.dll go to bin folder under public app folder
var wwwRootOutBinPath = Path.Combine(wwwRootOutPath, "bin");
// Copy Microsoft.AspNet.Loader.IIS.Interop/tools/*.dll into bin to support AspNet.Loader.dll
var package = root.Packages.SingleOrDefault(
x => string.Equals(x.Library.Name, "Microsoft.AspNet.Loader.IIS.Interop"));
if (package == null)
{
return;
}
var resolver = new DefaultPackagePathResolver(root.SourcePackagesPath);
var packagePath = resolver.GetInstallPath(package.Library.Name, package.Library.Version);
var packageToolsPath = Path.Combine(packagePath, "tools");
if (Directory.Exists(packageToolsPath))
{
foreach (var packageToolFile in Directory.EnumerateFiles(packageToolsPath, "*.dll").Select(Path.GetFileName))
{
// Create the bin folder only when we need to put something inside it
if (!Directory.Exists(wwwRootOutBinPath))
{
Directory.CreateDirectory(wwwRootOutBinPath);
}
// Copy to bin folder under public app folder
File.Copy(
Path.Combine(packageToolsPath, packageToolFile),
Path.Combine(wwwRootOutBinPath, packageToolFile),
overwrite: true);
}
}
}
private void PrunePackages(PublishRoot root)
{
if (root.MainProjectLockFile == null)
{
return;
}
var resolver = new DefaultPackagePathResolver(root.TargetPackagesPath);
var lockFilePath = Path.GetFullPath(Path.Combine(ApplicationBasePath, LockFileFormat.LockFileName));
root.PublishedLockFile = new LockFileFormat().Read(lockFilePath);
var filesToKeep = new HashSet<string>();
var filesToRemove = new HashSet<string>();
foreach (var target in root.PublishedLockFile.Targets)
{
foreach (var library in target.Libraries)
{
var packageDir = resolver.GetInstallPath(library.Name, library.Version);
if (library.Name != root.MainProjectName && string.Equals(library.Type, Runtime.LibraryTypes.Package, StringComparison.OrdinalIgnoreCase))
{
filesToRemove.Add(resolver.GetHashPath(library.Name, library.Version));
filesToRemove.Add(resolver.GetPackageFilePath(library.Name, library.Version));
filesToRemove.AddRange(Directory.EnumerateFiles(packageDir, $"{library.Name}.xml", SearchOption.AllDirectories));
}
foreach (var path in library.RuntimeAssemblies)
{
filesToKeep.Add(Path.Combine(packageDir, path));
}
foreach (var path in library.CompileTimeAssemblies)
{
filesToKeep.Add(Path.Combine(packageDir, path));
}
foreach (var path in library.NativeLibraries)
{
filesToKeep.Add(Path.Combine(packageDir, path));
}
foreach (var path in library.ResourceAssemblies)
{
filesToKeep.Add(Path.Combine(packageDir, path));
}
}
}
foreach (var target in root.MainProjectLockFile.Targets.Where(projectTarget =>
string.IsNullOrEmpty(projectTarget.RuntimeIdentifier) &&
!root.PublishedLockFile.Targets.Any(publishTarget =>
projectTarget.TargetFramework == publishTarget.TargetFramework)))
{
foreach (var library in target.Libraries)
{
var packageDir = resolver.GetInstallPath(library.Name, library.Version);
if (Directory.Exists(packageDir))
{
foreach (var path in library.RuntimeAssemblies)
{
filesToRemove.Add(Path.Combine(packageDir, path));
}
foreach (var path in library.CompileTimeAssemblies)
{
filesToRemove.Add(Path.Combine(packageDir, path));
}
foreach (var path in library.NativeLibraries)
{
filesToRemove.Add(Path.Combine(packageDir, path));
}
foreach (var path in library.ResourceAssemblies)
{
filesToRemove.Add(Path.Combine(packageDir, path));
}
}
}
}
foreach (var file in filesToRemove.Except(filesToKeep))
{
File.Delete(file);
}
if (Directory.Exists(root.TargetPackagesPath))
{
root.Operations.DeleteEmptyFolders(root.TargetPackagesPath);
}
return;
}
private async Task<bool> RestoreForProject(LocalPackageRepository localRepository, string projectJsonPath, string rootDirectory, string packagesDirectory)
{
var success = true;
Reports.Information.WriteLine(string.Format("Restoring packages for {0}", projectJsonPath.Bold()));
var sw = new Stopwatch();
sw.Start();
Project project;
if (!Project.TryGetProject(projectJsonPath, out project))
{
throw new Exception("TODO: project.json parse error");
}
Func<string, string> getVariable = key =>
{
return null;
};
ScriptExecutor.Execute(project, "prerestore", getVariable);
var projectDirectory = project.ProjectDirectory;
var restoreOperations = new RestoreOperations { Report = Reports.Information };
var projectProviders = new List<IWalkProvider>();
var localProviders = new List<IWalkProvider>();
var remoteProviders = new List<IWalkProvider>();
var contexts = new List<RestoreContext>();
projectProviders.Add(
new LocalWalkProvider(
new ProjectReferenceDependencyProvider(
new ProjectResolver(
projectDirectory,
rootDirectory))));
localProviders.Add(
new LocalWalkProvider(
new NuGetDependencyResolver(
packagesDirectory,
new EmptyFrameworkResolver())));
var allSources = SourceProvider.LoadPackageSources();
var enabledSources = Sources.Any() ?
Enumerable.Empty<PackageSource>() :
allSources.Where(s => s.IsEnabled);
var addedSources = Sources.Concat(FallbackSources).Select(
value => allSources.FirstOrDefault(source => CorrectName(value, source)) ?? new PackageSource(value));
var effectiveSources = enabledSources.Concat(addedSources).Distinct().ToList();
foreach (var source in effectiveSources)
{
if (new Uri(source.Source).IsFile)
{
remoteProviders.Add(
new RemoteWalkProvider(
new PackageFolder(
source.Source,
Reports.Verbose)));
}
else
{
remoteProviders.Add(
new RemoteWalkProvider(
new PackageFeed(
source.Source,
source.UserName,
source.Password,
NoCache,
Reports.Verbose)));
}
}
foreach (var configuration in project.GetTargetFrameworks())
{
var context = new RestoreContext
{
FrameworkName = configuration.FrameworkName,
ProjectLibraryProviders = projectProviders,
LocalLibraryProviders = localProviders,
RemoteLibraryProviders = remoteProviders,
};
contexts.Add(context);
}
if (!contexts.Any())
{
contexts.Add(new RestoreContext
{
FrameworkName = ApplicationEnvironment.TargetFramework,
ProjectLibraryProviders = projectProviders,
LocalLibraryProviders = localProviders,
RemoteLibraryProviders = remoteProviders,
});
}
var tasks = new List<Task<GraphNode>>();
foreach (var context in contexts)
{
tasks.Add(restoreOperations.CreateGraphNode(context, new Library { Name = project.Name, Version = project.Version }, _ => true));
}
var graphs = await Task.WhenAll(tasks);
Reports.Information.WriteLine(string.Format("{0}, {1}ms elapsed", "Resolving complete".Green(), sw.ElapsedMilliseconds));
var installItems = new List<GraphItem>();
var missingItems = new List<Library>();
ForEach(graphs, node =>
{
if (node == null || node.Library == null)
{
return;
}
if (node.Item == null || node.Item.Match == null)
{
if (node.Library.Version != null && !missingItems.Contains(node.Library))
{
missingItems.Add(node.Library);
Reports.Information.WriteLine(string.Format("Unable to locate {0} >= {1}", node.Library.Name.Red().Bold(), node.Library.Version));
success = false;
}
return;
}
var isRemote = remoteProviders.Contains(node.Item.Match.Provider);
var isAdded = installItems.Any(item => item.Match.Library == node.Item.Match.Library);
if (!isAdded && isRemote)
{
installItems.Add(node.Item);
}
});
var dependencies = new Dictionary<Library, string>();
// If there is a global.json file specified, we should do SHA value verification
var globalJsonFileSpecified = !string.IsNullOrEmpty(GlobalJsonFile);
JToken dependenciesNode = null;
if (globalJsonFileSpecified)
{
var globalJson = JObject.Parse(File.ReadAllText(GlobalJsonFile));
dependenciesNode = globalJson["dependencies"];
if (dependenciesNode != null)
{
dependencies = dependenciesNode
.OfType<JProperty>()
.ToDictionary(d => new Library()
{
Name = d.Name,
Version = SemanticVersion.Parse(d.Value.Value<string>("version"))
},
d => d.Value.Value<string>("sha"));
}
}
var packagePathResolver = new DefaultPackagePathResolver(packagesDirectory);
using (var sha512 = SHA512.Create())
{
foreach (var item in installItems)
{
var library = item.Match.Library;
var memStream = new MemoryStream();
await item.Match.Provider.CopyToAsync(item.Match, memStream);
memStream.Seek(0, SeekOrigin.Begin);
var nupkgSHA = Convert.ToBase64String(sha512.ComputeHash(memStream));
string expectedSHA;
if (dependencies.TryGetValue(library, out expectedSHA))
{
if (!string.Equals(expectedSHA, nupkgSHA, StringComparison.Ordinal))
{
Reports.Information.WriteLine(
string.Format("SHA of downloaded package {0} doesn't match expected value.".Red().Bold(),
library.ToString()));
success = false;
continue;
}
}
else
{
// Report warnings only when given global.json contains "dependencies"
if (globalJsonFileSpecified && dependenciesNode != null)
{
Reports.Information.WriteLine(
string.Format("Expected SHA of package {0} doesn't exist in given global.json file.".Yellow().Bold(),
library.ToString()));
}
}
Reports.Information.WriteLine(string.Format("Installing {0} {1}", library.Name.Bold(), library.Version));
var targetPath = packagePathResolver.GetInstallPath(library.Name, library.Version);
var targetNupkg = packagePathResolver.GetPackageFilePath(library.Name, library.Version);
var hashPath = packagePathResolver.GetHashPath(library.Name, library.Version);
// Acquire the lock on a nukpg before we extract it to prevent the race condition when multiple
// processes are extracting to the same destination simultaneously
await ConcurrencyUtilities.ExecuteWithFileLocked(targetNupkg, async createdNewLock =>
{
// If this is the first process trying to install the target nupkg, go ahead
// After this process successfully installs the package, all other processes
// waiting on this lock don't need to install it again
if (createdNewLock)
{
Directory.CreateDirectory(targetPath);
using (var stream = new FileStream(targetNupkg, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite | FileShare.Delete))
{
await item.Match.Provider.CopyToAsync(item.Match, stream);
stream.Seek(0, SeekOrigin.Begin);
ExtractPackage(targetPath, stream);
}
File.WriteAllText(hashPath, nupkgSHA);
}
return 0;
});
}
}
ScriptExecutor.Execute(project, "postrestore", getVariable);
ScriptExecutor.Execute(project, "prepare", getVariable);
Reports.Information.WriteLine(string.Format("{0}, {1}ms elapsed", "Restore complete".Green().Bold(), sw.ElapsedMilliseconds));
// Print the dependency graph
if (success)
{
var graphNum = contexts.Count;
for (int i = 0; i < graphNum; i++)
{
PrintDependencyGraph(graphs[i], contexts[i].FrameworkName);
}
}
return success;
}
internal static async Task InstallFromStream(
Stream stream,
LibraryIdentity library,
string packagesDirectory,
IReport information,
string packageHash = null)
{
var packagePathResolver = new DefaultPackagePathResolver(packagesDirectory);
var targetPath = packagePathResolver.GetInstallPath(library.Name, library.Version);
var targetNuspec = packagePathResolver.GetManifestFilePath(library.Name, library.Version);
var targetNupkg = packagePathResolver.GetPackageFilePath(library.Name, library.Version);
var targetHashPath = packagePathResolver.GetHashPath(library.Name, library.Version);
// Acquire the lock on a nukpg before we extract it to prevent the race condition when multiple
// processes are extracting to the same destination simultaneously
await ConcurrencyUtilities.ExecuteWithFileLocked(targetNupkg, action: async _ =>
{
if (string.IsNullOrEmpty(packageHash))
{
using (var sha512 = SHA512.Create())
{
packageHash = Convert.ToBase64String(sha512.ComputeHash(stream));
}
}
var actionName = "Installing";
var installedPackageHash = string.Empty;
if (File.Exists(targetHashPath) && File.Exists(targetNuspec))
{
installedPackageHash = File.ReadAllText(targetHashPath);
actionName = "Overwriting";
}
if (string.Equals(packageHash, installedPackageHash, StringComparison.Ordinal))
{
information.WriteLine($"{library.Name}.{library.Version} already exists");
}
else
{
information.WriteLine($"{actionName} {library.Name}.{library.Version}");
Directory.CreateDirectory(targetPath);
using (var nupkgStream = new FileStream(
targetNupkg,
FileMode.Create,
FileAccess.ReadWrite,
FileShare.ReadWrite | FileShare.Delete,
bufferSize: 4096,
useAsync: true))
{
stream.Seek(0, SeekOrigin.Begin);
await stream.CopyToAsync(nupkgStream);
nupkgStream.Seek(0, SeekOrigin.Begin);
ExtractPackage(targetPath, nupkgStream);
}
// Fixup the casing of the nuspec on disk to match what we expect
var nuspecFile = Directory.EnumerateFiles(targetPath, "*" + NuGet.Constants.ManifestExtension).Single();
Manifest manifest = null;
using (var nuspecStream = File.OpenRead(nuspecFile))
{
manifest = Manifest.ReadFrom(nuspecStream, validateSchema: false);
manifest.Metadata.Id = library.Name;
manifest.Metadata.Version = library.Version;
}
// Delete the previous nuspec file
File.Delete(nuspecFile);
// Write the new manifest
using (var targetNuspecStream = File.OpenWrite(targetNuspec))
{
manifest.Save(targetNuspecStream);
}
// Note: PackageRepository relies on the hash file being written out as the final operation as part of a package install
// to assume a package was fully installed.
File.WriteAllText(targetHashPath, packageHash);
}
return 0;
});
}
private bool EmitNupkg(PublishRoot root)
{
root.Reports.Quiet.WriteLine(" Packing nupkg from {0} dependency {1}",
_libraryDescription.Type, _libraryDescription.Identity.Name);
IsPackage = true;
var project = GetCurrentProject();
var resolver = new DefaultPackagePathResolver(root.TargetPackagesPath);
var targetNupkg = resolver.GetPackageFileName(project.Name, project.Version);
TargetPath = resolver.GetInstallPath(project.Name, project.Version);
root.Reports.Quiet.WriteLine(" Source {0}", _libraryDescription.Path.Bold());
root.Reports.Quiet.WriteLine(" Target {0}", TargetPath);
if (Directory.Exists(TargetPath))
{
root.Operations.Delete(TargetPath);
}
// Generate nupkg from this project dependency
var buildOptions = new BuildOptions();
buildOptions.ProjectPatterns.Add(project.ProjectDirectory);
buildOptions.OutputDir = Path.Combine(project.ProjectDirectory, "bin");
buildOptions.Configurations.Add(root.Configuration);
buildOptions.GeneratePackages = true;
buildOptions.Reports = root.Reports.ShallowCopy();
// Mute "dnu pack" completely if it is invoked by "dnu publish --quiet"
buildOptions.Reports.Information = root.Reports.Quiet;
var buildManager = new BuildManager(root.HostServices, buildOptions);
if (!buildManager.Build())
{
return false;
}
// Extract the generated nupkg to target path
var srcNupkgPath = Path.Combine(buildOptions.OutputDir, root.Configuration, targetNupkg);
var srcSymbolsNupkgPath = Path.ChangeExtension(srcNupkgPath, "symbols.nupkg");
var options = new Microsoft.Framework.PackageManager.Packages.AddOptions
{
NuGetPackage = root.IncludeSymbols ? srcSymbolsNupkgPath : srcNupkgPath,
SourcePackages = root.TargetPackagesPath,
Reports = root.Reports
};
var packagesAddCommand = new Microsoft.Framework.PackageManager.Packages.AddCommand(options);
packagesAddCommand.Execute().GetAwaiter().GetResult();
// Copy content files (e.g. html, js and images) of main project into "root" folder of the exported package
var rootFolderPath = Path.Combine(TargetPath, "root");
var rootProjectJson = Path.Combine(rootFolderPath, Runtime.Project.ProjectFileName);
root.Operations.Delete(rootFolderPath);
CopyProject(root, project, rootFolderPath, includeSource: false);
UpdateWebRoot(root, rootFolderPath);
UpdateJson(rootProjectJson, jsonObj =>
{
// Update the project entrypoint
jsonObj["entryPoint"] = _libraryDescription.Identity.Name;
// Set mark this as non loadable
jsonObj["loadable"] = false;
// Update the dependencies node to reference the main project
var deps = new JObject();
jsonObj["dependencies"] = deps;
deps[_libraryDescription.Identity.Name] = _libraryDescription.Identity.Version.ToString();
});
var appBase = Path.Combine(PublishRoot.AppRootName, "packages", resolver.GetPackageDirectory(_libraryDescription.Identity.Name, _libraryDescription.Identity.Version), "root");
_relativeAppBase = Path.Combine("..", appBase);
ApplicationBasePath = Path.Combine(root.OutputPath, appBase);
root.Reports.Quiet.WriteLine("Removing {0}", srcNupkgPath);
File.Delete(srcNupkgPath);
root.Reports.Quiet.WriteLine("Removing {0}", srcSymbolsNupkgPath);
File.Delete(srcSymbolsNupkgPath);
return true;
}
public string GetInstallPath(IPackage package)
{
pathResolver = new DefaultPackagePathResolver(PackageRepositoryPath);
return pathResolver.GetInstallPath(package);
}
internal static async Task InstallFromStream(Stream stream,
Library library,
string packagesDirectory,
SHA512 sha512,
bool performingParallelInstalls = false)
{
var packagePathResolver = new DefaultPackagePathResolver(packagesDirectory);
var targetPath = packagePathResolver.GetInstallPath(library.Name, library.Version);
var targetNuspec = packagePathResolver.GetManifestFilePath(library.Name, library.Version);
var targetNupkg = packagePathResolver.GetPackageFilePath(library.Name, library.Version);
var hashPath = packagePathResolver.GetHashPath(library.Name, library.Version);
// Acquire the lock on a nukpg before we extract it to prevent the race condition when multiple
// processes are extracting to the same destination simultaneously
await ConcurrencyUtilities.ExecuteWithFileLocked(targetNupkg, async createdNewLock =>
{
// If this is the first process trying to install the target nupkg, go ahead
// After this process successfully installs the package, all other processes
// waiting on this lock don't need to install it again.
if (createdNewLock && !File.Exists(targetNupkg))
{
var extractPath = targetPath;
if (performingParallelInstalls)
{
// Extracting to the {id}/{version} has an issue with concurrent installs - when a package has been partially
// extracted, the Restore Operation can inadvertly conclude the package is available locally and proceed to read
// partially written package contents. To avoid this we'll extract the package to a sibling directory and Move it
// to the target path.
extractPath = Path.Combine(Path.GetDirectoryName(targetPath), Path.GetRandomFileName());
targetNupkg = Path.Combine(extractPath, Path.GetFileName(targetNupkg));
}
var extractDirectory = Directory.CreateDirectory(extractPath);
using (var nupkgStream = new FileStream(
targetNupkg,
FileMode.Create,
FileAccess.ReadWrite,
FileShare.ReadWrite | FileShare.Delete,
bufferSize: 4096,
useAsync: true))
{
await stream.CopyToAsync(nupkgStream);
nupkgStream.Seek(0, SeekOrigin.Begin);
ExtractPackage(extractPath, nupkgStream);
}
// Fixup the casing of the nuspec on disk to match what we expect
var nuspecFile = Directory.EnumerateFiles(targetPath, "*" + NuGet.Constants.ManifestExtension).Single();
if (!string.Equals(nuspecFile, targetNuspec, StringComparison.Ordinal))
{
Manifest manifest = null;
using (var nuspecStream = File.OpenRead(nuspecFile))
{
manifest = Manifest.ReadFrom(nuspecStream, validateSchema: false);
manifest.Metadata.Id = library.Name;
}
// Delete the previous nuspec file
File.Delete(nuspecFile);
// Write the new manifest
using (var targetNuspecStream = File.OpenWrite(targetNuspec))
{
manifest.Save(targetNuspecStream);
}
}
stream.Seek(0, SeekOrigin.Begin);
var nupkgSHA = Convert.ToBase64String(sha512.ComputeHash(stream));
File.WriteAllText(hashPath, nupkgSHA);
if (performingParallelInstalls)
{
extractDirectory.MoveTo(targetPath);
}
}
return 0;
});
}