deploy impl

    return rpc_adhoc_storage;

}

admire::error_code

deploy_adhoc_storage(const server& srv,

                     const adhoc_storage& adhoc_storage) {

    scord::network::rpc_client rpc_client{srv.protocol(), rpc_registration_cb};

    const auto rpc_id = ::api::remote_procedure::new_id();

    auto endp = rpc_client.lookup(srv.address());

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

                "body: {{adhoc_stx: {}}}",

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

                std::quoted(rpc_client.self_address()), adhoc_storage);

    const auto rpc_stx = api::convert(adhoc_storage);

    ADM_deploy_adhoc_storage_in_t in{rpc_stx.get()};

    ADM_deploy_adhoc_storage_out_t out;

    const auto rpc = endp.call("ADM_deploy_adhoc_storage", &in, &out);

    if(const auto rv = admire::error_code{out.retval}; !rv) {

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

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

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

                     std::quoted(rpc_client.self_address()), rv);

        return rv;

    }

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

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

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

                admire::error_code::success);

    return admire::error_code::success;

}

tl::expected<transfer, error_code>

transfer_datasets(const server& srv, const job& job,

                  const std::vector<dataset>& sources,