void
rwdtsperf_instance_stop(rwdtsperf_component_ptr_t component,
rwdtsperf_instance_ptr_t instance)
{
xact_config_t *xact_cfg;
// Validate input parameters
RW_CF_TYPE_VALIDATE(component, rwdtsperf_component_ptr_t);
RW_CF_TYPE_VALIDATE(instance, rwdtsperf_instance_ptr_t);
xact_cfg = &(instance->config.xact_cfg);
xact_cfg->running = false;
xact_cfg->xact_max_with_outstanding = 0;
rwdts_api_deinit(instance->dts_h);
}
static void
rwlogd__component__instance_stop(
RwTaskletPluginComponent * self,
RwTaskletPluginComponentHandle * h_component,
RwTaskletPluginInstanceHandle * h_instance)
{
rwlogd_component_ptr_t component;
rwlogd_instance_ptr_t instance;
// Validate input parameters
component = (rwlogd_component_ptr_t) h_component->priv;
RW_CF_TYPE_VALIDATE(component, rwlogd_component_ptr_t);
instance = (rwlogd_instance_ptr_t) h_instance->priv;
RW_CF_TYPE_VALIDATE(instance, rwlogd_instance_ptr_t);
rwmsg_clichan_halt(instance->cc);
rwmsg_srvchan_halt(instance->sc);
rwdts_api_deinit(instance->dts_h);
RWTRACE_WARN(instance->rwtasklet_info->rwtrace_instance,
RWTRACE_CATEGORY_RWTASKLET,
"RW.Logd[%d] -- Stopping ",
instance->rwtasklet_info->identity.rwtasklet_instance_id);
}
struct rwmain_gi * rwmain_alloc(
rwvx_instance_ptr_t rwvx,
const char * component_name,
uint32_t instance_id,
const char * component_type,
const char * parent_id,
const char * vm_ip_address,
uint32_t vm_instance_id)
{
rw_status_t status;
int r;
rwtasklet_info_ptr_t info = NULL;
rwdts_api_t * dts = NULL;
struct rwmain_gi * rwmain = NULL;
char * instance_name = NULL;
rwmain = (struct rwmain_gi *)malloc(sizeof(struct rwmain_gi));
if (!rwmain) {
RW_CRASH();
goto err;
}
bzero(rwmain, sizeof(struct rwmain_gi));
/* If the component name wasn't specified on the command line, pull it
* from the manifest init-phase.
*/
if (!component_name) {
char cn[1024];
status = rwvcs_variable_evaluate_str(
rwvx->rwvcs,
"$rw_component_name",
cn,
sizeof(cn));
if (status != RW_STATUS_SUCCESS) {
RW_CRASH();
goto err;
}
rwmain->component_name = strdup(cn);
} else {
rwmain->component_name = strdup(component_name);
}
if (!rwmain->component_name) {
RW_CRASH();
goto err;
}
/* If the instance id wasn't specified on the command line pull it from
* the manifest init-phase if it is there, otherwise autoassign one.
*/
if (instance_id == 0) {
int id;
status = rwvcs_variable_evaluate_int(
rwvx->rwvcs,
"$instance_id",
&id);
if ((status == RW_STATUS_SUCCESS) && id) {
rwmain->instance_id = (uint32_t)id;
} else {
status = rwvcs_rwzk_next_instance_id(rwvx->rwvcs, &rwmain->instance_id, NULL);
if (status != RW_STATUS_SUCCESS) {
RW_CRASH();
goto err;
}
}
} else {
rwmain->instance_id = instance_id;
}
if (component_type) {
rwmain->component_type = component_type_str_to_enum(component_type);
} else {
char ctype[64];
status = rwvcs_variable_evaluate_str(
rwvx->rwvcs,
"$component_type",
ctype,
sizeof(ctype));
if (status != RW_STATUS_SUCCESS) {
RW_CRASH();
goto err;
}
rwmain->component_type = component_type_str_to_enum(ctype);
}
if (vm_instance_id > 0)
rwmain->vm_instance_id = vm_instance_id;
else if (rwmain->component_type == RWVCS_TYPES_COMPONENT_TYPE_RWVM)
rwmain->vm_instance_id = rwmain->instance_id;
else {
int vm_instance_id;
status = rwvcs_variable_evaluate_int(
rwvx->rwvcs,
"$vm_instance_id",
&vm_instance_id);
if (status == RW_STATUS_SUCCESS) {
rwmain->vm_instance_id = (uint32_t)vm_instance_id;
}
}
RW_ASSERT(rwmain->vm_instance_id);
// 10 hz with tolerance 600
// TODO: Must take from YANG. These are currently defined as the defaults in rw-base.yang
rwmain->rwproc_heartbeat = rwproc_heartbeat_alloc(10, 600);
if (!rwmain->rwproc_heartbeat) {
RW_CRASH();
goto err;
}
bzero(&rwmain->sys, sizeof(rwmain->sys));
if (parent_id) {
rwmain->parent_id = strdup(parent_id);
if (!rwmain->parent_id) {
RW_CRASH();
goto err;
}
}
else {
char ctype[64];
status = rwvcs_variable_evaluate_str(
rwvx->rwvcs,
"$parent_id",
ctype,
sizeof(ctype));
if (status == RW_STATUS_SUCCESS) {
rwmain->parent_id = strdup(ctype);
}
}
if (rwvx->rwvcs->pb_rwmanifest->init_phase->settings->rwvcs->collapse_each_rwvm) {
r = asprintf(&rwmain->vm_ip_address, "127.%u.%u.1", rwmain->instance_id / 256, rwmain->instance_id % 256);
if (r == -1) {
RW_CRASH();
goto err;
}
} else if (vm_ip_address) {
rwmain->vm_ip_address = strdup(vm_ip_address);
if (!rwmain->vm_ip_address) {
RW_CRASH();
goto err;
}
char *variable[0];
r = asprintf(&variable[0], "vm_ip_address = '%s'", vm_ip_address);
if (r == -1) {
RW_CRASH();
goto err;
}
status = rwvcs_variable_list_evaluate(
rwvx->rwvcs,
1,
variable);
if (status != RW_STATUS_SUCCESS) {
RW_CRASH();
goto err;
}
free(variable[0]);
} else {
char buf[32];
status = rwvcs_variable_evaluate_str(
rwvx->rwvcs,
"$vm_ip_address",
buf,
sizeof(buf));
if (status != RW_STATUS_SUCCESS) {
RW_CRASH();
goto err;
}
rwmain->vm_ip_address = strdup(buf);
if (!rwmain->vm_ip_address) {
RW_CRASH();
goto err;
}
}
rwvx->rwvcs->identity.vm_ip_address = strdup(rwmain->vm_ip_address);
if (!rwvx->rwvcs->identity.vm_ip_address) {
RW_CRASH();
goto err;
}
rwvx->rwvcs->identity.rwvm_instance_id = rwmain->vm_instance_id;
instance_name = to_instance_name(rwmain->component_name, rwmain->instance_id);
RW_ASSERT(instance_name!=NULL);
if (rwmain->component_type == RWVCS_TYPES_COMPONENT_TYPE_RWVM) {
rwvx->rwvcs->identity.rwvm_name = instance_name;
}
else if (rwmain->component_type == RWVCS_TYPES_COMPONENT_TYPE_RWPROC) {
RW_ASSERT(rwmain->parent_id);
rwvx->rwvcs->identity.rwvm_name = strdup(rwmain->parent_id);
}
char rift_var_vm[255];
if (rwvx->rwvcs->identity.rwvm_name) {
snprintf(rift_var_vm, 255, "%s%c%s", rwvx->rwvcs->pb_rwmanifest->bootstrap_phase->test_name,
'-', rwvx->rwvcs->identity.rwvm_name);
} else {
snprintf(rift_var_vm, 255, "%s", rwvx->rwvcs->pb_rwmanifest->bootstrap_phase->test_name);
}
setenv("RIFT_VAR_VM", rift_var_vm, true);
info = get_rwmain_tasklet_info(
rwvx,
rwmain->component_name,
rwmain->instance_id,
rwmain->vm_instance_id);
if (!info) {
RW_CRASH();
goto err;
}
if (rwvx->rwsched) {
if (!rwvx->rwsched->rwlog_instance) {
rwvx->rwsched->rwlog_instance = rwlog_init("RW.Sched");
}
}
if (!rwvx->rwlog) {
rwvx->rwlog = rwlog_init("Logging");
}
dts = rwdts_api_new(
info,
(rw_yang_pb_schema_t *)RWPB_G_SCHEMA_YPBCSD(RwVcs),
rwmain_dts_handle_state_change,
NULL,
NULL);
if (!dts) {
RW_CRASH();
goto err;
}
RW_SKLIST_PARAMS_DECL(
procs_sklist_params,
struct rwmain_proc,
instance_name,
rw_sklist_comp_charptr,
_sklist);
RW_SKLIST_INIT(&(rwmain->procs), &procs_sklist_params);
RW_SKLIST_PARAMS_DECL(
tasklets_sklist_params,
struct rwmain_tasklet,
instance_name,
rw_sklist_comp_charptr,
_sklist);
RW_SKLIST_INIT(&(rwmain->tasklets), &tasklets_sklist_params);
RW_SKLIST_PARAMS_DECL(
multivms_sklist_params,
struct rwmain_multivm,
key,
rw_sklist_comp_charbuf,
_sklist);
RW_SKLIST_INIT(&(rwmain->multivms), &multivms_sklist_params);
rwmain->dts = dts;
rwmain->tasklet_info = info;
rwmain->rwvx = rwvx;
r = asprintf(&VCS_GET(rwmain)->vcs_instance_xpath,
VCS_INSTANCE_XPATH_FMT,
instance_name);
if (r == -1) {
RW_CRASH();
goto err;
}
VCS_GET(rwmain)->instance_name = instance_name;
goto done;
err:
if (info) {
rwsched_tasklet_free(info->rwsched_tasklet_info);
free(info->identity.rwtasklet_name);
rwmsg_endpoint_halt(info->rwmsg_endpoint);
free(info);
}
if (dts)
rwdts_api_deinit(dts);
if (rwmain->component_name)
free(rwmain->component_name);
if (rwmain->parent_id)
free(rwmain->parent_id);
if (rwmain)
free(rwmain);
done:
return rwmain;
}
