Verified Commit 697dd084 authored by Alberto Miranda's avatar Alberto Miranda ♨️
Browse files

Refactor ADM_register_job() implementation

parent 77bfe429

CMakeLists.txt

+15 −0
Original line number Diff line number Diff line
@@ -209,6 +209,21 @@ FetchContent_Declare( 


FetchContent_MakeAvailable(genopts)



### expected: required for using tl::expected in the C++ library implementation

### until std::expected makes it to C++



message(STATUS "[${PROJECT_NAME}] Downloading and building tl::expected")

set(EXPECTED_BUILD_PACKAGE OFF)

set(EXPECTED_BUILD_TESTS OFF)

FetchContent_Declare(

  expected

  GIT_REPOSITORY https://github.com/TartanLlama/expected

  GIT_TAG 96d547c03d2feab8db64c53c3744a9b4a7c8f2c5 # latest

  GIT_SHALLOW ON

  GIT_PROGRESS ON

)



FetchContent_MakeAvailable(expected)



### Mark any CMake variables imported from {fmt} and spdlog as advanced, so

### that they don't appear in cmake-gui or ccmake. Similarly for FETCHCONTENT

examples/cxx/ADM_register_job.cpp

+8 −13
Original line number Diff line number Diff line
@@ -13,24 +13,19 @@ main(int argc, char* argv[]) { 


    admire::server server{"tcp", argv[1]};



    ADM_job_handle_t job{};

    ADM_job_requirements_t reqs{};

    ADM_dataset_info_t info{};

    ADM_return_t ret = ADM_SUCCESS;



    try {

        ret = admire::register_job(server, reqs, &job);

    } catch(const std::exception& e) {

        fmt::print(stderr, "FATAL: ADM_register_job() failed: {}\n", e.what());

        exit(EXIT_FAILURE);

    }



    if(ret != ADM_SUCCESS) {

        fmt::print(stdout, "ADM_register_job() remote procedure not completed "

                           "successfully\n");

        exit(EXIT_FAILURE);

    }

        [[maybe_unused]] const auto job = admire::register_job(server, reqs);



        // do something with job



        fmt::print(stdout, "ADM_register_job() remote procedure completed "

                           "successfully\n");

        exit(EXIT_SUCCESS);

    } catch(const std::exception& e) {

        fmt::print(stderr, "FATAL: ADM_register_job() failed: {}\n", e.what());

        exit(EXIT_FAILURE);

    }

}

src/api/CMakeLists.txt

+4 −4
Original line number Diff line number Diff line
@@ -22,15 +22,15 @@ 
# SPDX-License-Identifier: GPL-3.0-or-later                                    #

################################################################################



add_library(adm_iosched SHARED c_wrapper.cpp admire.hpp)

add_library(adm_iosched SHARED)



target_sources(adm_iosched

  PUBLIC admire.h

  PRIVATE admire.cpp)

  PUBLIC admire.h admire.hpp

  PRIVATE admire.cpp c_wrapper.cpp detail/impl.hpp detail/impl.cpp)



target_include_directories(adm_iosched PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})



target_link_libraries(adm_iosched PRIVATE network_engine)

target_link_libraries(adm_iosched PRIVATE network_engine PUBLIC tl::expected)



install(

  TARGETS adm_iosched

src/api/admire.cpp

+9 −22
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 
#include <admire.hpp>

#include <engine.hpp>

#include <logger.hpp>

#include "detail/impl.hpp"





namespace {
@@ -47,37 +48,23 @@ init_logger() { 
    scord::logger::create_global_logger("libadm_iosched", "console color");

}





} // namespace





namespace admire {



ADM_return_t

register_job(const server& srv, ADM_job_requirements_t reqs,

             ADM_job_handle_t* job) {

    (void) srv;

    (void) reqs;

    (void) job;

admire::job

register_job(const server& srv, ADM_job_requirements_t reqs) {



    scord::network::rpc_client rpc_client{srv.m_protocol};

    rpc_client.register_rpcs();

    const auto rv = detail::register_job(srv, reqs);



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



    LOGGER_INFO("ADM_register_job(...)");



    ADM_register_job_in_t in{};

    ADM_register_job_out_t out;



    endp.call("ADM_register_job", &in, &out);



    if(out.ret < 0) {

        LOGGER_ERROR("ADM_register_job() = {}", out.ret);

        return static_cast<ADM_return_t>(out.ret);

    if(!rv) {

        /* TODO ADM_strerror(rv.error()) */

        throw std::runtime_error("ADM_register_job() error");

    }



    LOGGER_INFO("ADM_register_job() = {}", ADM_SUCCESS);

    return ADM_SUCCESS;

    return rv.value();

}



ADM_return_t

src/api/admire.h

+2 −3
Original line number Diff line number Diff line
@@ -203,14 +203,13 @@ typedef struct { 
 *

 * @param[in] server The server to which the request is directed

 * @param[in] reqs The requirements for the job.

 * @param[out] job An ADHOC_HANDLE referring to the newly-created

 * adhoc storage instance.

 * @param[out] job_handle A JOB_HANDLE referring to the newly-registered job.

 * @return Returns ADM_SUCCESS if the remote procedure has completed

 * successfully.

 */

ADM_return_t

ADM_register_job(ADM_server_t server, ADM_job_requirements_t reqs,

                 ADM_job_handle_t* job);

                 ADM_job_handle_t* job_handle);



ADM_return_t

ADM_update_job(ADM_server_t server, ADM_job_handle_t job,