confc.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2015-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_CONF_CONFC_H__
#define __MOTR_CONF_CONFC_H__

#include "conf/cache.h"   /* m0_conf_cache */
#include "conf/onwire.h"  /* m0_conf_fetch */
#include "lib/mutex.h"    /* m0_mutex */
#include "sm/sm.h"        /* m0_sm, m0_sm_ast */
#include "rpc/link.h"     /* m0_rpc_link */

struct m0_conf_obj;


enum m0_confc_state {
        M0_CC_READY,          
        M0_CC_REVOKED,        
        M0_CC_GETTING_READY,  
        M0_CC_FAILED,
};

struct m0_confc_update_state {
        enum m0_confc_state cus_state;
        struct m0_mutex     cus_lock;
};

/* ------------------------------------------------------------------
 * confc instance
 * ------------------------------------------------------------------ */

struct m0_confc_gate_ops;

struct m0_confc {
        struct m0_sm_group       *cc_group;

        struct m0_mutex           cc_lock;

        struct m0_conf_cache      cc_cache;

        struct m0_conf_obj       *cc_root;

        struct m0_rpc_link        cc_rlink;

        uint32_t                  cc_nr_ctx;

        struct m0_confc_gate_ops *cc_gops;

        struct m0_clink           cc_drain;

        uint64_t                  cc_rpc_timeout;

        struct m0_chan            cc_unattached;

        struct m0_mutex           cc_unatt_guard;

        uint64_t                  cc_magic;
};

struct m0_confc_gate_ops {
        bool (*go_check)(struct m0_confc *confc);
        int (*go_skip)(struct m0_confc *confc);
        bool (*go_drain)(struct m0_clink *clink);
};

M0_INTERNAL int m0_confc_init_wait(struct m0_confc       *confc,
                                   struct m0_sm_group    *sm_group,
                                   const char            *confd_addr,
                                   struct m0_rpc_machine *rpc_mach,
                                   const char            *local_conf,
                                   uint64_t               timeout_ns);

M0_INTERNAL int m0_confc_init(struct m0_confc       *confc,
                              struct m0_sm_group    *sm_group,
                              const char            *confd_addr,
                              struct m0_rpc_machine *rpc_mach,
                              const char            *local_conf);

M0_INTERNAL void m0_confc_fini(struct m0_confc *confc);

M0_INTERNAL struct m0_confc *m0_confc_from_obj(const struct m0_conf_obj *obj);

M0_INTERNAL void m0_confc_gate_ops_set(struct m0_confc          *confc,
                                       struct m0_confc_gate_ops *gops);

/* ------------------------------------------------------------------
 * context
 * ------------------------------------------------------------------ */

struct m0_confc_ctx {
        struct m0_confc    *fc_confc;

        struct m0_sm        fc_mach;

        struct m0_sm_ast    fc_ast;

        int                 fc_ast_datum;

        struct m0_conf_obj *fc_origin;

        struct m0_fid       fc_path[M0_CONF_PATH_MAX + 1];

        struct m0_clink     fc_clink;

        struct m0_conf_obj *fc_result;

        struct m0_rpc_item *fc_rpc_item;

        bool                fc_finalized;

        uint64_t            fc_magic;
};

M0_INTERNAL int m0_confc_ctx_init(struct m0_confc_ctx *ctx,
                                  struct m0_confc *confc);

M0_INTERNAL void m0_confc_ctx_fini(struct m0_confc_ctx *ctx);

M0_INTERNAL void m0_confc_ctx_fini_locked(struct m0_confc_ctx *ctx);

M0_INTERNAL int m0_confc_reconnect(struct m0_confc       *confc,
                                   struct m0_rpc_machine *rpc_mach,
                                   const char            *confd_addr);

M0_INTERNAL bool m0_confc_ctx_is_completed(const struct m0_confc_ctx *ctx);

M0_INTERNAL bool m0_confc_ctx_is_completed_lock(const struct m0_confc_ctx *ctx);

M0_INTERNAL int32_t m0_confc_ctx_error(const struct m0_confc_ctx *ctx);

M0_INTERNAL int32_t m0_confc_ctx_error_lock(const struct m0_confc_ctx *ctx);

M0_INTERNAL struct m0_conf_obj *m0_confc_ctx_result(struct m0_confc_ctx *ctx);

/* ------------------------------------------------------------------
 * open/close
 * ------------------------------------------------------------------ */

#define m0_confc_open(ctx, origin, ...)                           \
        m0_confc__open((ctx), (origin), (const struct m0_fid []){ \
                        __VA_ARGS__, M0_FID0 })
M0_INTERNAL void m0_confc__open(struct m0_confc_ctx *ctx,
                                struct m0_conf_obj *origin,
                                const struct m0_fid *path);

#define m0_confc_open_sync(result, origin, ...)                           \
        m0_confc__open_sync((result), (origin), (const struct m0_fid []){ \
                        __VA_ARGS__, M0_FID0 })
M0_INTERNAL int m0_confc__open_sync(struct m0_conf_obj **result,
                                    struct m0_conf_obj *origin,
                                    const struct m0_fid *path);

M0_INTERNAL void m0_confc_close(struct m0_conf_obj *obj);

M0_INTERNAL void m0_confc_open_by_fid(struct m0_confc_ctx *ctx,
                                      const struct m0_fid *fid);

M0_INTERNAL int m0_confc_open_by_fid_sync(struct m0_confc      *confc,
                                          const struct m0_fid  *fid,
                                          struct m0_conf_obj  **result);

/* ------------------------------------------------------------------
 * readdir
 * ------------------------------------------------------------------ */

M0_INTERNAL int m0_confc_readdir(struct m0_confc_ctx *ctx,
                                 struct m0_conf_obj  *dir,
                                 struct m0_conf_obj **pptr);

M0_INTERNAL int m0_confc_readdir_sync(struct m0_conf_obj *dir,
                                      struct m0_conf_obj **pptr);

M0_INTERNAL bool m0_confc_invariant(const struct m0_confc *confc);

M0_INTERNAL bool m0_confc_is_inited(const struct m0_confc *confc);
M0_INTERNAL bool m0_confc_is_online(const struct m0_confc *confc);

M0_INTERNAL struct m0_rpc_conn    *m0_confc2conn(struct m0_confc *confc);
M0_INTERNAL struct m0_rpc_session *m0_confc2sess(struct m0_confc *confc);

#endif /* __MOTR_CONF_CONFC_H__ */