/**
* Invoked by the networking layer when there is new
* data to be handled. The connection handler should
* consume all the input possible, and generate responses
* to all requests.
* @arg handle The connection related information
* @return 0 on success.
*/
int handle_client_connect(statsite_conn_handler *handle) {
// Look for the next command line
char *buf, *key, *val_str, *type_str, *endptr;
metric_type type;
int buf_len, should_free, status, i, after_len;
double val;
while (1) {
status = extract_to_terminator(handle->conn, '\n', &buf, &buf_len, &should_free);
if (status == -1) return 0; // Return if no command is available
// Check for a valid metric
// Scan for the colon
status = buffer_after_terminator(buf, buf_len, ':', &val_str, &after_len);
if (!status) status |= buffer_after_terminator(val_str, after_len, '|', &type_str, &after_len);
if (status == 0) {
// Convert the type
switch (*type_str) {
case 'c':
type = COUNTER;
break;
case 'm':
type = TIMER;
break;
case 'k':
type = KEY_VAL;
break;
default:
type = UNKNOWN;
}
// Convert the value to a double
endptr = NULL;
val = strtod(val_str, &endptr);
// Store the sample if we did the conversion
if (val != 0 || endptr != val_str) {
metrics_add_sample(GLOBAL_METRICS, type, buf, val);
} else {
syslog(LOG_WARNING, "Failed value conversion! Input: %s", val_str);
}
} else {
syslog(LOG_WARNING, "Failed parse metric! Input: %s", buf);
}
// Make sure to free the command buffer if we need to
if (should_free) free(buf);
}
return 0;
}
// Handles the binary set command
// Return 0 on success, -1 on error, -2 if missing data
static int handle_binary_set(statsite_conn_handler *handle, uint16_t *header, int should_free) {
/*
* Abort if we haven't received the command
* header[1] is the key length
* header[2] is the set length
*/
char *key;
int val_bytes = header[1] + header[2];
// Read the full command if available
if (unlikely(should_free)) free(header);
if (read_client_bytes(handle->conn, MIN_BINARY_HEADER_SIZE + val_bytes, (char**)&header, &should_free))
return -2;
key = ((char*)header) + MIN_BINARY_HEADER_SIZE;
// Verify the null terminators
if (unlikely(*(key + header[1] - 1))) {
syslog(LOG_WARNING, "Received command from binary stream with non-null terminated key: %.*s!", header[1], key);
goto ERR_RET;
}
if (unlikely(*(key + val_bytes - 1))) {
syslog(LOG_WARNING, "Received command from binary stream with non-null terminated set key: %.*s!", header[2], key+header[1]);
goto ERR_RET;
}
// Increment the input counter
if (GLOBAL_CONFIG->input_counter)
metrics_add_sample(GLOBAL_METRICS, COUNTER, GLOBAL_CONFIG->input_counter, 1);
// Update the set
metrics_set_update(GLOBAL_METRICS, key, key+header[1]);
// Make sure to free the command buffer if we need to
if (unlikely(should_free)) free(header);
return 0;
ERR_RET:
if (unlikely(should_free)) free(header);
return -1;
}
/**
* Invoked to handle binary commands.
* @arg handle The connection related information
* @return 0 on success.
*/
static int handle_binary_client_connect(statsite_conn_handler *handle) {
metric_type type;
uint16_t key_len;
int should_free;
unsigned char *cmd, *key;
while (1) {
// Peek and check for the header. This is up to 12 bytes.
// Magic byte - 1 byte
// Metric type - 1 byte
// Key length - 2 bytes
// Metric value - 8 bytes OR Set Length 2 bytes
if (peek_client_bytes(handle->conn, MIN_BINARY_HEADER_SIZE, (char**)&cmd, &should_free))
return 0; // Return if no command is available
// Check for the magic byte
if (unlikely(cmd[0] != BINARY_MAGIC_BYTE)) {
syslog(LOG_WARNING, "Received command from binary stream without magic byte! Byte: %u", cmd[0]);
goto ERR_RET;
}
// Get the metric type
switch (cmd[1]) {
case BIN_TYPE_KV:
type = KEY_VAL;
break;
case BIN_TYPE_COUNTER:
type = COUNTER;
break;
case BIN_TYPE_TIMER:
type = TIMER;
break;
case BIN_TYPE_GAUGE:
type = GAUGE;
break;
case BIN_TYPE_GAUGE_DELTA:
type = GAUGE_DELTA;
break;
// Special case set handling
case BIN_TYPE_SET:
switch (handle_binary_set(handle, (uint16_t*)cmd, should_free)) {
case -1:
return -1;
case -2:
return 0;
default:
continue;
}
default:
syslog(LOG_WARNING, "Received command from binary stream with unknown type: %u!", cmd[1]);
goto ERR_RET;
}
// Abort if we haven't received the full key, wait for the data
key_len = *(uint16_t*)(cmd+2);
// Read the full command if available
if (unlikely(should_free)) free(cmd);
if (read_client_bytes(handle->conn, MAX_BINARY_HEADER_SIZE + key_len, (char**)&cmd, &should_free))
return 0;
key = cmd + MAX_BINARY_HEADER_SIZE;
// Verify the key contains a null terminator
if (unlikely(*(key + key_len - 1))) {
syslog(LOG_WARNING, "Received command from binary stream with non-null terminated key: %.*s!", key_len, key);
goto ERR_RET;
}
// Increment the input counter
if (GLOBAL_CONFIG->input_counter)
metrics_add_sample(GLOBAL_METRICS, COUNTER, GLOBAL_CONFIG->input_counter, 1);
// Add the sample
metrics_add_sample(GLOBAL_METRICS, type, key, *(double*)(cmd+4));
// Make sure to free the command buffer if we need to
if (unlikely(should_free)) free(cmd);
}
return 0;
ERR_RET:
if (unlikely(should_free)) free(cmd);
return -1;
}
/**
* Invoked to handle ASCII commands. This is the default
* mode for statsite, to be backwards compatible with statsd
* @arg handle The connection related information
* @return 0 on success.
*/
static int handle_ascii_client_connect(statsite_conn_handler *handle) {
// Look for the next command line
char *buf, *key, *val_str, *type_str, *sample_str, *endptr;
metric_type type;
int buf_len, should_free, status, i, after_len;
double val, sample_rate;
while (1) {
status = extract_to_terminator(handle->conn, '\n', &buf, &buf_len, &should_free);
if (status == -1) return 0; // Return if no command is available
// Check for a valid metric
// Scan for the colon
status = buffer_after_terminator(buf, buf_len, ':', &val_str, &after_len);
if (likely(!status)) status |= buffer_after_terminator(val_str, after_len, '|', &type_str, &after_len);
if (unlikely(status)) {
syslog(LOG_WARNING, "Failed parse metric! Input: %s", buf);
goto ERR_RET;
}
// Convert the type
switch (*type_str) {
case 'c':
type = COUNTER;
break;
case 'm':
type = TIMER;
break;
case 'k':
type = KEY_VAL;
break;
case 'g':
type = GAUGE;
// Check if this is a delta update
switch (*val_str) {
case '+':
// Advance past the + to avoid breaking str2double
val_str++;
case '-':
type = GAUGE_DELTA;
}
break;
case 's':
type = SET;
break;
default:
type = UNKNOWN;
syslog(LOG_WARNING, "Received unknown metric type! Input: %c", *type_str);
goto ERR_RET;
}
// Increment the number of inputs received
if (GLOBAL_CONFIG->input_counter)
metrics_add_sample(GLOBAL_METRICS, COUNTER, GLOBAL_CONFIG->input_counter, 1);
// Fast track the set-updates
if (type == SET) {
metrics_set_update(GLOBAL_METRICS, buf, val_str);
goto END_LOOP;
}
// Convert the value to a double
val = str2double(val_str, &endptr);
if (unlikely(endptr == val_str)) {
syslog(LOG_WARNING, "Failed value conversion! Input: %s", val_str);
goto ERR_RET;
}
// Handle counter sampling if applicable
if (type == COUNTER && !buffer_after_terminator(type_str, after_len, '@', &sample_str, &after_len)) {
sample_rate = str2double(sample_str, &endptr);
if (unlikely(endptr == sample_str)) {
syslog(LOG_WARNING, "Failed sample rate conversion! Input: %s", sample_str);
goto ERR_RET;
}
if (sample_rate > 0 && sample_rate <= 1) {
// Magnify the value
val = val * (1.0 / sample_rate);
}
}
// Store the sample
metrics_add_sample(GLOBAL_METRICS, type, buf, val);
END_LOOP:
// Make sure to free the command buffer if we need to
if (should_free) free(buf);
}
return 0;
ERR_RET:
if (should_free) free(buf);
return -1;
}