Beispiel #1
0
        private void ProcessFilesInBackground(IEnumerable <string> files, Action <string, IThreadWorker, ProgressContext> processFile)
        {
            WorkerGroup workerGroup    = null;
            int         maxConcurrency = Environment.ProcessorCount > 2 ? Environment.ProcessorCount - 1 : 2;

            progressBackgroundWorker.BackgroundWorkWithProgress(
                (ProgressContext progress) =>
            {
                progress.AddItems(files.Count());
                using (workerGroup = new WorkerGroup(maxConcurrency, progress))
                {
                    foreach (string file in files)
                    {
                        IThreadWorker worker = workerGroup.CreateWorker();
                        string closureOverCopyOfLoopVariableFile = file;
                        InteractionSafeUi(() =>
                        {
                            processFile(closureOverCopyOfLoopVariableFile, worker, progress);
                        });
                        if (workerGroup.FirstError != FileOperationStatus.Success)
                        {
                            break;
                        }
                        progress.AddItems(-1);
                    }
                    workerGroup.WaitAllAndFinish();
                    return(workerGroup.FirstError);
                }
            },
                (FileOperationStatus status) =>
            {
            });
        }
Beispiel #2
0
        public static void TestFinishInBackground()
        {
            bool            didComplete = false;
            ProgressContext progress    = new ProgressContext();

            progress.Progressing += (object sender2, ProgressEventArgs e2) =>
            {
                didComplete = true;
            };

            using (ThreadWorker threadWorker = new ThreadWorker(progress))
            {
                threadWorker.Work += (object sender, ThreadWorkerEventArgs e) =>
                {
                    using (WorkerGroup workerGroup = new WorkerGroup(progress))
                    {
                        IThreadWorker worker = workerGroup.CreateWorker();
                        worker.Work += (object sender2, ThreadWorkerEventArgs e2) =>
                        {
                            e2.Progress.NotifyLevelStart();
                            e2.Progress.NotifyLevelFinished();
                        };
                        worker.Run();
                    }
                };
                threadWorker.Run();
            }

            Assert.That(didComplete, "Execution should continue here, with the flag set indicating that the progress event occurred.");
        }
        public static void TestSimple()
        {
            int workThreadId = -1;
            FileOperationContext returnedStatus = new FileOperationContext(String.Empty, ErrorStatus.UnspecifiedError);

            bool done = false;

            using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestSimple), new ProgressContext(), false))
            {
                worker.WorkAsync = (ThreadWorkerEventArgs e) =>
                {
                    workThreadId = Thread.CurrentThread.ManagedThreadId;
                    e.Result     = new FileOperationContext(String.Empty, ErrorStatus.Success);
                    return(Task.FromResult <object>(null));
                };
                worker.Completing += (object sender, ThreadWorkerEventArgs e) =>
                {
                    returnedStatus = e.Result;
                    done           = true;
                };
                worker.Run();
                worker.Join();
            }

            Assert.That(returnedStatus.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "The status should be returned as successful.");
            Assert.That(workThreadId, Is.Not.EqualTo(Thread.CurrentThread.ManagedThreadId), "The work should not be performed on the caller thread.");
            Assert.That(done, Is.True, "The background work must have executed the completed handler now.");
        }
        public static void TestObjectDisposedException()
        {
            IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestObjectDisposedException), new ProgressContext(), false);

            worker.WorkAsync = (ThreadWorkerEventArgs e) =>
            {
                e.Result = new FileOperationContext(String.Empty, ErrorStatus.Success);
                return(Task.FromResult <object>(null));
            };
            try
            {
                worker.Run();
                worker.Join();
            }
            finally
            {
                worker.Dispose();
            }

            bool hasCompleted = false;

            Assert.Throws <ObjectDisposedException>(() => { worker.Run(); });
            Assert.DoesNotThrow(() => { worker.Join(); });
            Assert.DoesNotThrow(() => { hasCompleted = worker.HasCompleted; });
            Assert.That(hasCompleted, "Even though the thread has completed, the variable should be set, since we allow calls to HasCompleted even after Dispose().");
            Assert.DoesNotThrow(() => { worker.Dispose(); });
        }
        public static void TestProgress()
        {
            FakeRuntimeEnvironment environment = (FakeRuntimeEnvironment)OS.Current;
            int progressCalls = 0;

            ProgressContext progress = new ProgressContext();

            using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestProgress), progress, false))
            {
                worker.WorkAsync = (ThreadWorkerEventArgs e) =>
                {
                    environment.CurrentTiming.CurrentTiming = TimeSpan.FromSeconds(1);
                    e.Progress.AddCount(1);
                    e.Result = new FileOperationContext(String.Empty, ErrorStatus.Success);
                    return(Task.FromResult <object>(null));
                };
                progress.Progressing += (object sender, ProgressEventArgs e) =>
                {
                    ++progressCalls;
                };
                worker.Run();
                worker.Join();
            }

            Assert.That(progressCalls, Is.EqualTo(1), "The Progressing event should be raised exactly one time.");
        }
Beispiel #6
0
        static void Main(string[] args)
        {
            ISingleConsumerQueue <TextFileContext> consumerQueue = new MonitorSingleConsumerQueue <TextFileContext>(new TextFileConsumer(FileName));
            IThreadWorker producerThread = new TextFileContextProducer(consumerQueue);
            IThreadWorker consumerThread = consumerQueue;

            try
            {
                consumerThread.Start();
                producerThread.Start();

                Console.WriteLine($"({Thread.CurrentThread.Name}): Модель запущена. Данные пишутся в {Path.Combine(Directory.GetCurrentDirectory(), FileName)}");
                Console.WriteLine($"({Thread.CurrentThread.Name}): Нажмите любую клавишу, чтобы остановить модель.");
                Console.ReadKey(true);
                Console.WriteLine($"({Thread.CurrentThread.Name}): Остановка модели...");
            }
            finally
            {
                producerThread.Dispose();
                consumerThread.Dispose();

                producerThread.Join();
                consumerThread.Join();

                Console.WriteLine($"({Thread.CurrentThread.Name}): Модель остановлена. Нажмите любую клавишу для выхода...");
                Console.ReadKey(true);
            }
        }
Beispiel #7
0
        public static void TestFinishInBackground()
        {
            bool            didComplete = false;
            ProgressContext progress    = new ProgressContext();

            progress.Progressing += (object sender2, ProgressEventArgs e2) =>
            {
                didComplete = true;
            };

            using (IThreadWorker threadWorker = Resolve.Portable.ThreadWorker(nameof(TestFinishInBackground) + "Outer", progress, false))
            {
                threadWorker.WorkAsync = (ThreadWorkerEventArgs e) =>
                {
                    using (WorkerGroup workerGroup = new WorkerGroup(progress))
                    {
                        IThreadWorker worker = workerGroup.CreateWorker(nameof(TestFinishInBackground) + "Inner");
                        worker.WorkAsync = (ThreadWorkerEventArgs e2) =>
                        {
                            e2.Progress.NotifyLevelStart();
                            e2.Progress.NotifyLevelFinished();
                            return(Task.FromResult <object>(null));
                        };
                        worker.Run();
                    }
                    return(Task.FromResult <object>(null));
                };
                threadWorker.Run();
                threadWorker.Join();
            }

            Assert.That(didComplete, "Execution should continue here, with the flag set indicating that the progress event occurred.");
        }
Beispiel #8
0
 public static void TestAddingSubscribersToWorkerThread()
 {
     using (WorkerGroup workerGroup = new WorkerGroup())
     {
         IThreadWorker worker      = workerGroup.CreateWorker(nameof(TestAddingSubscribersToWorkerThread));
         bool          wasPrepared = false;
         worker.Prepare += (object sender, ThreadWorkerEventArgs e) =>
         {
             wasPrepared = true;
         };
         bool didWork = false;
         worker.WorkAsync = (ThreadWorkerEventArgs e) =>
         {
             didWork = true;
             return(Task.FromResult <object>(null));
         };
         bool didComplete = false;
         worker.Completing += (object sender, ThreadWorkerEventArgs e) =>
         {
             didComplete = true;
         };
         worker.Run();
         workerGroup.WaitAllAndFinish();
         Assert.That(wasPrepared, "The Prepare event should be raised.");
         Assert.That(didWork, "The Work event should be raised.");
         Assert.That(didComplete, "The Completed event should be raised.");
     }
 }
Beispiel #9
0
        public static void TestRemovingSubscribersFromWorkerThread()
        {
            using (WorkerGroup workerGroup = new WorkerGroup())
            {
                IThreadWorker worker = workerGroup.CreateWorker(nameof(TestRemovingSubscribersFromWorkerThread) + "1");
                worker.Prepare    += ThreadWorkerEventHandler;
                worker.WorkAsync   = ThreadWorkerCommandHandler;
                worker.Completing += ThreadWorkerEventHandler;

                worker.Run();
                workerGroup.WaitAllAndFinish();

                Assert.That(workerGroup.FirstError.ErrorStatus, Is.EqualTo(ErrorStatus.UnspecifiedError), "The status should be set by one of the event handlers.");
            }

            using (WorkerGroup workerGroup = new WorkerGroup())
            {
                IThreadWorker worker = workerGroup.CreateWorker(nameof(TestRemovingSubscribersFromWorkerThread) + "2");
                worker.Prepare    += ThreadWorkerEventHandler;
                worker.WorkAsync   = ThreadWorkerCommandHandler;
                worker.Completing += ThreadWorkerEventHandler;

                worker.Prepare    -= ThreadWorkerEventHandler;
                worker.WorkAsync   = null;
                worker.Completing -= ThreadWorkerEventHandler;

                worker.Run();
                workerGroup.WaitAllAndFinish();

                Assert.That(workerGroup.FirstError.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "None of the event handlers should have been called, so the status should not have been set there.");
            }
        }
Beispiel #10
0
        private void EncryptFile(string file, IThreadWorker worker, ProgressContext progress)
        {
            FileOperationsController operationsController = new FileOperationsController(persistentState.Current, progress);

            operationsController.QuerySaveFileAs += (object sender, FileOperationEventArgs e) =>
            {
                using (SaveFileDialog sfd = new SaveFileDialog())
                {
                    sfd.Title            = Resources.EncryptFileSaveAsDialogTitle;
                    sfd.AddExtension     = true;
                    sfd.ValidateNames    = true;
                    sfd.CheckPathExists  = true;
                    sfd.DefaultExt       = OS.Current.AxCryptExtension;
                    sfd.FileName         = e.SaveFileFullName;
                    sfd.Filter           = Resources.EncryptedFileDialogFilterPattern.InvariantFormat(OS.Current.AxCryptExtension);
                    sfd.InitialDirectory = Path.GetDirectoryName(e.SaveFileFullName);
                    sfd.ValidateNames    = true;
                    DialogResult saveAsResult = sfd.ShowDialog();
                    if (saveAsResult != DialogResult.OK)
                    {
                        e.Cancel = true;
                        return;
                    }
                    e.SaveFileFullName = sfd.FileName;
                }
            };

            operationsController.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) =>
            {
                string passphrase = AskForEncryptionPassphrase();
                if (String.IsNullOrEmpty(passphrase))
                {
                    e.Cancel = true;
                    return;
                }
                e.Passphrase = passphrase;
                AesKey defaultEncryptionKey = new Passphrase(e.Passphrase).DerivedPassphrase;
                persistentState.Current.KnownKeys.DefaultEncryptionKey = defaultEncryptionKey;
            };

            operationsController.Completed += (object sender, FileOperationEventArgs e) =>
            {
                if (e.Status == FileOperationStatus.FileAlreadyEncrypted)
                {
                    e.Status = FileOperationStatus.Success;
                    return;
                }
                if (CheckStatusAndShowMessage(e.Status, e.OpenFileFullName))
                {
                    IRuntimeFileInfo encryptedInfo = OS.Current.FileInfo(e.SaveFileFullName);
                    IRuntimeFileInfo decryptedInfo = OS.Current.FileInfo(FileOperation.GetTemporaryDestinationName(e.OpenFileFullName));
                    ActiveFile       activeFile    = new ActiveFile(encryptedInfo, decryptedInfo, e.Key, ActiveFileStatus.NotDecrypted, null);
                    persistentState.Current.Add(activeFile);
                    persistentState.Current.Save();
                }
            };

            operationsController.EncryptFile(file, worker);
        }
Beispiel #11
0
 /// <summary>
 /// Add new Thread-worker to ThreadController
 /// </summary>
 /// <param name="worker">ThreadWorker</param>
 public void addWorker(IThreadWorker worker)
 {
     if (worker != null)
     {
         worker.init();
         m_workers.Add(worker);
         m_workCounts++;
     }
 }
Beispiel #12
0
 public static void TestDoubleFinished()
 {
     using (WorkerGroup workerGroup = new WorkerGroup())
     {
         IThreadWorker worker = workerGroup.CreateWorker(nameof(TestDoubleFinished));
         worker.Run();
         workerGroup.WaitAllAndFinish();
         Assert.Throws <InvalidOperationException>(() => { workerGroup.WaitAllAndFinish(); });
     }
 }
Beispiel #13
0
        /// <summary>
        /// Create a ThreadWorker for background work. Concurrency limitations are effective, so this call may block.
        /// </summary>
        /// <remarks>
        /// Since this call may block, it should not be called from the GUI thread if there is a risk of blocking.
        /// </remarks>
        /// <returns></returns>
        public IThreadWorker CreateWorker(string name, bool startSerializedOnUIThread)
        {
            if (_disposed)
            {
                throw new ObjectDisposedException("WorkerGroup");
            }
            AcquireOneConcurrencyRight();
            IThreadWorker threadWorker = Resolve.Portable.ThreadWorker(name, Progress, startSerializedOnUIThread);

            threadWorker.Completed += new EventHandler <ThreadWorkerEventArgs>(HandleThreadWorkerCompletedEvent);
            return(new ThreadWorkerWrapper(threadWorker));
        }
Beispiel #14
0
 public static void TestDoubleDispose()
 {
     Assert.DoesNotThrow(() =>
     {
         using (WorkerGroup workerGroup = new WorkerGroup())
         {
             IThreadWorker worker = workerGroup.CreateWorker(nameof(TestDoubleDispose));
             worker.Run();
             workerGroup.Dispose();
         }
     });
 }
Beispiel #15
0
        public static void TestCoreFunctionality()
        {
            int threadCount = 0;
            int maxCount    = 0;

            using (WorkerGroup workerGroup = new WorkerGroup())
            {
                object        threadLock = new object();
                IThreadWorker worker1    = workerGroup.CreateWorker(nameof(TestCoreFunctionality) + "1");
                worker1.WorkAsync = (ThreadWorkerEventArgs e) =>
                {
                    lock (threadLock)
                    {
                        ++threadCount;
                        if (threadCount > maxCount)
                        {
                            maxCount = threadCount;
                        }
                    }
                    Thread.Sleep(new TimeSpan(0, 0, 0, 0, 100));
                    return(Task.FromResult <object>(null));
                };
                worker1.Completing += (object sender, ThreadWorkerEventArgs e) =>
                {
                    --threadCount;
                };
                worker1.Run();

                IThreadWorker worker2 = workerGroup.CreateWorker(nameof(TestCoreFunctionality) + "2");
                worker2.WorkAsync = (ThreadWorkerEventArgs e) =>
                {
                    lock (threadLock)
                    {
                        ++threadCount;
                        if (threadCount > maxCount)
                        {
                            maxCount = threadCount;
                        }
                    }
                    Thread.Sleep(new TimeSpan(0, 0, 0, 0, 100));
                    return(Task.FromResult <object>(null));
                };
                worker2.Completing += (object sender, ThreadWorkerEventArgs e) =>
                {
                    --threadCount;
                };
                worker2.Run();

                workerGroup.WaitAllAndFinish();
                Assert.That(maxCount, Is.EqualTo(1), "There should never be more than one thread active at one time.");
            }
        }
Beispiel #16
0
        public static void TestObjectDisposed()
        {
            WorkerGroup   workerGroup = new WorkerGroup();
            IThreadWorker worker      = workerGroup.CreateWorker(nameof(TestObjectDisposed));

            worker.Run();
            workerGroup.Dispose();

            worker = null;
            Assert.Throws <ObjectDisposedException>(() => { worker = workerGroup.CreateWorker(nameof(TestObjectDisposed)); }, "A call to a method on a disposed object should raise ObjectDisposedException.");
            Assert.That(worker, Is.Null, "The worker should still be null, since the previous attempt to create should fail with an exception.");
            Assert.Throws <ObjectDisposedException>(() => { workerGroup.WaitAllAndFinish(); }, "A call to a method on a disposed object should raise ObjectDisposedException.");
        }
Beispiel #17
0
        public static void TestInvalidOperationException()
        {
            using (WorkerGroup workerGroup = new WorkerGroup())
            {
                IThreadWorker worker = workerGroup.CreateWorker(nameof(TestInvalidOperationException));

                bool?f = null;
                Assert.Throws <InvalidOperationException>(() => { f = worker.HasCompleted; });
                Assert.That(!f.HasValue, "No value should be set, since an exception should have occurred.");
                Assert.Throws <InvalidOperationException>(() => { worker.Join(); });
                worker.Abort();
            }
        }
Beispiel #18
0
        public static void TestCoreFunctionality()
        {
            int threadCount = 0;
            int maxCount    = 0;

            using (WorkerGroup workerGroup = new WorkerGroup())
            {
                object        threadLock = new object();
                IThreadWorker worker1    = workerGroup.CreateWorker();
                worker1.Work += (object sender, ThreadWorkerEventArgs e) =>
                {
                    lock (threadLock)
                    {
                        ++threadCount;
                        if (threadCount > maxCount)
                        {
                            maxCount = threadCount;
                        }
                    }
                    Thread.Sleep(100);
                };
                worker1.Completing += (object sender, ThreadWorkerEventArgs e) =>
                {
                    --threadCount;
                };
                worker1.Run();

                IThreadWorker worker2 = workerGroup.CreateWorker();
                worker2.Work += (object sender, ThreadWorkerEventArgs e) =>
                {
                    lock (threadLock)
                    {
                        ++threadCount;
                        if (threadCount > maxCount)
                        {
                            maxCount = threadCount;
                        }
                    }
                    Thread.Sleep(100);
                };
                worker2.Completing += (object sender, ThreadWorkerEventArgs e) =>
                {
                    --threadCount;
                };
                worker2.Run();

                workerGroup.WaitAllAndFinish();
                Assert.That(maxCount, Is.EqualTo(1), "There should never be more than one thread active at one time.");
            }
        }
Beispiel #19
0
 public static void TestProgressing()
 {
     using (WorkerGroup workerGroup = new WorkerGroup())
     {
         int percent = 0;
         workerGroup.Progress.Progressing += (object sender, ProgressEventArgs e) =>
         {
             percent = e.Percent;
         };
         IThreadWorker worker = workerGroup.CreateWorker(nameof(TestProgressing));
         worker.Run();
         workerGroup.WaitAllAndFinish();
         Assert.That(percent, Is.EqualTo(100), "Progress at 100 percent should always be reported when the thread completes.");
     }
 }
        public static void TestPrepare()
        {
            bool wasPrepared = false;

            using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestPrepare), new ProgressContext(), false))
            {
                worker.Prepare += (object sender, ThreadWorkerEventArgs e) =>
                {
                    wasPrepared = true;
                };
                worker.Run();
                worker.Join();
            }

            Assert.That(wasPrepared, Is.True, "The Prepare event should be raised.");
        }
Beispiel #21
0
        private void DecryptFile(string file, IThreadWorker worker, ProgressContext progress)
        {
            FileOperationsController operationsController = new FileOperationsController(persistentState.Current, progress);

            operationsController.QueryDecryptionPassphrase += HandleQueryDecryptionPassphraseEvent;

            operationsController.QuerySaveFileAs += (object sender, FileOperationEventArgs e) =>
            {
                string extension = Path.GetExtension(e.SaveFileFullName);
                using (SaveFileDialog sfd = new SaveFileDialog())
                {
                    sfd.AddExtension     = !String.IsNullOrEmpty(extension);
                    sfd.CheckPathExists  = true;
                    sfd.DefaultExt       = extension;
                    sfd.Filter           = Resources.DecryptedSaveAsFileDialogFilterPattern.InvariantFormat(extension);
                    sfd.InitialDirectory = Path.GetDirectoryName(file);
                    sfd.FileName         = Path.GetFileName(e.SaveFileFullName);
                    sfd.OverwritePrompt  = true;
                    sfd.RestoreDirectory = true;
                    sfd.Title            = Resources.DecryptedSaveAsFileDialogTitle;
                    DialogResult result = sfd.ShowDialog();
                    if (result != DialogResult.OK)
                    {
                        e.Cancel = true;
                        return;
                    }
                    e.SaveFileFullName = sfd.FileName;
                }
                return;
            };

            operationsController.KnownKeyAdded += (object sender, FileOperationEventArgs e) =>
            {
                persistentState.Current.KnownKeys.Add(e.Key);
            };

            operationsController.Completed += (object sender, FileOperationEventArgs e) =>
            {
                if (CheckStatusAndShowMessage(e.Status, e.OpenFileFullName))
                {
                    persistentState.Current.RemoveRecentFiles(new string[] { e.OpenFileFullName }, progress);
                }
            };

            operationsController.DecryptFile(file, worker);
        }
Beispiel #22
0
        public static void TestExplicitConstructor()
        {
            ProgressContext progress = new ProgressContext();
            int             percent  = 0;

            progress.Progressing += (object sender, ProgressEventArgs e) =>
            {
                percent = e.Percent;
            };
            using (WorkerGroup workerGroup = new WorkerGroup(1, progress))
            {
                IThreadWorker worker = workerGroup.CreateWorker(nameof(TestExplicitConstructor));
                worker.Run();
                workerGroup.WaitAllAndFinish();
            }
            Assert.That(percent, Is.EqualTo(100), "Progress at 100 percent should always be reported when the thread completes.");
        }
 private void DoFile(string fullName, IThreadWorker worker, Func <string, bool> preparation, Func <bool> operation)
 {
     if (!preparation(fullName))
     {
         worker.Abort();
         OnCompleted(_eventArgs);
         return;
     }
     worker.Work += (object workerSender, ThreadWorkerEventArgs threadWorkerEventArgs) =>
     {
         operation();
     };
     worker.Completing += (object workerSender, ThreadWorkerEventArgs threadWorkerEventArgs) =>
     {
         _eventArgs.Status = threadWorkerEventArgs.Result;
         OnCompleted(_eventArgs);
     };
     worker.Run();
 }
        public static void TestExceptionDuringWork()
        {
            FileOperationContext status = new FileOperationContext(String.Empty, ErrorStatus.Unknown);

            using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestExceptionDuringWork), new ProgressContext(), false))
            {
                worker.WorkAsync = (e) =>
                {
                    throw new InvalidOperationException("Something went intentionally wrong.");
                };
                worker.Completed += (sender, e) =>
                {
                    status = e.Result;
                };
                worker.Run();
                worker.Join();
            }

            Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Exception));
        }
        public static void TestErrorSetInWorkCompleted()
        {
            bool errorInWork = false;

            using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestErrorSetInWorkCompleted), new ProgressContext(), false))
            {
                worker.WorkAsync = (ThreadWorkerEventArgs e) =>
                {
                    throw new InvalidOperationException();
                };
                worker.Completing += (object sender, ThreadWorkerEventArgs e) =>
                {
                    errorInWork = e.Result.ErrorStatus == ErrorStatus.Exception;
                };
                worker.Run();
                worker.Join();
            }

            Assert.That(errorInWork, Is.True, "The operation was interrupted by an exception and should return status as such.");
        }
        public static void TestCancellationByException()
        {
            bool wasCanceled = false;

            using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestCancellationByException), new ProgressContext(), false))
            {
                worker.WorkAsync = (ThreadWorkerEventArgs e) =>
                {
                    throw new OperationCanceledException();
                };
                worker.Completing += (object sender, ThreadWorkerEventArgs e) =>
                {
                    wasCanceled = e.Result.ErrorStatus == ErrorStatus.Canceled;
                };
                worker.Run();
                worker.Join();
            }

            Assert.That(wasCanceled, Is.True, "The operation was canceled and should return status as such.");
        }
Beispiel #27
0
        private void WipeFile(string file, IThreadWorker worker, ProgressContext progress)
        {
            FileOperationsController operationsController = new FileOperationsController(persistentState.Current, progress);

            operationsController.WipeQueryConfirmation += (object sender, FileOperationEventArgs e) =>
            {
                using (ConfirmWipeDialog cwd = new ConfirmWipeDialog())
                {
                    cwd.FileNameLabel.Text = Path.GetFileName(file);
                    DialogResult confirmResult = cwd.ShowDialog();
                    e.ConfirmAll = cwd.ConfirmAllCheckBox.Checked;
                    if (confirmResult == DialogResult.Yes)
                    {
                        e.Skip = false;
                    }
                    if (confirmResult == DialogResult.No)
                    {
                        e.Skip = true;
                    }
                    if (confirmResult == DialogResult.Cancel)
                    {
                        e.Cancel = true;
                    }
                }
            };

            operationsController.Completed += (object sender, FileOperationEventArgs e) =>
            {
                if (CheckStatusAndShowMessage(e.Status, e.OpenFileFullName))
                {
                    if (!e.Skip)
                    {
                        persistentState.Current.RemoveRecentFiles(new string[] { e.SaveFileFullName }, progress);
                    }
                }
            };

            operationsController.WipeFile(file, worker);
        }
 public static void TestHasCompleted()
 {
     using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestHasCompleted), new ProgressContext(), false))
     {
         bool wasCompletedInWork = false;
         worker.WorkAsync = (ThreadWorkerEventArgs e) =>
         {
             wasCompletedInWork = worker.HasCompleted;
             return(Task.FromResult <object>(null));
         };
         bool wasCompletedInCompleted = false;
         worker.Completing += (object sender, ThreadWorkerEventArgs e) =>
         {
             wasCompletedInCompleted = worker.HasCompleted;
         };
         worker.Run();
         worker.Join();
         Assert.That(!wasCompletedInWork, "Completion is not set as true in the work event.");
         Assert.That(!wasCompletedInCompleted, "Completion is not set as true until after the completed event.");
         Assert.That(worker.HasCompleted, "Completion should be set as true when the thread is joined.");
     }
 }
Beispiel #29
0
        private void OpenEncrypted(string file, IThreadWorker worker, ProgressContext progress)
        {
            FileOperationsController operationsController = new FileOperationsController(persistentState.Current, progress);

            operationsController.QueryDecryptionPassphrase += HandleQueryDecryptionPassphraseEvent;

            operationsController.KnownKeyAdded += (object sender, FileOperationEventArgs e) =>
            {
                persistentState.Current.KnownKeys.Add(e.Key);
            };

            operationsController.Completed += (object sender, FileOperationEventArgs e) =>
            {
                if (e.Status == FileOperationStatus.Canceled)
                {
                    return;
                }
                CheckStatusAndShowMessage(e.Status, e.OpenFileFullName);
            };

            operationsController.DecryptAndLaunch(file, worker);
        }
        public static void TestCancellationByRequest()
        {
            bool wasCanceled = false;
            FakeRuntimeEnvironment environment = (FakeRuntimeEnvironment)OS.Current;

            using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestCancellationByRequest), new CancelProgressContext(new ProgressContext()), false))
            {
                worker.WorkAsync = (ThreadWorkerEventArgs e) =>
                {
                    e.Progress.Cancel = true;
                    environment.CurrentTiming.CurrentTiming = TimeSpan.FromSeconds(1);
                    e.Progress.AddCount(1);
                    return(Task.FromResult <object>(null));
                };
                worker.Completing += (object sender, ThreadWorkerEventArgs e) =>
                {
                    wasCanceled = e.Result.ErrorStatus == ErrorStatus.Canceled;
                };
                worker.Run();
                worker.Join();
            }

            Assert.That(wasCanceled, Is.True, "The operation was canceled and should return status as such.");
        }
 /// <summary>
 /// Process a file with the main task performed in a background thread.
 /// </summary>
 /// <param name="fullName"></param>
 public void EncryptFile(string fullName, IThreadWorker worker)
 {
     DoFile(fullName, worker, EncryptFilePreparation, EncryptFileOperation);
 }
Beispiel #32
0
 public ThreadWorkerWrapper(IThreadWorker worker)
 {
     _worker = worker;
 }
 /// <summary>
 /// Wipes a file asynchronously on a background thread.
 /// </summary>
 /// <param name="fullName">The full name and path of the file to wipe.</param>
 /// <param name="worker">The worker thread instance on which to do the wipe.</param>
 public void WipeFile(string fullName, IThreadWorker worker)
 {
     DoFile(fullName, worker, WipeFilePreparation, WipeFileOperation);
 }
        private void DecryptFile(string file, IThreadWorker worker, ProgressContext progress)
        {
            FileOperationsController operationsController = new FileOperationsController(persistentState.Current, progress);

            operationsController.QueryDecryptionPassphrase += HandleQueryDecryptionPassphraseEvent;

            operationsController.QuerySaveFileAs += (object sender, FileOperationEventArgs e) =>
                {
                    string extension = Path.GetExtension(e.SaveFileFullName);
                    using (SaveFileDialog sfd = new SaveFileDialog())
                    {
                        sfd.AddExtension = !String.IsNullOrEmpty(extension);
                        sfd.CheckPathExists = true;
                        sfd.DefaultExt = extension;
                        sfd.Filter = Resources.DecryptedSaveAsFileDialogFilterPattern.InvariantFormat(extension);
                        sfd.InitialDirectory = Path.GetDirectoryName(file);
                        sfd.FileName = Path.GetFileName(e.SaveFileFullName);
                        sfd.OverwritePrompt = true;
                        sfd.RestoreDirectory = true;
                        sfd.Title = Resources.DecryptedSaveAsFileDialogTitle;
                        DialogResult result = sfd.ShowDialog();
                        if (result != DialogResult.OK)
                        {
                            e.Cancel = true;
                            return;
                        }
                        e.SaveFileFullName = sfd.FileName;
                    }
                    return;
                };

            operationsController.KnownKeyAdded += (object sender, FileOperationEventArgs e) =>
                {
                    persistentState.Current.KnownKeys.Add(e.Key);
                };

            operationsController.Completed += (object sender, FileOperationEventArgs e) =>
                {
                    if (CheckStatusAndShowMessage(e.Status, e.OpenFileFullName))
                    {
                        persistentState.Current.RemoveRecentFiles(new string[] { e.OpenFileFullName }, progress);
                    }
                };

            operationsController.DecryptFile(file, worker);
        }
        private void WipeFile(string file, IThreadWorker worker, ProgressContext progress)
        {
            FileOperationsController operationsController = new FileOperationsController(persistentState.Current, progress);

            operationsController.WipeQueryConfirmation += (object sender, FileOperationEventArgs e) =>
            {
                using (ConfirmWipeDialog cwd = new ConfirmWipeDialog())
                {
                    cwd.FileNameLabel.Text = Path.GetFileName(file);
                    DialogResult confirmResult = cwd.ShowDialog();
                    e.ConfirmAll = cwd.ConfirmAllCheckBox.Checked;
                    if (confirmResult == DialogResult.Yes)
                    {
                        e.Skip = false;
                    }
                    if (confirmResult == DialogResult.No)
                    {
                        e.Skip = true;
                    }
                    if (confirmResult == DialogResult.Cancel)
                    {
                        e.Cancel = true;
                    }
                }
            };

            operationsController.Completed += (object sender, FileOperationEventArgs e) =>
            {
                if (CheckStatusAndShowMessage(e.Status, e.OpenFileFullName))
                {
                    if (!e.Skip)
                    {
                        persistentState.Current.RemoveRecentFiles(new string[] { e.SaveFileFullName }, progress);
                    }
                }
            };

            operationsController.WipeFile(file, worker);
        }
        private void EncryptFile(string file, IThreadWorker worker, ProgressContext progress)
        {
            FileOperationsController operationsController = new FileOperationsController(persistentState.Current, progress);

            operationsController.QuerySaveFileAs += (object sender, FileOperationEventArgs e) =>
                {
                    using (SaveFileDialog sfd = new SaveFileDialog())
                    {
                        sfd.Title = Resources.EncryptFileSaveAsDialogTitle;
                        sfd.AddExtension = true;
                        sfd.ValidateNames = true;
                        sfd.CheckPathExists = true;
                        sfd.DefaultExt = OS.Current.AxCryptExtension;
                        sfd.FileName = e.SaveFileFullName;
                        sfd.Filter = Resources.EncryptedFileDialogFilterPattern.InvariantFormat(OS.Current.AxCryptExtension);
                        sfd.InitialDirectory = Path.GetDirectoryName(e.SaveFileFullName);
                        sfd.ValidateNames = true;
                        DialogResult saveAsResult = sfd.ShowDialog();
                        if (saveAsResult != DialogResult.OK)
                        {
                            e.Cancel = true;
                            return;
                        }
                        e.SaveFileFullName = sfd.FileName;
                    }
                };

            operationsController.QueryEncryptionPassphrase += (object sender, FileOperationEventArgs e) =>
                {
                    string passphrase = AskForEncryptionPassphrase();
                    if (String.IsNullOrEmpty(passphrase))
                    {
                        e.Cancel = true;
                        return;
                    }
                    e.Passphrase = passphrase;
                    AesKey defaultEncryptionKey = new Passphrase(e.Passphrase).DerivedPassphrase;
                    persistentState.Current.KnownKeys.DefaultEncryptionKey = defaultEncryptionKey;
                };

            operationsController.Completed += (object sender, FileOperationEventArgs e) =>
                {
                    if (e.Status == FileOperationStatus.FileAlreadyEncrypted)
                    {
                        e.Status = FileOperationStatus.Success;
                        return;
                    }
                    if (CheckStatusAndShowMessage(e.Status, e.OpenFileFullName))
                    {
                        IRuntimeFileInfo encryptedInfo = OS.Current.FileInfo(e.SaveFileFullName);
                        IRuntimeFileInfo decryptedInfo = OS.Current.FileInfo(FileOperation.GetTemporaryDestinationName(e.OpenFileFullName));
                        ActiveFile activeFile = new ActiveFile(encryptedInfo, decryptedInfo, e.Key, ActiveFileStatus.NotDecrypted, null);
                        persistentState.Current.Add(activeFile);
                        persistentState.Current.Save();
                    }
                };

            operationsController.EncryptFile(file, worker);
        }
        private void OpenEncrypted(string file, IThreadWorker worker, ProgressContext progress)
        {
            FileOperationsController operationsController = new FileOperationsController(persistentState.Current, progress);

            operationsController.QueryDecryptionPassphrase += HandleQueryDecryptionPassphraseEvent;

            operationsController.KnownKeyAdded += (object sender, FileOperationEventArgs e) =>
                {
                    persistentState.Current.KnownKeys.Add(e.Key);
                };

            operationsController.Completed += (object sender, FileOperationEventArgs e) =>
                {
                    if (e.Status == FileOperationStatus.Canceled)
                    {
                        return;
                    }
                    CheckStatusAndShowMessage(e.Status, e.OpenFileFullName);
                };

            operationsController.DecryptAndLaunch(file, worker);
        }
 private void DoFile(string fullName, IThreadWorker worker, Func<string, bool> preparation, Func<bool> operation)
 {
     if (!preparation(fullName))
     {
         worker.Abort();
         OnCompleted(_eventArgs);
         return;
     }
     worker.Work += (object workerSender, ThreadWorkerEventArgs threadWorkerEventArgs) =>
     {
         operation();
     };
     worker.Completing += (object workerSender, ThreadWorkerEventArgs threadWorkerEventArgs) =>
     {
         _eventArgs.Status = threadWorkerEventArgs.Result;
         OnCompleted(_eventArgs);
     };
     worker.Run();
 }
 /// <summary>
 /// Wipes a file asynchronously on a background thread.
 /// </summary>
 /// <param name="fullName">The full name and path of the file to wipe.</param>
 /// <param name="worker">The worker thread instance on which to do the wipe.</param>
 public void WipeFile(string fullName, IThreadWorker worker)
 {
     DoFile(fullName, worker, WipeFilePreparation, WipeFileOperation);
 }
 /// <summary>
 /// Decrypt a file, and launch the associated application raising events as required by
 /// the situation. The decryption is performed asynchronously on a background thread.
 /// </summary>
 /// <param name="sourceFile">The full path to an encrypted file.</param>
 /// <param name="worker">The worker thread on which to execute the decryption and launch.</param>
 public void DecryptAndLaunch(string fullName, IThreadWorker worker)
 {
     DoFile(fullName, worker, DecryptAndLaunchPreparation, DecryptAndLaunchFileOperation);
 }