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));
}
