/// <summary>
/// Deletes a package from a FileSystem.
/// </summary>
/// <param name="fileSystem">The FileSystem where the specified package is deleted.</param>
/// <param name="packageId">The package Id.</param>
/// <param name="packageVersion">The package Id.</param>
private static void DeletePackageFromFileSystem(IFileSystem fileSystem, string packageId, string packageVersion)
{
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var packageFileName = pathResolver.GetPackageFileName(packageId, new SemanticVersion(packageVersion));
fileSystem.DeleteFile(packageFileName);
}
void CreatePackageManager(IProject project, PackageReferenceRepositoryHelper packageRefRepositoryHelper)
{
options = new TestablePackageManagementOptions();
options.PackagesDirectory = "packages";
repositoryPaths = new SolutionPackageRepositoryPath(project, options);
var pathResolver = new DefaultPackagePathResolver(repositoryPaths.PackageRepositoryPath);
fakeFileSystem = new FakeFileSystem();
fakeFeedSourceRepository = new FakePackageRepository();
fakeSolutionSharedRepository = packageRefRepositoryHelper.FakeSharedSourceRepository;
fakePackageOperationResolverFactory = new FakePackageOperationResolverFactory();
var fakeSolutionPackageRepository = new FakeSolutionPackageRepository();
fakeSolutionPackageRepository.FileSystem = fakeFileSystem;
fakeSolutionPackageRepository.PackagePathResolver = pathResolver;
fakeSolutionPackageRepository.FakeSharedRepository = fakeSolutionSharedRepository;
packageManager = new SharpDevelopPackageManager(fakeFeedSourceRepository,
packageRefRepositoryHelper.FakeProjectSystem,
fakeSolutionPackageRepository,
fakePackageOperationResolverFactory);
}
public NugetService(Solution solution)
{
//_defaultPackageSource = new PackageSource(NuGetConstants.DefaultFeedUrl);
var factory = new PackageRepositoryFactory();
_remoteRepository = factory.CreateRepository(GalleryUrl);
_localRepository = factory.CreateRepository(solution.PackagesFolder());
_sourceRepository = new AggregateRepository(new[] { _remoteRepository, _localRepository });
_fileSystem = new PhysicalFileSystem(solution.PackagesFolder());
_pathResolver = new DefaultPackagePathResolver(_fileSystem);
_console = new Console();
_packageManager = new PackageManager(_sourceRepository, _pathResolver, _fileSystem, _localRepository){
Logger = _console
};
_packages = new Cache<NugetDependency, IPackage>(dep =>
{
Install(dep);
return _sourceRepository.FindPackage(dep.Name, dep.Version);
});
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="settings"></param>
/// <param name="mapPath">A delegate method used to perform a Server.MapPath operation</param>
public DefaultPackageContext(RebelSettings settings, Func<string, string> mapPath)
{
_settings = settings;
_pluginInstallFolderPath = mapPath(_settings.PluginConfig.PluginsPath + "/Packages");
_localPackageRepoFolderPath = mapPath(_settings.RebelFolders.LocalPackageRepositoryFolder);
//create lazy instances of each
_localPackageRepository = new Lazy<IPackageRepository>(
() =>
{
//create a new path resolver with false as 'useSideBySidePaths' so that it doesn't install with version numbers.
var packageFileSys = new PhysicalFileSystem(_localPackageRepoFolderPath);
var packagePathResolver = new DefaultPackagePathResolver(packageFileSys, false);
return new LocalPackageRepository(packagePathResolver, packageFileSys, true);
});
_localPackageManager = new Lazy<IPackageManager>(
() =>
{
//create a new path resolver with false as 'useSideBySidePaths' so that it doesn't install with version numbers.
var packageFileSys = new PhysicalFileSystem(_pluginInstallFolderPath);
var packagePathResolver = new DefaultPackagePathResolver(packageFileSys, false);
return new PackageManager(_localPackageRepository.Value, packagePathResolver, packageFileSys);
});
// Public packages
_publicPackageRepository = new Lazy<IPackageRepository>(
() => PackageRepositoryFactory.Default.CreateRepository(_settings.PublicPackageRepository.RepositoryAddress));
_publicPackageManager = new Lazy<IPackageManager>(
() => new PackageManager(_publicPackageRepository.Value, mapPath(_settings.PluginConfig.PluginsPath + "/Packages")));
}
public void GetRemotePackagesTest()
{
// Arrange
var siteRoot = "x:\\";
var localRepository = new MockPackageRepository();
var sourceRepository = new MockServiceBasePackageRepository();
var projectSystem = new WebProjectSystem(siteRoot);
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(sourceRepository, pathResolver, projectSystem, localRepository);
var net40 = new FrameworkName(".NETFramework", new Version("4.0.0.0"));
var net45 = new FrameworkName(".NETFramework", new Version("4.5.0.0"));
IPackage packageA = PackageFactory.Create("A", new Version("1.0"), null, new FrameworkName[]{ net40 });
IPackage packageB = PackageFactory.Create("B", new Version("1.0"), null, new FrameworkName[]{ net45 });
IPackage packageC = PackageFactory.Create("C", new Version("1.0"));
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
// NOTE THAT target framework used by WebProjectManager would be .NETFramework, Version=4.0.0.0
var webProjectManager = new WebProjectManager(projectManager, siteRoot);
// Act
var packages = webProjectManager.GetRemotePackages(null, false).ToList();
// Assert
Assert.Equal(2, packages.Count);
Assert.Equal(packageA, packages[0]);
Assert.Equal(packageC, packages[1]);
}
/// <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;
}
public void DnuPackagesAddOverwritesInstalledPackageWhenShasDoNotMatch(string flavor, string os, string architecture)
{
var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture);
using (var tempSamplesDir = TestUtils.PrepareTemporarySamplesFolder(runtimeHomeDir))
{
var projectFilePath = Path.Combine(tempSamplesDir, ProjectName, Runtime.Project.ProjectFileName);
var packagesDir = Path.Combine(tempSamplesDir, PackagesDirName);
var packagePathResolver = new DefaultPackagePathResolver(packagesDir);
var nuspecPath = packagePathResolver.GetManifestFilePath(ProjectName, ProjectVersion);
SetProjectDescription(projectFilePath, "Old");
BuildPackage(tempSamplesDir, runtimeHomeDir);
string stdOut;
var exitCode = DnuPackagesAddOutputPackage(tempSamplesDir, runtimeHomeDir, out stdOut);
Assert.Equal(0, exitCode);
Assert.Contains($"Installing {ProjectName}.{ProjectVersion}", stdOut);
var lastInstallTime = new FileInfo(nuspecPath).LastWriteTimeUtc;
SetProjectDescription(projectFilePath, "New");
BuildPackage(tempSamplesDir, runtimeHomeDir);
exitCode = DnuPackagesAddOutputPackage(tempSamplesDir, runtimeHomeDir, out stdOut);
Assert.Equal(0, exitCode);
Assert.Contains($"Overwriting {ProjectName}.{ProjectVersion}", stdOut);
var xDoc = XDocument.Load(packagePathResolver.GetManifestFilePath(ProjectName, ProjectVersion));
var actualDescription = xDoc.Root.Descendants()
.Single(x => string.Equals(x.Name.LocalName, "description")).Value;
Assert.Equal("New", actualDescription);
Assert.NotEqual(lastInstallTime, new FileInfo(nuspecPath).LastWriteTimeUtc);
}
}
public void DnuPackagesAddSkipsInstalledPackageWhenShasMatch(string flavor, string os, string architecture)
{
var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture);
using (var tempSamplesDir = TestUtils.PrepareTemporarySamplesFolder(runtimeHomeDir))
{
var projectFilePath = Path.Combine(tempSamplesDir, ProjectName, Runtime.Project.ProjectFileName);
var packagesDir = Path.Combine(tempSamplesDir, PackagesDirName);
var packagePathResolver = new DefaultPackagePathResolver(packagesDir);
var nuspecPath = packagePathResolver.GetManifestFilePath(ProjectName, ProjectVersion);
BuildPackage(tempSamplesDir, runtimeHomeDir);
string stdOut;
var exitCode = DnuPackagesAddOutputPackage(tempSamplesDir, runtimeHomeDir, out stdOut);
Assert.Equal(0, exitCode);
Assert.Contains($"Installing {ProjectName}.{ProjectVersion}", stdOut);
var lastInstallTime = new FileInfo(nuspecPath).LastWriteTimeUtc;
exitCode = DnuPackagesAddOutputPackage(tempSamplesDir, runtimeHomeDir, out stdOut);
Assert.Equal(0, exitCode);
Assert.Contains($"{ProjectName}.{ProjectVersion} already exists", stdOut);
Assert.Equal(lastInstallTime, new FileInfo(nuspecPath).LastWriteTimeUtc);
}
}
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 NugetStore(string rootDirectory, string configFile = DefaultConfig, string overrideFile = OverrideConfig)
{
if (rootDirectory == null) throw new ArgumentNullException(nameof(rootDirectory));
if (configFile == null) throw new ArgumentNullException(nameof(configFile));
if (overrideFile == null) throw new ArgumentNullException(nameof(overrideFile));
// First try the override file with custom settings
var configFileName = overrideFile;
var configFilePath = Path.Combine(rootDirectory, configFileName);
if (!File.Exists(configFilePath))
{
// Override file does not exist, fallback to default config file
configFileName = configFile;
configFilePath = Path.Combine(rootDirectory, configFileName);
if (!File.Exists(configFilePath))
{
throw new ArgumentException($"Invalid installation. Configuration file [{configFile}] not found", nameof(configFile));
}
}
rootFileSystem = new PhysicalFileSystem(rootDirectory);
Settings = NuGet.Settings.LoadDefaultSettings(rootFileSystem, configFileName, null);
string installPath = Settings.GetRepositoryPath();
packagesFileSystem = new PhysicalFileSystem(installPath);
packageSourceProvider = new PackageSourceProvider(Settings);
repositoryFactory = new PackageRepositoryFactory();
SourceRepository = packageSourceProvider.CreateAggregateRepository(repositoryFactory, true);
pathResolver = new DefaultPackagePathResolver(packagesFileSystem);
Manager = new PackageManager(SourceRepository, pathResolver, packagesFileSystem);
var mainPackageList = Settings.GetConfigValue(MainPackagesKey);
if (string.IsNullOrWhiteSpace(mainPackageList))
{
throw new InvalidOperationException($"Invalid configuration. Expecting [{MainPackagesKey}] in config");
}
MainPackageIds = mainPackageList.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
VSIXPluginId = Settings.GetConfigValue(VsixPluginKey);
if (string.IsNullOrWhiteSpace(VSIXPluginId))
{
throw new InvalidOperationException($"Invalid configuration. Expecting [{VsixPluginKey}] in config");
}
RepositoryPath = Settings.GetConfigValue(RepositoryPathKey);
if (string.IsNullOrWhiteSpace(RepositoryPath))
{
RepositoryPath = DefaultGamePackagesDirectory;
}
// Setup NugetCachePath in the cache folder
Environment.SetEnvironmentVariable("NuGetCachePath", Path.Combine(rootDirectory, "Cache", RepositoryPath));
}
// Methods
public WebProjectManager(string remoteSource, string siteRoot)
{
string webRepositoryDirectory = GetWebRepositoryDirectory(siteRoot);
var sourceRepository = PackageRepositoryFactory.Default.CreateRepository(remoteSource);
var pathResolver = new DefaultPackagePathResolver(webRepositoryDirectory);
var localRepository = PackageRepositoryFactory.Default.CreateRepository(webRepositoryDirectory);
IProjectSystem project = new WebProjectSystem(siteRoot);
_projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository);
}
public PackageInstaller(string localRepositoryPath, string projectPath, IConsole console, string projectName, bool addReferencesToProject)
{
_projectName = projectName;
_localRepositoryPath = localRepositoryPath;
IPackagePathResolver packagePathResolver = new DefaultPackagePathResolver(localRepositoryPath);
IPackageRepository localRepository = new UnzipedLocalPackageRepository(localRepositoryPath, _flagFileName);
_projectSystem = new ModdedMSBuildProjectSystem(projectPath, addReferencesToProject) { Logger = console };
_projectManager = new ProjectManager(localRepository, packagePathResolver, _projectSystem, localRepository) { Logger = console };
}
protected PackageManagerService()
{
var repo = PackageRepositoryFactory.Default.CreateRepository(MyGetRepoUrl);
var path = new DefaultPackagePathResolver(MyGetRepoUrl);
var fileSystem = new PhysicalFileSystem(HostingEnvironment.MapPath("~/App_Plugins/Packages"));
var localRepo = PackageRepositoryFactory.Default.CreateRepository(HostingEnvironment.MapPath("~/App_Plugins/Packages"));
//Create a NuGet Package Manager
PackageManager = new PackageManager(repo, path, fileSystem, localRepo);
}
/// <summary>
/// Pushes a package to a FileSystem.
/// </summary>
/// <param name="fileSystem">The FileSystem that the package is pushed to.</param>
/// <param name="package">The package to be pushed.</param>
private static void PushPackageToFileSystem(IFileSystem fileSystem, IPackage package)
{
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var packageFileName = pathResolver.GetPackageFileName(package);
using (var stream = package.GetStream())
{
fileSystem.AddFile(packageFileName, stream);
}
}
public ExtensionManagerTests()
{
resharperApi = new FakeReSharperApi(Version.Parse("6.0.0.0"));
localRepository = new FakePackageRepository(RepoPath);
fileSystem = new FakeFileSystem(RepoPath);
var pathResolver = new DefaultPackagePathResolver(fileSystem);
packageManager = new PackageManager(new AggregateRepository(Enumerable.Empty<IPackageRepository>()), pathResolver, fileSystem, localRepository);
manager = new ExtensionManager.Implementation.ExtensionManager(resharperApi, null, packageManager);
}
ISharpDevelopPackageManager CreatePackageManager(
IFileSystem fileSystem,
IPackageRepository packageRepository,
MSBuildBasedProject project)
{
DefaultPackagePathResolver pathResolver = new DefaultPackagePathResolver(fileSystem);
ISharedPackageRepository sharedRepository = CreateSharedRepository(pathResolver, fileSystem);
IProjectSystem projectSystem = CreateProjectSystem(project);
return new SharpDevelopPackageManager(packageRepository, projectSystem, fileSystem, sharedRepository, pathResolver);
}
public WebProjectManager(string remoteSource, string siteRoot)
{
string webRepositoryDirectory = GetWebRepositoryDirectory(siteRoot);
Uri uri = new Uri(remoteSource);
IPackageRepository repository = new DataServicePackageRepository(uri);//PackageRepositoryFactory.Default.CreateRepository(remoteSource);
IPackagePathResolver resolver = new DefaultPackagePathResolver(webRepositoryDirectory);
IPackageRepository repository2 = new LocalPackageRepository(webRepositoryDirectory, false); //PackageRepositoryFactory.Default.CreateRepository(webRepositoryDirectory);
IProjectSystem system = new WebProjectSystem(siteRoot);
((DataServicePackageRepository)repository).ProgressAvailable += new EventHandler<ProgressEventArgs>(repository_ProgressAvailable);
//((DataServicePackageRepository)repository).SendingRequest += new EventHandler<WebRequestEventArgs>(repository_sendingRequest);
this._projectManager = new ProjectManager(repository, resolver, system, repository2);
_projectManager.Logger = new LoggerController();
}
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}", _libraryDescription.Type, Library);
var packagePathResolver = new DefaultPackagePathResolver(root.SourcePackagesPath);
var srcNupkgPath = packagePathResolver.GetPackageFilePath(_libraryDescription.Identity.Name, _libraryDescription.Identity.Version);
var options = new Microsoft.Framework.PackageManager.Packages.AddOptions
{
NuGetPackage = srcNupkgPath,
SourcePackages = root.TargetPackagesPath,
Reports = root.Reports
};
var packagesAddCommand = new Microsoft.Framework.PackageManager.Packages.AddCommand(options);
packagesAddCommand.Execute().GetAwaiter().GetResult();
}
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);
}
void CreatePackageManager(IProject project, PackageReferenceRepositoryHelper packageRefRepositoryHelper)
{
options = new PackageManagementOptions(new Properties());
options.PackagesDirectory = "packages";
repositoryPaths = new PackageRepositoryPaths(project, options);
var pathResolver = new DefaultPackagePathResolver(repositoryPaths.SolutionPackagesPath);
fakeFileSystem = new FakeFileSystem();
fakeFeedSourceRepository = new FakePackageRepository();
fakeSolutionSharedRepository = packageRefRepositoryHelper.FakeSharedSourceRepository;
packageManager = new SharpDevelopPackageManager(fakeFeedSourceRepository,
packageRefRepositoryHelper.FakeProjectSystem,
fakeFileSystem,
fakeSolutionSharedRepository,
pathResolver);
}
public IPackageManager CreatePackageManager(IEnumerable<string> remoteSources, string packagesPath)
{
if (remoteSources == null)
{
throw new ArgumentNullException("remoteSources");
}
if (!remoteSources.Any())
{
throw new ArgumentException("Must provide at least one remote source");
}
var sourceRepo = new AggregateRepository(PackageRepositoryFactory.Default, remoteSources, true);
var pathResolver = new DefaultPackagePathResolver(packagesPath);
var packageManagerFileSystem = new PhysicalFileSystem(packagesPath);
return new PackageManager(sourceRepository: sourceRepo,
pathResolver: pathResolver,
fileSystem: packageManagerFileSystem);
}
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 async Task Emit(PublishRoot root)
{
root.Reports.Quiet.WriteLine("Using {0} dependency {1}", _libraryDescription.Type, Library);
var packagePathResolver = new DefaultPackagePathResolver(root.SourcePackagesPath);
var srcNupkgPath = packagePathResolver.GetPackageFilePath(_libraryDescription.Identity.Name, _libraryDescription.Identity.Version);
var options = new Packages.AddOptions
{
NuGetPackage = srcNupkgPath,
PackageHashFilePath = Path.ChangeExtension(srcNupkgPath, NuGet.Constants.HashFileExtension),
SourcePackages = root.TargetPackagesPath,
};
// Mute "packages add" subcommand
options.Reports = Reports.Constants.NullReports;
var packagesAddCommand = new Packages.AddCommand(options);
await packagesAddCommand.Execute();
}
public IProjectManager CreateProjectManager(IEnumerable<string> remoteSources, string packagesPath, IProjectSystem project)
{
if(remoteSources == null)
{
throw new ArgumentNullException("remoteSources");
}
if (!remoteSources.Any())
{
throw new ArgumentException("Must provide at least one remote source");
}
var sourceRepo = new AggregateRepository(PackageRepositoryFactory.Default, remoteSources, true);
var pathResolver = new DefaultPackagePathResolver(packagesPath);
var packagesConfigRepo = new PackageReferenceRepository(project, project.ProjectName, new SharedPackageRepository(packagesPath));
return new ProjectManager(sourceRepository: sourceRepo,
pathResolver: pathResolver,
localRepository: packagesConfigRepo,
project: project);
}
//download the specified version of the package and update project reference to it. The newly downloaded package
//will be located in /packages folder. The updated project reference can be checked in corresponding .csproj file.
public bool Execute(string packageid, string projectFile, SemanticVersion version, string packages)
{
try
{
System.Console.WriteLine("-------------------------------------");
System.Console.WriteLine("Project File " + projectFile);
System.Console.WriteLine("Package "+packageid);
System.Console.WriteLine("Version "+version);
IPackageRepository repo = PackageRepositoryFactory.Default.CreateRepository("https://packages.nuget.org/api/v2");
var packagePathResolver = new DefaultPackagePathResolver(packages);
var packagesFolderFileSystem = new PhysicalFileSystem(packages);
var projectSystem = new MSBuildProjectSystem(projectFile);
var localRepository = new LocalPackageRepository(packagePathResolver, packagesFolderFileSystem);
var projectManager = new ProjectManager(repo, packagePathResolver, projectSystem, localRepository);
projectManager.RemovePackageReference(packageid,true,false);
projectManager.AddPackageReference(packageid, version, true, false);
projectSystem.Save();
string filename = packageid + "." + version;
string[] s = Directory.GetFiles(packages+ @"\"+filename);
if (s.IsEmpty()) { System.Console.WriteLine("empty"); }
else
{
var nupkgFile = new PhysicalFileSystem(s[0]);
ZipPackage z = new ZipPackage(s[0]);
z.ExtractContents(nupkgFile, packages + @"\" + filename);
}
System.Console.WriteLine("Successfully updated");
return true;
}
catch (Exception e)
{
System.Console.Write("failure");
System.Console.Write(e.StackTrace);
return false;
}
}
public NugetService(Solution solution, IEnumerable<string> remoteFeeds)
{
var repoBuilder = new PackageRepositoryBuilder();
_remoteRepository = repoBuilder.BuildRemote(remoteFeeds);
_localRepository = repoBuilder.BuildLocal(solution.PackagesFolder());
_sourceRepository = repoBuilder.BuildSource(_remoteRepository, _localRepository);
_fileSystem = new PhysicalFileSystem(solution.PackagesFolder());
_pathResolver = new DefaultPackagePathResolver(_fileSystem);
_console = new Console();
_packageManager = new PackageManager(_sourceRepository, _pathResolver, _fileSystem, _localRepository){
Logger = _console
};
_packages = new Cache<NugetDependency, IPackage>(dep =>
{
Install(dep);
return _sourceRepository.FindPackage(dep.Name, new SemanticVersion(dep.Version));
});
}
public string GetInstallPath(IPackage package)
{
pathResolver = new DefaultPackagePathResolver(PackageRepositoryPath);
return pathResolver.GetInstallPath(package);
}
void CreatePackagePathResolver()
{
packagePathResolver = new DefaultPackagePathResolver(repositoryPath.PackageRepositoryPath);
}
/// <summary>
/// Deletes a package from a FileSystem.
/// </summary>
/// <param name="fileSystem">The FileSystem where the specified package is deleted.</param>
/// <param name="packageId">The package Id.</param>
/// <param name="packageVersion">The package Id.</param>
private static void DeletePackageFromFileSystem(IFileSystem fileSystem, string packageId, string packageVersion)
{
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var packageFileName = pathResolver.GetPackageFileName(packageId, new SemanticVersion(packageVersion));
fileSystem.DeleteFile(packageFileName);
}
/// <summary>
/// Pushes a package to a FileSystem.
/// </summary>
/// <param name="fileSystem">The FileSystem that the package is pushed to.</param>
/// <param name="package">The package to be pushed.</param>
private static void PushPackageToFileSystem(IFileSystem fileSystem, IPackage package)
{
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var packageFileName = pathResolver.GetPackageFileName(package);
using (var stream = package.GetStream())
{
fileSystem.AddFile(packageFileName, stream);
}
}
public bool Execute()
{
var projectFile = ResolveProjectFile();
if (string.IsNullOrEmpty(projectFile))
{
return false;
}
_solutionRoot = ProjectResolver.ResolveRootDirectory(projectFile);
var globalFile = GlobalSettings.GetGlobalFilePath(_solutionRoot);
if (!File.Exists(globalFile))
{
_reports.WriteError($"The '{GlobalSettings.GlobalFileName}' is missing from '{_solutionRoot}'.");
return false;
}
var packagesFolder = ResolvePackagesFolder();
if (string.IsNullOrEmpty(packagesFolder))
{
return false;
}
var packageVersion = ResolvePackageVersion(projectFile);
if (packageVersion == null)
{
return false;
}
var packageResolver = new DefaultPackagePathResolver(packagesFolder);
var packageFolder = packageResolver.GetPackageDirectory(_packageId, packageVersion);
packageFolder = Path.Combine(packagesFolder, packageFolder);
var snapshotInfo = ReadRepositoryInfo(packageFolder);
if (snapshotInfo == null)
{
return false;
}
string repoType;
if (!snapshotInfo.TryGetValue(Constants.RepoTypeKey, out repoType))
{
_reports.WriteError("Repository type information is missing from the repository information file.");
return false;
}
var provider = SourceControlProviderFactory.ResolveProvider(repoType, _reports);
if (provider == null)
{
_reports.WriteError($"Unknown repository type '{repoType}'");
return false;
}
if (!provider.IsInstalled)
{
_reports.WriteError($"The '{repoType}' client application is not installed.");
return false;
}
var sourcesFolder = ResolveSourcesFolder();
var sourceFolderName = provider.CreateShortFolderName(snapshotInfo);
var sourceDestinationFullPath = Path.Combine(sourcesFolder, sourceFolderName);
if (!Directory.Exists(sourceDestinationFullPath))
{
_reports.WriteInformation($"Downloading sources in '{sourceDestinationFullPath}'...");
if (!provider.GetSources(sourceDestinationFullPath, snapshotInfo))
{
return false;
}
}
else
{
_reports.WriteInformation($"Sources already found in '{sourceDestinationFullPath}'");
}
var srcFolder = provider.GetSourceFolderPath(snapshotInfo);
srcFolder = Path.Combine(sourceDestinationFullPath, srcFolder);
if (!Directory.Exists(srcFolder))
{
_reports.WriteError($"The source code folder '{srcFolder}' is missing.");
return false;
}
_reports.Verbose.WriteLine($"Updating {GlobalSettings.GlobalFileName}...");
ModifyJson(globalFile, jObj =>
{
var projects = jObj["projects"] as JArray;
if (projects == null)
{
projects = new JArray();
projects.Add(srcFolder);
jObj.Add("projects", projects);
}
else
{
if (!projects.Any(t => t.ToString().Equals(srcFolder)))
{
projects.Add(srcFolder);
}
}
});
return true;
}