def __init__(self, inputs,logger,
project_name=None,
username=None,
password=None):
self.inputs = inputs
project_name = project_name or self.inputs.project_name
username = username or self.inputs.stack_user
password = password or self.inputs.stack_password
self.username = username
self.password = password
self.project_name = project_name
self.logger = logger
self.vnc_lib_fixture = VncLibFixture(
username=username, password=password,
domain=self.inputs.domain_name, project_name=project_name,
inputs = self.inputs,
cfgm_ip=self.inputs.cfgm_ip,
api_server_port=self.inputs.api_server_port,
auth_server_ip=self.inputs.auth_ip,
orchestrator=self.inputs.orchestrator,
logger=self.logger)
self.vnc_lib_fixture.setUp()
self.vnc_lib = self.vnc_lib_fixture.get_handle()
self.nova_h = None
self.quantum_h = None
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(username, password, project_name, self.inputs, logger)
self.project_id = self.auth.get_project_id(project_name)
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, project_name, username, password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.orch = OpenstackOrchestrator(username=username, password=password,
project_id=self.project_id, project_name=project_name,
inputs=inputs, vnclib=self.vnc_lib, logger=logger,
auth_server_ip=self.inputs.auth_ip)
self.nova_h = self.orch.get_nova_handler()
self.quantum_h = self.orch.get_network_handler()
else: # vcenter
self.auth = VcenterAuth(username, password, project_name, self.inputs)
self.orch = VcenterOrchestrator(user=username, pwd=password,
host=self.inputs.auth_ip,
port=self.inputs.auth_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs, logger=logger)
self.api_server_inspects = {}
self.dnsagent_inspect = {}
self.cn_inspect = {}
self.agent_inspect = {}
self.ops_inspects = {}
self.ds_inspect = {}
self.update_inspect_handles()
def __init__(self, inputs=None, logger=None, project_name=None,
username=None, password=None, domain_name=None, ini_file=None):
project_fq_name = [domain_name or 'default-domain', project_name] \
if project_name else None
self.inputs = inputs or ContrailTestInit(ini_file,
project_fq_name=project_fq_name)
self.project_name = project_name or self.inputs.project_name
self.domain_name = domain_name or self.inputs.domain_name
self.username = username or self.inputs.stack_user
self.password = password or self.inputs.stack_password
self.logger = logger or self.inputs.logger
self.nova_h = None
self.quantum_h = None
self.api_server_inspects = custom_dict(self.get_api_inspect_handle,
'api_inspect:'+self.project_name+':'+self.username)
self.dnsagent_inspect = custom_dict(self.get_dns_agent_inspect_handle,
'dns_inspect')
self.agent_inspect = custom_dict(self.get_vrouter_agent_inspect_handle,
'agent_inspect')
self.ops_inspects = custom_dict(self.get_opserver_inspect_handle,
'ops_inspect')
self.cn_inspect = custom_dict(self.get_control_node_inspect_handle,
'cn_inspect')
self.ds_inspect = custom_dict(self.get_discovery_service_inspect_handle,
'ds_inspect')
# ToDo: msenthil/sandipd rest of init needs to be better handled
self.vnc_lib = self.get_vnc_lib_h()
self.auth = self.get_auth_h()
if self.inputs.orchestrator == 'openstack':
self.project_id = self.get_project_id()
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, project_name, username, password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.orch = OpenstackOrchestrator(username=self.username,
password=self.password,
project_id=self.project_id,
project_name=self.project_name,
inputs=self.inputs,
vnclib=self.vnc_lib,
logger=self.logger,
auth_server_ip=self.inputs.auth_ip)
self.nova_h = self.orch.get_compute_handler()
self.quantum_h = self.orch.get_network_handler()
else: # vcenter
self.orch = VcenterOrchestrator(user=self.username,
pwd=self.password,
host=self.inputs.auth_ip,
port=self.inputs.auth_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
def __init__(self, inputs=None, logger=None, project_name=None,
username=None, password=None, domain_name=None, ini_file=None):
self.inputs = inputs or ContrailTestInit(ini_file,
stack_tenant=project_name)
self.project_name = project_name or self.inputs.project_name
self.domain_name = domain_name or self.inputs.domain_name
self.username = username or self.inputs.stack_user
self.password = password or self.inputs.stack_password
self.logger = logger or self.inputs.logger
self.nova_h = None
self.quantum_h = None
self.api_server_inspects = custom_dict(self.get_api_inspect_handle,
'api_inspect:'+self.project_name+':'+self.username)
self.dnsagent_inspect = custom_dict(self.get_dns_agent_inspect_handle,
'dns_inspect')
self.agent_inspect = custom_dict(self.get_vrouter_agent_inspect_handle,
'agent_inspect')
self.ops_inspects = custom_dict(self.get_opserver_inspect_handle,
'ops_inspect')
self.cn_inspect = custom_dict(self.get_control_node_inspect_handle,
'cn_inspect')
self.ds_inspect = custom_dict(self.get_discovery_service_inspect_handle,
'ds_inspect')
# ToDo: msenthil/sandipd rest of init needs to be better handled
self.vnc_lib = self.get_vnc_lib_h()
self.auth = self.get_auth_h()
if self.inputs.orchestrator == 'openstack':
self.project_id = self.get_project_id()
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, project_name, username, password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.orch = OpenstackOrchestrator(username=self.username,
password=self.password,
project_id=self.project_id,
project_name=self.project_name,
inputs=self.inputs,
vnclib=self.vnc_lib,
logger=self.logger,
auth_server_ip=self.inputs.auth_ip)
self.nova_h = self.orch.get_compute_handler()
self.quantum_h = self.orch.get_network_handler()
else: # vcenter
self.orch = VcenterOrchestrator(user=self.username,
pwd=self.password,
host=self.inputs.auth_ip,
port=self.inputs.auth_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
def main():
init_obj = ContrailTestInit(sys.argv[1])
if init_obj.inputs.vcenter_gw_setup or (init_obj.inputs.orchestrator == 'vcenter'):
vcenter=get_vcenter_server_details(init_obj.inputs)
vcenter_orch = VcenterOrchestrator(init_obj.inputs, vcenter.server,
vcenter.port, vcenter.user,
vcenter.password,
init_obj.inputs.vcenter_dc,
logger = log
)
images = ['ubuntu', 'ubuntu-traffic', 'vcenter_tiny_vm', 'tiny_nat_fw',
'tiny_in_net']
for image in images:
try:
vcenter_orch.load_and_register_template(image)
except:
log.info('Not able to load template %s' %image)
def get_orch_h(self):
if not getattr(self, 'orch', None):
if self.inputs.orchestrator == 'openstack':
self.orch = OpenstackOrchestrator(username=self.username,
password=self.password,
project_name=self.project_name,
inputs=self.inputs, logger=self.logger)
self.nova_h = self.orch.get_compute_h()
self.quantum_h = self.orch.get_network_h()
else:
self.get_vnc_lib_h()
self.orch = VcenterOrchestrator(user=self.username, pwd=self.password,
host=self.inputs.auth_ip,
port=self.inputs.auth_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs, logger=self.logger)
return self.orch
def main():
init_obj = ContrailTestInit(sys.argv[1])
if init_obj.inputs.vcenter_gw_setup or (init_obj.inputs.orchestrator
== 'vcenter'):
vcenter = get_vcenter_server_details(init_obj.inputs)
vcenter_orch = VcenterOrchestrator(init_obj.inputs,
vcenter.server,
vcenter.port,
vcenter.user,
vcenter.password,
init_obj.inputs.vcenter_dc,
logger=log)
images = [
'ubuntu', 'ubuntu-traffic', 'vcenter_tiny_vm', 'tiny_nat_fw',
'tiny_in_net'
]
for image in images:
try:
vcenter_orch.load_and_register_template(image)
except:
log.info('Not able to load template %s' % image)
def get_vcenter_handle(self):
if self.inputs and self.inputs.vcenter_dc:
vcntr = VcenterOrchestrator(user=self.inputs.vcenter_username,
pwd=self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=self.inputs.vcenter_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
else:
vcntr = None
return vcntr
def main():
init_obj = ContrailTestInit(sys.argv[1])
init_obj.read_prov_file()
if init_obj.inputs.vcenter_gw_setup:
vcenter = get_vcenter_server_details(init_obj.inputs)
vcenter_orch = VcenterOrchestrator(init_obj.inputs,
vcenter.server,
vcenter.port,
vcenter.user,
vcenter.password,
init_obj.inputs.vcenter_dc,
logger=log)
vcenter_orch._nfs_ds.delete_datastore()
def get_orch_h(self):
if not getattr(self, 'orch', None):
if self.inputs.orchestrator == 'openstack':
self.orch = OpenstackOrchestrator(
username=self.username,
password=self.password,
project_name=self.project_name,
inputs=self.inputs,
logger=self.logger)
self.nova_h = self.orch.get_compute_h()
self.quantum_h = self.orch.get_network_h()
else:
self.get_vnc_lib_h()
self.orch = VcenterOrchestrator(user=self.username,
pwd=self.password,
host=self.inputs.auth_ip,
port=self.inputs.auth_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
return self.orch
def get_orch_h(self):
if self.connections:
return self.connections.orch
else:
if self.orchestrator == 'openstack':
return OpenstackOrchestrator(vnclib=self.vnc_api_h,
logger=self.logger,
auth_h=self.auth_client,
inputs=self.inputs)
elif self.orchestrator == 'vcenter':
vcenter_dc = self.inputs.vcenter_dc if self.inputs else \
os.getenv('VCENTER_DC', None)
return VcenterOrchestrator(user=self.username,
pwd=self.password,
host=self.inputs.vcenter_server,
port=self.inputs.vcenter_port,
dc_name=vcenter_dc,
vnc=self.vnc_api_h,
inputs=self.inputs,
logger=self.logger)
return
def __init__(self,
inputs=None,
logger=None,
project_name=None,
username=None,
password=None,
domain_name=None,
input_file=None,
domain_obj=None,
scope='domain'):
self.inputs = inputs or ContrailTestInit(input_file,
stack_tenant=project_name)
self.project_name = project_name or self.inputs.project_name
self.domain_name = domain_name or self.inputs.domain_name
self.orch_domain_name = domain_name or self.inputs.domain_name
if self.orch_domain_name == 'Default':
self.domain_name = 'default-domain'
self.scope = scope
self.username = username or self.inputs.stack_user
self.password = password or self.inputs.stack_password
self.logger = logger or self.inputs.logger
self.nova_h = None
self.quantum_h = None
self.vnc_lib_fixture = None
self.api_server_inspects = custom_dict(
self.get_api_inspect_handle,
'api_inspect:' + self.project_name + ':' + self.username)
self.dnsagent_inspect = custom_dict(self.get_dns_agent_inspect_handle,
'dns_inspect')
self.agent_inspect = custom_dict(self.get_vrouter_agent_inspect_handle,
'agent_inspect')
self.ops_inspects = custom_dict(
self.get_opserver_inspect_handle,
'ops_inspect:' + self.project_name + ':' + self.username)
self.cn_inspect = custom_dict(self.get_control_node_inspect_handle,
'cn_inspect')
self.k8s_client = self.get_k8s_api_client_handle()
# ToDo: msenthil/sandipd rest of init needs to be better handled
self.domain_id = None
if self.inputs.domain_isolation:
#get admin auth to list domains and get domain_id
auth = self.get_auth_h(username=self.inputs.admin_username,
password=self.inputs.admin_password,
project_name=self.inputs.admin_tenant,
domain_name=self.inputs.admin_domain)
self.domain_id = auth.get_domain_id(self.domain_name)
self.auth = self.get_auth_h()
self.vnc_lib = self.get_vnc_lib_h()
self.project_id = self.get_project_id()
if self.inputs.orchestrator == 'openstack':
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, project_name,
username, password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.orch = OpenstackOrchestrator(inputs=self.inputs,
vnclib=self.vnc_lib,
logger=self.logger,
auth_h=self.auth)
self.nova_h = self.orch.get_compute_handler()
self.quantum_h = self.orch.get_network_handler()
self.glance_h = self.orch.get_image_handler()
elif self.inputs.orchestrator == 'vcenter' and self.inputs.slave_orchestrator == 'vro':
self.orch = VroWorkflows(user=self.inputs.vcenter_username,
pwd=self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=self.inputs.vcenter_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
elif self.inputs.orchestrator == 'vcenter': # vcenter
self.orch = VcenterOrchestrator(user=self.inputs.vcenter_username,
pwd=self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=self.inputs.vcenter_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
elif self.inputs.orchestrator == 'kubernetes':
self.orch = None
if self.inputs.vcenter_gw_setup: # vcenter_gateway
self.slave_orch = VcenterGatewayOrch(
user=self.inputs.vcenter_username,
pwd=self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=int(self.inputs.vcenter_port),
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
self._kube_manager_inspect = None
class ContrailConnections():
def __init__(self,
inputs=None,
logger=None,
project_name=None,
username=None,
password=None,
domain_name=None,
input_file=None,
domain_obj=None,
scope='domain'):
self.inputs = inputs or ContrailTestInit(input_file,
stack_tenant=project_name)
self.project_name = project_name or self.inputs.project_name
self.domain_name = domain_name or self.inputs.domain_name
self.orch_domain_name = domain_name or self.inputs.domain_name
if self.orch_domain_name == 'Default':
self.domain_name = 'default-domain'
self.scope = scope
self.username = username or self.inputs.stack_user
self.password = password or self.inputs.stack_password
self.logger = logger or self.inputs.logger
self.nova_h = None
self.quantum_h = None
self.vnc_lib_fixture = None
self.api_server_inspects = custom_dict(
self.get_api_inspect_handle,
'api_inspect:' + self.project_name + ':' + self.username)
self.dnsagent_inspect = custom_dict(self.get_dns_agent_inspect_handle,
'dns_inspect')
self.agent_inspect = custom_dict(self.get_vrouter_agent_inspect_handle,
'agent_inspect')
self.ops_inspects = custom_dict(
self.get_opserver_inspect_handle,
'ops_inspect:' + self.project_name + ':' + self.username)
self.cn_inspect = custom_dict(self.get_control_node_inspect_handle,
'cn_inspect')
self.k8s_client = self.get_k8s_api_client_handle()
# ToDo: msenthil/sandipd rest of init needs to be better handled
self.domain_id = None
if self.inputs.domain_isolation:
#get admin auth to list domains and get domain_id
auth = self.get_auth_h(username=self.inputs.admin_username,
password=self.inputs.admin_password,
project_name=self.inputs.admin_tenant,
domain_name=self.inputs.admin_domain)
self.domain_id = auth.get_domain_id(self.domain_name)
self.auth = self.get_auth_h()
self.vnc_lib = self.get_vnc_lib_h()
self.project_id = self.get_project_id()
if self.inputs.orchestrator == 'openstack':
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, project_name,
username, password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.orch = OpenstackOrchestrator(inputs=self.inputs,
vnclib=self.vnc_lib,
logger=self.logger,
auth_h=self.auth)
self.nova_h = self.orch.get_compute_handler()
self.quantum_h = self.orch.get_network_handler()
self.glance_h = self.orch.get_image_handler()
elif self.inputs.orchestrator == 'vcenter' and self.inputs.slave_orchestrator == 'vro':
self.orch = VroWorkflows(user=self.inputs.vcenter_username,
pwd=self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=self.inputs.vcenter_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
elif self.inputs.orchestrator == 'vcenter': # vcenter
self.orch = VcenterOrchestrator(user=self.inputs.vcenter_username,
pwd=self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=self.inputs.vcenter_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
elif self.inputs.orchestrator == 'kubernetes':
self.orch = None
if self.inputs.vcenter_gw_setup: # vcenter_gateway
self.slave_orch = VcenterGatewayOrch(
user=self.inputs.vcenter_username,
pwd=self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=int(self.inputs.vcenter_port),
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
self._kube_manager_inspect = None
# end __init__
def get_project_id(self, project_name=None):
project_name = project_name or self.project_name
auth = self.get_auth_h(project_name=project_name)
if auth:
return auth.get_project_id(project_name or self.project_name,
self.domain_id)
else:
return self.vnc_lib_fixture.project_id if self.vnc_lib_fixture else None
def get_auth_h(self,
refresh=False,
project_name=None,
username=None,
password=None,
domain_name=None):
project_name = project_name or self.project_name
username = username or self.username
password = password or self.password
attr = '_auth_' + project_name + '_' + username
if not getattr(env, attr, None) or refresh:
if self.inputs.orchestrator == 'openstack':
env[attr] = OpenstackAuth(username,
password,
project_name,
self.inputs,
self.logger,
domain_name=domain_name
or self.orch_domain_name,
scope=self.scope)
elif self.inputs.orchestrator == 'vcenter':
env[attr] = VcenterAuth(username, password, project_name,
self.inputs)
# elif self.inputs.orchestrator == 'kubernetes':
# env[attr] = self.get_k8s_api_client_handle()
return env.get(attr)
def get_vnc_lib_h(self, refresh=False):
attr = '_vnc_lib_fixture_' + self.project_name + '_' + self.username
cfgm_ip = self.inputs.command_server_ip or self.inputs.api_server_ip or \
self.inputs.cfgm_ip
api_server_url = self.go_config_proxy_url
api_server_port = self.inputs.go_server_port if self.inputs.command_server_ip \
else self.inputs.api_server_port
insecure = True if self.inputs.command_server_ip else self.inputs.insecure
use_ssl = True if self.inputs.command_server_ip else self.inputs.api_protocol
if not getattr(env, attr, None) or refresh:
if self.inputs.orchestrator == 'openstack':
domain = self.orch_domain_name
else:
domain = self.domain_name
env[attr] = VncLibFixture(username=self.username,
password=self.password,
domain=domain,
project_name=self.project_name,
inputs=self.inputs,
cfgm_ip=cfgm_ip,
project_id=self.get_project_id(),
api_server_port=api_server_port,
api_server_url=api_server_url,
orchestrator=self.inputs.orchestrator,
certfile=self.inputs.keystonecertfile,
keyfile=self.inputs.keystonekeyfile,
cacert=self.inputs.certbundle,
insecure=insecure,
use_ssl=use_ssl,
logger=self.logger)
env[attr].setUp()
self.vnc_lib_fixture = env[attr]
self.vnc_lib = self.vnc_lib_fixture.get_handle()
return self.vnc_lib
def get_go_client_handle(self):
if not self.inputs.command_server_ip:
return None
return GoApiInspect(self.inputs.command_server_ip,
port=self.inputs.go_server_port,
inputs=self.inputs,
logger=self.logger)
def get_api_inspect_handle(self, host):
cfgm_ip = self.inputs.command_server_ip or self.inputs.api_server_ip
if cfgm_ip:
host = cfgm_ip
api_protocol = 'https' if self.inputs.command_server_ip else self.inputs.api_protocol
api_server_port = self.inputs.go_server_port if self.inputs.command_server_ip \
else self.inputs.api_server_port
insecure = True if self.inputs.command_server_ip else self.inputs.insecure
if host not in self.api_server_inspects:
self.api_server_inspects[host] = VNCApiInspect(
host,
inputs=self.inputs,
port=api_server_port,
protocol=api_protocol,
base_url=self.go_config_proxy_url,
insecure=insecure,
logger=self.logger)
return self.api_server_inspects[host]
def get_control_node_inspect_handle(self, host):
if host not in self.cn_inspect:
self.cn_inspect[host] = ControlNodeInspect(host,
self.inputs.bgp_port,
logger=self.logger)
return self.cn_inspect[host]
def get_dns_agent_inspect_handle(self, host):
if host not in self.dnsagent_inspect:
self.dnsagent_inspect[host] = DnsAgentInspect(host,
self.inputs.dns_port,
logger=self.logger)
return self.dnsagent_inspect[host]
def get_vrouter_agent_inspect_handle(self, host):
if host not in self.agent_inspect:
self.agent_inspect[host] = AgentInspect(
host, port=self.inputs.agent_port, logger=self.logger)
return self.agent_inspect[host]
def get_opserver_inspect_handle(self, host):
#ToDo: WA till scripts are modified to use ip rather than hostname
ip = host if is_v4(host) else self.inputs.get_host_ip(host)
collector_ip = self.inputs.command_server_ip or self.inputs.analytics_api_ip
if collector_ip:
ip = collector_ip
port = self.inputs.go_server_port if self.inputs.command_server_ip \
else self.inputs.analytics_api_port
protocol = 'https' if self.inputs.command_server_ip else 'http'
insecure = True if self.inputs.command_server_ip else self.inputs.insecure
if ip not in self.ops_inspects:
self.ops_inspects[ip] = VerificationOpsSrv(
ip,
port=port,
protocol=protocol,
base_url=self.go_analytics_proxy_url,
insecure=insecure,
logger=self.logger,
inputs=self.inputs)
return self.ops_inspects[ip]
def get_k8s_api_client_handle(self):
if self.inputs.orchestrator != 'kubernetes' and self.inputs.slave_orchestrator != 'kubernetes':
return None
if not getattr(self, 'k8s_client', None):
self.k8s_client = Kubernetes_client(self.inputs.kube_config_file,
self.logger)
return self.k8s_client
# end get_k8s_api_client_handle
def get_svc_mon_h(self, refresh=False):
if not getattr(self, '_svc_mon_inspect', None) or refresh:
for cfgm_ip in self.inputs.cfgm_ips:
#contrail-status would increase run time hence netstat approach
cmd = 'netstat -antp | grep :8088 | grep LISTEN'
if 'LISTEN' in self.inputs.run_cmd_on_server(
cfgm_ip, cmd, container='svc-monitor'):
self._svc_mon_inspect = SvcMonInspect(cfgm_ip,
logger=self.logger)
break
return self._svc_mon_inspect
def get_kube_manager_h(self, refresh=False):
if not getattr(self, '_kube_manager_inspect', None) or refresh:
for km_ip in self.inputs.kube_manager_ips:
#contrail-status would increase run time hence netstat approach
cmd = 'netstat -antp | grep :%s | grep LISTEN' % self.inputs.k8s_port
if 'LISTEN' in self.inputs.run_cmd_on_server(
km_ip, cmd, container='contrail-kube-manager'):
self._kube_manager_inspect = KubeManagerInspect(
km_ip, logger=self.logger)
break
return self._kube_manager_inspect
# end get_kube_manager_h
@property
def go_api_handle(self):
if not getattr(self, '_go_api_handle', None):
self._go_api_handle = self.get_go_client_handle()
return self._go_api_handle
@property
def go_cluster_id(self):
if not self.go_api_handle:
return None
if not getattr(self, '_go_cluster_id', None):
self._go_cluster_id = self.go_api_handle.get_cluster_id()
return self._go_cluster_id
@property
def go_config_proxy_url(self):
if not self.go_api_handle:
return '/'
if not getattr(self, '_config_proxy_url', None):
self._config_proxy_url = '/proxy/%s/config/' % self.go_cluster_id
return self._config_proxy_url
@property
def go_analytics_proxy_url(self):
if not self.go_api_handle:
return '/'
if not getattr(self, '_analytics_proxy_url', None):
self._analytics_proxy_url = '/proxy/%s/telemetry/' % self.go_cluster_id
return self._analytics_proxy_url
@property
def api_server_inspect(self):
if not getattr(self, '_api_server_inspect', None):
self._api_server_inspect = self.api_server_inspects[
self.inputs.cfgm_ips[0]]
return self._api_server_inspect
@api_server_inspect.setter
def api_server_inspect(self, value):
self._api_server_inspect = value
@property
def ops_inspect(self):
if not getattr(self, '_ops_inspect', None):
self._ops_inspect = self.ops_inspects[self.inputs.collector_ips[0]]
return self._ops_inspect
@ops_inspect.setter
def ops_inspect(self, value):
self._ops_inspect = value
@property
def analytics_obj(self):
if not getattr(self, '_analytics_obj', None):
self._analytics_obj = AnalyticsVerification(self.inputs,
self.cn_inspect,
self.agent_inspect,
self.ops_inspects,
logger=self.logger)
return self._analytics_obj
@analytics_obj.setter
def analytics_obj(self, value):
self._analytics_obj = value
def update_inspect_handles(self):
self.api_server_inspects.clear()
self.cn_inspect.clear()
self.dnsagent_inspect.clear()
self.agent_inspect.clear()
self.ops_inspects.clear()
self._svc_mon_inspect = None
self._api_server_inspect = None
self._ops_inspect = None
self._analytics_obj = None
self._kube_manager_inspect = None
# end update_inspect_handles
def update_vnc_lib_fixture(self):
self.vnc_lib = self.get_vnc_lib_h(refresh=True)
# end update_vnc_lib_fixture()
def set_vrouter_config_encap(self, encap1=None, encap2=None, encap3=None):
return self.update_vrouter_config_encap(encap1,
encap2,
encap3,
create=True)
# end set_vrouter_config_encap
def update_vrouter_config_encap(self,
encap1=None,
encap2=None,
encap3=None,
create=False):
'''Used to change the existing encapsulation priorities to new values'''
if not (encap1 and encap2 and encap3):
return self.delete_vrouter_encap()
try:
# Reading Existing config
current_config = self.vnc_lib.global_vrouter_config_read(fq_name=[
'default-global-system-config', 'default-global-vrouter-config'
])
except NoIdError as e:
self.logger.exception('No config id found. Creating new one')
if not create:
raise
conf_obj = GlobalVrouterConfig()
self.vnc_lib.global_vrouter_config_create(conf_obj)
encaps_obj = EncapsulationPrioritiesType(
encapsulation=[encap1, encap2, encap3])
confs_obj = GlobalVrouterConfig(encapsulation_priorities=encaps_obj)
result = self.vnc_lib.global_vrouter_config_update(confs_obj)
return result
# end update_vrouter_config_encap
def delete_vrouter_encap(self):
try:
conf_id = self.vnc_lib.get_default_global_vrouter_config_id()
obj = self.vnc_lib.global_vrouter_config_read(id=conf_id)
encap_obj = obj.get_encapsulation_priorities()
if not encap_obj:
return ['', '', '']
encaps = encap_obj.encapsulation
l = len(encaps)
encaps.extend([''] * (3 - l))
obj.set_encapsulation_priorities(None)
self.vnc_lib.global_vrouter_config_update(obj)
return encaps
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return (errmsg)
# end delete_vrouter_encap
def read_vrouter_config_encap(self):
result = None
try:
conf_id = self.vnc_lib.get_default_global_vrouter_config_id()
config_parameters = self.vnc_lib.global_vrouter_config_read(
id=conf_id)
obj = config_parameters.get_encapsulation_priorities()
if not obj:
return ['', '', '']
else:
return obj.encapsulation
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return result
# end read_vrouter_config_encap
def set_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
# Check if already configured
try:
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except Exception:
msg = "No config id found. Configuring new one"
self.logger.info(msg)
pass
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_create(conf_obj)
return result
# end set_vrouter_config_evpn
def update_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_update(conf_obj)
return result
# end update_vrouter_config_evpn
def delete_vrouter_config_evpn(self):
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
# end delete_vrouter_config_evpn
def read_vrouter_config_evpn(self):
result = False
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
out = self.obj.global_vrouter_config_read(id=conf_id)
if 'evpn_status' in out.__dict__.keys():
result = out.evpn_status
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return result
def __init__(self, inputs=None, logger=None, project_name=None,
username=None, password=None, domain_name=None, input_file=None, domain_obj=None,scope='domain'):
self.inputs = inputs or ContrailTestInit(input_file,
stack_tenant=project_name)
self.project_name = project_name or self.inputs.project_name
self.domain_name = domain_name or self.inputs.domain_name
self.orch_domain_name = domain_name or self.inputs.domain_name
if self.orch_domain_name == 'Default':
self.domain_name = 'default-domain'
self.scope = scope
self.username = username or self.inputs.stack_user
self.password = password or self.inputs.stack_password
self.logger = logger or self.inputs.logger
self.nova_h = None
self.quantum_h = None
self.vnc_lib_fixture = None
self.ironic_h = None
self.api_server_inspects = custom_dict(self.get_api_inspect_handle,
'api_inspect:'+self.project_name+':'+self.username)
self.dnsagent_inspect = custom_dict(self.get_dns_agent_inspect_handle,
'dns_inspect')
self.agent_inspect = custom_dict(self.get_vrouter_agent_inspect_handle,
'agent_inspect')
self.ops_inspects = custom_dict(self.get_opserver_inspect_handle,
'ops_inspect:'+self.project_name+':'+self.username)
self.cn_inspect = custom_dict(self.get_control_node_inspect_handle,
'cn_inspect')
self.k8s_cluster = self.get_k8s_cluster()
self.k8s_client = self.get_k8s_api_client_handle()
# ToDo: msenthil/sandipd rest of init needs to be better handled
self.domain_id = None
if self.inputs.domain_isolation:
#get admin auth to list domains and get domain_id
auth = self.get_auth_h(username = self.inputs.admin_username,
password=self.inputs.admin_password,
project_name=self.inputs.admin_tenant,
domain_name=self.inputs.admin_domain)
self.domain_id = auth.get_domain_id(self.domain_name)
self.auth = self.get_auth_h()
self.vnc_lib = self.get_vnc_lib_h()
self.project_id = self.get_project_id()
if self.inputs.orchestrator == 'openstack':
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, project_name, username, password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.orch = OpenstackOrchestrator(inputs=self.inputs,
vnclib=self.vnc_lib,
logger=self.logger,
auth_h=self.auth
)
self.ironic_h = self.orch.get_ironic_handler()
self.nova_h = self.orch.get_compute_handler()
self.quantum_h = self.orch.get_network_handler()
self.glance_h = self.orch.get_image_handler()
elif self.inputs.orchestrator == 'vcenter':
self.orch = VcenterOrchestrator(user=self.inputs.vcenter_username,
pwd= self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=self.inputs.vcenter_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
if self.inputs.vro_server:
self.vro_orch = VroWorkflows(user=self.inputs.vcenter_username,
pwd= self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=self.inputs.vcenter_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
elif self.inputs.orchestrator == 'kubernetes':
self.orch = None
if self.inputs.vcenter_gw_setup: # vcenter_gateway
self.slave_orch = VcenterGatewayOrch(user=self.inputs.vcenter_username,
pwd=self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=int(self.inputs.vcenter_port),
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
self._kube_manager_inspect = None
class ContrailConnections():
def __init__(self, inputs=None, logger=None, project_name=None,
username=None, password=None, domain_name=None, ini_file=None):
self.inputs = inputs or ContrailTestInit(ini_file,
stack_tenant=project_name)
self.project_name = project_name or self.inputs.project_name
self.domain_name = domain_name or self.inputs.domain_name
self.username = username or self.inputs.stack_user
self.password = password or self.inputs.stack_password
self.logger = logger or self.inputs.logger
self.nova_h = None
self.quantum_h = None
self.api_server_inspects = custom_dict(self.get_api_inspect_handle,
'api_inspect:'+self.project_name+':'+self.username)
self.dnsagent_inspect = custom_dict(self.get_dns_agent_inspect_handle,
'dns_inspect')
self.agent_inspect = custom_dict(self.get_vrouter_agent_inspect_handle,
'agent_inspect')
self.ops_inspects = custom_dict(self.get_opserver_inspect_handle,
'ops_inspect')
self.cn_inspect = custom_dict(self.get_control_node_inspect_handle,
'cn_inspect')
self.ds_inspect = custom_dict(self.get_discovery_service_inspect_handle,
'ds_inspect')
# ToDo: msenthil/sandipd rest of init needs to be better handled
self.vnc_lib = self.get_vnc_lib_h()
self.auth = self.get_auth_h()
if self.inputs.orchestrator == 'openstack':
self.project_id = self.get_project_id()
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, project_name, username, password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.orch = OpenstackOrchestrator(username=self.username,
password=self.password,
project_id=self.project_id,
project_name=self.project_name,
inputs=self.inputs,
vnclib=self.vnc_lib,
logger=self.logger,
auth_server_ip=self.inputs.auth_ip)
self.nova_h = self.orch.get_compute_handler()
self.quantum_h = self.orch.get_network_handler()
else: # vcenter
self.orch = VcenterOrchestrator(user=self.username,
pwd=self.password,
host=self.inputs.auth_ip,
port=self.inputs.auth_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
# end __init__
def get_project_id(self, project_name=None):
project_name = project_name or self.project_name
auth = self.get_auth_h(project_name)
return auth.get_project_id(project_name or self.project_name)
def get_auth_h(self, refresh=False, project_name=None,
username=None, password=None):
project_name = project_name or self.project_name
username = username or self.username
password = password or self.password
attr = '_auth_'+project_name+'_'+username
if not getattr(env, attr, None) or refresh:
if self.inputs.orchestrator == 'openstack':
env[attr] = OpenstackAuth(username, password,
project_name, self.inputs, self.logger)
else:
env[attr] = VcenterAuth(username, password,
project_name, self.inputs)
return env[attr]
def get_vnc_lib_h(self, refresh=False):
attr = '_vnc_lib_' + self.project_name + '_' + self.username
if not getattr(env, attr, None) or refresh:
self.vnc_lib_fixture = VncLibFixture(
username=self.username, password=self.password,
domain=self.domain_name, project_name=self.project_name,
inputs = self.inputs,
cfgm_ip=self.inputs.cfgm_ip,
api_server_port=self.inputs.api_server_port,
auth_server_ip=self.inputs.auth_ip,
orchestrator=self.inputs.orchestrator,
logger=self.logger)
self.vnc_lib_fixture.setUp()
self.vnc_lib = self.vnc_lib_fixture.get_handle()
return self.vnc_lib
def get_api_inspect_handle(self, host):
if host not in self.api_server_inspects:
self.api_server_inspects[host] = VNCApiInspect(host,
args=self.inputs,
logger=self.logger)
return self.api_server_inspects[host]
def get_control_node_inspect_handle(self, host):
if host not in self.cn_inspect:
self.cn_inspect[host] = ControlNodeInspect(host, logger=self.logger)
return self.cn_inspect[host]
def get_dns_agent_inspect_handle(self, host):
if host not in self.dnsagent_inspect:
self.dnsagent_inspect[host] = DnsAgentInspect(host,
logger=self.logger)
return self.dnsagent_inspect[host]
def get_vrouter_agent_inspect_handle(self, host):
if host not in self.agent_inspect:
self.agent_inspect[host] = AgentInspect(host, logger=self.logger)
return self.agent_inspect[host]
def get_opserver_inspect_handle(self, host):
#ToDo: WA till scripts are modified to use ip rather than hostname
ip = host if is_v4(host) else self.inputs.get_host_ip(host)
if ip not in self.ops_inspects:
self.ops_inspects[ip] = VerificationOpsSrv(ip, logger=self.logger)
return self.ops_inspects[ip]
def get_discovery_service_inspect_handle(self, host):
if host not in self.ds_inspect:
self.ds_inspect[host] = VerificationDsSrv(host, logger=self.logger)
return self.ds_inspect[host]
def get_svc_mon_h(self, refresh=False):
if not getattr(self, '_svc_mon_inspect', None) or refresh:
for cfgm_ip in self.inputs.cfgm_ips:
#contrail-status would increase run time hence netstat approach
cmd = 'netstat -antp | grep 8088 | grep LISTEN'
if self.inputs.run_cmd_on_server(cfgm_ip, cmd) is not None:
self._svc_mon_inspect = SvcMonInspect(cfgm_ip,
logger=self.logger)
break
return self._svc_mon_inspect
@property
def api_server_inspect(self):
if not getattr(self, '_api_server_inspect', None):
self._api_server_inspect = self.api_server_inspects[
self.inputs.cfgm_ips[0]]
return self._api_server_inspect
@api_server_inspect.setter
def api_server_inspect(self, value):
self._api_server_inspect = value
@property
def ops_inspect(self):
if not getattr(self, '_ops_inspect', None):
self._ops_inspect = self.ops_inspects[self.inputs.collector_ips[0]]
return self._ops_inspect
@ops_inspect.setter
def ops_inspect(self, value):
self._ops_inspect = value
@property
def analytics_obj(self):
if not getattr(self, '_analytics_obj', None):
self._analytics_obj = AnalyticsVerification(self.inputs,
self.cn_inspect, self.agent_inspect,
self.ops_inspects, logger=self.logger)
return self._analytics_obj
@analytics_obj.setter
def analytics_obj(self, value):
self._analytics_obj = value
@property
def ds_verification_obj(self):
if not getattr(self, '_ds_verification_obj', None):
self._ds_verification_obj = DiscoveryVerification(self.inputs,
self.cn_inspect, self.agent_inspect,
self.ops_inspects, self.ds_inspect,
logger=self.logger)
return self._ds_verification_obj
@ds_verification_obj.setter
def ds_verification_obj(self, value):
self._ds_verification_obj = value
def update_inspect_handles(self):
self.api_server_inspects.clear()
self.cn_inspect.clear()
self.dnsagent_inspect.clear()
self.agent_inspect.clear()
self.ops_inspects.clear()
self.ds_inspect.clear()
self.api_server_inspect = None
self.ops_inspect = None
self.ds_verification_obj = None
self._svc_mon_inspect = None
self._api_server_inspect = None
self._ops_inspect = None
self._analytics_obj = None
self._ds_verification_obj = None
# end update_inspect_handles
def update_vnc_lib_fixture(self):
self.vnc_lib = self.get_vnc_lib_h(refresh=True)
# end update_vnc_lib_fixture()
def set_vrouter_config_encap(self, encap1=None, encap2=None, encap3=None):
self.obj = self.vnc_lib
try:
# Reading Existing config
current_config=self.obj.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
current_linklocal=current_config.get_linklocal_services()
except NoIdError as e:
self.logger.exception('No config id found. Creating new one')
current_linklocal=''
encap_obj = EncapsulationPrioritiesType(
encapsulation=[encap1, encap2, encap3])
conf_obj = GlobalVrouterConfig(linklocal_services=current_linklocal,encapsulation_priorities=encap_obj)
result = self.obj.global_vrouter_config_create(conf_obj)
return result
# end set_vrouter_config_encap
def update_vrouter_config_encap(self, encap1=None, encap2=None, encap3=None):
'''Used to change the existing encapsulation priorities to new values'''
self.obj = self.vnc_lib
try:
# Reading Existing config
current_config=self.obj.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
current_linklocal=current_config.get_linklocal_services()
except NoIdError as e:
self.logger.exception('No config id found. Creating new one')
current_linklocal=''
encaps_obj = EncapsulationPrioritiesType(
encapsulation=[encap1, encap2, encap3])
confs_obj = GlobalVrouterConfig(linklocal_services=current_linklocal,
encapsulation_priorities=encaps_obj)
result = self.obj.global_vrouter_config_update(confs_obj)
return result
# end update_vrouter_config_encap
def delete_vrouter_encap(self):
self.obj = self.vnc_lib
try:
conf_id = self.obj.get_default_global_vrouter_config_id()
self.logger.info("Config id found.Deleting it")
config_parameters = self.obj.global_vrouter_config_read(id=conf_id)
self.inputs.config.obj = config_parameters.get_encapsulation_priorities(
)
if not self.inputs.config.obj:
# temp workaround,delete default-global-vrouter-config.need to
# review this testcase
self.obj.global_vrouter_config_delete(id=conf_id)
errmsg = "No config id found"
self.logger.info(errmsg)
return (errmsg)
try:
encaps1 = self.inputs.config.obj.encapsulation[0]
encaps2 = self.inputs.config.obj.encapsulation[1]
try:
encaps1 = self.inputs.config.obj.encapsulation[0]
encaps2 = self.inputs.config.obj.encapsulation[1]
encaps3 = self.inputs.config.obj.encapsulation[2]
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, encaps2, encaps3)
except IndexError:
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, encaps2, None)
except IndexError:
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, None, None)
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return (errmsg)
# end delete_vrouter_encap
def read_vrouter_config_encap(self):
result = None
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
config_parameters = self.obj.global_vrouter_config_read(id=conf_id)
self.inputs.config.obj = config_parameters.get_encapsulation_priorities(
)
result = self.inputs.config.obj.encapsulation
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return result
# end read_vrouter_config_encap
def set_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
# Check if already configured
try:
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except Exception:
msg = "No config id found. Configuring new one"
self.logger.info(msg)
pass
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_create(conf_obj)
return result
# end set_vrouter_config_evpn
def update_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_update(conf_obj)
return result
# end update_vrouter_config_evpn
def delete_vrouter_config_evpn(self):
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
# end delete_vrouter_config_evpn
def read_vrouter_config_evpn(self):
result = False
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
out = self.obj.global_vrouter_config_read(id=conf_id)
if 'evpn_status' in out.__dict__.keys():
result = out.evpn_status
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return result
class ContrailConnections():
def __init__(self, inputs, logger,
project_name=None,
username=None,
password=None):
self.inputs = inputs
project_name = project_name or self.inputs.project_name
self.username = username or self.inputs.stack_user
self.password = password or self.inputs.stack_password
self.project_name = project_name
self.logger = logger
self.nova_h = None
self.quantum_h = None
if self.inputs.orchestrator == 'openstack':
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, self.project_name, self.username, self.password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.api_server_inspects = {}
self.dnsagent_inspect = {}
self.cn_inspect = {}
self.agent_inspect = {}
self.ops_inspects = {}
self.ds_inspect = {}
# end __init__
def get_all_handles(self):
self.get_vnc_lib_h()
self.get_auth_h()
self.get_orch_h()
self.get_inspect_handles()
def get_vnc_lib_h(self):
if not getattr(self, 'vnc_lib', None):
auth_host = self.inputs.get_auth_host()
self.vnc_lib_fixture = VncLibHelper(
username=self.username, password=self.password,
domain=self.inputs.domain_name, project=self.project_name,
inputs=self.inputs, cfgm_ip=self.inputs.cfgm_ip,
api_port=self.inputs.api_server_port, auth_host=auth_host)
self.vnc_lib = self.vnc_lib_fixture.get_handle()
return self.vnc_lib_fixture
def get_auth_h(self):
if not getattr(self, 'auth', None):
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(self.username, self.password, self.project_name, self.inputs, self.logger)
else: # vcenter
self.auth = VcenterAuth(self.username, self.password, self.project_name, self.inputs)
return self.auth
def get_orch_h(self):
if not getattr(self, 'orch', None):
if self.inputs.orchestrator == 'openstack':
self.orch = OpenstackOrchestrator(username=self.username,
password=self.password,
project_name=self.project_name,
inputs=self.inputs, logger=self.logger)
self.nova_h = self.orch.get_compute_h()
self.quantum_h = self.orch.get_network_h()
else:
self.get_vnc_lib_h()
self.orch = VcenterOrchestrator(user=self.username, pwd=self.password,
host=self.inputs.auth_ip,
port=self.inputs.auth_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs, logger=self.logger)
return self.orch
def get_network_h(self):
orch = self.get_orch_h()
return orch.get_network_h()
def get_compute_h(self):
orch = self.get_orch_h()
return orch.get_compute_h()
def get_project_fq_name(self):
return [self.inputs.domain_name, self.project_name]
def get_project_id(self):
if not getattr(self, 'project_id', None):
self.get_auth_h()
self.project_id = self.auth.get_project_id(self.inputs.domain_name,
self.project_name)
return self.project_id
def get_inspect_handles(self):
self.get_api_server_inspect_handles()
self.get_control_node_inspect_handles()
self.get_dns_agent_inspect_handles()
self.get_opserver_inspect_handles()
self.get_discovery_service_inspect_handles()
for compute_ip in self.inputs.compute_ips:
self.get_vrouter_agent_inspect_handle(compute_ip)
self.analytics_obj = self.get_analytics_object()
self.ds_verification_obj = self.get_discovery_service_object()
# for collector_name in self.inputs.collector_names:
# self.ops_inspects[collector_name] = VerificationOpsSrv(
# collector_ip, logger=self.inputs.logger)
def get_api_server_inspect_handles(self):
for cfgm_ip in self.inputs.cfgm_ips:
self.get_api_inspect_handle(cfgm_ip)
self.api_server_inspect = self.api_server_inspects.values()[0]
return self.api_server_inspects
def get_control_node_inspect_handles(self):
for bgp_ip in self.inputs.bgp_ips:
self.get_control_node_inspect_handle(bgp_ip)
return self.cn_inspect
def get_dns_agent_inspect_handles(self):
for bgp_ip in self.inputs.bgp_ips:
self.get_dns_agent_inspect_handle(bgp_ip)
return self.dnsagent_inspect
def get_opserver_inspect_handles(self):
for collector_ip in self.inputs.collector_ips:
self.get_opserver_inspect_handle(collector_ip)
self.ops_inspect = self.ops_inspects.values()[0]
return self.ops_inspects
def get_discovery_service_inspect_handles(self):
for ds_ip in self.inputs.ds_server_ip:
self.get_discovery_service_inspect_handle(ds_ip)
return self.ds_inspect
def get_api_inspect_handle(self, host):
if host not in self.api_server_inspects:
self.api_server_inspects[host]= VNCApiInspect(host, args=self.inputs,
logger=self.logger)
return self.api_server_inspects[host]
def get_control_node_inspect_handle(self, host):
if host not in self.cn_inspect:
self.cn_inspect[host] = ControlNodeInspect(host,
logger=self.logger)
return self.cn_inspect[host]
def get_dns_agent_inspect_handle(self, host):
if host not in self.dnsagent_inspect:
self.dnsagent_inspect[host] = DnsAgentInspect(host,
logger=self.logger)
return self.dnsagent_inspect[host]
def get_vrouter_agent_inspect_handle(self, host):
if host not in self.agent_inspect:
self.agent_inspect[host] = AgentInspect(host,
logger=self.logger)
return self.agent_inspect[host]
def get_opserver_inspect_handle(self, host):
if host not in self.ops_inspects:
self.ops_inspects[host] = VerificationOpsSrv(host,
logger=self.logger)
return self.ops_inspects[host]
def get_analytics_object(self):
if not getattr(self, 'analytics_obj', None):
ops_inspects = self.get_opserver_inspect_handles()
self.analytics_obj = AnalyticsVerification(
self.inputs, ops_inspects, logger=self.logger)
return self.analytics_obj
def get_discovery_service_inspect_handle(self, host):
if host not in self.ds_inspect:
self.ds_inspect[host] = VerificationDsSrv(
host, logger=self.logger)
return self.ds_inspect[host]
def get_discovery_service_object(self):
if not getattr(self, 'ds_verification_obj', None):
self.ds_verification_obj = DiscoveryVerification(self.inputs,
self.api_server_inspect, self.cn_inspect,
self.agent_inspect, self.ops_inspects,
self.ds_inspect, logger=self.logger)
return self.ds_verification_obj
def update_inspect_handles(self):
self.api_server_inspects.clear()
self.cn_inspect.clear()
self.dnsagent_inspect.clear()
self.agent_inspect.clear()
self.ops_inspects.clear()
self.ds_inspect.clear()
self.get_inspect_handles()
def update_vnc_lib_h(self):
if getattr(self, 'vnc_lib_fixture', None):
self.vnc_lib_fixture.cleanUp()
self.vnc_lib = None
self.vnc_lib_fixture = None
self.get_vnc_lib_h()
# ToDo: msenthil move anything other than connections out of connections.py
def set_vrouter_config_encap(self, encap1=None, encap2=None, encap3=None):
self.obj = self.vnc_lib
try:
# Reading Existing config
current_config=self.obj.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
current_linklocal=current_config.get_linklocal_services()
except NoIdError as e:
self.logger.exception('No config id found. Creating new one')
current_linklocal=''
encap_obj = EncapsulationPrioritiesType(
encapsulation=[encap1, encap2, encap3])
conf_obj = GlobalVrouterConfig(linklocal_services=current_linklocal,encapsulation_priorities=encap_obj)
result = self.obj.global_vrouter_config_create(conf_obj)
return result
# end set_vrouter_config_encap
def update_vrouter_config_encap(self, encap1=None, encap2=None, encap3=None):
'''Used to change the existing encapsulation priorities to new values'''
self.obj = self.vnc_lib
try:
# Reading Existing config
current_config=self.obj.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
current_linklocal=current_config.get_linklocal_services()
except NoIdError as e:
self.logger.exception('No config id found. Creating new one')
current_linklocal=''
encaps_obj = EncapsulationPrioritiesType(
encapsulation=[encap1, encap2, encap3])
confs_obj = GlobalVrouterConfig(linklocal_services=current_linklocal,
encapsulation_priorities=encaps_obj)
result = self.obj.global_vrouter_config_update(confs_obj)
return result
# end update_vrouter_config_encap
def delete_vrouter_encap(self):
self.obj = self.vnc_lib
try:
conf_id = self.obj.get_default_global_vrouter_config_id()
self.logger.info("Config id found.Deleting it")
config_parameters = self.obj.global_vrouter_config_read(id=conf_id)
self.inputs.config.obj = config_parameters.get_encapsulation_priorities(
)
if not self.inputs.config.obj:
# temp workaround,delete default-global-vrouter-config.need to
# review this testcase
self.obj.global_vrouter_config_delete(id=conf_id)
errmsg = "No config id found"
self.logger.info(errmsg)
return (errmsg)
try:
encaps1 = self.inputs.config.obj.encapsulation[0]
encaps2 = self.inputs.config.obj.encapsulation[1]
try:
encaps1 = self.inputs.config.obj.encapsulation[0]
encaps2 = self.inputs.config.obj.encapsulation[1]
encaps3 = self.inputs.config.obj.encapsulation[2]
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, encaps2, encaps3)
except IndexError:
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, encaps2, None)
except IndexError:
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, None, None)
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return (errmsg)
# end delete_vrouter_encap
def read_vrouter_config_encap(self):
result = None
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
config_parameters = self.obj.global_vrouter_config_read(id=conf_id)
self.inputs.config.obj = config_parameters.get_encapsulation_priorities(
)
result = self.inputs.config.obj.encapsulation
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return result
# end read_vrouter_config_encap
def set_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
# Check if already configured
try:
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except Exception:
msg = "No config id found. Configuring new one"
self.logger.info(msg)
pass
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_create(conf_obj)
return result
# end set_vrouter_config_evpn
def update_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_update(conf_obj)
return result
# end update_vrouter_config_evpn
def delete_vrouter_config_evpn(self):
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
# end delete_vrouter_config_evpn
def read_vrouter_config_evpn(self):
result = False
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
out = self.obj.global_vrouter_config_read(id=conf_id)
if 'evpn_status' in out.__dict__.keys():
result = out.evpn_status
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return result
class ContrailConnections():
def __init__(self, inputs=None, logger=None, project_name=None,
username=None, password=None, domain_name=None, input_file=None, domain_obj=None,scope='domain'):
self.inputs = inputs or ContrailTestInit(input_file,
stack_tenant=project_name)
self.project_name = project_name or self.inputs.project_name
self.domain_name = domain_name or self.inputs.domain_name
self.orch_domain_name = domain_name or self.inputs.domain_name
if self.orch_domain_name == 'Default':
self.domain_name = 'default-domain'
self.scope = scope
self.username = username or self.inputs.stack_user
self.password = password or self.inputs.stack_password
self.logger = logger or self.inputs.logger
self.nova_h = None
self.quantum_h = None
self.vnc_lib_fixture = None
self.ironic_h = None
self.api_server_inspects = custom_dict(self.get_api_inspect_handle,
'api_inspect:'+self.project_name+':'+self.username)
self.dnsagent_inspect = custom_dict(self.get_dns_agent_inspect_handle,
'dns_inspect')
self.agent_inspect = custom_dict(self.get_vrouter_agent_inspect_handle,
'agent_inspect')
self.ops_inspects = custom_dict(self.get_opserver_inspect_handle,
'ops_inspect:'+self.project_name+':'+self.username)
self.cn_inspect = custom_dict(self.get_control_node_inspect_handle,
'cn_inspect')
self.k8s_cluster = self.get_k8s_cluster()
self.k8s_client = self.get_k8s_api_client_handle()
# ToDo: msenthil/sandipd rest of init needs to be better handled
self.domain_id = None
if self.inputs.domain_isolation:
#get admin auth to list domains and get domain_id
auth = self.get_auth_h(username = self.inputs.admin_username,
password=self.inputs.admin_password,
project_name=self.inputs.admin_tenant,
domain_name=self.inputs.admin_domain)
self.domain_id = auth.get_domain_id(self.domain_name)
self.auth = self.get_auth_h()
self.vnc_lib = self.get_vnc_lib_h()
self.project_id = self.get_project_id()
if self.inputs.orchestrator == 'openstack':
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, project_name, username, password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.orch = OpenstackOrchestrator(inputs=self.inputs,
vnclib=self.vnc_lib,
logger=self.logger,
auth_h=self.auth
)
self.ironic_h = self.orch.get_ironic_handler()
self.nova_h = self.orch.get_compute_handler()
self.quantum_h = self.orch.get_network_handler()
self.glance_h = self.orch.get_image_handler()
elif self.inputs.orchestrator == 'vcenter':
self.orch = VcenterOrchestrator(user=self.inputs.vcenter_username,
pwd= self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=self.inputs.vcenter_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
if self.inputs.vro_server:
self.vro_orch = VroWorkflows(user=self.inputs.vcenter_username,
pwd= self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=self.inputs.vcenter_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
elif self.inputs.orchestrator == 'kubernetes':
self.orch = None
if self.inputs.vcenter_gw_setup: # vcenter_gateway
self.slave_orch = VcenterGatewayOrch(user=self.inputs.vcenter_username,
pwd=self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=int(self.inputs.vcenter_port),
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
self._kube_manager_inspect = None
# end __init__
def get_project_id(self, project_name=None):
project_name = project_name or self.project_name
auth = self.get_auth_h(project_name=project_name)
if auth:
return auth.get_project_id(project_name or self.project_name,
self.domain_id)
else:
return self.vnc_lib_fixture.project_id if self.vnc_lib_fixture else None
def get_auth_h(self, refresh=False, project_name=None,
username=None, password=None, domain_name=None):
project_name = project_name or self.project_name
username = username or self.username
password = password or self.password
attr = '_auth_'+project_name+'_'+username
if not getattr(env, attr, None) or refresh:
if self.inputs.orchestrator == 'openstack':
env[attr] = OpenstackAuth(username, password,
project_name, self.inputs, self.logger,
domain_name=domain_name or self.orch_domain_name,
scope=self.scope)
elif self.inputs.orchestrator == 'vcenter':
env[attr] = VcenterAuth(username, password,
project_name, self.inputs)
# elif self.inputs.orchestrator == 'kubernetes':
# env[attr] = self.get_k8s_api_client_handle()
return env.get(attr)
def get_vnc_lib_h(self, refresh=False):
attr = '_vnc_lib_fixture_' + self.project_name + '_' + self.username
cfgm_ip = self.inputs.command_server_ip or self.inputs.api_server_ip or \
self.inputs.cfgm_ip
api_server_url = self.go_config_proxy_url
api_server_port = self.inputs.go_server_port if self.inputs.command_server_ip \
else self.inputs.api_server_port
insecure = True if self.inputs.command_server_ip else self.inputs.insecure
use_ssl = False
if self.inputs.command_server_ip:
use_ssl = True
if self.inputs.api_protocol == 'https':
use_ssl = True
if not getattr(env, attr, None) or refresh:
if self.inputs.orchestrator == 'openstack' :
domain = self.orch_domain_name
else:
domain = self.domain_name
env[attr] = VncLibFixture(
username=self.username, password=self.password,
domain=domain, project_name=self.project_name,
inputs=self.inputs,
cfgm_ip=cfgm_ip,
project_id=self.get_project_id(),
api_server_port=api_server_port,
api_server_url=api_server_url,
orchestrator=self.inputs.orchestrator,
certfile = self.inputs.keystonecertfile,
keyfile = self.inputs.keystonekeyfile,
cacert = self.inputs.certbundle,
insecure = insecure,
use_ssl = use_ssl,
logger=self.logger)
env[attr].setUp()
self.vnc_lib_fixture = env[attr]
self.vnc_lib = self.vnc_lib_fixture.get_handle()
return self.vnc_lib
def get_policy_generator_handle(self):
if not self.inputs.policy_generator_ips:
return None
return PolicyGeneratorClient(inputs=self.inputs, logger=self.logger)
def get_go_client_handle(self):
if not self.inputs.command_server_ip:
return None
return GoApiInspect(self.inputs.command_server_ip,
port=self.inputs.go_server_port,
inputs=self.inputs,
logger=self.logger)
def get_api_inspect_handle(self, host):
cfgm_ip = self.inputs.command_server_ip or self.inputs.api_server_ip
if cfgm_ip:
host = cfgm_ip
api_protocol = 'https' if self.inputs.command_server_ip else self.inputs.api_protocol
api_server_port = self.inputs.go_server_port if self.inputs.command_server_ip \
else self.inputs.api_server_port
insecure = True if self.inputs.command_server_ip else self.inputs.insecure
if host not in self.api_server_inspects:
self.api_server_inspects[host] = VNCApiInspect(host,
inputs=self.inputs,
port=api_server_port,
protocol=api_protocol,
base_url=self.go_config_proxy_url,
insecure=insecure,
logger=self.logger)
return self.api_server_inspects[host]
def get_control_node_inspect_handle(self, host):
if host not in self.cn_inspect:
self.cn_inspect[host] = ControlNodeInspect(host,
self.inputs.bgp_port,
logger=self.logger,
args=self.inputs,
protocol=self.inputs.introspect_protocol)
return self.cn_inspect[host]
def get_dns_agent_inspect_handle(self, host):
if host not in self.dnsagent_inspect:
self.dnsagent_inspect[host] = DnsAgentInspect(host,
self.inputs.dns_port,
logger=self.logger,
args=self.inputs,
protocol=self.inputs.introspect_protocol)
return self.dnsagent_inspect[host]
def get_vrouter_agent_inspect_handle(self, host):
if host not in self.agent_inspect:
self.agent_inspect[host] = AgentInspect(host,
port=self.inputs.agent_port,
logger=self.logger,
inputs=self.inputs,
protocol=self.inputs.introspect_protocol)
return self.agent_inspect[host]
def get_opserver_inspect_handle(self, host):
#ToDo: WA till scripts are modified to use ip rather than hostname
ip = host if is_v4(host) else self.inputs.get_host_ip(host)
collector_ip = self.inputs.command_server_ip or self.inputs.analytics_api_ip
if collector_ip:
ip = collector_ip
port = self.inputs.go_server_port if self.inputs.command_server_ip \
else self.inputs.analytics_api_port
protocol = 'https' if self.inputs.command_server_ip else \
self.inputs.analytics_api_protocol
insecure = True if self.inputs.command_server_ip else self.inputs.insecure
if ip not in self.ops_inspects:
self.ops_inspects[ip] = VerificationOpsSrv(ip,
port=port,
protocol=protocol,
base_url=self.go_analytics_proxy_url,
insecure=insecure,
logger=self.logger,
inputs=self.inputs)
return self.ops_inspects[ip]
def get_k8s_cluster(self):
if self.inputs.slave_orchestrator != 'kubernetes':
return None
if not getattr(self, 'k8s_cluster', None):
self.k8s_cluster = None
for clus in self.inputs.k8s_clusters:
if clus['name'] == self.project_name:
self.k8s_cluster = clus
break
return self.k8s_cluster
def get_k8s_api_client_handle(self):
if self.inputs.orchestrator != 'kubernetes' and self.inputs.slave_orchestrator != 'kubernetes':
return None
if not getattr(self, 'k8s_client', None):
if self.inputs.deployer == 'openshift':
self.k8s_client = Openshift_client(self.inputs.kube_config_file,
self.logger)
else:
if self.inputs.slave_orchestrator == 'kubernetes':
if self.k8s_cluster:
self.k8s_client = Kubernetes_client(
cluster=self.k8s_cluster,
logger=self.logger)
else:
self.k8s_client = None
else:
self.k8s_client = Kubernetes_client(
self.inputs.kube_config_file,
self.logger)
return self.k8s_client
# end get_k8s_api_client_handle
def get_svc_mon_h(self, refresh=False):
if not getattr(self, '_svc_mon_inspect', None) or refresh:
for cfgm_ip in self.inputs.cfgm_ips:
#contrail-status would increase run time hence netstat approach
cmd = 'netstat -antp | grep :8088 | grep LISTEN'
if 'LISTEN' in self.inputs.run_cmd_on_server(cfgm_ip, cmd, container='svc-monitor'):
self._svc_mon_inspect = SvcMonInspect(cfgm_ip,
logger=self.logger,
args=self.inputs,
protocol=self.inputs.introspect_protocol)
break
return self._svc_mon_inspect
def get_kube_manager_h(self, refresh=False):
if not getattr(self, '_kube_manager_inspect', None) or refresh:
if self.k8s_cluster:
self._kube_manager_inspect = KubeManagerInspect(
self.k8s_cluster['master_public_ip'],
logger=self.logger,
args=self.inputs,
protocol=self.inputs.introspect_protocol)
return self._kube_manager_inspect
for km_ip in self.inputs.kube_manager_ips:
#contrail-status would increase run time hence netstat approach
cmd = 'netstat -antp | grep :%s | grep LISTEN' % self.inputs.k8s_port
if 'LISTEN' in self.inputs.run_cmd_on_server(km_ip, cmd,
container='contrail-kube-manager'):
self._kube_manager_inspect = KubeManagerInspect(km_ip,
logger=self.logger,
args=self.inputs,
protocol=self.inputs.introspect_protocol)
break
return self._kube_manager_inspect
# end get_kube_manager_h
@property
def policy_generator_handle(self):
if not getattr(self, '_policygen', None):
self._policygen = self.get_policy_generator_handle()
return self._policygen
@property
def go_api_handle(self):
if not getattr(self, '_go_api_handle', None):
self._go_api_handle = self.get_go_client_handle()
return self._go_api_handle
@property
def go_cluster_id(self):
if not self.go_api_handle:
return None
if not getattr(self, '_go_cluster_id', None):
self._go_cluster_id = self.go_api_handle.get_cluster_id()
return self._go_cluster_id
@property
def go_config_proxy_url(self):
if not self.go_api_handle:
return '/'
if not getattr(self, '_config_proxy_url', None):
self._config_proxy_url = '/proxy/%s/config/'%self.go_cluster_id
return self._config_proxy_url
@property
def go_analytics_proxy_url(self):
if not self.go_api_handle:
return '/'
if not getattr(self, '_analytics_proxy_url', None):
self._analytics_proxy_url = '/proxy/%s/telemetry/'%self.go_cluster_id
return self._analytics_proxy_url
@property
def api_server_inspect(self):
if not getattr(self, '_api_server_inspect', None):
self._api_server_inspect = self.api_server_inspects[
self.inputs.cfgm_ips[0]]
return self._api_server_inspect
@api_server_inspect.setter
def api_server_inspect(self, value):
self._api_server_inspect = value
@property
def ops_inspect(self):
if not getattr(self, '_ops_inspect', None):
self._ops_inspect = self.ops_inspects[self.inputs.collector_ips[0]]
return self._ops_inspect
@ops_inspect.setter
def ops_inspect(self, value):
self._ops_inspect = value
@property
def analytics_obj(self):
if not getattr(self, '_analytics_obj', None):
self._analytics_obj = AnalyticsVerification(self.inputs,
self.cn_inspect, self.agent_inspect,
self.ops_inspects, logger=self.logger)
return self._analytics_obj
@analytics_obj.setter
def analytics_obj(self, value):
self._analytics_obj = value
def update_inspect_handles(self):
self.api_server_inspects.clear()
self.cn_inspect.clear()
self.dnsagent_inspect.clear()
self.agent_inspect.clear()
self.ops_inspects.clear()
self._svc_mon_inspect = None
self._api_server_inspect = None
self._ops_inspect = None
self._analytics_obj = None
self._kube_manager_inspect = None
# end update_inspect_handles
def update_vnc_lib_fixture(self):
self.vnc_lib = self.get_vnc_lib_h(refresh=True)
# end update_vnc_lib_fixture()
def set_vrouter_config_encap(self, encap1=None, encap2=None, encap3=None):
return self.update_vrouter_config_encap(encap1, encap2, encap3, create=True)
# end set_vrouter_config_encap
def update_vrouter_config_encap(self, encap1=None, encap2=None, encap3=None, create=False):
'''Used to change the existing encapsulation priorities to new values'''
if not (encap1 and encap2 and encap3):
return self.delete_vrouter_encap()
try:
# Reading Existing config
current_config = self.vnc_lib.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
except NoIdError as e:
self.logger.exception('No config id found. Creating new one')
if not create:
raise
conf_obj = GlobalVrouterConfig()
self.vnc_lib.global_vrouter_config_create(conf_obj)
encaps_obj = EncapsulationPrioritiesType(
encapsulation=[encap1, encap2, encap3])
confs_obj = GlobalVrouterConfig(encapsulation_priorities=encaps_obj)
result = self.vnc_lib.global_vrouter_config_update(confs_obj)
return result
# end update_vrouter_config_encap
def delete_vrouter_encap(self):
try:
conf_id = self.vnc_lib.get_default_global_vrouter_config_id()
obj = self.vnc_lib.global_vrouter_config_read(id=conf_id)
encap_obj = obj.get_encapsulation_priorities()
if not encap_obj:
return ['', '', '']
encaps = encap_obj.encapsulation
l = len(encaps)
encaps.extend([''] * (3 - l))
obj.set_encapsulation_priorities(None)
self.vnc_lib.global_vrouter_config_update(obj)
return encaps
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return (errmsg)
# end delete_vrouter_encap
def read_vrouter_config_encap(self):
result = None
try:
conf_id = self.vnc_lib.get_default_global_vrouter_config_id()
config_parameters = self.vnc_lib.global_vrouter_config_read(id=conf_id)
obj = config_parameters.get_encapsulation_priorities()
if not obj:
return ['', '', '']
else:
return obj.encapsulation
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return result
# end read_vrouter_config_encap
def set_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
# Check if already configured
try:
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except Exception:
msg = "No config id found. Configuring new one"
self.logger.info(msg)
pass
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_create(conf_obj)
return result
# end set_vrouter_config_evpn
def update_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_update(conf_obj)
return result
# end update_vrouter_config_evpn
def delete_vrouter_config_evpn(self):
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
# end delete_vrouter_config_evpn
def read_vrouter_config_evpn(self):
result = False
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
out = self.obj.global_vrouter_config_read(id=conf_id)
if 'evpn_status' in out.__dict__.keys():
result = out.evpn_status
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return result
def __init__(self,
inputs,
logger,
project_name=None,
username=None,
password=None):
self.inputs = inputs
project_name = project_name or self.inputs.project_name
username = username or self.inputs.stack_user
password = password or self.inputs.stack_password
self.username = username
self.password = password
self.project_name = project_name
self.vnc_lib_fixture = VncLibFixture(
username=username,
password=password,
domain=self.inputs.domain_name,
project=project_name,
inputs=self.inputs,
cfgm_ip=self.inputs.cfgm_ip,
api_port=self.inputs.api_server_port)
self.vnc_lib_fixture.setUp()
self.vnc_lib = self.vnc_lib_fixture.get_handle()
self.nova_h = None
self.quantum_h = None
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(username, password, project_name,
self.inputs, logger)
self.project_id = self.auth.get_project_id(self.inputs.domain_name,
project_name)
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, project_name,
username, password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.orch = OpenstackOrchestrator(username=username,
password=password,
project_id=self.project_id,
project_name=project_name,
inputs=inputs,
vnclib=self.vnc_lib,
logger=logger)
self.nova_h = self.orch.nova_h
self.quantum_h = self.orch.quantum_h
else: # vcenter
self.auth = VcenterAuth(username, password, project_name,
self.inputs)
self.orch = VcenterOrchestrator(user=username,
pwd=password,
host=self.inputs.auth_ip,
port=self.inputs.auth_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=logger)
self.api_server_inspects = {}
self.dnsagent_inspect = {}
self.cn_inspect = {}
self.agent_inspect = {}
self.ops_inspects = {}
self.ds_inspect = {}
self.update_inspect_handles()
class ContrailConnections():
def __init__(self,
inputs,
logger,
project_name=None,
username=None,
password=None):
self.inputs = inputs
project_name = project_name or self.inputs.project_name
self.username = username or self.inputs.stack_user
self.password = password or self.inputs.stack_password
self.project_name = project_name
self.logger = logger
self.nova_h = None
self.quantum_h = None
if self.inputs.orchestrator == 'openstack':
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, self.project_name,
self.username, self.password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.api_server_inspects = {}
self.dnsagent_inspect = {}
self.cn_inspect = {}
self.agent_inspect = {}
self.ops_inspects = {}
self.ds_inspect = {}
# end __init__
def get_all_handles(self):
self.get_vnc_lib_h()
self.get_auth_h()
self.get_orch_h()
self.get_inspect_handles()
def get_vnc_lib_h(self):
if not getattr(self, 'vnc_lib', None):
auth_host = self.inputs.get_auth_host()
self.vnc_lib_fixture = VncLibHelper(
username=self.username,
password=self.password,
domain=self.inputs.domain_name,
project=self.project_name,
inputs=self.inputs,
cfgm_ip=self.inputs.cfgm_ip,
api_port=self.inputs.api_server_port,
auth_host=auth_host)
self.vnc_lib = self.vnc_lib_fixture.get_handle()
return self.vnc_lib_fixture
def get_auth_h(self):
if not getattr(self, 'auth', None):
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(self.username, self.password,
self.project_name, self.inputs,
self.logger)
else: # vcenter
self.auth = VcenterAuth(self.username, self.password,
self.project_name, self.inputs)
return self.auth
def get_orch_h(self):
if not getattr(self, 'orch', None):
if self.inputs.orchestrator == 'openstack':
self.orch = OpenstackOrchestrator(
username=self.username,
password=self.password,
project_name=self.project_name,
inputs=self.inputs,
logger=self.logger)
self.nova_h = self.orch.get_compute_h()
self.quantum_h = self.orch.get_network_h()
else:
self.get_vnc_lib_h()
self.orch = VcenterOrchestrator(user=self.username,
pwd=self.password,
host=self.inputs.auth_ip,
port=self.inputs.auth_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
return self.orch
def get_network_h(self):
orch = self.get_orch_h()
return orch.get_network_h()
def get_compute_h(self):
orch = self.get_orch_h()
return orch.get_compute_h()
def get_project_fq_name(self):
return [self.inputs.domain_name, self.project_name]
def get_project_id(self):
if not getattr(self, 'project_id', None):
self.get_auth_h()
self.project_id = self.auth.get_project_id(self.inputs.domain_name,
self.project_name)
return self.project_id
def get_inspect_handles(self):
self.get_api_server_inspect_handles()
self.get_control_node_inspect_handles()
self.get_dns_agent_inspect_handles()
self.get_opserver_inspect_handles()
self.get_discovery_service_inspect_handles()
for compute_ip in self.inputs.compute_ips:
self.get_vrouter_agent_inspect_handle(compute_ip)
self.analytics_obj = self.get_analytics_object()
self.ds_verification_obj = self.get_discovery_service_object()
# for collector_name in self.inputs.collector_names:
# self.ops_inspects[collector_name] = VerificationOpsSrv(
# collector_ip, logger=self.inputs.logger)
def get_api_server_inspect_handles(self):
for cfgm_ip in self.inputs.cfgm_ips:
self.get_api_inspect_handle(cfgm_ip)
self.api_server_inspect = self.api_server_inspects.values()[0]
return self.api_server_inspects
def get_control_node_inspect_handles(self):
for bgp_ip in self.inputs.bgp_ips:
self.get_control_node_inspect_handle(bgp_ip)
return self.cn_inspect
def get_dns_agent_inspect_handles(self):
for bgp_ip in self.inputs.bgp_ips:
self.get_dns_agent_inspect_handle(bgp_ip)
return self.dnsagent_inspect
def get_opserver_inspect_handles(self):
for collector_ip in self.inputs.collector_ips:
self.get_opserver_inspect_handle(collector_ip)
self.ops_inspect = self.ops_inspects.values()[0]
return self.ops_inspects
def get_discovery_service_inspect_handles(self):
for ds_ip in self.inputs.ds_server_ip:
self.get_discovery_service_inspect_handle(ds_ip)
return self.ds_inspect
def get_api_inspect_handle(self, host):
if host not in self.api_server_inspects:
self.api_server_inspects[host] = VNCApiInspect(host,
args=self.inputs,
logger=self.logger)
return self.api_server_inspects[host]
def get_control_node_inspect_handle(self, host):
if host not in self.cn_inspect:
self.cn_inspect[host] = ControlNodeInspect(host,
logger=self.logger)
return self.cn_inspect[host]
def get_dns_agent_inspect_handle(self, host):
if host not in self.dnsagent_inspect:
self.dnsagent_inspect[host] = DnsAgentInspect(host,
logger=self.logger)
return self.dnsagent_inspect[host]
def get_vrouter_agent_inspect_handle(self, host):
if host not in self.agent_inspect:
self.agent_inspect[host] = AgentInspect(host, logger=self.logger)
return self.agent_inspect[host]
def get_opserver_inspect_handle(self, host):
if host not in self.ops_inspects:
self.ops_inspects[host] = VerificationOpsSrv(host,
logger=self.logger)
return self.ops_inspects[host]
def get_analytics_object(self):
if not getattr(self, 'analytics_obj', None):
ops_inspects = self.get_opserver_inspect_handles()
self.analytics_obj = AnalyticsVerification(self.inputs,
ops_inspects,
logger=self.logger)
return self.analytics_obj
def get_discovery_service_inspect_handle(self, host):
if host not in self.ds_inspect:
self.ds_inspect[host] = VerificationDsSrv(host, logger=self.logger)
return self.ds_inspect[host]
def get_discovery_service_object(self):
if not getattr(self, 'ds_verification_obj', None):
self.ds_verification_obj = DiscoveryVerification(
self.inputs,
self.api_server_inspect,
self.cn_inspect,
self.agent_inspect,
self.ops_inspects,
self.ds_inspect,
logger=self.logger)
return self.ds_verification_obj
def update_inspect_handles(self):
self.api_server_inspects.clear()
self.cn_inspect.clear()
self.dnsagent_inspect.clear()
self.agent_inspect.clear()
self.ops_inspects.clear()
self.ds_inspect.clear()
self.get_inspect_handles()
def update_vnc_lib_h(self):
if getattr(self, 'vnc_lib_fixture', None):
self.vnc_lib_fixture.cleanUp()
self.vnc_lib = None
self.vnc_lib_fixture = None
self.get_vnc_lib_h()
# ToDo: msenthil move anything other than connections out of connections.py
def set_vrouter_config_encap(self, encap1=None, encap2=None, encap3=None):
self.obj = self.vnc_lib
try:
# Reading Existing config
current_config = self.obj.global_vrouter_config_read(fq_name=[
'default-global-system-config', 'default-global-vrouter-config'
])
current_linklocal = current_config.get_linklocal_services()
except NoIdError as e:
self.logger.exception('No config id found. Creating new one')
current_linklocal = ''
encap_obj = EncapsulationPrioritiesType(
encapsulation=[encap1, encap2, encap3])
conf_obj = GlobalVrouterConfig(linklocal_services=current_linklocal,
encapsulation_priorities=encap_obj)
result = self.obj.global_vrouter_config_create(conf_obj)
return result
# end set_vrouter_config_encap
def update_vrouter_config_encap(self,
encap1=None,
encap2=None,
encap3=None):
'''Used to change the existing encapsulation priorities to new values'''
self.obj = self.vnc_lib
try:
# Reading Existing config
current_config = self.obj.global_vrouter_config_read(fq_name=[
'default-global-system-config', 'default-global-vrouter-config'
])
current_linklocal = current_config.get_linklocal_services()
except NoIdError as e:
self.logger.exception('No config id found. Creating new one')
current_linklocal = ''
encaps_obj = EncapsulationPrioritiesType(
encapsulation=[encap1, encap2, encap3])
confs_obj = GlobalVrouterConfig(linklocal_services=current_linklocal,
encapsulation_priorities=encaps_obj)
result = self.obj.global_vrouter_config_update(confs_obj)
return result
# end update_vrouter_config_encap
def delete_vrouter_encap(self):
self.obj = self.vnc_lib
try:
conf_id = self.obj.get_default_global_vrouter_config_id()
self.logger.info("Config id found.Deleting it")
config_parameters = self.obj.global_vrouter_config_read(id=conf_id)
self.inputs.config.obj = config_parameters.get_encapsulation_priorities(
)
if not self.inputs.config.obj:
# temp workaround,delete default-global-vrouter-config.need to
# review this testcase
self.obj.global_vrouter_config_delete(id=conf_id)
errmsg = "No config id found"
self.logger.info(errmsg)
return (errmsg)
try:
encaps1 = self.inputs.config.obj.encapsulation[0]
encaps2 = self.inputs.config.obj.encapsulation[1]
try:
encaps1 = self.inputs.config.obj.encapsulation[0]
encaps2 = self.inputs.config.obj.encapsulation[1]
encaps3 = self.inputs.config.obj.encapsulation[2]
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, encaps2, encaps3)
except IndexError:
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, encaps2, None)
except IndexError:
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, None, None)
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return (errmsg)
# end delete_vrouter_encap
def read_vrouter_config_encap(self):
result = None
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
config_parameters = self.obj.global_vrouter_config_read(id=conf_id)
self.inputs.config.obj = config_parameters.get_encapsulation_priorities(
)
result = self.inputs.config.obj.encapsulation
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return result
# end read_vrouter_config_encap
def set_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
# Check if already configured
try:
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except Exception:
msg = "No config id found. Configuring new one"
self.logger.info(msg)
pass
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_create(conf_obj)
return result
# end set_vrouter_config_evpn
def update_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_update(conf_obj)
return result
# end update_vrouter_config_evpn
def delete_vrouter_config_evpn(self):
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
# end delete_vrouter_config_evpn
def read_vrouter_config_evpn(self):
result = False
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
out = self.obj.global_vrouter_config_read(id=conf_id)
if 'evpn_status' in out.__dict__.keys():
result = out.evpn_status
except NoIdError:
errmsg = "No config id found"
self.logger.info(errmsg)
return result