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

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

small keysearcher fix

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