TLCube.com

/* 
    Need a small utility which chould be started to run in the background and monitors a folder 
    for specific files when it finds a file it should open it with an application. 
 
    I have an application on the server which creates files for users in their
    folder (e.g. "\\server\user"), I need a client side program which should 
    run on the users computer and monitor that folder (local or network share) 
    and open the file when it finds it.
 
    Program should be self contained as a single executable file and should not need 
    an installer or any additional libraries/files.
 
    The program should take command line arguments as described further, when 
    started with no arguments the program should just output a message box with brief 
    usage instructions.
 
    The program should not open the file untill the server finishes writing it.
    Program needs no GUI and needs to be run in the background untill killed or 
    computer is shut down.
 
    Program should use minimum resources (less than 5MB ram and less that 2% CPU).
    Variables need to be expanded in the arguments (e.g. %username%)
    The system should not stop working or give any errors if it can't find the 
    path that it monitors (e.g. a network drive that got disconnected) even for
    extended periods of time, should also not crash for any other errors.
 
    The arguments it needs to take:
    /f:<folder to watch> -  /f:"C:\Temp" or /f:"\\server\user\%username%"
    /e:<file extensions to watch>  -    /e:*.txt
    /x:<application to open file>    -    /x:"C:\WINDOWS\NOTEPAD.EXE" 
      (if "" is used or /X: is omitted use default windows program for this filetype)
    /d - optional, if present delete all files in the watched folder when started
 
    FolderMon.exe /f:"\\server\%username% /e:*.txt /x:"C:\WINDOWS\NOTEPAD.EXE" /d
    Developer should fix any bugs if found in the first 3 months after 
    payment without any charge.
 
    Program should keep a log file (in the same path as the executable file is)
    which should log every action (date-time, filename found whetrher opened  etc.),
    the log file should be deleted when the program starts 
    (to avoid getting large log files).
 
    Program should run with normal "User" rights 
 */
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Collections.Specialized;
using System.Text.RegularExpressions;
using System.IO;
using System.Diagnostics;
using System.Threading;
 
namespace FolderMon
{
    public partial class FolderMon : Form
    {
        String Folder;
        String Extension;
        String Application;
        Boolean Delete;
 
        public FolderMon()
        {
            InitializeComponent();
        }
 
        /// <summary>
        /// Application main logic is here.
        /// </summary>
        private void Form1_Load(object sender, EventArgs e)
        {
            // Hide window
            this.WindowState = FormWindowState.Minimized;
            this.ShowInTaskbar = false;
            this.Visible = false;
 
            // Handle command line switchs.
            HandleCommandLine();
 
            // Delete old log file
            File.Delete(Program.AppPath() + "FolderMon.txt");
 
            // Log parameters file.
            Program.LogMessageToFile("Application started");
            Program.LogMessageToFile("Folder: " + Folder);
            Program.LogMessageToFile("Extension: " + Extension);
            Program.LogMessageToFile("Application:" + Application);
            Program.LogMessageToFile("Delete: " + (Delete ? "True" : "False"));
 
            // Delete all files in Watching folder if /D is used.
            if (Delete)
            {
                string[] List = Directory.GetFiles(Folder);
                foreach (string f in List)
                {
                    FileInfo fi = new FileInfo(f);
                    fi.Delete();
                }
            }
 
            // Create a new FileSystemWatcher and enable it.
            FileSystemWatcher watcher = new FileSystemWatcher();
            watcher.Filter = Extension;
            watcher.Created += new
            FileSystemEventHandler(watcher_FileCreated);
            watcher.Path = Folder;
            watcher.EnableRaisingEvents = true;
        }
 
        /// <summary>
        /// Handle the command line.
        /// </summary>
        void HandleCommandLine()
        {
            //create an instance of the parser
            String[] args = Environment.GetCommandLineArgs();
            CommandLineParser parser = new CommandLineParser(args);
            const string Help = "FolderMon /f:\"C:\\foo\" /e:\"*.txt\"\n\n" +
                                "/f:<folder to watch>\n" +
                                "/e:<file extensions to watch>\n" +
                                "/x:<application to open file> (optional)\n" +
                                "/d delete all files in the watched folder(optional)";
 
            if (parser["f"] != null)
                Folder = Environment.ExpandEnvironmentVariables(parser["f"]); 
            else
            {
                MessageBox.Show(Help,"FolderMon");
                Environment.Exit(0);
            }
            if (parser["e"] != null)
                Extension = parser["e"];
            else
            {
                MessageBox.Show(Help, "FolderMon");
                Environment.Exit(0);
            }
            if (parser["x"] != null)
                Application = Environment.ExpandEnvironmentVariables(parser["x"]);
            if (parser["d"] != null)
                Delete = true;                       
        }
 
        /// <summary>
        /// Run when new file is created to watch folder.
        /// </summary>
        void watcher_FileCreated(object sender, FileSystemEventArgs e)
        {
            String run;
 
            if(Application != null)
                run = Application + e.FullPath;
            else
                run = e.FullPath;
 
            Program.LogMessageToFile("Run: " + run);
            System.Diagnostics.Process.Start(run);
        }
    }
 
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.ThreadException += new ThreadExceptionEventHandler(
                 Application_ThreadException);
 
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new FolderMon());
        }
 
        /// <summary>
        /// Custom error handler.
        /// </summary>
        private static void Application_ThreadException(object sender, ThreadExceptionEventArgs e)
        {
            string errorMsg = "An error occurred please contact the adminstrator " +
                              "with the following information:\n\n";
            errorMsg = errorMsg + e.Exception.Message + "\n\nStack Trace:\n" + e.Exception.StackTrace;
            LogMessageToFile(errorMsg);
            // Application.ExitThread(); 
        }
 
        /// <summary>
        /// Return application path. 
        /// Hack: Best way?
        /// </summary>        
        internal static string AppPath()
        {
            return Application.StartupPath + "\\";
            //return System.Environment.CurrentDirectory;
        }
 
        /// <summary>
        /// Write simple log file.
        /// </summary>        
        internal static void LogMessageToFile(string msg)
        {
            System.IO.StreamWriter sw = System.IO.File.AppendText(
                AppPath() + "FolderMon.txt");
            try
            {
                string logLine = System.String.Format(
                    "{0:G}: {1}", System.DateTime.Now, msg);
                sw.WriteLine(logLine);
            }
            finally
            {
                sw.Close();
            }
        }
    }
 
 
    public class CommandLineParser
    {
        private StringDictionary parameters;
 
        public CommandLineParser(string[] arguments)
        {
            //create our stringDictionary Object for holding
            //the resulting key/value pairs
            parameters = new StringDictionary();
 
            //create a RegEx Object for splitting the parameters
            Regex paramSplit = new Regex(@"^-{1,2}|^/|=|:", RegexOptions.IgnoreCase | RegexOptions.Compiled);
 
            //create a RegEx Object for removing trailing & 
            //leading single and double quotes
            Regex paramRemover = new Regex(@"^['""]?(.*?)['""]?$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
 
            string param = null;
            string[] paramParts;
            //loop through each item in the arguments array
            foreach (string str in arguments)
            {
                //split the parameter array
                paramParts = paramSplit.Split(str, 3);
                //use a switch statement to tell the parser what
                //to do for each possible length of the array
                switch (paramParts.Length)
                {
                    case 1:
                        if (param != null)
                        {
                            if (!parameters.ContainsKey(param))
                            {
                                paramParts[0] = paramRemover.Replace(paramParts[0], "$1");
                                parameters.Add(param, paramParts[0]);
                            }
                            param = null;
                        }
                        break;
                    //here we found just a parameter
                    case 2:
                        // The last parameter is still waiting. 
                        // With no value, set it to true.
                        if (param != null)
                        {
                            if (!parameters.ContainsKey(param))
                                parameters.Add(param, "true");
                        }
                        param = paramParts[1];
                        break;
                    //here we found a parameter with a value
                    case 3:
                        // The last parameter is still waiting. 
                        // With no value, set it to true.
                        if (param != null)
                        {
                            if (!parameters.ContainsKey(param))
                                parameters.Add(param, "true");
                        }
                        param = paramParts[1];
                        // Remove possible enclosing characters (",')
                        if (!parameters.ContainsKey(param))
                        {
                            paramParts[2] = paramRemover.Replace(paramParts[2], "$1");
                            parameters.Add(param, paramParts[2]);
                        }
                        param = null;
                        break;
                }
            }
            // In case a parameter is still waiting
            if (param != null)
            {
                if (!(parameters.ContainsKey(param)))
                {
                    parameters.Add(param, "true");
                }
            }
        }
 
        /// <summary>
        /// indexer to retrieve the parameters value if it exists
        /// </summary>
        /// <param name="param">parameter we want the value for</param>
        /// <returns></returns>
        public string this[string param]
        {
            get
            {
                return (parameters[param]);
            }
        }
    }
}