コード例 #1
0
        public void OnChanged(object sender, FileSystemEventArgs e)
        {
            if (this.IsPathLock(e.FullPath))
            {
                return;
            }

            DiskChangeEvent theevent = new DiskChangeEvent();

            theevent.FullPath = e.FullPath;

            if (e.ChangeType == WatcherChangeTypes.Changed)
            {
                theevent.ChangeType = DiskChangeType.Updated;
            }
            else if (e.ChangeType == WatcherChangeTypes.Created)
            {
                theevent.ChangeType = DiskChangeType.Created;
            }
            else if (e.ChangeType == WatcherChangeTypes.Deleted)
            {
                theevent.ChangeType = DiskChangeType.Deleted;
            }
            else if (e.ChangeType == WatcherChangeTypes.Renamed)
            {
                throw new Exception("should fire rename event");
            }

            if (this.AddTask(theevent))
            {
                startNewFromDisk();
            }
        }
コード例 #2
0
 public void RemoveTask(DiskChangeEvent change)
 {
     lock (_queuelocker)
     {
         this.ChangeTasks.RemoveAll(o => o.Id == change.Id);
     }
 }
コード例 #3
0
        public void OnRenamed(object sender, RenamedEventArgs e)
        {
            if (!string.IsNullOrEmpty(e.OldFullPath) && !string.IsNullOrEmpty(e.FullPath))
            {
                DiskChangeEvent theevent = new DiskChangeEvent();
                theevent.OldFullPath = e.OldFullPath;
                theevent.FullPath    = e.FullPath;
                theevent.ChangeType  = DiskChangeType.Rename;

                if (this.AddTask(theevent))
                {
                    startNewFromDisk();
                }
            }
        }
コード例 #4
0
        public bool AddTask(DiskChangeEvent ChangeItem)
        {
            lock (_queuelocker)
            {
                if (ChangeItem.ChangeType == DiskChangeType.Created && this.SyncMediator.IsDiskLock(ChangeItem.FullPath, int.MaxValue))
                {
                    return(false);
                }
                var SameItems = this.ChangeTasks.FindAll(o => o.FullPath == ChangeItem.FullPath).ToList();

                if (SameItems == null || SameItems.Count == 0)
                {
                    this.ChangeTasks.Add(ChangeItem);
                    return(true);
                }
                else
                {
                    if (ChangeItem.ChangeType == DiskChangeType.Deleted)
                    {
                        foreach (var item in SameItems)
                        {
                            if (!item.Peeked && item.ChangeType != DiskChangeType.Deleted)
                            {
                                this.ChangeTasks.Remove(item);
                            }
                        }

                        if (SameItems.Find(o => o.ChangeType == DiskChangeType.Deleted) == null)
                        {
                            this.ChangeTasks.Add(ChangeItem);
                            return(true);
                        }
                        else
                        {
                            return(false);
                        }
                    }
                    else if (ChangeItem.ChangeType == DiskChangeType.Rename)
                    {
                        var item = SameItems.Find(o => o.ChangeType == DiskChangeType.Rename && o.OldFullPath == ChangeItem.OldFullPath && !o.Peeked);

                        if (item != null)
                        {
                            item.FullPath = ChangeItem.FullPath;
                            return(false);
                        }
                        else
                        {
                            this.ChangeTasks.Add(ChangeItem);
                            return(true);
                        }
                    }
                    else
                    {
                        // if there is an update item to be executed, do nothing.
                        if (SameItems.Find(o => (o.ChangeType == DiskChangeType.Created || o.ChangeType == DiskChangeType.Updated)) != null)
                        {
                            return(false);
                        }

                        else
                        {
                            this.ChangeTasks.Add(ChangeItem);
                            return(true);
                        }
                    }
                }
            }
        }
コード例 #5
0
        internal void ProcessFromDisk()
        {
            if (this.CanAccept)
            {
                Interlocked.Increment(ref this.CurrentThreadCount);
                DiskChangeEvent task = PeekTask();

                if (task != null)
                {
                    try
                    {
                        Data.Models.WebSite website = Data.GlobalDb.WebSites.Get(WebSiteId);
                        var sitedb = website.SiteDb();

                        if (task.ChangeType == DiskChangeType.Rename)
                        {
                            if (DiskPathService.IsDirectory(website, task.OldFullPath) && DiskPathService.IsDirectory(website, task.FullPath))
                            {
                                SyncService.DiskFolderRename(sitedb, task.OldFullPath, task.FullPath);
                            }
                            else
                            {
                                SyncService.DiskFileRename(sitedb, task.OldFullPath, task.FullPath);
                            }
                        }
                        else if (task.ChangeType == DiskChangeType.Deleted)
                        {
                            if (DiskPathService.IsDirectory(website, task.FullPath))
                            {
                                SyncService.DeleteDiskFolder(task.FullPath, sitedb);
                            }
                            else
                            {
                                this.DeleteFromDb(task.FullPath, sitedb);
                            }
                        }
                        else
                        {
                            //if (task.ChangeType == DiskChangeType.Created)
                            //{
                            //    contentbytes = new byte[0];
                            //}

                            this.SyncToDb(task.FullPath, sitedb, null);
                        }
                    }
                    catch (Exception ex)
                    {
                        var error = ex.Message;
                    }

                    this.RemoveTask(task);
                }
                Interlocked.Decrement(ref this.CurrentThreadCount);

                if (task != null)
                {
                    startNewFromDisk();
                }
            }
        }