/Users/maurits/Documents/studie/afstuderen/biosphere/modules/stat/time_functions.c

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: may 4, 2007
 * 
 * Function:
 * Timing related functions for the stat module.
 * 
 * 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 "time_functions.h"
#include "general.h"
#include <list.h>
#include <type.h>
#include <str.h>
#include <biosphere.h>

#include <apr_time.h>
#include <apr_strings.h>

extern bs_list *timers;
extern apr_pool_t *pool;


static bs_status bsmod_stat_handle_start_timer(
                const bs_service_request *request,
                bs_service_response **response)
{
        unsigned i;
        char *timer_id;
        
        /* Retrieve timer_id argument: */
        if (request->input->num_parts != 1 ||
                        request->input->parts[0] == NULL) return BS_ERROR;
        timer_id = request->input->parts[0]->data;
        
        /* Set (create) the timer: */
        lock_bsmod_stat_mux();
        for (i = 0; i < list_size(timers); i++) {
                timer_info *ti = (timer_info *) list_index(timers, i);
                if (streq(ti->timer_id, timer_id)) {
                        /* We're already keeping time for this timer_id */
                        ti->start = apr_time_now();
                        break;
                }       
        }
        if (i >= list_size(timers)) {
                /* Timer_id unknown: create: */
                timer_info *ti;
                ti = (timer_info *) apr_pcalloc(pool, sizeof(timer_info));
                ti->start = apr_time_now();
                ti->timer_id = apr_pstrdup(pool, timer_id);
                list_append(timers, ti);
        }
        
        /* Create the response: */
        *response = create_void_message(request, pool);
        unlock_bsmod_stat_mux();
        return BS_OK;
}


static bs_status bsmod_stat_handle_stop_timer(
                const bs_service_request *request,
                bs_service_response **response)
{
        unsigned i;
        char *timer_id;
        
        /* Retrieve timer_id argument: */
        if (request->input->num_parts != 1 ||
                        request->input->parts[0] == NULL) return BS_ERROR;
        timer_id = request->input->parts[0]->data;
        
        /* Stop (create) the timer: */
        lock_bsmod_stat_mux();
        for (i = 0; i < list_size(timers); i++) {
                timer_info *ti = (timer_info *) list_index(timers, i);
                if (streq(ti->timer_id, timer_id)) {
                        apr_time_t diff;
                        ti->stop = apr_time_now();
                        diff = ti->stop - ti->start;
                        if (!ti->gathered_times) {
                                ti->gathered_times = apr_psprintf(pool, "%" BS_UINT64_FMT, diff);
                        }
                        else {
                                ti->gathered_times = apr_psprintf(pool, "%s %" BS_UINT64_FMT,
                                                ti->gathered_times, diff);
                        }
                        break;
                }       
        }
        
        /* Create the response: */
        if (i >= list_size(timers)) {
                /* Timer_id unknown: return fault message: */
                *response = create_error_response(request, 1, 
                                "The provided timer_id is unknown.", pool);
        }
        else {
                *response = create_void_message(request, pool);
        }
        unlock_bsmod_stat_mux();
        return BS_OK;
}


static bs_status bsmod_stat_handle_gather_times(
                const bs_service_request *request,
                bs_service_response **response)
{
        unsigned i;
        char *timer_id, *data = NULL;
        
        /* Retrieve timer_id argument: */
        if (request->input->num_parts != 1 ||
                        request->input->parts[0] == NULL) return BS_ERROR;
        timer_id = request->input->parts[0]->data;
        
        /* Stop (create) the timer: */
        lock_bsmod_stat_mux();
        for (i = 0; i < list_size(timers); i++) {
                timer_info *ti = (timer_info *) list_index(timers, i);
                if (streq(ti->timer_id, timer_id)) {
                        data = ti->gathered_times;
                        break;
                }       
        }
        
        /* Create the response: */
        if (i >= list_size(timers)) {
                /* Timer_id unknown: return fault message: */
                *response = create_error_response(request, 1, 
                                "The provided timer_id is unknown.", pool);
        }
        else if (data == NULL) {
                *response = create_error_response(request, 2, 
                                "No data yet for provided timer_id.", pool);
        }
        else {
                bs_message_instance *output;
                bs_part_instance *time_list;
                bs_data_type *type;
                
                type = new_bs_data_type(pool, "bsmod_stat_times_list");
                time_list = new_bs_part_instance(pool, "time_list", type,
                                data, strlen(data));
                output = new_bs_message_instance(pool, "BSModStatGatherTimeOutput", 1);
                output->parts[0] = time_list;
                *response = new_bs_service_response(pool, request->uuid,
                                request->service, request->port, request->operation,
                                output, NULL);
        }
        unlock_bsmod_stat_mux();
        return BS_OK;
}


bs_status bsmod_stat_handle_time_functions(
                const bs_service_request *request,
                bs_service_response **response)
{
        if (streq(request->operation, "start_timer"))
                return bsmod_stat_handle_start_timer(request, response);
        else if (streq(request->operation, "stop_timer"))
                return bsmod_stat_handle_stop_timer(request, response);
        else if (streq(request->operation, "gather_times"))
                return bsmod_stat_handle_gather_times(request, response);
        return BS_NO_SERVICE;
}

---