BosMon Webserver first Running Version

[v1.6.2] Adding a Test for Lora Binary

CmdArgs.cs

@@ -38,7 +38,7 @@ namespace BlubbFish.Utils
       public ArgTouple(String type)
       {
         this.Type = type;
-        this.Data = "";
+        this.Data = null;
       }
       public String Type { get; private set; }
       public String Data { get; private set; }
@@ -100,7 +100,8 @@ namespace BlubbFish.Utils
             if (this.args.Length > i + 1) {
               arg.SetData(this.args[++i]);
             } else {
-              throw new ArgumentException();
+              Console.WriteLine(this.GetUsageList(""));
+              throw new ArgumentException("Argument: "+this.args[i]+" missing second argument.");
             }
           }
           this.argList.Add(arg);
@@ -142,12 +143,10 @@ namespace BlubbFish.Utils
       foreach (ArgTouple t in this.argList) {
         if (t.Type == name && t.Data != null) {
           return t.Data;
-        } else {
+        }
+      }
       throw new ArgumentNullException();
     }
-      }
-      return null;
-    }
 
     public Boolean HasAllRequiredArguments()
     {

FileLogger.cs

@@ -11,7 +11,7 @@ namespace BlubbFish.Utils
   {
     private static Dictionary<String, FileLogger> instances = new Dictionary<String, FileLogger>();
     private static String logDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar;
-    private StreamWriter file;
+    private readonly StreamWriter file;
     private FileLogger(String filename, Boolean append)
     {
       filename = logDir + filename;

Helper.cs

@@ -0,0 +1,98 @@
+using System;
+using System.ComponentModel;
+using System.Reflection;
+
+namespace BlubbFish.Utils {
+  public static class Helper {
+    #region PropertyHelper
+    public static Boolean HasProperty(this Object o, String type) {
+      Type t = o.GetType();
+      foreach (PropertyInfo item in t.GetProperties()) {
+        if (item.Name == type) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    public static Object GetProperty(this Object o, String name) {
+      PropertyInfo prop = o.GetType().GetProperty(name);
+      if (prop.CanRead) {
+        return prop.GetValue(o);
+      }
+      return null;
+    }
+
+    public static void SetProperty(this Object o, String name, String value) {
+      PropertyInfo prop = o.GetType().GetProperty(name);
+      if (prop.CanWrite) {
+        if (prop.PropertyType == typeof(Boolean) && Boolean.TryParse(value, out Boolean vb)) {
+          prop.SetValue(o, vb);
+        } else if (prop.PropertyType == typeof(Byte) && Byte.TryParse(value, out Byte v8)) {
+          prop.SetValue(o, v8);
+        } else if (prop.PropertyType == typeof(Int32) && Int32.TryParse(value, out Int32 v32)) {
+          prop.SetValue(o, v32);
+        } else if (prop.PropertyType == typeof(Single) && Single.TryParse(value, out Single vs)) {
+          prop.SetValue(o, vs);
+        } else if (prop.PropertyType == typeof(Double) && Double.TryParse(value, out Double vd)) {
+          prop.SetValue(o, vd);
+        } else if (prop.PropertyType == typeof(Int64) && Int64.TryParse(value, out Int64 v64)) {
+          prop.SetValue(o, v64);
+        } else if (prop.PropertyType.BaseType == typeof(Enum)) {
+          try {
+            prop.SetValue(o, Enum.Parse(prop.PropertyType, value));
+          } catch (Exception) { }
+        }
+      }
+    }
+    #endregion
+
+    #region InterfaceHelper
+    public static Boolean HasInterface(this Type o, Type interf) {
+      foreach (Type item in o.GetInterfaces()) {
+        if (item == interf) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    public static Boolean HasAbstract(this Type o, Type type) {
+      if (o.BaseType == type) {
+        return true;
+      }
+      return false;
+    }
+    #endregion
+
+    #region StringHelper
+    public static String GetEnumDescription(Enum value) {
+      FieldInfo fi = value.GetType().GetField(value.ToString());
+
+      DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);
+
+      if (attributes != null && attributes.Length > 0) {
+        return attributes[0].Description;
+      } else {
+        return value.ToString();
+      }
+    }
+
+    public static String ToUpperLower(this String s) {
+      if (s.Length == 0) {
+        return "";
+      }
+      if (s.Length == 1) {
+        return s.ToUpper();
+      }
+      return s[0].ToString().ToUpper() + s.Substring(1).ToLower();
+    }
+
+    public static void WriteError(String text) {
+      Console.ForegroundColor = ConsoleColor.Red;
+      Console.Error.WriteLine("ERROR: " + text);
+      Console.ResetColor();
+    }
+    #endregion
+  }
+}

InIReader.cs

@@ -2,23 +2,57 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text;
 using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 
-namespace BlubbFish.Utils
+namespace BlubbFish.Utils {
-{
   public class InIReader : IDisposable
   {
     private Dictionary<String, Dictionary<String, String>> inifile;
-    private FileSystemWatcher k = new FileSystemWatcher(Directory.GetCurrentDirectory(), "*.ini");
+    private readonly FileSystemWatcher k;
-    private String filename;
+    private readonly String filename;
+    private static List<String> search_path = new List<String>() {
+      Directory.GetCurrentDirectory()
+    };
 
     private static Dictionary<String, InIReader> instances = new Dictionary<String, InIReader>();
 
+    public static void SetSearchPath(List<String> directorys) {
+      search_path.AddRange(directorys);
+    }
+
+    public static Boolean ConfigExist(String filename) {
+      foreach (String path in search_path) {
+        if (File.Exists(path + Path.DirectorySeparatorChar + filename)) {
+          return true;
+        } else if (File.Exists(path + Path.DirectorySeparatorChar + filename + ".ini")) {
+          return true;
+        } else if (File.Exists(path + Path.DirectorySeparatorChar + filename + ".conf")) {
+          return true;
+        }
+      }
+      return false;
+    }
+
     private InIReader(String filename)
     {
-      this.filename = filename;
+      foreach (String path in search_path) {
+        if (File.Exists(path + Path.DirectorySeparatorChar + filename)) {
+          this.filename = path + Path.DirectorySeparatorChar + filename;
+          this.k = new FileSystemWatcher(path, filename);
+          break;
+        } else if (File.Exists(path + Path.DirectorySeparatorChar + filename + ".ini")) {
+          this.filename = path + Path.DirectorySeparatorChar + filename + ".ini";
+          this.k = new FileSystemWatcher(path, filename + ".ini");
+          break;
+        } else if(File.Exists(path + Path.DirectorySeparatorChar + filename + ".conf")) {
+          this.filename = path + Path.DirectorySeparatorChar + filename + ".conf";
+          this.k = new FileSystemWatcher(path, filename + ".conf");
+          break;
+        }
+      }
+      if(this.filename == null) {
+        throw new ArgumentException(filename + " not found!");
+      }
       this.k.Changed += new FileSystemEventHandler(this.ReadAgain);
       LoadFile();
     }

OwnModel.cs

@@ -9,7 +9,7 @@ namespace BlubbFish.Utils
   public abstract class OwnModel<T> where T : class
   {
     private static readonly Lazy<T> _instance = new Lazy<T>(() => CreateInstanceOfT());
-    private List<OwnView> observer = new List<OwnView>();
+    private readonly List<OwnView> observer = new List<OwnView>();
     public static T Instance
     {
       get {
@@ -35,5 +35,6 @@ namespace BlubbFish.Utils
       this.observer.ForEach(delegate (OwnView view) { view.Update(); });
     }
     abstract protected void Init();
+    abstract public void Dispose();
   }
 }

ProgramLogger.cs

@@ -0,0 +1,165 @@
+using System;
+using System.IO;
+using System.Reflection;
+using System.Security;
+using System.Security.Permissions;
+using System.Text;
+
+namespace BlubbFish.Utils {
+  public class ProgramLogger {
+    private FileWriter fw;
+    private ConsoleWriter stdout;
+    private ConsoleWriter errout;
+    private String loggerfile;
+
+    public ProgramLogger() {
+      this.loggerfile = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar + "output.log";
+      this.Init(this.loggerfile);
+      this.AttachToFw();
+      this.SetOutputs();
+    }
+
+    private void SetOutputs() {
+      Console.SetOut(this.stdout);
+      Console.SetError(this.errout);
+    }
+
+    private void Init(String file) {
+      if(!this.IsWritable(file)) {
+        Console.Error.WriteLine("Cannot write to " + file);
+        throw new ArgumentException("Cannot write to " + file);
+      }
+      this.fw = new FileWriter(file);
+      this.stdout = new ConsoleWriter(Console.Out, ConsoleWriterEventArgs.ConsoleType.Info);
+      this.errout = new ConsoleWriter(Console.Error, ConsoleWriterEventArgs.ConsoleType.Error);
+    }
+
+    private Boolean IsWritable(String filename) {
+      FileIOPermission writePermission = new FileIOPermission(FileIOPermissionAccess.Write, filename);
+      PermissionSet p = new PermissionSet(PermissionState.None);
+      p.AddPermission(writePermission);
+      if (!p.IsSubsetOf(AppDomain.CurrentDomain.PermissionSet)) {
+        return false;
+      }
+      try {
+        using (FileStream fstream = new FileStream(filename, FileMode.Append))
+        using (TextWriter writer = new StreamWriter(fstream)) {
+          writer.Write("");
+        }
+      } catch (UnauthorizedAccessException) {
+        return false;
+      }
+      return true;
+    }
+
+    public void SetPath(String file) {
+      if(file == null) {
+        return;
+      }
+      if (!this.IsWritable(file)) {
+        Console.Error.WriteLine("Cannot write to " + file);
+        throw new ArgumentException("Cannot write to " + file);
+      }
+      this.DisattachToFw();
+      this.fw.Close();
+      if(new FileInfo(this.loggerfile).Length > 0) {
+        File.Move(this.loggerfile, file);
+      } else {
+        File.Delete(this.loggerfile);
+      }
+      this.loggerfile = file;
+      this.fw = new FileWriter(this.loggerfile);
+      this.AttachToFw();
+    }
+
+    private void DisattachToFw() {
+      this.stdout.WriteEvent -= this.fw.Write;
+      this.stdout.WriteLineEvent -= this.fw.WriteLine;
+      this.errout.WriteEvent -= this.fw.WriteLine;
+      this.errout.WriteLineEvent -= this.fw.WriteLine;
+    }
+    private void AttachToFw() {
+      this.stdout.WriteEvent += this.fw.Write;
+      this.stdout.WriteLineEvent += this.fw.WriteLine;
+      this.errout.WriteEvent += this.fw.WriteLine;
+      this.errout.WriteLineEvent += this.fw.WriteLine;
+    }
+  }
+
+  internal class FileWriter : StreamWriter {
+    private Boolean newline = true;
+    public FileWriter(String path) : base(path) {
+    }
+
+    public override Encoding Encoding { get { return Encoding.UTF8; } }
+    public override Boolean AutoFlush { get { return true; } set { base.AutoFlush = value; } }
+
+    private void Write(String value, TextWriter origstream, ConsoleWriterEventArgs.ConsoleType type) {
+      String text = "";
+      if (this.newline) {
+        text = "[" + DateTime.Now.ToString("o") + "]-" + type.ToString() + ": " + value;
+        this.newline = false;
+      } else {
+        text = value;
+      }
+      origstream.Write(text);
+      base.Write(text);
+      base.Flush();
+    }
+
+    private void WriteLine(String value, TextWriter origstream, ConsoleWriterEventArgs.ConsoleType type) {
+      String text = "[" + DateTime.Now.ToString("o") + "]-" + type.ToString() + ": " + value;
+      origstream.WriteLine(text);
+      base.WriteLine(text);
+      this.newline = true;
+      base.Flush();
+    }
+
+    internal void Write(Object sender, ConsoleWriterEventArgs e) {
+      this.Write(e.Value, e.Writer, e.StreamType);
+    }
+
+    internal void WriteLine(Object sender, ConsoleWriterEventArgs e) {
+      this.WriteLine(e.Value, e.Writer, e.StreamType);
+    }
+  }
+
+  internal class ConsoleWriterEventArgs : EventArgs {
+    public String Value { get; private set; }
+    public TextWriter Writer { get; private set; }
+    public ConsoleType StreamType { get; private set; }
+
+    public enum ConsoleType {
+      Info,
+      Error
+    }
+
+    public ConsoleWriterEventArgs(String value, TextWriter writer, ConsoleType type) {
+      this.Value = value;
+      this.Writer = writer;
+      this.StreamType = type;
+    }
+  }
+
+  internal class ConsoleWriter : TextWriter {
+    private readonly TextWriter stream;
+    private readonly ConsoleWriterEventArgs.ConsoleType streamtype;
+
+    public ConsoleWriter(TextWriter writer, ConsoleWriterEventArgs.ConsoleType type) {
+      this.stream = writer;
+      this.streamtype = type;
+    }
+
+    public override Encoding Encoding { get { return Encoding.UTF8; } }
+    public override void Write(String value) {
+      this.WriteEvent?.Invoke(this, new ConsoleWriterEventArgs(value, this.stream, this.streamtype));
+      base.Write(value);
+    }
+    public override void WriteLine(String value) {
+      this.WriteLineEvent?.Invoke(this, new ConsoleWriterEventArgs(value, this.stream, this.streamtype));
+      base.WriteLine(value);
+    }
+    public event EventHandler<ConsoleWriterEventArgs> WriteEvent;
+    public event EventHandler<ConsoleWriterEventArgs> WriteLineEvent;
+  }
+}

Properties/AssemblyInfo.cs

@@ -10,7 +10,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("Utils")]
-[assembly: AssemblyCopyright("Copyright ©  2014 - 22.12.2017")]
+[assembly: AssemblyCopyright("Copyright ©  2014 - 02.10.2018")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
@@ -32,5 +32,9 @@ using System.Runtime.InteropServices;
 // Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern 
 // übernehmen, indem Sie "*" eingeben:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.6.0")]
+[assembly: AssemblyVersion("1.4.0")]
-[assembly: AssemblyFileVersion("1.0.6.0")]
+[assembly: AssemblyFileVersion("1.4.0")]
+
+/**
+ * 1.4.0 Add Helper to Utils
+ */

Utils.csproj

@@ -45,11 +45,13 @@
     <Compile Include="EventArgsHelper.cs" />
     <Compile Include="FileLogger.cs" />
     <Compile Include="FileMutex.cs" />
+    <Compile Include="Helper.cs" />
     <Compile Include="InIReader.cs" />
     <Compile Include="OwnController.cs" />
     <Compile Include="OwnModel.cs" />
     <Compile Include="OwnObject.cs" />
     <Compile Include="OwnView.cs" />
+    <Compile Include="ProgramLogger.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Updater.cs" />
   </ItemGroup>