Synnefo » Pithos MS Client

using System;

using System.Collections;

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.Linq.Expressions;

using System.Security.Cryptography;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using Castle.ActiveRecord;

using Castle.ActiveRecord.Framework.Config;

using Pithos.Interfaces;

namespace Pithos.Core

{

    [Export(typeof(IStatusChecker)),Export(typeof(IStatusKeeper))]

    public class StatusKeeper:IStatusChecker,IStatusKeeper

    {

        [System.ComponentModel.Composition.Import]

        public IPithosSettings Settings { get; set; }

        private JobQueue _statusUpdateQueue;

        public StatusKeeper()

        {            

            var appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

            var pithosDbPath = Path.Combine(appDataPath , "Pithos");

            var source = GetConfiguration(pithosDbPath);

            ActiveRecordStarter.Initialize(source,typeof(FileState),typeof(FileTag));            

            if (!File.Exists(Path.Combine(pithosDbPath ,"pithos.db")))

                ActiveRecordStarter.CreateSchema();

        }

        private static InPlaceConfigurationSource GetConfiguration(string pithosDbPath)

        {

            var properties = new Dictionary<string, string>

                                 {

                                     {"connection.driver_class", "NHibernate.Driver.SQLite20Driver"},

                                     {"dialect", "NHibernate.Dialect.SQLiteDialect"},

                                     {"connection.provider", "NHibernate.Connection.DriverConnectionProvider"},

                                     {

                                         "proxyfactory.factory_class",

                                         "NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle"

                                         },

                                 };

            var connectionString = String.Format(@"Data Source={0}\pithos.db;Version=3", pithosDbPath);

            properties.Add("connection.connection_string", connectionString);

            var source = new InPlaceConfigurationSource();

            source.Add(typeof (ActiveRecordBase), properties);

            return source;

        }

        public void StartProcessing(CancellationToken token)

        {

            _statusUpdateQueue.Start(token);

        }

        public void Stop()

        {

            _statusUpdateQueue.Stop();            

        }

        public IEnumerable<string> StoreUnversionedFiles(ParallelQuery<string> paths)

        {            

            var existingFiles = from state in  FileState.Queryable

                                    select state.FilePath;

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

                            select new FileState

                                       {

                                           FilePath = file,

                                           OverlayStatus = FileOverlayStatus.Unversioned,

                                           FileStatus=FileStatus.Created,     

                                           Checksum=Signature.CalculateHash(file)

                                       }

                           );

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

            newFiles.ForAll(state=> _statusUpdateQueue.Add(state.Save));

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

        }

/*

        private static Task<string> CalculateHashAsync(string path)

        {

            string hash;

            using (var hasher = MD5.Create())

            {

                return FileAsync.ReadAllBytes(path)

                    .ContinueWith(t => hasher.ComputeHash(t.Result))

                    .ContinueWith(t =>

                                      {

                                          //var hashBuilder = new StringBuilder();

                                          return (from byte b in t.Result.AsParallel()

                                                  select b.ToString("x2").ToLower()).Aggregate((s1, s2) => s1 + s2);                                         

                                      });

            }

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

            {

                stream.ReadAllBytes()

                    .ContinueWith(result => hasher.ComputeHash(result.Result))

                    .;

                var hashBytes = hasher.ComputeHash(stream);

                var hashBuilder = new StringBuilder();

                foreach (byte b in hasher.ComputeHash(stream))

                    hashBuilder.Append(b.ToString("x2").ToLower());

                hash = hashBuilder.ToString();

            }

            return hash;#1#

        }

*/

        private PithosStatus _pithosStatus=PithosStatus.InSynch;       

        public void SetPithosStatus(PithosStatus status)

        {

            _pithosStatus = status;

        }

        public PithosStatus GetPithosStatus()

        {

            return _pithosStatus;

        }

        ConcurrentDictionary<string,NetworkState> _networkState=new ConcurrentDictionary<string, NetworkState>();

        public void SetNetworkState(string path,NetworkState state)

        {

            _networkState[path.ToLower()] = state;

            //Removing may fail so we store the "None" value anyway

            if (state == NetworkState.None)

            {

                NetworkState oldState;

                _networkState.TryRemove(path, out oldState);

            }

        }

        public NetworkState GetNetworkState(string path)

        {

            NetworkState state ;

            if (_networkState.TryGetValue(path, out state))

                return state;

            return NetworkState.None;

        }

        public T GetStatus<T>(string path,Func<FileState,T> getter,T defaultValue )

        {

            try

            {

                var state = FileState.TryFind(path.ToLower());

                return state == null ? defaultValue : getter(state);

            }

            catch (Exception exc)

            {

                Trace.TraceError(exc.ToString());

                return defaultValue;

            }

        }

        /// <summary>

        /// Sets the status of a file, creating a new FileState entry if one doesn't already exist.

        /// </summary>

        /// <param name="path"></param>

        /// <param name="setter"></param>

        public void SetStatus(string path,Action<FileState> setter)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path", "path can't be empty");

            if (setter==null)

                throw new ArgumentNullException("setter", "setter can't be empty");

            _statusUpdateQueue.Add(() =>

            {

                var filePath = path.ToLower();

                var state = FileState.TryFind(filePath);

                if (state != null)

                {

                    setter(state);

                    state.Update();

                }

                else

                {

                    state = new FileState {FilePath = filePath};

                    setter(state);

                    state.Save();

                }

            });

        }

        /// <summary>

        /// Sets the status of a file only if the file already exists

        /// </summary>

        /// <param name="path"></param>

        /// <param name="setter"></param>

        private void UpdateStatus(string path, Action<FileState> setter)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path", "path can't be empty");

            if (setter == null)

                throw new ArgumentNullException("setter", "setter can't be empty");

            _statusUpdateQueue.Add(() =>

            {

                var filePath = path.ToLower();

                var state = FileState.TryFind(filePath);

                if (state == null)

                {

                    Trace.TraceWarning("[NOFILE] Unable to set status for {0}.", filePath);

                    return;

                }

                setter(state);

                state.Save();

            });

        }

        public FileOverlayStatus GetFileOverlayStatus(string path)

        {

            try

            {

                var state = FileState.TryFind(path.ToLower());

                return state == null ? FileOverlayStatus.Unversioned : state.OverlayStatus;

            }

            catch (Exception exc)

            {

                Trace.TraceError(exc.ToString());

                return FileOverlayStatus.Unversioned;

            }

        }

        public void SetFileOverlayStatus(string path, FileOverlayStatus overlayStatus)

        {

            SetStatus(path,s=>s.OverlayStatus=overlayStatus);

        }

        public void RemoveFileOverlayStatus(string path)

        {

            _statusUpdateQueue.Add(() =>

                InnerRemoveFileOverlayStatus(path));

        }

        private static void InnerRemoveFileOverlayStatus(string path)

        {

            FileState.DeleteAll(new[] {path});

        }

        public void RenameFileOverlayStatus(string oldPath, string newPath)

        {

            _statusUpdateQueue.Add(() =>

                InnerRenameFileOverlayStatus(oldPath, newPath));

        }

        private static void InnerRenameFileOverlayStatus(string oldPath, string newPath)

        {

            var state = FileState.TryFind(oldPath);

            if (state == null)

            {

                Trace.TraceWarning("[NOFILE] Unable to set status for {0}.", oldPath);

                return;

            }

            //NOTE: This will cause problems if path is used as a key in relationships

            state.FilePath = newPath;

            state.Update();

        }

        public void SetFileState(string path, FileStatus fileStatus, FileOverlayStatus overlayStatus)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path", "path can't be empty");

            UpdateStatus(path,state=>

                                  {

                                      state.FileStatus = fileStatus;

                                      state.OverlayStatus = overlayStatus;

                                  });            

        }

        public void StoreInfo(string path,ObjectInfo objectInfo)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path", "path can't be empty");

            if (objectInfo==null)

                throw new ArgumentNullException("objectInfo", "objectInfo can't be empty");

            var state = FileState.TryFind(path)??new FileState();

            state.FilePath = path.ToLower();

            state.Checksum = objectInfo.Hash;

            state.FileStatus = FileStatus.Unchanged;

            state.OverlayStatus = FileOverlayStatus.Normal;

            foreach (var tag in objectInfo.Tags)

            {

                state.Tags.Add(new FileTag

                                   {

                                       FilePath=state.FilePath,

                                       FileState=state,

                                       Value=tag.Value

                                   });

            }

            state.Save();

        }

        public void SetFileStatus(string path, FileStatus status)

        {            

            UpdateStatus(path, state=>state.FileStatus = status);

        }

       /* private static void InnerSetFileStatus(string path, FileStatus status)

        {

            var filePath = path.ToLower();

            var state = FileState.TryFind(filePath);

            if (state == null)

            {

                Trace.TraceWarning("[NOFILE] Unable to set status for {0}.", filePath);

                return;

            }

            state.FileStatus = status;

            state.Update();

        }*/

        public FileStatus GetFileStatus(string path)

        {

            var state = FileState.TryFind(path.ToLower());

            return (state==null)?FileStatus.Missing:state.FileStatus ;

        }

        public void ClearFileStatus(string path)

        {

            //TODO:SHOULDN'T need both clear file status and remove overlay status

            _statusUpdateQueue.Add(()=>

                FileState.DeleteAll(new[] { path.ToLower() }));   

        }

        public void UpdateFileChecksum(string path, string checksum)

        {

            var state = FileState.TryFind(path);

            if (state == null)

            {

                Trace.TraceWarning("[NOFILE] Unable to set checkesum for {0}.",path);

                return;

            }

            state.Checksum = checksum;

            state.Update();

        }

    }

    public enum NetworkState

    {

        None,

        Uploading,

        Downloading

    }

}