Merge "Initial commit for VRO infra" into R5.0

common/connections.py

@@ -13,6 +13,7 @@
 import os
 from openstack import OpenstackAuth, OpenstackOrchestrator
 from vcenter import VcenterAuth, VcenterOrchestrator
+from vro import VroWorkflows
 from common.contrail_test_init import ContrailTestInit
 from vcenter_gateway import VcenterGatewayOrch
 try:
@@ -80,6 +81,15 @@ def __init__(self, inputs=None, logger=None, project_name=None,
             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,

common/contrail_test_init.py

@@ -796,9 +796,10 @@ def parse_yml_file(self):
             self.config.get('orchestrator_configuration') or {}
         test_configs = self.config.get('test_configuration') or {}
         self.orchestrator = deployment_configs.get('orchestrator') or 'openstack'
-        self.slave_orchestrator = deployment_configs.get('slave_orchestrator')
+        self.slave_orchestrator = deployment_configs.get('slave_orchestrator',None)
         if self.deployer == 'openshift':
             kube_config_file = OPENSHIFT_CONFIG_FILE
+
         else:
             kube_config_file = K8S_CONFIG_FILE
         self.kube_config_file = test_configs.get('kube_config_file') or kube_config_file
@@ -954,6 +955,9 @@ def parse_yml_file(self):
             self.admin_password = self.vcenter_password
             self.admin_tenant = self.stack_tenant 
             self.admin_domain = self.stack_domain
+        if self.slave_orchestrator == 'vro':
+            self.vro_ip = test_configs.get('vro_ip')
+            self.vro_port = test_configs.get('vro_port')
 
     def get_os_env(self, var, default=''):
         if var in os.environ:

fixtures/policy_test.py

@@ -76,7 +76,10 @@ def setUp(self):
             try:
                 self.policy_obj = self.vnc_lib.network_policy_read(fq_name=self.project_fq_name+[unicode(self.policy_name)])
             except:
-                self.policy_fq_name = self._set_policy_api(self.policy_name, self.rules_list)
+                if self.inputs.slave_orchestrator == 'vro':
+                    self.policy_fq_name = self._set_policy_vro(self.policy_name, self.rules_list)
+                else:
+                    self.policy_fq_name = self._set_policy_api(self.policy_name, self.rules_list)
             else:
                 self.already_present = True
                 self.policy_fq_name=self.policy_obj.fq_name
@@ -321,7 +324,16 @@ def serialize(obj):
         self.policy_obj = policy_rsp
         return policy_rsp
     # end  _create_policy
-
+
+    def _set_policy_vro(self, policy_name, rules_list, policy_obj=None):
+        '''create policy and rules from vro'''
+        self.connections.orch.create_policy(name = policy_name, rules = rules_list)
+        self.policy_obj = self.vnc_lib.network_policy_read(
+                fq_name=self.project_fq_name+[unicode(self.policy_name)])
+        self._populate_attr()
+        return self.policy_fq_name
+    #end _set_policy_vro
+
     def _set_policy_api(self, policy_name, rules_list, policy_obj=None):
         ''' Create a policy from the supplied rules
         Sample rules_list:
@@ -346,7 +358,7 @@ def _set_policy_api(self, policy_name, rules_list, policy_obj=None):
                'dest_network'  : vn1_name, 'dst_ports'     : [100,10],
              }
                 ]
-        '''
+        '''              
         np_rules = []
         for rule_dict in rules_list:
             source_vn = None
@@ -537,9 +549,9 @@ def _set_policy_api(self, policy_name, rules_list, policy_obj=None):
                     dst_ports=new_rule['dst_ports'],
                     action_list=new_rule['action_list']))
 
-
         # end for
         self.logger.debug("Policy np_rules : %s" % (np_rules))
+
         pol_entries = PolicyEntriesType(np_rules)
         if policy_obj:
             policy_obj.network_policy_entries = pol_entries
@@ -606,7 +618,10 @@ def get_entries(self):
 
     def _delete_policy(self):
         if self.api_flag:
-            self.vnc_lib.network_policy_delete(id=self.policy_obj.uuid)
+            if self.inputs.slave_orchestrator == 'vro':
+                self.connections.orch.delete_policy(self.policy_name)
+            else:
+                self.vnc_lib.network_policy_delete(id=self.policy_obj.uuid)
             self.logger.info("Deleted policy %s" % (self.policy_name))
         elif self.inputs.is_gui_based_config():
             self.webui.delete_policy(self)
@@ -1119,6 +1134,7 @@ def verify_policy_in_api_server(self):
             logger=self.logger)
         if out:
             err_msg.append(out)
+
         # compare policy_rules
         out = policy_test_utils.compare_args(
             'policy_rules', self.api_s_policy_obj_x[

fixtures/security_group.py

@@ -63,6 +63,9 @@ def create(self):
             self.already_present = False
             if self.inputs.is_gui_based_config():
                 self.webui.create_security_group(self)
+            elif self.inputs.slave_orchestrator == 'vro':
+                self.secgrp_id = self.orch.create_security_group(self.secgrp_name, 
+                                                                 self.secgrp_entries)
             else:
                 self.secgrp_id = self.orch.create_security_group(
                                                  sg_name=self.secgrp_name,
@@ -104,6 +107,8 @@ def delete(self, verify=False):
         if do_cleanup:
             if self.inputs.is_gui_based_config():
                 self.webui.delete_security_group(self)
+            elif self.inputs.slave_orchestrator == 'vro':
+                self.orch.delete_security_group(self.secgrp_name) 
             else:
                 self.orch.delete_security_group(sg_id=self.secgrp_id, option=self.option)
             if self.verify_is_run or verify:

fixtures/svc_instance_fixture.py

@@ -32,6 +32,7 @@ def __init__(self,
         self.port_tuples_props = port_tuples_props
 
         self.connections = connections
+        self.orch = connections.orch
         self.vnc_lib = connections.vnc_lib
         self.api_s_inspect = connections.api_server_inspect
         self.nova_h = connections.nova_h
@@ -115,6 +116,11 @@ def _create_si(self):
                 "Service instance: %s already exists", self.si_fq_name)
         except NoIdError:
             self.logger.debug("Creating service instance: %s", self.si_fq_name)
+            if self.inputs.slave_orchestrator == 'vro':
+                self.orch.create_si(self.si_name, self.svc_template, self.if_details)
+                self.si_obj = self.vnc_lib.service_instance_read(
+                fq_name=self.si_fq_name)
+                self.orch.add_port_tuple(self.si_name, self.port_tuples_props)
             project = self.vnc_lib.project_read(fq_name=self.project_fq_name)
             svc_instance = ServiceInstance(self.si_name, parent_obj=project)
             si_type_args = None
@@ -279,7 +285,10 @@ def _delete_si(self):
         for irt in intf_rt_table_list:
             self.disassociate_static_route_table(irt['uuid'])
         self.logger.debug("Deleting service instance: %s", self.si_fq_name)
-        self.vnc_lib.service_instance_delete(fq_name=self.si_fq_name)
+        if self.inputs.slave_orchestrator == 'vro':
+            self.orch.delete_si(self.si_name)
+        else:
+            self.vnc_lib.service_instance_delete(fq_name=self.si_fq_name)
     # end _delete_si
 
     @property

fixtures/svc_template_fixture.py

@@ -88,45 +88,58 @@ def _create_st(self):
             self.logger.debug(
                 "Service template: %s already exists", self.st_fq_name)
         except NoIdError:
-            domain = self.connections.vnc_lib_fixture.domain_read(fq_name=self.domain_fq_name)
-            svc_template = ServiceTemplate(
-                name=self.st_name, parent_obj=domain)
-            svc_properties = ServiceTemplateType()
-            svc_properties.set_service_type(self.service_type)
-            svc_properties.set_service_mode(self.service_mode)
-            svc_properties.set_version(self.version)
-            # Add flavor if not already added
-            if self.version == 1:
-                svc_properties.set_image_name(self.image_name)
-                svc_properties.set_service_scaling(self.svc_scaling)
-                self.orch.get_flavor(self.flavor)
-                svc_properties.set_flavor(self.flavor)
-                svc_properties.set_availability_zone_enable(self.availability_zone_enable)
-#            for itf in self.if_list:
-            for itf_type, val in self.if_details.iteritems():
-                shared_ip = val.get('shared_ip_enable', None)
-                static_route_enable = val.get('static_route_enable', None)
-                if_type = ServiceTemplateInterfaceType(
-                    service_interface_type=itf_type,
-                    shared_ip=shared_ip,
-                    static_route_enable=static_route_enable)
-                if_type.set_service_interface_type(itf_type)
-                svc_properties.add_interface_type(if_type)
-
-            svc_template.set_service_template_properties(svc_properties)
-            if self.inputs.is_gui_based_config():
-                self.webui.create_svc_template(self)
-            else:
-                self.uuid = self.vnc_lib_h.service_template_create(svc_template)
-            svc_template = self.vnc_lib_h.service_template_read(
+            if self.inputs.slave_orchestrator == 'vro':
+                st = {}
+                st['st_name'] = self.st_name
+                st['if_details'] = self.if_details
+                st['svc_mode'] = self.service_mode
+                st['svc_type'] = self.service_type
+                self.orch.create_st(st)
+                svc_template = self.vnc_lib_h.service_template_read(
                 fq_name=self.st_fq_name)
+            else:
+                domain = self.connections.vnc_lib_fixture.domain_read(fq_name=self.domain_fq_name)
+                svc_template = ServiceTemplate(
+                    name=self.st_name, parent_obj=domain)
+                svc_properties = ServiceTemplateType()
+                svc_properties.set_service_type(self.service_type)
+                svc_properties.set_service_mode(self.service_mode)
+                svc_properties.set_version(self.version)
+                # Add flavor if not already added
+                if self.version == 1:
+                    svc_properties.set_image_name(self.image_name)
+                    svc_properties.set_service_scaling(self.svc_scaling)
+                    self.orch.get_flavor(self.flavor)
+                    svc_properties.set_flavor(self.flavor)
+                    svc_properties.set_availability_zone_enable(self.availability_zone_enable)
+    #            for itf in self.if_list:
+                for itf_type, val in self.if_details.iteritems():
+                    shared_ip = val.get('shared_ip_enable', None)
+                    static_route_enable = val.get('static_route_enable', None)
+                    if_type = ServiceTemplateInterfaceType(
+                        service_interface_type=itf_type,
+                        shared_ip=shared_ip,
+                        static_route_enable=static_route_enable)
+                    if_type.set_service_interface_type(itf_type)
+                    svc_properties.add_interface_type(if_type)
+
+                svc_template.set_service_template_properties(svc_properties)
+                if self.inputs.is_gui_based_config():
+                    self.webui.create_svc_template(self)
+                else:
+                    self.uuid = self.vnc_lib_h.service_template_create(svc_template)
+                svc_template = self.vnc_lib_h.service_template_read(
+                    fq_name=self.st_fq_name)
 
         return svc_template
     # end _create_st
 
     def _delete_st(self):
         self.logger.debug("Deleting service template: %s", self.st_fq_name)
-        self.vnc_lib_h.service_template_delete(fq_name=self.st_fq_name)
+        if self.inputs.slave_orchestrator == 'vro':
+            self.orch.delete_st(self.st_name)
+        else:
+            self.vnc_lib_h.service_template_delete(fq_name=self.st_fq_name)
     # end _delete_st
 
     def verify_on_setup(self):

fixtures/vn_test.py

@@ -1451,7 +1451,9 @@ def get_obj(self):
 
     def bind_policies(self, policy_fq_names, vn_id=None, reset=True):
         vn_id = vn_id or self.uuid
-        if  isinstance(self.orchestrator,VcenterOrchestrator) or self.option == 'contrail':
+        if  self.inputs.slave_orchestrator == 'vro':
+            self.orch.add_network_policy_to_vn(self.vn_name, policy_fq_names)
+        elif  isinstance(self.orchestrator,VcenterOrchestrator) or self.option == 'contrail':
             self.api_vn_obj = self.vnc_lib_h.virtual_network_read(id=self.uuid)
             if reset:
                 self.api_vn_obj.set_network_policy_list([],True)
@@ -1498,6 +1500,8 @@ def update_vn_object(self):
 
     def unbind_policies(self, vn_id=None, policy_fq_names=[]):
         vn_id = vn_id or self.uuid
+        if  self.inputs.slave_orchestrator == 'vro':
+            self.orch.remove_network_policy_from_vn(self.vn_name, policy_fq_names)
         if isinstance(self.orchestrator,VcenterOrchestrator) or self.option == 'contrail':
             if policy_fq_names == []:
                 self.api_vn_obj.set_network_policy_list([],True)