blob: 71557afdaa69f2ef55bbe0ab875e1f610d069004 [file] [log] [blame]
import os
import shutil
import re
from novaclient import client as nova_client
import novaclient.v1_1.client as novaclient
from SSHTestAgent import SSHTestAgent
from CordTestUtils import *
from CordTestUtils import log_test as log
log.setLevel('INFO')
class OnboardingServiceUtils(object):
@classmethod
def setUp(cls):
pass
@classmethod
def tearDown(cls):
pass
'''
@method: get_nova_credentials_v2
@Description: Get nova credentials
@params:
returns credential from env
'''
@classmethod
def get_nova_credentials_v2(cls):
credential = {}
credential['username'] = os.environ['OS_USERNAME']
credential['api_key'] = os.environ['OS_PASSWORD']
credential['auth_url'] = os.environ['OS_AUTH_URL']
credential['project_id'] = os.environ['OS_TENANT_NAME']
return credential
'''
@method: get_compute_nodes
@Description: Get the list of compute nodes
@params:
returns node list
'''
@classmethod
def get_compute_nodes(cls):
credentials = cls.get_nova_credentials_v2()
nvclient = nova_client.Client('2', **credentials)
return nvclient.hypervisors.list()
'''
@method: get_exampleservices
@Description: Get list of exampleservice's running in compute node
@params: status of exampleservice
returns exampleservice wrappers
'''
@classmethod
def get_exampleservices(cls, active = True):
credentials = cls.get_nova_credentials_v2()
nvclient = nova_client.Client('2', **credentials)
exampleservices = nvclient.servers.list(search_opts = {'all_tenants': 1})
if active is True:
exampleservices = filter(lambda exampleservice: exampleservice.status == 'ACTIVE', exampleservices)
exampleservice_wrappers = []
for exampleservice in exampleservices:
exampleservice_wrappers.append(ExampleSeviceWrapper(exampleservice))
return exampleservice_wrappers
'''
@method: health_check
@Description: Check if exampleservices are reachable
@params:
returns True
'''
@classmethod
def health_check(cls):
'''Returns 0 if all active exampleservices are reachable through the compute node'''
exampleservices = cls.get_exampleservices()
exampleservice_status = []
for exampleservice in exampleservices:
exampleservice_status.append(exampleservice.get_health())
unreachable = filter(lambda st: st == False, exampleservice_status)
return len(unreachable) == 0
def make_veth_pairs(self):
def check_iface(iface):
return os.system('ip link show {}'.format(iface)) == 0
def make_veth(iface):
os.system('ip link add type veth')
os.system('ip link set {} up'.format(iface))
peer = iface[:len('veth')] + str(int(iface[len('veth'):]) + 1)
os.system('ip link set {} up'.format(peer))
assert has_iface(iface)
for iface_number in (0, 2):
iface = 'veth{}'.format(iface_number)
if not check_iface(iface):
make_veth(iface)
yield asleep(2)
def source_env(self):
a_dir = os.path.abspath(os.path.dirname(__file__))
res = os.system('cd {}'.format(a_dir))
assert res == 0
# set the env
command = ['bash', '-c', '. env.sh']
proc = subprocess.Popen(command, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if proc.wait() != 0:
err_msg = "Failed to source the environment'"
raise RuntimeError(err_msg)
env = os.environ.copy()
return env
@classmethod
def discover_exampleservice_vm_instance_on_cord(cls, tenant_name):
name=None
status=None
try:
credentials = cls.get_nova_credentials_v2()
nvclient = nova_client.Client('2', **credentials)
instance_list=nvclient.servers.list()
if instance_list > 0:
for inst in instance_list:
instance_id = inst.id
name=inst.name
inst_find=nvclient.servers.find(id=instance_id)
print(' - Instance %s Discovered' % inst.name)
print(' - Instance ID %s Discovered' % instance_id)
print(' - Instance %s Status' % inst.status)
status=inst.status
except Exception:
print(' - Instance Not Found')
status = False
instance_data = {'instance_name': name,
'status': status }
return instance_data
@classmethod
def terminate_exampleservice_instance_vm_on_cord(cls, tenant_name, vm_name, network_id):
credentials = cls.get_nova_credentials_v2()
nvclient = nova_client.Client('2', **credentials)
nvclient.quotas.delete(tenant_name)
try:
instance = nvclient.servers.find(name=vm_name)
nvclient.servers.delete(instance.id)
print " * Instance terminated on cord: " + str(network_id)
except Exception:
print " * Instance Not Found on cord: " + str(network_id)
pass
return True
class ExampleSeviceWrapper(object):
def __init__(self, exampleservice):
self.exampleservice = exampleservice
self.name = self.exampleservice.name
self.compute_node = self.get_compute_node()
self.ip = self.get_ip()
'''
@method: get_compute_node
@Description:
@params:
returns compute node name
'''
def get_compute_node(self):
return self.exampleservice._info['OS-EXT-SRV-ATTR:hypervisor_hostname']
'''
@method: get_ip
@Description:
@params:
returns ip of network
'''
def get_ip(self):
if 'management' in self.exampleservice.networks:
ips = self.exampleservice.networks['management']
if len(ips) > 0:
return ips[0]
return None
def get_public_ip(self):
if 'public' in self.exampleservice.networks:
ips = self.exampleservice.networks['public']
if len(ips) > 0:
return ips[0]
return None
def get_name(self):
return self.exampleservice.name
'''
@method: run_cmd_compute
@Description:
@params:
returns Status & output
'''
def run_cmd_compute(self, cmd, timeout = 5):
ssh_agent = SSHTestAgent(self.compute_node)
st, output = ssh_agent.run_cmd(cmd, timeout = timeout)
if st == True and output:
output = output.strip()
else:
output = None
return st, output
'''
@method: get_health
@Description:
@params:
returns Status
'''
def get_health(self):
if self.ip is None:
return True
cmd = 'ping -c 1 {}'.format(self.ip)
log.info('Pinging ONBOARDED SERVICE %s at IP %s' %(self.name, self.ip))
st, _ = self.run_cmd_compute(cmd)
log.info('ONBOARDED SERVICE %s at IP %s is %s' %(self.name, self.ip, 'reachable' if st == True else 'unreachable'))
return st
'''
@method: check_access
@Description: validates access
@params:
returns Status
'''
def check_access(self):
if self.ip is None:
return True
ssh_agent = SSHTestAgent(self.compute_node)
st, _ = ssh_agent.run_cmd('ls', timeout=10)
if st == False:
log.error('Compute node at %s is not accessible' %(self.compute_node))
return st
log.info('Checking if ONBOARDING SERVICE at %s is accessible from compute node %s' %(self.ip, self.compute_node))
st, _ = ssh_agent.run_cmd('ssh {} ls'.format(self.ip), timeout=30)
if st == True:
log.info('OK')
return st
'''
@method: Validate services
@Description: This validates if expected service is running in example service VM
@params:
returns Status
'''
def validate_service_in_vm(self):
if self.ip is None:
return True
ssh_agent = SSHTestAgent(self.compute_node)
st, _ = ssh_agent.run_cmd('ls', timeout=10)
if st == False:
log.error('Compute node at %s is not accessible' %(self.compute_node))
return st
log.info('Checking if APACHE SERVICE at %s is running %s' %(self.ip, self.compute_node))
st, _ = ssh_agent.run_cmd('ssh {} ls /var/run/apache2/apache2.pid'.format(self.ip), timeout=30)
if st == True:
log.info('OK')
return st
def pause(self):
return self.exampleservice.pause()
def unpause(self):
return self.exampleservice.unpause()
def stop(self):
return self.exampleservice.stop()
def start(self):
return self.exampleservice.start()
def suspend(self):
return self.exampleservice.suspend()
def resume(self):
return self.exampleservice.resume()
def reboot(self):
return self.exampleservice.reboot()