Synnefo » Pithos MS Client

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Diagnostics.Contracts;

using System.Linq;

using System.Text;

using Pithos.Interfaces;

namespace Pithos.Core.Test

{

    public class MockStatusChecker : IStatusChecker, IStatusKeeper

    {

        public IPithosSettings Settings { get; set; }

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

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

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

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

        public FileOverlayStatus GetFileOverlayStatus(string path)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(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 IEnumerable<string> StoreUnversionedFiles(ParallelQuery<string> paths)

        {

            var newFiles = (from file in paths

                            where !_overlayCache.ContainsKey(file)

                            select new

                            {

                                FilePath = file,

                                OverlayStatus = FileOverlayStatus.Unversioned,

                                FileStatus = FileStatus.Created,

                                Checksum = Signature.CalculateHash(file)

                            });

            var files = new ConcurrentBag<string>();

            newFiles.ForAll(state =>

            {

                _overlayCache[state.FilePath] = state.OverlayStatus;

                _statusCache[state.FilePath] = state.FileStatus;

                _checksums[state.FilePath] = state.Checksum;

                files.Add(state.FilePath);

            });

            return files.ToList();

        }

        public void Stop()

        {

            throw new NotImplementedException();

        }

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

        {

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

        }

        private PithosStatus _pithosStatus = PithosStatus.InSynch;

        public void SetPithosStatus(PithosStatus status)

        {

            _pithosStatus = status;

        }

        public PithosStatus GetPithosStatus()

        {

            return _pithosStatus;

        }

        public void SetFileOverlayStatus(string path, FileOverlayStatus overlayStatus)

        {

            _overlayCache[path] = overlayStatus;

        }

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

        }

    }

}