Synnefo » Pithos MS Client

#region

/* -----------------------------------------------------------------------

 * <copyright file="TreeHash.cs" company="GRNet">

 * 

 * Copyright 2011-2012 GRNET S.A. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or

 * without modification, are permitted provided that the following

 * conditions are met:

 *

 *   1. Redistributions of source code must retain the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer.

 *

 *   2. Redistributions in binary form must reproduce the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer in the documentation and/or other materials

 *      provided with the distribution.

 *

 *

 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 *

 * The views and conclusions contained in the software and

 * documentation are those of the authors and should not be

 * interpreted as representing official policies, either expressed

 * or implied, of GRNET S.A.

 * </copyright>

 * -----------------------------------------------------------------------

 */

#endregion

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

    {

        public const string DEFAULT_HASH_ALGORITHM = "sha256";

        public const long DEFAULT_BLOCK_SIZE = 4*1024*1024;

        public string BlockHash { get; set; }

        public long BlockSize { get; set; }

        private long _bytes;

        public long Bytes

        {

            get

            {

                Contract.Ensures(Contract.Result<long>() >= 0);

                return _bytes;

            }

            set

            {

                Contract.Requires<ArgumentOutOfRangeException>(value>=0,"Bytes");

                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=new List<byte[]>();

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

        //Retruns the hashes as a dictionary to the block location. Used to locate blocks

        public IDictionary<string,long> HashDictionary

        {

            get

            {

                Func<ConcurrentDictionary<string, long>> blocksInit = () =>

                {

                    var blocks =

                        new ConcurrentDictionary<string, long>();

                    if (Hashes == null)

                        return blocks;

                    var blockIndex = 0;

                    foreach (var hash in this.Hashes)

                    {

                        blocks[hash.ToHashString()] = blockIndex++;

                    }

                    return blocks;

                };

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

            }

        }

        //private string _md5=Signature.MD5_EMPTY;

        //public string MD5

        //{

        //    get { return _md5; }

        //    set { _md5 = value; }

        //}

        //Saves the Json representation to a file

        public async Task Save(string filePath)

        {

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            var fileName = FileId.ToString("N");

            var path = Path.Combine(filePath, fileName);

            if (!Directory.Exists(filePath))

                Directory.CreateDirectory(filePath);

            var json = await TaskEx.Run(() => ToJson()).ConfigureAwait(false);

            await FileAsync.WriteAllText(path, json).ConfigureAwait(false);

        }

        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).ConfigureAwait(false);

            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;

        }

    }

}