Resolve "Compiling in Release disables asserts, making variables unused (Werror)" (!63) · Merge requests · eu / ADMIRE / scord

examples/c/ADM_deploy_adhoc_storage.c

+83 −34

Changes for examples/c/ADM_deploy_adhoc_storage.c: 83 added lines, 34 removed lines.
Original line number	Diff line number	Diff line
		@@ -25,7 +25,6 @@
		#include <stdlib.h>
		#include <stdio.h>
		#include <admire.h>
		#include <assert.h>
		#include "common.h"

		#define NADHOC_NODES 25
		@@ -41,58 +40,108 @@ main(int argc, char* argv[]) {
		exit(EXIT_FAILURE);
		}

		int exit_status = EXIT_SUCCESS;
		ADM_server_t server = ADM_server_create("tcp", argv[1]);
		int exit_status = EXIT_FAILURE;
		ADM_return_t ret = ADM_SUCCESS;
		ADM_server_t server = NULL;

		ADM_node_t* adhoc_nodes = prepare_nodes(NADHOC_NODES);
		assert(adhoc_nodes);
		ADM_dataset_t* inputs = prepare_datasets("input-dataset-%d", NINPUTS);
		assert(inputs);
		ADM_dataset_t* outputs = prepare_datasets("output-dataset-%d", NOUTPUTS);
		assert(outputs);
		// adhoc information
		const char* adhoc_name = "adhoc_storage_42";

		ADM_adhoc_resources_t adhoc_resources =
		ADM_adhoc_resources_create(adhoc_nodes, NADHOC_NODES);
		assert(adhoc_resources);
		ADM_node_t* adhoc_nodes = NULL;
		ADM_adhoc_resources_t adhoc_resources = NULL;
		ADM_adhoc_context_t adhoc_ctx = NULL;
		ADM_adhoc_context_t new_adhoc_ctx = NULL;
		ADM_storage_t adhoc_storage = NULL;

		ADM_adhoc_context_t ctx = ADM_adhoc_context_create(
		ADM_ADHOC_MODE_SEPARATE_NEW, ADM_ADHOC_ACCESS_RDWR, adhoc_resources,

		// Let's prepare all the information required by the API calls.
		// ADM_update_adhoc_storage() obviously requires an adhoc storage to have
		// been registered onto the system, so let's prepare first the data required
		// to call ADM_register_adhoc_storage():

		// 1. the jobs required by the associated adhoc storage
		adhoc_nodes = prepare_nodes(NADHOC_NODES);

		if(adhoc_nodes == NULL) {
		fprintf(stderr, "Fatal error preparing adhoc nodes\n");
		goto cleanup;
		}

		// 2. the adhoc storage resources
		adhoc_resources = ADM_adhoc_resources_create(adhoc_nodes, NADHOC_NODES);

		if(adhoc_resources == NULL) {
		fprintf(stderr, "Fatal error preparing adhoc resources\n");
		goto cleanup;
		}

		// 3. the adhoc storage execution context
		adhoc_ctx = ADM_adhoc_context_create(ADM_ADHOC_MODE_SEPARATE_NEW,
		ADM_ADHOC_ACCESS_RDWR, adhoc_resources,
		100, false);
		assert(ctx);

		const char* name = "adhoc_storage_42";
		if(adhoc_ctx == NULL) {
		fprintf(stderr, "Fatal error preparing adhoc context\n");
		goto cleanup;
		}


		ADM_storage_t adhoc_storage;
		ADM_return_t ret = ADM_register_adhoc_storage(
		server, name, ADM_STORAGE_GEKKOFS, ctx, &adhoc_storage);
		// All the information required by the ADM_register_adhoc_storage() API is
		// now ready. Let's actually contact the server:

		if(ret != ADM_SUCCESS) {
		fprintf(stderr,
		"ADM_register_adhoc_storage() remote procedure not completed "
		"successfully: %s\n",
		// 1. Find the server endpoint
		if((server = ADM_server_create("tcp", argv[1])) == NULL) {
		fprintf(stderr, "Fatal error creating server\n");
		goto cleanup;
		}

		// 2. Register the adhoc storage
		if(ADM_register_adhoc_storage(server, adhoc_name, ADM_STORAGE_GEKKOFS,
		adhoc_ctx, &adhoc_storage) != ADM_SUCCESS) {
		fprintf(stderr, "ADM_register_adhoc_storage() failed: %s\n",
		ADM_strerror(ret));
		exit_status = EXIT_FAILURE;
		goto cleanup;
		}

		fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "
		"successfully\n");

		ret = ADM_deploy_adhoc_storage(server, adhoc_storage);
		// Now that we have an existing adhoc storage registered into the
		// system, let's prepare a new execution context for the adhoc
		// storage system

		new_adhoc_ctx = ADM_adhoc_context_create(ADM_ADHOC_MODE_SEPARATE_NEW,
		ADM_ADHOC_ACCESS_RDWR,
		adhoc_resources, 200, false);

		if(new_adhoc_ctx == NULL) {
		fprintf(stderr, "Fatal error preparing new adhoc context\n");
		goto cleanup;
		}

		if(ret != ADM_SUCCESS) {
		fprintf(stderr,
		"ADM_deploy_adhoc_storage() remote procedure not completed "
		"successfully: %s\n",
		// We can now request the deployment to the server
		if((ret = ADM_deploy_adhoc_storage(server, adhoc_storage)) != ADM_SUCCESS) {
		fprintf(stderr, "ADM_deploy_adhoc_storage() failed: %s\n",
		ADM_strerror(ret));
		exit_status = EXIT_FAILURE;
		goto cleanup;
		}

		fprintf(stdout, "ADM_deploy_adhoc_storage() remote procedure completed "
		"successfully\n");
		// At this point, the adhoc storage has been updated...
		exit_status = EXIT_SUCCESS;

		// Once the adhoc storage is no longer required we need to notify the server
		if((ret = ADM_remove_adhoc_storage(server, adhoc_storage)) != ADM_SUCCESS) {
		fprintf(stderr, "ADM_remove_adhoc_storage() failed: %s\n",
		ADM_strerror(ret));
		adhoc_storage = NULL;
		exit_status = EXIT_FAILURE;
		// intentionally fall through...
		}


		cleanup:
		ADM_server_destroy(server);
		ADM_adhoc_context_destroy(new_adhoc_ctx);
		ADM_adhoc_context_destroy(adhoc_ctx);
		ADM_adhoc_resources_destroy(adhoc_resources);
		destroy_nodes(adhoc_nodes, NADHOC_NODES);
		exit(exit_status);
		}

examples/c/ADM_register_adhoc_storage.c

+64 −26

Changes for examples/c/ADM_register_adhoc_storage.c: 64 added lines, 26 removed lines.
Original line number	Diff line number	Diff line
		@@ -25,7 +25,6 @@
		#include <stdlib.h>
		#include <stdio.h>
		#include <admire.h>
		#include <assert.h>
		#include "common.h"

		#define NADHOC_NODES 25
		@@ -41,44 +40,83 @@ main(int argc, char* argv[]) {
		exit(EXIT_FAILURE);
		}

		int exit_status = EXIT_SUCCESS;
		ADM_server_t server = ADM_server_create("tcp", argv[1]);
		int exit_status = EXIT_FAILURE;
		ADM_return_t ret = ADM_SUCCESS;
		ADM_server_t server = NULL;

		ADM_node_t* adhoc_nodes = prepare_nodes(NADHOC_NODES);
		assert(adhoc_nodes);
		ADM_dataset_t* inputs = prepare_datasets("input-dataset-%d", NINPUTS);
		assert(inputs);
		ADM_dataset_t* outputs = prepare_datasets("output-dataset-%d", NOUTPUTS);
		assert(outputs);
		// adhoc information
		const char* adhoc_name = "adhoc_storage_42";
		ADM_node_t* adhoc_nodes = NULL;
		ADM_adhoc_resources_t adhoc_resources = NULL;
		ADM_adhoc_context_t adhoc_ctx = NULL;
		ADM_storage_t adhoc_storage = NULL;

		ADM_adhoc_resources_t adhoc_resources =
		ADM_adhoc_resources_create(adhoc_nodes, NADHOC_NODES);
		assert(adhoc_resources);
		// Let's prepare all the information required by the API calls.
		// ADM_register_adhoc_storage() requires a set of nodes for the adhoc
		// storage to use and an appropriate execution context defining how it
		// should behave:

		ADM_adhoc_context_t ctx = ADM_adhoc_context_create(
		ADM_ADHOC_MODE_SEPARATE_NEW, ADM_ADHOC_ACCESS_RDWR, adhoc_resources,
		// 1. prepare the nodes
		adhoc_nodes = prepare_nodes(NADHOC_NODES);

		if(adhoc_nodes == NULL) {
		fprintf(stderr, "Fatal error preparing adhoc nodes\n");
		goto cleanup;
		}

		// 2. define the adhoc storage resources
		adhoc_resources = ADM_adhoc_resources_create(adhoc_nodes, NADHOC_NODES);

		if(adhoc_resources == NULL) {
		fprintf(stderr, "Fatal error preparing adhoc resources\n");
		goto cleanup;
		}

		// 3. define the adhoc execution context
		adhoc_ctx = ADM_adhoc_context_create(ADM_ADHOC_MODE_SEPARATE_NEW,
		ADM_ADHOC_ACCESS_RDWR, adhoc_resources,
		100, false);
		assert(ctx);

		const char* name = "adhoc_storage_42";
		if(adhoc_ctx == NULL) {
		fprintf(stderr, "Fatal error preparing adhoc context\n");
		goto cleanup;
		}

		// All the information required by the ADM_register_adhoc_storage() API is
		// now ready. Let's actually contact the server:

		ADM_storage_t adhoc_storage;
		ADM_return_t ret = ADM_register_adhoc_storage(
		server, name, ADM_STORAGE_GEKKOFS, ctx, &adhoc_storage);
		// 1. Find the server endpoint
		if((server = ADM_server_create("tcp", argv[1])) == NULL) {
		fprintf(stderr, "Fatal error creating server\n");
		goto cleanup;
		}

		if(ret != ADM_SUCCESS) {
		fprintf(stderr,
		"ADM_register_adhoc_storage() remote procedure not completed "
		"successfully: %s\n",
		// 2. Register the adhoc storage
		if(ADM_register_adhoc_storage(server, adhoc_name, ADM_STORAGE_GEKKOFS,
		adhoc_ctx, &adhoc_storage) != ADM_SUCCESS) {
		fprintf(stderr, "ADM_register_adhoc_storage() failed: %s\n",
		ADM_strerror(ret));
		exit_status = EXIT_FAILURE;
		goto cleanup;
		}

		fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "
		"successfully\n");
		// The adhoc storage is now registered into the system :)
		exit_status = EXIT_SUCCESS;

		// Once the adhoc storage is no longer required we need to notify the server
		if((ret = ADM_remove_adhoc_storage(server, adhoc_storage)) != ADM_SUCCESS) {
		fprintf(stderr, "ADM_remove_adhoc_storage() failed: %s\n",
		ADM_strerror(ret));
		adhoc_storage = NULL;
		exit_status = EXIT_FAILURE;
		// intentionally fall through...
		}

		cleanup:
		ADM_server_destroy(server);

		ADM_adhoc_context_destroy(adhoc_ctx);
		ADM_adhoc_resources_destroy(adhoc_resources);
		destroy_nodes(adhoc_nodes, NADHOC_NODES);

		exit(exit_status);
		}

examples/c/ADM_register_job.c

+131 −56

Changes for examples/c/ADM_register_job.c: 131 added lines, 56 removed lines.
Original line number	Diff line number	Diff line
		@@ -25,7 +25,6 @@
		#include <stdlib.h>
		#include <stdio.h>
		#include <admire.h>
		#include <assert.h>
		#include "common.h"

		#define NJOB_NODES 50
		@@ -42,82 +41,158 @@ main(int argc, char* argv[]) {
		exit(EXIT_FAILURE);
		}

		int exit_status = EXIT_SUCCESS;
		ADM_server_t server = ADM_server_create("tcp", argv[1]);

		ADM_job_t job;
		ADM_node_t* job_nodes = prepare_nodes(NJOB_NODES);
		assert(job_nodes);
		ADM_node_t* adhoc_nodes = prepare_nodes(NADHOC_NODES);
		assert(adhoc_nodes);
		ADM_dataset_t* inputs = prepare_datasets("input-dataset-%d", NINPUTS);
		assert(inputs);
		ADM_dataset_t* outputs = prepare_datasets("output-dataset-%d", NOUTPUTS);
		assert(outputs);

		ADM_job_resources_t job_resources =
		ADM_job_resources_create(job_nodes, NJOB_NODES);
		assert(job_resources);

		ADM_adhoc_resources_t adhoc_resources =
		ADM_adhoc_resources_create(adhoc_nodes, NADHOC_NODES);
		assert(adhoc_resources);

		ADM_adhoc_context_t ctx = ADM_adhoc_context_create(
		ADM_ADHOC_MODE_SEPARATE_NEW, ADM_ADHOC_ACCESS_RDWR, adhoc_resources,
		int exit_status = EXIT_FAILURE;
		ADM_return_t ret = ADM_SUCCESS;
		ADM_server_t server = NULL;

		// adhoc information
		const char* adhoc_name = "adhoc_storage_42";
		ADM_node_t* adhoc_nodes = NULL;
		ADM_adhoc_resources_t adhoc_resources = NULL;
		ADM_adhoc_context_t adhoc_ctx = NULL;
		ADM_storage_t adhoc_storage = NULL;

		// job information
		ADM_node_t* job_nodes = NULL;
		ADM_job_t job = NULL;
		ADM_job_resources_t job_resources = NULL;
		ADM_job_requirements_t reqs = NULL;
		uint64_t slurm_job_id = 42;
		ADM_dataset_t* inputs = NULL;
		ADM_dataset_t* outputs = NULL;

		// Let's prepare all the information required by the API calls.
		// ADM_register_job() often requires an adhoc storage to have been
		// registered onto the system, so let's prepare first the data required
		// to call ADM_register_adhoc_storage():

		// 1. the jobs required by the associated adhoc storage
		adhoc_nodes = prepare_nodes(NADHOC_NODES);

		if(adhoc_nodes == NULL) {
		fprintf(stderr, "Fatal error preparing adhoc nodes\n");
		goto cleanup;
		}

		// 2. the adhoc storage resources
		adhoc_resources = ADM_adhoc_resources_create(adhoc_nodes, NADHOC_NODES);

		if(adhoc_resources == NULL) {
		fprintf(stderr, "Fatal error preparing adhoc resources\n");
		goto cleanup;
		}

		// 3. the adhoc storage execution context
		adhoc_ctx = ADM_adhoc_context_create(ADM_ADHOC_MODE_SEPARATE_NEW,
		ADM_ADHOC_ACCESS_RDWR, adhoc_resources,
		100, false);
		assert(ctx);

		const char* name = "adhoc_storage_42";
		if(adhoc_ctx == NULL) {
		fprintf(stderr, "Fatal error preparing adhoc context\n");
		goto cleanup;
		}


		// All the information required by the ADM_register_adhoc_storage() API is
		// now ready. Let's actually contact the server:

		ADM_storage_t adhoc_storage;
		ADM_return_t ret = ADM_register_adhoc_storage(
		server, name, ADM_STORAGE_GEKKOFS, ctx, &adhoc_storage);
		// 1. Find the server endpoint
		if((server = ADM_server_create("tcp", argv[1])) == NULL) {
		fprintf(stderr, "Fatal error creating server\n");
		goto cleanup;
		}

		if(ret != ADM_SUCCESS) {
		fprintf(stderr,
		"ADM_register_adhoc_storage() remote procedure not completed "
		"successfully: %s\n",
		// 2. Register the adhoc storage
		if(ADM_register_adhoc_storage(server, adhoc_name, ADM_STORAGE_GEKKOFS,
		adhoc_ctx, &adhoc_storage) != ADM_SUCCESS) {
		fprintf(stderr, "ADM_register_adhoc_storage() failed: %s\n",
		ADM_strerror(ret));
		exit_status = EXIT_FAILURE;
		goto cleanup;
		}

		ADM_job_requirements_t reqs = ADM_job_requirements_create(
		inputs, NINPUTS, outputs, NOUTPUTS, adhoc_storage);
		assert(reqs);

		uint64_t slurm_job_id = 42;
		ret = ADM_register_job(server, job_resources, reqs, slurm_job_id, &job);
		// Now that we have an existing adhoc storage registered into the
		// system, let's prepare all the information for actually registering the
		// job with ADM_register_job():

		if(ret != ADM_SUCCESS) {
		fprintf(stderr,
		"ADM_register_job() remote procedure not completed "
		"successfully: %s\n",
		ADM_strerror(ret));
		exit_status = EXIT_FAILURE;
		// 1. the job's resources
		job_nodes = prepare_nodes(NJOB_NODES);

		if(job_nodes == NULL) {
		fprintf(stderr, "Fatal error preparing job nodes\n");
		goto cleanup;
		}

		fprintf(stdout, "ADM_register_job() remote procedure completed "
		"successfully\n");
		job_resources = ADM_job_resources_create(job_nodes, NJOB_NODES);

		cleanup:
		for(int i = 0; i < NINPUTS; ++i) {
		ADM_dataset_destroy(inputs[i]);
		if(job_resources == NULL) {
		fprintf(stderr, "Fatal error preparing job resources\n");
		goto cleanup;
		}

		for(int i = 0; i < NOUTPUTS; ++i) {
		ADM_dataset_destroy(outputs[i]);
		// 2. the job's requirements
		inputs = prepare_datasets("input-dataset-%d", NINPUTS);

		if(inputs == NULL) {
		fprintf(stderr, "Fatal error preparing input datasets\n");
		goto cleanup;
		}

		ADM_storage_destroy(adhoc_storage);
		outputs = prepare_datasets("output-dataset-%d", NOUTPUTS);

		ADM_adhoc_context_destroy(ctx);
		if(outputs == NULL) {
		fprintf(stderr, "Fatal error preparing output datasets\n");
		goto cleanup;
		}

		ADM_job_requirements_destroy(reqs);
		if((reqs = ADM_job_requirements_create(inputs, NINPUTS, outputs, NOUTPUTS,
		adhoc_storage)) == NULL) {
		fprintf(stderr, "ADM_job_requirements_create() failed");
		goto cleanup;
		}


		// All the information required by the ADM_register_job() API is now ready.
		// Let's actually contact the server:
		if(ADM_register_job(server, job_resources, reqs, slurm_job_id, &job) !=
		ADM_SUCCESS) {
		fprintf(stderr, "ADM_register_job() failed: %s\n", ADM_strerror(ret));
		goto cleanup;
		}

		// At this point, the job can execute...
		exit_status = EXIT_SUCCESS;

		ADM_remove_job(server, job);
		// When the job finishes, it is necessary to notify the server
		if((ret = ADM_remove_job(server, job)) != ADM_SUCCESS) {
		fprintf(stderr, "ADM_remove_job() failed: %s\n", ADM_strerror(ret));
		job = NULL;
		exit_status = EXIT_FAILURE;
		// intentionally fall through...
		}

		// It is also nice to remove the adhoc storage instance once it's no
		// longer needed
		if((ret = ADM_remove_adhoc_storage(server, adhoc_storage)) != ADM_SUCCESS) {
		fprintf(stderr, "ADM_remove_adhoc_storage() failed: %s\n",
		ADM_strerror(ret));
		adhoc_storage = NULL;
		exit_status = EXIT_FAILURE;
		// intentionally fall through...
		}

		cleanup:
		ADM_server_destroy(server);

		ADM_job_requirements_destroy(reqs);
		destroy_datasets(outputs, NOUTPUTS);
		destroy_datasets(inputs, NINPUTS);
		ADM_job_resources_destroy(job_resources);
		destroy_nodes(job_nodes, NJOB_NODES);

		ADM_adhoc_context_destroy(adhoc_ctx);
		ADM_adhoc_resources_destroy(adhoc_resources);
		destroy_nodes(adhoc_nodes, NADHOC_NODES);

		exit(exit_status);
		}

examples/c/ADM_register_pfs_storage.c

+0 −9

Changes for examples/c/ADM_register_pfs_storage.c: 0 added lines, 9 removed lines.
Original line number	Diff line number	Diff line
		@@ -43,15 +43,6 @@ main(int argc, char* argv[]) {
		int exit_status = EXIT_SUCCESS;
		ADM_server_t server = ADM_server_create("tcp", argv[1]);

		ADM_dataset_t* inputs = prepare_datasets("input-dataset-%d", NINPUTS);
		assert(inputs);
		ADM_dataset_t* outputs = prepare_datasets("output-dataset-%d", NOUTPUTS);
		assert(outputs);

		ADM_job_requirements_t reqs = ADM_job_requirements_create(
		inputs, NINPUTS, outputs, NOUTPUTS, NULL);
		assert(reqs);

		ADM_storage_t pfs_storage;

		ADM_pfs_context_t ctx = ADM_pfs_context_create("/gpfs");

examples/c/ADM_remove_adhoc_storage.c

+62 −34

Changes for examples/c/ADM_remove_adhoc_storage.c: 62 added lines, 34 removed lines.
Original line number	Diff line number	Diff line
		@@ -25,7 +25,6 @@
		#include <stdlib.h>
		#include <stdio.h>
		#include <admire.h>
		#include <assert.h>
		#include "common.h"

		#define NADHOC_NODES 25
		@@ -41,58 +40,87 @@ main(int argc, char* argv[]) {
		exit(EXIT_FAILURE);
		}

		int exit_status = EXIT_SUCCESS;
		ADM_server_t server = ADM_server_create("tcp", argv[1]);
		int exit_status = EXIT_FAILURE;
		ADM_return_t ret = ADM_SUCCESS;
		ADM_server_t server = NULL;

		ADM_node_t* adhoc_nodes = prepare_nodes(NADHOC_NODES);
		assert(adhoc_nodes);
		ADM_dataset_t* inputs = prepare_datasets("input-dataset-%d", NINPUTS);
		assert(inputs);
		ADM_dataset_t* outputs = prepare_datasets("output-dataset-%d", NOUTPUTS);
		assert(outputs);
		// adhoc information
		const char* adhoc_name = "adhoc_storage_42";

		ADM_adhoc_resources_t adhoc_resources =
		ADM_adhoc_resources_create(adhoc_nodes, NADHOC_NODES);
		assert(adhoc_resources);
		ADM_node_t* adhoc_nodes = NULL;
		ADM_adhoc_resources_t adhoc_resources = NULL;
		ADM_adhoc_context_t adhoc_ctx = NULL;
		ADM_storage_t adhoc_storage = NULL;

		ADM_adhoc_context_t ctx = ADM_adhoc_context_create(
		ADM_ADHOC_MODE_SEPARATE_NEW, ADM_ADHOC_ACCESS_RDWR, adhoc_resources,

		// Let's prepare all the information required by the API calls.
		// ADM_remove_adhoc_storage() obviously requires an adhoc storage to have
		// been registered onto the system, so let's prepare first the data required
		// to call ADM_register_adhoc_storage():

		// 1. the jobs required by the associated adhoc storage
		adhoc_nodes = prepare_nodes(NADHOC_NODES);

		if(adhoc_nodes == NULL) {
		fprintf(stderr, "Fatal error preparing adhoc nodes\n");
		goto cleanup;
		}

		// 2. the adhoc storage resources
		adhoc_resources = ADM_adhoc_resources_create(adhoc_nodes, NADHOC_NODES);

		if(adhoc_resources == NULL) {
		fprintf(stderr, "Fatal error preparing adhoc resources\n");
		goto cleanup;
		}

		// 3. the adhoc storage execution context
		adhoc_ctx = ADM_adhoc_context_create(ADM_ADHOC_MODE_SEPARATE_NEW,
		ADM_ADHOC_ACCESS_RDWR, adhoc_resources,
		100, false);
		assert(ctx);

		const char* name = "adhoc_storage_42";
		if(adhoc_ctx == NULL) {
		fprintf(stderr, "Fatal error preparing adhoc context\n");
		goto cleanup;
		}

		ADM_storage_t adhoc_storage;
		ADM_return_t ret = ADM_register_adhoc_storage(
		server, name, ADM_STORAGE_GEKKOFS, ctx, &adhoc_storage);

		if(ret != ADM_SUCCESS) {
		fprintf(stderr,
		"ADM_register_adhoc_storage() remote procedure not completed "
		"successfully: %s\n",
		// All the information required by the ADM_register_adhoc_storage() API is
		// now ready. Let's actually contact the server:

		// 1. Find the server endpoint
		if((server = ADM_server_create("tcp", argv[1])) == NULL) {
		fprintf(stderr, "Fatal error creating server\n");
		goto cleanup;
		}

		// 2. Register the adhoc storage
		if(ADM_register_adhoc_storage(server, adhoc_name, ADM_STORAGE_GEKKOFS,
		adhoc_ctx, &adhoc_storage) != ADM_SUCCESS) {
		fprintf(stderr, "ADM_register_adhoc_storage() failed: %s\n",
		ADM_strerror(ret));
		exit_status = EXIT_FAILURE;
		goto cleanup;
		}

		fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "
		"successfully\n");

		ret = ADM_remove_adhoc_storage(server, adhoc_storage);
		// Now that we have an existing adhoc storage registered into the system
		// we can try to remove it...

		if(ret != ADM_SUCCESS) {
		fprintf(stderr,
		"ADM_remove_adhoc_storage() remote procedure not completed "
		"successfully: %s\n",
		if((ret = ADM_remove_adhoc_storage(server, adhoc_storage)) != ADM_SUCCESS) {
		fprintf(stderr, "ADM_remove_adhoc_storage() failed: %s\n",
		ADM_strerror(ret));
		exit_status = EXIT_FAILURE;
		goto cleanup;
		}

		fprintf(stdout, "ADM_remove_adhoc_storage() remote procedure completed "
		"successfully\n");
		// Everything is fine now...
		exit_status = EXIT_SUCCESS;

		cleanup:
		ADM_server_destroy(server);

		ADM_adhoc_context_destroy(adhoc_ctx);
		ADM_adhoc_resources_destroy(adhoc_resources);
		destroy_nodes(adhoc_nodes, NADHOC_NODES);

		exit(exit_status);
		}

Resolve "Compiling in Release disables asserts, making variables unused (Werror)"

Merge request reports