crate_client_utils.c

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2020 Seagate Technology LLC and/or its Affiliates
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For any questions about this software or licensing,
 * please email opensource@seagate.com or cortx-questions@seagate.com.
 *
 */



#include <errno.h>
#include "lib/trace.h"
#include "motr/m0crate/logger.h"
#include "motr/client_internal.h" /* m0_instance */
#include "motr/m0crate/crate_client_utils.h"

#define LOG_PREFIX "utils:"

struct crate_conf              *conf = NULL;
struct m0_config                m0_conf = {};
struct m0_idx_cass_config       cass_conf = {};
static int                      num_m0_workloads = 0;
struct m0_client               *m0_instance = NULL;
struct m0_container             container = {};
static struct m0_realm          uber_realm = {};
static struct m0_idx_dix_config dix_conf = {};

struct m0_realm *crate_uber_realm()
{
        M0_PRE(uber_realm.re_instance != NULL);
        return &uber_realm;
}

int adopt_motr_thread(struct m0_workload_task *task)
{
        int               rc = 0;

        M0_PRE(crate_uber_realm() != NULL);
        M0_PRE(crate_uber_realm()->re_instance != NULL);

        if (m0_thread_tls() != NULL)
                return M0_RC(rc);

        rc = m0_thread_adopt(&task->mthread, m0_instance->m0c_motr);
        if (rc < 0) {
                crlog(CLL_ERROR, "Motr adoptation failed");
        }

        return M0_RC(rc);
}

void release_motr_thread(struct m0_workload_task *task)
{
        m0_thread_shun();
}

static void dix_config_init(struct m0_idx_dix_config *conf)
{
        conf->kc_create_meta = false;
}

int init(struct workload *w)
{
        int rc;

        num_m0_workloads++;

        if (num_m0_workloads != 1) {
                rc = 0;
                goto do_exit;
        }

        m0_conf.mc_is_addb_init          = conf->is_addb_init;
        m0_conf.mc_addb_size             = conf->addb_size;
        m0_conf.mc_is_oostore            = conf->is_oostrore;
        m0_conf.mc_is_read_verify        = conf->is_read_verify;
        m0_conf.mc_local_addr            = conf->local_addr;
        m0_conf.mc_ha_addr               = conf->ha_addr;
        m0_conf.mc_profile               = conf->prof;
        m0_conf.mc_process_fid           = conf->process_fid;
        m0_conf.mc_tm_recv_queue_min_len = conf->tm_recv_queue_min_len ?:
                                               M0_NET_TM_RECV_QUEUE_DEF_LEN;
        m0_conf.mc_max_rpc_msg_size      = conf->max_rpc_msg_size ?:
                                               M0_RPC_DEF_MAX_RPC_MSG_SIZE;
        m0_conf.mc_layout_id             = conf->layout_id;
        m0_conf.mc_idx_service_id        = conf->index_service_id;

        if (m0_conf.mc_idx_service_id == M0_IDX_CASS) {
                cass_conf.cc_cluster_ep              = conf->cass_cluster_ep;
                cass_conf.cc_keyspace                = conf->cass_keyspace;
                cass_conf.cc_max_column_family_num   = conf->col_family;
                m0_conf.mc_idx_service_conf = &cass_conf;
        } else if (m0_conf.mc_idx_service_id == M0_IDX_DIX ||
                   m0_conf.mc_idx_service_id == M0_IDX_MOCK) {
                dix_config_init(&dix_conf);
                m0_conf.mc_idx_service_conf = &dix_conf;
        } else {
                rc = -EINVAL;
                cr_log(CLL_ERROR, "Unknown index service id: %d!\n",
                       m0_conf.mc_idx_service_id);
                goto do_exit;
        }

        /* Client instance */
        rc = m0_client_init(&m0_instance, &m0_conf, true);
        if (rc != 0) {
                cr_log(CLL_ERROR, "Failed to initialise Client: %d\n", rc);
                goto do_exit;
        }

        M0_POST(m0_instance != NULL);

        /* And finally, client root realm */
        m0_container_init(&container,
                                 NULL, &M0_UBER_REALM,
                                 m0_instance);

        rc = container.co_realm.re_entity.en_sm.sm_rc;
        if (rc != 0) {
                cr_log(CLL_ERROR, "Failed to open uber realm\n");
                goto do_exit;
        }

        M0_POST(container.co_realm.re_instance != NULL);
        uber_realm = container.co_realm;

do_exit:
        return rc;
}

void free_m0_conf()
{
        m0_free(conf->local_addr);
        m0_free(conf->ha_addr);
        m0_free(conf->prof);
        m0_free(conf->process_fid);
        m0_free(conf->cass_cluster_ep);
        m0_free(conf->cass_keyspace);
        m0_free(conf);
}

int fini(struct workload *w)
{
        num_m0_workloads--;
        if(num_m0_workloads == 0) {
                m0_client_fini(m0_instance, true);
                free_m0_conf();
        }
        return 0;
}

void check(struct workload *w)
{
}

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */
/*
 * vim: tabstop=8 shiftwidth=8 noexpandtab textwidth=80 nowrap
 */