/** Initialize global stats stuff */
static void _stats_init(struct mg *mg)
{
mg->stats = stats_create(mg->mm);
/* iitis-generator internal stats */
mgstats_writer_add(mg,
_stats_global, NULL,
NULL, "internal-stats.txt",
"scheduler_evt",
"scheduler_lag",
NULL);
/* global stats of line generators */
mgstats_writer_add(mg,
_stats_aggregate_lines, NULL,
NULL, "linestats.txt",
"snt_ok",
"snt_time",
"snt_err",
"rcv_ok",
"rcv_ok_bytes",
"rcv_dup",
"rcv_dup_bytes",
"rcv_lost",
NULL);
}
static struct stats *open_stats(const char *name)
{
struct stats *stats = NULL;
int err;
err = stats_create(name,&stats);
if (err != S_OK)
{
printf("Failed to create stats: %s\n", error_message(err));
return NULL;
}
err = stats_open(stats);
if (err != S_OK)
{
printf("Failed to open stats: %s\n", error_message(err));
stats_free(stats);
return NULL;
}
return stats;
}
static struct context *
core_ctx_create(struct instance *nci)
{
rstatus_t status;
struct context *ctx;
struct conn *sentinel_conn;
ctx = nc_alloc(sizeof(*ctx));
if (ctx == NULL) {
return NULL;
}
ctx->id = ++ctx_id;
ctx->cf = NULL;
ctx->stats = NULL;
array_null(&ctx->pool);
ctx->ep = -1;
ctx->nevent = EVENT_SIZE_HINT;
ctx->max_timeout = nci->stats_interval;
ctx->timeout = ctx->max_timeout;
ctx->event = NULL;
ctx->server_reconnect_interval = nci->server_reconnect_interval;
ctx->whitelist = nci->whitelist;
/* parse and create configuration */
ctx->cf = conf_create(nci->conf_filename);
if (ctx->cf == NULL) {
nc_free(ctx);
return NULL;
}
/* initialize server pool from configuration */
status = server_pool_init(&ctx->pool, &ctx->cf->pool, ctx);
if (status != NC_OK) {
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* initialize sentinel server */
ctx->sentinel = sentinel_init(nci->sentinel_port, nci->sentinel_addr);
if (ctx->sentinel == NULL) {
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* create stats per server pool */
ctx->stats = stats_create(nci->stats_port, nci->stats_addr, nci->stats_interval,
nci->hostname, &ctx->pool);
if (ctx->stats == NULL) {
sentinel_deinit(ctx->sentinel);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* initialize event handling for client, proxy and server */
status = event_init(ctx, EVENT_SIZE_HINT);
if (status != NC_OK) {
stats_destroy(ctx->stats);
sentinel_deinit(ctx->sentinel);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* preconnect? servers in server pool */
status = server_pool_preconnect(ctx);
if (status != NC_OK) {
server_pool_disconnect(ctx);
event_deinit(ctx);
stats_destroy(ctx->stats);
sentinel_deinit(ctx->sentinel);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* initialize sentinel server conn */
sentinel_conn = sentinel_connect(ctx);
if (sentinel_conn == NULL) {
server_pool_disconnect(ctx);
event_deinit(ctx);
stats_destroy(ctx->stats);
sentinel_deinit(ctx->sentinel);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
}
/* initialize proxy per server pool */
status = proxy_init(ctx);
if (status != NC_OK) {
sentinel_conn->close(ctx, sentinel_conn);
server_pool_disconnect(ctx);
event_deinit(ctx);
stats_destroy(ctx->stats);
sentinel_deinit(ctx->sentinel);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
log_debug(LOG_VVERB, "created ctx %p id %"PRIu32"", ctx, ctx->id);
return ctx;
}
/** Parse traffic file
* @retval 0 success
* @retval 1 syntax error
* @retval 2 logic error
*/
static int parse_traffic(struct mg *mg)
{
FILE *fp;
const char *file;
char buf[BUFSIZ];
uint32_t line_num = 0;
struct line *line;
int i, rc;
char *rest, *errmsg;
struct mgp_line *pl;
file = mg->options.traf_file;
fp = fopen(file, "r");
if (!fp) {
dbg(0, "could not open traffic file: %s: %s\n", file, strerror(errno));
return 1;
}
while (fgets(buf, sizeof buf, fp)) {
line_num++;
if (line_num >= N(mg->lines))
die("Too many lines in the traffic file");
/* skip comments */
if (buf[0] == '#' || buf[0] == '\r' || buf[0] == '\n')
continue;
/* parse line */
pl = mgp_parse_line(mg->mm, buf, 8, &rest, &errmsg,
"s", "ms", "iface", "src", "dst", "rate", "noack", "cmd", NULL);
if (!pl) {
dbg(0, "%s: line %d: parse error: %s\n", file, line_num, errmsg);
return 1;
}
/* ...and rewrite into struct line */
line = mmatic_zalloc(mg->mm, sizeof *line);
mg->lines[line_num] = line;
line->mg = mg;
line->line_num = line_num;
line->contents = mmatic_strdup(mg->mm, buf);
line->stats = stats_create(mg->mm);
/* time */
line->tv.tv_sec = mgp_get_int(pl, "s", 0);
line->tv.tv_usec = mgp_get_int(pl, "ms", 0) * 1000;
/* interface */
i = mgp_get_int(pl, "iface", 0);
if (i >= IFINDEX_MAX) {
dbg(0, "%s: line %d: too big interface number: %d\n", file, line_num, i);
return 1;
}
line->interface = &mg->interface[i];
if (line->interface->fd <= 0) {
dbg(0, "%s: line %d: interface not opened: %d\n", file, line_num, i);
return 2;
}
/* src/dst */
line->srcid = mgp_get_int(pl, "src", 1);
line->dstid = mgp_get_int(pl, "dst", 1);
line->my = (line->srcid == mg->options.myid);
/* rate/noack */
line->rate = mgp_get_float(pl, "rate", 0) * 2.0; /* driver uses "half-rates"; NB: "auto" => 0 */
line->noack = mgp_get_int(pl, "noack", 0);
/*
* command
*/
line->cmd = mgp_get_string(pl, "cmd", "");
if (!line->cmd) {
dbg(0, "%s: line %d: no line command\n", file, line_num);
return 2;
}
/* find command handlers */
if (!find_line_cmd(line)) {
dbg(0, "%s: line %d: invalid command: %s\n", file, line_num, line->cmd);
return 2;
}
/* initialize scheduler of outgoing frames */
mgs_setup(&line->schedule, mg, line->cmd_timeout, line);
/* call command initializer */
rc = line->cmd_init(line, rest);
if (rc != 0)
return rc;
}
fclose(fp);
return 0;
}
static struct context *
core_ctx_create(struct instance *nci)
{
rstatus_t status;
struct context *ctx;
srand((unsigned) time(NULL));
ctx = dn_alloc(sizeof(*ctx));
if (ctx == NULL) {
return NULL;
}
ctx->id = ++ctx_id;
ctx->cf = NULL;
ctx->stats = NULL;
ctx->evb = NULL;
array_null(&ctx->pool);
ctx->max_timeout = nci->stats_interval;
ctx->timeout = ctx->max_timeout;
ctx->dyn_state = INIT;
/* parse and create configuration */
ctx->cf = conf_create(nci->conf_filename);
if (ctx->cf == NULL) {
loga("Failed to create context!!!");
dn_free(ctx);
return NULL;
}
/* initialize server pool from configuration */
status = server_pool_init(&ctx->pool, &ctx->cf->pool, ctx);
if (status != DN_OK) {
loga("Failed to initialize server pool!!!");
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
/* crypto init */
status = crypto_init(ctx);
if (status != DN_OK) {
loga("Failed to initialize crypto!!!");
dn_free(ctx);
return NULL;
}
/* create stats per server pool */
ctx->stats = stats_create(nci->stats_port, nci->stats_addr, nci->stats_interval,
nci->hostname, &ctx->pool, ctx);
if (ctx->stats == NULL) {
loga("Failed to create stats!!!");
crypto_deinit();
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
/* initialize event handling for client, proxy and server */
ctx->evb = event_base_create(EVENT_SIZE, &core_core);
if (ctx->evb == NULL) {
loga("Failed to create socket event handling!!!");
crypto_deinit();
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
/* preconnect? servers in server pool */
status = server_pool_preconnect(ctx);
if (status != DN_OK) {
loga("Failed to preconnect for server pool!!!");
crypto_deinit();
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
/* initialize proxy per server pool */
status = proxy_init(ctx);
if (status != DN_OK) {
loga("Failed to initialize proxy!!!");
crypto_deinit();
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
/* initialize dnode listener per server pool */
status = dnode_init(ctx);
if (status != DN_OK) {
loga("Failed to initialize dnode!!!");
crypto_deinit();
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
ctx->dyn_state = JOINING; //TODOS: change this to JOINING
/* initialize peers */
status = dnode_peer_init(&ctx->pool, ctx);
if (status != DN_OK) {
loga("Failed to initialize dnode peers!!!");
crypto_deinit();
dnode_deinit(ctx);
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
core_debug(ctx);
/* preconntect peers - probably start gossip here */
status = dnode_peer_pool_preconnect(ctx);
if (status != DN_OK) {
loga("Failed to preconnect dnode peers!!!");
crypto_deinit();
dnode_peer_deinit(&ctx->pool);
dnode_deinit(ctx);
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
//init ring msg queue
CBUF_Init(C2G_InQ);
CBUF_Init(C2G_OutQ);
//init stats msg queue
CBUF_Init(C2S_InQ);
CBUF_Init(C2S_OutQ);
gossip_pool_init(ctx);
log_debug(LOG_VVERB, "created ctx %p id %"PRIu32"", ctx, ctx->id);
return ctx;
}
int main(int argc, char *argv[])
{
GOptionContext *context;
GError *error = NULL;
struct stats_file_header *hdr;
struct stats_file data, *data_file;
struct stats_record *rec;
time_t start_ts;
int err;
rec = NULL;
data_file = &data;
putenv("TZ=GMT0");
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
if (error) {
g_printerr("%s\n", error->message);
g_error_free(error);
} else
g_printerr("An unknown error occurred\n");
exit(1);
}
g_option_context_free(context);
if (argc < 2) {
printf("Usage: %s [FILENAME]\n", argv[0]);
exit(0);
}
err = stats_open(data_file, argv[1]);
if (err < 0) {
fprintf(stderr, "failed open file %s\n", argv[1]);
exit(1);
}
if (option_last_file_name) {
struct stats_file last;
if (stats_open(&last, option_last_file_name) < 0) {
fprintf(stderr, "failed open file %s\n",
option_last_file_name);
exit(1);
}
rec = get_end(&last);
}
if (option_start_ts == -1)
start_ts = time(NULL);
else
start_ts = option_start_ts;
if (option_create > 0)
stats_create(data_file, option_create, option_interval,
start_ts, rec);
hdr = get_hdr(data_file);
if (hdr->magic != MAGIC) {
fprintf(stderr, "header file magic test failed\n");
goto err;
}
stats_file_update_cache(data_file);
stats_hdr_info(data_file);
if (option_dump)
stats_print_entries(data_file);
if (option_summary)
stats_print_diff(data_file);
if (option_info_file_name)
history_file_update(data_file, option_info_file_name);
err:
stats_close(data_file);
return 0;
}
static struct context *
core_ctx_create(struct instance *nci)
{
rstatus_t status;
struct context *ctx;
ctx = nc_alloc(sizeof(*ctx));
if (ctx == NULL) {
return NULL;
}
ctx->id = ++ctx_id;
ctx->cf = NULL;
ctx->stats = NULL;
ctx->evb = NULL;
array_null(&ctx->pool);
ctx->max_timeout = nci->stats_interval;
ctx->timeout = ctx->max_timeout;
ctx->max_nfd = 0;
ctx->max_ncconn = 0;
ctx->max_nsconn = 0;
/* parse and create configuration */
ctx->cf = conf_create(nci->conf_filename);
if (ctx->cf == NULL) {
nc_free(ctx);
return NULL;
}
/* initialize server pool from configuration */
status = server_pool_init(&ctx->pool, &ctx->cf->pool, ctx);
if (status != NC_OK) {
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/*
* Get rlimit and calculate max client connections after we have
* calculated max server connections
*/
status = core_calc_connections(ctx);
if (status != NC_OK) {
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* create stats per server pool */
ctx->stats = stats_create(nci->stats_port, nci->stats_addr, nci->stats_interval,
nci->hostname, &ctx->pool);
if (ctx->stats == NULL) {
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* initialize event handling for client, proxy and server */
ctx->evb = event_base_create(EVENT_SIZE, &core_core);
if (ctx->evb == NULL) {
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* preconnect? servers in server pool */
status = server_pool_preconnect(ctx);
if (status != NC_OK) {
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* initialize proxy per server pool */
status = proxy_init(ctx);
if (status != NC_OK) {
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
log_debug(LOG_VVERB, "created ctx %p id %"PRIu32"", ctx, ctx->id);
return ctx;
}
static struct context *
core_ctx_create(struct instance *nci)
{
rstatus_t status;
struct context *ctx;
int64_t now;
uint32_t npool;
ctx = nc_alloc(sizeof(*ctx));
if (ctx == NULL) {
return NULL;
}
now = nc_msec_now();
if (now < 0) {
nc_free(ctx);
return NULL;
}
ctx->id = ++ctx_id;
ctx->cf = NULL;
ctx->stats = NULL;
ctx->evb = NULL;
array_null(&ctx->pool);
ctx->max_timeout = nci->stats_interval;
ctx->timeout = ctx->max_timeout;
ctx->next_tick = now + NC_TICK_INTERVAL;
/* parse and create configuration */
ctx->cf = conf_create(nci->conf_filename);
if (ctx->cf == NULL) {
nc_free(ctx);
return NULL;
}
npool = array_n(&ctx->cf->pool);
/* initialize server pool from configuration */
if (npool != 0) {
status = server_pool_init(&ctx->pool, &ctx->cf->pool, ctx);
if (status != NC_OK) {
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
}
/* create stats per server pool */
if (npool != 0) {
ctx->stats = stats_create(nci->stats_port, nci->stats_addr, nci->stats_interval,
nci->hostname, &ctx->pool);
if (ctx->stats == NULL) {
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
}
/* initialize event handling for client, proxy and server */
ctx->evb = evbase_create(NC_EVENT_SIZE, &core_core);
if (ctx->evb == NULL) {
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* preconnect? servers in server pool */
if (npool != 0) {
status = server_pool_preconnect(ctx);
if (status != NC_OK) {
server_pool_disconnect(ctx);
evbase_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
}
/* initialize proxy per server pool */
if (npool != 0) {
status = proxy_init(ctx);
if (status != NC_OK) {
server_pool_disconnect(ctx);
evbase_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
}
log_debug(LOG_VVERB, "created ctx %p id %"PRIu32"", ctx, ctx->id);
return ctx;
}
/**
* Create a new zone.
*
*/
zone_type*
zone_create(char* name, ldns_rr_class klass)
{
allocator_type* allocator = NULL;
zone_type* zone = NULL;
if (!name || !klass) {
return NULL;
}
allocator = allocator_create(malloc, free);
if (!allocator) {
ods_log_error("[%s] unable to create zone %s: allocator_create() "
"failed", zone_str, name);
return NULL;
}
zone = (zone_type*) allocator_alloc(allocator, sizeof(zone_type));
if (!zone) {
ods_log_error("[%s] unable to create zone %s: allocator_alloc()",
"failed", zone_str, name);
allocator_cleanup(allocator);
return NULL;
}
zone->allocator = allocator;
/* [start] PS 9218653: Drop trailing dot in domain name */
if (strlen(name) > 1 && name[strlen(name)-1] == '.') {
name[strlen(name)-1] = '\0';
}
/* [end] PS 9218653 */
zone->name = allocator_strdup(allocator, name);
if (!zone->name) {
ods_log_error("[%s] unable to create zone %s: allocator_strdup() "
"failed", zone_str, name);
zone_cleanup(zone);
return NULL;
}
zone->klass = klass;
zone->default_ttl = 3600; /* TODO: configure --default-ttl option? */
zone->apex = ldns_dname_new_frm_str(name);
/* check zone->apex? */
zone->notify_command = NULL;
zone->notify_ns = NULL;
zone->notify_args = NULL;
zone->policy_name = NULL;
zone->signconf_filename = NULL;
zone->adinbound = NULL;
zone->adoutbound = NULL;
zone->zl_status = ZONE_ZL_OK;
zone->task = NULL;
zone->xfrd = NULL;
zone->notify = NULL;
zone->db = namedb_create((void*)zone);
if (!zone->db) {
ods_log_error("[%s] unable to create zone %s: namedb_create() "
"failed", zone_str, name);
zone_cleanup(zone);
return NULL;
}
zone->ixfr = ixfr_create((void*)zone);
if (!zone->ixfr) {
ods_log_error("[%s] unable to create zone %s: ixfr_create() "
"failed", zone_str, name);
zone_cleanup(zone);
return NULL;
}
zone->signconf = signconf_create();
if (!zone->signconf) {
ods_log_error("[%s] unable to create zone %s: signconf_create() "
"failed", zone_str, name);
zone_cleanup(zone);
return NULL;
}
zone->stats = stats_create();
lock_basic_init(&zone->zone_lock);
lock_basic_init(&zone->xfr_lock);
return zone;
}