?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* tools/Info.cs: Add --list-backends, --list-static-indexes to
[beagle.git] / Util / Conf.cs
blob097069f9a8eca75b00df6212b15d68f6ca8da9dc
1 //
2 // Conf.cs
3 //
4 // Copyright (C) 2005 Novell, Inc.
5 //
6
7 //
8 // Permission is hereby granted, free of charge, to any person obtaining a copy
9 // of this software and associated documentation files (the "Software"), to deal
10 // in the Software without restriction, including without limitation the rights
11 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 // copies of the Software, and to permit persons to whom the Software is
13 // furnished to do so, subject to the following conditions:
14 //
15 // The above copyright notice and this permission notice shall be included in all
16 // copies or substantial portions of the Software.
17 //
18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24 // SOFTWARE.
25 //
26
27 using System;
28 using System.Collections;
29 using System.IO;
30 using System.Diagnostics;
31 using System.Reflection;
32 using System.Xml.Serialization;
33 using System.Text.RegularExpressions;
34
35 using Beagle.Util;
36
37 namespace Beagle.Util {
38
39 public class Conf {
40
41 // No instantiation
42 private Conf () { }
43
44 public static Hashtable Sections;
45
46 public static IndexingConfig Indexing = null;
47 public static DaemonConfig Daemon = null;
48 public static SearchingConfig Searching = null;
49
50 //#if ENABLE_WEBSERVICES
51 public static NetworkingConfig Networking = null;
52 public static WebServicesConfig WebServices = null;
53 //#endif
54 private static string configs_dir;
55 private static Hashtable mtimes;
56 private static Hashtable subscriptions;
57
58 private static bool watching_for_updates;
59 private static bool update_watch_present;
60
61 private static BindingFlags method_search_flags = BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod;
62
63 public delegate void ConfigUpdateHandler (Section section);
64
65 static Conf ()
66 {
67 Sections = new Hashtable (3);
68 mtimes = new Hashtable (3);
69 subscriptions = new Hashtable (3);
70
71 configs_dir = Path.Combine (PathFinder.StorageDir, "config");
72 if (!Directory.Exists (configs_dir))
73 Directory.CreateDirectory (configs_dir);
74
75 Conf.Load ();
76 }
77
78 public static void WatchForUpdates ()
79 {
80 // Make sure we don't try and watch for updates more than once
81 if (update_watch_present)
82 return;
83
84 if (Inotify.Enabled) {
85 Inotify.Subscribe (configs_dir, OnInotifyEvent, Inotify.EventType.Create | Inotify.EventType.CloseWrite);
86 } else {
87 // Poll for updates every 60 secs
88 GLib.Timeout.Add (60000, new GLib.TimeoutHandler (CheckForUpdates));
89 }
90
91 update_watch_present = true;
92 }
93
94 private static void OnInotifyEvent (Inotify.Watch watch, string path, string subitem, string srcpath, Inotify.EventType type)
95 {
96 if (subitem == "" || watching_for_updates == false)
97 return;
98
99 Load ();
100 }
101
102 private static bool CheckForUpdates ()
103 {
104 if (watching_for_updates)
105 Load ();
106 return true;
107 }
108
109 public static void Subscribe (Type type, ConfigUpdateHandler callback)
110 {
111 if (!subscriptions.ContainsKey (type))
112 subscriptions.Add (type, new ArrayList (1));
113
114 ArrayList callbacks = (ArrayList) subscriptions [type];
115 callbacks.Add (callback);
116 }
117
118 private static void NotifySubscribers (Section section)
119 {
120 Type type = section.GetType ();
121 ArrayList callbacks = (ArrayList) subscriptions [type];
122
123 if (callbacks == null)
124 return;
125
126 foreach (ConfigUpdateHandler callback in callbacks)
127 callback (section);
128 }
129
130 public static void Load ()
131 {
132 Load (false);
133 }
134
135 public static void Load (bool force)
136 {
137 Section temp;
138
139 // FIXME: Yeah
140 LoadFile (typeof (IndexingConfig), Indexing, out temp, force);
141 Indexing = (IndexingConfig) temp;
142 NotifySubscribers (Indexing);
143
144 LoadFile (typeof (DaemonConfig), Daemon, out temp, force);
145 Daemon = (DaemonConfig) temp;
146 NotifySubscribers (Daemon);
147
148 LoadFile (typeof (SearchingConfig), Searching, out temp, force);
149 Searching = (SearchingConfig) temp;
150 NotifySubscribers (Searching);
151
152 //#if ENABLE_WEBSERVICES
153 LoadFile (typeof (NetworkingConfig), Networking, out temp, force);
154 Networking = (NetworkingConfig) temp;
155 NotifySubscribers (Networking);
156
157 LoadFile (typeof (WebServicesConfig), WebServices, out temp, force);
158 WebServices = (WebServicesConfig) temp;
159 NotifySubscribers (WebServices);
160 //#endif
161
162 watching_for_updates = true;
163 }
164
165 public static void Save ()
166 {
167 Save (false);
168 }
169
170 public static void Save (bool force)
171 {
172 foreach (Section section in Sections.Values)
173 if (force || section.SaveNeeded)
174 SaveFile (section);
175 }
176
177 private static bool LoadFile (Type type, Section current, out Section section, bool force)
178 {
179 section = current;
180 object [] attrs = Attribute.GetCustomAttributes (type, typeof (ConfigSection));
181 if (attrs.Length == 0)
182 throw new ConfigException ("Could not find ConfigSection attribute on " + type);
183
184 string sectionname = ((ConfigSection) attrs [0]).Name;
185 string filename = sectionname + ".xml";
186 string filepath = Path.Combine (configs_dir, filename);
187 if (!File.Exists (filepath)) {
188 if (current == null)
189 ConstructDefaultSection (type, sectionname, out section);
190 return false;
191 }
192
193 if (!force && current != null && mtimes.ContainsKey (sectionname) &&
194 File.GetLastWriteTimeUtc (filepath).CompareTo ((DateTime) mtimes [sectionname]) <= 0)
195 return false;
196
197 Logger.Log.Debug ("Loading {0} from {1}", type, filename);
198 FileStream fs = null;
199
200 try {
201 fs = File.Open (filepath, FileMode.Open, FileAccess.Read, FileShare.Read);
202 XmlSerializer serializer = new XmlSerializer (type);
203 section = (Section) serializer.Deserialize (fs);
204 } catch (Exception e) {
205 Logger.Log.Error ("Could not load configuration from {0}: {1}", filename, e.Message);
206 if (fs != null)
207 fs.Close ();
208 if (current == null)
209 ConstructDefaultSection (type, sectionname, out section);
210 return false;
211 }
212
213 fs.Close ();
214 Sections.Remove (sectionname);
215 Sections.Add (sectionname, section);
216 mtimes.Remove (sectionname);
217 mtimes.Add (sectionname, File.GetLastWriteTimeUtc (filepath));
218 return true;
219 }
220
221 private static bool SaveFile (Section section)
222 {
223 Type type = section.GetType ();
224 object [] attrs = Attribute.GetCustomAttributes (type, typeof (ConfigSection));
225 if (attrs.Length == 0)
226 throw new ConfigException ("Could not find ConfigSection attribute on " + type);
227
228 string sectionname = ((ConfigSection) attrs [0]).Name;
229 string filename = sectionname + ".xml";
230 string filepath = Path.Combine (configs_dir, filename);
231
232 Logger.Log.Debug ("Saving {0} to {1}", type, filename);
233 FileStream fs = null;
234
235 try {
236 watching_for_updates = false;
237 fs = new FileStream (filepath, FileMode.Create);
238 XmlSerializer serializer = new XmlSerializer (type);
239 XmlFu.SerializeUtf8 (serializer, fs, section);
240 } catch (Exception e) {
241 if (fs != null)
242 fs.Close ();
243 Logger.Log.Error ("Could not save configuration to {0}: {1}", filename, e);
244 watching_for_updates = true;
245 return false;
246 }
247
248 fs.Close ();
249 mtimes.Remove (sectionname);
250 mtimes.Add (sectionname, File.GetLastWriteTimeUtc (filepath));
251 watching_for_updates = true;
252 return true;
253 }
254
255 private static void ConstructDefaultSection (Type type, string sectionname, out Section section)
256 {
257 ConstructorInfo ctor = type.GetConstructor (Type.EmptyTypes);
258 section = (Section) ctor.Invoke (null);
259 Sections.Remove (sectionname);
260 Sections.Add (sectionname, section);
261 }
262
263 // Lists all config file options in a hash table where key is option name,
264 // and value is description.
265 public static Hashtable GetOptions (Section section)
266 {
267 Hashtable options = new Hashtable ();
268 MemberInfo [] members = section.GetType ().GetMembers (method_search_flags);
269
270 // Find all of the methods ("options") inside the specified section
271 // object which have the ConfigOption attribute.
272 foreach (MemberInfo member in members) {
273 object [] attrs = member.GetCustomAttributes (typeof (ConfigOption), false);
274 if (attrs.Length > 0)
275 options.Add (member.Name, ((ConfigOption) attrs [0]).Description);
276 }
277
278 return options;
279 }
280
281 public static bool InvokeOption (Section section, string option, string [] args, out string output)
282 {
283 MethodInfo method = section.GetType ().GetMethod (option, method_search_flags);
284 if (method == null) {
285 string msg = String.Format ("No such method '{0}' for section '{1}'", option, section);
286 throw new ConfigException(msg);
287 }
288 object [] attrs = method.GetCustomAttributes (typeof (ConfigOption), false);
289 if (attrs.Length == 0) {
290 string msg = String.Format ("Method '{0}' is not a configurable option", option);
291 throw new ConfigException (msg);
292 }
293
294 // Check the required number of parameters have been provided
295 ConfigOption attr = (ConfigOption) attrs [0];
296 if (attr.Params > 0 && args.Length < attr.Params) {
297 string msg = String.Format ("Option '{0}' requires {1} parameter(s): {2}", option, attr.Params, attr.ParamsDescription);
298 throw new ConfigException (msg);
299 }
300
301 object [] methodparams = { null, args };
302 bool result = (bool) method.Invoke (section, methodparams);
303 output = (string) methodparams [0];
304
305 // Mark the section as save-needed if we just changed something
306 if (result && attr.IsMutator)
307 section.SaveNeeded = true;
308
309 return result;
310 }
311
312 [ConfigSection (Name="searching")]
313 public class SearchingConfig : Section {
314
315 private bool autostart = true;
316 public bool Autostart {
317 get { return autostart; }
318 set { autostart = value; }
319 }
320
321 private KeyBinding show_search_window_binding = new KeyBinding ("F12");
322 public KeyBinding ShowSearchWindowBinding {
323 get { return show_search_window_binding; }
324 set { show_search_window_binding = value; }
325 }
326
327 private int max_displayed = 5;
328 public int MaxDisplayed {
329 get { return max_displayed; }
330 set {
331 if (value <= 0)
332 max_displayed = 1;
333 else
334 max_displayed = value;
335 }
336 }
337
338 // Best window position and dimension
339 // stored as percentage of screen co-ordinates
340 // to deal with change of resolution problem - hints from tberman
341
342 private float best_pos_x = 0;
343 public float BestPosX {
344 get { return best_pos_x; }
345 set { best_pos_x = value; }
346 }
347
348 private float best_pos_y = 0;
349 public float BestPosY {
350 get { return best_pos_y; }
351 set { best_pos_y = value; }
352 }
353
354 // dont explicitly set height on first run
355 private float best_width = 0;
356 public float BestWidth {
357 get { return best_width; }
358 set { best_width = value; }
359 }
360
361 private float best_height = 0; // -ditto-
362 public float BestHeight {
363 get { return best_height; }
364 set { best_height = value; }
365 }
366
367 // FIXME Change names when Holmes is released under new name
368 // Holmes window position and dimension
369
370 private float holmes_pos_x = 0;
371 public float HolmesPosX {
372 get { return holmes_pos_x; }
373 set { holmes_pos_x = value; }
374 }
375
376 private float holmes_pos_y = 0;
377 public float HolmesPosY {
378 get { return holmes_pos_y; }
379 set { holmes_pos_y = value; }
380 }
381
382 private float holmes_width = 0;
383 public float HolmesWidth {
384 get { return holmes_width; }
385 set { holmes_width = value; }
386 }
387
388 private float holmes_height = 0;
389 public float HolmesHeight {
390 get { return holmes_height; }
391 set { holmes_height = value; }
392 }
393
394 // ah!We want a Queue but Queue doesnt serialize *easily*
395 private ArrayList search_history = new ArrayList ();
396 public ArrayList SearchHistory {
397 get { return search_history; }
398 set { search_history = value; }
399 }
400
401 }
402
403 [ConfigSection (Name="daemon")]
404 public class DaemonConfig : Section {
405 private ArrayList static_queryables = new ArrayList ();
406 public ArrayList StaticQueryables {
407 get { return static_queryables; }
408 set { static_queryables = value; }
409 }
410
411 // By default, every backend is allowed.
412 // Only maintain a list of denied backends.
413 private ArrayList denied_backends = new ArrayList ();
414 public ArrayList DeniedBackends {
415 get { return denied_backends; }
416 set { denied_backends = value; }
417 }
418
419 private bool allow_static_backend = false; // by default, false
420 public bool AllowStaticBackend {
421 get { return allow_static_backend; }
422 // Don't really want to expose this, but serialization requires it
423 set { allow_static_backend = value; }
424 }
425
426 private bool index_synchronization = true;
427 public bool IndexSynchronization {
428 get { return index_synchronization; }
429 // Don't really want to expose this, but serialization requires it
430 set { index_synchronization = value; }
431 }
432
433 [ConfigOption (Description="Enable a backend", Params=1, ParamsDescription="Name of the backend to enable")]
434 internal bool AllowBackend (out string output, string [] args)
435 {
436 denied_backends.Remove (args [0]);
437 output = "Backend allowed (need to restart beagled for changes to take effect).";
438 return true;
439 }
440
441 [ConfigOption (Description="Disable a backend", Params=1, ParamsDescription="Name of the backend to disable")]
442 internal bool DenyBackend (out string output, string [] args)
443 {
444 denied_backends.Add (args [0]);
445 output = "Backend disabled (need to restart beagled for changes to take effect).";
446 return true;
447 }
448
449 private bool allow_root = false;
450 public bool AllowRoot {
451 get { return allow_root; }
452 set { allow_root = value; }
453 }
454
455 [ConfigOption (Description="Add a static queryable", Params=1, ParamsDescription="Index path")]
456 internal bool AddStaticQueryable (out string output, string [] args)
457 {
458 static_queryables.Add (args [0]);
459 output = "Static queryable added.";
460 return true;
461 }
462
463 [ConfigOption (Description="Remove a static queryable", Params=1, ParamsDescription="Index path")]
464 internal bool DelStaticQueryable (out string output, string [] args)
465 {
466 static_queryables.Remove (args [0]);
467 output = "Static queryable removed.";
468 return true;
469 }
470
471 [ConfigOption (Description="List user-specified static queryables", IsMutator=false)]
472 internal bool ListStaticQueryables (out string output, string [] args)
473 {
474 output = "User-specified static queryables:\n";
475 foreach (string index_path in static_queryables)
476 output += String.Format (" - {0}\n", index_path);
477 return true;
478 }
479
480 [ConfigOption (Description="Toggles whether static indexes will be enabled")]
481 internal bool ToggleAllowStaticBackend (out string output, string [] args)
482 {
483 allow_static_backend = !allow_static_backend;
484 output = "Static indexes are " + ((allow_static_backend) ? "enabled" : "disabled") + " (need to restart beagled for changes to take effect).";
485 return true;
486 }
487
488 [ConfigOption (Description="Toggles whether your indexes will be synchronized locally if your home directory is on a network device (eg. NFS/Samba)")]
489 internal bool ToggleIndexSynchronization (out string output, string [] args)
490 {
491 index_synchronization = !index_synchronization;
492 output = "Index Synchronization is " + ((index_synchronization) ? "enabled" : "disabled") + ".";
493 return true;
494 }
495
496 [ConfigOption (Description="Toggles whether Beagle can be run as root")]
497 internal bool ToggleAllowRoot (out string output, string [] args)
498 {
499 allow_root = ! allow_root;
500 if (allow_root)
501 output = "Beagle is now permitted to run as root";
502 else
503 output = "Beagle is no longer permitted to run as root";
504 return true;
505 }
506 }
507
508 [ConfigSection (Name="indexing")]
509 public class IndexingConfig : Section
510 {
511 private ArrayList roots = new ArrayList ();
512 [XmlArray]
513 [XmlArrayItem(ElementName="Root", Type=typeof(string))]
514 public ArrayList Roots {
515 get { return roots; }
516 set { roots = value; }
517 }
518
519 private bool index_home_dir = true;
520 public bool IndexHomeDir {
521 get { return index_home_dir; }
522 set { index_home_dir = value; }
523 }
524
525 private ArrayList excludes = new ArrayList ();
526 [XmlArray]
527 [XmlArrayItem (ElementName="ExcludeItem", Type=typeof(ExcludeItem))]
528 public ArrayList Excludes {
529 get { return excludes; }
530 set { excludes = value; }
531 }
532
533 [ConfigOption (Description="List the indexing roots", IsMutator=false)]
534 internal bool ListRoots (out string output, string [] args)
535 {
536 output = "Current roots:\n";
537 if (this.index_home_dir == true)
538 output += " - Your home directory\n";
539 foreach (string root in roots)
540 output += " - " + root + "\n";
541
542 return true;
543 }
544
545 [ConfigOption (Description="Toggles whether your home directory is to be indexed as a root")]
546 internal bool IndexHome (out string output, string [] args)
547 {
548 if (index_home_dir)
549 output = "Your home directory will not be indexed.";
550 else
551 output = "Your home directory will be indexed.";
552 index_home_dir = !index_home_dir;
553 return true;
554 }
555
556 [ConfigOption (Description="Add a root path to be indexed", Params=1, ParamsDescription="A path")]
557 internal bool AddRoot (out string output, string [] args)
558 {
559 roots.Add (args [0]);
560 output = "Root added.";
561 return true;
562 }
563
564 [ConfigOption (Description="Remove an indexing root", Params=1, ParamsDescription="A path")]
565 internal bool DelRoot (out string output, string [] args)
566 {
567 roots.Remove (args [0]);
568 output = "Root removed.";
569 return true;
570 }
571
572 [ConfigOption (Description="List user-specified resources to be excluded from indexing", IsMutator=false)]
573 internal bool ListExcludes (out string output, string [] args)
574 {
575 output = "User-specified resources to be excluded from indexing:\n";
576 foreach (ExcludeItem exclude_item in excludes)
577 output += String.Format (" - [{0}] {1}\n", exclude_item.Type.ToString (), exclude_item.Value);
578 return true;
579 }
580
581 [ConfigOption (Description="Add a resource to exclude from indexing", Params=2, ParamsDescription="A type [path/pattern/mailfolder], a path/pattern/name")]
582 internal bool AddExclude (out string output, string [] args)
583 {
584 ExcludeType type;
585 try {
586 type = (ExcludeType) Enum.Parse (typeof (ExcludeType), args [0], true);
587 } catch (Exception e) {
588 output = String.Format("Invalid type '{0}'. Valid types: Path, Pattern, MailFolder", args [0]);
589 return false;
590 }
591
592 excludes.Add (new ExcludeItem (type, args [1]));
593 output = "Exclude added.";
594 return true;
595 }
596
597 [ConfigOption (Description="Remove an excluded resource", Params=2, ParamsDescription="A type [path/pattern/mailfolder], a path/pattern/name")]
598 internal bool DelExclude (out string output, string [] args)
599 {
600 ExcludeType type;
601 try {
602 type = (ExcludeType) Enum.Parse (typeof (ExcludeType), args [0], true);
603 } catch (Exception e) {
604 output = String.Format("Invalid type '{0}'. Valid types: Path, Pattern, MailFolder", args [0]);
605 return false;
606 }
607
608 foreach (ExcludeItem item in excludes) {
609 if (item.Type != type || item.Value != args [1])
610 continue;
611 excludes.Remove (item);
612 output = "Exclude removed.";
613 return true;
614 }
615
616 output = "Could not find requested exclude to remove.";
617 return false;
618 }
619
620 }
621
622 //#if ENABLE_WEBSERVICES
623 [ConfigSection (Name="webservices")]
624 public class WebServicesConfig: Section
625 {
626 private ArrayList publicFolders = new ArrayList ();
627 [XmlArray]
628 [XmlArrayItem(ElementName="PublicFolders", Type=typeof(string))]
629 public ArrayList PublicFolders {
630 get { return publicFolders; }
631 set { publicFolders = value; }
632 }
633
634 private bool allowGlobalAccess = true;
635 public bool AllowGlobalAccess {
636 get { return allowGlobalAccess; }
637 set { allowGlobalAccess = value; }
638 }
639
640 [ConfigOption (Description="List the public folders", IsMutator=false)]
641 internal bool ListPublicFolders(out string output, string [] args)
642 {
643 output = "Current list of public folders:\n";
644
645 foreach (string pf in publicFolders)
646 output += " - " + pf + "\n";
647
648 return true;
649 }
650
651 [ConfigOption (Description="Check current configuration of global access to Beagle web-services", IsMutator=false)]
652 internal bool CheckGlobalAccess(out string output, string [] args)
653 {
654 if (allowGlobalAccess)
655 output = "Global Access to Beagle WebServices is currently ENABLED.";
656 else
657 output = "Global Access to Beagle WebServices is currently DISABLED.";
658
659 return true;
660 }
661
662 [ConfigOption (Description="Enable/Disable global access to Beagle web-services")]
663 internal bool SwitchGlobalAccess (out string output, string [] args)
664 {
665 allowGlobalAccess = !allowGlobalAccess;
666
667 if (allowGlobalAccess)
668 output = "Global Access to Beagle WebServices now ENABLED.";
669 else
670 output = "Global Access to Beagle WebServices now DISABLED.";
671
672 return true;
673 }
674
675 [ConfigOption (Description="Add public web-service access to a folder", Params=1, ParamsDescription="A path")]
676 internal bool AddPublicFolder (out string output, string [] args)
677 {
678 publicFolders.Add (args [0]);
679 output = "PublicFolder " + args[0] + " added.";
680 return true;
681 }
682
683 [ConfigOption (Description="Remove public web-service access to a folder", Params=1, ParamsDescription="A path")]
684 internal bool DelPublicFolder (out string output, string [] args)
685 {
686 publicFolders.Remove (args [0]);
687 output = "PublicFolder " + args[0] + " removed.";
688 return true;
689 }
690
691 }
692
693 [ConfigSection (Name="networking")]
694 public class NetworkingConfig: Section
695 {
696 private ArrayList netBeagleNodes = new ArrayList ();
697
698 [XmlArray]
699 [XmlArrayItem(ElementName="NetBeagleNodes", Type=typeof(string))]
700 public ArrayList NetBeagleNodes {
701 get { return netBeagleNodes; }
702 set { netBeagleNodes = value; }
703 }
704
705 [ConfigOption (Description="List Networked Beagle Daemons to query", IsMutator=false)]
706 internal bool ListBeagleNodes (out string output, string [] args)
707 {
708 output = "Current list of Networked Beagle Daemons to query:\n";
709
710 foreach (string nb in netBeagleNodes)
711 output += " - " + nb + "\n";
712
713 return true;
714 }
715
716 [ConfigOption (Description="Add a Networked Beagle Daemon to query", Params=1, ParamsDescription="HostName:PortNo")]
717 internal bool AddBeagleNode (out string output, string [] args)
718 {
719 string node = args[0];
720
721 if (((string[])node.Split(':')).Length < 2)
722 node = args [0].Trim() + ":8888";
723
724 netBeagleNodes.Add(node);
725 output = "Networked Beagle Daemon \"" + node +"\" added.";
726 return true;
727 }
728
729 [ConfigOption (Description="Remove a configured Networked Beagle Daemon", Params=1, ParamsDescription="HostName:PortNo")]
730 internal bool DelBeagleNode (out string output, string [] args)
731 {
732 string node = args[0];
733
734 if (((string[])node.Split(':')).Length < 2)
735 node = args [0].Trim() + ":8888";
736
737 netBeagleNodes.Remove(node);
738 output = "Networked Beagle Daemon \"" + node +"\" removed.";
739 return true;
740 }
741 }
742 //#endif
743
744 public class Section {
745 [XmlIgnore]
746 public bool SaveNeeded = false;
747 }
748
749 private class ConfigOption : Attribute {
750 public string Description;
751 public int Params;
752 public string ParamsDescription;
753 public bool IsMutator = true;
754 }
755
756 private class ConfigSection : Attribute {
757 public string Name;
758 }
759
760 public class ConfigException : Exception {
761 public ConfigException (string msg) : base (msg) { }
762 }
763
764 }
765
766 //////////////////////////////////////////////////////////////////////
767
768 public enum ExcludeType {
769 Path,
770 Pattern,
771 MailFolder
772 }
773
774 public class ExcludeItem {
775
776 private ExcludeType type;
777 private string val;
778
779 [XmlAttribute]
780 public ExcludeType Type {
781 get { return type; }
782 set { type = value; }
783 }
784
785 private string exactMatch;
786 private string prefix;
787 private string suffix;
788 private Regex regex;
789
790 [XmlAttribute]
791 public string Value {
792 get { return val; }
793 set {
794 switch (type) {
795 case ExcludeType.Path:
796 case ExcludeType.MailFolder:
797 prefix = value;
798 break;
799
800 case ExcludeType.Pattern:
801 if (value.StartsWith ("/") && value.EndsWith ("/")) {
802 regex = new Regex (value.Substring (1, value.Length - 2));
803 break;
804 }
805
806 int i = value.IndexOf ('*');
807 if (i == -1) {
808 exactMatch = value;
809 } else {
810 if (i > 0)
811 prefix = value.Substring (0, i);
812 if (i < value.Length-1)
813 suffix = value.Substring (i+1);
814 }
815 break;
816 }
817
818 val = value;
819 }
820 }
821
822 public ExcludeItem () {}
823
824 public ExcludeItem (ExcludeType type, string value) {
825 this.Type = type;
826 this.Value = value;
827 }
828
829 public bool IsMatch (string param)
830 {
831 switch (Type) {
832 case ExcludeType.Path:
833 case ExcludeType.MailFolder:
834 if (prefix != null && ! param.StartsWith (prefix))
835 return false;
836
837 return true;
838
839 case ExcludeType.Pattern:
840 if (exactMatch != null)
841 return param == exactMatch;
842 if (prefix != null && ! param.StartsWith (prefix))
843 return false;
844 if (suffix != null && ! param.EndsWith (suffix))
845 return false;
846 if (regex != null && ! regex.IsMatch (param))
847 return false;
848
849 return true;
850 }
851
852 return false;
853 }
854
855 public override bool Equals (object obj)
856 {
857 ExcludeItem exclude = obj as ExcludeItem;
858 return (exclude != null && exclude.Type == type && exclude.Value == val);
859 }
860
861 public override int GetHashCode ()
862 {
863 return (this.Value.GetHashCode () ^ (int) this.Type);
864 }
865
866 }
867
868 //////////////////////////////////////////////////////////////////////
869
870 public class KeyBinding {
871 public string Key;
872
873 [XmlAttribute]
874 public bool Ctrl = false;
875 [XmlAttribute]
876 public bool Alt = false;
877
878 public KeyBinding () {}
879 public KeyBinding (string key) : this (key, false, false) {}
880
881 public KeyBinding (string key, bool ctrl, bool alt)
882 {
883 Key = key;
884 Ctrl = ctrl;
885 Alt = alt;
886 }
887
888 public override string ToString ()
889 {
890 string result = "";
891
892 if (Ctrl)
893 result += "<Ctrl>";
894 if (Alt)
895 result += "<Alt>";
896
897 result += Key;
898
899 return result;
900 }
901
902 public string ToReadableString ()
903 {
904 return ToString ().Replace (">", "-").Replace ("<", "");
905 }
906 }
907 }
A Beagle Git Repo