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

         <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
       </PropertyGroup>
       <ItemGroup>
         <Reference Include="AsyncCtpLibrary, Version=1.0.4107.18181, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
           <HintPath>C:\Users\Administrator\Documents\Microsoft Visual Studio Async CTP\Samples\AsyncCtpLibrary.dll</HintPath>
         </Reference>
         <Reference Include="Caliburn.Micro, Version=1.2.0.0, Culture=neutral, PublicKeyToken=8e5891231f2ed21f, processorArchitecture=MSIL">
           <HintPath>..\Libraries\Caliburn.Micro.dll</HintPath>
         </Reference>

                                 var query = request.QueryString;
                                 var userName = query["user"];
                                 var token = query["token"];
                                 Log.InfoFormat("[RETRIEVE] Credentials retrieved user:{0} token:{1}", userName, token);
                                 Respond(context);
                                 return new NetworkCredential(userName, token);
                                 if (String.IsNullOrWhiteSpace(userName) || String.IsNullOrWhiteSpace(token))
+                                {
                                     Respond(context, "Failure", "The server did not return a username or token");
                                     Log.ErrorFormat("[RETRIEVE] No credentials returned by server");
                                     throw new Exception("The server did not return a username or token");
+                                }
                                 else
+                                {
                                     Log.InfoFormat("[RETRIEVE] Credentials retrieved user:{0} token:{1}", userName, token);
                                     Respond(context, "Authenticated", "Got It");
                                     return new NetworkCredential(userName, token);
+                                }
+                            }
+                        }
-...
                 return receiveCredentials;
+            }
             private static void Respond(HttpListenerContext context)
             private static void Respond(HttpListenerContext context,string title,string message)
+            {
                 var response = context.Response;
                 var outBuffer = Encoding.UTF8.GetBytes("<html><head><title>Authenticated</title></head><body><h1>Got It</h1></body></html>");
                 var html = String.Format("<html><head><title>{0}</title></head><body><h1>{1}</h1></body></html>", title, message);
                 var outBuffer = Encoding.UTF8.GetBytes(html);
                 response.ContentLength64 = outBuffer.Length;
                 using (var stream = response.OutputStream)
+                {

                 NotifyOfPropertyChange(()=>Settings);
+            }
             public void AddPithosAccount()
             public async void AddPithosAccount()
+           {
                var task=PithosAccount.RetrieveCredentialsAsync(Settings.PithosSite)
                    .ContinueWith(t=>
+                       {
                            var credentials=t.Result;
                            var account = Settings.Accounts.FirstOrDefault(act => act.AccountName == credentials.UserName);
                            if (account == null)
+                           {
                                account=new AccountSettings{
                                    AccountName=credentials.UserName,
                                    ApiKey=credentials.Password,
                                    UsePithos=true
                                };
                                Settings.Accounts.Add(account);
                                (Accounts as IProducerConsumerCollection<AccountSettings>).TryAdd(account);
+                           }
                            else
+                           {
                                account.ApiKey=credentials.Password;
+                           }
                            //SelectedAccountIndex= Settings.Accounts.IndexOf(account);
                            CurrentAccount = account;
                            NotifyOfPropertyChange(() => Accounts);
                            NotifyOfPropertyChange(()=>Settings);
                        });
                 ((Task)task).WaitWithPumping();
                 var credentials=await PithosAccount.RetrieveCredentialsAsync(Settings.PithosSite);
                 var account = Settings.Accounts.FirstOrDefault(act => act.AccountName == credentials.UserName);
                 if (account == null)
+                {
                     account=new AccountSettings{
                         AccountName=credentials.UserName,
                         ApiKey=credentials.Password,
                         UsePithos=true
                     };
                     Settings.Accounts.Add(account);
                     (Accounts as IProducerConsumerCollection<AccountSettings>).TryAdd(account);
+                }
                 else
+                {
                     account.ApiKey=credentials.Password;
+                }
                 //SelectedAccountIndex= Settings.Accounts.IndexOf(account);
                 CurrentAccount = account;
                 NotifyOfPropertyChange(() => Accounts);
                 NotifyOfPropertyChange(()=>Settings);
+           }
             public void RemoveAccount()

b/trunk/Pithos.Client.WPF/ShellViewModel.cs
422	422	{
423	423	var message = String.Format("API Key Expired for {0}. Starting Renewal",monitor.UserName);
424	424	Log.Error(message,exc);
425		TryAuthorize(monitor,retries);
	425	TryAuthorize(monitor,retries).Wait();
426	426	}
427	427	else
428	428	{

         class NetworkAgentTest
+        {
             [Test]
             public void TestUpload()
             public async void TestUpload()
+            {
                 var agent = new NetworkAgent();
-...
                 client.DeleteObject(null, FolderConstants.PithosContainer, fileName);
                 var task = Signature.CalculateTreeHashAsync(filePath, accountInfo.BlockSize, accountInfo.BlockHash);
                 var treeHash = await Signature.CalculateTreeHashAsync(filePath, accountInfo.BlockSize, accountInfo.BlockHash);
                 var cloudFile = new ObjectInfo {Account = account, Container = "pithos"};
                 var fileInfo = new FileInfo(filePath);
                 var tasks=agent.UploadWithHashMap(accountInfo,cloudFile,fileInfo,fileName,task);
                 Task.Factory.Iterate(tasks).Wait();
                 var newHash = client.GetHashMap(null, FolderConstants.PithosContainer, fileName).Result;
                 agent.UploadWithHashMap(accountInfo,cloudFile,fileInfo,fileName,treeHash);
                 var newHash = await client.GetHashMap(null, FolderConstants.PithosContainer, fileName);
                 var treeHash = task.Result;
                 Assert.AreEqual(treeHash.TopHash, newHash.TopHash);
                 Assert.AreEqual(treeHash.Hashes, newHash.Hashes);

         <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
       </PropertyGroup>
       <ItemGroup>
         <Reference Include="AsyncCtpLibrary, Version=1.0.4107.18181, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
           <HintPath>C:\Users\Administrator\Documents\Microsoft Visual Studio Async CTP\Samples\AsyncCtpLibrary.dll</HintPath>
         </Reference>
         <Reference Include="Castle.ActiveRecord, Version=3.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL" />
         <Reference Include="Castle.Core">
           <HintPath>..\Libraries\Castle.Core.dll</HintPath>

+            }
             private void UploadCloudFile(CloudAction action)
             private async void UploadCloudFile(CloudAction action)
+            {
                 if (action == null)
                     throw new ArgumentNullException("action");
-...
                 try
+                {
                     var upload = Task.Factory.Iterate(UploadIterator(action));
                     upload.Wait();
+                }
                 catch (AggregateException ex)
+                {
                     var exc = ex.InnerException as WebException;
                     if (exc==null)
                         throw ex.InnerException;
                     var response = exc.Response as HttpWebResponse;
                     if (response==null)
                         throw exc;
                     if (response.StatusCode == HttpStatusCode.Unauthorized)
+                    {
                         Log.Error("Not allowed to upload file", exc);
                         var message = String.Format("Not allowed to uplad file {0}",action.LocalFile.FullName);
                         StatusKeeper.SetFileState(action.LocalFile.FullName,FileStatus.Unchanged,FileOverlayStatus.Normal);
                         StatusNotification.NotifyChange(message,TraceLevel.Warning);
                         return;
+                    }
                     throw;
+                }
+            }
                     if (action == null)
                         throw new ArgumentNullException("action");
                     Contract.EndContractBlock();
             private IEnumerable<Task> UploadIterator(CloudAction action)
+            {
                 if (action == null)
                     throw new ArgumentNullException("action");
                 Contract.EndContractBlock();
                 var accountInfo=action.AccountInfo;
                     var accountInfo=action.AccountInfo;
                 var fileInfo=action.LocalFile;
                     var fileInfo=action.LocalFile;
                 if (fileInfo.Extension.Equals("ignore", StringComparison.InvariantCultureIgnoreCase))
                     yield break;
                     if (fileInfo.Extension.Equals("ignore", StringComparison.InvariantCultureIgnoreCase))
                         return;
                 var relativePath = fileInfo.AsRelativeTo(accountInfo.AccountPath);
                 if (relativePath.StartsWith(FolderConstants.OthersFolder))
+                {
                     var parts=relativePath.Split('\\');
                     var accountName = parts[1];
                     var oldName = accountInfo.UserName;
                     var absoluteUri = accountInfo.StorageUri.AbsoluteUri;
                     var nameIndex=absoluteUri.IndexOf(oldName);
                     var root=absoluteUri.Substring(0, nameIndex);
                     accountInfo = new AccountInfo
                     var relativePath = fileInfo.AsRelativeTo(accountInfo.AccountPath);
                     if (relativePath.StartsWith(FolderConstants.OthersFolder))
+                    {
                         UserName = accountName,
                         AccountPath = Path.Combine(accountInfo.AccountPath, parts[0], parts[1]),
                         StorageUri = new Uri(root + accountName),
                         BlockHash=accountInfo.BlockHash,
                         BlockSize=accountInfo.BlockSize,
                         Token=accountInfo.Token
                     };
+                }
                         var parts=relativePath.Split('\\');
                         var accountName = parts[1];
                         var oldName = accountInfo.UserName;
                         var absoluteUri = accountInfo.StorageUri.AbsoluteUri;
                         var nameIndex=absoluteUri.IndexOf(oldName);
                         var root=absoluteUri.Substring(0, nameIndex);
                         accountInfo = new AccountInfo
+                        {
                             UserName = accountName,
                             AccountPath = Path.Combine(accountInfo.AccountPath, parts[0], parts[1]),
                             StorageUri = new Uri(root + accountName),
                             BlockHash=accountInfo.BlockHash,
                             BlockSize=accountInfo.BlockSize,
                             Token=accountInfo.Token
                         };
+                    }
                 var fullFileName = fileInfo.FullName;
                 using(var gate=NetworkGate.Acquire(fullFileName,NetworkOperation.Uploading))
+                {
                     //Abort if the file is already being uploaded or downloaded
                     if (gate.Failed)
                         yield break;
                     var fullFileName = fileInfo.FullName;
                     using(var gate=NetworkGate.Acquire(fullFileName,NetworkOperation.Uploading))
+                    {
                         //Abort if the file is already being uploaded or downloaded
                         if (gate.Failed)
                             return;
                     var cloudFile = action.CloudFile;
                     var account = cloudFile.Account ?? accountInfo.UserName;
                         var cloudFile = action.CloudFile;
                         var account = cloudFile.Account ?? accountInfo.UserName;
                     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 cloudHash = info.Hash.ToLower();
                         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 cloudHash = info.Hash.ToLower();
                     var hash = action.LocalHash.Value;
                     var topHash = action.TopHash.Value;
                         var hash = action.LocalHash.Value;
                         var topHash = action.TopHash.Value;
                     //If the file hashes match, abort the upload
                     if (hash == cloudHash  || topHash ==cloudHash)
+                    {
                         //but store any metadata changes
                         this.StatusKeeper.StoreInfo(fullFileName, info);
                         Log.InfoFormat("Skip upload of {0}, hashes match", fullFileName);
                         yield break;
+                    }
                         //If the file hashes match, abort the upload
                         if (hash == cloudHash  || topHash ==cloudHash)
+                        {
                             //but store any metadata changes
                             this.StatusKeeper.StoreInfo(fullFileName, info);
                             Log.InfoFormat("Skip upload of {0}, hashes match", fullFileName);
                             return;
+                        }
                     if (info.AllowedTo=="read")
                         yield break;
                         if (info.AllowedTo=="read")
                             return;
                     //Mark the file as modified while we upload it
                     StatusKeeper.SetFileOverlayStatus(fullFileName, FileOverlayStatus.Modified);
                     //And then upload it
                         //Mark the file as modified while we upload it
                         StatusKeeper.SetFileOverlayStatus(fullFileName, FileOverlayStatus.Modified);
                         //And then upload it
                     //Upload even small files using the Hashmap. The server may already containt
                     //the relevant folder
                         //Upload even small files using the Hashmap. The server may already containt
                         //the relevant folder
                     //First, calculate the tree hash
                     var treeHash = Signature.CalculateTreeHashAsync(fileInfo.FullName, accountInfo.BlockSize,
                         accountInfo.BlockHash);
                     yield return treeHash;
                         //First, calculate the tree hash
                         var treeHash = await Signature.CalculateTreeHashAsync(fileInfo.FullName, accountInfo.BlockSize,
                             accountInfo.BlockHash);
                     yield return Task.Factory.Iterate(UploadWithHashMap(accountInfo,cloudFile,fileInfo,cloudFile.Name,treeHash));
                         UploadWithHashMap(accountInfo,cloudFile,fileInfo,cloudFile.Name,treeHash);
                     //If everything succeeds, change the file and overlay status to normal
                     this.StatusKeeper.SetFileState(fullFileName, FileStatus.Unchanged, FileOverlayStatus.Normal);
                         //If everything succeeds, change the file and overlay status to normal
                         this.StatusKeeper.SetFileState(fullFileName, FileStatus.Unchanged, FileOverlayStatus.Normal);
+                    }
                     //Notify the Shell to update the overlays
                     NativeMethods.RaiseChangeNotification(fullFileName);
                     StatusNotification.NotifyChangedFile(fullFileName);
+                }
                 //Notify the Shell to update the overlays
                 NativeMethods.RaiseChangeNotification(fullFileName);
                 StatusNotification.NotifyChangedFile(fullFileName);
                 catch (AggregateException ex)
+                {
                     var exc = ex.InnerException as WebException;
                     if (exc == null)
                         throw ex.InnerException;
                     var response = exc.Response as HttpWebResponse;
                     if (response == null)
                         throw exc;
                     if (response.StatusCode == HttpStatusCode.Unauthorized)
+                    {
                         Log.Error("Not allowed to upload file", exc);
                         var message = String.Format("Not allowed to uplad file {0}", action.LocalFile.FullName);
                         StatusKeeper.SetFileState(action.LocalFile.FullName, FileStatus.Unchanged, FileOverlayStatus.Normal);
                         StatusNotification.NotifyChange(message, TraceLevel.Warning);
                         return;
+                    }
                     throw;
+                }
+            }
             public IEnumerable<Task> UploadWithHashMap(AccountInfo accountInfo,ObjectInfo cloudFile,FileInfo fileInfo,string url,Task<TreeHash> treeHash)
             public async void UploadWithHashMap(AccountInfo accountInfo,ObjectInfo cloudFile,FileInfo fileInfo,string url,TreeHash treeHash)
+            {
                 if (accountInfo == null)
                     throw new ArgumentNullException("accountInfo");
-...
                 var client = new CloudFilesClient(accountInfo);
                 //Send the hashmap to the server
                 var hashPut = client.PutHashMap(account, container, url, treeHash.Result);
                 yield return hashPut;
                 var missingHashes = hashPut.Result;
                 var missingHashes =  await client.PutHashMap(account, container, url, treeHash);
                 //If the server returns no missing hashes, we are done
                 while (missingHashes.Count > 0)
+                {
-...
                     foreach (var missingHash in missingHashes)
+                    {
                         //Find the proper block
                         var blockIndex = treeHash.Result.HashDictionary[missingHash];
                         var blockIndex = treeHash.HashDictionary[missingHash];
                         var offset = blockIndex*accountInfo.BlockSize;
                         var read = fileInfo.Read(buffer, offset, accountInfo.BlockSize);
                         //And upload the block
                         var postBlock = client.PostBlock(account, container, buffer, 0, read);
                         try
+                        {
                             //And upload the block
                             await client.PostBlock(account, container, buffer, 0, read);
                             Log.InfoFormat("[BLOCK] Block {0} of {1} uploaded", blockIndex, fullFileName);
+                        }
                         catch (Exception exc)
+                        {
                             Log.ErrorFormat("[ERROR] uploading block {0} of {1}\n{2}", blockIndex, fullFileName, exc);
+                        }
                         //We have to handle possible exceptions in a continuation because
                         //*yield return* can't appear inside a try block
                         yield return postBlock.ContinueWith(t =>
                             t.ReportExceptions(
                                 exc => Log.ErrorFormat("[ERROR] uploading block {0} of {1}\n{2}", blockIndex, fullFileName, exc),
                                 ()=>Log.InfoFormat("[BLOCK] Block {0} of {1} uploaded", blockIndex,fullFileName)));
+                    }
                     //Repeat until there are no more missing hashes
                     hashPut = client.PutHashMap(account, container, url, treeHash.Result);
                     yield return hashPut;
                     missingHashes = hashPut.Result;
                     //Repeat until there are no more missing hashes
                     missingHashes = await client.PutHashMap(account, container, url, treeHash);
+                }
+            }

         <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
       </PropertyGroup>
       <ItemGroup>
         <Reference Include="AsyncCtpLibrary">
           <HintPath>C:\Users\Administrator\Documents\Microsoft Visual Studio Async CTP\Samples\AsyncCtpLibrary.dll</HintPath>
         </Reference>
         <Reference Include="Caliburn.Micro, Version=1.2.0.0, Culture=neutral, PublicKeyToken=8e5891231f2ed21f, processorArchitecture=MSIL">
           <HintPath>..\Libraries\Caliburn.Micro.dll</HintPath>
         </Reference>

                     throw new InvalidOperationException("The Authentication url is empty");
                 Contract.EndContractBlock();
                 //If the account doesn't have a valid path, don't start monitoring but don't throw either
                 if (String.IsNullOrWhiteSpace(RootPath))
                     //TODO; Warn user?
                     return;
                 StatusNotification.NotifyChange("Starting");
                 if (_started)
+                {

         <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
       </PropertyGroup>
       <ItemGroup>
         <Reference Include="AsyncCtpLibrary">
           <HintPath>C:\Users\Administrator\Documents\Microsoft Visual Studio Async CTP\Samples\AsyncCtpLibrary.dll</HintPath>
         </Reference>
         <Reference Include="Newtonsoft.Json, Version=4.0.2.0, Culture=neutral, PublicKeyToken=b9a188c8922137c6, processorArchitecture=MSIL">
           <SpecificVersion>False</SpecificVersion>
           <HintPath>..\Pithos.Network\bin\Debug\Newtonsoft.Json.dll</HintPath>

         <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
       </PropertyGroup>
       <ItemGroup>
         <Reference Include="AsyncCtpLibrary">
           <HintPath>C:\Users\Administrator\Documents\Microsoft Visual Studio Async CTP\Samples\AsyncCtpLibrary.dll</HintPath>
         </Reference>
         <Reference Include="log4net">
           <HintPath>..\Libraries\log4net.dll</HintPath>
         </Reference>

                 return hash.Result;
+            }
             public static Task<TreeHash> CalculateTreeHashAsync(FileInfo fileInfo, int blockSize, string algorithm)
             public static async Task<TreeHash> CalculateTreeHashAsync(FileInfo fileInfo, int blockSize, string algorithm)
+            {
                 if (fileInfo == null)
                     throw new ArgumentNullException("fileInfo");
-...
                     throw new ArgumentNullException("algorithm");
                 Contract.EndContractBlock();
                 return CalculateTreeHashAsync(fileInfo.FullName, blockSize, algorithm);
                 return await CalculateTreeHashAsync(fileInfo.FullName, blockSize, algorithm);
+            }
             public static Task<TreeHash> CalculateTreeHashAsync(string filePath, int blockSize,string algorithm)
             public static async Task<TreeHash> CalculateTreeHashAsync(string filePath, int blockSize,string algorithm)
+            {
                 if (String.IsNullOrWhiteSpace(filePath))
                     throw new ArgumentNullException("filePath");
-...
                 //DON'T calculate hashes for folders
                 if (Directory.Exists(filePath))
                     return Task.Factory.StartNew(()=>new TreeHash(algorithm));
                     return new TreeHash(algorithm);
                 //The hash of a non-existent file is the empty hash
                 if (!File.Exists(filePath))
                     return Task.Factory.StartNew(()=>new TreeHash(algorithm));
                     return new TreeHash(algorithm);
                 //Calculate the hash of all blocks using a blockhash iterator
                 var treeHash =Iterate<TreeHash>(BlockHashIterator(filePath, blockSize, algorithm));
                 return treeHash;
+            }
             private static IEnumerable<Task> BlockHashIterator(string filePath, int blockSize, string algorithm)
+            {
                 using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, blockSize, true))
+                {
                     //Calculate the blocks asyncrhonously
                     var hashes= CalculateBlockHashesAsync(stream, blockSize, algorithm);
                     yield return hashes;
                     var hashes = await CalculateBlockHashesAsync(stream, blockSize, algorithm);
                     //And then proceed with creating and returning a TreeHash
                     var length = stream.Length;
                     var list = hashes.Result.OrderBy(pair => pair.Key).Select(pair => pair.Value).ToList();
                     var length = stream.Length;
                     var list = hashes.OrderBy(pair => pair.Key).Select(pair => pair.Value).ToList();
                     var treeHash = new TreeHash(algorithm)
+                    {
                         Bytes = length,
                         BlockSize = blockSize,
                         Bytes = length,
                         BlockSize = blockSize,
                         Hashes = list
                     };
                     yield return Task.Factory.FromResult(treeHash);
                     return treeHash;
+                }
+            }
             //The Task Iterator style allows the execution of a sequence of patterns using
             //iterator syntax.
             //This particular variation returns the result of the last task, if there is one

                 Debug.WriteLine(String.Format("ICON Status check for {0} - {1}", path, GetType().Name), LogCategories.ShellOverlays);
                 if (!Settings.Accounts.Any(account=>path.StartsWith(account.RootPath,StringComparison.InvariantCultureIgnoreCase)))
                 if (!Settings.Accounts.Any(account=>account.RootPath!=null && path.StartsWith(account.RootPath,StringComparison.InvariantCultureIgnoreCase)))
                     return WinError.S_FALSE;
                 var status=StatusChecker.GetFileOverlayStatus(path);

Synnefo » Pithos MS Client

Revision 437abfca