static gboolean
_configure_events_queue (struct sqlx_service_s *ss)
{
if (ss->flag_no_event) {
GRID_DEBUG("Events queue disabled, the service disabled it");
return TRUE;
}
gchar *url = gridcluster_get_eventagent (SRV.ns_name);
STRING_STACKIFY (url);
if (!url) {
GRID_DEBUG("Events queue disabled, no URL configured");
return TRUE;
}
GError *err = oio_events_queue_factory__create(url, &ss->events_queue);
if (!ss->events_queue) {
GRID_WARN("Events queue creation failure: (%d) %s", err->code, err->message);
return FALSE;
}
GRID_INFO("Event queue ready, connected to [%s]", url);
return TRUE;
}
static void
_NOLOCK_local_score_update (const struct service_info_s *si0)
{
gchar *k = service_info_key (si0);
STRING_STACKIFY(k);
struct service_info_s *si = lru_tree_get (srv_registered, k);
if (si) si->score.value = si0->score.value;
}
gboolean
grid_string_to_sockaddr(const gchar *start, struct sockaddr *s, gsize *slen)
{
EXTRA_ASSERT (start != NULL);
EXTRA_ASSERT (slen != NULL);
if (!*start)
return FALSE;
gchar *addr = g_strdup (start);
STRING_STACKIFY(addr);
EXTRA_ASSERT(addr != NULL);
if (*addr == '/') { // UNIX socket
struct sockaddr_un *sun = (struct sockaddr_un*) s;
*slen = sizeof(*sun);
sun->sun_family = AF_UNIX;
g_strlcpy(sun->sun_path, addr, sizeof(sun->sun_path));
return TRUE;
}
// Find the ':' separator and fill the working buffers with each part
gchar *colon = strrchr(addr, ':');
if (!colon) return FALSE;
*(colon++) = '\0';
// Parse the port
guint16 u16port = 0;
if (!_port_parse(colon, &u16port))
return 0;
// And now, parse the address
if (addr[0] == '[') {
struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) s;
size_t l = strlen(addr);
*slen = sizeof(struct sockaddr_in6);
if (addr[l-1] == ']')
addr[--l] = '\0';
if (0 < inet_pton(AF_INET6, addr+1, &sin6->sin6_addr)) {
sin6->sin6_family = AF_INET6;
sin6->sin6_port = g_htons(u16port);
return 1;
}
} else {
struct sockaddr_in *sin = (struct sockaddr_in*) s;
*slen = sizeof(struct sockaddr_in);
if (0 < inet_pton(AF_INET, addr, &sin->sin_addr)) {
sin->sin_family = AF_INET;
sin->sin_port = g_htons(u16port);
return 1;
}
}
return 0;
}
static gboolean
_configure_events_queue (struct sqlx_service_s *ss)
{
gchar *url = gridcluster_get_eventagent (SRV.ns_name);
STRING_STACKIFY (url);
if (!url) {
GRID_DEBUG("Events queue disabled, no URL configured");
return TRUE;
}
ss->events_queue = oio_events_queue_factory__create_agent (url, OIO_EVTQ_MAXPENDING);
if (!ss->events_queue) {
GRID_WARN("Events queue creation failure");
return FALSE;
}
GRID_INFO("Event queue ready, connected to [%s]", url);
return TRUE;
}
static gboolean
meta1_dispatch_v2_SRV_LIST(struct gridd_reply_ctx_s *reply,
struct meta1_backend_s *m1, gpointer ignored UNUSED)
{
struct oio_url_s *url = metautils_message_extract_url (reply->request);
gchar *srvtype = metautils_message_extract_string_copy (reply->request, NAME_MSGKEY_TYPENAME);
reply->subject("%s|%s|%s", oio_url_get(url, OIOURL_WHOLE), oio_url_get(url, OIOURL_HEXID), srvtype);
STRING_STACKIFY(srvtype);
gchar **result = NULL;
GError *err = meta1_backend_services_list(m1, url, srvtype, &result);
if (NULL != err)
reply->send_error(0, err);
else {
reply->add_body(encode_and_clean(STRV_encode_gba, result));
reply->send_reply(CODE_FINAL_OK, "OK");
}
oio_url_clean (url);
return TRUE;
}
static enum http_rc_e
_registration (struct req_args_s *args, enum reg_op_e op, struct json_object *jsrv)
{
GError *err;
if (!jsrv || !json_object_is_type (jsrv, json_type_object))
return _reply_common_error (args, BADREQ("Expected: json object"));
if (!push_queue)
return _reply_bad_gateway(args, SYSERR("Service upstream disabled"));
if (NULL != (err = _cs_check_tokens(args)))
return _reply_notfound_error (args, err);
struct service_info_s *si = NULL;
err = service_info_load_json_object (jsrv, &si, TRUE);
if (err) {
g_prefix_error (&err, "JSON error: ");
if (err->code == CODE_BAD_REQUEST)
return _reply_format_error (args, err);
else
return _reply_system_error (args, err);
}
if (!si->type[0]) {
service_info_clean (si);
return _reply_format_error (args, BADREQ("Service type not specified"));
}
if (!si->ns_name[0]) {
GRID_TRACE2("%s NS forced to %s", __FUNCTION__, si->ns_name);
g_strlcpy (si->ns_name, nsname, sizeof(si->ns_name));
} else if (!validate_namespace (si->ns_name)) {
service_info_clean (si);
return _reply_format_error (args, BADNS());
}
gchar *k = service_info_key (si);
STRING_STACKIFY(k);
GRID_TRACE2("%s op=%s score=%d key=[%s]", __FUNCTION__,
_regop_2str(op), si->score.value, k);
switch (op) {
case REGOP_PUSH:
si->score.value = SCORE_UNSET;
if (!service_is_known (k)) {
service_learn (k);
service_tag_set_value_boolean (service_info_ensure_tag (
si->tags, NAME_TAGNAME_RAWX_FIRST), TRUE);
}
break;
case REGOP_LOCK:
si->score.value = CLAMP(si->score.value, SCORE_DOWN, SCORE_MAX);
break;
case REGOP_UNLOCK:
si->score.value = SCORE_UNLOCK;
break;
default:
g_assert_not_reached();
}
if (cs_expire_local_services > 0) {
struct service_info_s *v = service_info_dup (si);
v->score.timestamp = oio_ext_monotonic_seconds ();
PUSH_DO(
const struct service_info_s *si0 = lru_tree_get(srv_registered, k);
if (si0) v->score.value = si0->score.value;
lru_tree_insert (srv_registered, g_strdup(k), v);
);
}
static GError *
_client_manage_reply(struct gridd_client_s *client, MESSAGE reply)
{
GError *err;
guint status = 0;
gchar *message = NULL;
if (NULL != (err = metaXClient_reply_simple(reply, &status, &message))) {
g_prefix_error (&err, "reply: ");
return err;
}
STRING_STACKIFY(message);
if (CODE_IS_NETWORK_ERROR(status)) {
err = NEWERROR(status, "net error: %s", message);
metautils_pclose(&(client->fd));
client->step = STATUS_FAILED;
return err;
}
if (status == CODE_TEMPORARY) {
client->step = REP_READING_SIZE;
return NULL;
}
if (CODE_IS_OK(status)) {
client->step = (status==CODE_FINAL_OK) ? STATUS_OK : REP_READING_SIZE;
if (client->step == STATUS_OK) {
if (!client->keepalive)
metautils_pclose(&(client->fd));
}
if (client->on_reply) {
if (!client->on_reply(client->ctx, reply))
return NEWERROR(CODE_INTERNAL_ERROR, "Handler error");
}
return NULL;
}
if (status == CODE_REDIRECT && !client->forbid_redirect) {
/* Reset the context */
_client_reset_reply(client);
_client_reset_cnx(client);
client->sent_bytes = 0;
if ((++ client->nb_redirects) > 3)
return NEWERROR(CODE_TOOMANY_REDIRECT, "Too many redirections");
/* Replace the URL */
g_strlcpy(client->url, message, URL_MAXLEN);
if (NULL != (err = _client_connect(client)))
g_prefix_error(&err, "Redirection error: Connect error: ");
return err;
}
/* all other are considered errors */
if (status != CODE_REDIRECT)
err = NEWERROR(status, "Request error: %s", message);
else
err = NEWERROR(status, "%s", message);
if (!client->keepalive)
_client_reset_cnx(client);
_client_reset_reply(client);
return err;
}
