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

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

P2PManager

  • Enlarged KeyPatternSize range to 1.000, because the new DES/AES-Implementation runs so fast, that a KeyPattern with KeyPatternSize of 150 will be processed in approximately 40 seconds on a modern PC
  • Embellished Layout
  • Enhanced information display (total processing time)
  • Jobs in progress change their color every second between Yellow and LightGray

Samples:

  • Changed from CFB to CBC, because this modus is much faster than CFB!
  • Changed KeyPatternSize to 150, because the new DES/AES Implementation runs much faster
File size: 28.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;
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.LightGray;
258                    Brush oddClr = System.Windows.Media.Brushes.Yellow;
259                    if((Math.Round(processTime.TotalSeconds,0) % 2) == 0)
260                    {
261                        for (int i = 0; i < ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks.JobCount; i++)
262                                    {
263                                    if(((P2PManagerPresentation)QuickWatchPresentation).PrgChunks[i] == oddClr)
264                                ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks[i] = evenClr;
265                                    }
266                    }
267                    else
268                    {
269                        for (int i = 0; i < ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks.JobCount; i++)
270                                    {
271                                    if(((P2PManagerPresentation)QuickWatchPresentation).PrgChunks[i] == evenClr)
272                                ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks[i] = oddClr;
273                                    }
274                    }
275                }, null);
276            }
277        }
278
279        private void UpdateQuickWatch(double progressInPercent)
280        {
281            UpdateQuickWatch(this.distributableKeyPatternJob.GlobalResultList, this.distributableKeyPatternJob.TotalAmount,
282                this.distributableKeyPatternJob.AllocatedAmount, this.distributableKeyPatternJob.FinishedAmount, 
283                progressInPercent, this.p2pManager.FreeWorkers(), this.p2pManager.BusyWorkers());
284        }
285
286        private void UpdateQuickWatch(LinkedList<KeySearcher.KeySearcher.ValueKey> globalTop10List,
287            BigInteger jobsTotalAmount, BigInteger jobsInProgress, BigInteger jobsFinished, double progressInPercent,
288            int freeWorkers, int busyWorkers)
289        {
290            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
291            LinkedListNode<KeySearcher.KeySearcher.ValueKey> listNode;
292
293            if (QuickWatchPresentation.IsVisible)
294            {
295                ((P2PManagerPresentation)QuickWatchPresentation).Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
296                {
297                    ((P2PManagerPresentation)QuickWatchPresentation).txtProgressInPercent.Text = "" + Math.Round(progressInPercent, 2) + "%";
298                    ((P2PManagerPresentation)QuickWatchPresentation).txtTotal.Text = "" + jobsTotalAmount.ToString();
299                    ((P2PManagerPresentation)QuickWatchPresentation).txtInProgress.Text = "" + jobsInProgress.ToString();
300                    ((P2PManagerPresentation)QuickWatchPresentation).txtLeft.Text = "" + new BigInteger((jobsTotalAmount - jobsInProgress - jobsFinished)).ToString();
301                    ((P2PManagerPresentation)QuickWatchPresentation).txtFinished.Text = "" + jobsFinished.ToString();
302
303                    ((P2PManagerPresentation)QuickWatchPresentation).txtTotalWorker.Text = "" + (freeWorkers + busyWorkers);
304                    ((P2PManagerPresentation)QuickWatchPresentation).txtFreeWorker.Text = "" + freeWorkers;
305                    ((P2PManagerPresentation)QuickWatchPresentation).txtBusyWorker.Text = "" + busyWorkers;
306
307                    /* START approximation of end time */
308                    // this value is MinValue until the first job is allocated to a worker
309                    DateTime estimatedDateTime = this.p2pManager.EstimatedEndTime();
310                    if(estimatedDateTime != DateTime.MaxValue)
311                    {
312                        ((P2PManagerPresentation)QuickWatchPresentation).txtEstimatedEndTime.Text = estimatedDateTime.ToString();
313                    }
314                    /* END approximation of end time */
315
316                    ((P2PManagerPresentation)QuickWatchPresentation).entries.Clear();
317                    listNode = globalTop10List.First;
318
319                    int i = 0;
320                    while (listNode != null)
321                    {
322                        i++;
323
324                        ResultEntry entry = new ResultEntry();
325                        entry.Ranking = "" + i;
326                        entry.Value = "" + Math.Round(listNode.Value.value, 3);
327                        entry.Key = listNode.Value.key;
328                        // remove all linebreaks, tabs and so on
329                        string decryptText = enc.GetString(listNode.Value.decryption, 0, this.bytesToUseForDecryption);
330                        decryptText = decryptText.Replace("\n", String.Empty);
331                        decryptText = decryptText.Replace("\t", String.Empty);
332                        decryptText = decryptText.Replace("\r", String.Empty);
333                        entry.Text = decryptText;//enc.GetString(listNode.Value.decryption, 0, this.bytesToUseForDecryption);
334
335                        ((P2PManagerPresentation)QuickWatchPresentation).entries.Add(entry);
336                        listNode = listNode.Next;
337                    }
338                    // to resize the WPF Presentation, so it will fit in the PlugIn-Borders
339                    ((P2PManagerPresentation)QuickWatchPresentation).P2PManagerPresentation_SizeChanged(null, null);
340                }, null);
341            }
342        }
343
344        private void UpdateProgressChunk(BigInteger jobId, System.Windows.Media.Brush color)
345        {
346            // new Progress Chunk - Arnold 2010.02.23
347            if (jobId.LongValue() <= Int32.MaxValue)
348            {
349                int iJobId = (int)jobId.LongValue();
350                if (QuickWatchPresentation.IsVisible)
351                {
352                    ((P2PManagerPresentation)QuickWatchPresentation).Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
353                    {
354                        if (((P2PManagerPresentation)QuickWatchPresentation).PrgChunks[iJobId] != null)
355                            ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks[iJobId] = color;
356                    }, null);
357                }
358            }
359        }
360
361        private void SetProgressChunkJobCount(BigInteger bigInteger)
362        {
363            if (bigInteger.LongValue() <= Int32.MaxValue)
364            {
365                int count = (int)bigInteger.LongValue();
366                if (QuickWatchPresentation.IsVisible)
367                {
368                    ((P2PManagerPresentation)QuickWatchPresentation).Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
369                    {
370                        ((P2PManagerPresentation)QuickWatchPresentation).PrgChunks.JobCount = count;
371                    }, null);
372                }
373            }
374        }
375
376        #endregion
377
378        void settings_OnPluginStatusChanged(IPlugin sender, StatusEventArgs args)
379        {
380            if (OnPluginStatusChanged != null)
381                OnPluginStatusChanged(this, args);
382        }
383
384        void settings_TaskPaneAttributeChanged(ISettings settings, TaskPaneAttributeChangedEventArgs args)
385        {
386            //throw new NotImplementedException();
387        }
388
389        void settings_PropertyChanged(object sender, PropertyChangedEventArgs e)
390        {
391            if (e.PropertyName == "Key")
392            {
393                if (this.EncryptionControl != null)
394                {
395                    KeyPattern checkPattern = new KeyPattern(this.EncryptionControl.getKeyPattern());
396                    if (!checkPattern.testWildcardKey(this.settings.Key))
397                    {
398                        GuiLogMessage("The set Pattern doesn't fit to the encryption plugin connected with this manager!", NotificationLevel.Warning);
399                    }
400                    else
401                        GuiLogMessage("Successfully changed the KeyPattern in the settings.", NotificationLevel.Info);
402                }
403            }
404
405            if (this.p2pControl == null)
406                return;
407            if (e.PropertyName == "BtnUnregister")
408            {
409                if (this.p2pManager != null && this.p2pManager.Started)
410                {
411                    Stop();
412                    //this.p2pManager.Stop(PubSubMessageType.Unregister);
413                    GuiLogMessage("Unregister button pressed, Publisher has stopped!", NotificationLevel.Info);
414                }
415            }
416            if (e.PropertyName == "BtnRegister")
417            {
418                if (this.p2pManager == null || !this.p2pManager.Started)
419                {
420                    this.process(this.EncryptionControl);
421                    GuiLogMessage("Register button pressed, Publisher has been started!", NotificationLevel.Info);
422                }
423            }
424            if (e.PropertyName == "BtnSolutionFound")
425            {
426                if (this.p2pManager != null && this.p2pManager.Started)
427                {
428                    Stop();
429                    //this.p2pManager.Stop(PubSubMessageType.Solution);
430                    GuiLogMessage("TEST: Emulate Solution-Found-message", NotificationLevel.Info);
431                }
432            }
433        }
434
435        public ISettings Settings
436        {
437            set { this.settings = (P2PManager_KeyPatternSettings)value; }
438            get { return this.settings; }
439        }
440
441        // Pre-Execute Method is below this region
442
443        // Execute-Method is below this region
444
445        public void PostExecution()
446        {
447            //throw new NotImplementedException();
448        }
449
450        public void Pause()
451        {
452            //throw new NotImplementedException();
453        }
454
455        public void Stop()
456        {
457
458            if (this.p2pManager != null && this.p2pManager.Started)
459            {
460                //stop processTime Timer
461                timerProcessingTimeReset();
462
463                this.p2pManager.Stop(PubSubMessageType.Unregister);
464                this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Neutral);
465                this.p2pManager.OnGuiMessage -= p2pManager_OnGuiMessage;
466                this.p2pManager.OnProcessProgress -= p2pManager_OnProcessProgress;
467                this.p2pManager.OnNewJobAllocated -= p2pManager_OnNewJobAllocated;
468                this.p2pManager.OnNoMoreJobsLeft -= p2pManager_OnNoMoreJobsLeft;
469                this.p2pManager.OnResultReceived -= p2pManager_OnResultReceived;
470                // set Manager to null, so after restarting the Workspace,
471                // a new Distributable stop will be initialized with (maybe)
472                // changed settings
473                this.p2pManager = null;
474            }
475        }
476
477        public void Initialize()
478        {
479        }
480
481        public void Dispose()
482        {
483        }
484
485        #endregion
486
487        public void PreExecution()
488        {
489            // if no P2P Slave PlugIn is connected with this PlugIn --> No execution!
490            if (P2PControl == null)
491            {
492                GuiLogMessage("No P2P_Peer connected with this PlugIn!", NotificationLevel.Error);
493                return;
494            }
495        }
496
497        void p2pManager_OnProcessProgress(double progressInPercent)
498        {
499            ProgressChanged(progressInPercent, 100.0);
500            UpdateQuickWatch(progressInPercent);
501        }
502
503        void p2pManager_OnGuiMessage(string sData, NotificationLevel notificationLevel)
504        {
505            GuiLogMessage(sData, notificationLevel);
506        }
507
508        DistributableKeyPatternJob distributableKeyPatternJob;
509        public void Execute()
510        {
511            if (this.DecryptedData != null)
512            {
513                // TODO: dirty hack because of a missing Initialization vector
514                // it can't be null, because serialization will throw an exception in this case
515                if (this.InitVector == null)
516                {
517                    this.InitVector = new byte[8]{0,0,0,0,0,0,0,0};
518                    GuiLogMessage("Initialization vector not set, so set a standard value - dirty hack!", NotificationLevel.Info);
519                }
520                this.process(this.EncryptionControl);
521            }               
522        }
523
524        private void process(IControlEncryption iControlEncryption)
525        {
526            // if no P2P Slave PlugIn is connected with this PlugIn --> No execution!
527            if (P2PControl == null)
528            {
529                GuiLogMessage("No P2P_Peer connected with this PlugIn!", NotificationLevel.Error);
530                return;
531            }
532            if (iControlEncryption == null)
533            {
534                GuiLogMessage("No Encryption Control connected with this PlugIn", NotificationLevel.Error);
535                return;
536            }
537
538            if (this.p2pManager == null)
539            {
540                byte[] byteEncryptedData = null;
541                CryptoolStream newEncryptedData = new CryptoolStream();
542                try
543                {
544                    newEncryptedData.OpenRead(this.DecryptedData.FileName);
545                    // Convert CryptoolStream to an byte Array and store it in the DHT
546                    if (newEncryptedData.Length > Int32.MaxValue)
547                        throw (new Exception("Encrypted Data are too long for this PlugIn. The maximum size of Data is " + Int32.MaxValue + "!"));
548                    byteEncryptedData = new byte[newEncryptedData.Length];
549                    int k = newEncryptedData.Read(byteEncryptedData, 0, byteEncryptedData.Length);
550                    if (k < byteEncryptedData.Length)
551                        throw (new Exception("Read Data are shorter than byteArrayLen"));
552                }
553                catch (Exception ex)
554                {
555                    throw (new Exception("Fatal error while reading the CryptoolStream. Exception: " + ex.ToString()));
556                }
557                finally
558                {
559                    newEncryptedData.Close();
560                    newEncryptedData.Dispose();
561                }
562                             
563                string pattern = this.encryptionControl.getKeyPattern();
564                KeyPattern kp = new KeyPattern(pattern);
565                if (kp.testWildcardKey(this.settings.Key))
566                {
567                    kp.WildcardKey = this.settings.Key;
568                }
569                else
570                {
571                    GuiLogMessage("The Key Pattern in the settings isn't valid for the given Encryption!", NotificationLevel.Error);
572                    return;
573                }
574
575                // create a new DistributableJob instance
576                distributableKeyPatternJob = new DistributableKeyPatternJob
577                    (kp, this.settings.KeyPatternSize * 10000, byteEncryptedData, this.InitVector);
578
579                //set progress chunk job count
580                SetProgressChunkJobCount(this.distributableKeyPatternJob.TotalAmount);
581
582                this.p2pManager = new P2PManagerBase_NEW(this.P2PControl, distributableKeyPatternJob);
583                this.p2pManager.OnGuiMessage += new P2PPublisherBase.GuiMessage(p2pManager_OnGuiMessage);
584                this.p2pManager.OnProcessProgress += new P2PManagerBase_NEW.ProcessProgress(p2pManager_OnProcessProgress);
585                this.p2pManager.OnNewJobAllocated += new P2PManagerBase_NEW.NewJobAllocated(p2pManager_OnNewJobAllocated);
586                this.p2pManager.OnNoMoreJobsLeft += new P2PManagerBase_NEW.NoMoreJobsLeft(p2pManager_OnNoMoreJobsLeft);
587                this.p2pManager.OnResultReceived += new P2PManagerBase_NEW.ResultReceived(p2pManager_OnResultReceived);
588                this.p2pManager.OnJobCanceled += new P2PManagerBase_NEW.JobCanceled(p2pManager_OnJobCanceled);
589                this.p2pManager.OnAllJobResultsReceived += new P2PManagerBase_NEW.AllJobResultsReceived(p2pManager_OnAllJobResultsReceived);
590            }
591
592            this.bytesToUseForDecryption = this.settings.BytesToUse;
593
594            this.p2pManager.StartManager(this.settings.TopicName, this.settings.SendAliveMessageInterval * 1000);
595
596            //added 2010.02.26 for displaying actual processing time - this variables have to be reset when restarting manager
597            firstTimeJobAllocated = true;
598
599            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Working);
600        }
601
602        void p2pManager_OnAllJobResultsReceived(BigInteger lastJobId)
603        {
604            timerProcessingTimeReset();
605        }
606
607        void p2pManager_OnJobCanceled(BigInteger jobId)
608        {
609            UpdateProgressChunk(jobId, System.Windows.Media.Brushes.Red);
610        }
611
612        void p2pManager_OnResultReceived(BigInteger jobId)
613        {
614            UpdateProgressChunk(jobId, System.Windows.Media.Brushes.Green);
615
616            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Finished);
617        }
618
619        void p2pManager_OnNoMoreJobsLeft()
620        {
621            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Finished);
622        }
623
624
625        private bool firstTimeJobAllocated = true;
626        private System.Timers.Timer timerProcessingTime;
627        void p2pManager_OnNewJobAllocated(BigInteger jobId)
628        {
629            if (firstTimeJobAllocated)
630            {
631                timerProcessingTime = new System.Timers.Timer(1000);
632                timerProcessingTime.Elapsed += new ElapsedEventHandler(timerProcessingTime_Elapsed);
633                timerProcessingTime.Start();
634                firstTimeJobAllocated = false;
635            }
636            UpdateProgressChunk(jobId, System.Windows.Media.Brushes.Yellow);
637
638            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Working);
639        }
640
641        #region INotifyPropertyChanged Members
642
643        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
644
645        public void OnPropertyChanged(string name)
646        {
647            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
648        }
649
650        public event PluginProgressChangedEventHandler OnPluginProcessChanged;
651
652        private void ProgressChanged(double value, double max)
653        {
654            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
655        }
656
657        private void GuiLogMessage(string p, NotificationLevel notificationLevel)
658        {
659            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(p, this, notificationLevel));
660        }
661
662        #endregion
663    }
664
665}
Note: See TracBrowser for help on using the repository browser.