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

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

1) Killed the LayoutUpdated-Event in WPF because it consumed 60-90% of the cpu load...
2) Changes Threading.Timer to Timers.Timer in P2PSubscriberBase.

File size: 20.0 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;
30
31namespace Cryptool.Plugins.PeerToPeer
32{
33    /// <summary>
34    /// This PlugIn only works, when its connected with a P2P_Peer object.
35    /// </summary>
36    [Author("Christian Arnold", "arnold@cryptool.org", "Uni Duisburg-Essen", "http://www.uni-due.de")]
37    [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")]
38    public class P2PManager_KeyPattern : IInput
39    {
40        private P2PManagerBase_NEW p2pManager;
41        private P2PManager_KeyPatternSettings settings;
42        // IInput
43        private CryptoolStream decryptedData;
44        private byte[] initVector;
45        // IControls       
46        private IControlEncryption encryptionControl;
47        private IP2PControl p2pControl;
48
49        private KeyPattern pattern = null;
50        public KeyPattern Pattern
51        {
52            get
53            {
54                return pattern;
55            }
56            set
57            {
58                pattern = value;
59                if ((settings.Key == null) || ((settings.Key != null) && !pattern.testWildcardKey(settings.Key)))
60                    settings.Key = pattern.giveInputPattern();
61            }
62        }
63
64        #region In and Output
65
66        [PropertyInfo(Direction.InputData, "Encrypted Data", "Encrypted data out of an Encryption PlugIn", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, "")]
67        public CryptoolStream DecryptedData
68        {
69            get { return this.decryptedData; }
70            set
71            {
72                if (value != this.decryptedData)
73                {
74                    this.decryptedData = value;
75                }
76            }
77        }
78
79        [PropertyInfo(Direction.InputData, "Initialization Vector", "Initialization vector with which the data were encrypted", "", DisplayLevel.Beginner)]
80        public byte[] InitVector
81        {
82            get { return this.initVector; }
83            set
84            {
85                if (value != this.initVector)
86                    this.initVector = value;
87            }
88        }
89
90        [PropertyInfo(Direction.ControlMaster, "Control Master", "Used for bruteforcing", "", DisplayLevel.Beginner)]
91        public IControlEncryption EncryptionControl
92        {
93            get { return this.encryptionControl; }
94            set
95            {
96                if (this.encryptionControl != null)
97                {
98                    this.encryptionControl.keyPatternChanged -= encryptionControl_keyPatternChanged;
99                    this.encryptionControl.OnStatusChanged -= encryptionControl_onStatusChanged;
100                }
101                if (value != null)
102                {
103                    Pattern = new KeyPattern(value.getKeyPattern());
104                    value.keyPatternChanged += encryptionControl_keyPatternChanged;
105                    value.OnStatusChanged += encryptionControl_onStatusChanged;
106                    this.encryptionControl = value;
107                    OnPropertyChanged("ControlMaster");
108
109                }
110                else
111                    this.encryptionControl = null;
112            }
113        }
114
115        private void encryptionControl_keyPatternChanged()
116        {
117            Pattern = new KeyPattern(this.encryptionControl.getKeyPattern());
118        }
119        private void encryptionControl_onStatusChanged(IControl sender, bool readyForExecution)
120        {
121            // obsolete stuff
122            if (readyForExecution)
123            {
124                this.process((IControlEncryption)sender);
125            }
126        }
127
128        /// <summary>
129        /// Catches the completely configurated, initialized and joined P2P object from the P2PPeer-Slave-PlugIn.
130        /// </summary>
131        [PropertyInfo(Direction.ControlMaster, "P2P Slave", "Input the P2P-Peer-PlugIn", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
132        public IP2PControl P2PControl
133        {
134            get
135            {
136                return this.p2pControl;
137            }
138            set
139            {
140                if (this.p2pControl != null)
141                {
142                    this.p2pControl.OnStatusChanged -= P2PControl_OnStatusChanged;
143                }
144                if (value != null)
145                {
146                    this.p2pControl = (P2PPeerMaster)value;
147                    this.p2pControl.OnStatusChanged += new IControlStatusChangedEventHandler(P2PControl_OnStatusChanged);
148                    OnPropertyChanged("P2PMaster");
149                }
150                else
151                {
152                    this.p2pControl = null;
153                }
154            }
155        }
156
157        private void P2PControl_OnStatusChanged(IControl sender, bool readyForExecution)
158        {
159            //throw new NotImplementedException();
160        }
161
162        #endregion
163
164        #region Events
165
166        public event StatusChangedEventHandler OnPluginStatusChanged;
167
168        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
169
170        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
171
172        #endregion
173
174        #region Standard PlugIn-Functionality
175
176        public P2PManager_KeyPattern()
177        {
178            this.settings = new P2PManager_KeyPatternSettings();
179            this.settings.PropertyChanged += new PropertyChangedEventHandler(settings_PropertyChanged);
180            this.settings.TaskPaneAttributeChanged += new TaskPaneAttributeChangedHandler(settings_TaskPaneAttributeChanged);
181            this.settings.OnPluginStatusChanged += new StatusChangedEventHandler(settings_OnPluginStatusChanged);
182
183            QuickWatchPresentation = new P2PManagerPresentation();
184        }
185
186        #region QuickWatchPresentation Stuff
187
188        public UserControl QuickWatchPresentation
189        {
190            get;
191            private set;
192        }
193
194        public UserControl Presentation
195        {
196            get { return QuickWatchPresentation; }
197        }
198
199        private void UpdateQuickWatch(double progressInPercent)
200        {
201            UpdateQuickWatch(this.distributableKeyPatternJob.GlobalResultList, this.distributableKeyPatternJob.TotalAmount,
202                this.distributableKeyPatternJob.AllocatedAmount, this.distributableKeyPatternJob.FinishedAmount, 
203                progressInPercent, this.p2pManager.FreeWorkers(), this.p2pManager.BusyWorkers());
204        }
205
206        private void UpdateQuickWatch(LinkedList<KeySearcher.KeySearcher.ValueKey> globalTop10List,
207            BigInteger jobsTotalAmount, BigInteger jobsInProgress, BigInteger jobsFinished, double progressInPercent,
208            int freeWorkers, int busyWorkers)
209        {
210            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
211            LinkedListNode<KeySearcher.KeySearcher.ValueKey> listNode;
212
213            if (QuickWatchPresentation.IsVisible)
214            {
215                ((P2PManagerPresentation)QuickWatchPresentation).Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
216                {
217                    ((P2PManagerPresentation)QuickWatchPresentation).txtProgressInPercent.Text = "" + Math.Round(progressInPercent, 2) + "%";
218                    ((P2PManagerPresentation)QuickWatchPresentation).txtTotal.Text = "" + jobsTotalAmount.ToString();
219                    ((P2PManagerPresentation)QuickWatchPresentation).txtInProgress.Text = "" + jobsInProgress.ToString();
220                    ((P2PManagerPresentation)QuickWatchPresentation).txtLeft.Text = "" + new BigInteger((jobsTotalAmount - jobsInProgress - jobsFinished)).ToString();
221                    ((P2PManagerPresentation)QuickWatchPresentation).txtFinished.Text = "" + jobsFinished.ToString();
222
223                    ((P2PManagerPresentation)QuickWatchPresentation).txtTotalWorker.Text = "" + (freeWorkers + busyWorkers);
224                    ((P2PManagerPresentation)QuickWatchPresentation).txtFreeWorker.Text = "" + freeWorkers;
225                    ((P2PManagerPresentation)QuickWatchPresentation).txtBusyWorker.Text = "" + busyWorkers;
226
227                    ((P2PManagerPresentation)QuickWatchPresentation).entries.Clear();
228                    listNode = globalTop10List.First;
229
230                    int i = 0;
231                    while (listNode != null)
232                    {
233                        i++;
234
235                        ResultEntry entry = new ResultEntry();
236                        entry.Ranking = "" + i;
237                        entry.Value = "" + Math.Round(listNode.Value.value, 3);
238                        entry.Key = listNode.Value.key;
239                        entry.Text = enc.GetString(listNode.Value.decryption);
240
241                        ((P2PManagerPresentation)QuickWatchPresentation).entries.Add(entry);
242                        listNode = listNode.Next;
243                    }
244                    // to resize the WPF Presentation, so it will fit in the PlugIn-Borders
245                    ((P2PManagerPresentation)QuickWatchPresentation).P2PManagerPresentation_SizeChanged(null, null);
246                }, null);
247            }
248        }
249
250        #endregion
251
252        void settings_OnPluginStatusChanged(IPlugin sender, StatusEventArgs args)
253        {
254            if (OnPluginStatusChanged != null)
255                OnPluginStatusChanged(this, args);
256        }
257
258        void settings_TaskPaneAttributeChanged(ISettings settings, TaskPaneAttributeChangedEventArgs args)
259        {
260            //throw new NotImplementedException();
261        }
262
263        void settings_PropertyChanged(object sender, PropertyChangedEventArgs e)
264        {
265            if (e.PropertyName == "Key")
266            {
267                if (this.EncryptionControl != null)
268                {
269                    KeyPattern checkPattern = new KeyPattern(this.EncryptionControl.getKeyPattern());
270                    if (!checkPattern.testWildcardKey(this.settings.Key))
271                    {
272                        GuiLogMessage("The set Pattern doesn't fit to the encryption plugin connected with this manager!", NotificationLevel.Warning);
273                    }
274                    else
275                        GuiLogMessage("Successfully changed the KeyPattern in the settings.", NotificationLevel.Info);
276                }
277            }
278
279            if (this.p2pControl == null)
280                return;
281            if (e.PropertyName == "BtnUnregister")
282            {
283                if (this.p2pManager != null && this.p2pManager.Started)
284                {
285                    Stop();
286                    //this.p2pManager.Stop(PubSubMessageType.Unregister);
287                    GuiLogMessage("Unregister button pressed, Publisher has stopped!", NotificationLevel.Info);
288                }
289            }
290            if (e.PropertyName == "BtnRegister")
291            {
292                if (this.p2pManager == null || !this.p2pManager.Started)
293                {
294                    this.process(this.EncryptionControl);
295                    GuiLogMessage("Register button pressed, Publisher has been started!", NotificationLevel.Info);
296                }
297            }
298            if (e.PropertyName == "BtnSolutionFound")
299            {
300                if (this.p2pManager != null && this.p2pManager.Started)
301                {
302                    Stop();
303                    //this.p2pManager.Stop(PubSubMessageType.Solution);
304                    GuiLogMessage("TEST: Emulate Solution-Found-message", NotificationLevel.Info);
305                }
306            }
307        }
308
309        public ISettings Settings
310        {
311            set { this.settings = (P2PManager_KeyPatternSettings)value; }
312            get { return this.settings; }
313        }
314
315        // Pre-Execute Method is below this region
316
317        // Execute-Method is below this region
318
319        public void PostExecution()
320        {
321            //throw new NotImplementedException();
322        }
323
324        public void Pause()
325        {
326            //throw new NotImplementedException();
327        }
328
329        public void Stop()
330        {
331
332            if (this.p2pManager != null && this.p2pManager.Started)
333            {
334                this.p2pManager.Stop(PubSubMessageType.Unregister);
335                this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Neutral);
336                this.p2pManager.OnGuiMessage -= p2pManager_OnGuiMessage;
337                this.p2pManager.OnProcessProgress -= p2pManager_OnProcessProgress;
338                this.p2pManager.OnNewJobAllocated -= p2pManager_OnNewJobAllocated;
339                this.p2pManager.OnNoMoreJobsLeft -= p2pManager_OnNoMoreJobsLeft;
340                this.p2pManager.OnResultReceived -= p2pManager_OnResultReceived;
341                // set Manager to null, so after restarting the Workspace,
342                // a new Distributable stop will be initialized with (maybe)
343                // changed settings
344                this.p2pManager = null;
345            }
346        }
347
348        public void Initialize()
349        {
350        }
351
352        public void Dispose()
353        {
354        }
355
356        #endregion
357
358        public void PreExecution()
359        {
360            // if no P2P Slave PlugIn is connected with this PlugIn --> No execution!
361            if (P2PControl == null)
362            {
363                GuiLogMessage("No P2P_Peer connected with this PlugIn!", NotificationLevel.Error);
364                return;
365            }
366        }
367
368        void p2pManager_OnProcessProgress(double progressInPercent)
369        {
370            ProgressChanged(progressInPercent, 100.0);
371            UpdateQuickWatch(progressInPercent);
372        }
373
374        void p2pManager_OnGuiMessage(string sData, NotificationLevel notificationLevel)
375        {
376            GuiLogMessage(sData, notificationLevel);
377        }
378
379        DistributableKeyPatternJob distributableKeyPatternJob;
380        public void Execute()
381        {
382            if (this.InitVector != null && this.DecryptedData != null)
383                this.process(this.EncryptionControl);
384        }
385
386        private void process(IControlEncryption iControlEncryption)
387        {
388            // if no P2P Slave PlugIn is connected with this PlugIn --> No execution!
389            if (P2PControl == null)
390            {
391                GuiLogMessage("No P2P_Peer connected with this PlugIn!", NotificationLevel.Error);
392                return;
393            }
394            if (iControlEncryption == null)
395            {
396                GuiLogMessage("No Encryption Control connected with this PlugIn", NotificationLevel.Error);
397                return;
398            }
399
400            if (this.p2pManager == null)
401            {
402                byte[] byteEncryptedData = null;
403                CryptoolStream newEncryptedData = new CryptoolStream();
404                try
405                {
406                    newEncryptedData.OpenRead(this.DecryptedData.FileName);
407                    // Convert CryptoolStream to an byte Array and store it in the DHT
408                    if (newEncryptedData.Length > Int32.MaxValue)
409                        throw (new Exception("Encrypted Data are too long for this PlugIn. The maximum size of Data is " + Int32.MaxValue + "!"));
410                    byteEncryptedData = new byte[newEncryptedData.Length];
411                    int k = newEncryptedData.Read(byteEncryptedData, 0, byteEncryptedData.Length);
412                    if (k < byteEncryptedData.Length)
413                        throw (new Exception("Read Data are shorter than byteArrayLen"));
414                }
415                catch (Exception ex)
416                {
417                    throw (new Exception("Fatal error while reading the CryptoolStream. Exception: " + ex.ToString()));
418                }
419                finally
420                {
421                    newEncryptedData.Close();
422                    newEncryptedData.Dispose();
423                }
424                             
425                string pattern = this.encryptionControl.getKeyPattern();
426                KeyPattern kp = new KeyPattern(pattern);
427                if (kp.testWildcardKey(this.settings.Key))
428                {
429                    kp.WildcardKey = this.settings.Key;
430                }
431                else
432                {
433                    GuiLogMessage("The Key Pattern in the settings isn't valid for the given Encryption!", NotificationLevel.Error);
434                    return;
435                }
436
437                // create a new DistributableJob instance
438                distributableKeyPatternJob = new DistributableKeyPatternJob
439                    (kp, this.settings.KeyPatternSize * 10000, byteEncryptedData, this.InitVector);
440
441                this.p2pManager = new P2PManagerBase_NEW(this.P2PControl, distributableKeyPatternJob);
442                this.p2pManager.OnGuiMessage += new P2PPublisherBase.GuiMessage(p2pManager_OnGuiMessage);
443                this.p2pManager.OnProcessProgress += new P2PManagerBase_NEW.ProcessProgress(p2pManager_OnProcessProgress);
444                this.p2pManager.OnNewJobAllocated += new P2PManagerBase_NEW.NewJobAllocated(p2pManager_OnNewJobAllocated);
445                this.p2pManager.OnNoMoreJobsLeft += new P2PManagerBase_NEW.NoMoreJobsLeft(p2pManager_OnNoMoreJobsLeft);
446                this.p2pManager.OnResultReceived += new P2PManagerBase_NEW.ResultReceived(p2pManager_OnResultReceived);
447            }
448
449            this.p2pManager.StartManager(this.settings.TopicName, this.settings.SendAliveMessageInterval * 1000);
450
451            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Working);
452        }
453
454        void p2pManager_OnResultReceived(BigInteger jobId)
455        {
456            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Finished);
457        }
458
459        void p2pManager_OnNoMoreJobsLeft()
460        {
461            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Finished);
462        }
463
464        void p2pManager_OnNewJobAllocated(BigInteger jobId)
465        {
466            this.settings.MngStatusChanged(P2PManager_KeyPatternSettings.MngStatus.Working);
467        }
468
469
470        #region INotifyPropertyChanged Members
471
472        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
473
474        public void OnPropertyChanged(string name)
475        {
476            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
477        }
478
479        public event PluginProgressChangedEventHandler OnPluginProcessChanged;
480
481        private void ProgressChanged(double value, double max)
482        {
483            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
484        }
485
486        private void GuiLogMessage(string p, NotificationLevel notificationLevel)
487        {
488            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(p, this, notificationLevel));
489        }
490
491        #endregion
492    }
493
494}
Note: See TracBrowser for help on using the repository browser.