GError*
metautils_message_extract_boolean(MESSAGE msg, const gchar *n,
gboolean mandatory, gboolean *v)
{
gchar tmp[16];
GError *err = metautils_message_extract_string(msg, n, tmp, sizeof(tmp));
if (err) {
if (!mandatory)
g_clear_error(&err);
return err;
}
if (v)
*v = metautils_cfg_get_bool (tmp, *v);
return NULL;
}
/**
* @return TRUE if "agent_check" tag is missing or is true,
* false otherwise
*/
static gboolean
_agent_check_enabled(struct service_info_s *si)
{
if (!si)
return FALSE;
gboolean srv_check_enabled = TRUE;
service_tag_t *tag = service_info_get_tag(si->tags,
NAME_TAGNAME_AGENT_CHECK);
if (tag) {
GError *err = NULL;
if (tag->type == STVT_BOOL) {
service_tag_get_value_boolean(tag, &srv_check_enabled, &err);
} else {
gchar buf[64] = {0};
service_tag_get_value_string(tag, buf, sizeof(buf), &err);
srv_check_enabled = metautils_cfg_get_bool(buf, TRUE);
}
g_clear_error(&err);
}
return srv_check_enabled;
}
static void
allservice_check_start_HT(struct namespace_data_s *ns_data, GHashTable *ht)
{
gsize offset;
struct taskdata_checksrv_s td_scheme;
GHashTableIter iter_serv;
gpointer k, v;
g_hash_table_iter_init(&iter_serv, ht);
while (g_hash_table_iter_next(&iter_serv, &k, &v)) {
struct service_info_s *si = v;
gboolean srv_check_enabled = TRUE;
/* Services can disable TCP checks (enabled by default) */
service_tag_t *tag = service_info_get_tag(si->tags,
NAME_TAGNAME_AGENT_CHECK);
if (tag) {
GError *err = NULL;
if (tag->type == STVT_BOOL) {
service_tag_get_value_boolean(tag, &srv_check_enabled, &err);
} else {
gchar buf[64] = {0};
service_tag_get_value_string(tag, buf, sizeof(buf), &err);
srv_check_enabled = metautils_cfg_get_bool(buf, TRUE);
}
g_clear_error(&err);
}
memset(&td_scheme, 0x00, sizeof(td_scheme));
offset = g_snprintf(td_scheme.task_name, sizeof(td_scheme.task_name), "%s.", TASK_ID);
addr_info_to_string(&(si->addr), td_scheme.task_name+offset, sizeof(td_scheme.task_name)-offset);
g_strlcpy(td_scheme.ns_name, ns_data->name, sizeof(td_scheme.ns_name)-1);
if (!srv_check_enabled) {
GRID_DEBUG("Task [%s] disabled by "
NAME_TAGNAME_AGENT_CHECK, td_scheme.task_name);
} else if (!is_task_scheduled(td_scheme.task_name)) {
GError *error_local = NULL;
task_t *task = NULL;
struct taskdata_checksrv_s *task_data;
agent_get_service_key(si, td_scheme.srv_key, sizeof(td_scheme.srv_key));
g_strlcpy(td_scheme.srv_key, (gchar*)k, sizeof(td_scheme.srv_key)-1);
/* prepare the task structure */
task_data = g_memdup(&td_scheme, sizeof(td_scheme));
if (!task_data) {
ERROR("Memory allocation failure");
continue;
}
task = create_task(period_check_services, td_scheme.task_name);
task = set_task_callbacks(task, _check_tcp_service_task,
g_free, task_data);
if (!task) {
ERROR("Memory allocation failure");
continue;
}
/* now start the task! */
if (add_task_to_schedule(task, &error_local))
INFO("Task started: %s", td_scheme.task_name);
else {
ERROR("Failed to add task to scheduler [%s] : %s", td_scheme.task_name, gerror_get_message(error_local));
g_free(task);
}
if (error_local)
g_clear_error(&error_local);
}
}
}
static enum http_rc_e
handler_action (struct http_request_s *rq, struct http_reply_ctx_s *rp)
{
gboolean _boolhdr (const gchar * n) {
return metautils_cfg_get_bool (
(gchar *) g_tree_lookup (rq->tree_headers, n), FALSE);
}
// Get a request id for the current request
const gchar *reqid = g_tree_lookup (rq->tree_headers, PROXYD_HEADER_REQID);
if (reqid)
oio_ext_set_reqid(reqid);
else
oio_ext_set_random_reqid();
// Then parse the request to find a handler
struct oio_url_s *url = NULL;
struct oio_requri_s ruri = {NULL, NULL, NULL, NULL};
oio_requri_parse (rq->req_uri, &ruri);
struct path_matching_s **matchings = _metacd_match (rq->cmd, ruri.path);
GRID_TRACE2("URI path[%s] query[%s] fragment[%s] matches[%u]",
ruri.path, ruri.query, ruri.fragment,
g_strv_length((gchar**)matchings));
GQuark gq_count = gq_count_unexpected;
GQuark gq_time = gq_time_unexpected;
enum http_rc_e rc;
if (!*matchings) {
rp->set_content_type ("application/json");
rp->set_body_gstr (g_string_new("{\"status\":404,\"message\":\"No handler found\"}"));
rp->set_status (HTTP_CODE_NOT_FOUND, "No handler found");
rp->finalize ();
rc = HTTPRC_DONE;
} else {
struct req_args_s args = {NULL,NULL,NULL, NULL,NULL, 0};
args.req_uri = &ruri;
args.matchings = matchings;
args.rq = rq;
args.rp = rp;
if (_boolhdr (PROXYD_HEADER_NOEMPTY))
args.flags |= FLAG_NOEMPTY;
args.url = url = _metacd_load_url (&args);
rp->subject(oio_url_get(url, OIOURL_HEXID));
gq_count = (*matchings)->last->gq_count;
gq_time = (*matchings)->last->gq_time;
GRID_TRACE("URL %s", oio_url_get(args.url, OIOURL_WHOLE));
req_handler_f handler = (*matchings)->last->u;
rc = (*handler) (&args);
}
gint64 spent = oio_ext_monotonic_time () - rq->client->time.evt_in;
network_server_stat_push4 (rq->client->server, TRUE,
gq_count, 1, gq_count_all, 1,
gq_time, spent, gq_time_all, spent);
path_matching_cleanv (matchings);
oio_requri_clear (&ruri);
oio_url_pclean (&url);
return rc;
}
