orte_node_rank_t orte_get_proc_node_rank(orte_process_name_t *proc)
{
    orte_proc_t *proct;
    orte_node_rank_t noderank;
    int rc;
    opal_list_t myvals;
    opal_value_t *kv;

    if (ORTE_PROC_IS_DAEMON || ORTE_PROC_IS_HNP) {
        /* look it up on our arrays */
        if (NULL == (proct = orte_get_proc_object(proc))) {
            ORTE_ERROR_LOG(ORTE_ERR_NOT_FOUND);
            return ORTE_NODE_RANK_INVALID;
        }
        return proct->node_rank;
    }

    /* if we are an app, get the value from the modex db */
    OBJ_CONSTRUCT(&myvals, opal_list_t);
    if (ORTE_SUCCESS != (rc = opal_dstore.fetch(opal_dstore_internal,
                                                (opal_identifier_t*)proc,
                                                OPAL_DSTORE_NODERANK,
                                                &myvals))) {
        ORTE_ERROR_LOG(rc);
        OPAL_LIST_DESTRUCT(&myvals);
        return ORTE_NODE_RANK_INVALID;
    }
    kv = (opal_value_t*)opal_list_get_first(&myvals);
    noderank = kv->data.uint16;
    OPAL_LIST_DESTRUCT(&myvals);
    return noderank;
}

static int external_close(void)
{
    OPAL_LIST_DESTRUCT(&mca_pmix_pmix2x_component.jobids);
    OPAL_LIST_DESTRUCT(&mca_pmix_pmix2x_component.events);
    OPAL_LIST_DESTRUCT(&mca_pmix_pmix2x_component.dmdx);
    return OPAL_SUCCESS;
}

static int external_close(void)
{
    OPAL_LIST_DESTRUCT(&mca_pmix_pmix2x_component.jobids);
    OPAL_LIST_DESTRUCT(&mca_pmix_pmix2x_component.single_events);
    OPAL_LIST_DESTRUCT(&mca_pmix_pmix2x_component.multi_events);
    OPAL_LIST_DESTRUCT(&mca_pmix_pmix2x_component.default_events);
    OPAL_LIST_DESTRUCT(&mca_pmix_pmix2x_component.cache);
    return OPAL_SUCCESS;
}

static int finalize(void)
{
    /* cleanup the proc state machine */
    OPAL_LIST_DESTRUCT(&orte_proc_states);
    /* cleanup the job state machine */
    OPAL_LIST_DESTRUCT(&orte_job_states);

    return ORTE_SUCCESS;
}

static int pmix_native_close(void)
{
    if (NULL != mca_pmix_native_component.uri) {
        free(mca_pmix_native_component.uri);
    }
    OPAL_LIST_DESTRUCT(&mca_pmix_native_component.send_queue);
    OPAL_LIST_DESTRUCT(&mca_pmix_native_component.posted_recvs);
    return OPAL_SUCCESS;
}

int vprotocol_pessimist_event_logger_connect(int el_rank, ompi_communicator_t **el_comm)
{
    int rc;
    char *port;
    int rank;
    vprotocol_pessimist_clock_t connect_info[2];
    opal_list_t results;
    opal_pmix_pdata_t *pdat;

    OBJ_CONSTRUCT(&results, opal_list_t);
    pdat = OBJ_NEW(opal_pmix_pdata_t);
    opal_asprintf(&pdat->value.key, VPROTOCOL_EVENT_LOGGER_NAME_FMT, el_rank);
    opal_list_append(&results, &pdat->super);

    rc = opal_pmix.lookup(&results, NULL);
    if (OPAL_SUCCESS != rc ||
        OPAL_STRING != pdat->value.type ||
        NULL == pdat->value.data.string) {
        OPAL_LIST_DESTRUCT(&results);
        return OMPI_ERR_NOT_FOUND;
    }
    port = strdup(pdat->value.data.string);
    OPAL_LIST_DESTRUCT(&results);
    V_OUTPUT_VERBOSE(45, "Found port < %s >", port);

    rc = ompi_dpm_connect_accept(MPI_COMM_SELF, 0, port, true, el_comm);
    if(OMPI_SUCCESS != rc) {
        OMPI_ERROR_LOG(rc);
    }

    /* Send Rank, receive max buffer size and max_clock back */
    rank = ompi_comm_rank(&ompi_mpi_comm_world.comm);
    rc = mca_pml_v.host_pml.pml_send(&rank, 1, MPI_INTEGER, 0,
                                     VPROTOCOL_PESSIMIST_EVENTLOG_NEW_CLIENT_CMD,
                                     MCA_PML_BASE_SEND_STANDARD,
                                     mca_vprotocol_pessimist.el_comm);
    if(OPAL_UNLIKELY(MPI_SUCCESS != rc))
        OMPI_ERRHANDLER_INVOKE(mca_vprotocol_pessimist.el_comm, rc,
                               __FILE__ ": failed sending event logger handshake");
    rc = mca_pml_v.host_pml.pml_recv(&connect_info, 2, MPI_UNSIGNED_LONG_LONG,
                                     0, VPROTOCOL_PESSIMIST_EVENTLOG_NEW_CLIENT_CMD,
                                     mca_vprotocol_pessimist.el_comm, MPI_STATUS_IGNORE);
    if(OPAL_UNLIKELY(MPI_SUCCESS != rc))                                  \
        OMPI_ERRHANDLER_INVOKE(mca_vprotocol_pessimist.el_comm, rc,       \
                               __FILE__ ": failed receiving event logger handshake");

    return rc;
}

static void imdes(orcm_pvsn_image_t *p)
{
    if (NULL != p->name) {
        free(p->name);
    }
    OPAL_LIST_DESTRUCT(&p->attributes);
}

static void peer_des(mca_oob_usock_peer_t *peer)
{
    if (0 <= peer->sd) {
        CLOSE_THE_SOCKET(peer->sd);
    }
    OPAL_LIST_DESTRUCT(&peer->send_queue);
}

static void queue_des(orcm_queue_t *q)
{
    if (NULL != q->name) {
        free(q->name);
    }
    OPAL_LIST_DESTRUCT(&q->sessions);
}

static void sess_des(orcm_session_t *s)
{
    if (NULL != s->alloc) {
        OBJ_RELEASE(s->alloc);
    }
    OPAL_LIST_DESTRUCT(&s->steps);
}

static int cray_get(const opal_process_name_t *id, const char *key, opal_value_t **kv)
{
    int rc;
    opal_list_t vals;

    opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                        "%s pmix:cray getting value for proc %s key %s",
                        OPAL_NAME_PRINT(OPAL_PROC_MY_NAME),
                        OPAL_NAME_PRINT(*id), key);

    OBJ_CONSTRUCT(&vals, opal_list_t);
    rc = opal_pmix_base_fetch(id, key, &vals);
    if (OPAL_SUCCESS == rc) {
        *kv = (opal_value_t*)opal_list_remove_first(&vals);
        return OPAL_SUCCESS;
    } else {
        opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                "%s pmix:cray fetch from dstore failed: %d",
                OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), rc);
    }
    OPAL_LIST_DESTRUCT(&vals);

    return rc;

}

static void qdes(opal_pmix_query_t *p)
{
    if (NULL != p->keys) {
        opal_argv_free(p->keys);
    }
    OPAL_LIST_DESTRUCT(&p->qualifiers);
}

static void wkstep_des(orcm_workflow_step_t *p)
{
    OPAL_LIST_DESTRUCT(&p->attributes);
    if (NULL != p->analytic) {
        free(p->analytic);
    }
}

static void orte_node_destruct(orte_node_t* node)
{
    int i;
    orte_proc_t *proc;

    if (NULL != node->name) {
        free(node->name);
        node->name = NULL;
    }

    if (NULL != node->daemon) {
        node->daemon->node = NULL;
        OBJ_RELEASE(node->daemon);
        node->daemon = NULL;
    }
    
    for (i=0; i < node->procs->size; i++) {
        if (NULL != (proc = (orte_proc_t*)opal_pointer_array_get_item(node->procs, i))) {
            opal_pointer_array_set_item(node->procs, i, NULL);
            OBJ_RELEASE(proc);
        }
    }
    OBJ_RELEASE(node->procs);
    
    /* do NOT destroy the topology */

    /* release the attributes */
    OPAL_LIST_DESTRUCT(&node->attributes);
}

static int orte_schizo_base_close(void)
{
    /* cleanup globals */
    OPAL_LIST_DESTRUCT(&orte_schizo_base.active_modules);

    return mca_base_framework_components_close(&orte_schizo_base_framework, NULL);
}

static void orte_app_context_destructor(orte_app_context_t* app_context)
{
    int i;
    orte_proc_t *proc;

    if (NULL != app_context->app) {
        free (app_context->app);
        app_context->app = NULL;
    }
    
    for (i=0; i < app_context->procs.size; i++) {
        if (NULL != (proc = (orte_proc_t*)opal_pointer_array_get_item(&app_context->procs, i))) {
            OBJ_RELEASE(proc);
        }
    }
    OBJ_DESTRUCT(&app_context->procs);

    /* argv and env lists created by util/argv copy functions */
    if (NULL != app_context->argv) {
        opal_argv_free(app_context->argv);
        app_context->argv = NULL;
    }
    
    if (NULL != app_context->env) {
        opal_argv_free(app_context->env);
        app_context->env = NULL;
    }
    
    if (NULL != app_context->cwd) {
        free (app_context->cwd);
        app_context->cwd = NULL;
    }
    
    OPAL_LIST_DESTRUCT(&app_context->attributes);
}

/**
 * Finalize the module
 */
static void finalize(void)
{
    /* cancel the recv */
    orte_rml.recv_cancel(ORTE_NAME_WILDCARD, ORTE_RML_TAG_XCAST);

    OPAL_LIST_DESTRUCT(&tracker);
    return;
}

static int rte_orte_close(void)
{
    opal_mutex_lock(&mca_rte_orte_component.lock);
    OPAL_LIST_DESTRUCT(&mca_rte_orte_component.modx_reqs);
    OBJ_DESTRUCT(&mca_rte_orte_component.lock);

    return OMPI_SUCCESS;
}

static int orcm_analytics_base_close(void)
{
    orcm_analytics_base_comm_stop();

    /* destruct the base objects */
    OPAL_LIST_DESTRUCT(&orcm_analytics_base.workflows);

    return mca_base_framework_components_close(&orcm_analytics_base_framework,
                                               NULL);
}

static void wk_des(orcm_workflow_t *p)
{
    if (NULL != p->ev_base) {
        orcm_stop_progress_thread(p->name, true);
    }
    if (NULL != p->name) {
        free(p->name);
    }
    OPAL_LIST_DESTRUCT(&p->steps);
}