Synnefo » Pithos MS Client

		    var uri = account.SiteUri.Replace("http://","https://");            

		    Process.Start(uri);

	    /// <summary>

                    //Do not upload files in conflict

                    if (action.FileState.FileStatus == FileStatus.Conflict )

                    {

                        Log.InfoFormat("Skipping file in conflict [{0}]",fileInfo.FullName);

                        return;

                    }

                    if (action.FileState.FileStatus == FileStatus.Forbidden)

                    {

                        Log.InfoFormat("Skipping forbidden file [{0}]",fileInfo.FullName);

                        return;

                    }

                        try

                        {

                            if (fileInfo is DirectoryInfo)

                            {

                                //If the directory doesn't exist the Hash property will be empty

                                if (String.IsNullOrWhiteSpace(info.Hash))

                                    //Go on and create the directory

                                    await

                                        client.PutObject(account, cloudFile.Container, cloudFile.Name, fullFileName,

                                                         String.Empty, "application/directory");

                            }

                            else

                            {

                                var cloudHash = info.Hash.ToLower();

                                var hash = action.LocalHash.Value;

                                var topHash = action.TopHash.Value;

                                //If the file hashes match, abort the upload

                                if (hash == cloudHash || topHash == cloudHash)

                                {

                                    //but store any metadata changes 

                                    StatusKeeper.StoreInfo(fullFileName, info);

                                    Log.InfoFormat("Skip upload of {0}, hashes match", fullFileName);

                                    return;

                                }

                                //Mark the file as modified while we upload it

                                StatusKeeper.SetFileOverlayStatus(fullFileName, FileOverlayStatus.Modified);

                                //And then upload it

                                //Upload even small files using the Hashmap. The server may already contain

                                //the relevant block

                                //First, calculate the tree hash

                                var treeHash = await Signature.CalculateTreeHashAsync(fullFileName, accountInfo.BlockSize,

                                                                                      accountInfo.BlockHash, 2);

                                //TODO: If the upload fails with a 403, abort it and mark conflict

                                await

                                    UploadWithHashMap(accountInfo, cloudFile, fileInfo as FileInfo, cloudFile.Name, treeHash);

                            }

                            //If everything succeeds, change the file and overlay status to normal

                            StatusKeeper.SetFileState(fullFileName, FileStatus.Unchanged, FileOverlayStatus.Normal);

                        }

                        catch (WebException exc)

                        {

                            var response=(exc.Response as HttpWebResponse);

                            if (response.StatusCode == HttpStatusCode.Forbidden)

                            {

                                StatusKeeper.SetFileState(fileInfo.FullName,FileStatus.Forbidden, FileOverlayStatus.Conflict);                                

                            }

        Unversioned,

        Forbidden

        private string _siteUri;

        public string SiteUri

        {

            get { return _siteUri; }

            set

            {

                _siteUri = value;

            }

        }

/*

            }

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

            {

                var block = new byte[read];

                Buffer.BlockCopy(buffer, 0, block, 0, read);

                await hashBlock.SendAsync(Tuple.Create(index, block));

                index += read;

            }

            hashBlock.Complete();

            await hashBlock.Completion;

            return hashes;

        } 

        public static async Task<ConcurrentDictionary<int, byte[]>> CalculateBlockHashesInPlace(FileStream stream, int blockSize, string algorithm, int parallelism)

        {

            if (stream == null)

                throw new ArgumentNullException("stream");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            if (blockSize <= 0)

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

            Contract.EndContractBlock();

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

            var path = stream.Name;

            var size = stream.Length;

            Log.DebugFormat("Hashing [{0}] size [{1}]",path,size);

            var buffer = new byte[blockSize];

            var index = 0;

                int read;

            }

            return hashes;

        }

*/

        public static async Task<ConcurrentDictionary<long, byte[]>> CalculateBlockHashesInPlacePFor(FileStream stream, int blockSize, string algorithm, int parallelism)

        {

            if (stream == null)

                throw new ArgumentNullException("stream");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            if (blockSize <= 0)

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

            Contract.EndContractBlock();

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

            var path = stream.Name;

            var size = stream.Length;

            Log.DebugFormat("Hashing [{0}] size [{1}]", path, size);

            var buffer = new byte[parallelism][];

            var hashers = new HashAlgorithm[parallelism];

            for (var i = 0; i < parallelism; i++)

            {

                buffer[i] = new byte[blockSize];

                hashers[i] = HashAlgorithm.Create(algorithm);

            try

            {

                var indices = new long[parallelism];

                var bufferCount = new int[parallelism];

                int read;

                int bufIdx = 0;

                long index = 0;

                while ((read = await stream.ReadAsync(buffer[bufIdx], 0, blockSize)) > 0)

                {

                    index += read;

                    indices[bufIdx] = index;

                    bufferCount[bufIdx] = read;

                    //If we have filled the last buffer or if we have read from the last block,

                    //we can calculate the clocks in parallel

                    if (bufIdx == parallelism - 1 || read < blockSize)

                    {

                        //var options = new ParallelOptions {MaxDegreeOfParallelism = parallelism};

                        Parallel.For(0, bufIdx + 1, idx =>

                        {

                            //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

                            var lastByteIndex = Array.FindLastIndex(buffer[idx],

                                                                    bufferCount[idx] - 1,

                                                                    aByte => aByte != 0);

                            var hasher = hashers[idx];

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

                            var filePosition = indices[idx];

                            /*

                                                        Trace.TraceInformation("Hashed [{0}] [{1}/{2}] [{3:p}]", path,

                                                                                filePosition, size,

                                                                                (double)filePosition / size);

                            */

                            hashes[filePosition] = hash;

                        });

                    }

                    bufIdx = (bufIdx + 1) % parallelism;

                }

            }

            finally

            {

                for (var i = 0; i < parallelism; i++)

                {

                    if (hashers[i] != null)

                        hashers[i].Dispose();

                }

            }

/*

*/

                var hashes = await BlockHashAlgorithms.CalculateBlockHashesInPlacePFor(stream, blockSize, algorithm, parallelism);