Synnefo » Pithos MS Client

        public static string CalculateMD5(FileInfo info)

        {

            if (info==null)

                throw new ArgumentNullException("info");

            Contract.EndContractBlock();

            return CalculateMD5(info.FullName);

        }

        public static TreeHash CalculateTreeHash(FileInfo fileInfo, int blockSize, string algorithm)

        {

            if (fileInfo==null)

                throw new ArgumentNullException("fileInfo");

            if (blockSize <= 0)

                throw new ArgumentOutOfRangeException("blockSize", "blockSize must be a value greater than zero ");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

            return CalculateTreeHash(fileInfo.FullName, blockSize, algorithm);

        }

                var buffer = new byte[blockSize];

                while ((read=stream.Read(buffer, 0, blockSize)) > 0)

                    //This code was added for compatibility with the way Pithos calculates the last hash

                    //We calculate the hash only up to the last non-null byte

                    //TODO: Remove if the server starts using the full block instead of the trimmed block

                    var lastByteIndex=Array.FindLastIndex(buffer,read-1, aByte => aByte != 0);

                    var hash = hasher.ComputeHash(buffer, 0, lastByteIndex+1);

                    list.Add(hash);                    

        public static Task<TreeHash> CalculateTreeHashAsync(FileInfo fileInfo, int blockSize, string algorithm)

        {

            if (fileInfo == null)

                throw new ArgumentNullException("fileInfo");

            if (blockSize <= 0)

                throw new ArgumentOutOfRangeException("blockSize", "blockSize must be a value greater than zero ");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

            return CalculateTreeHashAsync(fileInfo.FullName, blockSize, algorithm);

        }

            //Calculate the hash of all blocks using a blockhash iterator

            var treeHash =Iterate<TreeHash>(BlockHashIterator(filePath, blockSize, algorithm));

            return treeHash;

        }

        private static IEnumerable<Task> BlockHashIterator(string filePath, int blockSize, string algorithm)

        {

            using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, blockSize, true))

            {

                //Calculate the blocks asyncrhonously

                var hashes= CalculateBlockHashesAsync(stream, blockSize, algorithm);

                yield return hashes;

                //And then proceed with creating and returning a TreeHash

                var length = stream.Length;                

                var list = hashes.Result.OrderBy(pair => pair.Key).Select(pair => pair.Value).ToList();

                var treeHash = new TreeHash(algorithm)

                {

                    Bytes = length, 

                    BlockSize = blockSize, 

                    Hashes = list

                };

                yield return Task.Factory.FromResult(treeHash);

            }

        }

        //The Task Iterator style allows the execution of a sequence of patterns using

        //iterator syntax.

        //This particular variation returns the result of the last task, if there is one

        public static Task<TResult> Iterate<TResult>(IEnumerable<Task> asyncIterator)

        {

            if (asyncIterator == null) 

                throw new ArgumentNullException("asyncIterator");

            var enumerator = asyncIterator.GetEnumerator();

            if (enumerator == null)

                throw new InvalidOperationException("Invalid enumerable - GetEnumerator returned null");

            var tcs = new TaskCompletionSource<TResult>();

            tcs.Task.ContinueWith(_ => enumerator.Dispose(), TaskContinuationOptions.ExecuteSynchronously);

            Action<Task> recursiveBody = null;

            recursiveBody = delegate

            {

                try

                {

                    if (enumerator.MoveNext())

                        enumerator.Current.ContinueWith(recursiveBody,

                                                        TaskContinuationOptions.ExecuteSynchronously);

                    else

                    {

                        var lastTask = enumerator.Current as Task<TResult>;

                        var result = (lastTask !=null ) 

                            ? lastTask.Result

                            : default(TResult);

                        tcs.TrySetResult(result);

                    }

                }

                catch (Exception exc)

                {

                    tcs.TrySetException(exc);

                }

            };

            recursiveBody(null);

            return tcs.Task;

        /*  public static byte[] CalculateTopHash(IEnumerable<byte[]> hashMap, string algorithm)

        private static Task<ConcurrentDictionary<int, byte[]>> CalculateBlockHashesAsync(FileStream stream, int blockSize, string algorithm, ConcurrentDictionary<int, byte[]> hashes=null, int index = 0)

            if (hashes==null)

                hashes= new ConcurrentDictionary<int, byte[]>();

                if (read>0)

                    using (var hasher = HashAlgorithm.Create(algorithm))

                    {

                        //This code was added for compatibility with the way Pithos calculates the last hash

                        //We calculate the hash only up to the last non-null byte

                        //TODO: Remove if the server starts using the full block instead of the trimmed block

                        var lastByteIndex = Array.FindLastIndex(buffer, read - 1, aByte => aByte != 0);

                        var hash = hasher.ComputeHash(buffer, 0, lastByteIndex+1);

                        hashes[index]=hash;

                    }