Synnefo » Pithos MS Client

            //var extensionController = new ShellExtensionController();

    [Export]

        public bool ShowDesktopNotifications

        {

            get { return Settings.Default.ShowDesktopNotifications; }

            set { Settings.Default.ShowDesktopNotifications = value; }

        }

    <Compile Include="Notification.cs" />

    <Compile Include="PithosAccount.cs" />

    <ProjectReference Include="..\Libraries\ParallelExtensionsExtras\ParallelExtensionsExtras.csproj">

      <Project>{C45218F8-09E7-4F57-85BC-5D8D2AC736A3}</Project>

      <Name>ParallelExtensionsExtras</Name>

    </ProjectReference>

                            <Button Name="AddPithosAccount" Content="Add" Style="{StaticResource ButtonStyle}" Width="50"/>

                            <Button Name="RemoveAccount" Content="Remove" Style="{StaticResource ButtonStyle}" Width="50"/>                            

                    <GroupBox Header="Account" Padding="5" Margin="5" Height="190" HorizontalAlignment="Stretch" VerticalAlignment="Top" Width="272">

                            <Grid>

using Caliburn.Micro;

using Hardcodet.Wpf.TaskbarNotification;

using Hardcodet.Wpf.TaskbarNotification;

    using System.Threading.Tasks;

    public class PreferencesViewModel : Screen, IShell, IHandle<Notification>

        private IEventAggregator _events;

        public PithosSettings Settings { get; set; }

        //ShellExtensionController _extensionController=new ShellExtensionController();

        public PreferencesViewModel(IEventAggregator events, TaskbarViewModel taskbar, PithosSettings settings, PithosMonitor monitor)

            _events = events;

            _events.Subscribe(this);

            Taskbar.StatusMessage = "In Synch";            

            Taskbar.UpdateStatus();

        public 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);

                       }

                       else

                       {

                           account.ApiKey=credentials.Password;

                       }

                       SelectedAccountIndex= Settings.Accounts.IndexOf(account);

                       NotifyOfPropertyChange(()=>Settings);

                   });

            ((Task)task).WaitWithPumping();

       }

                //if (value)

                //    _extensionController.RegisterExtensions();

                //else

                //{

                //    _extensionController.UnregisterExtensions();

                //}

                _selectedAccountIndex = value;

        public void Handle(Notification notification)

        {

            if (!Settings.ShowDesktopNotifications)

                return;

            BalloonIcon icon = BalloonIcon.None;

            switch (notification.Level)

            {

                case TraceLevel.Error:

                    icon = BalloonIcon.Error;

                    break;

                case TraceLevel.Info:

                case TraceLevel.Verbose:

                    icon = BalloonIcon.Info;

                    break;

                case TraceLevel.Warning:

                    icon = BalloonIcon.Warning;

                    break;

                default:

                    icon = BalloonIcon.None;

                    break;

            }

            var tv = (PreferencesView)this.GetView();

            tv.TaskbarView.ShowBalloonTip(notification.Title, notification.Message, icon);

        }

using System.Threading.Tasks;

    public class TaskbarViewModel:ViewAware,IStatusNotification

        private IEventAggregator _events;

        public TaskbarViewModel(IEventAggregator events, IStatusChecker statusChecker,PithosMonitor monitor,IPithosSettings settings)

            _events = events;            

            Monitor.StatusNotification = this;

            var tv=this.GetView();

            _events.Publish(new Notification { Title = "Start", Message = "Start Monitoring", Level = TraceLevel.Info});

                Task.Factory.StartNew(() => 

                    Monitor.Start())

                    .ContinueWith(t =>{

                        if (t.IsFaulted)

                        {

                            var message= String.Format("An exception occured. Can't start monitoring\n{0}",t.Exception);

                            _events.Publish(new Notification { Title = "Error",Message=message,Level= TraceLevel.Error });

                            MessageBox.Show(message);

                        }

                    });                

        }

        public void NotifyChange(string status, TraceLevel level=TraceLevel.Info)

        {

            this.StatusMessage = status;

            _events.Publish(new Notification { Title = "Pithos", Message = status, Level = level });

using System.Collections.Generic;

public class FileHashMap

{

    public byte[] Hash { get; set; }

    public IEnumerable<byte[]> Hashes { get; set; }

}

using System.Threading.Tasks;

        [HasMany(Cascade = ManyRelationCascadeEnum.AllDeleteOrphan, Lazy = true)]

        public IList<FileHash> Hashes { get; set; }

        public FileState()

        {

        }

        private static int BLOCK_SIZE = 4194304;

        public static Task<FileState> CreateForAsync(string filePath)

        {

            var fileState = new FileState

                                {

                                    FilePath = filePath, 

                                    OverlayStatus = FileOverlayStatus.Unversioned, 

                                    FileStatus = FileStatus.Created

                                };

            return Task.Factory.StartNew(()=> {

                    fileState.Checksum = Signature.CalculateHash(fileState.FilePath);

                })

                .ContinueWith(_=> Signature.CalculateBlockHashesAsync(filePath, BLOCK_SIZE)).Unwrap()

                .ContinueWith(t =>

                {

                    fileState.Hashes = t.Result;

                }).ContinueWith(t =>

                {

                    fileState.HashmapHash = Signature.CalculateHashmapHash(fileState.Hashes);

                }).ContinueWith(t=> fileState);

            //return fileState;

        }

        public byte[] HashmapHash { get; set; }

    [ActiveRecord]

    public class FileHash : ActiveRecordLinqBase<FileHash>

    {

        [PrimaryKey]

        public string FilePath { get; set; }

        [Property]

        public byte[] Value { get; set; }        

        [BelongsTo("FilePath")]

        public FileState FileState { get; set; }

    }

    <Compile Include="FileHashMap.cs" />

        public IStatusNotification StatusNotification { get; set; }

                    StatusNotification.NotifyChange("Paused");

                    StatusNotification.NotifyChange("In Synch");

            StatusNotification.NotifyChange("Starting");

            StatusNotification.NotifyChange("Indexing Local Files",TraceLevel.Info);

            Trace.TraceInformation("[START] Index Local");

            StatusNotification.NotifyChange("Restart processing interrupted files", TraceLevel.Verbose);

                                              .Except(_networkActions,new LocalFileComparer());                                      

                                      StatusNotification.NotifyChange(String.Format("Processing {0} files", _networkActions.Count));

    public interface IStatusNotification

    {        

        void NotifyChange(string status,TraceLevel level=TraceLevel.Info);

    }

using System;

using System.Collections;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Threading.Tasks;

using System.Linq;

using Pithos.Core;

    /*public static FileHashMap CalculateHashMap(string path, int blockSize)

    {

        CalculateBlockHashes(path, blockSize)

            .ContinueWith(blockTask =>

                              {

                                  var hashes = blockTask.Result;

                                  var hashMapHash = CalculateHashmapHash(hashes);

                                  return new FileHashMap {Hash = hashMapHash, Hashes = hashes};

                              });

    }*/

    public static Task<IList<FileHash>> CalculateBlockHashesAsync(string path, int blockSize)

    {

        var hashMap = new ConcurrentQueue<FileHash>();

        var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 4096, true);

            return stream.ReadBuffersAsync(blockSize, (buffer, read) =>

            {

                using (var hasher = SHA256.Create())

                {

                    var hash = hasher.ComputeHash(buffer, 0, read);

                    hashMap.Enqueue(new FileHash{FilePath=path,Value=hash});

                }

            }).ContinueWith(t=>

                                {

                                    stream.Close();

                                    return (IList<FileHash>)hashMap.ToList();

                                });                

    }

    //I'd rather return an enumerable of hash calculation tasks, each of which can

    //be use to further store the hashes to storage without first creating the list of hashes

    /* //Or I could pass an action object, just like ReadBuffers does

     Task.Factory.Iterate(HashMapIterator(stream, blockSize,hashMap.Enqueue))

         .ContinueWith(t=>

                           {

                               SHA256.Create();

                           });*/

    public static byte[] CalculateHashmapHash(IList<FileHash> hashMap )

    {

        using (var stream = new MemoryStream())

        using(var hasher=SHA256.Create())

        {

            foreach (var hash in hashMap)

            {

                stream.Write(hash.Value, 0, hash.Value.Length);

            }

            return hasher.ComputeHash(stream);

        }

    }

    public static IEnumerable<byte[]> HashMapLinq(string path, int blockSize)

    {

        using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 4096, true))

        {

            var query = from block in stream.GetIterator(blockSize).AsParallel().AsOrdered()

                        select block;  

            return query;

        }

    }

    public class Block

    {

        public int Offset { get; set; }

        public byte[] Data { get; set; }

    }

    public static IEnumerable<byte[]> GetIterator(this Stream stream,int blockSize)

    {        

        var buffer = new byte[blockSize];

        while(true)

        {            

            stream.Read(buffer, 0, buffer.Length);            

            yield return buffer;

        }

    }

    private static IEnumerable<Task> HashMapIterator(Stream input, int bufferSize,Action<byte[]> hashAvailable )

    {

        // Create a buffer that will be used over and over

        var buffer = new byte[bufferSize];

        using (var hasher = SHA256.Create())

        {

            // Until there's no more data

            while (true)

            {

                // Asynchronously read a buffer and yield until the operation completes

                var readTask = input.ReadAsync(buffer, 0, buffer.Length);

                yield return readTask;

                // If there's no more data in the stream, we're done.

                if (readTask.Result <= 0) break;

                // Otherwise, hand the data off to the delegate

                var hashTask = Task.Factory.StartNew(() => hasher.ComputeHash(buffer, 0, readTask.Result));

                yield return hashTask;

                hashAvailable(hashTask.Result);

            }

        }

    }

            var existingFiles = (from state in  FileState.Queryable

                                    select state.FilePath).ToList();

            var newFiles = paths.Except(existingFiles.AsParallel());//(from file in paths.Except(existingFiles.AsParallel())

                            //select FileState.FromPathAsync(file)

                           //);

            //var files=new ConcurrentBag<string>();            

            newFiles.ForAll(file=>  

                FileState.CreateForAsync(file)

                .ContinueWith(state=>_statusUpdateQueue.Add(state.Result.Save)));

            return newFiles;//.Select(state => state);// files.GetConsumingEnumerable();

        private int BLOCK_SIZE = 4194304;

            var webRequest = base.GetWebRequest(address);

            var request = webRequest as HttpWebRequest;

        private Task<T> Retry<T>(Func<T> original, int retryCount, TaskCompletionSource<T> tcs = null)

            if (tcs == null)

                tcs = new TaskCompletionSource<T>();

            Task.Factory.StartNew(original).ContinueWith(_original =>

                    if (!_original.IsFaulted)

                        tcs.SetFromTask(_original);

                    else 

                        var we = (e as WebException);

                        if (we==null)

                            tcs.SetException(e);

                        else

                            var statusCode = GetStatusCode(we);

                            //Return null for 404

                            if (statusCode == HttpStatusCode.NotFound)

                                tcs.SetResult(default(T));

                            //Retry for timeouts and service unavailable

                            else if (we.Status == WebExceptionStatus.Timeout ||

                                (we.Status == WebExceptionStatus.ProtocolError && statusCode == HttpStatusCode.ServiceUnavailable))

                                    tcs.SetException(new RetryException("Timed out too many times.", e));                                    

                                }

                                else

                                {

                                    Trace.TraceError(

                                        "[RETRY] Timed out after {0} ms. Will retry {1} more times\n{2}", Timeout,

                                        retryCount, e);

                                    Retry(original, retryCount - 1, tcs);

                            else

                                tcs.SetException(e);

                    };

                });

            return tcs.Task;

        private HttpStatusCode GetStatusCode(WebException we)

        {

            var statusCode = HttpStatusCode.RequestTimeout;

            if (we.Response != null)

            {

                statusCode = ((HttpWebResponse) we.Response).StatusCode;

                this.StatusCode = statusCode;

            }

            return statusCode;

        }