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);
}
GByteArray *
sqlx_pack_PROPDEL(const struct sqlx_name_s *name, const gchar * const *keys)
{
MESSAGE req = make_request(NAME_MSGNAME_SQLX_PROPDEL, name);
metautils_message_add_body_unref(req, STRV_encode_gba((gchar**)keys));
return message_marshall_gba_and_clean(req);
}
GByteArray*
sqlx_pack_PIPEFROM(const struct sqlx_name_s *name, const gchar *source)
{
MESSAGE req = make_request(NAME_MSGNAME_SQLX_PIPEFROM, name);
metautils_message_add_field_str(req, NAME_MSGKEY_SRC, source);
return message_marshall_gba_and_clean(req);
}
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);
}
gint
reply_context_reply (struct reply_context_s *ctx, GError **err)
{
EXTRA_ASSERT (ctx != NULL);
register gchar *ptr_msg = ctx->header.msg ? ctx->header.msg : "NOMSG";
MESSAGE answer = metaXServer_reply_simple (ctx->req_ctx->request, ctx->header.code, ptr_msg);
if (ctx->extra_headers)
g_hash_table_foreach(ctx->extra_headers, reply_ctx_header_adder, answer);
if (ctx->body.buffer && (ctx->body.size > 0))
metautils_message_set_BODY(answer, ctx->body.buffer, ctx->body.size);
GByteArray *encoded = message_marshall_gba_and_clean(answer);
answer = NULL;
if (encoded) {
gint _to = MAX(MS_REPLY_TIMEOUT, MIN(60000, default_to_operation));
gint sent = sock_to_write(ctx->req_ctx->fd, _to, encoded->data, encoded->len, err);
gboolean done = (sent > 0) && (encoded->len == (guint)sent);
g_byte_array_unref (encoded);
if (!done) {
g_prefix_error(err, "Failed to reply: ");
return 0;
}
}
return 1;
}
GByteArray*
sqlx_pack_PIPETO(const struct sqlx_name_s *name, const gchar *target)
{
MESSAGE req = make_request(NAME_MSGNAME_SQLX_PIPETO, name);
metautils_message_add_field_str(req, NAME_MSGKEY_DST, target);
return message_marshall_gba_and_clean(req);
}
GByteArray*
sqlx_pack_DUMP(const struct sqlx_name_s *name, gboolean chunked)
{
MESSAGE req = make_request(NAME_MSGNAME_SQLX_DUMP, name);
metautils_message_add_field(req, NAME_MSGKEY_CHUNKED, &chunked, 1);
return message_marshall_gba_and_clean(req);
}
GByteArray*
sqlx_pack_RESTORE(const struct sqlx_name_s *name, const guint8 *raw, gsize rawsize)
{
MESSAGE req = make_request(NAME_MSGNAME_SQLX_RESTORE, name);
metautils_message_set_BODY(req, raw, rawsize);
return message_marshall_gba_and_clean(req);
}
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, COMMON_STAT_TIMEOUT, 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;
}
GByteArray*
sqlx_pack_GETVERS(const struct sqlx_name_s *name)
{
EXTRA_ASSERT(name != NULL);
MESSAGE req = make_request(NAME_MSGNAME_SQLX_GETVERS, name);
return message_marshall_gba_and_clean(req);
}
static GByteArray*
m2v2_remote_pack_STGPOL(struct oio_url_s *url, const char *pol)
{
MESSAGE msg = _m2v2_build_request(NAME_MSGNAME_M2V2_STGPOL, url, NULL);
metautils_message_add_field_str(msg, NAME_MSGKEY_STGPOLICY, pol);
return message_marshall_gba_and_clean(msg);
}
static GByteArray*
m2v2_remote_pack_LIST(struct oio_url_s *url, struct list_params_s *p)
{
MESSAGE msg = _m2v2_build_request(NAME_MSGNAME_M2V2_LIST, url, NULL);
_pack_list_params (msg, p);
return message_marshall_gba_and_clean(msg);
}
static GByteArray *
_m2v2_pack_request(const gchar *name, GByteArray *sid,
struct hc_url_s *url, GByteArray *body)
{
return message_marshall_gba_and_clean(
_m2v2_build_request(name, sid, url, body));
}
static GByteArray*
m2v2_remote_pack_PUT(struct oio_url_s *url, GSList *beans)
{
GByteArray *body = bean_sequence_marshall(beans);
MESSAGE msg = _m2v2_build_request (NAME_MSGNAME_M2V2_PUT, url, body);
return message_marshall_gba_and_clean(msg);
}
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 *
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 GByteArray*
m2v2_remote_pack_OVERWRITE(struct oio_url_s *url, GSList *beans)
{
GByteArray *body = bean_sequence_marshall(beans);
MESSAGE msg = _m2v2_build_request(NAME_MSGNAME_M2V2_PUT, url, body);
metautils_message_add_field_str(msg, NAME_MSGKEY_OVERWRITE, "1");
return message_marshall_gba_and_clean(msg);
}
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));
}
GByteArray *
sqlx_pack_PROPSET_pairs(struct sqlx_name_s *name, gboolean flush, GSList *pairs)
{
MESSAGE req = make_request(NAME_MSGNAME_SQLX_PROPSET, name);
if (flush)
metautils_message_add_field_strint (req, NAME_MSGKEY_FLUSH, 1);
metautils_message_add_body_unref (req, key_value_pairs_marshall_gba (pairs, NULL));
return message_marshall_gba_and_clean(req);
}
static GByteArray*
m2v2_remote_pack_LIST_BY_CHUNKID(struct oio_url_s *url, struct list_params_s *p,
const char *chunk)
{
MESSAGE msg = _m2v2_build_request(NAME_MSGNAME_M2V2_LCHUNK, url, NULL);
_pack_list_params (msg, p);
metautils_message_add_field_str (msg, NAME_MSGKEY_KEY, chunk);
return message_marshall_gba_and_clean(msg);
}
GByteArray *
sqlx_pack_DESTROY(struct sqlx_name_s *name, gboolean local)
{
gint8 local2 = BOOL(local);
MESSAGE req = make_request(NAME_MSGNAME_SQLX_DESTROY, name);
if (local)
metautils_message_add_field(req, NAME_MSGKEY_LOCAL, &local2, 1);
return message_marshall_gba_and_clean(req);
}
GByteArray *
sqlx_pack_PROPSET_tab(const struct sqlx_name_s *name, gboolean flush, gchar **kv)
{
MESSAGE req = make_request(NAME_MSGNAME_SQLX_PROPSET, name);
if (flush)
metautils_message_add_field_strint (req, NAME_MSGKEY_FLUSH, 1);
metautils_message_add_body_unref (req, KV_encode_gba((gchar**)kv));
return message_marshall_gba_and_clean(req);
}
static GByteArray *
_m2v2_pack_request_with_flags(const char *name, struct oio_url_s *url,
GByteArray *body, guint32 flags)
{
MESSAGE msg = _m2v2_build_request(name, url, body);
flags = g_htonl(flags);
metautils_message_add_field(msg, NAME_MSGKEY_FLAGS, &flags, sizeof(flags));
return message_marshall_gba_and_clean(msg);
}
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));
}
GByteArray*
sqlx_pack_REPLICATE(struct sqlx_name_s *name, struct TableSequence *tabseq)
{
EXTRA_ASSERT(name != NULL);
EXTRA_ASSERT(tabseq != NULL);
MESSAGE req = make_request(NAME_MSGNAME_SQLX_REPLICATE, name);
metautils_message_add_body_unref(req, sqlx_encode_TableSequence(tabseq, NULL));
return message_marshall_gba_and_clean(req);
}
static GByteArray*
m2v2_remote_pack_LIST_BY_HEADERID(struct oio_url_s *url, struct list_params_s *p,
GBytes *h)
{
MESSAGE msg = _m2v2_build_request(NAME_MSGNAME_M2V2_LHID, url, NULL);
_pack_list_params (msg, p);
metautils_message_add_field (msg, NAME_MSGKEY_KEY,
g_bytes_get_data(h,NULL), g_bytes_get_size(h));
return message_marshall_gba_and_clean(msg);
}
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));
}
GByteArray*
m2v2_remote_pack_STGPOL(GByteArray *sid, struct hc_url_s *url,
const gchar *pol)
{
struct message_s *msg;
msg = _m2v2_build_request("M2V2_STGPOL", sid, url, NULL);
message_add_fields_str(msg, "STORAGE_POLICY", pol, NULL);
return message_marshall_gba_and_clean(msg);
}
