Synnefo » Pithos MS Client

using System;

using System.Collections.Generic;

using System.ComponentModel.Composition;

using System.Diagnostics;

using System.Diagnostics.Contracts;

using System.IO;

using System.Linq;

using System.Text;

using Pithos.Interfaces;

namespace Pithos.Core.Agents

{

    [Export]

    public class WorkflowAgent

    {

        Agent<WorkflowState> _agent;

        public IStatusNotification StatusNotification { get; set; }

        [Import]

        public IStatusKeeper StatusKeeper { get; set; }

        //We should avoid processing files stored in the Fragments folder

        //The Full path to the fragments folder is stored in FragmentsPath

        public string FragmentsPath { get; set; }

        [Import]

        public NetworkAgent NetworkAgent { get; set; }

        public void Start()

        {

            _agent = Agent<WorkflowState>.Start(inbox =>

            {

                Action loop = null;

                loop = () =>

                {

                    var message = inbox.Receive();

                    var process = message.ContinueWith(t =>

                    {

                        var state = t.Result;

                        Process(state);

                        inbox.DoAsync(loop);

                    });

                    process.ContinueWith(t =>

                    {

                        inbox.DoAsync(loop);

                        if (t.IsFaulted)

                        {

                            var ex = t.Exception.InnerException;

                            if (ex is OperationCanceledException)

                                inbox.Stop();

                            Trace.TraceError("[ERROR] Synch for {0}:\r{1}", message.Result.FileName, ex);

                        }

                    });

                };

                loop();

            });

        }

        public void RestartInterruptedFiles()

        {

            StatusNotification.NotifyChange("Restart processing interrupted files", TraceLevel.Verbose);

            var interruptedStates = new[] { FileOverlayStatus.Unversioned, FileOverlayStatus.Modified };

            var pendingEntries = (from state in FileState.Queryable

                                 where interruptedStates.Contains(state.OverlayStatus) &&

                                       !state.FilePath.StartsWith(FragmentsPath) &&

                                       !state.FilePath.EndsWith(".ignore")

                                 select state).ToList();

            var staleEntries = from state in pendingEntries

                                  where !File.Exists(state.FilePath)

                                  select state;

            var staleKeys = staleEntries.Select(state=>state.Id);

            FileState.DeleteAll(staleKeys);

            var validEntries = from state in pendingEntries.Except(staleEntries)

                             where File.Exists(state.FilePath)

                             select new WorkflowState

                             {

                                 Path = state.FilePath.ToLower(),

                                 FileName = Path.GetFileName(state.FilePath).ToLower(),

                                 Hash = state.Checksum,

                                 Status = state.OverlayStatus == FileOverlayStatus.Unversioned ?

                                                   FileStatus.Created :

                                                   FileStatus.Modified,

                                 TriggeringChange = state.OverlayStatus == FileOverlayStatus.Unversioned ?

                                                   WatcherChangeTypes.Created :

                                                   WatcherChangeTypes.Changed

                             };

            foreach (var entry in validEntries)

            {

                Post(entry);

            }            

        }       

        private void Process(WorkflowState state)

        {

            if (state.Skip)

                return;

            string path = state.Path.ToLower();

            string fileName = Path.GetFileName(path);

            //Bypass deleted files, unless the status is Deleted

            if (!(File.Exists(path) || state.Status != FileStatus.Deleted))

            {

                state.Skip = true;

                this.StatusKeeper.RemoveFileOverlayStatus(path);

                return;

            }

            var fileState = FileState.FindByFilePath(path);

            switch (state.Status)

            {

                case FileStatus.Created:

                case FileStatus.Modified:

                    var info = new FileInfo(path);

                    NetworkAgent.Post(new CloudAction(CloudActionType.UploadUnconditional, info, ObjectInfo.Empty,fileState));

                    break;

                case FileStatus.Deleted:

                    NetworkAgent.Post(new CloudAction(CloudActionType.DeleteCloud, null, new ObjectInfo {Name=fileName},fileState));                    

                    break;

                case FileStatus.Renamed:

                    NetworkAgent.Post(new CloudAction(CloudActionType.RenameCloud, state.OldFileName,state.OldPath,state.FileName,state.Path));                    

                    break;

            }

            return;

        }

        public void Post(WorkflowState workflowState)

        {

            _agent.Post(workflowState);

        }

    }

}