/ - Diff - Pithos MS Client - Greek Research and Technology Network's projects

                     loop = () =>
+                    {
                         var message = inbox.Receive();
                         var process=message.Then(Process,inbox.CancellationToken);
                         var process=message.Then(Process,inbox.CancellationToken);
                         inbox.LoopAsync(process,loop,ex=>
                             Log.ErrorFormat("[ERROR] File Event Processing:\r{0}", ex));
                     };
-...
             private bool Ignore(string filePath)
+            {
                 //Ignore all first-level directories and files
                 //Ignore all first-level directories and files (ie at the container folders level)
                 if (FoundBelowRoot(filePath, RootPath,1))
                     return true;
                     return true;
                 //Ignore first-level items under the "others" folder.
                 //Ignore first-level items under the "others" folder (ie at the accounts folders level).
                 var othersPath = Path.Combine(RootPath, FolderConstants.OthersFolder);
                 if (FoundBelowRoot(filePath, othersPath,1))
                     return true;
                     return true;
                 //Ignore second-level (container) folders under the "others" folder.
                 //Ignore second-level (container) folders under the "others" folder (ie at the container folders level).
                 if (FoundBelowRoot(filePath, othersPath,2))
                     return true;
-...
                     return true;
                 if (_ignoreFiles.ContainsKey(filePath.ToLower()))
                     return true;
                 //If selective synchronization is defined,
                 if (SelectivePaths.Count>0)
+                {
                     //Abort if the file is not located under any of the selected folders
                     if (!SelectivePaths.Any(filePath.StartsWith))
                         return true;
+                }
                 return false;
+            }

     using System.Diagnostics.Contracts;
     using System.IO;
     using System.Threading.Tasks;
     using Pithos.Interfaces;
     namespace Pithos.Core.Agents
+    {
-...
                 //      as this is actually a MOVE operation
                 //Deleting by Shift+Delete results in a delete event for each file followed by the delete of the folder itself
                 _cachedDeletedFullPath = e.FullPath;
                 //TODO: This requires synchronization of the _cachedDeletedFullPath field
                 //TODO: This creates a new task for each file even though we can cancel any existing tasks if a new event arrives
                 //Maybe, use a timer instead of a task
-...
                     //If the actual action is a Move, raise a Move event instead of the actual event
                     var newDirectory = Path.GetDirectoryName(e.FullPath);
                     var oldDirectory = Path.GetDirectoryName(_cachedDeletedFullPath);
                     if (Moved != null)
+                    {
                         Moved(sender, new MovedEventArgs(newDirectory, newName, oldDirectory, oldName));
                         //If the moved item is a dictionary, we need to raise a change event for each child item
                         //When a directory is moved within the same volume, Windows raises events only for the directory object,
                         //not its children. This happens because the move actually changes a single directory entry. It doesn't
                         //affect the entries of the children.
                         var directory = new DirectoryInfo(e.FullPath);
                         if (directory.Exists)
+                        {
                             foreach (var child in directory.EnumerateFileSystemInfos("*", SearchOption.AllDirectories))
+                            {
                                 var newChildDirectory = Path.GetDirectoryName(child.FullName);
                                 var relativePath=child.AsRelativeTo(newDirectory);
                                 var relativeFolder = Path.GetDirectoryName(relativePath);
                                 var oldChildDirectory = Path.Combine(oldDirectory, relativeFolder);
                                 Moved(sender,new MovedEventArgs(newChildDirectory,child.Name,oldChildDirectory,child.Name));
+                            }
+                        }
+                    }
+                }
                 finally
+                {
-...
                 var deletedFileName = Path.GetFileName(_cachedDeletedFullPath);
                 var deletedFileDirectory = Path.GetDirectoryName(_cachedDeletedFullPath);
                 if (Deleted!=null)
                     Deleted(sender, new FileSystemEventArgs(WatcherChangeTypes.Deleted, deletedFileDirectory, deletedFileName));
                 //Only a single file Delete event is raised when moving a file to the Recycle Bin, as this is actually a MOVE operation
                 //In this case we need to raise the proper events for all child objects of the deleted directory.
                 //UNFORTUNATELY, this can't be detected here, eg. by retrieving the child objects, because they are already deleted
                 //This should be done at a higher level, eg by checking the stored state
                 if (Deleted != null)
                     Deleted(sender,new FileSystemEventArgs(WatcherChangeTypes.Deleted, deletedFileDirectory, deletedFileName));
                 _cachedDeletedFullPath = null;
+            }

b/trunk/Pithos.Core/Agents/WorkflowAgent.cs
145	145	newInfo));
146	146	//TODO: Do I have to move children as well or will Pithos handle this?
147	147	//Need to find all children of the OLD filepath
148		MoveChildObjects(state);
	148	//MoveChildObjects(state);
149	149	break;
150	150	}
151	151	}
...	...
160	160	}
161	161	}
162	162
	163
163	164	private void DeleteChildObjects(WorkflowState state, FileState fileState)
164	165	{
165	166	if (fileState != null)
...	...
175	176	}
176	177	}
177	178
178		private void MoveChildObjects(WorkflowState state)
	179	/*private void MoveChildObjects(WorkflowState state)
179	180	{
180	181	var oldFileState = StatusKeeper.GetStateByFilePath(state.OldPath);
181	182	if (oldFileState != null)
...	...
198	199	oldMoveInfo, newMoveInfo));
199	200	}
200	201	}
201		}
	202	}*/
202	203
203	204
204	205	//Starts interrupted files for a specific account

b/trunk/Pithos.Network/TreeHash.cs
89	89	get { return _topHash.Value; }
90	90	}
91	91
92		private IList<byte[]> _hashes;
	92	private IList<byte[]> _hashes=new List<byte[]>();
93	93
94	94	public IList<byte[]> Hashes
95	95	{

Synnefo » Pithos MS Client

Revision 139ac1e8