public override ExitCode Execute()
{
try
{
switch (AdditionalArgs.Count)
{
case 1:
// Verify a directory inside the store
ImplementationStore.Verify(new ManifestDigest(AdditionalArgs[0]), Handler);
break;
case 2:
// Verify an arbitrary directory
ImplementationStoreUtils.Verify(AdditionalArgs[0], new ManifestDigest(AdditionalArgs[1]), Handler);
break;
}
}
catch (DigestMismatchException ex)
{
Handler.Output(Resources.VerifyImplementation, ex.LongMessage);
return(ExitCode.DigestMismatch);
}
return(ExitCode.OK);
}
public override ExitCode Execute()
{
var manifestDigest = new ManifestDigest(AdditionalArgs[0]);
string path = AdditionalArgs[1];
try
{
if (File.Exists(path))
{ // One or more archives (combined/overlay)
ImplementationStore.Add(manifestDigest, BuildImplementation);
return(ExitCode.OK);
}
else if (Directory.Exists(path))
{ // A single directory
if (AdditionalArgs.Count > 2)
{
throw new OptionException(Resources.TooManyArguments + Environment.NewLine + AdditionalArgs.Skip(2).JoinEscapeArguments(), null);
}
ImplementationStore.Add(manifestDigest, builder => Handler.RunTask(new ReadDirectory(Path.GetFullPath(path), builder)));
return(ExitCode.OK);
}
else
{
throw new FileNotFoundException(string.Format(Resources.FileOrDirNotFound, path), path);
}
}
catch (ImplementationAlreadyInStoreException ex)
{
Log.Warn(ex);
return(ExitCode.NoChanges);
}
}
public override ExitCode Execute()
{
var manifestDigest = new ManifestDigest(AdditionalArgs[0]);
try
{
string path = AdditionalArgs[1];
if (Directory.Exists(path))
{
if (AdditionalArgs.Count > 2)
{
throw new OptionException(Resources.TooManyArguments + Environment.NewLine + AdditionalArgs.Skip(2).JoinEscapeArguments(), null);
}
ImplementationStore.Add(manifestDigest, builder => Handler.RunTask(new ReadDirectory(Path.GetFullPath(path), builder)));
return(ExitCode.OK);
}
ImplementationStore.Add(manifestDigest, BuildImplementation);
return(ExitCode.OK);
}
catch (ImplementationAlreadyInStoreException ex)
{
Log.Warn(ex.Message, ex);
return(ExitCode.NoChanges);
}
}
public override ExitCode Execute()
{
bool removed = false;
foreach (var digest in AdditionalArgs.Select(x => new ManifestDigest(x)))
{
removed |= ImplementationStore.Remove(digest, Handler);
}
return(removed ? ExitCode.OK : ExitCode.NoChanges);
}
private void CleanImplementations(IEnumerable <ImplementationSelection> implementations)
{
var digestsToKeep = implementations.Select(x => x.ManifestDigest);
var digestsToRemove = ImplementationStore.ListAll().Except(digestsToKeep, ManifestDigestPartialEqualityComparer.Instance);
Handler.RunTask(ForEachTask.Create(
name: Resources.RemovingOutdated,
target: digestsToRemove.ToList(),
work: digest => ImplementationStore.Remove(digest, Handler)));
}
public override ExitCode Execute()
{
foreach (var digest in AdditionalArgs.Select(x => new ManifestDigest(x)))
{
if (!ImplementationStore.Remove(digest, Handler))
{
throw new ImplementationNotFoundException(digest);
}
}
return(ExitCode.OK);
}
/// <summary>
/// Deletes this implementation from the <see cref="IImplementationStore"/> it is located in.
/// </summary>
/// <param name="handler">A callback object used when the the user needs to be asked questions or informed about IO tasks.</param>
/// <exception cref="KeyNotFoundException">No matching implementation could be found in the <see cref="IImplementationStore"/>.</exception>
/// <exception cref="IOException">The implementation could not be deleted.</exception>
/// <exception cref="UnauthorizedAccessException">Write access to the store is not permitted.</exception>
public override void Delete(ITaskHandler handler)
{
try
{
ImplementationStore.Remove(_digest, handler);
}
#region Error handling
catch (ImplementationNotFoundException ex)
{
throw new KeyNotFoundException(ex.Message, ex);
}
#endregion
}
public override ExitCode Execute()
{
var digest = new ManifestDigest(AdditionalArgs[0]);
string?path = ImplementationStore.GetPath(digest);
if (path == null)
{
throw new ImplementationNotFoundException(digest);
}
Handler.Output(string.Format(Resources.LocalPathOf, AdditionalArgs[0]), path);
return(ExitCode.OK);
}
/// <summary>
/// Deletes this implementation from the <see cref="IImplementationStore"/> it is located in.
/// </summary>
/// <param name="handler">A callback object used when the the user needs to be asked questions or informed about IO tasks.</param>
/// <exception cref="KeyNotFoundException">No matching implementation could be found in the <see cref="IImplementationStore"/>.</exception>
/// <exception cref="IOException">The implementation could not be deleted.</exception>
/// <exception cref="UnauthorizedAccessException">Write access to the store is not permitted.</exception>
public override void Delete(ITaskHandler handler)
{
try
{
handler.RunTask(new SimpleTask(
string.Format(Resources.DeletingImplementation, _digest),
() => ImplementationStore.Remove(_digest, handler)));
}
#region Error handling
catch (ImplementationNotFoundException ex)
{
throw new KeyNotFoundException(ex.Message, ex);
}
#endregion
}
public override ExitCode Execute()
{
string outputArchive = AdditionalArgs[1];
string mimeType = (AdditionalArgs.Count == 3) ? AdditionalArgs[3] : Archive.GuessMimeType(outputArchive);
var digest = new ManifestDigest(AdditionalArgs[0]);
string?sourceDirectory = ImplementationStore.GetPath(digest);
if (sourceDirectory == null)
{
throw new ImplementationNotFoundException(digest);
}
using var builder = ArchiveBuilder.Create(outputArchive, mimeType);
Handler.RunTask(new ReadDirectory(sourceDirectory, builder));
return(ExitCode.OK);
}
public override ExitCode Execute()
{
if (ZeroInstallInstance.IsRunningFromCache)
{
Log.Error("This instance of Zero Install is running from a cache. There is nothing to uninstall.");
return(ExitCode.NoChanges);
}
if (MachineWide && !WindowsUtils.IsAdministrator)
{
throw new NotAdminException(Resources.MustBeAdminForMachineWide);
}
if (!Handler.Ask(Resources.AskRemoveZeroInstall, defaultAnswer: true))
{
return(ExitCode.UserCanceled);
}
if (ExistingDesktopIntegration(MachineWide) || ExistingDesktopIntegration(machineWide: false))
{
new RemoveAllApps(Handler)
{
MachineWide = MachineWide
}.Execute();
}
if (Handler.Ask(Resources.ConfirmPurge, defaultAnswer: false))
{
ImplementationStore.Purge(Handler);
}
if (WindowsUtils.IsWindows)
{
DelegateToTempCopy();
}
else
{
PerformRemove();
}
return(ExitCode.OK);
}
public override ExitCode Execute()
{
string path = GetPath();
// Init new store to ensure the target is suitable
ImplementationStore = new ImplementationStore(path);
var dirs = GetImplementationDirs().ToList();
if (dirs.AddIfNew(path))
{
SetImplementationDirs(dirs);
return(ExitCode.OK);
}
else
{
Log.Warn(string.Format(Resources.AlreadyInImplDirs, path));
return(ExitCode.NoChanges);
}
}
private void CleanImplementations(IEnumerable <ImplementationSelection> implementations)
{
var digestsToKeep = implementations.Select(x => x.ManifestDigest);
var digestsToRemove = ImplementationStore.ListAll().Except(digestsToKeep, ManifestDigestPartialEqualityComparer.Instance);
Handler.RunTask(ForEachTask.Create(
name: Resources.RemovingOutdated,
target: digestsToRemove.ToList(),
work: digest =>
{
try
{
ImplementationStore.Remove(digest, Handler);
}
catch (NotAdminException ex) when(ZeroInstallInstance.IsLibraryMode)
{
Log.Info($"Unable to remove {digest}", ex);
}
}
));
}
public override ExitCode Execute()
{
var manifestDigest = new ManifestDigest(AdditionalArgs[0]);
string outputArchive = AdditionalArgs[1];
Debug.Assert(outputArchive != null);
string?sourceDirectory = ImplementationStore.GetPath(manifestDigest);
if (sourceDirectory == null)
{
throw new ImplementationNotFoundException(manifestDigest);
}
string mimeType = (AdditionalArgs.Count == 3) ? AdditionalArgs[3] : Archive.GuessMimeType(outputArchive);
using var generator = ArchiveGenerator.Create(sourceDirectory, outputArchive, mimeType);
Handler.RunTask(generator);
return(ExitCode.OK);
}
private void Clean(IEnumerable <ManifestDigest> digestsToKeep)
{
var toDelete = ImplementationStore.ListAll().Except(digestsToKeep, ManifestDigestPartialEqualityComparer.Instance).ToList();
Handler.RunTask(ForEachTask.Create(Resources.RemovingOutdated, toDelete, x => ImplementationStore.Remove(x, Handler)));
}
public ImplementationStoreTest()
{
_handler = new MockTaskHandler();
_tempDir = new TemporaryDirectory("0install-test-store");
_store = new ImplementationStore(_tempDir);
}
/// <summary> /// Verify this implementation is undamaged. /// </summary> /// <param name="handler">A callback object used when the the user needs to be asked questions or informed about IO tasks.</param> /// <exception cref="OperationCanceledException">The user canceled the task.</exception> /// <exception cref="IOException">The entry's directory could not be processed.</exception> /// <exception cref="UnauthorizedAccessException">Read access to the entry's directory is not permitted.</exception> public void Verify(ITaskHandler handler) => ImplementationStore.Verify(_digest, handler);
