public PackageKeyDiff(DiffType diffType, PackageKey newPackageKey, PackageKey oldPackageKey, RepositoryType packageType) : base(newPackageKey.PackageId, newPackageKey.Version, newPackageKey.Framework) { DiffType = diffType; OldPackageKey = oldPackageKey; PackageType = packageType; }
public async Task <PackageStatus> Status(PackageKey packageKey) { var response = await innerClient.StatusAsync(new StatusRequest { PackageId = packageKey.ToString(), Target = 0 }); return((PackageStatus)response.Value); }
public async Task ReturnsPersistedStatusesIfValidationAlreadyStarted(ValidationStatus status) { // Arrange _symbolsValidationEntitiesService .Setup(x => x.GetSymbolsServerRequestAsync(It.IsAny <INuGetValidationRequest>())) .ReturnsAsync(new SymbolsServerRequest { Created = DateTime.UtcNow, LastUpdated = DateTime.UtcNow, RequestName = PackageKey.ToString(), RequestStatusKey = ConvertToSymbolsPackageIngestRequestStatus(status), SymbolsKey = PackageKey }); // Act & Assert await _target.StartAsync(_validationRequest.Object); _symbolMessageEnqueuer .Verify(x => x.EnqueueSymbolsIngestionMessageAsync(It.IsAny <INuGetValidationRequest>()), Times.Never); _symbolsValidationEntitiesService .Verify(x => x.AddSymbolsServerRequestAsync(It.IsAny <SymbolsServerRequest>()), Times.Never); _telemetryService.Verify( x => x.TrackSymbolsMessageEnqueued(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>()), Times.Never); }
public PackageMenuItem(UserPackageSelectionStore store, PackageKey key, IWindowsExecutable payload, string name, string version) { _store = store; Key = key; Name = name; Version = version; Payload = payload; _store.Observe() .SubscribeOn(PahkatApp.Current.Dispatcher) .Subscribe(state => { PahkatApp.Current.Dispatcher.InvokeAsync(async() => { var lastActionInfo = _actionInfo; if (state.SelectedPackages.TryGetValue(key, out var value)) { _actionInfo = value; } else { _actionInfo = null; } // Log.Verbose("Updating item state"); _status = await PahkatApp.Current.PackageStore.Status(Key); if (PropertyChanged != null) { PropertyChanged.Invoke(this, new PropertyChangedEventArgs("Status")); PropertyChanged.Invoke(this, new PropertyChangedEventArgs("IsSelected")); } }); }).DisposedBy(_bag); }
public async Task TryUpdateSymbolsServerRequestAsyncReturnsFalseIfRequestNotInDatabase() { // Arrange SymbolsServerRequest request1 = new SymbolsServerRequest() { Created = DateTime.UtcNow, LastUpdated = DateTime.UtcNow, RequestName = PackageKey.ToString(), RequestStatusKey = SymbolsPackageIngestRequestStatus.Ingesting, SymbolsKey = PackageKey }; SymbolsServerRequest request2 = new SymbolsServerRequest() { Created = new DateTime(2018, 4, 5), LastUpdated = DateTime.UtcNow, RequestName = "Some Name", RequestStatusKey = SymbolsPackageIngestRequestStatus.Ingesting, SymbolsKey = PackageKey }; _validationEntitiesContext .Setup(x => x.SymbolsServerRequests) .Returns(DbSetMockFactory.Create(request1)); // Act var result = await _target.TryUpdateSymbolsServerRequestAsync(request2, SymbolsPackageIngestRequestStatus.Ingested); // Assert Assert.False(result); }
/// <summary> /// Get the file extension key associated with a subkey /// </summary> /// /// <param name="KeyId">The id of the subkey</param> /// /// <returns>The keys extension array</returns> public byte[] GetExtensionKey(byte[] KeyId) { try { long keyPos; int index; // get the key data MemoryStream keyStream = GetKeyStream(); // get the keying materials starting offset within the key file keyPos = PackageKey.SubKeyOffset(keyStream, KeyId); if (keyPos == -1) { throw new CryptoProcessingException("PackageFactory:GetExtensionKey", "This package does not contain the key file!", new ArgumentException()); } // get the index index = PackageKey.IndexFromId(keyStream, KeyId); // key flagged PostOverwrite was used for decryption and was erased if (PackageKey.KeyHasPolicy(m_keyPackage.SubKeyPolicy[index], (long)PackageKeyStates.Erased)) { throw new CryptoProcessingException("PackageFactory:GetExtensionKey", "SubKey is erased. The subkey has a post erase policy and was previously used to decrypt the file.", new Exception()); } // get the keying material KeyParams keyParam = GetKeySet(keyStream, m_keyPackage.Description, keyPos); return(keyParam.ExtKey); } catch { throw; } }
private void SetCurrentItem(PackageKey packageKey) { var app = (PahkatApp)Application.Current; if (!app.CurrentTransaction.Value.IsT1) { return; } var x = app.CurrentTransaction.Value.AsT1; var actions = x.Actions; var position = Array.FindIndex( actions, x => x.Action.PackageKey.Equals(packageKey)); PrgBar.Maximum = actions.Length; PrgBar.Value = position; PrgBar.IsIndeterminate = false; var action = actions[position]; var fmtString = action.Action.Action == InstallAction.Install ? Strings.InstallingPackage : Strings.UninstallingPackage; LblPrimary.Text = string.Format(fmtString, action.NativeName(), action.Version); SetRemaining(); }
private async Task <object> Status(JArray args) { var app = (PahkatApp)Application.Current; var keys = new List <PackageKey>(); foreach (var arg in args) { var rawKey = arg.ToObject <string>(); if (rawKey != null) { try { keys.Add(PackageKey.From(rawKey)); } catch { } } } var map = new JObject(); var pahkat = app.PackageStore; foreach (var packageKey in keys) { var status = await pahkat.Status(packageKey); var obj = new JObject(); obj["status"] = (int)status; obj["target"] = "system"; map[packageKey.ToString()] = obj; } return(map); }
/// <summary> /// For use only when decrypting a volume member. /// <para>Resets the Expired flag; useage must guarantee that the same key-to-file matching is used when re-encrypting the file.</para> /// </summary> /// /// <param name="KeyId">The unique subkey id</param> public void ResetSubKeyFlag(byte[] KeyId) { if (AccessScope.Equals(KeyScope.NoAccess)) { throw new CryptoProcessingException("PackageFactory:Extract", "You do not have permission to access this key!", new UnauthorizedAccessException()); } try { long keyPos; int index; // get the key data MemoryStream keyStream = GetKeyStream(); // get the keying materials starting offset within the key file keyPos = PackageKey.SubKeyOffset(keyStream, KeyId); if (keyPos == -1) { throw new CryptoProcessingException("PackageFactory:Extract", "This package does not contain the key file!", new ArgumentException()); } // get the index index = PackageKey.IndexFromId(keyStream, KeyId); PackageKey.SubKeyClearPolicy(keyStream, index, (long)PackageKeyStates.Expired); // write to file WriteKeyStream(keyStream); } catch { throw; } }
public void Uninstall(PackageKey pck) { if (InstalledPackages.Contains(pck)) { InstalledPackages.Remove(pck); } }
public static string GetRelatedSearchFileName(this PackageKey key) { return(string.Format(PackageFileNamePattern, key.PackageId, ToPunditVersion(key.Version, true), key.Framework)); }
public static string GetNoFrameworkFileName(this PackageKey key) { return(string.Format(PackageFileNamePattern, key.PackageId, ToPunditVersion(key.Version, false), "*")); }
public async Task TryUpdateSymbolsServerRequestAsyncUpdateRequestIfInDatabase() { // Arrange SymbolsServerRequest request = new SymbolsServerRequest() { Created = new DateTime(2000, 4, 5), LastUpdated = new DateTime(2000, 4, 5), RequestName = PackageKey.ToString(), RequestStatusKey = SymbolsPackageIngestRequestStatus.Ingesting, SymbolsKey = PackageKey }; _validationEntitiesContext .Setup(x => x.SymbolsServerRequests) .Returns(DbSetMockFactory.Create(request)); _validationEntitiesContext .Setup(x => x.SaveChangesAsync()) .ReturnsAsync(7); // Act var result = await _target.TryUpdateSymbolsServerRequestAsync(request, SymbolsPackageIngestRequestStatus.Ingested); // Assert Assert.True(result); Assert.Equal(DateTime.UtcNow.Year, request.LastUpdated.Year); }
public async Task TryAddReturnsAnExistentRequestIfAlreadyExistsInDatabase() { // Arrange SymbolsServerRequest request1 = new SymbolsServerRequest() { Created = DateTime.UtcNow, LastUpdated = DateTime.UtcNow, RequestName = PackageKey.ToString(), RequestStatusKey = SymbolsPackageIngestRequestStatus.Ingested, SymbolsKey = PackageKey }; SymbolsServerRequest request2 = new SymbolsServerRequest() { Created = new DateTime(2018, 4, 5), LastUpdated = DateTime.UtcNow, RequestName = PackageKey.ToString(), RequestStatusKey = SymbolsPackageIngestRequestStatus.Ingested, SymbolsKey = PackageKey }; _validationEntitiesContext .Setup(x => x.SymbolsServerRequests) .Returns(DbSetMockFactory.Create(request1)); // Act var result = await _target.AddSymbolsServerRequestAsync(request2); // Assert Assert.Equal(request1.Created, result.Created); }
public PackageDto(IPackage package) { Key = new PackageKey(package.Id, package.Version.ToString()); IsReleaseVersion = package.IsReleaseVersion(); Dependencies = GetPackageDependencyDtos(package); SemanticVersion = package.Version; }
public ActionResult DeleteConfirmed(int id) { PackageKey packageKey = db.PackageKeys.Find(id); db.PackageKeys.Remove(packageKey); db.SaveChanges(); return(RedirectToAction("Index")); }
private static async Task <PackageStatus> InstallStatus(PackageKey packageKey) { // var app = (PahkatApp) Application.Current; // using var x = ((PahkatApp) Application.Current).PackageStore.Lock(); // var what = 32; Log.Verbose("install status"); return(await PahkatApp.Current.PackageStore.Status(packageKey)); }
public PackageControlModel(PackageKey packageKey, IEnumerable <PackageKey> availableVersions) { Name = packageKey.Id; Version = packageKey.Version; AvailableVersions = availableVersions.Select(x => x.Version) .ToList(); FixVersionIndex = string.IsNullOrEmpty(Version) ? -1 : AvailableVersions.IndexOf(Version); }
public bool PackageExist(PackageKey package) { var findLocalPackagesResource = _sourceRepository.GetResource <PackageMetadataResource>(); var packageIdentity = new NuGet.Packaging.Core.PackageIdentity(package.PackageId, package.Version); return(findLocalPackagesResource.GetMetadataAsync(packageIdentity, NullSourceCacheContext.Instance, NullLogger.Instance, CancellationToken.None).Result != null); }
public void AddVersion(IList <PackageKey> existing, PackageKey packageKey) { _versions.Add(packageKey); var composed = _versionSpecRangeBuilder.ComposeFrom(existing, _versions) .Select(x => x.ToString()); Text = _packageId + " " + string.Join(", ", composed); }
public InProgress IntoInstall(PackageKey packageKey) { State = new TransactionProcessState.InstallState() { CurrentItem = packageKey, }; return(this); }
/// <remarks> /// Returns the PackageKey structure /// </remarks> public PackageKey GetPackage() { MemoryStream keyStream = GetKeyStream(); PackageKey package = new PackageKey(keyStream); keyStream.Dispose(); return(package); }
public PackageAction( PackageKey packageKey, InstallAction instAction, InstallTarget instTarget = InstallTarget.System ) { PackageKey = packageKey; Action = instAction; Target = instTarget; }
public void GetPackageKeyFromFileNameTest() { string name = "Pundit.Core-1.0.0-4-noarch.pundit"; PackageKey key = PackageUtils.GetPackageKeyFromFileName(name); Assert.AreEqual("Pundit.Core", key.PackageId); Assert.AreEqual(new Version(1, 0, 0, 4), key.Version); Assert.AreEqual("noarch", key.Platform); }
public void Install(PackageKey pck) { PackageKey installedPackage = InstalledPackages.FirstOrDefault(k => k.LooseEquals(pck)); if (installedPackage != null) { InstalledPackages.Remove(installedPackage); } InstalledPackages.Add(pck); }
public async Task StartsValidationIfNotStarted() { // Arrange // The order of operations is important! The state MUST be persisted AFTER verification has been queued. var statePersisted = false; bool verificationQueuedBeforeStatePersisted = false; var ingestingRequest = new SymbolsServerRequest { Created = DateTime.UtcNow, LastUpdated = DateTime.UtcNow, RequestName = PackageKey.ToString(), RequestStatusKey = SymbolsPackageIngestRequestStatus.Ingesting, SymbolsKey = PackageKey }; var symbolsIngesterMessage = new SymbolsIngesterMessage(ValidationId, PackageKey, PackageId, PackageVersion, SnupkgUrl, "DummyRequestName"); _symbolsValidationEntitiesService .Setup(x => x.GetSymbolsServerRequestAsync(It.IsAny <INuGetValidationRequest>())) .ReturnsAsync((SymbolsServerRequest)null); _symbolMessageEnqueuer .Setup(x => x.EnqueueSymbolsIngestionMessageAsync(It.IsAny <INuGetValidationRequest>())) .Callback(() => { verificationQueuedBeforeStatePersisted = !statePersisted; }) .Returns(Task.FromResult(symbolsIngesterMessage)); _symbolsValidationEntitiesService .Setup(x => x.AddSymbolsServerRequestAsync(It.IsAny <SymbolsServerRequest>())) .Callback(() => { statePersisted = true; }) .ReturnsAsync(ingestingRequest); // Act await _target.StartAsync(_validationRequest.Object); // Assert _symbolMessageEnqueuer .Verify(x => x.EnqueueSymbolsIngestionMessageAsync(It.IsAny <INuGetValidationRequest>()), Times.Once); _symbolsValidationEntitiesService .Verify( x => x.AddSymbolsServerRequestAsync(It.IsAny <SymbolsServerRequest>()), Times.Once); _telemetryService.Verify( x => x.TrackSymbolsMessageEnqueued(_validationRequest.Object.PackageId, _validationRequest.Object.PackageVersion, ValidatorName.SymbolsIngester, _validationRequest.Object.ValidationId), Times.Once); Assert.True(verificationQueuedBeforeStatePersisted); }
public static Task <bool> IsValidAction(this PackageKey package, PackageAction action) { switch (action.Action) { case 0: return(IsInstallable(package)); default: return(IsUninstallable(package)); } }
public Stream Download(PackageKey key) { var fullPath = Path.Combine(RootPath, key.GetFileName()); if (!File.Exists(fullPath)) { throw new FileNotFoundException("package not found"); } return(File.OpenRead(fullPath)); }
public ActionResult Edit([Bind(Include = "Id,PackageId,Name,IsOk")] PackageKey packageKey) { if (ModelState.IsValid) { db.Entry(packageKey).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } ViewBag.PackageId = new SelectList(db.Packages, "Id", "Name", packageKey.PackageId); return(View(packageKey)); }
private RepoTreeItem FilterByTagPrefix(ILoadedRepository repo, string prefix, Func <string, string> convertor) { // var nodes = new ObservableCollection<PackageCategoryTreeItem>(); var map = new Dictionary <string, List <PackageMenuItem> >(); foreach (var package in repo.Packages.Packages) { if (package.Value == null) { continue; } IDescriptor descriptor = package.Value !; var pkgKey = PackageKey.Create(repo.Index.Url, descriptor.Id); var release = repo.Release(pkgKey); var payload = release?.WindowsExecutable(); if (release == null || payload == null) { continue; } var tags = Iter.ToArray(descriptor.Tags.Where(x => x.StartsWith(prefix))); if (tags.IsNullOrEmpty()) { tags = new[] { prefix }; } foreach (var tag in tags) { if (!map.ContainsKey(tag)) { map[tag] = new List <PackageMenuItem>(); } map[tag].Add(new PackageMenuItem(_store, pkgKey, payload, descriptor.NativeName() ?? "<>", release.Version)); } } var categoriesSet = new SortedSet <PackageCategoryTreeItem>(map.OrderBy(x => x.Key).Map(x => { x.Value.Sort(); var items = new ObservableCollection <PackageMenuItem>(x.Value); return(new PackageCategoryTreeItem(_store, convertor(x.Key), items)); })); var categories = new ObservableCollection <PackageCategoryTreeItem>(categoriesSet); return(new RepoTreeItem(repo.Index.NativeName(), categories)); }