Exemplo n.º 1
0
        // Locked by caller
        public static bool GetInstance(out IFileWatcher watcher, bool gamin)
        {
            if (failed == true)
            {
                watcher = null;
                return(false);
            }

            if (instance != null)
            {
                watcher = instance;
                return(true);
            }

            use_gamin = gamin;
            watches   = Hashtable.Synchronized(new Hashtable());
            requests  = Hashtable.Synchronized(new Hashtable());
            if (FAMOpen(out conn) == -1)
            {
                failed  = true;
                watcher = null;
                return(false);
            }

            instance = new FAMWatcher();
            watcher  = instance;
            return(true);
        }
Exemplo n.º 2
0
        public void StartDispatching(FileSystemWatcher fsw)
        {
            FAMData famdata;

            lock (this)
            {
                if (FAMWatcher.thread == null)
                {
                    FAMWatcher.thread = new Thread(new ThreadStart(this.Monitor));
                    FAMWatcher.thread.IsBackground = true;
                    FAMWatcher.thread.Start();
                }
                famdata = (FAMData)FAMWatcher.watches[fsw];
            }
            if (famdata == null)
            {
                famdata                = new FAMData();
                famdata.FSW            = fsw;
                famdata.Directory      = fsw.FullPath;
                famdata.FileMask       = fsw.MangledFilter;
                famdata.IncludeSubdirs = fsw.IncludeSubdirectories;
                if (famdata.IncludeSubdirs)
                {
                    famdata.SubDirs = new Hashtable();
                }
                famdata.Enabled = true;
                FAMWatcher.StartMonitoringDirectory(famdata, false);
                lock (this)
                {
                    FAMWatcher.watches[fsw] = famdata;
                    FAMWatcher.requests[famdata.Request.ReqNum] = famdata;
                    FAMWatcher.stop = false;
                }
            }
        }
Exemplo n.º 3
0
        private static void StartMonitoringDirectory(FAMData data, bool justcreated)
        {
            FAMRequest request;

            if (FAMWatcher.FAMMonitorDirectory(ref FAMWatcher.conn, data.Directory, out request, IntPtr.Zero) == -1)
            {
                throw new System.ComponentModel.Win32Exception();
            }
            FileSystemWatcher fsw = data.FSW;

            data.Request = request;
            if (data.IncludeSubdirs)
            {
                foreach (string text in Directory.GetDirectories(data.Directory))
                {
                    FAMData famdata = new FAMData();
                    famdata.FSW            = data.FSW;
                    famdata.Directory      = text;
                    famdata.FileMask       = data.FSW.MangledFilter;
                    famdata.IncludeSubdirs = true;
                    famdata.SubDirs        = new Hashtable();
                    famdata.Enabled        = true;
                    if (justcreated)
                    {
                        FileSystemWatcher obj = fsw;
                        lock (obj)
                        {
                            RenamedEventArgs renamedEventArgs = null;
                            fsw.DispatchEvents(FileAction.Added, text, ref renamedEventArgs);
                            if (fsw.Waiting)
                            {
                                fsw.Waiting = false;
                                System.Threading.Monitor.PulseAll(fsw);
                            }
                        }
                    }
                    FAMWatcher.StartMonitoringDirectory(famdata, justcreated);
                    data.SubDirs[text] = famdata;
                    FAMWatcher.requests[famdata.Request.ReqNum] = famdata;
                }
            }
            if (justcreated)
            {
                foreach (string filename in Directory.GetFiles(data.Directory))
                {
                    FileSystemWatcher obj2 = fsw;
                    lock (obj2)
                    {
                        RenamedEventArgs renamedEventArgs2 = null;
                        fsw.DispatchEvents(FileAction.Added, filename, ref renamedEventArgs2);
                        fsw.DispatchEvents(FileAction.Modified, filename, ref renamedEventArgs2);
                        if (fsw.Waiting)
                        {
                            fsw.Waiting = false;
                            System.Threading.Monitor.PulseAll(fsw);
                        }
                    }
                }
            }
        }
Exemplo n.º 4
0
 private static void StopMonitoringDirectory(FAMData data)
 {
     if (FAMWatcher.FAMCancelMonitor(ref FAMWatcher.conn, ref data.Request) == -1)
     {
         throw new System.ComponentModel.Win32Exception();
     }
 }
Exemplo n.º 5
0
 public void StopDispatching(FileSystemWatcher fsw)
 {
     lock (this)
     {
         FAMData famdata = (FAMData)FAMWatcher.watches[fsw];
         if (famdata != null)
         {
             FAMWatcher.StopMonitoringDirectory(famdata);
             FAMWatcher.watches.Remove(fsw);
             FAMWatcher.requests.Remove(famdata.Request.ReqNum);
             if (FAMWatcher.watches.Count == 0)
             {
                 FAMWatcher.stop = true;
             }
             if (famdata.IncludeSubdirs)
             {
                 foreach (object obj in famdata.SubDirs.Values)
                 {
                     FAMData famdata2 = (FAMData)obj;
                     FAMWatcher.StopMonitoringDirectory(famdata2);
                     FAMWatcher.requests.Remove(famdata2.Request.ReqNum);
                 }
             }
         }
     }
 }
Exemplo n.º 6
0
 private static int FAMPending(ref FAMConnection fc)
 {
     if (FAMWatcher.use_gamin)
     {
         return(FAMWatcher.gamin_Pending(ref fc));
     }
     return(FAMWatcher.fam_Pending(ref fc));
 }
Exemplo n.º 7
0
 private static int FAMCancelMonitor(ref FAMConnection fc, ref FAMRequest fr)
 {
     if (FAMWatcher.use_gamin)
     {
         return(FAMWatcher.gamin_CancelMonitor(ref fc, ref fr));
     }
     return(FAMWatcher.fam_CancelMonitor(ref fc, ref fr));
 }
Exemplo n.º 8
0
 private static int FAMMonitorDirectory(ref FAMConnection fc, string filename, out FAMRequest fr, IntPtr user_data)
 {
     if (FAMWatcher.use_gamin)
     {
         return(FAMWatcher.gamin_MonitorDirectory(ref fc, filename, out fr, user_data));
     }
     return(FAMWatcher.fam_MonitorDirectory(ref fc, filename, out fr, user_data));
 }
Exemplo n.º 9
0
 private static int FAMClose(ref FAMConnection fc)
 {
     if (FAMWatcher.use_gamin)
     {
         return(FAMWatcher.gamin_Close(ref fc));
     }
     return(FAMWatcher.fam_Close(ref fc));
 }
Exemplo n.º 10
0
 private static int FAMOpen(out FAMConnection fc)
 {
     if (FAMWatcher.use_gamin)
     {
         return(FAMWatcher.gamin_Open(out fc));
     }
     return(FAMWatcher.fam_Open(out fc));
 }
        void InitWatcher()
        {
            lock (lockobj)
            {
                if (watcher != null)
                {
                    return;
                }

                string managed = Environment.GetEnvironmentVariable("MONO_MANAGED_WATCHER");
                int    mode    = 0;
                if (managed == null)
                {
                    mode = InternalSupportsFSW();
                }

                bool ok = false;
                switch (mode)
                {
                case 1: // windows
                    ok = DefaultWatcher.GetInstance(out watcher);
                    //ok = WindowsWatcher.GetInstance (out watcher);
                    break;

                case 2: // libfam
                    ok = FAMWatcher.GetInstance(out watcher, false);
                    break;

                case 3: // kevent
                    ok = KeventWatcher.GetInstance(out watcher);
                    break;

                case 4: // libgamin
                    ok = FAMWatcher.GetInstance(out watcher, true);
                    break;

                case 5: // inotify
                    ok = InotifyWatcher.GetInstance(out watcher, true);
                    break;
                }

                if (mode == 0 || !ok)
                {
                    if (String.Compare(managed, "disabled", true) == 0)
                    {
                        NullFileWatcher.GetInstance(out watcher);
                    }
                    else
                    {
                        DefaultWatcher.GetInstance(out watcher);
                    }
                }

                ShowWatcherInfo();
            }
        }
Exemplo n.º 12
0
        private void InitWatcher()
        {
            object obj = FileSystemWatcher.lockobj;

            lock (obj)
            {
                if (FileSystemWatcher.watcher == null)
                {
                    string environmentVariable = Environment.GetEnvironmentVariable("MONO_MANAGED_WATCHER");
                    int    num = 0;
                    if (environmentVariable == null)
                    {
                        num = FileSystemWatcher.InternalSupportsFSW();
                    }
                    bool flag = false;
                    switch (num)
                    {
                    case 1:
                        flag = DefaultWatcher.GetInstance(out FileSystemWatcher.watcher);
                        break;

                    case 2:
                        flag = FAMWatcher.GetInstance(out FileSystemWatcher.watcher, false);
                        break;

                    case 3:
                        flag = KeventWatcher.GetInstance(out FileSystemWatcher.watcher);
                        break;

                    case 4:
                        flag = FAMWatcher.GetInstance(out FileSystemWatcher.watcher, true);
                        break;

                    case 5:
                        flag = InotifyWatcher.GetInstance(out FileSystemWatcher.watcher, true);
                        break;
                    }
                    if (num == 0 || !flag)
                    {
                        if (string.Compare(environmentVariable, "disabled", true) == 0)
                        {
                            NullFileWatcher.GetInstance(out FileSystemWatcher.watcher);
                        }
                        else
                        {
                            DefaultWatcher.GetInstance(out FileSystemWatcher.watcher);
                        }
                    }
                }
            }
        }
Exemplo n.º 13
0
 private void Monitor()
 {
     while (!FAMWatcher.stop)
     {
         int num;
         lock (this)
         {
             num = FAMWatcher.FAMPending(ref FAMWatcher.conn);
         }
         if (num > 0)
         {
             this.ProcessEvents();
         }
         else
         {
             Thread.Sleep(500);
         }
     }
     lock (this)
     {
         FAMWatcher.thread = null;
         FAMWatcher.stop   = false;
     }
 }
Exemplo n.º 14
0
        private void ProcessEvents()
        {
            ArrayList arrayList = null;

            lock (this)
            {
                string text;
                int    num;
                int    num2;
                while (FAMWatcher.InternalFAMNextEvent(ref FAMWatcher.conn, out text, out num, out num2) == 1)
                {
                    bool flag;
                    switch (num)
                    {
                    case 1:
                    case 2:
                    case 5:
                        flag = FAMWatcher.requests.ContainsKey(num2);
                        break;

                    case 3:
                    case 4:
                    case 6:
                    case 7:
                    case 8:
                    case 9:
                        goto IL_75;

                    default:
                        goto IL_75;
                    }
IL_7D:
                    if (flag)
                    {
                        FAMData famdata = (FAMData)FAMWatcher.requests[num2];
                        if (famdata.Enabled)
                        {
                            FileSystemWatcher fsw              = famdata.FSW;
                            NotifyFilters     notifyFilter     = fsw.NotifyFilter;
                            RenamedEventArgs  renamedEventArgs = null;
                            FileAction        fileAction       = (FileAction)0;
                            if (num == 1 && (notifyFilter & (NotifyFilters.Attributes | NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.Size)) != (NotifyFilters)0)
                            {
                                fileAction = FileAction.Modified;
                            }
                            else if (num == 2)
                            {
                                fileAction = FileAction.Removed;
                            }
                            else if (num == 5)
                            {
                                fileAction = FileAction.Added;
                            }
                            if (fileAction != (FileAction)0)
                            {
                                if (fsw.IncludeSubdirectories)
                                {
                                    string fullPath = fsw.FullPath;
                                    string text2    = famdata.Directory;
                                    if (text2 != fullPath)
                                    {
                                        int length = fullPath.Length;
                                        int num3   = 1;
                                        if (length > 1 && fullPath[length - 1] == Path.DirectorySeparatorChar)
                                        {
                                            num3 = 0;
                                        }
                                        string path = text2.Substring(fullPath.Length + num3);
                                        text2 = Path.Combine(text2, text);
                                        text  = Path.Combine(path, text);
                                    }
                                    else
                                    {
                                        text2 = Path.Combine(fullPath, text);
                                    }
                                    if (fileAction == FileAction.Added && Directory.Exists(text2))
                                    {
                                        if (arrayList == null)
                                        {
                                            arrayList = new ArrayList(4);
                                        }
                                        arrayList.Add(new FAMData
                                        {
                                            FSW            = fsw,
                                            Directory      = text2,
                                            FileMask       = fsw.MangledFilter,
                                            IncludeSubdirs = true,
                                            SubDirs        = new Hashtable(),
                                            Enabled        = true
                                        });
                                        arrayList.Add(famdata);
                                    }
                                }
                                if (!(text != famdata.Directory) || fsw.Pattern.IsMatch(text))
                                {
                                    FileSystemWatcher obj = fsw;
                                    lock (obj)
                                    {
                                        fsw.DispatchEvents(fileAction, text, ref renamedEventArgs);
                                        if (fsw.Waiting)
                                        {
                                            fsw.Waiting = false;
                                            System.Threading.Monitor.PulseAll(fsw);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if (FAMWatcher.FAMPending(ref FAMWatcher.conn) <= 0)
                    {
                        goto IL_28F;
                    }
                    continue;
IL_75:
                    flag = false;
                    goto IL_7D;
                }
                return;
            }
IL_28F:
            if (arrayList != null)
            {
                int count = arrayList.Count;
                for (int i = 0; i < count; i += 2)
                {
                    FAMData famdata2 = (FAMData)arrayList[i];
                    FAMData famdata3 = (FAMData)arrayList[i + 1];
                    FAMWatcher.StartMonitoringDirectory(famdata2, true);
                    FAMWatcher.requests[famdata2.Request.ReqNum] = famdata2;
                    FAMData obj2 = famdata3;
                    lock (obj2)
                    {
                        famdata3.SubDirs[famdata2.Directory] = famdata2;
                    }
                }
                arrayList.Clear();
            }
        }
Exemplo n.º 15
0
        void InitWatcher()
        {
            lock (lockobj) {
                if (watcher_handle != null)
                {
                    return;
                }

                string managed = Environment.GetEnvironmentVariable("MONO_MANAGED_WATCHER");
                int    mode    = 0;
                if (managed == null)
                {
                    mode = InternalSupportsFSW();
                }

                bool ok = false;
                switch (mode)
                {
                case 1:                 // windows
                    ok             = DefaultWatcher.GetInstance(out watcher);
                    watcher_handle = this;
                    break;

                case 2:                 // libfam
                    ok             = FAMWatcher.GetInstance(out watcher, false);
                    watcher_handle = this;
                    break;

                case 3:                 // kevent
                    ok             = KeventWatcher.GetInstance(out watcher);
                    watcher_handle = this;
                    break;

                case 4:                 // libgamin
                    ok             = FAMWatcher.GetInstance(out watcher, true);
                    watcher_handle = this;
                    break;

                case 6:                 // CoreFX
                    ok             = CoreFXFileSystemWatcherProxy.GetInstance(out watcher);
                    watcher_handle = (watcher as CoreFXFileSystemWatcherProxy).NewWatcher(this);
                    break;
                }

                if (mode == 0 || !ok)
                {
                    if (String.Compare(managed, "disabled", true) == 0)
                    {
                        NullFileWatcher.GetInstance(out watcher);
                    }
                    else
                    {
                        DefaultWatcher.GetInstance(out watcher);
                        watcher_handle = this;
                    }
                }
                this.inited = true;

                ShowWatcherInfo();
            }
        }
Exemplo n.º 16
0
		// Locked by caller
		public static bool GetInstance (out IFileWatcher watcher, bool gamin)
		{
			if (failed == true) {
				watcher = null;
				return false;
			}

			if (instance != null) {
				watcher = instance;
				return true;
			}

			use_gamin = gamin;
			watches = Hashtable.Synchronized (new Hashtable ());
			requests = Hashtable.Synchronized (new Hashtable ());
			if (FAMOpen (out conn) == -1) {
				failed = true;
				watcher = null;
				return false;
			}

			instance = new FAMWatcher ();
			watcher = instance;
			return true;
		}