Rework netconf-executor

- rework connection logic
- rework rpc service
- rework netconf session handling
- rework netconf device communicator
- rework python netconf bindings
- rework python netconf client
- add python script showcasing netconf functions

Change-Id: Ibb9bf811e7d96e993aa866371d56c172de83be2c
Issue-ID: CCSDK-790:x
Signed-off-by: Alexis de Talhouët <adetalhouet89@gmail.com>

1 files changed, 70 insertions, 56 deletions

diff --git a/components/scripts/python/ccsdk_netconf/netconfclient.py b/components/scripts/python/ccsdk_netconf/netconfclient.py
index 421e5009..cdaf8409 100644
--- a/components/scripts/python/ccsdk_netconf/netconfclient.py
+++ b/components/scripts/python/ccsdk_netconf/netconfclient.py
@@ -1,60 +1,74 @@
-from netconf_constant import CONFIG_TARGET_RUNNING, CONFIG_DEFAULT_OPERATION_REPLACE
-
+from netconf_constant import CONFIG_TARGET_RUNNING, CONFIG_TARGET_CANDIDATE, \
+  CONFIG_DEFAULT_OPERATION_REPLACE
 
 
 class NetconfClient:
 
-    def __init__(self, log, componentFunction):
-        self.log = log
-        self.componentFunction = componentFunction
-        self.nc = None
-
-    def createRPCServiceFromRequirement(self, requirementName):
-        self.nc = self.componentFunction.netconfRpcClientService(requirementName)
-
-    def disconnect(self):
-        self.nc.disconnect()
-        return
-
-    def connect(self, deviceInfo):
-        self.nc.connect(deviceInfo)
-        return
-
-    def lock(self, messageId, configTarget, messageTimeout=30):
-        deviceResponse = self.nc.lock(messageId, configTarget, messageTimeout)
-        return deviceResponse
-
-    def getConfig(self, messageId, filter, configTarget=CONFIG_TARGET_RUNNING, messageTimeout=30):
-        self.log.info("in the ncclient getConfig {}",messageId)
-        self.log.info("in the ncclient getConfig {}",filter)
-        deviceResponse = self.nc.getConfig(messageId, filter, configTarget, messageTimeout)
-        return deviceResponse
-    
-    def editConfig(self, messageId, messageContent, reConnect=False, wait=0, lock=False,
-                   configTarget=CONFIG_TARGET_RUNNING, editDefaultOperation=CONFIG_DEFAULT_OPERATION_REPLACE, 
-                   deleteConfig= False, validate= False, commit=False, discardChanges =True, unlock=False, 
-                   preRestartWait=0, postRestartWait=0, messageTimeout=30):
-        deviceResponse = self.nc.editConfig(messageId, messageContent, reConnect, wait, lock, configTarget,
-                                            editDefaultOperation, deleteConfig, validate, commit, discardChanges, unlock,
-                                            preRestartWait, postRestartWait, messageTimeout)
-        return deviceResponse
-
-    def commit(self, messageId, message, discardChanges =True, messageTimeout=30):
-        deviceResponse = self.nc.commit(messageId, message, discardChanges, messageTimeout)
-        return deviceResponse
-
-    def unLock(self, messageId, configTarget, messageTimeout=30):
-        deviceResponse = self.nc.unLock(messageId, configTarget, messageTimeout)
-        return deviceResponse
-
-    def discardChanges(self, messageId, messageTimeout=30):
-        deviceResponse = self.nc.discardChanges(messageId, messageTimeout)
-        return deviceResponse
-
-    def close(self, messageId, force=False, messageTimeout=30):
-        deviceResponse = self.nc.close(messageId, force, messageTimeout)
-        return deviceResponse
-
-    def rpc(self, request, messageId, messageTimeout=30):
-        deviceResponse = self.nc.rpc(request, messageId, messageTimeout)
-        return deviceResponse
+  def __init__(self, log, component_function, requirement_name):
+    self.log = log
+    self.component_function = component_function
+    netconf_device = self.component_function.initializeNetconfConnection(
+        requirement_name)
+    self.netconf_rpc_client = netconf_device.netconfRpcService
+    self.netconf_session = netconf_device.netconfSession
+
+  def disconnect(self):
+    self.netconf_session.disconnect()
+    return
+
+  def connect(self):
+    self.netconf_session.connect()
+    return
+
+  def lock(self, message_id, config_target=CONFIG_TARGET_CANDIDATE,
+      message_timeout=30):
+    device_response = self.netconf_rpc_client.lock(message_id, config_target,
+                                                   message_timeout)
+    return device_response
+
+  def get_config(self, message_id, filter="",
+      config_target=CONFIG_TARGET_RUNNING, message_timeout=30):
+    self.log.info("in the ncclient getConfig {}", message_id)
+    device_response = self.netconf_rpc_client.getConfig(message_id, filter,
+                                                        config_target,
+                                                        message_timeout)
+    return device_response
+
+  def edit_config(self, message_id, message_content, lock=False,
+      config_target=CONFIG_TARGET_CANDIDATE,
+      edit_default_peration=CONFIG_DEFAULT_OPERATION_REPLACE,
+      deleteConfig=False, validate=False, commit=False, discard_change=False,
+      unlock=False, message_timeout=30):
+    device_response = self.netconf_rpc_client.editConfig(message_id,
+                                                         message_content, lock,
+                                                         config_target,
+                                                         edit_default_peration,
+                                                         deleteConfig, validate,
+                                                         commit, discard_change,
+                                                         unlock,
+                                                         message_timeout)
+    return device_response
+
+  def commit(self, message_id, discard_change=True,
+      message_timeout=30):
+    device_response = self.netconf_rpc_client.commit(message_id, discard_change,
+                                                     message_timeout)
+    return device_response
+
+  def unlock(self, message_id, config_target=CONFIG_TARGET_CANDIDATE,
+      message_timeout=30):
+    device_response = self.netconf_rpc_client.unLock(message_id, config_target,
+                                                     message_timeout)
+    return device_response
+
+  def validate(self, message_id, config_target=CONFIG_TARGET_CANDIDATE,
+      message_timeout=30):
+    device_response = self.netconf_rpc_client.validate(message_id,
+                                                       config_target,
+                                                       message_timeout)
+    return device_response
+
+  def discard_change(self, message_id, message_timeout=30):
+    device_response = self.netconf_rpc_client.discardConfig(message_id,
+                                                            message_timeout)
+    return device_response