/Users/maurits/Documents/studie/afstuderen/biosphere/daemon/core_services.c

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: mar 20, 2007
 * 
 * Function:
 * The core services are a group of basic platform services.
 * 
 * License information:
 * 
 * Copyright (c) 2006 Maurits Hartman
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 * 
 */
 
#include "core_services.h"
#include "module.h"
#include "settings.h"
#include "service.h"
#include "thread.h"
#include <io.h>
#include <list.h>
#include <type.h>
#include <str.h>

#include <apr_file_io.h>
#include <apr_strings.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>


static bs_service_response *core_service_create_status_response(
                const bs_service_request *request, bs_status status,
                apr_pool_t *mp)
{
        bs_service_response *resp;
        bs_message_instance *output = NULL;
        bs_part_instance *part = NULL;
        bs_data_type *type = NULL;
        char *data;
        
        data = apr_psprintf(mp, "%u", status);
        type = new_bs_data_type(mp, "bs_uint32");
        if (!type) return NULL;
        part = new_bs_part_instance(mp, "status", type,
                        data, strlen(data));
        if (!part) return NULL;
        output = new_bs_message_instance(mp, "BSStatusMessage", 1);
        if (!output) return NULL;
        output->parts[0] = part;
        resp = new_bs_service_response(mp, request->uuid,
                        request->service, request->port, request->operation,
                        output, NULL);
        
        return resp;
}


static bs_status core_service_admin_shutdown(
                const bs_service_request *request,
                bs_service_response **response, apr_pool_t *mp)
{
        bs_status rv;
        bs_service_response *resp;
        bs_uint32 timeout;
        
        /* Retrieve timeout and start shutdown process: */
        timeout = atoi(request->input->parts[0]->data);
        rv = stop_daemon(timeout * 1000000);
        
        /* Create return message: */
        resp = core_service_create_status_response(request, rv, mp);
        if (!resp) return BS_ERROR;
        *response = resp;
        return BS_OK;
}


static bs_status core_service_module_service_list(
                const bs_service_request *request,
                bs_service_response **response, apr_pool_t *mp)
{
        bs_service_response *resp;
        bs_message_instance *output = NULL;
        bs_data_type *type;
        bs_part_instance *part = NULL, *part2 = NULL, *part3 = NULL, *part4 = NULL;
        bs_status rv;
        bs_list *names, *descr, *fnames, *versions;
        names = new_list(mp);
        descr = new_list(mp);
        fnames = new_list(mp);
        versions = new_list(mp);
        
        rv = get_module_descriptions(names, fnames, versions, descr);
        if (rv == BS_OK) {
                unsigned i;
                char *name_string = "", *descr_string = "";
                char *fname_string = "", *version_string = "";
                
                /* Gather names and descriptions in two big strings: */
                assert(list_size(names) == list_size(descr));
                assert(list_size(names) == list_size(fnames));
                assert(list_size(fnames) == list_size(versions));
                for (i = 0; i < list_size(names); i++) {
                        name_string     = apr_pstrcat(mp, name_string, "#",
                                        list_index(names, i), NULL);
                        descr_string = apr_pstrcat(mp, descr_string, "#",
                                        list_index(descr, i), NULL);
                        fname_string = apr_pstrcat(mp, fname_string, "#",
                                        list_index(fnames, i), NULL);
                        version_string = apr_pstrcat(mp, version_string, "#",
                                        list_index(versions, i), NULL);
                }
                
                /* Create response: */
                type = new_bs_data_type(mp, "bs_string");
                part = new_bs_part_instance(mp, "modules_names",
                                type, name_string, strlen(name_string));
                part2 = new_bs_part_instance(mp, "modules_full_names",
                                type, fname_string, strlen(fname_string));
                part3 = new_bs_part_instance(mp, "modules_versions",
                                type, version_string, strlen(version_string));
                part4 = new_bs_part_instance(mp, "modules_descriptions",
                                type, descr_string, strlen(descr_string));
                output = new_bs_message_instance(mp, "ModuleListMessage", 4);
                output->parts[0] = part;
                output->parts[1] = part2;
                output->parts[2] = part3;
                output->parts[3] = part4;
                
                resp = new_bs_service_response(mp, request->uuid,
                                request->service, request->port,
                                request->operation, output, NULL);
        }
        else {
                /* TODO: create fault status message, for now, fail. */
                return BS_NO_SERVICE;
        }
        
        *response = resp;
        return BS_OK;
}


static bs_status core_service_module_service_load(
                const bs_service_request *request,
                bs_service_response **response, apr_pool_t *mp)
{
        char *modname;
        bs_status rv;
        
        /* Get the module name: */
        if (!request->input || request->input->num_parts != 1 ||
                        !request->input->parts[0]) return BS_ERROR;
        modname = request->input->parts[0]->data;
        
        /* Try to load the module: */
        rv = load_module(modname);
        
        /* Create the return message: */
        *response = core_service_create_status_response(request, rv, mp);
        return BS_OK;   
}


static bs_status core_service_module_service_unload(
                const bs_service_request *request,
                bs_service_response **response, apr_pool_t *mp)
{
        char *modname;
        bs_status rv;
        
        /* Get the module name: */
        if (!request->input || request->input->num_parts != 1 ||
                        !request->input->parts[0]) return BS_ERROR;
        modname = request->input->parts[0]->data;
        
        /* Try to load the module: */
        rv = unload_module(modname);
        
        /* Create the return message: */
        *response = core_service_create_status_response(request, rv, mp);
        return BS_OK;           
}


static bs_status core_service_module_service(
                const bs_service_request *request,
                bs_service_response **response, apr_pool_t *mp)
{
        if (streq(request->operation, "ListModules"))
                return core_service_module_service_list(request, response, mp);
        else if (streq(request->operation, "LoadModule"))
                return core_service_module_service_load(request, response, mp);
        else if (streq(request->operation, "UnloadModule"))
                return core_service_module_service_unload(request, response, mp);
        else return BS_NO_SERVICE;
}


static bs_status core_service_daemon_admin(
                const bs_service_request *request,
                bs_service_response **response, apr_pool_t *mp)
{
        if (streq(request->operation, "Shutdown"))
                return core_service_admin_shutdown(request, response, mp);
        return BS_NOT_IMPLEMENTED;
}


static bs_status core_service_logging_service(
                const bs_service_request *request,
                bs_service_response **response, apr_pool_t *mp)
{
        bs_service_response *resp = NULL;
        
        if (!streq(request->operation, "Log") || request->input->num_parts != 1)
                return BS_ERROR;
        
        /* Print the message which is supposed to be safe and checked: */
        printf("%s\n", request->input->parts[0]->data);
        
        /* Create response: */
        resp = core_service_create_status_response(request, BS_OK, mp);
        
        if (!resp) return BS_ERROR;
        *response = resp;
        return BS_OK;
}


static bs_status core_service_composition_service(
                const bs_service_request *request,
                bs_service_response **response, apr_pool_t *mp)
{

        return BS_NO_SERVICE;
}


bs_status core_service_request_handler (const bs_service_request *request,
                bs_service_response **response, void *extra)
{
        apr_pool_t *mp = (apr_pool_t *) extra;
        
        /* Check to see if really the core services are requested: */
        if (!streq(request->service, "BiosphereCoreServices"))
                return BS_ERROR;
        
        /* Check which port is requested: */
        if (streq(request->port, "DaemonAdministration"))
                return core_service_daemon_admin(request, response, mp);
        else if (streq(request->port, "LoggingService"))
                return core_service_logging_service(request, response, mp);
        else if (streq(request->port, "ModuleService"))
                return core_service_module_service(request, response, mp);
        else if (streq(request->port, "CompositionService"))
                return core_service_composition_service(request, response, mp);
        else return BS_ERROR;
}

---