Synnefo » Pithos MS Client

                            <TextBox x:Name="PermissionName" Width="200" Margin="5"/>

                            <RadioButton x:Name="PermissionRead" Content="Read" Margin="5"/>

                            <RadioButton x:Name="PermissionWrite" Content="Write" Margin="5"/>

                            <Button x:Name="AddPermission" Content="Add" Margin="5"/>

                        <DataGrid x:Name="Permissions" ItemsSource="{Binding Permissions}" 

        private Permission _currentPermission;

        public Permission CurrentPermission

            get { return _currentPermission; }

                _currentPermission = value;

                NotifyOfPropertyChange(()=>CurrentPermission);

            }

        }

        private bool _permissionRead;

        public bool PermissionRead

        {

            get { return _permissionRead; }

            set

            {

                _permissionRead = value;

                NotifyOfPropertyChange(()=>PermissionRead);

                if (CurrentPermission != null)

                {

                    CurrentPermission.Read = value;

                }

            }

        }

        public bool PermissionWrite

        {

            get { return CurrentPermission.Write; }

            set

            {

                CurrentPermission.Write = value;

                NotifyOfPropertyChange(()=>PermissionWrite);

            Permissions.Add(new Permission{Read=PermissionRead,UserName=PermissionName,Write=!PermissionRead});   

    <Reference Include="Castle.Components.Validator">

      <HintPath>..\Libraries\Castle.Components.Validator.dll</HintPath>

    </Reference>

    <Reference Include="Castle.Core">

      <HintPath>..\Libraries\Castle.Core.dll</HintPath>

    </Reference>

    <Reference Include="NHibernate.ByteCode.Castle">

      <HintPath>..\Libraries\NHibernate.ByteCode.Castle.dll</HintPath>

    </Reference>

using System;

using System.Collections.Generic;

using System.ComponentModel.Composition;

using System.Diagnostics.Contracts;

using System.IO;

using System.Linq;

using System.Reflection;

using System.Threading;

using System.Threading.Tasks;

using Pithos.Interfaces;

using Pithos.Network;

using log4net;

namespace Pithos.Core.Agents

{

    [Export(typeof(Downloader))]

    public class Downloader

    {

        private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

        [Import]

        private IStatusKeeper StatusKeeper { get; set; }

        public IStatusNotification StatusNotification { get; set; }

/*

        private CancellationTokenSource _cts=new CancellationTokenSource();

        public void SignalStop()

        {

            _cts.Cancel();

        }

*/

        //Download a file.

        public async Task DownloadCloudFile(AccountInfo accountInfo, ObjectInfo cloudFile, string filePath,CancellationToken cancellationToken)

        {

            if (accountInfo == null)

                throw new ArgumentNullException("accountInfo");

            if (cloudFile == null)

                throw new ArgumentNullException("cloudFile");

            if (String.IsNullOrWhiteSpace(cloudFile.Account))

                throw new ArgumentNullException("cloudFile");

            if (String.IsNullOrWhiteSpace(cloudFile.Container))

                throw new ArgumentNullException("cloudFile");

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            if (!Path.IsPathRooted(filePath))

                throw new ArgumentException("The filePath must be rooted", "filePath");

            Contract.EndContractBlock();

                using (ThreadContext.Stacks["Operation"].Push("DownloadCloudFile"))

                {

                        return;

                    var localPath = FileInfoExtensions.GetProperFilePathCapitalization(filePath);

                    var relativeUrl = new Uri(cloudFile.Name, UriKind.Relative);

                    var url = relativeUrl.ToString();

                    if (cloudFile.Name.EndsWith(".ignore", StringComparison.InvariantCultureIgnoreCase))

                        return;

                    if (!Selectives.IsSelected(cloudFile))

                        return;

                    //Are we already downloading or uploading the file? 

                    using (var gate = NetworkGate.Acquire(localPath, NetworkOperation.Downloading))

                    {

                        if (gate.Failed)

                            return;

                        var client = new CloudFilesClient(accountInfo);

                        var account = cloudFile.Account;

                        var container = cloudFile.Container;

                        if (cloudFile.IsDirectory)

                        {

                            if (!Directory.Exists(localPath))

                                try

                                {

                                    Directory.CreateDirectory(localPath);

                                    if (Log.IsDebugEnabled)

                                        Log.DebugFormat("Created Directory [{0}]", localPath);

                                }

                                catch (IOException)

                                {

                                    var localInfo = new FileInfo(localPath);

                                    if (localInfo.Exists && localInfo.Length == 0)

                                    {

                                        Log.WarnFormat("Malformed directory object detected for [{0}]", localPath);

                                        localInfo.Delete();

                                        Directory.CreateDirectory(localPath);

                                        if (Log.IsDebugEnabled)

                                            Log.DebugFormat("Created Directory [{0}]", localPath);

                                    }

                                }

                        }

                        else

                        {

                            var isChanged = IsObjectChanged(cloudFile, localPath);

                            if (isChanged)

                            {

                                //Retrieve the hashmap from the server

                                var serverHash = await client.GetHashMap(account, container, url);

                                //If it's a small file

                                if (serverHash.Hashes.Count == 1)

                                    //Download it in one go

                                    await

                                        DownloadEntireFileAsync(accountInfo, client, cloudFile, relativeUrl, localPath,cancellationToken);

                                    //Otherwise download it block by block

                                else

                                    await

                                        DownloadWithBlocks(accountInfo, client, cloudFile, relativeUrl, localPath,

                                                           serverHash,cancellationToken);

                                if (!cloudFile.IsWritable(accountInfo.UserName))

                                {

                                    var attributes = File.GetAttributes(localPath);

                                    File.SetAttributes(localPath, attributes | FileAttributes.ReadOnly);

                                }

                            }

                        }

                        //Now we can store the object's metadata without worrying about ghost status entries

                        StatusKeeper.StoreInfo(localPath, cloudFile);

                    }

                }

        }

        //Download a file asynchronously using blocks

        public async Task DownloadWithBlocks(AccountInfo accountInfo, CloudFilesClient client, ObjectInfo cloudFile, Uri relativeUrl, string filePath, TreeHash serverHash, CancellationToken cancellationToken)

        {

            if (client == null)

                throw new ArgumentNullException("client");

            if (cloudFile == null)

                throw new ArgumentNullException("cloudFile");

            if (relativeUrl == null)

                throw new ArgumentNullException("relativeUrl");

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            if (!Path.IsPathRooted(filePath))

                throw new ArgumentException("The filePath must be rooted", "filePath");

            if (serverHash == null)

                throw new ArgumentNullException("serverHash");

            if (cloudFile.IsDirectory)

                throw new ArgumentException("cloudFile is a directory, not a file", "cloudFile");

                return;

            var fileAgent = GetFileAgent(accountInfo);

            var localPath = FileInfoExtensions.GetProperFilePathCapitalization(filePath);

            //Calculate the relative file path for the new file

            var relativePath = relativeUrl.RelativeUriToFilePath();

            var blockUpdater = new BlockUpdater(fileAgent.CachePath, localPath, relativePath, serverHash);

            StatusNotification.SetPithosStatus(PithosStatus.LocalSyncing, String.Format("Calculating hashmap for {0} before download", Path.GetFileName(localPath)));

            //Calculate the file's treehash

            //TODO: Should pass cancellation token here

            var treeHash = await Signature.CalculateTreeHashAsync(localPath, (int)serverHash.BlockSize, serverHash.BlockHash, 2);

            //And compare it with the server's hash

            var upHashes = serverHash.GetHashesAsStrings();

            var localHashes = treeHash.HashDictionary;

            ReportDownloadProgress(Path.GetFileName(localPath), 0, upHashes.Length, cloudFile.Bytes);

            for (var i = 0; i < upHashes.Length; i++)

                    return;

                //For every non-matching hash

                var upHash = upHashes[i];

                if (!localHashes.ContainsKey(upHash))

                {

                    StatusNotification.Notify(new CloudNotification { Data = cloudFile });

                    if (blockUpdater.UseOrphan(i, upHash))

                    {

                        Log.InfoFormat("[BLOCK GET] ORPHAN FOUND for {0} of {1} for {2}", i, upHashes.Length, localPath);

                        continue;

                    }

                    Log.InfoFormat("[BLOCK GET] START {0} of {1} for {2}", i, upHashes.Length, localPath);

                    var start = i * serverHash.BlockSize;

                    //To download the last block just pass a null for the end of the range

                    long? end = null;

                    if (i < upHashes.Length - 1)

                        end = ((i + 1) * serverHash.BlockSize);

                    //TODO: Pass token here

                    //Download the missing block

                    var block = await client.GetBlock(cloudFile.Account, cloudFile.Container, relativeUrl, start, end,cancellationToken);

                    //and store it

                    blockUpdater.StoreBlock(i, block);

                    Log.InfoFormat("[BLOCK GET] FINISH {0} of {1} for {2}", i, upHashes.Length, localPath);

                }

                ReportDownloadProgress(Path.GetFileName(localPath), i, upHashes.Length, cloudFile.Bytes);

            }

            //Want to avoid notifications if no changes were made

            var hasChanges = blockUpdater.HasBlocks;

            blockUpdater.Commit();

            if (hasChanges)

                //Notify listeners that a local file has changed

                StatusNotification.NotifyChangedFile(localPath);

            Log.InfoFormat("[BLOCK GET] COMPLETE {0}", localPath);

        }

        //Download a small file with a single GET operation

        private async Task DownloadEntireFileAsync(AccountInfo accountInfo, CloudFilesClient client, ObjectInfo cloudFile, Uri relativeUrl, string filePath, CancellationToken cancellationToken)

        {

            if (client == null)

                throw new ArgumentNullException("client");

            if (cloudFile == null)

                throw new ArgumentNullException("cloudFile");

            if (relativeUrl == null)

                throw new ArgumentNullException("relativeUrl");

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            if (!Path.IsPathRooted(filePath))

                throw new ArgumentException("The localPath must be rooted", "filePath");

            if (cloudFile.IsDirectory)

                throw new ArgumentException("cloudFile is a directory, not a file", "cloudFile");

                return;

            var localPath = FileInfoExtensions.GetProperFilePathCapitalization(filePath);

            StatusNotification.SetPithosStatus(PithosStatus.LocalSyncing, String.Format("Downloading {0}", Path.GetFileName(localPath)));

            StatusNotification.Notify(new CloudNotification { Data = cloudFile });

            var fileAgent = GetFileAgent(accountInfo);

            //Calculate the relative file path for the new file

            var relativePath = relativeUrl.RelativeUriToFilePath();

            //The file will be stored in a temporary location while downloading with an extension .download

            var tempPath = Path.Combine(fileAgent.CachePath, relativePath + ".download");

            //Make sure the target folder exists. DownloadFileTask will not create the folder

            var tempFolder = Path.GetDirectoryName(tempPath);

            if (!Directory.Exists(tempFolder))

                Directory.CreateDirectory(tempFolder);

            //TODO: Should pass the token here

            //Download the object to the temporary location

            await client.GetObject(cloudFile.Account, cloudFile.Container, relativeUrl.ToString(), tempPath,cancellationToken);

            //Create the local folder if it doesn't exist (necessary for shared objects)

            var localFolder = Path.GetDirectoryName(localPath);

            if (!Directory.Exists(localFolder))

                try

                {

                    Directory.CreateDirectory(localFolder);

                }

                catch (IOException)

                {

                    //A file may already exist that has the same name as the new folder.

                    //This may be an artifact of the way Pithos handles directories

                    var fileInfo = new FileInfo(localFolder);

                    if (fileInfo.Exists && fileInfo.Length == 0)

                    {

                        Log.WarnFormat("Malformed directory object detected for [{0}]", localFolder);

                        fileInfo.Delete();

                        Directory.CreateDirectory(localFolder);

                    }

                    else

                        throw;

                }

            //And move it to its actual location once downloading is finished

            if (File.Exists(localPath))

                File.Replace(tempPath, localPath, null, true);

            else

                File.Move(tempPath, localPath);

            //Notify listeners that a local file has changed

            StatusNotification.NotifyChangedFile(localPath);

        }

        private void ReportDownloadProgress(string fileName, int block, int totalBlocks, long fileSize)

        {

            StatusNotification.Notify(totalBlocks == 0

                                          ? new ProgressNotification(fileName, "Downloading", 1, 1, fileSize)

                                          : new ProgressNotification(fileName, "Downloading", block, totalBlocks, fileSize));

        }

        private bool IsObjectChanged(ObjectInfo cloudFile, string localPath)

        {

            //If the target is a directory, there are no changes to download

            if (Directory.Exists(localPath))

                return false;

            //If the file doesn't exist, we have a chagne

            if (!File.Exists(localPath))

                return true;

            //If there is no stored state, we have a change

            var localState = StatusKeeper.GetStateByFilePath(localPath);

            if (localState == null)

                return true;

            var info = new FileInfo(localPath);

            var shortHash = info.ComputeShortHash();

            //If the file is different from the stored state, we have a change

            if (localState.ShortHash != shortHash)

                return true;

            //If the top hashes differ, we have a change

            return (localState.Checksum != cloudFile.Hash);

        }

        private static FileAgent GetFileAgent(AccountInfo accountInfo)

        {

            return AgentLocator<FileAgent>.Get(accountInfo.AccountPath);

        }

        [Import]

        public Selectives Selectives { get; set; }

        public AsyncManualResetEvent UnpauseEvent { get; set; }

    }

}

                //If the local and remote files have 0 length their hashes will not match

                if (!cloudFile.IsDirectory && cloudFile.Bytes==0 && action.LocalFile is FileInfo && (action.LocalFile as FileInfo).Length==0 )

                {

                    Log.InfoFormat("Skipping {0}, files are empty", downloadPath);

                    return;

                }

                try

                    string account;

                    string container;

                    var segmentsCount = folderUri.Segments.Length;

                    if (segmentsCount < 3)

                        continue;

                    if (segmentsCount == 3)

                    {

                        account = folderUri.Segments[1].TrimEnd('/');

                        container = folderUri.Segments[2].TrimEnd('/');

                    }

                    else

                    {

                        account = folderUri.Segments[2].TrimEnd('/');

                        container = folderUri.Segments[3].TrimEnd('/');

                    }

                    IList<ObjectInfo> items;

                    if (segmentsCount > 3)

                    {

                        var folder = String.Join("", folderUri.Segments.Splice(4));

                        items = client.ListObjects(account, container, folder);

                    }

                    else

                    {

                        items = client.ListObjects(account, container);

                    }

                    var actions = CreatesToActions(accountInfo, items);

                    foreach (var action in actions)

                    {

                        NetworkAgent.Post(action);

                    }

                catch (Exception exc)

                    Log.WarnFormat("Listing of new selective path [{0}] failed with \r\n{1}", folderUri, exc);