[pithos-ms-client] / trunk%2FPithos.Network%2FTreeHash.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.IO;
using System.Text;
using System.Threading.Tasks;

using System.Linq;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace Pithos.Network
{
    public class TreeHash
    {
        private const string DEFAULT_HASH_ALGORITHM = "sha256";
        private const int DEFAULT_BLOCK_SIZE = 4*1024*1024;
        public string BlockHash { get; set; }
        public int BlockSize { get; set; }
        
        private long _bytes;
        public long Bytes
        {
            get
            {
                Contract.Ensures(Contract.Result<long>() >= 0);
                return _bytes;
            }
            set
            {
                if (value<0)
                    throw new ArgumentOutOfRangeException("Bytes");
                Contract.Requires(value >= 0);
                Contract.EndContractBlock();
                
                _bytes = value;
            }
        }
        


        public Guid FileId { get; set; }

        private readonly Lazy<byte[]> _topHash;        
        public byte[] TopHash
        {
            get { return _topHash.Value; }
        }

        private IList<byte[]> _hashes;

        public IList<byte[]> Hashes
        {
            get { return _hashes; }
            set
            {
                _hashes = value;
                _topHash.Force();
            }
        }

        [ContractInvariantMethod]
        private void Invariants()
        {
            Contract.Invariant(_bytes>=0);
        }
        

       public TreeHash(string algorithm)
        {
            BlockHash = algorithm;            
            _topHash = new Lazy<byte[]>(() =>
            {
                //
                //Cast the hashes to an IList or create a new list out of the hashes
                var hashMap = (_hashes as IList<byte[]>)??_hashes.ToList();
                return Signature.CalculateTopHash(hashMap, BlockHash);
            });
        }

        //Returns a Json representation of the hashes, as required by Pithos
        public string ToJson()
        {
            var value = new JObject();
            //We avoid using JObject's dynamic features because they use exceptions to detect new properties.
            value["block_hash"] = BlockHash;
            //Create a string array for all the hashes           
            
            string[] hashes=null ;
            if (Hashes!=null)
                hashes= GetHashesAsStrings();
            value["hashes"]= new JArray(hashes);
            value["block_size"] = BlockSize;
            value["bytes"] = Bytes;
            
            var json = JsonConvert.SerializeObject(value, Formatting.None);
            return json;
        }

        private string[] _stringHashes;
        //Returns the hashes as an array of hash strings. Used for serialization to Json
        public string[] GetHashesAsStrings()
        {
            return _stringHashes 
                ?? (_stringHashes = Hashes.Select(hash => hash.ToHashString()).ToArray());
        }

        ConcurrentDictionary<string, int> _blocks;
        //Retruns the hashes as a dictionary to the block location. Used to locate blocks
        public IDictionary<string,int> HashDictionary
        {
            get
            {
                Func<ConcurrentDictionary<string, int>> blocksInit = () =>
                {
                    var blocks =
                        new ConcurrentDictionary<string, int>();
                    if (Hashes == null)
                        return blocks;

                    var blockIndex = 0;
                    foreach (var hash in this.Hashes)
                    {
                        blocks[hash.ToHashString()] = blockIndex++;
                    }
                    return blocks;
                };

                return _blocks ?? (_blocks = blocksInit());
            }
        }

        //Saves the Json representation to a file
        public async Task Save(string filePath)
        {
            if (String.IsNullOrWhiteSpace(filePath))
                throw new ArgumentNullException("filePath");
            Contract.EndContractBlock();

            var fileName = FileId.ToString("N");
            var path = Path.Combine(filePath, fileName);
            if (!Directory.Exists(filePath))
                Directory.CreateDirectory(filePath);
            
            var json=await TaskEx.Run(()=>ToJson());
            await FileAsync.WriteAllText(path, json);
        }

        public static async Task<TreeHash> LoadTreeHash(string dataPath,Guid fileId)
        {
            var fileName = fileId.ToString("N");
            var path = Path.Combine(dataPath, fileName);
            
            var json=await FileAsync.ReadAllText(path);
            var treeHash = Parse(json);
            treeHash.FileId = fileId;
            return treeHash;
        }

        public static TreeHash Empty = new TreeHash(DEFAULT_HASH_ALGORITHM)
        {
            BlockSize = DEFAULT_BLOCK_SIZE,
            Bytes = 0
        };

        //Parse a json string and return a TreeHash
        //Returns an empty TreeHash if the string is null or empty
        public static TreeHash Parse(string json)
        {
            if (String.IsNullOrWhiteSpace(json))
                return Empty;            

            var value = JsonConvert.DeserializeObject<JObject>(json);
            if (value==null)
                throw new ArgumentException("The json parameter doesn't contain any json data","json");
            Contract.Assume(value!=null);

            var blockHash = (string) value["block_hash"];
            var size = value.Value<int>("block_size");
            var bytes = value.Value<long>("bytes");
            var hashes = value.Value<JArray>("hashes");
            var hashValues = from JToken token in hashes
                             select token.Value<string>().ToBytes();

            var treeHash = new TreeHash(blockHash)
                               {
                                   BlockSize = size,
                                   Hashes = hashValues.ToList(),
                                   Bytes = bytes
                               };
            return treeHash;
        }
    }
}