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

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: may 4, 2007
 * 
 * Function:
 * Statistics 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 "stat_functions.h"
#include "general.h"
#include "time_functions.h"
#include <list.h>
#include <str.h>
#include <type.h>

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


extern bs_list *timers;
extern apr_pool_t *pool;

static bs_status bsmod_stat_handle_avgminmax(
                const bs_service_request *request,
                bs_service_response **response)
{
        unsigned i;
        char *timer_id, *data = NULL;
        
        /* Retrieve the argument: */
        if (request->input->num_parts != 1 ||
                        request->input->parts[0] == NULL) return BS_ERROR;
        timer_id = request->input->parts[0]->data;
        
        /* Retrieve the timer data: */
        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 *part_avg, *part_min, *part_max;
                bs_data_type *type;
                apr_time_t avg = 0, min = apr_time_now(), max = 0;
                bs_list *times;
                unsigned i;
                char *avg_data, *min_data, *max_data;
                
                /* Calculate average, min and max: */
                times = new_list(pool);
                strtokenize(times, data, NULL);
                for (i = 0; i < list_size(times); i++) {
                        char *end;
                        apr_time_t val;
                        
                        val = apr_strtoi64(list_index(times, i), &end, 0);
                        if (val <= min) min = val;
                        if (val >= max) max = val;
                        avg += val;
                }
                if (list_size(times) == 0) avg = min = max = 0;
                else avg /= list_size(times);
                avg_data = apr_psprintf(pool, "%" BS_UINT64_FMT, avg);
                min_data = apr_psprintf(pool, "%" BS_UINT64_FMT, min);
                max_data = apr_psprintf(pool, "%" BS_UINT64_FMT, max);
                
                /* Create response message */
                type = new_bs_data_type(pool, "bsmod_stat_time");
                part_avg = new_bs_part_instance(pool, "average", type,
                                avg_data, strlen(avg_data));
                part_min = new_bs_part_instance(pool, "min", type,
                                min_data, strlen(min_data));
                part_max = new_bs_part_instance(pool, "max", type,
                                max_data, strlen(max_data));
                output = new_bs_message_instance(pool, "BSModStatAvgMinMaxOutput", 3);
                output->parts[0] = part_avg;
                output->parts[1] = part_min;
                output->parts[2] = part_max;
                *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_stat_functions(
                const bs_service_request *request,
                bs_service_response **response)
{
        if (streq(request->operation, "avgminmax"))
                return bsmod_stat_handle_avgminmax(request, response);
        return BS_NO_SERVICE;
}

---