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

using System.Security.Cryptography;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using Castle.ActiveRecord;

using Castle.ActiveRecord.Framework;

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 BlockingCollection<Action> _statusUpdateQueue = new BlockingCollection<Action>();

        //private readonly CancellationToken _cancel=new CancellationToken();

        public StatusKeeper()

        {

            var source = new XmlConfigurationSource("DbConfig.xml");

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

            if (!File.Exists("pithos.db"))

                ActiveRecordStarter.CreateSchema();

            Task.Factory.StartNew(ProcessUpdates);

        }

        public void ProcessUpdates()

        {            

            foreach (var action in _statusUpdateQueue.GetConsumingEnumerable())

            {

                action();

            }

        }

        public void Stop()

        {

            _statusUpdateQueue.CompleteAdding();

        }

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

        }

       /* private static void InnerSetOverlayStatus(string path, FileOverlayStatus overlayStatus)

        {

            var filePath = path.ToLower();

            var state = FileState.TryFind(filePath);

            if (state != null)

            {

                state.OverlayStatus = overlayStatus;

                state.Update();

            }

            else

            {

                state = new FileState

                            {FilePath = filePath, OverlayStatus = overlayStatus};

                state.Save();

            }

        }*/

        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;            

            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

    }

}