more infrastructure

include_directories(include)

set(SOURCE_FILES main.cpp main.hpp)

set(SOURCE_FILES main.cpp main.hpp configure.hpp

        src/db/db_util.cpp src/classes/fs_data.cpp

        include/db/db_util.hpp include/classes/fs_data.hpp

        src/daemon/adafs_daemon.cpp include/daemon/adafs_daemon.hpp)

add_executable(adafs_daemon ${SOURCE_FILES})

target_link_libraries(adafs_daemon ${ROCKSDB_LIBRARIES}

        # rocksdb libs

//

// Created by evie on 4/18/17.

//

#ifndef LFS_FS_DATA_H

#define LFS_FS_DATA_H

#include "../../main.hpp"

#include <map>

class FsData {

private:

    FsData() {}

    // Caching

    std::unordered_map<std::string, std::string> hashmap_;

    std::hash<std::string> hashf_;

    // inodes

//    fuse_ino_t inode_count_;

    // Later the blocksize will likely be coupled to the chunks to allow individually big chunk sizes.

    blksize_t blocksize_;

    //logger

    std::shared_ptr<spdlog::logger> spdlogger_;

    // paths

    std::string rootdir_;

    std::string inode_path_;

    std::string dentry_path_;

    std::string chunk_path_;

    std::string mgmt_path_;

    // hosts_

    std::map<uint64_t, std::string> hosts_;

    uint64_t host_id_; // my host number

    size_t host_size_;

    std::string rpc_port_;

    // rocksdb

    std::shared_ptr<rocksdb::DB> rdb_;

    std::shared_ptr<rocksdb::DB> rdb_crt_; // additional db instance (currently not used)

    std::shared_ptr<rocksdb::OptimisticTransactionDB> txn_rdb_;

    rocksdb::Options rdb_options_;

    rocksdb::OptimisticTransactionOptions txn_rdb_options_; // needed for snapshots

    rocksdb::WriteOptions rdb_write_options_;

    std::string rdb_path_;

public:

    // mutex has a deleted method to assign an existing mutex. As such it cannot use getter or setters

    std::mutex inode_mutex;

    static FsData* getInstance() {

        static FsData instance;

        return &instance;

    }

    FsData(FsData const&) = delete;

    void operator=(FsData const&) = delete;

    // getter/setter

    const std::unordered_map<std::string, std::string>& hashmap() const;

    void hashmap(const std::unordered_map<std::string, std::string>& hashmap_);

    const std::hash<std::string>& hashf() const;

    void hashf(const std::hash<std::string>& hashf_);

//    fuse_ino_t inode_count() const;

//

//    void inode_count(fuse_ino_t inode_count);

    blksize_t blocksize() const;

    void blocksize(blksize_t blocksize_);

    const std::shared_ptr<spdlog::logger>& spdlogger() const;

    void spdlogger(const std::shared_ptr<spdlog::logger>& spdlogger_);

    const std::string& rootdir() const;

    void rootdir(const std::string& rootdir_);

    const std::string& inode_path() const;

    void inode_path(const std::string& inode_path_);

    const std::string& dentry_path() const;

    void dentry_path(const std::string& dentry_path_);

    const std::string& chunk_path() const;

    void chunk_path(const std::string& chunk_path_);

    const std::string& mgmt_path() const;

    void mgmt_path(const std::string& mgmt_path_);

    const std::shared_ptr<rocksdb::DB>& rdb() const;

    void rdb(const std::shared_ptr<rocksdb::DB>& rdb);

    const rocksdb::Options& rdb_options() const;

    void rdb_options(const rocksdb::Options& rdb_options);

    const std::string& rdb_path() const;

    void rdb_path(const std::string& rdb_path);

    const std::shared_ptr<rocksdb::OptimisticTransactionDB>& txn_rdb() const;

    void txn_rdb(const std::shared_ptr<rocksdb::OptimisticTransactionDB>& tx_rdb);

    const std::shared_ptr<rocksdb::DB>& rdb_crt() const;

    void rdb_crt(const std::shared_ptr<rocksdb::DB>& rdb_crt);

    const rocksdb::OptimisticTransactionOptions& txn_rdb_options() const;

    void txn_rdb_options(const rocksdb::OptimisticTransactionOptions& tx_rdb_options);

    const rocksdb::WriteOptions& rdb_write_options() const;

    void rdb_write_options(const rocksdb::WriteOptions& rdb_write_options);

    const std::map<uint64_t, std::string>& hosts() const;

    void hosts(const std::map<uint64_t, std::string>& hosts);

    const uint64_t& host_id() const;

    void host_id(const uint64_t& host_id);

    size_t host_size() const;

    void host_size(size_t host_size);

    std::string rpc_port() const;

    void rpc_port(std::string rpc_port);

    // Utility member functions

//    fuse_ino_t raise_inode_count(fuse_ino_t count);

    bool is_local_op(size_t recipient);

};

#endif //LFS_FS_DATA_H

//

// Created by evie on 6/21/17.

//

#ifndef LFS_RPC_DATA_HPP

#define LFS_RPC_DATA_HPP

#include "../../main.hpp"

#include "extern/lrucache/LRUCache11.hpp"

class RPCData {

private:

    RPCData() {}

    // Can't use shared pointers here 'cause the Mercury environment has problems with it, e.g., unable to finalize,

    // resulting into a faulty fuse shutdown

    // Mercury Server

    hg_class_t* server_hg_class_;

    hg_context_t* server_hg_context_;

    // Mercury Client

    hg_class_t* client_hg_class_;

    hg_context_t* client_hg_context_;

    // Margo IDs. They can also be used to retrieve the Mercury classes and contexts that were created at init time

    margo_instance_id server_mid_;

    margo_instance_id client_mid_;

    lru11::Cache<uint64_t, hg_addr_t> address_cache_{32768, 4096}; // XXX Set values are not based on anything...

    // TODO RPC client IDs

    // RPC client IDs

    hg_id_t rpc_minimal_id_;

    hg_id_t rpc_srv_create_dentry_id_;

    hg_id_t rpc_srv_create_mdata_id_;

    hg_id_t rpc_srv_attr_id_;

    hg_id_t rpc_srv_lookup_id_;

    hg_id_t rpc_srv_remove_dentry_id_;

    hg_id_t rpc_srv_remove_mdata_id_;

    hg_id_t rpc_srv_read_data_id_;

    hg_id_t rpc_srv_write_data_id_;

public:

    static RPCData* getInstance() {

        static RPCData instance;

        return &instance;

    }

    hg_addr_t svr_addr_ = HG_ADDR_NULL; // XXX TEMPORARY! server addresses will be put into a LRU map

    RPCData(RPCData const&) = delete;

    void operator=(RPCData const&) = delete;

    // Utility functions

    bool get_addr_by_hostid(const uint64_t hostid, hg_addr_t& svr_addr);

    size_t get_rpc_node(std::string to_hash);

    std::string get_dentry_hashable(const fuse_ino_t parent, const char* name);

    // Getter/Setter

    hg_class_t* server_hg_class() const;

    void server_hg_class(hg_class_t* server_hg_class);

    hg_context_t* server_hg_context() const;

    void server_hg_context(hg_context_t* server_hg_context);

    hg_class_t* client_hg_class() const;

    void client_hg_class(hg_class_t* client_hg_class);

    hg_context_t* client_hg_context() const;

    void client_hg_context(hg_context_t* client_hg_context);

    margo_instance* server_mid();

    void server_mid(margo_instance* server_mid);

    margo_instance* client_mid();

    void client_mid(margo_instance* client_mid);

    hg_id_t rpc_minimal_id() const;

    void rpc_minimal_id(hg_id_t rpc_minimal_id);

    lru11::Cache<uint64_t, hg_addr_t>& address_cache();

    hg_id_t rpc_srv_attr_id() const;

    void rpc_srv_attr_id(hg_id_t rpc_srv_attr_id);

    hg_id_t rpc_srv_create_dentry_id() const;

    void rpc_srv_create_dentry_id(hg_id_t rpc_srv_create_dentry_id);

    hg_id_t rpc_srv_create_mdata_id() const;

    void rpc_srv_create_mdata_id(hg_id_t rpc_srv_create_mdata_id);

    hg_id_t rpc_srv_lookup_id() const;

    void rpc_srv_lookup_id(hg_id_t rpc_srv_lookup_id);

    hg_id_t rpc_srv_remove_dentry_id() const;

    void rpc_srv_remove_dentry_id(hg_id_t rpc_srv_remove_dentry_id);

    hg_id_t rpc_srv_remove_mdata_id() const;

    void rpc_srv_remove_mdata_id(hg_id_t rpc_srv_remove_mdata_id);

    hg_id_t rpc_srv_read_data_id() const;

    void rpc_srv_read_data_id(hg_id_t rpc_srv_read_data_id);

    hg_id_t rpc_srv_write_data_id() const;

    void rpc_srv_write_data_id(hg_id_t rpc_srv_write_data_id);

};

#endif //LFS_RPC_DATA_HPP

//

// Created by evie on 8/31/17.

//

#ifndef IFS_ADAFS_DAEMON_HPP

#define IFS_ADAFS_DAEMON_HPP

#include "../../main.hpp"

bool init_argobots();

void destroy_argobots();

void init_environment();

#endif //IFS_ADAFS_DAEMON_HPP

//

// Created by evie on 6/8/17.

//

#ifndef LFS_DB_UTIL_HPP

#define LFS_DB_UTIL_HPP

#include "../../main.hpp"

using namespace std;

template<typename E>

constexpr typename std::underlying_type<E>::type to_underlying(E e) {

    return static_cast<typename std::underlying_type<E>::type>(e);

}

// mapping of enum to string to get the db_keys for metadata

enum class Md_fields {

    atime, mtime, ctime, uid, gid, mode, inode_no, link_count, size, blocks

};

const std::array<std::string, 10> md_field_map = {

        "_atime"s, "_mtime"s, "_ctime"s, "_uid"s, "_gid"s, "_mode"s, "_inodeno"s, "_lnkcnt"s, "_size"s, "_blkcnt"s

};

bool init_rocksdb();

void optimize_rocksdb(rocksdb::Options& options);

//std::string db_build_dentry_key(const fuse_ino_t inode, const std::string& name);

//

//std::string db_build_dentry_prefix(const fuse_ino_t inode);

//

//std::string db_build_dentry_value(const fuse_ino_t inode, const mode_t mode);

//

//std::string db_build_mdata_key(const fuse_ino_t inode, const std::string& field);

//

//string db_build_mdata_key(const string& inode, const string& field);

//

//std::vector<std::string> db_build_all_mdata_keys(const fuse_ino_t inode);

#endif //LFS_DB_UTIL_HPP