void wait_server_backoff(unsigned int timeout /* seconds */,
jsonrpc_server_t* server, bool delay)
{
if(!server) {
ERR("Trying to close/reconnect a NULL server\n");
return;
}
if(delay == false) {
if (requests_using_server(server) <= 0) {
if(server->status == JSONRPC_SERVER_RECONNECTING) {
bev_connect(server);
} else if(server->status == JSONRPC_SERVER_CLOSING) {
close_server(server);
}
return;
}
}
const struct timeval tv = {timeout, 0};
server_backoff_args_t* args = pkg_malloc(sizeof(server_backoff_args_t));
CHECK_MALLOC_VOID(args);
memset(args, 0, sizeof(server_backoff_args_t));
args->ev = evtimer_new(global_ev_base, server_backoff_cb, (void*)args);
CHECK_MALLOC_GOTO(args->ev, error);
args->server = server;
args->timeout = timeout;
if(evtimer_add(args->ev, &tv)<0) {
ERR("event_add failed while setting request timer (%s).", strerror(errno));
goto error;
}
return;
error:
ERR("schedule_server failed.\n");
if(args) {
if(args->ev) {
evtimer_del(args->ev);
}
pkg_free(args);
}
if (server->status == JSONRPC_SERVER_CLOSING) {
ERR("Closing server now...\n");
close_server(server);
} else if (server->status == JSONRPC_SERVER_RECONNECTING) {
ERR("Reconnecting server now...\n");
force_reconnect(server);
}
}
void cmd_pipe_cb(int fd, short event, void *arg)
{
struct jsonrpc_pipe_cmd *cmd;
char *ns = 0;
size_t bytes;
json_object *payload = NULL;
jsonrpc_request_t *req = NULL;
json_object *params;
/* struct event *ev = (struct event*)arg; */
if (read(fd, &cmd, sizeof(cmd)) != sizeof(cmd)) {
LM_ERR("failed to read from command pipe: %s\n", strerror(errno));
return;
}
cfg_update();
params = json_tokener_parse(cmd->params);
if (cmd->notify_only) {
payload = build_jsonrpc_notification(cmd->method, params);
} else {
req = build_jsonrpc_request(cmd->method, params, (char*)cmd, res_cb);
if (req)
payload = req->payload;
}
if (!payload) {
LM_ERR("Failed to build jsonrpc_request_t (method: %s, params: %s)\n", cmd->method, cmd->params);
goto error;
}
char *json = (char*)json_object_get_string(payload);
bytes = netstring_encode_new(&ns, json, (size_t)strlen(json));
struct jsonrpc_server_group *g;
int sent = 0;
for (g = server_group; g != NULL; g = g->next_group)
{
struct jsonrpc_server *s, *first = NULL;
for (s = g->next_server; s != first; s = s->next)
{
if (first == NULL) first = s;
if (s->status == JSONRPC_SERVER_CONNECTED) {
if (send(s->socket, ns, bytes, 0) == bytes)
{
sent = 1;
break;
} else {
handle_server_failure(s);
}
}
g->next_server = s->next;
}
if (sent) {
break;
} else {
LM_WARN("Failed to send on priority group %d... proceeding to next priority group.\n", g->priority);
}
}
if (sent && req) {
int timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
if (timerfd == -1) {
LM_ERR("Could not create timerfd.");
goto error;
}
req->timerfd = timerfd;
struct itimerspec *itime = pkg_malloc(sizeof(struct itimerspec));
CHECK_MALLOC_VOID(itime);
itime->it_interval.tv_sec = 0;
itime->it_interval.tv_nsec = 0;
itime->it_value.tv_sec = JSONRPC_TIMEOUT/1000;
itime->it_value.tv_nsec = (JSONRPC_TIMEOUT % 1000) * 1000000;
if (timerfd_settime(timerfd, 0, itime, NULL) == -1)
{
LM_ERR("Could not set timer.");
pkg_free(itime);
goto error;
}
pkg_free(itime);
struct event *timer_ev = pkg_malloc(sizeof(struct event));
CHECK_MALLOC_VOID(timer_ev);
event_set(timer_ev, timerfd, EV_READ, timeout_cb, req);
if(event_add(timer_ev, NULL) == -1) {
LM_ERR("event_add failed while setting request timer (%s).", strerror(errno));
goto error;
}
req->timer_ev = timer_ev;
} else if (!sent) {
LM_ERR("Request could not be sent... no more failover groups.\n");
if (req) {
json_object *error = json_object_new_string("failure");
void_jsonrpc_request(req->id);
req->cbfunc(error, req->cbdata, 1);
}
}
pkg_free(ns);
json_object_put(payload);
if (cmd->notify_only) free_pipe_cmd(cmd);
return;
error:
if(ns) pkg_free(ns);
if(payload) json_object_put(payload);
if (cmd->notify_only) free_pipe_cmd(cmd);
return;
}
