Zway-Bot [v1.7.2] Add Logging to some Modules, fixing a bug in overtaker (now it not removes every time all events, so only the latest event are watched)

[Utils] Fixing a bug if more than one argument with params

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;

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 String filename;
+    private readonly FileSystemWatcher k;
+    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,5 @@ 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: AssemblyFileVersion("1.0.6.0")]
+[assembly: AssemblyVersion("1.1.3")]
+[assembly: AssemblyFileVersion("1.1.3")]

Utils.csproj

@@ -50,6 +50,7 @@
     <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>