Merge pull request #13681 from LabNConsulting/chopps/bad-abstract2

lib: mgmtd: remove backend abstraction layer and other cleanup

3 files changed, 140 insertions, 345 deletions

diff --git a/lib/mgmt_be_client.c b/lib/mgmt_be_client.c
index 534dc4340..5c875204f 100644
--- a/lib/mgmt_be_client.c
+++ b/lib/mgmt_be_client.c
@@ -28,6 +28,8 @@
 #define MGMTD_DBG_BE_CLIENT_CHECK()                                            \
 	DEBUG_MODE_CHECK(&mgmt_dbg_be_client, DEBUG_MODE_ALL)
 
+DEFINE_MTYPE_STATIC(LIB, MGMTD_BE_CLIENT, "backend client");
+DEFINE_MTYPE_STATIC(LIB, MGMTD_BE_CLIENT_NAME, "backend client name");
 DEFINE_MTYPE_STATIC(LIB, MGMTD_BE_BATCH, "backend transaction batch data");
 DEFINE_MTYPE_STATIC(LIB, MGMTD_BE_TXN, "backend transaction data");
 
@@ -70,8 +72,6 @@ struct mgmt_be_batch_ctx {
 #define MGMTD_BE_TXN_FLAGS_CFG_APPLIED (1U << 1)
 DECLARE_LIST(mgmt_be_batches, struct mgmt_be_batch_ctx, list_linkage);
 
-struct mgmt_be_client_ctx;
-
 PREDECL_LIST(mgmt_be_txns);
 struct mgmt_be_txn_ctx {
 	/* Txn-Id as assigned by MGMTD */
@@ -79,7 +79,7 @@ struct mgmt_be_txn_ctx {
 	uint32_t flags;
 
 	struct mgmt_be_client_txn_ctx client_data;
-	struct mgmt_be_client_ctx *client_ctx;
+	struct mgmt_be_client *client;
 
 	/* List of batches belonging to this transaction */
 	struct mgmt_be_batches_head cfg_batches;
@@ -100,9 +100,11 @@ DECLARE_LIST(mgmt_be_txns, struct mgmt_be_txn_ctx, list_linkage);
 #define FOREACH_BE_APPLY_BATCH_IN_LIST(txn, batch)                             \
 	frr_each_safe (mgmt_be_batches, &(txn)->apply_cfgs, (batch))
 
-struct mgmt_be_client_ctx {
+struct mgmt_be_client {
 	struct msg_client client;
 
+	char *name;
+
 	struct nb_config *candidate_config;
 	struct nb_config *running_config;
 
@@ -114,7 +116,9 @@ struct mgmt_be_client_ctx {
 	unsigned long avg_apply_nb_cfg_tm;
 
 	struct mgmt_be_txns_head txn_head;
-	struct mgmt_be_client_params client_params;
+
+	struct mgmt_be_client_cbs cbs;
+	uintptr_t user_data;
 };
 
 #define FOREACH_BE_TXN_IN_LIST(client_ctx, txn)                                \
@@ -122,9 +126,6 @@ struct mgmt_be_client_ctx {
 
 struct debug mgmt_dbg_be_client = {0, "Management backend client operations"};
 
-static struct mgmt_be_client_ctx mgmt_be_client_ctx = {
-	.client = {.conn = {.fd = -1}}};
-
 const char *mgmt_be_client_names[MGMTD_BE_CLIENT_ID_MAX + 1] = {
 #ifdef HAVE_STATICD
 	[MGMTD_BE_CLIENT_ID_STATICD] = "staticd",
@@ -132,7 +133,7 @@ const char *mgmt_be_client_names[MGMTD_BE_CLIENT_ID_MAX + 1] = {
 	[MGMTD_BE_CLIENT_ID_MAX] = "Unknown/Invalid",
 };
 
-static int mgmt_be_client_send_msg(struct mgmt_be_client_ctx *client_ctx,
+static int mgmt_be_client_send_msg(struct mgmt_be_client *client_ctx,
 				   Mgmtd__BeMessage *be_msg)
 {
 	return msg_conn_send_msg(
@@ -216,8 +217,7 @@ static void mgmt_be_cleanup_all_batches(struct mgmt_be_txn_ctx *txn)
 }
 
 static struct mgmt_be_txn_ctx *
-mgmt_be_find_txn_by_id(struct mgmt_be_client_ctx *client_ctx,
-			   uint64_t txn_id)
+mgmt_be_find_txn_by_id(struct mgmt_be_client *client_ctx, uint64_t txn_id)
 {
 	struct mgmt_be_txn_ctx *txn = NULL;
 
@@ -230,8 +230,7 @@ mgmt_be_find_txn_by_id(struct mgmt_be_client_ctx *client_ctx,
 }
 
 static struct mgmt_be_txn_ctx *
-mgmt_be_txn_create(struct mgmt_be_client_ctx *client_ctx,
-		       uint64_t txn_id)
+mgmt_be_txn_create(struct mgmt_be_client *client_ctx, uint64_t txn_id)
 {
 	struct mgmt_be_txn_ctx *txn = NULL;
 
@@ -242,7 +241,7 @@ mgmt_be_txn_create(struct mgmt_be_client_ctx *client_ctx,
 		assert(txn);
 
 		txn->txn_id = txn_id;
-		txn->client_ctx = client_ctx;
+		txn->client = client_ctx;
 		mgmt_be_batches_init(&txn->cfg_batches);
 		mgmt_be_batches_init(&txn->apply_cfgs);
 		mgmt_be_txns_add_tail(&client_ctx->txn_head, txn);
@@ -253,8 +252,8 @@ mgmt_be_txn_create(struct mgmt_be_client_ctx *client_ctx,
 	return txn;
 }
 
-static void mgmt_be_txn_delete(struct mgmt_be_client_ctx *client_ctx,
-				   struct mgmt_be_txn_ctx **txn)
+static void mgmt_be_txn_delete(struct mgmt_be_client *client_ctx,
+			       struct mgmt_be_txn_ctx **txn)
 {
 	char err_msg[] = "MGMT Transaction Delete";
 
@@ -274,12 +273,10 @@ static void mgmt_be_txn_delete(struct mgmt_be_client_ctx *client_ctx,
 	 * CFGDATA_CREATE_REQs. But first notify the client
 	 * about the transaction delete.
 	 */
-	if (client_ctx->client_params.txn_notify)
-		(void)(*client_ctx->client_params
-				.txn_notify)(
-			(uintptr_t)client_ctx,
-			client_ctx->client_params.user_data,
-			&(*txn)->client_data, true);
+	if (client_ctx->cbs.txn_notify)
+		(void)(*client_ctx->cbs.txn_notify)(client_ctx,
+						    client_ctx->user_data,
+						    &(*txn)->client_data, true);
 
 	mgmt_be_cleanup_all_batches(*txn);
 	if ((*txn)->nb_txn)
@@ -290,8 +287,7 @@ static void mgmt_be_txn_delete(struct mgmt_be_client_ctx *client_ctx,
 	*txn = NULL;
 }
 
-static void
-mgmt_be_cleanup_all_txns(struct mgmt_be_client_ctx *client_ctx)
+static void mgmt_be_cleanup_all_txns(struct mgmt_be_client *client_ctx)
 {
 	struct mgmt_be_txn_ctx *txn = NULL;
 
@@ -300,9 +296,8 @@ mgmt_be_cleanup_all_txns(struct mgmt_be_client_ctx *client_ctx)
 	}
 }
 
-static int mgmt_be_send_txn_reply(struct mgmt_be_client_ctx *client_ctx,
-				      uint64_t txn_id, bool create,
-				      bool success)
+static int mgmt_be_send_txn_reply(struct mgmt_be_client *client_ctx,
+				  uint64_t txn_id, bool create, bool success)
 {
 	Mgmtd__BeMessage be_msg;
 	Mgmtd__BeTxnReply txn_reply;
@@ -321,8 +316,8 @@ static int mgmt_be_send_txn_reply(struct mgmt_be_client_ctx *client_ctx,
 	return mgmt_be_client_send_msg(client_ctx, &be_msg);
 }
 
-static int mgmt_be_process_txn_req(struct mgmt_be_client_ctx *client_ctx,
-				       uint64_t txn_id, bool create)
+static int mgmt_be_process_txn_req(struct mgmt_be_client *client_ctx,
+				   uint64_t txn_id, bool create)
 {
 	struct mgmt_be_txn_ctx *txn;
 
@@ -342,11 +337,9 @@ static int mgmt_be_process_txn_req(struct mgmt_be_client_ctx *client_ctx,
 		MGMTD_BE_CLIENT_DBG("Created new txn-id %" PRIu64, txn_id);
 		txn = mgmt_be_txn_create(client_ctx, txn_id);
 
-		if (client_ctx->client_params.txn_notify)
-			(void)(*client_ctx->client_params
-					.txn_notify)(
-				(uintptr_t)client_ctx,
-				client_ctx->client_params.user_data,
+		if (client_ctx->cbs.txn_notify)
+			(void)(*client_ctx->cbs.txn_notify)(
+				client_ctx, client_ctx->user_data,
 				&txn->client_data, false);
 	} else {
 		if (!txn) {
@@ -368,10 +361,10 @@ static int mgmt_be_process_txn_req(struct mgmt_be_client_ctx *client_ctx,
 	return 0;
 }
 
-static int
-mgmt_be_send_cfgdata_create_reply(struct mgmt_be_client_ctx *client_ctx,
-				     uint64_t txn_id, uint64_t batch_id,
-				     bool success, const char *error_if_any)
+static int mgmt_be_send_cfgdata_create_reply(struct mgmt_be_client *client_ctx,
+					     uint64_t txn_id, uint64_t batch_id,
+					     bool success,
+					     const char *error_if_any)
 {
 	Mgmtd__BeMessage be_msg;
 	Mgmtd__BeCfgDataCreateReply cfgdata_reply;
@@ -398,7 +391,7 @@ static void mgmt_be_txn_cfg_abort(struct mgmt_be_txn_ctx *txn)
 {
 	char errmsg[BUFSIZ] = {0};
 
-	assert(txn && txn->client_ctx);
+	assert(txn && txn->client);
 	if (txn->nb_txn) {
 		MGMTD_BE_CLIENT_ERR(
 			"Aborting configs after prep for txn-id: %" PRIu64,
@@ -416,13 +409,13 @@ static void mgmt_be_txn_cfg_abort(struct mgmt_be_txn_ctx *txn)
 	MGMTD_BE_CLIENT_DBG(
 		"Reset candidate configurations after abort of txn-id: %" PRIu64,
 		txn->txn_id);
-	nb_config_replace(txn->client_ctx->candidate_config,
-			  txn->client_ctx->running_config, true);
+	nb_config_replace(txn->client->candidate_config,
+			  txn->client->running_config, true);
 }
 
 static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
 {
-	struct mgmt_be_client_ctx *client_ctx;
+	struct mgmt_be_client *client_ctx;
 	struct mgmt_be_txn_req *txn_req = NULL;
 	struct nb_context nb_ctx = {0};
 	struct timeval edit_nb_cfg_start;
@@ -437,15 +430,15 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
 	size_t num_processed;
 	int err;
 
-	assert(txn && txn->client_ctx);
-	client_ctx = txn->client_ctx;
+	assert(txn && txn->client);
+	client_ctx = txn->client;
 
 	num_processed = 0;
 	FOREACH_BE_TXN_BATCH_IN_LIST (txn, batch) {
 		txn_req = &batch->txn_req;
 		error = false;
 		nb_ctx.client = NB_CLIENT_CLI;
-		nb_ctx.user = (void *)client_ctx->client_params.user_data;
+		nb_ctx.user = (void *)client_ctx->user_data;
 
 		if (!txn->nb_txn) {
 			/*
@@ -492,7 +485,7 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
 	 * Now prepare all the batches we have applied in one go.
 	 */
 	nb_ctx.client = NB_CLIENT_CLI;
-	nb_ctx.user = (void *)client_ctx->client_params.user_data;
+	nb_ctx.user = (void *)client_ctx->user_data;
 
 	gettimeofday(&prep_nb_cfg_start, NULL);
 	err = nb_candidate_commit_prepare(nb_ctx, client_ctx->candidate_config,
@@ -556,12 +549,11 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
 /*
  * Process all CFG_DATA_REQs received so far and prepare them all in one go.
  */
-static int
-mgmt_be_update_setcfg_in_batch(struct mgmt_be_client_ctx *client_ctx,
-				  struct mgmt_be_txn_ctx *txn,
-				  uint64_t batch_id,
-				  Mgmtd__YangCfgDataReq * cfg_req[],
-				  int num_req)
+static int mgmt_be_update_setcfg_in_batch(struct mgmt_be_client *client_ctx,
+					  struct mgmt_be_txn_ctx *txn,
+					  uint64_t batch_id,
+					  Mgmtd__YangCfgDataReq *cfg_req[],
+					  int num_req)
 {
 	struct mgmt_be_batch_ctx *batch = NULL;
 	struct mgmt_be_txn_req *txn_req = NULL;
@@ -611,11 +603,10 @@ mgmt_be_update_setcfg_in_batch(struct mgmt_be_client_ctx *client_ctx,
 	return 0;
 }
 
-static int
-mgmt_be_process_cfgdata_req(struct mgmt_be_client_ctx *client_ctx,
-			       uint64_t txn_id, uint64_t batch_id,
-			       Mgmtd__YangCfgDataReq * cfg_req[], int num_req,
-			       bool end_of_data)
+static int mgmt_be_process_cfgdata_req(struct mgmt_be_client *client_ctx,
+				       uint64_t txn_id, uint64_t batch_id,
+				       Mgmtd__YangCfgDataReq *cfg_req[],
+				       int num_req, bool end_of_data)
 {
 	struct mgmt_be_txn_ctx *txn;
 
@@ -640,10 +631,10 @@ mgmt_be_process_cfgdata_req(struct mgmt_be_client_ctx *client_ctx,
 	return 0;
 }
 
-static int mgmt_be_send_apply_reply(struct mgmt_be_client_ctx *client_ctx,
-				       uint64_t txn_id, uint64_t batch_ids[],
-				       size_t num_batch_ids, bool success,
-				       const char *error_if_any)
+static int mgmt_be_send_apply_reply(struct mgmt_be_client *client_ctx,
+				    uint64_t txn_id, uint64_t batch_ids[],
+				    size_t num_batch_ids, bool success,
+				    const char *error_if_any)
 {
 	Mgmtd__BeMessage be_msg;
 	Mgmtd__BeCfgDataApplyReply apply_reply;
@@ -673,7 +664,7 @@ static int mgmt_be_send_apply_reply(struct mgmt_be_client_ctx *client_ctx,
 
 static int mgmt_be_txn_proc_cfgapply(struct mgmt_be_txn_ctx *txn)
 {
-	struct mgmt_be_client_ctx *client_ctx;
+	struct mgmt_be_client *client_ctx;
 	struct timeval apply_nb_cfg_start;
 	struct timeval apply_nb_cfg_end;
 	unsigned long apply_nb_cfg_tm;
@@ -682,8 +673,8 @@ static int mgmt_be_txn_proc_cfgapply(struct mgmt_be_txn_ctx *txn)
 	size_t num_processed;
 	static uint64_t batch_ids[MGMTD_BE_MAX_BATCH_IDS_IN_REQ];
 
-	assert(txn && txn->client_ctx);
-	client_ctx = txn->client_ctx;
+	assert(txn && txn->client);
+	client_ctx = txn->client;
 
 	assert(txn->nb_txn);
 	num_processed = 0;
@@ -735,9 +726,8 @@ static int mgmt_be_txn_proc_cfgapply(struct mgmt_be_txn_ctx *txn)
 	return 0;
 }
 
-static int
-mgmt_be_process_cfg_apply(struct mgmt_be_client_ctx *client_ctx,
-			     uint64_t txn_id)
+static int mgmt_be_process_cfg_apply(struct mgmt_be_client *client_ctx,
+				     uint64_t txn_id)
 {
 	struct mgmt_be_txn_ctx *txn;
 
@@ -754,9 +744,8 @@ mgmt_be_process_cfg_apply(struct mgmt_be_client_ctx *client_ctx,
 	return 0;
 }
 
-static int
-mgmt_be_client_handle_msg(struct mgmt_be_client_ctx *client_ctx,
-			     Mgmtd__BeMessage *be_msg)
+static int mgmt_be_client_handle_msg(struct mgmt_be_client *client_ctx,
+				     Mgmtd__BeMessage *be_msg)
 {
 	/*
 	 * protobuf-c adds a max size enum with an internal, and changing by
@@ -833,12 +822,12 @@ mgmt_be_client_handle_msg(struct mgmt_be_client_ctx *client_ctx,
 static void mgmt_be_client_process_msg(uint8_t version, uint8_t *data,
 				       size_t len, struct msg_conn *conn)
 {
-	struct mgmt_be_client_ctx *client_ctx;
+	struct mgmt_be_client *client_ctx;
 	struct msg_client *client;
 	Mgmtd__BeMessage *be_msg;
 
 	client = container_of(conn, struct msg_client, conn);
-	client_ctx = container_of(client, struct mgmt_be_client_ctx, client);
+	client_ctx = container_of(client, struct mgmt_be_client, client);
 
 	be_msg = mgmtd__be_message__unpack(NULL, len, data);
 	if (!be_msg) {
@@ -853,17 +842,17 @@ static void mgmt_be_client_process_msg(uint8_t version, uint8_t *data,
 	mgmtd__be_message__free_unpacked(be_msg, NULL);
 }
 
-static int mgmt_be_send_subscr_req(struct mgmt_be_client_ctx *client_ctx,
-				   bool subscr_xpaths, uint16_t num_reg_xpaths,
-				   char **reg_xpaths)
+int mgmt_be_send_subscr_req(struct mgmt_be_client *client_ctx,
+			    bool subscr_xpaths, int num_xpaths,
+			    char **reg_xpaths)
 {
 	Mgmtd__BeMessage be_msg;
 	Mgmtd__BeSubscribeReq subscr_req;
 
 	mgmtd__be_subscribe_req__init(&subscr_req);
-	subscr_req.client_name = client_ctx->client_params.name;
-	subscr_req.n_xpath_reg = num_reg_xpaths;
-	if (num_reg_xpaths)
+	subscr_req.client_name = client_ctx->name;
+	subscr_req.n_xpath_reg = num_xpaths;
+	if (num_xpaths)
 		subscr_req.xpath_reg = reg_xpaths;
 	else
 		subscr_req.xpath_reg = NULL;
@@ -881,24 +870,24 @@ static int mgmt_be_send_subscr_req(struct mgmt_be_client_ctx *client_ctx,
 	return mgmt_be_client_send_msg(client_ctx, &be_msg);
 }
 
-static int _notify_conenct_disconnect(struct msg_client *client, bool connected)
+static int _notify_conenct_disconnect(struct msg_client *msg_client,
+				      bool connected)
 {
-	struct mgmt_be_client_ctx *client_ctx =
-		container_of(client, struct mgmt_be_client_ctx, client);
+	struct mgmt_be_client *client =
+		container_of(msg_client, struct mgmt_be_client, client);
 	int ret;
 
 	if (connected) {
-		assert(client->conn.fd != -1);
-		ret = mgmt_be_send_subscr_req(client_ctx, false, 0, NULL);
+		assert(msg_client->conn.fd != -1);
+		ret = mgmt_be_send_subscr_req(client, false, 0, NULL);
 		if (ret)
 			return ret;
 	}
 
 	/* Notify BE client through registered callback (if any) */
-	if (client_ctx->client_params.client_connect_notify)
-		(void)(*client_ctx->client_params.client_connect_notify)(
-			(uintptr_t)client_ctx,
-			client_ctx->client_params.user_data, connected);
+	if (client->cbs.client_connect_notify)
+		(void)(*client->cbs.client_connect_notify)(
+			client, client->user_data, connected);
 	return 0;
 }
 
@@ -914,6 +903,10 @@ static int mgmt_be_client_notify_disconenct(struct msg_conn *conn)
 	return _notify_conenct_disconnect(client, false);
 }
 
+/*
+ * Debug Flags
+ */
+
 DEFPY(debug_mgmt_client_be, debug_mgmt_client_be_cmd,
       "[no] debug mgmt client backend",
       NO_STR DEBUG_STR MGMTD_STR
@@ -956,32 +949,33 @@ static struct cmd_node mgmt_dbg_node = {
 	.config_write = mgmt_debug_be_client_config_write,
 };
 
-/*
- * Initialize library and try connecting with MGMTD.
- */
-uintptr_t mgmt_be_client_lib_init(struct mgmt_be_client_params *params,
-				  struct event_loop *master_thread)
+struct mgmt_be_client *mgmt_be_client_create(const char *client_name,
+					     struct mgmt_be_client_cbs *cbs,
+					     uintptr_t user_data,
+					     struct event_loop *event_loop)
 {
-	/* Don't call twice */
-	assert(!mgmt_be_client_ctx.client.conn.loop);
+	struct mgmt_be_client *client =
+		XCALLOC(MTYPE_MGMTD_BE_CLIENT, sizeof(*client));
 
 	/* Only call after frr_init() */
 	assert(running_config);
 
-	mgmt_be_client_ctx.running_config = running_config;
-	mgmt_be_client_ctx.candidate_config = nb_config_new(NULL);
-	mgmt_be_client_ctx.client_params = *params;
-	mgmt_be_txns_init(&mgmt_be_client_ctx.txn_head);
-	msg_client_init(&mgmt_be_client_ctx.client, master_thread,
-			MGMTD_BE_SERVER_PATH, mgmt_be_client_notify_conenct,
+	client->name = XSTRDUP(MTYPE_MGMTD_BE_CLIENT_NAME, client_name);
+	client->running_config = running_config;
+	client->candidate_config = nb_config_new(NULL);
+	if (cbs)
+		client->cbs = *cbs;
+	mgmt_be_txns_init(&client->txn_head);
+	msg_client_init(&client->client, event_loop, MGMTD_BE_SERVER_PATH,
+			mgmt_be_client_notify_conenct,
 			mgmt_be_client_notify_disconenct,
 			mgmt_be_client_process_msg, MGMTD_BE_MAX_NUM_MSG_PROC,
 			MGMTD_BE_MAX_NUM_MSG_WRITE, MGMTD_BE_MSG_MAX_LEN, false,
 			"BE-client", MGMTD_DBG_BE_CLIENT_CHECK());
 
-	MGMTD_BE_CLIENT_DBG("Initialized client '%s'", params->name);
+	MGMTD_BE_CLIENT_DBG("Initialized client '%s'", client_name);
 
-	return (uintptr_t)&mgmt_be_client_ctx;
+	return client;
 }
 
 
@@ -993,86 +987,16 @@ void mgmt_be_client_lib_vty_init(void)
 	install_element(CONFIG_NODE, &debug_mgmt_client_be_cmd);
 }
 
-
-/*
- * Subscribe with MGMTD for one or more YANG subtree(s).
- */
-enum mgmt_result mgmt_be_subscribe_yang_data(uintptr_t lib_hndl,
-						char *reg_yang_xpaths[],
-						int num_reg_xpaths)
+void mgmt_be_client_destroy(struct mgmt_be_client *client)
 {
-	struct mgmt_be_client_ctx *client_ctx;
-
-	if (!num_reg_xpaths)
-		return MGMTD_SUCCESS;
-
-	client_ctx = (struct mgmt_be_client_ctx *)lib_hndl;
-	if (!client_ctx)
-		return MGMTD_INVALID_PARAM;
-
-	if (mgmt_be_send_subscr_req(client_ctx, true, num_reg_xpaths,
-				       reg_yang_xpaths)
-	    != 0)
-		return MGMTD_INTERNAL_ERROR;
-
-	return MGMTD_SUCCESS;
-}
-
-/*
- * Unsubscribe with MGMTD for one or more YANG subtree(s).
- */
-enum mgmt_result mgmt_be_unsubscribe_yang_data(uintptr_t lib_hndl,
-						  char *reg_yang_xpaths[],
-						  int num_reg_xpaths)
-{
-	struct mgmt_be_client_ctx *client_ctx;
-
-	if (!num_reg_xpaths)
-		return MGMTD_SUCCESS;
-
-	client_ctx = (struct mgmt_be_client_ctx *)lib_hndl;
-	if (!client_ctx)
-		return MGMTD_INVALID_PARAM;
-
-
-	if (mgmt_be_send_subscr_req(client_ctx, false, num_reg_xpaths,
-				       reg_yang_xpaths)
-	    < 0)
-		return MGMTD_INTERNAL_ERROR;
-
-	return MGMTD_SUCCESS;
-}
-
-/*
- * Send one or more YANG notifications to MGMTD daemon.
- */
-enum mgmt_result mgmt_be_send_yang_notify(uintptr_t lib_hndl,
-					     Mgmtd__YangData * data_elems[],
-					     int num_elems)
-{
-	struct mgmt_be_client_ctx *client_ctx;
-
-	client_ctx = (struct mgmt_be_client_ctx *)lib_hndl;
-	if (!client_ctx)
-		return MGMTD_INVALID_PARAM;
-
-	return MGMTD_SUCCESS;
-}
-
-/*
- * Destroy library and cleanup everything.
- */
-void mgmt_be_client_lib_destroy(void)
-{
-	struct mgmt_be_client_ctx *client_ctx = &mgmt_be_client_ctx;
-
 	MGMTD_BE_CLIENT_DBG("Destroying MGMTD Backend Client '%s'",
-			    client_ctx->client_params.name);
+			    client->name);
 
-	msg_client_cleanup(&client_ctx->client);
-	mgmt_be_cleanup_all_txns(client_ctx);
-	mgmt_be_txns_fini(&client_ctx->txn_head);
-	nb_config_free(client_ctx->candidate_config);
+	msg_client_cleanup(&client->client);
+	mgmt_be_cleanup_all_txns(client);
+	mgmt_be_txns_fini(&client->txn_head);
+	nb_config_free(client->candidate_config);
 
-	memset(client_ctx, 0, sizeof(*client_ctx));
+	XFREE(MTYPE_MGMTD_BE_CLIENT_NAME, client->name);
+	XFREE(MTYPE_MGMTD_BE_CLIENT, client);
 }
diff --git a/lib/mgmt_be_client.h b/lib/mgmt_be_client.h
index bbe938b5b..4d8a1f51a 100644
--- a/lib/mgmt_be_client.h
+++ b/lib/mgmt_be_client.h
@@ -82,67 +82,26 @@ enum mgmt_be_client_id {
 
 #define MGMTD_BE_MAX_CLIENTS_PER_XPATH_REG 32
 
+struct mgmt_be_client;
+
 struct mgmt_be_client_txn_ctx {
 	uintptr_t *user_ctx;
 };
 
-/*
- * All the client-specific information this library needs to
- * initialize itself, setup connection with MGMTD BackEnd interface
- * and carry on all required procedures appropriately.
+/**
+ * Backend client callbacks.
  *
- * BackEnd clients need to initialise a instance of this structure
- * with appropriate data and pass it while calling the API
- * to initialize the library (See mgmt_be_client_lib_init for
- * more details).
+ * Callbacks:
+ *	client_connect_notify: called when connection is made/lost to mgmtd.
+ *	txn_notify: called when a txn has been created
  */
-struct mgmt_be_client_params {
-	char name[MGMTD_CLIENT_NAME_MAX_LEN];
-	uintptr_t user_data;
-	unsigned long conn_retry_intvl_sec;
-
-	void (*client_connect_notify)(uintptr_t lib_hndl,
-				      uintptr_t usr_data,
-				      bool connected);
-
-	void (*client_subscribe_notify)(
-		uintptr_t lib_hndl, uintptr_t usr_data,
-		struct nb_yang_xpath **xpath,
-		enum mgmt_result subscribe_result[], int num_paths);
-
-	void (*txn_notify)(
-		uintptr_t lib_hndl, uintptr_t usr_data,
-		struct mgmt_be_client_txn_ctx *txn_ctx, bool destroyed);
-
-	enum mgmt_result (*data_validate)(
-		uintptr_t lib_hndl, uintptr_t usr_data,
-		struct mgmt_be_client_txn_ctx *txn_ctx,
-		struct nb_yang_xpath *xpath, struct nb_yang_value *data,
-		bool delete, char *error_if_any);
-
-	enum mgmt_result (*data_apply)(
-		uintptr_t lib_hndl, uintptr_t usr_data,
-		struct mgmt_be_client_txn_ctx *txn_ctx,
-		struct nb_yang_xpath *xpath, struct nb_yang_value *data,
-		bool delete);
-
-	enum mgmt_result (*get_data_elem)(
-		uintptr_t lib_hndl, uintptr_t usr_data,
-		struct mgmt_be_client_txn_ctx *txn_ctx,
-		struct nb_yang_xpath *xpath, struct nb_yang_xpath_elem *elem);
-
-	enum mgmt_result (*get_data)(
-		uintptr_t lib_hndl, uintptr_t usr_data,
-		struct mgmt_be_client_txn_ctx *txn_ctx,
-		struct nb_yang_xpath *xpath, bool keys_only,
-		struct nb_yang_xpath_elem **elems, int *num_elems,
-		int *next_key);
-
-	enum mgmt_result (*get_next_data)(
-		uintptr_t lib_hndl, uintptr_t usr_data,
-		struct mgmt_be_client_txn_ctx *txn_ctx,
-		struct nb_yang_xpath *xpath, bool keys_only,
-		struct nb_yang_xpath_elem **elems, int *num_elems);
+struct mgmt_be_client_cbs {
+	void (*client_connect_notify)(struct mgmt_be_client *client,
+				      uintptr_t usr_data, bool connected);
+
+	void (*txn_notify)(struct mgmt_be_client *client, uintptr_t usr_data,
+			   struct mgmt_be_client_txn_ctx *txn_ctx,
+			   bool destroyed);
 };
 
 /***************************************************************
@@ -176,20 +135,20 @@ mgmt_be_client_name2id(const char *name)
  * API prototypes
  ***************************************************************/
 
-/*
- * Initialize library and try connecting with MGMTD.
- *
- * params
- *    Backend client parameters.
+/**
+ * Create backend client and connect to MGMTD.
  *
- * master_thread
- *    Thread master.
+ * Args:
+ *	client_name: the name of the client
+ *	cbs: callbacks for various events.
+ *	event_loop: the main event loop.
  *
  * Returns:
- *    Backend client lib handler (nothing but address of mgmt_be_client_ctx)
+ *    Backend client object.
  */
-extern uintptr_t mgmt_be_client_lib_init(struct mgmt_be_client_params *params,
-					 struct event_loop *master_thread);
+extern struct mgmt_be_client *
+mgmt_be_client_create(const char *name, struct mgmt_be_client_cbs *cbs,
+		      uintptr_t user_data, struct event_loop *event_loop);
 
 /*
  * Initialize library vty (adds debug support).
@@ -206,13 +165,13 @@ extern void mgmt_be_client_lib_vty_init(void);
 extern void mgmt_debug_be_client_show_debug(struct vty *vty);
 
 /*
- * Subscribe with MGMTD for one or more YANG subtree(s).
+ * [Un]-subscribe with MGMTD for one or more YANG subtree(s).
  *
- * lib_hndl
- *    Client library handler.
+ * client
+ *    The client object.
  *
  * reg_yang_xpaths
- *    Yang xpath(s) that needs to be subscribed to.
+ *    Yang xpath(s) that needs to be [un]-subscribed from/to
  *
  * num_xpaths
  *    Number of xpaths
@@ -220,52 +179,14 @@ extern void mgmt_debug_be_client_show_debug(struct vty *vty);
  * Returns:
  *    MGMTD_SUCCESS on success, MGMTD_* otherwise.
  */
-extern enum mgmt_result mgmt_be_subscribe_yang_data(uintptr_t lib_hndl,
-						       char **reg_yang_xpaths,
-						       int num_xpaths);
-
-/*
- * Send one or more YANG notifications to MGMTD daemon.
- *
- * lib_hndl
- *    Client library handler.
- *
- * data_elems
- *    Yang data elements from data tree.
- *
- * num_elems
- *    Number of data elements.
- *
- * Returns:
- *    MGMTD_SUCCESS on success, MGMTD_* otherwise.
- */
-extern enum mgmt_result
-mgmt_be_send_yang_notify(uintptr_t lib_hndl, Mgmtd__YangData **data_elems,
-			    int num_elems);
-
-/*
- * Un-subscribe with MGMTD for one or more YANG subtree(s).
- *
- * lib_hndl
- *    Client library handler.
- *
- * reg_yang_xpaths
- *    Yang xpath(s) that needs to be un-subscribed from.
- *
- * num_reg_xpaths
- *    Number of subscribed xpaths
- *
- * Returns:
- *    MGMTD_SUCCESS on success, MGMTD_* otherwise.
- */
-enum mgmt_result mgmt_be_unsubscribe_yang_data(uintptr_t lib_hndl,
-						  char **reg_yang_xpaths,
-						  int num_reg_xpaths);
+extern int mgmt_be_send_subscr_req(struct mgmt_be_client *client,
+				   bool subscr_xpaths, int num_xpaths,
+				   char **reg_xpaths);
 
 /*
- * Destroy library and cleanup everything.
+ * Destroy backend client and cleanup everything.
  */
-extern void mgmt_be_client_lib_destroy(void);
+extern void mgmt_be_client_destroy(struct mgmt_be_client *client);
 
 #ifdef __cplusplus
 }
diff --git a/staticd/static_main.c b/staticd/static_main.c
index 464c42eca..f6b784760 100644
--- a/staticd/static_main.c
+++ b/staticd/static_main.c
@@ -53,7 +53,7 @@ struct option longopts[] = { { 0 } };
 /* Master of threads. */
 struct event_loop *master;
 
-uintptr_t mgmt_lib_hndl;
+struct mgmt_be_client *mgmt_be_client;
 
 static struct frr_daemon_info staticd_di;
 /* SIGHUP handler. */
@@ -71,7 +71,7 @@ static void sigint(void)
 	/* Disable BFD events to avoid wasting processing. */
 	bfd_protocol_integration_set_shutdown(true);
 
-	mgmt_be_client_lib_destroy();
+	mgmt_be_client_destroy(mgmt_be_client);
 
 	static_vrf_terminate();
 
@@ -106,56 +106,6 @@ struct frr_signal_t static_signals[] = {
 	},
 };
 
-#if 0
-static void static_mgmt_be_client_connect(uintptr_t lib_hndl,
-					  uintptr_t usr_data, bool connected)
-{
-	(void)usr_data;
-
-	assert(lib_hndl == mgmt_lib_hndl);
-
-	zlog_debug("Got %s %s MGMTD Backend Client Server",
-		   connected ? "connected" : "disconnected",
-		   connected ? "to" : "from");
-
-	/* unless we are subscribing to xpaths we don't need to do this */
-	if (connected)
-		(void)mgmt_be_subscribe_yang_data(mgmt_lib_hndl, NULL, 0);
-}
-
-static void
-static_mgmt_txn_notify(uintptr_t lib_hndl, uintptr_t usr_data,
-			struct mgmt_be_client_txn_ctx *txn_ctx,
-			bool destroyed)
-{
-	zlog_debug("Got Txn %s Notify from MGMTD server",
-		   destroyed ? "DESTROY" : "CREATE");
-
-	if (!destroyed) {
-		/*
-		 * TODO: Allocate and install a private scratchpad for this
-		 * transaction if required
-		 */
-	} else {
-		/*
-		 * TODO: Uninstall and deallocate the private scratchpad for
-		 * this transaction if installed earlier.
-		 */
-	}
-}
-#endif
-
-static struct mgmt_be_client_params mgmt_params = {
-	.name = "staticd",
-	.conn_retry_intvl_sec = 3,
-	/*
-	 * instead of a connect routine maybe just put xpaths to subcribe to
-	 * here
-	 */
-	.client_connect_notify = NULL, /* static_mgmt_be_client_connect, */
-	.txn_notify = NULL,	    /* static_mgmt_txn_notify */
-};
-
 static const struct frr_yang_module_info *const staticd_yang_modules[] = {
 	&frr_filter_info,
 	&frr_interface_info,
@@ -212,7 +162,7 @@ int main(int argc, char **argv, char **envp)
 	static_vty_init();
 
 	/* Initialize MGMT backend functionalities */
-	mgmt_lib_hndl = mgmt_be_client_lib_init(&mgmt_params, master);
+	mgmt_be_client = mgmt_be_client_create("staticd", NULL, 0, master);
 
 	hook_register(routing_conf_event,
 		      routing_control_plane_protocols_name_validate);