y_loadrunner_utils.c

Go to the documentation of this file.

/*
 * Ylib Loadrunner function library.
 * Copyright (C) 2005-2014 Floris Kraak <randakar@gmail.com> | <fkraak@ymor.nl>
 * Copyright (C) 2009 Raymond de Jongh <ferretproof@gmail.com> | <rdjongh@ymor.nl>
 * Copyright (C) 2013-2014 André Luyer
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

#ifndef _LOADRUNNER_UTILS_C
#define _LOADRUNNER_UTILS_C

#include "y_core.c"

#define _vUserID 0_vUserID_no_longer_exists_please_use_y_virtual_user_id_or_function_y_is_vugen_run
#define _vUserGroup 0_vUserGroup_no_longer_exists_please_use_y_virtual_user_group


static unsigned long y_hash_sdbm(char* str)
{
    unsigned long hash = 0;
    int c;
    
    if( str == NULL )
        return NULL;

    while (c = *str++)
        hash = c + (hash << 6) + (hash << 16) - hash;
    return hash;
}

// --------------------------------------------------------------------------------------------------


int y_rand_in_sliding_window(int lowerbound, int upperbound, int rand_max)
{
    int roll;

    if( (0>lowerbound) || (lowerbound>upperbound) || (upperbound > rand_max) || (rand_max <= 0))
    {
        lr_error_message("y_rand_in_sliding_window called with nonsensical arguments: ( 0 <= %d < %d <= %d ) == FALSE",
                        lowerbound, upperbound, rand_max);
        return -1;
    }

    roll = y_rand_between(0, rand_max);
    if( (roll >= lowerbound) && (roll <= upperbound) )
    {
        return 1;
    }

    return 0;
}


// --------------------------------------------------------------------------------------------------



int y_rand_between(int lowerbound, int upperbound)
{
    if (lowerbound > upperbound)
    {
        lr_error_message("y_rand_between(): lowerbound should be less than upperbound!");
        return -1;    // Note to self: This is a classic case for standard error codes.
    }
    return lowerbound + y_drand() * (upperbound - lowerbound + 1);
}


int y_save_attribute_to_parameter( char* attrib, char* param )
{
   char *tmp = lr_get_attrib_string(attrib);
   if( tmp  == NULL )
      return -1;
   else
   {
      lr_save_string(tmp, param);
      return 1;
   }
}

// --------------------------------------------------------------------------------------------------



int y_save_attribute( char* param )
{
   return y_save_attribute_to_parameter( param, param );
}


// --------------------------------------------------------------------------------------------------



void y_log_rendezvous_result(int result)
{
    char *message;
    switch( result ) {
        case LR_REND_ALL_ARRIVED:
            message = "LR_REND_ALL_ARRIVED - Vuser was released after all the designated Vusers arrived.";
            break;
        case LR_REND_TIMEOUT:
            message = "LR_REND_TIMEOUT - Vuser was released after the timeout value was reached.";
            break;
        case LR_REND_DISABLED:
            message = "LR_REND_DISABLED - The rendezvous was disabled from the Controller.";
            break;
        case LR_REND_NOT_FOUND:
            message = "LR_REND_NOT_FOUND - The rendezvous was not found.";
            break;
        case LR_REND_VUSER_NOT_MEMBER:
            message = "LR_REND_VUSER_NOT_MEMBER - Vuser was not defined in the rendezvous.";
            break;
        case LR_REND_VUSER_DISABLED:
            message = "LR_REND_VUSER_DISABLED - Vuser was disabled for the rendezvous.";
            break;
        case LR_REND_BY_USER:
            message = "LR_REND_BY_USER - The rendezvous was released by the user.";
            break;
        default:
            message = "Unknown rendezvous result code.";
    }

    //lr_vuser_status_message("Rendezvous returned: %s", message);
    lr_log_message("Rendezvous returned: %s", message);
}


// --------------------------------------------------------------------------------------------------



void y_breadcrumb(char *breadcrumb)
{
    lr_message("---------------------------------------------------------------------------------");

    if( y_is_empty_parameter("breadcrumb") || ((strlen(breadcrumb) == 0)) )
    {
        lr_save_string(breadcrumb, "breadcrumb");
    }
    else
    {
        lr_param_sprintf("breadcrumb", "%s;%s", lr_eval_string("{breadcrumb}"), breadcrumb);
    }
}

// --------------------------------------------------------------------------------------------------


#define y_breadcrumb_reset() lr_save_string("", "breadcrumb")


// --------------------------------------------------------------------------------------------------



int y_write_to_file(char *filename, char *content)
{
   long file;
   int result;

   lr_log_message("y_write_to_file(%s, %s)", filename, content);

   if ((file = fopen(filename, "at")) == NULL)
   { 
       lr_error_message ("Cannot write to file >>%s<<", filename); 
       return -1;             // failed to open file...
   } 
   if (result = fprintf(file, "%s\n", content) <0)
   {
       fclose(file);
       return result;        // failed to write to file...
   }

   if (fclose(file)!=0)
   {
       return -1;        // failed to close file...
   }

   return 0;                // everything worked great!
}


int y_write_parameter_to_file(char *filename, char *content_parameter)
{
    long fp;
    char *szBuf, *param;
    unsigned long nLength;
    int result = 0;
    int tmp = 0;

    lr_log_message("y_write_parameter_to_file(\"%s\", \"%s\")", filename, content_parameter);
    
    // Get the parameter content. Tricky because of the possibility of embedded null bytes in there.
    param = y_get_parameter_eval_string(content_parameter);
    lr_eval_string_ext(param, strlen(param), &szBuf, &nLength, 0, 0, -1);
    free(param);

    // Open the file.
    if( !(fp = fopen(filename, "wb")) ) 
    {
        lr_error_message("Cannot open file %s for writing!", filename);
           lr_eval_string_ext_free(&szBuf); // Free the parameter content buffer.
        lr_abort();
        return -1; // Errors while opening the file means writing to it is pointless.
    }
    
    // Write the file.
    if( (result = fwrite(szBuf, 1, nLength, fp)) < nLength )
    {
        lr_error_message("Error while writing %d bytes to file: %s ; Only %d bytes were written.", nLength, filename, result);
        result = -2;
        // errors during writing should not stop us from closing the file..
    }
    else
    {
        result = 0;
    }
    
    // Close the file.
    if( (tmp = fclose(fp)) != 0 )
    {
        lr_error_message("Error code %d while closing file %s", tmp, filename);
        if( result >= 0 )  // if no error occured during writing, fclose() failed, return -3.
            result = -3;
    }

    // Free the parameter content buffer.
    lr_eval_string_ext_free(&szBuf);
    return result;
}

// --------------------------------------------------------------------------------------------------



void y_datetime()
{
    lr_save_datetime("%Y%m%d,%H%M%S", DATE_NOW, "DATE_TIME_STRING");
}


// --------------------------------------------------------------------------------------------------



int y_workdays_from_today(int workdays)
{
    int weekday, weeksOffset, weekstart;
    int i = 0;
    int result = workdays;
    //int debugOffset = 0;

    // debugging loop
    //for(debugOffset = 0; debugOffset < 13; debugOffset++) {
    // result = debugOffset;

    //lr_log_message("--- result start %d ---", result);

    // Determine what day of the week today falls into.
    lr_save_datetime("%w", DATE_NOW, "weekdayToday");
    weekstart = atoi(lr_eval_string("{weekdayToday}"));
    //lr_log_message("--- weekstart = %d ---", weekstart);

    weeksOffset = result / 5;
    //lr_log_message("weeksOffset %d", weeksOffset);
    result += (2 * weeksOffset);
    //lr_log_message("Adding extra weeks weekends adds up to %d", result);

    // Determine what day of the week our target day falls into.
    lr_save_datetime("%w", DATE_NOW + result*(ONE_DAY), "weekdayFuture");
    weekday = atoi(lr_eval_string("{weekdayFuture}"));
    //lr_log_message("--- weekday = %d ---", weekday);

    // Look at each day between the day of the week that our count started on,
    // and the day of our target date. Shift the target date backwards if we find
    // a weekend.
    i = weekstart;
    do {
        // Weekend rollover
        if( i > 6) {
            i = 0;
        }
        // Weekend day found
        if( i == 0 || i == 6 ) {
            //lr_log_message("i = %d, adding 1 day", i);
            result++;
        }
        i++;
    } while( i != (weekday+1) );

    // Add another day if our target day falls on a saturday.
    // The search loop accounted for the saturday itself, but saturdays tend to be
    // followed by sundays ..
    if ( weekday == 6 ) {
        //lr_log_message("weekday = %d, adding 1 day", weekday);
        result++;
    }

    //lr_log_message( "############ Final day offset = %d ############", result);
    
    //} // end debugging loop
    return result;
}

void y_get_disk_space(const char *folder_name, double *available, double *total)
{
    // returned double precision = 53 bit, thus up to 8 EiB (exa byte) it is accurate to the byte.
    int ret;
    // struct because were are lacking 64 bit support...
    struct {
        unsigned low;
        unsigned high;
    } FreeBytesAvailable = {0,0}, TotalNumberOfBytes = {0,0};

    // require once...
    static int kernel_dll_loaded = 0;
    if (!kernel_dll_loaded) {
        const int le = 0x01020304;
        // No support for int64_t and __LITTLE_ENDIAN__ in Vugen scripts, so check it here (once):
        if (sizeof(int) != 4 || *(short*)&le != 0x304) {
            lr_error_message("This system is not supported, expected 32bit little endian (%d %x)", sizeof(int), *(short*)&le);
            lr_abort();
        }
        ret = lr_load_dll("kernel32.dll");
        if (ret) {
            lr_log_error("Unable to load kernel32.dll. Error number %d. Unable to report disk space usage.", ret);
            lr_abort();
        }
        kernel_dll_loaded = 1;
    }

    // DiskFreeSpaceEx function http://msdn.microsoft.com/en-us/library/windows/desktop/aa364937(v=vs.85).aspx
    // The &&GetLastError trick allows to capture the last error before it is erased in the debugger.
    if (GetDiskFreeSpaceExA(folder_name,
                            available ? &FreeBytesAvailable: NULL,
                            total ? &TotalNumberOfBytes : NULL,
                            NULL) == 0
            && ((ret = GetLastError())|1)) {
        char *lpMsgBuf;
        FormatMessageA(0x1300, NULL, ret, 0, &lpMsgBuf, 0, NULL);
        lr_error_message("GetDiskFreeSpaceEx returned Windows Error: (%d) %s", ret, lpMsgBuf);
        LocalFree(lpMsgBuf);
        // System Error Codes http://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx
        // continue to return value of 0.
    }

    if (available) {
        // the total number of free bytes on a disk that are available to the vuser
        *available = 4294967296. * FreeBytesAvailable.high + FreeBytesAvailable.low;
    }
    
    if (total) {
        // the total number of free bytes on a disk that are available to the vuser
        *total = 4294967296. * TotalNumberOfBytes.high + TotalNumberOfBytes.low;
    }
}

double y_get_free_disk_space_in_mebibytes(const char* folder_name)
{
    double free_mebibytes;
    y_get_disk_space(folder_name, &free_mebibytes, NULL);
    free_mebibytes /= 1048576.;
    lr_log_message("Free disk space for folder \"%s\": %.0lf MiB)", folder_name, free_mebibytes);
    return free_mebibytes;
}

double y_get_free_disk_space_percentage(const char* folder_name)
{
    double available, total;
    y_get_disk_space(folder_name, &available, &total);
    available = total ? available / total * 100. : 0.;
    lr_log_message("Free disk space percentage for folder \"%s\": %.2lf%%", folder_name, available);
    return available;   
}


int y_read_file_into_parameter(char* filename, char* param)
{
    long pos;
    char *bytes;
    long f;
    lr_log_message("y_read_file_into_parameter(%s, %s)", filename, param);

    // Open the file.
    if( (f = fopen(filename, "rb")) == NULL )
    {
        lr_error_message("Unable to open file %s", filename);
        lr_abort();
        return -1;
    }

    fseek(f, 0, SEEK_END);
    pos = ftell(f);
    fseek(f, 0, SEEK_SET);

    bytes = y_mem_alloc(pos);
    fread(bytes, pos, 1, f);
    fclose(f);

    // hexdump(bytes); // do some stuff with it

    // Save the size for later use
    lr_param_sprintf("y_byte_size_param_name", "y_size_%s", param);
    lr_save_int(pos, lr_eval_string("{y_byte_size_param_name}"));

    lr_save_var(bytes, pos, 0, param);
    free(bytes); // free allocated memory
    return pos;
}

void y_user_data_point(char* param)
{
    lr_user_data_point(param, atof(y_get_parameter(param)) );
}

double y_get_current_time()
{
    struct _timeb timebuffer;
    ftime(&timebuffer);
    return timebuffer.time + (timebuffer.millitm / 1000.);
}


double y_delay_until(double timestamp)
{
    double current_time = y_get_current_time();

    if( current_time < timestamp )
    {
        double result = timestamp - current_time;
        lr_force_think_time(result);
        return result;
    }
    else
        return 0;
}

#define y_delay_once( delay_in_seconds )       \
{                                              \
    static int delay_done = 0;                 \
                                               \
    if( !delay_done )                          \
    {                                          \
        delay_done = 1;                        \
        lr_force_think_time(delay_in_seconds); \
    }                                          \
}


double y_think_time_for_rampup_ext(int rampup_period, double TPS_initial, double TPS_max, int virtual_users)
{
    static double test_start_time = 0;               // Test starttime in seconds since 1 jan 1970.
    static double previous_time = 0;                 // Timestamp of the last call to this, after think time.
    double time_passed;                              // Elapsed time since test start, in seconds.
    double response_time;                            // Elapsed time since previous call.
    double current_time = y_get_current_time();      // Current time, in seconds since 1 jan 1970.

    // Initialisation.
    // On the first call we store the current time as the test start time and the end time of the previous call.
    if( test_start_time < 1 )
    {
        test_start_time = current_time;
        previous_time = current_time;
    }

    // Calculate how much time has passed since test start and the previous call.
    time_passed = current_time - test_start_time;
    response_time = current_time - previous_time;

    // Debugging//
    lr_log_message("TT calculation: starttime %f, current time %f, previous time %f, virtual_users %d, rampup_period %d",
                                 test_start_time, current_time,    previous_time,    virtual_users,    rampup_period);

    {
        double TT, TPS_target;
        double factor = time_passed / rampup_period; // multiplication factor for the target load, based on rampup.

        if( factor > 1 ) // after rampup load should be stable.
            factor = 1;
        else if( factor < 0.03 )  // To prevent extreme thinktimes the first 3% of the rampup thinktime is calculated as if 3% of the time has passed.
            factor = 0.03;

        // double TPS_max = virtual_users * (1/response_time); // this is the absolute theoretical maximum, which we aren't using right now.
        TPS_target = ((TPS_max - TPS_initial) * factor) + TPS_initial; // Apply the ramp up to get the target TPS.
        TT = (virtual_users / TPS_target) - response_time;             // Apply the base formula to get the resulting think time

        // Debugging.
        lr_log_message("TT: %f, time_passed: %f, factor %f, response_time %f, TPS_init %f, TPS_max %f, TPS_target %f", 
                        TT,     time_passed,     factor,    response_time,    TPS_initial, TPS_max,    TPS_target);

        lr_user_data_point("y_thinktime", TT);
        if( TT > 0 )
            lr_think_time(TT);

        // Store the old time in our backup location.
        //previous_time = current_time; 
        // Do a new time measurement..
        //ftime(&ts);
        //current_time = ts.time + (ts.millitm / 1000.);

        // We measure the response time by comparing previous_time to a new measurement later, but that measurement 
        // will have to be schewed a tad to account for rounding in the windows sleep() call used by lr_think_time().
        //{
            //double time_slept = current_time - previous_time;
            //double deviation = TT - time_slept;
            //previous_time = current_time + deviation;
            //lr_log_message("Slept %f sec, deviation %f, current_time %f with deviation added: %f", time_slept, deviation, current_time, previous_time);
        //}

        // All of the above can be rewritten to:
        previous_time = current_time + TT; // Note that the "current time" actually is the timestamp from *before* we slept.

        return TT;
    }
}

double y_think_time_for_rampup(const int rampup_period, double TPS_max)
{
    // These used to be parameters. I've kept them for documentation purposes, but I feel 
    // these defaults are sane enough to allow me to internalize them.
    const double TPS_initial = 0.1;                // Start rampup with this many transactions / sec in total, across all virtual users.
    const int virtual_users = 1;                   // How many virtual users the script is using. If you use "1", you can just use TPS / virtual user for the initial target TPS.

    return y_think_time_for_rampup_ext(rampup_period, TPS_initial, TPS_max, virtual_users);
}

y_execute_shell_command(char* command, int debug)
{
    const int buffer_size = 10240; // 10 KB;
    char buffer[10240];            // allocate memory for the output of the command.
                                   // Has to be hardcoded because this compiler is stupid about const keywords and I do not want to use #define because of potential side effects. -- FBK
    long fp;           // file/stream pointer
    int count;         // number of characters that have been read from the stream.
    char *token;
    char *command_evaluated = lr_eval_string(command);

    lr_save_string("-- command not yet executed --", "command_result");
    lr_log_message("Executing command: %s", command_evaluated);

    fp = popen(command_evaluated, "r");
    if (fp == NULL) {
        lr_error_message("Error opening stream.");
        return -1;
    }

    buffer[0] = '\0';  // Clear the buffer before we try to fill it - Prevents the previous command output from showing up in here. -- FBK
    count = fread(buffer, sizeof(char), buffer_size, fp); // read up to 10KB
    if (feof(fp) == 0) 
    {
        lr_error_message("Did not reach the end of the input stream when reading. Try increasing buffer_size.");
        pclose(fp);
        return -1;
    }
    if (ferror(fp)) 
    {
        lr_error_message ("I/O error during read."); 
        pclose(fp);
        return -1;
    }
    count = fread(buffer, sizeof(char), (sizeof buffer) - 1, fp);
    lr_save_var(buffer, count, 0, "command_output");

    // Split the stream at each newline character, and save them to a parameter array.
    token = (char*) strtok(buffer, "\n"); // Get the first token
 
    if (token == NULL) {
        lr_save_string("", "command_result");        
    }
    else 
    {
        lr_save_string(token, "command_result"); // First token saved

        if(debug)
        {
            char param_buf[10];         // buffer to hold the parameter name.
            int i = 1;
    
            while (token != NULL) { // While valid tokens are returned 
                sprintf(param_buf, "output_%d", i);
                lr_save_string(token, param_buf);
                i++;
                token = (char*) strtok(NULL, "\n");
             }
            lr_save_int(i-1, "output_count");
            
            // Print all values of the parameter array.
            for (i=1; i<=lr_paramarr_len("output"); i++) {
                lr_output_message("Parameter value: %s", lr_paramarr_idx("output", i));
            } 
        }
    }
    
    pclose(fp);
    return 0;
}

int y_errorcheck(int ok)
{
    static int enabled = -1;
    static int pause_time = 900; // in seconds
    static unsigned pacing_limit = 10, abort_limit = -1; // == MAX_INT
    static unsigned errorcount = 0; // static means this value will not be reset to zero when a new iteration starts.

    if (enabled < 0) {
        // initialize
        long tmp, tmp2, nr; char *str;
        str = lr_get_attrib_string("errorcheck_enabled");
        enabled = str ? // errorcheck_enabled used?
                    *str ? // and not empty
                    atoi(str) > 0 // use it's value
                    : 1 // else errorcheck_enabled used as flag
                  : 0; // else not set

        str = lr_get_attrib_string("errorcheck_pause_time");
        if (!str) str = lr_get_attrib_string("errorcheck_pause_time_seconds"); // old name
        if (str && (nr = sscanf(str, "%d:%d", &tmp, &tmp2)) > 0) {
            // treat as mm:ss or just seconds
            pause_time = nr == 1 ? tmp: tmp * 60 + tmp2;
        }

        str = lr_get_attrib_string("errorcheck_limit");
        if (str && (nr = sscanf(str, "%u/%u", &tmp, &tmp2)) > 0) {
            pacing_limit = tmp;
            if (nr == 2) abort_limit = tmp2; // abort_limit is optional
        }

        lr_log_message("y_errorcheck() settings: -errorcheck_enabled%s -errorcheck_limit %d/%d -errorcheck_pause_time %u:%02d",
                       enabled ? "": " 0", pacing_limit, abort_limit, pause_time / 60, pause_time % 60);
    }
    
    if (!enabled) return 0;
    
    if (ok) errorcount = 0;
    else 
    {
        if (errorcount >= abort_limit) 
        {
            lr_error_message("y_errorcheck(): Too many errors occurred. Aborting.");
            lr_set_transaction("---TOO MANY ERRORS - ABORTING---", 0, LR_FAIL);
            lr_abort();
        } 

        if (errorcount >= pacing_limit)
        {
            lr_error_message("y_errorcheck(): Too many errors occurred. Pausing %d seconds.", pause_time);
            lr_set_transaction("---TOO MANY ERRORS - THROTTLING LOAD---", 0, LR_FAIL);
            y_pace(pause_time); // Prevents overload in case y_pace() is used in this script.
            lr_force_think_time(pause_time);
        }
        if (errorcount) lr_log_message("Number of failed iterations: %d", errorcount);
        lr_user_data_point( "y_errorcheck_errorcount", errorcount);
        errorcount++;
    }

    return 0; // Adding this function to the run logic has the same effect as y_errorcheck(0); 
}



double y_pace(double pacing_time_in_seconds)
{
    static double test_start_time = 0;               // Test starttime in seconds since 1 jan 1970.
    static double total_pacing_time = 0;             // Running total of requested pacing time.
    double current_time = y_get_current_time();      // Current time, in seconds since 1 jan 1970.

    // Initialisation.
    // On the first call we store the current time as the test start time and the end time of the previous call.
    if( test_start_time < 1 )
    {
        test_start_time = current_time;
    }

    // Debugging
    lr_log_message("Pacing calculation: starttime %f, current time %f, total pacing %d", test_start_time, current_time, total_pacing_time );

    {
        double time_passed = current_time - test_start_time;   // Elapsed time since test start, in seconds. 
        double pacing_delta = total_pacing_time - time_passed; // How much time still needs to pass to get to the full pacing so far.

        lr_user_data_point("y_pace", pacing_delta);
        if( pacing_delta > 0 )
            lr_force_think_time(pacing_delta);

        // Now we finally add the pacing time for the *next* iteration to the total.
        total_pacing_time += pacing_time_in_seconds;

        return pacing_delta;
    }
}
double y_pace_rnd(double min_pacing_time_in_seconds, double max_pacing_time_in_seconds)
{
    return y_pace(min_pacing_time_in_seconds + y_drand() * (max_pacing_time_in_seconds - min_pacing_time_in_seconds);
}


#endif // _LOADRUNNER_UTILS_C