Python3: resources and libraries

Change-Id: I1392c06b1d64f62b141d24c0d42a8e36913b15e2
Signed-off-by: Jan Gelety <jgelety@cisco.com>

1 files changed, 0 insertions, 333 deletions

diff --git a/resources/libraries/python/HTTPRequest.py b/resources/libraries/python/HTTPRequest.py
deleted file mode 100644
index 0f650a89a1..0000000000
--- a/resources/libraries/python/HTTPRequest.py
+++ /dev/null
@@ -1,333 +0,0 @@
-# Copyright (c) 2018 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.
-
-"""Implementation of HTTP requests GET, PUT, POST and DELETE used in
-communication with Honeycomb.
-
-The HTTP requests are implemented in the class HTTPRequest which uses
-requests.request.
-"""
-
-from ipaddress import IPv6Address, AddressValueError
-from enum import IntEnum, unique
-
-from robot.api.deco import keyword
-from robot.api import logger
-from robot.libraries.BuiltIn import BuiltIn
-
-from requests import request, RequestException, Timeout, TooManyRedirects, \
-    HTTPError, ConnectionError
-from requests.auth import HTTPBasicAuth
-
-
-@unique
-class HTTPCodes(IntEnum):
-    """HTTP status codes"""
-    OK = 200  # HTTP standard code name.  # pylint: disable=invalid-name
-    ACCEPTED = 201
-    UNAUTHORIZED = 401
-    FORBIDDEN = 403
-    NOT_FOUND = 404
-    CONFLICT = 409
-    INTERNAL_SERVER_ERROR = 500
-    SERVICE_UNAVAILABLE = 503
-
-
-class HTTPRequestError(Exception):
-    """Exception raised by HTTPRequest objects.
-
-    When raising this exception, put this information to the message in this
-    order:
-
-     - short description of the encountered problem,
-     - relevant messages if there are any collected, e.g., from caught
-       exception,
-     - relevant data if there are any collected.
-
-    The logging is performed on two levels: 1. error - short description of the
-    problem; 2. debug - detailed information.
-    """
-
-    def __init__(self, msg, details='', enable_logging=True):
-        """Sets the exception message and enables / disables logging.
-
-        It is not wanted to log errors when using these keywords together
-        with keywords like "Wait until keyword succeeds". So you can disable
-        logging by setting enable_logging to False.
-
-        :param msg: Message to be displayed and logged.
-        :param enable_logging: When True, logging is enabled, otherwise
-            logging is disabled.
-        :type msg: str
-        :type enable_logging: bool
-        """
-        super(HTTPRequestError, self).__init__()
-        self._msg = "{0}: {1}".format(self.__class__.__name__, msg)
-        self._details = details
-        if enable_logging:
-            logger.info(self._msg)
-            logger.debug(self._details)
-
-    def __repr__(self):
-        return repr(self._msg)
-
-    def __str__(self):
-        return str(self._msg)
-
-
-class HTTPRequest(object):
-    """A class implementing HTTP requests GET, PUT, POST and DELETE used in
-    communication with Honeycomb.
-
-    The communication with Honeycomb and processing of all exceptions is done in
-    the method _http_request which uses requests.request to send requests and
-    receive responses. The received status code and content of response are
-    logged on the debug level.
-    All possible exceptions raised by requests.request are also processed there.
-
-    The other methods (get, put, post and delete) use _http_request to send
-    corresponding request.
-
-    These methods must not be used as keywords in tests. Use keywords
-    implemented in the module HoneycombAPIKeywords instead.
-    """
-
-    def __init__(self):
-        pass
-
-    @staticmethod
-    def create_full_url(ip_addr, port, path):
-        """Creates full url including host, port, and path to data.
-
-        :param ip_addr: Server IP.
-        :param port: Communication port.
-        :param path: Path to data.
-        :type ip_addr: str
-        :type port: str or int
-        :type path: str
-        :returns: Full url.
-        :rtype: str
-        """
-
-        try:
-            IPv6Address(unicode(ip_addr))
-            # IPv6 address must be in brackets
-            ip_addr = "[{0}]".format(ip_addr)
-        except (AttributeError, AddressValueError):
-            pass
-
-        return "http://{ip}:{port}{path}".format(ip=ip_addr, port=port,
-                                                 path=path)
-
-    @staticmethod
-    def _http_request(method, node, path, enable_logging=True, **kwargs):
-        """Sends specified HTTP request and returns status code and response
-        content.
-
-        :param method: The method to be performed on the resource identified by
-        the given request URI.
-        :param node: Honeycomb node.
-        :param path: URL path, e.g. /index.html.
-        :param enable_logging: Used to suppress errors when checking Honeycomb
-        state during suite setup and teardown.
-        :param kwargs: Named parameters accepted by request.request:
-            params -- (optional) Dictionary or bytes to be sent in the query
-            string for the Request.
-            data -- (optional) Dictionary, bytes, or file-like object to
-            send in the body of the Request.
-            json -- (optional) json data to send in the body of the Request.
-            headers -- (optional) Dictionary of HTTP Headers to send with
-            the Request.
-            cookies -- (optional) Dict or CookieJar object to send with the
-            Request.
-            files -- (optional) Dictionary of 'name': file-like-objects
-            (or {'name': ('filename', fileobj)}) for multipart encoding upload.
-            timeout (float or tuple) -- (optional) How long to wait for the
-            server to send data before giving up, as a float, or a (connect
-            timeout, read timeout) tuple.
-            allow_redirects (bool) -- (optional) Boolean. Set to True if POST/
-            PUT/DELETE redirect following is allowed.
-            proxies -- (optional) Dictionary mapping protocol to the URL of
-            the proxy.
-            verify -- (optional) whether the SSL cert will be verified.
-            A CA_BUNDLE path can also be provided. Defaults to True.
-            stream -- (optional) if False, the response content will be
-            immediately downloaded.
-            cert -- (optional) if String, path to ssl client cert file (.pem).
-            If Tuple, ('cert', 'key') pair.
-        :type method: str
-        :type node: dict
-        :type path: str
-        :type enable_logging: bool
-        :type kwargs: dict
-        :returns: Status code and content of response.
-        :rtype: tuple
-        :raises HTTPRequestError: If
-        1. it is not possible to connect,
-        2. invalid HTTP response comes from server,
-        3. request exceeded the configured number of maximum re-directions,
-        4. request timed out,
-        5. there is any other unexpected HTTP request exception.
-        """
-        timeout = kwargs["timeout"]
-
-        use_odl = BuiltIn().get_variable_value("${use_odl_client}")
-
-        if use_odl:
-            port = 8181
-            # Using default ODL Restconf port
-            # TODO: add node["honeycomb"]["odl_port"] to topology, use it here
-            odl_url_part = "/network-topology:network-topology/topology/" \
-                           "topology-netconf/node/vpp/yang-ext:mount"
-        else:
-            port = node["honeycomb"]["port"]
-            odl_url_part = ""
-
-        try:
-            path = path.format(odl_url_part=odl_url_part)
-        except KeyError:
-            pass
-
-        url = HTTPRequest.create_full_url(node['host'],
-                                          port,
-                                          path)
-        try:
-            auth = HTTPBasicAuth(node['honeycomb']['user'],
-                                 node['honeycomb']['passwd'])
-            rsp = request(method, url, auth=auth, verify=False, **kwargs)
-
-            logger.debug("Status code: {0}".format(rsp.status_code))
-            logger.debug("Response: {0}".format(rsp.content))
-
-            return rsp.status_code, rsp.content
-
-        except ConnectionError as err:
-            # Switching the logging on / off is needed only for
-            # "requests.ConnectionError"
-            raise HTTPRequestError("Not possible to connect to {0}:{1}.".
-                                   format(node['host'],
-                                          node['honeycomb']['port']),
-                                   repr(err), enable_logging=enable_logging)
-        except HTTPError as err:
-            raise HTTPRequestError("Invalid HTTP response from {0}.".
-                                   format(node['host']), repr(err))
-        except TooManyRedirects as err:
-            raise HTTPRequestError("Request exceeded the configured number "
-                                   "of maximum re-directions.", repr(err))
-        except Timeout as err:
-            raise HTTPRequestError("Request timed out. Timeout is set to {0}.".
-                                   format(timeout), repr(err))
-        except RequestException as err:
-            raise HTTPRequestError("Unexpected HTTP request exception.",
-                                   repr(err))
-
-    @staticmethod
-    @keyword(name="HTTP Get")
-    def get(node, path, headers=None, timeout=15, enable_logging=True):
-        """Sends a GET request and returns the response and status code.
-
-        :param node: Honeycomb node.
-        :param path: URL path, e.g. /index.html.
-        :param headers: Dictionary of HTTP Headers to send with the Request.
-        :param timeout: How long to wait for the server to send data before
-            giving up, as a float, or a (connect timeout, read timeout) tuple.
-        :param enable_logging: Used to suppress errors when checking Honeycomb
-            state during suite setup and teardown. When True,
-            logging is enabled, otherwise logging is disabled.
-        :type node: dict
-        :type path: str
-        :type headers: dict
-        :type timeout: float or tuple
-        :type enable_logging: bool
-        :returns: Status code and content of response.
-        :rtype: tuple
-        """
-
-        return HTTPRequest._http_request('GET', node, path,
-                                         enable_logging=enable_logging,
-                                         headers=headers, timeout=timeout)
-
-    @staticmethod
-    @keyword(name="HTTP Put")
-    def put(node, path, headers=None, payload=None, json=None, timeout=15):
-        """Sends a PUT request and returns the response and status code.
-
-        :param node: Honeycomb node.
-        :param path: URL path, e.g. /index.html.
-        :param headers: Dictionary of HTTP Headers to send with the Request.
-        :param payload: Dictionary, bytes, or file-like object to send in
-            the body of the Request.
-        :param json: JSON formatted string to send in the body of the Request.
-        :param timeout: How long to wait for the server to send data before
-            giving up, as a float, or a (connect timeout, read timeout) tuple.
-        :type node: dict
-        :type path: str
-        :type headers: dict
-        :type payload: dict, bytes, or file-like object
-        :type json: str
-        :type timeout: float or tuple
-        :returns: Status code and content of response.
-        :rtype: tuple
-        """
-        return HTTPRequest._http_request('PUT', node, path, headers=headers,
-                                         data=payload, json=json,
-                                         timeout=timeout)
-
-    @staticmethod
-    @keyword(name="HTTP Post")
-    def post(node, path, headers=None, payload=None, json=None, timeout=15,
-             enable_logging=True):
-        """Sends a POST request and returns the response and status code.
-
-        :param node: Honeycomb node.
-        :param path: URL path, e.g. /index.html.
-        :param headers: Dictionary of HTTP Headers to send with the Request.
-        :param payload: Dictionary, bytes, or file-like object to send in
-            the body of the Request.
-        :param json: JSON formatted string to send in the body of the Request.
-        :param timeout: How long to wait for the server to send data before
-            giving up, as a float, or a (connect timeout, read timeout) tuple.
-        :param enable_logging: Used to suppress errors when checking ODL
-            state during suite setup and teardown. When True,
-            logging is enabled, otherwise logging is disabled.
-        :type node: dict
-        :type path: str
-        :type headers: dict
-        :type payload: dict, bytes, or file-like object
-        :type json: str
-        :type timeout: float or tuple
-        :type enable_logging: bool
-        :returns: Status code and content of response.
-        :rtype: tuple
-        """
-        return HTTPRequest._http_request('POST', node, path,
-                                         enable_logging=enable_logging,
-                                         headers=headers, data=payload,
-                                         json=json, timeout=timeout)
-
-    @staticmethod
-    @keyword(name="HTTP Delete")
-    def delete(node, path, timeout=15):
-        """Sends a DELETE request and returns the response and status code.
-
-        :param node: Honeycomb node.
-        :param path: URL path, e.g. /index.html.
-        :param timeout: How long to wait for the server to send data before
-            giving up, as a float, or a (connect timeout, read timeout) tuple.
-        :type node: dict
-        :type path: str
-        :type timeout: float or tuple
-        :returns: Status code and content of response.
-        :rtype: tuple
-        """
-        return HTTPRequest._http_request('DELETE', node, path, timeout=timeout)