public void AnalyzerInstaller_InstallMultiplePackages_Succeeds()
{
// Arrange
// Create dummy NuGet package containing multiple assemblies
string fakeRemotePackageSource = TestUtils.CreateTestSpecificFolder(this.TestContext, "fakeNuGetSource");
LocalPackageRepository fakeRemoteRepo = new LocalPackageRepository(fakeRemotePackageSource);
CreateAndInstallPackageWithDummyContent(fakeRemoteRepo, "package1", "1.0-rc1", "package1.dll");
CreateAndInstallPackageWithDummyContent(fakeRemoteRepo, "package2", "22.2", "package2.dll");
IEnumerable<NuGetPackageInfo> packages = new NuGetPackageInfo[] {
new NuGetPackageInfo() { Id = "package1", Version = "1.0-rc1" },
new NuGetPackageInfo() { Id = "package2", Version = "22.2" }
};
string localCacheDir = TestUtils.CreateTestSpecificFolder(this.TestContext, "localInstallCache");
AnalyzerInstaller testSubject = new AnalyzerInstaller(fakeRemotePackageSource, localCacheDir, new TestLogger());
// Act
IEnumerable<string> assemblyPaths = testSubject.InstallAssemblies(packages);
// Assert
AssertExpectedAssembliesReturned(assemblyPaths,
"package1.dll",
"package2.dll");
}
public void AnalyzerInstaller_InstallMultiFilePackage_Succeeds()
{
// Arrange
// Create dummy NuGet package containing multiple assemblies
string fakeRemotePackageSource = TestUtils.CreateTestSpecificFolder(this.TestContext, "fakeNuGetSource");
LocalPackageRepository fakeRemoteRepo = new LocalPackageRepository(fakeRemotePackageSource);
PackageBuilder builder = CreatePackageBuilder("simplepackage1", "1.0.0");
AddDummyFile(builder, "test.txt"); // not an assembly
AddDummyFile(builder, "\\analyzer\\bbb.dll.xxx"); // not an assembly
AddDummyFile(builder, "\\analyzer\\aaa.dll");
AddDummyFile(builder, "\\supporting\\bbb.DLL");
CreateAndInstallPackage(fakeRemoteRepo, builder);
IEnumerable<NuGetPackageInfo> packages = new NuGetPackageInfo[] {
new NuGetPackageInfo() { Id = "simplepackage1", Version = "1.0.0" }
};
string localCacheDir = TestUtils.CreateTestSpecificFolder(this.TestContext, "localInstallCache");
AnalyzerInstaller testSubject = new AnalyzerInstaller(fakeRemotePackageSource, localCacheDir, new TestLogger());
// Act
IEnumerable<string> assemblyPaths = testSubject.InstallAssemblies(packages);
// Assert
AssertExpectedAssembliesReturned(assemblyPaths,
"\\analyzer\\aaa.dll",
"\\supporting\\bbb.dll");
}
public static async Task<string> Install(this IPackage package, string source, string dest)
{
IPackageRepository packageRepository = new LocalPackageRepository(source);
IPackageManager packageManager = new PackageManager(packageRepository, dest);
var tcs = new TaskCompletionSource<string>();
var handler = new EventHandler<PackageOperationEventArgs>((sender, args) => tcs.SetResult(args.InstallPath));
packageManager.PackageInstalled += handler;
packageManager.InstallPackage(package, true, true);
packageManager.PackageInstalled -= handler;
if (await Task.WhenAny(tcs.Task, Task.Delay(5000)) == tcs.Task)
{
await tcs.Task;
return tcs.Task.Result;
}
else
{
throw new TimeoutException("Package install timeout");
}
}
public IEnumerable<string> CreatePackageFile()
{
var packagesFile = Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFile);
var packageReferenceFile = new PackageReferenceFile(packagesFile);
var packagesFolder = Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFolder);
var repository = new LocalPackageRepository(packagesFolder);
var newestPackages = repository.GetPackages().GroupBy(p => p.Id)
.Select(g => g.OrderByDescending(p => p.Version).FirstOrDefault());
foreach (var package in newestPackages)
{
var newestFramework = GetNewestSupportedFramework(package);
packageReferenceFile.AddEntry(package.Id, package.Version, newestFramework);
if (newestFramework == null)
{
yield return string.Format("{0}, Version {1}", package.Id, package.Version);
}
else
{
yield return string.Format("{0}, Version {1}, .NET {2}", package.Id, package.Version, newestFramework.Version);
}
}
}
public ReferenceAttacher(Solution solution)
{
_solution = solution;
_repository = new LocalPackageRepository(_solution.PackagesFolder());
_packages = new Cache<string, IPackage>(name => _repository.FindPackage(name));
}
internal static Target ProcessDependencies(string solutionName, PackageSpec project)
{
List <string> packageCollection = new List <string>();
Target projectTarget = new Target();
projectTarget.project = solutionName;
projectTarget.moduleId = $"netframework:{project.Name}";
projectTarget.module = project.Name;
projectTarget.release = project.Version.ToFullString();
projectTarget.dependencies = new List <Dependency>();
// Generate lock file
var lockFileService = new LockFileService();
var lockFile = lockFileService.GetLockFile(project.FilePath, project.RestoreMetadata.OutputPath);
foreach (var targetFramework in project.TargetFrameworks)
{
var lockFileTargetFramework = lockFile.Targets.FirstOrDefault(t => t.TargetFramework.Equals(targetFramework.FrameworkName));
ReportDependency(projectTarget.dependencies, targetFramework, false, packageCollection, lockFileTargetFramework);
}
var packageRepository = new NuGet.LocalPackageRepository($@"{project.BaseDirectory}\packages");
IQueryable <IPackage> packages = packageRepository.GetPackages();
foreach (IPackage package in packages)
{
ReportDependencyPackage(projectTarget.dependencies, package, true, packageCollection);
}
return(projectTarget);
}
public ReferenceAttacher(Solution solution)
{
_solution = solution;
_repository = new LocalPackageRepository(_solution.PackagesFolder());
_packages = new Cache<string, IPackage>(name => _repository.FindPackage(name));
_toolsVersionMatch["4.0"] = "net40";
}
public NuGetPackageFolder(
string physicalPath,
Reports reports)
{
_repository = new LocalPackageRepository(physicalPath, reports.Quiet);
_reports = reports;
Source = physicalPath;
}
public PackageFolder(
string physicalPath,
IReport report)
{
_repository = new LocalPackageRepository(physicalPath)
{
Report = report
};
_report = report;
}
public IPackageObject FindPackage(string path, IPackageReference packageRef)
{
var repository = new LocalPackageRepository(path);
var package = packageRef.Version != null
? repository.FindPackage(packageRef.PackageId, new SemanticVersion(packageRef.Version, packageRef.SpecialVersion), true, true)
: repository.FindPackage(packageRef.PackageId);
return package == null ? null : new PackageObject(package, packageRef.FrameworkName);
}
public void GenerateGraph_with_assemblies_should_include_all_packages()
{
var repo = new LocalPackageRepository(@"..\..\..\packages");
var g = new GraphGenerator(repo) { IncludeAssemblyReferences = true };
using (var s = File.OpenWrite("nuget.dgml"))
{
g.WriteGraph(s);
s.Flush();
}
}
public void GenerateGraph_should_include_all_packages()
{
var repo = new LocalPackageRepository(@"..\..\..\packages");
var g = new GraphGenerator(repo);
using (var s = File.OpenWrite("nuget.dgml"))
{
g.WriteGraph(s);
s.Flush();
}
}
public static bool IsPackageInstalled (this PackageReference packageReference, PhysicalFileSystem fileSystem)
{
if (packageReference.Version == null) {
return false;
}
var repository = new LocalPackageRepository (new DefaultPackagePathResolver (fileSystem), fileSystem);
return repository
.GetPackageLookupPaths (packageReference.Id, packageReference.Version)
.Any ();
}
public IPackageObject FindPackage(string path, IPackageReference packageRef)
{
Guard.AgainstNullArgument("packageRef", packageRef);
var repository = new LocalPackageRepository(path);
var package = packageRef.Version != null && !(packageRef.Version.Major == 0 && packageRef.Version.Minor == 0)
? repository.FindPackage(packageRef.PackageId, new SemanticVersion(packageRef.Version, packageRef.SpecialVersion), true, true)
: repository.FindPackage(packageRef.PackageId);
return package == null ? null : new PackageObject(package, packageRef.FrameworkName);
}
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 static void InstallPackage(this IVsPackageInstaller packageInstaller, Project project, string packageName, IVsPackageInstallerServices packageInstallerServices, string version = null)
{
if (version == null)
{
version = new V2FeedContext(new Uri("http://www.nuget.org/api/v2/")).Execute<V2FeedPackage>(new Uri("http://www.nuget.org/api/v2/Packages?$filter=IsAbsoluteLatestVersion and Id eq '" + packageName + "'&$skip=0&$top=1&$select=Id,Version&targetFramework=&includePrerelease=true")).Single().Version;
}
packageInstaller.InstallPackage("http://packages.nuget.org", project, packageName, version, false);
//workaround to the bug on Package installer that does not install package depencences
var dependencies = new LocalPackageRepository(packageInstallerServices.GetPackageLocation(packageName)).FindPackage(packageName).DependencySets.SelectMany(ds => ds.Dependencies);
foreach (var dependency in dependencies)
{
InstallPackage(packageInstaller, project, dependency.Id, packageInstallerServices, dependency.VersionSpec.ToString());
}
}
public IEnumerable<string> CreatePackageFile()
{
var packageReferenceFile = new PackageReferenceFile(Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFile));
var repository = new LocalPackageRepository(Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFolder));
var arbitraryPackages = repository.GetPackages();
var result = new List<string>();
foreach (var package in arbitraryPackages.GroupBy(i => i.Id))
{
var p = package.OrderByDescending(i => i.Version).FirstOrDefault();
packageReferenceFile.AddEntry(p.Id, p.Version, VersionUtility.ParseFrameworkName("net45"));
result.Add(string.Format("{0}, Version {1}, .NET 4.5", p.Id, p.Version));
}
return result;
}
public void CreatePackageFile()
{
var packagesFile = Path.Combine(_fileSystem.CurrentDirectory, _fileSystem.PackagesFile);
var packageReferenceFile = new PackageReferenceFile(packagesFile);
var packagesFolder = Path.Combine(_fileSystem.CurrentDirectory, _fileSystem.PackagesFolder);
var repository = new LocalPackageRepository(packagesFolder);
var newestPackages = repository.GetPackages().GroupBy(p => p.Id)
.Select(g => g.OrderByDescending(p => p.Version).FirstOrDefault());
if (!newestPackages.Any())
{
_logger.Info("No packages found!");
return;
}
_logger.InfoFormat("{0} {1}...", (File.Exists(packagesFile) ? "Updating" : "Creating"), _fileSystem.PackagesFile);
foreach (var package in newestPackages)
{
var newestFramework = GetNewestSupportedFramework(package);
if (!packageReferenceFile.EntryExists(package.Id, package.Version))
{
packageReferenceFile.AddEntry(package.Id, package.Version, package.DevelopmentDependency, newestFramework);
if (newestFramework == null)
{
_logger.InfoFormat("Added {0} (v{1}) to {2}", package.Id, package.Version, _fileSystem.PackagesFile);
}
else
{
_logger.InfoFormat("Added {0} (v{1}, .NET {2}) to {3}", package.Id, package.Version, newestFramework.Version, _fileSystem.PackagesFile);
}
continue;
}
_logger.InfoFormat("Skipped {0} because it already exists.", package.Id);
}
_logger.InfoFormat("Successfully {0} {1}.", (File.Exists(packagesFile) ? "updated" : "created"), _fileSystem.PackagesFile);
}
public void CreatePackageFile()
{
var packagesFile = Path.Combine(_fileSystem.CurrentDirectory, _fileSystem.PackagesFile);
var packagesFolder = Path.Combine(_fileSystem.CurrentDirectory, _fileSystem.PackagesFolder);
var repository = new LocalPackageRepository(packagesFolder);
var packages = repository.GetPackages().OrderByDescending(x => x.Version);
var configFile = new JObject();
var dependencyObject = new JObject();
configFile.Add("dependencies", dependencyObject);
foreach (var package in packages)
{
if (dependencyObject[package.Id] == null)
dependencyObject.Add(new JProperty(package.Id, package.Version.ToString()));
}
File.WriteAllText(packagesFile, configFile.ToString());
}
public ReferenceAttacher(Solution solution)
{
_solution = solution;
_repository = new LocalPackageRepository(_solution.PackagesDirectory());
_packages = new Cache<string, IPackage>(name =>
{
try
{
return _repository.FindPackage(name);
}
catch (Exception)
{
return null;
}
});
_toolsVersionMatch["4.0"] = "net40";
}
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;
}
internal static Target ProcessDependencies(string solutionName, PackageSpec project, string projectPath)
{
HashSet <string> packageCollection = new HashSet <string>();
Target projectTarget = new Target();
projectTarget.project = solutionName;
projectTarget.moduleId = $"vs:{project.Name}";
projectTarget.module = project.Name;
projectTarget.release = project.Version.ToFullString();
projectTarget.dependencies = new List <Dependency>();
foreach (var targetFramework in project.TargetFrameworks)
{
Dependency targetDependency = new Dependency();
projectTarget.dependencies.Add(targetDependency);
var frameworkName = targetFramework.FrameworkName.ToString();
packageCollection.Add(frameworkName);
targetDependency.name = frameworkName;
targetDependency.key = $"netframework:{frameworkName}";
}
var directoryInfo = VisualStudioProvider.TryGetPackagesDirectoryInfo(project.BaseDirectory);
if (directoryInfo == null)
{
directoryInfo = VisualStudioProvider.TryGetPackagesDirectoryInfo(projectPath);
}
var packageRepository = new NuGet.LocalPackageRepository($@"{directoryInfo.FullName}\packages");
IQueryable <IPackage> packages = packageRepository.GetPackages();
foreach (IPackage package in packages)
{
ReportDependencyPackage(packageRepository, projectTarget.dependencies, package, packageCollection);
}
return(projectTarget);
}
//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 void RunFromGallery()
{
Directory.CreateDirectory(_targetDirectory);
var client = new HttpClient(DeveloperFeed);
client.SendingRequest += (sender, e) =>
{
e.Request.Credentials = _credentials;
e.Request.PreAuthenticate = true;
};
var remoteRepo = new DataServicePackageRepository(client);
var targetRepo = new LocalPackageRepository(_targetDirectory);
var packages = remoteRepo.GetPackages()
.Where(p => p.IsAbsoluteLatestVersion)
.ToList();
Parallel.ForEach(packages,
new ParallelOptions { MaxDegreeOfParallelism = 4 },
package =>
{
// Some packages are updated without revving the version. We'll only opt not to re-download
// a package if an identical version does not exist on disk.
var existingPackage = targetRepo.FindPackage(package.Id, package.Version);
var dataServicePackage = (DataServicePackage)package;
if (existingPackage == null ||
!existingPackage.GetHash(dataServicePackage.PackageHashAlgorithm).Equals(dataServicePackage.PackageHash, StringComparison.Ordinal))
{
Trace.WriteLine(string.Format("{0}: Adding package {1}", DateTime.Now, package.GetFullName()));
var packagePath = GetPackagePath(package);
using (var input = package.GetStream())
using (var output = File.Create(packagePath))
{
input.CopyTo(output);
}
PurgeOldVersions(targetRepo, package);
}
});
}
public Form1()
{
InitializeComponent();
var kerbalPath = ConfigurationManager.AppSettings.Get("kerbalInstallPath");
var serverUrl = ConfigurationManager.AppSettings.Get("kerbalModServer");
txtKerbalPath.Text = kerbalPath;
// var modCacheDirectory = kerbalPath + @"\ModCache";
var modCacheDirectory = @"ModCache";
Directory.SetCurrentDirectory(kerbalPath);
_PackageRepository = PackageRepositoryFactory.Default.CreateRepository(serverUrl);
var localPackageRepository = new LocalPackageRepository(modCacheDirectory);
var project = new KerbalProjectSystem("");
_ProjectManager = new ProjectManager(_PackageRepository,
new DefaultPackagePathResolver(serverUrl),
project,
localPackageRepository);
_PackageManager = new PackageManager(_PackageRepository, new DefaultPackagePathResolver(serverUrl), project, localPackageRepository);
if (!Directory.Exists(modCacheDirectory))
{
Directory.CreateDirectory(modCacheDirectory);
}
lstAvailableMods.DisplayMember = "Description";
lstAvailableMods.ValueMember = "Id";
lstInstalledMods.DisplayMember = "Description";
lstInstalledMods.ValueMember = "Id";
RefreshModLists();
}
public IEnumerable<IPackageReference> FindReferences(string path)
{
var packageReferenceFile = new PackageReferenceFile(path);
var references = packageReferenceFile.GetPackageReferences();
if (!references.Any())
{
var packagesFolder = Path.Combine(_fileSystem.GetWorkingDirectory(path), Constants.PackagesFolder);
if (_fileSystem.DirectoryExists(packagesFolder))
{
var repository = new LocalPackageRepository(packagesFolder);
var arbitraryPackages = repository.GetPackages().Where(i => i.GetSupportedFrameworks().Any(x => x.FullName == VersionUtility.ParseFrameworkName("net40").FullName)).ToList();
if (arbitraryPackages.Any())
{
return arbitraryPackages.Select(i => new PackageReference(i.Id, VersionUtility.ParseFrameworkName("net40"), i.Version.Version) { SpecialVersion = i.Version.SpecialVersion });
}
}
return Enumerable.Empty<IPackageReference>();
}
var packages = references.Select(i => new PackageReference(i.Id, i.TargetFramework, i.Version.Version) { SpecialVersion = i.Version.SpecialVersion });
return packages;
}
internal void VerifyPackage(string filename)
{
try
{
Log.InfoFormat("Creating verify path {0}", filename);
var fi = new FileInfo(filename);
var tempPath =
new FileInfo(
Path.Combine(
Path.GetTempPath(),
"octgn",
Guid.NewGuid().ToString(),
fi.Name.Replace(fi.Extension, ".nupkg")));
if (!File.Exists(filename))
{
Log.InfoFormat("Package magically disappeared {0}", filename);
return;
}
Log.InfoFormat("Creating directory {0}", filename);
if (!Directory.Exists(tempPath.Directory.FullName)) Directory.CreateDirectory(tempPath.Directory.FullName);
Log.InfoFormat("Copying file {0}", filename);
fi.MegaCopyTo(tempPath);
Log.InfoFormat("Creating repo to make sure it loads {0}", filename);
var repo = new LocalPackageRepository(tempPath.Directory.FullName);
Log.InfoFormat("Loading repo into array to make sure it works {0}", filename);
var arr = repo.GetPackages().ToArray();
Log.InfoFormat("Fully verified {0}", filename);
}
catch (Exception)
{
Log.WarnFormat("Package not valid {0}", filename);
throw new UserMessageException(L.D.Exception__FileIsInvalid_Format, filename);
}
finally
{
Log.InfoFormat("Finished {0}", filename);
}
}
public IEnumerable<IPackage> GetAllPackages(string rootFolder)
{
//rootFolder is repository root
var targetFolder = rootFolder.AppendPath(PackagesFolder);
var packagePathResolver = new DefaultPackagePathResolver(targetFolder);
var packagesFolderFileSystem = new PhysicalFileSystem(targetFolder);
var localRepository = new LocalPackageRepository(packagePathResolver, packagesFolderFileSystem);
return localRepository.GetPackages();
}
public IPackageRepository get_local_repository(IPackagePathResolver pathResolver, NuGet.IFileSystem nugetPackagesFileSystem)
{
this.Log().Debug(() => "Setting up local repository at '{0}'".format_with(nugetPackagesFileSystem.Root));
IPackageRepository localRepository = new LocalPackageRepository(pathResolver, nugetPackagesFileSystem);
localRepository.PackageSaveMode = PackageSaveModes.Nupkg | PackageSaveModes.Nuspec;
return localRepository;
}
private void ExecuteInitScripts()
{
// Fix for Bug 1426 Disallow ExecuteInitScripts from being executed concurrently by multiple threads.
lock (_initScriptsLock)
{
if (!_solutionManager.IsSolutionOpen)
{
return;
}
IRepositorySettings repositorySettings = ServiceLocator.GetInstance<IRepositorySettings>();
Debug.Assert(repositorySettings != null);
if (repositorySettings == null)
{
return;
}
try
{
var localRepository = new LocalPackageRepository(repositorySettings.RepositoryPath);
// invoke init.ps1 files in the order of package dependency.
// if A -> B, we invoke B's init.ps1 before A's.
var sorter = new PackageSorter();
var sortedPackages = sorter.GetPackagesByDependencyOrder(localRepository);
foreach (var package in sortedPackages)
{
string installPath = localRepository.PathResolver.GetInstallPath(package);
AddPathToEnvironment(Path.Combine(installPath, "tools"));
Runspace.ExecuteScript(installPath, "tools\\init.ps1", package);
}
}
catch (Exception ex)
{
// if execution of Init scripts fails, do not let it crash our console
ReportError(ex);
ExceptionHelper.WriteToActivityLog(ex);
}
}
}
void DownloadPackage(IPackage package, string fullPathToDownloadTo, NuGet.PackageDownloader directDownloader)
{
Log.VerboseFormat("Found package {0} version {1}", package.Id, package.Version);
Log.Verbose("Downloading to: " + fullPathToDownloadTo);
var dsp = package as DataServicePackage;
if (dsp != null && directDownloader != null)
{
Log.Verbose("A direct download is possible; bypassing the NuGet machine cache");
using (var targetFile = new FileStream(fullPathToDownloadTo, FileMode.CreateNew))
directDownloader.DownloadPackage(dsp.DownloadUrl, dsp, targetFile);
return;
}
var physical = new PhysicalFileSystem(Path.GetDirectoryName(fullPathToDownloadTo));
var local = new LocalPackageRepository(new FixedFilePathResolver(package.Id, fullPathToDownloadTo), physical);
local.AddPackage(package);
}
public IEnumerable<IPackageReference> FindReferences(string path)
{
var packageReferenceFile = new PackageReferenceFile(path);
var references = packageReferenceFile.GetPackageReferences().ToList();
if (references.Any())
{
foreach (var packageReference in references)
{
yield return new PackageReference(
packageReference.Id,
packageReference.TargetFramework,
packageReference.Version.Version,
packageReference.Version.SpecialVersion);
}
yield break;
}
// No packages.config, check packages folder
var packagesFolder = Path.Combine(_fileSystem.GetWorkingDirectory(path), Constants.PackagesFolder);
if (!_fileSystem.DirectoryExists(packagesFolder)) yield break;
var repository = new LocalPackageRepository(packagesFolder);
var arbitraryPackages = repository.GetPackages();
if (!arbitraryPackages.Any()) yield break;
foreach (var arbitraryPackage in arbitraryPackages)
{
var newestFramework = GetNewestSupportedFramework(arbitraryPackage)
?? VersionUtility.EmptyFramework;
yield return new PackageReference(
arbitraryPackage.Id,
newestFramework,
arbitraryPackage.Version.Version,
arbitraryPackage.Version.SpecialVersion);
}
}
