ibp_op_t *new_ibp_op(ibp_context_t *ic)
{
ibp_op_t *op;
//** Make the struct and clear it
tbx_type_malloc(op, ibp_op_t, 1);
tbx_atomic_inc(ic->n_ops);
ibp_op_init(ic, op);
return(op);
}
void rsrs_update_register(resource_service_fn_t *rs, mq_frame_t *fid, mq_msg_t *address, int timeout)
{
rs_remote_server_priv_t *rsrs = (rs_remote_server_priv_t *)rs->priv;
rsrs_update_handle_t *h;
tbx_type_malloc(h, rsrs_update_handle_t, 1);
//** Form the core message
h->msg = mq_msg_new();
mq_msg_append_mem(h->msg, MQF_VERSION_KEY, MQF_VERSION_SIZE, MQF_MSG_KEEP_DATA);
mq_msg_append_mem(h->msg, MQF_RESPONSE_KEY, MQF_RESPONSE_SIZE, MQF_MSG_KEEP_DATA);
mq_msg_append_frame(h->msg, fid);
mq_get_frame(fid, (void **)&(h->id), &(h->id_size));
//** Add the empty version frame and track it for filling in later
h->version_frame = mq_frame_new(NULL, 0, MQF_MSG_AUTO_FREE);
mq_msg_append_frame(h->msg, h->version_frame);
//** Add the empty config frame and track it for filling in later
h->config_frame = mq_frame_new(NULL, 0, MQF_MSG_AUTO_FREE);
mq_msg_append_frame(h->msg, h->config_frame);
//** End with an empty frame
mq_msg_append_mem(h->msg, NULL, 0, MQF_MSG_KEEP_DATA);
//** Now address it
mq_apply_return_address_msg(h->msg, address, 0);
//** Figure out when we wake up if no change
if (timeout > 10) {
h->reply_time = apr_time_from_sec(timeout-10);
} else if (timeout > 5) {
h->reply_time = apr_time_from_sec(timeout-5);
} else {
h->reply_time = apr_time_from_sec(1);
}
h->reply_time += apr_time_now();
apr_thread_mutex_lock(rsrs->lock);
//** Add it to the queue
tbx_stack_push(rsrs->pending, h);
//** Check if we need to change when we wake up
if ((h->reply_time < rsrs->wakeup_time) || (rsrs->wakeup_time == 0)) rsrs->wakeup_time = h->reply_time;
log_printf(5, "timeout=%d now=" TT " reply_time=" TT " wakeup=" TT "\n", timeout, apr_time_now(), h->reply_time, rsrs->wakeup_time);
apr_thread_mutex_unlock(rsrs->lock);
}
int zero_native_recv(mq_socket_t *socket, mq_msg_t *msg, int flags)
{
mq_frame_t *f;
int n, nframes, rc;
int64_t more = 0;
size_t msize = sizeof(more);
if ((flags & MQ_DONTWAIT) > 0) {
more = 0;
rc = zmq_getsockopt (socket->arg, ZMQ_EVENTS, &more, &msize);
log_printf(5, "more=" I64T "\n", more);
assert (rc == 0);
if ((more & ZMQ_POLLIN) == 0) return(-1);
}
n = 0;
nframes = 0;
do {
tbx_type_malloc(f, mq_frame_t, 1);
rc = zmq_msg_init(&(f->zmsg));
assert (rc == 0);
rc = zmq_msg_recv(&(f->zmsg), socket->arg, flags);
log_printf(15, "rc=%d errno=%d\n", rc, errno);
assert (rc != -1);
rc = zmq_getsockopt (socket->arg, ZMQ_RCVMORE, &more, &msize);
assert (rc == 0);
f->len = zmq_msg_size(&(f->zmsg));
f->data = zmq_msg_data(&(f->zmsg));
f->auto_free = MQF_MSG_INTERNAL_FREE;
mq_msg_append_frame(msg, f);
n += f->len;
nframes++;
log_printf(5, "more=" I64T "\n", more);
} while (more > 0);
log_printf(5, "total bytes=%d nframes=%d\n", n, nframes);
return((n>0) ? 0 : -1);
}
void _rss_make_check_table(resource_service_fn_t *rs)
{
rs_simple_priv_t *rss = (rs_simple_priv_t *)rs->priv;
rss_check_entry_t *ce, *ce2;
rss_rid_entry_t *re;
int i;
//** Clear out the old one
_rss_clear_check_table(rss->ds, rss->rid_mapping, rss->mpool);
//** Now make the new one
rss->unique_rids = 1;
for (i=0; i<rss->n_rids; i++) {
re = rss->random_array[i];
tbx_type_malloc(ce, rss_check_entry_t, 1);
ce->ds_key = strdup(re->ds_key);
ce->rid_key = strdup(re->rid_key);
ce->space = ds_inquire_create(rss->ds);
ce->re = re;
//** Check for dups. If so we only keep the 1st entry and spew a log message
ce2 = apr_hash_get(rss->rid_mapping, ce->rid_key, APR_HASH_KEY_STRING);
if (ce2 == NULL) { //** Unique so add it
apr_hash_set(rss->rid_mapping, ce->rid_key, APR_HASH_KEY_STRING, ce);
} else { //** Dup so disable dynamic mapping by unsetting unique_rids
log_printf(0, "WARNING duplicate RID found. Dropping dynamic mapping. res=%s --- new res=%s\n", ce2->ds_key, ce->ds_key);
rss->unique_rids = 0;
ds_inquire_destroy(rss->ds, ce->space);
free(ce->rid_key);
free(ce->ds_key);
free(ce);
}
}
return;
}
lio_data_block_t *data_block_deserialize_text(lio_service_manager_t *sm, ex_id_t id, lio_exnode_exchange_t *exp)
{
int bufsize=1024;
char capgrp[bufsize];
char *text, *etext;
int i;
lio_data_block_t *b;
lio_data_service_fn_t *ds;
tbx_inip_file_t *cfd;
tbx_inip_group_t *cg;
tbx_inip_element_t *ele;
char *key;
lio_data_block_attr_t *attr;
//** Parse the ini text
cfd = exp->text.fd;
//** Find the cooresponding cap
snprintf(capgrp, bufsize, "block-" XIDT, id);
cg = tbx_inip_group_find(cfd, capgrp);
if (cg == NULL) {
log_printf(0, "data_block_deserialize_text: id=" XIDT " not found!\n", id);
return(NULL);
}
//** Determine the type and make a blank block
text = tbx_inip_get_string(cfd, capgrp, "type", "");
ds = lio_lookup_service(sm, DS_SM_RUNNING, text);
if (ds == NULL) {
log_printf(0, "data_block_deserialize_text: b->id=" XIDT " Unknown data service tpye=%s!\n", id, text);
return(NULL);;
}
free(text);
//** Make the space
b = data_block_create_with_id(ds, id);
//** and parse the fields
b->rid_key = tbx_inip_get_string(cfd, capgrp, "rid_key", "");
b->size = tbx_inip_get_integer(cfd, capgrp, "size", b->size);
b->max_size = tbx_inip_get_integer(cfd, capgrp, "max_size", b->max_size);
i = tbx_inip_get_integer(cfd, capgrp, "ref_count", b->ref_count);
tbx_atomic_set(b->ref_count, 0);
tbx_atomic_set(b->initial_ref_count, i);
etext = tbx_inip_get_string(cfd, capgrp, "read_cap", "");
ds_set_cap(b->ds, b->cap, DS_CAP_READ, tbx_stk_unescape_text('\\', etext));
free(etext);
etext = tbx_inip_get_string(cfd, capgrp, "write_cap", "");
ds_set_cap(b->ds, b->cap, DS_CAP_WRITE, tbx_stk_unescape_text('\\', etext));
free(etext);
etext = tbx_inip_get_string(cfd, capgrp, "manage_cap", "");
ds_set_cap(b->ds, b->cap, DS_CAP_MANAGE, tbx_stk_unescape_text('\\', etext));
free(etext);
//** Now cycle through any misc attributes set
ele = tbx_inip_ele_first(tbx_inip_group_find(cfd, capgrp));
while (ele != NULL) {
key = tbx_inip_ele_get_key(ele);
//** Ignore the builtin commands
if ((strcmp("rid_key", key) != 0) && (strcmp("size", key) != 0) && (strcmp("max_size", key) != 0) && (strcmp("type", key) != 0) &&
(strcmp("ref_count", key) != 0) && (strcmp("read_cap", key) != 0) && (strcmp("write_cap", key) != 0) && (strcmp("manage_cap", key) != 0)) {
tbx_type_malloc(attr, lio_data_block_attr_t, 1);
attr->key = tbx_stk_unescape_text('\\', tbx_inip_ele_get_key(ele));
attr->value = tbx_stk_unescape_text('\\', tbx_inip_ele_get_value(ele));
if (b->attr_stack == NULL) b->attr_stack = tbx_stack_new();
tbx_stack_push(b->attr_stack, attr);
}
ele = tbx_inip_ele_next(ele);
}
return(b);
}
