c examples modified to initialize variables

examples/c/ADM_cancel_transfer.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -39,7 +43,57 @@ main(int argc, char* argv[]) {
     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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
+    ADM_dataset_t** sources = NULL;
+    ADM_dataset_t** targets = NULL;
+    ADM_qos_limit_t** limits = NULL;
+    ADM_transfer_mapping_t mapping = ADM_MAPPING_ONE_TO_ONE;
     ADM_transfer_t tx;
+    ADM_return_t ret_tx = ADM_transfer_dataset(server, job, sources, targets,
+                                            limits, mapping, &tx);
+        if(ret_tx != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_transfer_dataset() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+        goto cleanup;
+    }
     ADM_return_t ret = ADM_cancel_transfer(server, job, tx);
 
     if(ret != ADM_SUCCESS) {

examples/c/ADM_connect_data_operation.c

@@ -25,6 +25,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
 
 #define NINPUTS  10
 #define NOUTPUTS 5
@@ -42,7 +43,8 @@ main(int argc, char* argv[]) {
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
     ADM_job_t job;
-    ADM_dataset_t inputs[NINPUTS];
+
+        ADM_dataset_t inputs[NINPUTS];
 
     for(int i = 0; i < NINPUTS; ++i) {
         const char* pattern = "input-dataset-%d";
@@ -62,8 +64,46 @@ main(int argc, char* argv[]) {
         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);
+
+    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_dataset_t input;
+
+    const char* pattern_i = "input-dataset";
+    size_t n_i = snprintf(NULL, 0, pattern_i);
+    char* id_i = (char*) malloc(n_i + 1);
+    snprintf(id_i, n_i + 1, pattern_i);
+    input= ADM_dataset_create(id_i);
+
+    ADM_dataset_t output;
+
+    const char* pattern_o = "output-dataset";
+    size_t n_o = snprintf(NULL, 0, pattern_o);
+    char* id_o = (char*) malloc(n_o + 1);
+    snprintf(id_o, n_o + 1, pattern_o);
+    output= ADM_dataset_create(id_o);
+
+
+    ADM_return_t ret_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    } 
+
+    exit_status = EXIT_SUCCESS;
+
     bool should_stream = false;
-    ADM_return_t ret = ADM_connect_data_operation(server, job, inputs, outputs,
+    ADM_return_t ret = ADM_connect_data_operation(server, job, input, output,
                                                   should_stream);
 
 
@@ -80,6 +120,10 @@ main(int argc, char* argv[]) {
 
 cleanup:
 
+    ADM_dataset_destroy(input);
+    ADM_dataset_destroy(output);
+
+    
     for(int i = 0; i < NINPUTS; ++i) {
         ADM_dataset_destroy(inputs[i]);
     }

examples/c/ADM_define_data_operation.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -40,9 +44,48 @@ main(int argc, char* argv[]) {
     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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
+    
     ADM_data_operation_t op;
     const char* path = "/tmpxxxxx";
-    va_list args; // FIXME placeholder
+    //va_list args; // FIXME placeholder
 
     ADM_return_t ret = ADM_define_data_operation(server, job, path, &op);
 

examples/c/ADM_deploy_adhoc_storage.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -39,8 +43,62 @@ main(int argc, char* argv[]) {
     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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
+
     ADM_storage_t adhoc_storage;
 
+    ADM_return_t ret_as =
+            ADM_register_adhoc_storage(server, job, ctx, &adhoc_storage);
+
+    if(ret_as != ADM_SUCCESS) {
+        fprintf(stdout,
+                "ADM_register_adhoc_storage() remote procedure not completed "
+                "successfully\n");
+        exit_status = EXIT_FAILURE;
+        goto cleanup;
+    }
+
+    fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "
+                    "successfully\n");
+
     ADM_return_t ret = ADM_deploy_adhoc_storage(server, job, adhoc_storage);
 
 

examples/c/ADM_finalize_data_operation.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -40,7 +44,48 @@ main(int argc, char* argv[]) {
     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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
     ADM_data_operation_t op;
+    const char* path = "/tmpxxxxx";
+
+    ADM_define_data_operation(server, job, path, &op);
     ADM_data_operation_status_t status;
 
     ADM_return_t ret = ADM_finalize_data_operation(server, job, op, &status);

examples/c/ADM_get_pending_transfers.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -39,6 +43,44 @@ main(int argc, char* argv[]) {
     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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
     ADM_transfer_t** tx = NULL;
 
     ADM_return_t ret = ADM_get_pending_transfers(server, job, tx);

examples/c/ADM_get_qos_constraints.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -39,20 +43,60 @@ main(int argc, char* argv[]) {
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
     ADM_job_t job;
-    ADM_qos_entity_t entity;
+
+    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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
+
+    ADM_qos_entity_t entity = NULL;
     ADM_qos_limit_t* limits;
 
     ADM_return_t ret = ADM_get_qos_constraints(server, job, entity, &limits);
 
 
     if(ret != ADM_SUCCESS) {
-        fprintf(stdout, "ADM_cancel_transfer() remote procedure not completed "
+        fprintf(stdout, "ADM_get_qos_constraints() remote procedure not completed "
                         "successfully\n");
         exit_status = EXIT_FAILURE;
         goto cleanup;
     }
 
-    fprintf(stdout, "ADM_cancel_transfer() remote procedure completed "
+    fprintf(stdout, "ADM_get_qos_constraints() remote procedure completed "
                     "successfully\n");
 
 cleanup:

examples/c/ADM_get_statistics.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -39,6 +43,44 @@ main(int argc, char* argv[]) {
     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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
     ADM_job_stats_t* stats = NULL;
 
     ADM_return_t ret = ADM_get_statistics(server, job, &stats);

examples/c/ADM_get_transfer_priority.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -39,7 +43,58 @@ main(int argc, char* argv[]) {
     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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
+    ADM_dataset_t** sources = NULL;
+    ADM_dataset_t** targets = NULL;
+    ADM_qos_limit_t** limits = NULL;
+    ADM_transfer_mapping_t mapping = ADM_MAPPING_ONE_TO_ONE;
     ADM_transfer_t tx;
+    ADM_return_t ret_tx = ADM_transfer_dataset(server, job, sources, targets,
+                                            limits, mapping, &tx);
+
+    if(ret_tx != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_transfer_dataset() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+        goto cleanup;
+    }
     ADM_transfer_priority_t priority;
 
     ADM_return_t ret = ADM_get_transfer_priority(server, job, tx, &priority);

examples/c/ADM_link_transfer_to_data_operation.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -40,12 +44,65 @@ main(int argc, char* argv[]) {
     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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
     ADM_data_operation_t op;
-    ADM_transfer_t transfer;
+    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_transfer_mapping_t mapping = ADM_MAPPING_ONE_TO_ONE;
+    ADM_transfer_t tx;
+    ADM_return_t ret_tx = ADM_transfer_dataset(server, job, sources, targets,
+                                            limits, mapping, &tx);
+
+    if(ret_tx != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_transfer_dataset() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+        goto cleanup;
+    }
     bool should_stream = false;
     va_list args;
     ADM_return_t ret = ADM_link_transfer_to_data_operation(
-            server, job, op, transfer, should_stream, args);
+            server, job, op, tx, should_stream, args);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,

examples/c/ADM_register_adhoc_storage.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -40,7 +44,46 @@ main(int argc, char* argv[]) {
 
 
     ADM_job_t job;
-    ADM_adhoc_context_t ctx;
+
+    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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
+    
     ADM_storage_t adhoc_storage;
 
     ADM_return_t ret =

examples/c/ADM_remove_adhoc_storage.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -40,7 +44,58 @@ main(int argc, char* argv[]) {
 
 
     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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
     ADM_storage_t adhoc_storage;
+    ADM_return_t ret_as =
+            ADM_register_adhoc_storage(server, job, ctx, &adhoc_storage);
+
+    if(ret_as != ADM_SUCCESS) {
+        fprintf(stdout,
+                "ADM_register_adhoc_storage() remote procedure not completed "
+                "successfully\n");
+        exit_status = EXIT_FAILURE;
+        goto cleanup;
+    }
+
+    fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "
+                    "successfully\n");
 
     ADM_return_t ret = ADM_remove_adhoc_storage(server, job, adhoc_storage);
 

examples/c/ADM_remove_job.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -39,6 +43,44 @@ main(int argc, char* argv[]) {
     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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
 
     ADM_return_t ret = ADM_remove_job(server, job);
 

examples/c/ADM_set_dataset_information.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -40,8 +44,46 @@ main(int argc, char* argv[]) {
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
     ADM_job_t job;
-    ADM_dataset_t target;
-    ADM_dataset_info_t info;
+    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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
+    ADM_dataset_t target = NULL;
+    ADM_dataset_info_t info = NULL;
     ADM_return_t ret = ADM_set_dataset_information(server, job, target, info);
 
     if(ret != ADM_SUCCESS) {

examples/c/ADM_set_io_resources.c

@@ -25,6 +25,11 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -39,8 +44,47 @@ main(int argc, char* argv[]) {
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
     ADM_job_t job;
-    ADM_storage_t tier;
-    ADM_storage_resources_t resources;
+
+    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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
+    ADM_storage_t tier = NULL;
+    ADM_storage_resources_t resources = NULL;
     ADM_return_t ret = ADM_set_io_resources(server, job, tier, resources);
 
     if(ret != ADM_SUCCESS) {

examples/c/ADM_set_qos_constraints.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -39,8 +43,49 @@ main(int argc, char* argv[]) {
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
     ADM_job_t job;
-    ADM_qos_entity_t entity;
-    ADM_qos_limit_t limit;
+
+    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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
+    
+    ADM_qos_entity_t entity = NULL;
+    ADM_qos_limit_t limit = NULL;
+
     ADM_return_t ret = ADM_set_qos_constraints(server, job, entity, limit);
 
     if(ret != ADM_SUCCESS) {

examples/c/ADM_update_adhoc_storage.c

@@ -25,6 +25,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <admire.h>
+#include <assert.h>
+
+#define NINPUTS  10
+#define NOUTPUTS 5
 
 int
 main(int argc, char* argv[]) {
@@ -39,8 +43,59 @@ main(int argc, char* argv[]) {
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
     ADM_job_t job;
-    ADM_adhoc_context_t ctx;
+    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*) malloc(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*) malloc(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);
+
+    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_job = ADM_register_job(server, reqs, &job);
+
+    if(ret_job != ADM_SUCCESS) {
+        fprintf(stdout, "ADM_register_job() remote procedure not completed "
+                        "successfully\n");
+        exit_status = EXIT_FAILURE;
+    }
     ADM_storage_t adhoc_storage;
+    ADM_return_t ret_as =
+            ADM_register_adhoc_storage(server, job, ctx, &adhoc_storage);
+
+    if(ret_as != ADM_SUCCESS) {
+        fprintf(stdout,
+                "ADM_register_adhoc_storage() remote procedure not completed "
+                "successfully\n");
+        exit_status = EXIT_FAILURE;
+        goto cleanup;
+    }
+
+    fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "
+                    "successfully\n");
+
     ADM_return_t ret =
             ADM_update_adhoc_storage(server, job, ctx, adhoc_storage);