Esempio n. 1
0
def test_vtn_flowfilter_audit_1():

    print "****CREATE Controller with valid IP****"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
        print "Controller Create Failed"
        exit(1)

    print """TEST 1 : create VTN FLOWFILTER when controller is up
             change the controller status to down delete VTN and VBR
             trigger Audit"""
    # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst', "up")
    if retval != 0:
        print "controller state change failed"
        exit(1)
    print "****Create VTN****"
    retval = vtn_vbr.create_vtn('VtnOne')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    print "****Create VBR****"
    retval = vtn_vbr.create_vbr('VtnOne', 'VbrOne', 'ControllerFirst')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval = vtn_vbr.validate_vtn_at_controller('VtnOne', 'ControllerFirst')
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    retval = vtn_vbr.validate_vbr_at_controller('VtnOne', 'VbrOne',
                                                'ControllerFirst')
    if retval != 0:
        print "VBR Validate Failed"
        exit(1)

    retval = flowlistentry.create_flowlist('FlowlistOne')
    if retval != 0:
        print "FlowList Create Failed"
        exit(1)

    retval = flowlistentry.create_flowlistentry('FlowlistOne',
                                                'FlowlistentryOne',
                                                'ControllerFirst')
    if retval != 0:
        print "FlowlistEntry Create Failed"
        exit(1)

    retval = flowfilter.create_flowfilter('VtnOne', 'VTNFlowfilterOne')
    if retval != 0:
        print "VTNFlowFilter Create Failed"
        exit(1)

    retval = flowfilter.create_flowfilter_entry('VtnOne', 'VTNFlowfilterOne')
    if retval != 0:
        print "VTNFlowFilterEntry Create Failed"
        exit(1)

    retval = flowfilter.validate_flowfilter_entry('VtnOne',
                                                  'VTNFlowfilterOne',
                                                  presence='yes',
                                                  position=0)
    if retval != 0:
        print "VTNFlowFilterEntry Validate Failed at Co-ordinator"
        exit(1)

    retval = flowfilter.validate_flowfilter_at_controller('VtnOne',
                                                          'ControllerFirst',
                                                          'VTNFlowfilterOne',
                                                          presence='yes',
                                                          position=0)
    if retval != 0:
        print "FlowFilter validation Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr = vtn_testconfig.ReadValues(
        CONTROLLERDATA, 'ControllerFirst')['invalid_ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',
                                             ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller invalid_ip update failed"
        exit(1)
# Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst', "down")
    if retval != 0:
        print "controller state change failed"
        exit(1)

    retval = flowfilter.delete_flowfilter_entry('VtnOne', 'VTNFlowfilterOne')
    if retval != 0:
        print "VTNFlowFilterEntry deletete Failed"
        exit(1)

    retval = flowfilter.delete_flowfilter('VtnOne', 'VTNFlowfilterOne')
    if retval != 0:
        print "VTNFlowFilter deletete Failed"
        exit(1)

    retval = flowlistentry.delete_flowlistentry('FlowlistOne',
                                                'FlowlistentryOne')
    if retval != 0:
        print "FlowilistEntry deletete Failed"
        exit(1)

    retval = flowlistentry.delete_flowlist('FlowlistOne')
    if retval != 0:
        print "Flowilist deletete Failed"
        exit(1)

    print "****Delete VTN****"
    retval = vtn_vbr.delete_vtn('VtnOne')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr = vtn_testconfig.ReadValues(
        CONTROLLERDATA, 'ControllerFirst')['ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',
                                             ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller valid_ip update failed"
        exit(1)

# Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst', "up")
    if retval != 0:
        print "controller state change failed"
        exit(1)

    retval = flowfilter.validate_flowfilter_at_controller('VtnOne',
                                                          'ControllerFirst',
                                                          'VTNFlowfilterOne',
                                                          presence='no',
                                                          position=0)
    if retval != 0:
        print "FlowFilter validation Failed after deleting"
        exit(1)

    retval = vtn_vbr.validate_vtn_at_controller('VtnOne',
                                                'ControllerFirst',
                                                presence="no")
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
        print "CONTROLLER delete failed"
        exit(1)
    print "VTN->FLOWFILTER TEST SUCCESS"
Esempio n. 2
0
def test_audit_vtn_multi_vterm_vtermif():
    print "CREATE Controller"
    print "VTNONE->VTERMONE->VTERMIFONE/VTERMIFTHREE"
    print "VTNONE->VTERMTWO->VTERMIFTWO/VTERMIFFOUR"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
      print "TEST 3 :Controller Create Failed"
      exit(1)

    print "TEST 3 : Audit One vtn and Two VTerminals with Two Interfaces each"
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)
    retval=vtn_vterm.create_vtn('VtnOne')
    if retval != 0:
      print "VTN Create Failed"
      exit(1)

    retval=vtn_vterm.create_vterm('VtnOne','VTermOne','ControllerFirst')
    if retval != 0:
      print "VTERM1 Create Failed"
      exit(1)

    retval=vtn_vterm.create_vterm('VtnOne','VTermTwo','ControllerFirst')
    if retval != 0:
      print "VTERM2 Create Failed"
      exit(1)

    retval=vtermif_portmap.create_vtermif('VtnOne','VTermOne','VTermIfOne')
    if retval != 0:
      print "VTERMIF1 Create Failed"
      exit(1)

    retval=vtermif_portmap.validate_vtermif_at_controller('VtnOne','VTermOne','VTermIfOne','ControllerFirst',position=0)
    if retval != 0:
      print "VTERMIF1 Validate Failed"
      exit(1)

    retval=vtermif_portmap.create_vtermif('VtnOne','VTermTwo','VTermIfOne')
    if retval != 0:
      print "VTERM2->VTERMIF1 Create Failed"
      exit(1)

    retval=vtermif_portmap.validate_vtermif_at_controller('VtnOne','VTermTwo','VTermIfOne','ControllerFirst',position=0)
    if retval != 0:
      print "VTERM2->VTERMIF2 Validate Failed"
      exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
    retval=controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
    if retval != 0:
     print "controller invalid_ip update failed"
     exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"down")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval = vtermif_portmap.delete_vtermif('VtnOne','VTermOne','VTermIfOne')
    if retval != 0:
      print "VTERM1->VTERMIF1 Delete Failed"
      exit(1)

    retval = vtermif_portmap.delete_vtermif('VtnOne','VTermTwo','VTermIfOne')
    if retval != 0:
      print "VTERM2->VTERMIF1 Delete Failed"
      exit(1)

    retval=vtermif_portmap.create_vtermif('VtnOne','VTermOne','VTermIfThree')
    if retval != 0:
      print "VTERMIF3 Create Failed"
      exit(1)

    retval=vtermif_portmap.create_vtermif('VtnOne','VTermTwo','VTermIfTwo')
    if retval != 0:
      print "VTERM2->VTERMIF2 Create Failed"
      exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
    retval=controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
    if retval != 0:
     print "controller valid_ip update failed"
     exit(1)
   # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval=vtermif_portmap.validate_vtermif_at_controller('VtnOne','VTermOne','VTermIfThree','ControllerFirst',position=0)
    if retval != 0:
      print "VTERMIF3 Validate Failed"
      exit(1)

    retval=vtermif_portmap.validate_vtermif_at_controller('VtnOne','VTermTwo','VTermIfTwo','ControllerFirst',position=0)
    if retval != 0:
      print "VTERM2->VTERMIF2 Validate Failed"
      exit(1)

    retval=vtn_vterm.validate_vterm_at_controller('VtnOne','VTermOne','ControllerFirst',position=0)
    if retval != 0:
      print "VTERMONE Validate Failed"
      exit(1)

    retval=vtn_vterm.validate_vterm_at_controller('VtnOne','VTermTwo','ControllerFirst',position=0)
    if retval != 0:
      print "VTERMTWO Validate Failed"
      exit(1)

    retval=vtn_vterm.validate_vtn_at_controller('VtnOne','ControllerFirst')
    if retval != 0:
      print "VTN Validate Failed"
      exit(1)


    retval = vtermif_portmap.delete_vtermif('VtnOne','VTermOne','VTermIfThree')
    if retval != 0:
      print "VTERM1->VTERMIF3 Delete Failed"
      exit(1)

    retval=vtermif_portmap.validate_vtermif_at_controller('VtnOne','VTermOne','VTermIfOne','ControllerFirst',presence="no",position=0)
    if retval != 0:
      print "VTERM1->VTERMIF1 Validate Failed"
      exit(1)

    retval=vtermif_portmap.validate_vtermif_at_controller('VtnOne','VTermOne','VTermIfThree','ControllerFirst',presence="no",position=0)
    if retval != 0:
      print "VTERM1->VTERMIF3 Validate Failed"
      exit(1)

    retval=vtermif_portmap.validate_vtermif_at_controller('VtnOne','VTermTwo','VTermIfOne','ControllerFirst',presence="no",position=0)
    if retval != 0:
      print "VTERM2->VTERMIF1 Validate Failed"
      exit(1)

    retval = vtermif_portmap.delete_vtermif('VtnOne','VTermTwo','VTermIfTwo')
    if retval != 0:
      print "VTERM2->VTERMIF2 Delete Failed"
      exit(1)

    retval=vtermif_portmap.validate_vtermif_at_controller('VtnOne','VTermTwo','VTermIfTwo','ControllerFirst',presence="no",position=0)
    if retval != 0:
      print "VTERM2->VTERMIF2 Validate Failed"
      exit(1)
    retval = vtn_vterm.delete_vterm('VtnOne','VTermOne')
    if retval != 0:
      print "VTERM1/VTN Delete Failed"
      exit(1)

    retval = vtn_vterm.delete_vterm('VtnOne','VTermTwo')
    if retval != 0:
      print "VTERM2/VTN Delete Failed"
      exit(1)

    retval=vtn_vterm.validate_vterm_at_controller('VtnOne','VTermOne','ControllerFirst',presence="no",position=0)
    if retval != 0:
      print "VTERM1/VTN Validate Failed"
      exit(1)

    retval=vtn_vterm.validate_vterm_at_controller('VtnOne','VTermTwo','ControllerFirst',presence="no",position=0)
    if retval != 0:
      print "VTERM2/VTN Validate Failed"
      exit(1)

    retval=vtn_vterm.validate_vtn_at_controller('VtnOne','ControllerFirst',presence="no")
    if retval != 0:
      print "VTN Validate Failed"
      exit(1)

    retval = vtn_vterm.delete_vtn('VtnOne')
    if retval != 0:
      print "VTN Delete Failed in coordinator"
      exit(1)

    print "DELETE CONTROLLER"
    retval=controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
      print "CONTROLLER delete failed"
      exit(1)
    print "VTN1->VTERM1->VTERMIF1/VTERMIF3 AND VTN1->VTERM2->VTERMIF1/VTERMIF2 AUDIT TEST SUCCESS"
Esempio n. 3
0
def test_audit_vtn_vterm_vtermif_portmap():

    print "CREATE Controller"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
      print "TEST 4 :Controller Create Failed"
      exit(1)

    print "TEST 4 : Test Audit with VTenant one VTerminal one VTERMIF and One PORTMAP"
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)
    retval=vtn_vterm.create_vtn('VtnOne')
    if retval != 0:
      print "VTN Create Failed"
      exit(1)

    retval=vtn_vterm.create_vterm('VtnOne','VTermOne','ControllerFirst')
    if retval != 0:
      print "VTERM Create Failed"
      exit(1)


    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
    retval=controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
    if retval != 0:
     print "controller invalid_ip update failed"
     exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"down")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval=vtermif_portmap.create_vtermif('VtnOne','VTermOne','VTermIfOne')
    if retval != 0:
      print "VTERMIF Create Failed"
      exit(1)

    retval=vtermif_portmap.create_portmap('VtnOne','VTermOne','VTermIfOne');
    if retval != 0:
      print "Portmap Create Failed"
      exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
    retval=controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
    if retval != 0:
      print "controller valid_ip update failed"
      exit(1)
   # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval=vtermif_portmap.validate_vtermif_portmap_at_controller('VtnOne','VTermOne','VTermIfOne','ControllerFirst',presence="yes");
    if retval != 0:
      print "Portmap Validate Failed"
      exit(1)

    retval=vtn_vterm.validate_vterm_at_controller('VtnOne','VTermOne','ControllerFirst')
    if retval != 0:
      print "After Create VTERM Validate Failed"
      exit(1)

    retval=vtn_vterm.validate_vtn_at_controller('VtnOne','ControllerFirst')
    if retval != 0:
      print "VTN Validate Failed"
      exit(1)

    retval=vtermif_portmap.delete_portmap('VtnOne','VTermOne','VTermIfOne');
    if retval != 0:
      print "Portmap Delete Failed"
      exit(1)

    retval = vtermif_portmap.delete_vtermif('VtnOne','VTermOne','VTermIfOne')
    if retval != 0:
      print "VTERMIF Delete Failed"
      exit(1)

    retval=vtermif_portmap.validate_vtermif_at_controller('VtnOne','VTermOne','VTermIfOne','ControllerFirst',presence="no",position=0)
    if retval != 0:
      print "After Delete VTERMIF Validate Failed"
      exit(1)

    retval = vtn_vterm.delete_vterm('VtnOne','VTermOne')
    if retval != 0:
      print "VTERM/VTN Delete Failed"
      exit(1)

    retval=vtn_vterm.validate_vterm_at_controller('VtnOne','VTermOne','ControllerFirst',presence="no")
    if retval != 0:
      print "After Delete VTERM Validate Failed"
      exit(1)

    retval=vtn_vterm.validate_vtn_at_controller('VtnOne','ControllerFirst',presence="no")
    if retval != 0:
      print "VTN Validate Failed after VTERM Deleted"
      exit(1)

    retval = vtn_vterm.delete_vtn('VtnOne')
    if retval != 0:
      print "VTN Delete Failed in coordinator"
      exit(1)

    print "DELETE CONTROLLER"
    retval=controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
      print "CONTROLLER delete failed"
      exit(1)
    print "VTN->VTERM->VTERMIF->PORTMAP AUDIT TEST SUCCESS"
Esempio n. 4
0
def test_vtn_vterm_audit_1():

    print "****CREATE Controller with valid IP****"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
        print "Controller Create Failed"
        exit(1)

    print """TEST 1 : create VTN and VTERM when controller is up
             change the controller status to down delete VTN and VTERM
             trigger Audit"""
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)
    print "****Create VTN****"
    retval = vtn_vterm.create_vtn('VtnOne')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    print "****Create VTERM****"
    retval = vtn_vterm.create_vterm('VtnOne','VTermOne','ControllerFirst')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)


    retval =  vtn_vterm.validate_vtn_at_controller('VtnOne','ControllerFirst')
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)


    retval =  vtn_vterm.validate_vterm_at_controller('VtnOne','VTermOne','ControllerFirst')
    if retval != 0:
        print "VTERM Validate Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller invalid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"down")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    print "****Delete VTERM****"
    retval = vtn_vterm.delete_vterm('VtnOne','VTermOne')
    if retval != 0:
        print "VTERM/VTN Delete Failed"
        exit(1)

    print "****Delete VTN****"
    retval = vtn_vterm.delete_vtn('VtnOne')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller valid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval =  vtn_vterm.validate_vterm_at_controller('VtnOne','VTermOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTERM Validate Failed"
        exit(1)

    retval =  vtn_vterm.validate_vtn_at_controller('VtnOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)


    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
        print "CONTROLLER delete failed"
        exit(1)
    print "VTN->VTERM AUDIT TEST SUCCESS"
Esempio n. 5
0
def test_multi_vtn_with_vterm_audit_test():

    print "CREATE Controller"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
        print "Controller Create Failed"
        exit(1)

    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)
    print "TEST 6 : 2 Tenants with one VTerminal each and test AUDIT"
    print "VTNONE->VTERMONE"
    print "VTNTWO->VTERMONE"

    retval = vtn_vterm.create_vtn('VtnOne')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval = vtn_vterm.create_vtn('VtnTwo')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm('VtnOne','VTermOne','ControllerFirst')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm('VtnTwo','VTermOne','ControllerFirst')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval =  vtn_vterm.validate_vtn_at_controller('VtnOne','ControllerFirst',position=0)
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    retval =  vtn_vterm.validate_vtn_at_controller('VtnTwo','ControllerFirst',position=1)
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    retval =  vtn_vterm.validate_vterm_at_controller('VtnOne','VTermOne','ControllerFirst')
    if retval != 0:
        print "VTERM Validate Failed"
        exit(1)

    retval =  vtn_vterm.validate_vterm_at_controller('VtnTwo','VTermOne','ControllerFirst')
    if retval != 0:
        print "VTERM Validate Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller invalid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"down")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval = vtn_vterm.delete_vterm('VtnOne','VTermOne')
    if retval != 0:
        print "VTERM/VTN Delete Failed"
        exit(1)

    retval = vtn_vterm.delete_vterm('VtnTwo','VTermOne')
    if retval != 0:
        print "VTERM/VTN Delete Failed"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller valid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval =  vtn_vterm.validate_vterm_at_controller('VtnOne','VTermOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTERM Validate Failed"
        exit(1)

    retval =  vtn_vterm.validate_vtn_at_controller('VtnOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)


    retval =  vtn_vterm.validate_vterm_at_controller('VtnTwo','VTermOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTERM Validate Failed"
        exit(1)

    retval =  vtn_vterm.validate_vtn_at_controller('VtnTwo','ControllerFirst',presence="no")
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    retval = vtn_vterm.delete_vtn('VtnOne')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)


    retval = vtn_vterm.delete_vtn('VtnTwo')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
        print "CONTROLLER delete failed"
        exit(1)

    print "MULTI VTN->VTERM AUDIT TEST SUCCESS"
Esempio n. 6
0
def update_vbrif_flowfilter_pass_audit():
  print "CREATE Controller"
  retval = controller.add_controller_ex('ControllerFirst')
  if retval != 0:
    print "Controller Create Failed"
    exit(1)

  print "TEST 4 : VBRIF->Update AUDIT FLOWFILTER DROP TEST"
  # Delay for AUDIT
  retval=controller.wait_until_state('ControllerFirst', "up")
  if retval != 0:
    print "Controller state check Failed"
    exit(1)

  retval=vtn_vbr.create_vtn('VtnOne')
  if retval != 0:
    print "VTN Create Failed"
    exit(1)

  retval=vtn_vbr.create_vbr('VtnOne','VbrOne','ControllerFirst')
  if retval != 0:
    print "VTN Create Failed"
    exit(1)

  retval=vbrif_portmap.create_vbrif('VtnOne','VbrOne','VbrIfOne')
  if retval != 0:
    print "VBRIF Create Failed"
    exit(1)

  retval=vtn_vbr.create_vbr('VtnOne','VbrTwo','ControllerFirst')
  if retval != 0:
    print "VTN Create Failed"
    exit(1)

  retval=vbrif_portmap.create_vbrif('VtnOne','VbrTwo','VbrIfTwo')
  if retval != 0:
    print "VBRIF Create Failed"
    exit(1)

  retval=vbrif_portmap.create_portmap('VtnOne','VbrOne','VbrIfOne');
  if retval != 0:
    print "Portmap Create Failed"
    exit(1)

  retval=vbrif_portmap.create_portmap('VtnOne','VbrTwo','VbrIfTwo');
  if retval != 0:
    print "Portmap Create Failed"
    exit(1)

  retval=vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst')
  if retval != 0:
    print "VTN Validate Failed"
    exit(1)

  retval=vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst')
  if retval != 0:
    print "VBR Validate Failed"
    exit(1)

  retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfOne','ControllerFirst')
  if retval != 0:
    print "After Create VBRIF Validate Failed"
    exit(1)

  retval=vtn_vbr.validate_vbr_at_controller('VtnOne','VbrTwo','ControllerFirst', presence = 'yes', position = 0)
  if retval != 0:
    print "VBR Validate Failed"
    exit(1)

  retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrTwo','VbrIfTwo','ControllerFirst', presence = 'yes', position = 0)
  if retval != 0:
    print "After Create VBRIF Validate Failed"
    exit(1)

  print "****UPDATE Controller IP to invalid****"
  test_invalid_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
  retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
  if retval != 0:
    print "controller invalid_ip update failed"
    exit(1)
  # Delay for AUDIT
  retval = controller.wait_until_state('ControllerFirst',"down")
  if retval != 0:
    print "controller state change failed"
    exit(1)



  retval=flowlistentry.create_flowlist('FlowlistOne')
  if retval != 0:
    print "FlowList Create Failed"
    exit(1)

  retval=flowlistentry.create_flowlistentry('FlowlistOne', 'FlowlistentryOne','ControllerFirst')
  if retval != 0:
    print "FlowlistEntry Create Failed"
    exit(1)

  retval=flowfilter.create_flowfilter('VtnOne|VbrOne|VbrIfOne', 'FlowfilterOnePass')
  if retval != 0:
    print "VBRFlowFilter Create Failed"
    exit(1)

  retval=flowfilter.create_flowfilter_entry('VtnOne|VbrOne|VbrIfOne', 'FlowfilterOnePass')
  if retval != 0:
    print "VBRFlowFilterEntry Create Failed"
    exit(1)

  print "****UPDATE Controller IP to Valid****"
  test_controller_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
  retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
  if retval != 0:
    print "controller valid_ip update failed"
    exit(1)
  # Delay for AUDIT
  retval = controller.wait_until_state('ControllerFirst',"up")
  if retval != 0:
    print "controller state change failed"
    exit(1)

  retval=flowfilter.validate_flowfilter_at_controller('VtnOne|VbrOne|VbrIfOne', 'ControllerFirst', 'FlowfilterOnePass', presence='yes', position=0)
  if retval != 0:
    print "FlowFilter validation at Controller Failed"
    exit(1)

  retval=vtn_vbr.create_vbr('VtnOne','VbrThree','ControllerFirst')
  if retval != 0:
    print "VTN Create Failed"
    exit(1)

  retval=vbrif_portmap.create_vbrif('VtnOne','VbrThree', 'VbrIfThree')
  if retval != 0:
    print "VBRIF Create Failed"
    exit(1)

  retval=vbrif_portmap.create_portmap('VtnOne','VbrThree','VbrIfThree');
  if retval != 0:
    print "Portmap Create Failed"
    exit(1)

  retval=flowfilter.update_flowfilter_entry('VtnOne|VbrOne|VbrIfOne', 'FlowfilterOnePass', 'UpdateFlowfilterOnePass')
  if retval != 0:
    print "VBRFIFlowFilterEntry Update Failed"
    exit(1)

  retval=flowfilter.validate_flowfilter_at_controller('VtnOne|VbrOne|VbrIfOne', 'ControllerFirst','UpdateFlowfilterOnePass', presence='yes', position=0)
  if retval != 0:
    print "VBRFIFlowFilterEntry Updatation Validate Failed at Co-ordinator"
    exit(1)

  retval=flowfilter.delete_flowfilter_entry('VtnOne|VbrOne|VbrIfOne', 'FlowfilterOnePass')
  if retval != 0:
    print "VBRFlowFilterEntry deletete Failed"
    exit(1)

  retval=flowfilter.delete_flowfilter('VtnOne|VbrOne|VbrIfOne', 'FlowfilterOnePass')
  if retval != 0:
    print "VBRFlowFilter deletete Failed"
    exit(1)

  retval=flowlistentry.delete_flowlistentry('FlowlistOne', 'FlowlistentryOne')
  if retval != 0:
    print "FlowilistEntry deletete Failed"
    exit(1)

  retval=flowlistentry.delete_flowlist('FlowlistOne')
  if retval != 0:
    print "Flowilist deletete Failed"
    exit(1)

  retval=flowfilter.validate_flowfilter_at_controller('VtnOne|VbrOne|VbrIfOne', 'ControllerFirst', 'FlowfilterOnePass', presence='no', position=0)
  if retval != 0:
    print "FlowFilter validation Failed after deleting"
    exit(1)

  retval=vtn_vbr.delete_vtn('VtnOne')
  if retval != 0:
    print "DELETE VTN Failed"
    exit(1)

  retval=vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst', presence='no')
  if retval != 0:
    print "VTN Validate Failed"
    exit(1)

  print "DELETE CONTROLLER"
  retval=controller.delete_controller_ex('ControllerFirst')
  if retval != 0:
     print "CONTROLLER delete failed"
     exit(1)
  print "VBR->AUDIT UPDATE FLOWFILTER DROP TEST SUCCESS"
def test_audit_vtn_vterm_vtermif_portmap_multi_controller():

    print "CREATE Controller"
    retval = controller.add_controller_ex("ControllerFirst")
    if retval != 0:
        print "TEST 4 :Controller1 Create Failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerFirst", "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    retval = controller.add_controller_ex("ControllerSecond")
    if retval != 0:
        print "TEST 4 :Controller2 Create Failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerSecond", "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    print "TEST 4 : VTenant with one VTerminal one VTERMIF and One PORTMAP with multi-controller"

    retval = vtn_vterm.create_vtn("VtnOne")
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm("VtnOne", "VTermOne", "ControllerFirst")
    if retval != 0:
        print "VTERM1 Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm("VtnOne", "VTermThree", "ControllerSecond")
    if retval != 0:
        print "VTERM3 Create Failed"
        exit(1)

    retval = vtermif_portmap.create_vtermif("VtnOne", "VTermOne", "VTermIfOne")
    if retval != 0:
        print "VTERMIF1 Create Failed"
        exit(1)

    retval = vtermif_portmap.create_vtermif("VtnOne", "VTermThree", "VTermIfTwo")
    if retval != 0:
        print "VTERMIF2 Create Failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_at_controller("VtnOne", "VTermOne", "VTermIfOne", "ControllerFirst")
    if retval != 0:
        print "After Create VTERMIF1 Validate Failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_at_controller("VtnOne", "VTermThree", "VTermIfTwo", "ControllerSecond")
    if retval != 0:
        print "After Create VTERMIF2 Validate Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerFirst")["invalid_ipaddr"]
    retval = controller.update_controller_ex("ControllerFirst", ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller1 invalid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerFirst", "down")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    test_invalid_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerSecond")["invalid_ipaddr"]
    retval = controller.update_controller_ex("ControllerSecond", ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller2 invalid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerSecond", "down")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    retval = vtermif_portmap.create_portmap("VtnOne", "VTermOne", "VTermIfOne")
    if retval != 0:
        print "Portmap1 Create Failed"
        exit(1)

    retval = vtermif_portmap.create_portmap("VtnOne", "VTermThree", "VTermIfTwo")
    if retval != 0:
        print "Portmap2 Create Failed"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerFirst")["ipaddr"]
    retval = controller.update_controller_ex("ControllerFirst", ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller1 valid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerFirst", "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    test_controller_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerSecond")["ipaddr"]
    retval = controller.update_controller_ex("ControllerSecond", ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller2 valid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerSecond", "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_portmap_at_controller(
        "VtnOne", "VTermOne", "VTermIfOne", "ControllerFirst", presence="yes"
    )
    if retval != 0:
        print "Portmap1 Validate Failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_portmap_at_controller(
        "VtnOne", "VTermThree", "VTermIfTwo", "ControllerSecond", presence="yes"
    )
    if retval != 0:
        print "Portmap2 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnOne", "VTermOne", "ControllerFirst")
    if retval != 0:
        print "After Create VTERM1 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnOne", "VTermThree", "ControllerSecond")
    if retval != 0:
        print "After Create VTERM3 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnOne", "ControllerFirst")
    if retval != 0:
        print "VTN Validate Failed at controller1"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnOne", "ControllerSecond")
    if retval != 0:
        print "VTN Validate Failed at controller2"
        exit(1)

    retval = vtermif_portmap.delete_portmap("VtnOne", "VTermOne", "VTermIfOne")
    if retval != 0:
        print "Portmap1 Delete Failed"
        exit(1)

    retval = vtermif_portmap.delete_portmap("VtnOne", "VTermThree", "VTermIfTwo")
    if retval != 0:
        print "Portmap2 Delete Failed"
        exit(1)

    #    retval=vtermif_portmap.validate_vtermif_portmap_at_controller('VtnOne','VTermOne','VTermIfOne','ControllerFirst',presence="no");
    #    if retval != 0:
    #        print "After Delete Portmap1 Validate Failed"
    #        exit(1)

    #    retval=vtermif_portmap.validate_vtermif_portmap_at_controller('VtnOne','VTermThree','VTermIfTwo','ControllerSecond',presence="no");
    #    if retval != 0:
    #        print "After Delete Portmap2 Validate Failed"
    #        exit(1)

    retval = vtermif_portmap.delete_vtermif("VtnOne", "VTermOne", "VTermIfOne")
    if retval != 0:
        print "VTERMIF1 Delete Failed"
        exit(1)

    retval = vtermif_portmap.delete_vtermif("VtnOne", "VTermThree", "VTermIfTwo")
    if retval != 0:
        print "VTERMIF2 Delete Failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_at_controller(
        "VtnOne", "VTermOne", "VTermIfOne", "ControllerFirst", presence="no", position=0
    )
    if retval != 0:
        print "After Delete VTERMIF1 Validate Failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_at_controller(
        "VtnOne", "VTermThree", "VTermIfTwo", "ControllerSecond", presence="no", position=0
    )
    if retval != 0:
        print "After Delete VTERMIF2 Validate Failed"
        exit(1)

    retval = vtn_vterm.delete_vterm("VtnOne", "VTermOne")
    if retval != 0:
        print "VTERM1/VTN Delete Failed"
        exit(1)

    retval = vtn_vterm.delete_vterm("VtnOne", "VTermThree")
    if retval != 0:
        print "VTERM3/VTN Delete Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnOne", "VTermOne", "ControllerFirst", presence="no")
    if retval != 0:
        print "After Delete VTERM1 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnOne", "VTermThree", "ControllerSecond", presence="no")
    if retval != 0:
        print "After Delete VTERM2 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnOne", "ControllerFirst", presence="no")
    if retval != 0:
        print "VTN Validate Failed after VTERM1 Deleted at controller1"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnOne", "ControllerSecond", presence="no")
    if retval != 0:
        print "VTN Validate Failed after VTERM3 Deleted at controller2"
        exit(1)

    retval = vtn_vterm.delete_vtn("VtnOne")
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex("ControllerFirst")
    if retval != 0:
        print "CONTROLLER1 delete failed"
        exit(1)

    retval = controller.delete_controller_ex("ControllerSecond")
    if retval != 0:
        print "CONTROLLER2 delete failed"
        exit(1)

    print "VTN->VTERM->VTERMIF->PORTMAP MULTI-CONTROLER TEST SUCCESS"
Esempio n. 8
0
def test_audit_vtn_vbr_multi_vbrif_portmap():
    print "CREATE Controller"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
        print "TEST 6 :Controller Create Failed"
        exit(1)

    print "TEST 6 : VTenant with one VBridge Two VBRIF1/VBRIF2 and One PORTMAP in VBRIF1"
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)
    retval=vtn_vbr.create_vtn('VtnOne')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval=vtn_vbr.create_vbr('VtnOne','VbrOne','ControllerFirst')
    if retval != 0:
        print "VBR1 Create Failed"
        exit(1)

    retval=vbrif_portmap.create_vbrif('VtnOne','VbrOne','VbrIfOne')
    if retval != 0:
        print "VBRIF1 Create Failed"
        exit(1)

    retval=vbrif_portmap.create_vbrif('VtnOne','VbrOne','VbrIfTwo')
    if retval != 0:
        print "VBRIF2 Create Failed"
        exit(1)

    retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfOne','ControllerFirst',position=0)
    if retval != 0:
        print "After Create VBRIF1 Validate Failed"
        exit(1)

    retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfTwo','ControllerFirst',position=1)
    if retval != 0:
        print "After Create VBRIF2 Validate Failed"
        exit(1)

    retval=vbrif_portmap.create_portmap('VtnOne','VbrOne','VbrIfOne');
    if retval != 0:
        print "VBRIF1 Portmap Create Failed"
        exit(1)

    retval=vbrif_portmap.validate_vbrif_portmap_at_controller('VtnOne','VbrOne','VbrIfOne','ControllerFirst',presence="yes",position=0);
    if retval != 0:
        print "VBRIF1 Portmap Validate Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
    retval=controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
    if retval != 0:
     print "controller invalid_ip update failed"
     exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"down")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval=vbrif_portmap.delete_portmap('VtnOne','VbrOne','VbrIfOne');
    if retval != 0:
        print "Portmap Delete Failed"
        exit(1)

    retval=vbrif_portmap.create_portmap('VtnOne','VbrOne','VbrIfTwo');
    if retval != 0:
        print "VBRIF2 Portmap Create Failed"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
    retval=controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
    if retval != 0:
     print "controller valid_ip update failed"
     exit(1)
   # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval=vbrif_portmap.validate_vbrif_portmap_at_controller('VtnOne','VbrOne','VbrIfTwo','ControllerFirst',presence="yes",position=0);
    if retval != 0:
        print "VBRIF2 Portmap Validate Failed"
        exit(1)

    retval=vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst',position=0)
    if retval != 0:
        print "After Create VBR1 Validate Failed"
        exit(1)

    retval=vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst')
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    retval=vbrif_portmap.delete_portmap('VtnOne','VbrOne','VbrIfTwo');
    if retval != 0:
        print "Portmap Delete Failed"
        exit(1)

    retval=vbrif_portmap.validate_vbrif_portmap_at_controller('VtnOne','VbrOne','VbrIfOne','ControllerFirst',presence="no",position=0);
    if retval != 0:
        print "After Delete VBRIF1 Portmap Validate Failed"
        exit(1)

    retval = vbrif_portmap.delete_vbrif('VtnOne','VbrOne','VbrIfOne')
    if retval != 0:
        print "VBRIF1 Delete Failed"
        exit(1)

    retval = vbrif_portmap.delete_vbrif('VtnOne','VbrOne','VbrIfTwo')
    if retval != 0:
        print "VBRIF2 Delete Failed"
        exit(1)

    retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfOne','ControllerFirst',presence="no",position=0)
    if retval != 0:
        print "After Delete VBRIF1 Validate Failed"
        exit(1)

    retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfTwo','ControllerFirst',presence="no",position=1)
    if retval != 0:
        print "After Delete VBRIF2 Validate Failed"
        exit(1)

    retval = vtn_vbr.delete_vbr('VtnOne','VbrOne')
    if retval != 0:
        print "VBR/VTN Delete Failed"
        exit(1)

    retval=vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst',presence="no")
    if retval != 0:
        print "After Delete VBR Validate Failed"
        exit(1)

    retval=vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTN Validate Failed after VBR Deleted"
        exit(1)

    retval = vtn_vbr.delete_vtn('VtnOne')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    print "DELETE CONTROLLER"
    retval=controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
        print "CONTROLLER delete failed"
        exit(1)
    print "VTN1->VBR1->VBRIF1->PORTMAP(DELETE) AND VTN1->VBR1->VBRIF2->PORTMAP(CREATE) AUDIT TEST SUCCESS"
def test_vtermif_flowfilter_drop_audit():
  print "CREATE Controller"
  retval = controller.add_controller_ex('ControllerFirst')
  if retval != 0:
    print "Controller Create Failed"
    exit(1)

  print "TEST 5 : VTERMIF->AUDIT FLOWFILTER TEST"
  # Delay for AUDIT
  retval=controller.wait_until_state('ControllerFirst', "up")
  if retval != 0:
    print "Controller state check Failed"
    exit(1)

  retval=vtn_vbr.create_vtn('VtnOne')
  if retval != 0:
    print "VTN Create Failed"
    exit(1)

  retval=vtn_vbr.create_vbr('VtnOne','VbrOne','ControllerFirst')
  if retval != 0:
    print "VTN Create Failed"
    exit(1)

  retval=vbrif_portmap.create_vbrif('VtnOne','VbrOne','VbrIfOne')
  if retval != 0:
    print "VBRIF Create Failed"
    exit(1)

  retval=vtn_vbr.create_vbr('VtnOne','VbrTwo','ControllerFirst')
  if retval != 0:
    print "VTN Create Failed"
    exit(1)

  retval=vbrif_portmap.create_vbrif('VtnOne','VbrTwo','VbrIfTwo')
  if retval != 0:
    print "VBRIF Create Failed"
    exit(1)

  retval=vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst')
  if retval != 0:
    print "VTN Validate Failed"
    exit(1)

  retval=vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst')
  if retval != 0:
    print "VBR Validate Failed"
    exit(1)

  retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfOne','ControllerFirst')
  if retval != 0:
    print "After Create VBRIF Validate Failed"
    exit(1)

  retval=vbrif_portmap.create_portmap('VtnOne','VbrOne','VbrIfOne');
  if retval != 0:
    print "Portmap Create Failed"
    exit(1)

  retval=vbrif_portmap.create_portmap('VtnOne','VbrTwo','VbrIfTwo');
  if retval != 0:
    print "Portmap Create Failed"
    exit(1)

  retval = vtn_vterm.create_vterm('VtnOne','VTermOne','ControllerFirst')
  if retval != 0:
    print "VTERM Create Failed"
    exit(1)

  retval = vtermif_portmap.create_vtermif('VtnOne','VTermOne','VTermIfOne')
  if retval != 0:
    print "VTERMIF Create Failed"
    exit(1)
    retval=flowlistentry.create_flowlist('FlowlistOne')

  retval = vtermif_portmap.create_portmap('VtnOne','VTermOne','VTermIfOne');
  if retval != 0:
    print "Portmap Create Failed"
    exit(1)

  retval=flowlistentry.create_flowlist('FlowlistOne')
  if retval != 0:
    print "FlowList Create Failed"
    exit(1)

  retval=flowlistentry.create_flowlistentry('FlowlistOne', 'FlowlistentryOne','ControllerFirst')
  if retval != 0:
    print "FlowlistEntry Create Failed"
    exit(1)

  retval=flowfilter.create_flowfilter('VtnOne|VTermOne|VbrIfOne|VTermIfOne', 'FlowfilterOneDrop')
  if retval != 0:
    print "VTERMFlowFilter Create Failed"
    exit(1)

  retval=flowfilter.create_flowfilter_entry('VtnOne|VTermOne|VbrIfOne|VTermIfOne', 'FlowfilterOneDrop')
  if retval != 0:
    print "VTERMFlowFilterEntry Create Failed"
    exit(1)
  print "****UPDATE Controller IP to invalid****"
  test_invalid_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
  retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
  if retval != 0:
    print "controller invalid_ip update failed"
    exit(1)
  # Delay for AUDIT
  retval = controller.wait_until_state('ControllerFirst',"down")
  if retval != 0:
    print "controller state change failed"
    exit(1)

  retval=flowfilter.delete_flowfilter_entry('VtnOne|VTermOne|VbrIfOne|VTermIfOne', 'FlowfilterOneDrop')
  if retval != 0:
    print "VTERMFlowFilterEntry deletete Failed"
    exit(1)

  retval=flowfilter.delete_flowfilter('VtnOne|VTermOne|VbrIfOne|VTermIfOne', 'FlowfilterOneDrop')
  if retval != 0:
    print "VTERMFlowFilter deletete Failed"
    exit(1)

  retval=flowlistentry.delete_flowlistentry('FlowlistOne', 'FlowlistentryOne')
  if retval != 0:
    print "FlowilistEntry deletete Failed"
    exit(1)

  retval=flowlistentry.delete_flowlist('FlowlistOne')
  if retval != 0:
    print "Flowilist deletete Failed"
    exit(1)


  retval=vtn_vbr.delete_vtn('VtnOne')
  if retval != 0:
    print "DELETE VTN Failed"
    exit(1)


  print "DELETE CONTROLLER"
  retval=controller.delete_controller_ex('ControllerFirst')
  if retval != 0:
     print "CONTROLLER delete failed"
     exit(1)
  print "VTERM->AUDIT FLOWFILTER TEST SUCCESS"
Esempio n. 10
0
def test_audit_multi_vbrif():

    print "CREATE Controller"
    print "VTNONE->VBRONE->VBRIFONE"
    print "VTNONE->VBRONE->VBRIFTWO"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
        print "TEST 2 :Controller Create Failed"
        exit(1)

    print "TEST 2 : Test audit One vtn and one VBridge with Two Interfaces"
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)
    retval=vtn_vbr.create_vtn('VtnOne')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval=vtn_vbr.create_vbr('VtnOne','VbrOne','ControllerFirst')
    if retval != 0:
        print "VBR Create Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
    retval=controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
    if retval != 0:
     print "controller invalid_ip update failed"
     exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"down")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval=vbrif_portmap.create_vbrif('VtnOne','VbrOne','VbrIfOne')
    if retval != 0:
        print "VBRIFONE Create Failed"
        exit(1)

    retval=vbrif_portmap.create_vbrif('VtnOne','VbrOne','VbrIfTwo')
    if retval != 0:
        print "VBRIFTWO Create Failed"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
    retval=controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
    if retval != 0:
     print "controller valid_ip update failed"
     exit(1)
   # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfTwo','ControllerFirst',position=1)
    if retval != 0:
        print "VBRIFTWO Validate Failed"
        exit(1)

    retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfOne','ControllerFirst',position=0)
    if retval != 0:
        print "VBRIFONE Validate Failed"
        exit(1)

    retval=vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst')
    if retval != 0:
        print "VBR Validate Failed"
        exit(1)

    retval=vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst')
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    retval = vbrif_portmap.delete_vbrif('VtnOne','VbrOne','VbrIfOne')
    if retval != 0:
        print "VTN1->VBR1->VBRIF1 Delete Failed"
        exit(1)

    retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfOne','ControllerFirst',presence="no",position=0)
    if retval != 0:
        print "After Delete VBRIFONE Validate Failed"
        exit(1)

    retval = vbrif_portmap.delete_vbrif('VtnOne','VbrOne','VbrIfTwo')
    if retval != 0:
        print "VTN1->VBR1->VBRIF1 Delete Failed"
        exit(1)

    retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfTwo','ControllerFirst',presence="no",position=1)
    if retval != 0:
        print "After Delete VBRIFTWO Validate Failed"
        exit(1)

    retval = vtn_vbr.delete_vbr('VtnOne','VbrOne')
    if retval != 0:
        print "VBR/VTN Delete Failed"
        exit(1)

    retval=vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst',presence="no")
    if retval != 0:
        print "After Delete VBR Validate Failed"
        exit(1)

    retval=vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    retval = vtn_vbr.delete_vtn('VtnOne')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    print "DELETE CONTROLLER"
    retval=controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
        print "CONTROLLER delete failed"
        exit(1)
    print "VTN->VBR->VBRIF1/VBRIF2 AUDIT TEST SUCCESS"
Esempio n. 11
0
def test_audit_vtn_vbr_vbrif():

    print "CREATE Controller"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
        print "TEST 1 :Controller Create Failed"
        exit(1)

    print "TEST 1: Test Audit VTenant with one VBridge one VBRIF"
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval=vtn_vbr.create_vtn('VtnOne')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval=vtn_vbr.create_vbr('VtnOne','VbrOne','ControllerFirst')
    if retval != 0:
        print "VBR Create Failed"
        exit(1)

    retval=vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst')
    if retval != 0:
        print "After Create VBR Validate Failed"
        exit(1)

    retval=vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst')
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
    retval=controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
    if retval != 0:
     print "controller invalid_ip update failed"
     exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"down")

    if retval != 0:
      print "controller state change failed"
      exit(1)
    retval=vbrif_portmap.create_vbrif('VtnOne','VbrOne','VbrIfOne')
    if retval != 0:
        print "VBRIF Create Failed"
        exit(1)


    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
    retval=controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
    if retval != 0:
     print "controller valid_ip update failed"
     exit(1)
   # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfOne','ControllerFirst')
    if retval != 0:
        print "After Create VBRIF Validate Failed"
        exit(1)

    retval = vbrif_portmap.delete_vbrif('VtnOne','VbrOne','VbrIfOne')
    if retval != 0:
        print "VBRIF Delete Failed"
        exit(1)

    retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfOne','ControllerFirst',presence="no",position=0)
    if retval != 0:
        print "After Delete VBRIF Validate Failed"
        exit(1)

    retval = vtn_vbr.delete_vbr('VtnOne','VbrOne')
    if retval != 0:
        print "VBR/VTN Delete Failed"
        exit(1)

    retval=vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst',presence="no")
    if retval != 0:
        print "After Delete VBR Validate Failed"
        exit(1)

    retval=vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTN Validate Failed after VBR Deleted"
        exit(1)

    retval = vtn_vbr.delete_vtn('VtnOne')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    print "DELETE CONTROLLER"
    retval=controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
        print "CONTROLLER delete failed"
        exit(1)
    print "VTN->VBR->VBRIF AUDIT TEST SUCCESS"
def test_multi_vtn_with_vterm_multi_controller_audit_test():
    print "TEST 3 : 2 Tenants with one VTerminal each in multi-controller and test AUDIT"
    print "CONTROLLER1->VTNONE->VTERMONE"
    print "CONTROLLER1->VTNTWO->VTERMONE"
    print "CONTROLLER2->VTNTHREE->VTERMONE"
    print "CONTROLLER2->VTNFOUR->VTERMONE"
    print "CREATE Controller"
    retval = controller.add_controller_ex("ControllerFirst")
    if retval != 0:
        print "Controller1 Create Failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerFirst", "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    retval = controller.add_controller_ex("ControllerSecond")
    if retval != 0:
        print "Controller2 Create Failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerSecond", "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    retval = vtn_vterm.create_vtn("VtnOne")
    if retval != 0:
        print "VTN1 Create Failed"
        exit(1)

    retval = vtn_vterm.create_vtn("VtnTwo")
    if retval != 0:
        print "VTN2 Create Failed"
        exit(1)

    retval = vtn_vterm.create_vtn("VtnThree")
    if retval != 0:
        print "VTN3 Create Failed"
        exit(1)

    retval = vtn_vterm.create_vtn("VtnFour")
    if retval != 0:
        print "VTN4 Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm("VtnOne", "VTermOne", "ControllerFirst")
    if retval != 0:
        print "VTERM1/VTN1 Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm("VtnTwo", "VTermOne", "ControllerFirst")
    if retval != 0:
        print "VTERM1/VTN2 Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm("VtnThree", "VTermThree", "ControllerSecond")
    if retval != 0:
        print "VTERM3/VTN3 Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm("VtnFour", "VTermThree", "ControllerSecond")
    if retval != 0:
        print "VTERM3/VTN4 Create Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnOne", "ControllerFirst", position=0)
    if retval != 0:
        print "VTN1 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnTwo", "ControllerFirst", position=1)
    if retval != 0:
        print "VTN2 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnThree", "ControllerSecond", position=1)
    if retval != 0:
        print "VTN3 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnFour", "ControllerSecond", position=0)
    if retval != 0:
        print "VTN4 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnOne", "VTermOne", "ControllerFirst")
    if retval != 0:
        print "VTERM1/VTN1 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnTwo", "VTermOne", "ControllerFirst")
    if retval != 0:
        print "VTERM1/VTN2 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnThree", "VTermThree", "ControllerSecond")
    if retval != 0:
        print "VTERM3/VTN3 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnFour", "VTermThree", "ControllerSecond")
    if retval != 0:
        print "VTERM4/VTN4 Validate Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerFirst")["invalid_ipaddr"]
    retval = controller.update_controller_ex("ControllerFirst", ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller1 invalid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerFirst", "down")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    test_invalid_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerSecond")["invalid_ipaddr"]
    retval = controller.update_controller_ex("ControllerSecond", ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller2 invalid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerSecond", "down")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    print "****DELETE VTERM****"
    retval = vtn_vterm.delete_vterm("VtnOne", "VTermOne")
    if retval != 0:
        print "VTERM1/VTN1 Delete Failed"
        exit(1)

    retval = vtn_vterm.delete_vterm("VtnTwo", "VTermOne")
    if retval != 0:
        print "VTERM1/VTN2 Delete Failed"
        exit(1)

    retval = vtn_vterm.delete_vterm("VtnThree", "VTermThree")
    if retval != 0:
        print "VTERM3/VTN3 Delete Failed"
        exit(1)

    retval = vtn_vterm.delete_vterm("VtnFour", "VTermThree")
    if retval != 0:
        print "VTERM3/VTN4 Delete Failed"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerFirst")["ipaddr"]
    retval = controller.update_controller_ex("ControllerFirst", ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller1 valid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerFirst", "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    test_controller_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerSecond")["ipaddr"]
    retval = controller.update_controller_ex("ControllerSecond", ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller2 valid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerSecond", "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnOne", "VTermOne", "ControllerFirst", presence="no")
    if retval != 0:
        print "VTERM1/VTN1 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnOne", "ControllerFirst", presence="no")
    if retval != 0:
        print "VTN1 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnTwo", "VTermOne", "ControllerFirst", presence="no")
    if retval != 0:
        print "VTERM1/VTN2 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnTwo", "ControllerFirst", presence="no")
    if retval != 0:
        print "VTN2 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnThree", "VTermThree", "ControllerSecond", presence="no")
    if retval != 0:
        print "VTERM3/VTN3 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnThree", "ControllerSecond", presence="no")
    if retval != 0:
        print "VTN3 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnFour", "VTermThree", "ControllerSecond", presence="no")
    if retval != 0:
        print "VTERM3/VTN4 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnFour", "ControllerSecond", presence="no")
    if retval != 0:
        print "VTN4 Validate Failed"
        exit(1)

    retval = vtn_vterm.delete_vtn("VtnOne")
    if retval != 0:
        print "VTN1 Delete Failed in coordinator"
        exit(1)

    retval = vtn_vterm.delete_vtn("VtnTwo")
    if retval != 0:
        print "VTN2 Delete Failed in coordinator"
        exit(1)

    retval = vtn_vterm.delete_vtn("VtnThree")
    if retval != 0:
        print "VTN3 Delete Failed in coordinator"
        exit(1)

    retval = vtn_vterm.delete_vtn("VtnFour")
    if retval != 0:
        print "VTN4 Delete Failed in coordinator"
        exit(1)

    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex("ControllerFirst")
    if retval != 0:
        print "CONTROLLER1 delete failed"
        exit(1)

    retval = controller.delete_controller_ex("ControllerSecond")
    if retval != 0:
        print "CONTROLLER2 delete failed"
        exit(1)

    print "MULTI VTN->VTERM MULTI_CONTROLLER AUDIT TEST SUCCESS"
def test_vtn_vterm_audit_multi_controller_2():
    print """TEST 2 : create VTN and VTERM when controller is down
             change the controller status to up trigger Audit"""
    print "****CREATE Controller with valid IP****"
    retval = controller.add_controller_ex("ControllerFirst")
    if retval != 0:
        print "Controller1 Create Failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerFirst", "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    retval = controller.add_controller_ex("ControllerSecond")
    if retval != 0:
        print "Controller2 Create Failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerSecond", "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerFirst")["invalid_ipaddr"]
    retval = controller.update_controller_ex("ControllerFirst", ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller1 invalid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerFirst", "down")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    test_invalid_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerSecond")["invalid_ipaddr"]
    retval = controller.update_controller_ex("ControllerSecond", ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller2 invalid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerSecond", "down")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    print "****Create VTN****"
    retval = vtn_vterm.create_vtn("VtnOne")
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    print "****Create VTERM****"
    retval = vtn_vterm.create_vterm("VtnOne", "VTermOne", "ControllerFirst")
    if retval != 0:
        print "VTERM1 Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm("VtnOne", "VTermThree", "ControllerSecond")
    if retval != 0:
        print "VTERM3 Create Failed"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerFirst")["ipaddr"]
    retval = controller.update_controller_ex("ControllerFirst", ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller1 valid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerFirst", "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    test_controller_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerSecond")["ipaddr"]
    retval = controller.update_controller_ex("ControllerSecond", ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller2 valid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerSecond", "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnOne", "ControllerFirst")
    if retval != 0:
        print "VTN Validate Failed at controller1"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnOne", "ControllerSecond")
    if retval != 0:
        print "VTN Validate Failed at controller2"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnOne", "VTermOne", "ControllerFirst")
    if retval != 0:
        print "VTERM1 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnOne", "VTermThree", "ControllerSecond")
    if retval != 0:
        print "VTERM3 Validate Failed"
        exit(1)

    print "****Delete VTERM****"
    retval = vtn_vterm.delete_vterm("VtnOne", "VTermOne")
    if retval != 0:
        print "VTERM1/VTN Delete Failed"
        exit(1)

    iretval = vtn_vterm.delete_vterm("VtnOne", "VTermThree")
    if retval != 0:
        print "VTERM3/VTN Delete Failed"
        exit(1)

    print "****Delete VTN****"
    retval = vtn_vterm.delete_vtn("VtnOne")
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnOne", "VTermOne", "ControllerFirst", presence="no")
    if retval != 0:
        print "VTERM1 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnOne", "VTermThree", "ControllerSecond", presence="no")
    if retval != 0:
        print "VTERM3 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnOne", "ControllerFirst", presence="no")
    if retval != 0:
        print "VTN Validate Failed at controller1"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnOne", "ControllerSecond", presence="no")
    if retval != 0:
        print "VTN Validate Failed at controller2"
        exit(1)

    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex("ControllerFirst")
    if retval != 0:
        print "CONTROLLER1 delete failed"
        exit(1)

    retval = controller.delete_controller_ex("ControllerSecond")
    if retval != 0:
        print "CONTROLLER2 delete failed"
        exit(1)

    print "VTN->VTERM Multi-controller AUDIT TEST SUCCESS"
def test_audit_vtn_vterm_vtermif():

    print "CREATE Controller"
    retval = controller.add_controller_ex("ControllerFirst")
    if retval != 0:
        print "TEST 1 :Controller Create Failed"
        exit(1)

    print "TEST 1: Test Audit VTenant with one VTerminal one VTERMIF"
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerFirst", "up")
    if retval != 0:
        print "controller state change failed"
        exit(1)

    retval = vtn_vterm.create_vtn("VtnOne")
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm("VtnOne", "VTermOne", "ControllerFirst")
    if retval != 0:
        print "VTERM Create Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnOne", "VTermOne", "ControllerFirst")
    if retval != 0:
        print "After Create VTERM Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnOne", "ControllerFirst")
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerFirst")["invalid_ipaddr"]
    retval = controller.update_controller_ex("ControllerFirst", ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller invalid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerFirst", "down")

    if retval != 0:
        print "controller state change failed"
        exit(1)
    retval = vtermif_portmap.create_vtermif("VtnOne", "VTermOne", "VTermIfOne")
    if retval != 0:
        print "VTERMIF Create Failed"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, "ControllerFirst")["ipaddr"]
    retval = controller.update_controller_ex("ControllerFirst", ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller valid_ip update failed"
        exit(1)
    # Delay for AUDIT
    retval = controller.wait_until_state("ControllerFirst", "up")
    if retval != 0:
        print "controller state change failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_at_controller("VtnOne", "VTermOne", "VTermIfOne", "ControllerFirst")
    if retval != 0:
        print "After Create VTERMIF Validate Failed"
        exit(1)

    retval = vtermif_portmap.delete_vtermif("VtnOne", "VTermOne", "VTermIfOne")
    if retval != 0:
        print "VTERMIF Delete Failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_at_controller(
        "VtnOne", "VTermOne", "VTermIfOne", "ControllerFirst", presence="no", position=0
    )
    if retval != 0:
        print "After Delete VTERMIF Validate Failed"
        exit(1)

    retval = vtn_vterm.delete_vterm("VtnOne", "VTermOne")
    if retval != 0:
        print "VTERM/VTN Delete Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller("VtnOne", "VTermOne", "ControllerFirst", presence="no")
    if retval != 0:
        print "After Delete VTERM Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller("VtnOne", "ControllerFirst", presence="no")
    if retval != 0:
        print "VTN Validate Failed after VTERM Deleted"
        exit(1)

    retval = vtn_vterm.delete_vtn("VtnOne")
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex("ControllerFirst")
    if retval != 0:
        print "CONTROLLER delete failed"
        exit(1)
    print "VTN->VTERM->VTERMIF AUDIT TEST SUCCESS"
Esempio n. 15
0
def test_vtn_vterm_audit_1():

    print "****CREATE Controller with valid IP****"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
        print "Controller Create Failed"
        exit(1)

    print """TEST 1 : create VTN and VTERM when controller is up
             change the controller status to down delete VTN and VTERM
             trigger Audit"""
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)
    print "****Create VTN****"
    retval = vtn_vterm.create_vtn('VtnOne')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    print "****Create VTERM****"
    retval = vtn_vterm.create_vterm('VtnOne','VTermOne','ControllerFirst')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)


    retval =  vtn_vterm.validate_vtn_at_controller('VtnOne','ControllerFirst')
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)


    retval =  vtn_vterm.validate_vterm_at_controller('VtnOne','VTermOne','ControllerFirst')
    if retval != 0:
        print "VTERM Validate Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller invalid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"down")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    print "****Delete VTERM****"
    retval = vtn_vterm.delete_vterm('VtnOne','VTermOne')
    if retval != 0:
        print "VTERM/VTN Delete Failed"
        exit(1)

    print "****Delete VTN****"
    retval = vtn_vterm.delete_vtn('VtnOne')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller valid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval =  vtn_vterm.validate_vterm_at_controller('VtnOne','VTermOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTERM Validate Failed"
        exit(1)

    retval =  vtn_vterm.validate_vtn_at_controller('VtnOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)


    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
        print "CONTROLLER delete failed"
        exit(1)
    print "VTN->VTERM AUDIT TEST SUCCESS"
def test_vtn_vbr_audit_multi_controller_2():
    print """TEST 2 : create VTN and VBR when controller is down
             change the controller status to up trigger Audit"""
    print "****CREATE Controller with valid IP****"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
        print "Controller1 Create Failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "Controller state check failed"
      exit(1)

    retval = controller.add_controller_ex('ControllerSecond')
    if retval != 0:
        print "Controller2 Create Failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerSecond',"up")
    if retval != 0:
      print "Controller state check failed"
      exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller1 invalid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"down")
    if retval != 0:
      print "Controller state check failed"
      exit(1)

    test_invalid_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerSecond')['invalid_ipaddr']
    retval = controller.update_controller_ex('ControllerSecond',ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller2 invalid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerSecond',"down")
    if retval != 0:
      print "Controller state check failed"
      exit(1)

    print "****Create VTN****"
    retval = vtn_vbr.create_vtn('VtnOne')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    print "****Create VBR****"
    retval = vtn_vbr.create_vbr('VtnOne','VbrOne','ControllerFirst')
    if retval != 0:
        print "VBR1 Create Failed"
        exit(1)

    retval = vtn_vbr.create_vbr('VtnOne','VbrThree','ControllerSecond')
    if retval != 0:
        print "VBR3 Create Failed"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller1 valid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "Controller state check failed"
      exit(1)

    test_controller_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerSecond')['ipaddr']
    retval = controller.update_controller_ex('ControllerSecond',ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller2 valid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerSecond',"up")
    if retval != 0:
      print "Controller state check failed"
      exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst')
    if retval != 0:
        print "VTN Validate Failed at controller1"
        exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerSecond')
    if retval != 0:
        print "VTN Validate Failed at controller2"
        exit(1)

    retval =  vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst')
    if retval != 0:
        print "VBR1 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vbr_at_controller('VtnOne','VbrThree','ControllerSecond')
    if retval != 0:
        print "VBR3 Validate Failed"
        exit(1)

    print "****Delete VBR****"
    retval = vtn_vbr.delete_vbr('VtnOne','VbrOne')
    if retval != 0:
        print "VBR1/VTN Delete Failed"
        exit(1)

    iretval = vtn_vbr.delete_vbr('VtnOne','VbrThree')
    if retval != 0:
        print "VBR3/VTN Delete Failed"
        exit(1)

    print "****Delete VTN****"
    retval = vtn_vbr.delete_vtn('VtnOne')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)


    retval =  vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VBR1 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vbr_at_controller('VtnOne','VbrThree','ControllerSecond',presence="no")
    if retval != 0:
        print "VBR3 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTN Validate Failed at controller1"
        exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerSecond',presence="no")
    if retval != 0:
        print "VTN Validate Failed at controller2"
        exit(1)


    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
        print "CONTROLLER1 delete failed"
        exit(1)

    retval = controller.delete_controller_ex('ControllerSecond')
    if retval != 0:
        print "CONTROLLER2 delete failed"
        exit(1)

    print "VTN->VBR Multi-controller AUDIT TEST SUCCESS"
Esempio n. 17
0
def test_multi_vtn_with_vterm_audit_test():

    print "CREATE Controller"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
        print "Controller Create Failed"
        exit(1)

    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)
    print "TEST 6 : 2 Tenants with one VTerminal each and test AUDIT"
    print "VTNONE->VTERMONE"
    print "VTNTWO->VTERMONE"

    retval = vtn_vterm.create_vtn('VtnOne')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval = vtn_vterm.create_vtn('VtnTwo')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm('VtnOne','VTermOne','ControllerFirst')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm('VtnTwo','VTermOne','ControllerFirst')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval =  vtn_vterm.validate_vtn_at_controller('VtnOne','ControllerFirst',position=0)
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    retval =  vtn_vterm.validate_vtn_at_controller('VtnTwo','ControllerFirst',position=0)
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    retval =  vtn_vterm.validate_vterm_at_controller('VtnOne','VTermOne','ControllerFirst')
    if retval != 0:
        print "VTERM Validate Failed"
        exit(1)

    retval =  vtn_vterm.validate_vterm_at_controller('VtnTwo','VTermOne','ControllerFirst')
    if retval != 0:
        print "VTERM Validate Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller invalid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"down")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval = vtn_vterm.delete_vterm('VtnOne','VTermOne')
    if retval != 0:
        print "VTERM/VTN Delete Failed"
        exit(1)

    retval = vtn_vterm.delete_vterm('VtnTwo','VTermOne')
    if retval != 0:
        print "VTERM/VTN Delete Failed"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller valid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval =  vtn_vterm.validate_vterm_at_controller('VtnOne','VTermOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTERM Validate Failed"
        exit(1)

    retval =  vtn_vterm.validate_vtn_at_controller('VtnOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)


    retval =  vtn_vterm.validate_vterm_at_controller('VtnTwo','VTermOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTERM Validate Failed"
        exit(1)

    retval =  vtn_vterm.validate_vtn_at_controller('VtnTwo','ControllerFirst',presence="no")
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    retval = vtn_vterm.delete_vtn('VtnOne')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)


    retval = vtn_vterm.delete_vtn('VtnTwo')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
        print "CONTROLLER delete failed"
        exit(1)

    print "MULTI VTN->VTERM AUDIT TEST SUCCESS"
def test_multi_vtn_with_vbr_multi_controller_audit_test():
    print "TEST 3 : 2 Tenants with one VBridge each in multi-controller and test AUDIT"
    print "CONTROLLER1->VTNONE->VBRONE"
    print "CONTROLLER1->VTNTWO->VBRONE"
    print "CONTROLLER2->VTNTHREE->VBRONE"
    print "CONTROLLER2->VTNFOUR->VBRONE"
    print "CREATE Controller"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
        print "Controller1 Create Failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "Controller state check failed"
      exit(1)

    retval = controller.add_controller_ex('ControllerSecond')
    if retval != 0:
        print "Controller2 Create Failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerSecond',"up")
    if retval != 0:
      print "Controller state check failed"
      exit(1)

    retval = vtn_vbr.create_vtn('VtnOne')
    if retval != 0:
        print "VTN1 Create Failed"
        exit(1)

    retval = vtn_vbr.create_vtn('VtnTwo')
    if retval != 0:
        print "VTN2 Create Failed"
        exit(1)

    retval = vtn_vbr.create_vtn('VtnThree')
    if retval != 0:
        print "VTN3 Create Failed"
        exit(1)

    retval = vtn_vbr.create_vtn('VtnFour')
    if retval != 0:
        print "VTN4 Create Failed"
        exit(1)

    retval = vtn_vbr.create_vbr('VtnOne','VbrOne','ControllerFirst')
    if retval != 0:
        print "VBR1/VTN1 Create Failed"
        exit(1)

    retval = vtn_vbr.create_vbr('VtnTwo','VbrOne','ControllerFirst')
    if retval != 0:
        print "VBR1/VTN2 Create Failed"
        exit(1)

    retval = vtn_vbr.create_vbr('VtnThree','VbrThree','ControllerSecond')
    if retval != 0:
        print "VBR3/VTN3 Create Failed"
        exit(1)

    retval = vtn_vbr.create_vbr('VtnFour','VbrThree','ControllerSecond')
    if retval != 0:
        print "VBR3/VTN4 Create Failed"
        exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst',position=0)
    if retval != 0:
        print "VTN1 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnTwo','ControllerFirst',position=1)
    if retval != 0:
        print "VTN2 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnThree','ControllerSecond',position=1)
    if retval != 0:
        print "VTN3 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnFour','ControllerSecond',position=0)
    if retval != 0:
        print "VTN4 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst')
    if retval != 0:
        print "VBR1/VTN1 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vbr_at_controller('VtnTwo','VbrOne','ControllerFirst')
    if retval != 0:
        print "VBR1/VTN2 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vbr_at_controller('VtnThree','VbrThree','ControllerSecond')
    if retval != 0:
        print "VBR3/VTN3 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vbr_at_controller('VtnFour','VbrThree','ControllerSecond')
    if retval != 0:
        print "VBR4/VTN4 Validate Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller1 invalid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"down")
    if retval != 0:
      print "Controller state check failed"
      exit(1)

    test_invalid_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerSecond')['invalid_ipaddr']
    retval = controller.update_controller_ex('ControllerSecond',ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller2 invalid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerSecond',"down")
    if retval != 0:
      print "Controller state check failed"
      exit(1)

    print "****DELETE VBR****"
    retval = vtn_vbr.delete_vbr('VtnOne','VbrOne')
    if retval != 0:
        print "VBR1/VTN1 Delete Failed"
        exit(1)

    retval = vtn_vbr.delete_vbr('VtnTwo','VbrOne')
    if retval != 0:
        print "VBR1/VTN2 Delete Failed"
        exit(1)

    retval = vtn_vbr.delete_vbr('VtnThree','VbrThree')
    if retval != 0:
        print "VBR3/VTN3 Delete Failed"
        exit(1)

    retval = vtn_vbr.delete_vbr('VtnFour','VbrThree')
    if retval != 0:
        print "VBR3/VTN4 Delete Failed"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller1 valid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "Controller state check failed"
      exit(1)

    test_controller_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerSecond')['ipaddr']
    retval = controller.update_controller_ex('ControllerSecond',ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller2 valid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerSecond',"up")
    if retval != 0:
      print "Controller state check failed"
      exit(1)

    retval =  vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VBR1/VTN1 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VTN1 Validate Failed"
        exit(1)


    retval =  vtn_vbr.validate_vbr_at_controller('VtnTwo','VbrOne','ControllerFirst',presence="no")
    if retval != 0:
        print "VBR1/VTN2 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnTwo','ControllerFirst',presence="no")
    if retval != 0:
        print "VTN2 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vbr_at_controller('VtnThree','VbrThree','ControllerSecond',presence="no")
    if retval != 0:
        print "VBR3/VTN3 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnThree','ControllerSecond',presence="no")
    if retval != 0:
        print "VTN3 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vbr_at_controller('VtnFour','VbrThree','ControllerSecond',presence="no")
    if retval != 0:
        print "VBR3/VTN4 Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnFour','ControllerSecond',presence="no")
    if retval != 0:
        print "VTN4 Validate Failed"
        exit(1)

    retval = vtn_vbr.delete_vtn('VtnOne')
    if retval != 0:
        print "VTN1 Delete Failed in coordinator"
        exit(1)

    retval = vtn_vbr.delete_vtn('VtnTwo')
    if retval != 0:
        print "VTN2 Delete Failed in coordinator"
        exit(1)

    retval = vtn_vbr.delete_vtn('VtnThree')
    if retval != 0:
        print "VTN3 Delete Failed in coordinator"
        exit(1)

    retval = vtn_vbr.delete_vtn('VtnFour')
    if retval != 0:
        print "VTN4 Delete Failed in coordinator"
        exit(1)

    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
        print "CONTROLLER1 delete failed"
        exit(1)

    retval = controller.delete_controller_ex('ControllerSecond')
    if retval != 0:
        print "CONTROLLER2 delete failed"
        exit(1)

    print "MULTI VTN->VBR MULTI_CONTROLLER AUDIT TEST SUCCESS"
def test_vbr_flowfilter_audit_1():

    print "****CREATE Controller with valid IP****"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
        print "Controller Create Failed"
        exit(1)

    print """TEST 1 : create VTN and VBR FLOWFILTER when controller is down
             change the controller status to up trigger Audit and validate"""
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)
    print "****Create VTN****"
    retval = vtn_vbr.create_vtn('VtnOne')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    print "****Create VBR****"
    retval = vtn_vbr.create_vbr('VtnOne','VbrOne','ControllerFirst')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval=vbrif_portmap.create_vbrif('VtnOne','VbrOne','VbrIfOne')
    if retval != 0:
        print "VBRIF Create Failed"
        exit(1)

    retval=vtn_vbr.create_vbr('VtnOne','VbrTwo','ControllerFirst')
    if retval != 0:
      print "VTN Create Failed"
      exit(1)

    retval=vbrif_portmap.create_vbrif('VtnOne','VbrTwo','VbrIfTwo')
    if retval != 0:
      print "VBRIF Create Failed"
      exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst')
    if retval != 0:
        print "VTN Validate Failed"
        exit(1)

    retval =  vtn_vbr.validate_vbr_at_controller('VtnOne','VbrOne','ControllerFirst')
    if retval != 0:
        print "VBR Validate Failed"
        exit(1)

    retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrOne','VbrIfOne','ControllerFirst')
    if retval != 0:
        print "After Create VBRIF Validate Failed"
        exit(1)

    retval=vtn_vbr.validate_vbr_at_controller('VtnOne','VbrTwo','ControllerFirst', presence = 'yes', position = 1)
    if retval != 0:
      print "VBR Validate Failed"
      exit(1)

    retval=vbrif_portmap.validate_vbrif_at_controller('VtnOne','VbrTwo','VbrIfTwo','ControllerFirst', presence = 'yes', position = 0)
    if retval != 0:
      print "After Create VBRIF Validate Failed"
      exit(1)

    retval=flowlistentry.create_flowlist('FlowlistOne')
    if retval != 0:
        print "FlowList Create Failed"
        exit(1)

    retval=flowlistentry.create_flowlistentry('FlowlistOne', 'FlowlistentryOne','ControllerFirst')
    if retval != 0:
        print "FlowlistEntry Create Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['invalid_ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller invalid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"down")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval=flowfilter.create_flowfilter('VtnOne|VbrOne', 'FlowfilterOne')
    if retval != 0:
        print "VBRFlowFilter Create Failed"
        exit(1)

    retval=flowfilter.create_flowfilter_entry('VtnOne|VbrOne', 'FlowfilterOne')
    if retval != 0:
        print "VBRFlowFilterEntry Create Failed"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr= vtn_testconfig.ReadValues(CONTROLLERDATA,'ControllerFirst')['ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller valid_ip update failed"
        exit(1)
  # Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst',"up")
    if retval != 0:
      print "controller state change failed"
      exit(1)

    retval=flowfilter.validate_flowfilter_entry('VtnOne|VbrOne', 'FlowfilterOne', presence='yes', position=0)
    if retval != 0:
        print "VBRFlowFilterEntry Validate Failed at Co-ordinator"
        exit(1)

    retval=flowfilter.validate_flowfilter_at_controller('VtnOne|VbrOne', 'ControllerFirst', 'FlowfilterOne', presence='yes', position=0)
    if retval != 0:
        print "FlowFilter validation Failed at Controller"
        exit(1)

    retval = flowfilter.delete_flowfilter_entry('VtnOne|VbrOne', 'FlowfilterOne')
    if retval != 0:
       print "VBRFlowFilterEntry deletete Failed"
       exit(1)
    retval = flowfilter.delete_flowfilter('VtnOne|VbrOne', 'FlowfilterOne')
    if retval != 0:
       print "VBRFlowFilter deletete Failed"
       exit(1)

    retval=flowlistentry.delete_flowlistentry('FlowlistOne', 'FlowlistentryOne')
    if retval != 0:
      print "FlowilistEntry deletete Failed"
      exit(1)

    retval=flowlistentry.delete_flowlist('FlowlistOne')
    if retval != 0:
      print "Flowilist deletete Failed"
      exit(1)

    print "****Delete VTN****"
    retval = vtn_vbr.delete_vtn('VtnOne')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    retval=flowfilter.validate_flowfilter_at_controller('VtnOne|VbrOne', 'ControllerFirst', 'FlowfilterOne', presence='no', position=0)
    if retval != 0:
      print "FlowFilter validation Failed after deleting"
      exit(1)

    retval =  vtn_vbr.validate_vtn_at_controller('VtnOne','ControllerFirst',presence="no")
    if retval != 0:
      print "VTN Validate Failed"
      exit(1)

    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
        print "CONTROLLER delete failed"
        exit(1)
    print "VBR->FLOWFILTER AUDIT_1 TEST SUCCESS"
Esempio n. 20
0
def test_audit_vtn_vterm_vtermif_portmap_multi_controller():

    print "CREATE Controller"
    retval = controller.add_controller_ex('ControllerFirst')
    if retval != 0:
        print "TEST 4 :Controller1 Create Failed"
        exit(1)
# Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst', "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    retval = controller.add_controller_ex('ControllerSecond')
    if retval != 0:
        print "TEST 4 :Controller2 Create Failed"
        exit(1)
# Delay for AUDIT
    retval = controller.wait_until_state('ControllerSecond', "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    print "TEST 4 : VTenant with one VTerminal one VTERMIF and One PORTMAP with multi-controller"

    retval = vtn_vterm.create_vtn('VtnOne')
    if retval != 0:
        print "VTN Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm('VtnOne', 'VTermOne', 'ControllerFirst')
    if retval != 0:
        print "VTERM1 Create Failed"
        exit(1)

    retval = vtn_vterm.create_vterm('VtnOne', 'VTermThree', 'ControllerSecond')
    if retval != 0:
        print "VTERM3 Create Failed"
        exit(1)

    retval = vtermif_portmap.create_vtermif('VtnOne', 'VTermOne', 'VTermIfOne')
    if retval != 0:
        print "VTERMIF1 Create Failed"
        exit(1)

    retval = vtermif_portmap.create_vtermif('VtnOne', 'VTermThree',
                                            'VTermIfTwo')
    if retval != 0:
        print "VTERMIF2 Create Failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_at_controller(
        'VtnOne', 'VTermOne', 'VTermIfOne', 'ControllerFirst')
    if retval != 0:
        print "After Create VTERMIF1 Validate Failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_at_controller(
        'VtnOne', 'VTermThree', 'VTermIfTwo', 'ControllerSecond')
    if retval != 0:
        print "After Create VTERMIF2 Validate Failed"
        exit(1)

    print "****UPDATE Controller IP to invalid****"
    test_invalid_ipaddr = vtn_testconfig.ReadValues(
        CONTROLLERDATA, 'ControllerFirst')['invalid_ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',
                                             ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller1 invalid_ip update failed"
        exit(1)
# Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst', "down")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    test_invalid_ipaddr = vtn_testconfig.ReadValues(
        CONTROLLERDATA, 'ControllerSecond')['invalid_ipaddr']
    retval = controller.update_controller_ex('ControllerSecond',
                                             ipaddr=test_invalid_ipaddr)
    if retval != 0:
        print "controller2 invalid_ip update failed"
        exit(1)
# Delay for AUDIT
    retval = controller.wait_until_state('ControllerSecond', "down")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    retval = vtermif_portmap.create_portmap('VtnOne', 'VTermOne', 'VTermIfOne')
    if retval != 0:
        print "Portmap1 Create Failed"
        exit(1)

    retval = vtermif_portmap.create_portmap('VtnOne', 'VTermThree',
                                            'VTermIfTwo')
    if retval != 0:
        print "Portmap2 Create Failed"
        exit(1)

    print "****UPDATE Controller IP to Valid****"
    test_controller_ipaddr = vtn_testconfig.ReadValues(
        CONTROLLERDATA, 'ControllerFirst')['ipaddr']
    retval = controller.update_controller_ex('ControllerFirst',
                                             ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller1 valid_ip update failed"
        exit(1)
# Delay for AUDIT
    retval = controller.wait_until_state('ControllerFirst', "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    test_controller_ipaddr = vtn_testconfig.ReadValues(
        CONTROLLERDATA, 'ControllerSecond')['ipaddr']
    retval = controller.update_controller_ex('ControllerSecond',
                                             ipaddr=test_controller_ipaddr)
    if retval != 0:
        print "controller2 valid_ip update failed"
        exit(1)
# Delay for AUDIT
    retval = controller.wait_until_state('ControllerSecond', "up")
    if retval != 0:
        print "Controller state check failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_portmap_at_controller(
        'VtnOne', 'VTermOne', 'VTermIfOne', 'ControllerFirst', presence="yes")
    if retval != 0:
        print "Portmap1 Validate Failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_portmap_at_controller(
        'VtnOne',
        'VTermThree',
        'VTermIfTwo',
        'ControllerSecond',
        presence="yes")
    if retval != 0:
        print "Portmap2 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller('VtnOne', 'VTermOne',
                                                    'ControllerFirst')
    if retval != 0:
        print "After Create VTERM1 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller('VtnOne', 'VTermThree',
                                                    'ControllerSecond')
    if retval != 0:
        print "After Create VTERM3 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller('VtnOne', 'ControllerFirst')
    if retval != 0:
        print "VTN Validate Failed at controller1"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller('VtnOne', 'ControllerSecond')
    if retval != 0:
        print "VTN Validate Failed at controller2"
        exit(1)

    retval = vtermif_portmap.delete_portmap('VtnOne', 'VTermOne', 'VTermIfOne')
    if retval != 0:
        print "Portmap1 Delete Failed"
        exit(1)

    retval = vtermif_portmap.delete_portmap('VtnOne', 'VTermThree',
                                            'VTermIfTwo')
    if retval != 0:
        print "Portmap2 Delete Failed"
        exit(1)

#    retval=vtermif_portmap.validate_vtermif_portmap_at_controller('VtnOne','VTermOne','VTermIfOne','ControllerFirst',presence="no");
#    if retval != 0:
#        print "After Delete Portmap1 Validate Failed"
#        exit(1)

#    retval=vtermif_portmap.validate_vtermif_portmap_at_controller('VtnOne','VTermThree','VTermIfTwo','ControllerSecond',presence="no");
#    if retval != 0:
#        print "After Delete Portmap2 Validate Failed"
#        exit(1)

    retval = vtermif_portmap.delete_vtermif('VtnOne', 'VTermOne', 'VTermIfOne')
    if retval != 0:
        print "VTERMIF1 Delete Failed"
        exit(1)

    retval = vtermif_portmap.delete_vtermif('VtnOne', 'VTermThree',
                                            'VTermIfTwo')
    if retval != 0:
        print "VTERMIF2 Delete Failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_at_controller('VtnOne',
                                                            'VTermOne',
                                                            'VTermIfOne',
                                                            'ControllerFirst',
                                                            presence="no",
                                                            position=0)
    if retval != 0:
        print "After Delete VTERMIF1 Validate Failed"
        exit(1)

    retval = vtermif_portmap.validate_vtermif_at_controller('VtnOne',
                                                            'VTermThree',
                                                            'VTermIfTwo',
                                                            'ControllerSecond',
                                                            presence="no",
                                                            position=0)
    if retval != 0:
        print "After Delete VTERMIF2 Validate Failed"
        exit(1)

    retval = vtn_vterm.delete_vterm('VtnOne', 'VTermOne')
    if retval != 0:
        print "VTERM1/VTN Delete Failed"
        exit(1)

    retval = vtn_vterm.delete_vterm('VtnOne', 'VTermThree')
    if retval != 0:
        print "VTERM3/VTN Delete Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller('VtnOne',
                                                    'VTermOne',
                                                    'ControllerFirst',
                                                    presence="no")
    if retval != 0:
        print "After Delete VTERM1 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vterm_at_controller('VtnOne',
                                                    'VTermThree',
                                                    'ControllerSecond',
                                                    presence="no")
    if retval != 0:
        print "After Delete VTERM2 Validate Failed"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller('VtnOne',
                                                  'ControllerFirst',
                                                  presence="no")
    if retval != 0:
        print "VTN Validate Failed after VTERM1 Deleted at controller1"
        exit(1)

    retval = vtn_vterm.validate_vtn_at_controller('VtnOne',
                                                  'ControllerSecond',
                                                  presence="no")
    if retval != 0:
        print "VTN Validate Failed after VTERM3 Deleted at controller2"
        exit(1)

    retval = vtn_vterm.delete_vtn('VtnOne')
    if retval != 0:
        print "VTN Delete Failed in coordinator"
        exit(1)

    print "DELETE CONTROLLER"
    retval = controller.delete_controller_ex('ControllerFirst')
    if retval != 0:
        print "CONTROLLER1 delete failed"
        exit(1)

    retval = controller.delete_controller_ex('ControllerSecond')
    if retval != 0:
        print "CONTROLLER2 delete failed"
        exit(1)

    print "VTN->VTERM->VTERMIF->PORTMAP MULTI-CONTROLER TEST SUCCESS"