def restart_service(cls, client_object, service_name=None, strict=None):
"""
Restarts the service with the given name.
@type name: str
@param name: Name of the service to be restarted.
@type strict: bool
@param strict: If set to 1/True, then exception will
be raised incase of errors. If set to
0/False, then exception will be discarded. default
value is set to enabled.
"""
current_state = cls.get_individual_service_status(
client_object, service_name)
if current_state == constants.Service.UNKNOWN:
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=current_state)
command = constants.Service.SERVICE_CMD % (service_name,
constants.Service.RESTART)
out = client_object.connection.\
request(command).response_data
pylogger.debug(out)
current_state = cls.get_individual_service_status(
client_object, service_name)
if not current_state == constants.Service.STARTED:
# Final State is started
current_state = "% is in %s state, expected it to be in %s "\
% (service_name, current_state,
constants.Service.STARTED)
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=current_state)
pylogger.info('%s is restarted' % service_name)
def node_cleanup(cls, client_object):
script_path = constants.ManagerScriptPath.NSXNODECLEANUPSCRIPTPATH
endpoint = 'chmod 755 ' + script_path
client_object.connection.login_to_st_en_terminal(expect=['#'])
expect_prompt = ['>', '#']
pylogger.debug("Command executed to change "
"the permission of file: [%s]" % endpoint)
result = client_object.connection.request(endpoint, expect_prompt)
response = result.response_data
if 'No such file or directory' in response:
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=response)
else:
endpoint = script_path
expect_prompt = ['>', '#']
pylogger.debug("Command executed to run "
"the mp node cleanup script: [%s]" % endpoint)
result = client_object.connection.request(endpoint, expect_prompt)
response = result.response_data
# Close the expect connection object
client_object.connection.close()
if response.find("Unable to stop") > 0:
pylogger.error("Failed to run the cleanup script")
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=response)
else:
return common.status_codes.SUCCESS
def set_log_level(cls, client_object, component=None, log_level=None):
"""
Sets the log level of components.
@type client_object: BaseClient
@param client_object: Used to pass commands to the host.
@type log_level: str
@param log_level: Specifies whether the log level is being increased or
decreased. Only supports increasing the log level now.
"""
if component not in cls.NSX_COMPONENTS:
response = ("Only %r components are allowed, got: %r" %
(cls.NSX_COMPONENTS, component))
raise errors.CLIError(
status_code=common.status_codes.INVALID_PARAM, reason=response)
if not log_level.lower() in cls.ALLOWED_LOG_LEVELS:
response = ("Only %r log levels are allowed, got: %r" %
(cls.ALLOWED_LOG_LEVELS, log_level))
raise errors.CLIError(
status_code=common.status_codes.INVALID_PARAM, reason=response)
component_map = {
constants.NSXPackages.OVS_L3D: cls._set_l3d_log_level,
constants.NSXPackages.NSXA: cls._set_nsxa_log_level,
constants.NSXPackages.NSX_MPA: cls._set_nsxmpa_log_level,
constants.NSXPackages.NSX_AGENT: cls._set_nsxagent_log_level
}
component_map[component](client_object, log_level=log_level)
def register_nsx_edge_node(cls, client_object, manager_ip=None,
manager_username=None,
manager_password=None,
manager_thumbprint=None):
try:
# This method register edgenode with nsx manager
cmd = 'join management-plane'
command = ('%s %s thumbprint %s username %s password %s' %
(cmd, manager_ip, manager_thumbprint,
manager_username, manager_password))
# XXX(dbadiani): Prompt we expect after exiting the configure
# termninal mode on Edge VM.
expect = ['bytes*', '>']
pylogger.info("Executing NSX registration command: %s" % command)
result = client_object.connection.request(
command=command, expect=expect)
client_object.connection.close()
if result.status_code == 0:
pylogger.info("Edge registration to NSX succeeded")
else:
pylogger.error("Edge registration to NSX failed")
raise errors.CLIError(status_code=result.status_code,
response_data=result.response_data,
reason=result.error)
except Exception, e:
raise errors.CLIError(exc=e)
def tunnel_process(cls, client_obj, endpoints=None, operation=None):
"""
Kill/Check tunnel to other conntroller on controller
@type endpoints: List
@param endpoints: List of controller object, to get ip address
@type operation: String
@param operation: kill/check
"""
connection = client_obj.connection
status_code = common.status_codes.FAILURE
command = None
error_info = 'No such file'
if operation == 'kill':
pid_list = []
for endpoint in endpoints:
if endpoint.ip != client_obj.ip:
filepath = cls.TUNNEL_PREFIX + endpoint.ip + ":7777.pid"
command = "cat %s" % filepath
result = connection.request(command,
expect=['bytes*', '#'])
response = result.response_data
if error_info in response:
pylogger.error("File %s doesn't exist" % filepath)
raise errors.CLIError(status_code=status_code,
reason=response)
pid = response.split("\n")[0].strip()
pid_list.append(pid)
pid_list = ' '.join(pid_list)
pylogger.debug("The pid list should be killed is %s" % pid_list)
command = "kill %s" % pid_list
result = connection.request(command, expect=['bytes*', '#'])
response = result.response_data
if 'process' in response:
raise errors.CLIError(status_code=status_code, reason=response)
elif operation == 'check':
for endpoint in endpoints:
if endpoint.ip != client_obj.ip:
filepath = cls.TUNNEL_PREFIX + endpoint.ip
command = "cat %s:7777.pid" % filepath
result = connection.request(command,
expect=['bytes*', '#'])
response = result.response_data
if error_info in response:
pylogger.error("File %s doesn't exist" % filepath)
raise errors.CLIError(status_code=status_code,
reason=response)
pid = response
command = "ps ax|grep %s|awk '{print $1}'" % filepath
result = connection.request(command,
expect=['bytes*', '#'])
response = result.response_data
if pid not in response:
raise errors.CLIError(status_code=status_code,
reason=response)
else:
raise ValueError("Received unknown <%s> tunnel "
"partitioning operation" % operation)
return constants.Result.SUCCESS.upper()
def check_node_backup_file(cls, client_object, path, **kwargs):
if path:
endpoint = 'ls -l ' + path
else:
raise ValueError("Received empty path")
pylogger.debug("Command executed to check file: [%s]" % endpoint)
client_object.connection.login_to_st_en_terminal(expect=['#'])
expect_prompt = ['>', '#']
raw_payload = client_object.connection.request(
endpoint, expect_prompt).response_data
client_object.connection.close()
lines = raw_payload.strip().split("\n")
pydict = dict()
if len(lines) > 0:
pydict.update({'content': raw_payload})
return pydict
else:
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason='Node backup file not found')
def check_cluster_backup_file(cls, client_object, path, **kwargs):
if path:
endpoint = 'ls -l ' + path
else:
raise ValueError("Received empty path")
pylogger.debug("Command executed to check file: [%s]" % endpoint)
client_object.connection.login_to_st_en_terminal(expect=['#'])
expect_prompt = ['>', '#']
endpoint1 = 'cd ' + path + ' && ls -L | wc -l'
result = client_object.connection.request(endpoint1, expect_prompt)
response = result.response_data
lines = response.strip().split("\n")
if (len(lines) > 0) and (lines[0] == '1'):
raw_payload = client_object.\
connection.request(endpoint, expect_prompt).response_data
client_object.connection.close()
lines = raw_payload.strip().split("\n")
pydict = dict()
if (len(lines) > 0) and ("backup_" in lines[1]):
pydict.update({'content': 'found'})
return pydict
pylogger.exception("backup file not found")
pydict.update({'content': 'error'})
return pydict
else:
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason='More than one backup file found')
def configure_ip_route(cls, client_obj, **kwargs):
client_obj.connection.request("configure terminal", ['bytes*', '#'])
if kwargs['cidr'] and kwargs['manager_ip']:
endpoint = \
"ip route " + kwargs['cidr'] + " " + kwargs['manager_ip']
else:
raise ValueError("Received empty cidr/manager_ip")
# Reset mode
if 'reset' in kwargs and \
(kwargs['reset'].lower() == 'yes' or
kwargs['reset'].lower() == 'true'):
endpoint = "no " + endpoint
expect_prompt = ["--More--", "#"]
try:
client_obj.connection.request(endpoint, expect_prompt)
# Close the expect connection object
client_obj.connection.close()
return common.status_codes.SUCCESS
except Exception:
raise errors.CLIError(status_code=common.status_codes.FAILURE)
def delete(cls, client_obj, manager_ip=None):
# No join management cluster node
endpoint = "no management-cluster node"
expect_prompt = ['bytes *', '#']
if manager_ip is None:
raise ValueError("Received empty manager ip")
endpoint = endpoint + " " + manager_ip
pylogger.debug("CLI to remove node from mgmt-cluster:[%s]" % endpoint)
client_obj.connection.request("configure terminal", expect_prompt)
raw_payload = (client_obj.connection.request(
endpoint, expect_prompt).response_data)
result_dict = dict()
lines = raw_payload.strip().splitlines()
client_obj.connection.close()
if ((len(lines) > 1) and ((lines[0].upper().find("ERROR") > 0) or
(lines[1].upper().find("ERROR") > 0))):
pylogger.exception("ERROR:Failure observed while running CLI: %s" %
raw_payload)
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason='no join management-cluster command '
'execution returned error')
else:
result_dict['response_data']['status_code'] = (
common.status_codes.SUCCESS)
return result_dict
def copy_tech_support(cls, client_object, logdir=None, collectorIP=None):
"""
Copy CCP tech support file to given dir on collectorIP
@logdir: String
@collectorIP: IP address for collector,
"""
filename = ('techsupportbundle-%s.tar.gz' %
time.strftime("%Y%m%d-%H%M%S"))
cmd = "get support-bundle file " + filename
client_object.connection.request(command=cmd,
expect=['bytes*', '>'])
cmd = ("copy file %s url scp://root@%s%s%s" %
(filename, collectorIP, logdir, filename))
try:
client_object.connection.execute_command_with_hostkey_prompt(
cmd, global_config.DEFAULT_PASSWORD,
final_expect=['bytes*', '>'])
except Exception, error:
pylogger.error("Copy tech support bundle failed from %s "
"to %s with command: %s" %
(client_object.ip, collectorIP, cmd))
pylogger.error("Failed reason: %s" % error)
raise errors.CLIError(status_code=common.status_codes.FAILURE)
def set_banner_motd(cls, client_obj, **kwargs):
# ###
# nsx-manager> configure terminal
# nsx-manager(config)# banner motd
# Enter TEXT message. End with 'Ctrl-D'
# Hello World!!
# nsx-manager(config)#
# ###
if not kwargs['message']:
raise ValueError("Received empty message")
try:
endpoint = "banner motd"
ctrl_key = 'd'
client_obj.connection.request("configure terminal",
['bytes*', '#'])
client_obj.connection.request(endpoint, ["--More--", "\'Ctrl-D\'"])
client_obj.connection.request(kwargs['message'],
["--More--", "\r\n", "#"], ctrl_key)
# Close the expect connection object
client_obj.connection.close()
return common.status_codes.SUCCESS
except Exception:
raise errors.CLIError(status_code=common.status_codes.FAILURE)
def map_sdk_exception(self, exc):
if type(exc) in (AttributeError, RuntimeError, TypeError, ValueError):
return errors.Error(status_code=common.status_codes.RUNTIME_ERROR,
exc=exc)
else:
# reuse same errors as cli
return errors.CLIError(exc=exc)
def get_motd(cls, client_obj, **kwargs):
# ###
# nsx-manager> st e
# Password:
# [root@nsx-manager ~]# cat /etc/motd.tail
# Hello World!!
# [root@nsx-manager ~]#
# ###
pydict = dict()
client_obj.connection.login_to_st_en_terminal(expect=['#'])
endpoint = "cat /etc/motd.tail"
expect_prompt = ['bytes *', '#']
try:
raw_payload = client_obj.connection.request(
endpoint, expect_prompt).response_data
pydict.update({'message': raw_payload})
# Close the expect connection object
client_obj.connection.close()
return pydict
except Exception:
raise errors.CLIError(status_code=common.status_codes.FAILURE)
def remove_nsx_manager(cls,
client_object,
manager_ip=None,
manager_thumbprint=None,
username=None,
password=None):
client_object.set_connection(
connection_type=constants.ConnectionType.EXPECT)
connection = client_object.connection
connection.request(command='/opt/vmware/nsx-cli/bin/scripts/nsxcli',
expect=['bytes*', '.>'])
connection.request(command='config terminal', expect=['bytes*', '#'])
if username is None:
username = constants.ManagerCredential.USERNAME
if password is None:
password = constants.ManagerCredential.PASSWORD
deregister_command = "deregister-node %s %s %s %s" % (
manager_ip, username, manager_thumbprint, password)
result = connection.request(command=deregister_command,
expect=['bytes*', '#'])
pylogger.info("Deregister Host Node result: %s" % result.response_data)
ret = result.response_data
connection.request(command='exit', expect=['bytes*', '.>'])
connection.request(command='exit', expect=['bytes*', '#', '$'])
client_object.restore_connection()
if NODE_DEREGISTRATION_SUCESSS not in ret:
pylogger.error("Host Node Deregistration Failed!")
message = [line for line in ret.splitlines() if "%" in line]
if not message:
message = [ret]
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=message[0][2:])
def _stop_service(cls, client_object, key=None):
current_state = cls._get_service_state(client_object,
EXPECT_PROMPT,
service_name=key)
if current_state == NOTFOUND:
raise errors.CLIError(status_code=-1, reason=current_state)
if current_state == 'STOP':
pylogger.info("%s is already stopped" % key)
else:
command = 'stop service %s' % key
try:
out = client_object.connection.\
request(command, EXPECT_PROMPT).response_data
except Exception as e:
pylogger.warning('%s stop failed due to exception: %s' %
(key, e))
return common.status_codes.FAILURE
pylogger.debug('Command: %s,output: %s' % (command, out))
current_state = cls._get_service_state(client_object,
EXPECT_PROMPT,
service_name=key)
if not current_state == STOP:
pylogger.warning("%s is not stopped, its current state is %s" %
(key, current_state))
return common.status_codes.FAILURE
return common.status_codes.SUCCESS
def read_hostname(cls, client_object, read_hostname=None):
"""
Method to return hostname of esx host.
@rtype: dict
@return: dictionary having esx hostname
"""
_ = read_hostname
command = 'esxcli --debug --formatter=json system hostname get'
try:
raw_payload = client_object.connection.request(
command, ['bytes*', '#']).response_data
except Exception:
error_msg = ("Command [%s] threw an exception during execution" %
command)
pylogger.exception(error_msg)
raise errors.CLIError(status_code=common.status_codes.FAILURE)
finally:
client_object.connection.close()
###
# Command returns json format string e.g.
# {"DomainName": "eng.vmware.com",
# "FullyQualifiedDomainName": "colo-nimbus-dhcp.eng.vmware.com",
# "HostName": "colo-nimbus-dhcp"}
# Converting this string to dictionary using json module
###
pydict = json.loads(raw_payload)
return {"hostname": pydict["FullyQualifiedDomainName"]}
def _restart_service(cls, client_object, key=None):
current_state = cls._get_service_state(client_object,
EXPECT_PROMPT,
service_name=key)
if current_state == NOTFOUND:
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=current_state)
command = 'restart service %s' % key
try:
out = client_object.connection.\
request(command, EXPECT_PROMPT).response_data
except Exception as e:
pylogger.warning('%s restart failed due to exception: %s' %
(key, e))
return common.status_codes.FAILURE
pylogger.debug('Command: %s,output: %s' % (command, out))
current_state = cls._get_service_state(client_object,
EXPECT_PROMPT,
service_name=key)
if not current_state == START:
pylogger.warning('%s is not restarted, its currect state is' %
(key, current_state))
return common.status_codes.FAILURE
pylogger.info('%s is restarted' % key)
return common.status_codes.SUCCESS
def method01(cls, client_object):
pylogger.info("method01(%r) called" % client_object)
out = client_object.connection.request('ls /tmp').response_data
# Assuming the command returned a status_code with 255
status_code = 255
if status_code: # non-zero for cli
raise errors.CLIError(status_code=status_code, reason=out)
def set_ntp_server(cls,
client_obj,
ip=None,
hostname=None,
reset=None,
**kwargs):
client_obj.connection.request("configure terminal", ['bytes*', '#'])
if (((ip is None and hostname is None)
or (ip is not None and hostname is not None))):
raise ValueError("Need to provide either ip or hostname, but "
"provided ip=%s, hostname=%s" % (ip, hostname))
endpoint = "ntp server %s" % (ip or hostname)
# NTP server reset mode
if utilities.is_true(reset):
endpoint = "no " + endpoint
expect_prompt = ["--More--", "#"]
try:
client_obj.connection.request(endpoint, expect_prompt)
client_obj.connection.close()
return common.status_codes.SUCCESS
except Exception, e:
raise errors.CLIError(status_code=common.status_codes.FAILURE,
exc=e)
def start_service(cls, client_object, service_name=None, strict=None):
"""
Starts a service with the given name.
@type name: str
@param name: Name of the service to be started.
@type strict: bool
@param strict: If set to 1/True, then exception will
be raised incase of errors. If set to
0/False, then exception will be discarded. default
value is set to enabled.
@return: Any string from constants.Service.
"""
if strict is None:
strict = True
current_state = cls.get_individual_service_status(
client_object, service_name)
if current_state == constants.Service.UNKNOWN:
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=current_state)
if current_state == constants.Service.STARTED:
pylogger.info("%s is already started" % service_name)
error_reason = ("%s is found started before"
" starting the service." % service_name)
if strict:
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=error_reason)
else:
return current_state
else:
command = constants.Service.SERVICE_CMD % (service_name,
constants.Service.START)
out = client_object.connection.\
request(command).response_data
pylogger.debug(out)
current_state = cls.get_individual_service_status(
client_object, service_name)
if not current_state == constants.Service.STARTED:
# To ensure that process is started state
pylogger.error('%s is not started' % service_name)
current_state = "% is in %s state, expected it to be in %s " \
% (service_name, current_state,
constants.Service.STARTED)
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=current_state)
def wait_for_nsx_services_running(cls, client_object):
pylogger.debug("Checking for nsx services to be running ...")
kwargs = {'service_name': 'nsx-mpa'}
if not timeouts.nsx_mpa_start_delay.wait_until(
client_object.is_service_running,
kwargs=kwargs,
exc_handler=False,
logger=pylogger):
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason='nsx-mpa service is not running')
kwargs = {'service_name': 'nsxa'}
if not timeouts.nsxa_start_delay.wait_until(
client_object.is_service_running,
kwargs=kwargs,
exc_handler=False,
logger=pylogger):
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason='nsxa service is not running')
def _stop_service(cls, client_object, key=None):
current_state = cls._get_service_state(client_object, EXPECT_PROMPT,
service_name=key)
if current_state == NOTFOUND:
raise errors.CLIError(status_code=-1, reason=current_state)
if current_state == 'STOP':
pylogger.info("%s is already stopped" % key)
else:
command = '/etc/init.d/%s stop' % key
out = client_object.connection.\
request(command, EXPECT_PROMPT).response_data
pylogger.debug('Command: %s,output: %s' % (command, out))
current_state = cls._get_service_state(
client_object, EXPECT_PROMPT, service_name=key)
if not current_state == STOP:
current_state = "%s :current State %s" % (key, current_state)
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=current_state)
return common.status_codes.SUCCESS
def set_nsx_manager(cls,
client_object,
manager_ip=None,
manager_thumbprint=None,
username=None,
password=None):
client_object.set_connection(
connection_type=constants.ConnectionType.EXPECT)
connection = client_object.connection
result = connection.request(
command='/opt/vmware/nsx-cli/bin/scripts/nsxcli',
expect=['bytes*', '.>'])
result = connection.request(command='config terminal',
expect=['bytes*', '.#'])
if username is None:
username = constants.ManagerCredential.USERNAME
if password is None:
password = constants.ManagerCredential.PASSWORD
register_command = "register-node %s %s %s %s" % (
manager_ip, username, manager_thumbprint, password)
pylogger.info("Executing fabric host registration command: %s" %
register_command)
result = connection.request(command=register_command,
expect=['bytes*', '#'])
pylogger.info("Register Host Node result: %s" % result.response_data)
ret = result.response_data.splitlines()
# Exit from the config terminal of the CLI.
result = connection.request(command='exit', expect=['bytes*', '.>'])
# Exit from the CLI itself.
result = connection.request(command='exit', expect=['bytes*', '.#'])
if not any(NODE_REGISTRATION_SUCESSS in line for line in ret):
pylogger.error("Host Node Registration Failed!")
message = [line for line in ret if "%" in line]
if len(message) < 1:
message[0] = ret
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=message[0][2:])
else:
pylogger.info("Verifiying that MPA is up ...")
result = connection.request(command='/etc/init.d/nsx-mpa status',
expect=['bytes*', '#'])
if not re.search("is running", result.response_data):
pylogger.error("NSX-MPA is not running!")
raise RuntimeError("NSX-MPA is not running!")
pylogger.info("Verifying nsxa status ...")
# TODO(salmanm): Call helpers for verifying the service status.
result = connection.request(command='/etc/init.d/nsxa status',
expect=['bytes*', '#'])
if not re.search("is running", result.response_data):
pylogger.error("NSXA not started successfully")
raise RuntimeError("NSXA is not running")
client_object.restore_connection()
def get_host_uuid(cls, client_object, get_host_uuid=None):
"""
Method to execute 'show host uuid' cli on KVM host using nsxcli and
return the fetched uuid.
@rtype: dict
@return: dictionary having host UUID
"""
_ = get_host_uuid
# Setting up the pexpect connection
client_object.set_connection(
connection_type=constants.ConnectionType.EXPECT)
connection = client_object.connection
# Invoking nsxcli prompt where the cli would run
command = NSXCLI_SCRIPT_PATH_ON_HV
expect_prompt = ['bytes*', '.>']
try:
connection.request(command, expect_prompt)
endpoint = "show host uuid"
raw_payload = connection.request(endpoint,
expect_prompt).response_data
connection.request(command='exit', expect=['bytes*', '#'])
except Exception:
error_msg = \
"NSXCLI [%s] thrown exception during execution" % endpoint
pylogger.exception(error_msg)
raise errors.CLIError(status_code=common.status_codes.FAILURE)
finally:
client_object.restore_connection()
if len(raw_payload.splitlines()) == 4:
return {'host_uuid': raw_payload.splitlines()[1]}
else:
raise errors.CLIError(
status_code=common.status_codes.FAILURE,
reason='Unexpected CLI output returned, raw_payload: [%s]' %
raw_payload)
def _get_query_object(cls, endpoints, switch_vni):
"""
Helper method to return the right object to be queried for data.
This method determines which host should be queried for getting MAC/ARP
table. If endpoints length is greater than 1, then method
assumes that all passed in objects are controller objects and then
determines the master controller for that vni, otherwise it returns the
one and only element in the verification objects list.
@param endpoints: List of objects on which the query needs
to be made. If multiple entries are found in the list then logic to
figure out master controller is triggered.
@type verification_onjects: list
@param switch_vni: VNI of the logical switch.
@type switch_vni: int
"""
queried_obj = None
if len(endpoints) > 1:
# Check that all objects are of type controller.
all_controllers = [
True for host_elem in endpoints if isinstance(
host_elem, controller_cli_client.ControllerCLIClient)
]
if not all(all_controllers):
raise TypeError("Since the list contains more than 1 element, "
"all elements were expected to be of "
"controller cli clients, got %r" % endpoints)
# Controller verification invloves determing which controller is
# the master controller.
master_controllers = []
for controller in endpoints:
if controller.is_master_for_vni(switch_vni=switch_vni):
master_controllers.append(controller)
if not master_controllers:
reason = ('No controller is identified as the '
'master controller for vni %r. Expected '
'at least one master controller.' % switch_vni)
raise errors.CLIError(
status_code=common.status_codes.NOT_FOUND, reason=reason)
if len(master_controllers) > 1:
raise AssertionError(
'More than one controllers [%r] have '
'been identified as master controllers '
'for vni %r. Expected only one '
'controller to be the master controller' %
([mc.ip for mc in master_controllers], switch_vni))
queried_obj = master_controllers[0]
pylogger.debug("Master controller(s) for LS %r: %r" %
(switch_vni, queried_obj.ip))
else:
queried_obj = endpoints[0]
return queried_obj
def delete_backend_file(cls, client_object, path, file_name):
endpoint = 'rm -rf ' + ' ' + path + '/' + file_name
expect_prompt = ['>', '#']
pylogger.debug("Command executed to delete file: [%s]" % endpoint)
result = client_object.connection.request(endpoint, expect_prompt)
response = result.response_data
if 'No such file or directory' in response:
pylogger.debug("%s file_name does not exist, skipping delete")
return common.status_codes.SUCCESS
if 'cannot remove' in response:
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=response)
else:
return common.status_codes.SUCCESS
def clear_controller(cls, client_obj):
"""Clear the left process in ccp"""
connection = client_obj.connection
command = 'docker ps -q | xargs docker kill | xargs docker rm'
result = connection.request(command, expect=['bytes*', '#'])
response = result.response_data
if 'docker' in response:
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=response)
command = "ps ax|grep openvpn-moot|awk '{print $1}'|xargs kill -9"
result = connection.request(command, expect=['bytes*', '#'])
command = 'openvpn-moot --rmtun --dev tun0'
result = connection.request(command, expect=['bytes*', '#'])
return constants.Result.SUCCESS.upper()
def kill_service(cls, client_object, service_name=None, strict=None):
if strict is None:
strict = True
current_state = cls.get_individual_service_status(
client_object, service_name)
if current_state == constants.Service.UNKNOWN:
current_state = "%s :current State %s"\
% (service_name, current_state)
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=current_state)
if current_state == constants.Service.STOPPED:
# assuming kill will be only used for
# abrupt stop
error_reason = "%s :current State %s"\
% (service_name, current_state)
if strict:
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason=error_reason)
else:
return current_state
else:
pid_before = client_object.connection.\
request("pgrep %s" % service_name)
command = 'pkill %s' % service_name
out = client_object.connection.\
request(command).response_data
pylogger.debug(out)
pid_after = client_object.connection.\
request("pgrep %s" % service_name)
# verifying whether process id is changed because
# watchdog restarts the process for NSX services
# post abrupt stop
if pid_before == pid_after:
raise errors.\
CLIError(status_code=common.status_codes.FAILURE,
reason=current_state)
pylogger.info('%s is killed' % service_name)
def configure_auth_type(cls, client_obj, **kwargs):
client_obj.connection.request("configure terminal", ['bytes*', '#'])
if kwargs['auth_type']:
endpoint = "tacacs-server-authentication " + kwargs['auth_type']
else:
raise ValueError("Received empty type field")
expect_prompt = ["--More--", "#"]
try:
client_obj.connection.request(endpoint, expect_prompt)
# Close the expect connection object
client_obj.connection.close()
return common.status_codes.SUCCESS
except Exception:
raise errors.CLIError(status_code=common.status_codes.FAILURE)
def create(cls, client_obj, schema=None, **kwargs):
if (schema['username'] is None or schema['manager_ip'] is None
or schema['password'] is None
or schema['manager_thumbprint'] is None):
raise ValueError("Required parameters not provided.")
manager_ip = schema['manager_ip']
username = schema['username']
password = schema['password']
thumbprint = schema['manager_thumbprint']
mgr_obj = manager_client.NSXManagerFacade(ip=manager_ip,
username=username,
password=password)
id_ = mgr_obj.get_node_id()
# Construct the command arguments
endpoint = ("join management-cluster " + manager_ip + " " + username +
" " + thumbprint + " " + password)
expect_prompt = ['bytes*', '#']
pylogger.debug("CLI for join node to mgmt-cluster:[%s]" % endpoint)
client_obj.connection.request("configure terminal", expect_prompt)
raw_payload = (client_obj.connection.request(
endpoint, expect_prompt).response_data)
result_dict = dict()
lines = raw_payload.strip().splitlines()
client_obj.connection.close()
if ((len(lines) > 1) and ((lines[0].upper().find("ERROR") > 0) or
(lines[1].upper().find("ERROR") > 0))):
pylogger.exception("ERROR:Failure observed while running CLI "
": %s" % raw_payload)
raise errors.CLIError(status_code=common.status_codes.FAILURE,
reason='join management-cluster command '
'execution returned error')
else:
result_dict['id_'] = id_
return result_dict
