def pingable_or_die(self):
if self.is_pingable:
return True
if self.ip() is None:
helpers.environment_failure("Ping failure - Node '%s' does not"
" have an IP address defined" %
self.name())
helpers.log("Ping %s ('%s')" % (self.ip(), self.name()))
loss = helpers.ping(self.ip(), count=6, loss=50)
if loss > 50:
# We can tolerate 50% loss.
# Consider init to be completed, so as not to be invoked again.
helpers.environment_failure("Ping failure - Node '%s' with IP"
" address %s is unreachable." %
(self.name(), self.ip()))
self.is_pingable = True
return True
def console(self, driver=None, force_reconnect=False):
"""
Inheriting class needs to further extend this method.
"""
helpers.log("Establishing console connection for node '%s'" %
self.name())
if self.dev_console and not force_reconnect:
return self.dev_console
else:
helpers.log("Connecting to console for node '%s'" % self.name())
if 'console' in self.node_params:
self._console_info = self.node_params['console']
else:
helpers.environment_failure(
"Console info is not defined for node '%s'" % self.name())
if 'ip' in self._console_info:
if self._console_info.get('libvirt_vm_name', None):
self._console_info['type'] = 'libvirt'
self._console_info['protocol'] = 'ssh'
self._console_info['port'] = None
elif self._console_info.get('port', None):
self._console_info['type'] = 'telnet'
self._console_info['protocol'] = 'telnet'
else:
helpers.environment_failure("Supported console types are"
" telnet (IP and port) and libvirt"
" (IP and VM name)")
else:
helpers.environment_failure("Console needs an IP and a port or"
" VM name (for libvirt)")
if 'user' not in self._console_info:
self._console_info['user'] = self.user()
if 'password' not in self._console_info:
self._console_info['password'] = self.password()
if driver:
self._console_info['driver'] = driver
elif self.dev:
# helpers.log("driver: %s" % self.dev.driver().name())
# self._console_info['driver'] = self.dev.driver().name()
helpers.log("driver: %s" % self.dev.driver())
self._console_info['driver'] = self.dev.driver()
else:
self._console_info['driver'] = None
helpers.log("Using devconf driver '%s' for console to '%s'" %
(self._console_info['driver'], self.name()))
# This is where we need to instantiate a devconf object,
# if applicable.
return self.dev_console
def console(self, driver=None):
helpers.environment_failure(
"Console is currently not supported for Ixia node.")
def _http_request(self,
url,
verb='GET',
data=None,
session=None,
quiet=0,
save_last_result=True,
log_level='info'):
"""
Generic HTTP request for POST, GET, PUT, DELETE, etc.
data is a Python dictionary.
"""
# helpers.log("url: '%s'" % url)
# helpers.log("verb: '%s'" % verb)
# helpers.log("data: '%s'" % data)
if url is None:
url = self.base_url
if url is None:
helpers.environment_failure("Problem locating base URL.")
headers = self.default_header
if session:
headers['Cookie'] = 'session_cookie=%s' % session
elif self.session_cookie:
headers['Cookie'] = 'session_cookie=%s' % self.session_cookie
if helpers.not_quiet(quiet, [2, 5]):
helpers.log("'%s' RestClient: %s %s" % (self._name, verb, url),
level=5,
log_level=log_level)
helpers.log("'%s' Headers = %s" %
(self._name, helpers.to_json(headers)),
level=5,
log_level=log_level)
if data:
helpers.log("'%s' Data = %s" %
(self._name, helpers.to_json(data)),
level=5,
log_level=log_level)
prefix_str = '%s %s' % (self.name(), verb.lower())
data_str = ''
if data:
data_str = ' %s' % helpers.to_json(data, is_raw=True)
if len(data_str) > 50:
# If data is more than 50 chars long, then prettify JSON
data_str = ' %s' % helpers.to_json(data)
# helpers.bigrobot_devcmd_write("%-9s: %s%s\n"
# % (prefix_str, url, data_str))
if helpers.is_dict(data) or helpers.is_list(data):
formatted_data = helpers.to_json(data)
else:
formatted_data = data
resp, content = self.http.request(url,
verb,
body=formatted_data,
headers=headers)
code = resp['status']
if content:
python_content = helpers.from_json(content)
else:
python_content = {}
result = {'content': python_content}
result['http_verb'] = verb
result['http_data'] = formatted_data
result['status_code'] = int(code)
result['request_url'] = url
if save_last_result:
self.last_result = result
if helpers.not_quiet(quiet, [1, 5]):
self.log_result(result=result, level=6, log_level=log_level)
# ATTENTION: RESTclient will generate an exception when the
# HTTP status code is anything other than:
# - 200-300
# - 200 (OK)
# - 201 (Created)
# - 202 (Accepted)
# - 401 (Authen/session cookie issue)
# - 409 (List element already exists)
#
# Reference:
# http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
if code in RestClient.http_codes:
result['status_descr'] = RestClient.http_codes[code]
elif int(code) in range(200, 300): # Success (BSN-specific)
result['status_descr'] = RestClient.http_codes['200']
else:
result['status_descr'] = RestClient.http_codes['unknown']
result['success'] = False
# As per https://github.com/bigswitch/floodlight/commit/a432f1b501640474b8bf6cb87a07dcbf28df8691
if int(code) in range(200, 300):
result['success'] = True
elif int(code) == 401:
# Session cookie has expired. This requires exception handling
# by BigRobot
pass
elif int(code) == 409:
# On POST when "List element already exists"
result['success'] = True
else:
helpers.test_error("REST call failed with status code %s" % code)
return result
def console(self, driver=None, force_reconnect=False):
helpers.environment_failure(
"Console is currently not supported for Mininet node.")
def __init__(self,
name,
ip,
user,
password,
t,
controller_ip,
controller_ip2=None,
openflow_port=None,
protocol=None,
no_ping=False,
devconf_debug_level=0):
super(MininetNode,
self).__init__(name,
ip,
user,
password,
t,
protocol=protocol,
no_ping=no_ping,
devconf_debug_level=devconf_debug_level)
self.controller_ip = controller_ip
self.controller_ip2 = controller_ip2
self.openflow_port = openflow_port
if 'topology' in self.node_params:
self.topology = self.node_params['topology']
else:
helpers.environment_failure("%s: Mininet topology is missing." %
name)
if 'type' not in self.node_params:
helpers.environment_failure("%s: Must specify a Mininet type in"
" topology file ('t6' or 'basic')." %
name)
if 'start_mininet' not in self.node_params:
self._start_mininet = True
else:
self._start_mininet = self.node_params['start_mininet']
if not helpers.is_bool(self._start_mininet):
helpers.environment_failure("%s: 'start_mininet' must be a"
" boolean value" % name)
self.mn_type = self.node_params['type'].lower()
if self.mn_type not in ('t6', 'basic'):
helpers.environment_failure(
"%s: Mininet type must be 't6' or 'basic'." % name)
if (not t.init_completed() and helpers.params_is_false(
'set_session_ssh', self.node_params)):
helpers.log("'set_session_ssh' is disabled for '%s', bypassing"
" node SSH and RestClient session setup" % name)
return
helpers.log("Mininet type: %s" % self.mn_type)
helpers.log("Setting up mininet ('%s')" % name)
self.dev = self.connect(name=self.name(),
host=self.ip(),
user=self.user(),
password=self.password(),
protocol=self.protocol())
# Shortcuts
self.cli = self.dev.cli
self.bash = self.dev.bash # Bash mode
self.cli_content = self.dev.content
self.cli_result = self.dev.result
self.bash_content = self.dev.content
self.bash_result = self.dev.result
self.start_mininet = self.dev.start_mininet
self.restart_mininet = self.dev.restart_mininet
self.stop_mininet = self.dev.stop_mininet
self.set_prompt = self.dev.set_prompt
self.get_prompt = self.dev.get_prompt
self.send = self.dev.send
self.expect = self.dev.expect
def __init__(self,
name,
ip,
user=None,
password=None,
t=None,
protocol=None,
no_ping=False,
devconf_debug_level=0):
if not name:
helpers.environment_failure("Node name is not defined")
self._name = name
self._user = user
self._password = password
self._ip = None
self._console_info = None
self.http_port = None
self.base_url = None
self.t = t
self.params = t.topology_params()
self.is_pingable = False
self.rest = None # REST handle
self.dev = None # DevConf handle (SSH)
self.dev_console = None # Console handle
self.dev_debug_level = 0
# If name are in the form 'node-<ip_addr>', e.g., 'node-10.193.0.43'
# then they are nodes spawned directly by the user. Don't try to
# look up their attributes in params since they are not defined.
if self.params and not name.startswith('node-'):
self.node_params = self.params[name]
val = helpers.params_val('set_devconf_debug_level',
self.node_params)
if val is not None:
self.dev_debug_level = val
helpers.log("Devconf for '%s' set to debug level %s" %
(name, self.dev_debug_level))
else:
self.node_params = {}
if devconf_debug_level > 0: # override set_devconf_debug_level
self.dev_debug_level = devconf_debug_level
self._port = self.node_params.get('port', None)
self._protocol = protocol if protocol else self.node_params.get(
'protocol', 'ssh')
self._privatekey = self.node_params.get('privatekey', None)
self._privatekey_password = self.node_params.get(
'privatekey_password', None)
self._privatekey_type = self.node_params.get('privatekey_type', None)
self._hostname = self.node_params.get('hostname', None)
if not ip:
if helpers.params_is_false('set_session_ssh', self.node_params):
# set_session_ssh is False, so IP address doesn't have to be
# defined
pass
else:
helpers.environment_failure(
"Node IP address is not defined for '%s'" % name)
else:
self._ip = ip.lower() # IP might be 'dummy'
if self.ip() == 'dummy':
helpers.environment_failure("IP address for '%s' is 'dummy'."
" Needs to be populated." %
self.name())
if helpers.is_esb():
helpers.summary_log("ESB environment - bypassing initial ping")
elif no_ping:
pass
elif helpers.params_is_false('set_init_ping', self.node_params):
helpers.log("'set_init_ping' is disabled for '%s', bypassing"
" initial ping" % name)
else:
self.pingable_or_die()
if name not in _active_nodes:
_active_nodes.append(name)