c examples modified to initialize variables (5a87c0d4) · Commits · eu / ADMIRE / scord

examples/c/ADM_cancel_transfer.c

+54 −0

Original line number	Diff line number	Diff line
		@@ -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

+46 −2

Original line number	Diff line number	Diff line
		@@ -25,6 +25,7 @@
		#include <stdlib.h>
		#include <stdio.h>
		#include <admire.h>
		#include <assert.h>

		#define NINPUTS 10
		#define NOUTPUTS 5
		@@ -42,6 +43,7 @@ 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) {
		@@ -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

+44 −1

Original line number	Diff line number	Diff line
		@@ -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

+58 −0

Original line number	Diff line number	Diff line
		@@ -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

+45 −0

Original line number	Diff line number	Diff line
		@@ -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);