static void
rwsched_instance_free_int(rwsched_instance_t *instance)
{
// Validate input paraemters
RW_CF_TYPE_VALIDATE(instance, rwsched_instance_ptr_t);
//FIXME
if (!g_atomic_int_dec_and_test(&instance->ref_cnt)) {
return;
}
#if 1
RW_FREE_TYPE(instance->default_rwqueue, rwsched_dispatch_queue_t);
RW_FREE_TYPE(instance->main_rwqueue, rwsched_dispatch_queue_t);
long i;
for (i=0; i<RWSCHED_DISPATCH_QUEUE_GLOBAL_CT; i++) {
instance->global_rwqueue[i].rwq->header.libdispatch_object._dq = NULL;
RW_FREE_TYPE(instance->global_rwqueue[i].rwq, rwsched_dispatch_queue_t);
instance->global_rwqueue[i].rwq = NULL;
}
ck_pr_dec_32(&g_rwsched_instance_count);
if (instance->rwlog_instance) {
rwlog_close(instance->rwlog_instance, FALSE);
}
//NO-FREE
RW_CF_TYPE_FREE(instance, rwsched_instance_ptr_t);
#endif
}
void rwmsg_destination_destroy(rwmsg_destination_t *dt) {
RW_ASSERT_TYPE(dt, rwmsg_destination_t);
if (!dt->refct) {
rwmsg_endpoint_t *ep = dt->ep;
RW_ASSERT(ep);
//?? TBD rwmsg_endpoint_del_srvchan_method_binding(ep, sc, ...);
RWMSG_EP_LOCK(ep);
RW_DL_REMOVE(&ep->track.destinations, dt, trackelem);
RWMSG_EP_UNLOCK(ep);
ck_pr_dec_32(&ep->stat.objects.destinations);
if (dt->localep) {
rwmsg_endpoint_release(dt->localep);
dt->localep = NULL;
}
if (dt->defstream.localsc) {
_RWMSG_CH_DEBUG_(&dt->defstream.localsc->ch, "--");
rwmsg_srvchan_release(dt->defstream.localsc);
dt->defstream.localsc = NULL;
}
RW_FREE_TYPE(dt, rwmsg_destination_t);
dt = NULL;
}
return;
}
void rwdts_appconf_register_deinit(rwdts_member_registration_t *reg) {
if (reg->appconf) {
if (reg->appconf->cb.prepare_dtor) {
reg->appconf->cb.prepare_dtor(reg->appconf->cb.prepare_ud);
}
RW_ASSERT_TYPE(reg->appconf, rwdts_appconf_reg_t);
RW_ASSERT_TYPE(reg->appconf->ac, rwdts_appconf_t);
RW_FREE_TYPE(reg->appconf, rwdts_appconf_reg_t);
reg->appconf = NULL;
}
}
static void rwdtsperf_dts_mgmt_xact_deinit(rwdts_appconf_t *ac,
rwdts_xact_t *xact,
void *ud,
void *scratch_in)
{
rwdtsperf_config_scratch_t *scratch = (rwdtsperf_config_scratch_t *)scratch_in;
int i = 0;
for (; i < scratch->count; i++) {
protobuf_c_message_free_unpacked(NULL, scratch->config[i]);
scratch->config[i] = NULL;
}
RW_ASSERT(scratch);
RW_FREE_TYPE(scratch, rwdtsperf_config_scratch_t);
}
void rwmsg_method_destroy(rwmsg_endpoint_t *ep,
rwmsg_method_t *meth) {
if (!meth->refct) {
if (meth->pathidx) {
rwmsg_bool_t prval = rwmsg_endpoint_path_del(ep, meth->pathidx);
RW_ASSERT(prval);
}
RW_ASSERT(meth->sig);
RW_ASSERT(meth->sig->refct > 0);
rwmsg_signature_release(ep, meth->sig);
RW_FREE_TYPE(meth, rwmsg_method_t);
ck_pr_dec_32(&ep->stat.objects.methods);
}
}
static void rwdts_appconf_xact_deinit(rwdts_group_t *grp,
rwdts_xact_t *xact,
void *ctx,
void *scratch) {
rwdts_appconf_xact_t *appx = (rwdts_appconf_xact_t *)scratch;
RW_ASSERT_TYPE(appx, rwdts_appconf_xact_t);
rwdts_appconf_t *ac = appx->ac;
int k;
if (ac->cb.xact_deinit) {
if (ac->cb.xact_deinit_dtor) {
ac->cb.xact_deinit_gi(ac,
xact,
ac->cb.ctx,
appx->scratch_gi);
if (appx->scratch_gi) {
g_value_unset(appx->scratch_gi);
appx->scratch_gi = NULL;
}
} else {
ac->cb.xact_deinit(ac,
xact,
ac->cb.ctx,
appx->scratch);
appx->scratch = NULL;
}
} else {
if (ac->cb.xact_init_dtor) {
if (appx->scratch_gi) {
g_value_unset(appx->scratch_gi);
appx->scratch_gi = NULL;
}
} else {
RW_ASSERT(!appx->scratch);
}
}
for(k=0;k<appx->errs_ct;free(appx->errs[k].str),k++);
free(appx->errs);
appx->errs = NULL;
appx->errs_ct = 0;
RW_FREE_TYPE(appx, rwdts_appconf_xact_t);
appx = NULL;
}
void rwdts_appconf_group_destroy(rwdts_appconf_t *ac) {
RW_ASSERT_TYPE(ac, rwdts_appconf_t);
if (ac->cb.xact_init_dtor) {
ac->cb.xact_init_dtor(ac->cb.ctx);
}
if (ac->cb.xact_deinit_dtor) {
ac->cb.xact_deinit_dtor(NULL);
}
if (ac->regn_timer) {
rwsched_dispatch_source_cancel(ac->apih->tasklet,
ac->regn_timer);
rwsched_dispatch_release(ac->apih->tasklet,
ac->regn_timer);
ac->regn_timer = NULL;
}
memset(&ac->cb, 0, sizeof(ac->cb));
rwdts_group_destroy(ac->group);
RW_FREE_TYPE(ac, rwdts_appconf_t);
}
static void
rwsched_dispatch_intercept(void *ud)
{
rwsched_dispatch_what_ptr_t what = ud;
// Validate input paraemters
RW_ASSERT_TYPE(what, rwsched_dispatch_what_ptr_t);
RW_ASSERT(what->closure.handler);
rwsched_tasklet_ptr_t sched_tasklet = what->tasklet_info;
RW_CF_TYPE_VALIDATE(sched_tasklet, rwsched_tasklet_ptr_t);
g_rwresource_track_handle = sched_tasklet->rwresource_track_handle;
g_tasklet_info = sched_tasklet;
(what->closure.handler)(what->closure.context);
RW_FREE_TYPE(what, rwsched_dispatch_what_ptr_t);
rwsched_tasklet_unref(sched_tasklet);
g_tasklet_info = 0;
g_rwresource_track_handle = 0;
}
static void
rwsched_tasklet_free_int(rwsched_tasklet_t *sched_tasklet)
{
RW_CF_TYPE_VALIDATE(sched_tasklet, rwsched_tasklet_ptr_t);
rwsched_instance_ptr_t instance = sched_tasklet->instance;
RW_CF_TYPE_VALIDATE(instance, rwsched_instance_ptr_t);
if (!g_atomic_int_dec_and_test(&sched_tasklet->ref_cnt)) {
return;
}
int i;
for (i = 0 ; i < RWSCHED_MAX_SIGNALS; i++) {
if (sched_tasklet->signal_dtor[i]) {
sched_tasklet->signal_dtor[i](sched_tasklet->signal_dtor_ud[i]);
}
sched_tasklet->signal_dtor[i]= NULL;
sched_tasklet->signal_dtor_ud[i]= NULL;
}
for (i = 1 ; i < instance->tasklet_array->len ; i++) {
if (g_array_index(instance->tasklet_array, rwsched_tasklet_ptr_t, i) == sched_tasklet) {
g_array_remove_index (instance->tasklet_array, i);
break;
}
}
rwsched_CFRunLoopTimerRef rw_timer;
while ((rw_timer = g_array_index(sched_tasklet->cftimer_array, rwsched_CFRunLoopTimerRef, 1)) != NULL) {
RW_CF_TYPE_VALIDATE(rw_timer, rwsched_CFRunLoopTimerRef);
rwsched_tasklet_CFRunLoopTimerInvalidate(sched_tasklet, rw_timer);
g_array_remove_index (sched_tasklet->cftimer_array, 1);
}
g_array_free(sched_tasklet->cftimer_array, TRUE);
rwsched_CFSocketRef rw_socket;
while ((rw_socket = g_array_index(sched_tasklet->cfsocket_array, rwsched_CFSocketRef, 1)) != NULL) {
RW_CF_TYPE_VALIDATE(rw_socket, rwsched_CFSocketRef);
rwsched_tasklet_CFSocketRelease(sched_tasklet, rw_socket);
//g_array_remove_index (sched_tasklet->cfsocket_array, 1);
}
g_array_free(sched_tasklet->cfsocket_array, TRUE);
rwsched_CFRunLoopSourceRef rw_source;
while ((rw_source = g_array_index(sched_tasklet->cfsource_array, rwsched_CFRunLoopSourceRef, 1)) != NULL) {
RW_CF_TYPE_VALIDATE(rw_source, rwsched_CFRunLoopSourceRef);
rwsched_tasklet_CFSocketReleaseRunLoopSource(sched_tasklet, rw_source);
g_array_remove_index (sched_tasklet->cfsource_array, 1);
}
g_array_free(sched_tasklet->cfsource_array, TRUE);
rwsched_dispatch_what_ptr_t what;
while ((what = g_array_index(sched_tasklet->dispatch_what_array, rwsched_dispatch_what_ptr_t, 1)) != NULL) {
RW_FREE_TYPE(what, rwsched_dispatch_what_ptr_t);
g_array_remove_index (sched_tasklet->dispatch_what_array, 1);
}
g_array_free(sched_tasklet->dispatch_what_array, TRUE);
ck_pr_dec_32(&g_rwsched_tasklet_count);
//NO-FREE
RW_CF_TYPE_FREE(sched_tasklet, rwsched_tasklet_ptr_t);
rwsched_instance_unref(instance);
}
// This will be supported after sharding support
//
//LCOV_EXCL_START
rw_status_t
rwdts_kv_update_db_xact_precommit(rwdts_member_data_object_t *mobj, RWDtsQueryAction action)
{
rwdts_api_t *apih;
rwdts_member_registration_t *reg;
ProtobufCMessage *msg;
uint8_t *payload;
size_t payload_len;
rw_status_t status;
rwdts_kv_table_handle_t *kv_tab_handle = NULL;
rwdts_shard_info_detail_t *shard_key1;
uint8_t *local_ks_binpath = NULL;
size_t local_ks_binpath_len;
rw_keyspec_path_t *local_keyspec = NULL;
/* Build the shard-key to get the shard-id and DB number */
char str[15] = "banana";
reg = mobj->reg;
RW_ASSERT_TYPE(reg, rwdts_member_registration_t);
apih = reg->apih;
RW_ASSERT(apih);
RW_ASSERT(action != RWDTS_QUERY_INVALID);
msg = mobj->msg;
shard_key1 = RW_MALLOC0_TYPE(sizeof(rwdts_shard_info_detail_t), rwdts_shard_info_detail_t);
shard_key1->shard_key_detail.u.byte_key.k.key = (void *)RW_MALLOC(sizeof(str));
memcpy((char *)shard_key1->shard_key_detail.u.byte_key.k.key, &str[0], strlen(str));
shard_key1->shard_key_detail.u.byte_key.k.key_len = strlen(str);
/* Get the shard-id and DB number */
rwdts_shard_db_num_info_t *shard_db_num_info = RW_MALLOC0(sizeof(rwdts_shard_db_num_info_t));
status = rw_keyspec_path_create_dup(reg->keyspec, &apih->ksi , &local_keyspec);
RW_ASSERT(status == RW_STATUS_SUCCESS);
status = rw_keyspec_path_get_binpath(local_keyspec, &apih->ksi , (const uint8_t **)&local_ks_binpath, &local_ks_binpath_len);
RW_ASSERT(status == RW_STATUS_SUCCESS);
rwdts_member_get_shard_db_info_keyspec(apih, local_keyspec,
shard_key1,
shard_db_num_info);
if (shard_db_num_info->shard_db_num_cnt > 0) {
mobj->db_number = shard_db_num_info->shard_db_num[0].db_number;
mobj->shard_id = shard_db_num_info->shard_db_num[0].shard_chunk_id;
/* Search for KV table handle */
status = RW_SKLIST_LOOKUP_BY_KEY(&(apih->kv_table_handle_list), &mobj->db_number,
(void *)&kv_tab_handle);
if (!kv_tab_handle) {
kv_tab_handle = rwdts_kv_light_register_table(apih->handle, mobj->db_number);
RW_ASSERT(kv_tab_handle);
status = RW_SKLIST_INSERT(&(apih->kv_table_handle_list), kv_tab_handle);
RW_ASSERT(status == RW_STATUS_SUCCESS);
}
mobj->kv_tab_handle = kv_tab_handle;
RWDTS_CREATE_SHARD(reg->reg_id, apih->client_path, apih->router_path);
/* Perform KV xact operation */
if (apih->db_up && ((action == RWDTS_QUERY_CREATE) ||
(RWDTS_QUERY_UPDATE == action))) {
RW_ASSERT(msg);
payload = protobuf_c_message_serialize(NULL, msg, &payload_len);
rwdts_kv_light_table_xact_insert(kv_tab_handle, 0, shard,
(void *)mobj->key,
mobj->key_len,
payload,
payload_len,
(void *)rwdts_kv_light_insert_xact_obj_cb,
(void *)mobj);
} else if (apih->db_up && (action == RWDTS_QUERY_DELETE)) {
rwdts_kv_light_table_xact_delete(kv_tab_handle, 0,
(void *)mobj->key,
mobj->key_len,
(void *)rwdts_kv_light_delete_xact_obj_cb,
(void *)mobj);
}
}
if (shard_db_num_info->shard_db_num_cnt) {
free(shard_db_num_info->shard_db_num);
}
RW_FREE(shard_db_num_info);
rw_keyspec_path_free(local_keyspec, NULL);
RW_FREE(shard_key1->shard_key_detail.u.byte_key.k.key);
RW_FREE_TYPE(shard_key1, rwdts_shard_info_detail_t);
return RW_STATUS_SUCCESS;
}
