public UninstallPackage ( IPackage package ) : void | ||
package | IPackage | |
return | void |
public void InstallPackage(PackageManager packageManager, Engine engine, bool updatePackages) { using (engine.Trace.WithIndent().Verbose("Installing package {0}{1} from {2}", _packageId, _versionSpec == null ? string.Empty : " " + _versionSpec, packageManager.SourceRepository.Source)) { // Find the local package IPackage localPackage = packageManager.LocalRepository.FindPackage(_packageId); // Check if we're up to date if (localPackage != null && _versionSpec.Satisfies(localPackage.Version) && !updatePackages) { engine.Trace.Verbose("Package {0}{1} is satisfied by version {2}, skipping", _packageId, _versionSpec == null ? string.Empty : " " + _versionSpec, localPackage.Version); return; } // Find the source package IPackage sourcePackage = packageManager.SourceRepository .FindPackage(_packageId, _versionSpec, _allowPrereleaseVersions, _allowUnlisted); if (sourcePackage == null) { engine.Trace.Warning("Package {0} {1} could not be found at {2}", _packageId, _versionSpec == null ? string.Empty : " " + _versionSpec, packageManager.SourceRepository.Source); return; } // Check if we're up to date if (localPackage != null && localPackage.Version >= sourcePackage.Version) { engine.Trace.Verbose("Package {0}{1} is up to date with version {2}, skipping", _packageId, _versionSpec == null ? string.Empty : " " + _versionSpec, localPackage.Version); return; } // Uninstall the old package (removing any content files) if (localPackage != null) { packageManager.UninstallPackage(localPackage, true); engine.Trace.Verbose("Uninstalled package {0} {1}", localPackage.Id, localPackage.Version); } // Install it packageManager.InstallPackage(sourcePackage, false, _allowPrereleaseVersions); engine.Trace.Verbose("Installed package {0} {1}", sourcePackage.Id, sourcePackage.Version); } }
/// <summary> /// Uninstall <paramref name="package"/>, while still keeping the downloaded file in the cache. /// </summary> /// <remarks>It is safe to call it concurrently be cause we operations are done using the FileLock.</remarks> /// <param name="package">Package to uninstall.</param> public void UninstallPackage(NugetPackage package, ProgressReport progress) { using (GetLocalRepositoryLock()) { currentProgressReport = progress; try { manager.UninstallPackage(package.IPackage); // Every time a new package is installed, we are updating the common targets UpdateTargetsHelper(); } finally { currentProgressReport = null; } } }
private void EnsureMultiplePackagesRespected(IReadOnlyCollection <IPackage> currentPackages, NuGet.PackageManager packageManager, string packageId, SemanticVersion packageSemanticVersion, Guid corrId) { if (this.allowMultipleVersionOfPackagesInCache) { return; } const string disallowMultipleVersion = "(Multiple version in cache disabled)"; var packagesToUninstall = currentPackages.Where(p => p.Version != packageSemanticVersion).ToList(); if (!packagesToUninstall.Any()) { return; } foreach (var existingPackage in packagesToUninstall) { this.LogPackageOperation(existingPackage.Id, existingPackage.Version, $"Uninstall from cache {disallowMultipleVersion}", corrId); packageManager.UninstallPackage(existingPackage); } }
/// <summary> /// Uninstall package /// </summary> /// <param name="pkgId"></param> /// <returns></returns> public static JsonResponse UninstallPackage(string pkgId) { try { var packageManager = new NuGet.PackageManager( _repository, new DefaultPackagePathResolver(_feedUrl), new PhysicalFileSystem(HttpContext.Current.Server.MapPath(Utils.ApplicationRelativeWebRoot + "App_Data/packages")) ); var package = _repository.FindPackage(pkgId); if (package == null) { return new JsonResponse { Success = false, Message = "Package " + pkgId + " not found" } } ; packageManager.UninstallPackage(package, true); FileSystem.RemovePackageFiles(package.Id, package.Version.ToString()); // reset cache Blog.CurrentInstance.Cache.Remove("Installed-Themes"); } catch (Exception ex) { Utils.Log("PackageManager.UninstallPackage", ex); return(new JsonResponse { Success = false, Message = "Error uninstalling package, see logs for details" }); } return(new JsonResponse { Success = true, Message = "Package successfully uninstalled" }); }
public static async Task Uninstall(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("Ok")); packageManager.PackageUninstalled += handler; packageManager.UninstallPackage(package, true, true); packageManager.PackageUninstalled -= handler; if (await Task.WhenAny(tcs.Task, Task.Delay(5000)) == tcs.Task) { await tcs.Task; } else { throw new TimeoutException("Package uninstall timeout"); } }
/// <summary> /// Uninstalls a package. /// </summary> /// <param name="packageId">The package identifier for the package to be uninstalled.</param> /// <param name="applicationPath">The application path.</param> public void Uninstall(string packageId, string applicationPath) { string solutionPath; string extensionFullPath = string.Empty; if (packageId.StartsWith(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Theme))) { extensionFullPath = _virtualPathProvider.MapPath("~/Themes/" + packageId.Substring(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Theme).Length)); } else if (packageId.StartsWith(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Module))) { extensionFullPath = _virtualPathProvider.MapPath("~/Modules/" + packageId.Substring(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Module).Length)); } if (string.IsNullOrEmpty(extensionFullPath) || !Directory.Exists(extensionFullPath)) { throw new OrchardException(T("Package not found: {0}", packageId)); } // if we can access the parent directory, and the solution is inside, NuGet-uninstall the package here if (TryGetSolutionPath(applicationPath, out solutionPath)) { // this logger is used to render NuGet's log on the notifier var logger = new NugetLogger(_notifier); var installedPackagesPath = Path.Combine(solutionPath, PackagesPath); var sourcePackageRepository = new LocalPackageRepository(installedPackagesPath); try { var project = new FileBasedProjectSystem(applicationPath) { Logger = logger }; var projectManager = new ProjectManager( sourcePackageRepository, new DefaultPackagePathResolver(installedPackagesPath), project, new ExtensionReferenceRepository(project, sourcePackageRepository, _extensionManager) ) { Logger = logger }; // add the package to the project projectManager.RemovePackageReference(packageId); } catch { // Uninstalling the package at the solution level failed } try { var packageManager = new NuGetPackageManager( sourcePackageRepository, new DefaultPackagePathResolver(applicationPath), new PhysicalFileSystem(installedPackagesPath) { Logger = logger } ) { Logger = logger }; packageManager.UninstallPackage(packageId); } catch { // Package doesnt exist anymore } } // If the package was not installed through nuget we still need to try to uninstall it by removing its directory if (Directory.Exists(extensionFullPath)) { Directory.Delete(extensionFullPath, true); } }
public override bool UninstallPackage(string packageId) { var installedRepository = GetInstalledRepository(); var package = installedRepository.FindPackage(packageId); if (package == null) { return false; } var packageManager = new PackageManager(installedRepository, InstalledRepository); packageManager.UninstallPackage(package, true); return true; }
public override bool InstallOrUpdatePackage(string packageId) { var installableRepository = GetInstallableRepository(); var installablePackage = installableRepository.FindPackage(packageId); if (installablePackage == null) { return false; } var installedRepository = GetInstalledRepository(); var installedPackages = installedRepository.GetPackages().ToList(); var packageManager = new PackageManager(installableRepository, InstalledRepository); packageManager.PackageInstalled += InstallPackage; var installedPackage = installedPackages.FirstOrDefault(i => string.Equals(i.Id, packageId, StringComparison.OrdinalIgnoreCase)); if (installedPackage != null) { if (installedPackage.Version == installablePackage.Version) { packageManager.UninstallPackage(installedPackage, true); packageManager.InstallPackage(installablePackage, false, true); } else { packageManager.UpdatePackage(installablePackage, false, true); } } else { packageManager.InstallPackage(installablePackage, false, true); } return true; }
public static IPackageManager GetPackageManager(ChocolateyConfiguration configuration, ILogger nugetLogger, Action<PackageOperationEventArgs> installSuccessAction, Action<PackageOperationEventArgs> uninstallSuccessAction, bool addUninstallHandler) { IFileSystem nugetPackagesFileSystem = GetNuGetFileSystem(configuration, nugetLogger); IPackagePathResolver pathResolver = GetPathResolver(configuration, nugetPackagesFileSystem); var packageManager = new PackageManager(GetRemoteRepository(configuration, nugetLogger), pathResolver, nugetPackagesFileSystem, GetLocalRepository(pathResolver, nugetPackagesFileSystem)) { DependencyVersion = DependencyVersion.Highest, }; if (configuration.Debug) { packageManager.Logger = nugetLogger; } //NOTE DO NOT EVER use this method - packageManager.PackageInstalling += (s, e) => packageManager.PackageInstalled += (s, e) => { var pkg = e.Package; "chocolatey".Log().Info(ChocolateyLoggers.Important, "{0}{1} v{2}{3}".format_with(Environment.NewLine, pkg.Id, pkg.Version.to_string(), configuration.Force ? " (forced)" : string.Empty)); if (installSuccessAction != null) installSuccessAction.Invoke(e); }; if (addUninstallHandler) { // NOTE DO NOT EVER use this method, or endless loop - packageManager.PackageUninstalling += (s, e) => packageManager.PackageUninstalled += (s, e) => { IPackage pkg = packageManager.LocalRepository.FindPackage(e.Package.Id, e.Package.Version); if (pkg != null) { // install not actually removed, let's clean it up. This is a bug with nuget, where it reports it removed some package and did NOTHING // this is what happens when you are switching from AllowMultiple to just one and back var chocoPathResolver = packageManager.PathResolver as ChocolateyPackagePathResolver; if (chocoPathResolver != null) { chocoPathResolver.UseSideBySidePaths = !chocoPathResolver.UseSideBySidePaths; // an unfound package folder can cause an endless loop. // look for it and ignore it if doesn't line up with versioning if (nugetPackagesFileSystem.DirectoryExists(chocoPathResolver.GetInstallPath(pkg))) { //todo: This causes an issue with upgrades. // this causes this to be called again, which should then call the uninstallSuccessAction below packageManager.UninstallPackage(pkg, forceRemove: configuration.Force, removeDependencies: false); } chocoPathResolver.UseSideBySidePaths = configuration.AllowMultipleVersions; } } else { if (uninstallSuccessAction != null) uninstallSuccessAction.Invoke(e); } }; } return packageManager; }
/// <summary> /// Uninstalls a package. /// </summary> /// <param name="packageId">The package identifier for the package to be uninstalled.</param> /// <param name="applicationPath">The application path.</param> public void Uninstall(string packageId, string applicationPath) { string solutionPath; string extensionFullPath = string.Empty; if (packageId.StartsWith(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Theme))) { extensionFullPath = _virtualPathProvider.MapPath("~/Themes/" + packageId.Substring(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Theme).Length)); } else if (packageId.StartsWith(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Module))) { extensionFullPath = _virtualPathProvider.MapPath("~/Modules/" + packageId.Substring(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Module).Length)); } if (string.IsNullOrEmpty(extensionFullPath) || !Directory.Exists(extensionFullPath)) { throw new OrchardException(T("Package not found: {0}", packageId)); } // if we can access the parent directory, and the solution is inside, NuGet-uninstall the package here if (TryGetSolutionPath(applicationPath, out solutionPath)) { // this logger is used to render NuGet's log on the notifier var logger = new NugetLogger(_notifier); var installedPackagesPath = Path.Combine(solutionPath, PackagesPath); var sourcePackageRepository = new LocalPackageRepository(installedPackagesPath); try { var project = new FileBasedProjectSystem(applicationPath) {Logger = logger}; var projectManager = new ProjectManager( sourcePackageRepository, new DefaultPackagePathResolver(installedPackagesPath), project, new ExtensionReferenceRepository(project, sourcePackageRepository, _extensionManager) ) {Logger = logger}; // add the package to the project projectManager.RemovePackageReference(packageId); } catch { // Uninstalling the package at the solution level failed } try { var packageManager = new NuGetPackageManager( sourcePackageRepository, new DefaultPackagePathResolver(applicationPath), new PhysicalFileSystem(installedPackagesPath) {Logger = logger} ) {Logger = logger}; packageManager.UninstallPackage(packageId); } catch { // Package doesnt exist anymore } } // If the package was not installed through nuget we still need to try to uninstall it by removing its directory if (Directory.Exists(extensionFullPath)) { Directory.Delete(extensionFullPath, true); } }
public virtual void UninstallPackage([NotNull] string packageId) { var installedRepository = GetInstalledRepository(); var package = installedRepository.FindPackage(packageId); if (package == null) { throw new InvalidOperationException("Package not found: " + packageId); } var packageManager = new PackageManager(installedRepository, InstalledRepository); packageManager.UninstallPackage(package, true); }
public virtual void InstallOrUpdatePackage([NotNull] string packageId) { var availableRepository = GetAvailableRepository(); var availablePackage = availableRepository.FindPackage(packageId); if (availablePackage == null) { throw new InvalidOperationException("Package not found: " + packageId); } var installedRepository = GetInstalledRepository(); var installedPackages = installedRepository.GetPackages().ToList(); var packageManager = new PackageManager(availableRepository, InstalledRepository); packageManager.PackageInstalled += InstallPackage; var installedPackage = installedPackages.FirstOrDefault(i => string.Equals(i.Id, packageId, StringComparison.OrdinalIgnoreCase)); if (installedPackage != null) { if (installedPackage.Version == availablePackage.Version) { packageManager.UninstallPackage(installedPackage, true); packageManager.InstallPackage(availablePackage, false, true); } else { packageManager.UpdatePackage(availablePackage, false, true); } } else { packageManager.InstallPackage(availablePackage, false, true); } }
static void Uninstall(string pkgName, SemanticVersion version) { var packageManager = new PackageManager(Repository, Path); packageManager.UninstallPackage(pkgName, version); }
/// <summary> /// Uninstall package /// </summary> /// <param name="pkgId"></param> /// <returns></returns> public static JsonResponse UninstallPackage(string pkgId) { try { var packageManager = new NuGet.PackageManager( _repository, new DefaultPackagePathResolver(_feedUrl), new PhysicalFileSystem(HttpContext.Current.Server.MapPath(Utils.ApplicationRelativeWebRoot + "App_Data/packages")) ); var package = _repository.FindPackage(pkgId); if(package == null) return new JsonResponse { Success = false, Message = "Package " + pkgId + " not found" }; packageManager.UninstallPackage(package, true); FileSystem.RemovePackageFiles(package.Id, package.Version.ToString()); // reset cache Blog.CurrentInstance.Cache.Remove("Installed-Themes"); } catch (Exception ex) { Utils.Log("PackageManager.UninstallPackage", ex); return new JsonResponse { Success = false, Message = "Error uninstalling package, see logs for details" }; } return new JsonResponse { Success = true, Message = "Package successfully uninstalled" }; }