Update tests involving ADM_transfer_dataset RPC

examples/c/ADM_cancel_transfer.c

@@ -68,13 +68,18 @@ main(int argc, char* argv[]) {
         exit_status = EXIT_FAILURE;
     }
 
-    ADM_dataset_t** sources = NULL;
-    ADM_dataset_t** targets = NULL;
-    ADM_qos_limit_t** limits = NULL;
+    ADM_dataset_t* sources = NULL;
+    size_t sources_len = 0;
+    ADM_dataset_t* targets = NULL;
+    size_t targets_len = 0;
+    ADM_qos_limit_t* limits = NULL;
+    size_t limits_len = 0;
     ADM_transfer_mapping_t mapping = ADM_MAPPING_ONE_TO_ONE;
     ADM_transfer_t tx;
-    ret = ADM_transfer_dataset(server, job, sources, targets, limits, mapping,
-                               &tx);
+
+    ret = ADM_transfer_dataset(server, job, sources, sources_len, targets,
+                               targets_len, limits, limits_len, mapping, &tx);
+
     if(ret != ADM_SUCCESS) {
         fprintf(stdout, "ADM_transfer_dataset() remote procedure not completed "
                         "successfully\n");

examples/c/ADM_get_transfer_priority.c

@@ -68,13 +68,17 @@ main(int argc, char* argv[]) {
         exit_status = EXIT_FAILURE;
     }
 
-    ADM_dataset_t** sources = NULL;
-    ADM_dataset_t** targets = NULL;
-    ADM_qos_limit_t** limits = NULL;
+    ADM_dataset_t* sources = NULL;
+    size_t sources_len = 0;
+    ADM_dataset_t* targets = NULL;
+    size_t targets_len = 0;
+    ADM_qos_limit_t* limits = NULL;
+    size_t limits_len = 0;
     ADM_transfer_mapping_t mapping = ADM_MAPPING_ONE_TO_ONE;
     ADM_transfer_t tx;
-    ret = ADM_transfer_dataset(server, job, sources, targets, limits, mapping,
-                               &tx);
+
+    ret = ADM_transfer_dataset(server, job, sources, sources_len, targets,
+                               targets_len, limits, limits_len, mapping, &tx);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout, "ADM_transfer_dataset() remote procedure not completed "

examples/c/ADM_link_transfer_to_data_operation.c

@@ -72,13 +72,19 @@ main(int argc, char* argv[]) {
     ADM_data_operation_t op;
     const char* path = "/tmpxxxxx";
     ADM_define_data_operation(server, job, path, &op);
-    ADM_dataset_t** sources = NULL;
-    ADM_dataset_t** targets = NULL;
-    ADM_qos_limit_t** limits = NULL;
+
+    ADM_dataset_t* sources = NULL;
+    size_t sources_len = 0;
+    ADM_dataset_t* targets = NULL;
+    size_t targets_len = 0;
+    ADM_qos_limit_t* limits = NULL;
+    size_t limits_len = 0;
     ADM_transfer_mapping_t mapping = ADM_MAPPING_ONE_TO_ONE;
     ADM_transfer_t tx;
-    ret = ADM_transfer_dataset(server, job, sources, targets, limits, mapping,
-                               &tx);
+
+    ret = ADM_transfer_dataset(server, job, sources, sources_len, targets,
+                               targets_len, limits, limits_len, mapping, &tx);
+
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout, "ADM_transfer_dataset() remote procedure not completed "

examples/c/ADM_set_transfer_priority.c

@@ -68,13 +68,17 @@ main(int argc, char* argv[]) {
         exit_status = EXIT_FAILURE;
     }
 
-    ADM_dataset_t** sources = NULL;
-    ADM_dataset_t** targets = NULL;
-    ADM_qos_limit_t** limits = NULL;
+    ADM_dataset_t* sources = NULL;
+    size_t sources_len = 0;
+    ADM_dataset_t* targets = NULL;
+    size_t targets_len = 0;
+    ADM_qos_limit_t* limits = NULL;
+    size_t limits_len = 0;
     ADM_transfer_mapping_t mapping = ADM_MAPPING_ONE_TO_ONE;
     ADM_transfer_t tx;
-    ret = ADM_transfer_dataset(server, job, sources, targets, limits, mapping,
-                               &tx);
+
+    ret = ADM_transfer_dataset(server, job, sources, sources_len, targets,
+                               targets_len, limits, limits_len, mapping, &tx);
 
     int incr = 42;
     ret = ADM_set_transfer_priority(server, job, tx, incr);

examples/c/ADM_transfer_dataset.c

@@ -68,13 +68,17 @@ main(int argc, char* argv[]) {
         exit_status = EXIT_FAILURE;
     }
 
-    ADM_dataset_t** sources = NULL;
-    ADM_dataset_t** targets = NULL;
-    ADM_qos_limit_t** limits = NULL;
+    ADM_dataset_t* sources = NULL;
+    size_t sources_len = 0;
+    ADM_dataset_t* targets = NULL;
+    size_t targets_len = 0;
+    ADM_qos_limit_t* limits = NULL;
+    size_t limits_len = 0;
     ADM_transfer_mapping_t mapping = ADM_MAPPING_ONE_TO_ONE;
     ADM_transfer_t tx;
-    ret = ADM_transfer_dataset(server, job, sources, targets, limits, mapping,
-                               &tx);
+
+    ret = ADM_transfer_dataset(server, job, sources, sources_len, targets,
+                               targets_len, limits, limits_len, mapping, &tx);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout, "ADM_transfer_dataset() remote procedure not completed "

examples/cxx/ADM_transfer_dataset.cpp

 /******************************************************************************
- * Copyright 2021, Barcelona Supercomputing Center (BSC), Spain
+ * Copyright 2021-2022, Barcelona Supercomputing Center (BSC), Spain
  *
  * This software was partially supported by the EuroHPC-funded project ADMIRE
  *   (Project ID: 956748, https://www.admire-eurohpc.eu).
@@ -24,43 +24,51 @@
 
 #include <fmt/format.h>
 #include <admire.hpp>
+#include "common.hpp"
 
+#define NINPUTS  10
+#define NOUTPUTS 5
+#define NSOURCES 5
+#define NTARGETS 5
+#define NLIMITS  4
 
 int
 main(int argc, char* argv[]) {
 
     if(argc != 2) {
-        fmt::print(stderr, "ERROR: no location provided\n");
+        fmt::print(stderr, "ERROR: no server address provided\n");
         fmt::print(stderr, "Usage: ADM_transfer_dataset <SERVER_ADDRESS>\n");
         exit(EXIT_FAILURE);
     }
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
-    ADM_dataset_t** sources = nullptr;
-    ADM_dataset_t** targets = nullptr;
-    ADM_qos_limit_t** limits = nullptr;
-    ADM_transfer_mapping_t mapping = ADM_MAPPING_ONE_TO_ONE;
-    ADM_transfer_t tx{};
-    ADM_return_t ret = ADM_SUCCESS;
+    const auto inputs = prepare_datasets("input-dataset-{}", NINPUTS);
+    const auto outputs = prepare_datasets("output-dataset-{}", NOUTPUTS);
+
+    const auto sources = prepare_datasets("source-dataset-{}", NSOURCES);
+    const auto targets = prepare_datasets("target-dataset-{}", NTARGETS);
+    const auto qos_limits = prepare_qos_limits(NLIMITS);
+    const auto mapping = admire::transfer::mapping::n_to_n;
+
+    auto p = std::make_unique<admire::adhoc_storage>(
+            admire::storage::type::gekkofs, "foobar",
+            admire::adhoc_storage::execution_mode::separate_new,
+            admire::adhoc_storage::access_type::read_write, 42, 100, false);
+
+    admire::job_requirements reqs(inputs, outputs, std::move(p));
 
     try {
-        ret = admire::transfer_dataset(server, job, sources, targets, limits,
-                                       mapping, &tx);
+        const auto job = admire::register_job(server, reqs);
+        const auto transfer = admire::transfer_dataset(
+                server, job, sources, targets, qos_limits, mapping);
+
+        fmt::print(stdout, "ADM_transfer_dataset() remote procedure completed "
+                           "successfully\n");
+        exit(EXIT_SUCCESS);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_cancel_transfer() failed: {}\n",
                    e.what());
         exit(EXIT_FAILURE);
     }
-
-    if(ret != ADM_SUCCESS) {
-        fmt::print(stdout,
-                   "ADM_transfer_dataset() remote procedure not completed "
-                   "successfully\n");
-        exit(EXIT_FAILURE);
-    } else {
-        fmt::print(stdout, "ADM_transfer_dataset() remote procedure completed "
-                           "successfully\n");
-    }
 }

examples/cxx/common.cpp

@@ -10,3 +10,16 @@ prepare_datasets(const std::string& pattern, size_t n) {
 
     return datasets;
 }
+
+std::vector<admire::qos::limit>
+prepare_qos_limits(size_t n) {
+
+    std::vector<admire::qos::limit> limits;
+    limits.reserve(n);
+
+    for(size_t i = 0; i < n; ++i) {
+        limits.emplace_back(admire::qos::subclass::bandwidth, 50);
+    }
+
+    return limits;
+}

examples/cxx/common.hpp

@@ -7,4 +7,7 @@
 std::vector<admire::dataset>
 prepare_datasets(const std::string& pattern, size_t n);
 
+std::vector<admire::qos::limit>
+prepare_qos_limits(size_t n);
+
 #endif // SCORD_CXX_EXAMPLES_COMMON_HPP