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

b/trunk/Pithos.Client.WPF/Configuration/PithosSettings.cs
231	231	{
232	232	_settings.Reload();
233	233	}
	234
	235	public void Reset()
	236	{
	237	_settings.Reset();
	238	_settings.Save();
	239	}
234	240	}
235	241	}

         <IsWebBootstrapper>false</IsWebBootstrapper>
         <UseApplicationTrust>false</UseApplicationTrust>
         <BootstrapperEnabled>true</BootstrapperEnabled>
         <CodeContractsAssemblyMode>0</CodeContractsAssemblyMode>
       </PropertyGroup>
       <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
         <PlatformTarget>x86</PlatformTarget>
-...
         <CodeAnalysisIgnoreBuiltInRuleSets>false</CodeAnalysisIgnoreBuiltInRuleSets>
         <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
         <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
         <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
         <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
         <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
         <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
         <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
         <CodeContractsRunCodeAnalysis>True</CodeContractsRunCodeAnalysis>
         <CodeContractsNonNullObligations>True</CodeContractsNonNullObligations>
         <CodeContractsBoundsObligations>True</CodeContractsBoundsObligations>
         <CodeContractsArithmeticObligations>True</CodeContractsArithmeticObligations>
         <CodeContractsEnumObligations>True</CodeContractsEnumObligations>
         <CodeContractsRedundantAssumptions>True</CodeContractsRedundantAssumptions>
         <CodeContractsRunInBackground>False</CodeContractsRunInBackground>
         <CodeContractsShowSquigglies>True</CodeContractsShowSquigglies>
         <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
         <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
         <CodeContractsCustomRewriterAssembly />
         <CodeContractsCustomRewriterClass />
         <CodeContractsLibPaths />
         <CodeContractsExtraRewriteOptions />
         <CodeContractsExtraAnalysisOptions />
         <CodeContractsBaseLineFile />
         <CodeContractsCacheAnalysisResults>True</CodeContractsCacheAnalysisResults>
         <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
         <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly>
         <CodeContractsAnalysisWarningLevel>0</CodeContractsAnalysisWarningLevel>
       </PropertyGroup>
       <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Premium Debug|AnyCPU'">
         <DebugSymbols>true</DebugSymbols>

     				monitor.Pause = !monitor.Pause;
     				isPaused = monitor.Pause;
+    			}
     			PauseSyncCaption = isPaused ? "Resume syncing" : "Pause syncing";
     			var iconKey = isPaused? "TraySyncPaused" : "TrayInSynch";
-...
     		private readonly Dictionary<PithosStatus, StatusInfo> _iconNames = new List<StatusInfo>
+    			{
     				new StatusInfo(PithosStatus.InSynch, "All files up to date", "TrayInSynch"),
     				new StatusInfo(PithosStatus.Syncing, "Syncing Files", "TraySynching"),
     				new StatusInfo(PithosStatus.PollSyncing, "Polling Files", "TraySynching"),
                     new StatusInfo(PithosStatus.LocalSyncing, "Syncing Files", "TraySynching"),
     				new StatusInfo(PithosStatus.SyncPaused, "Sync Paused", "TraySyncPaused")
     			}.ToDictionary(s => s.Status);
     		readonly IWindowManager _windowManager;
             //private int _syncCount=0;
             private PithosStatus _pithosStatus = PithosStatus.Disconnected;
             public void SetPithosStatus(PithosStatus status)
+            {
                 if (_pithosStatus == PithosStatus.LocalSyncing && status == PithosStatus.PollComplete)
                     return;
                 if (_pithosStatus == PithosStatus.PollSyncing && status == PithosStatus.LocalComplete)
                     return;
                 if (status == PithosStatus.LocalComplete || status == PithosStatus.PollComplete)
                     _pithosStatus = PithosStatus.InSynch;
                 else
                     _pithosStatus = status;
                 UpdateStatus();
+            }
             public void SetPithosStatus(PithosStatus status,string message)
+            {
                 StatusMessage = message;
                 SetPithosStatus(status);
+            }
     		///<summary>
     		/// Updates the visual status indicators of the application depending on status changes, e.g. icon, stat
     		///</summary>
     		public void UpdateStatus()
+    		{
     			var pithosStatus = _statusChecker.GetPithosStatus();
     			if (_iconNames.ContainsKey(pithosStatus))
     			if (_iconNames.ContainsKey(_pithosStatus))
+    			{
     				var info = _iconNames[pithosStatus];
     				var info = _iconNames[_pithosStatus];
     				StatusIcon = String.Format(@"../Images/{0}.ico", info.IconName);
     				StatusMessage = String.Format("Pithos {0}\r\n{1}", _fileVersion.Value.FileVersion,info.StatusText);
+    			}
     			//_events.Publish(new Notification { Title = "Start", Message = "Start Monitoring", Level = TraceLevel.Info});
                 if (_pithosStatus == PithosStatus.InSynch)
                     StatusMessage = "All files up to date";
+    		}
-...
     		    var progress = notification as ProgressNotification;
     		    if (progress != null)
+    		    {
     		        StatusMessage = String.Format("Pithos {0}\r\n{1} {2} of {3} - {4}",
     		        StatusMessage = String.Format("Pithos {0}\r\n{1} {2:p2} of {3} - {4}",
     		                                      _fileVersion.Value.FileVersion,
                                                   progress.Action,
     		                                      progress.Block/(double)progress.TotalBlocks,
-...
     		        return;
+    		    }
     		    var info = notification as StatusNotification;
                 if (info != null)
+                {
                     StatusMessage = String.Format("Pithos {0}\r\n{1}",
                                                   _fileVersion.Value.FileVersion,
                                                   info.Title);
                     return;
+                }
     			if (String.IsNullOrWhiteSpace(notification.Message) && String.IsNullOrWhiteSpace(notification.Title))
     				return;
     			BalloonIcon icon;
     			switch (notification.Level)
+    			{
     				case TraceLevel.Error:
     					icon = BalloonIcon.Error;
     					break;
     				case TraceLevel.Info:
     				case TraceLevel.Verbose:
     					icon = BalloonIcon.Info;
     					break;
     				case TraceLevel.Warning:
     					icon = BalloonIcon.Warning;
     					break;
     				default:
     					icon = BalloonIcon.None;
     					break;
+    			}
     			if (Settings.ShowDesktopNotifications)
+    			{
     				var tv = (ShellView) GetView();
     			    System.Action clickAction = null;
                     if (notification is ExpirationNotification)
+                    {
                         clickAction = ()=>ShowPreferences("AccountTab");
+                    }
     				var balloon=new PithosBalloon{Title=notification.Title,Message=notification.Message,Icon=icon,ClickAction=clickAction};
     				tv.TaskbarView.ShowCustomBalloon(balloon,PopupAnimation.Fade,4000);
     //				tv.TaskbarView.ShowBalloonTip(notification.Title, notification.Message, icon);
+    			}
     			ShowBalloonFor(notification);
+    		}
     		#endregion
     	    private void ShowBalloonFor(Notification notification)
+    	    {
                 Contract.Requires(notification!=null);
                 if (!Settings.ShowDesktopNotifications)
                     return;
                 BalloonIcon icon;
     	        switch (notification.Level)
+    	        {
     	            case TraceLevel.Info:
     	            case TraceLevel.Verbose:
     	                return;
                     case TraceLevel.Error:
                         icon = BalloonIcon.Error;
                         break;
                     case TraceLevel.Warning:
     	                icon = BalloonIcon.Warning;
     	                break;
     	            default:
     	                return;
+    	        }
     	        var tv = (ShellView) GetView();
     	        System.Action clickAction = null;
     	        if (notification is ExpirationNotification)
+    	        {
     	            clickAction = () => ShowPreferences("AccountTab");
+    	        }
     	        var balloon = new PithosBalloon
+    	                          {
     	                              Title = notification.Title,
     	                              Message = notification.Message,
     	                              Icon = icon,
     	                              ClickAction = clickAction
     	                          };
     	        tv.TaskbarView.ShowCustomBalloon(balloon, PopupAnimation.Fade, 4000);
+    	    }
     	    #endregion
     		public void Handle(ShowFilePropertiesEvent message)
+    		{

     			<appender-ref ref="TraceAppender"/>
     		</logger>
     		<logger name="Pithos" additivity="false">
     			<level value="DEBUG"/>
     			<appender-ref ref="TraceAppender"/>
     		</logger>
     		<root>
     			<level value="DEBUG" />
     			<appender-ref ref="LossyFileAppender" />

b/trunk/Pithos.Core.Test/MockStatusKeeper.cs
6	6	using System.Linq;
7	7	using System.Text;
8	8	using System.Threading;
	9	using System.Threading.Tasks;
9	10	using Pithos.Interfaces;
10	11	using Pithos.Network;
11	12
...	...
146	147	throw new NotImplementedException();
147	148	}
148	149
	150	public void EnsureFileState(string path)
	151	{
	152	throw new NotImplementedException();
	153	}
	154
149	155
150	156	private PithosStatus _pithosStatus = PithosStatus.InSynch;
151	157	public void SetPithosStatus(PithosStatus status)
...	...
158	164	return _pithosStatus;
159	165	}
160	166
161		public void SetFileOverlayStatus(string path, FileOverlayStatus overlayStatus)
	167	public Task SetFileOverlayStatus(string path, FileOverlayStatus overlayStatus, string shortHash = null)
162	168	{
163	169	_overlayCache[path] = overlayStatus;
	170	return Task.Factory.StartNew(()=>{});
164	171	}
165	172
166	173	public void RemoveFileOverlayStatus(string path)
...	...
177	184	_overlayCache.TryRemove(oldPath, out value);
178	185	}
179	186
180		public void UpdateFileChecksum(string path, string checksum)
	187	public void UpdateFileChecksum(string path, string shortHash, string checksum)
181	188	{
182	189	_checksums[path] = checksum;
183	190	}

b/trunk/Pithos.Core/Agents/Agent.cs
53	53	public class Agent<TMessage> : IDisposable
54	54	{
55	55	private readonly ConcurrentQueue<TMessage> _queue;
56		private readonly AsyncProducerConsumerCollection<TMessage> _messages;
	56	//private readonly AsyncCollection<TMessage> _messages;
	57	private readonly AsyncCollection<TMessage> _messages;
57	58	private readonly CancellationTokenSource _cancelSource = new CancellationTokenSource();
58	59	public CancellationToken CancellationToken;
59	60
...	...
63	64	public Agent(Action<Agent<TMessage>> action)
64	65	{
65	66	_queue=new ConcurrentQueue<TMessage>();
66		_messages = new AsyncProducerConsumerCollection<TMessage>(_queue);
	67	_messages = new AsyncCollection<TMessage>(_queue);
67	68	_process = action;
68	69	CancellationToken = _cancelSource.Token;
69	70	}
...	...
78	79	_messages.Add(message);
79	80	}
80	81
	82	ConcurrentDictionary<TMessage,TaskCompletionSource<object>> _awaiters=new ConcurrentDictionary<TMessage,TaskCompletionSource<object>>();
	83
	84	public Task PostAndAwait(TMessage message)
	85	{
	86	var tcs = new TaskCompletionSource<object>();
	87	_awaiters[message] = tcs;
	88	Post(message);
	89	return tcs.Task;
	90	}
	91
81	92	/// <summary>
82	93	/// Receives a message asynchronously, optionally with a timeout. Receive throws a TimeoutException if the timeout expires
83	94	/// </summary>
...	...
87	98	return _messages.Take();
88	99	}
89	100
	101	public void NotifyComplete(TMessage message)
	102	{
	103	TaskCompletionSource<object> tcs;
	104	if (_awaiters.TryRemove(message,out tcs))
	105	tcs.SetResult(null);
	106	}
	107
90	108
91	109
92	110	/// <summary>
...	...
148	166	if (disposing)
149	167	{
150	168	Stop();
151		_messages.Dispose();
152	169	_cancelSource.Dispose();
153	170	}
154	171	}
...	...
209	226	onError(ex);
210	227	}
211	228	return default(T);
212		},CancellationToken);
	229	});
213	230	}
214	231	}
215	232	}

     //--------------------------------------------------------------------------
     //
     //  Copyright (c) Microsoft Corporation.  All rights reserved.
     //
     //  File: AsyncProducerConsumerCollection.cs
     //
     //--------------------------------------------------------------------------
     using System;
     using System.Collections.Concurrent;
     using System.Diagnostics;
     using System.Threading;
     using System.Threading.Tasks;
     namespace Pithos.Core
+    {
         /// <summary>Provides an asynchronous producer/consumer collection.</summary>
         [DebuggerDisplay("Count={CurrentCount}")]
         public sealed class AsyncCollection<T>
+        {
             /// <summary>Asynchronous semaphore used to keep track of asynchronous work.</summary>
             private AsyncSemaphore _semaphore = new AsyncSemaphore(0);
             /// <summary>The data stored in the collection.</summary>
             private IProducerConsumerCollection<T> _collection;
             /// <summary>Initializes the asynchronous producer/consumer collection to store data in a first-in-first-out (FIFO) order.</summary>
             public AsyncCollection() : this(new ConcurrentQueue<T>()) { }
             /// <summary>Initializes the asynchronous producer/consumer collection.</summary>
             /// <param name="collection">The underlying collection to use to store data.</param>
             public AsyncCollection(IProducerConsumerCollection<T> collection)
+            {
                 if (collection == null) throw new ArgumentNullException("collection");
                 _collection = collection;
+            }
             /// <summary>Adds an element to the collection.</summary>
             /// <param name="item">The item to be added.</param>
             public void Add(T item)
+            {
                 if (_collection.TryAdd(item))
                     Task.Factory.StartNew(s => ((AsyncSemaphore)s).Release(),
                         _semaphore, CancellationToken.None, TaskCreationOptions.PreferFairness, TaskScheduler.Default);
                 else throw new InvalidOperationException("Invalid collection");
+            }
             /// <summary>Takes an element from the collection asynchronously.</summary>
             /// <returns>A Task that represents the element removed from the collection.</returns>
             public Task<T> Take()
+            {
                 return _semaphore.WaitAsync().ContinueWith(_ =>
+                {
                     T result;
                     if (!_collection.TryTake(out result)) throw new InvalidOperationException("Invalid collection");
                     return result;
                 }, TaskContinuationOptions.OnlyOnRanToCompletion);
+            }
             /// <summary>Gets the number of elements in the collection.</summary>
             public int Count { get { return _collection.Count; } }
+        }
+    }

b/trunk/Pithos.Core/Agents/AsyncManualResetEvent.cs
87	87	while (true)
88	88	{
89	89	var tcs = _tcs;
90		if (!tcs.Task.IsCompleted \|\|
91		Interlocked.CompareExchange(ref _tcs, new TaskCompletionSource<bool>(), tcs) == tcs)
	90	if (!tcs.Task.IsCompleted)
	91	return;
	92	#pragma warning disable 420
	93	if (Interlocked.CompareExchange(ref _tcs, new TaskCompletionSource<bool>(), tcs) == tcs)
	94	#pragma warning restore 420
92	95	return;
93	96	}
94	97	}

     // -----------------------------------------------------------------------
     // <copyright file="AsyncSemaphore.cs" company="Microsoft">
     // TODO: Update copyright text.
     // </copyright>
     // -----------------------------------------------------------------------
     using System.Threading.Tasks;
     namespace Pithos.Core
+    {
         using System;
         using System.Collections.Generic;
         using System.Linq;
         using System.Text;
         /// <summary>
         /// TODO: Update summary.
         /// </summary>
         public class AsyncSemaphore
+        {
             private readonly static Task s_completed = TaskEx.FromResult(true);
             private readonly Queue<TaskCompletionSource<bool>> m_waiters = new Queue<TaskCompletionSource<bool>>();
             private int m_currentCount;
             public AsyncSemaphore(int initialCount)
+            {
                 if (initialCount < 0) throw new ArgumentOutOfRangeException("initialCount");
                 m_currentCount = initialCount;
+            }
             public Task WaitAsync()
+            {
                 lock (m_waiters)
+                {
                     if (m_currentCount > 0)
+                    {
                         --m_currentCount;
                         return s_completed;
+                    }
                     else
+                    {
                         var waiter = new TaskCompletionSource<bool>();
                         m_waiters.Enqueue(waiter);
                         return waiter.Task;
+                    }
+                }
+            }
             public void Release()
+            {
                 TaskCompletionSource<bool> toRelease = null;
                 lock (m_waiters)
+                {
                     if (m_waiters.Count > 0)
                         toRelease = m_waiters.Dequeue();
                     else
                         ++m_currentCount;
+                }
                 if (toRelease != null)
                     toRelease.SetResult(true);
+            }
+        }
+    }

     using System.Collections.Generic;
     using System.Diagnostics.Contracts;
     using System.Linq;
     using System.Security.Cryptography;
     using System.Text;
     using System.IO;
     using System.Text.RegularExpressions;
-...
                return Signature.CalculateTreeHash(info.FullName, blockSize, algorithm).TopHash.ToHashString();
+            }
            /// <summary>
            ///Calculates a simple hash for an entire file
            /// </summary>
            /// <param name="info">The file to hash</param>
            /// <param name="hasher">The hash algorithm to use</param>
            /// <returns>A hash value for the entire file. An empty string if the file does not exist.</returns>
            public static string ComputeShortHash(this FileInfo info, HashAlgorithm hasher)
+           {
                Contract.Requires(info != null);
                Contract.Requires(hasher!= null);
                if (!info.Exists)
                    return String.Empty;
                using (var stream = info.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
+               {
                    var hash = hasher.ComputeHash(stream);
                    var hashString = hash.ToHashString();
                    return hashString;
+               }
+           }
             public static string ComputeShortHash(this FileInfo info)
+           {
                Contract.Requires(info != null);
                using (var hasher=HashAlgorithm.Create("sha1"))
+               {
                    return ComputeShortHash(info,hasher);
+               }
+           }
+        }
+    }

                 if (File.Exists(FilePath))
                     File.Replace(TempPath, FilePath, null, true);
                 else
+                {
                     var targetDirectory = Path.GetDirectoryName(FilePath);
                     if (!Directory.Exists(targetDirectory))
                         Directory.CreateDirectory(targetDirectory);
                     File.Move(TempPath, FilePath);
+                }
+            }
             private void ClearBlocks()

             public readonly DateTime Created = DateTime.Now;
             public Lazy<string> LocalHash { get; protected set; }
             public Lazy<string> TopHash { get; set; }
             public Lazy<TreeHash> TreeHash { get; protected set; }
             //public Lazy<string> TopHash { get; set; }
             [ContractInvariantMethod]
-...
                 LocalFile = localFile.WithProperCapitalization();
                 CloudFile = cloudFile;
                 FileState = state;
                 if (LocalFile != null)
+                {
                 if (LocalFile == null)
                     return;
                     LocalHash = new Lazy<string>(() => LocalFile.CalculateHash(blockSize,algorithm),
                                                  LazyThreadSafetyMode.ExecutionAndPublication);
+                }
                 TreeHash = new Lazy<TreeHash>(() => Signature.CalculateTreeHash(LocalFile, blockSize,algorithm),
                                                 LazyThreadSafetyMode.ExecutionAndPublication);
+            }
             //Calculate the download path for the cloud file
-...
                 OldCloudFile = CreateObjectInfoFor(accountInfo, oldFile);
                 //This is a rename operation, a hash will not be used
                 LocalHash = new Lazy<string>(() => String.Empty, LazyThreadSafetyMode.ExecutionAndPublication);
                 TreeHash = new Lazy<TreeHash>(() => Network.TreeHash.Empty, LazyThreadSafetyMode.ExecutionAndPublication);
+            }
             public override string ToString()

     #endregion
     using System;
     using System.Collections.Generic;
     using System.ComponentModel.Composition;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
     using System.IO;
     using System.Linq;
     using System.Reflection;
     using System.Text;
     using System.Threading.Tasks;
     using Pithos.Interfaces;
     using Pithos.Network;
     using log4net;
     using log4net.Core;
     namespace Pithos.Core.Agents
+    {
-...
             //[Import]
             public IStatusKeeper StatusKeeper { get; set; }
             public IStatusNotification StatusNotification { get; set; }
             //[Import]
             public IPithosWorkflow Workflow { get; set; }
             //[Import]
-...
                 AccountInfo = accountInfo;
                 RootPath = rootPath;
                 _watcher = new FileSystemWatcher(rootPath) {IncludeSubdirectories = true};
                 _watcher = new FileSystemWatcher(rootPath) {IncludeSubdirectories = true,InternalBufferSize=8*4096};
                 _adapter = new FileSystemWatcherAdapter(_watcher);
                 _adapter.Changed += OnFileEvent;
                 _adapter.Created += OnFileEvent;
                 _adapter.Deleted += OnFileEvent;
                 _adapter.Renamed += OnRenameEvent;
                 //_adapter.Renamed += OnRenameEvent;
                 _adapter.Moved += OnMoveEvent;
                 _watcher.EnableRaisingEvents = true;
-...
                 try
+                {
                     //StatusKeeper.EnsureFileState(state.Path);
                     UpdateFileStatus(state);
                     UpdateOverlayStatus(state);
                     UpdateFileChecksum(state);
-...
+            {
                 if (_watcher != null)
+                {
                     _watcher.Changed -= OnFileEvent;
                     _watcher.Created -= OnFileEvent;
                     _watcher.Deleted -= OnFileEvent;
                     _watcher.Renamed -= OnRenameEvent;
                     _watcher.Dispose();
+                }
                 _watcher = null;
-...
+            }
     /*
             //Post a Change message for renames containing the old and new names
             void OnRenameEvent(object sender, RenamedEventArgs e)
+            {
-...
                     TriggeringChange = e.ChangeType
                 });
+            }
     */
             //Post a Change message for renames containing the old and new names
             //Post a Change message for moves containing the old and new names
             void OnMoveEvent(object sender, MovedEventArgs e)
+            {
                 var oldFullPath = e.OldFullPath;
-...
                 switch (state.Status)
+                {
                     case FileStatus.Created:
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified,state.ShortHash);
                         break;
                     case FileStatus.Modified:
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified);
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified,state.ShortHash);
                         break;
                     case FileStatus.Deleted:
                         //this.StatusAgent.RemoveFileOverlayStatus(state.Path);
                         break;
                     case FileStatus.Renamed:
                         this.StatusKeeper.ClearFileStatus(state.OldPath);
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified);
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified,state.ShortHash);
                         break;
                     case FileStatus.Unchanged:
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Normal);
                         this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Normal,state.ShortHash);
                         break;
+                }
-...
                 if (Directory.Exists(path))
                     return state;
                 var info = new FileInfo(path);
                 string hash = info.CalculateHash(StatusKeeper.BlockSize,StatusKeeper.BlockHash);
                 StatusKeeper.UpdateFileChecksum(path, hash);
                 StatusNotification.Notify(new StatusNotification(String.Format("Hashing [{0}]",info.Name)));
                 var shortHash = info.ComputeShortHash();
                 string merkleHash = info.CalculateHash(StatusKeeper.BlockSize,StatusKeeper.BlockHash);
                 StatusKeeper.UpdateFileChecksum(path,shortHash, merkleHash);
                 state.Hash = hash;
                 state.Hash = merkleHash;
                 return state;
+            }

     #endregion
     using System.Diagnostics.Contracts;
     using System.IO;
     using System.Reflection;
     using System.Threading.Tasks;
     using Pithos.Interfaces;
     using log4net;
     namespace Pithos.Core.Agents
+    {
-...
         /// </summary>
         public class FileSystemWatcherAdapter
+        {
              public event FileSystemEventHandler Changed;
             private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
             public event FileSystemEventHandler Changed;
             public event FileSystemEventHandler Created;
             public event FileSystemEventHandler Deleted;
             public event RenamedEventHandler Renamed;
             //public event RenamedEventHandler Renamed;
             public event MovedEventHandler Moved;
             public FileSystemWatcherAdapter(FileSystemWatcher watcher)
-...
                 watcher.Changed += OnChangeOrCreate;
                 watcher.Created += OnChangeOrCreate;
                 watcher.Deleted += OnDeleted;
                 watcher.Renamed += OnRename;
                 watcher.Renamed += OnRename;
                 watcher.Error += OnError;
+            }
             private void OnError(object sender, ErrorEventArgs e)
+            {
                 var error = e.GetException();
                 Log.Error("FSW error",error);
+            }
             private string _cachedDeletedFullPath;
-...
                 Contract.Ensures(!String.IsNullOrWhiteSpace(_cachedDeletedFullPath));
                 Contract.EndContractBlock();
                 //Handle any previously deleted event
                 TaskEx.Run(() => InnerOnDeleted(sender, e));
+            }
             private void InnerOnDeleted(object sender, FileSystemEventArgs e)
+            {
     //Handle any previously deleted event
                 if (Log.IsDebugEnabled)
                     Log.DebugFormat("[{0}] for [{1}]", Enum.GetName(typeof(WatcherChangeTypes), e.ChangeType), e.FullPath);
                 PropagateCachedDeleted(sender);
                 //A delete event may be an actual delete event or the first event in a move action.
-...
                 //      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
                 TaskEx.Delay(PropagateDelay).ContinueWith(t =>
+                                                               {
                                                                    var myPath = e.FullPath;
                                                                    if (_cachedDeletedFullPath==myPath)
                                                                         PropagateCachedDeleted(sender);
                                                                });
+                                                              {
                                                                   var myPath = e.FullPath;
                                                                   if (_cachedDeletedFullPath == myPath)
                                                                       PropagateCachedDeleted(sender);
                                                               });
+            }
             private void OnRename(object sender, RenamedEventArgs e)
-...
                 Contract.Ensures(_cachedDeletedFullPath == null);
                 Contract.EndContractBlock();
                 TaskEx.Run(() => InnerRename(sender, e));
+            }
             private void InnerRename(object sender, RenamedEventArgs e)
+            {
                 try
+                {
                     if (Log.IsDebugEnabled)
                         Log.DebugFormat("[{0}] for [{1}]", Enum.GetName(typeof(WatcherChangeTypes), e.ChangeType), e.FullPath);
                     //Propagate any previous cached delete event
                     PropagateCachedDeleted(sender);
                     if (Renamed!=null)
                         Renamed(sender, e);
                     if (Moved!= null)
+                    {
                         try
+                        {
                             Moved(sender, new MovedEventArgs(e.FullPath,e.Name,e.OldFullPath,e.OldName));
+                        }
                         catch (Exception exc)
+                        {
                             Log.Error("Rename event error", exc);
                             throw;
+                        }
                         var directory = new DirectoryInfo(e.FullPath);
                         if (directory.Exists)
+                        {
                             var newDirectory = e.FullPath;
                             var oldDirectory = e.OldFullPath;
                             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
+                {
                     _cachedDeletedFullPath = null;
                     _cachedDeletedFullPath = null;
+                }
+            }
-...
                     throw new ArgumentException("e");
                 Contract.Ensures(_cachedDeletedFullPath == null);
                 Contract.EndContractBlock();
                 TaskEx.Run(() => InnerChangeOrCreated(sender, e));
+            }
             private void InnerChangeOrCreated(object sender, FileSystemEventArgs e)
+            {
                 try
+                {
                     if (Log.IsDebugEnabled)
                         Log.DebugFormat("[{0}] for [{1}]",Enum.GetName(typeof(WatcherChangeTypes),e.ChangeType),e.FullPath);
                     //A Move action results in a sequence of a Delete and a Create or Change event
                     //If the actual action is a Move, raise a Move event instead of the actual event
                     if (HandleMoved(sender, e))
-...
+                    {
                         actualEvent(sender, e);
                         //For Folders, raise Created events for all children
                         RaiseCreatedForChildren(sender,e);
                         RaiseCreatedForChildren(sender, e);
+                    }
+                }
                 finally
-...
                     //Finally, make sure the cached path is cleared
                     _cachedDeletedFullPath = null;
+                }
+            }
             private void RaiseCreatedForChildren(object sender, FileSystemEventArgs e)
-...
                 //Skip if this is not a folder
                 if (!dir.Exists)
                     return;
                 foreach (var info in dir.EnumerateFileSystemInfos("*",SearchOption.AllDirectories))
                 try
+                {
                     var path = Path.GetDirectoryName(info.FullName);
                     Created(sender,new FileSystemEventArgs(WatcherChangeTypes.Created,path,info.Name));
+                }
                     foreach (var info in dir.EnumerateFileSystemInfos("*",SearchOption.AllDirectories))
+                    {
                         var path = Path.GetDirectoryName(info.FullName);
                         Created(sender,new FileSystemEventArgs(WatcherChangeTypes.Created,path,info.Name));
+                    }
+                }
                 catch (IOException exc)
+                {
                     TaskEx.Delay(1000)
                         .ContinueWith(_=>RaiseCreatedForChildren(sender,e));
+                }
+            }
             private bool HandleMoved(object sender, FileSystemEventArgs e)
-...
                 try
+                {
                     if (Log.IsDebugEnabled)
                         Log.DebugFormat("Moved for [{0}]",  e.FullPath);
                     //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);
-...
                 var deletedFileName = Path.GetFileName(_cachedDeletedFullPath);
                 var deletedFileDirectory = Path.GetDirectoryName(_cachedDeletedFullPath);
                 if (Log.IsDebugEnabled)
                     Log.DebugFormat("Propagating delete for [{0}]", _cachedDeletedFullPath);
                 //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

             public void Start()
+            {
                 if (_agent != null)
                     return;
                 if (Log.IsDebugEnabled)
                     Log.Debug("Starting Network Agent");
                 _agent = Agent<CloudAction>.Start(inbox =>
+                {
                     Action loop = null;
-...
                     try
+                    {
                         StatusNotification.SetPithosStatus(PithosStatus.LocalSyncing,"Processing");
                         _proceedEvent.Reset();
                         //UpdateStatus(PithosStatus.Syncing);
                         var accountInfo = action.AccountInfo;
-...
+                    {
                         if (_agent.IsEmpty)
                             _proceedEvent.Set();
                         UpdateStatus(PithosStatus.InSynch);
                         UpdateStatus(PithosStatus.LocalComplete);
+                    }
+                }
+            }
-...
             private void UpdateStatus(PithosStatus status)
+            {
                 StatusKeeper.SetPithosStatus(status);
                 StatusNotification.Notify(new Notification());
                 StatusNotification.SetPithosStatus(status);
                 //StatusNotification.Notify(new Notification());
+            }
             private void RenameLocalFile(AccountInfo accountInfo, CloudAction action)
-...
                     var cloudHash = cloudFile.Hash.ToLower();
                     var previousCloudHash = cloudFile.PreviousHash.ToLower();
                     var localHash = action.LocalHash.Value.ToLower();
                     var topHash = action.TopHash.Value.ToLower();
                     var localHash = action.TreeHash.Value.TopHash.ToHashString();// LocalHash.Value.ToLower();
                     //var topHash = action.TopHash.Value.ToLower();
                     //At this point we know that an object has changed on the server and that a local
                     //file already exists. We need to decide whether the file has only changed on
                     //the server or there is a conflicting change on the client.
                     //
                     //Not enough to compare only the local hashes (MD5), also have to compare the tophashes
                     //If any of the hashes match, we are done
                     if ((cloudHash == localHash || cloudHash == topHash))
                     //If the hashes match, we are done
                     if (cloudHash == localHash)
+                    {
                         Log.InfoFormat("Skipping {0}, hashes match", downloadPath);
                         return;
-...
                 Contract.EndContractBlock();
                 _deleteAgent.ProceedEvent.Wait();
     /*
                 //If the action targets a local file, add a treehash calculation
                 if (!(cloudAction is CloudDeleteAction) && cloudAction.LocalFile as FileInfo != null)
+                {
                     var accountInfo = cloudAction.AccountInfo;
                     var localFile = (FileInfo) cloudAction.LocalFile;
                     if (localFile.Length > accountInfo.BlockSize)
                         cloudAction.TopHash =
                             new Lazy<string>(() => Signature.CalculateTreeHashAsync(localFile,
-...
+                    {
                         cloudAction.TopHash = new Lazy<string>(() => cloudAction.LocalHash.Value);
+                    }
+                }
                 else
+                {
                     //The hash for a directory is the empty string
                     cloudAction.TopHash = new Lazy<string>(() => String.Empty);
+                }
     */
                 if (cloudAction is CloudDeleteAction)
                     _deleteAgent.Post((CloudDeleteAction)cloudAction);
-...
+                        }
                         else
+                        {
                             //Retrieve the hashmap from the server
                             var serverHash = await client.GetHashMap(account, container, url);
                             //If it's a small file
                             if (serverHash.Hashes.Count == 1)
                                 //Download it in one go
                                 await
                                     DownloadEntireFileAsync(accountInfo, client, cloudFile, relativeUrl, localPath,
                                                             serverHash);
                                 //Otherwise download it block by block
                             else
                                 await DownloadWithBlocks(accountInfo, client, cloudFile, relativeUrl, localPath, serverHash);
                             if (cloudFile.AllowedTo == "read")
                             var isChanged = IsObjectChanged(cloudFile, localPath);
                             if (isChanged)
+                            {
                                 var attributes = File.GetAttributes(localPath);
                                 File.SetAttributes(localPath, attributes | FileAttributes.ReadOnly);
                                 //Retrieve the hashmap from the server
                                 var serverHash = await client.GetHashMap(account, container, url);
                                 //If it's a small file
                                 if (serverHash.Hashes.Count == 1)
                                     //Download it in one go
                                     await
                                         DownloadEntireFileAsync(accountInfo, client, cloudFile, relativeUrl, localPath,
                                                                 serverHash);
                                     //Otherwise download it block by block
                                 else
                                     await
                                         DownloadWithBlocks(accountInfo, client, cloudFile, relativeUrl, localPath,
                                                            serverHash);
                                 if (cloudFile.AllowedTo == "read")
+                                {
                                     var attributes = File.GetAttributes(localPath);
                                     File.SetAttributes(localPath, attributes | FileAttributes.ReadOnly);
+                                }
+                            }
+                        }
-...
+                }
+            }
             private bool IsObjectChanged(ObjectInfo cloudFile, string localPath)
+            {
                 //If the target is a directory, there are no changes to download
                 if (Directory.Exists(localPath))
                     return false;
                 //If the file doesn't exist, we have a chagne
                 if (!File.Exists(localPath))
                     return true;
                 //If there is no stored state, we have a change
                 var localState = StatusKeeper.GetStateByFilePath(localPath);
                 if (localState == null)
                     return true;
                 var info = new FileInfo(localPath);
                 var shortHash = info.ComputeShortHash();
                 //If the file is different from the stored state, we have a change
                 if (localState.ShortHash != shortHash)
                     return true;
                 //If the top hashes differ, we have a change
                 return (localState.Checksum != cloudFile.Hash);
+            }
             //Download a small file with a single GET operation
             private async Task DownloadEntireFileAsync(AccountInfo accountInfo, CloudFilesClient client, ObjectInfo cloudFile, Uri relativeUrl, string filePath,TreeHash serverHash)
+            {
-...
                 Contract.EndContractBlock();
                 var localPath = Pithos.Interfaces.FileInfoExtensions.GetProperFilePathCapitalization(filePath);
                 //If the file already exists
                 if (File.Exists(localPath))
+                {
                     //First check with MD5 as this is a small file
                     var localMD5 = Signature.CalculateMD5(localPath);
                     var cloudHash=serverHash.TopHash.ToHashString();
                     if (localMD5==cloudHash)
                         return;
                     //Then check with a treehash
                     var localTreeHash = Signature.CalculateTreeHash(localPath, serverHash.BlockSize, serverHash.BlockHash);
                     var localHash = localTreeHash.TopHash.ToHashString();
                     if (localHash==cloudHash)
                         return;
+                }
                 StatusNotification.SetPithosStatus(PithosStatus.LocalSyncing,String.Format("Downloading {0}",Path.GetFileName(localPath)));
                 StatusNotification.Notify(new CloudNotification { Data = cloudFile });
                 var fileAgent = GetFileAgent(accountInfo);
-...
                 var blockUpdater = new BlockUpdater(fileAgent.CachePath, localPath, relativePath, serverHash);
                 StatusNotification.SetPithosStatus(PithosStatus.LocalSyncing,String.Format("Calculating hashmap for {0} before download",Path.GetFileName(localPath)));
                 //Calculate the file's treehash
                 var treeHash = await Signature.CalculateTreeHashAsync(localPath, serverHash.BlockSize, serverHash.BlockHash, 2);
-...
                         if (fileInfo.Extension.Equals("ignore", StringComparison.InvariantCultureIgnoreCase))
                             return;
                         //
                         if (action.FileState == null)
                             action.FileState = StatusKeeper.GetStateByFilePath(fileInfo.FullName);
                         //Do not upload files in conflict
                         if (action.FileState.FileStatus == FileStatus.Conflict )
+                        {
-...
                             var client = new CloudFilesClient(accountInfo);
                             //Even if GetObjectInfo times out, we can proceed with the upload
                             var info = client.GetObjectInfo(account, cloudFile.Container, cloudFile.Name);
                             var cloudInfo = client.GetObjectInfo(account, cloudFile.Container, cloudFile.Name);
                             //If this is a read-only file, do not upload changes
                             if (info.AllowedTo == "read")
                             if (cloudInfo.AllowedTo == "read")
                                 return;
                             //TODO: Check how a directory hash is calculated -> All dirs seem to have the same hash
                                 if (fileInfo is DirectoryInfo)
+                                {
                                     //If the directory doesn't exist the Hash property will be empty
                                     if (String.IsNullOrWhiteSpace(info.Hash))
                                     if (String.IsNullOrWhiteSpace(cloudInfo.Hash))
                                         //Go on and create the directory
                                         await
                                             client.PutObject(account, cloudFile.Container, cloudFile.Name, fullFileName,
-...
                                 else
+                                {
                                     var cloudHash = info.Hash.ToLower();
                                     var cloudHash = cloudInfo.Hash.ToLower();
                                     StatusNotification.Notify(new StatusNotification(String.Format("Hashing {0} for Upload",fileInfo.Name)));
                                     //TODO: This is the same as the calculation for the Local Hash!
                                     //First, calculate the tree hash
     /*
                                     var treeHash = await Signature.CalculateTreeHashAsync(fullFileName, accountInfo.BlockSize,
                                                                                           accountInfo.BlockHash, 2);
     */
                                     var hash = action.LocalHash.Value;
                                     var topHash = action.TopHash.Value;
                                     var treeHash = action.TreeHash.Value;
                                     var topHash = treeHash.TopHash.ToHashString();
                                     //var topHash = action.TopHash.Value;
                                     //If the file hashes match, abort the upload
                                     if (hash == cloudHash || topHash == cloudHash)
                                     if (topHash == cloudHash /*|| topHash == cloudHash*/)
+                                    {
                                         //but store any metadata changes
                                         StatusKeeper.StoreInfo(fullFileName, info);
                                         StatusKeeper.StoreInfo(fullFileName, cloudInfo);
                                         Log.InfoFormat("Skip upload of {0}, hashes match", fullFileName);
                                         return;
+                                    }
-...
                                     //Upload even small files using the Hashmap. The server may already contain
                                     //the relevant block
                                     //First, calculate the tree hash
                                     var treeHash = await Signature.CalculateTreeHashAsync(fullFileName, accountInfo.BlockSize,
                                                                                           accountInfo.BlockHash, 2);
                                     //TODO: If the upload fails with a 403, abort it and mark conflict
                                     await
-...
                     throw new ArgumentException("Invalid container","cloudFile");
                 Contract.EndContractBlock();
                 StatusNotification.Notify(new StatusNotification(String.Format("Uploading {0} for Upload", fileInfo.Name)));
                 var fullFileName = fileInfo.GetProperCapitalization();
                 var account = cloudFile.Account ?? accountInfo.UserName;
-...
                     //Repeat until there are no more missing hashes
                     missingHashes = await client.PutHashMap(account, container, url, treeHash);
+                }
                 ReportUploadProgress(fileInfo.Name, missingHashes.Count, missingHashes.Count, fileInfo.Length);
+            }
             private void ReportUploadProgress(string fileName,int block, int totalBlocks, long fileSize)
+            {
                 StatusNotification.Notify(new ProgressNotification(fileName,"Uploading",block,totalBlocks,fileSize) );
                 StatusNotification.Notify(totalBlocks == 0
                                               ? new ProgressNotification(fileName, "Uploading", 1, 1, fileSize)
                                               : new ProgressNotification(fileName, "Uploading", block, totalBlocks, fileSize));
+            }
             private void ReportDownloadProgress(string fileName,int block, int totalBlocks, long fileSize)
+            {
                 StatusNotification.Notify(new ProgressNotification(fileName,"Downloading",block,totalBlocks,fileSize) );
                 StatusNotification.Notify(totalBlocks == 0
                                               ? new ProgressNotification(fileName, "Downloading", 1, 1, fileSize)
                                               : new ProgressNotification(fileName, "Downloading", block, totalBlocks, fileSize));
+            }
+        }

b/trunk/Pithos.Core/Agents/PollAgent.cs
105	105	/// <returns></returns>
106	106	public async Task PollRemoteFiles(DateTime? since = null)
107	107	{
108		Debug.Assert(Thread.CurrentThread.IsBackground, "Polling Ended up in the main thread!");
	108	if (Log.IsDebugEnabled)
	109	Log.DebugFormat("Polling changes after [{0}]",since);
109	110
110		UpdateStatus(PithosStatus.Syncing);
111		StatusNotification.Notify(new PollNotification());
	111	Debug.Assert(Thread.CurrentThread.IsBackground, "Polling Ended up in the main thread!");
	112
112	113
113	114	using (ThreadContext.Stacks["Retrieve Remote"].Push("All accounts"))
114	115	{
...	...
116	117	var nextSince = since;
117	118	try
118	119	{
	120	UpdateStatus(PithosStatus.PollSyncing);
	121
119	122	//Next time we will check for all changes since the current check minus 1 second
120	123	//This is done to ensure there are no discrepancies due to clock differences
121	124	var current = DateTime.Now.AddSeconds(-1);
...	...
135	138	//In case of failure retry with the same "since" value
136	139	}
137	140
138		UpdateStatus(PithosStatus.InSynch);
	141	UpdateStatus(PithosStatus.PollComplete);
139	142	//The multiple try blocks are required because we can't have an await call
140	143	//inside a finally block
141	144	//TODO: Find a more elegant solution for reschedulling in the event of an exception
...	...
512	515	{
513	516	try
514	517	{
515		StatusKeeper.SetPithosStatus(status);
516		StatusNotification.Notify(new Notification());
	518	StatusNotification.SetPithosStatus(status);
	519	//StatusNotification.Notify(new Notification());
517	520	}
518	521	catch (Exception exc)
519	522	{

     using System.IO;
     using System.Linq;
     using System.Reflection;
     using System.Security.Cryptography;
     using System.Text;
     using System.Threading;
     using System.Threading.Tasks;
     using Castle.ActiveRecord;
     using Castle.ActiveRecord.Framework;
     using Castle.ActiveRecord.Framework.Config;
     using Pithos.Interfaces;
     using Pithos.Network;
-...
+                            {
                                 Log.ErrorFormat("[ERROR] STATE \n{0}", ex);
+                            }
                             queue.NotifyComplete(action);
     // ReSharper disable AccessToModifiedClosure
                             queue.DoAsync(loop);
     // ReSharper restore AccessToModifiedClosure
-...
+            {
                 _persistenceAgent.Stop();
+            }
             public void ProcessExistingFiles(IEnumerable<FileInfo> existingFiles)
+            {
-...
                             where missingStates.Contains(state.Id)
                             select new { File = default(FileInfo), State = state };
                 var pairs = currentFiles.Union(deletedFiles);
                 var pairs = currentFiles.Union(deletedFiles).ToList();
                 foreach(var pair in pairs)
                 using (var shortHasher = HashAlgorithm.Create("sha1"))
+                {
                     var fileState = pair.State;
                     var file = pair.File;
                     if (fileState == null)
+                    {
                         //This is a new file
                         var fullPath = pair.File.FullName;
                         var createState = FileState.CreateForAsync(fullPath, BlockSize, BlockHash);
                         createState.ContinueWith(state => _persistenceAgent.Post(state.Result.Create));
+                    }
                     else if (file == null)
                     foreach (var pair in pairs)
+                    {
                         //This file was deleted while we were down. We should mark it as deleted
                         //We have to go through UpdateStatus here because the state object we are using
                         //was created by a different ORM session.
                         _persistenceAgent.Post(()=> UpdateStatusDirect(fileState.Id, FileStatus.Deleted));
+                    }
                     else
+                    {
                         //This file has a matching state. Need to check for possible changes
                         var hashString = file.CalculateHash(BlockSize,BlockHash);
                         //TODO: Need a way to attach the hashes to the filestate so we don't
                         //recalculate them each time a call to calculate has is made
                         //We can either store them to the filestate or add them to a
                         //dictionary
                         //If the hashes don't match the file was changed
                         if (fileState.Checksum != hashString)
                         var fileState = pair.State;
                         var file = pair.File;
                         if (fileState == null)
+                        {
                             _persistenceAgent.Post(() => UpdateStatusDirect(fileState.Id, FileStatus.Modified));
+                        }
                             //This is a new file
                             var createState = FileState.CreateFor(file);
                             _persistenceAgent.Post(createState.Create);
+                        }
                         else if (file == null)
+                        {
                             //This file was deleted while we were down. We should mark it as deleted
                             //We have to go through UpdateStatus here because the state object we are using
                             //was created by a different ORM session.
                             _persistenceAgent.Post(() => UpdateStatusDirect(fileState.Id, FileStatus.Deleted));
+                        }
                         else
+                        {
                             //This file has a matching state. Need to check for possible changes
                             //To check for changes, we use the cheap (in CPU terms) SHA1 algorithm
                             //on the entire file.
                             var hashString = file.ComputeShortHash(shortHasher);
                             //TODO: Need a way to attach the hashes to the filestate so we don't
                             //recalculate them each time a call to calculate has is made
                             //We can either store them to the filestate or add them to a
                             //dictionary
                             //If the hashes don't match the file was changed
                             if (fileState.ShortHash != hashString)
+                            {
                                 _persistenceAgent.Post(() => UpdateStatusDirect(fileState.Id, FileStatus.Modified));
+                            }
+                        }
+                    }
                 };
+                }
+            }
             private int UpdateStatusDirect(Guid id, FileStatus status)
+            {
-...
+            }
             private PithosStatus _pithosStatus=PithosStatus.InSynch;
             public void SetPithosStatus(PithosStatus status)
+            {
                 _pithosStatus = status;
+            }
             public PithosStatus GetPithosStatus()
+            {
                 return _pithosStatus;
+            }

Synnefo » Pithos MS Client

Revision 174bbb6e