aboutsummaryrefslogtreecommitdiffstats
path: root/resources/libraries/python
diff options
context:
space:
mode:
Diffstat (limited to 'resources/libraries/python')
-rw-r--r--resources/libraries/python/HTTPRequest.py258
-rw-r--r--resources/libraries/python/HoneycombSetup.py301
-rw-r--r--resources/libraries/python/HoneycombUtil.py97
-rw-r--r--resources/libraries/python/constants.py17
4 files changed, 671 insertions, 2 deletions
diff --git a/resources/libraries/python/HTTPRequest.py b/resources/libraries/python/HTTPRequest.py
new file mode 100644
index 0000000000..7b21f5a761
--- /dev/null
+++ b/resources/libraries/python/HTTPRequest.py
@@ -0,0 +1,258 @@
+# Copyright (c) 2016 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.
+
+"""Implements HTTP requests GET, PUT, POST, DELETE used in communication with
+honeycomb.
+"""
+
+from requests import request, RequestException, Timeout, TooManyRedirects, \
+ HTTPError, ConnectionError
+from requests.auth import HTTPBasicAuth
+
+from robot.api import logger
+from robot.api.deco import keyword
+
+
+HTTP_CODES = {"OK": 200,
+ "UNAUTHORIZED": 401,
+ "FORBIDDEN": 403,
+ "NOT_FOUND": 404,
+ "SERVICE_UNAVAILABLE": 503}
+
+
+class HTTPRequestError(Exception):
+ """Exception raised by HTTPRequest objects."""
+
+ def __init__(self, msg, 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".
+
+ :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 = msg
+ self._repr_msg = self.__module__ + '.' + \
+ self.__class__.__name__ + ": " + self._msg
+
+ if enable_logging:
+ logger.error(self._msg)
+ logger.debug(self._repr_msg)
+
+ def __repr__(self):
+ return repr(self._repr_msg)
+
+ def __str__(self):
+ return str(self._repr_msg)
+
+
+class HTTPRequest(object):
+ """A class implementing HTTP requests."""
+
+ def __init__(self):
+ pass
+
+ @staticmethod
+ def create_full_url(ip_addr, port, path):
+ """Creates full url including IP, 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
+ :return: full url
+ :rtype: str
+ """
+ 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
+ :return: 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"]
+ url = HTTPRequest.create_full_url(node['host'],
+ node['honeycomb']['port'],
+ path)
+ try:
+ auth = HTTPBasicAuth(node['honeycomb']['user'],
+ node['honeycomb']['passwd'])
+ rsp = request(method, url, auth=auth, **kwargs)
+ return rsp.status_code, rsp.content
+
+ except ConnectionError as err:
+ # Switching the logging on / off is needed only for
+ # "requests.ConnectionError"
+ if enable_logging:
+ raise HTTPRequestError("Not possible to connect to {0}\n".
+ format(url) + repr(err))
+ else:
+ raise HTTPRequestError("Not possible to connect to {0}\n".
+ format(url) + repr(err),
+ enable_logging=False)
+ except HTTPError as err:
+ raise HTTPRequestError("Invalid HTTP response from {0}\n".
+ format(url) + repr(err))
+ except TooManyRedirects as err:
+ raise HTTPRequestError("Request exceeded the configured number "
+ "of maximum re-directions\n" + repr(err))
+ except Timeout as err:
+ raise HTTPRequestError("Request timed out. Timeout is set to "
+ "{0}\n".format(timeout) + repr(err))
+ except RequestException as err:
+ raise HTTPRequestError("Unexpected HTTP request exception.\n" +
+ repr(err))
+
+ @staticmethod
+ @keyword(name="HTTP Get")
+ def get(node, path, headers=None, timeout=10, 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
+ :return: 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, timeout=10):
+ """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 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 timeout: float or tuple
+ :return: Status code and content of response
+ :rtype: tuple
+ """
+ return HTTPRequest._http_request('PUT', node, path, headers=headers,
+ data=payload, timeout=timeout)
+
+ @staticmethod
+ @keyword(name="HTTP Post")
+ def post(node, path, headers=None, payload=None, json=None, timeout=10):
+ """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 data 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
+ :return: Status code and content of response
+ :rtype: tuple
+ """
+ return HTTPRequest._http_request('POST', node, path, headers=headers,
+ data=payload, json=json,
+ timeout=timeout)
+
+ @staticmethod
+ @keyword(name="HTTP Delete")
+ def delete(node, path, timeout=10):
+ """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
+ :return: Status code and content of response
+ :rtype: tuple
+ """
+ return HTTPRequest._http_request('DELETE', node, path, timeout=timeout)
diff --git a/resources/libraries/python/HoneycombSetup.py b/resources/libraries/python/HoneycombSetup.py
new file mode 100644
index 0000000000..de05eff6ed
--- /dev/null
+++ b/resources/libraries/python/HoneycombSetup.py
@@ -0,0 +1,301 @@
+# Copyright (c) 2016 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.
+
+"""Implements keywords for Honeycomb setup."""
+
+import os.path
+from xml.etree import ElementTree as ET
+
+from robot.api import logger
+
+from resources.libraries.python.topology import NodeType
+from resources.libraries.python.ssh import SSH
+from resources.libraries.python.HTTPRequest import HTTPRequest, \
+ HTTPRequestError, HTTP_CODES
+from resources.libraries.python.constants import Constants as C
+
+
+class HoneycombError(Exception):
+ """Exception(s) raised by methods working with Honeycomb."""
+
+ def __init__(self, msg, 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".
+
+ :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(HoneycombError, self).__init__()
+ self._msg = msg
+ self._repr_msg = self.__module__ + '.' + \
+ self.__class__.__name__ + ": " + self._msg
+ if enable_logging:
+ logger.error(self._msg)
+ logger.debug(self._repr_msg)
+
+ def __repr__(self):
+ return repr(self._repr_msg)
+
+ def __str__(self):
+ return str(self._repr_msg)
+
+
+class HoneycombSetup(object):
+ """Implements keywords for Honeycomb setup."""
+
+ def __init__(self):
+ pass
+
+ @staticmethod
+ def start_honeycomb_on_all_duts(nodes):
+ """Start honeycomb on all DUT nodes in topology.
+
+ :param nodes: all nodes in topology
+ :type nodes: dict
+ """
+ logger.console("Starting honeycomb service")
+
+ for node in nodes.values():
+ if node['type'] == NodeType.DUT:
+ HoneycombSetup.start_honeycomb(node)
+
+ @staticmethod
+ def start_honeycomb(node):
+ """Start up honeycomb on DUT node.
+
+ :param node: DUT node with honeycomb
+ :type node: dict
+ :return: ret_code, stdout, stderr
+ :rtype: tuple
+ :raises HoneycombError: if Honeycomb fails to start.
+ """
+
+ ssh = SSH()
+ ssh.connect(node)
+ cmd = os.path.join(C.REMOTE_HC_DIR, "start")
+ (ret_code, stdout, stderr) = ssh.exec_command_sudo(cmd)
+ if int(ret_code) != 0:
+ logger.debug('stdout: {0}'.format(stdout))
+ logger.debug('stderr: {0}'.format(stderr))
+ raise HoneycombError('Node {0} failed to start honeycomb'.
+ format(node['host']))
+ return ret_code, stdout, stderr
+
+ @staticmethod
+ def stop_honeycomb_on_all_duts(nodes):
+ """Stop the honeycomb service on all DUTs.
+
+ :param nodes: nodes in topology
+ :type nodes: dict
+ :return: ret_code, stdout, stderr
+ :rtype: tuple
+ :raises HoneycombError: if Honeycomb failed to stop.
+ """
+ logger.console("Shutting down honeycomb service")
+ errors = []
+ for node in nodes.values():
+ if node['type'] == NodeType.DUT:
+
+ ssh = SSH()
+ ssh.connect(node)
+ cmd = os.path.join(C.REMOTE_HC_DIR, "stop")
+ (ret_code, stdout, stderr) = ssh.exec_command_sudo(cmd)
+ if int(ret_code) != 0:
+ logger.debug('stdout: {0}'.format(stdout))
+ logger.debug('stderr: {0}'.format(stderr))
+ errors.append(node['host'])
+ continue
+ logger.info("Honeycomb was successfully stopped on node {0}.".
+ format(node['host']))
+ if errors:
+ raise HoneycombError('Node(s) {0} failed to stop honeycomb.'.
+ format(errors))
+
+ @staticmethod
+ def check_honeycomb_startup_state(nodes):
+ """Check state of honeycomb service during startup.
+
+ Reads html path from template file vpp_version.url
+
+ Honeycomb node replies with connection refused or the following status
+ codes depending on startup progress: codes 200, 401, 403, 404, 503
+
+ :param nodes: nodes in topology
+ :type nodes: dict
+ :return: True if all GETs returned code 200(OK)
+ :rtype bool
+ """
+
+ url_file = os.path.join(C.RESOURCES_TPL_HC, "vpp_version.url")
+ with open(url_file) as template:
+ data = template.readline()
+
+ expected_status_codes = (HTTP_CODES["UNAUTHORIZED"],
+ HTTP_CODES["FORBIDDEN"],
+ HTTP_CODES["NOT_FOUND"],
+ HTTP_CODES["SERVICE_UNAVAILABLE"])
+
+ for node in nodes.values():
+ if node['type'] == NodeType.DUT:
+ status_code, _ = HTTPRequest.get(node, data, timeout=10,
+ enable_logging=False)
+ if status_code == HTTP_CODES["OK"]:
+ pass
+ elif status_code in expected_status_codes:
+ if status_code == HTTP_CODES["UNAUTHORIZED"]:
+ logger.info('Unauthorized. If this triggers keyword '
+ 'timeout, verify honeycomb '
+ 'username and password')
+ raise HoneycombError('Honeycomb on node {0} running but '
+ 'not yet ready.'.format(node['host']),
+ enable_logging=False)
+ else:
+ raise HoneycombError('Unexpected return code: {0}'.
+ format(status_code))
+ return True
+
+ @staticmethod
+ def check_honeycomb_shutdown_state(nodes):
+ """Check state of honeycomb service during shutdown.
+
+ Honeycomb node replies with connection refused or the following status
+ codes depending on shutdown progress: codes 200, 404
+
+ :param nodes: nodes in topology
+ :type nodes: dict
+ :return: True if all GETs fail to connect
+ :rtype bool
+ """
+
+ for node in nodes.values():
+ if node['type'] == NodeType.DUT:
+ try:
+ status_code, _ = HTTPRequest.get(node, '/index.html',
+ timeout=5,
+ enable_logging=False)
+ if status_code == HTTP_CODES["OK"]:
+ raise HoneycombError('Honeycomb on node {0} is still '
+ 'running'.format(node['host']),
+ enable_logging=False)
+ elif status_code == HTTP_CODES["NOT_FOUND"]:
+ raise HoneycombError('Honeycomb on node {0} is shutting'
+ ' down'.format(node['host']),
+ enable_logging=False)
+ else:
+ raise HoneycombError('Unexpected return code: {'
+ '0}'.format(status_code))
+ except HTTPRequestError:
+ logger.debug('Connection refused')
+
+ return True
+
+
+ @staticmethod
+ def add_vpp_to_honeycomb_network_topology(nodes, headers):
+ """Add vpp node to Honeycomb network topology.
+
+ :param nodes: all nodes in test topology
+ :param headers: headers to be used with PUT requests
+ :type nodes: dict
+ :type headers: dict
+ :return: status code and response from PUT requests
+ :rtype: tuple
+ :raises HoneycombError: if a node was not added to honeycomb topology
+
+ Reads HTML path from template file config_topology_node.url
+ Path to the node to be added, e.g.:
+ ("/restconf/config/network-topology:network-topology"
+ "/topology/topology-netconf/node/")
+ There must be "/" at the end, as generated node name is added
+ at the end.
+
+ Reads payload data from template file add_vpp_to_topology.xml
+ Information about node as XML structure, e.g.:
+ <node xmlns="urn:TBD:params:xml:ns:yang:network-topology">
+ <node-id>
+ {vpp_host}
+ </node-id>
+ <host xmlns="urn:opendaylight:netconf-node-topology">
+ {vpp_ip}
+ </host>
+ <port xmlns="urn:opendaylight:netconf-node-topology">
+ {vpp_port}
+ </port>
+ <username xmlns="urn:opendaylight:netconf-node-topology">
+ {user}
+ </username>
+ <password xmlns="urn:opendaylight:netconf-node-topology">
+ {passwd}
+ </password>
+ <tcp-only xmlns="urn:opendaylight:netconf-node-topology">
+ false
+ </tcp-only>
+ <keepalive-delay xmlns="urn:opendaylight:netconf-node-topology">
+ 0
+ </keepalive-delay>
+ </node>
+ NOTE: The placeholders:
+ {vpp_host}
+ {vpp_ip}
+ {vpp_port}
+ {user}
+ {passwd}
+ MUST be there as they are replaced by correct values.
+ """
+
+ with open(os.path.join(C.RESOURCES_TPL_HC, "config_topology_node.url"))\
+ as template:
+ path = template.readline()
+
+ try:
+ xml_data = ET.parse(os.path.join(C.RESOURCES_TPL_HC,
+ "add_vpp_to_topology.xml"))
+ except ET.ParseError as err:
+ raise HoneycombError(repr(err))
+ data = ET.tostring(xml_data.getroot())
+
+ status_codes = []
+ responses = []
+ for node_name, node in nodes.items():
+ if node['type'] == NodeType.DUT:
+ try:
+ payload = data.format(
+ vpp_host=node_name,
+ vpp_ip=node["host"],
+ vpp_port=node['honeycomb']["netconf_port"],
+ user=node['honeycomb']["user"],
+ passwd=node['honeycomb']["passwd"])
+ status_code, resp = HTTPRequest.put(
+ node=node,
+ path=path + '/' + node_name,
+ headers=headers,
+ payload=payload)
+ if status_code != HTTP_CODES["OK"]:
+ raise HoneycombError(
+ "VPP {0} was not added to topology. "
+ "Status code: {1}".format(node["host"],
+ status_code))
+
+ status_codes.append(status_code)
+ responses.append(resp)
+
+ except HTTPRequestError as err:
+ raise HoneycombError("VPP {0} was not added to topology.\n"
+ "{1}".format(node["host"], repr(err)))
+
+ return status_codes, responses
diff --git a/resources/libraries/python/HoneycombUtil.py b/resources/libraries/python/HoneycombUtil.py
new file mode 100644
index 0000000000..c4dc3a067a
--- /dev/null
+++ b/resources/libraries/python/HoneycombUtil.py
@@ -0,0 +1,97 @@
+# Copyright (c) 2016 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.
+
+"""Implements keywords used with Honeycomb."""
+
+import os.path
+from json import loads
+
+from robot.api import logger
+
+from resources.libraries.python.topology import NodeType
+from resources.libraries.python.HTTPRequest import HTTPRequest
+from resources.libraries.python.constants import Constants as C
+
+
+class HoneycombUtil(object):
+ """Implements keywords used with Honeycomb."""
+
+ def __init__(self):
+ pass
+
+ def get_configured_topology(self, nodes):
+ """Retrieves topology node IDs from each honeycomb node.
+
+ :param nodes: all nodes in topology
+ :type nodes: dict
+ :return: list of string IDs such as ['vpp1', 'vpp2']
+ :rtype list
+ """
+
+ url_file = os.path.join(C.RESOURCES_TPL_HC, "config_topology.url")
+ with open(url_file) as template:
+ path = template.readline()
+
+ data = []
+ for node in nodes.values():
+ if node['type'] == NodeType.DUT:
+ _, ret = HTTPRequest.get(node, path)
+ logger.debug('return: {0}'.format(ret))
+ data.append(self.parse_json_response(ret, ("topology",
+ "node", "node-id")))
+
+ return data
+
+ def parse_json_response(self, response, path=None):
+ """Parse data from response string in JSON format according to given
+ path.
+
+ :param response: JSON formatted string
+ :param path: Path to navigate down the data structure
+ :type response: string
+ :type path: tuple
+ :return: JSON dictionary/list tree
+ :rtype: dict
+ """
+ data = loads(response)
+
+ if path:
+ data = self._parse_json_tree(data, path)
+ while isinstance(data, list) and len(data) == 1:
+ data = data[0]
+
+ return data
+
+ def _parse_json_tree(self, data, path):
+ """Retrieve data from python representation of JSON object.
+
+ :param data: parsed JSON dictionary tree
+ :param path: Path to navigate down the dictionary tree
+ :type data: dict
+ :type path: tuple
+ :return: data from specified path
+ :rtype: list or str
+ """
+
+ count = 0
+ for key in path:
+ if isinstance(data, dict):
+ data = data[key]
+ count += 1
+ elif isinstance(data, list):
+ result = []
+ for item in data:
+ result.append(self._parse_json_tree(item, path[count:]))
+ return result
+
+ return data
diff --git a/resources/libraries/python/constants.py b/resources/libraries/python/constants.py
index f9bbc46a95..b3a61da16a 100644
--- a/resources/libraries/python/constants.py
+++ b/resources/libraries/python/constants.py
@@ -10,10 +10,23 @@
# 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.
+
+
class Constants(object):
- #OpenVPP testing directory location at topology nodes
+ # OpenVPP testing directory location at topology nodes
REMOTE_FW_DIR = '/tmp/openvpp-testing'
+
+ # shell scripts location
RESOURCES_LIB_SH = 'resources/libraries/bash'
+
+ # vat templates location
RESOURCES_TPL_VAT = 'resources/templates/vat'
- #OpenVPP VAT binary name
+
+ # OpenVPP VAT binary name
VAT_BIN_NAME = 'vpp_api_test'
+
+ # Honeycomb directory location at topology nodes:
+ REMOTE_HC_DIR = '/opt/honeycomb/v3po-karaf-1.0.0-SNAPSHOT/bin'
+
+ # Honeycomb templates location
+ RESOURCES_TPL_HC = 'resources/templates/honeycomb'