public async Task <bool> Execute()
{
Reports = Options.Reports;
LocalPackages = Options.SourcePackages ??
NuGetDependencyResolver.ResolveRepositoryPath(Directory.GetCurrentDirectory());
Options.Reports.Information.WriteLine(string.Format("Adding NuGet package {0} to {1}",
Options.NuGetPackage.Bold(), LocalPackages.Bold()));
var sw = new Stopwatch();
sw.Start();
var library = NuGetPackageUtils.CreateLibraryFromNupkg(Options.NuGetPackage);
using (var sha512 = SHA512.Create())
using (var stream = File.OpenRead(Options.NuGetPackage))
{
Reports.Information.WriteLine("Installing {0} {1}", library.Name.Bold(), library.Version);
await NuGetPackageUtils.InstallFromStream(stream, library, LocalPackages, sha512);
}
Reports.Information.WriteLine(
"{0}, {1}ms elapsed",
"Add complete".Green().Bold(),
sw.ElapsedMilliseconds);
return(true);
}
public async Task <bool> Execute()
{
Reports = Options.Reports;
LocalPackages = Options.SourcePackages ??
NuGetDependencyResolver.ResolveRepositoryPath(Directory.GetCurrentDirectory());
Options.Reports.Quiet.WriteLine(string.Format("Adding NuGet package {0} to {1}",
Options.NuGetPackage.Bold(), LocalPackages.Bold()));
var sw = new Stopwatch();
sw.Start();
var library = NuGetPackageUtils.CreateLibraryFromNupkg(Options.NuGetPackage);
using (var stream = File.OpenRead(Options.NuGetPackage))
{
string packageHash = null;
if (File.Exists(Options.PackageHashFilePath))
{
packageHash = File.ReadAllText(Options.PackageHashFilePath);
}
await NuGetPackageUtils.InstallFromStream(stream, library, LocalPackages, Reports.Quiet, packageHash);
}
Reports.Quiet.WriteLine(
"{0}, {1}ms elapsed",
"Add complete".Green().Bold(),
sw.ElapsedMilliseconds);
return(true);
}
public Program(
IApplicationEnvironment appEnv, IServiceProvider services, NuGetDependencyResolver nuget)
{
GraphicsTest.Setup = container =>
{
container.Map(nuget).Map(appEnv);
};
xunitRunner = new Xunit.Runner.Dnx.Program(appEnv, services);
}
public async Task ResolveAsync_WithExistingPackage_ReturnsPackages()
{
// Arrange
var repository = NugetRepository.FromSourceUrl(NugetRepositoryTests.TestNugetFeed);
var provider = new NuGetDependencyResolver(new AggregateNugetRepository(new[] { repository }));
// Act
var result = await provider.ResolveAsync(NugetRepositoryTests.TestPackageName);
// Assert
Assert.NotEmpty(result.FoundDependencies);
Assert.Empty(result.NotFoundDependencies);
}
public async Task ResolveAsync_WithNoPackage_ReturnsMissing()
{
// Arrange
var repository = NugetRepository.FromSourceUrl(NugetRepositoryTests.TestNugetFeed);
var provider = new NuGetDependencyResolver(new AggregateNugetRepository(new[] { repository }));
// Act
var result = await provider.ResolveAsync("this.package.does.not.exist");
// Assert
Assert.NotEmpty(result.NotFoundDependencies);
Assert.Empty(result.FoundDependencies);
}
/// <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, NuGetDependencyResolver resolver)
{
var outputPathsMap = root.Packages
.ToDictionary(
pkg => pkg.Library,
pkg => pkg.TargetPath
);
var result = new HashSet <string>();
var libraryNotInOutput = new List <Library>();
var missingOutputFolder = new List <string>();
foreach (var dependency in resolver.PackageAssemblyLookup.Values)
{
var libId = dependency.Library.Identity;
var libPath = dependency.Library.Path;
var assemblyDir = Path.GetDirectoryName(dependency.Path);
var assemblySelection = assemblyDir.Substring(libPath.Length);
string outputLibLocation;
if (!outputPathsMap.TryGetValue(libId, out outputLibLocation))
{
libraryNotInOutput.Add(libId);
continue;
}
var output = outputLibLocation + assemblySelection;
if (!Directory.Exists(output))
{
missingOutputFolder.Add(output);
}
else
{
result.Add(output);
}
}
if (libraryNotInOutput.Any())
{
throw new InvalidOperationException(string.Format("Library {0} cannot be found in the published output.", string.Join(", ", libraryNotInOutput)));
}
if (missingOutputFolder.Any())
{
throw new InvalidOperationException("Published output does not contain directory:\n" + string.Join("\n", missingOutputFolder));
}
return(result);
}
private bool TryPopulateMetadataReferences(PackageDescription library, FrameworkName targetFramework, IDictionary <string, IMetadataReference> paths)
{
foreach (var assemblyPath in library.LockFileLibrary.CompileTimeAssemblies)
{
if (NuGetDependencyResolver.IsPlaceholderFile(assemblyPath))
{
continue;
}
var name = Path.GetFileNameWithoutExtension(assemblyPath);
var path = Path.Combine(library.Path, assemblyPath);
paths[name] = new MetadataFileReference(name, path);
}
return(true);
}
private string ResolvePackagesFolder()
{
var packagesFolder = PackagesFolder;
if (string.IsNullOrEmpty(packagesFolder))
{
packagesFolder = NuGetDependencyResolver.ResolveRepositoryPath(_solutionRoot);
}
if (!Directory.Exists(packagesFolder))
{
_reports.WriteError($"Cannot find the packages folder '{packagesFolder}'.");
return(null);
}
return(packagesFolder);
}
public bool ExecuteCommand()
{
var sw = new Stopwatch();
sw.Start();
var restoreDirectory = RestoreDirectory ?? Directory.GetCurrentDirectory();
var projectJsonFiles = Directory.GetFiles(restoreDirectory, "project.json", SearchOption.AllDirectories);
var rootDirectory = ProjectResolver.ResolveRootDirectory(restoreDirectory);
ReadSettings(rootDirectory);
string packagesDirectory = PackageFolder;
if (string.IsNullOrEmpty(PackageFolder))
{
packagesDirectory = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
}
var packagesFolderFileSystem = CreateFileSystem(packagesDirectory);
var pathResolver = new DefaultPackagePathResolver(packagesFolderFileSystem, useSideBySidePaths: true);
var localRepository = new LocalPackageRepository(pathResolver, packagesFolderFileSystem);
int restoreCount = 0;
int successCount = 0;
foreach (var projectJsonPath in projectJsonFiles)
{
restoreCount += 1;
var success = RestoreForProject(localRepository, projectJsonPath, rootDirectory, packagesDirectory).Result;
if (success)
{
successCount += 1;
}
}
if (restoreCount > 1)
{
Reports.Information.WriteLine(string.Format("Total time {0}ms", sw.ElapsedMilliseconds));
}
return(restoreCount == successCount);
}
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
});
}
private int RunTests(TestOptions options)
{
if (options.Sink != null)
{
var parts = options.Sink.Split('|');
var packagesPath = Path.GetFullPath(parts[0]);
var dependencyResolver = new NuGetDependencyResolver(packagesPath);
var lib = dependencyResolver.GetDescription(new LibraryRange
{
Name = parts[1]
}, _environment.RuntimeFramework);
dependencyResolver.Initialize(new[] { lib }, _environment.RuntimeFramework);
var dependencyLoader = new NuGetAssemblyLoader(_loadContextAccessor, dependencyResolver);
var referenceLoader = new ReferenceLoader(_frameworkReferenceResolver, _environment.RuntimeFramework);
using (_container.AddLoader(dependencyLoader))
using (_container.AddLoader(referenceLoader))
using (var context = _loadContextFactory.Create())
{
var assembly = dependencyLoader.Load(parts[1], context);
var locator = assembly.GetCustomAttributes()
.OfType <ITestSinkFactory>()
.FirstOrDefault();
if (locator == null)
{
throw new InvalidOperationException($"No assembly attribute found that implements the interface 'ITestSinkLocator' in the assembly ${assembly.GetName().Name}");
}
var testServices = new ServiceProvider(_services);
testServices.Add(typeof(ITestSinkFactory), locator);
return(RunTestAssembly(options, ".", _container, testServices) ? 0 : -1);
}
}
else
{
return(RunTestAssembly(options, ".", _container, _services) ? 0 : -1);
}
}
public ModuleLoaderContext(IServiceProvider serviceProvider,
string projectDirectory,
ICache cache)
{
_serviceProvider = serviceProvider;
_cache = cache;
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(
NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory), RootDirectory);
var gacDependencyResolver = new GacDependencyResolver();
var ProjectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDepencyProvider,
NuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ModuleProjectLibraryExportProvider(
ProjectResolver, _serviceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
NuGetDependencyProvider
});
}
public FontLoader(
NuGetDependencyResolver nuget, IContentProvider contentProvider = null,
string defaultFont = null, int baseFontSize = 72, int textureSize = 512)
{
if (nuget == null)
{
throw new ArgumentNullException(nameof(nuget));
}
if (baseFontSize <= 1 || baseFontSize > textureSize)
{
throw new ArgumentOutOfRangeException(nameof(baseFontSize));
}
if (textureSize <= 1)
{
throw new ArgumentOutOfRangeException(nameof(textureSize));
}
this.dependencyResolver = nuget;
this.defaultFont = defaultFont ?? "Consola";
this.contentProvider = contentProvider;
this.baseFontSize = baseFontSize;
this.textureSize = textureSize;
this.freetype = new Lazy <Library>(LoadFreeTypeLibrary);
}
public void LibrariesAreResolvedCorrectly(string packageName, string framework, bool resolved)
{
var repo = new PackageRepository("path/to/packages");
var resolver = new NuGetDependencyResolver(repo);
var net45Target = new LockFileTarget
{
TargetFramework = new FrameworkName(".NETFramework,Version=v4.5"),
Libraries = new List<LockFileTargetLibrary>
{
new LockFileTargetLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("ref", "net45", "_._") },
RuntimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net45", "_._") }
}
}
};
var dnx451Target = new LockFileTarget
{
TargetFramework = new FrameworkName("DNX,Version=v4.5.1"),
Libraries = new List<LockFileTargetLibrary>
{
new LockFileTargetLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0")
},
new LockFileTargetLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") },
RuntimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") }
},
new LockFileTargetLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("ref", "net451", "Net451LibPackage.dll") }
},
new LockFileTargetLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0")
}
}
};
var metaPackageLibrary = new LockFilePackageLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0")
};
var net451LibPackageLibrary = new LockFilePackageLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List<string>
{
Path.Combine("lib", "net451", "Net451LibPackage.dll"),
Path.Combine("lib", "net451", "Net451LibPackage.xml")
}
};
var net451RefPackageLibrary = new LockFilePackageLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List<string>
{
Path.Combine("ref", "net451", "Net451LibPackage.dll")
}
};
var assemblyPlaceholderPackageLibrary = new LockFilePackageLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List<string>
{
Path.Combine("lib", "net45", "_._"),
Path.Combine("ref", "net45", "_._"),
}
};
var lockFile = new LockFile()
{
Targets = new List<LockFileTarget> { net45Target, dnx451Target },
PackageLibraries = new List<LockFilePackageLibrary>
{
metaPackageLibrary,
net451LibPackageLibrary,
net451RefPackageLibrary,
assemblyPlaceholderPackageLibrary
}
};
resolver.ApplyLockFile(lockFile);
var libToLookup = new LibraryRange(packageName, frameworkReference: false);
Assert.Equal(resolved, resolver.GetDescription(libToLookup, new FrameworkName(framework)).Resolved);
}
public void AddLoader(NuGetDependencyResolver nugetLoader)
{
Loaders.Add(nugetLoader);
}
public async Task <bool> ExecuteCommand()
{
try
{
var sw = Stopwatch.StartNew();
// If the root argument is a project.json file
if (string.Equals(
Runtime.Project.ProjectFileName,
Path.GetFileName(RestoreDirectory),
StringComparison.OrdinalIgnoreCase))
{
RestoreDirectory = Path.GetDirectoryName(Path.GetFullPath(RestoreDirectory));
}
else if (!Directory.Exists(RestoreDirectory) && !string.IsNullOrEmpty(RestoreDirectory))
{
throw new InvalidOperationException("The given root is invalid.");
}
var restoreDirectory = RestoreDirectory ?? Directory.GetCurrentDirectory();
var rootDirectory = ProjectResolver.ResolveRootDirectory(restoreDirectory);
ReadSettings(rootDirectory);
string packagesDirectory = FeedOptions.TargetPackagesFolder;
if (string.IsNullOrEmpty(packagesDirectory))
{
packagesDirectory = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
}
var packagesFolderFileSystem = CreateFileSystem(packagesDirectory);
var pathResolver = new DefaultPackagePathResolver(packagesFolderFileSystem, useSideBySidePaths: true);
int restoreCount = 0;
int successCount = 0;
var projectJsonFiles = Directory.EnumerateFiles(
restoreDirectory,
Runtime.Project.ProjectFileName,
SearchOption.AllDirectories);
Func <string, Task> restorePackage = async projectJsonPath =>
{
Interlocked.Increment(ref restoreCount);
var success = await RestoreForProject(projectJsonPath, rootDirectory, packagesDirectory);
if (success)
{
Interlocked.Increment(ref successCount);
}
};
if (!Parallel || PlatformHelper.IsMono)
{
// Restoring in parallel on Mono throws native exception
foreach (var projectJsonFile in projectJsonFiles)
{
await restorePackage(projectJsonFile);
}
}
else
{
await ForEachAsync(
projectJsonFiles,
maxDegreesOfConcurrency : Environment.ProcessorCount,
body : restorePackage);
}
if (restoreCount > 1)
{
Reports.Information.WriteLine(string.Format("Total time {0}ms", sw.ElapsedMilliseconds));
}
foreach (var category in ErrorMessages)
{
Reports.Error.WriteLine("Errors in {0}".Red().Bold(), category.Key);
foreach (var message in category.Value)
{
Reports.Error.WriteLine(" {0}", message);
}
}
return(restoreCount == successCount);
}
catch (Exception ex)
{
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine(ex.ToString());
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine("Restore failed");
Reports.Information.WriteLine(ex.Message);
return(false);
}
}
public NuGetAssemblyLoader(IAssemblyLoaderEngine loaderEngine, NuGetDependencyResolver dependencyResolver)
{
_dependencyResolver = dependencyResolver;
_loaderEngine = loaderEngine;
}
public async Task <bool> ExecuteCommand()
{
try
{
var sw = Stopwatch.StartNew();
// If the root argument is a project.json file
if (string.Equals(
Runtime.Project.ProjectFileName,
Path.GetFileName(RestoreDirectory),
StringComparison.OrdinalIgnoreCase))
{
RestoreDirectory = Path.GetDirectoryName(Path.GetFullPath(RestoreDirectory));
}
// If the root argument is a global.json file
else if (string.Equals(
GlobalSettings.GlobalFileName,
Path.GetFileName(RestoreDirectory),
StringComparison.OrdinalIgnoreCase))
{
GlobalJsonFile = RestoreDirectory;
RestoreDirectory = Path.GetDirectoryName(Path.GetFullPath(RestoreDirectory));
}
else if (!Directory.Exists(RestoreDirectory) && !string.IsNullOrEmpty(RestoreDirectory))
{
throw new InvalidOperationException("The given root is invalid.");
}
var restoreDirectory = RestoreDirectory ?? Directory.GetCurrentDirectory();
var rootDirectory = ProjectResolver.ResolveRootDirectory(restoreDirectory);
ReadSettings(rootDirectory);
string packagesDirectory = PackageFolder;
if (string.IsNullOrEmpty(PackageFolder))
{
packagesDirectory = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
}
var packagesFolderFileSystem = CreateFileSystem(packagesDirectory);
var pathResolver = new DefaultPackagePathResolver(packagesFolderFileSystem, useSideBySidePaths: true);
int restoreCount = 0;
int successCount = 0;
if (string.IsNullOrEmpty(GlobalJsonFile))
{
var projectJsonFiles = Directory.GetFiles(restoreDirectory, "project.json", SearchOption.AllDirectories);
foreach (var projectJsonPath in projectJsonFiles)
{
restoreCount += 1;
var success = await RestoreForProject(projectJsonPath, rootDirectory, packagesDirectory);
if (success)
{
successCount += 1;
}
}
}
else
{
restoreCount = 1;
var success = await RestoreFromGlobalJson(rootDirectory, packagesDirectory);
if (success)
{
successCount = 1;
}
}
if (restoreCount > 1)
{
Reports.Information.WriteLine(string.Format("Total time {0}ms", sw.ElapsedMilliseconds));
}
return(restoreCount == successCount);
}
catch (Exception ex)
{
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine(ex.ToString());
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine("Restore failed");
Reports.Information.WriteLine(ex.Message);
return(false);
}
}
private async Task <bool> Execute(string restoreDirectory)
{
try
{
var sw = Stopwatch.StartNew();
var projectJsonFiles = new List <string>();
if (string.Equals(
Runtime.Project.ProjectFileName,
Path.GetFileName(restoreDirectory),
StringComparison.OrdinalIgnoreCase) && File.Exists(restoreDirectory))
{
// If the path is a project.json file we don't do recursive search in subfolders
projectJsonFiles.Add(restoreDirectory);
}
else if (Directory.Exists(restoreDirectory))
{
var projectJsonFile = Path.Combine(restoreDirectory, Runtime.Project.ProjectFileName);
if (File.Exists(projectJsonFile))
{
// If the path contains a project.json file we don't do recursive search in subfolders
projectJsonFiles.Add(projectJsonFile);
}
else
{
projectJsonFiles.AddRange(Directory.EnumerateFiles(
restoreDirectory,
Runtime.Project.ProjectFileName,
SearchOption.AllDirectories));
}
}
else
{
var errorMessage = $"The given root {restoreDirectory.Red().Bold()} is invalid.";
ErrorMessages.GetOrAdd(restoreDirectory, _ => new List <string>()).Add(errorMessage);
Reports.Error.WriteLine(errorMessage);
return(false);
}
var rootDirectory = ProjectResolver.ResolveRootDirectory(restoreDirectory);
ReadSettings(rootDirectory);
string packagesDirectory = FeedOptions.TargetPackagesFolder;
if (string.IsNullOrEmpty(packagesDirectory))
{
packagesDirectory = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
}
var packagesFolderFileSystem = CreateFileSystem(packagesDirectory);
var pathResolver = new DefaultPackagePathResolver(packagesFolderFileSystem, useSideBySidePaths: true);
int restoreCount = 0;
int successCount = 0;
Func <string, Task> restorePackage = async projectJsonPath =>
{
Interlocked.Increment(ref restoreCount);
var success = await RestoreForProject(projectJsonPath, rootDirectory, packagesDirectory);
if (success)
{
Interlocked.Increment(ref successCount);
}
};
if (!RestoringInParallel())
{
// Restoring in parallel on Mono throws native exception
foreach (var projectJsonFile in projectJsonFiles)
{
await restorePackage(projectJsonFile);
}
}
else
{
await ForEachAsync(
projectJsonFiles,
MaxDegreesOfConcurrency,
restorePackage);
}
if (restoreCount > 1)
{
Reports.Information.WriteLine(string.Format("Total time {0}ms", sw.ElapsedMilliseconds));
}
if (_installCount > 0)
{
InformationMessages.GetOrAdd("Installed:", _ => new List <string>()).Add($"{_installCount} package(s) to {packagesDirectory}");
_installCount = 0;
}
return(restoreCount == successCount);
}
catch (Exception ex)
{
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine(ex.ToString());
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine("Restore failed");
Reports.Information.WriteLine(ex.Message);
return(false);
}
}
private async Task <bool> Execute(string restoreDirectory, PackageFeedCache packageFeeds, SummaryContext summary)
{
try
{
var sw = Stopwatch.StartNew();
IEnumerable <string> projectJsonFiles;
if (!RestoreProjectsCollector.Find(restoreDirectory, out projectJsonFiles))
{
var errorMessage = $"The given root {restoreDirectory.Red().Bold()} is invalid.";
summary.ErrorMessages.GetOrAdd(restoreDirectory, _ => new List <string>()).Add(errorMessage);
Reports.Error.WriteLine(errorMessage);
return(false);
}
var rootDirectory = ProjectResolver.ResolveRootDirectory(restoreDirectory);
ReadSettings(rootDirectory);
var settings = Config.Settings as Settings;
if (settings != null)
{
var configFiles = settings.GetConfigFiles();
foreach (var file in configFiles)
{
summary.InformationMessages.GetOrAdd("NuGet Config files used:", _ => new List <string>()).Add(file);
}
}
string packagesDirectory = FeedOptions.TargetPackagesFolder;
if (string.IsNullOrEmpty(packagesDirectory))
{
packagesDirectory = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
}
var packagesFolderFileSystem = CreateFileSystem(packagesDirectory);
var pathResolver = new DefaultPackagePathResolver(packagesDirectory);
var effectiveSources = PackageSourceUtils.GetEffectivePackageSources(
Config.Sources,
FeedOptions.Sources,
FeedOptions.FallbackSources);
var remoteProviders = new List <IWalkProvider>();
AddRemoteProvidersFromSources(remoteProviders, effectiveSources, packageFeeds, summary);
int restoreCount = 0;
int successCount = 0;
Func <string, Task> restorePackage = async projectJsonPath =>
{
Interlocked.Increment(ref restoreCount);
var success = await RestoreForProject(projectJsonPath, rootDirectory, packagesDirectory, remoteProviders, summary);
if (success)
{
Interlocked.Increment(ref successCount);
}
};
if (!RestoringInParallel())
{
// Restoring in parallel on Mono throws native exception
foreach (var projectJsonFile in projectJsonFiles)
{
await restorePackage(projectJsonFile);
}
}
else
{
await ForEachAsync(
projectJsonFiles,
MaxDegreesOfConcurrency,
restorePackage);
}
if (restoreCount > 1)
{
Reports.Information.WriteLine(string.Format("Total time {0}ms", sw.ElapsedMilliseconds));
}
if (summary.InstallCount > 0)
{
summary.InformationMessages.GetOrAdd("Installed:", _ => new List <string>()).Add($"{summary.InstallCount} package(s) to {packagesDirectory}");
}
return(restoreCount == successCount);
}
catch (Exception ex)
{
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine(ex.ToString());
Reports.Information.WriteLine("----------");
Reports.Information.WriteLine("Restore failed");
Reports.Information.WriteLine(ex.Message);
return(false);
}
}
public ProjectHostContext(IServiceProvider serviceProvider,
string projectDirectory,
string packagesDirectory,
string[] sourcePaths,
string configuration,
FrameworkName targetFramework,
ICache cache,
ICacheContextAccessor cacheContextAccessor,
INamedCacheDependencyProvider namedCacheDependencyProvider,
IAssemblyLoadContextFactory loadContextFactory = null)
{
ProjectDirectory = projectDirectory;
Configuration = configuration;
RootDirectory = Microsoft.Framework.Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory, sourcePaths);
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 AssemblyLoadContextFactory(ServiceProvider);
var sourceCodeService = new SourceTextService(cache);
var provider = new RoslynProjectReferenceProvider(cache, cacheContextAccessor, namedCacheDependencyProvider, loadContextFactory, _serviceProvider.GetService <IFileWatcher>(), _serviceProvider);
// Default services
_serviceProvider.Add(typeof(IApplicationEnvironment), new ApplicationEnvironment(Project, targetFramework, configuration));
_serviceProvider.Add(typeof(ILibraryExportProvider), LibraryExportProvider, includeInManifest: false);
_serviceProvider.Add(typeof(IProjectResolver), ProjectResolver);
_serviceProvider.Add(typeof(IFileWatcher), NoopWatcher.Instance);
_serviceProvider.Add(typeof(NuGetDependencyResolver), NuGetDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(ProjectReferenceDependencyProvider), ProjectDepencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(ILibraryManager), LibraryManager);
_serviceProvider.Add(typeof(ICache), cache);
_serviceProvider.Add(typeof(ICacheContextAccessor), cacheContextAccessor);
_serviceProvider.Add(typeof(INamedCacheDependencyProvider), namedCacheDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(IAssemblyLoadContextFactory), AssemblyLoadContextFactory);
_serviceProvider.Add(typeof(IProjectReferenceProvider), provider);
_serviceProvider.Add(typeof(ISourceTextService), sourceCodeService);
}
public NuGetAssemblyLoader(IAssemblyLoadContextAccessor loadContextAccessor,
NuGetDependencyResolver dependencyResolver)
{
_dependencyResolver = dependencyResolver;
_loadContextAccessor = loadContextAccessor;
}
private void WriteGlobalJson()
{
var rootDirectory = ProjectResolver.ResolveRootDirectory(_project.ProjectDirectory);
var projectResolver = new ProjectResolver(_project.ProjectDirectory, rootDirectory);
var packagesDir = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
var nugetDependencyResolver = new NuGetDependencyResolver(packagesDir, new EmptyFrameworkResolver());
var pathResolver = new DefaultPackagePathResolver(PackagesPath);
var dependenciesObj = new JObject();
// Generate SHAs for all package dependencies
foreach (var deploymentPackage in Packages)
{
// Use the exactly same approach in PackPackage.Emit() to
// find the package actually in use
var package = nugetDependencyResolver.FindCandidate(
deploymentPackage.Library.Name,
deploymentPackage.Library.Version);
var shaFilePath = pathResolver.GetHashPath(package.Id, package.Version);
var sha = File.ReadAllText(shaFilePath);
var shaObj = new JObject();
shaObj.Add(new JProperty("version", package.Version.ToString()));
shaObj.Add(new JProperty("sha", sha));
dependenciesObj.Add(new JProperty(package.Id, 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, PackRoot.AppRootName);
rootObject["dependencies"] = dependenciesObj;
rootObject["packages"] = PathUtility.GetRelativePath(PathUtility.EnsureTrailingSlash(applicationRoot),
PackagesPath);
File.WriteAllText(Path.Combine(applicationRoot, GlobalSettings.GlobalFileName),
rootObject.ToString());
}
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());
}
public void LibrariesAreResolvedCorrectly(string packageName, string framework, bool resolved)
{
var repo = new PackageRepository("path/to/packages");
var resolver = new NuGetDependencyResolver(repo);
var net45Target = new LockFileTarget
{
TargetFramework = new FrameworkName(".NETFramework,Version=v4.5"),
Libraries = new List <LockFileTargetLibrary>
{
new LockFileTargetLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List <LockFileItem> {
Path.Combine("ref", "net45", "_._")
},
RuntimeAssemblies = new List <LockFileItem> {
Path.Combine("lib", "net45", "_._")
}
}
}
};
var dnx451Target = new LockFileTarget
{
TargetFramework = new FrameworkName("DNX,Version=v4.5.1"),
Libraries = new List <LockFileTargetLibrary>
{
new LockFileTargetLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0")
},
new LockFileTargetLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List <LockFileItem> {
Path.Combine("lib", "net451", "Net451LibPackage.dll")
},
RuntimeAssemblies = new List <LockFileItem> {
Path.Combine("lib", "net451", "Net451LibPackage.dll")
}
},
new LockFileTargetLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List <LockFileItem> {
Path.Combine("ref", "net451", "Net451LibPackage.dll")
}
},
new LockFileTargetLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0")
}
}
};
var metaPackageLibrary = new LockFilePackageLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0")
};
var net451LibPackageLibrary = new LockFilePackageLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List <string>
{
Path.Combine("lib", "net451", "Net451LibPackage.dll"),
Path.Combine("lib", "net451", "Net451LibPackage.xml")
}
};
var net451RefPackageLibrary = new LockFilePackageLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List <string>
{
Path.Combine("ref", "net451", "Net451LibPackage.dll")
}
};
var assemblyPlaceholderPackageLibrary = new LockFilePackageLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List <string>
{
Path.Combine("lib", "net45", "_._"),
Path.Combine("ref", "net45", "_._"),
}
};
var lockFile = new LockFile()
{
Targets = new List <LockFileTarget> {
net45Target, dnx451Target
},
PackageLibraries = new List <LockFilePackageLibrary>
{
metaPackageLibrary,
net451LibPackageLibrary,
net451RefPackageLibrary,
assemblyPlaceholderPackageLibrary
}
};
resolver.ApplyLockFile(lockFile);
var libToLookup = new LibraryRange(packageName, frameworkReference: false);
Assert.Equal(resolved, resolver.GetDescription(libToLookup, new FrameworkName(framework)).Resolved);
}
public NuGetAssemblyLoader(IAssemblyLoadContextAccessor loadContextAccessor,
NuGetDependencyResolver dependencyResolver)
{
_dependencyResolver = dependencyResolver;
_loadContextAccessor = loadContextAccessor;
}
public PackPackage(NuGetDependencyResolver nugetDependencyResolver, LibraryDescription libraryDescription)
{
_nugetDependencyResolver = nugetDependencyResolver;
_libraryDescription = libraryDescription;
}
