Commit 78e2c1cc authored by Marc Vef's avatar Marc Vef
Browse files

Adding get_dirents_single proxy to client

parent 329ef661

include/client/rpc/forward_metadata_proxy.hpp

+3 −0
Original line number Diff line number Diff line
@@ -30,6 +30,9 @@ forward_update_metadentry_size_proxy(const std::string& path, const size_t size, 
                                     const off64_t offset,

                                     const bool append_flag);



std::pair<int, std::vector<std::tuple<const std::string, bool, size_t, time_t>>>

forward_get_dirents_single_proxy(const std::string& path, int server);



} // namespace gkfs::rpc



#endif // GEKKOFS_FORWARD_METADATA_PROXY_HPP

include/client/rpc/rpc_types.hpp

+133 −0
Original line number Diff line number Diff line
@@ -3172,6 +3172,139 @@ struct update_metadentry_size_proxy { 
    };

};



//==============================================================================

// definitions for get_dirents_extended

struct get_dirents_extended_proxy {



    // forward declarations of public input/output types for this RPC

    class input;



    class output;



    // traits used so that the engine knows what to do with the RPC

    using self_type = get_dirents_extended_proxy;

    using handle_type = hermes::rpc_handle<self_type>;

    using input_type = input;

    using output_type = output;

    using mercury_input_type = rpc_proxy_get_dirents_in_t;

    using mercury_output_type = rpc_get_dirents_out_t;



    // RPC public identifier

    // (N.B: we reuse the same IDs assigned by Margo so that the daemon

    // understands Hermes RPCs)

    constexpr static const uint64_t public_id = 1463943168; // TODO



    // RPC internal Mercury identifier

    constexpr static const hg_id_t mercury_id = public_id;



    // RPC name

    constexpr static const auto name =

            gkfs::rpc::tag::proxy_get_dirents_extended;



    // requires response?

    constexpr static const auto requires_response = true;



    // Mercury callback to serialize input arguments

    constexpr static const auto mercury_in_proc_cb =

            HG_GEN_PROC_NAME(rpc_proxy_get_dirents_in_t);



    // Mercury callback to serialize output arguments

    constexpr static const auto mercury_out_proc_cb =

            HG_GEN_PROC_NAME(rpc_get_dirents_out_t);



    class input {



        template <typename ExecutionContext>

        friend hg_return_t

        hermes::detail::post_to_mercury(ExecutionContext*);



    public:

        input(const std::string& path, int32_t server,

              const hermes::exposed_memory& buffers)

            : m_path(path), m_server(server), m_buffers(buffers) {}



        input(input&& rhs) = default;



        input(const input& other) = default;



        input&

        operator=(input&& rhs) = default;



        input&

        operator=(const input& other) = default;



        std::string

        path() const {

            return m_path;

        }



        int32_t

        server() const {

            return m_server;

        }



        hermes::exposed_memory

        buffers() const {

            return m_buffers;

        }



        explicit input(const rpc_proxy_get_dirents_in_t& other)

            : m_path(other.path), m_server(other.server),

              m_buffers(other.bulk_handle) {}



        explicit operator rpc_proxy_get_dirents_in_t() {

            return {m_path.c_str(), m_server, hg_bulk_t(m_buffers)};

        }



    private:

        std::string m_path;

        int32_t m_server;

        hermes::exposed_memory m_buffers;

    };



    class output {



        template <typename ExecutionContext>

        friend hg_return_t

        hermes::detail::post_to_mercury(ExecutionContext*);



    public:

        output() : m_err(), m_dirents_size() {}



        output(int32_t err, size_t dirents_size)

            : m_err(err), m_dirents_size(dirents_size) {}



        output(output&& rhs) = default;



        output(const output& other) = default;



        output&

        operator=(output&& rhs) = default;



        output&

        operator=(const output& other) = default;



        explicit output(const rpc_get_dirents_out_t& out) {

            m_err = out.err;

            m_dirents_size = out.dirents_size;

        }



        int32_t

        err() const {

            return m_err;

        }



        size_t

        dirents_size() const {

            return m_dirents_size;

        }



    private:

        int32_t m_err;

        size_t m_dirents_size;

    };

};



} // namespace gkfs::rpc

include/common/common_defs.hpp

+2 −0
Original line number Diff line number Diff line
@@ -69,6 +69,8 @@ constexpr auto proxy_update_size = "proxy_rpc_srv_update_metadentry_size"; 
constexpr auto proxy_write = "proxy_rpc_srv_write_data";

constexpr auto proxy_read = "proxy_rpc_srv_read_data";

constexpr auto proxy_chunk_stat = "proxy_rpc_srv_chunk_stat";

constexpr auto proxy_get_dirents_extended =

        "proxy_rpc_srv_get_dirents_extended";

} // namespace tag



namespace protocol {

include/common/rpc/rpc_types.hpp

+4 −0
Original line number Diff line number Diff line
@@ -139,5 +139,9 @@ MERCURY_GEN_PROC(rpc_proxy_read_data_in_t, 


MERCURY_GEN_PROC(rpc_proxy_test_in_t, ((hg_const_string_t) (path)))



MERCURY_GEN_PROC(rpc_proxy_get_dirents_in_t,

                 ((hg_const_string_t) (path))((int32_t) (server))(

                         (hg_bulk_t) (bulk_handle)))





#endif // LFS_RPC_TYPES_HPP

include/config.hpp

+1 −0
Original line number Diff line number Diff line
@@ -111,6 +111,7 @@ constexpr auto fwd_remove = true; 
constexpr auto fwd_update_size = true;

constexpr auto fwd_io = true;

constexpr auto fwd_chunk_stat = true;

constexpr auto fwd_get_dirents_single = true;

// Only use proxy for io if write/read size is higher than set value

constexpr auto fwd_io_count_threshold = 0;