fileoperation.hxx

Go to the documentation of this file.

#pragma once
#ifndef _QICORE_FILEOPERATION_HPP_
#define _QICORE_FILEOPERATION_HPP_

#include <memory>
#include <boost/filesystem/fstream.hpp>
#include <boost/filesystem/operations.hpp>
#include <qi/detail/warn_push_ignore_deprecated.hpp>

namespace qi
{
  class FileOperation
  {
  public:
    virtual ~FileOperation()
    {
      auto task = std::move(_task);
      if (task)
      {
        task->promise.future().cancel();
      }
    }

    // Move only
    FileOperation(const FileOperation&) = delete;
    FileOperation& operator=(const FileOperation&) = delete;

    FileOperation(FileOperation&& other) // TODO VS2015 C++11: = default;
      : _task(std::move(other._task))
    {}

    FileOperation& operator=(FileOperation&& other) // TODO VS2015 C++11: = default;
    {
      _task = std::move(other._task);
      return *this;
    }

    qi::Future<void> start()
    {
      if (!_task)
      {
        throw std::runtime_error{ "Tried to start an invalid FileOperation" };
      }

      if (_task->isLaunched.swap(true))
      {
        throw std::runtime_error{ "Called FileOperation::start() more than once!" };
      }

      return _task->run();
    }

    qi::Future<void> detach()
    {
      boost::shared_ptr<Task> sharedTask = std::move(_task);

      if (!sharedTask)
      {
        throw std::runtime_error("Called FileOperation::detach() but no task is owned!");
      }

      if (!sharedTask->isLaunched._value)
      {
        throw std::runtime_error("Called FileOperation::detach() but task was not started!");
      }

      auto future = sharedTask->promise.future();
      future.connect([sharedTask](const Future<void>&){}); // keep the task alive until it ends
      return future;
    }

    auto operator()() -> decltype(start()) { return start(); }

    ProgressNotifierPtr notifier() const { return _task ? _task->localNotifier : ProgressNotifierPtr{}; }

    bool isValid() const { return _task ? true : false; }

    explicit operator bool() const { return isValid(); }

  protected:
    struct Task
      : public boost::enable_shared_from_this<Task>
    {
      Task(FilePtr file)
        : sourceFile{ std::move(file) }
        , fileSize{ sourceFile->size() }
        , promise{ PromiseNoop<void> }
        , localNotifier{ createProgressNotifier(promise.future()) }
        , remoteNotifier{ sourceFile->operationProgress() }
        , isRemoteDeprecated(sourceFile.metaObject().findMethod("read").empty())
      {
      }

      virtual ~Task() = default;

      qi::Future<void> run()
      {
        localNotifier->reset();
        isRemoteDeprecated ? remoteNotifier->_reset() : remoteNotifier->reset();
        localNotifier->notifyRunning();
        isRemoteDeprecated ? remoteNotifier->_notifyRunning() : remoteNotifier->notifyRunning();
        start();
        return promise.future();
      }

      void finish()
      {
        promise.setValue(0);
        localNotifier->notifyFinished();
        isRemoteDeprecated ? remoteNotifier->_notifyFinished() : remoteNotifier->notifyFinished();
      }

      void fail(const std::string& errorMessage)
      {
        promise.setError(errorMessage);
        localNotifier->notifyFailed();
        isRemoteDeprecated ? remoteNotifier->_notifyFailed() : remoteNotifier->notifyFailed();
      }

      void cancel()
      {
        promise.setCanceled();
        localNotifier->notifyCanceled();
        isRemoteDeprecated ? remoteNotifier->_notifyCanceled() : remoteNotifier->notifyCanceled();
      }

      void notifyProgressed(double newProgress)
      {
        localNotifier->notifyProgressed(newProgress);
        isRemoteDeprecated ? remoteNotifier->_notifyProgressed(newProgress) : remoteNotifier->notifyProgressed(newProgress);
      }

      virtual void start() = 0;

      qi::Atomic<bool> isLaunched{ false };
      const FilePtr sourceFile;
      const std::streamsize fileSize;
      Promise<void> promise;
      const ProgressNotifierPtr localNotifier;
      const ProgressNotifierPtr remoteNotifier;
      const bool isRemoteDeprecated;
    };

    using TaskPtr = boost::shared_ptr<Task>;

    explicit FileOperation(TaskPtr task)
      : _task{ std::move(task) }
    {
      if (!_task)
        throw std::runtime_error("FileOperation requires a non-null task on constrution.");
    }

  private:
    TaskPtr _task;
  };


  using FileOperationPtr = Object<FileOperation>;

  class FileCopyToLocal
    : public FileOperation
  {
  public:
    FileCopyToLocal(qi::FilePtr file, qi::Path localPath)
      : FileOperation(boost::make_shared<Task>(std::move(file), std::move(localPath)))
    {
    }

  private:
    class Task
      : public FileOperation::Task
    {
    public:
      Task(FilePtr sourceFile, qi::Path localFilePath)
        : FileOperation::Task(std::move(sourceFile))
        , localPath(std::move(localFilePath))
      {
      }

      void start() override
      {
        if (makeLocalFile())
        {
          fetchData();
        }
      }

      void stop()
      {
        localFile.close();
        finish();
      }

      bool makeLocalFile()
      {
        localFile.open(localPath.bfsPath(), std::ios::out | std::ios::binary);
        if (!localFile.is_open())
        {
          fail("Failed to create local file copy.");
          return false;
        }
        return true;
      }

      void write(Buffer buffer)
      {
        assert(localFile.is_open());
        localFile.write(static_cast<const char*>(buffer.data()), buffer.totalSize());
        bytesWritten += buffer.totalSize();
        assert(fileSize >= bytesWritten);

        const double progress = static_cast<double>(bytesWritten) / static_cast<double>(fileSize);
        notifyProgressed(progress);
      }

      void fetchData()
      {
        static const size_t ARBITRARY_BYTES_TO_READ_PER_CYCLE = 512 * 1024;
        auto myself = shared_from_this();

        const auto readFuncName = isRemoteDeprecated ? "_read" : "read";

        sourceFile.async<Buffer>(readFuncName, bytesWritten, ARBITRARY_BYTES_TO_READ_PER_CYCLE)
          .connect([this, myself](Future<Buffer> futureBuffer)
        {
          if (futureBuffer.hasError())
          {
            fail(futureBuffer.error());
            clearLocalFile();
            return;
          }
          if (promise.isCancelRequested())
          {
            clearLocalFile();
            cancel();
            return;
          }

          write(futureBuffer.value());
          if (bytesWritten < fileSize)
            fetchData();
          else
            stop();
        }
        );
      }

      void clearLocalFile()
      {
        localFile.close();
        boost::filesystem::remove(localPath);
      }

      boost::filesystem::ofstream localFile;
      std::streamsize bytesWritten = 0;
      const qi::Path localPath;
    };

  };

  QICORE_API FutureSync<void> copyToLocal(FilePtr file, Path localPath);
}

#include <qi/detail/warn_pop_ignore_deprecated.hpp>
#endif