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

Last change on this file since 1434 was 1434, checked in by Paul Lelgemann, 12 years ago

+ Added early version of Peer2PeerBaseProxy, which uses CrypP2P instead of new P2P connections for each plugin instance in a workspace (compatible, but not yet functional)

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