static void
_dump_chunks_xml_NORMAL(const struct loc_context_s *lc, GString **s)
{
chunk_pair_t *current = NULL;
for(guint i=0; i < lc->rc->pairs->len; i++) {
current = &g_array_index(lc->rc->pairs, chunk_pair_t, i);
GByteArray *hash = CHUNKS_get_hash(current->chunk);
char str_hash[1 + sizeof(chunk_hash_t) * 2];
oio_str_bin2hex(hash->data, hash->len, str_hash, sizeof(str_hash));
char *loc = _chunk_location_row_xml(lc,
CHUNKS_get_id(current->chunk)->str, "");
g_string_append_printf(*s,
" <chunk>\n"
" <locations>\n"
"%s"
" </locations>\n"
" <position>%d</position>\n"
" <size>%"G_GINT64_FORMAT"</size>\n"
" <md5>%s</md5>\n"
" </chunk>\n",
loc,
current->position.meta,
CHUNKS_get_size(current->chunk),
str_hash);
g_free(loc);
}
}
static void
_dump_chunks_xml_DUPLI(const struct loc_context_s *lc, GString **s)
{
chunk_pair_t *base = NULL;
chunk_pair_t *current = NULL;
int copies = 0;
GString *urls = NULL;
void _append(void) {
GByteArray *hash = CHUNKS_get_hash(base->chunk);
char str_hash[1 + sizeof(chunk_hash_t) * 2];
oio_str_bin2hex(hash->data, hash->len, str_hash, sizeof(str_hash));
g_string_append_printf(*s,
" <chunk>\n"
" <nb-copies>%d</nb-copies>"
" <locations>\n"
"%s"
" </locations>\n"
" <position>%d</position>\n"
" <size>%"G_GINT64_FORMAT"</size>\n"
" <md5>%s</md5>\n"
" </chunk>\n",
copies,
urls->str,
base->position.meta,
CHUNKS_get_size(base->chunk),
str_hash);
g_string_free(urls, TRUE);
}
int
main(int argc, char ** args)
{
int i;
for (i=1; i<argc ;i++) {
struct hc_url_s *url = hc_url_oldinit(args[i]);
if (url && NULL != hc_url_get_id(url)) {
memset(str_id, 0, sizeof(str_id));
oio_str_bin2hex(hc_url_get_id(url), hc_url_get_id_size(url),
str_id, sizeof(str_id));
fputs(str_id, stdout);
}
else {
fputs(bad, stdout);
}
fputc(' ', stdout);
fputs(args[i], stdout);
fputc('\n', stdout);
if (url)
hc_url_clean(url);
}
fflush(stdout);
return 0;
}
static gboolean
_zmq2agent_manage_event (guint32 r, struct _zmq2agent_ctx_s *ctx, zmq_msg_t *msg)
{
const time_t now = oio_ext_monotonic_seconds();
if (!ctx->zagent) return TRUE;
const size_t len = zmq_msg_size(msg);
struct event_s *evt = g_malloc (sizeof(struct event_s) + len);
memcpy (evt->message, zmq_msg_data(msg), len);
evt->last_sent = now;
evt->rand = r;
evt->evtid = ctx->q->counter ++;
evt->procid = ctx->q->procid;
evt->size = len;
evt->recv_time = evt->last_sent;
ctx->pending_events = g_list_prepend (ctx->pending_events, evt);
ctx->q->gauge_pending ++;
gchar strid[1+ 2*HEADER_SIZE];
oio_str_bin2hex(evt, HEADER_SIZE, strid, sizeof(strid));
GRID_DEBUG("EVT:DEF %s (%u) %.*s", strid,
ctx->q->gauge_pending, evt->size, evt->message);
return _zmq2agent_send_event (now, ctx, evt, strid);
}
static void
chunk_id2str (const gs_chunk_t *chunk, char *d, size_t dS)
{
EXTRA_ASSERT(chunk);
EXTRA_ASSERT(d);
oio_str_bin2hex (chunk->ci->id.id, sizeof(chunk->ci->id.id), d, dS);
}
static void
_dump_cid (const char *s)
{
static gchar bad[] = {
'-', '-', '-', '-', '-', '-', '-', '-',
'-', '-', '-', '-', '-', '-', '-', '-',
'-', '-', '-', '-', '-', '-', '-', '-',
'-', '-', '-', '-', '-', '-', '-', '-',
'-', '-', '-', '-', '-', '-', '-', '-',
'-', '-', '-', '-', '-', '-', '-', '-',
'-', '-', '-', '-', '-', '-', '-', '-',
'-', '-', '-', '-', '-', '-', '-', '-',
0
};
char str_id[128];
const char *dst;
struct oio_url_s *url = oio_url_init (s);
if (url && NULL != oio_url_get_id(url)) {
memset(str_id, 0, sizeof(str_id));
oio_str_bin2hex(oio_url_get_id(url), oio_url_get_id_size(url),
str_id, sizeof(str_id));
dst = str_id;
}
else {
dst = bad;
}
g_print("%s %s\n", dst, s);
oio_url_clean(url);
}
void
oio_ext_set_random_reqid (void)
{
struct {
pid_t pid:16;
guint8 buf[14];
} bulk;
bulk.pid = getpid();
oio_str_randomize(bulk.buf, sizeof(bulk.buf));
char hex[33];
oio_str_bin2hex((guint8*)&bulk, sizeof(bulk), hex, sizeof(hex));
oio_ext_set_reqid(hex);
}
static void
_dump_addr (const char *s)
{
gchar str[256], hexa[1024];
struct addr_info_s addr;
if (grid_string_to_addrinfo(s, &addr)) {
memset(str, 0, sizeof(str));
grid_addrinfo_to_string(&addr, str, sizeof(str));
memset(hexa, 0, sizeof(hexa));
oio_str_bin2hex(&addr, sizeof(addr), hexa, sizeof(hexa));
g_print("%s %s\n", str, hexa);
}
}
static void
_retry_events (struct _zmq2agent_ctx_s *ctx)
{
gchar strid[1+(2*HEADER_SIZE)];
const time_t now = oio_ext_monotonic_seconds ();
const time_t oldest = now > 5 ? now - 5 : 0;
for (GList *l=g_list_last(ctx->pending_events); l ;l=l->prev) {
struct event_s *evt = l->data;
if (evt->last_sent < oldest) {
oio_str_bin2hex(evt, HEADER_SIZE, strid, sizeof(strid));
if (!_zmq2agent_send_event (now, ctx, evt, strid))
break;
}
}
}
// TODO: factorize with _gen_chunk() from meta2_utils.c
static gpointer
_gen_chunk_bean(const char *straddr)
{
guint8 binid[32];
gchar strid[65];
gchar *chunkid = NULL;
struct bean_CHUNKS_s *chunk = NULL;
oio_buf_randomize (binid, sizeof(binid));
oio_str_bin2hex (binid, sizeof(binid), strid, sizeof(strid));
chunk = _bean_create(&descr_struct_CHUNKS);
chunkid = m2v2_build_chunk_url (straddr, strid);
CHUNKS_set2_id(chunk, chunkid);
g_free(chunkid);
return (gpointer)chunk;
}
static void
_log_reqid(GString *gs, MESSAGE req)
{
g_string_append_c(gs, ' ');
gsize field_len=0;
void *field = metautils_message_get_ID(req, &field_len);
if (!field || !field_len)
g_string_append_c(gs, '_');
else {
gsize max = field_len * 2 + 2;
char *hex;
hex = g_alloca(max);
memset(hex, 0, max);
oio_str_bin2hex(field, field_len, hex, max);
g_string_append(gs, (gchar*)hex);
}
}
static void
test_bin (void)
{
guint8 buf[64];
gchar str[129];
g_assert_false (oio_str_hex2bin ("0", buf, sizeof(buf)));
g_assert_false (oio_str_hex2bin ("x", buf, sizeof(buf)));
g_assert_false (oio_str_hex2bin ("0x", buf, sizeof(buf)));
g_assert_true (oio_str_hex2bin ("00", buf, 1));
g_assert_false (oio_str_hex2bin ("0000", buf, 1));
g_assert_true (oio_str_hex2bin ("00", buf, sizeof(buf)));
g_assert_true (buf[0] == 0);
g_assert (2 == oio_str_bin2hex (buf, 1, str, sizeof(str)));
g_assert (!g_ascii_strcasecmp(str, "00"));
}
static void
_zmq2agent_manage_ack (struct _zmq2agent_ctx_s *ctx, zmq_msg_t *msg)
{
if (zmq_msg_size (msg) != HEADER_SIZE)
return;
gchar strid[1+(2*HEADER_SIZE)];
void *d = zmq_msg_data (msg);
oio_str_bin2hex(d, HEADER_SIZE, strid, sizeof(strid));
GList *li = g_list_find_custom (ctx->pending_events, d, _cmp);
if (!li) {
GRID_INFO("EVT:OUT %s", strid);
++ ctx->q->counter_ack_notfound;
} else {
GRID_DEBUG("EVT:ACK %s", strid);
ctx->pending_events = g_list_remove_link (ctx->pending_events, li);
g_list_free_full (li, g_free);
-- ctx->q->gauge_pending;
++ ctx->q->counter_ack;
}
}
gboolean
rawx_client_get_directory_data(rawx_session_t * session, hash_sha256_t chunk_id, struct content_textinfo_s *content,
struct chunk_textinfo_s *chunk, GError ** error)
{
int rc;
gchar str_addr[64];
gsize str_addr_size;
gchar str_req[2048];
gchar str_chunk_id[(sizeof(hash_sha256_t) * 2) + 1];
GHashTable *result = NULL;
GByteArray *buffer = NULL;
ne_request *request = NULL;
if (!session) {
GSETERROR(error, "Invalid parameter");
return FALSE;
}
memset(str_chunk_id, '\0', sizeof(str_chunk_id));
oio_str_bin2hex(chunk_id, sizeof(hash_sha256_t), str_chunk_id, sizeof(str_chunk_id));
memset(str_req, '\0', sizeof(str_req));
snprintf(str_req, sizeof(str_req) - 1, "%s/%s", RAWX_REQ_GET_DIRINFO, str_chunk_id);
ne_set_connect_timeout(session->neon_session, session->timeout.cnx / 1000);
ne_set_read_timeout(session->neon_session, session->timeout.req / 1000);
request = ne_request_create(session->neon_session, "HEAD", str_req);
if (!request) {
GSETERROR(error, "neon request creation error");
return FALSE;
}
buffer = g_byte_array_new();
ne_add_response_body_reader(request, ne_accept_2xx, body_reader, buffer);
switch (rc = ne_request_dispatch(request)) {
case NE_OK:
if (ne_get_status(request)->klass != 2) {
GSETERROR(error, "RAWX returned an error %d : %s",
ne_get_status(request)->code, ne_get_status(request)->reason_phrase);
goto error;
}
else if (!(result = header_parser(request))) {
GSETERROR(error, "No attr from the RAWX server");
goto error;
}
break;
case NE_ERROR:
case NE_TIMEOUT:
case NE_CONNECT:
case NE_AUTH:
str_addr_size = addr_info_to_string(&(session->addr), str_addr, sizeof(str_addr));
GSETERROR(error, "cannot download the data from [%.*s]' (%s)",
(int)str_addr_size, str_addr, ne_get_error(session->neon_session));
goto error;
default:
GSETERROR(error, "Unexpected return code from the neon library : %d", rc);
goto error;
}
g_byte_array_free(buffer, TRUE);
ne_request_destroy(request);
/* Fill the textinfo structs */
parse_chunkinfo_from_rawx(result, content, chunk);
g_hash_table_destroy(result);
return TRUE;
error:
g_byte_array_free(buffer, TRUE);
ne_request_destroy(request);
return FALSE;
}
static gboolean
_rawx_update_chunk_attrs(chunk_id_t *cid, GSList *attrs, GError **err)
{
ne_session *s = NULL;
ne_request *r = NULL;
int ne_rc;
gboolean result = FALSE;
gchar dst[128];
guint16 port = 0;
GString *req_str = NULL;
char idstr[65];
if (!addr_info_get_addr(&(cid->addr), dst, sizeof(dst), &port))
return result;
s = ne_session_create("http", dst, port);
if (!s) {
GSETERROR(err, "Failed to create session to rawx %s:%d", dst, port);
return result;
}
ne_set_connect_timeout(s, 10);
ne_set_read_timeout(s, 30);
req_str =g_string_new("/rawx/chunk/set/");
oio_str_bin2hex (&(cid->id), sizeof(cid->id), idstr, sizeof(idstr));
req_str = g_string_append(req_str, idstr);
GRID_TRACE("Calling %s", req_str->str);
r = ne_request_create (s, "GET", req_str->str);
if (!r) {
goto end_attr;
}
for (; attrs != NULL; attrs = attrs->next) {
struct chunk_attr_s *attr = attrs->data;
ne_add_request_header(r, attr->key, attr->val);
}
switch (ne_rc = ne_request_dispatch(r)) {
case NE_OK:
result = TRUE;
break;
case NE_ERROR:
GSETCODE(err, CODE_INTERNAL_ERROR, "Request NE_ERROR");
break;
case NE_TIMEOUT:
GSETCODE(err, CODE_INTERNAL_ERROR, "Request Timeout");
break;
case NE_CONNECT:
GSETCODE(err, CODE_INTERNAL_ERROR, "Request Connection timeout");
break;
default:
GSETCODE(err, CODE_INTERNAL_ERROR, "Request failed");
break;
}
end_attr:
if (NULL != req_str)
g_string_free(req_str, TRUE);
if (NULL != r)
ne_request_destroy (r);
if (NULL != s)
ne_session_destroy (s);
return result;
}
static void
_random_string (gchar *d, gsize dlen)
{
RANDOM_UID (uid,uidlen);
oio_str_bin2hex ((void*)&uid, uidlen, d, dlen);
}
gsize
container_id_to_string(const container_id_t id, gchar * dst, gsize dstsize)
{
return oio_str_bin2hex(id, sizeof(container_id_t), dst, dstsize);
}
