/**
* Sort comparator for ch_ring_entry structs on pos, ip and port.
*/
static int
entrycmp_fnv1a(const void *l, const void *r)
{
ch_ring_entry *ch_l = (ch_ring_entry *)l;
ch_ring_entry *ch_r = (ch_ring_entry *)r;
if (ch_l->pos != ch_r->pos)
return ch_l->pos - ch_r->pos;
#ifndef CH_CMP_V40_BEHAVIOUR
{
int d = strcmp(server_ip(ch_l->server), server_ip(ch_r->server));
if (d != 0)
return d;
return server_port(ch_l->server) - server_port(ch_r->server);
}
#endif
return 0;
}
static void *
collector_writer(void *unused)
{
int i = 0;
size_t queued;
size_t queuesize;
double queueusage;
size_t totdropped;
size_t numaggregators = aggregator_numaggregators();
server **srvs = NULL;
while (keep_running) {
if (cluster_refresh_pending) {
server **newservers = router_getservers(pending_clusters);
if (srvs != NULL)
free(srvs);
srvs = newservers;
cluster_refresh_pending = 0;
}
assert(srvs != NULL);
sleep(1);
i++;
if (i < collector_interval)
continue;
totdropped = 0;
for (i = 0; srvs[i] != NULL; i++) {
queued = server_get_queue_len(srvs[i]);
queuesize = server_get_queue_size(srvs[i]);
totdropped += server_get_dropped(srvs[i]);
queueusage = (double)queued / (double)queuesize;
if (queueusage >= 0.75)
logout("warning: metrics queuing up "
"for %s:%u: %zd metrics (%d%% of queue size)\n",
server_ip(srvs[i]), server_port(srvs[i]), queued,
(int)(queueusage * 100));
}
if (totdropped - lastdropped > 0)
logout("warning: dropped %zd metrics\n", totdropped - lastdropped);
lastdropped = totdropped;
if (numaggregators > 0) {
totdropped = aggregator_get_dropped();
if (totdropped - lastaggrdropped > 0)
logout("warning: aggregator dropped %zd metrics\n",
totdropped - lastaggrdropped);
lastaggrdropped = totdropped;
}
i = 0;
}
return NULL;
}
std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> ServerPort::CreatePortPair(
u32 max_sessions, std::string name) {
SharedPtr<ServerPort> server_port(new ServerPort);
SharedPtr<ClientPort> client_port(new ClientPort);
server_port->name = name + "_Server";
client_port->name = name + "_Client";
client_port->server_port = server_port;
client_port->max_sessions = max_sessions;
client_port->active_sessions = 0;
return std::make_tuple(std::move(server_port), std::move(client_port));
}
/*
* Connects to specified server(s)
* - @servers_count: the number of servers to be connected to
* - @servers: a vector of Connection objects (for ip, port, pub_id)
*/
void Communication::Connect(int servers_count, std::vector<Connection> servers)
{
// connect with the server(s)
for (int i=0; i<servers_count; i++)
{
boost::shared_ptr<boost::asio::ip::tcp::socket> sock(new boost::asio::ip::tcp::socket(*io_service_));
// get the pub from the options
Connection con = servers[i];
boost::shared_ptr<std::string> server_name(new std::string(con.pub_id));
boost::shared_ptr<std::string> server_ip(new std::string(con.ip));
boost::shared_ptr<std::string> server_port(new std::string(con.port));
try
{
// try to connect
boost::asio::ip::tcp::resolver resolver(*io_service_);
boost::asio::ip::tcp::resolver::query query(con.ip, con.port);
boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
boost::asio::ip::tcp::endpoint endpoint = *iterator;
sock->async_connect(endpoint,
boost::bind(&Communication::AddServer,
this,
boost::asio::placeholders::error(),
sock,
endpoint,
server_name,
server_ip,
server_port));
std::cout << "[" << boost::this_thread::get_id()
<< "] Connecting to: " << endpoint << std::endl;
}
// catch any exception
catch (std::exception & ex)
{
std::cout << "[" << boost::this_thread::get_id()
<< "] Exception: " << ex.what() << std::endl;
}
}
}
void
ch_printhashring(ch_ring *ring, FILE *f)
{
ch_ring_entry *w;
char column = 0;
char srvbuf[21];
for (w = ring->entries; w != NULL; w = w->next) {
snprintf(srvbuf, sizeof(srvbuf), "%s:%d%s%s",
server_ip(w->server),
server_port(w->server),
server_instance(w->server) ? "=" : "",
server_instance(w->server) ? server_instance(w->server) : "");
fprintf(f, "%5d@%-20s", w->pos, srvbuf);
if (column < 2) {
fprintf(f, " ");
column++;
} else {
fprintf(f, "\n");
column = 0;
}
}
}
/**
* Collects metrics from dispatchers and servers and emits them.
*/
static void *
collector_runner(void *s)
{
int i;
size_t totticks;
size_t totmetrics;
size_t totblackholes;
size_t totqueued;
size_t totstalls;
size_t totdropped;
size_t totsleeps;
size_t ticks;
size_t metrics;
size_t blackholes;
size_t queued;
size_t stalls;
size_t dropped;
size_t sleeps;
time_t now;
time_t nextcycle;
char destbuf[1024]; /* sort of POSIX_MAX_PATH */
char *p;
size_t numaggregators = 0;
aggregator *aggrs = NULL;
server *submission = (server *)s;
server **srvs = NULL;
char metric[METRIC_BUFSIZ];
char *m = NULL;
size_t sizem = 0;
size_t (*s_ticks)(server *);
size_t (*s_metrics)(server *);
size_t (*s_stalls)(server *);
size_t (*s_dropped)(server *);
size_t (*d_ticks)(dispatcher *);
size_t (*d_metrics)(dispatcher *);
size_t (*d_blackholes)(dispatcher *);
size_t (*d_sleeps)(dispatcher *);
size_t (*a_received)(aggregator *);
size_t (*a_sent)(aggregator *);
size_t (*a_dropped)(aggregator *);
/* setup functions to target what the user wants */
if (debug & 2) {
s_ticks = server_get_ticks_sub;
s_metrics = server_get_metrics_sub;
s_stalls = server_get_stalls_sub;
s_dropped = server_get_dropped_sub;
d_ticks = dispatch_get_ticks_sub;
d_metrics = dispatch_get_metrics_sub;
d_blackholes = dispatch_get_blackholes_sub;
d_sleeps = dispatch_get_sleeps_sub;
a_received = aggregator_get_received_sub;
a_sent = aggregator_get_sent_sub;
a_dropped = aggregator_get_dropped_sub;
} else {
s_ticks = server_get_ticks;
s_metrics = server_get_metrics;
s_stalls = server_get_stalls;
s_dropped = server_get_dropped;
d_ticks = dispatch_get_ticks;
d_metrics = dispatch_get_metrics;
d_blackholes = dispatch_get_blackholes;
d_sleeps = dispatch_get_sleeps;
a_received = aggregator_get_received;
a_sent = aggregator_get_sent;
a_dropped = aggregator_get_dropped;
}
#define send(metric) \
if (debug & 1) \
logout("%s", metric); \
else \
server_send(submission, strdup(metric), 1);
nextcycle = time(NULL) + collector_interval;
while (keep_running) {
if (cluster_refresh_pending) {
char *stub = router_getcollectorstub(pending_router);
server **newservers = router_getservers(pending_router);
if (srvs != NULL)
free(srvs);
srvs = newservers;
aggrs = router_getaggregators(pending_router);
numaggregators = aggregator_numaggregators(aggrs);
/* prepare hostname for graphite metrics */
snprintf(metric, sizeof(metric), "%scarbon.relays.%s",
stub == NULL ? "" : stub, relay_hostname);
for (m = metric + strlen("carbon.relays."); *m != '\0'; m++)
if (*m == '.')
*m = '_';
*m++ = '.';
*m = '\0';
sizem = sizeof(metric) - (m - metric);
cluster_refresh_pending = 0;
}
assert(srvs != NULL);
sleep(1);
now = time(NULL);
if (nextcycle > now)
continue;
nextcycle += collector_interval;
totticks = 0;
totmetrics = 0;
totblackholes = 0;
totsleeps = 0;
for (i = 0; dispatchers[i] != NULL; i++) {
totsleeps += sleeps = d_sleeps(dispatchers[i]);
totticks += ticks = d_ticks(dispatchers[i]);
totmetrics += metrics = d_metrics(dispatchers[i]);
totblackholes += blackholes = d_blackholes(dispatchers[i]);
snprintf(m, sizem, "dispatcher%d.metricsReceived %zu %zu\n",
i + 1, metrics, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatcher%d.metricsBlackholed %zu %zu\n",
i + 1, blackholes, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatcher%d.wallTime_us %zu %zu\n",
i + 1, ticks, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatcher%d.sleepTime_us %zu %zu\n",
i + 1, sleeps, (size_t)now);
send(metric);
}
snprintf(m, sizem, "metricsReceived %zu %zu\n",
totmetrics, (size_t)now);
send(metric);
snprintf(m, sizem, "metricsBlackholed %zu %zu\n",
totblackholes, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatch_wallTime_us %zu %zu\n",
totticks, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatch_sleepTime_us %zu %zu\n",
totsleeps, (size_t)now);
send(metric);
#define send_server_metrics(ipbuf, ticks, metrics, queued, stalls, dropped) \
snprintf(m, sizem, "destinations.%s.sent %zu %zu\n", \
ipbuf, metrics, (size_t)now); \
send(metric); \
snprintf(m, sizem, "destinations.%s.queued %zu %zu\n", \
ipbuf, queued, (size_t)now); \
send(metric); \
snprintf(m, sizem, "destinations.%s.stalls %zu %zu\n", \
ipbuf, stalls, (size_t)now); \
send(metric); \
snprintf(m, sizem, "destinations.%s.dropped %zu %zu\n", \
ipbuf, dropped, (size_t)now); \
send(metric); \
snprintf(m, sizem, "destinations.%s.wallTime_us %zu %zu\n", \
ipbuf, ticks, (size_t)now); \
send(metric);
totticks = 0;
totmetrics = 0;
totqueued = 0;
totstalls = 0;
totdropped = 0;
/* exclude internal_submission metrics from the totals to avoid
* artificial doubles due to internal routing details */
ticks = s_ticks(submission);
metrics = s_metrics(submission);
queued = server_get_queue_len(submission);
stalls = s_stalls(submission);
dropped = s_dropped(submission);
send_server_metrics(server_ip(submission),
ticks, metrics, queued, stalls, dropped);
for (i = 0; srvs[i] != NULL; i++) {
switch (server_ctype(srvs[i])) {
case CON_FILE:
case CON_PIPE:
snprintf(destbuf, sizeof(destbuf), "%s",
server_ip(srvs[i]));
break;
case CON_TCP:
snprintf(destbuf, sizeof(destbuf), "%s:%u",
server_ip(srvs[i]), server_port(srvs[i]));
break;
case CON_UDP:
snprintf(destbuf, sizeof(destbuf), "%s:%u-udp",
server_ip(srvs[i]), server_port(srvs[i]));
break;
}
for (p = destbuf; *p != '\0'; p++)
if (*p == '.')
*p = '_';
totticks += ticks = s_ticks(srvs[i]);
totmetrics += metrics = s_metrics(srvs[i]);
totqueued += queued = server_get_queue_len(srvs[i]);
totstalls += stalls = s_stalls(srvs[i]);
totdropped += dropped = s_dropped(srvs[i]);
send_server_metrics(destbuf,
ticks, metrics, queued, stalls, dropped);
}
snprintf(m, sizem, "metricsSent %zu %zu\n",
totmetrics, (size_t)now);
send(metric);
snprintf(m, sizem, "metricsQueued %zu %zu\n",
totqueued, (size_t)now);
send(metric);
snprintf(m, sizem, "metricStalls %zu %zu\n",
totstalls, (size_t)now);
send(metric);
snprintf(m, sizem, "metricsDropped %zu %zu\n",
totdropped, (size_t)now);
send(metric);
snprintf(m, sizem, "server_wallTime_us %zu %zu\n",
totticks, (size_t)now);
send(metric);
snprintf(m, sizem, "connections %zu %zu\n",
dispatch_get_accepted_connections(), (size_t)now);
send(metric);
snprintf(m, sizem, "disconnects %zu %zu\n",
dispatch_get_closed_connections(), (size_t)now);
send(metric);
if (numaggregators > 0) {
snprintf(m, sizem, "aggregators.metricsReceived %zu %zu\n",
a_received(aggrs), (size_t)now);
send(metric);
snprintf(m, sizem, "aggregators.metricsSent %zu %zu\n",
a_sent(aggrs), (size_t)now);
send(metric);
snprintf(m, sizem, "aggregators.metricsDropped %zu %zu\n",
a_dropped(aggrs), (size_t)now);
send(metric);
}
if (debug & 1)
fflush(stdout);
}
if (srvs != NULL)
free(srvs);
return NULL;
}
static void *
collector_writer(void *unused)
{
int i = 0;
size_t queued;
size_t queuesize;
double queueusage;
size_t totdropped;
size_t lastconn = 0;
size_t lastdisc = 0;
size_t numaggregators = 0;
server **srvs = NULL;
aggregator *aggrs = NULL;
while (keep_running) {
if (cluster_refresh_pending) {
server **newservers = router_getservers(pending_router);
if (srvs != NULL)
free(srvs);
srvs = newservers;
aggrs = router_getaggregators(pending_router);
numaggregators = aggregator_numaggregators(aggrs);
cluster_refresh_pending = 0;
}
assert(srvs != NULL);
sleep(1);
if (debug & 1) {
size_t mpsout;
size_t totout;
size_t mpsdrop;
size_t totdrop;
size_t totqueue;
size_t mpsin;
size_t totin;
size_t totconn;
size_t totdisc;
size_t dticks;
size_t dsleeps;
int j;
/* Solaris iostat like output:
metrics in metrics out metrics drop queue conns disconn workr
mps tot mps tot dps tot cur cps tot dps tot act
99999 9999999 99999 9999999 99999 9999999 99999 999 99999 999 99999 99%
*/
if (i % 24 == 0)
printf(" metrics in metrics out metrics drop queue conns disconn workr\n"
" mps tot mps tot dps tot cur cps tot dps tot act\n");
mpsout = totout = 0;
mpsdrop = totdrop = 0;
totqueue = 0;
for (j = 0; srvs[j] != NULL; j++) {
mpsout += server_get_metrics_sub(srvs[j]);
totout += server_get_metrics(srvs[j]);
mpsdrop += server_get_dropped_sub(srvs[j]);
totdrop += server_get_dropped(srvs[j]);
totqueue += server_get_queue_len(srvs[j]);
}
mpsin = totin = 0;
dticks = dsleeps = 0;
for (j = 0; dispatchers[j] != NULL; j++) {
mpsin += dispatch_get_metrics_sub(dispatchers[j]);
totin += dispatch_get_metrics(dispatchers[j]);
dticks += dispatch_get_ticks_sub(dispatchers[j]);
dsleeps += dispatch_get_sleeps_sub(dispatchers[j]);
}
totconn = dispatch_get_accepted_connections();
totdisc = dispatch_get_closed_connections();
printf("%5zu %7zu " /* metrics in */
"%5zu %7zu " /* metrics out */
"%5zu %7zu " /* metrics dropped */
"%5zu " /* queue */
"%3zu %5zu " /* conns */
"%3zu %5zu " /* disconns */
"%2d%%\n", /* workers */
mpsin, totin,
mpsout, totout,
mpsdrop, totdrop,
totqueue,
totconn - lastconn, totconn,
totdisc - lastdisc, totdisc,
(int)(((double)dticks * 100.0) / (double)(dticks + dsleeps))
);
lastconn = totconn;
lastdisc = totdisc;
}
i++;
if (i < collector_interval)
continue;
totdropped = 0;
for (i = 0; srvs[i] != NULL; i++) {
queued = server_get_queue_len(srvs[i]);
queuesize = server_get_queue_size(srvs[i]);
totdropped += server_get_dropped(srvs[i]);
queueusage = (double)queued / (double)queuesize;
if (queueusage >= 0.75)
logout("warning: metrics queuing up "
"for %s:%u: %zu metrics (%d%% of queue size)\n",
server_ip(srvs[i]), server_port(srvs[i]), queued,
(int)(queueusage * 100));
}
if (totdropped - lastdropped > 0)
logout("warning: dropped %zu metrics\n", totdropped - lastdropped);
lastdropped = totdropped;
if (numaggregators > 0) {
totdropped = aggregator_get_dropped(aggrs);
if (totdropped - lastaggrdropped > 0)
logout("warning: aggregator dropped %zu metrics\n",
totdropped - lastaggrdropped);
lastaggrdropped = totdropped;
}
i = 0;
}
return NULL;
}
int main(int argc, char *argv[])
{
if (argc < 5) /* Test for correct number of arguments */
usage();
/* get info from parameters , or default to defaults if they're not specified */
char *server_ip = argv[1]; /* First arg: server IP address (dotted quad) */
Parameter<uint16_t> server_port("server port", 0, 65535, atoi(argv[2]));
Parameter<int> num_bursts("number of bursts", 1, MAX_NUM_BURSTS, atoi(argv[3]));
Parameter<int> burst_delay("burst iteration delay", 0, MAX_BURST_DELAY, atoi(argv[4]));
Parameter<int> payload_len("payload length", 0, ECHOMAX-48, 0);
Parameter<int> requested_burst_len("burst length", -1, -1, MAX_BURST_LEN);
if (argc >= 6) // allow specifying payload length
payload_len.value(atoi(argv[5]));
if (argc >= 7) // specify burst length to repeat
requested_burst_len.value(atoi(argv[6]));
// set up CNT-C catcher
signal(SIGINT, cntc);
/* Construct the server address structure */
struct sockaddr_in server_address; /* Echo server address */
memset(&server_address, 0, sizeof(server_address)); /* Zero out structure */
server_address.sin_family = AF_INET; /* Internet addr family */
int address = inet_addr(server_ip);
/* If user gave a dotted decimal address, we need to resolve it */
if (address == -1) {
struct hostent *thehost = gethostbyname(server_ip);
address = *((unsigned long *) thehost->h_addr_list[0]);
}
server_address.sin_addr.s_addr = address; /* Server IP address */
server_address.sin_port = htons(server_port.value());
/* Create a datagram/UDP socket */
int sock;
if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
throw DieException("socket() failed");
// set up message bytes with header pointing at beginning 20
char message_buffer[ECHOMAX];
// int message_len = sizeof(burst_protocol_header_t) + payload_len.value();
memset(&message_buffer, 0, sizeof(message_buffer));
burst_protocol_header_t *header = (burst_protocol_header_t *)message_buffer;
header->test_type = htons(1);
header->message_type = htons(MSG_PROBE);
header->payload_len = htonl(payload_len.value());
int bursts_sent = 0;
int messages_sent = 0;
int burst_len = requested_burst_len.value() == -1 ? 100 : requested_burst_len.value();
// send the begin message
// wait for the begin_ack
int burst_num;
for (burst_num = 0; !stopping && burst_num < num_bursts.value(); burst_num++) {
header->burst_num = htonl(burst_num);
Burst burst(TEST_TYPE, burst_num, burst_len, payload_len.value());
burst.send(sock, server_address);
messages_sent += burst_len;
bursts_sent++;
printf("burst %d sent, %d messages\n", burst_num, burst_len);
sleep(burst_delay.value());
}
// send the complete message
// wait for complete_ack
printf("\ntotal of %d bursts sent, totalling %d messages\n", bursts_sent, messages_sent);
close(sock);
exit(0);
}
/**
* Computes the hash positions for the server name given. This is based
* on the hashpos function. The server name usually is the IPv4
* address. The port component is just stored and not used in the
* carbon hash calculation in case of carbon_ch. The instance component
* is used in the hash calculation of carbon_ch, it is ignored for
* fnv1a_ch. Returns an updated ring.
*/
ch_ring *
ch_addnode(ch_ring *ring, server *s)
{
int i;
char buf[256];
ch_ring_entry *entries;
char *instance = server_instance(s);
int (*cmp)(const void *, const void *) = NULL;
if (ring == NULL)
return NULL;
entries =
(ch_ring_entry *)malloc(sizeof(ch_ring_entry) * ring->hash_replicas);
if (entries == NULL)
return NULL;
switch (ring->type) {
case CARBON:
for (i = 0; i < ring->hash_replicas; i++) {
/* this format is actually Python's tuple format that is
* used in serialised form as input for the hash */
snprintf(buf, sizeof(buf), "('%s', %s%s%s):%d",
server_ip(s),
instance == NULL ? "" : "'",
instance == NULL ? "None" : instance,
instance == NULL ? "" : "'",
i);
/* carbon upstream committed:
* https://github.com/graphite-project/carbon/commit/024f9e67ca47619438951c59154c0dec0b0518c7
* this makes sure no collissions exist on pos, however,
* at the expense of being agnostic to the input order,
* therefore that change isn't implemented here, see
* https://github.com/grobian/carbon-c-relay/issues/84 */
entries[i].pos = carbon_hashpos(buf, buf + strlen(buf));
entries[i].server = s;
entries[i].next = NULL;
entries[i].malloced = 0;
}
cmp = *entrycmp_carbon;
break;
case FNV1a:
for (i = 0; i < ring->hash_replicas; i++) {
/* take all server info into account, such that
* different port numbers for the same hosts will work
* (unlike CARBON), unless we got a full overrride */
if (instance == NULL) {
snprintf(buf, sizeof(buf), "%d-%s:%u",
i, server_ip(s), server_port(s));
} else {
snprintf(buf, sizeof(buf), "%d-%s", i, instance);
}
entries[i].pos = fnv1a_hash16(buf, buf + strlen(buf));
entries[i].server = s;
entries[i].next = NULL;
entries[i].malloced = 0;
}
cmp = *entrycmp_fnv1a;
break;
}
/* sort to allow merge joins later down the road */
qsort(entries, ring->hash_replicas, sizeof(ch_ring_entry), cmp);
entries[0].malloced = 1;
if (ring->entries == NULL) {
for (i = 1; i < ring->hash_replicas; i++)
entries[i - 1].next = &entries[i];
ring->entries = entries;
} else {
/* merge-join the two rings */
ch_ring_entry *w, *last;
i = 0;
last = NULL;
assert(ring->hash_replicas > 0);
for (w = ring->entries; w != NULL && i < ring->hash_replicas; ) {
if (cmp(&w->pos, &entries[i].pos) <= 0) {
last = w;
w = w->next;
} else {
entries[i].next = w;
if (last == NULL) {
ring->entries = &entries[i];
} else {
last->next = &entries[i];
}
last = &entries[i];
i++;
}
}
if (w != NULL) {
last->next = w;
} else {
last->next = &entries[i];
for (i = i + 1; i < ring->hash_replicas; i++)
entries[i - 1].next = &entries[i];
}
}
return ring;
}
int main(int argc, char *argv[])
{
try {
if (argc < 5) /* Test for correct number of arguments */
usage();
/* get info from parameters , or default to defaults if they're not specified */
char *server_ip = argv[1]; /* First arg: server IP address (dotted quad) */
Parameter<uint16_t> server_port("server port", 0, 65535, atoi(argv[2]));
Parameter<int> num_bursts("number of bursts", 1, TestData::MAX_LEN, atoi(argv[3]));
Parameter<int> burst_delay("burst iteration delay", 0, TestData::MAX_DELAY, atoi(argv[4]));
Parameter<int> payload_len("payload length", 0, Message::MAX_PAYLOAD, 0);
Parameter<int> initial_burst_len("initial burst length", 1, Burst::MAX_LEN, 100);
Parameter<float> burst_len_multiplier("burst length multiplier", 0, 100, 0);
if (argc >= 6) // allow specifying payload length
payload_len.value(atoi(argv[5]));
if (argc >= 7) // specify burst length to repeat
initial_burst_len.value(atoi(argv[6]));
if (argc >= 8)
burst_len_multiplier.value(atof(argv[7]));
// other (currently constant) parameters
int test_type = TestData::BUFFER_SIZE_TEST;
int client_port = server_port.value()+1;
SignalHandler cntlcCatcher(SIGINT);
// open a socket, bind for control messages
UDPSocket socket(client_port);
const unsigned int bufferSize = Message::MAX_SIZE;
unsigned char controlBuffer[bufferSize];
unsigned char responseBuffer[bufferSize];
// first burst length
int burst_len = initial_burst_len.value();
Message controlMessage(controlBuffer, 0);
controlMessage.setAddress(server_ip, server_port.value());
// send the begin message
controlMessage.header().message_type(Message::BEGIN);
controlMessage.header().test_type(test_type);
controlMessage.header().burst_num(num_bursts.value());
// seq_num set in sending
controlMessage.header().burst_len(burst_len);
bool gotResponse = false;
for (int i = 0; i < Socket::MAX_RETRIES; i++) {
controlMessage.header().seq_num(i+1);
socket.send(controlMessage);
// wait for the begin_ack
Message responseMessage(responseBuffer, bufferSize);
socket.receive(responseMessage, 1);
if (responseMessage.size() <= 0)
continue;
if (!Message::isResponsePair(controlMessage, responseMessage))
throw std::runtime_error("Got an unexpected response to begin message.");
gotResponse = true;
break;
}
if (!gotResponse)
throw std::runtime_error("Didn't get a response to the begin message from the server.");
int bursts_sent = 0;
int messages_sent = 0;
// send the bursts
for (int burst_num = 0; !cntlcCatcher.receivedSignal() && burst_num < num_bursts.value(); burst_num++) {
Burst burst(test_type, burst_num, burst_len, payload_len.value(), server_ip, server_port.value());
burst.send(socket);
messages_sent += burst_len;
bursts_sent++;
// printf("burst %d sent, %d messages\n", burst_num, burst_len);
burst_len += burst_len * burst_len_multiplier.value();
usleep(burst_delay.value());
}
// printf("\nTotal of %d bursts sent, totalling %d messages\n", bursts_sent, messages_sent);
// send the complete message
controlMessage.header().message_type(Message::COMPLETE);
controlMessage.header().burst_num(num_bursts.value());
// seq_num set in sending
controlMessage.header().burst_len(burst_len);
gotResponse = false;
for (int i = 0; i < Socket::MAX_RETRIES; i++) {
controlMessage.header().seq_num(i+1);
socket.send(controlMessage);
// wait for the complete_ack
Message responseMessage(responseBuffer, bufferSize);
socket.receive(responseMessage, 1);
if (responseMessage.size() <= 0)
continue;
if (!Message::isResponsePair(controlMessage, responseMessage))
throw std::runtime_error("Got an unexpected response to complete message.");
TestResults results(responseMessage.payload(), responseMessage.header().payload_len());
std::cout << results;
gotResponse = true;
break;
}
if (!gotResponse)
throw std::runtime_error("Didn't get a response to the complete message from the server.");
} catch (std::exception &e) {
std::cerr << "exception caught: " << e.what() << std::endl;
}
exit(0);
}
/**
* Collects metrics from dispatchers and servers and emits them.
*/
static void *
collector_runner(void *s)
{
int i;
size_t totticks;
size_t totmetrics;
size_t totqueued;
size_t totstalls;
size_t totdropped;
size_t ticks;
size_t metrics;
size_t queued;
size_t stalls;
size_t dropped;
size_t dispatchers_idle;
size_t dispatchers_busy;
time_t now;
time_t nextcycle;
char ipbuf[32];
char *p;
size_t numaggregators = aggregator_numaggregators();
server *submission = (server *)s;
server **srvs = NULL;
char metric[METRIC_BUFSIZ];
char *m;
size_t sizem = 0;
/* prepare hostname for graphite metrics */
snprintf(metric, sizeof(metric), "carbon.relays.%s", relay_hostname);
for (m = metric + strlen("carbon.relays."); *m != '\0'; m++)
if (*m == '.')
*m = '_';
*m++ = '.';
*m = '\0';
sizem = sizeof(metric) - (m - metric);
#define send(metric) \
if (debug) \
logout("%s", metric); \
else \
server_send(submission, strdup(metric), 1);
nextcycle = time(NULL) + collector_interval;
while (keep_running) {
if (cluster_refresh_pending) {
server **newservers = router_getservers(pending_clusters);
if (srvs != NULL)
free(srvs);
srvs = newservers;
cluster_refresh_pending = 0;
}
assert(srvs != NULL);
sleep(1);
now = time(NULL);
if (nextcycle > now)
continue;
nextcycle += collector_interval;
totticks = 0;
totmetrics = 0;
dispatchers_idle = 0;
dispatchers_busy = 0;
for (i = 0; dispatchers[i] != NULL; i++) {
if (dispatch_busy(dispatchers[i])) {
dispatchers_busy++;
} else {
dispatchers_idle++;
}
totticks += ticks = dispatch_get_ticks(dispatchers[i]);
totmetrics += metrics = dispatch_get_metrics(dispatchers[i]);
snprintf(m, sizem, "dispatcher%d.metricsReceived %zd %zd\n",
i + 1, metrics, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatcher%d.wallTime_us %zd %zd\n",
i + 1, ticks, (size_t)now);
send(metric);
}
snprintf(m, sizem, "metricsReceived %zd %zd\n",
totmetrics, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatch_wallTime_us %zd %zd\n",
totticks, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatch_busy %zd %zd\n",
dispatchers_busy, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatch_idle %zd %zd\n",
dispatchers_idle, (size_t)now);
send(metric);
totticks = 0;
totmetrics = 0;
totqueued = 0;
totstalls = 0;
totdropped = 0;
for (i = 0; srvs[i] != NULL; i++) {
if (server_ctype(srvs[i]) == CON_PIPE) {
strncpy(ipbuf, "internal", sizeof(ipbuf));
ticks = server_get_ticks(srvs[i]);
metrics = server_get_metrics(srvs[i]);
queued = server_get_queue_len(srvs[i]);
stalls = server_get_stalls(srvs[i]);
dropped = server_get_dropped(srvs[i]);
} else {
snprintf(ipbuf, sizeof(ipbuf), "%s:%u",
server_ip(srvs[i]), server_port(srvs[i]));
for (p = ipbuf; *p != '\0'; p++)
if (*p == '.')
*p = '_';
totticks += ticks = server_get_ticks(srvs[i]);
totmetrics += metrics = server_get_metrics(srvs[i]);
totqueued += queued = server_get_queue_len(srvs[i]);
totstalls += stalls = server_get_stalls(srvs[i]);
totdropped += dropped = server_get_dropped(srvs[i]);
}
snprintf(m, sizem, "destinations.%s.sent %zd %zd\n",
ipbuf, metrics, (size_t)now);
send(metric);
snprintf(m, sizem, "destinations.%s.queued %zd %zd\n",
ipbuf, queued, (size_t)now);
send(metric);
snprintf(m, sizem, "destinations.%s.stalls %zd %zd\n",
ipbuf, stalls, (size_t)now);
send(metric);
snprintf(m, sizem, "destinations.%s.dropped %zd %zd\n",
ipbuf, dropped, (size_t)now);
send(metric);
snprintf(m, sizem, "destinations.%s.wallTime_us %zd %zd\n",
ipbuf, ticks, (size_t)now);
send(metric);
}
snprintf(m, sizem, "metricsSent %zd %zd\n",
totmetrics, (size_t)now);
send(metric);
snprintf(m, sizem, "metricsQueued %zd %zd\n",
totqueued, (size_t)now);
send(metric);
snprintf(m, sizem, "metricStalls %zd %zd\n",
totstalls, (size_t)now);
send(metric);
snprintf(m, sizem, "metricsDropped %zd %zd\n",
totdropped, (size_t)now);
send(metric);
snprintf(m, sizem, "server_wallTime_us %zd %zd\n",
totticks, (size_t)now);
send(metric);
snprintf(m, sizem, "connections %zd %zd\n",
dispatch_get_accepted_connections(), (size_t)now);
send(metric);
snprintf(m, sizem, "disconnects %zd %zd\n",
dispatch_get_closed_connections(), (size_t)now);
send(metric);
if (numaggregators > 0) {
snprintf(m, sizem, "aggregators.metricsReceived %zd %zd\n",
aggregator_get_received(), (size_t)now);
send(metric);
snprintf(m, sizem, "aggregators.metricsSent %zd %zd\n",
aggregator_get_sent(), (size_t)now);
send(metric);
snprintf(m, sizem, "aggregators.metricsDropped %zd %zd\n",
aggregator_get_dropped(), (size_t)now);
send(metric);
}
if (debug)
fflush(stdout);
}
return NULL;
}
