Esempio n. 1
0
    def __init__(self,params):

      self.gbpaci = Gbp_Aci()
      self.heat_stack_name = 'gbpapic1'
      cntlr_ip = params['cntlr_ip']
      self.heat_temp_test = params['heat_temp_file']
      self.gbpheat = gbpHeat(cntlr_ip)
      self.gbpnova = gbpNova(cntlr_ip)
      self.leaf_ip = params['leaf1_ip']
      self.apic_ip = params['apic_ip']
      self.network_node = params['network_node']
      self.az_comp_node = params['az_comp_node']
      self.nova_agg = params['nova_agg']
      self.nova_az = params['nova_az']
      self.debug = params['pausetodebug']
    def __init__(self, params):

        self.gbpaci = Gbp_Aci()
        self.heat_stack_name = 'gbpleaf1'
        cntlr_ip = params['cntlr_ip']
        self.heat_temp_test = params['heat_temp_file']
        self.gbpheat = gbpHeat(cntlr_ip)
        self.gbpnova = gbpNova(cntlr_ip)
        self.leaf_ip = params['leaf1_ip']
        self.apic_ip = params['apic_ip']
        self.network_node = params['network_node']
        self.az_comp_node = params['az_comp_node']
        self.nova_agg = params['nova_agg']
        self.nova_az = params['nova_az']
        self.leaf_port_comp_node1 = params[
            'leaf1_port1']  #This connects Leaf to Comp-node1
        self.node_id = params['leaf1_node_id']
    def __init__(self, params):

        self.gbpcfg = gbpCfgCli()
        self.gbpverify = Gbp_Verify()
        self.gbpdeftraff = Gbp_def_traff()
        self.gbpaci = Gbp_Aci()
        self.heat_stack_name = 'gbpapic3'
        self.cntlr_ip = params['cntlr_ip']
        self.heat_temp_test = params['heat_temp_file']
        self.gbpheat = gbpHeat(self.cntlr_ip)
        self.gbpnova = gbpNova(self.cntlr_ip)
        self.leaf_ip = params['leaf1_ip']
        self.apic_ip = params['apic_ip']
        self.network_node = params['network_node']
        self.az_comp_node = params['az_comp_node']
        self.nova_agg = params['nova_agg']
        self.nova_az = params['nova_az']
        self.debug = param['pausetodebug']

        self.test_name = 'DISCONN_APIC_UPDATECFG_RECONN_APIC'
        self._log.info(
            "\nSteps of the TESTCASE_GBP_INTG_APIC_2_DISCONN_APIC_UPDATECFG_RECONN_APIC to be executed\n"
        )
        if self.test_step_SetUpConfig() != 1:
            self._log.info("Test Failed at Step_1 == SetUpConfig")
            self.test_CleanUp()
        if self.test_step_VerifyTraffic() != 1:
            self._log.info("Test Failed at Step_2 == TestVerifyTraffic")
            self.test_CleanUp()
        objs_uuid = self.gbpverify.get_uuid_from_stack(self.heat_temp_test,
                                                       self.heat_stack_name)
        self.ptg_1 = objs_uuid['server_ptg_id']
        self.ptg_2 = objs_uuid['client_ptg_id']
        self.test_1_prs = objs_uuid['demo_ruleset_icmp_id']
        self.test_2_prs = objs_uuid['demo_ruleset_tcp_id']
        self.test_3_prs = objs_uuid['demo_ruleset_udp_id']
        self.test_4_prs = objs_uuid['demo_ruleset_icmp_tcp_id']
        self.test_5_prs = objs_uuid['demo_ruleset_icmp_udp_id']
        self.test_6_prs = objs_uuid['demo_ruleset_tcp_udp_id']
        self.prs_proto = {self.test_1_prs:['icmp'],self.test_2_prs:['tcp'],self.test_3_prs:['udp'],\
                     self.test_4_prs:['icmp','tcp'],self.test_5_prs:['icmp','udp'],self.test_6_prs:['tcp','udp']}
    def __init__(self,params):

      self.gbpaci = Gbp_Aci()
      self.heat_stack_name = 'gbpvpc5'
      cntlr_ip = params['cntlr_ip']
      self.heat_temp_test = params['heat_temp_file']
      self.gbpheat = gbpHeat(cntlr_ip)
      self.gbpnova = gbpNova(cntlr_ip)
      self.apic_ip = params['apic_ip']
      self.az_comp_node = params['az_comp_node']
      self.nova_agg = params['nova_agg']
      self.nova_az = params['nova_az']
      self.network_node = params['network_node']
      self.leaf1_port_comp_node1 = params['leaf1_port1'] #This connects Leaf1 to Comp-node1
      self.leaf1_port_comp_node2 = params['leaf1_port2'] #This connects Leaf1 to Comp-node2
      self.node_id = params['leaf1_node_id']
    def __init__(self,params):

      self.gbpcfg = gbpCfgCli()
      self.gbpverify = Gbp_Verify()
      self.gbpdeftraff = Gbp_def_traff()
      self.gbpaci = Gbp_Aci()
      self.heat_stack_name = 'gbpapic3'
      self.cntlr_ip = params['cntlr_ip']
      self.heat_temp_test = params['heat_temp_file']
      self.gbpheat = gbpHeat(self.cntlr_ip)
      self.gbpnova = gbpNova(self.cntlr_ip)
      self.leaf_ip = params['leaf1_ip']
      self.apic_ip = params['apic_ip']
      self.network_node = params['network_node']
      self.az_comp_node = params['az_comp_node']
      self.nova_agg = params['nova_agg']
      self.nova_az = params['nova_az']
      self.debug = param['pausetodebug']

      self.test_name = 'DISCONN_APIC_UPDATECFG_RECONN_APIC'
      self._log.info("\nSteps of the TESTCASE_GBP_INTG_APIC_2_DISCONN_APIC_UPDATECFG_RECONN_APIC to be executed\n")
      if self.test_step_SetUpConfig()!=1:
           self._log.info("Test Failed at Step_1 == SetUpConfig")
           self.test_CleanUp()
      if self.test_step_VerifyTraffic() != 1:
           self._log.info("Test Failed at Step_2 == TestVerifyTraffic")
           self.test_CleanUp()
      objs_uuid = self.gbpverify.get_uuid_from_stack(self.heat_temp_test,self.heat_stack_name)
      self.ptg_1 = objs_uuid['server_ptg_id']
      self.ptg_2 = objs_uuid['client_ptg_id']
      self.test_1_prs = objs_uuid['demo_ruleset_icmp_id']
      self.test_2_prs = objs_uuid['demo_ruleset_tcp_id']
      self.test_3_prs = objs_uuid['demo_ruleset_udp_id']
      self.test_4_prs = objs_uuid['demo_ruleset_icmp_tcp_id']
      self.test_5_prs = objs_uuid['demo_ruleset_icmp_udp_id']
      self.test_6_prs = objs_uuid['demo_ruleset_tcp_udp_id']
      self.prs_proto = {self.test_1_prs:['icmp'],self.test_2_prs:['tcp'],self.test_3_prs:['udp'],\
                   self.test_4_prs:['icmp','tcp'],self.test_5_prs:['icmp','udp'],self.test_6_prs:['tcp','udp']}
class  testcase_gbp_aci_intg_apic_2(object):
    """
    This is a GBP_ACI Integration TestCase
    """
    # Initialize logging
    logging.basicConfig(format='%(asctime)s [%(levelname)s] %(name)s - %(message)s', level=logging.WARNING)
    _log = logging.getLogger( __name__ )
    hdlr = logging.FileHandler('/tmp/testcase_gbp_aci_intg_apic_2.log')
    formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
    hdlr.setFormatter(formatter)
    _log.addHandler(hdlr)
    _log.setLevel(logging.INFO)
    _log.setLevel(logging.DEBUG)

    def __init__(self,params):

      self.gbpcfg = gbpCfgCli()
      self.gbpverify = Gbp_Verify()
      self.gbpdeftraff = Gbp_def_traff()
      self.gbpaci = Gbp_Aci()
      self.heat_stack_name = 'gbpapic3'
      self.cntlr_ip = params['cntlr_ip']
      self.heat_temp_test = params['heat_temp_file']
      self.gbpheat = gbpHeat(self.cntlr_ip)
      self.gbpnova = gbpNova(self.cntlr_ip)
      self.leaf_ip = params['leaf1_ip']
      self.apic_ip = params['apic_ip']
      self.network_node = params['network_node']
      self.az_comp_node = params['az_comp_node']
      self.nova_agg = params['nova_agg']
      self.nova_az = params['nova_az']
      self.debug = param['pausetodebug']

      self.test_name = 'DISCONN_APIC_UPDATECFG_RECONN_APIC'
      self._log.info("\nSteps of the TESTCASE_GBP_INTG_APIC_2_DISCONN_APIC_UPDATECFG_RECONN_APIC to be executed\n")
      if self.test_step_SetUpConfig()!=1:
           self._log.info("Test Failed at Step_1 == SetUpConfig")
           self.test_CleanUp()
      if self.test_step_VerifyTraffic() != 1:
           self._log.info("Test Failed at Step_2 == TestVerifyTraffic")
           self.test_CleanUp()
      objs_uuid = self.gbpverify.get_uuid_from_stack(self.heat_temp_test,self.heat_stack_name)
      self.ptg_1 = objs_uuid['server_ptg_id']
      self.ptg_2 = objs_uuid['client_ptg_id']
      self.test_1_prs = objs_uuid['demo_ruleset_icmp_id']
      self.test_2_prs = objs_uuid['demo_ruleset_tcp_id']
      self.test_3_prs = objs_uuid['demo_ruleset_udp_id']
      self.test_4_prs = objs_uuid['demo_ruleset_icmp_tcp_id']
      self.test_5_prs = objs_uuid['demo_ruleset_icmp_udp_id']
      self.test_6_prs = objs_uuid['demo_ruleset_tcp_udp_id']
      self.prs_proto = {self.test_1_prs:['icmp'],self.test_2_prs:['tcp'],self.test_3_prs:['udp'],\
                   self.test_4_prs:['icmp','tcp'],self.test_5_prs:['icmp','udp'],self.test_6_prs:['tcp','udp']}

    def test_runner(self):
        """
        Method to run the Testcase in Ordered Steps
        """
        testcase_steps = [self.test_step_DisconnectApic,
                              self.test_step_UpdatePtg,
                              self.test_step_ReconnectApic,
                              self.test_step_RestartNeutron,
                              self.test_step_VerifyTraffic]
	status = ''
        for prs,proto in self.prs_proto.iteritems():
            for step in testcase_steps: 
                if step == 'self.test_step_VerifyTraffic':
                   if step(proto) != 1:
                      self._log.info("Test Failed at Step == VerifyTraffic for Protocol = %s" %(proto))
                      self._log.info("%s_%s == FAILED" %(self.__class__.__name__.upper(),self.test_name))
                      status = 'failed'
                      break
                   elif step()!=1:
                      self._log.info("Test Failed at Step == %s" %(step.__name__.lstrip('self')))
                      self._log.info("%s_%s == FAILED" %(self.__class__.__name__.upper(),self.test_name))
                      status = 'failed'
                      break
            if status == 'failed':
               if self.debug == True:
                     PauseToDebug()
               break
        if status != 'failed':
           self._log.info("%s_%s == PASSED" %(self.__class__.__name__.upper(),self.test_name))
        self.test_CleanUp()

    def test_step_SetUpConfig(self):
        """
        Test Step using Heat, setup the Test Config
        """
        self.agg_id = self.gbpnova.avail_zone('api','create',self.nova_agg,avail_zone_name=self.nova_az)
        if self.agg_id == 0:
            self._log.info("\n ABORTING THE TESTSUITE RUN,nova host aggregate creation Failed")
            sys.exit(1)
        self._log.info(" Agg %s" %(self.agg_id))
        if self.gbpnova.avail_zone('api','addhost',self.agg_id,hostname=self.az_comp_node) == 0:
            self._log.info("\n ABORTING THE TESTSUITE RUN, availability zone creation Failed")
            self.gbpnova.avail_zone('api','delete',self.nova_agg,avail_zone_name=self.nova_az) # Cleaning up
            sys.exit(1)
        sleep(3)
        if self.gbpheat.cfg_all_cli(1,self.heat_stack_name,heat_temp=self.heat_temp_test) == 0:
           self._log.info("\n ABORTING THE TESTSUITE RUN, HEAT STACK CREATE of %s Failed" %(self.heat_stack_name))
           self.test_CleanUp()
           sys.exit(1)
        print 'Enable SSH .. sleeping for 20 secs'
        create_add_filter(self.apic_ip,'demo_bd') # 'demo_bd' is the name of L2Policy in the Heat Temp
        sleep(20)
        return 1

    def test_step_UpdatePtg(self,prs):
        """
        Update the PTG with new PRS & Restart the Neutron-Server
        """
        if self.gbpcfg.gbp_policy_cfg_all(2,'group',self.ptg_1,provided_policy_rule_sets="%s=scope" %(prs))\
           and self.gbpcfg.gbp_policy_cfg_all(2,'group',self.ptg_2,consumed_policy_rule_sets="%s=scope" %(prs))==0:
           self._log.info("Updating PTG = Failed")
           return 0

    def test_step_RestartNeutron(self):
        getoutput('systemctl restart neutron-server.service')
        sleep(5)
        return 1

    def test_step_DisconnectApic(self):
        """
        Test Step to Disconnect APIC from Ostack Controller
        """
        if self.gbpaci.dev_conn_disconn(self.cntlr_ip,self.apic_ip,'disconnect') == 0:
           return 0
        return 1
 
    def test_step_VerifyObjsApic(self):
        """
        Test Step to verify that all configured objs are available in APIC
        """
        if self.gbpaci.apic_verify_mos(self.apic_ip) == 0:
           return 0
        return 1

    def test_step_ReconnectApic(self):
        """
        Test Step to Reconnect APIC to Ostack Controller
        """
        if self.gbpaci.dev_conn_disconn(self.cntlr_ip,self.apic_ip,'reconnect') == 0:
           return 0
        return 1

    def test_step_VerifyTraffic(self,proto='all'):
        """
        Send and Verify traffic
        """
        return verify_traff(self.network_node)

    def test_CleanUp(self):
        """
        Cleanup the Testcase setup
        """
        self.gbpaci.dev_conn_disconn(self.cntlr_ip,self.apic_ip,'reconnect')
        self.gbpnova.avail_zone('api','removehost',self.agg_id,hostname=self.az_comp_node)
        self.gbpnova.avail_zone('api','delete',self.agg_id)
        self.gbpheat.cfg_all_cli(0,self.heat_stack_name)
Esempio n. 7
0
class testcase_gbp_aci_intg_leaf_vpc_flap_5(object):
    """
    This is a GBP_ACI Integration TestCase
    """

    # Initialize logging
    #logging.basicConfig(level=logging.INFO)
    _log = logging.getLogger(__name__)
    _log.setLevel(logging.INFO)
    # create a logfile handler
    hdlr = logging.FileHandler(
        '/tmp/testcase_gbp_aci_intg_leaf_vpc_flap_5.log')
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    hdlr.setFormatter(formatter)
    # Add the handler to the logger
    _log.addHandler(hdlr)

    def __init__(self, params):

        self.gbpaci = Gbp_Aci()
        self.heat_stack_name = 'gbpvpc7'
        cntlr_ip = params['cntlr_ip']
        self.heat_temp_test = params['heat_temp_file']
        self.gbpheat = gbpHeat(cntlr_ip)
        self.gbpnova = gbpNova(cntlr_ip)
        self.apic_ip = params['apic_ip']
        self.az_comp_node = params['az_comp_node']
        self.nova_agg = params['nova_agg']
        self.nova_az = params['nova_az']
        self.network_node = params['network_node']
        self.leaf1_port_comp_node1 = params[
            'leaf1_port1']  #This connects Leaf1 to Comp-node1
        self.leaf2_port_comp_node2 = params[
            'leaf2_port2']  #This connects Leaf2 to Comp-node2
        self.leaf1_node_id = params['leaf1_node_id']
        self.leaf2_node_id = params['leaf2_node_id']
        self.debug = params['pausetodebug']

    def test_runner(self):
        """
        Method to run the Testcase in Ordered Steps
        """
        test_name = 'VPC_DISCON_LEAF1_NODE1_LEAF2_NODE2'
        self._log.info(
            "\nSteps of the TESTCASE_GBP_INTG_LEAF_VPC_5_VPC_DISCON_LEAF1_NODE1_LEAF2_NODE2 to be executed\n"
        )
        testcase_steps = [
            self.test_step_SetUpConfig,
            self.test_step_DisconnectLeafsFromHosts,
            self.test_step_VerifyTraffic
        ]
        status = ''
        for step in testcase_steps:
            if step() != 1:
                self._log.info("Test Failed at Step == %s" %
                               (step.__name__.lstrip('self')))
                if self.debug == True:
                    PauseToDebug()
                self._log.info("%s_%s == FAILED" %
                               (self.__class__.__name__.upper(), test_name))
                status = 'failed'
                break
        if status != 'failed':
            self._log.info("%s_%s == PASSED" %
                           (self.__class__.__name__.upper(), test_name))
        self.test_CleanUp()

    def test_step_SetUpConfig(self):
        """
        Test Step using Heat, setup the Test Config
        """
        self._log.info(
            "\nSetupCfg: Create Aggregate & Availability Zone to be executed\n"
        )
        self.agg_id = self.gbpnova.avail_zone('api',
                                              'create',
                                              self.nova_agg,
                                              avail_zone_name=self.nova_az)
        if self.agg_id == 0:
            self._log.info(
                "\n ABORTING THE TESTSUITE RUN,nova host aggregate creation Failed"
            )
            sys.exit(1)
        self._log.info(" Agg %s" % (self.agg_id))
        if self.gbpnova.avail_zone('api',
                                   'addhost',
                                   self.agg_id,
                                   hostname=self.az_comp_node) == 0:
            self._log.info(
                "\n ABORTING THE TESTSUITE RUN, availability zone creation Failed"
            )
            self.gbpnova.avail_zone(
                'api', 'delete', self.nova_agg,
                avail_zone_name=self.nova_az)  # Cleaning up
            sys.exit(1)
        sleep(3)
        if self.gbpheat.cfg_all_cli(1,
                                    self.heat_stack_name,
                                    heat_temp=self.heat_temp_test) == 0:
            self._log.info(
                "\n ABORTING THE TESTSUITE RUN, HEAT STACK CREATE of %s Failed"
                % (self.heat_stack_name))
            self.test_CleanUp()
            sys.exit(1)
        print 'Enable SSH .. sleeping for 20 secs'
        create_add_filter(
            self.apic_ip,
            'demo_bd')  # 'demo_bd' is the name of L2Policy in the Heat Temp
        sleep(20)
        return 1

    def test_step_DisconnectLeafsFromHosts(self):
        """
        Test Step to Disconnect Links b/w Leaf1-CompNode1,Leaf2-CompNode2
        """
        self._log.info(
            "\nStep to Disconnect Links b/w Leaf1-CompNode1,Leaf2-CompNode2\n")
        if self.gbpaci.enable_disable_switch_port(
                self.apic_ip, self.leaf1_node_id, 'disable',
                self.leaf1_port_comp_node1) == 0:
            return 0
        if self.gbpaci.enable_disable_switch_port(
                self.apic_ip, self.leaf2_node_id, 'disable',
                self.leaf2_port_comp_node2) == 0:
            return 0
        return 1

    def test_step_VerifyTraffic(self):
        """
        Send and Verify traffic
        """
        self._log.info("\nSend and Verify Traffic\n")
        return verify_traff(self.network_node)

    def test_CleanUp(self):
        """
        Cleanup the Testcase setup
        """
        self._log.info("\nCleanUp to be executed\n")
        self.gbpaci.enable_disable_switch_port(self.apic_ip,
                                               self.leaf1_node_id, 'enable',
                                               self.leaf1_port_comp_node1)
        self.gbpaci.enable_disable_switch_port(self.apic_ip,
                                               self.leaf2_node_id, 'enable',
                                               self.leaf2_port_comp_node2)
        self.gbpnova.avail_zone('api',
                                'removehost',
                                self.agg_id,
                                hostname=self.az_comp_node)
        self.gbpnova.avail_zone('api', 'delete', self.agg_id)
        self.gbpheat.cfg_all_cli(0, self.heat_stack_name)
class testcase_gbp_aci_intg_leaf_vpc_flap_3(object):
    """
    This is a GBP_ACI Integration TestCase
    """
    # Initialize logging
    #logging.basicConfig(level=logging.INFO)
    _log = logging.getLogger(__name__)
    _log.setLevel(logging.INFO)
    # create a logfile handler
    hdlr = logging.FileHandler('/tmp/testcase_gbp_aci_intg_leaf_vpc_flap_3.log')
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    hdlr.setFormatter(formatter)
    # Add the handler to the logger
    _log.addHandler(hdlr)

    def __init__(self,params):

      self.gbpaci = Gbp_Aci()
      self.heat_stack_name = 'gbpvpc5'
      cntlr_ip = params['cntlr_ip']
      self.heat_temp_test = params['heat_temp_file']
      self.gbpheat = gbpHeat(cntlr_ip)
      self.gbpnova = gbpNova(cntlr_ip)
      self.apic_ip = params['apic_ip']
      self.az_comp_node = params['az_comp_node']
      self.nova_agg = params['nova_agg']
      self.nova_az = params['nova_az']
      self.network_node = params['network_node']
      self.leaf1_port_comp_node1 = params['leaf1_port1'] #This connects Leaf1 to Comp-node1
      self.leaf1_port_comp_node2 = params['leaf1_port2'] #This connects Leaf1 to Comp-node2
      self.node_id = params['leaf1_node_id']


    def test_runner(self):
        """
        Method to run the Testcase in Ordered Steps
        """
        test_name = 'VPC_DISCON_LEAF1_NODE1_NODE2'
        self._log.info("\nSteps of the TESTCASE_GBP_INTG_LEAF_VPC_3_VPC_DISCON_LEAF1_NODE1_NODE2 to be executed\n")
        testcase_steps = [self.test_step_SetUpConfig,
                          self.test_step_DisconnectLeafOneHost,
                          self.test_step_VerifyTraffic
                         ]
	status = ''
        for step in testcase_steps:
            if step()!=1:
                  self._log.info("Test Failed at Step == %s" %(step.__name__.lstrip('self')))
                  self._log.info("%s_%s == FAILED" %(self.__class__.__name__.upper(),test_name))        
                  status = 'failed'
                  break
        if status != 'failed':
           self._log.info("%s_%s == PASSED" %(self.__class__.__name__.upper(),test_name))        
        self.test_CleanUp()

    def test_step_SetUpConfig(self):
        """
        Test Step using Heat, setup the Test Config
        """
        self._log.info("\nSetupCfg: Create Aggregate & Availability Zone to be executed\n")
        self.agg_id = self.gbpnova.avail_zone('api','create',self.nova_agg,avail_zone_name=self.nova_az)
        if self.agg_id == 0:
            self._log.info("\n ABORTING THE TESTSUITE RUN,nova host aggregate creation Failed")
            sys.exit(1)
        self._log.info(" Agg %s" %(self.agg_id))
        if self.gbpnova.avail_zone('api','addhost',self.agg_id,hostname=self.az_comp_node) == 0:
            self._log.info("\n ABORTING THE TESTSUITE RUN, availability zone creation Failed")
            self.gbpnova.avail_zone('api','delete',self.nova_agg,avail_zone_name=self.nova_az) # Cleaning up
            sys.exit(1)
        sleep(3)
        if self.gbpheat.cfg_all_cli(1,self.heat_stack_name,heat_temp=self.heat_temp_test) == 0:
           self._log.info("\n ABORTING THE TESTSUITE RUN, HEAT STACK CREATE of %s Failed" %(self.heat_stack_name))
           self.test_CleanUp()
           sys.exit(1)
        print 'Enable SSH .. sleeping for 20 secs'
        create_add_filter(self.apic_ip,'demo_bd') # 'demo_bd' is the name of L2Policy in the Heat Temp
        sleep(20)
        return 1

    def test_step_DisconnectLeafOneHost(self):
        """
        Test Step to Disconnect Leaf1 Ports from both Comp-Nodes
        """
        self._log.info("\nStep to Disconnect Links between Leaf1 and Both Comp-nodes\n")
        if self.gbpaci.enable_disable_switch_port(self.apic_ip,self.node_id,'disable',self.leaf1_port_comp_node1) == 0:
           return 0
        if self.gbpaci.enable_disable_switch_port(self.apic_ip,self.node_id,'disable',self.leaf1_port_comp_node2) == 0:
           return 0
        return 1
 
    def test_step_VerifyTraffic(self):
        """
        Send and Verify traffic
        """
        self._log.info("\nSend and Verify Traffic\n")
        return verify_traff(self.network_node)

    def test_CleanUp(self):
        """
        Cleanup the Testcase setup
        """
        self._log.info("\nCleanUp to be executed\n")
        for port in [self.leaf1_port_comp_node1,self.leaf1_port_comp_node2]:
           self.gbpaci.enable_disable_switch_port(self.apic_ip,self.node_id,'enable',port)
        self.gbpnova.avail_zone('api','removehost',self.agg_id,hostname=self.az_comp_node)
        self.gbpnova.avail_zone('api','delete',self.agg_id)
        self.gbpheat.cfg_all_cli(0,self.heat_stack_name)
Esempio n. 9
0
class  testcase_gbp_aci_intg_apic_1(object):
    """
    This is a GBP_ACI Integration TestCase
    """
    # Initialize logging
    logging.basicConfig(format='%(asctime)s [%(levelname)s] %(name)s - %(message)s', level=logging.WARNING)
    _log = logging.getLogger( __name__ )
    hdlr = logging.FileHandler('/tmp/testcase_gbp_aci_intg_apic_1.log')
    formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
    hdlr.setFormatter(formatter)
    _log.addHandler(hdlr)
    _log.setLevel(logging.INFO)
    _log.setLevel(logging.DEBUG)

    def __init__(self,params):

      self.gbpaci = Gbp_Aci()
      self.heat_stack_name = 'gbpapic1'
      cntlr_ip = params['cntlr_ip']
      self.heat_temp_test = params['heat_temp_file']
      self.gbpheat = gbpHeat(cntlr_ip)
      self.gbpnova = gbpNova(cntlr_ip)
      self.leaf_ip = params['leaf1_ip']
      self.apic_ip = params['apic_ip']
      self.network_node = params['network_node']
      self.az_comp_node = params['az_comp_node']
      self.nova_agg = params['nova_agg']
      self.nova_az = params['nova_az']
      self.debug = params['pausetodebug']


    def test_runner(self):
        """
        Method to run the Testcase in Ordered Steps
        """
        test_name = 'REBOOT_APIC'
        self._log.info("\nSteps of the TESTCASE_GBP_INTG_APIC_1_SETUPCFG_REBOOT_APIC to be executed\n")
        testcase_steps = [self.test_step_SetUpConfig,
                          self.test_step_RebootApic,
                          self.test_step_VerifyTraffic
                         ]
	status = ''
        for step in testcase_steps:
            if step()!=1:
                  self._log.info("Test Failed at Step == %s" %(step.__name__.lstrip('self')))
                  if self.debug == True:
                     PauseToDebug()
                  self._log.info("%s_%s == FAILED" %(self.__class__.__name__.upper(),test_name))        
                  status = 'failed'
                  break
        if status != 'failed':
           self._log.info("%s_%s == PASSED" %(self.__class__.__name__.upper(),test_name))        
        self.test_CleanUp()

    def test_step_SetUpConfig(self):
        """
        Test Step using Heat, setup the Test Config
        """
        self.agg_id = self.gbpnova.avail_zone('api','create',self.nova_agg,avail_zone_name=self.nova_az)
        if self.agg_id == 0:
            self._log.info("\n ABORTING THE TESTSUITE RUN,nova host aggregate creation Failed")
            sys.exit(1)
        self._log.info(" Agg %s" %(self.agg_id))
        if self.gbpnova.avail_zone('api','addhost',self.agg_id,hostname=self.az_comp_node) == 0:
            self._log.info("\n ABORTING THE TESTSUITE RUN, availability zone creation Failed")
            self.gbpnova.avail_zone('api','delete',self.nova_agg,avail_zone_name=self.nova_az) # Cleaning up
            sys.exit(1)
        sleep(3)
        if self.gbpheat.cfg_all_cli(1,self.heat_stack_name,heat_temp=self.heat_temp_test) == 0:
           self._log.info("\n ABORTING THE TESTSUITE RUN, HEAT STACK CREATE of %s Failed" %(self.heat_stack_name))
           self.test_CleanUp()
           sys.exit(1)
        print 'Enable SSH .. sleeping for 20 secs'
        create_add_filter(self.apic_ip,'demo_bd') # 'demo_bd' is the name of L2Policy in the Heat Temp
        sleep(20)
        return 1

    def test_step_RebootApic(self):
        """
        Test Step to Reboot APIC from Ostack Controller
        """
        if self.gbpaci.reboot_aci(self.apic_ip,node='apic') == 0:
           return 0
        self._log.info("Rebooted the APIC, hence sleeping for 200 secs before exiting the method")
        sleep(200)
        return 1
 
    def test_step_VerifyTraffic(self):
        """
        Send and Verify traffic
        """
        return verify_traff(self.network_node)

    def test_CleanUp(self):
        """
        Cleanup the Testcase setup
        """
        self.gbpnova.avail_zone('api','removehost',self.agg_id,hostname=self.az_comp_node)
        self.gbpnova.avail_zone('api','delete',self.agg_id)
        self.gbpheat.cfg_all_cli(0,self.heat_stack_name)
class  testcase_gbp_aci_intg_leaf_2(object):
    """
    This is a GBP_ACI Integration TestCase
    """
    # Initialize logging
    logging.basicConfig(format='%(asctime)s [%(levelname)s] %(name)s - %(message)s', level=logging.WARNING)
    _log = logging.getLogger( __name__ )
    hdlr = logging.FileHandler('/tmp/testcase_gbp_aci_intg_leaf_2.log')
    formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
    hdlr.setFormatter(formatter)
    _log.addHandler(hdlr)
    _log.setLevel(logging.INFO)
    _log.setLevel(logging.DEBUG)

    def __init__(self,params):

      self.gbpaci = Gbp_Aci()
      self.heat_stack_name = 'gbpleaf3'
      cntlr_ip = params['cntlr_ip']
      self.heat_temp_test = params['heat_temp_file']
      self.gbpheat = gbpHeat(cntlr_ip)
      self.gbpnova = gbpNova(cntlr_ip)
      self.leaf_ip = params['leaf1_ip']
      self.apic_ip = params['apic_ip']
      self.network_node = params['network_node']
      self.az_comp_node = params['az_comp_node']
      self.nova_agg = params['nova_agg']
      self.nova_az = params['nova_az']
      self.leaf_port_comp_node1 = params['leaf1_port1'] #This connects Leaf1 to Comp-node1
      self.leaf_port_comp_node2 = params['leaf1_port2'] #This connects Leaf1 to Comp-node2
      self.node_id = params['leaf1_node_id']


    def test_runner(self):
        """
        Method to run the Testcase in Ordered Steps
        """
        test_name = 'SETUPCFG_WITH_OFFLINE_BOTH_COMP_NODES'
        self._log.info("\nSteps of the TESTCASE_GBP_INTG_LEAF_3_SETUPCFG_WITH_OFFLINE_BOTH_COMP_NODES to be executed\n")
        testcase_steps = [self.test_step_DisconnectLeaf,
                          self.test_step_SetUpConfig,
                          self.test_step_ReconnectLeaf,
                          self.test_step_VerifyTraffic
                         ]
	status = ''
        for step in testcase_steps:
            if step()!=1:
                  self._log.info("Test Failed at Step == %s" %(step.__name__.lstrip('self')))
                  self._log.info("%s_%s == FAILED" %(self.__class__.__name__.upper(),test_name))        
                  status = 'failed'
                  break
        if status != 'failed':
           self._log.info("%s_%s == PASSED" %(self.__class__.__name__.upper(),test_name))        
        self.test_CleanUp()

    def test_step_SetUpConfig(self):
        """
        Test Step using Heat, setup the Test Config
        """
        self._log.info("\nSetupCfg: Create Aggregate & Availability Zone to be executed\n")
        self.agg_id = self.gbpnova.avail_zone('api','create',self.nova_agg,avail_zone_name=self.nova_az)
        if self.agg_id == 0:
            self._log.info("\n ABORTING THE TESTSUITE RUN,nova host aggregate creation Failed")
            sys.exit(1)
        self._log.info(" Agg %s" %(self.agg_id))
        if self.gbpnova.avail_zone('api','addhost',self.agg_id,hostname=self.az_comp_node) == 0:
            self._log.info("\n ABORTING THE TESTSUITE RUN, availability zone creation Failed")
            self.gbpnova.avail_zone('api','delete',self.nova_agg,avail_zone_name=self.nova_az) # Cleaning up
            sys.exit(1)
        sleep(3)
        if self.gbpheat.cfg_all_cli(1,self.heat_stack_name,heat_temp=self.heat_temp_test) == 0:
           self._log.info("\n ABORTING THE TESTSUITE RUN, HEAT STACK CREATE of %s Failed" %(self.heat_stack_name))
           self.test_CleanUp()
           sys.exit(1)
        print 'Enable SSH .. sleeping for 20 secs'
        create_add_filter(self.apic_ip,'demo_bd') # 'demo_bd' is the name of L2Policy in the Heat Temp
        sleep(20)
        return 1

    def test_step_DisconnectLeaf(self):
        """
        Test Step to Disconnect Leaf Port from two Comp-nodes
        """
        self._log.info("\nStep to Disconnect Leaf Port from Two Comp-nodes= CompNode1 & CompNode2\n")
        for port in [self.leaf_port_comp_node1,self.leaf_port_comp_node2]:
          if self.gbpaci.enable_disable_switch_port(self.apic_ip,self.node_id,'disable',port) == 0:
           return 0
        return 1

    def test_step_ReconnectLeaf(self):
        """
        Test Step to Reconnect Leaf Port to two Comp-nodes
        """
        self._log.info("\nStep to RE-connect Leaf Ports to both Comp-nodes= CompNode1 & CompNode2\n")
        for port in [self.leaf_port_comp_node1,self.leaf_port_comp_node2]:
          if self.gbpaci.enable_disable_switch_port(self.apic_ip,self.node_id,'enable',port) == 0:
           return 0
        sleep(20)  ##For Opflex to re-converge
        return 1

    def test_step_VerifyTraffic(self):
        """
        Send and Verify traffic
        """
        self._log.info("\nSend and Verify Traffic\n")
        return verify_traff(self.network_node)

    def test_CleanUp(self):
        """
        Cleanup the Testcase setup
        """
        self._log.info("\nCleanUp to be executed\n")
        self.gbpnova.avail_zone('api','removehost',self.agg_id,hostname=self.az_comp_node)
        self.gbpnova.avail_zone('api','delete',self.agg_id)
        self.gbpheat.cfg_all_cli(0,self.heat_stack_name)
class testcase_gbp_aci_intg_apic_2(object):
    """
    This is a GBP_ACI Integration TestCase
    """
    # Initialize logging
    logging.basicConfig(
        format='%(asctime)s [%(levelname)s] %(name)s - %(message)s',
        level=logging.WARNING)
    _log = logging.getLogger(__name__)
    hdlr = logging.FileHandler('/tmp/testcase_gbp_aci_intg_apic_2.log')
    formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
    hdlr.setFormatter(formatter)
    _log.addHandler(hdlr)
    _log.setLevel(logging.INFO)
    _log.setLevel(logging.DEBUG)

    def __init__(self, params):

        self.gbpcfg = gbpCfgCli()
        self.gbpverify = Gbp_Verify()
        self.gbpdeftraff = Gbp_def_traff()
        self.gbpaci = Gbp_Aci()
        self.heat_stack_name = 'gbpapic3'
        self.cntlr_ip = params['cntlr_ip']
        self.heat_temp_test = params['heat_temp_file']
        self.gbpheat = gbpHeat(self.cntlr_ip)
        self.gbpnova = gbpNova(self.cntlr_ip)
        self.leaf_ip = params['leaf1_ip']
        self.apic_ip = params['apic_ip']
        self.network_node = params['network_node']
        self.az_comp_node = params['az_comp_node']
        self.nova_agg = params['nova_agg']
        self.nova_az = params['nova_az']
        self.debug = param['pausetodebug']

        self.test_name = 'DISCONN_APIC_UPDATECFG_RECONN_APIC'
        self._log.info(
            "\nSteps of the TESTCASE_GBP_INTG_APIC_2_DISCONN_APIC_UPDATECFG_RECONN_APIC to be executed\n"
        )
        if self.test_step_SetUpConfig() != 1:
            self._log.info("Test Failed at Step_1 == SetUpConfig")
            self.test_CleanUp()
        if self.test_step_VerifyTraffic() != 1:
            self._log.info("Test Failed at Step_2 == TestVerifyTraffic")
            self.test_CleanUp()
        objs_uuid = self.gbpverify.get_uuid_from_stack(self.heat_temp_test,
                                                       self.heat_stack_name)
        self.ptg_1 = objs_uuid['server_ptg_id']
        self.ptg_2 = objs_uuid['client_ptg_id']
        self.test_1_prs = objs_uuid['demo_ruleset_icmp_id']
        self.test_2_prs = objs_uuid['demo_ruleset_tcp_id']
        self.test_3_prs = objs_uuid['demo_ruleset_udp_id']
        self.test_4_prs = objs_uuid['demo_ruleset_icmp_tcp_id']
        self.test_5_prs = objs_uuid['demo_ruleset_icmp_udp_id']
        self.test_6_prs = objs_uuid['demo_ruleset_tcp_udp_id']
        self.prs_proto = {self.test_1_prs:['icmp'],self.test_2_prs:['tcp'],self.test_3_prs:['udp'],\
                     self.test_4_prs:['icmp','tcp'],self.test_5_prs:['icmp','udp'],self.test_6_prs:['tcp','udp']}

    def test_runner(self):
        """
        Method to run the Testcase in Ordered Steps
        """
        testcase_steps = [
            self.test_step_DisconnectApic, self.test_step_UpdatePtg,
            self.test_step_ReconnectApic, self.test_step_RestartNeutron,
            self.test_step_VerifyTraffic
        ]
        status = ''
        for prs, proto in self.prs_proto.iteritems():
            for step in testcase_steps:
                if step == 'self.test_step_VerifyTraffic':
                    if step(proto) != 1:
                        self._log.info(
                            "Test Failed at Step == VerifyTraffic for Protocol = %s"
                            % (proto))
                        self._log.info(
                            "%s_%s == FAILED" %
                            (self.__class__.__name__.upper(), self.test_name))
                        status = 'failed'
                        break
                    elif step() != 1:
                        self._log.info("Test Failed at Step == %s" %
                                       (step.__name__.lstrip('self')))
                        self._log.info(
                            "%s_%s == FAILED" %
                            (self.__class__.__name__.upper(), self.test_name))
                        status = 'failed'
                        break
            if status == 'failed':
                if self.debug == True:
                    PauseToDebug()
                break
        if status != 'failed':
            self._log.info("%s_%s == PASSED" %
                           (self.__class__.__name__.upper(), self.test_name))
        self.test_CleanUp()

    def test_step_SetUpConfig(self):
        """
        Test Step using Heat, setup the Test Config
        """
        self.agg_id = self.gbpnova.avail_zone('api',
                                              'create',
                                              self.nova_agg,
                                              avail_zone_name=self.nova_az)
        if self.agg_id == 0:
            self._log.info(
                "\n ABORTING THE TESTSUITE RUN,nova host aggregate creation Failed"
            )
            sys.exit(1)
        self._log.info(" Agg %s" % (self.agg_id))
        if self.gbpnova.avail_zone('api',
                                   'addhost',
                                   self.agg_id,
                                   hostname=self.az_comp_node) == 0:
            self._log.info(
                "\n ABORTING THE TESTSUITE RUN, availability zone creation Failed"
            )
            self.gbpnova.avail_zone(
                'api', 'delete', self.nova_agg,
                avail_zone_name=self.nova_az)  # Cleaning up
            sys.exit(1)
        sleep(3)
        if self.gbpheat.cfg_all_cli(1,
                                    self.heat_stack_name,
                                    heat_temp=self.heat_temp_test) == 0:
            self._log.info(
                "\n ABORTING THE TESTSUITE RUN, HEAT STACK CREATE of %s Failed"
                % (self.heat_stack_name))
            self.test_CleanUp()
            sys.exit(1)
        print 'Enable SSH .. sleeping for 20 secs'
        create_add_filter(
            self.apic_ip,
            'demo_bd')  # 'demo_bd' is the name of L2Policy in the Heat Temp
        sleep(20)
        return 1

    def test_step_UpdatePtg(self, prs):
        """
        Update the PTG with new PRS & Restart the Neutron-Server
        """
        if self.gbpcfg.gbp_policy_cfg_all(2,'group',self.ptg_1,provided_policy_rule_sets="%s=scope" %(prs))\
           and self.gbpcfg.gbp_policy_cfg_all(2,'group',self.ptg_2,consumed_policy_rule_sets="%s=scope" %(prs))==0:
            self._log.info("Updating PTG = Failed")
            return 0

    def test_step_RestartNeutron(self):
        getoutput('systemctl restart neutron-server.service')
        sleep(5)
        return 1

    def test_step_DisconnectApic(self):
        """
        Test Step to Disconnect APIC from Ostack Controller
        """
        if self.gbpaci.dev_conn_disconn(self.cntlr_ip, self.apic_ip,
                                        'disconnect') == 0:
            return 0
        return 1

    def test_step_VerifyObjsApic(self):
        """
        Test Step to verify that all configured objs are available in APIC
        """
        if self.gbpaci.apic_verify_mos(self.apic_ip) == 0:
            return 0
        return 1

    def test_step_ReconnectApic(self):
        """
        Test Step to Reconnect APIC to Ostack Controller
        """
        if self.gbpaci.dev_conn_disconn(self.cntlr_ip, self.apic_ip,
                                        'reconnect') == 0:
            return 0
        return 1

    def test_step_VerifyTraffic(self, proto='all'):
        """
        Send and Verify traffic
        """
        return verify_traff(self.network_node)

    def test_CleanUp(self):
        """
        Cleanup the Testcase setup
        """
        self.gbpaci.dev_conn_disconn(self.cntlr_ip, self.apic_ip, 'reconnect')
        self.gbpnova.avail_zone('api',
                                'removehost',
                                self.agg_id,
                                hostname=self.az_comp_node)
        self.gbpnova.avail_zone('api', 'delete', self.agg_id)
        self.gbpheat.cfg_all_cli(0, self.heat_stack_name)