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

Last change on this file since 2040 was 2040, checked in by Sven Rech, 11 years ago
  • added OpenCL.Net project
  • added OpenCL settings in KeySearcher
  • changed rereservation status message behavior
File size: 12.7 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 = 0; 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        private bool useOpenCL;
246        [TaskPane("Use OpenCL", "If checked, an OpenCL device is used for bruteforcing.",
247            GroupOpenCL, 1, false, DisplayLevel.Experienced, ControlType.CheckBox)]
248        public bool UseOpenCL
249        {
250            get { return useOpenCL; }
251            set
252            {
253                if (value != useOpenCL)
254                {
255                    useOpenCL = value;
256                    hasChanges = true;
257                    OnPropertyChanged("UseOpenCL");
258
259                    DeviceVisibility();
260                }
261            }
262        }
263
264        private void DeviceVisibility()
265        {
266            if (TaskPaneAttributeChanged == null)
267                return;
268
269            Visibility visibility = UseOpenCL ? Visibility.Visible : Visibility.Collapsed;
270            TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLDevice", visibility)));
271        }
272
273        private void OpenCLGroupVisiblity()
274        {
275            if (TaskPaneAttributeChanged == null)
276                return;
277
278            if (DevicesAvailable.Count == 0)
279            {
280                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLDevice", Visibility.Collapsed)));
281                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("UseOpenCL", Visibility.Collapsed)));
282            }
283            else
284            {
285                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLDevice", Visibility.Visible)));
286                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("UseOpenCL", Visibility.Visible)));
287                DeviceVisibility();
288            }
289        }
290
291        private int openCLDevice;
292        [TaskPane("OpenCL Device", "Choose the OpenCL you want to use.", GroupOpenCL, 2, false, DisplayLevel.Experienced, ControlType.DynamicComboBox, new string[] { "DevicesAvailable" })]
293        public int OpenCLDevice
294        {
295            get { return this.openCLDevice; }
296            set
297            {
298                if (value != this.openCLDevice)
299                {
300                    this.openCLDevice = value;
301                    OnPropertyChanged("OpenCLDevice");
302                    HasChanges = true;
303                }
304            }
305        }
306
307        private ObservableCollection<string> devicesAvailable = new ObservableCollection<string>();
308        public ObservableCollection<string> DevicesAvailable
309        {
310            get { return devicesAvailable; }
311            set
312            {
313                if (value != devicesAvailable)
314                {
315                    devicesAvailable = value;
316                }
317                OnPropertyChanged("DevicesAvailable");
318            }
319        }
320
321        #endregion
322
323        private ObservableCollection<string> coresAvailable = new ObservableCollection<string>();
324        public ObservableCollection<string> CoresAvailable
325        {
326            get { return coresAvailable; }
327            set
328            {
329                if (value != coresAvailable)
330                {
331                    coresAvailable = value;
332                }
333                OnPropertyChanged("CoresAvailable");
334            }
335        }
336
337        #region ISettings Members
338
339        private bool hasChanges;
340
341        public bool HasChanges
342        {
343            get
344            {
345                return hasChanges;
346            }
347            set
348            {
349                hasChanges = value;
350                OnPropertyChanged("HasChanges");
351            }
352        }
353
354        #endregion
355
356        #region INotifyPropertyChanged Members
357
358        public event PropertyChangedEventHandler PropertyChanged;
359
360        private void OnPropertyChanged(string p)
361        {
362            if (PropertyChanged != null)
363            {
364                PropertyChanged(this, new PropertyChangedEventArgs(p));
365            }
366        }
367
368        #endregion
369    }
370}
Note: See TracBrowser for help on using the repository browser.