-# Copyright (c) 2016 Cisco and/or its affiliates.
+# 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:
requests.request.
"""
+from ipaddress import IPv6Address, AddressValueError
from enum import IntEnum, unique
from robot.api.deco import keyword
@unique
class HTTPCodes(IntEnum):
"""HTTP status codes"""
- OK = 200
+ OK = 200 # HTTP standard code name. # pylint: disable=invalid-name
ACCEPTED = 201
UNAUTHORIZED = 401
FORBIDDEN = 403
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.
+
+ - 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.
"""
:param msg: Message to be displayed and logged.
:param enable_logging: When True, logging is enabled, otherwise
- logging is disabled.
+ logging is disabled.
:type msg: str
:type enable_logging: bool
"""
self._msg = "{0}: {1}".format(self.__class__.__name__, msg)
self._details = details
if enable_logging:
- logger.error(self._msg)
+ logger.info(self._msg)
logger.debug(self._details)
def __repr__(self):
:type ip_addr: str
:type port: str or int
:type path: str
- :return: Full url.
+ :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)
:type path: str
:type enable_logging: bool
:type kwargs: dict
- :return: Status code and content of response.
+ :returns: Status code and content of response.
:rtype: tuple
:raises HTTPRequestError: If
1. it is not possible to connect,
"""
timeout = kwargs["timeout"]
- if BuiltIn().get_variable_value("${use_odl_client}"):
- # TODO: node["honeycomb"]["odl_port"]
+ 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:
try:
auth = HTTPBasicAuth(node['honeycomb']['user'],
node['honeycomb']['passwd'])
- rsp = request(method, url, auth=auth, **kwargs)
+ 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))
@staticmethod
@keyword(name="HTTP Get")
- def get(node, path, headers=None, timeout=10, enable_logging=True):
+ 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.
+ 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.
+ 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
- :return: Status code and content of response.
+ :returns: Status code and content of response.
:rtype: tuple
"""
@staticmethod
@keyword(name="HTTP Put")
- def put(node, path, headers=None, payload=None, json=None, timeout=10):
+ 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.
+ 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.
+ 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
- :return: Status code and content of response.
+ :returns: Status code and content of response.
:rtype: tuple
"""
return HTTPRequest._http_request('PUT', node, path, headers=headers,
@staticmethod
@keyword(name="HTTP Post")
- def post(node, path, headers=None, payload=None, json=None, timeout=10,
+ 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 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.
+ 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.
+ 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.
+ 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 json: str
:type timeout: float or tuple
:type enable_logging: bool
- :return: Status code and content of response.
+ :returns: Status code and content of response.
:rtype: tuple
"""
return HTTPRequest._http_request('POST', node, path,
@staticmethod
@keyword(name="HTTP Delete")
- def delete(node, path, timeout=10):
+ 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.
+ giving up, as a float, or a (connect timeout, read timeout) tuple.
:type node: dict
:type path: str
:type timeout: float or tuple
- :return: Status code and content of response.
+ :returns: Status code and content of response.
:rtype: tuple
"""
return HTTPRequest._http_request('DELETE', node, path, timeout=timeout)
Code Review / csit.git / blobdiff