示例#1
0
        private static void StartStrategy()
        {
            var             extractorOptions = ReadOptions();
            var             target           = extractorOptions?.Target;
            var             targetPath       = extractorOptions?.TargetPath;
            ITargetStrategy targetStrategy;

            if (target.EqualTo("Folder"))
            {
                targetStrategy = new FolderTarget(targetPath);
            }
            else if (target.EqualTo("Solution"))
            {
                targetStrategy = new SolutionTarget(targetPath);
            }
            else if (target.EqualTo("Project"))
            {
                targetStrategy = new ProjectTarget(targetPath);
            }
            else
            {
                Warning($"Unknown target '{target}'");
                return;
            }

            var outputStrategy = new SingleFolder(extractorOptions?.OutputFolder, targetStrategy);

            outputStrategy.Process();
        }
示例#2
0
 protected override bool ResolveParameter(string param)
 {
     int equalPos = param.IndexOf('=');
     if (IsParam(param, "method", "m"))
     {
      if (equalPos == -1)
       throw new ArgumentException("--method must be specified with an Erasure " +
        "method GUID.");
      List<KeyValuePair<string, string> > subParams =
       GetSubParameters(param.Substring(equalPos + 1));
      ErasureMethod = new Guid(subParams[0].Key);
     }
     else if (IsParam(param, "schedule", "s"))
     {
      if (equalPos == -1)
       throw new ArgumentException("--schedule must be specified with a Schedule " +
        "type.");
      List<KeyValuePair<string, string> > subParams =
       GetSubParameters(param.Substring(equalPos + 1));
      switch (subParams[0].Key)
      {
       case "now":
        Schedule = Schedule.RunNow;
        break;
       case "manually":
        Schedule = Schedule.RunManually;
        break;
       case "restart":
        Schedule = Schedule.RunOnRestart;
        break;
       default:
        throw new ArgumentException("Unknown schedule type: " + subParams[0].Key);
      }
     }
     else if (IsParam(param, "recycled", "r"))
     {
      Targets.Add(new RecycleBinTarget());
     }
     else if (IsParam(param, "unused", "u"))
     {
      if (equalPos == -1)
       throw new ArgumentException("--unused must be specified with the Volume " +
        "to erase.");
      UnusedSpaceTarget target = new UnusedSpaceTarget();
      target.EraseClusterTips = false;
      List<KeyValuePair<string, string> > subParams =
       GetSubParameters(param.Substring(equalPos + 1));
      foreach (KeyValuePair<string, string> kvp in subParams)
       if (kvp.Value == null && target.Drive == null)
        target.Drive = Path.GetFullPath(kvp.Key);
       else if (kvp.Key == "clusterTips")
        target.EraseClusterTips = true;
       else
        throw new ArgumentException("Unknown subparameter: " + kvp.Key);
      Targets.Add(target);
     }
     else if (IsParam(param, "dir", "d") || IsParam(param, "directory", null))
     {
      if (equalPos == -1)
       throw new ArgumentException("--directory must be specified with the " +
        "directory to erase.");
      FolderTarget target = new FolderTarget();
      List<KeyValuePair<string, string> > subParams =
       GetSubParameters(param.Substring(equalPos + 1));
      foreach (KeyValuePair<string, string> kvp in subParams)
       if (kvp.Value == null && target.Path == null)
        target.Path = Path.GetFullPath(kvp.Key);
       else if (kvp.Key == "excludeMask")
       {
        if (kvp.Value == null)
     throw new ArgumentException("The exclude mask must be specified " +
      "if the excludeMask subparameter is specified");
        target.ExcludeMask = kvp.Value;
       }
       else if (kvp.Key == "includeMask")
       {
        if (kvp.Value == null)
     throw new ArgumentException("The include mask must be specified " +
      "if the includeMask subparameter is specified");
        target.IncludeMask = kvp.Value;
       }
       else if (kvp.Key == "delete")
        target.DeleteIfEmpty = true;
       else
        throw new ArgumentException("Unknown subparameter: " + kvp.Key);
      Targets.Add(target);
     }
     else if (IsParam(param, "file", "f"))
     {
      if (equalPos == -1)
       throw new ArgumentException("--file must be specified with the " +
        "file to erase.");
      FileTarget target = new FileTarget();
      List<KeyValuePair<string, string> > subParams =
       GetSubParameters(param.Substring(equalPos + 1));
      foreach (KeyValuePair<string, string> kvp in subParams)
       if (kvp.Value == null && target.Path == null)
        target.Path = Path.GetFullPath(kvp.Key);
       else
        throw new ArgumentException("Unknown subparameter: " + kvp.Key);
      Targets.Add(target);
     }
     else
      return false;
     return true;
 }
示例#3
0
 private void scheduler_DragDrop(object sender, DragEventArgs e)
 {
     if (!e.Data.GetDataPresent(DataFormats.FileDrop))
     e.Effect = DragDropEffects.None;
        else
        {
     string[] files = (string[])e.Data.GetData(DataFormats.FileDrop, false);
     if (e.Effect == DragDropEffects.Copy)
     {
      foreach (string file in files)
       using (FileStream stream = new FileStream(file, FileMode.Open,
        FileAccess.Read, FileShare.Read))
       {
        try
        {
     Program.eraserClient.Tasks.LoadFromStream(stream);
        }
        catch (SerializationException ex)
        {
     MessageBox.Show(S._("Could not import task list from {0}. The " +
      "error returned was: {1}", file, ex.Message), S._("Eraser"),
      MessageBoxButtons.OK, MessageBoxIcon.Error,
      MessageBoxDefaultButton.Button1,
      S.IsRightToLeft(null) ?
       MessageBoxOptions.RtlReading | MessageBoxOptions.RightAlign : 0);
        }
       }
     }
     else if (e.Effect == DragDropEffects.Move)
     {
      Task task = new Task();
      foreach (string file in files)
      {
       FileSystemObjectTarget target;
       if (Directory.Exists(file))
        target = new FolderTarget();
       else
        target = new FileTarget();
       target.Path = file;
       task.Targets.Add(target);
      }
      Program.eraserClient.Tasks.Add(task);
     }
        }
        DropTargetHelper.Drop(e.Data, new Point(e.X, e.Y), e.Effect);
 }
示例#4
0
        private static void CommandAddTask(ConsoleArguments arg)
        {
            AddTaskArguments arguments = (AddTaskArguments)arg;

               Task task = new Task();
               ErasureMethod method = arguments.ErasureMethod == Guid.Empty ?
            ErasureMethodManager.Default :
            ErasureMethodManager.GetInstance(arguments.ErasureMethod);
               switch (arguments.Schedule.ToUpperInvariant())
               {
            case "NOW":
             task.Schedule = Schedule.RunNow;
             break;
            case "MANUALLY":
             task.Schedule = Schedule.RunManually;
             break;
            case "RESTART":
             task.Schedule = Schedule.RunOnRestart;
             break;
            default:
             throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
              "Unknown schedule type: {0}", arguments.Schedule), "--schedule");
               }

               List<string> trueValues = new List<string>(new string[] { "yes", "true" });
               string[] strings = new string[] {

            "(?<recycleBin>recyclebin)",

            "unused=(?<unusedVolume>.*)(?<unusedTips>,clusterTips(=(?<unusedTipsValue>true|false))?)?",

            "dir=(?<directoryName>.*)(?<directoryParams>(?<directoryExcludeMask>,-[^,]+)|(?<directoryIncludeMask>,\\+[^,]+)|(?<directoryDeleteIfEmpty>,deleteIfEmpty(=(?<directoryDeleteIfEmptyValue>true|false))?))*",

            "file=(?<fileName>.*)"
               };

               Regex regex = new Regex(string.Join("|", strings),
            RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.RightToLeft);
               foreach (string argument in arguments.PositionalArguments)
               {
            Match match = regex.Match(argument);
            if (match.Captures.Count == 0)
            {
             Console.WriteLine("Unknown argument: {0}, skipped.", argument);
             continue;
            }

            ErasureTarget target = null;
            if (match.Groups["recycleBin"].Success)
            {
             target = new RecycleBinTarget();
            }
            else if (match.Groups["unusedVolume"].Success)
            {
             UnusedSpaceTarget unusedSpaceTarget = new UnusedSpaceTarget();
             target = unusedSpaceTarget;
             unusedSpaceTarget.Drive = match.Groups["unusedVolume"].Value;

             if (!match.Groups["unusedTips"].Success)
              unusedSpaceTarget.EraseClusterTips = false;
             else if (!match.Groups["unusedTipsValue"].Success)
              unusedSpaceTarget.EraseClusterTips = true;
             else
              unusedSpaceTarget.EraseClusterTips =
               trueValues.IndexOf(match.Groups["unusedTipsValue"].Value) != -1;
            }
            else if (match.Groups["directoryName"].Success)
            {
             FolderTarget folderTarget = new FolderTarget();
             target = folderTarget;

             folderTarget.Path = match.Groups["directoryName"].Value;
             if (!match.Groups["directoryDeleteIfEmpty"].Success)
              folderTarget.DeleteIfEmpty = false;
             else if (!match.Groups["directoryDeleteIfEmptyValue"].Success)
              folderTarget.DeleteIfEmpty = true;
             else
              folderTarget.DeleteIfEmpty =
               trueValues.IndexOf(match.Groups["directoryDeleteIfEmptyValue"].Value) != -1;
             if (match.Groups["directoryExcludeMask"].Success)
              folderTarget.ExcludeMask += match.Groups["directoryExcludeMask"].Value.Remove(0, 2) + ' ';
             if (match.Groups["directoryIncludeMask"].Success)
              folderTarget.IncludeMask += match.Groups["directoryIncludeMask"].Value.Remove(0, 2) + ' ';
            }
            else if (match.Groups["fileName"].Success)
            {
             FileTarget fileTarget = new FileTarget();
             target = fileTarget;
             fileTarget.Path = match.Groups["fileName"].Value;
            }

            if (target == null)
             continue;

            target.Method = method;
            task.Targets.Add(target);
               }

               if (task.Targets.Count == 0)
            throw new ArgumentException("Tasks must contain at least one erasure target.");

               try
               {
            using (RemoteExecutorClient client = new RemoteExecutorClient())
            {
             client.Run();
             if (!client.IsConnected)
             {

              Process eraserInstance = Process.Start(
               Assembly.GetExecutingAssembly().Location, "--quiet");
              eraserInstance.WaitForInputIdle();

              client.Run();
              if (!client.IsConnected)
               throw new IOException("Eraser cannot connect to the running " +
            "instance for erasures.");
             }

             client.Tasks.Add(task);
            }
               }
               catch (UnauthorizedAccessException e)
               {

            throw new UnauthorizedAccessException("Another instance of Eraser " +
             "is already running but it is running with higher privileges than " +
             "this instance of Eraser. Tasks cannot be added in this manner.\n\n" +
             "Close the running instance of Eraser and start it again without " +
             "administrator privileges, or run the command again as an " +
             "administrator.", e);
               }
        }