Synnefo » Pithos MS Client

using System;

using System.Collections;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Threading.Tasks;

using System.Linq;

using Pithos.Core;

    /*public static FileHashMap CalculateHashMap(string path, int blockSize)

    {

        CalculateBlockHashes(path, blockSize)

            .ContinueWith(blockTask =>

                              {

                                  var hashes = blockTask.Result;

                                  var hashMapHash = CalculateHashmapHash(hashes);

                                  return new FileHashMap {Hash = hashMapHash, Hashes = hashes};

                              });

    }*/

    public static Task<IList<FileHash>> CalculateBlockHashesAsync(string path, int blockSize)

    {

        var hashMap = new ConcurrentQueue<FileHash>();

        var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 4096, true);

            return stream.ReadBuffersAsync(blockSize, (buffer, read) =>

            {

                using (var hasher = SHA256.Create())

                {

                    var hash = hasher.ComputeHash(buffer, 0, read);

                    hashMap.Enqueue(new FileHash{FilePath=path,Value=hash});

                }

            }).ContinueWith(t=>

                                {

                                    stream.Close();

                                    return (IList<FileHash>)hashMap.ToList();

                                });                

    }

    //I'd rather return an enumerable of hash calculation tasks, each of which can

    //be use to further store the hashes to storage without first creating the list of hashes

    /* //Or I could pass an action object, just like ReadBuffers does

     Task.Factory.Iterate(HashMapIterator(stream, blockSize,hashMap.Enqueue))

         .ContinueWith(t=>

                           {

                               SHA256.Create();

                           });*/

    public static byte[] CalculateHashmapHash(IList<FileHash> hashMap )

    {

        using (var stream = new MemoryStream())

        using(var hasher=SHA256.Create())

        {

            foreach (var hash in hashMap)

            {

                stream.Write(hash.Value, 0, hash.Value.Length);

            }

            return hasher.ComputeHash(stream);

        }

    }

    public static IEnumerable<byte[]> HashMapLinq(string path, int blockSize)

    {

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

        {

            var query = from block in stream.GetIterator(blockSize).AsParallel().AsOrdered()

                        select block;  

            return query;

        }

    }

    public class Block

    {

        public int Offset { get; set; }

        public byte[] Data { get; set; }

    }

    public static IEnumerable<byte[]> GetIterator(this Stream stream,int blockSize)

    {        

        var buffer = new byte[blockSize];

        while(true)

        {            

            stream.Read(buffer, 0, buffer.Length);            

            yield return buffer;

        }

    }

    private static IEnumerable<Task> HashMapIterator(Stream input, int bufferSize,Action<byte[]> hashAvailable )

    {

        // Create a buffer that will be used over and over

        var buffer = new byte[bufferSize];

        using (var hasher = SHA256.Create())

        {

            // Until there's no more data

            while (true)

            {

                // Asynchronously read a buffer and yield until the operation completes

                var readTask = input.ReadAsync(buffer, 0, buffer.Length);

                yield return readTask;

                // If there's no more data in the stream, we're done.

                if (readTask.Result <= 0) break;

                // Otherwise, hand the data off to the delegate

                var hashTask = Task.Factory.StartNew(() => hasher.ComputeHash(buffer, 0, readTask.Result));

                yield return hashTask;

                hashAvailable(hashTask.Result);

            }

        }

    }