source: trunk/CrypPlugins/PeerToPeerManager_NEW/P2PManager_KeyPattern.cs @ 1448

Last change on this file since 1448 was 1448, checked in by Sven Rech, 12 years ago

replaced all BigInteger stuff with the new BigInteger class from .net 4.0

But there are still problems with some plugins (Keysearcher, BigInteger Operations...)

File size: 29.4 KB
Line 
1/* Copyright 2010 Team CrypTool (Christian Arnold), Uni Duisburg-Essen
2
3   Licensed under the Apache License, Version 2.0 (the "License");
4   you may not use this file except in compliance with the License.
5   You may obtain a copy of the License at
6
7       http://www.apache.org/licenses/LICENSE-2.0
8
9   Unless required by applicable law or agreed to in writing, software
10   distributed under the License is distributed on an "AS IS" BASIS,
11   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12   See the License for the specific language governing permissions and
13   limitations under the License.
14*/
15
16using System;
17using System.Collections.Generic;
18using System.Linq;
19using System.Text;
20using System.Threading;
21using Cryptool.PluginBase;
22using Cryptool.PluginBase.IO;
23using Cryptool.PluginBase.Control;
24using Cryptool.PluginBase.Miscellaneous;
25using System.ComponentModel;
26using KeySearcher;
27using System.Windows.Controls;
28using System.Windows.Threading;
29using Cryptool.Plugins.PeerToPeer.Jobs;
30using System.Timers;
31using System.Windows.Media;
32using Cryptool.Plugins.PeerToPeer.Internal;
33using System.Numerics;
34
35/*TODO:
36 * - Execute: If InitVector is null, try to create a fitting InitVector with the format 0...0
37 * - 2 Output values (Top1-Key and Top1-Decryption)
38 */
39
40namespace Cryptool.Plugins.PeerToPeer
41{
42    /// <summary>
43    /// This PlugIn only works, when its connected with a P2P_Peer object.
44    /// </summary>
45    [Author("Christian Arnold", "arnold@cryptool.org", "Uni Duisburg-Essen", "http://www.uni-due.de")]
46    [PluginInfo(false, "P2P_Manager_KeyPattern", "Creates a new Manager-Peer for distributable KeyPattern-Jobs", "", "PeerToPeerManager_NEW/manager_medium_neutral.png", "PeerToPeerManager_NEW/manager_medium_working.png", "PeerToPeerManager_NEW/manager_medium_finished.png")]
47    public class P2PManager_KeyPattern : IInput
48    {
49        private P2PManagerBase_NEW p2pManager;
50        private P2PManager_KeyPatternSettings settings;
51        // IInput
52        private CryptoolStream decryptedData;
53        private byte[] initVector;
54        // IControls       
55        private IControlEncryption encryptionControl;
56        private IP2PControl p2pControl;
57
58        private KeyPattern pattern = null;
59        public KeyPattern Pattern
60        {
61            get
62            {
63                return pattern;
64            }
65            set
66            {
67                pattern = value;
68                if ((settings.Key == null) || ((settings.Key != null) && !pattern.testWildcardKey(settings.Key)))
69                    settings.Key = pattern.giveInputPattern();
70            }
71        }
72
73        /// <summary>
74        /// after starting the execution, set this value, so after receiving
75        /// a Job result, the WPF UpdateQuickWatch can use this value, without
76        /// accessing the Settings every time.
77        /// </summary>
78        private int bytesToUseForDecryption = 0;
79
80        #region In and Output
81
82        [PropertyInfo(Direction.InputData, "Encrypted Data", "Encrypted data out of an Encryption PlugIn", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, "")]
83        public CryptoolStream DecryptedData
84        {
85            get { return this.decryptedData; }
86            set
87            {
88                if (value != this.decryptedData)
89                {
90                    this.decryptedData = value;
91                }
92            }
93        }
94
95        [PropertyInfo(Direction.InputData, "Initialization Vector", "Initialization vector with which the data were encrypted", "", DisplayLevel.Beginner)]
96        public byte[] InitVector
97        {
98            get { return this.initVector; }
99            set
100            {
101                if (value != this.initVector)
102                    this.initVector = value;
103            }
104        }
105
106        [PropertyInfo(Direction.ControlMaster, "Control Master", "Used for bruteforcing", "", DisplayLevel.Beginner)]
107        public IControlEncryption EncryptionControl
108        {
109            get { return this.encryptionControl; }
110            set
111            {
112                if (this.encryptionControl != null)
113                {
114                    this.encryptionControl.keyPatternChanged -= encryptionControl_keyPatternChanged;
115                    this.encryptionControl.OnStatusChanged -= encryptionControl_onStatusChanged;
116                }
117                if (value != null)
118                {
119                    Pattern = new KeyPattern(value.getKeyPattern());
120                    value.keyPatternChanged += encryptionControl_keyPatternChanged;
121                    value.OnStatusChanged += encryptionControl_onStatusChanged;
122                    this.encryptionControl = value;
123                    OnPropertyChanged("ControlMaster");
124
125                }
126                else
127                    this.encryptionControl = null;
128            }
129        }
130
131        private void encryptionControl_keyPatternChanged()
132        {
133            Pattern = new KeyPattern(this.encryptionControl.getKeyPattern());
134        }
135        private void encryptionControl_onStatusChanged(IControl sender, bool readyForExecution)
136        {
137            // obsolete stuff
138            if (readyForExecution)
139            {
140                this.process((IControlEncryption)sender);
141            }
142        }
143
144        /// <summary>
145        /// Catches the completely configurated, initialized and joined P2P object from the P2PPeer-Slave-PlugIn.
146        /// </summary>
147        [PropertyInfo(Direction.ControlMaster, "P2P Slave", "Input the P2P-Peer-PlugIn", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
148        public IP2PControl P2PControl
149        {
150            get
151            {
152                return this.p2pControl;
153            }
154            set
155            {
156                if (this.p2pControl != null)
157                {
158                    this.p2pControl.OnStatusChanged -= P2PControl_OnStatusChanged;
159                }
160                if (value != null)
161                {
162                    this.p2pControl = (IP2PControl)value;
163                    this.p2pControl.OnStatusChanged += new IControlStatusChangedEventHandler(P2PControl_OnStatusChanged);
164                    OnPropertyChanged("P2PMaster");
165                }
166                else
167                {
168                    this.p2pControl = null;
169                }
170            }
171        }
172
173        private void P2PControl_OnStatusChanged(IControl sender, bool readyForExecution)
174        {
175            //throw new NotImplementedException();
176        }
177
178        #endregion
179
180        #region Events
181
182        public event StatusChangedEventHandler OnPluginStatusChanged;
183
184        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
185
186        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
187
188        #endregion
189
190        #region Standard PlugIn-Functionality
191
192        public P2PManager_KeyPattern()
193        {
194            this.settings = new P2PManager_KeyPatternSettings();
195            this.settings.PropertyChanged += new PropertyChangedEventHandler(settings_PropertyChanged);
196            this.settings.TaskPaneAttributeChanged += new TaskPaneAttributeChangedHandler(settings_TaskPaneAttributeChanged);
197            this.settings.OnPluginStatusChanged += new StatusChangedEventHandler(settings_OnPluginStatusChanged);
198
199            QuickWatchPresentation = new P2PManagerPresentation();
200        }
201
202        #region QuickWatchPresentation Stuff
203
204        public UserControl QuickWatchPresentation
205        {
206            get;
207            private set;
208        }
209
210        public UserControl Presentation
211        {
212            get { return QuickWatchPresentation; }
213        }
214
215        private void timerProcessingTimeReset()
216        {
217            this.timerProcessingTime.Stop();
218            this.timerProcessingTime.Close();
219            this.timerProcessingTime.Dispose();
220            this.timerProcessingTime = null;
221
222            if (QuickWatchPresentation.IsVisible)
223            {
224                ((P2PManagerPresentation)QuickWatchPresentation).Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
225                {                   
226                    //((P2PManagerPresentation)QuickWatchPresentation).txtTimeInProcess.Text = "not started";
227                    ((P2PManagerPresentation)QuickWatchPresentation).txtProgressInPercent.Text = "not started";
228                    //((P2PManagerPresentation)QuickWatchPresentation).txtEstimatedEndTime.Text = "no finished jobs";
229                    //((P2PManagerPresentation)QuickWatchPresentation).PrgChunks.JobCount = 0;
230                }, null);
231            }
232        }
233
234        void timerProcessingTime_Elapsed(object sender, ElapsedEventArgs e)
235        {
236            if (QuickWatchPresentation.IsVisible)
237            {
238                ((P2PManagerPresentation)QuickWatchPresentation).Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
239                {
240                    // calculate and display current processing time span
241                    TimeSpan processTime = DateTime.Now.Subtract(this.p2pManager.StartWorkingTime);
242                    StringBuilder sbProcess = new StringBuilder();
243                    if(processTime.Days != 0)
244                        sbProcess.Append(processTime.Days.ToString() + " Days ");
245                    if (processTime.Hours <= 9)
246                        sbProcess.Append("0");
247                    sbProcess.Append(processTime.Hours.ToString() + ":");
248                    if (processTime.Minutes <= 9)
249                        sbProcess.Append("0");
250                    sbProcess.Append(processTime.Minutes.ToString() + ":");
251                    if (processTime.Seconds <= 9)
252                        sbProcess.Append("0");
253                    sbProcess.Append(processTime.Seconds.ToString());
254
255                    ((P2PManagerPresentation)QuickWatchPresentation).txtTimeInProcess.Text = sbProcess.ToString() + " (hh:mm:ss)";
256                    sbProcess = null;
257
258                    // change color of jobs in progress
259                    Brush evenClr = System.Windows.Media.Brushes.Black;
260                    Brush oddClr = System.Windows.Media.Brushes.Yellow;
261                    try
262                    {
263                        if((Math.Round(processTime.TotalSeconds,0) % 2) == 0)
264                        {
265                            for (int i = 0; i < ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks.JobCount; i++)
266                                        {
267                                        if(((P2PManagerPresentation)QuickWatchPresentation).PrgChunks[i] == oddClr)
268                                    ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks[i] = evenClr;
269                                        }
270                        }
271                        else
272                        {
273                            for (int i = 0; i < ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks.JobCount; i++)
274                                        {
275                                        if(((P2PManagerPresentation)QuickWatchPresentation).PrgChunks[i] == evenClr)
276                                    ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks[i] = oddClr;
277                                        }
278                        }
279                    }
280                    catch (Exception ex)
281                    {
282                        GuiLogMessage(ex.ToString(), NotificationLevel.Warning);
283                    }
284                }, null);
285            }
286        }
287
288        private void UpdateQuickWatch(double progressInPercent)
289        {
290            UpdateQuickWatch(this.distributableKeyPatternJob.GlobalResultList, this.distributableKeyPatternJob.TotalAmount,
291                this.distributableKeyPatternJob.AllocatedAmount, this.distributableKeyPatternJob.FinishedAmount, 
292                progressInPercent, this.p2pManager.FreeWorkers(), this.p2pManager.BusyWorkers());
293        }
294
295        private void UpdateQuickWatch(LinkedList<KeySearcher.KeySearcher.ValueKey> globalTop10List,
296            BigInteger jobsTotalAmount, BigInteger jobsInProgress, BigInteger jobsFinished, double progressInPercent,
297            int freeWorkers, int busyWorkers)
298        {
299            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
300            LinkedListNode<KeySearcher.KeySearcher.ValueKey> listNode;
301
302            if (QuickWatchPresentation.IsVisible)
303            {
304                ((P2PManagerPresentation)QuickWatchPresentation).Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
305                {
306                    ((P2PManagerPresentation)QuickWatchPresentation).txtProgressInPercent.Text = "" + Math.Round(progressInPercent, 2) + "%";
307                    ((P2PManagerPresentation)QuickWatchPresentation).txtTotal.Text = "" + jobsTotalAmount.ToString();
308                    ((P2PManagerPresentation)QuickWatchPresentation).txtInProgress.Text = "" + jobsInProgress.ToString();
309                    ((P2PManagerPresentation)QuickWatchPresentation).txtLeft.Text = "" + (jobsTotalAmount - jobsInProgress - jobsFinished).ToString();
310                    ((P2PManagerPresentation)QuickWatchPresentation).txtFinished.Text = "" + jobsFinished.ToString();
311
312                    ((P2PManagerPresentation)QuickWatchPresentation).txtTotalWorker.Text = "" + (freeWorkers + busyWorkers);
313                    ((P2PManagerPresentation)QuickWatchPresentation).txtFreeWorker.Text = "" + freeWorkers;
314                    ((P2PManagerPresentation)QuickWatchPresentation).txtBusyWorker.Text = "" + busyWorkers;
315
316                    /* START approximation of end time */
317                    // this value is MinValue until the first job is allocated to a worker
318                    DateTime estimatedDateTime = this.p2pManager.EstimatedEndTime();
319                    if(estimatedDateTime != DateTime.MaxValue)
320                    {
321                        ((P2PManagerPresentation)QuickWatchPresentation).txtEstimatedEndTime.Text = estimatedDateTime.ToString();
322                    }
323                    /* END approximation of end time */
324
325                    ((P2PManagerPresentation)QuickWatchPresentation).entries.Clear();
326                    listNode = globalTop10List.First;
327
328                    int i = 0;
329                    while (listNode != null)
330                    {
331                        i++;
332
333                        ResultEntry entry = new ResultEntry();
334                        entry.Ranking = "" + i;
335                        entry.Value = "" + Math.Round(listNode.Value.value, 3);
336                        entry.Key = listNode.Value.key;
337                        // remove all linebreaks, tabs and so on
338                        string decryptText = enc.GetString(listNode.Value.decryption, 0, this.bytesToUseForDecryption);
339                        decryptText = decryptText.Replace("\n", String.Empty);
340                        decryptText = decryptText.Replace("\t", String.Empty);
341                        decryptText = decryptText.Replace("\r", String.Empty);
342                        entry.Text = decryptText;//enc.GetString(listNode.Value.decryption, 0, this.bytesToUseForDecryption);
343
344                        ((P2PManagerPresentation)QuickWatchPresentation).entries.Add(entry);
345                        listNode = listNode.Next;
346                    }
347                    // to resize the WPF Presentation, so it will fit in the PlugIn-Borders
348                    ((P2PManagerPresentation)QuickWatchPresentation).P2PManagerPresentation_SizeChanged(null, null);
349                }, null);
350            }
351        }
352
353        private void UpdateProgressChunk(BigInteger jobId, System.Windows.Media.Brush color)
354        {
355            // new Progress Chunk - Arnold 2010.02.23
356            if ((long)jobId <= Int32.MaxValue)
357            {
358                int iJobId = (int)jobId;
359                if (QuickWatchPresentation.IsVisible)
360                {
361                    //((P2PManagerPresentation)QuickWatchPresentation).Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
362                    ((P2PManagerPresentation)QuickWatchPresentation).Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
363                    {
364                        try
365                        {
366                            if (((P2PManagerPresentation)QuickWatchPresentation).PrgChunks != null && ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks.JobCount != 0)
367                                ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks[iJobId] = color;
368                        }
369                        catch (Exception ex)
370                        {
371                            GuiLogMessage(ex.ToString(), NotificationLevel.Warning);
372                        }
373                    }, null);
374                }
375            }
376        }
377
378        private void SetProgressChunkJobCount(BigInteger bigInteger)
379        {
380            if ((long)bigInteger <= Int32.MaxValue)
381            {
382                int count = (int)bigInteger;
383                if (QuickWatchPresentation.IsVisible)
384                {
385                    //((P2PManagerPresentation)QuickWatchPresentation).Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
386                    ((P2PManagerPresentation)QuickWatchPresentation).Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
387                    {
388                        if(((P2PManagerPresentation)QuickWatchPresentation).PrgChunks != null)
389                            ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks.JobCount = count;
390                    }, null);
391                }
392            }
393        }
394
395        #endregion
396
397        void settings_OnPluginStatusChanged(IPlugin sender, StatusEventArgs args)
398        {
399            if (OnPluginStatusChanged != null)
400                OnPluginStatusChanged(this, args);
401        }
402
403        void settings_TaskPaneAttributeChanged(ISettings settings, TaskPaneAttributeChangedEventArgs args)
404        {
405            //throw new NotImplementedException();
406        }
407
408        void settings_PropertyChanged(object sender, PropertyChangedEventArgs e)
409        {
410            if (e.PropertyName == "Key")
411            {
412                if (this.EncryptionControl != null)
413                {
414                    KeyPattern checkPattern = new KeyPattern(this.EncryptionControl.getKeyPattern());
415                    if (!checkPattern.testWildcardKey(this.settings.Key))
416                    {
417                        GuiLogMessage("The set Pattern doesn't fit to the encryption plugin connected with this manager!", NotificationLevel.Warning);
418                    }
419                    else
420                        GuiLogMessage("Successfully changed the KeyPattern in the settings.", NotificationLevel.Info);
421                }
422            }
423
424            if (this.p2pControl == null)
425                return;
426            if (e.PropertyName == "BtnStop")
427            {
428                if (this.p2pManager != null && this.p2pManager.Started)
429                {
430                    Stop();
431                    //this.p2pManager.Stop(PubSubMessageType.Unregister);
432                    GuiLogMessage("Stop button pressed, Manager has been stopped!", NotificationLevel.Info);
433                }
434            }
435            if (e.PropertyName == "BtnStart")
436            {
437                if (this.p2pManager == null || !this.p2pManager.Started)
438                {
439                    this.process(this.EncryptionControl);
440                    GuiLogMessage("Start button pressed, Manager will be return job distribution!", NotificationLevel.Info);
441                }
442            }
443        }
444
445        public ISettings Settings
446        {
447            set { this.settings = (P2PManager_KeyPatternSettings)value; }
448            get { return this.settings; }
449        }
450
451        // Pre-Execute Method is below this region
452
453        // Execute-Method is below this region
454
455        public void PostExecution()
456        {
457            //throw new NotImplementedException();
458        }
459
460        public void Pause()
461        {
462            //throw new NotImplementedException();
463        }
464
465        public void Stop()
466        {
467
468            if (this.p2pManager != null && this.p2pManager.Started)
469            {
470                //stop processTime Timer
471                timerProcessingTimeReset();
472
473                this.p2pManager.Stop(PubSubMessageType.Unregister);
474                this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Neutral);
475                this.p2pManager.OnGuiMessage -= p2pManager_OnGuiMessage;
476                this.p2pManager.OnProcessProgress -= p2pManager_OnProcessProgress;
477                this.p2pManager.OnNewJobAllocated -= p2pManager_OnNewJobAllocated;
478                this.p2pManager.OnNoMoreJobsLeft -= p2pManager_OnNoMoreJobsLeft;
479                this.p2pManager.OnResultReceived -= p2pManager_OnResultReceived;
480                // set Manager to null, so after restarting the Workspace,
481                // a new Distributable stop will be initialized with (maybe)
482                // changed settings
483                this.p2pManager = null;
484            }
485        }
486
487        public void Initialize()
488        {
489        }
490
491        public void Dispose()
492        {
493        }
494
495        #endregion
496
497        public void PreExecution()
498        {
499            // if no P2P Slave PlugIn is connected with this PlugIn --> No execution!
500            if (P2PControl == null)
501            {
502                GuiLogMessage("No P2P_Peer connected with this PlugIn!", NotificationLevel.Error);
503                return;
504            }
505        }
506
507        void p2pManager_OnProcessProgress(double progressInPercent)
508        {
509            ProgressChanged(progressInPercent, 100.0);
510            UpdateQuickWatch(progressInPercent);
511        }
512
513        void p2pManager_OnGuiMessage(string sData, NotificationLevel notificationLevel)
514        {
515            GuiLogMessage(sData, notificationLevel);
516        }
517
518        DistributableKeyPatternJob distributableKeyPatternJob;
519        public void Execute()
520        {
521            if (this.DecryptedData != null)
522            {
523                // TODO: dirty hack because of a missing Initialization vector
524                // it can't be null, because serialization will throw an exception in this case
525                if (this.InitVector == null)
526                {
527                    this.InitVector = new byte[8]{0,0,0,0,0,0,0,0};
528                    GuiLogMessage("Initialization vector not set, so set a standard value - dirty hack!", NotificationLevel.Info);
529                }
530                this.process(this.EncryptionControl);
531            }               
532        }
533
534        private void process(IControlEncryption iControlEncryption)
535        {
536            // if no P2P Slave PlugIn is connected with this PlugIn --> No execution!
537            if (P2PControl == null)
538            {
539                GuiLogMessage("No P2P_Peer connected with this PlugIn!", NotificationLevel.Error);
540                return;
541            }
542            if (iControlEncryption == null)
543            {
544                GuiLogMessage("No Encryption Control connected with this PlugIn", NotificationLevel.Error);
545                return;
546            }
547
548            if (this.p2pManager == null)
549            {
550                byte[] byteEncryptedData = null;
551                CryptoolStream newEncryptedData = new CryptoolStream();
552                try
553                {
554                    newEncryptedData.OpenRead(this.DecryptedData.FileName);
555                    // Convert CryptoolStream to an byte Array and store it in the DHT
556                    if (newEncryptedData.Length > Int32.MaxValue)
557                        throw (new Exception("Encrypted Data are too long for this PlugIn. The maximum size of Data is " + Int32.MaxValue + "!"));
558                    byteEncryptedData = new byte[newEncryptedData.Length];
559                    int k = newEncryptedData.Read(byteEncryptedData, 0, byteEncryptedData.Length);
560                    if (k < byteEncryptedData.Length)
561                        throw (new Exception("Read Data are shorter than byteArrayLen"));
562                }
563                catch (Exception ex)
564                {
565                    throw (new Exception("Fatal error while reading the CryptoolStream. Exception: " + ex.ToString()));
566                }
567                finally
568                {
569                    newEncryptedData.Close();
570                    newEncryptedData.Dispose();
571                }
572                             
573                string pattern = this.encryptionControl.getKeyPattern();
574                KeyPattern kp = new KeyPattern(pattern);
575                if (kp.testWildcardKey(this.settings.Key))
576                {
577                    kp.WildcardKey = this.settings.Key;
578                }
579                else
580                {
581                    GuiLogMessage("The Key Pattern in the settings isn't valid for the given Encryption!", NotificationLevel.Error);
582                    return;
583                }
584
585                GuiLogMessage("Begin creating a new distributable KeyPatternJob. (" + DebugToFile.GetTimeStamp() + ")", NotificationLevel.Debug);
586
587                // create a new DistributableJob instance
588                distributableKeyPatternJob = new DistributableKeyPatternJob
589                    (kp, this.settings.KeyPatternSize * 10000, byteEncryptedData, this.InitVector);
590
591                GuiLogMessage("Ended creating a new distributable KeyPatternJob. (" + DebugToFile.GetTimeStamp() + ")", NotificationLevel.Debug);
592
593                //set progress chunk job count
594                SetProgressChunkJobCount(this.distributableKeyPatternJob.TotalAmount);
595
596                this.p2pManager = new P2PManagerBase_NEW(this.P2PControl, distributableKeyPatternJob);
597                this.p2pManager.OnGuiMessage += new P2PPublisherBase.GuiMessage(p2pManager_OnGuiMessage);
598                this.p2pManager.OnProcessProgress += new P2PManagerBase_NEW.ProcessProgress(p2pManager_OnProcessProgress);
599                this.p2pManager.OnNewJobAllocated += new P2PManagerBase_NEW.NewJobAllocated(p2pManager_OnNewJobAllocated);
600                this.p2pManager.OnNoMoreJobsLeft += new P2PManagerBase_NEW.NoMoreJobsLeft(p2pManager_OnNoMoreJobsLeft);
601                this.p2pManager.OnResultReceived += new P2PManagerBase_NEW.ResultReceived(p2pManager_OnResultReceived);
602                this.p2pManager.OnJobCanceled += new P2PManagerBase_NEW.JobCanceled(p2pManager_OnJobCanceled);
603                this.p2pManager.OnAllJobResultsReceived += new P2PManagerBase_NEW.AllJobResultsReceived(p2pManager_OnAllJobResultsReceived);
604            }
605
606            this.bytesToUseForDecryption = this.settings.BytesToUse;
607
608            this.p2pManager.StartManager(this.settings.TopicName, this.settings.SendAliveMessageInterval * 1000);
609
610            //added 2010.02.26 for displaying actual processing time - this variables have to be reset when restarting manager
611            firstTimeJobAllocated = true;
612
613            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Working);
614        }
615
616        void p2pManager_OnAllJobResultsReceived(BigInteger lastJobId)
617        {
618            timerProcessingTimeReset();
619
620            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Finished);
621        }
622
623        void p2pManager_OnJobCanceled(BigInteger jobId)
624        {
625            UpdateProgressChunk(jobId, System.Windows.Media.Brushes.Red);
626        }
627
628        void p2pManager_OnResultReceived(BigInteger jobId)
629        {
630            UpdateProgressChunk(jobId, System.Windows.Media.Brushes.Green);
631
632            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Finished);
633        }
634
635        void p2pManager_OnNoMoreJobsLeft()
636        {
637            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Finished);
638        }
639
640
641        private bool firstTimeJobAllocated = true;
642        private System.Timers.Timer timerProcessingTime;
643        void p2pManager_OnNewJobAllocated(BigInteger jobId)
644        {
645            if (firstTimeJobAllocated)
646            {
647                timerProcessingTime = new System.Timers.Timer(1000);
648                timerProcessingTime.Elapsed += new ElapsedEventHandler(timerProcessingTime_Elapsed);
649                timerProcessingTime.Start();
650                firstTimeJobAllocated = false;
651            }
652            UpdateProgressChunk(jobId, System.Windows.Media.Brushes.Yellow);
653
654            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Working);
655        }
656
657        #region INotifyPropertyChanged Members
658
659        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
660
661        public void OnPropertyChanged(string name)
662        {
663            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
664        }
665
666        public event PluginProgressChangedEventHandler OnPluginProcessChanged;
667
668        private void ProgressChanged(double value, double max)
669        {
670            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
671        }
672
673        private void GuiLogMessage(string p, NotificationLevel notificationLevel)
674        {
675            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(p, this, notificationLevel));
676        }
677
678        #endregion
679    }
680
681}
Note: See TracBrowser for help on using the repository browser.