Synnefo » Pithos MS Client

    <Reference Include="System.ServiceModel" />

    <Compile Include="Services\Events.cs" />

    <Compile Include="ShellViewModel.cs" />

    <Compile Include="Services\StatusService.cs" />

    <Page Include="ShellView.xaml">

      <Generator>MSBuild:Compile</Generator>

      <SubType>Designer</SubType>

    </Page>

            <Button Name="SaveChanges" Content="OK" Margin="5,5,10,5" Style="{StaticResource ButtonStyle}"/>

            <Button Name="RejectChanges" Content="Cancel" Margin="5,5,10,5" Style="{StaticResource ButtonStyle}"/>

    [Export]

    public class PreferencesViewModel : Screen

        public ShellViewModel Shell { get;  set; }

        public PreferencesViewModel(IEventAggregator events,ShellViewModel shell, PithosSettings settings)

            Shell = shell;

/*

*/

            TryClose(true);

            TryClose(false);

            foreach (var account in Settings.Accounts)

            {                

                Shell.MonitorAccount(account);

            }

            NotifyOfPropertyChange(()=>Settings);

            SelectedAccountIndex= Settings.Accounts.Count-1;           

            var accountName = CurrentAccount.AccountName;

            Settings.Accounts.RemoveAll(account => account.AccountName == accountName);

            Shell.RemoveMonitor(accountName);

            var monitor = Shell.Monitors[CurrentAccount.AccountName];            

namespace Pithos.Client.WPF.Services

{

    public class ShowFilePropertiesEvent

    {

        public string FileName { get; set; }

        public ShowFilePropertiesEvent(){}

        public ShowFilePropertiesEvent(string fileName)

        {

            FileName = fileName;

        }

    }

}

// -----------------------------------------------------------------------

// <copyright file="StatusService.cs" company="Microsoft">

// TODO: Update copyright text.

// </copyright>

// -----------------------------------------------------------------------

using Caliburn.Micro;

using System.ServiceModel;

using System.ComponentModel.Composition;

using Pithos.Core;

using Pithos.Interfaces;

namespace Pithos.Client.WPF.Services

{

    /// <summary>

    /// TODO: Update summary.

    /// </summary>

    [ServiceBehavior(IncludeExceptionDetailInFaults = true)]

    [Export]

    public class StatusService : IStatusService,ISettingsService, ICommandsService

    {

        [Import]

        public IPithosSettings Settings { get; set; }

        [Import]

        public IStatusChecker Checker { get; set; }

        [Import]

        public PithosMonitor Monitor { get; set; }

        public StatusService()

        {

            IoC.BuildUp(this);

        }

        private IEventAggregator _events;

        [ImportingConstructor]

        public StatusService(IStatusChecker checker,IEventAggregator events)

        {

            Checker = checker;

            _events = events;

        }

        public FileOverlayStatus GetStatus(string filePath)

        {

            return Checker.GetFileOverlayStatus(filePath);

        }

        public void DisplayProperties(string filePath)

        {

            //Monitor.

        }

        public PithosSettingsData GetSettings()

        {

            var data = new PithosSettingsData(Settings);

            return data;

        }

        public void ShowProperties(string fileName)

        {

            _events.Publish(new ShowFilePropertiesEvent(fileName));

        }

    }

}

    <Window.Resources>

        <ResourceDictionary>

            <ResourceDictionary.MergedDictionaries>

                <ResourceDictionary Source="PithosStyles.xaml" />

            </ResourceDictionary.MergedDictionaries>

        </ResourceDictionary>

    </Window.Resources>

    <Grid>

        <tb:TaskbarIcon x:Name="TaskbarView"                           

                        IconSource="{Binding StatusIcon}" 

                        ToolTipText="{Binding StatusMessage}"                        

                        MenuActivation="LeftOrRightClick" 

                        DoubleClickCommand="{Binding OpenPithosFolderCommand}"                         

                        >

            <tb:TaskbarIcon.ContextMenu>

                <ContextMenu x:Name="TaskbarMenu" >

                    <MenuItem Header="Open PITHOS Folder" x:Name="OpenPithosFolder" cal:Message.Attach="OpenPithosFolder" FontWeight="Bold" />

                    <MenuItem Header="Launch PITHOS Site"  x:Name="GoToSite" cal:Message.Attach="GoToSite" />

                    <MenuItem Header="Recently Changed Files" x:Name="RecentFiles" ItemsSource="{Binding RecentFiles}">

                        <MenuItem.ItemTemplate>

                            <DataTemplate>

                                <TextBlock Text="{Binding FileName}"/>

                            </DataTemplate>

                        </MenuItem.ItemTemplate>

                    <MenuItem Header="{Binding UsageMessage}" x:Name="UsageMessage" />

                    <MenuItem Header="{Binding StatusMessage}" x:Name="StatusMessage" />

                    <MenuItem  Header="{Binding PauseSyncCaption}" x:Name="ToggleSynching" cal:Message.Attach="ToggleSynching"  />

                    <MenuItem  Header="Preferences ..." x:Name="ShowPreferences" cal:Message.Attach="ShowPreferences"  />

                    <MenuItem  Header="Exit" Name="ExitPithos" cal:Message.Attach="ExitPithos" />

using System.Collections.Concurrent;

using System.ComponentModel.Composition;

using System.Diagnostics;

using System.IO;

using System.Runtime.InteropServices;

using System.ServiceModel;

using System.ServiceModel.Description;

using System.Threading.Tasks;

using System.Windows;

using Hardcodet.Wpf.TaskbarNotification;

using Pithos.Client.WPF.Configuration;

using Pithos.Client.WPF.Properties;

using Pithos.Core;

using Pithos.Interfaces;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using StatusService = Pithos.Client.WPF.Services.StatusService;

    public class ShellViewModel : ViewAware, IStatusNotification, IShell, IHandle<Notification>

        private IStatusChecker _statusChecker;

        private IEventAggregator _events;

        public PithosSettings Settings { get; private set; }

        public IScreen Parent { get; set; }

        private Dictionary<string, PithosMonitor> _monitors = new Dictionary<string, PithosMonitor>();

        public Dictionary<string, PithosMonitor> Monitors

            get { return _monitors; }

        }

        private ServiceHost _statusService { get; set; }

        private static readonly log4net.ILog Log = log4net.LogManager.GetLogger("Pithos");

        [ImportingConstructor]

        public ShellViewModel(IWindowManager windowManager, IEventAggregator events, IStatusChecker statusChecker, PithosSettings settings)

        {

            _windowManager = windowManager;

            OpenPithosFolderCommand = new PithosCommand(OpenPithosFolder);

            _statusChecker = statusChecker;

            _events = events;            

            Settings = settings;

            UsageMessage = "Using 15% of 50 GB";

            StatusMessage = "In Synch";

            foreach (var account in settings.Accounts)

            {

                MonitorAccount(account);

            }

            StartStatusService();

        }

        public void MonitorAccount(AccountSettings account)

        {

            PithosMonitor monitor = null;

            var accountName = account.AccountName;

            if (_monitors.TryGetValue(accountName,out monitor))

            {

                //If the account is active

                if (account.IsActive)

                    //Start the monitor. It's OK to start an already started monitor,

                    //it will just ignore the call

                    monitor.Start();

                else

                {

                    //If the account is inactive

                    //Stop and remove the monitor

                    RemoveMonitor(accountName);

                }

                return;

            }

            //PithosMonitor uses MEF so we need to resolve it

            monitor = new PithosMonitor

                          {

                              UserName = accountName,

                              ApiKey = account.ApiKey,

                              UsePithos = account.UsePithos,

                              StatusNotification = this,

                              RootPath=account.RootPath                             

                          };          

            IoC.BuildUp(monitor);

            var appSettings = Properties.Settings.Default;

            monitor.AuthenticationUrl = account.UsePithos

                                            ? appSettings.PithosAuthenticationUrl

                                            : appSettings.CloudfilesAuthenticationUrl;

            _monitors[accountName] = monitor;

            if (account.IsActive)

            {                

                //Don't start a monitor if it doesn't have an account and ApiKey

                if (String.IsNullOrWhiteSpace(monitor.UserName) || String.IsNullOrWhiteSpace(monitor.ApiKey))

                    return;

                StartMonitor(monitor);

            }

            var window = (Window)view;

            UpdateStatus();

                NotifyOfPropertyChange(() => StatusMessage);

                NotifyOfPropertyChange(() => UsageMessage);

        private string _pauseSyncCaption="Pause Syncing";

        public string PauseSyncCaption

        {

            get { return _pauseSyncCaption; }

            set

            {

                _pauseSyncCaption = value;

                NotifyOfPropertyChange(() => PauseSyncCaption);

            }

        }

        private readonly ObservableConcurrentCollection<FileEntry> _recentFiles = new ObservableConcurrentCollection<FileEntry>();

        public ObservableConcurrentCollection<FileEntry> RecentFiles

        {

            get { return _recentFiles; }

        }

        private string _statusIcon="Images/Tray.ico";

        public string StatusIcon

            get { return _statusIcon; }

            set

            {

                _statusIcon = value;

                NotifyOfPropertyChange(() => StatusIcon);

            }

        #region Commands

            Settings.Reload();

            var preferences = new PreferencesViewModel(_events, this,Settings);            

            _windowManager.ShowDialog(preferences);

        public PithosCommand OpenPithosFolderCommand { get; private set; }

            Process.Start(Settings.PithosPath);

            var activeAccount=Settings.Accounts.FirstOrDefault(account => account.IsActive);

            if (activeAccount == null)

                return;            

            var site = String.Format("http://{0}/ui/?token={1}&user={2}",

                Properties.Settings.Default.PithosSite,activeAccount.ApiKey,

                activeAccount.AccountName);

            Process.Start(site);

            bool isPaused=false;

            foreach (var pair in Monitors)

            {

                var monitor = pair.Value;

                monitor.Pause = !monitor.Pause;

                isPaused = monitor.Pause;

            }

            PauseSyncCaption = isPaused ? "Resume syncing" : "Pause syncing";

            var iconKey = isPaused? "TraySyncPaused" : "TrayInSynch";

            StatusIcon = String.Format(@"Images/{0}.ico", iconKey);

        }

        public void ExitPithos()

        {

            foreach (var pair in Monitors)

            {

                var monitor = pair.Value;

                monitor.Stop();

            }

            ((Window)GetView()).Close();

        }

        #endregion

        private Dictionary<PithosStatus, StatusInfo> iconNames = new List<StatusInfo>

            {

                new StatusInfo(PithosStatus.InSynch, "All files up to date", "TrayInSynch"),

                new StatusInfo(PithosStatus.Syncing, "Syncing Files", "TraySynching"),

                new StatusInfo(PithosStatus.SyncPaused, "Sync Paused", "TraySyncPaused")

            }.ToDictionary(s => s.Status);

        readonly IWindowManager _windowManager;

        public void UpdateStatus()

        {

            var pithosStatus = _statusChecker.GetPithosStatus();

            if (iconNames.ContainsKey(pithosStatus))

            {

                var info = iconNames[pithosStatus];

                StatusIcon = String.Format(@"Images/{0}.ico", info.IconName);

                StatusMessage = String.Format("Pithos 1.0\r\n{0}", info.StatusText);

            }

            var tv=this.GetView();

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

        }

        private Task StartMonitor(PithosMonitor monitor)

        {

            return Task.Factory.StartNew(() =>

            {

                using (log4net.ThreadContext.Stacks["Monitor"].Push("Start"))

                {

                    try

                    {

                        Log.InfoFormat("Start Monitoring {0}", monitor.UserName);

                        monitor.Start();

                    }

                    catch (Exception exc)

                    {

                        var message =

                            String.Format("An exception occured. Can't start monitoring\nWill retry in 10 seconds");

                        Task.Factory.StartNewDelayed(10000, () => StartMonitor(monitor));

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

                        Log.Error(message, exc);

                    }

                }

            });

        }

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

        {

            this.StatusMessage = status;

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

        public void NotifyChangedFile(string filePath)

            var entry = new FileEntry {FullPath=filePath};

            IProducerConsumerCollection<FileEntry> files=this.RecentFiles;

            FileEntry popped;

            while (files.Count > 5)

                files.TryTake(out popped);

            files.TryAdd(entry);

        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 = (ShellView)this.GetView();

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

        public void RemoveMonitor(string accountName)

        {

            if (String.IsNullOrWhiteSpace(accountName))

                return;

            PithosMonitor monitor;

            if (Monitors.TryGetValue(accountName, out monitor))

            {

                Monitors.Remove(accountName);

                monitor.Stop();

            }

        }

        public void RefreshOverlays()

        {

            foreach (var pair in Monitors)

            {

                var monitor = pair.Value;

                var path = monitor.RootPath;

                if (String.IsNullOrWhiteSpace(path))

                    continue;

                if (!Directory.Exists(path) && !File.Exists(path))

                    continue;

                IntPtr pathPointer = Marshal.StringToCoTaskMemAuto(path);

                try

                {

                    NativeMethods.SHChangeNotify(HChangeNotifyEventID.SHCNE_UPDATEITEM,

                                                 HChangeNotifyFlags.SHCNF_PATHW | HChangeNotifyFlags.SHCNF_FLUSHNOWAIT,

                                                 pathPointer, IntPtr.Zero);

                }

                finally

                {

                    Marshal.FreeHGlobal(pathPointer);

                }

            }

        }

        private void StartStatusService()

        {

            // Create a ServiceHost for the CalculatorService type and provide the base address.

            var baseAddress = new Uri("net.pipe://localhost/pithos");

            _statusService = new ServiceHost(typeof(StatusService), baseAddress);

            var binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);

            _statusService.AddServiceEndpoint(typeof(IStatusService), binding, "net.pipe://localhost/pithos/statuscache");

            _statusService.AddServiceEndpoint(typeof(ISettingsService), binding, "net.pipe://localhost/pithos/settings");

            //// Add a mex endpoint

            var smb = new ServiceMetadataBehavior

            {

                HttpGetEnabled = true,

                HttpGetUrl = new Uri("http://localhost:30000/pithos/mex")

            };

            _statusService.Description.Behaviors.Add(smb);

            _statusService.Open();

        }

        private void StopStatusService()

        {

            if (_statusService == null)

                return;

            if (_statusService.State == CommunicationState.Faulted)

                _statusService.Abort();

            else if (_statusService.State != CommunicationState.Closed)

                _statusService.Close();

            _statusService = null;

        }

using System.Threading.Tasks;

            var agent = new NetworkAgent();

            var apiKey = "24989dce4e0fcb072f8cb60c8922be19";

            var client = new CloudFilesClient(account,apiKey)

                             {

                                 AuthenticationUrl = @"https://pithos.dev.grnet.gr",

                                 UsePithos = true

                             };

            var accountInfo=client.Authenticate();

            client.DeleteObject(null, FolderConstants.PithosContainer, fileName);

            var task = Signature.CalculateTreeHashAsync(filePath, accountInfo.BlockSize, accountInfo.BlockHash);

            var tasks=agent.UploadWithHashMap(accountInfo,account,"pithos",new FileInfo(filePath),fileName,task);

            Task.Factory.Iterate(tasks).Wait();

            var newHash = client.GetHashMap(null, FolderConstants.PithosContainer, fileName).Result;

            var agent = new NetworkAgent();

            var account = "890329@vho.grnet.gr";

            var apiKey = "24989dce4e0fcb072f8cb60c8922be19";

            var client = new CloudFilesClient(account,apiKey)

                AuthenticationUrl = @"https://pithos.dev.grnet.gr",

                UsePithos = true

            var accountInfo=client.Authenticate();

                File.Delete(filePath);

            var newHash = client.GetHashMap(null, FolderConstants.PithosContainer, fileName).Result;

            agent.DownloadWithBlocks(client, account, FolderConstants.PithosContainer, new Uri(fileName, UriKind.Relative), filePath, newHash)

            var treeHash = Signature.CalculateTreeHashAsync(filePath, accountInfo.BlockSize, accountInfo.BlockHash).Result;

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

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

      <Name>ParallelExtensionsExtras</Name>

    </ProjectReference>

using System.Diagnostics.Contracts;

        public AccountInfo AccountInfo { get; set; }

        [ContractInvariantMethod]

        private void Invariants()

            Contract.Invariant(AccountInfo!=null);

        }

        protected CloudAction(AccountInfo accountInfo,CloudActionType action)

        {

            if (accountInfo==null)

                throw new ArgumentNullException("accountInfo");

            Contract.EndContractBlock();

            AccountInfo = accountInfo;

        public CloudAction(AccountInfo accountInfo, CloudActionType action, FileInfo localFile, ObjectInfo cloudFile, FileState state, int blockSize, string algorithm)

            : this(accountInfo,action)

        public CloudDownloadAction(AccountInfo accountInfo, ObjectInfo cloudFile)

            :base(accountInfo,CloudActionType.DownloadUnconditional)

        public CloudDeleteAction(AccountInfo accountInfo, string fileName, FileState fileState)

            : this(accountInfo,new ObjectInfo { Name = fileName },fileState)

        public CloudDeleteAction(AccountInfo accountInfo, ObjectInfo cloudFile, FileState fileState) 

            : base(accountInfo,CloudActionType.DeleteCloud)

        public CloudUploadAction(AccountInfo accountInfo, FileInfo fileInfo, FileState state, int blockSize, string algorithm) 

            : base(accountInfo,CloudActionType.UploadUnconditional,fileInfo,ObjectInfo.Empty,state,blockSize,algorithm)

        public CloudMoveAction(AccountInfo accountInfo, CloudActionType action, string oldPath, string oldFileName, string newFileName, string newPath)

            :base(accountInfo,action)

    [Export,PartCreationPolicy(CreationPolicy.NonShared)]

        private AccountInfo AccountInfo { get; set; }

        private string RootPath { get;  set; }

        public void Start(AccountInfo accountInfo,string rootPath)

            if (accountInfo==null)

                throw new ArgumentNullException("accountInfo");

            AccountInfo = accountInfo;

            _agent.Post(new WorkflowState(AccountInfo) { Path = filePath, FileName = e.Name, TriggeringChange = e.ChangeType });

            _agent.Post(new WorkflowState(AccountInfo)

       /* public int BlockSize { get; set; }

        public string BlockHash { get; set; }*/

        private List<AccountInfo> _accounts=new List<AccountInfo>();

        public void Start(/*int blockSize, string blockHash*/)

/*

            if (blockSize<0)

                throw new ArgumentOutOfRangeException("blockSize");

            if (String.IsNullOrWhiteSpace(blockHash))

                throw new ArgumentOutOfRangeException("blockHash");

*/

/*

*/

            if (action.AccountInfo==null)

                throw new ArgumentException("The action.AccountInfo is empty","action");

            var accountInfo = action.AccountInfo;

                var cloudFile = action.CloudFile;                

                                       : Path.Combine(accountInfo.AccountPath, cloudFile.RelativeUrlToFilePath(accountInfo.UserName));

                    var account = action.CloudFile.Account ?? accountInfo.UserName;

                    var container = action.CloudFile.Container ?? FolderConstants.PithosContainer;

                            UploadCloudFile(accountInfo,account, container, localFile, action.LocalHash.Value, action.TopHash.Value);

                            DownloadCloudFile(accountInfo, account, container, new Uri(cloudFile.Name, UriKind.Relative),

                            DeleteCloudFile(accountInfo, account, container, cloudFile.Name);

                            RenameCloudFile(accountInfo, account, container, moveAction.OldFileName, moveAction.NewPath,

                                DownloadCloudFile(accountInfo, account, container, cloudUri, downloadPath);

                                SyncFiles(accountInfo, action);

                    Post(new CloudDeleteAction(accountInfo,action.CloudFile,action.FileState));

        private void SyncFiles(AccountInfo accountInfo,CloudAction action)

            if (accountInfo == null)

                throw new ArgumentNullException("accountInfo");

            var container = cloudFile.Container ?? FolderConstants.PithosContainer;

                UploadCloudFile(accountInfo,account, container, localFile, action.LocalHash.Value,

                        DownloadCloudFile(accountInfo,account, container,cloudUri,downloadPath);

            if (cloudAction.AccountInfo==null)

                throw new ArgumentException("The CloudAction.AccountInfo is empty","cloudAction");

                var accountInfo = cloudAction.AccountInfo;

                if (cloudAction.LocalFile.Length>accountInfo.BlockSize)

                    cloudAction.TopHash = new Lazy<string>(() => Signature.CalculateTreeHashAsync(cloudAction.LocalFile,

                                    accountInfo.BlockSize, accountInfo.BlockHash).Result

        public Task ProcessRemoteFiles(DateTime? since=null)

        {

            return Task<Task>.Factory.StartNewDelayed(10000, () =>

            {

                using (log4net.ThreadContext.Stacks["Retrieve Remote"].Push("All accounts"))

                {

                    //Next time we will check for all changes since the current check minus 1 second

                    //This is done to ensure there are no discrepancies due to clock differences

                    DateTime nextSince = DateTime.Now.AddSeconds(-1);

                    var tasks=from accountInfo in _accounts

                              select ProcessAccountFiles(accountInfo, since);

                    var process=Task.Factory.Iterate(tasks);

                    return process.ContinueWith(t=>

                        ProcessRemoteFiles(nextSince));

                }

            });            

        }

        public Task ProcessAccountFiles(AccountInfo accountInfo,DateTime? since=null)

            if (accountInfo==null)

                throw new ArgumentNullException("accountInfo");

            if (String.IsNullOrWhiteSpace(accountInfo.AccountPath))

                throw new ArgumentException("The AccountInfo.AccountPath is empty","accountInfo");

            using (log4net.ThreadContext.Stacks["Retrieve Remote"].Push(accountInfo.UserName))

                Log.Info("Scheduled");

                var client=new CloudFilesClient(accountInfo);

                var listObjects = Task<IList<ObjectInfo>>.Factory.StartNew(() =>