1 files changed, 0 insertions, 166 deletions
diff --git a/resources/libraries/python/honeycomb/Netconf.py b/resources/libraries/python/honeycomb/Netconf.py
deleted file mode 100644
index caca14ed1a..0000000000
--- a/resources/libraries/python/honeycomb/Netconf.py
+++ /dev/null
@@ -1,166 +0,0 @@
-# Copyright (c) 2019 Cisco 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.
-
-"""Keywords used to connect to Honeycomb through Netconf, send messages
- and receive replies."""
-
-import socket
-from time import time
-
-import paramiko
-from robot.api import logger
-
-from resources.libraries.python.honeycomb.HoneycombUtil import HoneycombError
-
-
-class Netconf(object):
-    """Implements methods for creating and managing Netconf sessions."""
-
-    def __init__(self, delimiter=']]>]]>'):
-        """Initializer.
-
-        Note: Passing the channel object as a robotframework argument closes
-        the channel. Class variables are used instead,
-        to persist the connection channel throughout test cases.
-        """
-
-        self.client = None
-        self.channel = None
-        self.delimiter = delimiter
-
-    def create_session(self, node, hello, time_out=10):
-        """Create an SSH session, connect to Honeycomb on the specified node,
-        open a communication channel to the Netconf subsystem and exchange hello
-        messages.
-
-        :param node: Honeycomb node.
-        :param hello: Hello message and capability list to be sent to Honeycomb.
-        :param time_out: Timeout value for the connection in seconds.
-        :type node: dict
-        :type hello: str
-        :type time_out: int
-        """
-
-        start = time()
-        client = paramiko.SSHClient()
-        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-
-        client.connect(node['host'],
-                       username=node['honeycomb']['user'],
-                       password=node['honeycomb']['passwd'],
-                       pkey=None,
-                       port=node['honeycomb']['netconf_port'],
-                       timeout=time_out)
-
-        logger.trace('Connect took {0} seconds'.format(time() - start))
-        logger.debug('New ssh: {0}'.format(client))
-        logger.debug('Connect peer: {0}'.
-                     format(client.get_transport().getpeername()))
-        logger.debug(client)
-
-        channel = client.get_transport().open_session()
-        channel.settimeout(time_out)
-        channel.set_combine_stderr(True)
-        channel.get_pty()
-        channel.invoke_subsystem("netconf")
-        logger.debug(channel)
-
-        self.client = client
-        self.channel = channel
-
-        # read OpenDaylight's hello message and capability list
-        self.get_response(
-            size=131072,
-            err="Timeout on getting hello message."
-        )
-
-        self.channel.send(hello)
-        if not self.channel.active:
-            raise HoneycombError("Channel closed on capabilities exchange.")
-
-    def get_response(self, size=4096, err="Unspecified Error."):
-        """Iteratively read data from the receive buffer and catenate together
-        until message ends with the message delimiter, or
-        until timeout is reached.
-
-        :param size: Maximum number of bytes to read in one iteration.
-        :param err: Error message to provide when timeout is reached.
-        :type size: int
-        :type err: str
-        :returns: Content of response.
-        :rtype: str
-        :raises HoneycombError: If the read process times out.
-        """
-
-        reply = ''
-
-        try:
-            while not reply.endswith(self.delimiter) or \
-                    self.channel.recv_ready():
-                try:
-                    chunk = self.channel.recv(size)
-                    if not chunk:
-                        break
-                    reply += chunk
-                    if self.channel.exit_status_ready():
-                        logger.debug('Channel exit status ready.')
-                        break
-                except socket.timeout:
-                    raise HoneycombError("Socket timeout.",
-                                         enable_logging=False)
-
-        except RuntimeError:
-            raise HoneycombError(err + " Content of buffer: {0}".format(reply),
-                                 enable_logging=False)
-
-        logger.trace(reply)
-        return reply.replace(self.delimiter, "")
-
-    def get_all_responses(self, size=4096):
-        """Read responses from the receive buffer and catenate together
-        until a read operation times out.
-
-        :param size: Maximum number of bytes to read in one iteration.
-        :type size: int
-        :returns: Content of response.
-        :rtype: str
-        """
-
-        response = ""
-        err = "Expected timeout occurred."
-
-        while True:
-            try:
-                response += self.get_response(size, err)
-            except HoneycombError:
-                break
-
-        return response
-
-    def send(self, message, **params):
-        """Sends provided message through the channel.
-
-        :param message: Message to be sent to Honeycomb.
-        :param params: Format the message string with these parameters.
-        :type message: str
-        :type params: dict
-        """
-
-        message = message.format(**params)
-
-        if not message.endswith(self.delimiter):
-            message += self.delimiter
-
-        logger.debug(message)
-
-        self.channel.send(message)