furrent.hpp

Go to the documentation of this file.

#pragma once
 
#include <download/downloader.hpp>
#include <mt/group.hpp>
#include <mt/sharing_queue.hpp>
#include <shared_mutex>
#include <torrent.hpp>
#include <types.hpp>
#include <unordered_map>
#include <util/singleton.hpp>
 
namespace fur {
 
struct TorrentGuiData {
  TorrentID tid;
  TorrentState state;
  std::string filename;
 
  int64_t pieces_processed;
  int64_t pieces_count;
};
 
struct PieceTaskStats {
  bool completed;
};
 
class PieceTask {
  // Downloaded piece content
  std::optional<download::Downloaded> _data;
 
 public:
  TorrentID tid;
  Piece piece;
  TorrentFile descriptor;
 
 public:
  explicit PieceTask();
  PieceTask(TorrentID tid, Piece piece, const TorrentFile& descriptor);
 
  PieceTaskStats process(const peer::Peer& peer);
 
 private:
  [[nodiscard]] bool download(const peer::Peer& peer);
  [[nodiscard]] bool save() const;
};
 
class Furrent : public Singleton<Furrent> {
  struct WorkerState {
    int64_t piece_processed = 0;
  };
 
  mt::ThreadGroup<WorkerState> _workers;
  mt::SharedQueue<PieceTask> _tasks;
 
  mutable std::shared_mutex _mtx;
  std::unordered_map<TorrentID, Torrent> _torrents;
  TorrentID _descriptor_next_uid;
 
  std::string _download_folder;
 
 public:
  enum class Error { GenericError, LoadingTorrentFailed };
 
  template <typename R>
  using Result = util::Result<R, Error>;
  using Empty = util::Empty;
 
 public:
  Furrent();
  virtual ~Furrent();
 
  Result<Empty> set_download_folder(const std::string& folder);
 
  Result<TorrentID> add_torrent(const std::string& filename);
 
  void remove_torrent(TorrentID tid);
 
  TorrentGuiData get_gui_data(TorrentID tid) const;
 
 private:
  void thread_main(mt::Runner runner, WorkerState& state, int64_t index);
 
  bool prepare_torrent_files(TorrentFile& descriptor);
};
 
}  // namespace fur