ADM_register_adhoc_storage.c: Fix asserts and cleanup

#include <stdlib.h>

#include <stdio.h>

#include <admire.h>

#include <assert.h>

#include "common.h"

#define NADHOC_NODES 25

        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);

}