rl_server.c

Go to the documentation of this file.

#include <libgen.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/statvfs.h>

#include "rl_lib.h"
#include "rl_util.h"
#include "sem.h"
#include "web.h"

#define ARG_COUNT 4
#define MAX_STRING_LENGTH 150
#define MAX_STRING_VALUE 20
#define TIME_MARGIN 10

// Global variables
int sem_id;
struct web_shm* web_data;

uint32_t id;
uint8_t get_data;
uint32_t t_scale;
int64_t last_time;
int64_t curr_time;
int8_t num_channels;

struct rl_status status;

int buffer_sizes[WEB_RING_BUFFER_COUNT] = {BUFFER1_SIZE, BUFFER10_SIZE,
                                           BUFFER100_SIZE};

// functions
int64_t get_free_space(char* path) {

    struct statvfs stat;
    statvfs(path, &stat);

    return (uint64_t)stat.f_bavail * (uint64_t)stat.f_bsize;
}

void print_json_32(int32_t data[], int length) {
    char str[MAX_STRING_LENGTH];
    char val[MAX_STRING_VALUE];
    int i;
    sprintf(str, "[\"%d\"", data[0]);
    for (i = 1; i < length; i++) {
        sprintf(val, ",\"%d\"", data[i]);
        strcat(str, val);
    }
    strcat(str, "]\n");
    printf("%s", str);
}

void print_json_64(int64_t data[], int length) {
    char str[MAX_STRING_LENGTH];
    char val[MAX_STRING_VALUE];
    int i;
    sprintf(str, "[\"%lld\"", data[0]);
    for (i = 1; i < length; i++) {
        sprintf(val, ",\"%lld\"", data[i]);
        strcat(str, val);
    }
    strcat(str, "]\n");
    printf("%s", str);
}

void print_status(void) {
    // STATUS
    printf("%d\n", status.state);
    if (status.state != RL_RUNNING) {
        read_default_config(&status.conf);

        // read calibration time
        struct rl_calibration tmp_calibration;
        rl_read_calibration(&tmp_calibration, &status.conf);
        status.calibration_time = tmp_calibration.time;
    }
    // copy of filename (for dirname)
    char file_name_copy[MAX_PATH_LENGTH];
    strcpy(file_name_copy, status.conf.file_name);
    printf("%llu\n", get_free_space(dirname(file_name_copy)));
    printf("%llu\n", status.calibration_time);

    // CONFIG
    printf("%d\n", status.conf.sample_rate);
    printf("%d\n", status.conf.update_rate);
    printf("%d\n", status.conf.digital_inputs);
    printf("%d\n", status.conf.calibration);
    printf("%d\n", status.conf.file_format);
    printf("%s\n", status.conf.file_name);
    printf("%llu\n", status.conf.max_file_size);
    print_json_32(status.conf.channels, NUM_CHANNELS);
    print_json_32(status.conf.force_high_channels, NUM_I_CHANNELS);
    printf("%llu\n", status.samples_taken);
    printf("%d\n", status.conf.enable_web_server);
}

void print_data(void) {

    // print data length
    int buffer_count = (curr_time - last_time + TIME_MARGIN) / 1000;

    // get available buffers
    if (wait_sem(sem_id, DATA_SEM, SEM_TIME_OUT) != SUCCESS) {
        return;
    }
    int buffer_available = web_data->buffer[t_scale].filled;
    set_sem(sem_id, DATA_SEM, 1);

    if (buffer_count > buffer_available) {
        buffer_count = buffer_available;
    }

    int buffer_size = buffer_sizes[t_scale];

    // print request id and status
    printf("%d\n", id);
    print_status();

    // data available
    printf("1\n");

    // print time scale
    printf("%d\n", t_scale);

    // print time
    printf("%lld\n", curr_time);

    // print buffer information
    printf("%d\n", buffer_count);
    printf("%d\n", buffer_size);

    // read data
    int64_t data[buffer_count][buffer_size][num_channels];
    int i;

    if (wait_sem(sem_id, DATA_SEM, SEM_TIME_OUT) != SUCCESS) {
        return;
    }
    for (i = 0; i < buffer_count; i++) {

        // read data buffer
        int64_t* shm_data = web_buffer_get(&web_data->buffer[t_scale], i);
        if (web_data->buffer[t_scale].element_size > sizeof(data)) {
            rl_log(ERROR,
                   "In print_data: memcpy is trying to copy to much data.");
            break;
        } else {
            memcpy(&data[i][0][0], shm_data,
                   web_data->buffer[t_scale].element_size);
        }
    }
    set_sem(sem_id, DATA_SEM, 1);

    // print data
    for (i = buffer_count - 1; i >= 0; i--) {
        int j;
        for (j = 0; j < buffer_size; j++) {
            print_json_64(data[i][j], num_channels);
        }
    }
}

int main(int argc, char* argv[]) {

    // parse arguments
    if (argc != ARG_COUNT + 1) {
        rl_log(ERROR, "in rl_server: not enough arguments");
        exit(FAILURE);
    }
    id = atoi(argv[1]);
    get_data = atoi(argv[2]);
    t_scale = atoi(argv[3]);
    last_time = atoll(argv[4]);

    // check time scale
    if (t_scale != S1 && t_scale != S10 && t_scale != S100) {
        rl_log(WARNING, "unknown time scale");
        t_scale = S1;
    }

    // get status
    rl_read_status(&status);

    // quit, if data not requested or not running or web disabled
    if (status.state != RL_RUNNING || status.sampling == SAMPLING_OFF ||
        status.conf.enable_web_server == 0 || get_data == 0) {
        // print request id and status
        printf("%d\n", id);
        print_status();
        printf("0\n"); // no data available
        exit(EXIT_SUCCESS);
    }

    // open semaphore
    sem_id = open_sem(SEM_KEY, NUM_SEMS);
    if (sem_id < 0) {
        // error already logged
        exit(EXIT_FAILURE);
    }

    // open shared memory
    web_data = web_open_shm();

    // fetch data
    uint8_t data_read = 0;
    while (data_read == 0) {

        // get current time
        if (wait_sem(sem_id, DATA_SEM, SEM_TIME_OUT) != SUCCESS) {
            exit(EXIT_FAILURE);
        }
        curr_time = web_data->time;
        num_channels = web_data->num_channels;
        set_sem(sem_id, DATA_SEM, 1);

        if (curr_time > last_time) {

            // re-read status
            rl_read_status(&status);

            // read and print data
            print_data();

            data_read = 1;
        } else {

            if (last_time > curr_time) {
                // assume outdated time stamp
                last_time = 0;
            }

            // wait on new data
            if (data_read == 0) {
                if (wait_sem(sem_id, WAIT_SEM, SEM_TIME_OUT) != SUCCESS) {
                    // time-out or error -> stop
                    break;
                }
            }
        }
    }

    // unmap shared memory
    shmdt(web_data);

    exit(EXIT_SUCCESS);
}