Esempio n. 1
0
def main():
    import sys
    from vn_test import VNFixture
    from vm_test import VMFixture
#    sys.settrace(tracefunc)
#    obj = LBaasFixture(api_type='neutron', name='LB', connections=setup_test_infra(), network_id='4b39a2bd-4528-40e8-b848-28084e59c944', members={'vms': ['a72ad607-f1ca-44f2-b31e-e825a3f2d408'], 'address': ['192.168.1.10']}, vip_net_id='4b39a2bd-4528-40e8-b848-28084e59c944', protocol='TCP', port='22', healthmonitors=[{'delay':5, 'timeout':5, 'max_retries':5, 'probe_type':'PING'}])
    conn = setup_test_infra()
    vnfix = VNFixture(connections=conn, vn_name='admin-33688095')
    vnfix.setUp()
    fip_fix = VNFixture(connections=conn, router_external=True, vn_name='fip-vn')
    fip_fix.setUp()
    subnet = vnfix.get_cidrs()[0]
    vm_fix = VMFixture(connections=conn, vn_obj=vnfix.obj, vm_name='member-vm')
    vm_fix.setUp()
    obj = LBaasV2Fixture(lb_name='LB-Test', connections=conn, network_id=vnfix.uuid,
                         fip_net_id=fip_fix.uuid, listener_name='Listener-Test', vip_port='80',
                         vip_protocol='HTTP', pool_name='Pool-Test', pool_port='80', pool_protocol='HTTP',
                         pool_algorithm='ROUND_ROBIN', members={'vms': [vm_fix.vm_id]},
                         hm_delay=5, hm_timeout=5, hm_max_retries=5, hm_probe_type='PING',
                        )
    obj.setUp()
    import pdb; pdb.set_trace()
    obj.verify_on_setup()
    obj.cleanUp()
    exit()
    import pdb; pdb.set_trace()
#    obj = LBaasFixture(api_type='neutron', uuid='58e5fb2c-ec47-4eb8-b4bf-9c66b0473f78', connections=setup_test_infra())
    obj.verify_on_setup()
    obj.delete_custom_attr('max_sess_rate')
    obj.add_custom_attr('client_timeout', 20000)
    obj.delete_custom_attr('server_timeout')
    obj.add_custom_attr('max_sess_rate', 20000)
    obj.delete_custom_attr('rate_limit_sessions')
    obj.add_custom_attr('rate_limit_sessions', 20)
    obj.delete_custom_attr('max_conn')
    obj.add_custom_attr('max_conn', 20)
    obj.delete_custom_attr('http_server_close')
    obj.add_custom_attr('http_server_close', "False")
    obj.verify_on_setup()
    obj.create_fip_on_vip()
    obj.verify_on_setup()
    obj.delete_fip_on_vip()
    obj.verify_on_setup()
    obj.delete_vip()
    obj.verify_on_setup()
    obj.check_and_create_vip()
    obj.verify_on_setup()
    obj.delete_member(address=obj.member_ips[1])
    obj.verify_on_setup()
    obj.create_member(address=get_random_ip(subnet))
    obj.verify_on_setup()
    obj.delete_hmon(obj.hmons.keys()[0])
    obj.verify_on_setup()
    obj.create_hmon({'delay': 5, 'max_retries': 5, 'probe_type': 'PING', 'timeout': 10})
    obj.verify_on_setup()
    obj.cleanUp()
    vm_fix.cleanUp()
    vnfix.cleanUp()
    vip_fix.cleanUp()
    fip_fix.cleanUp()
Esempio n. 2
0
 def create_only_vm(
     cls,
     vn_fixture=None,
     vm_name=None,
     node_name=None,
     flavor="contrail_flavor_small",
     image_name="ubuntu-traffic",
     port_ids=[],
     **kwargs
 ):
     vn_obj = None
     if not vm_name:
         vm_name = "vm-%s" % (get_random_name(cls.inputs.project_name))
     if vn_fixture:
         vn_obj = vn_fixture.obj
     vm_obj = VMFixture(
         project_name=cls.inputs.project_name,
         connections=cls.connections,
         vn_obj=vn_obj,
         vm_name=vm_name,
         image_name=image_name,
         flavor=flavor,
         node_name=node_name,
         port_ids=port_ids,
         **kwargs
     )
     vm_obj.setUp()
     return vm_obj
Esempio n. 3
0
 def create_only_vm(cls,
                    vn_fixture=None,
                    vm_name=None,
                    node_name=None,
                    flavor='contrail_flavor_small',
                    image_name='ubuntu-traffic',
                    port_ids=[],
                    **kwargs):
     vn_obj = None
     if vn_fixture:
         vn_obj = vn_fixture.obj
     project_name = kwargs.get(
         'project_name') or cls.connections.project_name
     connections = kwargs.get('connections') or cls.connections
     vm_obj = VMFixture(project_name=project_name,
                        connections=connections,
                        vn_obj=vn_obj,
                        vm_name=vm_name,
                        image_name=image_name,
                        flavor=flavor,
                        node_name=node_name,
                        port_ids=port_ids,
                        **kwargs)
     vm_obj.setUp()
     return vm_obj
Esempio n. 4
0
 def verify_vms(self, stack, vn_list, env, stack_name):
     op = stack.stacks.get(stack_name).outputs
     time.sleep(5)
     vm1_name = str(env['parameters']['left_vm_name'])
     vm2_name = str(env['parameters']['right_vm_name'])
     vm1_fix = self.useFixture(
         VMFixture(project_name=self.inputs.project_name,
                   vn_obj=vn_list[0].obj,
                   vm_name=vm1_name,
                   connections=self.connections))
     vm2_fix = self.useFixture(
         VMFixture(project_name=self.inputs.project_name,
                   vn_obj=vn_list[1].obj,
                   vm_name=vm2_name,
                   connections=self.connections))
     # ToDo: Do we need to wait here or should we check before accessing
     assert vm1_fix.wait_till_vm_is_up()
     assert vm2_fix.wait_till_vm_is_up()
     for output in op:
         if output['output_value'] == vm1_fix.vm_ip:
             self.logger.info('VM %s launched successfully' %
                              vm1_fix.vm_name)
         elif output['output_value'] == vm2_fix.vm_ip:
             self.logger.info('VM %s launched successfully' %
                              vm2_fix.vm_name)
     vms_list = [vm1_fix, vm2_fix]
     return vms_list
Esempio n. 5
0
    def config_vm(self,
                  vm_name,
                  vn_fix=None,
                  node_name=None,
                  image_name='ubuntu-traffic',
                  flavor='contrail_flavor_small',
                  vns=[],
                  count=1,
                  zone=None):
        if vn_fix:
            vm_fixture = self.useFixture(
                VMFixture(project_name=self.inputs.project_name,
                          connections=self.connections,
                          vn_obj=vn_fix.obj,
                          vm_name=vm_name,
                          node_name=node_name,
                          image_name=image_name,
                          flavor=flavor,
                          count=count,
                          zone=zone))
        elif vns:
            vm_fixture = self.useFixture(
                VMFixture(project_name=self.inputs.project_name,
                          connections=self.connections,
                          vm_name=vm_name,
                          node_name=node_name,
                          image_name=image_name,
                          flavor=flavor,
                          vn_objs=vns,
                          count=count,
                          zone=zone))

        return vm_fixture
 def svm_list(self):
     if not getattr(self, '_svm_list', None):
         self._svm_list = []
         for vmid in self.svm_ids:
            vm = VMFixture(self.connections, uuid=vmid)
            vm.setUp()
            vm.verify_on_setup()
            self._svm_list.append(vm)
     return self._svm_list
 def svm_list(self):
     vms = getattr(self, '_svm_list', [])
     if not vms or len(vms) != len(self.svm_ids):
         # Reduce the svm_list to take care of reduce in ecmp instances
         self._svm_list = [vm for vm in vms if vm.get_uuid() in self.svm_ids]
         # Increase the svm_list to take care of increase in ecmp instances
         for vmid in set(self.svm_ids) - set([vm.get_uuid() for vm in self._svm_list]):
             vm = VMFixture(self.connections, uuid=vmid)
             vm.setUp()
             vm.wait_till_vm_is_active()
             self._svm_list.append(vm)
     return self._svm_list
    def vm_add_delete(self):

        vm1_name = 'vn11_vm1_mine'
        vm2_name = 'vn22_vm1_mine'
        vm3_name = 'fip_vn_vm1_mine'
        vm4_name = 'newvn_vm1_mine'
        vm5_name = 'newvn11_vm1_mine'

        vn_obj = self.res.vn11_fixture.obj
        self.vm11_fixture = self.useFixture(
            VMFixture(connections=self.connections,
                      vn_obj=vn_obj,
                      vm_name=vm1_name,
                      project_name=self.inputs.project_name))
        assert self.vm11_fixture.verify_on_setup()

        vn_obj = self.res.vn22_fixture.obj
        self.vm22_fixture = self.useFixture(
            VMFixture(connections=self.connections,
                      vn_obj=vn_obj,
                      vm_name=vm2_name,
                      project_name=self.inputs.project_name))
        assert self.vm22_fixture.verify_on_setup()

        vn_obj = self.res.fvn_fixture.obj
        self.vm33_fixture = self.useFixture(
            VMFixture(connections=self.connections,
                      vn_obj=vn_obj,
                      vm_name=vm3_name,
                      project_name=self.inputs.project_name))
        assert self.vm33_fixture.verify_on_setup()

        vn_obj = self.newvn_fixture.obj
        self.vm4_fixture = self.useFixture(
            VMFixture(connections=self.connections,
                      vn_obj=vn_obj,
                      vm_name=vm4_name,
                      project_name=self.inputs.project_name))
        assert self.vm4_fixture.verify_on_setup()

        vn_obj = self.newvn11_fixture.obj
        self.vm5_fixture = self.useFixture(
            VMFixture(connections=self.connections,
                      vn_obj=vn_obj,
                      vm_name=vm5_name,
                      project_name=self.inputs.project_name))
        assert self.vm5_fixture.verify_on_setup()

        return True
Esempio n. 9
0
    def create_2_legs(self):

        vn1_name = get_random_name('bgpaas_vn')
        vn1_subnets = [get_random_cidr()]
        vn1_fixture = self.create_vn(vn1_name, vn1_subnets)
        test_vm = self.create_vm(vn1_fixture,
                                 'test_vm',
                                 image_name='ubuntu-traffic')
        assert test_vm.wait_till_vm_is_up()
        vn2_name = get_random_name('bgpaas_vn')
        vn2_subnets = [get_random_cidr()]
        vn2_fixture = self.create_vn(vn2_name, vn2_subnets)
        bgpaas_vm1 = self.useFixture(
            VMFixture(project_name=self.inputs.project_name,
                      connections=self.connections,
                      vn_objs=[vn1_fixture.obj, vn2_fixture.obj],
                      vm_name='bgpaas_vm1',
                      node_name=None,
                      image_name='vsrx'))

        assert bgpaas_vm1.wait_till_vm_is_up()
        ret_dict = {
            'vn1_fixture': vn1_fixture,
            'vn2_fixture': vn2_fixture,
            'test_vm': test_vm,
            'bgpaas_vm1': bgpaas_vm1,
        }
        return ret_dict
Esempio n. 10
0
 def create_dhcp_server_vm(self,
                           vn1_fixture,
                           vn2_fixture,
                           vm_name=None,
                           node_name=None,
                           flavor='contrail_flavor_large',
                           image_name='ubuntu-dns-server',
                           port_ids=[]):
     if not vm_name:
         vm_name = get_random_name('dhcp-server')
     vm_fixture = self.useFixture(
         VMFixture(project_name=self.inputs.project_name,
                   connections=self.connections,
                   vn_objs=[vn1_fixture.obj, vn2_fixture.obj],
                   vm_name=vm_name,
                   image_name=image_name,
                   flavor=flavor,
                   node_name=node_name,
                   port_ids=port_ids))
     assert vm_fixture.verify_on_setup(), (
         "DHCP Server VM Verification failed ")
     assert vm_fixture.wait_till_vm_is_up()
     vn2_fq_name = vn2_fixture.vn_fq_name
     vm_ip = vm_fixture.vm_ip_dict[vn2_fq_name][0]
     cmds = [
         'ifconfig eth1 up',
         'ifconfig eth1 %s netmask 255.255.255.0' % (vm_ip),
         'service isc-dhcp-server restart'
     ]
     vm_fixture.run_cmd_on_vm(cmds, as_sudo=True)
     self.sleep(5)
     return vm_fixture
Esempio n. 11
0
 def create_only_vm(cls, vn_fixture=None, vm_name=None,
               image_name='ubuntu-traffic', **kwargs):
     vn_obj = None
     if vn_fixture:
         vn_obj = vn_fixture.obj
     project_name = kwargs.pop('project_name', None) or cls.connections.project_name
     connections = kwargs.pop('connections', None) or cls.connections
     vm_obj = VMFixture(
                 connections,
                 project_name=project_name,
                 vn_obj=vn_obj,
                 vm_name=vm_name,
                 image_name=image_name,
                 **kwargs)
     vm_obj.setUp()
     return vm_obj
Esempio n. 12
0
    def create_vn(self):
        #Script has run till now with the same name and subnets. Lets change it!
        self.vn1_name = "test_DM_v4_only"
        self.vn1_net = ['12.6.2.0/24']
        #router external tag will cause DM ip allocation problem. Changing it to false
        self.vn1_fixture = self.useFixture(
            VNFixture(project_name=self.inputs.project_name,
                      connections=self.connections,
                      vn_name=self.vn1_name,
                      inputs=self.inputs,
                      subnets=self.vn1_net,
                      router_external=False,
                      shared=False))
        #assert self.vn1_fixture.verify_on_setup()
        self.add_RT_basic_traffic()

        self.vn2_name = "test_DM_dual_stack"
        self.vn2_net = ['2001::101:0/120']
        self.vn2_fixture = self.useFixture(
            VNFixture(project_name=self.inputs.project_name,
                      connections=self.connections,
                      vn_name=self.vn2_name,
                      inputs=self.inputs,
                      subnets=self.vn2_net))
        #assert self.vn2_fixture.verify_on_setup()

        self.vm1_fixture = self.useFixture(
            VMFixture(project_name=self.inputs.project_name,
                      connections=self.connections,
                      vn_obj=self.vn1_fixture.obj,
                      vm_name='sender',
                      node_name=None,
                      image_name='cirros',
                      flavor='m1.tiny'))
Esempio n. 13
0
    def create_vn(self):
        self.vn1_name = "test_vn"
        self.vn1_net = ['1.1.1.0/24']
        self.vn1_fixture = self.useFixture(
            VNFixture(project_name=self.inputs.project_name,
                      connections=self.connections,
                      vn_name=self.vn1_name,
                      inputs=self.inputs,
                      subnets=self.vn1_net,
                      router_external=True))
        #assert self.vn1_fixture.verify_on_setup()
        self.add_RT_basic_traffic()

        self.vn2_name = "test_v6"
        self.vn2_net = ['2001::101:0/120']
        self.vn2_fixture = self.useFixture(
            VNFixture(project_name=self.inputs.project_name,
                      connections=self.connections,
                      vn_name=self.vn2_name,
                      inputs=self.inputs,
                      subnets=self.vn2_net))
        #assert self.vn2_fixture.verify_on_setup()

        self.vm1_fixture = self.useFixture(
            VMFixture(project_name=self.inputs.project_name,
                      connections=self.connections,
                      vn_obj=self.vn1_fixture.obj,
                      vm_name='sender',
                      node_name=None,
                      image_name='cirros',
                      flavor='m1.tiny'))
Esempio n. 14
0
 def config_pt_svm(self,
                   stack_name,
                   si_fqdn,
                   vn_list,
                   intf_rt_table_fqdn=''):
     template = self.get_template(stack_name)
     env = self.get_env(stack_name)
     env['parameters']['si_fqdn'] = si_fqdn
     env['parameters']['svm_name'] = get_random_name('svm')
     env['parameters']['right_net_id'] = vn_list[2].vn_fq_name
     env['parameters']['left_net_id'] = vn_list[1].vn_fq_name
     env['parameters']['mgmt_net_id'] = vn_list[0].vn_fq_name
     env['parameters']['intf_rt_table_fqdn'] = intf_rt_table_fqdn
     env['parameters']['def_sg_id'] = (':').join(
         self.project_fq_name) + ':default'
     if 'image' in env['parameters']:
         self.nova_h.get_image(env['parameters']['image'])
     vn_obj_list = []
     for vn in vn_list:
         vn_obj_list.append(vn.obj)
     stack_name = get_random_name(stack_name)
     pt_svm_hs_obj = self.config_heat_obj(stack_name, template, env)
     pt_svm_fix = self.useFixture(
         VMFixture(project_name=self.inputs.project_name,
                   vn_objs=vn_obj_list,
                   vm_name=str(env['parameters']['svm_name']),
                   connections=self.connections))
     pt_svm_fix.wait_for_ssh_on_vm()
     return pt_svm_hs_obj, pt_svm_fix
Esempio n. 15
0
 def create_vm(self, vn_fixture, image_name='ubuntu', *args, **kwargs):
     return self.useFixture(
         VMFixture(project_name=self.inputs.project_name,
                   connections=self.connections,
                   vn_obj=vn_fixture.obj,
                   image_name=image_name,
                   *args,
                   **kwargs))
Esempio n. 16
0
 def svm_list(self):
     vms = getattr(self, '_svm_list', [])
     if not vms or len(vms) != len(self.svm_ids):
         # Reduce the svm_list to take care of reduce in ecmp instances
         self._svm_list = [
             vm for vm in vms if vm.get_uuid() in self.svm_ids
         ]
         self.svms = {
             k: v
             for k, v in self.svms.items() if k in self.svm_ids
         }
         # Increase the svm_list to take care of increase in ecmp instances
         for vmid in set(self.svm_ids) - set(
             [vm.get_uuid() for vm in self._svm_list]):
             vm = VMFixture(self.connections, uuid=vmid)
             vm.setUp()
             vm.wait_till_vm_is_active()
             # Populate tap intf details on the VM objects
             # Faster than calling wait_till_vm_is_up()
             if not vm.verify_vm_in_agent():
                 self.logger.error('VM %s not found in vrouter agent' %
                                   (vmid))
             self._svm_list.append(vm)
             self.svms[vmid] = vm
     return self._svm_list
Esempio n. 17
0
 def verify_vms(self, stack, vn_list, stack_name):
     op = stack.stacks.get(stack_name).outputs
     time.sleep(5)
     vm1_fix = self.useFixture(VMFixture(project_name=self.inputs.project_name,
                                         vn_obj=vn_list[0].obj, vm_name='left_vm', connections=self.connections))
     vm2_fix = self.useFixture(VMFixture(project_name=self.inputs.project_name,
                                         vn_obj=vn_list[1].obj, vm_name='right_vm', connections=self.connections))
     assert vm1_fix.wait_till_vm_is_up()
     assert vm2_fix.wait_till_vm_is_up()
     for output in op:
         if output['output_value'] == vm1_fix.vm_ip:
             self.logger.info(
                 'VM %s launched successfully' % vm1_fix.vm_name)
         elif output['output_value'] == vm2_fix.vm_ip:
             self.logger.info(
                 'VM %s launched successfully' % vm2_fix.vm_name)
     vms_list = [vm1_fix, vm2_fix]
     return vms_list
Esempio n. 18
0
 def create_only_vm(cls,
                    vn_fixture,
                    vm_name=None,
                    node_name=None,
                    flavor='contrail_flavor_small',
                    image_name='ubuntu-traffic',
                    port_ids=[]):
     if not vm_name:
         vm_name = 'vm-%s' % (get_random_name(vn_fixture.vn_name))
     vm_obj = VMFixture(project_name=cls.inputs.project_name,
                        connections=cls.connections,
                        vn_obj=vn_fixture.obj,
                        vm_name=vm_name,
                        image_name=image_name,
                        flavor=flavor,
                        node_name=node_name,
                        port_ids=port_ids)
     vm_obj.setUp()
     return vm_obj
Esempio n. 19
0
 def add_multiple_vns(self):
     self.vn3_name = "test_vn3"
     self.vn3_net = ['2.1.1.0/24']
     self.vn3_fixture = self.useFixture(VNFixture(
         project_name=self.inputs.project_name, connections=self.connections,
         vn_name=self.vn3_name, inputs=self.inputs, subnets=self.vn3_net, router_external=True))
     assert self.vn3_fixture.verify_on_setup()
     self.vm3_fixture = self.useFixture(VMFixture(
         project_name=self.inputs.project_name, connections=self.connections,
         vn_obj=self.vn3_fixture.obj, vm_name='receiver', node_name=None,
         image_name='cirros', flavor='m1.tiny'))
Esempio n. 20
0
 def create_vm(self, vn_fixture, vm_name, node_name=None,
               flavor='contrail_flavor_small',
               image_name='ubuntu-traffic'):
     return self.useFixture(
         VMFixture(
             project_name=self.inputs.project_name,
             connections=self.connections,
             vn_obj=vn_fixture.obj,
             vm_name=vm_name,
             image_name=image_name,
             flavor=flavor,
             node_name=node_name))
Esempio n. 21
0
 def config_vm(self, vn):
     stack_name = 'single_vm'
     template = self.get_template('single_vm')
     env = self.get_env('single_vm')
     env['parameters']['vm_name'] = get_random_name(
         env['parameters']['vm_name'])
     env['parameters']['net_id'] = vn.vn_id
     vm_hs_obj = self.config_heat_obj(stack_name, template, env)
     vm_fix = self.useFixture(VMFixture(project_name=self.inputs.project_name,
                                        vn_obj=vn.obj, vm_name=str(env['parameters']['vm_name']), connections=self.connections))
     assert vm_fix.wait_till_vm_is_up()
     return vm_hs_obj, vm_fix
Esempio n. 22
0
 def create_only_vm(cls, vn_fixture=None, vm_name=None, node_name=None,
               flavor='contrail_flavor_small',
               image_name='ubuntu-traffic',
               port_ids=[], **kwargs):
     vn_obj = None
     if vn_fixture:
         vn_obj = vn_fixture.obj
     project_name = kwargs.pop('project_name', None) or cls.connections.project_name
     connections = kwargs.pop('connections', None) or cls.connections
     vm_obj = VMFixture(
                 project_name=project_name,
                 connections=connections,
                 vn_obj=vn_obj,
                 vm_name=vm_name,
                 image_name=image_name,
                 flavor=flavor,
                 node_name=node_name,
                 port_ids=port_ids,
                 **kwargs)
     vm_obj.setUp()
     return vm_obj
Esempio n. 23
0
 def config_vm(self, vn):
     stack_name = get_random_name('single_vm')
     template = self.get_template('single_vm')
     env = self.get_env('single_vm')
     env['parameters']['vm_name'] = get_random_name(
         env['parameters']['vm_name'])
     env['parameters']['net_id'] = vn.vn_id
     vm_hs_obj = self.config_heat_obj(stack_name, template, env)
     vm_fix = self.useFixture(VMFixture(project_name=self.inputs.project_name,
                                        vn_obj=vn.obj, vm_name=str(env['parameters']['vm_name']), connections=self.connections))
     # ToDo: Do we really need to wait till the VMs are up, may be move it down where we login to the VM
     assert vm_fix.wait_till_vm_is_up()
     return vm_hs_obj, vm_fix
Esempio n. 24
0
 def create_vm(self, vn_fixture, vm_name, node_name=None,
                 flavor='contrail_flavor_small',
                 image_name='ubuntu-traffic'):
     image_name = os.environ['ci_image'] if os.environ.has_key('ci_image') else 'ubuntu-traffic'
     return self.useFixture(
             VMFixture(
                 project_name=self.inputs.project_name,
                 connections=self.connections,
                 vn_obj=vn_fixture.obj,
                 vm_name=vm_name,
                 image_name=image_name,
                 flavor=flavor,
                 node_name=node_name))
    def setup_vm(self):
        # add VMs to VNs
        self.VM11_fixture = self.useFixture(
            VMFixture(connections=self.connections,
                      vn_obj=self.VN1_fixture.obj,
                      vm_name='VM11',
                      project_name=self.project.project_name))

        self.VM21_fixture = self.useFixture(
            VMFixture(connections=self.connections,
                      vn_obj=self.VN2_fixture.obj,
                      vm_name='VM21',
                      project_name=self.project.project_name))

        self.VM31_fixture = self.useFixture(
            VMFixture(connections=self.connections,
                      vn_obj=self.VN3_fixture.obj,
                      vm_name='VM31',
                      project_name=self.project.project_name))

        self.VM11_fixture.wait_till_vm_is_up()
        self.VM21_fixture.wait_till_vm_is_up()
        self.VM31_fixture.wait_till_vm_is_up()
 def svm_list(self):
     if not getattr(self, '_svm_list', None):
         self._svm_list = []
         for vmid in self.svm_ids:
             vm = VMFixture(self.connections, uuid=vmid)
             vm.setUp()
             vm.wait_till_vm_is_active()
             self._svm_list.append(vm)
     return self._svm_list
Esempio n. 27
0
    def config_basic(self, vm2=False):
        self.vn1_fixture = self.create_vn(disable_dns=True)
        self.vn2_fixture = self.create_vn(disable_dns=True)
        self.vn1_name = self.vn1_fixture.vn_name
        self.vn2_name = self.vn2_fixture.vn_name
        self.left_vm_fixture = self.create_vm(self.vn1_fixture)
        self.right_vm_fixture = self.create_vm(self.vn2_fixture)
        self.left_vm_fixture.wait_till_vm_is_up()
        self.right_vm_fixture.wait_till_vm_is_up()

        vm1_name = 'middle_vm1'

        self.vm1_fixture = self.useFixture(
            VMFixture(project_name=self.inputs.project_name,
                      connections=self.connections,
                      vn_objs=[self.vn1_fixture.obj, self.vn2_fixture.obj],
                      vm_name=vm1_name,
                      node_name=None,
                      image_name='ubuntu',
                      flavor='m1.tiny'))
        self.vm1_fixture.wait_till_vm_is_up()
        cmd = 'echo 1 > /proc/sys/net/ipv4/ip_forward'
        self.vm1_fixture.run_cmd_on_vm(cmds=[cmd], as_sudo=True)
        vm2_name = 'middle_vm2'
        if vm2:
            self.vm2_fixture = self.useFixture(
                VMFixture(project_name=self.inputs.project_name,
                          connections=self.connections,
                          vn_objs=[self.vn1_fixture.obj, self.vn2_fixture.obj],
                          vm_name=vm2_name,
                          node_name=None,
                          image_name='ubuntu',
                          flavor='m1.tiny'))
            self.vm2_fixture.wait_till_vm_is_up()
            cmd = 'echo 1 > /proc/sys/net/ipv4/ip_forward'
            self.vm2_fixture.run_cmd_on_vm(cmds=[cmd], as_sudo=True)
Esempio n. 28
0
 def create_vm(self, vn_fixture, vm_name, node_name=None,
                 flavor='contrail_flavor_small',
                 image_name='ubuntu',
                 *args, **kwargs):
     image_name = self.inputs.get_ci_image() or image_name
     return self.useFixture(
             VMFixture(
                 project_name=self.inputs.project_name,
                 connections=self.connections,
                 vn_obj=vn_fixture.obj,
                 vm_name=vm_name,
                 image_name=image_name,
                 flavor=flavor,
                 node_name=node_name,
                 *args, **kwargs))
Esempio n. 29
0
 def config_vm(self,
               vn_fix,
               vm_name,
               node_name=None,
               image_name='ubuntu-traffic',
               flavor='contrail_flavor_small'):
     vm_fixture = self.useFixture(
         VMFixture(project_name=self.inputs.project_name,
                   connections=self.connections,
                   vn_obj=vn_fix.obj,
                   vm_name=vm_name,
                   node_name=node_name,
                   image_name=image_name,
                   flavor=flavor))
     return vm_fixture
Esempio n. 30
0
 def create_vm(self,
               vn_fixture,
               vm_name=None,
               node_name=None,
               flavor='contrail_flavor_small',
               image_name='ubuntu-traffic',
               port_ids=[]):
     if not vm_name:
         vm_name = 'vm-%s' % (get_random_name(vn_fixture.vn_name))
     return self.useFixture(
         VMFixture(project_name=self.inputs.project_name,
                   connections=self.connections,
                   vn_obj=vn_fixture.obj,
                   vm_name=vm_name,
                   image_name=image_name,
                   flavor=flavor,
                   node_name=node_name,
                   port_ids=port_ids))
Esempio n. 31
0
 def setUp(self):
     super(VPCVMFixture, self).setUp()
     try:
         f = '/tmp/key%s'%self.inputs.stack_user
         lock = Lock(f)
         lock.acquire()
         self._create_keypair(self.key)
     finally:
         lock.release()
     self.create_vm()
     # Build up data structure for std VM verification to happen
     # Note that this Fixture does not create a VM if it is already present
     if self.vm_name:
         self.c_vm_fixture = self.useFixture(VMFixture(
             project_name=self.vpc_id,
             connections=self.connections,
             image_name=self.image_name,
             vn_obj=self.vn_obj,
             vm_name=self.vm_name,
             sg_ids=self.sg_ids))
 def svm_list(self):
     vms = getattr(self, '_svm_list', [])
     if not vms or len(vms) != len(self.svm_ids):
         # Reduce the svm_list to take care of reduce in ecmp instances
         self._svm_list = [
             vm for vm in vms if vm.get_uuid() in self.svm_ids
         ]
         # Increase the svm_list to take care of increase in ecmp instances
         for vmid in set(self.svm_ids) - set(
             [vm.get_uuid() for vm in self._svm_list]):
             vm = VMFixture(self.connections, uuid=vmid)
             vm.setUp()
             vm.wait_till_vm_is_active()
             self._svm_list.append(vm)
     return self._svm_list
Esempio n. 33
0
 def verify_si(self, stack, stack_name, si_name, st_fix, max_inst, svc_mode, image):
     svc_inst = self.useFixture(SvcInstanceFixture(
         connections=self.connections, inputs=self.inputs,
         domain_name='default-domain', project_name=self.inputs.project_name, si_name=si_name,
         svc_template=st_fix.st_obj, if_list=st_fix.if_list))
     assert svc_inst.verify_on_setup()
     if self.pt_based_svc:
         op = stack.stacks.get(stack_name).outputs
         for output in op:
             if output['output_key'] == 'svm_id':
                 svm_id = output['output_value']
         vm = VMFixture(self.connections, uuid=svm_id)
         vm.setUp()
         vm.verify_on_setup()
         image='ubuntu-in-net'
         (vm.vm_username, vm.vm_password) = vm.orch.get_image_account(image)
         svc_inst._svm_list.append(vm)
         if self.inputs.get_af() == 'v6':
             vm.run_cmd_on_vm(['dhclient -6 -pf /var/run/dhclient6.eth0.pid -lf /var/lib/dhcp/dhclient6.eth0.leases',
                               'dhclient -6 -pf /var/run/dhclient6.eth1.pid -lf /var/lib/dhcp/dhclient6.eth1.leases'], as_sudo=True)
     return svc_inst
Esempio n. 34
0
 def verify_si(self, stack, stack_name, si_name, st_fix, max_inst, svc_mode, image):
     svc_inst = self.useFixture(SvcInstanceFixture(
         connections=self.connections, inputs=self.inputs,
         domain_name='default-domain', project_name=self.inputs.project_name, si_name=si_name,
         svc_template=st_fix.st_obj, if_list=st_fix.if_list))
     assert svc_inst.verify_on_setup()
     if self.pt_based_svc:
         op = stack.stacks.get(stack_name).outputs
         for output in op:
             if output['output_key'] == 'svm_id':
                 svm_id = output['output_value']
         vm = VMFixture(self.connections, uuid=svm_id)
         vm.setUp()
         vm.verify_on_setup()
         image='tiny-in-net'
         (vm.vm_username, vm.vm_password) = vm.orch.get_image_account(image)
         svc_inst._svm_list.append(vm)
     return svc_inst
 def svm_list(self):
     vms = getattr(self, '_svm_list', [])
     if not vms or len(vms) != len(self.svm_ids):
         # Reduce the svm_list to take care of reduce in ecmp instances
         self._svm_list = [vm for vm in vms if vm.get_uuid() in self.svm_ids]
         self.svms = {k:v for k,v in self.svms.items() if k in self.svm_ids}
         # Increase the svm_list to take care of increase in ecmp instances
         for vmid in set(self.svm_ids) - set([vm.get_uuid() for vm in self._svm_list]):
             vm = VMFixture(self.connections, uuid=vmid)
             vm.setUp()
             vm.wait_till_vm_is_active()
             # Populate tap intf details on the VM objects
             # Faster than calling wait_till_vm_is_up()
             if not vm.verify_vm_in_agent():
                 self.logger.error('VM %s not found in vrouter agent' %(
                     vmid))
             self._svm_list.append(vm)
             self.svms[vmid] = vm
     return self._svm_list
Esempio n. 36
0
    def test_policy_protocol_summary(self):
        ''' Test to validate that when policy is created with multiple rules that can be summarized by protocol

        '''
        proj_name = self.inputs.project_name
        vn1_name = 'vn40'
        vn1_subnets = ['10.1.1.0/24']
        policy1_name = 'policy1'
        policy2_name = 'policy2'

        rules2 = [
            {
                'direction': '<>',
                'simple_action': 'pass',
                'protocol': 'any',
                'source_network': vn1_name,
                'dest_network': vn1_name,
            },
            {
                'direction': '<>',
                'simple_action': 'pass',
                'protocol': 'icmp',
                'source_network': vn1_name,
                'dest_network': vn1_name,
            },
        ]
        rules1 = [
            {
                'direction': '<>',
                'simple_action': 'pass',
                'protocol': 'any',
                'source_network': vn1_name,
                'dest_network': vn1_name,
            },
        ]
        policy1_fixture = self.useFixture(
            PolicyFixture(policy_name=policy1_name,
                          rules_list=rules1,
                          inputs=self.inputs,
                          connections=self.connections))
        policy2_fixture = self.useFixture(
            PolicyFixture(policy_name=policy2_name,
                          rules_list=rules2,
                          inputs=self.inputs,
                          connections=self.connections))

        vn1_fixture = self.useFixture(
            VNFixture(project_name=self.inputs.project_name,
                      connections=self.connections,
                      vn_name=vn1_name,
                      inputs=self.inputs,
                      subnets=vn1_subnets,
                      policy_objs=[policy1_fixture.policy_obj]))
        assert vn1_fixture.verify_on_setup()

        vn1_vm1_name = 'vm1'
        vm1_fixture = self.useFixture(
            VMFixture(project_name=self.inputs.project_name,
                      connections=self.connections,
                      vn_obj=vn1_fixture.obj,
                      vm_name=vn1_vm1_name))
        assert vm1_fixture.verify_on_setup()

        inspect_h = self.agent_inspect[vm1_fixture.vm_node_ip]
        vn_fq_name = inspect_h.get_vna_vn(domain='default-domain',
                                          project=proj_name,
                                          vn_name=vn1_name)['name']

        vna_acl1 = inspect_h.get_vna_acl_by_vn(vn_fq_name)

        policy1_fixture.verify_policy_in_api_server()

        if vn1_fixture.policy_objs:
            policy_fq_names = [
                self.quantum_h.get_policy_fq_name(x)
                for x in vn1_fixture.policy_objs
            ]

        policy_fq_name2 = self.quantum_h.get_policy_fq_name(
            policy2_fixture.policy_obj)
        policy_fq_names.append(policy_fq_name2)
        vn1_fixture.bind_policies(policy_fq_names, vn1_fixture.vn_id)

        vna_acl2 = inspect_h.get_vna_acl_by_vn(vn_fq_name)
        out = policy_test_utils.compare_args('policy_rules',
                                             vna_acl1['entries'],
                                             vna_acl2['entries'])

        if out:
            self.logger.info(
                "policy rules are not matching with expected %s  and actual %s"
                % (vna_acl1['entries'], vna_acl2['entries']))
            self.assertIsNone(out, "policy compare failed")

        return True
Esempio n. 37
0
 def test_policy_with_multi_vn_in_vm(self):
     ''' Test to validate policy action in VM with vnic's in  multiple VN's with different policies.
     Test flow: vm1 in vn1 and vn2; vm3 in vn3. policy to allow traffic from vn2 to vn3 and deny from vn1 to vn3.
     Default route for vm1 in vn1, which has no reachability to vn3 - verify traffic - should fail.
     Add specific route to direct vn3 traffic through vn2 - verify traffic - should pass.
     '''
     vm1_name = 'vm_mine1'
     vm2_name = 'vm_mine2'
     vn1_name = 'vn221'
     vn1_subnets = ['11.1.1.0/24']
     vn2_name = 'vn222'
     vn2_subnets = ['22.1.1.0/24']
     vn3_gateway = '22.1.1.254'
     vn3_name = 'vn223'
     vn3_subnets = ['33.1.1.0/24']
     rules1 = [
         {
             'direction': '>',
             'simple_action': 'deny',
             'protocol': 'icmp',
             'src_ports': 'any',
             'dst_ports': 'any',
             'source_network': 'any',
             'dest_network': 'any',
         },
     ]
     rules2 = [
         {
             'direction': '<>',
             'simple_action': 'pass',
             'protocol': 'any',
             'src_ports': 'any',
             'dst_ports': 'any',
             'source_network': 'any',
             'dest_network': 'any',
         },
     ]
     policy1_name = 'p1'
     policy2_name = 'p2'
     policy1_fixture = self.useFixture(
         PolicyFixture(policy_name=policy1_name,
                       rules_list=rules1,
                       inputs=self.inputs,
                       connections=self.connections))
     policy2_fixture = self.useFixture(
         PolicyFixture(policy_name=policy2_name,
                       rules_list=rules2,
                       inputs=self.inputs,
                       connections=self.connections))
     vn1_fixture = self.useFixture(
         VNFixture(project_name=self.inputs.project_name,
                   connections=self.connections,
                   vn_name=vn1_name,
                   inputs=self.inputs,
                   subnets=vn1_subnets,
                   policy_objs=[policy1_fixture.policy_obj]))
     vn2_fixture = self.useFixture(
         VNFixture(project_name=self.inputs.project_name,
                   connections=self.connections,
                   vn_name=vn2_name,
                   inputs=self.inputs,
                   subnets=vn2_subnets,
                   disable_gateway=True,
                   policy_objs=[policy2_fixture.policy_obj]))
     vn3_fixture = self.useFixture(
         VNFixture(project_name=self.inputs.project_name,
                   connections=self.connections,
                   vn_name=vn3_name,
                   inputs=self.inputs,
                   subnets=vn3_subnets,
                   policy_objs=[policy2_fixture.policy_obj]))
     assert vn1_fixture.verify_on_setup()
     assert vn2_fixture.verify_on_setup()
     assert vn3_fixture.verify_on_setup()
     assert vn1_fixture.verify_vn_policy_in_api_server()
     assert vn2_fixture.verify_vn_policy_in_api_server()
     assert vn3_fixture.verify_vn_policy_in_api_server()
     vm1_fixture = self.useFixture(
         VMFixture(connections=self.connections,
                   vn_objs=[vn1_fixture.obj, vn2_fixture.obj],
                   vm_name=vm1_name,
                   project_name=self.inputs.project_name))
     vm2_fixture = self.useFixture(
         VMFixture(connections=self.connections,
                   vn_objs=[vn3_fixture.obj],
                   vm_name=vm2_name,
                   project_name=self.inputs.project_name))
     assert vm1_fixture.verify_on_setup()
     assert vm2_fixture.verify_on_setup()
     self.nova_h.wait_till_vm_is_up(vm1_fixture.vm_obj)
     self.nova_h.wait_till_vm_is_up(vm2_fixture.vm_obj)
     # For multi-vn vm, configure ip address for 2nd interface
     multivn_vm_ip_list = vm1_fixture.vm_ips
     intf_conf_cmd = "ifconfig eth1 %s netmask 255.255.255.0" % multivn_vm_ip_list[
         1]
     vm_cmds = (intf_conf_cmd, 'ifconfig -a')
     for cmd in vm_cmds:
         cmd_to_output = [cmd]
         vm1_fixture.run_cmd_on_vm(cmds=cmd_to_output, as_sudo=True)
         output = vm1_fixture.return_output_cmd_dict[cmd]
     for ip in multivn_vm_ip_list:
         if ip not in output:
             self.logger.error("IP %s not assigned to any eth intf of %s" %
                               (ip, vm1_fixture.vm_name))
             assert False
     # Ping test from multi-vn vm to peer vn, result will be based on action
     # defined in policy attached to VN which has the default gw of VM
     self.logger.info(
         "Ping from multi-vn vm to vm2, with no allow rule in the VN where default gw is part of, traffic should fail"
     )
     result = vm1_fixture.ping_with_certainty(vm2_fixture.vm_ip,
                                              expectation=False)
     assertEqual(result, True, "ping passed which is not expected")
     # Configure VM to reroute traffic to interface belonging to different
     # VN
     self.logger.info(
         "Direct traffic to gw which is part of VN with allow policy to destination VN, traffic should pass now"
     )
     i = ' route add -net %s netmask 255.255.255.0 gw %s dev eth1' % (
         vn3_subnets[0].split('/')[0], multivn_vm_ip_list[1])
     cmd_to_output = [i]
     vm1_fixture.run_cmd_on_vm(cmds=cmd_to_output, as_sudo=True)
     output = vm1_fixture.return_output_cmd_dict[i]
     # Ping test from multi-vn vm to peer vn, result will be based on action
     # defined in policy attached to VN which has the default gw for VM
     self.logger.info(
         "Ping from multi-vn vm to vm2, with allow rule in the VN where network gw is part of, traffic should pass"
     )
     result = vm1_fixture.ping_with_certainty(vm2_fixture.vm_ip,
                                              expectation=True)
     assertEqual(result, True, "ping failed which is not expected")
     return True
Esempio n. 38
0
if __name__ == "__main__":
    import sys
    from vn_test import VNFixture
    from vm_test import VMFixture
#    sys.settrace(tracefunc)
#    obj = LBaasFixture(api_type='neutron', name='LB', connections=setup_test_infra(), network_id='4b39a2bd-4528-40e8-b848-28084e59c944', members={'vms': ['a72ad607-f1ca-44f2-b31e-e825a3f2d408'], 'address': ['192.168.1.10']}, vip_net_id='4b39a2bd-4528-40e8-b848-28084e59c944', protocol='TCP', port='22', healthmonitors=[{'delay':5, 'timeout':5, 'max_retries':5, 'probe_type':'PING'}])
    conn = setup_test_infra()
    vnfix = VNFixture(connections=conn)
    vnfix.setUp()
    vip_fix = VNFixture(connections=conn)
    vip_fix.setUp()
    fip_fix = VNFixture(connections=conn, router_external=True)
    fip_fix.setUp()
    subnet = vnfix.get_cidrs()[0]
    vm_fix = VMFixture(connections=conn, vn_obj=vnfix.obj)
    vm_fix.setUp()
    obj = LBaasFixture(api_type='neutron', name='LB', connections=conn, network_id=vnfix.uuid,
                       members={'address': [get_random_ip(subnet)], 'vms': [vm_fix.vm_id]},
                       vip_net_id=vip_fix.uuid, fip_net_id=fip_fix.uuid, protocol='TCP', port='22',
                       healthmonitors=[{'delay':5, 'timeout':5, 'max_retries':5, 'probe_type':'PING'}],
                       custom_attr={'max_conn': 100, 'max_sess_rate': 20, 'server_timeout': 50000, 'rate_limit_sessions': 10, 'http_server_close': "True"})
    obj.setUp()
#    obj = LBaasFixture(api_type='neutron', uuid='58e5fb2c-ec47-4eb8-b4bf-9c66b0473f78', connections=setup_test_infra())
    obj.verify_on_setup()
    obj.delete_custom_attr('max_sess_rate')
    obj.add_custom_attr('client_timeout', 20000)
    obj.delete_custom_attr('server_timeout')
    obj.add_custom_attr('max_sess_rate', 20000)
    obj.delete_custom_attr('rate_limit_sessions')
    obj.add_custom_attr('rate_limit_sessions', 20)
Esempio n. 39
0
    def config_v2_svc_chain(self, stack_name):
        template = self.get_template(template_name=stack_name)
        env = self.get_env(env_name=stack_name)
        stack_name = get_random_name(stack_name)
        self.nova_h.get_image(env['parameters']['image'])
        self.nova_h.get_flavor(env['parameters']['flavor'])
        svc_pt_hs = self.config_heat_obj(stack_name, template, env)
        stack = svc_pt_hs.heat_client_obj
        op = stack.stacks.get(stack_name).outputs
        time.sleep(5)
        for output in op:
            if output['output_key'] == 'left_VM_ID':
                left_vm_id = output['output_value']
            elif output['output_key'] == 'left_VM1_ID':
                left_vm1_id = output['output_value']
            elif output['output_key'] == 'left_VM2_ID':
                left_vm2_id = output['output_value']
            elif output['output_key'] == 'right_VM_ID':
                right_vm_id = output['output_value']
            elif output['output_key'] == 'right_VM1_ID':
                right_vm1_id = output['output_value']
            elif output['output_key'] == 'right_VM2_ID':
                right_vm2_id = output['output_value']
            elif output['output_key'] == 'left_vn_FQDN':
                left_vn_fqdn = output['output_value']
            elif output['output_key'] == 'right_vn_FQDN':
                right_vn_fqdn = output['output_value']
            elif output['output_key'] == 'si_fqdn':
                si_fqdn = output['output_value']
            elif output['output_key'] == 'si2_fqdn':
                si2_fqdn = output['output_value']
                si2_fqdn=":".join(si2_fqdn)
            elif output['output_key'] == 'left_VM1_IP_ADDRESS':
                left_vm1_ip_address = output['output_value']
                network_policy_entries_policy_rule_src_addresses_subnet_ip_prefix = left_vm1_ip_address
                network_policy_entries_policy_rule_src_addresses_subnet_ip_prefix_len = "32"
            elif output['output_key'] == 'right_VM1_IP_ADDRESS':
                right_vm1_ip_address = output['output_value']
                network_policy_entries_policy_rule_dst_addresses_subnet_ip_prefix = right_vm1_ip_address
                network_policy_entries_policy_rule_dst_addresses_subnet_ip_prefix_len = "32"

        #Update the policy
        si_fqdn=":".join(si_fqdn)
        left_vn_fqdn=":".join(left_vn_fqdn)
        right_vn_fqdn=":".join(right_vn_fqdn)
        if 'multi' in stack_name:
            self.update_stack(svc_pt_hs, change_sets=[['left_vn_fqdn', left_vn_fqdn], ['right_vn_fqdn', right_vn_fqdn], ['service_instance1_fq_name', si_fqdn], ['service_instance2_fq_name', si2_fqdn]])
        else:
            if 'cidr' in stack_name:
                if 'src_cidr' in stack_name:
                    self.update_stack(svc_pt_hs, change_sets=[['left_vn_fqdn', left_vn_fqdn], ['right_vn_fqdn', right_vn_fqdn], ['service_instance_fq_name', si_fqdn], ['network_policy_entries_policy_rule_src_addresses_subnet_ip_prefix', network_policy_entries_policy_rule_src_addresses_subnet_ip_prefix], ['network_policy_entries_policy_rule_src_addresses_subnet_ip_prefix_len', network_policy_entries_policy_rule_src_addresses_subnet_ip_prefix_len]])
            else:
                self.update_stack(svc_pt_hs, change_sets=[['left_vn_fqdn', left_vn_fqdn], ['right_vn_fqdn', right_vn_fqdn], ['service_instance_fq_name', si_fqdn]])
        if 'cidr' in stack_name:
                if 'src_cidr' in stack_name:
                    # 2 VMs in the left_vn
                    left_vm1 = VMFixture(connections=self.connections,uuid = left_vm1_id, image_name = 'cirros')
                    left_vm1.read()
                    left_vm1.verify_on_setup()

                    left_vm2 = VMFixture(connections=self.connections,uuid = left_vm2_id, image_name = 'cirros')
                    left_vm2.read()
                    left_vm2.verify_on_setup()

                    # One VM in the right_vn
                    right_vm = VMFixture(connections=self.connections,uuid = right_vm_id, image_name = 'cirros')
                    right_vm.read()
                    right_vm.verify_on_setup()

                    # Ping from left_vm1 to right_vm should pass
                    assert left_vm1.ping_with_certainty(right_vm.vm_ip, expectation=True)

                    # Ping from left_vm2 to right_vm should fail
                    assert left_vm2.ping_with_certainty(right_vm.vm_ip, expectation=False)
        else:
            left_vm = VMFixture(connections=self.connections,uuid = left_vm_id, image_name = 'cirros')
            left_vm.read()
            left_vm.verify_on_setup()
            right_vm = VMFixture(connections=self.connections,uuid = right_vm_id, image_name = 'cirros')
            right_vm.read()
            right_vm.verify_on_setup()
            assert left_vm.ping_with_certainty(right_vm.vm_ip, expectation=True)
Esempio n. 40
0
 def config_v2_svc_chain(self, stack_name):
     svc_pt_hs = self.config_heat_obj(stack_name)
     stack = svc_pt_hs.heat_client_obj
     op = stack.stacks.get(stack_name).outputs
     time.sleep(5) 
     for output in op:
         if output['output_key'] == 'left_VM_ID':
             left_vm_id = output['output_value']
         elif output['output_key'] == 'right_VM_ID': 
             right_vm_id = output['output_value']
         elif output['output_key'] == 'left_vn_FQDN': 
             left_vn_fqdn = output['output_value']
         elif output['output_key'] == 'right_vn_FQDN': 
             right_vn_fqdn = output['output_value']
         elif output['output_key'] == 'si_fqdn': 
             si_fqdn = output['output_value']
         elif output['output_key'] == 'si2_fqdn': 
             si2_fqdn = output['output_value']
             si2_fqdn=":".join(si2_fqdn)
     #Update the policy
     si_fqdn=":".join(si_fqdn)
     left_vn_fqdn=":".join(left_vn_fqdn)
     right_vn_fqdn=":".join(right_vn_fqdn)
     if 'multi' in stack_name:
         self.update_stack(svc_pt_hs, change_sets=[['left_vn_fqdn', left_vn_fqdn], ['right_vn_fqdn', right_vn_fqdn], ['service_instance1_fq_name', si_fqdn], ['service_instance2_fq_name', si2_fqdn]])
     else:
         self.update_stack(svc_pt_hs, change_sets=[['left_vn_fqdn', left_vn_fqdn], ['right_vn_fqdn', right_vn_fqdn], ['service_instance_fq_name', si_fqdn]])
     left_vm = VMFixture(connections=self.connections,uuid = left_vm_id, image_name = 'cirros-0.3.0-x86_64-uec')
     left_vm.read()
     left_vm.verify_on_setup()
     right_vm = VMFixture(connections=self.connections,uuid = right_vm_id, image_name = 'cirros-0.3.0-x86_64-uec')
     right_vm.read()
     right_vm.verify_on_setup()
     assert left_vm.ping_with_certainty(right_vm.vm_ip, expectation=True)