conn.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2012-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.
 *
 */


#pragma once

#ifndef __MOTR_RPC_CONN_H__
#define __MOTR_RPC_CONN_H__

#include "lib/tlist.h"
#include "lib/time.h"          /* m0_time_t */
#include "sm/sm.h"
#include "rpc/onwire.h"        /* m0_rpc_sender_uuid */
#include "fid/fid.h"           /* m0_fid */

/* Imports */
struct m0_rpc_machine;
struct m0_rpc_service;
struct m0_rpc_chan;
struct m0_net_end_point;
struct m0_conf_obj;

/* Exports */
struct m0_rpc_conn;

enum m0_rpc_conn_state {
        M0_RPC_CONN_INITIALISED,

        M0_RPC_CONN_CONNECTING,

        M0_RPC_CONN_ACTIVE,

        M0_RPC_CONN_FAILED,

        M0_RPC_CONN_TERMINATING,

        M0_RPC_CONN_TERMINATED,

        M0_RPC_CONN_FINALISED,
};

enum m0_rpc_conn_flags {
        RCF_SENDER_END = 1 << 0,
        RCF_RECV_END   = 1 << 1,
        RCF_TRANSIENT_SENT = 1 << 2
};

struct m0_rpc_conn {
        uint64_t                   c_sender_id;

        struct m0_uint128          c_uuid;

        uint64_t                   c_flags;

        struct m0_rpc_machine     *c_rpc_machine;

        const struct m0_rpc_conn_ha_cfg *c_ha_cfg;

        uint64_t                   c_ha_attempts;

        struct m0_sm_timer         c_ha_timer;

        struct m0_tlink            c_link;

        uint64_t                   c_nr_sessions;

        struct m0_tl               c_sessions;

        struct m0_tl               c_item_sources;

        struct m0_rpc_chan        *c_rpcchan;

        struct m0_sm               c_sm;

        struct m0_sm_ast           c_ast;

        bool                       c_ast_in_progress;

        uint64_t                   c_magic;

        struct m0_clink            c_ha_clink;

        struct m0_clink            c_conf_exp_clink;

        struct m0_clink            c_conf_ready_clink;

        struct m0_fid              c_svc_fid;
};

M0_INTERNAL int m0_rpc_conn_init(struct m0_rpc_conn      *conn,
                                 struct m0_fid           *svc_obj,
                                 struct m0_net_end_point *ep,
                                 struct m0_rpc_machine   *machine,
                                 uint64_t                 max_rpcs_in_flight);

M0_INTERNAL void m0_rpc_conn_reset(struct m0_rpc_conn *conn);

M0_INTERNAL int m0_rpc_conn_establish(struct m0_rpc_conn *conn,
                                      m0_time_t abs_timeout);

M0_INTERNAL int m0_rpc_conn_establish_sync(struct m0_rpc_conn *conn,
                                           m0_time_t abs_timeout);

M0_INTERNAL int m0_rpc_conn_create(struct m0_rpc_conn *conn,
                                   struct m0_fid *svc_fid,
                                   struct m0_net_end_point *ep,
                                   struct m0_rpc_machine *rpc_machine,
                                   uint64_t max_rpcs_in_flight,
                                   m0_time_t abs_timeout);

M0_INTERNAL int m0_rpc_conn_terminate(struct m0_rpc_conn *conn,
                                      m0_time_t abs_timeout);

M0_INTERNAL int m0_rpc_conn_terminate_sync(struct m0_rpc_conn *conn,
                                           m0_time_t abs_timeout);

M0_INTERNAL void m0_rpc_conn_fini(struct m0_rpc_conn *conn);

int m0_rpc_conn_destroy(struct m0_rpc_conn *conn, m0_time_t abs_timeout);

M0_INTERNAL int m0_rpc_conn_timedwait(struct m0_rpc_conn *conn,
                                      uint64_t states,
                                      const m0_time_t abs_timeout);

M0_INTERNAL int m0_rpc_conn_ha_subscribe(struct m0_rpc_conn *conn,
                                         struct m0_fid      *svc_fid);

M0_INTERNAL void m0_rpc_conn_ha_unsubscribe(struct m0_rpc_conn *conn);

M0_INTERNAL int m0_rpc_machine_conn_list_dump(struct m0_rpc_machine *machine,
                                              int dir);

M0_INTERNAL const char *m0_rpc_conn_addr(const struct m0_rpc_conn *conn);

M0_INTERNAL bool m0_rpc_conn_is_known_dead(const struct m0_rpc_conn *conn);

M0_INTERNAL struct m0_conf_obj *m0_rpc_conn2svc(const struct m0_rpc_conn *conn);

M0_INTERNAL void m0_rpc_conn_ha_cfg_set(struct m0_rpc_conn        *conn,
                                        const struct m0_rpc_conn_ha_cfg *cfg);

M0_INTERNAL const char *m0_rpc_conn_state_to_str(enum m0_rpc_conn_state state);

M0_INTERNAL void m0_rpc_conn_sessions_cancel(struct m0_rpc_conn *conn);

#endif /* __MOTR_RPC_CONN_H__ */