GError*
meta0_remote_cache_refresh(const char *m0)
{
GByteArray *gba = message_marshall_gba_and_clean (
metautils_message_create_named (NAME_MSGNAME_M0_RELOAD));
return _m0_remote_no_return (m0, gba);
}
GError *
meta0_remote_get_meta1_all(const char *m0, GSList **out)
{
GByteArray *req = message_marshall_gba_and_clean (
metautils_message_create_named (NAME_MSGNAME_M0_GETALL));
return _m0_remote_m0info (m0, req, out);
}
static GError *
_remote_ping (const char *to)
{
GByteArray *encoded = message_marshall_gba_and_clean (
metautils_message_create_named("REQ_PING"));
return gridd_client_exec (to, 30.0, encoded);
}
GError *
conscience_remote_get_types(const char *cs, GSList **out)
{
MESSAGE req = metautils_message_create_named (NAME_MSGNAME_CS_GET_SRVNAMES);
return gridd_client_exec_and_decode (cs, CS_CLIENT_TIMEOUT,
message_marshall_gba_and_clean(req), out, strings_unmarshall);
}
enum http_rc_e
action_forward_stats (struct req_args_s *args)
{
const char *id = OPT("id");
if (!id)
return _reply_format_error (args, BADREQ("Missing SRVID"));
args->rp->no_access();
MESSAGE req = metautils_message_create_named("REQ_STATS");
GByteArray *encoded = message_marshall_gba_and_clean (req);
gchar *packed = NULL;
GError *err = gridd_client_exec_and_concat_string (id, 1.0, encoded, &packed);
if (err) {
g_free0 (packed);
if (CODE_IS_NETWORK_ERROR(err->code)) {
if (err->code == ERRCODE_CONN_TIMEOUT || err->code == ERRCODE_READ_TIMEOUT)
return _reply_gateway_timeout (args, err);
return _reply_srv_unavailable (args, err);
}
return _reply_common_error (args, err);
}
for (gchar *s=packed; *s ;++s) { if (*s == '=') *s = ' '; }
/* TODO(jfs): quite duplicated from _reply_json() but the original
was not suitable. */
args->rp->set_status (200, "OK");
args->rp->set_body_bytes (g_bytes_new_take((guint8*)packed, strlen(packed)));
args->rp->finalize ();
return HTTPRC_DONE;
}
static GError *
_remote_version (const char *to, gchar **out)
{
GByteArray *encoded = message_marshall_gba_and_clean (
metautils_message_create_named("REQ_VERSION"));
return gridd_client_exec_and_concat_string (to, 30.0, encoded, out);
}
GError *
meta0_remote_cache_reset (const char *m0, gboolean local)
{
MESSAGE req = metautils_message_create_named (NAME_MSGNAME_M0_RESET);
if (local)
metautils_message_add_field_struint(req, NAME_MSGKEY_LOCAL, 1);
return _m0_remote_no_return (m0, message_marshall_gba_and_clean (req));
}
GError*
meta0_remote_get_meta1_one(const char *m0, const guint8 *prefix,
GSList **out)
{
MESSAGE request = metautils_message_create_named (NAME_MSGNAME_M0_GETONE);
metautils_message_add_field (request, NAME_MSGKEY_PREFIX, prefix, 2);
return _m0_remote_m0info (m0, message_marshall_gba_and_clean (request), out);
}
GError*
meta0_remote_assign(const char *m0, gboolean nocheck)
{
MESSAGE request = metautils_message_create_named(NAME_MSGNAME_M0_ASSIGN);
if (nocheck)
metautils_message_add_field_str (request, NAME_MSGKEY_NOCHECK, "yes");
return _m0_remote_no_return (m0, message_marshall_gba_and_clean(request));
}
GError *
conscience_remote_push_services(const char *cs, GSList *ls)
{
MESSAGE req = metautils_message_create_named (NAME_MSGNAME_CS_PUSH_SRV);
metautils_message_add_body_unref (req, service_info_marshall_gba (ls, NULL));
return gridd_client_exec (cs, CS_CLIENT_TIMEOUT,
message_marshall_gba_and_clean(req));
}
static MESSAGE
make_request(const gchar *rn, struct sqlx_name_s *name)
{
MESSAGE req = metautils_message_create_named(rn);
metautils_message_add_field_str(req, NAME_MSGKEY_BASENAME, name->base);
metautils_message_add_field_str(req, NAME_MSGKEY_BASETYPE, name->type);
metautils_message_add_field_str(req, NAME_MSGKEY_NAMESPACE, name->ns);
return req;
}
GError*
meta0_remote_destroy_meta0zknode(const char *m0, const char *urls)
{
if (!urls || !*urls)
return NEWERROR(CODE_BAD_REQUEST, "Too few URL's");
MESSAGE request = metautils_message_create_named(NAME_MSGNAME_M0_DESTROY_META0ZKNODE);
metautils_message_add_field_str (request, NAME_MSGKEY_METAURL, urls);
return _m0_remote_no_return (m0, message_marshall_gba_and_clean(request));
}
GError*
conscience_remote_remove_services(const char *cs, const char *type, GSList *ls)
{
MESSAGE req = metautils_message_create_named (NAME_MSGNAME_CS_RM_SRV);
if (ls)
metautils_message_add_body_unref (req, service_info_marshall_gba (ls, NULL));
if (type) metautils_message_add_field_str (req, NAME_MSGKEY_TYPENAME, type);
return gridd_client_exec (cs, CS_CLIENT_TIMEOUT,
message_marshall_gba_and_clean(req));
}
GError*
meta0_remote_fill_v2(const char *m0, guint nbreplicas, gboolean nodist)
{
if (nbreplicas < 1)
return NEWERROR(CODE_BAD_REQUEST, "Too few replicas");
MESSAGE request = metautils_message_create_named(NAME_MSGNAME_M0_V2_FILL);
metautils_message_add_field_strint64(request, NAME_MSGKEY_REPLICAS, nbreplicas);
if (nodist)
metautils_message_add_field_struint(request, NAME_MSGKEY_NODIST, nodist);
return _m0_remote_no_return (m0, message_marshall_gba_and_clean(request));
}
GError *
conscience_remote_get_services(const char *cs, const char *type, gboolean full,
GSList **out)
{
EXTRA_ASSERT(type != NULL);
MESSAGE req = metautils_message_create_named(NAME_MSGNAME_CS_GET_SRV);
metautils_message_add_field_str (req, NAME_MSGKEY_TYPENAME, type);
if (full)
metautils_message_add_field_str(req, NAME_MSGKEY_FULL, "1");
return gridd_client_exec_and_decode (cs, CS_CLIENT_TIMEOUT,
message_marshall_gba_and_clean(req), out, service_info_unmarshall);
}
static MESSAGE
_m2v2_build_request(const char *name, struct oio_url_s *url, GByteArray *body)
{
EXTRA_ASSERT(name != NULL);
EXTRA_ASSERT(url != NULL);
MESSAGE msg = metautils_message_create_named(name);
metautils_message_add_url (msg, url);
if (body)
metautils_message_add_body_unref (msg, body);
return msg;
}
GError *
gcluster_push_services(addr_info_t * addr, long timeout, GSList *ls)
{
EXTRA_ASSERT (addr != NULL);
gchar target[STRLEN_ADDRINFO];
grid_addrinfo_to_string (addr, target, sizeof(target));
MESSAGE req = metautils_message_create_named (NAME_MSGNAME_CS_PUSH_SRV);
metautils_message_add_body_unref (req, service_info_marshall_gba (ls, NULL));
return gridd_client_exec (target, ((gdouble)timeout)/1000.0,
message_marshall_gba_and_clean(req));
}
GError*
meta0_remote_disable_meta1(const char *m0, gchar **urls, gboolean nocheck)
{
if (!urls || !*urls)
return NEWERROR(CODE_BAD_REQUEST, "Too few URL's");
MESSAGE request = metautils_message_create_named(NAME_MSGNAME_M0_DISABLE_META1);
if (nocheck)
metautils_message_add_field_str(request, NAME_MSGKEY_NOCHECK, "yes");
gchar *body = g_strjoinv("\n", urls);
metautils_message_set_BODY(request, body, strlen(body));
g_free(body);
return _m0_remote_no_return (m0, message_marshall_gba_and_clean(request));
}
GError * conscience_remote_get_types(const char *cs, gchar ***out) {
MESSAGE req = metautils_message_create_named (NAME_MSGNAME_CS_GET_SRVNAMES);
gchar *json = NULL;
GError *err = gridd_client_exec_and_concat_string (cs, CS_CLIENT_TIMEOUT,
message_marshall_gba_and_clean(req), &json);
EXTRA_ASSERT((err != NULL) ^ (json != NULL));
if (!err) {
err = STRV_decode_buffer((guint8*)json, strlen(json), out);
if (out) {
EXTRA_ASSERT((err != NULL) ^ (*out != NULL));
}
g_free(json);
}
return err;
}
GError*
meta0_remote_fill(const char *m0, gchar **urls, guint nbreplicas)
{
if (nbreplicas < 1)
return NEWERROR(CODE_BAD_REQUEST, "Too few replicas");
if (!urls || !*urls)
return NEWERROR(CODE_BAD_REQUEST, "Too few URL's");
if (nbreplicas > g_strv_length(urls))
return NEWERROR(CODE_BAD_REQUEST, "Too many replicas for the URL's set");
MESSAGE request = metautils_message_create_named(NAME_MSGNAME_M0_FILL);
metautils_message_add_field_strint64(request, NAME_MSGKEY_REPLICAS, nbreplicas);
gchar *body = g_strjoinv("\n", urls);
metautils_message_set_BODY(request, body, strlen(body));
g_free(body);
return _m0_remote_no_return (m0, message_marshall_gba_and_clean(request));
}
static GError *
_remote_stat (const char *to, gchar ***out)
{
MESSAGE req = metautils_message_create_named("REQ_STATS");
GByteArray *encoded = message_marshall_gba_and_clean (req);
gchar *packed = NULL;
GError *err = gridd_client_exec_and_concat_string (to, 30.0, encoded, &packed);
if (err) {
g_free0 (packed);
return err;
}
*out = metautils_decode_lines(packed, packed + strlen(packed));
g_free0 (packed);
return NULL;
}
GSList *
gcluster_get_service_types(addr_info_t *addr, long timeout, GError ** error)
{
EXTRA_ASSERT (addr != NULL);
gchar target[STRLEN_ADDRINFO];
grid_addrinfo_to_string (addr, target, sizeof(target));
GSList *out = NULL;
MESSAGE req = metautils_message_create_named (NAME_MSGNAME_CS_GET_SRVNAMES);
GError *err = gridd_client_exec_and_decode (target, ((gdouble)timeout)/1000.0,
message_marshall_gba_and_clean(req), &out, strings_unmarshall);
if (err) {
g_prefix_error (&err, "Remote: ");
g_error_transmit(error, err);
}
return out;
}
GHashTable*
gridd_stats_remote (addr_info_t *ai, gint ms, GError **err, const gchar *pattern)
{
GHashTable *ht=NULL;
struct code_handler_s codes [] = {
{ CODE_FINAL_OK, REPSEQ_FINAL, NULL, field_extractor },
{ CODE_PARTIAL_CONTENT, 0, NULL, field_extractor },
{ 0, 0, NULL, NULL },
};
struct reply_sequence_data_s data = { &ht , 0 , codes };
/*create the result hash table*/
ht = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
if (!ht) {
GSETERROR(err, "cannot create a hashtable");
return NULL;
}
/*create and fill the request*/
GByteArray *gba_pattern = g_byte_array_append(g_byte_array_new(), (guint8*)pattern, strlen(pattern));
MESSAGE request = metautils_message_create_named("REQ_STATS");
metautils_message_add_fields_gba (request, MSGKEY_PATTERN, gba_pattern, NULL);
g_byte_array_free(gba_pattern, TRUE);
if (!request) {
GSETERROR(err, "Cannot create a message");
goto errorLabel;
}
/*run the reply sequence*/
if (!metaXClient_reply_sequence_run_from_addrinfo(err, request, ai, ms, &data)) {
GSETERROR(err, "Cannot execute the request and parse the answers");
goto errorLabel;
}
metautils_message_destroy (request);
return ht;
errorLabel:
if (ht)
g_hash_table_destroy (ht);
metautils_message_destroy (request);
return NULL;
}
static int
_ping(gchar *dest, gchar *to)
{
gdouble timeout = g_ascii_strtod(to, NULL);
GByteArray *encoded = message_marshall_gba_and_clean (
metautils_message_create_named("REQ_PING"));
gint64 start = oio_ext_monotonic_time();
GError *err = gridd_client_exec(dest, timeout, encoded);
gint64 end = oio_ext_monotonic_time();
if (err) {
g_print("KO (%d) %s\n", err->code, err->message);
g_clear_error(&err);
return 1;
} else {
g_print("OK %lfs\n", (end - start) / (gdouble)G_TIME_SPAN_SECOND);
return 0;
}
}
GError *
conscience_remote_get_namespace (const char *cs, namespace_info_t **out)
{
MESSAGE req = metautils_message_create_named(NAME_MSGNAME_CS_GET_NSINFO);
GByteArray *gba = NULL;
GError *err = gridd_client_exec_and_concat (cs, CS_CLIENT_TIMEOUT,
message_marshall_gba_and_clean(req), &gba);
if (err) {
g_assert (gba == NULL);
g_prefix_error(&err, "request: ");
return err;
}
*out = namespace_info_unmarshall(gba->data, gba->len, &err);
g_byte_array_unref (gba);
if (*out) return NULL;
GSETERROR(&err, "Decoding error");
return err;
}
GSList *
gcluster_get_services(const char *target, gdouble timeout,
const gchar *type, gboolean full, GError ** error)
{
MESSAGE req = metautils_message_create_named(NAME_MSGNAME_CS_GET_SRV);
metautils_message_add_field_str (req, NAME_MSGKEY_TYPENAME, type);
if (full)
metautils_message_add_field_str(req, NAME_MSGKEY_FULL, "1");
GSList *out = NULL;
GError *err = gridd_client_exec_and_decode (target, ((gdouble)timeout)/1000.0,
message_marshall_gba_and_clean(req),
&out, service_info_unmarshall);
if (err) {
g_error_transmit(error, err);
g_slist_free_full (out, (GDestroyNotify)service_info_clean);
}
return out;
}
namespace_info_t *
gcluster_get_namespace_info_full(addr_info_t * addr, long timeout, GError ** error)
{
EXTRA_ASSERT (addr != NULL);
gchar str[STRLEN_ADDRINFO];
addr_info_to_string(addr, str, sizeof(str));
GByteArray *out = NULL;
GError *err = gridd_client_exec_and_concat (str, ((gdouble)timeout)/1000.0,
message_marshall_gba_and_clean(metautils_message_create_named(
NAME_MSGNAME_CS_GET_NSINFO)), &out);
if (err) {
g_prefix_error(&err, "request: ");
g_error_transmit(error, err);
return NULL;
}
namespace_info_t *ns_info = namespace_info_unmarshall(out->data, out->len, error);
if (!ns_info)
GSETERROR(error, "Decoding error");
return ns_info;
}
GByteArray* sqlx_pack_RELOAD (void) {
return message_marshall_gba_and_clean (metautils_message_create_named (
NAME_MSGNAME_SQLX_RELOAD));
}
GByteArray*
sqlx_pack_LEANIFY(void)
{
MESSAGE req = metautils_message_create_named (NAME_MSGNAME_SQLX_LEANIFY);
return message_marshall_gba_and_clean(req);
}
enum http_rc_e
action_forward (struct req_args_s *args)
{
const char *id = OPT("id");
const char *action = TOK("ACTION");
if (!id)
return _reply_format_error (args, BADREQ("Missing SRVID"));
if (!action)
return _reply_format_error (args, BADREQ("Missing action"));
GError *err = NULL;
if (!g_ascii_strcasecmp (action, "flush")) {
err = sqlx_remote_execute_FLUSH (id);
if (!err)
return _reply_success_json (args, NULL);
return _reply_common_error (args, err);
}
if (!g_ascii_strcasecmp (action, "reload")) {
err = sqlx_remote_execute_RELOAD (id);
if (!err)
return _reply_success_json (args, NULL);
return _reply_common_error (args, err);
}
if (!g_ascii_strcasecmp (action, "kill")) {
GByteArray *encoded = message_marshall_gba_and_clean (
metautils_message_create_named("REQ_KILL"));
err = gridd_client_exec (id, 1.0, encoded);
if (err)
return _reply_common_error (args, err);
return _reply_success_json (args, NULL);
}
if (!g_ascii_strcasecmp (action, "ping")) {
args->rp->no_access();
GByteArray *encoded = message_marshall_gba_and_clean (
metautils_message_create_named("REQ_PING"));
err = gridd_client_exec (id, 1.0, encoded);
if (err)
return _reply_common_error (args, err);
return _reply_success_json (args, NULL);
}
if (!g_ascii_strcasecmp (action, "lean-glib")) {
MESSAGE req = metautils_message_create_named("REQ_LEAN");
metautils_message_add_field_str(req, "LIBC", "1");
metautils_message_add_field_str(req, "THREADS", "1");
GByteArray *encoded = message_marshall_gba_and_clean (req);
err = gridd_client_exec (id, 1.0, encoded);
if (err)
return _reply_common_error (args, err);
return _reply_success_json (args, NULL);
}
if (!g_ascii_strcasecmp (action, "lean-sqlx")) {
GByteArray *encoded = message_marshall_gba_and_clean (
metautils_message_create_named(NAME_MSGNAME_SQLX_LEANIFY));
err = gridd_client_exec (id, 1.0, encoded);
if (err)
return _reply_common_error (args, err);
return _reply_success_json (args, NULL);
}
if (!g_ascii_strcasecmp (action, "version")) {
args->rp->no_access();
MESSAGE req = metautils_message_create_named("REQ_VERSION");
GByteArray *encoded = message_marshall_gba_and_clean (req);
gchar *packed = NULL;
err = gridd_client_exec_and_concat_string (id, 1.0, encoded, &packed);
if (err) {
g_free0 (packed);
return _reply_common_error (args, err);
}
/* TODO(jfs): quite duplicated from _reply_json() but the original
was not suitable. */
args->rp->set_status (200, "OK");
args->rp->set_body_bytes (g_bytes_new_take((guint8*)packed, strlen(packed)));
args->rp->finalize ();
return HTTPRC_DONE;
}
if (!g_ascii_strcasecmp (action, "handlers")) {
args->rp->no_access();
MESSAGE req = metautils_message_create_named("REQ_HANDLERS");
GByteArray *encoded = message_marshall_gba_and_clean (req);
gchar *packed = NULL;
err = gridd_client_exec_and_concat_string (id, 1.0, encoded, &packed);
if (err) {
g_free0 (packed);
return _reply_common_error (args, err);
}
/* TODO(jfs): quite duplicated from _reply_json() but the original
was not suitable. */
args->rp->set_status (200, "OK");
args->rp->set_body_bytes (g_bytes_new_take((guint8*)packed, strlen(packed)));
args->rp->finalize ();
return HTTPRC_DONE;
}
return _reply_common_error (args, BADREQ("unexpected action"));
}
