Changeset 2509 for trunk/eraser/Eraser/Program.cs

Timestamp:

3/14/2012 5:45:46 AM (14 months ago)

Author:

lowjoel

Message:

Redesign the Eraser Plugin framework.

• Split the plugin-dependent interfaces and related support classes out to Eraser.Plugins assembly
  • The extension interfaces are in the Eraser.Plugins.ExtensionPoints? namespace.
    • New IClientTool interface for plugins to create Eraser-hosted tools (e.g. #147)
  • The Registrars are in the Eraser.Plugins.Registrars namespace
  • Base types are now interfaces, no longer abstract base classes
  • Version the Eraser.plugins assembly differently from the rest of the project so that other plugins can target different versions of Eraser with the same assembly. Change the Eraser.Plugins assembly version only if there is an API change.
• Plugin loading behaviour:
  • Core plugins will be loaded before the rest of the plugins, but they will be loaded only by assembly name and not by path
  • Non-core plugin loading is handled by the Manager Library and not the Plugin code
  • The PluginInstance? class is now the PluginInfo? class
  • There is no longer a need to indicate the default file and unused space erasure methods, PRNGs etc; they are now hardcoded to prevent plugins from changing defaults.
• The separate command line for the Eraser shell extension has been removed.
  • The Erase on Restart menu item has been removed (since it is a scheduling option and should be set in the Task Properties Dialog)
• Task Progress information is now pulled from the Eraser core instead of pushed via events.
• New persistent store class to generalise the use of the old Settings class
• IDragAndDropConfigurerFactory for transforming drag-and-drop operations to erasure targets. This removes the Eraser.exe assembly's dependency on Eraser.DefaultPlugins?.

Closes #363.

Location:

trunk/eraser

Files:

• . (modified) (1 prop)
• Eraser/Program.cs (modified) (16 diffs)

trunk/eraser/Eraser/Program.cs

@@ -31 +31 @@
 using System.Security.Principal;
 using System.Text.RegularExpressions;
+using System.Text;
 
 using System.Reflection;
@@ -39 +40 @@
 using Eraser.Manager;
 using Eraser.Util;
-using Eraser.DefaultPlugins;
-using System.Text;
+using Eraser.Plugins;
+using Eraser.Plugins.ExtensionPoints;
+using Eraser.Plugins.Registrars;
 
 namespace Eraser
@@ -133 +135 @@
         }
 
-        class AddTaskArguments : EraseArguments
+        class TaskArguments : EraseArguments
         {
             /// <summary>
             /// Constructor.
             /// </summary>
-            public AddTaskArguments()
-            {
-            }
-
-            /// <summary>
-            /// Constructs Add Task arguments from Erase arguments.
+            public TaskArguments()
+            {
+            }
+
+            /// <summary>
+            /// Constructs Task arguments from Erase arguments.
             /// </summary>
             /// <param name="arguments">The <see cref="EraseArguments"/> to use as a template
             /// for this instance.</param>
-            internal AddTaskArguments(EraseArguments arguments)
+            internal TaskArguments(EraseArguments arguments)
                 : base(arguments)
             {
@@ -159 +161 @@
         }
 
-        class ShellArguments : ConsoleArguments
-        {
-            /// <summary>
-            /// The action which the shell extension has requested.
-            /// </summary>
-            [Arg("action", "The action selected by the user", typeof(string), true, null, null)]
-            public ShellActions ShellAction { get; set; }
-
-            /// <summary>
-            /// Whether the recycle bin was specified on the command line.
-            /// </summary>
-            [Arg("recycleBin", "The recycle bin as an erasure target", typeof(string), false, null, null)]
-            public bool RecycleBin { get; set; }
-
-            /// <summary>
-            /// The destination for secure move operations, only valid when
-            /// <see cref="ShellAction"/> is <see cref="ShellActions.SecureMove"/>
-            /// </summary>
-            [Arg("destination", "The destination for secure move operations", typeof(string), false, null, null)]
-            public string Destination { get; set; }
-
+        class ShellArguments : TaskArguments
+        {
             /// <summary>
             /// The parent HWND which can be used as a parent to display dialogs.
@@ -185 +168 @@
             [Arg("parent", "The parent HWND which can be used as a parent to display dialogues", typeof(string), false, null, null)]
             public string Parent { get; set; }
+
+            /// <summary>
+            /// Whether we should display a confirmation dialog.
+            /// </summary>
+            [Arg("confirm", "Whether a confirmation dialog should be shown", typeof(bool), false, true, null)]
+            public bool Confirm { get; set; }
         }
 
@@ -242 +231 @@
 
             //Load the Eraser.Manager library
-            using (ManagerLibrary library = new ManagerLibrary(new Settings()))
+            using (ManagerLibrary library = new ManagerLibrary(Settings.Get()))
             {
                 //Set our UI language
@@ -331 +320 @@
                         new ConsoleActionData(CommandErase, new EraseArguments())); 
                     program.Handlers.Add("addtask",
-                        new ConsoleActionData(CommandAddTask, new AddTaskArguments()));
+                        new ConsoleActionData(CommandAddTask, new TaskArguments()));
                     program.Handlers.Add("importtasklist",
                         new ConsoleActionData(CommandImportTaskList, new ConsoleArguments()));
@@ -362 +351 @@
             //Get the command-line help for every erasure target
             StringBuilder targets = new StringBuilder();
-            foreach (ErasureTarget target in ManagerLibrary.Instance.ErasureTargetRegistrar)
+            foreach (IErasureTarget target in Host.Instance.ErasureTargetFactories)
             {
                 //Replace all \r\n with \n, and split into lines
@@ -379 +368 @@
 
             //Generate the list of erasure methods.
-            foreach (ErasureMethod method in ManagerLibrary.Instance.ErasureMethodRegistrar)
-            {
-                methods.AppendFormat(methodFormat, (method is UnusedSpaceErasureMethod) ?
+            foreach (IErasureMethod method in Host.Instance.ErasureTargetFactories)
+            {
+                methods.AppendFormat(methodFormat, (method is IUnusedSpaceErasureMethod) ?
                     "U" : "", method.Name, method.Guid);
             }
@@ -460 +449 @@
         private static void CommandErase(ConsoleArguments arg)
         {
-            AddTaskArguments arguments = new AddTaskArguments((EraseArguments)arg);
+            TaskArguments arguments = new TaskArguments((EraseArguments)arg);
             arguments.Schedule = "NOW";
 
@@ -473 +462 @@
         private static void CommandAddTask(ConsoleArguments arg)
         {
-            AddTaskArguments arguments = (AddTaskArguments)arg;
-
+            TaskArguments arguments = (TaskArguments)arg;
+            Task task = TaskFromCommandLine(arguments);
+
+            //Send the task out.
+            using (eraserClient = CommandConnect())
+                eraserClient.Tasks.Add(task);
+        }
+
+        /// <summary>
+        /// Parses the command line for erasure targets and returns them as
+        /// a Task object.
+        /// </summary>
+        /// <param name="arguments">The arguments specified on the command line.</param>
+        /// <returns>The task represented on the command line.</returns>
+        private static Task TaskFromCommandLine(TaskArguments arguments)
+        {
             //Create the task
             Task task = new Task();
 
             //Get the erasure method the user wants to use
-            ErasureMethod method = string.IsNullOrEmpty(arguments.ErasureMethod) ?
+            IErasureMethod method = string.IsNullOrEmpty(arguments.ErasureMethod) ?
                 ErasureMethodRegistrar.Default :
                 ErasureMethodFromNameOrGuid(arguments.ErasureMethod);
@@ -504 +507 @@
             foreach (string argument in arguments.PositionalArguments)
             {
-                ErasureTarget selectedTarget = null;
+                IErasureTarget selectedTarget = null;
 
                 //Iterate over every defined erasure target
-                foreach (ErasureTarget target in ManagerLibrary.Instance.ErasureTargetRegistrar)
+                foreach (IErasureTarget target in Host.Instance.ErasureTargetFactories)
                 {
                     //See if this argument can be handled by the target's configurer
@@ -545 +548 @@
                 throw new ArgumentException(S._("Tasks must contain at least one erasure target."));
 
-            //Send the task out.
-            using (eraserClient = CommandConnect())
-                eraserClient.Tasks.Add(task);
-        }
-
-        private static ErasureMethod ErasureMethodFromNameOrGuid(string param)
+            return task;
+        }
+
+        private static IErasureMethod ErasureMethodFromNameOrGuid(string param)
         {
             try
             {
-                return ManagerLibrary.Instance.ErasureMethodRegistrar[new Guid(param)];
+                return Host.Instance.ErasureMethods[new Guid(param)];
             }
             catch (FormatException)
@@ -560 +561 @@
                 //Invalid GUID. Check every registered erasure method for the name
                 string upperParam = param.ToUpperInvariant();
-                ErasureMethod result = null;
-                foreach (ErasureMethod method in ManagerLibrary.Instance.ErasureMethodRegistrar)
+                IErasureMethod result = null;
+                foreach (IErasureMethod method in Host.Instance.ErasureMethods)
                 {
                     if (method.Name.ToUpperInvariant() == upperParam)
@@ -595 +596 @@
         private static void CommandShell(ConsoleArguments args)
         {
-            switch (((ShellArguments)args).ShellAction)
-            {
-                case ShellActions.SecureMove:
-                    CommandShellSecureMove((ShellArguments)args);
-                    break;
-
-                default:
-                    CommandShellErase((ShellArguments)args);
-                    break;
-            }
-        }
-
-        /// <summary>
-        /// Handles the erasure of files from the Shell extension.
-        /// </summary>
-        /// <param name="args">The command line parameters passed to the program.</param>
-        private static void CommandShellErase(ShellArguments args)
-        {
-            //Construct a draft task.
-            Task task = new Task();
-            switch (args.ShellAction)
-            {
-                case ShellActions.EraseOnRestart:
-                    task.Schedule = Schedule.RunOnRestart;
-                    goto case ShellActions.EraseNow;
-
-                case ShellActions.EraseNow:
-                    foreach (string path in args.PositionalArguments)
-                    {
-                        //If the path doesn't exist, skip the file
-                        if (!(File.Exists(path) || Directory.Exists(path)))
-                            continue;
-
-                        FileSystemObjectErasureTarget target = null;
-                        if ((File.GetAttributes(path) & FileAttributes.Directory) != 0)
-                        {
-                            target = new FolderErasureTarget();
-                            target.Path = path;
-                        }
-                        else
-                        {
-                            target = new FileErasureTarget();
-                            target.Path = path;
-                        }
-
-                        task.Targets.Add(target);
-                    }
-
-                    //Was the recycle bin specified?
-                    if (args.RecycleBin)
-                        task.Targets.Add(new RecycleBinErasureTarget());
-                    break;
-
-                case ShellActions.EraseUnusedSpace:
-                    foreach (string path in args.PositionalArguments)
-                    {
-                        UnusedSpaceErasureTarget target = new UnusedSpaceErasureTarget();
-                        target.Drive = path;
-                        task.Targets.Add(target);
-                    }
-                    break;
-            }
+            ShellArguments arguments = (ShellArguments)args;
+            Task task = TaskFromCommandLine(arguments);
 
             //Do we have a parent dialog?
             IWin32Window parent = null;
-            if (args.Parent != null)
+            if (arguments.Parent != null)
             {
                 parent = new Win32Window((IntPtr)(ulong)
-                    Convert.ChangeType(args.Parent, typeof(ulong)));
+                    Convert.ChangeType(arguments.Parent, typeof(ulong)));
             }
 
             //Confirm that the user wants the erase.
-            Application.EnableVisualStyles();
-            using (Form dialog = new ShellConfirmationDialog(task))
-            {
-                if (dialog.ShowDialog(parent) != DialogResult.Yes)
-                    return;
-            }
-
-            //Then queue for erasure.
-            using (eraserClient = CommandConnect())
-                eraserClient.Tasks.Add(task);
-        }
-
-        /// <summary>
-        /// Handles the movement of files from the Shell extension.
-        /// </summary>
-        /// <param name="args">The command line parameters passed to the program.</param>
-        private static void CommandShellSecureMove(ShellArguments args)
-        {
-            //Construct a draft task.
-            Task task = new Task();
-            foreach (string path in args.PositionalArguments)
-            {
-                SecureMoveErasureTarget target = new SecureMoveErasureTarget();
-                target.Path = path;
-                target.Destination = args.Destination;
-
-                task.Targets.Add(target);
+            if (arguments.Confirm)
+            {
+                Application.EnableVisualStyles();
+                using (Form dialog = new ShellConfirmationDialog(task))
+                {
+                    if (dialog.ShowDialog(parent) != DialogResult.Yes)
+                        return;
+                }
             }
 
@@ -852 +774 @@
         /// </summary>
         public const string SettingsPath = @"SOFTWARE\Eraser\Eraser 6";
+
+        public static IEnumerable<IErasureTarget> ErasureTargetRegistrar { get; set; }
     }