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

        }

        public void SetFileOverlayStatus(string path, FileOverlayStatus overlayStatus)

        {

            _statusUpdateQueue.Add(() => 

                InnerSetOverlayStatus(path, overlayStatus));

        }

        private static void InnerSetOverlayStatus(string path, FileOverlayStatus overlayStatus)

        {

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

            if (state != null)

            {

                state.OverlayStatus = overlayStatus;

                state.Update();

            }

            else

            {

                state = new FileState

                            {FilePath = path, 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.Find(oldPath);

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

            state.FilePath = newPath;

            state.Update();

        }

        public void SetFileStatus(string path, FileStatus status)

        {

            _statusUpdateQueue.Add(() =>

                InnerSetFileStatus(path, status));

        }

        private static void InnerSetFileStatus(string path, FileStatus status)

        {

            var state = FileState.Find(path);

            state.FileStatus = status;

        }

        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

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

        }

        public void UpdateFileChecksum(string path, string checksum)

        {

            var state = FileState.Find(path);

            state.Checksum = checksum;

            state.Update();

        }

    }

}