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

Last change on this file since 2200 was 2200, checked in by Sven Rech, 11 years ago

some keysearcher settings changes

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