public async Task<Hash> PutAsync(long id, SemanticVersion version, IPackage package)
{
#region Preconditions
if (package == null) throw new ArgumentNullException(nameof(package));
#endregion
var key = id.ToString() + "/" + version.ToString();
using (var ms = new MemoryStream())
{
await package.ZipToStreamAsync(ms).ConfigureAwait(false);
var hash = Hash.ComputeSHA256(ms, leaveOpen: true);
var blob = new Blob(ms) {
ContentType = "application/zip"
};
await bucket.PutAsync(key, blob).ConfigureAwait(false);
return hash;
}
}
public static ServerPackageMetadata Parse(IPackage package)
{
var Version = NuGetVersion.Parse(package.Version.ToString());
var Published = package.Published;
var title = String.IsNullOrEmpty(package.Title) ? package.Id : package.Title;
var summary = package.Summary;
var desc = package.Description;
//*TODOs: Check if " " is the separator in the case of V3 jobjects ...
var authors = package.Authors;
var owners = package.Owners;
var iconUrl = package.IconUrl;
var licenseUrl = package.LicenseUrl;
var projectUrl = package.ProjectUrl;
IEnumerable<string> tags = package.Tags == null ? new string[0] : package.Tags.Split(' ');
var dependencySets = package.DependencySets.Select(p => GetVisualStudioUIPackageDependencySet(p));
var requiresLiceneseAcceptance = package.RequireLicenseAcceptance;
var identity = new PackageIdentity(package.Id, Version);
NuGetVersion minClientVersion = null;
if (package.MinClientVersion != null)
{
NuGetVersion.TryParse(package.MinClientVersion.ToString(), out minClientVersion);
}
var downloadCount = package.DownloadCount;
// This concept is not in v2 yet
IEnumerable<string> types = new string[] { "Package" };
return new ServerPackageMetadata(
identity, title, summary, desc, authors, iconUrl, licenseUrl,
projectUrl, tags, Published, dependencySets, requiresLiceneseAcceptance, minClientVersion, downloadCount, -1, owners, types);
}
public override IEnumerable<PackageOperation> GetInstallPackageOperations(IPackage package, InstallPackageAction installAction)
{
if (ExceptionToThrowWhenGetInstallPackageOperationsCalled != null) {
throw ExceptionToThrowWhenGetInstallPackageOperationsCalled;
}
return base.GetInstallPackageOperations(package, installAction);
}
public void Parse(byte[] packagebodybyte, IPackage package)
{
try
{
byte[] header = packagebodybyte.Take(min_body_header_length).ToArray();
byte[] body = packagebodybyte.Skip(min_body_header_length).Take(packagebodybyte.Length - min_body_header_length).ToArray();
ipp_Header ippheader = new ipp_Header(header);
ipp_Body ippbody = new ipp_Body(body, _defEncoding);
Indexes indexes = new Indexes(0, 6);
package.PCC = ippbody.GetString(indexes);
package.UID = ippbody.GetUid(indexes.Next(24));//ci + ippheader.PT + ippheader.PCT, ippheader.PCT);
package.PD = ippbody.GetDatetime(indexes.Next(14));//ci + ippheader.PT + ippheader.PCT, ippheader.PCT);
package.IPPV = ippbody.GetString(indexes.Next(ippheader.IPPV));//ci, ippheader.PT);
package.PT = ippbody.GetInt(indexes.Next(ippheader.PT));//ci, ippheader.PT);
package.PCT = ippbody.GetInt(indexes.Next(ippheader.PCT));//ci + ippheader.PT, ippheader.PCT);
package.PCL = ippbody.GetInt(indexes.Next(ippheader.PCL));//ci + ippheader.PT + ippheader.PCT, ippheader.PCT);
package.PS = ippbody.GetString(indexes.Next(ippheader.PS));//ci + ippheader.PT + ippheader.PCT + ippheader.PCL, ippheader.PS);
package.PR = ippbody.GetString(indexes.Next(ippheader.PR));//ci + ippheader.PT + ippheader.PCT + ippheader.PCL + ippheader.PS, ippheader.PR);
package.PCN = ippbody.GetString(indexes.Next(ippheader.PCN));//ci + ippheader.PT + ippheader.PCT + ippheader.PCL + ippheader.PS + ippheader.PR, ippheader.PS);
package.PC = body.Skip(indexes.Index + indexes.Count).Take(body.Length - indexes.Index + indexes.Count).ToArray();//ci + ippheader.PT + ippheader.PCT + ippheader.PCL, ippheader.PCT);
}
catch (Exception e)
{
}
}
public override PackageValidationOutput is_valid(IPackage package)
{
var valid = true;
var files = package.GetFiles().or_empty_list_if_null();
foreach (var packageFile in files.or_empty_list_if_null())
{
string extension = Path.GetExtension(packageFile.Path).to_lower();
if (extension != ".ps1" && extension != ".psm1") continue;
var contents = packageFile.GetStream().ReadToEnd().to_lower();
if (contents.Contains("install-chocolateypackage") ||
contents.Contains("start-chocolateyprocessasadmin") ||
contents.Contains("install-chocolateyinstallpackage") ||
contents.Contains("install-chocolateyenvironmentvariable") ||
contents.Contains("install-chocolateyexplorermenuitem") ||
contents.Contains("install-chocolateyfileassociation"))
{
valid = package.Tags.to_string().Split(' ').Any(tag => tag.ToLower() == "admin");
}
}
return valid;
}
public void LoadPackages(IPackage appPackage)
{
this._packageTable = new Hashtable();
if (appPackage != null)
{
appPackage.Initialize(this._serviceProvider);
this._packageTable.Add(typeof(IApplicationPackage), appPackage);
}
IPackage package = new CorePackage();
package.Initialize(this._serviceProvider);
this._packageTable.Add(typeof(CorePackage), package);
IDictionary config = (IDictionary) ConfigurationSettings.GetConfig("microsoft.matrix/packages");
if (config != null)
{
IDictionaryEnumerator enumerator = config.GetEnumerator();
while (enumerator.MoveNext())
{
DictionaryEntry current = (DictionaryEntry) enumerator.Current;
string packageTypeName = (string) current.Value;
try
{
this.LoadPackage(packageTypeName);
continue;
}
catch (Exception)
{
continue;
}
}
}
}
public IEnumerable<PackageIssue> Validate(IPackage package)
{
if (package.ProjectUrl != null && package.ProjectUrl.OriginalString.Equals(SpecCommand.SampleProjectUrl, StringComparison.Ordinal))
{
yield return CreateIssueFor("ProjectUrl", package.ProjectUrl.OriginalString);
}
if (package.LicenseUrl != null && package.LicenseUrl.OriginalString.Equals(SpecCommand.SampleLicenseUrl, StringComparison.Ordinal))
{
yield return CreateIssueFor("LicenseUrl", package.LicenseUrl.OriginalString);
}
if (package.IconUrl != null && package.IconUrl.OriginalString.Equals(SpecCommand.SampleIconUrl, StringComparison.Ordinal))
{
yield return CreateIssueFor("IconUrl", package.IconUrl.OriginalString);
}
if (!String.IsNullOrEmpty(package.Tags) && package.Tags.Trim().Equals(SpecCommand.SampleTags, StringComparison.Ordinal))
{
yield return CreateIssueFor("Tags", SpecCommand.SampleTags);
}
if (SpecCommand.SampleReleaseNotes.Equals(package.ReleaseNotes, StringComparison.Ordinal))
{
yield return CreateIssueFor("ReleaseNotes", SpecCommand.SampleReleaseNotes);
}
if (SpecCommand.SampleDescription.Equals(package.Description, StringComparison.Ordinal))
{
yield return CreateIssueFor("Description", SpecCommand.SampleDescription);
}
var dependency = package.GetCompatiblePackageDependencies(targetFramework: null).FirstOrDefault();
if (dependency != null && dependency.Id.Equals(SpecCommand.SampleManifestDependency.Id, StringComparison.Ordinal)
&& dependency.VersionSpec.ToString().Equals("[" + SpecCommand.SampleManifestDependency.Version + "]", StringComparison.Ordinal))
{
yield return CreateIssueFor("Dependency", dependency.ToString());
}
}
public void AddPackage(IPackage package)
{
// if the package is already present in the cache, no need to do anything
if (FindPackage(package.Id, package.Version) != null)
{
return;
}
// create the cache directory if it doesn't exist
var cacheDirectory = new DirectoryInfo(Source);
if (!cacheDirectory.Exists)
{
cacheDirectory.Create();
}
// don't want to blow up user's hard drive with too many packages
ClearCache(cacheDirectory, MaxNumberOfPackages);
// now copy the package to the cache
string filePath = GetPackageFilePath(package.Id, package.Version);
using (Stream stream = package.GetStream(),
fileStream = File.Create(filePath))
{
if (stream != null)
{
stream.CopyTo(fileStream);
}
}
}
public bool Execute(string installPath, string scriptFileName, IPackage package, Project project, FrameworkName targetFramework, ILogger logger)
{
string scriptPath, fullPath;
if (package.FindCompatibleToolFiles(scriptFileName, targetFramework, out scriptPath))
{
fullPath = Path.Combine(installPath, scriptPath);
}
else
{
return false;
}
if (File.Exists(fullPath))
{
string toolsPath = Path.GetDirectoryName(fullPath);
string logMessage = String.Format(CultureInfo.CurrentCulture, VsResources.ExecutingScript, fullPath);
// logging to both the Output window and progress window.
logger.Log(MessageLevel.Info, logMessage);
IConsole console = OutputConsoleProvider.CreateOutputConsole(requirePowerShellHost: true);
Host.Execute(console,
"$__pc_args=@(); $input|%{$__pc_args+=$_}; & " + PathHelper.EscapePSPath(fullPath) + " $__pc_args[0] $__pc_args[1] $__pc_args[2] $__pc_args[3]; Remove-Variable __pc_args -Scope 0",
new object[] { installPath, toolsPath, package, project });
return true;
}
return false;
}
private static PackageUpgradeAction DetectUpgradeAction(PackageDependency dependency, IPackage recentPackage)
{
var upgradeType = PackageUpgradeAction.None;
if (recentPackage == null)
{
upgradeType = PackageUpgradeAction.Unknown;
}
else if (dependency.VersionSpec.Satisfies(recentPackage.Version))
{
upgradeType = IsMinVersionUpgradeable(dependency, recentPackage)
? PackageUpgradeAction.MinVersion
: PackageUpgradeAction.None;
}
else
{
var fromRelease = DependsOnReleaseVersion(dependency);
if (recentPackage.IsReleaseVersion())
{
upgradeType = fromRelease ? PackageUpgradeAction.ReleaseToRelease : PackageUpgradeAction.PrereleaseToRelease;
}
else
{
upgradeType = fromRelease ? PackageUpgradeAction.ReleaseToPrerelease : PackageUpgradeAction.PrereleaseToPrerelease;
}
}
return upgradeType;
}
public void AddPackage(IPackage package)
{
if (AddPackageCallback != null)
{
AddPackageCallback(package);
}
}
public Package(IPackage package, DerivedPackageData derivedData)
{
Id = package.Id;
Version = package.Version.ToString();
Title = package.Title;
Authors = String.Join(",", package.Authors);
if (package.IconUrl != null)
{
IconUrl = package.IconUrl.GetComponents(UriComponents.HttpRequestUrl, UriFormat.Unescaped);
}
if (package.LicenseUrl != null)
{
LicenseUrl = package.LicenseUrl.GetComponents(UriComponents.HttpRequestUrl, UriFormat.Unescaped);
}
if (package.ProjectUrl != null)
{
ProjectUrl = package.ProjectUrl.GetComponents(UriComponents.HttpRequestUrl, UriFormat.Unescaped);
}
RequireLicenseAcceptance = package.RequireLicenseAcceptance;
Description = package.Description;
Summary = package.Summary;
ReleaseNotes = package.ReleaseNotes;
Tags = package.Tags;
Dependencies = String.Join("|", package.DependencySets.SelectMany(ConvertDependencySetToStrings));
PackageHash = derivedData.PackageHash;
PackageHashAlgorithm = "SHA512";
PackageSize = derivedData.PackageSize;
LastUpdated = derivedData.LastUpdated.UtcDateTime;
Published = derivedData.Created.UtcDateTime;
IsAbsoluteLatestVersion = package.IsAbsoluteLatestVersion;
IsLatestVersion = package.IsLatestVersion;
Path = derivedData.Path;
FullPath = derivedData.FullPath;
}
public IEnumerable<PackageIssue> Validate(IPackage package)
{
foreach (IPackageFile file in package.GetFiles())
{
string path = file.Path;
string directory = Path.GetDirectoryName(path);
// if under 'lib' directly
if (directory.Equals(Constants.LibDirectory, StringComparison.OrdinalIgnoreCase))
{
if (PackageHelper.IsAssembly(path))
{
yield return CreatePackageIssueForAssembliesUnderLib(path);
}
}
else if (!directory.StartsWith(Constants.LibDirectory + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
{
// when checking for assemblies outside 'lib' folder, only check .dll files.
// .exe files are often legitimate outside 'lib'.
if (path.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) ||
path.EndsWith(".winmd", StringComparison.OrdinalIgnoreCase))
{
yield return CreatePackageIssueForAssembliesOutsideLib(path);
}
}
}
}
public IEnumerable<PackageVerifierIssue> Validate(IPackageRepository packageRepo, IPackage package, IPackageVerifierLogger logger)
{
if (!package.IsSatellitePackage())
{
IEnumerable<string> allXmlFiles =
from file in package.GetLibFiles()
select file.Path into path
where path.EndsWith(".xml", StringComparison.OrdinalIgnoreCase)
select path;
foreach (IPackageFile current in package.GetLibFiles())
{
string assemblyPath = current.Path;
// TODO: Does this need to check for just managed code?
if (assemblyPath.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
{
string docFilePath = Path.ChangeExtension(assemblyPath, ".xml");
if (!allXmlFiles.Contains(docFilePath, StringComparer.OrdinalIgnoreCase))
{
yield return PackageIssueFactory.AssemblyHasNoDocFile(assemblyPath);
}
}
}
}
yield break;
}
public void UninstallPackage(IPackage package, UninstallPackageAction uninstallAction)
{
PackagePassedToUninstallPackage = package;
ForceRemovePassedToUninstallPackage = uninstallAction.ForceRemove;
RemoveDependenciesPassedToUninstallPackage = uninstallAction.RemoveDependencies;
IsRefreshProjectBrowserCalledWhenUninstallPackageCalled = FakeProjectService.IsRefreshProjectBrowserCalled;
}
public IEnumerable<PackageIssue> Validate(IPackage package)
{
foreach (IPackageFile file in package.GetFiles())
{
string path = file.Path;
if (!path.EndsWith(ScriptExtension, StringComparison.OrdinalIgnoreCase))
{
continue;
}
if (!path.StartsWith(Constants.ToolsDirectory + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
{
yield return CreatePackageIssueForMisplacedScript(path);
}
else
{
string directory = Path.GetDirectoryName(path);
string name = Path.GetFileNameWithoutExtension(path);
if (!directory.Equals(Constants.ToolsDirectory, StringComparison.OrdinalIgnoreCase) ||
!name.Equals("install", StringComparison.OrdinalIgnoreCase) &&
!name.Equals("uninstall", StringComparison.OrdinalIgnoreCase) &&
!name.Equals("init", StringComparison.OrdinalIgnoreCase))
{
yield return CreatePackageIssueForUnrecognizedScripts(path);
}
}
}
}
public void RemovePackage(IPackage package)
{
if (RemovePackageCallback != null)
{
RemovePackageCallback(package);
}
}
public PackageViewModelOperationLogger(ILogger logger, IPackage package)
{
this.logger = logger;
this.package = package;
GetMessageFormats();
}
public void GetUpdatesReturnAllPackageVersionsWhenFlagIsSpecified()
{
// Arrange
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0", new string[] { "hello" }));
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "2.0", new string[] { "hello" }));
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "3.0", new string[] { "hello" }));
sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "3.0-alpha", new string[] { "hello" }));
var packages = new IPackage[]
{
PackageUtility.CreatePackage("A", "1.5")
};
// Act
var foundPackages = PackageRepositoryExtensions.GetUpdates(sourceRepository, packages, includePrerelease: true, includeAllVersions: true).ToList();
// Assert
Assert.Equal(3, foundPackages.Count);
Assert.Equal("A", foundPackages[0].Id);
Assert.Equal(new SemanticVersion("2.0"), foundPackages[0].Version);
Assert.Equal("A", foundPackages[1].Id);
Assert.Equal(new SemanticVersion("3.0"), foundPackages[1].Version);
Assert.Equal("A", foundPackages[2].Id);
Assert.Equal(new SemanticVersion("3.0-alpha"), foundPackages[2].Version);
}
public Package CreatePackage(IPackage nugetPackage, User currentUser)
{
ValidateNuGetPackage(nugetPackage);
var packageRegistration = CreateOrGetPackageRegistration(currentUser, nugetPackage);
var package = CreatePackageFromNuGetPackage(packageRegistration, nugetPackage);
packageRegistration.Packages.Add(package);
using (var tx = new TransactionScope())
{
using (var stream = nugetPackage.GetStream())
{
UpdateIsLatest(packageRegistration);
packageRegistrationRepo.CommitChanges();
packageFileSvc.SavePackageFile(package, stream);
tx.Complete();
}
}
if (package.Status != PackageStatusType.Approved && package.Status != PackageStatusType.Exempted) NotifyForModeration(package, comments: string.Empty);
NotifyIndexingService();
return package;
}
public override void AddPackage(IPackage package)
{
// If we exceed the package count then clear the cache.
var files = GetPackageFiles().ToList();
if (files.Count >= MaxPackages)
{
// It's expensive to hit the file system to get the last accessed date for files
// To reduce this cost from occuring frequently, we'll purge packages in batches allowing for a 20% buffer.
var filesToDelete = files.OrderBy(FileSystem.GetLastAccessed)
.Take(files.Count - (int)(0.8 * MaxPackages))
.ToList();
TryClear(filesToDelete);
}
string path = GetPackageFilePath(package);
TryAct(() =>
{
// we want to do this in the TryAct, i.e. in the mutex
// for cases where package was added to cache by another process
if (FileSystem.FileExists(path))
{
return true;
}
string tmp = GetTempFile(path);
using (var stream = package.GetStream())
{
FileSystem.AddFile(tmp, stream);
}
FileSystem.MoveFile(tmp, path);
return true;
}, path);
}
public PackageResult(IPackage package, string installLocation, string source = null)
: this(package.Id.to_lower(), package.Version.to_string(), installLocation)
{
Package = package;
Source = source;
var sources = new List<Uri>();
if (!string.IsNullOrEmpty(source))
{
sources.AddRange(source.Split(new[] {";", ","}, StringSplitOptions.RemoveEmptyEntries).Select(s => new Uri(s)));
}
var rp = Package as DataServicePackage;
if (rp != null)
{
SourceUri = rp.DownloadUrl.ToString();
Source = sources.FirstOrDefault(uri => uri.IsBaseOf(rp.DownloadUrl)).to_string();
if (string.IsNullOrEmpty(Source))
{
Source = sources.FirstOrDefault(uri => uri.DnsSafeHost == rp.DownloadUrl.DnsSafeHost).to_string();
}
}
else
{
Source = sources.FirstOrDefault(uri => uri.IsFile || uri.IsUnc).to_string();
}
}
public override bool Import(string filename, IPackage package)
{
ImageResource.ImageResource resource = CreateResource(package) as ImageResource.ImageResource;
FileStream fileStream = new FileStream(filename, FileMode.Open, FileAccess.Read);
try
{
using (BinaryReader stream = new BinaryReader(fileStream))
{
resource.Stream.Position = 0;
resource.Stream.SetLength(stream.BaseStream.Length);
resource.Stream.Write(stream.ReadBytes((int)stream.BaseStream.Length), 0, (int)stream.BaseStream.Length);
}
package.ReplaceResource(mEntry, resource);
return true;
}
catch (Exception ex)
{
MainForm.IssueError(ex, "Import failed.");
return false;
}
finally
{
fileStream.Close();
}
}
PackageCardViewModel GetPackageCardViewModel(IPackage pacakge)
{
var isInstalled = _random.Next(1, 10)%2 == 0;
return isInstalled
? (PackageCardViewModel)new InstalledPackageCardViewModel(pacakge)
: (PackageCardViewModel)new GalleryPackageCardViewModel(pacakge);
}
protected override PackageValidationOutput is_valid(IPackage package)
{
var files = package.GetFiles().or_empty_list_if_null();
var hasBadInstallScripts = files.Any(f => f.Path.to_lower().Contains("install.ps1")) && !files.Any(f => f.Path.to_lower().Contains("chocolateyinstall.ps1"));
return !hasBadInstallScripts;
}
public override void AddPackage(IPackage package)
{
if (PackageSaveMode.HasFlag(PackageSaveModes.Nuspec))
{
// Starting from 2.1, we save the nuspec file into the subdirectory with the name as <packageId>.<version>
// for example, for jQuery version 1.0, it will be "jQuery.1.0\\jQuery.1.0.nuspec"
string packageFilePath = GetManifestFilePath(package.Id, package.Version);
Manifest manifest = Manifest.Create(package);
// The IPackage object doesn't carry the References information.
// Thus we set the References for the manifest to the set of all valid assembly references
manifest.Metadata.ReferenceSets = package.AssemblyReferences
.GroupBy(f => f.TargetFramework)
.Select(
g => new ManifestReferenceSet
{
TargetFramework = g.Key == null ? null : VersionUtility.GetFrameworkString(g.Key),
References = g.Select(p => new ManifestReference { File = p.Name }).ToList()
})
.ToList();
FileSystem.AddFileWithCheck(packageFilePath, manifest.Save);
}
if (PackageSaveMode.HasFlag(PackageSaveModes.Nupkg))
{
string packageFilePath = GetPackageFilePath(package);
FileSystem.AddFileWithCheck(packageFilePath, package.GetStream);
}
}
void WalkPackage (IPackage package)
{
var localRepository = new FakePackageRepository ();
var sourceRepository = new FakePackageRepository ();
var walker = new InstallWalker (localRepository, sourceRepository, null, NullLogger.Instance, true, false, DependencyVersion.Lowest);
walker.Walk (package);
}
void SetUpdateActionParameters(UpdatePackageAction action, IPackage package)
{
action.PackageId = package.Id;
action.PackageScriptRunner = PackageScriptRunner;
action.UpdateIfPackageDoesNotExistInProject = false;
action.UpdateDependencies = UpdateDependencies;
}
public override string GetInstallPath(IPackage package)
{
var packageVersionPath = Path.Combine(_nugetFileSystem.Root, GetPackageDirectory(package.Id,package.Version,useVersionInPath:true));
if (_nugetFileSystem.DirectoryExists(packageVersionPath)) return packageVersionPath;
return Path.Combine(_nugetFileSystem.Root, GetPackageDirectory(package.Id, package.Version));
}
public static void ExecuteScript(this IScriptExecutor executor, string installPath, string scriptFileName, IPackage package, Project project, ILogger logger)
{
if (package.HasPowerShellScript(new[] { scriptFileName }))
{
executor.Execute(installPath, scriptFileName, package, project, logger);
}
}
internal IEnumerable <IPackage> GetPackagesRequiringLicenseAcceptance(IPackage package)
{
return(GetPackagesRequiringLicenseAcceptance(package, localRepository: LocalRepository, sourceRepository: SourceRepository));
}
public IEnumerable <Project> ShowProjectSelectorWindow(
string instructionText,
IPackage package,
Predicate <Project> checkedStateSelector,
Predicate <Project> enabledStateSelector)
{
if (!_uiDispatcher.CheckAccess())
{
// Use Invoke() here to block the worker thread
object result = _uiDispatcher.Invoke(
new Func <string, IPackage, Predicate <Project>, Predicate <Project>, IEnumerable <Project> >(ShowProjectSelectorWindow),
instructionText,
package,
checkedStateSelector,
enabledStateSelector);
return((IEnumerable <Project>)result);
}
var viewModel = new SolutionExplorerViewModel(
ServiceLocator.GetInstance <DTE>().Solution,
package,
checkedStateSelector,
enabledStateSelector);
// only show the solution explorer window if there is at least one compatible project
if (viewModel.HasProjects)
{
var window = new SolutionExplorer()
{
DataContext = viewModel
};
window.InstructionText.Text = instructionText;
bool?dialogResult = window.ShowModal();
if (dialogResult ?? false)
{
return(viewModel.GetSelectedProjects());
}
else
{
return(null);
}
}
else
{
IEnumerable <FrameworkName> supportedFrameworks = package.GetSupportedFrameworks()
.Where(name => name != null && name != VersionUtility.UnsupportedFrameworkName);
string errorMessage = supportedFrameworks.Any() ?
String.Format(
CultureInfo.CurrentCulture,
Resources.Dialog_NoCompatibleProject,
package.Id,
Environment.NewLine + String.Join(Environment.NewLine, supportedFrameworks)) :
String.Format(
CultureInfo.CurrentCulture,
Resources.Dialog_NoCompatibleProjectNoFrameworkNames,
package.Id);
// if there is no project compatible with the selected package, show an error message and return
MessageHelper.ShowWarningMessage(errorMessage, title: null);
return(null);
}
}
private PackageItem GetPackageItem(IPackage package)
{
return(GetPackageItem(package?.uniqueId));
}
protected override void OnAfterPackageWalk(IPackage package)
{
base.OnAfterPackageWalk(package);
_sortedPackages.Add(package);
}
public static string IdAndVersion(this IPackage package)
{
return(string.Format("{0}-{1}", package.Id, package.Version));
}
public bool IsPackageInstalled(IPackage package)
{
return(LocalRepository.Exists(package));
}
internal IEnumerable <string> UpdatePackage(IPackage package)
{
return(UpdatePackage(package, AppDomain.CurrentDomain));
}
public TextName(TransProp transProp, IPackage package)
: base(transProp, package)
{
}
public IEnumerable <PackageOperation> GetInstallPackageOperations(IPackage package, InstallPackageAction installAction)
{
return(packageManager.GetInstallPackageOperations(package, installAction));
}
public bool IsPackageInstalled(IPackage package)
{
return(projectManager.IsInstalled(package));
}
public Item(InstanceLocator instance, IPackage package)
{
this.Instance = instance;
this.Package = package;
}
public static PackageDependency ToPackageDependency(this IPackage package)
{
return(new PackageDependency(string.Format("{0} {1}", package.Id, package.Version)));
}
internal IEnumerable <string> InstallPackage(IPackage package)
{
return(InstallPackage(package, AppDomain.CurrentDomain));
}
public static List <IPackage> FindDependencies(this IPackage package, params ISource[] sources)
{
return(Source.FindDependencies(package, sources));
}
private void AttemptToDownload(string packageId, SemanticVersion version, Uri feedUri, string cacheDirectory, out string downloadedTo, out IPackage downloaded)
{
Log.Info("Downloading NuGet package {0} {1} from feed: '{2}'", packageId, version, feedUri);
Log.VerboseFormat("Downloaded package will be stored in: '{0}'", cacheDirectory);
fileSystem.EnsureDirectoryExists(cacheDirectory);
fileSystem.EnsureDiskHasEnoughFreeSpace(cacheDirectory);
downloaded = null;
downloadedTo = null;
Exception downloadException = null;
for (var i = 1; i <= NumberOfTimesToAttemptToDownloadPackage; i++)
{
try
{
AttemptToFindAndDownloadPackage(i, packageId, version.ToString(), feedUri.ToString(), cacheDirectory,
out downloaded, out downloadedTo);
break;
}
catch (Exception dataException)
{
Log.VerboseFormat("Attempt {0} of {1}: Unable to download package: {2}", i,
NumberOfTimesToAttemptToDownloadPackage, dataException.Message);
downloadException = dataException;
Thread.Sleep(i * 1000);
}
}
if (downloaded == null || downloadedTo == null)
{
if (downloadException != null)
{
Log.ErrorFormat("Unable to download package: {0}", downloadException.Message);
}
throw new Exception(
"The package could not be downloaded from NuGet. If you are getting a package verification error, try switching to a Windows File Share package repository to see if that helps.");
}
if (downloaded.Version != version)
{
throw new Exception(string.Format(
"Octopus requested version {0} of {1}, but the NuGet server returned a package with version {2}",
version, packageId, downloaded.Version));
}
CheckWhetherThePackageHasDependencies(downloaded);
}
public override bool Update(IPackage package)
{
throw new UpdateMethodCalledException("The update method is called");
}
ILayoutDefinition ILayoutDefinition.PartOf(IPackage package)
{
_layout.Package = package;
return(this);
}
public override PackageValidationOutput is_valid(IPackage package)
{
return(!package.ProjectUrl.to_string().is_equal_to(package.ProjectSourceUrl.to_string()) && !string.IsNullOrWhiteSpace(package.ProjectUrl.to_string()));
}
public bool IsPackageInstalled(IPackage package)
{
return(FakePackages.Contains(package));
}
public void UpdatePackageReference(IPackage package, IUpdatePackageSettings settings)
{
throw new NotImplementedException();
}
private PackageOperationEventArgs CreateOperation(IPackage package)
{
return(new PackageOperationEventArgs(package, this.FileSystem, this.PathResolver.GetInstallPath(package)));
}
private void OnPackageProgressUpdate(IPackage package)
{
GetPackageItem(package)?.UpdateProgressSpinner();
}
public bool HasOlderPackageInstalled(IPackage package)
{
return(false);
}
public void UninstallPackage(IPackage package, UninstallPackageAction uninstallAction)
{
PackagePassedToUninstallPackage = package;
ForceRemovePassedToUninstallPackage = uninstallAction.ForceRemove;
RemoveDependenciesPassedToUninstallPackage = uninstallAction.RemoveDependencies;
}
public void GetPackageDoNotShowUnlistedPackagesForUpdates2()
{
// Arrange
var sourceRepository = new MockPackageRepository()
{
PackageUtility.CreatePackage("C", "1.0.0", listed: true),
PackageUtility.CreatePackage("C", "2.0.0", listed: false),
PackageUtility.CreatePackage("C", "2.0.1", listed: true),
PackageUtility.CreatePackage("C", "2.0.3.4-alpha", listed: false),
PackageUtility.CreatePackage("C", "2.0.3.5-alpha", listed: true),
PackageUtility.CreatePackage("C", "2.5.0", listed: false),
};
var repositoryFactory = new Mock <IPackageRepositoryFactory>(MockBehavior.Strict);
repositoryFactory.Setup(r => r.CreateRepository("NuGet Official Source")).Returns(sourceRepository);
var solutionManager = TestUtils.GetSolutionManager();
var localPackages = new IPackage[]
{
PackageUtility.CreatePackage("C", "1.0.0")
};
var localRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict);
localRepository.SetupSet(p => p.PackageSaveMode = PackageSaveModes.Nupkg);
localRepository.Setup(p => p.GetPackages()).Returns(localPackages.AsQueryable()).Verifiable();
var packageManager = new VsPackageManager(
solutionManager,
sourceRepository,
new Mock <IFileSystemProvider>().Object,
new Mock <IFileSystem>().Object,
localRepository.Object,
new Mock <IDeleteOnRestartManager>().Object,
new VsPackageInstallerEvents());
var mockPackageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
mockPackageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager).Verifiable();
var cmdlet = new GetPackageCommand(
repositoryFactory.Object,
GetSourceProvider("NuGet Official Source"),
solutionManager,
mockPackageManagerFactory.Object,
new Mock <IHttpClient>().Object,
new Mock <IProductUpdateService>().Object);
cmdlet.Updates = true;
cmdlet.IncludePrerelease = true;
cmdlet.AllVersions = true;
cmdlet.Source = "NuGet Official Source";
// Act
var packages = cmdlet.GetResults <dynamic>();
// Assert
localRepository.Verify();
Assert.Equal(2, packages.Count());
AssertPackageResultsEqual(packages.ElementAt(0), new { Id = "C", Version = new SemanticVersion("2.0.1") });
AssertPackageResultsEqual(packages.ElementAt(1), new { Id = "C", Version = new SemanticVersion("2.0.3.5-alpha") });
}
protected override void ProcessRecordCore()
{
if (!SolutionManager.IsSolutionOpen)
{
// terminating
ErrorHandler.ThrowSolutionNotOpenTerminatingError();
}
// Locate the package to uninstall
IPackage package = PackageManager.LocatePackageToUninstall(
ProjectManager,
Id,
Version);
#if VS14
var nugetAwareProject = ProjectManager == null ?
null :
ProjectManager.Project as INuGetPackageManager;
if (nugetAwareProject != null)
{
var args = new Dictionary <string, object>();
args["WhatIf"] = WhatIf;
args["SourceRepository"] = PackageManager.SourceRepository;
args["SharedRepository"] = PackageManager.LocalRepository;
using (var cts = new CancellationTokenSource())
{
var task = nugetAwareProject.UninstallPackageAsync(
new NuGetPackageMoniker
{
Id = package.Id,
Version = package.Version.ToString()
},
args,
logger: null,
progress: null,
cancellationToken: cts.Token);
task.Wait();
return;
}
}
#endif
// resolve actions
var resolver = new ActionResolver()
{
Logger = this,
ForceRemove = Force.IsPresent,
RemoveDependencies = RemoveDependencies.IsPresent
};
resolver.AddOperation(
PackageAction.Uninstall,
package,
ProjectManager);
var actions = resolver.ResolveActions();
if (WhatIf)
{
foreach (var operation in actions)
{
Log(MessageLevel.Info, Resources.Log_OperationWhatIf, operation);
}
return;
}
// execute actions
var actionExecutor = new ActionExecutor()
{
Logger = this
};
actionExecutor.Execute(actions);
}
private void AttemptToGetPackageFromCache(string packageId, SemanticVersion version, string feedId, string cacheDirectory, out IPackage downloaded, out string downloadedTo)
{
downloaded = null;
downloadedTo = null;
Log.VerboseFormat("Checking package cache for package {0} {1}", packageId, version.ToString());
var name = GetNameOfPackage(packageId, version.ToString());
fileSystem.EnsureDirectoryExists(cacheDirectory);
var files = fileSystem.EnumerateFilesRecursively(cacheDirectory, name + "*.nupkg");
foreach (var file in files)
{
var package = ReadPackageFile(file);
if (package == null)
{
continue;
}
if (!string.Equals(package.Id, packageId, StringComparison.OrdinalIgnoreCase) || !string.Equals(package.Version.ToString(), version.ToString(), StringComparison.OrdinalIgnoreCase))
{
continue;
}
downloaded = package;
downloadedTo = file;
}
}
void AttemptToFindAndDownloadPackage(int attempt, string packageId, string packageVersion, string feed, string cacheDirectory, out IPackage downloadedPackage, out string path)
{
NuGet.PackageDownloader downloader;
var package = FindPackage(attempt, packageId, packageVersion, feed, out downloader);
var fullPathToDownloadTo = GetFilePathToDownloadPackageTo(cacheDirectory, package);
DownloadPackage(package, fullPathToDownloadTo, downloader);
path = fullPathToDownloadTo;
downloadedPackage = new ZipPackage(fullPathToDownloadTo);
}
public IEnumerable <PackageVerifierIssue> Validate(IPackageRepository packageRepo, IPackage package, IPackageVerifierLogger logger)
{
foreach (IPackageFile currentFile in package.GetFiles())
{
string extension = Path.GetExtension(currentFile.Path);
if (extension.Equals(".dll", StringComparison.OrdinalIgnoreCase) ||
extension.Equals(".exe", StringComparison.OrdinalIgnoreCase))
{
string assemblyPath = Path.ChangeExtension(Path.Combine(Path.GetTempPath(), Path.GetTempFileName()), extension);
var isManagedCode = false;
var isStrongNameSigned = false;
int hresult = 0;
try
{
using (Stream packageFileStream = currentFile.GetStream())
{
var _assemblyBytes = new byte[packageFileStream.Length];
packageFileStream.Read(_assemblyBytes, 0, _assemblyBytes.Length);
using (var fileStream = new FileStream(assemblyPath, FileMode.Create))
{
packageFileStream.Seek(0, SeekOrigin.Begin);
packageFileStream.CopyTo(fileStream);
fileStream.Flush(true);
}
if (AssemblyHelpers.IsAssemblyManaged(assemblyPath))
{
isManagedCode = true;
var clrStrongName = (IClrStrongName)RuntimeEnvironment.GetRuntimeInterfaceAsObject(new Guid("B79B0ACD-F5CD-409b-B5A5-A16244610B92"), new Guid("9FD93CCF-3280-4391-B3A9-96E1CDE77C8D"));
bool verificationForced;
hresult = clrStrongName.StrongNameSignatureVerificationEx(assemblyPath, true, out verificationForced);
if (hresult == 0)
{
isStrongNameSigned = true;
}
}
}
}
catch (Exception ex)
{
logger.LogError("Error while verifying strong name signature for {0}: {1}", currentFile.Path, ex.Message);
}
finally
{
if (File.Exists(assemblyPath))
{
File.Delete(assemblyPath);
}
}
if (isManagedCode && !isStrongNameSigned)
{
yield return(PackageIssueFactory.AssemblyNotStrongNameSigned(currentFile.Path, hresult));
}
}
}
yield break;
}
public IPackage GetUpdate(IPackage package)
{
return(SourceRepository.GetUpdates(new[] { package }, includePrerelease: false).SingleOrDefault());
}
