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

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: feb 26, 2007
 * 
 * Function:
 * Service handling subsystem.
 * 
 * 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 "service.h"
#include "core_services.h"
#include "mutex.h"
#include "node.h"
#include "settings.h"
#include <copy.h>
#include <list.h>
#include <http_common.h>
#include <io.h>
#include <str.h>
#include <type.h>
#include <xml.h>

#include <assert.h>
#include <apr_pools.h>
#include <apr_file_io.h>
#include <apr_strings.h>
#include <stdio.h>

extern apr_pool_t *global_mp;

static bs_list *services_pool = NULL;

typedef struct service_info
{
        bs_definition *def;             
        service_request_handler handler;        
} service_info;


bs_status init_service(apr_pool_t *mp)
{
        bs_status rv;
        bs_uint64 len;
        bs_definition *def = NULL;
        char *buf, *fname;
        unsigned type;
        
        services_pool = new_list(mp);
        
        /* Read the core services definition file and add to pool: */
        fname = apr_pstrcat(mp, BIOSPHERED_PREFIX, "/bin/",
                        CORE_SERVICES_DEFINITION_FILE, NULL);
        rv = read_file_into_buf(fname, &buf, &len, mp);
        if (rv != BS_OK) {
                fprintf(stderr, "%d Error while reading core services definition file: %s\n", rv, fname);
                return rv;
        }
        
        /* Parse the wsdl file and add to the service pool: */
        rv = xlate_from_xml(buf, len, (void **) &def, &type, mp);
        if (rv != BS_OK) {
                fprintf(stderr, "%d Error while parsing core services definition file: %s\n", rv, fname);
                return rv;
        }
        rv = add_service(def, &core_service_request_handler);
        if (rv != BS_OK) {
                fprintf(stderr, "%d Error while adding core services\n", rv);
                return rv;      
        }
        return BS_OK;   
}


bs_status add_service(bs_definition *def, service_request_handler handler)
{
        service_info *info;
        unsigned i;
        
        /* Check if the service is not already in the pool: */
        lock_service_mux();
        for (i = 0; i < list_size(services_pool); i++) {
                bs_definition *tmp = ((service_info *) list_index(services_pool, i))->def;
                if (streq(def->name, tmp->name)) {
                        fprintf(stderr, "Service with the same name already exists: %s\n", def->name);
                        unlock_service_mux();
                        return BS_SERVICE_DOUBLE;
                }
        }
        unlock_service_mux();
        
        /* Add the service to the pool: */
        lock_pool_mux();
        info = (service_info *) apr_pcalloc(global_mp, sizeof(service_info));
        unlock_pool_mux();
        info->def = def;
        info->handler = handler;
        lock_service_mux();
        list_append(services_pool, info);
        unlock_service_mux();
        
        return BS_OK;
}


bs_status remove_service(const char *name)
{
        unsigned i;
        
        lock_service_mux();
        for (i = 0; i < list_size(services_pool); i++) {        
                bs_definition *def = ((service_info *) list_index(services_pool, i))->def;
                if (streq(name, def->name)) {
                        list_remove(services_pool, i);
                        unlock_service_mux();
                        return BS_OK;   
                }
        }
        unlock_service_mux();
        return BS_OK;
}


bs_status get_services(bs_definition **def, apr_pool_t *mp)
{
        bs_definition *result = NULL;
        unsigned i;
        
        lock_service_mux();
        result = new_bs_definition(mp, "service_definitions", 0, 0, 0, 0);
        for (i = 0; i < list_size(services_pool); i++) {
                bs_status rv;
                service_info *info = list_index(services_pool, i);
                rv = merge_def_with_def(mp, result, info->def);
                if (rv != BS_OK) {
                        unlock_service_mux();
                        return BS_ERROR;
                }
        }
        
        unlock_service_mux();
        *def = result;
        return BS_OK;
}


static bs_status handle_service_request_remotely(
                const bs_service_request *request,
                bs_service_response **response, apr_pool_t *mp)
{
        bs_service_response *resp;
        node_info *ni;
        bs_status rv;
        
        /* Look for the first node that can service the request: */
        ni = get_servicing_node(request);
        if (!ni) return BS_NO_SERVICE;
        
        /* Forward the request to that node: */
        rv = connect_and_post(request, &resp, ni->address->address,
                        ni->address->port, mp);
        if (rv != BS_OK) return rv;
        *response = resp;
        return BS_OK;
}


bs_status handle_service_request(const bs_service_request *request,
                bs_service_response **response, void *mp)
{
        bs_status rv;
        bs_service_response *resp;
        apr_pool_t *pool;
        unsigned i;
        assert(request != NULL);
        
        /* If no pool is given, we use a temporary pool allocated
         * from the global pool for allocation. The response will
         * be a malloced copy from this temporary pool. It is the
         * responsibility of the caller to clean up this copy. */
        if (mp == NULL) {
                apr_status_t rv2;
                lock_pool_mux();
                rv2 = apr_pool_create(&pool, global_mp);
                unlock_pool_mux();
                if (rv2 != APR_SUCCESS) {
                        fprintf(stderr, "could not create memory pool");
                        return BS_ERROR;        
                }
        }
        else pool = mp;
        
        /* Look if the service is available locally by going through the
         * services list. Since the core services will be added first,
         * they we will considered first: */
        lock_service_mux();
        for (i = 0; i < list_size(services_pool); i++) {
                service_info *si = list_index(services_pool, i);
                if (request_corresponds_with_definition(request, si->def)) {
                        unlock_service_mux();
                        rv = si->handler(request, &resp, pool);
                        if (rv == BS_OK) {
                                if (mp == NULL) {
                                        /* We are using a temporary pool so we must
                                         * make a malloced copy of this pool-alloced
                                         * response before destroying the temp pool: */
                                        *response = copy_response(resp);
                                        apr_pool_destroy(pool);
                                }
                                else {
                                        /* We were given a valid pool, so it is the
                                         * callers responsibility to look after the
                                         * validity of allocated objects from that
                                         * pool: */
                                        *response = resp;
                                }
                        }
                        return rv;
                }
        }
        unlock_service_mux();
        
        /* Try to see if it can be serviced remotely. This follows the
         * same pattern as with the local servicing: */
        rv = handle_service_request_remotely(request, &resp, pool);
        if (rv == BS_OK) {
                if (mp == NULL) {
                        *response = copy_response(resp);
                        apr_pool_destroy(pool);
                }
                else {
                        *response = resp;
                }
        }
        
        return rv;
}

---