int in_mem_init(struct flb_config *config)
{
int ret;
struct flb_in_mem_config *ctx;
ctx = malloc(sizeof(struct flb_in_mem_config));
if (!ctx) {
return -1;
}
ctx->idx = 0;
msgpack_sbuffer_init(&ctx->sbuf);
msgpack_packer_init(&ctx->pckr, &ctx->sbuf, msgpack_sbuffer_write);
ret = flb_input_set_context("mem", ctx, config);
if (ret == -1) {
flb_utils_error_c("Could not set configuration for "
"memory input plugin");
}
ret = flb_input_set_collector_time("mem",
in_mem_collect,
IN_MEM_COLLECT_SEC,
IN_MEM_COLLECT_NSEC,
config);
if (ret == -1) {
flb_utils_error_c("Could not set collector for memory input plugin");
}
return 0;
}
/* Init serial input */
int in_serial_init(struct flb_config *config)
{
int fd;
int ret;
struct flb_in_serial_config *ctx;
ctx = calloc(1, sizeof(struct flb_in_serial_config));
if (!ctx) {
perror("calloc");
return -1;
}
if (!config->file) {
flb_utils_error_c("serial input plugin needs configuration file");
return -1;
}
serial_config_read(ctx, config->file);
/* set context */
ret = flb_input_set_context("serial", ctx, config);
if (ret == -1) {
flb_utils_error_c("Could not set configuration for"
"serial input plugin");
}
if (ret == -1) {
flb_utils_error_c("Could not set collector for serial input plugin");
}
/* initialize MessagePack buffers */
msgpack_sbuffer_init(&ctx->mp_sbuf);
msgpack_packer_init(&ctx->mp_pck, &ctx->mp_sbuf, msgpack_sbuffer_write);
tcgetattr(fd, &ctx->tio_orig);
memset(&ctx->tio, 0, sizeof(ctx->tio));
ctx->tio.c_cflag = ctx->tio.c_ispeed = ctx->tio.c_ospeed = atoi(ctx->bitrate);
ctx->tio.c_cflag |= CRTSCTS | CS8 | CLOCAL | CREAD;
ctx->tio.c_iflag = IGNPAR | IGNCR;
ctx->tio.c_oflag = 0;
ctx->tio.c_lflag = ICANON;
/* open device */
fd = open(ctx->file, O_RDWR | O_NOCTTY | O_NONBLOCK);
if (fd == -1) {
perror("open");
flb_utils_error_c("Could not open serial port device");
}
ctx->fd = fd;
tcflush(fd, TCIFLUSH);
tcsetattr(fd, TCSANOW, &ctx->tio);
#if __linux__
/* Set our collector based on a file descriptor event */
ret = flb_input_set_collector_event("serial",
in_serial_collect,
ctx->fd,
config);
#else
/* Set our collector based on a timer event */
ret = flb_input_set_collector_time("serial",
in_serial_collect,
IN_SERIAL_COLLECT_SEC,
IN_SERIAL_COLLECT_NSEC,
config);
#endif
return 0;
}
/* Init CPU input */
int in_cpu_init(struct flb_config *config)
{
int i;
int ret;
int len;
double total;
struct flb_in_cpu_config *ctx;
struct cpu_stats *cstats;
struct cpu_snapshot *snap;
/* Allocate space for the configuration */
ctx = malloc(sizeof(struct flb_in_cpu_config));
if (!ctx) {
perror("malloc");
return -1;
}
/* Gather number of processors and CPU ticks */
ctx->n_processors = sysconf(_SC_NPROCESSORS_ONLN);
ctx->cpu_ticks = sysconf(_SC_CLK_TCK);
/* Initialize buffers for CPU stats */
cstats = &ctx->cstats;
cstats->info = malloc(sizeof(struct cpu_snapshot) * (ctx->n_processors + 1));
if (!cstats->info) {
perror("malloc");
return -1;
}
for (i = 1; i <= ctx->n_processors; i++) {
snap = &cstats->info[i];
CPU_KEY_FORMAT(snap, user, i);
CPU_KEY_FORMAT(snap, nice, i);
CPU_KEY_FORMAT(snap, system, i);
CPU_KEY_FORMAT(snap, idle, i);
CPU_KEY_FORMAT(snap, iowait, i);
CPU_KEY_FORMAT(snap, irq, i);
CPU_KEY_FORMAT(snap, softirq, i);
}
/* initialize MessagePack buffers */
msgpack_sbuffer_init(&ctx->mp_sbuf);
msgpack_packer_init(&ctx->mp_pck, &ctx->mp_sbuf, msgpack_sbuffer_write);
/* Get CPU load, ready to be updated once fired the calc callback */
total = proc_cpu_load(ctx->n_processors, &ctx->cstats);
if (total == -1) {
flb_utils_error_c("Could not obtain CPU data");
}
ctx->cstats.load_pre = total;
/* Set the context */
ret = flb_input_set_context("cpu", ctx, config);
if (ret == -1) {
flb_utils_error_c("Could not set configuration for CPU input plugin");
}
/* Set our collector based on time, CPU usage every 1 second */
ret = flb_input_set_collector_time("cpu",
in_cpu_collect,
IN_CPU_COLLECT_SEC,
IN_CPU_COLLECT_NSEC,
config);
if (ret == -1) {
flb_utils_error_c("Could not set collector for CPU input plugin");
}
return 0;
}
/* Init kmsg input */
int in_xbee_init(struct flb_config *config)
{
int ret;
int opt_baudrate = 9600;
char *tmp;
char *opt_device = FLB_XBEE_DEFAULT_DEVICE;
struct stat dev_st;
struct xbee *xbee;
struct xbee_con *con;
struct xbee_conAddress address;
struct flb_in_xbee_config *ctx;
/* Check an optional baudrate */
tmp = getenv("FLB_XBEE_BAUDRATE");
if (tmp) {
opt_baudrate = atoi(tmp);
}
/* Get the target device entry */
tmp = getenv("FLB_XBEE_DEVICE");
if (tmp) {
opt_device = strdup(tmp);
}
flb_info("XBee device=%s, baudrate=%i", opt_device, opt_baudrate);
ret = stat(opt_device, &dev_st);
if (ret < 0) {
printf("Error: could not open %s device\n", opt_device);
exit(EXIT_FAILURE);
}
if (!S_ISCHR(dev_st.st_mode)) {
printf("Error: invalid device %s \n", opt_device);
exit(EXIT_FAILURE);
}
if (access(opt_device, R_OK | W_OK) == -1) {
printf("Error: cannot open the device %s (permission denied ?)\n",
opt_device);
exit(EXIT_FAILURE);
}
/* Init library */
xbee_init();
ret = xbee_setup(&xbee, "xbeeZB", opt_device, opt_baudrate);
if (ret != XBEE_ENONE) {
flb_utils_error_c("xbee_setup");
return ret;
}
/* FIXME: just a built-in example */
memset(&address, 0, sizeof(address));
address.addr64_enabled = 1;
address.addr64[0] = 0x00;
address.addr64[1] = 0x13;
address.addr64[2] = 0xA2;
address.addr64[3] = 0x00;
address.addr64[4] = 0x40;
address.addr64[5] = 0xB7;
address.addr64[6] = 0xB1;
address.addr64[7] = 0xEB;
/* Prepare a connection with the peer XBee */
if ((ret = xbee_conNew(xbee, &con, "Data", &address)) != XBEE_ENONE) {
xbee_log(xbee, -1, "xbee_conNew() returned: %d (%s)", ret, xbee_errorToStr(ret));
return ret;
}
/* Prepare the configuration context */
ctx = calloc(1, sizeof(struct flb_in_xbee_config));
if (!ctx) {
perror("calloc");
return -1;
}
ctx->device = opt_device;
ctx->baudrate = opt_baudrate;
ctx->con = con;
ctx->buffer_len = 0;
if ((ret = xbee_conDataSet(con, ctx, NULL)) != XBEE_ENONE) {
xbee_log(xbee, -1, "xbee_conDataSet() returned: %d", ret);
return ret;
}
if ((ret = xbee_conCallbackSet(con, in_xbee_cb, NULL)) != XBEE_ENONE) {
xbee_log(xbee, -1, "xbee_conCallbackSet() returned: %d", ret);
return ret;
}
/* Set the context */
ret = flb_input_set_context("xbee", ctx, config);
if (ret == -1) {
flb_utils_error_c("Could not set configuration for xbee input plugin");
}
/*
* Set our collector based on time. We will trigger a collection at certain
* intervals. For now it works but it's not the ideal implementation. I am
* talking with libxbee maintainer to check possible workarounds and use
* proper events mechanism.
*/
ret = flb_input_set_collector_time("xbee",
in_xbee_collect,
IN_XBEE_COLLECT_SEC,
IN_XBEE_COLLECT_NSEC,
config);
if (ret == -1) {
flb_utils_error_c("Could not set collector for xbee input plugin");
}
return 0;
}
/* Init serial input */
int in_serial_init(struct flb_input_instance *in,
struct flb_config *config, void *data)
{
int fd;
int ret;
int br;
struct flb_in_serial_config *ctx;
(void) data;
ctx = calloc(1, sizeof(struct flb_in_serial_config));
if (!ctx) {
perror("calloc");
return -1;
}
if (!serial_config_read(ctx, in)) {
return -1;
}
/* set context */
flb_input_set_context(in, ctx);
/* initialize MessagePack buffers */
msgpack_sbuffer_init(&ctx->mp_sbuf);
msgpack_packer_init(&ctx->mp_pck, &ctx->mp_sbuf, msgpack_sbuffer_write);
/* open device */
fd = open(ctx->file, O_RDWR | O_NOCTTY | O_NONBLOCK);
if (fd == -1) {
perror("open");
flb_utils_error_c("Could not open serial port device");
}
ctx->fd = fd;
/* Store original settings */
tcgetattr(fd, &ctx->tio_orig);
/* Reset for new... */
memset(&ctx->tio, 0, sizeof(ctx->tio));
tcgetattr(fd, &ctx->tio);
br = atoi(ctx->bitrate);
cfsetospeed(&ctx->tio, (speed_t) flb_serial_speed(br));
cfsetispeed(&ctx->tio, (speed_t) flb_serial_speed(br));
/* Settings */
ctx->tio.c_cflag &= ~PARENB; /* 8N1 */
ctx->tio.c_cflag &= ~CSTOPB;
ctx->tio.c_cflag &= ~CSIZE;
ctx->tio.c_cflag |= CS8;
ctx->tio.c_cflag &= ~CRTSCTS; /* No flow control */
ctx->tio.c_cc[VMIN] = ctx->min_bytes; /* Min number of bytes to read */
ctx->tio.c_cflag |= CREAD | CLOCAL; /* Enable READ & ign ctrl lines */
tcflush(fd, TCIFLUSH);
tcsetattr(fd, TCSANOW, &ctx->tio);
#if __linux__
/* Set our collector based on a file descriptor event */
ret = flb_input_set_collector_event(in,
in_serial_collect,
ctx->fd,
config);
#else
/* Set our collector based on a timer event */
ret = flb_input_set_collector_time(in,
in_serial_collect,
IN_SERIAL_COLLECT_SEC,
IN_SERIAL_COLLECT_NSEC,
config);
#endif
return ret;
}
