Merge branch '50-adm_register_-_storage-apis-should-not-require-an-adm_job_t-argument' into 'main'

Resolve "ADM_register_*_storage APIs should not require an `ADM_job_t` argument"

This MR removes the necessity to provide a `job` argument when registering or manipulating an `adhoc_storage` or `pfs_storage` instance.

Closes #50

See merge request !34

examples/c/ADM_deploy_adhoc_storage.c

@@ -42,28 +42,6 @@ main(int argc, char* argv[]) {
     int exit_status = EXIT_SUCCESS;
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
-    ADM_job_t job;
-
-    ADM_dataset_t inputs[NINPUTS];
-
-    for(int i = 0; i < NINPUTS; ++i) {
-        const char* pattern = "input-dataset-%d";
-        size_t n = snprintf(NULL, 0, pattern, i);
-        char* id = (char*) alloca(n + 1);
-        snprintf(id, n + 1, pattern, i);
-        inputs[i] = ADM_dataset_create(id);
-    }
-
-    ADM_dataset_t outputs[NOUTPUTS];
-
-    for(int i = 0; i < NOUTPUTS; ++i) {
-        const char* pattern = "output-dataset-%d";
-        size_t n = snprintf(NULL, 0, pattern, i);
-        char* id = (char*) alloca(n + 1);
-        snprintf(id, n + 1, pattern, i);
-        outputs[i] = ADM_dataset_create(id);
-    }
-
     ADM_adhoc_context_t ctx = ADM_adhoc_context_create(
             ADM_ADHOC_MODE_SEPARATE_NEW, ADM_ADHOC_ACCESS_RDWR, 42, 100, false);
     assert(ctx);
@@ -71,21 +49,9 @@ main(int argc, char* argv[]) {
     ADM_storage_t st = ADM_storage_create("foobar", ADM_STORAGE_GEKKOFS, ctx);
     assert(st);
 
-    ADM_job_requirements_t reqs =
-            ADM_job_requirements_create(inputs, NINPUTS, outputs, NOUTPUTS, st);
-    assert(reqs);
-
-    ADM_return_t ret = ADM_register_job(server, reqs, &job);
-
-    if(ret != ADM_SUCCESS) {
-        fprintf(stdout, "ADM_register_job() remote procedure not completed "
-                        "successfully\n");
-        exit_status = EXIT_FAILURE;
-    }
-
     ADM_storage_t adhoc_storage;
 
-    ret = ADM_register_adhoc_storage(server, job, ctx, &adhoc_storage);
+    ADM_return_t ret = ADM_register_adhoc_storage(server, ctx, &adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,
@@ -98,7 +64,7 @@ main(int argc, char* argv[]) {
     fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "
                     "successfully\n");
 
-    ret = ADM_deploy_adhoc_storage(server, job, adhoc_storage);
+    ret = ADM_deploy_adhoc_storage(server, adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,

examples/c/ADM_register_adhoc_storage.c

@@ -42,9 +42,6 @@ main(int argc, char* argv[]) {
     int exit_status = EXIT_SUCCESS;
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
-
-    ADM_job_t job;
-
     ADM_dataset_t inputs[NINPUTS];
 
     for(int i = 0; i < NINPUTS; ++i) {
@@ -76,17 +73,9 @@ main(int argc, char* argv[]) {
             ADM_job_requirements_create(inputs, NINPUTS, outputs, NOUTPUTS, st);
     assert(reqs);
 
-    ADM_return_t ret = ADM_register_job(server, reqs, &job);
-
-    if(ret != ADM_SUCCESS) {
-        fprintf(stdout, "ADM_register_job() remote procedure not completed "
-                        "successfully\n");
-        exit_status = EXIT_FAILURE;
-    }
-
     ADM_storage_t adhoc_storage;
 
-    ret = ADM_register_adhoc_storage(server, job, ctx, &adhoc_storage);
+    ADM_return_t ret = ADM_register_adhoc_storage(server, ctx, &adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,

examples/c/ADM_remove_adhoc_storage.c

@@ -42,28 +42,6 @@ main(int argc, char* argv[]) {
     int exit_status = EXIT_SUCCESS;
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
-
-    ADM_job_t job;
-    ADM_dataset_t inputs[NINPUTS];
-
-    for(int i = 0; i < NINPUTS; ++i) {
-        const char* pattern = "input-dataset-%d";
-        size_t n = snprintf(NULL, 0, pattern, i);
-        char* id = (char*) alloca(n + 1);
-        snprintf(id, n + 1, pattern, i);
-        inputs[i] = ADM_dataset_create(id);
-    }
-
-    ADM_dataset_t outputs[NOUTPUTS];
-
-    for(int i = 0; i < NOUTPUTS; ++i) {
-        const char* pattern = "output-dataset-%d";
-        size_t n = snprintf(NULL, 0, pattern, i);
-        char* id = (char*) alloca(n + 1);
-        snprintf(id, n + 1, pattern, i);
-        outputs[i] = ADM_dataset_create(id);
-    }
-
     ADM_adhoc_context_t ctx = ADM_adhoc_context_create(
             ADM_ADHOC_MODE_SEPARATE_NEW, ADM_ADHOC_ACCESS_RDWR, 42, 100, false);
     assert(ctx);
@@ -71,20 +49,8 @@ main(int argc, char* argv[]) {
     ADM_storage_t st = ADM_storage_create("foobar", ADM_STORAGE_GEKKOFS, ctx);
     assert(st);
 
-    ADM_job_requirements_t reqs =
-            ADM_job_requirements_create(inputs, NINPUTS, outputs, NOUTPUTS, st);
-    assert(reqs);
-
-    ADM_return_t ret = ADM_register_job(server, reqs, &job);
-
-    if(ret != ADM_SUCCESS) {
-        fprintf(stdout, "ADM_register_job() remote procedure not completed "
-                        "successfully\n");
-        exit_status = EXIT_FAILURE;
-    }
-
     ADM_storage_t adhoc_storage;
-    ret = ADM_register_adhoc_storage(server, job, ctx, &adhoc_storage);
+    ADM_return_t ret = ADM_register_adhoc_storage(server, ctx, &adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,
@@ -97,7 +63,7 @@ main(int argc, char* argv[]) {
     fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "
                     "successfully\n");
 
-    ret = ADM_remove_adhoc_storage(server, job, adhoc_storage);
+    ret = ADM_remove_adhoc_storage(server, adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,

examples/c/ADM_update_adhoc_storage.c

@@ -42,27 +42,6 @@ main(int argc, char* argv[]) {
     int exit_status = EXIT_SUCCESS;
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
-    ADM_job_t job;
-    ADM_dataset_t inputs[NINPUTS];
-
-    for(int i = 0; i < NINPUTS; ++i) {
-        const char* pattern = "input-dataset-%d";
-        size_t n = snprintf(NULL, 0, pattern, i);
-        char* id = (char*) alloca(n + 1);
-        snprintf(id, n + 1, pattern, i);
-        inputs[i] = ADM_dataset_create(id);
-    }
-
-    ADM_dataset_t outputs[NOUTPUTS];
-
-    for(int i = 0; i < NOUTPUTS; ++i) {
-        const char* pattern = "output-dataset-%d";
-        size_t n = snprintf(NULL, 0, pattern, i);
-        char* id = (char*) alloca(n + 1);
-        snprintf(id, n + 1, pattern, i);
-        outputs[i] = ADM_dataset_create(id);
-    }
-
     ADM_adhoc_context_t ctx = ADM_adhoc_context_create(
             ADM_ADHOC_MODE_SEPARATE_NEW, ADM_ADHOC_ACCESS_RDWR, 42, 100, false);
     assert(ctx);
@@ -70,20 +49,8 @@ main(int argc, char* argv[]) {
     ADM_storage_t st = ADM_storage_create("foobar", ADM_STORAGE_GEKKOFS, ctx);
     assert(st);
 
-    ADM_job_requirements_t reqs =
-            ADM_job_requirements_create(inputs, NINPUTS, outputs, NOUTPUTS, st);
-    assert(reqs);
-
-    ADM_return_t ret = ADM_register_job(server, reqs, &job);
-
-    if(ret != ADM_SUCCESS) {
-        fprintf(stdout, "ADM_register_job() remote procedure not completed "
-                        "successfully\n");
-        exit_status = EXIT_FAILURE;
-    }
-
     ADM_storage_t adhoc_storage;
-    ret = ADM_register_adhoc_storage(server, job, ctx, &adhoc_storage);
+    ADM_return_t ret = ADM_register_adhoc_storage(server, ctx, &adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,
@@ -96,7 +63,7 @@ main(int argc, char* argv[]) {
     fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "
                     "successfully\n");
 
-    ret = ADM_update_adhoc_storage(server, job, ctx, adhoc_storage);
+    ret = ADM_update_adhoc_storage(server, ctx, adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,

examples/cxx/ADM_deploy_adhoc_storage.cpp

@@ -38,12 +38,11 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_storage_t adhoc_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::deploy_adhoc_storage(server, job, adhoc_storage);
+        ret = admire::deploy_adhoc_storage(server, adhoc_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_deploy_adhoc_storage() failed: {}\n",
                    e.what());

examples/cxx/ADM_register_adhoc_storage.cpp

@@ -38,13 +38,12 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_adhoc_context_t ctx{};
     ADM_storage_t adhoc_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::register_adhoc_storage(server, job, ctx, &adhoc_storage);
+        ret = admire::register_adhoc_storage(server, ctx, &adhoc_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_register_adhoc_storage() failed: {}\n",
                    e.what());

examples/cxx/ADM_register_pfs_storage.cpp

@@ -38,13 +38,12 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_pfs_context_t ctx{};
     ADM_storage_t pfs_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::register_pfs_storage(server, job, ctx, &pfs_storage);
+        ret = admire::register_pfs_storage(server, ctx, &pfs_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_register_pfs_storage() failed: {}\n",
                    e.what());

examples/cxx/ADM_remove_adhoc_storage.cpp

@@ -38,12 +38,11 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_storage_t adhoc_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::remove_adhoc_storage(server, job, adhoc_storage);
+        ret = admire::remove_adhoc_storage(server, adhoc_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_remove_adhoc_storage() failed: {}\n",
                    e.what());

examples/cxx/ADM_remove_pfs_storage.cpp

@@ -37,12 +37,11 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_storage_t pfs_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::remove_pfs_storage(server, job, pfs_storage);
+        ret = admire::remove_pfs_storage(server, pfs_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_remove_pfs_storage() failed: {}\n",
                    e.what());

examples/cxx/ADM_update_adhoc_storage.cpp

@@ -38,13 +38,12 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_adhoc_context_t ctx{};
     ADM_storage_t adhoc_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::update_adhoc_storage(server, job, ctx, adhoc_storage);
+        ret = admire::update_adhoc_storage(server, ctx, adhoc_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_update_adhoc_storage() failed: {}\n",
                    e.what());

examples/cxx/ADM_update_pfs_storage.cpp

@@ -37,13 +37,12 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_pfs_context_t ctx{};
     ADM_storage_t pfs_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::update_pfs_storage(server, job, ctx, pfs_storage);
+        ret = admire::update_pfs_storage(server, ctx, pfs_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_update_pfs_storage() failed: {}\n",
                    e.what());

src/lib/admire.cpp

@@ -214,10 +214,10 @@ remove_job(const server& srv, const job& job) {
 }
 
 ADM_return_t
-register_adhoc_storage(const server& srv, ADM_job_t job,
-                       ADM_adhoc_context_t ctx, ADM_storage_t* adhoc_storage) {
+register_adhoc_storage(const server& srv, ADM_adhoc_context_t ctx,
+                       ADM_storage_t* adhoc_storage) {
+
     (void) srv;
-    (void) job;
     (void) ctx;
     (void) adhoc_storage;
 
@@ -242,10 +242,10 @@ register_adhoc_storage(const server& srv, ADM_job_t job,
 }
 
 ADM_return_t
-update_adhoc_storage(const server& srv, ADM_job_t job, ADM_adhoc_context_t ctx,
+update_adhoc_storage(const server& srv, ADM_adhoc_context_t ctx,
                      ADM_storage_t adhoc_storage) {
+
     (void) srv;
-    (void) job;
     (void) ctx;
     (void) adhoc_storage;
 
@@ -270,10 +270,9 @@ update_adhoc_storage(const server& srv, ADM_job_t job, ADM_adhoc_context_t ctx,
 }
 
 ADM_return_t
-remove_adhoc_storage(const server& srv, ADM_job_t job,
-                     ADM_storage_t adhoc_storage) {
+remove_adhoc_storage(const server& srv, ADM_storage_t adhoc_storage) {
+
     (void) srv;
-    (void) job;
     (void) adhoc_storage;
 
     scord::network::rpc_client rpc_client{srv.protocol(), rpc_registration_cb};
@@ -297,10 +296,9 @@ remove_adhoc_storage(const server& srv, ADM_job_t job,
 }
 
 ADM_return_t
-deploy_adhoc_storage(const server& srv, ADM_job_t job,
-                     ADM_storage_t adhoc_storage) {
+deploy_adhoc_storage(const server& srv, ADM_storage_t adhoc_storage) {
+
     (void) srv;
-    (void) job;
     (void) adhoc_storage;
 
     scord::network::rpc_client rpc_client{srv.protocol(), rpc_registration_cb};
@@ -324,10 +322,9 @@ deploy_adhoc_storage(const server& srv, ADM_job_t job,
 }
 
 ADM_return_t
-register_pfs_storage(const server& srv, ADM_job_t job, ADM_pfs_context_t ctx,
+register_pfs_storage(const server& srv, ADM_pfs_context_t ctx,
                      ADM_storage_t* pfs_storage) {
     (void) srv;
-    (void) job;
     (void) ctx;
     (void) pfs_storage;
 
@@ -352,10 +349,9 @@ register_pfs_storage(const server& srv, ADM_job_t job, ADM_pfs_context_t ctx,
 }
 
 ADM_return_t
-update_pfs_storage(const server& srv, ADM_job_t job, ADM_pfs_context_t ctx,
+update_pfs_storage(const server& srv, ADM_pfs_context_t ctx,
                    ADM_storage_t pfs_storage) {
     (void) srv;
-    (void) job;
     (void) ctx;
     (void) pfs_storage;
 
@@ -380,10 +376,8 @@ update_pfs_storage(const server& srv, ADM_job_t job, ADM_pfs_context_t ctx,
 }
 
 ADM_return_t
-remove_pfs_storage(const server& srv, ADM_job_t job,
-                   ADM_storage_t pfs_storage) {
+remove_pfs_storage(const server& srv, ADM_storage_t pfs_storage) {
     (void) srv;
-    (void) job;
     (void) pfs_storage;
 
     scord::network::rpc_client rpc_client{srv.protocol(), rpc_registration_cb};

src/lib/admire.h

@@ -87,7 +87,6 @@ ADM_remove_job(ADM_server_t server, ADM_job_t job);
  * Register an adhoc storage system.
  *
  * @param[in] server The server to which the request is directed
- * @param[in] job An ADM_JOB identifying the originating job.
  * @param[in] ctx The EXECUTION_CONTEXT for the adhoc storage system.
  * @param[out] adhoc_storage An ADM_STORAGE referring to the newly-created
  * adhoc storage instance.
@@ -95,15 +94,13 @@ ADM_remove_job(ADM_server_t server, ADM_job_t job);
  * successfully.
  */
 ADM_return_t
-ADM_register_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                           ADM_adhoc_context_t ctx,
+ADM_register_adhoc_storage(ADM_server_t server, ADM_adhoc_context_t ctx,
                            ADM_storage_t* adhoc_storage);
 
 /**
  * Update an already-registered adhoc storage system.
  *
  * @param[in] server The server to which the request is directed
- * @param[in] job An ADM_JOB identifying the originating job.
  * @param[in] ctx The updated EXECUTION_CONTEXT for the adhoc storage system.
  * @param[in] adhoc_storage An ADM_STORAGE referring to the adhoc storage
  * instance of interest.
@@ -111,8 +108,8 @@ ADM_register_adhoc_storage(ADM_server_t server, ADM_job_t job,
  * successfully.
  */
 ADM_return_t
-ADM_update_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_adhoc_context_t ctx, ADM_storage_t adhoc_storage);
+ADM_update_adhoc_storage(ADM_server_t server, ADM_adhoc_context_t ctx,
+                         ADM_storage_t adhoc_storage);
 
 /**
  * Remove an already-registered adhoc storage system.
@@ -125,8 +122,7 @@ ADM_update_adhoc_storage(ADM_server_t server, ADM_job_t job,
  * successfully.
  */
 ADM_return_t
-ADM_remove_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_storage_t adhoc_storage);
+ADM_remove_adhoc_storage(ADM_server_t server, ADM_storage_t adhoc_storage);
 
 /**
  * Initiate the deployment of an adhoc storage system instance.
@@ -138,14 +134,12 @@ ADM_remove_adhoc_storage(ADM_server_t server, ADM_job_t job,
  * @return Returns ADM_SUCCESS if the remote procedure has completed
  */
 ADM_return_t
-ADM_deploy_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_storage_t adhoc_storage);
+ADM_deploy_adhoc_storage(ADM_server_t server, ADM_storage_t adhoc_storage);
 
 /**
  * Register a PFS storage tier.
  *
  * @param[in] server The server to which the request is directed
- * @param[in] job An ADM_JOB identifying the originating job.
  * @param[in] ctx The EXECUTION_CONTEXT for the PFS.
  * @param[out] adhoc_storage An ADM_STORAGE referring to the newly-created
  * PFS instance.
@@ -153,14 +147,13 @@ ADM_deploy_adhoc_storage(ADM_server_t server, ADM_job_t job,
  * successfully.
  */
 ADM_return_t
-ADM_register_pfs_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_pfs_context_t ctx, ADM_storage_t* pfs_storage);
+ADM_register_pfs_storage(ADM_server_t server, ADM_pfs_context_t ctx,
+                         ADM_storage_t* pfs_storage);
 
 /**
  * Update an already-registered PFS storage tier.
  *
  * @param[in] server The server to which the request is directed
- * @param[in] job An ADM_JOB identifying the originating job.
  * @param[in] ctx The updated EXECUTION_CONTEXT for the PFS.
  * @param[in] adhoc_storage An ADM_STORAGE referring to the PFS
  * instance of interest.
@@ -168,8 +161,8 @@ ADM_register_pfs_storage(ADM_server_t server, ADM_job_t job,
  * successfully.
  */
 ADM_return_t
-ADM_update_pfs_storage(ADM_server_t server, ADM_job_t job,
-                       ADM_pfs_context_t ctx, ADM_storage_t adhoc_storage);
+ADM_update_pfs_storage(ADM_server_t server, ADM_pfs_context_t ctx,
+                       ADM_storage_t adhoc_storage);
 
 /**
  * Remove an already-registered PFS storage tier.
@@ -182,8 +175,7 @@ ADM_update_pfs_storage(ADM_server_t server, ADM_job_t job,
  * successfully.
  */
 ADM_return_t
-ADM_remove_pfs_storage(ADM_server_t server, ADM_job_t job,
-                       ADM_storage_t adhoc_storage);
+ADM_remove_pfs_storage(ADM_server_t server, ADM_storage_t adhoc_storage);
 
 /**
  * Transfers the dataset identified by the source_name to the storage tier

src/lib/admire.hpp

@@ -57,31 +57,29 @@ ADM_return_t
 remove_job(const server& srv, const job& job);
 
 ADM_return_t
-register_adhoc_storage(const server& srv, ADM_job_t job,
-                       ADM_adhoc_context_t ctx, ADM_storage_t* adhoc_storage);
+register_adhoc_storage(const server& srv, ADM_adhoc_context_t ctx,
+                       ADM_storage_t* adhoc_storage);
 
 ADM_return_t
-update_adhoc_storage(const server& srv, ADM_job_t job, ADM_adhoc_context_t ctx,
+update_adhoc_storage(const server& srv, ADM_adhoc_context_t ctx,
                      ADM_storage_t adhoc_storage);
 
 ADM_return_t
-remove_adhoc_storage(const server& srv, ADM_job_t job,
-                     ADM_storage_t adhoc_storage);
+remove_adhoc_storage(const server& srv, ADM_storage_t adhoc_storage);
 
 ADM_return_t
-deploy_adhoc_storage(const server& srv, ADM_job_t job,
-                     ADM_storage_t adhoc_storage);
+deploy_adhoc_storage(const server& srv, ADM_storage_t adhoc_storage);
 
 ADM_return_t
-register_pfs_storage(const server& srv, ADM_job_t job, ADM_pfs_context_t ctx,
+register_pfs_storage(const server& srv, ADM_pfs_context_t ctx,
                      ADM_storage_t* pfs_storage);
 
 ADM_return_t
-update_pfs_storage(const server& srv, ADM_job_t job, ADM_pfs_context_t ctx,
+update_pfs_storage(const server& srv, ADM_pfs_context_t ctx,
                    ADM_storage_t pfs_storage);
 
 ADM_return_t
-remove_pfs_storage(const server& srv, ADM_job_t job, ADM_storage_t pfs_storage);
+remove_pfs_storage(const server& srv, ADM_storage_t pfs_storage);
 
 ADM_return_t
 transfer_dataset(const server& srv, ADM_job_t job, ADM_dataset_t** sources,
@@ -134,7 +132,8 @@ finalize_data_operation(const server& srv, ADM_job_t job,
 
 ADM_return_t
 link_transfer_to_data_operation(const server& srv, ADM_job_t job,
-                                ADM_data_operation_t op, ADM_transfer_t transfer, bool should_stream,
+                                ADM_data_operation_t op,
+                                ADM_transfer_t transfer, bool should_stream,
                                 va_list args);
 
 ADM_return_t

src/lib/c_wrapper.cpp

@@ -79,67 +79,63 @@ ADM_remove_job(ADM_server_t server, ADM_job_t job) {
 }
 
 ADM_return_t
-ADM_register_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                           ADM_adhoc_context_t ctx,
+ADM_register_adhoc_storage(ADM_server_t server, ADM_adhoc_context_t ctx,
                            ADM_storage_t* adhoc_storage) {
 
     const admire::server srv{server};
 
-    return admire::register_adhoc_storage(srv, job, ctx, adhoc_storage);
+    return admire::register_adhoc_storage(srv, ctx, adhoc_storage);
 }
 
 ADM_return_t
-ADM_update_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_adhoc_context_t ctx, ADM_storage_t adhoc_storage) {
+ADM_update_adhoc_storage(ADM_server_t server, ADM_adhoc_context_t ctx,
+                         ADM_storage_t adhoc_storage) {
 
     const admire::server srv{server};
 
-    return admire::update_adhoc_storage(srv, job, ctx, adhoc_storage);
+    return admire::update_adhoc_storage(srv, ctx, adhoc_storage);
 }
 
 ADM_return_t
-ADM_remove_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_storage_t adhoc_storage) {
+ADM_remove_adhoc_storage(ADM_server_t server, ADM_storage_t adhoc_storage) {
 
     const admire::server srv{server};
 
-    return admire::remove_adhoc_storage(srv, job, adhoc_storage);
+    return admire::remove_adhoc_storage(srv, adhoc_storage);
 }
 
 ADM_return_t
-ADM_deploy_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_storage_t adhoc_storage) {
+ADM_deploy_adhoc_storage(ADM_server_t server, ADM_storage_t adhoc_storage) {
 
     const admire::server srv{server};
 
-    return admire::deploy_adhoc_storage(srv, job, adhoc_storage);
+    return admire::deploy_adhoc_storage(srv, adhoc_storage);
 }
 
 ADM_return_t
-ADM_register_pfs_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_pfs_context_t ctx, ADM_storage_t* pfs_storage) {
+ADM_register_pfs_storage(ADM_server_t server, ADM_pfs_context_t ctx,
+                         ADM_storage_t* pfs_storage) {
 
     const admire::server srv{server};
 
-    return admire::register_pfs_storage(srv, job, ctx, pfs_storage);
+    return admire::register_pfs_storage(srv, ctx, pfs_storage);
 }
 
 ADM_return_t
-ADM_update_pfs_storage(ADM_server_t server, ADM_job_t job,
-                       ADM_pfs_context_t ctx, ADM_storage_t pfs_storage) {
+ADM_update_pfs_storage(ADM_server_t server, ADM_pfs_context_t ctx,
+                       ADM_storage_t pfs_storage) {
 
     const admire::server srv{server};
 
-    return admire::update_pfs_storage(srv, job, ctx, pfs_storage);
+    return admire::update_pfs_storage(srv, ctx, pfs_storage);
 }
 
 ADM_return_t
-ADM_remove_pfs_storage(ADM_server_t server, ADM_job_t job,
-                       ADM_storage_t pfs_storage) {
+ADM_remove_pfs_storage(ADM_server_t server, ADM_storage_t pfs_storage) {
 
     const admire::server srv{server};
 
-    return admire::remove_pfs_storage(srv, job, pfs_storage);
+    return admire::remove_pfs_storage(srv, pfs_storage);
 }
 
 ADM_return_t