static MESSAGE
make_srv_request(const gchar *rn, struct sqlxsrv_name_s *name)
{
MESSAGE req = NULL;
gchar strcid[65], strseq[32];
GByteArray *gba_cid;
gba_cid = metautils_gba_from_cid(*(name->cid));
memset(strcid, 0, sizeof(strcid));
buffer2str(name->cid, sizeof(container_id_t), strcid, sizeof(strcid));
g_snprintf(strseq, sizeof(strseq), "%"G_GINT64_FORMAT, name->seq);
req = message_create_request(NULL, NULL, rn, NULL, NULL);
message_add_fields_str(req,
"BASE_SEQ", strseq,
"BASE_NAME", strcid,
"BASE_TYPE", name->schema,
"SCHEMA", name->schema,
"NAMESPACE", name->ns,
"VIRTUAL_NAMESPACE", name->ns,
NULL);
message_add_fields_gba(req,
"CONTAINER_ID", gba_cid,
NULL);
g_byte_array_free(gba_cid, TRUE);
return req;
}
GByteArray*
m2v2_remote_pack_DESTROY(GByteArray *sid, struct hc_url_s *url, guint32 flags)
{
struct message_s *msg;
msg = _m2v2_build_request("M2V2_DESTROY", sid, url, NULL);
if (flags & M2V2_DESTROY_FORCE)
message_add_fields_str(msg, "FORCE", "1", NULL);
if (flags & M2V2_DESTROY_FLUSH)
message_add_fields_str(msg, "FLUSH", "1", NULL);
if (flags & M2V2_DESTROY_PURGE)
message_add_fields_str(msg, "PURGE", "1", NULL);
if (flags & M2V2_DESTROY_LOCAL)
message_add_fields_str(msg, "LOCAL", "1", NULL);
return message_marshall_gba_and_clean(msg);
}
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);
}
GByteArray*
sqlx_pack_PIPETO(struct sqlx_name_s *name, const gchar *target)
{
MESSAGE req;
GByteArray *gba;
req = make_request("SQLX_PIPETO", name);
message_add_fields_str(req, "DST", target, NULL);
gba = message_marshall_gba(req, NULL);
(void) message_destroy(req, NULL);
return gba;
}
GByteArray*
sqlx_pack_PIPEFROM(struct sqlx_name_s *name, const gchar *source)
{
MESSAGE req;
GByteArray *gba;
req = make_request("SQLX_PIPEFROM", name);
message_add_fields_str(req, "SRC", source, NULL);
gba = message_marshall_gba(req, NULL);
(void) message_destroy(req, NULL);
return gba;
}
GByteArray*
m2v2_remote_pack_GET_BY_CHUNK(GByteArray *sid, struct hc_url_s *url,
const gchar *chunk_id, gint64 limit)
{
struct message_s *msg;
gchar limit_str[16];
g_snprintf(limit_str, 16, "%"G_GINT64_FORMAT, limit);
msg = _m2v2_build_request("M2V2_GET", sid, url, NULL);
message_add_fields_str(msg,
M2_KEY_CHUNK_ID, chunk_id,
M2_KEY_MAX_KEYS, limit_str,
NULL);
return message_marshall_gba_and_clean(msg);
}
GByteArray*
m2v2_remote_pack_BEANS(GByteArray *sid, struct hc_url_s *url,
const gchar *pol, gint64 size, gboolean append)
{
gchar strsize[128];
struct message_s *msg;
g_snprintf(strsize, sizeof(strsize), "%"G_GINT64_FORMAT, size);
msg = _m2v2_build_request("M2V2_BEANS", sid, url, NULL);
if(!append) {
message_add_fields_str(msg,
NAME_MSGKEY_CONTENTLENGTH, strsize,
"STORAGE_POLICY", pol, NULL);
} else {
message_add_fields_str(msg,
NAME_MSGKEY_CONTENTLENGTH, strsize,
"APPEND", "true",
"STORAGE_POLICY", pol, NULL);
}
/* si policy est NULL, le paramètre ne sera pas ajouté. On profite que
* ce soit ldernier argument de la liste */
return message_marshall_gba_and_clean(msg);
}
GByteArray *
sqlx_pack_ADMSET(struct sqlx_name_s *name, const gchar *k, const gchar *v)
{
GByteArray *encoded;
MESSAGE req;
EXTRA_ASSERT(name != NULL);
req = make_request("SQLX_GETADM", name);
message_add_fields_str(req, "K", k, "V", v, NULL);
encoded = message_marshall_gba(req, NULL);
(void) message_destroy(req, NULL);
return encoded;
}
static MESSAGE
make_request(const gchar *rn, struct sqlx_name_s *name)
{
MESSAGE req = NULL;
req = message_create_request(NULL, NULL, rn, NULL, NULL);
message_add_fields_str(req,
"BASE_NAME", name->base,
"BASE_TYPE", name->type,
"NAMESPACE", name->ns,
"VIRTUAL_NAMESPACE", name->ns,
NULL);
return req;
}
GByteArray*
m2v2_remote_pack_SPARE(GByteArray *sid, struct hc_url_s *url,
const gchar *pol, GSList *notin_list, GSList *broken_list)
{
struct message_s *msg;
gchar *spare_type = M2V2_SPARE_BY_STGPOL;
GByteArray *body = NULL;
GSList *beans = NULL;
if (notin_list != NULL) {
spare_type = M2V2_SPARE_BY_BLACKLIST;
for (GSList *l = notin_list; l != NULL; l = l->next) {
if (DESCR(l->data) != &descr_struct_CHUNKS)
continue;
beans = g_slist_prepend(beans, _bean_dup(l->data));
}
}
for (GSList *l = broken_list; l != NULL; l = l->next) {
if (DESCR(l->data) != &descr_struct_CHUNKS)
continue;
struct bean_CHUNKS_s *chunk = _bean_dup(l->data);
// This makes difference between valid and broken chunks
CHUNKS_set_size(chunk, -1);
beans = g_slist_prepend(beans, chunk);
}
/* body is only mandatory for M2V2_SPARE_BY_BLACKLIST so when
* notin_list != NULL. If not_in_list != NULL, beans is always
* != NULL so body is sent.
*/
if (beans != NULL)
body = bean_sequence_marshall(beans);
msg = _m2v2_build_request("M2V2_BEANS", sid, url, body);
message_add_fields_str(msg,
M2_KEY_STORAGE_POLICY, pol,
M2_KEY_SPARE, spare_type,
NULL);
_bean_cleanl2(beans);
return message_marshall_gba_and_clean(msg);
}
void
gcluster_update_conf(addr_info_t * addr, long timeout, const gchar *srv_type,
GHashTable *options, gboolean no_overwrite, GError **error)
{
static struct code_handler_s codes[] = {
{200, REPSEQ_FINAL, NULL, NULL},
{0, 0, NULL, NULL}
};
struct reply_sequence_data_s data = { NULL, 0, codes };
MESSAGE req = NULL;
GString *body = g_string_sized_new(64);
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init(&iter, options);
while (g_hash_table_iter_next(&iter, &key, &value)) {
if (!value)
value = "";
if (srv_type)
g_string_append_printf(body, "%s_%s=%s\n",
srv_type, (gchar*)key, (gchar*)value);
else
g_string_append_printf(body, "%s=%s\n",
(gchar*)key, (gchar*)value);
}
req = build_request(NAME_MSGNAME_OCTO_CONF_UPDATE, body->str, body->len,
error);
g_string_free(body, TRUE);
if (!req)
return;
if (no_overwrite)
message_add_fields_str(req, NAME_HEADER_NO_OVERWRITE, "True", NULL);
metaXClient_reply_sequence_run_from_addrinfo(error, req, addr,
timeout, &data);
message_destroy(req, NULL);
}
GByteArray*
sqlx_pack_QUERY(struct sqlxsrv_name_s *name, const gchar *query,
struct TableSequence *params, gboolean autocreate)
{
MESSAGE req;
guint8 ac = (guint8) autocreate;
EXTRA_ASSERT(name != NULL);
EXTRA_ASSERT(query != NULL);
req = make_srv_request("SQLX_QUERY", name);
message_add_field(req, "AUTOCREATE", 10, &ac, 1, NULL);
message_add_fields_str(req, "QUERY", query, NULL);
if (!params) {
GByteArray *body;
body = sqlx_encode_TableSequence(params, NULL);
message_set_BODY(req, body->data, body->len, NULL);
g_byte_array_free(body, TRUE);
}
return message_marshall_gba_and_clean(req);
}
