mgmtd: add support for native 'edit' operation

This operation basically implements support for RESTCONF operations. It
receives an xpath and a data tree in JSON/XML format, instead of a list
of (xpath, value) tuples as required by the current protobuf interface.

Signed-off-by: Igor Ryzhov <iryzhov@nfware.com>

5 files changed, 384 insertions, 16 deletions

diff --git a/mgmtd/mgmt_fe_adapter.c b/mgmtd/mgmt_fe_adapter.c
index 62d1a0109a..ab0da64d8f 100644
--- a/mgmtd/mgmt_fe_adapter.c
+++ b/mgmtd/mgmt_fe_adapter.c
@@ -898,11 +898,13 @@ static int mgmt_fe_session_handle_commit_config_req_msg(
 	/*
 	 * Create COMMITConfig request under the transaction
 	 */
-	if (mgmt_txn_send_commit_config_req(
-		    session->cfg_txn_id, commcfg_req->req_id,
-		    commcfg_req->src_ds_id, src_ds_ctx, commcfg_req->dst_ds_id,
-		    dst_ds_ctx, commcfg_req->validate_only, commcfg_req->abort,
-		    false) != 0) {
+	if (mgmt_txn_send_commit_config_req(session->cfg_txn_id,
+					    commcfg_req->req_id,
+					    commcfg_req->src_ds_id, src_ds_ctx,
+					    commcfg_req->dst_ds_id, dst_ds_ctx,
+					    commcfg_req->validate_only,
+					    commcfg_req->abort, false,
+					    NULL) != 0) {
 		fe_adapter_send_commit_cfg_reply(
 			session, commcfg_req->src_ds_id, commcfg_req->dst_ds_id,
 			commcfg_req->req_id, MGMTD_INTERNAL_ERROR,
@@ -1099,6 +1101,33 @@ done:
 	return ret;
 }
 
+static int fe_adapter_send_edit_reply(struct mgmt_fe_session_ctx *session,
+				      uint64_t req_id, const char *xpath)
+{
+	struct mgmt_msg_edit_reply *msg;
+	int ret;
+
+	msg = mgmt_msg_native_alloc_msg(struct mgmt_msg_edit_reply, 0,
+					MTYPE_MSG_NATIVE_EDIT_REPLY);
+	msg->refer_id = session->session_id;
+	msg->req_id = req_id;
+	msg->code = MGMT_MSG_CODE_EDIT_REPLY;
+
+	mgmt_msg_native_xpath_encode(msg, xpath);
+
+	__dbg("Sending edit-reply from adapter %s to session-id %" PRIu64
+	      " req-id %" PRIu64 " len %u",
+	      session->adapter->name, session->session_id, req_id,
+	      mgmt_msg_native_get_msg_len(msg));
+
+	ret = fe_adapter_send_native_msg(session->adapter, msg,
+					 mgmt_msg_native_get_msg_len(msg),
+					 false);
+	mgmt_msg_native_free_msg(msg);
+
+	return ret;
+}
+
 /**
  * fe_adapter_handle_get_data() - Handle a get-tree message from a FE client.
  * @session: the client session.
@@ -1224,6 +1253,112 @@ done:
 	darr_free(xpath_resolved);
 }
 
+static void fe_adapter_handle_edit(struct mgmt_fe_session_ctx *session,
+				   void *__msg, size_t msg_len)
+{
+	struct mgmt_msg_edit *msg = __msg;
+	Mgmtd__DatastoreId ds_id, rds_id;
+	struct mgmt_ds_ctx *ds_ctx, *rds_ctx;
+	const char *xpath, *data;
+	bool lock, commit;
+	int ret;
+
+	if (msg->datastore != MGMT_MSG_DATASTORE_CANDIDATE) {
+		fe_adapter_send_error(session, msg->req_id, false, -EINVAL,
+				      "Unsupported datastore");
+		return;
+	}
+
+	xpath = mgmt_msg_native_xpath_data_decode(msg, msg_len, data);
+	if (!xpath || !data) {
+		fe_adapter_send_error(session, msg->req_id, false, -EINVAL,
+				      "Invalid message");
+		return;
+	}
+
+	ds_id = MGMTD_DS_CANDIDATE;
+	ds_ctx = mgmt_ds_get_ctx_by_id(mm, ds_id);
+	assert(ds_ctx);
+
+	rds_id = MGMTD_DS_RUNNING;
+	rds_ctx = mgmt_ds_get_ctx_by_id(mm, rds_id);
+	assert(rds_ctx);
+
+	lock = CHECK_FLAG(msg->flags, EDIT_FLAG_IMPLICIT_LOCK);
+	commit = CHECK_FLAG(msg->flags, EDIT_FLAG_IMPLICIT_COMMIT);
+
+	if (lock) {
+		if (mgmt_fe_session_write_lock_ds(ds_id, ds_ctx, session)) {
+			fe_adapter_send_error(session, msg->req_id, false,
+					      -EBUSY,
+					      "Candidate DS is locked by another session");
+			return;
+		}
+
+		if (commit) {
+			if (mgmt_fe_session_write_lock_ds(rds_id, rds_ctx,
+							  session)) {
+				mgmt_fe_session_unlock_ds(ds_id, ds_ctx,
+							  session);
+				fe_adapter_send_error(
+					session, msg->req_id, false, -EBUSY,
+					"Running DS is locked by another session");
+				return;
+			}
+		}
+	} else {
+		if (!session->ds_locked[ds_id]) {
+			fe_adapter_send_error(session, msg->req_id, false,
+					      -EBUSY,
+					      "Candidate DS is not locked");
+			return;
+		}
+
+		if (commit) {
+			if (!session->ds_locked[rds_id]) {
+				fe_adapter_send_error(session, msg->req_id,
+						      false, -EBUSY,
+						      "Running DS is not locked");
+				return;
+			}
+		}
+	}
+
+	session->cfg_txn_id = mgmt_create_txn(session->session_id,
+					      MGMTD_TXN_TYPE_CONFIG);
+	if (session->cfg_txn_id == MGMTD_SESSION_ID_NONE) {
+		if (lock) {
+			mgmt_fe_session_unlock_ds(ds_id, ds_ctx, session);
+			if (commit)
+				mgmt_fe_session_unlock_ds(rds_id, rds_ctx,
+							  session);
+		}
+		fe_adapter_send_error(session, msg->req_id, false, -EBUSY,
+				      "Failed to create a configuration transaction");
+		return;
+	}
+
+	__dbg("Created new config txn-id: %" PRIu64 " for session-id: %" PRIu64,
+	      session->cfg_txn_id, session->session_id);
+
+	ret = mgmt_txn_send_edit(session->cfg_txn_id, msg->req_id, ds_id,
+				 ds_ctx, rds_id, rds_ctx, lock, commit,
+				 msg->request_type, msg->flags, msg->operation,
+				 xpath, data);
+	if (ret) {
+		/* destroy the just created txn */
+		mgmt_destroy_txn(&session->cfg_txn_id);
+		if (lock) {
+			mgmt_fe_session_unlock_ds(ds_id, ds_ctx, session);
+			if (commit)
+				mgmt_fe_session_unlock_ds(rds_id, rds_ctx,
+							  session);
+		}
+		fe_adapter_send_error(session, msg->req_id, false, -EBUSY,
+				      "Failed to create a configuration transaction");
+	}
+}
+
 /**
  * Handle a native encoded message from the FE client.
  */
@@ -1245,6 +1380,9 @@ static void fe_adapter_handle_native_msg(struct mgmt_fe_client_adapter *adapter,
 	case MGMT_MSG_CODE_GET_DATA:
 		fe_adapter_handle_get_data(session, msg, msg_len);
 		break;
+	case MGMT_MSG_CODE_EDIT:
+		fe_adapter_handle_edit(session, msg, msg_len);
+		break;
 	default:
 		__log_err("unknown native message session-id %" PRIu64
 			  " req-id %" PRIu64 " code %u to FE adapter %s",
@@ -1484,6 +1622,52 @@ int mgmt_fe_adapter_send_tree_data(uint64_t session_id, uint64_t txn_id,
 	return ret;
 }
 
+int mgmt_fe_adapter_send_edit_reply(uint64_t session_id, uint64_t txn_id,
+				    uint64_t req_id, bool unlock, bool commit,
+				    const char *xpath, int16_t error,
+				    const char *errstr)
+{
+	struct mgmt_fe_session_ctx *session;
+	Mgmtd__DatastoreId ds_id, rds_id;
+	struct mgmt_ds_ctx *ds_ctx, *rds_ctx;
+	int ret;
+
+	session = mgmt_session_id2ctx(session_id);
+	if (!session || session->cfg_txn_id != txn_id)
+		return -1;
+
+	if (session->cfg_txn_id != MGMTD_TXN_ID_NONE && commit)
+		mgmt_fe_session_register_event(session,
+					       MGMTD_FE_SESSION_CFG_TXN_CLNUP);
+
+	if (unlock) {
+		ds_id = MGMTD_DS_CANDIDATE;
+		ds_ctx = mgmt_ds_get_ctx_by_id(mm, ds_id);
+		assert(ds_ctx);
+
+		mgmt_fe_session_unlock_ds(ds_id, ds_ctx, session);
+
+		if (commit) {
+			rds_id = MGMTD_DS_RUNNING;
+			rds_ctx = mgmt_ds_get_ctx_by_id(mm, rds_id);
+			assert(rds_ctx);
+
+			mgmt_fe_session_unlock_ds(rds_id, rds_ctx, session);
+		}
+	}
+
+	if (error)
+		ret = fe_adapter_send_error(session, req_id, false, error, "%s",
+					    errstr);
+	else
+		ret = fe_adapter_send_edit_reply(session, req_id, xpath);
+
+	if (session->cfg_txn_id != MGMTD_TXN_ID_NONE && !commit)
+		mgmt_destroy_txn(&session->cfg_txn_id);
+
+	return ret;
+}
+
 /**
  * Send an error back to the FE client and cleanup any in-progress txn.
  */
diff --git a/mgmtd/mgmt_fe_adapter.h b/mgmtd/mgmt_fe_adapter.h
index e768a3cca0..8d61ffe910 100644
--- a/mgmtd/mgmt_fe_adapter.h
+++ b/mgmtd/mgmt_fe_adapter.h
@@ -163,6 +163,26 @@ mgmt_fe_adapter_send_tree_data(uint64_t session_id, uint64_t txn_id,
 			       int partial_error, bool short_circuit_ok);
 
 /**
+ * Send edit reply back to client. If error is not 0, a native error is sent.
+ *
+ * This also cleans up and frees the transaction.
+ *
+ * Args:
+ *     session_id: the session.
+ *     txn_id: the txn_id this data pertains to
+ *     req_id: the req id for the edit message
+ *     unlock: implicit-lock flag was set in the request
+ *     commit: implicit-commit flag was set in the request
+ *     xpath: the xpath of the data node that was created
+ *     error: the error code, zero for successful request
+ *     errstr: the error string, if error is non-zero
+ */
+extern int mgmt_fe_adapter_send_edit_reply(uint64_t session_id, uint64_t txn_id,
+					   uint64_t req_id, bool unlock,
+					   bool commit, const char *xpath,
+					   int16_t error, const char *errstr);
+
+/**
  * Send an error back to the FE client using native messaging.
  *
  * This also cleans up and frees the transaction.
diff --git a/mgmtd/mgmt_txn.c b/mgmtd/mgmt_txn.c
index 3a052c0e35..901163c6e6 100644
--- a/mgmtd/mgmt_txn.c
+++ b/mgmtd/mgmt_txn.c
@@ -91,6 +91,11 @@ DECLARE_LIST(mgmt_txn_batches, struct mgmt_txn_be_cfg_batch, list_linkage);
 #define FOREACH_TXN_CFG_BATCH_IN_LIST(list, batch)                             \
 	frr_each_safe (mgmt_txn_batches, list, batch)
 
+struct mgmt_edit_req {
+	char xpath_created[XPATH_MAXLEN];
+	bool unlock;
+};
+
 struct mgmt_commit_cfg_req {
 	Mgmtd__DatastoreId src_ds_id;
 	struct mgmt_ds_ctx *src_ds_ctx;
@@ -109,6 +114,12 @@ struct mgmt_commit_cfg_req {
 	enum mgmt_commit_phase be_phase[MGMTD_BE_CLIENT_ID_MAX];
 
 	/*
+	 * Additional information when the commit is triggered by native edit
+	 * request.
+	 */
+	struct mgmt_edit_req *edit;
+
+	/*
 	 * Set of config changes to commit. This is used only
 	 * when changes are NOT to be determined by comparing
 	 * candidate and running DSs. This is typically used
@@ -444,6 +455,8 @@ static void mgmt_txn_req_free(struct mgmt_txn_req **txn_req)
 		cleanup = (ccreq->phase >= MGMTD_COMMIT_PHASE_TXN_CREATE &&
 			   ccreq->phase < MGMTD_COMMIT_PHASE_TXN_DELETE);
 
+		XFREE(MTYPE_MGMTD_TXN_REQ, ccreq->edit);
+
 		FOREACH_MGMTD_BE_CLIENT_ID (id) {
 			/*
 			 * Send TXN_DELETE to cleanup state for this
@@ -604,7 +617,8 @@ static void mgmt_txn_process_set_cfg(struct event *thread)
 								->dst_ds_id,
 							txn_req->req.set_cfg
 								->dst_ds_ctx,
-							false, false, true);
+							false, false, true,
+							NULL);
 
 			if (mm->perf_stats_en)
 				gettimeofday(&cmt_stats->last_start, NULL);
@@ -655,7 +669,8 @@ static int mgmt_txn_send_commit_cfg_reply(struct mgmt_txn_ctx *txn,
 	 * b/c right now that is special cased.. that special casing should be
 	 * removed; however...
 	 */
-	if (!txn->commit_cfg_req->req.commit_cfg.implicit && txn->session_id &&
+	if (!txn->commit_cfg_req->req.commit_cfg.edit &&
+	    !txn->commit_cfg_req->req.commit_cfg.implicit && txn->session_id &&
 	    !txn->commit_cfg_req->req.commit_cfg.rollback &&
 	    mgmt_fe_send_commit_cfg_reply(txn->session_id, txn->txn_id,
 					  txn->commit_cfg_req->req.commit_cfg
@@ -671,7 +686,8 @@ static int mgmt_txn_send_commit_cfg_reply(struct mgmt_txn_ctx *txn,
 			  txn->txn_id, txn->session_id);
 	}
 
-	if (txn->commit_cfg_req->req.commit_cfg.implicit && txn->session_id &&
+	if (!txn->commit_cfg_req->req.commit_cfg.edit &&
+	    txn->commit_cfg_req->req.commit_cfg.implicit && txn->session_id &&
 	    !txn->commit_cfg_req->req.commit_cfg.rollback &&
 	    mgmt_fe_send_set_cfg_reply(txn->session_id, txn->txn_id,
 				       txn->commit_cfg_req->req.commit_cfg
@@ -685,6 +701,21 @@ static int mgmt_txn_send_commit_cfg_reply(struct mgmt_txn_ctx *txn,
 			  txn->txn_id, txn->session_id);
 	}
 
+	if (txn->commit_cfg_req->req.commit_cfg.edit &&
+	    mgmt_fe_adapter_send_edit_reply(txn->session_id, txn->txn_id,
+					    txn->commit_cfg_req->req_id,
+					    txn->commit_cfg_req->req.commit_cfg
+						    .edit->unlock,
+					    true,
+					    txn->commit_cfg_req->req.commit_cfg
+						    .edit->xpath_created,
+					    success ? 0 : -1,
+					    error_if_any) != 0) {
+		__log_err("Failed to send EDIT-REPLY txn-id: %" PRIu64
+			  " session-id: %" PRIu64,
+			  txn->txn_id, txn->session_id);
+	}
+
 	if (success) {
 		/* Stop the commit-timeout timer */
 		/* XXX why only on success? */
@@ -2011,7 +2042,7 @@ int mgmt_txn_send_commit_config_req(uint64_t txn_id, uint64_t req_id,
 				    Mgmtd__DatastoreId dst_ds_id,
 				    struct mgmt_ds_ctx *dst_ds_ctx,
 				    bool validate_only, bool abort,
-				    bool implicit)
+				    bool implicit, struct mgmt_edit_req *edit)
 {
 	struct mgmt_txn_ctx *txn;
 	struct mgmt_txn_req *txn_req;
@@ -2035,6 +2066,7 @@ int mgmt_txn_send_commit_config_req(uint64_t txn_id, uint64_t req_id,
 	txn_req->req.commit_cfg.validate_only = validate_only;
 	txn_req->req.commit_cfg.abort = abort;
 	txn_req->req.commit_cfg.implicit = implicit;
+	txn_req->req.commit_cfg.edit = edit;
 	txn_req->req.commit_cfg.cmt_stats =
 		mgmt_fe_get_session_commit_stats(txn->session_id);
 
@@ -2418,6 +2450,52 @@ state:
 	return 0;
 }
 
+int mgmt_txn_send_edit(uint64_t txn_id, uint64_t req_id,
+		       Mgmtd__DatastoreId ds_id, struct mgmt_ds_ctx *ds_ctx,
+		       Mgmtd__DatastoreId commit_ds_id,
+		       struct mgmt_ds_ctx *commit_ds_ctx, bool unlock,
+		       bool commit, LYD_FORMAT request_type, uint8_t flags,
+		       uint8_t operation, const char *xpath, const char *data)
+{
+	struct mgmt_txn_ctx *txn;
+	struct mgmt_edit_req *edit;
+	struct nb_config *nb_config;
+	char errstr[BUFSIZ];
+	int ret;
+
+	txn = mgmt_txn_id2ctx(txn_id);
+	if (!txn)
+		return -1;
+
+	edit = XCALLOC(MTYPE_MGMTD_TXN_REQ, sizeof(struct mgmt_edit_req));
+
+	nb_config = mgmt_ds_get_nb_config(ds_ctx);
+	assert(nb_config);
+
+	ret = nb_candidate_edit_tree(nb_config, operation, request_type, xpath,
+				     data, edit->xpath_created, errstr,
+				     sizeof(errstr));
+	if (ret)
+		goto reply;
+
+	if (commit) {
+		edit->unlock = unlock;
+
+		mgmt_txn_send_commit_config_req(txn_id, req_id, ds_id, ds_ctx,
+						commit_ds_id, commit_ds_ctx,
+						false, false, true, edit);
+		return 0;
+	}
+reply:
+	mgmt_fe_adapter_send_edit_reply(txn->session_id, txn->txn_id, req_id,
+					unlock, commit, edit->xpath_created,
+					ret ? -1 : 0, errstr);
+
+	XFREE(MTYPE_MGMTD_TXN_REQ, edit);
+
+	return 0;
+}
+
 /*
  * Error reply from the backend client.
  */
diff --git a/mgmtd/mgmt_txn.h b/mgmtd/mgmt_txn.h
index b7198326da..aeb74469f1 100644
--- a/mgmtd/mgmt_txn.h
+++ b/mgmtd/mgmt_txn.h
@@ -43,6 +43,7 @@
 PREDECL_LIST(mgmt_txns);
 
 struct mgmt_master;
+struct mgmt_edit_req;
 
 enum mgmt_txn_type {
 	MGMTD_TXN_TYPE_NONE = 0,
@@ -171,16 +172,17 @@ extern int mgmt_txn_send_set_config_req(uint64_t txn_id, uint64_t req_id,
  * implicit
  *    TRUE if the commit is implicit, FALSE otherwise.
  *
+ * edit
+ *    Additional info when triggered from native edit request.
+ *
  * Returns:
  *    0 on success, -1 on failures.
  */
-extern int mgmt_txn_send_commit_config_req(uint64_t txn_id, uint64_t req_id,
-					   Mgmtd__DatastoreId src_ds_id,
-					   struct mgmt_ds_ctx *dst_ds_ctx,
-					   Mgmtd__DatastoreId dst_ds_id,
-					   struct mgmt_ds_ctx *src_ds_ctx,
-					   bool validate_only, bool abort,
-					   bool implicit);
+extern int mgmt_txn_send_commit_config_req(
+	uint64_t txn_id, uint64_t req_id, Mgmtd__DatastoreId src_ds_id,
+	struct mgmt_ds_ctx *dst_ds_ctx, Mgmtd__DatastoreId dst_ds_id,
+	struct mgmt_ds_ctx *src_ds_ctx, bool validate_only, bool abort,
+	bool implicit, struct mgmt_edit_req *edit);
 
 /*
  * Send get-{cfg,data} request to be processed later in transaction.
@@ -219,6 +221,31 @@ extern int mgmt_txn_send_get_tree_oper(uint64_t txn_id, uint64_t req_id,
 				       uint32_t wd_options, bool simple_xpath,
 				       const char *xpath);
 
+/**
+ * Send edit request.
+ *
+ * Args:
+ *	txn_id: Transaction identifier.
+ *	req_id: FE client request identifier.
+ *	ds_id: Datastore ID.
+ *	ds_ctx: Datastore context.
+ *	commit_ds_id: Commit datastore ID.
+ *	commit_ds_ctx: Commit datastore context.
+ *	unlock: Unlock datastores after the edit.
+ *	commit: Commit the candidate datastore after the edit.
+ *	request_type: LYD_FORMAT request type.
+ *	flags: option flags for the request.
+ *	operation: The operation to perform.
+ *	xpath: The xpath of data node to edit.
+ *	data: The data tree.
+ */
+extern int
+mgmt_txn_send_edit(uint64_t txn_id, uint64_t req_id, Mgmtd__DatastoreId ds_id,
+		   struct mgmt_ds_ctx *ds_ctx, Mgmtd__DatastoreId commit_ds_id,
+		   struct mgmt_ds_ctx *commit_ds_ctx, bool unlock, bool commit,
+		   LYD_FORMAT request_type, uint8_t flags, uint8_t operation,
+		   const char *xpath, const char *data);
+
 /*
  * Notifiy backend adapter on connection.
  */
diff --git a/mgmtd/mgmt_vty.c b/mgmtd/mgmt_vty.c
index 2cd24719bc..61d0760e05 100644
--- a/mgmtd/mgmt_vty.c
+++ b/mgmtd/mgmt_vty.c
@@ -238,6 +238,64 @@ DEFPY(mgmt_replace_config_data, mgmt_replace_config_data_cmd,
 	return CMD_SUCCESS;
 }
 
+DEFPY(mgmt_edit, mgmt_edit_cmd,
+      "mgmt edit {create|delete|merge|replace|remove}$op XPATH [json|xml]$fmt [lock$lock] [commit$commit] [DATA]",
+      MGMTD_STR
+      "Edit configuration data\n"
+      "Create data\n"
+      "Delete data\n"
+      "Merge data\n"
+      "Replace data\n"
+      "Remove data\n"
+      "XPath expression specifying the YANG data path\n"
+      "JSON input format (default)\n"
+      "XML input format\n"
+      "Lock the datastores automatically\n"
+      "Commit the changes automatically\n"
+      "Data tree\n")
+{
+	LYD_FORMAT format = (fmt && fmt[0] == 'x') ? LYD_XML : LYD_JSON;
+	uint8_t operation;
+	uint8_t flags = 0;
+
+	switch (op[2]) {
+	case 'e':
+		operation = NB_OP_CREATE_EXCL;
+		break;
+	case 'l':
+		operation = NB_OP_DELETE;
+		break;
+	case 'r':
+		operation = NB_OP_MODIFY;
+		break;
+	case 'p':
+		operation = NB_OP_REPLACE;
+		break;
+	case 'm':
+		operation = NB_OP_DESTROY;
+		break;
+	default:
+		vty_out(vty, "Invalid operation!\n");
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	if (!data && (operation == NB_OP_CREATE_EXCL ||
+		      operation == NB_OP_MODIFY || operation == NB_OP_REPLACE)) {
+		vty_out(vty, "Data tree is missing!\n");
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	if (lock)
+		flags |= EDIT_FLAG_IMPLICIT_LOCK;
+
+	if (commit)
+		flags |= EDIT_FLAG_IMPLICIT_COMMIT;
+
+	vty_mgmt_send_edit_req(vty, MGMT_MSG_DATASTORE_CANDIDATE, format, flags,
+			       operation, xpath, data);
+	return CMD_SUCCESS;
+}
+
 DEFPY(show_mgmt_get_config, show_mgmt_get_config_cmd,
       "show mgmt get-config [candidate|operational|running]$dsname WORD$path",
       SHOW_STR MGMTD_STR
@@ -643,6 +701,7 @@ void mgmt_vty_init(void)
 	install_element(CONFIG_NODE, &mgmt_delete_config_data_cmd);
 	install_element(CONFIG_NODE, &mgmt_remove_config_data_cmd);
 	install_element(CONFIG_NODE, &mgmt_replace_config_data_cmd);
+	install_element(CONFIG_NODE, &mgmt_edit_cmd);
 	install_element(CONFIG_NODE, &mgmt_load_config_cmd);
 	install_element(CONFIG_NODE, &mgmt_save_config_cmd);
 	install_element(CONFIG_NODE, &mgmt_rollback_cmd);