Verified Commit 5c9f1805 authored by Alberto Miranda's avatar Alberto Miranda ♨️
Browse files

IDs for adhoc_storage instances no longer assigned automatically 

The previous automatic ID generation caused problems with the usage of
adhoc_storage constructors outside RPC handler code (e.g. during
conversions). It makes more sense for IDs to be assigned by
a server-centric adhoc_storage_manager.
parent 28fe772e

src/common/api/admire_types.hpp

+25 −10
Original line number Diff line number Diff line
@@ -294,27 +294,29 @@ struct adhoc_storage : public storage { 
        bool m_should_flush;

    };



    adhoc_storage(enum storage::type type, std::string id,

    adhoc_storage(enum storage::type type, std::string user_id,

                  execution_mode exec_mode, access_type access_type,

                  std::uint32_t nodes, std::uint32_t walltime,

                  bool should_flush);

    adhoc_storage(enum storage::type type, std::string id,

    adhoc_storage(enum storage::type type, std::string user_id,

                  ADM_adhoc_context_t ctx);

    adhoc_storage(const adhoc_storage& other) noexcept;

    adhoc_storage(enum storage::type type, std::string id,

    adhoc_storage(enum storage::type type, std::string user_id,

                  const admire::adhoc_storage::ctx& ctx);



    adhoc_storage(adhoc_storage&&) noexcept = default;

    adhoc_storage(const adhoc_storage& other) noexcept;

    adhoc_storage(adhoc_storage&&) noexcept;

    adhoc_storage&

    operator=(const adhoc_storage&) noexcept;

    adhoc_storage&

    operator=(adhoc_storage&&) noexcept = default;

    operator=(adhoc_storage&&) noexcept;

    ~adhoc_storage() override;





    std::uint64_t

    const std::optional<std::uint64_t>&

    id() const;



    std::optional<std::uint64_t>&

    id();



    std::shared_ptr<storage::ctx>

    context() const final;
@@ -594,6 +596,19 @@ struct fmt::formatter<std::shared_ptr<admire::storage>> 
    }

};



template <>

struct fmt::formatter<std::optional<std::uint64_t>>

    : formatter<std::string_view> {



    // parse is inherited from formatter<string_view>.

    template <typename FormatContext>

    auto

    format(const std::optional<std::uint64_t>& v, FormatContext& ctx) const {

        return formatter<std::string_view>::format(

                v ? std::to_string(v.value()) : "none", ctx);

    }

};



template <>

struct fmt::formatter<admire::adhoc_storage> : formatter<std::string_view> {

    // parse is inherited from formatter<string_view>.
@@ -605,8 +620,8 @@ struct fmt::formatter<admire::adhoc_storage> : formatter<std::string_view> { 
                s.context());



        const auto str =

                fmt::format("{{type: {}, id: {}, context: {}}}", s.type(),

                            std::quoted(std::to_string(s.id())),

                fmt::format("{{type: {}, id: {}, user_id: {}, context: {}}}",

                            s.type(), s.id(), std::quoted(s.user_id()),

                            (pctx ? fmt::format("{}", *pctx) : "NULL"));

        return formatter<std::string_view>::format(str, ctx);

    }

src/common/api/types.cpp

+20 −12
Original line number Diff line number Diff line
@@ -1111,34 +1111,33 @@ adhoc_storage::ctx::should_flush() const { 


class adhoc_storage::impl {



    static std::uint64_t

    generate_id() {

        static std::atomic_uint64_t s_current_server_id = 0;

        return s_current_server_id++;

    }



public:

    explicit impl(adhoc_storage::ctx ctx)

        : m_id(generate_id()), m_ctx(std::move(ctx)) {}

    explicit impl(adhoc_storage::ctx ctx) : m_id(), m_ctx(std::move(ctx)) {}

    impl(const impl& rhs) = default;

    impl(impl&& rhs) = default;

    impl&

    operator=(const impl& other) noexcept = default;

    impl&

    operator=(impl&&) noexcept = default;

    ~impl() = default;



    std::uint64_t

    const std::optional<std::uint64_t>&

    id() const {

        return m_id;

    }



    std::optional<std::uint64_t>&

    id() {

        return m_id;

    }



    adhoc_storage::ctx

    context() const {

        return m_ctx;

    }



private:

    std::uint64_t m_id;

    std::optional<std::uint64_t> m_id;

    adhoc_storage::ctx m_ctx;

};
@@ -1164,22 +1163,31 @@ adhoc_storage::adhoc_storage(const adhoc_storage& other) noexcept 
    : storage(other.m_type, other.m_user_id),

      m_pimpl(std::make_unique<impl>(*other.m_pimpl)) {}



adhoc_storage::adhoc_storage(adhoc_storage&&) noexcept = default;



adhoc_storage&

adhoc_storage::operator=(const adhoc_storage& other) noexcept {

    this->m_pimpl = std::make_unique<impl>(*other.m_pimpl);

    return *this;

}



std::uint64_t

adhoc_storage&

adhoc_storage::operator=(adhoc_storage&&) noexcept = default;



const std::optional<std::uint64_t>&

adhoc_storage::id() const {

    return m_pimpl->id();

}



std::optional<std::uint64_t>&

adhoc_storage::id() {

    return m_pimpl->id();

}



std::shared_ptr<storage::ctx>

adhoc_storage::context() const {

    return std::make_shared<adhoc_storage::ctx>(m_pimpl->context());

}



adhoc_storage::~adhoc_storage() = default;



pfs_storage::ctx::ctx(std::filesystem::path mount_point)

src/lib/detail/impl.cpp

+3 −1
Original line number Diff line number Diff line
@@ -341,9 +341,11 @@ register_adhoc_storage(const server& srv, const job& job, 
        return tl::make_unexpected(retval);

    }



    const auto rpc_adhoc_storage =

    auto rpc_adhoc_storage =

            admire::adhoc_storage{admire::storage::type::gekkofs, user_id, ctx};



    rpc_adhoc_storage.id() = out.server_id;



    LOGGER_INFO("rpc id: {} name: {} from: {} <= "

                "body: {{retval: {}}} [op_id: {}]",

                rpc_id, std::quoted("ADM_"s + __FUNCTION__), ADM_SUCCESS,

src/scord/rpc_handlers.cpp

+14 −2
Original line number Diff line number Diff line
@@ -37,6 +37,18 @@ struct remote_procedure { 
    }

};



struct adhoc_storage_manager {



    template <typename... Args>

    static admire::adhoc_storage

    create(Args&&... args) {

        static std::atomic_uint64_t current_id;

        auto adhoc_storage = admire::adhoc_storage(std::forward<Args>(args)...);

        adhoc_storage.id() = current_id++;

        return adhoc_storage;

    }

};



static void

ADM_ping(hg_handle_t h) {
@@ -232,14 +244,14 @@ ADM_register_adhoc_storage(hg_handle_t h) { 
                rpc_id, std::quoted(__FUNCTION__), std::quoted(get_address(h)),

                job);



    const auto adhoc_storage = admire::adhoc_storage(

    const auto adhoc_storage = adhoc_storage_manager::create(

            admire::adhoc_storage::type::gekkofs, id, ctx);



    admire::error_code rv = ADM_SUCCESS;



    out.op_id = rpc_id;

    out.retval = rv;

    out.server_id = adhoc_storage.id();

    out.server_id = *adhoc_storage.id();



    LOGGER_INFO("rpc id: {} name: {} to: {} => "

                "body: {{retval: {}, server_id: {}}}",