source: trunk/CrypPlugins/KeySearcher/KeySearcherSettings.cs @ 2263

Last change on this file since 2263 was 2263, checked in by nolte, 11 years ago

Feature: Added a Save-Path for the csv-statistics to the Keysearcher Settings.

File size: 17.6 KB
RevLine 
[409]1using System;
[2194]2using System.Collections.Generic;
[1727]3using System.Windows;
[409]4using Cryptool.PluginBase;
5using System.ComponentModel;
[754]6using System.Collections.ObjectModel;
[1727]7using KeySearcher.P2P.Storage;
[2040]8using OpenCLNet;
[409]9
10namespace KeySearcher
11{
[676]12    public class KeySearcherSettings : ISettings
13    {
[1674]14        private readonly KeySearcher keysearcher;
[754]15        private int coresUsed;
[2263]16        private string csvPath;
[1634]17        private const string GroupPeerToPeer = "Peer-to-Peer network";
[1751]18        private const string GroupEvaluation = "Evaluation";
[2040]19        private const string GroupOpenCL = "OpenCL";
[2200]20        private const string GroupExternalClient = "External Client";
[2263]21        private const String GroupStatisticPath = "Statistic Save Path";
[409]22
[2194]23        public class OpenCLDeviceSettings
24        {
25            public string name;
26            public int index;
27            public bool useDevice;
28            public int mode;
29        }
30
31        private List<OpenCLDeviceSettings> deviceSettings = new List<OpenCLDeviceSettings>();
32        public List<OpenCLDeviceSettings> DeviceSettings
33        {
34            get
35            {
36                return deviceSettings;
37            }
38        }
39
[2040]40        public event TaskPaneAttributeChangedHandler TaskPaneAttributeChanged;
41
42        public KeySearcherSettings(KeySearcher ks, OpenCLManager oclManager)
[676]43        {
44            keysearcher = ks;
[2040]45
46            devicesAvailable.Clear();
[2194]47            int c = 0;
[2040]48            if (oclManager != null)
49                foreach (var device in oclManager.Context.Devices)
[2194]50                {
51                    string deviceName = device.Vendor + ":" + device.Name;
52                    deviceSettings.Add(new OpenCLDeviceSettings() {name = deviceName, index = c, mode = 1, useDevice = false});
53                    devicesAvailable.Add(deviceName);
54                    c++;
55                }
[2040]56
[754]57            CoresAvailable.Clear();
[2086]58            for (int i = -1; i < Environment.ProcessorCount; i++)
[754]59                CoresAvailable.Add((i + 1).ToString());
60            CoresUsed = Environment.ProcessorCount - 1;
[1634]61
[1643]62            chunkSize = 21;
[676]63        }
[409]64
[2040]65        public void Initialize()
66        {
67            OpenCLGroupVisiblity();
68        }
69
[676]70        private string key;
[682]71        [TaskPane("Key", "Key pattern used to bruteforce", null, 1, false, DisplayLevel.Beginner, ControlType.TextBox)]
[676]72        public String Key
73        {
74            get
75            {
76                return key;
77            }
78            set
[754]79            {
[676]80                key = value;
[682]81                OnPropertyChanged("Key");
[952]82                if (!(keysearcher.Pattern != null && keysearcher.Pattern.testWildcardKey(value)))
[754]83                    keysearcher.GuiLogMessage("Wrong key pattern!", NotificationLevel.Error);
[1634]84                HasChanges = true;
[676]85            }
86        }
[409]87
[676]88        [TaskPane("Reset", "Reset Key", null, 2, false, DisplayLevel.Beginner, ControlType.Button)]
89        public void Reset()
90        {
[952]91            Key = keysearcher.Pattern.giveInputPattern();
[676]92        }
[754]93       
94        [TaskPane("CoresUsed", "Choose how many cores should be used", null, 3, false, DisplayLevel.Beginner, ControlType.DynamicComboBox, new string[] { "CoresAvailable" })]
95        public int CoresUsed
96        {
97            get { return this.coresUsed; }
98            set
99            {
100                if (value != this.coresUsed)
101                {
102                    this.coresUsed = value;
103                    OnPropertyChanged("CoresUsed");
104                    HasChanges = true;
105                }
106            }
107        }
[409]108
[1634]109        private bool usePeerToPeer;
110        [TaskPane("Use Peer-to-Peer network", "Distributes the operation on available peers by using the built-in peer-to-peer network.", GroupPeerToPeer, 0, false, DisplayLevel.Beginner,
111            ControlType.CheckBox)]
112        public bool UsePeerToPeer
113        {
114            get { return usePeerToPeer; }
115            set
116            {
117                if (value != usePeerToPeer)
118                {
119                    usePeerToPeer = value;
120                    OnPropertyChanged("UsePeerToPeer");
121                    HasChanges = true;
122                }
123            }
124        }
125
126        private bool autoconnectPeerToPeer;
127        [TaskPane("Autoconnect network", "Establish a connection to the network if the workspace is started without the background connection being active.", GroupPeerToPeer, 1, false, DisplayLevel.Beginner,
128            ControlType.CheckBox)]
129        public bool AutoconnectPeerToPeer
130        {
131            get { return autoconnectPeerToPeer; }
132            set
133            {
134                if (value != autoconnectPeerToPeer)
135                {
136                    autoconnectPeerToPeer = value;
137                    OnPropertyChanged("AutoconnectPeerToPeer");
138                    HasChanges = true;
139                }
140            }
141        }
142
[1682]143        private bool verbosePeerToPeerDisplay;
144        [TaskPane("Display verbose information", "Display verbose information about network requests in the quick watch.", GroupPeerToPeer, 2, true, DisplayLevel.Beginner,
145            ControlType.CheckBox)]
146        public bool VerbosePeerToPeerDisplay
147        {
148            get { return verbosePeerToPeerDisplay; }
149            set
150            {
151                if (value != verbosePeerToPeerDisplay)
152                {
153                    verbosePeerToPeerDisplay = value;
154                    OnPropertyChanged("VerbosePeerToPeerDisplay");
155                    HasChanges = true;
156                }
157            }
158        }
159
[1634]160        private int chunkSize;
[1643]161        [TaskPane("Chunk size", "Amount of keys, that will be calculated by one peer at a time. This value is the exponent of the power of two used for the chunk size.", GroupPeerToPeer, 3, false, DisplayLevel.Professional,
162            ControlType.NumericUpDown, ValidationType.RangeInteger, 1, 1000)]
[1634]163        public int ChunkSize
164        {
165            get { return chunkSize; }
166            set
167            {
168                if (value != chunkSize)
169                {
170                    chunkSize = value;
171                    OnPropertyChanged("ChunkSize");
172                    HasChanges = true;
173                }
174            }
175        }
176
[1727]177        [TaskPane("Copy status key", "Copy status key to clipboard. The key can than be used to upload it together with the job using the P2PEditor.", GroupPeerToPeer, 4, true, DisplayLevel.Professional, ControlType.Button)]
178        public void StatusKeyButton()
179        {
180            if (!keysearcher.IsKeySearcherRunning)
181            {
182                keysearcher.GuiLogMessage("KeySearcher must be running to copy the status key.", NotificationLevel.Error);
183                return;
184            }
185
186            var generator = new StorageKeyGenerator(keysearcher, this);
187            var statusKey = generator.GenerateStatusKey();
188
189            Clipboard.SetDataObject(statusKey, true);
190            keysearcher.GuiLogMessage("Status key '" + statusKey + "' has been copied to clipboard.",
191                                      NotificationLevel.Info);
192        }
193
[1751]194        private string evaluationHost;
195        [TaskPane("Host", "Database host with evaluation database", GroupEvaluation, 0, false, DisplayLevel.Expert, ControlType.TextBox)]
196        public String EvaluationHost
197        {
198            get
199            {
200                return evaluationHost;
201            }
202            set
203            {
204                if (value != evaluationHost)
205                {
206                    evaluationHost = value;
207                    OnPropertyChanged("EvaluationHost");
208                    HasChanges = true;
209                }
210            }
211        }
212
213        private string evaluationUser;
214        [TaskPane("User", "Username for evaluation database", GroupEvaluation, 1, false, DisplayLevel.Expert, ControlType.TextBox)]
215        public String EvaluationUser
216        {
217            get
218            {
219                return evaluationUser;
220            }
221            set
222            {
223                if (value != evaluationUser)
224                {
225                    evaluationUser = value;
226                    OnPropertyChanged("EvaluationUser");
227                    HasChanges = true;
228                }
229            }
230        }
231
232        private string evaluationPassword;
233        [TaskPane("Password", "Password for evaluation database", GroupEvaluation, 2, false, DisplayLevel.Expert, ControlType.TextBox)]
234        public String EvaluationPassword
235        {
236            get
237            {
238                return evaluationPassword;
239            }
240            set
241            {
242                if (value != evaluationPassword)
243                {
244                    evaluationPassword = value;
245                    OnPropertyChanged("EvaluationPassword");
246                    HasChanges = true;
247                }
248            }
249        }
250
251        private string evaluationDatabase;
252        [TaskPane("Database", "Name of the evaluation database", GroupEvaluation, 3, false, DisplayLevel.Expert, ControlType.TextBox)]
253        public String EvaluationDatabase
254        {
255            get
256            {
257                return evaluationDatabase;
258            }
259            set
260            {
261                if (value != evaluationDatabase)
262                {
263                    evaluationDatabase = value;
264                    OnPropertyChanged("EvaluationDatabase");
265                    HasChanges = true;
266                }
267            }
268        }
269
[2040]270        #region OpenCL
271
[2043]272        [TaskPane("No OpenCL available", null, GroupOpenCL, 1, false, DisplayLevel.Experienced, ControlType.TextBoxReadOnly)]
273        public string NoOpenCL
274        {
275            get { return "No OpenCL Device available!"; }
276            set {}
277        }
278
[2040]279        private void OpenCLGroupVisiblity()
280        {
281            if (TaskPaneAttributeChanged == null)
282                return;
283
284            if (DevicesAvailable.Count == 0)
285            {
286                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLDevice", Visibility.Collapsed)));
[2183]287                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLMode", Visibility.Collapsed)));
[2040]288                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("UseOpenCL", Visibility.Collapsed)));
[2043]289                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("NoOpenCL", Visibility.Visible)));
[2040]290            }
291            else
292            {
293                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLDevice", Visibility.Visible)));
[2183]294                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLMode", Visibility.Visible)));
[2040]295                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("UseOpenCL", Visibility.Visible)));
[2043]296                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("NoOpenCL", Visibility.Collapsed)));
[2040]297            }
298        }
299
300        private int openCLDevice;
[2194]301        [TaskPane("OpenCL Device", "Choose the OpenCL device you want to use.", GroupOpenCL, 1, false, DisplayLevel.Experienced, ControlType.DynamicComboBox, new string[] { "DevicesAvailable" })]
[2040]302        public int OpenCLDevice
303        {
304            get { return this.openCLDevice; }
305            set
306            {
307                if (value != this.openCLDevice)
308                {
309                    this.openCLDevice = value;
[2194]310                    UseOpenCL = deviceSettings[value].useDevice;
311                    OpenCLMode = deviceSettings[value].mode;
[2040]312                    OnPropertyChanged("OpenCLDevice");
313                    HasChanges = true;
314                }
315            }
316        }
317
[2194]318        [TaskPane("Use selected device", "If checked, the selected OpenCL device is used for bruteforcing.",
319            GroupOpenCL, 2, false, DisplayLevel.Experienced, ControlType.CheckBox)]
320        public bool UseOpenCL
321        {
[2200]322            get
323            {
324                if (deviceSettings.Count > OpenCLDevice)
325                    return deviceSettings[OpenCLDevice].useDevice;
326                else
327                    return false;
328            }
[2194]329            set
330            {
[2200]331                if ((deviceSettings.Count > OpenCLDevice) && (value != deviceSettings[OpenCLDevice].useDevice))
[2194]332                {
333                    deviceSettings[OpenCLDevice].useDevice = value;
334                    hasChanges = true;
335                    OnPropertyChanged("UseOpenCL");
336                }
337            }
338        }
339
[2161]340        [TaskPane("OpenCL Mode", "Choose the OpenCL mode you want to use.", GroupOpenCL, 3, false, DisplayLevel.Experienced, ControlType.RadioButton, new string[] { "Low Load", "Normal Load", "High Load (use with caution)" })]
341        public int OpenCLMode
342        {
[2200]343            get
344            {
345                if (deviceSettings.Count > OpenCLDevice)
346                    return deviceSettings[OpenCLDevice].mode;
347                else
348                    return 0;
349            }
[2161]350            set
351            {
[2200]352                if ((deviceSettings.Count > OpenCLDevice) && (value != deviceSettings[OpenCLDevice].mode))
[2161]353                {
[2194]354                    deviceSettings[OpenCLDevice].mode = value;
[2161]355                    OnPropertyChanged("OpenCLMode");
356                    HasChanges = true;
357                }
358            }
359        }
360
[2040]361        private ObservableCollection<string> devicesAvailable = new ObservableCollection<string>();
362        public ObservableCollection<string> DevicesAvailable
363        {
364            get { return devicesAvailable; }
365            set
366            {
367                if (value != devicesAvailable)
368                {
369                    devicesAvailable = value;
370                }
371                OnPropertyChanged("DevicesAvailable");
372            }
373        }
374
375        #endregion
376
[2200]377        #region external client
378
379        private bool useExternalClient = false;
380        [TaskPane("Use external client", "If checked, external clients are allowed to connect to this CrypTool 2.0 instance to support the bruteforce process.",
381            GroupExternalClient, 1, false, DisplayLevel.Experienced, ControlType.CheckBox)]
382        public bool UseExternalClient
383        {
384            get { return useExternalClient; }
385            set
386            {
387                if (value != useExternalClient)
388                {
389                    useExternalClient = value;
390                    hasChanges = true;
391                    OnPropertyChanged("UseExternalClient");
392                }
393            }
394        }
395
396        private int port = 6234;
397        [TaskPane("Port", "Port on which to listen for external clients.", GroupExternalClient, 2, false, DisplayLevel.Experienced, ControlType.TextBox)]
398        public int Port
399        {
400            get { return port; }
401            set
402            {
403                if (value != port)
404                {
405                    port = value;
406                    hasChanges = true;
407                    OnPropertyChanged("Port");
408                }
409            }
410        }
411
412        #endregion
413
[2263]414        #region csv path
415        /// <summary>
416        /// Getter/Setter for the csv file
417        /// </summary>
418        [TaskPane("Select the Comma-Seperated-Values file", "Select the folder and csv file you want to use.", GroupStatisticPath, 1, false, DisplayLevel.Beginner, ControlType.SaveFileDialog, FileExtension = "Comma Seperated Values (*.csv)|*.csv")]
419        public string CsvPath
420        {
421            get { return csvPath; }
422            set
423            {
424                if (value != csvPath)
425                {
426                    csvPath = value;
427                    HasChanges = true;
428                    OnPropertyChanged("CsvPath");
429                }
430            }
431        }
432
433        /// <summary>
434        /// Button to "reset" the csv file. That means it will not appear any more in the text field
435        /// </summary>
436        [TaskPane("Default file", "Use the default folder %APPDATA%\\Local\\CrypTool2", GroupStatisticPath, 2, false, DisplayLevel.Beginner, ControlType.Button)]
437        public void DefaultPath()
438        {
439            csvPath = null;
440            OnPropertyChanged("CsvPath");
441        }
442        #endregion
443
[754]444        private ObservableCollection<string> coresAvailable = new ObservableCollection<string>();
445        public ObservableCollection<string> CoresAvailable
446        {
447            get { return coresAvailable; }
448            set
449            {
450                if (value != coresAvailable)
451                {
452                    coresAvailable = value;
453                }
454                OnPropertyChanged("CoresAvailable");
455            }
456        }
[1634]457
[676]458        #region ISettings Members
459
460        private bool hasChanges;
461
462        public bool HasChanges
463        {
464            get
465            {
466                return hasChanges;
467            }
468            set
469            {
470                hasChanges = value;
471                OnPropertyChanged("HasChanges");
472            }
473        }
474
475        #endregion
476
477        #region INotifyPropertyChanged Members
478
479        public event PropertyChangedEventHandler PropertyChanged;
480
481        private void OnPropertyChanged(string p)
482        {
483            if (PropertyChanged != null)
484            {
485                PropertyChanged(this, new PropertyChangedEventArgs(p));
486            }
487        }
488
489        #endregion
[409]490    }
491}
Note: See TracBrowser for help on using the repository browser.