Synnefo » Pithos MS Client

// -----------------------------------------------------------------------

// <copyright file="NetworkAgent.cs" company="GRNET">

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

// -----------------------------------------------------------------------

using System;

    //TODO: Ensure all network operations use exact casing. Pithos is case sensitive

        //A separate agent is used to execute delete actions immediatelly;

        private Agent<CloudDeleteAction> _deleteAgent;

            });

            _deleteAgent = Agent<CloudDeleteAction>.Start(inbox =>

            {

                Action loop = null;

                loop = () =>

                            {

                                var message = inbox.Receive();

                                var process = message.Then(ProcessDelete,inbox.CancellationToken);

                                inbox.LoopAsync(process, loop);

                            };

                loop();

            });

                            //Redirect deletes to the delete agent 

                            _deleteAgent.Post((CloudDeleteAction)action);

        /// <summary>

        /// Processes cloud delete actions

        /// </summary>

        /// <param name="action">The delete action to execute</param>

        /// <returns></returns>

        /// <remarks>

        /// When a file/folder is deleted locally, we must delete it ASAP from the server and block any download

        /// operations that may be in progress.

        /// <para>

        /// A separate agent is used to process deletes because the main agent may be busy with a long operation.

        /// </para>

        /// </remarks>

        private async Task ProcessDelete(CloudDeleteAction action)

        {

            if (action == null)

                throw new ArgumentNullException("action");

            if (action.AccountInfo==null)

                throw new ArgumentException("The action.AccountInfo is empty","action");

            Contract.EndContractBlock();

            var accountInfo = action.AccountInfo;

            using (log4net.ThreadContext.Stacks["NETWORK"].Push("PROCESS"))

            {                

                Log.InfoFormat("[ACTION] Start Processing {0}", action);

                var cloudFile = action.CloudFile;

                try

                {

                    //Acquire a lock on the deleted file to prevent uploading/downloading operations from the normal

                    //agent

                    using (var gate = NetworkGate.Acquire(action.LocalFile.FullName, NetworkOperation.Deleting))

                    {

                        // Remove any related actions from the normal agent

                        _agent.Remove(queuedAction =>

                                      queuedAction.CloudFile.Container == action.CloudFile.Container &&

                                      queuedAction.CloudFile.Name == action.CloudFile.Name);

                        // and then delete the file from the server

                        DeleteCloudFile(accountInfo, cloudFile);

                        Log.InfoFormat("[ACTION] End Delete {0}:{1}->{2}", action.Action, action.LocalFile,

                                       action.CloudFile.Name);

                    }

                }

                catch (WebException exc)

                {

                    Log.ErrorFormat("[WEB ERROR] {0} : {1} -> {2} due to exception\r\n{3}", action.Action, action.LocalFile, action.CloudFile, exc);

                }

                catch (OperationCanceledException)

                {

                    throw;

                }

                catch (DirectoryNotFoundException)

                {

                    Log.ErrorFormat("{0} : {1} -> {2}  failed because the directory was not found.\n Rescheduling a delete",

                        action.Action, action.LocalFile, action.CloudFile);

                    //Repost a delete action for the missing file

                    _deleteAgent.Post(action);                    

                }

                catch (FileNotFoundException)

                {

                    Log.ErrorFormat("{0} : {1} -> {2}  failed because the file was not found.\n Rescheduling a delete",

                        action.Action, action.LocalFile, action.CloudFile);

                    //Post a delete action for the missing file

                    _deleteAgent.Post(action);

                }

                catch (Exception exc)

                {

                    Log.ErrorFormat("[REQUEUE] {0} : {1} -> {2} due to exception\r\n{3}",

                                     action.Action, action.LocalFile, action.CloudFile, exc);

                    _deleteAgent.Post(action);

                }                

            }

        }

            var downloadPath=action.LocalFile.GetProperCapitalization();

            if (cloudAction is CloudDeleteAction)

                _deleteAgent.Post((CloudDeleteAction)cloudAction);

            else

                _agent.Post(cloudAction);

                    var localFile = fileAgent.GetFileSystemInfo(relativePath);

            var newFilePath = action.LocalFile.FullName;

            //How do we handle concurrent renames and deletes/uploads/downloads?

            //* A conflicting upload means that a file was renamed before it had a chance to finish uploading

            //  This should never happen as the network agent executes only one action at a time

            //* A conflicting download means that the file was modified on the cloud. While we can go on and complete

            //  the rename, there may be a problem if the file is downloaded in blocks, as subsequent block requests for the 

            //  same name will fail.

            //  This should never happen as the network agent executes only one action at a time.

            //* A conflicting delete can happen if the rename was followed by a delete action that didn't have the chance

            //  to remove the rename from the queue.

            //  We can probably ignore this case. It will result in an error which should be ignored            

            //TODO: What code is returned when the source file doesn't exist?

                var info = fileAgent.GetFileSystemInfo(fileName);                

        private async Task DownloadCloudFile(AccountInfo accountInfo, ObjectInfo cloudFile , string filePath)

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            if (!Path.IsPathRooted(filePath))

                throw new ArgumentException("The filePath must be rooted", "filePath");

            var localPath = Interfaces.FileInfoExtensions.GetProperFilePathCapitalization(filePath);

        private async Task DownloadEntireFileAsync(AccountInfo accountInfo, CloudFilesClient client, ObjectInfo cloudFile, Uri relativeUrl, string filePath,TreeHash serverHash)

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            if (!Path.IsPathRooted(filePath))

                throw new ArgumentException("The localPath must be rooted", "filePath");

            var localPath = Pithos.Interfaces.FileInfoExtensions.GetProperFilePathCapitalization(filePath);

            await client.GetObject(cloudFile.Account, cloudFile.Container, relativeUrl.ToString(), tempPath);

            //Create the local folder if it doesn't exist (necessary for shared objects)

            var localFolder = Path.GetDirectoryName(localPath);

            if (!Directory.Exists(localFolder))

                Directory.CreateDirectory(localFolder);            

            //And move it to its actual location once downloading is finished

            if (File.Exists(localPath))

                File.Replace(tempPath,localPath,null,true);

            else

                File.Move(tempPath,localPath);

            //Notify listeners that a local file has changed

            StatusNotification.NotifyChangedFile(localPath);

        public async Task DownloadWithBlocks(AccountInfo accountInfo, CloudFilesClient client, ObjectInfo cloudFile, Uri relativeUrl, string filePath, TreeHash serverHash)

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            if (!Path.IsPathRooted(filePath))

                throw new ArgumentException("The filePath must be rooted", "filePath");

            var localPath = Interfaces.FileInfoExtensions.GetProperFilePathCapitalization(filePath);

                var fullFileName = fileInfo.GetProperCapitalization();

                    //TODO: Check how a directory hash is calculated -> All dirs seem to have the same hash

                            client.PutObject(account, cloudFile.Container, cloudFile.Name, fullFileName, String.Empty, "application/directory");

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

            var fullFileName = fileInfo.GetProperCapitalization();