Synnefo » Pithos MS Client

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Diagnostics.Contracts;

using System.IO;

using System.Linq;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using Pithos.Interfaces;

using Pithos.Network;

namespace Pithos.Core.Test

{

    public class MockStatusChecker : IStatusChecker, IStatusKeeper

    {

        public IPithosSettings Settings { get; set; }

        private readonly string[] _states = { "Normal", "Modified", "Conflict", "Synch" };

        readonly ConcurrentDictionary<string, FileOverlayStatus> _overlayCache = new ConcurrentDictionary<string, FileOverlayStatus>();

        readonly ConcurrentDictionary<string, FileStatus> _statusCache = new ConcurrentDictionary<string, FileStatus>();

        readonly ConcurrentDictionary<string, string> _checksums = new ConcurrentDictionary<string, string>();

        public FileOverlayStatus GetFileOverlayStatus(string path)

        {

            if (!_overlayCache.ContainsKey(path))

                return FileOverlayStatus.Unversioned;

            var pithosPath = Settings.PithosPath;

            if (path.StartsWith(pithosPath, true, null))

            {

                var status = _overlayCache[path];

                return status;

            }

            return FileOverlayStatus.Unversioned;

        }

        public void ProcessExistingFiles(IEnumerable<FileInfo> paths)

        {

            var newFiles = (from file in paths

                            where !_overlayCache.ContainsKey(file.FullName)

                            select new

                            {

                                FilePath = file.FullName.ToLower(),

                                OverlayStatus = FileOverlayStatus.Unversioned,

                                FileStatus = FileStatus.Created,

                                Checksum = Signature.CalculateMD5(file)

                            });

            var files = new ConcurrentBag<string>();

            foreach (var state in newFiles)

            {            

                _overlayCache[state.FilePath] = state.OverlayStatus;

                _statusCache[state.FilePath] = state.FileStatus;

                _checksums[state.FilePath] = state.Checksum;

                files.Add(state.FilePath);

            }            

        }

        public void Stop()

        {

            throw new NotImplementedException();

        }

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

        {

            if (String.IsNullOrWhiteSpace(path))

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

            SetFileStatus(path, fileStatus);

            SetFileOverlayStatus(path, 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");

            _statusCache[path] = FileStatus.Unchanged;

            _overlayCache[path] = FileOverlayStatus.Normal;

            _checksums[path] = objectInfo.Hash;

        }

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

        {

            throw new NotImplementedException();

        }

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

        {

            throw new NotImplementedException();

        }

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

        public void SetNetworkState(string path, NetworkOperation operation)

        {

            _networkState[path.ToLower()] = operation;

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

            if (operation == NetworkOperation.None)

            {

                NetworkOperation oldOperation;

                _networkState.TryRemove(path, out oldOperation);

            }

        }

        public NetworkOperation GetNetworkState(string path)

        {

            NetworkOperation operation;

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

                return operation;

            return NetworkOperation.None;

        }

        public void StartProcessing(CancellationToken token)

        {

        }

        public string BlockHash { get; set; }

        public int BlockSize { get; set; }

        public void ChangeRoots(string oldPath, string newPath)

        {

            throw new NotImplementedException();

        }

        public FileState GetStateByFilePath(string path)

        {

            throw new NotImplementedException();

        }

        public void ClearFolderStatus(string path)

        {

            throw new NotImplementedException();

        }

        public IEnumerable<FileState> GetChildren(FileState fileState)

        {

            throw new NotImplementedException();

        }

        public void EnsureFileState(string path)

        {

            throw new NotImplementedException();

        }

        private PithosStatus _pithosStatus = PithosStatus.InSynch;

        public void SetPithosStatus(PithosStatus status)

        {

            _pithosStatus = status;

        }

        public PithosStatus GetPithosStatus()

        {

            return _pithosStatus;

        }

        public Task SetFileOverlayStatus(string path, FileOverlayStatus overlayStatus, string shortHash = null)

        {

            _overlayCache[path] = overlayStatus;

            return Task.Factory.StartNew(()=>{});

        }

        public void RemoveFileOverlayStatus(string path)

        {

            FileOverlayStatus value;

            _overlayCache.TryRemove(path, out value);

        }

        public void RenameFileOverlayStatus(string oldPath, string newPath)

        {

            var status = _overlayCache[oldPath];

            _overlayCache[newPath] = status;

            FileOverlayStatus value;

            _overlayCache.TryRemove(oldPath, out value);

        }

        public void UpdateFileChecksum(string path, string shortHash, string checksum)

        {

            _checksums[path] = checksum;

        }

        public void SetFileStatus(string path, FileStatus status)

        {

            _statusCache[path] = status;

        }

        public FileStatus GetFileStatus(string path)

        {

            if (!_statusCache.ContainsKey(path))

                return FileStatus.Missing;

            return _statusCache[path];

        }

        public void ClearFileStatus(string path)

        {

            FileStatus value;

            _statusCache.TryRemove(path,out value);

        }

        public void CleanupStaleStates(AccountInfo accountInfo, List<ObjectInfo> objectInfos)

        {

            //throw new NotImplementedException();

        }

        public void CleanupOrphanStates()

        {

            throw new NotImplementedException();

        }

    }

}