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

Revision 1caef52e

     using System;
     using System.Runtime.InteropServices;
     namespace Pithos.Client.WPF
+    {
         #region Enums & Structs
         #region enum HChangeNotifyEventID
         /// <summary>
         /// Describes the event that has occurred.
         /// Typically, only one event is specified at a time.
         /// If more than one event is specified, the values contained
         /// in the <i>dwItem1</i> and <i>dwItem2</i>
         /// parameters must be the same, respectively, for all specified events.
         /// This parameter can be one or more of the following values.
         /// </summary>
         /// <remarks>
         /// <para><b>Windows NT/2000/XP:</b> <i>dwItem2</i> contains the index
         /// in the system image list that has changed.
         /// <i>dwItem1</i> is not used and should be <see langword="null"/>.</para>
         /// <para><b>Windows 95/98:</b> <i>dwItem1</i> contains the index
         /// in the system image list that has changed.
         /// <i>dwItem2</i> is not used and should be <see langword="null"/>.</para>
         /// </remarks>
         [Flags]
         enum HChangeNotifyEventID
+        {
             /// <summary>
             /// All events have occurred.
             /// </summary>
             SHCNE_ALLEVENTS = 0x7FFFFFFF,
             /// <summary>
             /// A file type association has changed. <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/>
             /// must be specified in the <i>uFlags</i> parameter.
             /// <i>dwItem1</i> and <i>dwItem2</i> are not used and must be <see langword="null"/>.
             /// </summary>
             SHCNE_ASSOCCHANGED = 0x08000000,
             /// <summary>
             /// The attributes of an item or folder have changed.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the item or folder that has changed.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_ATTRIBUTES = 0x00000800,
             /// <summary>
             /// A nonfolder item has been created.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the item that was created.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_CREATE = 0x00000002,
             /// <summary>
             /// A nonfolder item has been deleted.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the item that was deleted.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_DELETE = 0x00000004,
             /// <summary>
             /// A drive has been added.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the root of the drive that was added.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_DRIVEADD = 0x00000100,
             /// <summary>
             /// A drive has been added and the Shell should create a new window for the drive.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the root of the drive that was added.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_DRIVEADDGUI = 0x00010000,
             /// <summary>
             /// A drive has been removed. <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the root of the drive that was removed.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_DRIVEREMOVED = 0x00000080,
             /// <summary>
             /// Not currently used.
             /// </summary>
             SHCNE_EXTENDED_EVENT = 0x04000000,
             /// <summary>
             /// The amount of free space on a drive has changed.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the root of the drive on which the free space changed.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_FREESPACE = 0x00040000,
             /// <summary>
             /// Storage media has been inserted into a drive.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the root of the drive that contains the new media.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_MEDIAINSERTED = 0x00000020,
             /// <summary>
             /// Storage media has been removed from a drive.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the root of the drive from which the media was removed.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_MEDIAREMOVED = 0x00000040,
             /// <summary>
             /// A folder has been created. <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/>
             /// or <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the folder that was created.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_MKDIR = 0x00000008,
             /// <summary>
             /// A folder on the local computer is being shared via the network.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the folder that is being shared.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_NETSHARE = 0x00000200,
             /// <summary>
             /// A folder on the local computer is no longer being shared via the network.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the folder that is no longer being shared.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_NETUNSHARE = 0x00000400,
             /// <summary>
             /// The name of a folder has changed.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the previous pointer to an item identifier list (PIDL) or name of the folder.
             /// <i>dwItem2</i> contains the new PIDL or name of the folder.
             /// </summary>
             SHCNE_RENAMEFOLDER = 0x00020000,
             /// <summary>
             /// The name of a nonfolder item has changed.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the previous PIDL or name of the item.
             /// <i>dwItem2</i> contains the new PIDL or name of the item.
             /// </summary>
             SHCNE_RENAMEITEM = 0x00000001,
             /// <summary>
             /// A folder has been removed.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the folder that was removed.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_RMDIR = 0x00000010,
             /// <summary>
             /// The computer has disconnected from a server.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the server from which the computer was disconnected.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// </summary>
             SHCNE_SERVERDISCONNECT = 0x00004000,
             /// <summary>
             /// The contents of an existing folder have changed,
             /// but the folder still exists and has not been renamed.
             /// <see cref="HChangeNotifyFlags.SHCNF_IDLIST"/> or
             /// <see cref="HChangeNotifyFlags.SHCNF_PATH"/> must be specified in <i>uFlags</i>.
             /// <i>dwItem1</i> contains the folder that has changed.
             /// <i>dwItem2</i> is not used and should be <see langword="null"/>.
             /// If a folder has been created, deleted, or renamed, use SHCNE_MKDIR, SHCNE_RMDIR, or
             /// SHCNE_RENAMEFOLDER, respectively, instead.
             /// </summary>
             SHCNE_UPDATEDIR = 0x00001000,
             SHCNE_UPDATEITEM = 0x00002000,
             /// <summary>
             /// An image in the system image list has changed.
             /// <see cref="HChangeNotifyFlags.SHCNF_DWORD"/> must be specified in <i>uFlags</i>.
             /// </summary>
             SHCNE_UPDATEIMAGE = 0x00008000,
+        }
         #endregion // enum HChangeNotifyEventID
         #region public enum HChangeNotifyFlags
         /// <summary>
         /// Flags that indicate the meaning of the <i>dwItem1</i> and <i>dwItem2</i> parameters.
         /// The uFlags parameter must be one of the following values.
         /// </summary>
         [Flags]
         public enum HChangeNotifyFlags
+        {
             /// <summary>
             /// The <i>dwItem1</i> and <i>dwItem2</i> parameters are DWORD values.
             /// </summary>
             SHCNF_DWORD = 0x0003,
             /// <summary>
             /// <i>dwItem1</i> and <i>dwItem2</i> are the addresses of ITEMIDLIST structures that
             /// represent the item(s) affected by the change.
             /// Each ITEMIDLIST must be relative to the desktop folder.
             /// </summary>
             SHCNF_IDLIST = 0x0000,
             /// <summary>
             /// <i>dwItem1</i> and <i>dwItem2</i> are the addresses of null-terminated strings of
             /// maximum length MAX_PATH that contain the full path names
             /// of the items affected by the change.
             /// </summary>
             SHCNF_PATHA = 0x0001,
             /// <summary>
             /// <i>dwItem1</i> and <i>dwItem2</i> are the addresses of null-terminated strings of
             /// maximum length MAX_PATH that contain the full path names
             /// of the items affected by the change.
             /// </summary>
             SHCNF_PATHW = 0x0005,
             /// <summary>
             /// <i>dwItem1</i> and <i>dwItem2</i> are the addresses of null-terminated strings that
             /// represent the friendly names of the printer(s) affected by the change.
             /// </summary>
             SHCNF_PRINTERA = 0x0002,
             /// <summary>
             /// <i>dwItem1</i> and <i>dwItem2</i> are the addresses of null-terminated strings that
             /// represent the friendly names of the printer(s) affected by the change.
             /// </summary>
             SHCNF_PRINTERW = 0x0006,
             /// <summary>
             /// The function should not return until the notification
             /// has been delivered to all affected components.
             /// As this flag modifies other data-type flags, it cannot by used by itself.
             /// </summary>
             SHCNF_FLUSH = 0x1000,
             /// <summary>
             /// The function should begin delivering notifications to all affected components
             /// but should return as soon as the notification process has begun.
             /// As this flag modifies other data-type flags, it cannot by used by itself.
             /// </summary>
             SHCNF_FLUSHNOWAIT = 0x2000
+        }
         #endregion // enum HChangeNotifyFlags
         #endregion
         internal static class NativeMethods
+        {
             [DllImport("shell32.dll")]
             public static extern void SHChangeNotify(HChangeNotifyEventID wEventId,
                                                HChangeNotifyFlags uFlags,
                                                IntPtr dwItem1,
                                                IntPtr dwItem2);
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.IO;
     using System.Linq;
     using System.Security.Cryptography;
     using System.Text;
     using System.Threading;
     using System.Threading.Tasks;
     using NUnit.Framework;
     using Newtonsoft.Json;
     namespace Pithos.Core.Test
+    {
         [TestFixture]
         public class SignatureTest
+        {
             [Test]
             public void TestCreate()
+            {
                 var hasher = HashAlgorithm.Create("sha256");
                 Assert.IsNotNull(hasher);
+            }
             [Test]
             public void TestHashmapCreation()
+            {
                 var file = "e:\\pithos\\vlc-1.1.11-win32.exe";
                 decimal blockSize = 4*1024*1024;
                 var fileSize = new FileInfo(file).Length;
                 var numBlocks = decimal.Ceiling(fileSize/blockSize);
                 var md5 = Signature.CalculateMD5(file);
                 var hash1 = Signature.CalculateTreeHashAsync(file, (int) blockSize,"sha256").Result;
                 Assert.IsNotNull(hash1.Hashes);
                 Assert.AreEqual(numBlocks, hash1.Hashes.Count());
                 var topHash = hash1.TopHash;
                 var hashString = BytesToStr(topHash);
                 var stringHashes = (from hash in hash1.Hashes
                                    select BytesToStr(hash)).ToList();
                 var hashes = JsonConvert.SerializeObject(stringHashes);
                 Assert.IsNotNull(topHash);
+            }
             [Test]
             public void TestHashmapStorage()
+            {
                 var file = "e:\\pithos\\vlc-1.1.11-win32.exe";
                 decimal blockSize = 4*1024*1024;
                 var fileSize = new FileInfo(file).Length;
                 var numBlocks = decimal.Ceiling(fileSize/blockSize);
                 var md5 = Signature.CalculateMD5(file);
                 var hash1 = Signature.CalculateTreeHashAsync(file, (int) blockSize, "sha256").Result;
                 hash1.FileId = Guid.NewGuid();
                 var task = hash1.Save(@"e:\")
                     .ContinueWith(_ => TreeHash.LoadTreeHash(@"e:\", hash1.FileId)).Unwrap();
                 task.ContinueWith(t =>
+                {
                     var hash = t.Result;
                     Assert.AreEqual(hash1.Hashes, hash.Hashes.ToArray());
                     int i = 0;
                 }).Wait();
+            }
             public static string BytesToStr(byte[] bytes)
+            {
                 var str = new StringBuilder();
                 foreach (byte t in bytes)
                     str.AppendFormat("{0:X2}", t);
                 return str.ToString();
+            }
             [Test]
             public void TestTopHashEmpty()
+            {
                 using (var hasher = HashAlgorithm.Create("sha256"))
+                {
                     var hashEmpty = hasher.ComputeHash(new byte[] {});
                     var empty = new List<byte[]>();
                     var hash = Signature.CalculateTopHash(empty,"sha256");
                     Assert.IsNull(hash);
+                }
+            }
+        }
+    }

     using System;
     using System.IO;
     using System.Threading;
     using Pithos.Interfaces;
     using Pithos.Network;
     namespace Pithos.Core.Agents
+    {
         public enum CloudActionType
+        {
             MustSynch,
             UploadUnconditional,
             DownloadUnconditional,
             DeleteLocal,
             DeleteCloud,
             RenameCloud
+        }
         public class CloudAction
+        {
             public CloudActionType Action { get; set; }
             public FileInfo LocalFile { get; set; }
             public ObjectInfo CloudFile { get; set; }
             public Lazy<string> LocalHash { get; private set; }
             public string OldFileName { get; set; }
             public string OldPath { get; set; }
             public string NewFileName { get; set; }
             public string NewPath { get; set; }
             public CloudAction(CloudActionType action, string oldPath, string oldFileName, string newFileName, string newPath)
+            {
                 Action = action;
                 OldFileName = oldFileName;
                 OldPath = oldPath;
                 NewFileName = newFileName;
                 NewPath = newPath;
                 LocalHash = new Lazy<string>(() => Signature.CalculateMD5(NewFileName), LazyThreadSafetyMode.ExecutionAndPublication);
+            }
             public CloudAction(CloudActionType action, FileInfo localFile, ObjectInfo cloudFile)
+            {
                 Action = action;
                 LocalFile = localFile;
                 CloudFile = cloudFile;
                 //Skip Hash calculation for folders
                 if (LocalFile != null)
                     LocalHash = new Lazy<string>(() => Signature.CalculateMD5(LocalFile.FullName), LazyThreadSafetyMode.ExecutionAndPublication);
+            }
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.ComponentModel.Composition;
     using System.Diagnostics;
     using System.IO;
     using System.Linq;
     using System.Text;
     using Pithos.Interfaces;
     using Pithos.Network;
     namespace Pithos.Core.Agents
+    {
         [Export]
         public class FileAgent
+        {
             Agent<WorkflowState> _agent;
             private FileSystemWatcher _watcher;
             [Import]
             public IStatusKeeper StatusKeeper { get; set; }
             [Import]
             public IPithosWorkflow Workflow { get; set; }
             [Import]
             public WorkflowAgent WorkflowAgent { get; set; }
             public string RootPath { get; private set; }
             public void Start(string rootPath)
+            {
                 RootPath = rootPath;
                 _watcher = new FileSystemWatcher(rootPath);
                 _watcher.Changed += OnFileEvent;
                 _watcher.Created += OnFileEvent;
                 _watcher.Deleted += OnFileEvent;
                 _watcher.Renamed += OnRenameEvent;
                 _watcher.EnableRaisingEvents = true;
                 _agent = Agent<WorkflowState>.Start(inbox =>
+                {
                     Action loop = null;
                     loop = () =>
+                    {
                         var message = inbox.Receive();
                         var process = message.ContinueWith(t =>
+                        {
                             var state = t.Result;
                             Process(state);
                             inbox.DoAsync(loop);
                         });
                         process.ContinueWith(t =>
+                        {
                             inbox.DoAsync(loop);
                             if (t.IsFaulted)
+                            {
                                 var ex = t.Exception.InnerException;
                                 if (ex is OperationCanceledException)
                                     inbox.Stop();
                                 Trace.TraceError("[ERROR] File Event Processing:\r{0}", ex);
+                            }
                         });
                     };
                     loop();
                 });
+            }
             public bool Pause
+            {
                 get { return _watcher == null || !_watcher.EnableRaisingEvents; }
                 set
+                {
                     if (_watcher != null)
                         _watcher.EnableRaisingEvents = !value;
+                }
+            }
             public string FragmentsPath { get; set; }
             public void Post(WorkflowState workflowState)
+            {
                 _agent.Post(workflowState);
+            }
             public void Stop()
+            {
                 if (_watcher != null)
+                {
                     _watcher.Changed -= OnFileEvent;
                     _watcher.Created -= OnFileEvent;
                     _watcher.Deleted -= OnFileEvent;
                     _watcher.Renamed -= OnRenameEvent;
                     _watcher.Dispose();
+                }
                 _watcher = null;
                 _agent.Stop();
+            }
             // Enumerate all files in the Pithos directory except those in the Fragment folder
             // and files with a .ignore extension
             public IEnumerable<string> EnumerateFiles(string searchPattern="*")
+            {
                 var monitoredFiles = from filePath in Directory.EnumerateFileSystemEntries(RootPath, searchPattern, SearchOption.AllDirectories)
                                      where !Ignore(filePath)
                                      select filePath;
                 return monitoredFiles;
+            }
             public IEnumerable<FileInfo> EnumerateFileInfos(string searchPattern="*")
+            {
                 var rootDir = new DirectoryInfo(RootPath);
                 var monitoredFiles = from file in rootDir.EnumerateFiles(searchPattern, SearchOption.AllDirectories)
                                      where !Ignore(file.FullName)
                                      select file;
                 return monitoredFiles;
+            }
             public IEnumerable<string> EnumerateFilesAsRelativeUrls(string searchPattern="*")
+            {
                 var rootDir = new DirectoryInfo(RootPath);
                 var monitoredFiles = from file in rootDir.EnumerateFiles(searchPattern, SearchOption.AllDirectories)
                                      where !Ignore(file.FullName)
                                      select file.AsRelativeUrlTo(RootPath);
                 return monitoredFiles;
+            }
             private bool Ignore(string filePath)
+            {
                 if (filePath.StartsWith(FragmentsPath))
                     return true;
                 return false;
+            }
             //Post a Change message for all events except rename
             void OnFileEvent(object sender, FileSystemEventArgs e)
+            {
                 //Ignore events that affect the Fragments folder
                 var filePath = e.FullPath;
                 if (Ignore(filePath))
                     return;
                 _agent.Post(new WorkflowState { Path = filePath, FileName = e.Name, TriggeringChange = e.ChangeType });
+            }
             //Post a Change message for renames containing the old and new names
             void OnRenameEvent(object sender, RenamedEventArgs e)
+            {
                 var oldFullPath = e.OldFullPath;
                 var fullPath = e.FullPath;
                 if (Ignore(oldFullPath) || Ignore(fullPath))
                     return;
                 _agent.Post(new WorkflowState
+                {
                     OldPath = oldFullPath,
                     OldFileName = e.OldName,
                     Path = fullPath,
                     FileName = e.Name,
                     TriggeringChange = e.ChangeType
                 });
+            }
             private void Process(WorkflowState state)
+            {
                 Debug.Assert(!Ignore(state.Path));
                 var networkState = NetworkGate.GetNetworkState(state.Path);
                 //Skip if the file is already being downloaded or uploaded and
                 //the change is create or modify
                 if (networkState != NetworkOperation.None &&
+                    (
                         state.TriggeringChange == WatcherChangeTypes.Created ||
                         state.TriggeringChange == WatcherChangeTypes.Changed
                     ))
                     return;
                 UpdateFileStatus(state);
                 UpdateOverlayStatus(state);
                 UpdateFileChecksum(state);
                 WorkflowAgent.Post(state);
+            }
             private Dictionary<WatcherChangeTypes, FileStatus> _statusDict = new Dictionary<WatcherChangeTypes, FileStatus>
+            {
                 {WatcherChangeTypes.Created,FileStatus.Created},
                 {WatcherChangeTypes.Changed,FileStatus.Modified},
                 {WatcherChangeTypes.Deleted,FileStatus.Deleted},
                 {WatcherChangeTypes.Renamed,FileStatus.Renamed}
             };
             private WorkflowState UpdateFileStatus(WorkflowState state)
+            {
                 Debug.Assert(!state.Path.Contains("fragments"));
                 Debug.Assert(!state.Path.EndsWith(".ignore", StringComparison.InvariantCultureIgnoreCase));
                 string path = state.Path;
                 FileStatus status = _statusDict[state.TriggeringChange];
                 var oldStatus = Workflow.StatusKeeper.GetFileStatus(path);
                 if (status == oldStatus)
+                {
                     state.Status = status;
                     state.Skip = true;
                     return state;
+                }
                 if (state.Status == FileStatus.Renamed)
                     Workflow.ClearFileStatus(path);
                 state.Status = Workflow.SetFileStatus(path, status);
                 return state;
+            }
             private WorkflowState UpdateOverlayStatus(WorkflowState state)
+            {
                 if (state.Skip)
                     return state;
                 switch (state.Status)
+                {
                     case FileStatus.Created:
                     case FileStatus.Modified:
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified);
                         break;
                     case FileStatus.Deleted:
                         this.StatusKeeper.RemoveFileOverlayStatus(state.Path);
                         break;
                     case FileStatus.Renamed:
                         this.StatusKeeper.RemoveFileOverlayStatus(state.OldPath);
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified);
                         break;
                     case FileStatus.Unchanged:
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Normal);
                         break;
+                }
                 if (state.Status == FileStatus.Deleted)
                     NativeMethods.RaiseChangeNotification(Path.GetDirectoryName(state.Path));
                 else
                     NativeMethods.RaiseChangeNotification(state.Path);
                 return state;
+            }
             private WorkflowState UpdateFileChecksum(WorkflowState state)
+            {
                 if (state.Skip)
                     return state;
                 if (state.Status == FileStatus.Deleted)
                     return state;
                 var path = state.Path;
                 //Skip calculation for folders
                 if (Directory.Exists(path))
                     return state;
                 string hash = Signature.CalculateMD5(path);
                 StatusKeeper.UpdateFileChecksum(path, hash);
                 state.Hash = hash;
                 return state;
+            }
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Text;
     using System.IO;
     using System.Text.RegularExpressions;
     namespace Pithos.Core.Agents
+    {
         static class FileInfoExtensions
+        {
             public static  string AsRelativeTo(this FileInfo fileInfo,string path )
+            {
                 if (!path.EndsWith("\\"))
                     path=path.ToLower() + "\\";
                 int pathLength = path.Length;
                 var filePath = fileInfo.FullName;
                 if (!filePath.StartsWith(path,StringComparison.InvariantCultureIgnoreCase))
                     throw new ArgumentException(String.Format("The path {0} doesn't contain the file {1}",path,filePath));
                 var relativePath = filePath.Substring(pathLength, filePath.Length - pathLength);
                 return relativePath;
+            }
             public static string AsRelativeUrlTo(this FileInfo fileInfo,string path )
+            {
                 var relativePath = fileInfo.AsRelativeTo(path);
                 var replacedSlashes = relativePath.Replace("\\","/");
                 var escaped = Uri.EscapeUriString(replacedSlashes);
                 return escaped;
+            }
             public static string RelativeUriToFilePath(this Uri uri)
+            {
                 return RelativeUrlToFilePath(uri.ToString());
+            }
             public static string RelativeUrlToFilePath(this string url)
+            {
                 var unescaped=Uri.UnescapeDataString(url);
                 var path = unescaped.Replace("/", "\\");
                 return path;
+            }
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.ComponentModel.Composition;
     using System.Diagnostics;
     using System.IO;
     using System.Linq;
     using System.Text;
     using Pithos.Interfaces;
     namespace Pithos.Core.Agents
+    {
         [Export]
         public class FileWatcherAgent
+        {
             Agent<WorkflowState> _agent;
             private FileSystemWatcher _watcher;
             [Import]
             public IStatusKeeper StatusKeeper { get; set; }
             [Import]
             public IPithosWorkflow Workflow { get; set; }
             [Import]
             public WorkflowAgent WorkflowAgent { get; set; }
             public void Start(string path)
+            {
                 _watcher = new FileSystemWatcher(path);
                 _watcher.Changed += OnFileEvent;
                 _watcher.Created += OnFileEvent;
                 _watcher.Deleted += OnFileEvent;
                 _watcher.Renamed += OnRenameEvent;
                 _watcher.EnableRaisingEvents = true;
                 _agent = Agent<WorkflowState>.Start(inbox =>
+                {
                     Action loop = null;
                     loop = () =>
+                    {
                         var message = inbox.Receive();
                         var process = message.ContinueWith(t =>
+                        {
                             var state = t.Result;
                             Process(state);
                             inbox.DoAsync(loop);
                         });
                         process.ContinueWith(t =>
+                        {
                             inbox.DoAsync(loop);
                             if (t.IsFaulted)
+                            {
                                 var ex = t.Exception.InnerException;
                                 if (ex is OperationCanceledException)
                                     inbox.Stop();
                                 Trace.TraceError("[ERROR] File Event Processing:\r{0}", ex);
+                            }
                         });
                     };
                     loop();
                 });
+            }
             public bool Pause
+            {
                 get { return _watcher == null || !_watcher.EnableRaisingEvents; }
                 set
+                {
                     if (_watcher != null)
                         _watcher.EnableRaisingEvents = !value;
+                }
+            }
             public void Post(WorkflowState workflowState)
+            {
                 _agent.Post(workflowState);
+            }
             public void Stop()
+            {
                 if (_watcher != null)
+                {
                     _watcher.Changed -= OnFileEvent;
                     _watcher.Created -= OnFileEvent;
                     _watcher.Deleted -= OnFileEvent;
                     _watcher.Renamed -= OnRenameEvent;
                     _watcher.Dispose();
+                }
                 _watcher = null;
                 _agent.Stop();
+            }
             void OnFileEvent(object sender, FileSystemEventArgs e)
+            {
                 _agent.Post(new WorkflowState { Path = e.FullPath, FileName = e.Name, TriggeringChange = e.ChangeType });
+            }
             void OnRenameEvent(object sender, RenamedEventArgs e)
+            {
                 _agent.Post(new WorkflowState
+                {
                     OldPath = e.OldFullPath,
                     OldFileName = e.OldName,
                     Path = e.FullPath,
                     FileName = e.Name,
                     TriggeringChange = e.ChangeType
                 });
+            }
             private void Process(WorkflowState state)
+            {
                 var networkState = StatusKeeper.GetNetworkState(state.Path);
                 //Skip if the file is already being downloaded or uploaded and
                 //the change is create or modify
                 if (networkState != NetworkState.None &&
+                    (
                         state.TriggeringChange == WatcherChangeTypes.Created ||
                         state.TriggeringChange == WatcherChangeTypes.Changed
                     ))
                     return;
                 UpdateFileStatus(state);
                 UpdateOverlayStatus(state);
                 UpdateFileChecksum(state);
                 WorkflowAgent.Post(state);
+            }
             private Dictionary<WatcherChangeTypes, FileStatus> _statusDict = new Dictionary<WatcherChangeTypes, FileStatus>
+            {
                 {WatcherChangeTypes.Created,FileStatus.Created},
                 {WatcherChangeTypes.Changed,FileStatus.Modified},
                 {WatcherChangeTypes.Deleted,FileStatus.Deleted},
                 {WatcherChangeTypes.Renamed,FileStatus.Renamed}
             };
             private WorkflowState UpdateFileStatus(WorkflowState state)
+            {
                 string path = state.Path;
                 FileStatus status = _statusDict[state.TriggeringChange];
                 var oldStatus = Workflow.StatusKeeper.GetFileStatus(path);
                 if (status == oldStatus)
+                {
                     state.Status = status;
                     state.Skip = true;
                     return state;
+                }
                 if (state.Status == FileStatus.Renamed)
                     Workflow.ClearFileStatus(path);
                 state.Status = Workflow.SetFileStatus(path, status);
                 return state;
+            }
             private WorkflowState UpdateOverlayStatus(WorkflowState state)
+            {
                 if (state.Skip)
                     return state;
                 switch (state.Status)
+                {
                     case FileStatus.Created:
                     case FileStatus.Modified:
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified);
                         break;
                     case FileStatus.Deleted:
                         this.StatusKeeper.RemoveFileOverlayStatus(state.Path);
                         break;
                     case FileStatus.Renamed:
                         this.StatusKeeper.RemoveFileOverlayStatus(state.OldPath);
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified);
                         break;
                     case FileStatus.Unchanged:
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Normal);
                         break;
+                }
                 if (state.Status == FileStatus.Deleted)
                     Workflow.RaiseChangeNotification(Path.GetDirectoryName(state.Path));
                 else
                     Workflow.RaiseChangeNotification(state.Path);
                 return state;
+            }
             private WorkflowState UpdateFileChecksum(WorkflowState state)
+            {
                 if (state.Skip)
                     return state;
                 if (state.Status == FileStatus.Deleted)
                     return state;
                 string path = state.Path;
                 string hash = Signature.CalculateMD5(path);
                 StatusKeeper.UpdateFileChecksum(path, hash);
                 state.Hash = hash;
                 return state;
+            }
+        }
+    }

     using System;
     using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.Diagnostics.Contracts;
     using System.IO;
     namespace Pithos.Core
+    {
         public enum NetworkOperation
+        {
             None,
             Uploading,
             Downloading
+        }
         //The NetworkGate prevents starting download/uploads for files that are already in the process of downloading,
         //uploading.
         public class NetworkGate:IDisposable
+        {
             //The state of each file is stored in a thread-safe dictionary
             static readonly ConcurrentDictionary<string, NetworkOperation> NetworkState = new ConcurrentDictionary<string, NetworkOperation>();
             public static NetworkOperation GetNetworkState(string path)
+            {
                 if (String.IsNullOrWhiteSpace(path))
                     throw new ArgumentNullException("path");
                 if (!Path.IsPathRooted(path))
                     throw new ArgumentException("path must be a rooted path", "path");
                 Contract.EndContractBlock();
                 NetworkOperation operation;
                 if (NetworkState.TryGetValue(path.ToLower(), out operation))
                     return operation;
                 return NetworkOperation.None;
+            }
             //Store a network operation for the specified path
             public static void SetNetworkState(string path, NetworkOperation operation)
+            {
                 if (String.IsNullOrWhiteSpace(path))
                     throw new ArgumentNullException("path");
                 if (!Path.IsPathRooted(path))
                     throw new ArgumentException("path must be a rooted path", "path");
                 Contract.EndContractBlock();
                 var lower = path.ToLower();
                 NetworkState[lower] = operation;
                 //By default, None values don't need to be stored. They are stored anyway
                 //because TryRemove may fail.
                 if (operation == NetworkOperation.None)
+                {
                     NetworkOperation oldOperation;
                     NetworkState.TryRemove(lower, out oldOperation);
+                }
+            }
             //Clients should acquire a NetworkGate before starting any network operation.
             //If Acquire fails, another network operation is already in progress
             public static NetworkGate Acquire(string path, NetworkOperation operation)
+            {
                 if (String.IsNullOrWhiteSpace(path))
                     throw new ArgumentNullException("path");
                 if (!Path.IsPathRooted(path))
                     throw new ArgumentException("path must be a rooted path", "path");
                 Contract.EndContractBlock();
                 var state = GetNetworkState(path);
                 //If no operation is in progress, return a NetworkGate
                 return (state == NetworkOperation.None)
                            ? new NetworkGate(path, operation)
                        //otherwise return a gate with Fail flagged
                            : new NetworkGate(path, NetworkOperation.None);
+            }
             public string FilePath { get; private set; }
             public NetworkOperation Operation { get; private set; }
             private NetworkGate(string path,NetworkOperation operation)
+            {
                 if (String.IsNullOrWhiteSpace(path))
                     throw new ArgumentNullException("path");
                 Contract.EndContractBlock();
                 Operation = operation;
                 FilePath = path.ToLower();
                 //Skip dummy operations (those with Operation == None)
                 if (Operation != NetworkOperation.None)
                     //and store the file's operation
                     SetNetworkState(FilePath, operation);
+            }
             //A NetworkGate has Failed if its operation is None
             public bool Failed { get { return Operation == NetworkOperation.None; } }
             //Release a gate by setting the NetworkOperation to None
             public void Release()
+            {
                 //Skip Failed flags
                 if (!Failed)
                     //And reset the operation state for the file
                     SetNetworkState(FilePath,NetworkOperation.None);
+            }
             public void Dispose()
+            {
                 Dispose(true);
                 GC.SuppressFinalize(this);
+            }
             protected void Dispose(bool disposing)
+            {
                 if (disposing)
+                {
                     Release();
+                }
+            }
+        }
+    }

     using System;
     using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.Diagnostics.Contracts;
     using System.IO;
     using System.Runtime.Remoting.Metadata.W3cXsd2001;
     using System.Security.Cryptography;
     using System.Text;
     using System.Threading.Tasks;
     using System.Linq;
     namespace Pithos.Core
+    {
         public static class Signature
+        {
             public static string CalculateMD5(string path)
+            {
                 if (String.IsNullOrWhiteSpace(path))
                     throw new ArgumentNullException("path");
                 Contract.EndContractBlock();
                 string hash;
                 using (var hasher = MD5.Create())
                 using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 4096, true))
+                {
                     var hashBytes = hasher.ComputeHash(stream);
                     hash = hashBytes.ToHashString();
+                }
                 return hash;
+            }
     /*
             public static string BytesToString(byte[] hashBytes)
+            {
                 var shb=new SoapHexBinary(hashBytes);
                 return shb.ToString();
+            }
             public static byte[] StringToBytes(string hash)
+            {
                 var shb=SoapHexBinary.Parse(hash);
                 return shb.Value;
+            }
     */
             public static byte[] ToBytes(this string hash)
+            {
                 var shb = SoapHexBinary.Parse(hash);
                 return shb.Value;
+            }
             public static string ToHashString(this byte[] hashBytes)
+            {
                 var shb = new SoapHexBinary(hashBytes);
                 return shb.ToString();
+            }
             /// <summary>
             /// Calculates a file's tree hash synchronously, using the specified block size
             /// </summary>
             /// <param name="filePath">Path to an existing file</param>
             /// <param name="blockSize">Block size used to calculate leaf hashes</param>
             /// <param name="algorithm"></param>
             /// <returns>A <see cref="TreeHash"/> with the block hashes and top hash</returns>
             public static TreeHash CalculateTreeHash(string filePath, int blockSize, string algorithm)
+            {
                 if (String.IsNullOrWhiteSpace(filePath))
                     throw new ArgumentNullException("filePath");
                 if (blockSize<=0)
                     throw new ArgumentOutOfRangeException("blockSize","blockSize must be a value greater than zero ");
                 if (String.IsNullOrWhiteSpace(algorithm))
                     throw new ArgumentNullException("algorithm");
                 Contract.EndContractBlock();
                 var list = new List<byte[]>();
                 using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, blockSize, false))
                 using (var hasher = HashAlgorithm.Create(algorithm))
+                {
                     int read;
                     var buffer = new byte[blockSize];
                     while ((read = stream.Read(buffer, 0, blockSize)) > 0)
+                    {
                         var hash = hasher.ComputeHash(buffer, 0, read);
                         list.Add(hash);
+                    }
                     return new TreeHash(algorithm) { Hashes = list,
                         BlockSize = blockSize,
                         Bytes = stream.Length};
+                }
+            }
             public static Task<TreeHash> CalculateTreeHashAsync(string path, int blockSize,string algorithm)
+            {
                 if (String.IsNullOrWhiteSpace(path))
                     throw new ArgumentNullException("path");
                 if (blockSize <= 0)
                     throw new ArgumentOutOfRangeException("blockSize", "blockSize must be a value greater than zero ");
                 if (String.IsNullOrWhiteSpace(algorithm))
                     throw new ArgumentNullException("algorithm");
                 Contract.EndContractBlock();
                 var hashes = new ConcurrentDictionary<int, byte[]>();
                 var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, blockSize, true);
                 return CalculateBlockHashesAsync(stream, blockSize, algorithm,hashes)
                     .ContinueWith(t => {
                                             var length = stream.Length;
                                            stream.Close();
                                            var list= t.Result.OrderBy(pair => pair.Key).Select(pair => pair.Value).ToList();
                                            return new TreeHash(algorithm) { Hashes = list,
                                                BlockSize = blockSize,
                                                Bytes = length };
                     });
+            }
             public static byte[] CalculateTopHash(IEnumerable<byte[]> hashMap, string algorithm)
+            {
                 if (hashMap == null)
                     throw new ArgumentNullException("hashMap");
                 if (String.IsNullOrWhiteSpace(algorithm))
                     throw new ArgumentNullException("algorithm");
                 Contract.EndContractBlock();
                 using (var hasher = HashAlgorithm.Create(algorithm))
+                {
                     var i = 0;
                     var count = hashMap.Count();
                     foreach (var block in hashMap)
+                    {
                         if (i++ != count - 1)
                             hasher.TransformBlock(block, 0, block.Length, null, 0);
                         else
                             hasher.TransformFinalBlock(block, 0, block.Length);
+                    }
                     var finalHash = hasher.Hash;
                     return finalHash;
+                }
+            }
             private static Task<ConcurrentDictionary<int, byte[]>> CalculateBlockHashesAsync(FileStream stream, int blockSize, string algorithm, ConcurrentDictionary<int, byte[]> hashes, int index = 0)
+            {
                 if (stream==null)
                     throw new ArgumentNullException("stream");
                 if (hashes==null)
                     throw new ArgumentNullException("hashes");
                 if (String.IsNullOrWhiteSpace(algorithm))
                     throw new ArgumentNullException("algorithm");
                 if (blockSize <= 0)
                     throw new ArgumentOutOfRangeException("blockSize", "blockSize must be a value greater than zero ");
                 if (index< 0)
                     throw new ArgumentOutOfRangeException("index", "index must be a non-negative value");
                 Contract.EndContractBlock();
                 var buffer = new byte[blockSize];
                 return stream.ReadAsync(buffer, 0, blockSize).ContinueWith(t =>
+                {
                     var read = t.Result;
                     var nextTask = read == blockSize
                                         ? CalculateBlockHashesAsync(stream, blockSize, algorithm, hashes, index + 1)
                                         : Task.Factory.StartNew(() => hashes);
                     using (var hasher = HashAlgorithm.Create(algorithm))
+                    {
                         var hash = hasher.ComputeHash(buffer, 0, read);
                         hashes[index]=hash;
+                    }
                     return nextTask;
                 }).Unwrap();
+            }
             public static byte[] CalculateHash(byte[] buffer,string algorithm)
+            {
                 if (buffer == null)
                     throw new ArgumentNullException("buffer");
                 if (String.IsNullOrWhiteSpace(algorithm))
                     throw new ArgumentNullException("algorithm");
                 Contract.EndContractBlock();
                 using (var hasher = HashAlgorithm.Create(algorithm))
+                {
                     var hash = hasher.ComputeHash(buffer, 0, buffer.Length);
                     return hash;
+                }
+            }
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Diagnostics.Contracts;
     using System.Linq;
     using System.Text;
     using System.Threading.Tasks;
     namespace Pithos.Interfaces
+    {
         [ContractClass(typeof(ICloudClientContract))]
         public interface ICloudClient
+        {
             string ApiKey { get; set; }
             string UserName { get; set; }
             Uri StorageUrl { get; set; }
             string Token { get; set; }
             bool UsePithos { get; set; }
             void Authenticate(string userName,string apiKey);
             Uri Proxy { get; set; }
             double DownloadPercentLimit { get; set; }
             double UploadPercentLimit { get; set; }
             string AuthenticationUrl { get; set; }
             IList<ContainerInfo> ListContainers();
             IList<ObjectInfo> ListObjects(string container,DateTime? since=null);
             IList<ObjectInfo> ListObjects(string container, string folder, DateTime? since = null);
             bool ContainerExists(string container);
             ContainerInfo GetContainerInfo(string container);
             void CreateContainer(string container);
             void DeleteContainer(string container);
             Task GetObject(string container, string objectName, string fileName);
             Task PutObject(string container, string objectName, string fileName, string hash = null);
             void DeleteObject(string container, string objectName);
             void MoveObject(string sourceContainer, string oldObjectName, string targetContainer,string newObjectName);
             bool ObjectExists(string container,string objectName);
             ObjectInfo GetObjectInfo(string container, string objectName);
             void CreateFolder(string container, string folder);
+        }
         [ContractClassFor(typeof(ICloudClient))]
         public abstract class ICloudClientContract:ICloudClient
+        {
             public string ApiKey { get; set; }
             public string UserName { get; set; }
             public Uri StorageUrl { get; set; }
             public string Token { get; set; }
             public Uri Proxy { get; set; }
             public double DownloadPercentLimit { get; set; }
             public double UploadPercentLimit { get; set; }
             public string AuthenticationUrl { get; set; }
             public bool UsePithos { get; set; }
             public void Authenticate(string userName, string apiKey)
+            {
                 Contract.Requires<ArgumentNullException>(!String.IsNullOrWhiteSpace(apiKey), "ApiKey must be filled before calling Authenticate");
                 Contract.Requires<ArgumentNullException>(!String.IsNullOrWhiteSpace(userName), "UserName must be filled before calling Authenticate");
                 Contract.Ensures(apiKey==ApiKey);
                 Contract.Ensures(userName==UserName);
                 Contract.Ensures(StorageUrl!=null);
                 Contract.Ensures(!String.IsNullOrWhiteSpace(Token));
+            }
             public IList<ContainerInfo> ListContainers()
+            {
                 Contract.Requires(!String.IsNullOrWhiteSpace(Token));
                 Contract.Requires(StorageUrl!=null);
                 return default(IList<ContainerInfo>);
+            }
             public IList<ObjectInfo> ListObjects(string container, DateTime? since = null)
+            {
                 Contract.Requires(!String.IsNullOrWhiteSpace(Token));
                 Contract.Requires(StorageUrl != null);
                 Contract.Requires(!String.IsNullOrWhiteSpace(container));
                 return default(IList<ObjectInfo>);
+            }
             public IList<ObjectInfo> ListObjects(string container, string folder, DateTime? since = null)
+            {
                 Contract.Requires(!String.IsNullOrWhiteSpace(Token));
                 Contract.Requires(StorageUrl != null);
                 Contract.Requires(!String.IsNullOrWhiteSpace(container));
                 Contract.Requires(!String.IsNullOrWhiteSpace(folder));
                 return default(IList<ObjectInfo>);
+            }
             public bool ContainerExists(string container)
+            {
                 Contract.Requires(!String.IsNullOrWhiteSpace(Token));
                 Contract.Requires(StorageUrl!=null);
                 Contract.Requires(!String.IsNullOrWhiteSpace(container));
                 return default(bool);
+            }
             public ContainerInfo GetContainerInfo(string container)
+            {
                 Contract.Requires(!String.IsNullOrWhiteSpace(Token));
                 Contract.Requires(StorageUrl!=null);
                 Contract.Requires(!String.IsNullOrWhiteSpace(container));
                 return default(ContainerInfo);
+            }
             public void CreateContainer(string container)
+            {
                 Contract.Requires(!String.IsNullOrWhiteSpace(Token));
                 Contract.Requires(StorageUrl!=null);
                 Contract.Requires(!String.IsNullOrWhiteSpace(container));
+            }
             public void DeleteContainer(string container)
+            {
                 Contract.Requires(!String.IsNullOrWhiteSpace(Token));
                 Contract.Requires(StorageUrl!=null);
                 Contract.Requires(!String.IsNullOrWhiteSpace(container));
+            }
             public Task GetObject(string container, string objectName, string fileName)
+            {
                 Contract.Requires(!String.IsNullOrWhiteSpace(Token));
                 Contract.Requires(StorageUrl!=null);
                 Contract.Requires(!String.IsNullOrWhiteSpace(container));
                 Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
                 return default(Task);
+            }
             public Task PutObject(string container, string objectName, string fileName, string hash = null)
+            {
                 Contract.Requires(!String.IsNullOrWhiteSpace(Token));
                 Contract.Requires(StorageUrl!=null);
                 Contract.Requires(!String.IsNullOrWhiteSpace(container));
                 Contract.Requires(!String.IsNullOrWhiteSpace(fileName));
                 Contract.Requires(!String.IsNullOrWhiteSpace(objectName));
                 return default(Task);
+            }
             public void DeleteObject(string container, string objectName)
+            {

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Synnefo » Pithos MS Client

Revision 1caef52e