Synnefo » Pithos MS Client

#region

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

 * <copyright file="BlockExtensions.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.Generic;

using System.Diagnostics;

using System.Diagnostics.Contracts;

using System.Linq;

using System.Reflection;

using System.Text;

using System.IO;

using System.Text.RegularExpressions;

using System.Threading;

using System.Threading.Tasks;

using Pithos.Network;

using log4net;

using OpenSSL.Core;

using OpenSSL.Crypto;

namespace Pithos.Core.Agents

{

    static class BlockExtensions

    {

        private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

        public static int Read(this FileInfo fileInfo,byte[] buffer,long offset,int count)

        {

            if (offset < 0)

                throw new ArgumentOutOfRangeException("offset", offset, "The file offset can't be negative");

            Contract.EndContractBlock();

            //Open the stream only long enough to read a block

            using (var stream = fileInfo.OpenRead())

            {

                stream.Seek(offset, SeekOrigin.Begin);

                return  stream.Read(buffer, 0, count);                

            }

        }

       public static string CalculateHash(this FileSystemInfo info,int blockSize,string algorithm,CancellationToken token,IProgress<double> progress )

        {

            if (info==null)

                throw new ArgumentNullException("info");

            if (String.IsNullOrWhiteSpace(info.FullName))

                throw new ArgumentException("info");

            if (blockSize<=0)

                throw new ArgumentOutOfRangeException("blockSize",blockSize,"blockSize must be greater than 0");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

           info.Refresh();

           if (info.FullName.Split('/').Contains(".pithos.cache"))

               throw new ArgumentException(String.Format("Trying to hash file from the cache folder: [{0}]", info.FullName));

           //The hash for directories is an empty string

           if (info is DirectoryInfo)

                return String.Empty;

           //The hash for non-existent files is an empty string

           if (!info.Exists)

               return String.Empty;

           return Signature.CalculateTreeHash(info.FullName, blockSize, algorithm,token,progress).TopHash.ToHashString();

        }

       /// <summary>

       ///Calculates a simple hash for an entire file

       /// </summary>

       /// <param name="info">The file to hash</param>

       /// <param name="hasher">The hash algorithm to use</param>

       /// <returns>A hash value for the entire file. An empty string if the file does not exist.</returns>

       //public static string ComputeShortHash(this FileInfo info, MessageDigestContext hasher,IStatusNotification notification)

       //{

       //    if(info == null)

       //        throw new ArgumentNullException("info");

       //    if(hasher== null)

       //        throw new ArgumentNullException("hasher");

       //    Contract.EndContractBlock();

       //    info.Refresh();

       //    if (!info.Exists)

       //        return String.Empty;

       //    if (info.FullName.Split('/').Contains(".pithos.cache"))

       //        throw new ArgumentException(String.Format("Trying to hash file from the cache folder: [{0}]", info.FullName));

       //    if (Log.IsDebugEnabled)

       //         Log.DebugFormat("Short Hashing [{0}] ",info.FullName);

       //    if (info.Length==0)

       //        return Signature.MD5_EMPTY;

       //    var progress = new StatusNotification("");

       //    using (var stream = new FileStream(info.FullName,FileMode.Open, FileAccess.Read, FileShare.Read,Signature.BufferSize))

       //    {

       //        var buffer = new byte[65536];

       //        int counter=0;

       //        int bytesRead;

       //        do

       //        {

       //            bytesRead = stream.Read(buffer, 0, 32768);

       //            if (bytesRead > 0)

       //            {

       //                if (bytesRead == buffer.Length)

       //                {

       //                    hasher.Update(buffer);

       //                }

       //                else

       //                {

       //                    var block = new byte[bytesRead];

       //                    Buffer.BlockCopy(buffer, 0, block, 0, bytesRead);

       //                    hasher.Update(block);

       //                }

       //            }

       //            counter++;

       //            if (counter % 100 == 0)

       //            {

       //                progress.Title = String.Format("Hashing {0:p} of {1}", stream.Position*1.0/stream.Length,

       //                                               info.Name);

       //                notification.Notify(progress);

       //            }

       //        } while (bytesRead > 0);               

       //        var hash = hasher.DigestFinal();

       //        progress.Title = String.Format("Hashed {0} ", info.Name);

       //        notification.Notify(progress);

       //        var hashString = hash.ToHashString();

       //        return hashString;

       //    }

       //}

/*

        public static async Task<string> ComputeShortHash(this FileInfo info, MD5BlockCalculator calculator,IStatusNotification notification)

       {

           if(info == null)

               throw new ArgumentNullException("info");

           if(calculator== null)

               throw new ArgumentNullException("calculator");

           Contract.EndContractBlock();

           info.Refresh();

           if (!info.Exists)

               return String.Empty;

           if (info.FullName.Split('/').Contains(".pithos.cache"))

               throw new ArgumentException(String.Format("Trying to hash file from the cache folder: [{0}]", info.FullName));

           if (Log.IsDebugEnabled)

                Log.DebugFormat("Short Hashing [{0}] ",info.FullName);

           if (info.Length == 0)

               return Signature.MD5_EMPTY;

           var progress = new StatusNotification("");

           using (var stream = new FileStream(info.FullName,FileMode.Open, FileAccess.Read, FileShare.Read,Signature.BufferSize))

           {

               int counter=0;

               int bytesRead;

               do

               {

                   var buffer = new byte[65536];

                   bytesRead = stream.Read(buffer, 0, 32768);

                   if (bytesRead > 0)

                   {

                       calculator.PostBlock(counter,buffer,bytesRead);

                   }

                   counter++;

                   if (counter % 100 == 0)

                   {

                       progress.Title = String.Format("Hashing {0:p} of {1}", stream.Position*1.0/stream.Length,

                                                      info.Name);

                       notification.Notify(progress);

                   }

               } while (bytesRead > 0);

               var hashString = await calculator.GetHash();

               progress.Title = String.Format("Hashed {0} ", info.Name);

               notification.Notify(progress);

               return hashString;

           }

       }

*/

       // public static string ComputeShortHash(this FileInfo info,IStatusNotification notification)

       //{

       //    if(info == null)

       //        throw new ArgumentNullException("info");

       //     Contract.EndContractBlock();

       //     if (info.FullName.Split('/').Contains(".pithos.cache"))

       //         throw new ArgumentException(String.Format("Trying to hash file from the cache folder: [{0}]", info.FullName));

       //    using (var hasher=new MessageDigestContext(MessageDigest.CreateByName("md5")))

       //    {               

       //        //hasher.Init();

       //        //return ComputeShortHash(info,hasher,notification);

       //        return null;

       //    }

       //}

    }

}