Synnefo » Pithos MS Client

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.Net.NetworkInformation;

using System.Security.Cryptography;

using System.ServiceModel.Description;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using Castle.ActiveRecord.Queries;

using Microsoft.WindowsAPICodePack.Net;

using Pithos.Core.Agents;

using Pithos.Interfaces;

using System.ServiceModel;

using Pithos.Network;

namespace Pithos.Core

{

    [Export(typeof(PithosMonitor))]

    public class PithosMonitor:IDisposable

    {

        private const string PithosContainer = "pithos";

        private const string TrashContainer = "trash";

        private const string FragmentsFolder = "fragments";

        private int _blockSize;

        private string _blockHash;

        [Import]

        public IPithosSettings Settings{get;set;}

        [Import]

        public IStatusKeeper StatusKeeper { get; set; }

        [Import]

        public IPithosWorkflow Workflow { get; set; }

        [Import]

        public ICloudClient CloudClient { get; set; }

        [Import]

        public ICloudClient CloudListeningClient { get; set; }

        public IStatusNotification StatusNotification { get; set; }

        [Import]

        public FileAgent FileAgent { get; set; }

        [Import]

        public WorkflowAgent WorkflowAgent { get; set; }

        [Import]

        public NetworkAgent NetworkAgent { get; set; }

        public string UserName { get; set; }

        public string ApiKey { get; set; }

        private ServiceHost _statusService { get; set; }

        public bool Pause

        {

            get { return FileAgent.Pause; }

            set

            {

                FileAgent.Pause = value;

                if (value)

                {

                    StatusKeeper.SetPithosStatus(PithosStatus.SyncPaused);

                    StatusNotification.NotifyChange("Paused");

                }

                else

                {

                    StatusKeeper.SetPithosStatus(PithosStatus.InSynch);

                    StatusNotification.NotifyChange("Synchronizing");

                }

            }

        }

        public string RootPath { get; set; }

        CancellationTokenSource _cancellationSource;

        public void Start()

        {

            StatusNotification.NotifyChange("Starting");

            if (_cancellationSource != null)

            {

                if (!_cancellationSource.IsCancellationRequested)

                    return;

            }

            _cancellationSource = new CancellationTokenSource();

            var proxyUri = ProxyFromSettings();            

            CloudClient.Proxy = proxyUri;

            CloudClient.UsePithos = this.UsePithos;

            EnsurePithosContainers();

            StatusKeeper.BlockHash = _blockHash;

            StatusKeeper.BlockSize = _blockSize;

            StatusKeeper.StartProcessing(_cancellationSource.Token);

            IndexLocalFiles(RootPath);

            StartWatcherAgent(RootPath);

            StartStatusService();

            StartWorkflowAgent();

            WorkflowAgent.RestartInterruptedFiles();

        }

        private void EnsurePithosContainers()

        {

            CloudClient.UsePithos = this.UsePithos;

            CloudClient.AuthenticationUrl = this.AuthenticationUrl;

            CloudClient.Authenticate(UserName, ApiKey);

            var pithosContainers = new[] { TrashContainer,PithosContainer};

            foreach (var container in pithosContainers)

            {

                var info=CloudClient.GetContainerInfo(container);

                if (info == ContainerInfo.Empty)

                {

                    CloudClient.CreateContainer(container);

                    info = CloudClient.GetContainerInfo(container);

                }

                _blockSize = info.BlockSize;

                _blockHash = info.BlockHash;

            }

            var allContainers= CloudClient.ListContainers();

            var extraContainers = from container in allContainers

                                  where !pithosContainers.Contains(container.Name.ToLower())

                                      select container;

        }

        public string AuthenticationUrl { get; set; }

        private Uri ProxyFromSettings()

        {            

            if (Settings.UseManualProxy)

            {

                var proxyUri = new UriBuilder

                                   {

                                       Host = Settings.ProxyServer, 

                                       Port = Settings.ProxyPort

                                   };

                if (Settings.ProxyAuthentication)

                {

                    proxyUri.UserName = Settings.ProxyUsername;

                    proxyUri.Password = Settings.ProxyPassword;

                }

                return proxyUri.Uri;

            }

            return null;

        }

        private void IndexLocalFiles(string path)

        {

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

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

            try

            {

                var fragmentsPath=Path.Combine(RootPath, FragmentsFolder);

                var files =

                    from filePath in Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories).AsParallel()

                    where !filePath.StartsWith(fragmentsPath,StringComparison.InvariantCultureIgnoreCase) &&

                            !filePath.EndsWith(".ignore",StringComparison.InvariantCultureIgnoreCase)

                    select filePath.ToLower();

                StatusKeeper.StoreUnversionedFiles(files);

            }

            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.

            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;

        }

        private void StartWorkflowAgent()

        {

            bool connected = NetworkListManager.IsConnectedToInternet;

            //If we are not connected retry later

            if (!connected)

            {

                Task.Factory.StartNewDelayed(10000, StartWorkflowAgent);

                return;

            }

            try

            {

                CloudClient.UsePithos = this.UsePithos;

                CloudClient.AuthenticationUrl = this.AuthenticationUrl;

                CloudClient.Authenticate(UserName, ApiKey);

                StartNetworkAgent(RootPath);

                WorkflowAgent.StatusNotification = StatusNotification;

                WorkflowAgent.FragmentsPath = Path.Combine(RootPath, FragmentsFolder);

                WorkflowAgent.Start();                

            }

            catch (Exception)

            {

                //Faild to authenticate due to network or account error

                //Retry after a while

                Task.Factory.StartNewDelayed(10000, StartWorkflowAgent);

            }

        }

        public bool UsePithos { get; set; }

        internal class LocalFileComparer:EqualityComparer<CloudAction>

        {

            public override bool Equals(CloudAction x, CloudAction y)

            {

                if (x.Action != y.Action)

                    return false;

                if (x.LocalFile != null && y.LocalFile != null && !x.LocalFile.FullName.Equals(y.LocalFile.FullName))

                    return false;

                if (x.CloudFile != null && y.CloudFile != null && !x.CloudFile.Hash.Equals(y.CloudFile.Hash))

                    return false;

                if (x.CloudFile == null ^ y.CloudFile == null ||

                    x.LocalFile == null ^ y.LocalFile == null)

                    return false;

                return true;

            }

            public override int GetHashCode(CloudAction obj)

            {

                var hash1 = (obj.LocalFile == null) ? int.MaxValue : obj.LocalFile.FullName.GetHashCode();

                var hash2 = (obj.CloudFile == null) ? int.MaxValue : obj.CloudFile.Hash.GetHashCode();

                var hash3 = obj.Action.GetHashCode();

                return hash1 ^ hash2 & hash3;

            }

        }        

        private Timer timer;

        private void StartNetworkAgent(string accountPath)

        {

            NetworkAgent.StatusNotification = StatusNotification;

            NetworkAgent.Start(PithosContainer, TrashContainer,_blockSize,_blockHash);

            NetworkAgent.ProcessRemoteFiles(accountPath);

        }

        //Make sure a hidden fragments folder exists to store partial downloads

        private static string CreateHiddenFolder(string rootPath, string folderName)

        {

            if (String.IsNullOrWhiteSpace(rootPath))

                throw new ArgumentNullException("rootPath");

            if (!Path.IsPathRooted(rootPath))

                throw new ArgumentException("rootPath");

            if (String.IsNullOrWhiteSpace(folderName))

                throw new ArgumentNullException("folderName");

            Contract.EndContractBlock();

            var folder = Path.Combine(rootPath, folderName);

            if (!Directory.Exists(folder))

            {

                var info = Directory.CreateDirectory(folder);

                info.Attributes |= FileAttributes.Hidden;

                Trace.TraceInformation("Created Fragments Folder: {0}", folder);

            }

            return folder;

        }

        private void StartWatcherAgent(string path)

        {

            FileAgent.StatusKeeper = StatusKeeper;

            FileAgent.Workflow = Workflow;

            FileAgent.FragmentsPath = Path.Combine(RootPath, FragmentsFolder);

            FileAgent.Start(path);

        }

        public void Stop()

        {            

            FileAgent.Stop();

            if (timer != null)

                timer.Dispose();

            timer = null;

            StopStatusService();

        }

        ~PithosMonitor()

        {

            Dispose(false);

        }

        public void Dispose()

        {

            Dispose(true);

            GC.SuppressFinalize(this);

        }

        protected virtual void Dispose(bool disposing)

        {

            if (disposing)

            {

                Stop();

            }

        }

    }

    public interface IStatusNotification

    {        

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

    }

}