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

                 var extensionController = new ShellExtensionController();
                 extensionController.RegisterExtensions();
     /*
                 var appPatth =    Assembly.GetExecutingAssembly().Location;
                 Registry.LocalMachine.SetValue(@"Software\Pithos\AppPath",appPatth );
     */
                 InitializeComponent();
                 //Application.Current.ApplyTheme("BureauBlue");

     using System;
     using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.Diagnostics.Contracts;
     using System.Linq;
-...
             private readonly string[] _states = { "Normal", "Modified", "Conflict", "Synch" };
             Dictionary<string, FileOverlayStatus> _overlayCache = new Dictionary<string, FileOverlayStatus>();
             Dictionary<string, FileStatus> _statusCache = new Dictionary<string, FileStatus>();
             Dictionary<string, string> _checksums = new Dictionary<string, string>();
             ConcurrentDictionary<string, FileOverlayStatus> _overlayCache = new ConcurrentDictionary<string, FileOverlayStatus>();
             ConcurrentDictionary<string, FileStatus> _statusCache = new ConcurrentDictionary<string, FileStatus>();
             ConcurrentDictionary<string, string> _checksums = new ConcurrentDictionary<string, string>();
             public FileOverlayStatus GetFileOverlayStatus(string path)
+            {
                 Contract.Requires(!String.IsNullOrWhiteSpace(path));
                 if (!_overlayCache.ContainsKey(path))
                     return FileOverlayStatus.NA;
                     return FileOverlayStatus.Unversioned;
                 var pithosPath = Settings.PithosPath;
                 if (path.StartsWith(pithosPath, true, null))
-...
                     var status = _overlayCache[path];
                     return status;
+                }
                 return FileOverlayStatus.NA;
                 return FileOverlayStatus.Unversioned;
+            }
             public IEnumerable<string> StoreUnversionedFiles(ParallelQuery<string> paths)
+            {
                 var newFiles = (from file in paths
                                 where !_overlayCache.ContainsKey(file)
                                 select new
+                                {
                                     FilePath = file,
                                     OverlayStatus = FileOverlayStatus.Unversioned,
                                     FileStatus = FileStatus.Created,
                                     Checksum = Signature.CalculateHash(file)
                                 });
                 var files = new ConcurrentBag<string>();
                 newFiles.ForAll(state =>
+                {
                     _overlayCache[state.FilePath] = state.OverlayStatus;
                     _statusCache[state.FilePath] = state.FileStatus;
                     _checksums[state.FilePath] = state.Checksum;
                     files.Add(state.FilePath);
                 });
                 return files.ToList();
+            }
-...
             public void RemoveFileOverlayStatus(string path)
+            {
                 _overlayCache.Remove(path);
                 FileOverlayStatus value;
                 _overlayCache.TryRemove(path, out value);
+            }
             public void RenameFileOverlayStatus(string oldPath, string newPath)
+            {
                 var status = _overlayCache[oldPath];
                 _overlayCache[newPath] = status;
                 _overlayCache.Remove(oldPath);
                 FileOverlayStatus value;
                 _overlayCache.TryRemove(oldPath, out value);
+            }
             public void UpdateFileChecksum(string path, string checksum)
-...
             public void ClearFileStatus(string path)
+            {
                 _statusCache.Remove(path);
                 FileStatus value;
                 _statusCache.TryRemove(path,out value);
+            }
+        }
+    }

                 checker.RemoveFileOverlayStatus(@"e:\pithos\0File3.txt");
                 var status = checker.GetFileOverlayStatus(@"e:\pithos\0File3.txt");
                 Assert.AreEqual(FileOverlayStatus.NA,status);
                 Assert.AreEqual(FileOverlayStatus.Unversioned,status);
+            }
-...
                     var status = checker.GetFileOverlayStatus(@"e:\pithos\notexisting");
                 Assert.AreEqual(FileOverlayStatus.NA,status);
                 Assert.AreEqual(FileOverlayStatus.Unversioned,status);
+            }

     // -----------------------------------------------------------------------
     using Castle.ActiveRecord;
     using Castle.ActiveRecord.Framework;
     using Pithos.Interfaces;
     namespace Pithos.Core
-...
         /// TODO: Update summary.
         /// </summary>
         [ActiveRecord]
         public class FileState:ActiveRecordBase<FileState>
         public class FileState:ActiveRecordLinqBase<FileState>
+        {
             [PrimaryKey]
             public string FilePath { get; set; }

     using System;
     using System.Collections.Generic;
     using System.Diagnostics.Contracts;
     using System.Linq;
     using Pithos.Interfaces;
     namespace Pithos.Core
-...
             FileStatus GetFileStatus(string path);
             void ClearFileStatus(string path);
             void SetPithosStatus(PithosStatus status);
             FileOverlayStatus GetFileOverlayStatus(string path);
             IEnumerable<string> StoreUnversionedFiles(ParallelQuery<string> paths);
+        }
         [ContractClassFor(typeof(IStatusKeeper))]
-...
                 return default(FileStatus);
+            }
             public FileOverlayStatus GetFileOverlayStatus(string path)
+            {
                 Contract.Requires(!String.IsNullOrWhiteSpace(path));
                 return default(FileOverlayStatus);
+            }
             public IEnumerable<string> StoreUnversionedFiles(ParallelQuery<string> paths)
+            {
                 Contract.Requires(paths!=null);
                 return default(IEnumerable<string>);
+            }
             public void ClearFileStatus(string path)
+            {
                 Contract.Requires(!String.IsNullOrWhiteSpace(path));

     using System;
     using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.ComponentModel.Composition;
     using System.Diagnostics.Contracts;
     using System.Linq;
     using Pithos.Interfaces;
     namespace Pithos.Core
-...
             private readonly string[] _states = {"Normal", "Modified", "Conflict","Synch"};
             Dictionary<string,FileOverlayStatus> _overlayCache=new Dictionary<string,FileOverlayStatus>();
             Dictionary<string, FileStatus> _statusCache= new Dictionary<string, FileStatus>();
             Dictionary<string, string> _checksums = new Dictionary<string, string>();
             ConcurrentDictionary<string, FileOverlayStatus> _overlayCache = new ConcurrentDictionary<string, FileOverlayStatus>();
             ConcurrentDictionary<string, FileStatus> _statusCache = new ConcurrentDictionary<string, FileStatus>();
             ConcurrentDictionary<string, string> _checksums = new ConcurrentDictionary<string, string>();
             public FileOverlayStatus GetFileOverlayStatus(string path)
+            {
                 if (!_overlayCache.ContainsKey(path))
                     return FileOverlayStatus.NA;
                     return FileOverlayStatus.Unversioned;
                 var pithosPath = Settings.PithosPath;
                 if (path.StartsWith(pithosPath,true,null))
-...
                     var status = _overlayCache[path];
                     return status;
+                }
                 return FileOverlayStatus.NA;
                 return FileOverlayStatus.Unversioned;
+            }
             public IEnumerable<string> StoreUnversionedFiles(ParallelQuery<string> paths)
+            {
                 var newFiles = (from file in paths
                                 where !_overlayCache.ContainsKey(file)
                                 select new {
                                                FilePath = file,
                                                OverlayStatus = FileOverlayStatus.Unversioned,
                                                FileStatus = FileStatus.Created,
                                                Checksum = Signature.CalculateHash(file)
                                            });
                 ConcurrentBag<string> files = new ConcurrentBag<string>();
                 newFiles.ForAll(state =>
+                                    {
                                         _overlayCache[state.FilePath] = state.OverlayStatus;
                                         _statusCache[state.FilePath] = state.FileStatus;
                                         _checksums[state.FilePath] = state.Checksum;
                                         files.Add(state.FilePath);
                                     });
                 return files.GetConsumingEnumerable();
+            }
-...
             public void RemoveFileOverlayStatus(string path)
+            {
                 _overlayCache.Remove(path);
                 FileOverlayStatus value;
                 _overlayCache.TryRemove(path, out value);
+            }
             public void RenameFileOverlayStatus(string oldPath, string newPath)
+            {
                 var status=_overlayCache[oldPath];
                 _overlayCache[newPath] = status;
                 _overlayCache.Remove(oldPath);
                 _overlayCache[newPath] = status;
                 FileOverlayStatus value;
                 _overlayCache.TryRemove(oldPath,out value);
+            }
             public void SetFileStatus(string path, FileStatus status)
-...
             public void ClearFileStatus(string path)
+            {
                 _statusCache.Remove(path);
                 FileStatus value;
                 _statusCache.TryRemove(path,out value);
+            }
             public void UpdateFileChecksum(string path, string checksum)

b/trunk/Pithos.Core/Pithos.Core.csproj
115	115	<ItemGroup>
116	116	<Compile Include="FileState.cs" />
117	117	<Compile Include="IStatusService.cs" />
	118	<Compile Include="Signature.cs" />
118	119	<Compile Include="StatusChecker.cs" />
119	120	<Compile Include="IPithosWorkflow.cs" />
120	121	<Compile Include="IStatusKeeper.cs" />

                 string path = Settings.PithosPath;
                 var proxyUri = ProxyFromSettings();
                 CloudClient.Proxy = proxyUri;
                 IndexLocalFiles(path);
                 StartMonitoringFiles(path);
                 StartStatusService();
-...
                 return null;
+            }
             private void IndexLocalFiles(string path)
+            {
                 Trace.TraceInformation("[START] Inxed Local");
                 try
+                {
                     var files =
                         from filePath in Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories).AsParallel()
                         select filePath;
                     StatusKeeper.StoreUnversionedFiles(files);
                     var newFiles= FileState.FindAllByProperty("OverlayStatus", FileOverlayStatus.Unversioned)
                                 .Select(state=>state.FilePath);
                     foreach (var newFile in newFiles)
+                    {
                         _uploadEvents.Add(new WorkflowState
+                                              {
                                                   Path = newFile,
                                                   FileName = Path.GetFileName(newFile),
                                                   TriggeringChange = WatcherChangeTypes.Created
                                               });
+                    }
+                }
                 catch (Exception exc)
+                {
                     Trace.TraceError("[ERROR] Index Local - {0}", exc);
+                }
                 finally
+                {
                     Trace.TraceInformation("[END] Inxed Local");
+                }
+            }
             private void StartStatusService()
+            {
                 // Create a ServiceHost for the CalculatorService type and provide the base address.
-...
                     CloudClient.Authenticate(Settings.UserName, Settings.ApiKey);
                     StartListening();
                     StartListening(Settings.PithosPath);
                     StartSending();
+                }
                 catch (Exception)
-...
                     Action = action;
                     LocalFile = localFile;
                     CloudFile = cloudFile;
                     LocalHash=new Lazy<string>(()=>CalculateHash(LocalFile.FullName),LazyThreadSafetyMode.ExecutionAndPublication);
                     LocalHash=new Lazy<string>(()=>Signature.CalculateHash(LocalFile.FullName),LazyThreadSafetyMode.ExecutionAndPublication);
+                }
+            }
-...
             private Timer timer;
             private void StartListening()
             private void StartListening(string accountPath)
+            {
                 Func<Task> listener = ()=>Task.Factory.StartNew(()=>CloudClient.ListObjects("PITHOS"))
                 ProcessRemoteFiles(accountPath);
                 Task.Factory.StartNew(ProcessListenerActions);
+            }
             private Task ProcessRemoteFiles(string accountPath)
+            {
                 Trace.TraceInformation("[LISTENER] Scheduled");
                 return Task.Factory.StartNewDelayed(10000)
                     .ContinueWith(t=>CloudClient.ListObjects("PITHOS"))
                     .ContinueWith(task =>
+                                      {
                                           var objects = task.Result;
                                           if (objects.Count == 0)
                                           Trace.TraceInformation("[LISTENER] Start Processing");
                                           var remoteObjects = task.Result;
     /*
                                           if (remoteObjects.Count == 0)
                                               return;
     */
                                           var pithosDir = new DirectoryInfo(Settings.PithosPath);
                                           var pithosDir = new DirectoryInfo(accountPath);
                                           var upFiles = from info in objects
                                           var remoteFiles = from info in remoteObjects
                                                         select info.Name;
                                           var onlyLocal = from localFile in pithosDir.EnumerateFiles()
                                                           where !upFiles.Contains(localFile.Name)
                                                           where !remoteFiles.Contains(localFile.Name)
                                                           select new ListenerAction(CloudActionType.UploadUnconditional, localFile,null);
                                           var localNames =pithosDir.EnumerateFiles().Select(info => info.Name);
                                           var onlyRemote = from upFile in objects
                                           var onlyRemote = from upFile in remoteObjects
                                                            where !localNames.Contains(upFile.Name)
                                                            select new ListenerAction(CloudActionType.DownloadUnconditional,null,upFile);
                                           var existingObjects = from  upFile in objects
                                           var commonObjects = from  upFile in remoteObjects
                                                                 join  localFile in pithosDir.EnumerateFiles()
                                                                 on upFile.Name equals localFile.Name
                                                            select new ListenerAction(CloudActionType.Download, localFile, upFile);
                                                                     on upFile.Name equals localFile.Name
                                                                 select new ListenerAction(CloudActionType.Download, localFile, upFile);
                                           var uniques =
                                               onlyLocal.Union(onlyRemote).Union(existingObjects)
                                               .Except(_listenerActions,new LocalFileComparer());
                                               onlyLocal.Union(onlyRemote).Union(commonObjects)
                                                   .Except(_listenerActions,new LocalFileComparer());
                                           _listenerActions.AddFromEnumerable(uniques, false);
+                                     }
                     );
                 Task.Factory.StartNew(() =>
+                                          {
                                               foreach (var action in _listenerActions.GetConsumingEnumerable())
+                                              {
                                                   var localFile = action.LocalFile;
                                                   var cloudFile = action.CloudFile;
                                                   var downloadPath = (cloudFile==null)? String.Empty:Path.Combine(Settings.PithosPath,cloudFile.Name);
                                                   try
+                                                  {
                                                       switch (action.Action)
+                                                      {
                                                           case CloudActionType.UploadUnconditional:
                                                               UploadCloudFile(localFile.Name, localFile.Length,
                                                                               localFile.FullName, action.LocalHash.Value);
                                                               break;
                                                           case CloudActionType.DownloadUnconditional:
                                                               DownloadCloudFile("PITHOS", cloudFile.Name, downloadPath);
                                                               break;
                                                           case CloudActionType.Download:
                                                               if (File.Exists(downloadPath))
+                                                              {
                                                                   if (cloudFile.Hash != action.LocalHash.Value)
+                                                                  {
                                                                       var lastLocalTime = localFile.LastWriteTime;
                                                                       var lastUpTime = cloudFile.Last_Modified;
                                                                       if (lastUpTime <= lastLocalTime)
+                                                                      {
                                                                           //Files in conflict
                                                                           StatusKeeper.SetFileOverlayStatus(downloadPath,
                                                                                                             FileOverlayStatus
                                                                                                                 .Conflict);
+                                                                      }
                                                                       else
                                                                           DownloadCloudFile("PITHOS", action.CloudFile.Name,
                                                                                             downloadPath);
+                                                                  }
+                                                              }
                                                               else
                                                                   DownloadCloudFile("PITHOS", action.CloudFile.Name,
                                                                                     downloadPath);
                                                               break;
+                                                      }
+                                                  }
                                                   catch (Exception exc)
+                                                  {
                                                       Debug.WriteLine("Processing of {0}:{1}->{2} failed. Putting it back in the queue",action.Action,action.LocalFile,action.CloudFile);
                                                       Debug.WriteLine(exc.ToString());
                                                       _listenerActions.Add(action);
+                                                  }
+                                              }
+                                          }
                     );
                 timer = new Timer(o => listener(), null, TimeSpan.Zero, TimeSpan.FromSeconds(10));
                                           Trace.TraceInformation("[LISTENER] End Processing");
+                                      }
                     ).ContinueWith(t=>
+                    {
                         if (t.IsFaulted)
+                        {
                             Trace.TraceError("[LISTENER] Exception: {0}",t.Exception);
+                        }
                         else
+                        {
                             Trace.TraceInformation("[LISTENER] Finished");
+                        }
                         ProcessRemoteFiles(accountPath);
                     });
+            }
             private void ProcessListenerActions()
+            {
                 foreach(var action in _listenerActions.GetConsumingEnumerable())
+                {
                     Trace.TraceInformation("[ACTION] Start Processing {0}:{1}->{2}",action.Action,action.LocalFile,action.CloudFile);
                     var localFile = action.LocalFile;
                     var cloudFile = action.CloudFile;
                     var downloadPath = (cloudFile == null)? String.Empty
                                             : Path.Combine(Settings.PithosPath,cloudFile.Name);
                     try
+                    {
                         switch (action.Action)
+                        {
                             case CloudActionType.UploadUnconditional:
                                 UploadCloudFile(localFile.Name,localFile.Length,localFile.FullName,action.LocalHash.Value);
                                 break;
                             case CloudActionType.DownloadUnconditional:
                                 DownloadCloudFile("PITHOS",cloudFile.Name,downloadPath);
                                 break;
                             case CloudActionType.Download:
                                 if (File.Exists(downloadPath))
+                                {
                                     if (cloudFile.Hash !=action.LocalHash.Value)
+                                    {
                                         var lastLocalTime =localFile.LastWriteTime;
                                         var lastUpTime =cloudFile.Last_Modified;
                                         if (lastUpTime <=lastLocalTime)
+                                        {
                                             //Files in conflict
                                             StatusKeeper.SetFileOverlayStatus(downloadPath,FileOverlayStatus.Conflict);
+                                        }
                                         else
                                             DownloadCloudFile("PITHOS",action.CloudFile.Name,downloadPath);
+                                    }
+                                }
                                 else
                                     DownloadCloudFile("PITHOS",action.CloudFile.Name,downloadPath);
                                 break;
+                        }
                         Trace.TraceInformation("[ACTION] End Processing {0}:{1}->{2}", action.Action, action.LocalFile, action.CloudFile);
+                    }
                     catch (Exception exc)
+                    {
                         Trace.TraceError("[REQUEUE] {0} : {1} -> {2} due to exception\r\n{3}",
                                         action.Action, action.LocalFile,action.CloudFile,exc);
                         Trace.TraceError(exc.ToString());
                         _listenerActions.Add(action);
+                    }
+                }
+            }
             private void DownloadCloudFile(string container, string fileName, string localPath)
-...
                 if ( hash != info.Hash)
+                {
                     this.StatusKeeper.SetFileOverlayStatus(path, FileOverlayStatus.Synch);
                         CloudClient.PutObject("PITHOS", fileName, path);
                     CloudClient.PutObject("PITHOS", fileName, path, hash).Wait();
+                }
                 this.StatusKeeper.SetFileStatus(path,FileStatus.Unchanged);
                 this.StatusKeeper.SetFileOverlayStatus(path,FileOverlayStatus.Normal);
-...
                     return state;
                 string path = state.Path;
                 string hash = CalculateHash(path);
                 string hash = Signature.CalculateHash(path);
                 StatusKeeper.UpdateFileChecksum(path, hash);
-...
                 return state;
+            }
             private static string CalculateHash(string path)
+            {
                 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);
                     var hashBuilder = new StringBuilder();
                     foreach (byte b in hasher.ComputeHash(stream))
                         hashBuilder.Append(b.ToString("x2").ToLower());
                     hash = hashBuilder.ToString();
+                }
                 return hash;
+            }
             private FileSystemEventArgs CalculateSignature(FileSystemEventArgs arg)
+            {

     using System;
     using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.ComponentModel.Composition;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
     using System.IO;
     using System.Linq;
     using System.Security.Cryptography;
     using System.Text;
     using System.Threading.Tasks;
     using Castle.ActiveRecord;
     using Castle.ActiveRecord.Framework;
     using Castle.ActiveRecord.Framework.Config;
     using Pithos.Interfaces;
-...
                 try
+                {
                     var state = FileState.TryFind(path);
                     return state == null ? FileOverlayStatus.NA : state.OverlayStatus;
                     return state == null ? FileOverlayStatus.Unversioned : state.OverlayStatus;
+                }
                 catch (Exception exc)
+                {
                     Trace.TraceError(exc.ToString());
                     return FileOverlayStatus.NA;
                     return FileOverlayStatus.Unversioned;
+                }
+            }
             public IEnumerable<string> StoreUnversionedFiles(ParallelQuery<string> paths)
+            {
                 var existingFiles =  FileState.FindAll().Select(state=>state.FilePath);
                 var newFiles = (from file in paths.Except(existingFiles.AsParallel())
                                 select new FileState
+                                           {
                                                FilePath = file,
                                                OverlayStatus = FileOverlayStatus.Unversioned,
                                                FileStatus=FileStatus.Created,
                                                Checksum=Signature.CalculateHash(file)
+                                           }
                                ).AsParallel();
                 var files=new ConcurrentBag<string>();
                 newFiles.ForAll(state=>
+                                    {
                                         state.Save();
                                         files.Add(state.FilePath);
                                     });
                 return files.GetConsumingEnumerable();
+            }
     /*
             private static Task<string> CalculateHashAsync(string path)
+            {
                 string hash;
                 using (var hasher = MD5.Create())
+                {
                     return FileAsync.ReadAllBytes(path)
                         .ContinueWith(t => hasher.ComputeHash(t.Result))
                         .ContinueWith(t =>
+                                          {
                                               //var hashBuilder = new StringBuilder();
                                               return (from byte b in t.Result.AsParallel()
                                                       select b.ToString("x2").ToLower()).Aggregate((s1, s2) => s1 + s2);
                                           });
+                }
                 /*using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 4096, true))
+                {
                     stream.ReadAllBytes()
                         .ContinueWith(result => hasher.ComputeHash(result.Result))
                         .;
                     var hashBytes = hasher.ComputeHash(stream);
                     var hashBuilder = new StringBuilder();
                     foreach (byte b in hasher.ComputeHash(stream))
                         hashBuilder.Append(b.ToString("x2").ToLower());
                     hash = hashBuilder.ToString();
+                }
                 return hash;#1#
+            }
     */
             private PithosStatus _pithosStatus=PithosStatus.InSynch;
             public void SetPithosStatus(PithosStatus status)

     using System.IO;
     using System.Linq;
     using System.Text;
     using System.Threading.Tasks;
     namespace Pithos.Interfaces
+    {
-...
             bool UsePithos { get; set; }
             void Authenticate(string userName,string apiKey);
             Uri Proxy { get; set; }
             double DownloadPercentLimit { get; set; }
             double UploadPercentLimit { get; set; }
             IList<ContainerInfo> ListContainers();
             IList<ObjectInfo> ListObjects(string container);
-...
             void DeleteContainer(string container);
             Stream GetObject(string container, string objectName);
             void PutObject(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 container, string oldObjectName, string newObjectName);
             bool ObjectExists(string container,string objectName);
-...
             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 bool UsePithos { get; set; }
-...
                 return default(Stream);
+            }
             public void PutObject(string container, string objectName, string fileName)
             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)

         public enum FileOverlayStatus
+        {
             Deleted=-2,
             NA=-1,
             Unversioned=-1,
             Normal=0,
             Modified,
             Conflict,

     using System.Net;
     using System.Security.Cryptography;
     using System.Text;
     using System.Threading.Tasks;
     using Hammock;
     using Hammock.Caching;
     using Hammock.Retries;
-...
             private RestClient _client;
             private readonly TimeSpan _shortTimeout = TimeSpan.FromSeconds(10);
             private readonly int _retries = 5;
             private RetryPolicy _retryPolicy;
             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 AuthUrl
+            {
-...
             public void Authenticate(string userName,string apiKey)
+            {
                 Trace.TraceInformation("[AUTHENTICATE] Start for {0}",userName);
                 if (String.IsNullOrWhiteSpace(userName))
                     throw new ArgumentNullException("userName","The userName property can't be empty");
                 if (String.IsNullOrWhiteSpace(apiKey))
-...
                 else
                     Token = "0000";
                 var retryPolicy = new RetryPolicy { RetryCount = _retries };
                 retryPolicy.RetryConditions.Add(new TimeoutRetryCondition());
                 _retryPolicy = new RetryPolicy { RetryCount = _retries };
                 _retryPolicy.RetryConditions.Add(new TimeoutRetryCondition());
                 _client = new RestClient { Authority = StorageUrl.AbsoluteUri, Path = UserName, Proxy = proxy, RetryPolicy = retryPolicy, };
                 _client = new RestClient { Authority = StorageUrl.AbsoluteUri, Path = UserName, Proxy = proxy };
                 _client.FileProgress += OnFileProgress;
                 _client.AddHeader("X-Auth-Token", Token);
                 if (UsePithos)
-...
                     _client.AddHeader("X-Auth-Key",ApiKey);
+                }
                 Trace.TraceInformation("[AUTHENTICATE] End for {0}", userName);
+            }
             private void OnFileProgress(object sender, FileProgressEventArgs e)
+            {
                 Trace.TraceInformation("[PROGRESS] {0} {1:p} {2} of {3}",e.FileName,(double)e.BytesWritten/e.TotalBytes, e.BytesWritten,e.TotalBytes);
+            }
             public IList<ContainerInfo> ListContainers()
-...
                 //appends a / unless a Path is specified.
                 //Create a request with a complete path
                 var request = new RestRequest { Path = StorageUrl.ToString(), Timeout = _shortTimeout };
                 var request = new RestRequest { Path = StorageUrl.ToString(), RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 request.AddParameter("format","json");
                 //Create a client clone
                 var client = new RestClient{Proxy=Proxy.ToString()};
-...
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 var request = new RestRequest { Path = container, Timeout = _shortTimeout };
                 Trace.TraceInformation("[START] ListObjects");
                 var request = new RestRequest { Path = container, RetryPolicy = _retryPolicy, Timeout = TimeSpan.FromMinutes(1) };
                 request.AddParameter("format", "json");
                 var response = _client.Request(request);
                 var infos = InfosFromContent(response);
                 Trace.TraceInformation("[END] ListObjects");
                 return infos;
+            }
-...
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 var request = new RestRequest { Path = container, Timeout = _shortTimeout };
                 Trace.TraceInformation("[START] ListObjects");
                 var request = new RestRequest { Path = container,RetryPolicy = _retryPolicy, Timeout = TimeSpan.FromMinutes(1) };
                 request.AddParameter("format", "json");
                 request.AddParameter("path", folder);
                 var response = _client.Request(request);
                 var infos = InfosFromContent(response);
                 Trace.TraceInformation("[END] ListObjects");
                 return infos;
+            }
-...
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 var request = new RestRequest { Path = container, Method = WebMethod.Head, Timeout = _shortTimeout };
                 var request = new RestRequest { Path = container, Method = WebMethod.Head, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 var response = _client.Request(request);
                 switch(response.StatusCode)
-...
                     throw new ArgumentNullException("objectName", "The objectName property can't be empty");
                 var request = new RestRequest { Path = container + "/" + objectName, Method = WebMethod.Head, Timeout = _shortTimeout };
                 var request = new RestRequest { Path = container + "/" + objectName, Method = WebMethod.Head,RetryPolicy = _retryPolicy, Timeout = _shortTimeout };
                 var response = _client.Request(request);
                 switch (response.StatusCode)
-...
                     throw new ArgumentNullException("objectName", "The objectName property can't be empty");
                 var request = new RestRequest { Path = container + "/" + objectName, Method = WebMethod.Head, Timeout = _shortTimeout };
                 var request = new RestRequest { Path = container + "/" + objectName, Method = WebMethod.Head, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 var response = _client.Request(request);
                 if (response.TimedOut)
-...
                         var keys = response.Headers.AllKeys.AsQueryable();
                         return new ObjectInfo
+                                   {
                                        Name=objectName,
                                        Name = objectName,
                                        Bytes = long.Parse(GetHeaderValue("Content-Length", response, keys)),
                                        Hash = GetHeaderValue("ETag", response, keys),
                                        Content_Type = GetHeaderValue("Content-Type", response, keys)
-...
                     case HttpStatusCode.NotFound:
                         return ObjectInfo.Empty;
                     default:
                             throw new WebException(String.Format("GetObjectInfo failed with unexpected status code {0}", response.StatusCode));
                         if (request.RetryState.RepeatCount > 0)
+                        {
                             Trace.TraceWarning("[RETRY FAIL] GetObjectInfo for {0} failed after {1} retries",
                                                           objectName, request.RetryState.RepeatCount);
                             return ObjectInfo.Empty;
+                        }
                         if (response.InnerException != null)
                             throw new WebException(String.Format("[FAIL] GetObjectInfo for {0} failed with unexpected status code {1}", objectName, response.StatusCode), response.InnerException);
                         throw new WebException(String.Format("[FAIL] GetObjectInfo for {0} failed with unexpected status code {1}", objectName, response.StatusCode));
+                }
+            }
-...
                     throw new ArgumentNullException("folder", "The folder property can't be empty");
                 var folderUrl=String.Format("{0}/{1}",container,folder);
                 var request = new RestRequest { Path = folderUrl, Method = WebMethod.Put, Timeout = _shortTimeout };
                 var request = new RestRequest { Path = folderUrl, Method = WebMethod.Put, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 request.AddHeader("Content-Type", @"application/directory");
                 request.AddHeader("Content-Length", "0");
-...
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 var request = new RestRequest { Path = container, Method = WebMethod.Head, Timeout = _shortTimeout };
                 var request = new RestRequest { Path = container, Method = WebMethod.Head, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 var response = _client.Request(request);
                 switch(response.StatusCode)
-...
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 var request = new RestRequest { Path = container, Method = WebMethod.Put, Timeout = _shortTimeout };
                 var request = new RestRequest { Path = container, Method = WebMethod.Put, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 var response = _client.Request(request);
-...
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 var request = new RestRequest { Path = container, Method = WebMethod.Delete, Timeout = _shortTimeout };
                 var request = new RestRequest { Path = container, Method = WebMethod.Delete, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 var response = _client.Request(request);
                 if (response.StatusCode == HttpStatusCode.NotFound || response.StatusCode == HttpStatusCode.NoContent)
-...
                     throw new ArgumentNullException("objectName", "The objectName property can't be empty");
                 var request = new RestRequest { Path = container + "/" + objectName, Method = WebMethod.Get };
     /*
                 if (DownloadPercentLimit > 0)
                     request.TaskOptions = new TaskOptions<int> { RateLimitPercent = DownloadPercentLimit };
     */
                 var response = _client.Request(request);
                 if (response.StatusCode == HttpStatusCode.NotFound)
-...
             /// <param name="container"></param>
             /// <param name="objectName"></param>
             /// <param name="fileName"></param>
             /// <param name="hash">Optional hash value for the file. If no hash is provided, the method calculates a new hash</param>
             /// <remarks>>This method should have no timeout or a very long one</remarks>
             public void PutObject(string container, string objectName, string fileName)
             public Task PutObject(string container, string objectName, string fileName, string hash = null)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
-...
                 string url = container + "/" + objectName;
                 var request = new RestRequest {Path=url,Method=WebMethod.Put};
                 request.TaskOptions=new TaskOptions<int>{RateLimitPercent=0.5};
                 string hash = CalculateHash(fileName);
                 request.AddPostContent(File.ReadAllBytes(fileName));
     /*
                 if(UploadPercentLimit>0)
                     request.TaskOptions=new TaskOptions<int>{RateLimitPercent=UploadPercentLimit};
     */
                 Trace.TraceInformation("[PUT] START {0}",objectName);
                 string etag = hash??CalculateHash(fileName);
                 request.AddFile(fileName, fileName, fileName);
                 //request.AddPostContent(File.ReadAllBytes(fileName));
                 request.AddHeader("Content-Type","application/octet-stream");
                 request.AddHeader("ETag",hash);
                 var response=_client.Request(request);
                 _client.TaskOptions = new TaskOptions<int> {RateLimitPercent = 0.5};
                 if (response.StatusCode == HttpStatusCode.Created)
                     return;
                 if (response.StatusCode == HttpStatusCode.LengthRequired)
                     throw new InvalidOperationException();
                 else
                     throw new WebException(String.Format("GetObject failed with unexpected status code {0}", response.StatusCode));
                 request.AddHeader("ETag", etag);
                 //_client.TaskOptions = new TaskOptions<int> {RateLimitPercent = 0.5};
                 try
+                {
                     var response=_client.Request(request);
                     Trace.TraceInformation("[PUT] END {0}", objectName);
                     if (response.StatusCode == HttpStatusCode.Created)
                         return Task.Factory.StartNew(()=>{});
                     if (response.StatusCode == HttpStatusCode.LengthRequired)
                         throw new InvalidOperationException();
                     else
                         throw new WebException(String.Format("GetObject failed with unexpected status code {0}",
                                 response.StatusCode));
                     /*            return Task.Factory.FromAsync(_client.BeginRequest(request),ar=>_client.EndRequest(ar))
                                     .ContinueWith(t=>
                                     {*/
+                }
                 catch (Exception exc)
+                {
                     Trace.TraceError("[PUT] END {0} with {1}", objectName, exc);
                     throw;
+                }
     /*
                 var response = t.Result;
                         if (t.IsFaulted)
                             Trace.TraceError("[PUT] END {0} with {1}", objectName, t.Exception);
                         else
+                        {
                             Trace.TraceInformation("[PUT] END {0}",objectName);
+                        }
     */
                       /*  if (response.StatusCode == HttpStatusCode.Created)
                             return;
                         if (response.StatusCode == HttpStatusCode.LengthRequired)
                             throw new InvalidOperationException();
                         else
                             throw new WebException(String.Format("GetObject failed with unexpected status code {0}",
                                     response.StatusCode));*/
                     /*});*/
+            }
             private static string CalculateHash(string fileName)
-...
                 if (String.IsNullOrWhiteSpace(objectName))
                     throw new ArgumentNullException("objectName", "The objectName property can't be empty");
                 var request = new RestRequest { Path = container + "/" + objectName, Method = WebMethod.Delete, Timeout=_shortTimeout };
                 var request = new RestRequest { Path = container + "/" + objectName, Method = WebMethod.Delete, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 var response = _client.Request(request);
                 if (response.StatusCode == HttpStatusCode.NotFound || response.StatusCode == HttpStatusCode.NoContent)

         <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
       </PropertyGroup>
       <ItemGroup>
         <Reference Include="Hammock.ClientProfile">
           <HintPath>..\packages\Hammock.1.2.6\lib\4.0\Hammock.ClientProfile.dll</HintPath>
         </Reference>
         <Reference Include="System" />
         <Reference Include="System.ComponentModel.Composition" />
         <Reference Include="System.Core" />
-...
         <Compile Include="TimeoutRetryCondition.cs" />
       </ItemGroup>
       <ItemGroup>
         <ProjectReference Include="..\hammock\src\net40\Hammock.ClientProfile\Hammock.ClientProfile.csproj">
           <Project>{487B7E3C-9689-47BC-8785-73CCD92A3749}</Project>
           <Name>Hammock.ClientProfile</Name>
         </ProjectReference>
         <ProjectReference Include="..\Libraries\Json40r2\Source\Src\Newtonsoft.Json\Newtonsoft.Json.csproj">
           <Project>{A9AE40FF-1A21-414A-9FE7-3BE13644CC6D}</Project>
           <Name>Newtonsoft.Json</Name>

b/trunk/Pithos.Network/TimeoutRetryCondition.cs
13	13	{
14	14	get
15	15	{
16		return r =>
17		(r.Exception != null && r.Exception is WebException
18		&& (((WebException)r.Exception).Status == WebExceptionStatus.Timeout));
	16	return r =>
	17	{
	18	var responseStatus = r.ResponseHttpStatusCode;
	19	if (r.Exception == null)
	20	return false;
	21	if (!(r.Exception is WebException))
	22	return false;
	23	var exceptionStatus = ((WebException) r.Exception).Status;
	24	return (r.Exception != null
	25	&& (exceptionStatus == WebExceptionStatus.Timeout));
	26	};
19	27	}
20	28	}
21	29	}

b/trunk/Pithos.ShellExtensions/FileContext.cs
25	25
26	26	public FileContext()
27	27	{
28		/* if (Process.GetProcessesByName("Pithos.Client.WPF").Length == 0)
29		{
30		var appPath = (string)Registry.LocalMachine.GetValue(@"Software\Pithos\AppPath");
31		Process.Start(appPath);
32		}*/
33	28	}
34	29
35	30	public bool IsManaged

         <Compile Include="Menus\DisplayFlags.cs" />
         <Compile Include="Menus\FileContextMenu.cs" />
         <Compile Include="Menus\MenuItem.cs" />
         <Compile Include="Overlays\AddedIcodOverlay.cs" />
         <Compile Include="Overlays\ConflictIconOverlay.cs" />
         <Compile Include="Overlays\IconOverlayBase.cs" />
         <Compile Include="Overlays\ModifiedIconOverlay.cs" />
         <Compile Include="Overlays\NormalIconOverlay.cs" />
         <Compile Include="Overlays\SynchIconOverlay.cs" />
         <Compile Include="Overlays\UnversionedIconOverlay.cs" />
         <Compile Include="PithosHost.cs" />
         <Compile Include="ProjectInstaller.cs">
           <SubType>Component</SubType>
         </Compile>

     <?xml version="1.0" encoding="utf-8"?>
     <?xml version="1.0" encoding="utf-8"?>
     <xs:schema xmlns:tns="http://schemas.datacontract.org/2004/07/Pithos.Interfaces" elementFormDefault="qualified" targetNamespace="http://schemas.datacontract.org/2004/07/Pithos.Interfaces" xmlns:xs="http://www.w3.org/2001/XMLSchema">
       <xs:import schemaLocation="http://localhost:30000/pithos/mex?xsd=xsd1" namespace="http://schemas.microsoft.com/2003/10/Serialization/" />
       <xs:import schemaLocation="http://localhost:30000/pithos/mex?xsd=xsd4" namespace="http://schemas.microsoft.com/2003/10/Serialization/Arrays" />
-...
               </xs:appinfo>
             </xs:annotation>
           </xs:enumeration>
           <xs:enumeration value="NA">
           <xs:enumeration value="Unversioned">
             <xs:annotation>
               <xs:appinfo>
                 <EnumerationValue xmlns="http://schemas.microsoft.com/2003/10/Serialization/">-1</EnumerationValue>

b/trunk/Pithos.ShellExtensions/ShellSettings.cs
7	7	using System.ComponentModel.Composition;
8	8	using System.Diagnostics;
9	9	using System.ServiceModel;
	10	using Microsoft.Win32;
10	11	using Pithos.Interfaces;
11	12
12	13	namespace Pithos.ShellExtensions
...	...
131	132
132	133	private IPithosSettings LoadSettings()
133	134	{
	135
134	136	try
135	137	{
136		var binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
137
138		var remoteAddress = new EndpointAddress("net.pipe://localhost/pithos/settings");
139		using (var client = new PithosService.SettingsServiceClient(binding, remoteAddress))
	138	using (var client = PithosHost.GetSettingsClient())
140	139	{
141	140	return client.GetSettings();
142	141	}

b/trunk/Pithos.ShellExtensions/ShellStatusChecker.cs
7	7	using System.ComponentModel.Composition;
8	8	using System.Diagnostics;
9	9	using System.ServiceModel;
	10	using Microsoft.Win32;
10	11	using Pithos.Interfaces;
11	12
12	13	namespace Pithos.ShellExtensions
...	...
30	31
31	32	try
32	33	{
33		var binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
34
35		var remoteAddress = new EndpointAddress("net.pipe://localhost/pithos/statuscache");
36		using (var client = new PithosService.StatusServiceClient(binding, remoteAddress))
	34	using (var client = PithosHost.GetStatusClient())
37	35	{
38	36	var status = client.GetStatus(path);
39	37	return status;
...	...
42	40	catch (Exception exc)
43	41	{
44	42	Trace.TraceError(exc.ToString());
45		return FileOverlayStatus.NA;
	43	return FileOverlayStatus.Unversioned;
46	44	}
47	45	}
48	46

b/trunk/Pithos.ShellExtensions/TestStatusChecker.cs
31	31	var status = Char.ConvertToUtf32(fileName, 0)%4;
32	32	return (FileOverlayStatus)status;
33	33	}
34		return FileOverlayStatus.NA;
	34	return FileOverlayStatus.Unversioned;
35	35	}
36	36
37	37

     EndProject
     Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Caliburn.Micro.WPF", "..\..\..\Downloads\caliburnmicro\caliburnmicro_1f6100f2f0af\src\Caliburn.Micro.WPF\Caliburn.Micro.WPF.csproj", "{B633FE8C-B40E-4122-A763-F94C8B1A70F8}"
     EndProject
     Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Hammock.ClientProfile", "hammock\src\net40\Hammock.ClientProfile\Hammock.ClientProfile.csproj", "{487B7E3C-9689-47BC-8785-73CCD92A3749}"
     EndProject
     Global
     	GlobalSection(SolutionConfigurationPlatforms) = preSolution
     		Debug|Any CPU = Debug|Any CPU
-...
     		{B633FE8C-B40E-4122-A763-F94C8B1A70F8}.Test|Mixed Platforms.ActiveCfg = Release|Any CPU
     		{B633FE8C-B40E-4122-A763-F94C8B1A70F8}.Test|Mixed Platforms.Build.0 = Release|Any CPU
     		{B633FE8C-B40E-4122-A763-F94C8B1A70F8}.Test|x86.ActiveCfg = Release|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Debug|Any CPU.Build.0 = Debug|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Debug|x86.ActiveCfg = Debug|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Release|Any CPU.ActiveCfg = Release|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Release|Any CPU.Build.0 = Release|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Release|Mixed Platforms.Build.0 = Release|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Release|x86.ActiveCfg = Release|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Test|Any CPU.ActiveCfg = Release|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Test|Any CPU.Build.0 = Release|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Test|Mixed Platforms.ActiveCfg = Release|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Test|Mixed Platforms.Build.0 = Release|Any CPU
     		{487B7E3C-9689-47BC-8785-73CCD92A3749}.Test|x86.ActiveCfg = Release|Any CPU
     	EndGlobalSection
     	GlobalSection(SolutionProperties) = preSolution
     		HideSolutionNode = FALSE

     Hammock (http://github.com/danielcrenna/hammock)
     --------------------------------------
     Copyright (c) 2010 Daniel Crenna and Jason Diller
     Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
     documentation files (the "Software"), to deal in the Software without restriction, including without limitation
     the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
     to permit persons to whom the Software is furnished to do so, subject to the following conditions:
     The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     Hammock for Silverlight and Windows Phone 7
     --------------------------------------
     This target optionally links to a port of SharpZipLib http://www.icsharpcode.net/opensource/sharpziplib as an independent
     module that does not derive from, and is not based on, SharpZipLib. As such it is compliant with the special
     exception of SharpZipLib's GNU General Public License and may be used in commercial, closed-source applications.
     As the independent module, this is compliant with Hammock's MIT X11 Licence.
     Hammock Extras
     --------------------------------------
     The Extras project in source code provides an example serializer that includes JSON.NET,
     licensed under the MIT X11 License http://www.opensource.org/licenses/mit-license.php.

     <?xml version="1.0" encoding="utf-8"?>
     <?xml-stylesheet type="text/xsl" href="c:\program files (x86)\microsoft visual studio 10.0\team tools\static analysis tools\fxcop\Xml\CodeAnalysisReport.xsl"?>
     <FxCopReport Version="10.0">
      <Targets>
       <Target Name="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\bin\lib\net40\Hammock.dll">
        <Modules>
         <Module Name="hammock.dll">
          <Namespaces>
           <Namespace Name="Hammock">
            <Types>
             <Type Name="RestBase" Kind="Class" Accessibility="Public" ExternallyVisible="True">
              <Members>
               <Member Name="#.ctor()" Kind="Method" Static="False" Accessibility="Family" ExternallyVisible="True">
                <Messages>
                 <Message TypeName="DoNotCallOverridableMethodsInConstructors" Category="Microsoft.Usage" CheckId="CA2214" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="NonBreaking">
                  <Issue Certainty="95" Level="CriticalWarning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestBase.cs" Line="89">'RestBase.RestBase()' contains a call chain that results in a call to a virtual method defined by the class. Review the following call stack for unintended consequences: &#xD;&#xA;&#xD;&#xA;RestBase..ctor()&#xD;&#xA;RestBase.Initialize():Void&#xD;&#xA;RestBase.set_Cookies(WebParameterCollection):Void</Issue>
                  <Issue Certainty="95" Level="CriticalWarning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestBase.cs" Line="89">'RestBase.RestBase()' contains a call chain that results in a call to a virtual method defined by the class. Review the following call stack for unintended consequences: &#xD;&#xA;&#xD;&#xA;RestBase..ctor()&#xD;&#xA;RestBase.Initialize():Void&#xD;&#xA;RestBase.set_Headers(NameValueCollection):Void</Issue>
                  <Issue Certainty="95" Level="CriticalWarning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestBase.cs" Line="89">'RestBase.RestBase()' contains a call chain that results in a call to a virtual method defined by the class. Review the following call stack for unintended consequences: &#xD;&#xA;&#xD;&#xA;RestBase..ctor()&#xD;&#xA;RestBase.Initialize():Void&#xD;&#xA;RestBase.set_Parameters(WebParameterCollection):Void</Issue>
                  <Issue Certainty="95" Level="CriticalWarning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestBase.cs" Line="89">'RestBase.RestBase()' contains a call chain that results in a call to a virtual method defined by the class. Review the following call stack for unintended consequences: &#xD;&#xA;&#xD;&#xA;RestBase..ctor()&#xD;&#xA;RestBase.Initialize():Void&#xD;&#xA;RestBase.set_PostParameters(ICollection&lt;HttpPostParameter&gt;):Void</Issue>
                 </Message>
                </Messages>
               </Member>
              </Members>
             </Type>
             <Type Name="RestClient" Kind="Class" Accessibility="Public" ExternallyVisible="True">
              <Members>
               <Member Name="#_streamQuery" Kind="Field" Static="False" Accessibility="Private" ExternallyVisible="False">
                <Messages>
                 <Message TypeName="MarkAllNonSerializableFields" Category="Microsoft.Usage" CheckId="CA2235" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="NonBreaking">
                  <Issue Certainty="95" Level="Error">Field 'RestClient._streamQuery' is a member of type 'RestClient', which is serializable, but is of type 'WebQuery', which is not serializable. Add the NonSerializedAttribute to 'RestClient._streamQuery'.</Issue>
                 </Message>
                </Messages>
               </Member>
               <Member Name="#BeginRequestWithTask(Hammock.RestRequest,Hammock.RestCallback,Hammock.Web.WebQuery,System.String,Hammock.Web.WebQueryAsyncResult&amp;,System.Object)" Kind="Method" Static="False" Accessibility="Private" ExternallyVisible="False">
                <Messages>
                 <Message TypeName="Dispose objects before losing scope" Category="Microsoft.Reliability" CheckId="CA2000" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="DependsOnFix">
                  <Issue Name="ExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="2064">In method 'RestClient.BeginRequestWithTask(RestRequest, RestCallback, WebQuery, string, out WebQueryAsyncResult, object)', object '&lt;&gt;g__initLocal3d' is not disposed along all exception paths. Call System.IDisposable.Dispose on object '&lt;&gt;g__initLocal3d' before all references to it are out of scope.</Issue>
                  <Issue Name="NonExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="2032">In method 'RestClient.BeginRequestWithTask(RestRequest, RestCallback, WebQuery, string, out WebQueryAsyncResult, object)', call System.IDisposable.Dispose on object 'task' before all references to it are out of scope.</Issue>
                 </Message>
                </Messages>
               </Member>
               <Member Name="#BeginRequestWithTask`1(Hammock.RestRequest,Hammock.RestCallback`1&lt;!!0&gt;,Hammock.Web.WebQuery,System.String,Hammock.Web.WebQueryAsyncResult&amp;,System.Object)" Kind="Method" Static="False" Accessibility="Private" ExternallyVisible="False">
                <Messages>
                 <Message TypeName="Dispose objects before losing scope" Category="Microsoft.Reliability" CheckId="CA2000" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="DependsOnFix">
                  <Issue Name="ExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="2126">In method 'RestClient.BeginRequestWithTask&lt;T&gt;(RestRequest, RestCallback&lt;T&gt;, WebQuery, string, out WebQueryAsyncResult, object)', object '&lt;&gt;g__initLocal45' is not disposed along all exception paths. Call System.IDisposable.Dispose on object '&lt;&gt;g__initLocal45' before all references to it are out of scope.</Issue>
                  <Issue Name="NonExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="2095">In method 'RestClient.BeginRequestWithTask&lt;T&gt;(RestRequest, RestCallback&lt;T&gt;, WebQuery, string, out WebQueryAsyncResult, object)', call System.IDisposable.Dispose on object 'task' before all references to it are out of scope.</Issue>
                 </Message>
                </Messages>
               </Member>
               <Member Name="#BuildBaseResponse(Hammock.Web.WebQueryResult)" Kind="Method" Static="True" Accessibility="Private" ExternallyVisible="False">
                <Messages>
                 <Message TypeName="Dispose objects before losing scope" Category="Microsoft.Reliability" CheckId="CA2000" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="DependsOnFix">
                  <Issue Name="ExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="2519">In method 'RestClient.BuildBaseResponse(WebQueryResult)', object 'response' is not disposed along all exception paths. Call System.IDisposable.Dispose on object 'response' before all references to it are out of scope.</Issue>
                 </Message>
                </Messages>
               </Member>
               <Member Name="#BuildBaseResponse`1(Hammock.Web.WebQueryResult)" Kind="Method" Static="True" Accessibility="Private" ExternallyVisible="False">
                <Messages>
                 <Message TypeName="Dispose objects before losing scope" Category="Microsoft.Reliability" CheckId="CA2000" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="DependsOnFix">
                  <Issue Name="ExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="2528">In method 'RestClient.BuildBaseResponse&lt;T&gt;(WebQueryResult)', object 'response' is not disposed along all exception paths. Call System.IDisposable.Dispose on object 'response' before all references to it are out of scope.</Issue>
                 </Message>
                </Messages>
               </Member>
               <Member Name="#BuildRateLimitingTask(Hammock.RestRequest,Hammock.Tasks.ITaskOptions,Hammock.RestCallback,Hammock.Web.WebQuery,System.String,System.Object)" Kind="Method" Static="False" Accessibility="Private" ExternallyVisible="False">
                <Messages>
                 <Message TypeName="Dispose objects before losing scope" Category="Microsoft.Reliability" CheckId="CA2000" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="DependsOnFix">
                  <Issue Name="NonExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="2247">In method 'RestClient.BuildRateLimitingTask(RestRequest, ITaskOptions, RestCallback, WebQuery, string, object)', call System.IDisposable.Dispose on object '&lt;&gt;g__initLocal4b' before all references to it are out of scope.</Issue>
                 </Message>
                </Messages>
               </Member>
               <Member Name="#CompleteWithMockWebResponse(System.IAsyncResult,System.IAsyncResult,Hammock.Web.Triplet`3&lt;Hammock.RestRequest,Hammock.RestCallback,System.Object&gt;)" Kind="Method" Static="False" Accessibility="Private" ExternallyVisible="False">
                <Messages>
                 <Message TypeName="Dispose objects before losing scope" Category="Microsoft.Reliability" CheckId="CA2000" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="DependsOnFix">
                  <Issue Name="ExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="1017">In method 'RestClient.CompleteWithMockWebResponse(IAsyncResult, IAsyncResult, Triplet&lt;RestRequest, RestCallback, object&gt;)', object '&lt;&gt;g__initLocal10' is not disposed along all exception paths. Call System.IDisposable.Dispose on object '&lt;&gt;g__initLocal10' before all references to it are out of scope.</Issue>
                  <Issue Name="ExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="1001">In method 'RestClient.CompleteWithMockWebResponse(IAsyncResult, IAsyncResult, Triplet&lt;RestRequest, RestCallback, object&gt;)', object 'm' is not disposed along all exception paths. Call System.IDisposable.Dispose on object 'm' before all references to it are out of scope.</Issue>
                 </Message>
                 <Message TypeName="Do not dispose objects multiple times" Category="Microsoft.Usage" CheckId="CA2202" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="DependsOnFix">
                  <Issue Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="1008">Object 'stream' can be disposed more than once in method 'RestClient.CompleteWithMockWebResponse(IAsyncResult, IAsyncResult, Triplet&lt;RestRequest, RestCallback, object&gt;)'. To avoid generating a System.ObjectDisposedException you should not call Dispose more than one time on an object.: Lines: 1008</Issue>
                 </Message>
                </Messages>
               </Member>
               <Member Name="#CompleteWithMockWebResponse`1(System.IAsyncResult,System.IAsyncResult,Hammock.Web.Triplet`3&lt;Hammock.RestRequest,Hammock.RestCallback`1&lt;!!0&gt;,System.Object&gt;)" Kind="Method" Static="False" Accessibility="Private" ExternallyVisible="False">
                <Messages>
                 <Message TypeName="Dispose objects before losing scope" Category="Microsoft.Reliability" CheckId="CA2000" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="DependsOnFix">
                  <Issue Name="ExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="953">In method 'RestClient.CompleteWithMockWebResponse&lt;T&gt;(IAsyncResult, IAsyncResult, Triplet&lt;RestRequest, RestCallback&lt;T&gt;, object&gt;)', object '&lt;&gt;g__initLocalf' is not disposed along all exception paths. Call System.IDisposable.Dispose on object '&lt;&gt;g__initLocalf' before all references to it are out of scope.</Issue>
                  <Issue Name="ExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="937">In method 'RestClient.CompleteWithMockWebResponse&lt;T&gt;(IAsyncResult, IAsyncResult, Triplet&lt;RestRequest, RestCallback&lt;T&gt;, object&gt;)', object 'm' is not disposed along all exception paths. Call System.IDisposable.Dispose on object 'm' before all references to it are out of scope.</Issue>
                 </Message>
                 <Message TypeName="Do not dispose objects multiple times" Category="Microsoft.Usage" CheckId="CA2202" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="DependsOnFix">
                  <Issue Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="944">Object 'stream' can be disposed more than once in method 'RestClient.CompleteWithMockWebResponse&lt;T&gt;(IAsyncResult, IAsyncResult, Triplet&lt;RestRequest, RestCallback&lt;T&gt;, object&gt;)'. To avoid generating a System.ObjectDisposedException you should not call Dispose more than one time on an object.: Lines: 944</Issue>
                 </Message>
                </Messages>
               </Member>
               <Member Name="#GetQueryFor(Hammock.RestBase,System.Uri)" Kind="Method" Static="False" Accessibility="Public" ExternallyVisible="True">
                <Messages>
                 <Message TypeName="Dispose objects before losing scope" Category="Microsoft.Reliability" CheckId="CA2000" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="DependsOnFix">
                  <Issue Name="ExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestClient.cs" Line="2659">In method 'RestClient.GetQueryFor(RestBase, Uri)', object 'new BasicAuthWebQuery(info)' is not disposed along all exception paths. Call System.IDisposable.Dispose on object 'new BasicAuthWebQuery(info)' before all references to it are out of scope.</Issue>
                 </Message>
                </Messages>
               </Member>
              </Members>
             </Type>
             <Type Name="RestRequest" Kind="Class" Accessibility="Public" ExternallyVisible="True">
              <Members>
               <Member Name="#.ctor()" Kind="Method" Static="False" Accessibility="Public" ExternallyVisible="True">
                <Messages>
                 <Message TypeName="DoNotCallOverridableMethodsInConstructors" Category="Microsoft.Usage" CheckId="CA2214" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="NonBreaking">
                  <Issue Certainty="95" Level="CriticalWarning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestRequest.cs" Line="27">'RestRequest.RestRequest()' contains a call chain that results in a call to a virtual method defined by the class. Review the following call stack for unintended consequences: &#xD;&#xA;&#xD;&#xA;RestRequest..ctor()&#xD;&#xA;RestRequest.Initialize():Void&#xD;&#xA;RestRequest.set_ExpectHeaders(WebHeaderCollection):Void</Issue>
                 </Message>
                </Messages>
               </Member>
              </Members>
             </Type>
             <Type Name="RestResponseBase" Kind="Class" Accessibility="Public" ExternallyVisible="True">
              <Messages>
               <Message TypeName="ImplementIDisposableCorrectly" Category="Microsoft.Design" CheckId="CA1063" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="Breaking">
                <Issue Name="ProvideDisposeBool" Certainty="95" Level="Error">Provide an overridable implementation of Dispose(bool) on 'RestResponseBase' or mark the type as sealed. A call to Dispose(false) should only clean up native resources. A call to Dispose(true) should clean up both managed and native resources.</Issue>
               </Message>
              </Messages>
              <Members>
               <Member Name="#Dispose()" Kind="Method" Static="False" Accessibility="Public" ExternallyVisible="True">
                <Messages>
                 <Message TypeName="ImplementIDisposableCorrectly" Category="Microsoft.Design" CheckId="CA1063" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="Breaking">
                  <Issue Name="DisposeImplementation" Certainty="95" Level="Error" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestResponse.cs" Line="287">Modify 'RestResponseBase.Dispose()' so that it calls Dispose(true), then calls GC.SuppressFinalize on the current object instance ('this' or 'Me' in Visual Basic), and then returns.</Issue>
                 </Message>
                </Messages>
               </Member>
               <Member Name="#ReplaceContentStreamWithMemoryStream()" Kind="Method" Static="False" Accessibility="Private" ExternallyVisible="False">
                <Messages>
                 <Message TypeName="Dispose objects before losing scope" Category="Microsoft.Reliability" CheckId="CA2000" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="DependsOnFix">
                  <Issue Name="ExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock" File="RestResponse.cs" Line="138">In method 'RestResponseBase.ReplaceContentStreamWithMemoryStream()', object 'stream' is not disposed along all exception paths. Call System.IDisposable.Dispose on object 'stream' before all references to it are out of scope.</Issue>
                 </Message>
                </Messages>
               </Member>
              </Members>
             </Type>
            </Types>
           </Namespace>
           <Namespace Name="Hammock.Attributes.Specialized">
            <Types>
             <Type Name="EntityAttribute" Kind="Class" Accessibility="Public" ExternallyVisible="True">
              <Members>
               <Member Name="#.ctor()" Kind="Method" Static="False" Accessibility="Public" ExternallyVisible="True">
                <Messages>
                 <Message TypeName="DoNotCallOverridableMethodsInConstructors" Category="Microsoft.Usage" CheckId="CA2214" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="NonBreaking">
                  <Issue Certainty="95" Level="CriticalWarning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock\Attributes\Specialized" File="EntityAttribute.cs" Line="12">'EntityAttribute.EntityAttribute()' contains a call chain that results in a call to a virtual method defined by the class. Review the following call stack for unintended consequences: &#xD;&#xA;&#xD;&#xA;EntityAttribute..ctor()&#xD;&#xA;EntityAttribute.set_ContentEncoding(Encoding):Void</Issue>
                 </Message>
                </Messages>
               </Member>
              </Members>
             </Type>
            </Types>
           </Namespace>
           <Namespace Name="Hammock.Authentication.OAuth">
            <Types>
             <Type Name="OAuthTools" Kind="Class" Accessibility="Public" ExternallyVisible="True">
              <Members>
               <Member Name="#GetSignature(Hammock.Authentication.OAuth.OAuthSignatureMethod,Hammock.Authentication.OAuth.OAuthSignatureTreatment,System.String,System.String,System.String)" Kind="Method" Static="True" Accessibility="Public" ExternallyVisible="True">
                <Messages>
                 <Message TypeName="Dispose objects before losing scope" Category="Microsoft.Reliability" CheckId="CA2000" Status="Active" Created="2011-06-01 12:43:22Z" FixCategory="DependsOnFix">
                  <Issue Name="NonExceptionEdge" Certainty="75" Level="Warning" Path="L:\My Dropbox\_7_Source_Code\_1_Projects\hammock\src\net35\Hammock\Authentication\OAuth" File="OAuthTools.cs" Line="292">In method 'OAuthTools.GetSignature(OAuthSignatureMethod, OAuthSignatureTreatment, string, string, string)', call System.IDisposable.Dispose on object 'crypto' before all references to it are out of scope.</Issue>

Synnefo » Pithos MS Client

Revision b5061ac8