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

Last change on this file since 1210 was 1210, checked in by arnold, 12 years ago

Bug fix: Crash after receiving the last job result

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