def test_120_natOneToOneWanDown(self): # create a 1:1 NAT and then down the wan which the NAT is set to # if there are more than one WAN if remote_control.quickTestsOnly: raise unittest2.SkipTest('Skipping a time consuming test') if (len(indexOfWans) < 2): raise unittest2.SkipTest("Need at least two WANS for combination of wan-balancer and wan failover tests") pre_count = global_functions.get_app_metric_value(appWanFailover,"changed") # raise unittest2.SkipTest('Skipping test_120_natOneToOneWanDown as not possible with current network layout ') netsettings = uvmContext.networkManager().getNetworkSettings() nukeWanBalancerRules(); nukeFailoverRules() # create valid failover tests for wanIndexTup in indexOfWans: wanIndex = wanIndexTup[0] buildWanTestRule(wanIndex) for wanIndexTup in indexOfWans: # get the WAN IP address which was source routed wanIndex = wanIndexTup[0] wanIP = wanIndexTup[1] wanExternalIP = wanIndexTup[2] # Add networking route which does not handle re-routing if WAN is down netsettings['natRules']['list']=[] netsettings['natRules']['list'].append(buildNatRule("DST_ADDR",ip_address_testdestination,wanIP)) uvmContext.networkManager().setNetworkSettings(netsettings) # Test that only the routed interface is used 5 times subprocess.check_output("ip route flush cache", shell=True) for x in range(0, 5): result = global_functions.get_public_ip_address() print("NAT 1:1 IP %s External IP %s and retrieved IP %s" % (wanIP, wanExternalIP, result)) assert (result == wanExternalIP) # now down the selected wan and see if traffic flows out the other wan buildWanTestRule(wanIndex, "ping", "192.168.244.1") # Wait for targeted the WAN to be off line before testing that the WAN is off line. timeout = 50000 online = True offlineWanIndex = wanIndex while online and timeout > 0: timeout -= 1 wanStatus = appWanFailover.getWanStatus() for statusInterface in wanStatus['list']: if statusInterface['interfaceId'] == offlineWanIndex: online = statusInterface['online'] time.sleep(10) # Let WAN balancer see that the interface is down subprocess.check_output("ip route flush cache", shell=True) for x in range(0, 5): result = global_functions.get_public_ip_address() print("WAN Down NAT 1:1 IP %s External IP %s and retrieved IP %s" % (wanIP, wanExternalIP, result)) assert (result == wanExternalIP) uvmContext.networkManager().setNetworkSettings(orig_netsettings) nukeFailoverRules() # Check to see if the faceplate counters have incremented. post_count = global_functions.get_app_metric_value(appWanFailover,"changed") assert(pre_count < post_count)
def test_060_routedByPortWan(self): # Test that route rules override weighted rules on 2 WANs if (len(indexOfWans) < 2): raise unittest2.SkipTest( "Need at least two WANS for test_060_routedByPortWan") nukeWanBalancerRouteRules() setWeightOfWan("all", 50) # Set all port 80 traffic out the first WAN and 443 on the other port80Index = indexOfWans[0][0] port80IP = indexOfWans[0][2] port443Index = indexOfWans[1][0] port443IP = indexOfWans[1][2] print "index443 %s" % port443Index buildSingleWanRouteRule("DST_PORT", 80, (port80Index)) buildSingleWanRouteRule("DST_PORT", 443, (port443Index)) for x in range(0, 9): result80 = global_functions.get_public_ip_address() result443 = global_functions.get_public_ip_address( base_URL="https://test.untangle.com", extra_options="--no-check-certificate --secure-protocol=auto") print "80 IP %s and 443 IP %s" % (result80, result443) assert (result80 == port80IP) assert (result443 == port443IP)
def test_080_routedWanVsNetworkRoute(self): # Test that Networking routes override routed rules in WAN Balancer if (len(indexOfWans) < 2): raise unittest2.SkipTest("Need at least two WANS for test_080_routedWanVsNetworkRoute") netsettings = netsettings = uvmContext.networkManager().getNetworkSettings() nukeWanBalancerRouteRules() setWeightOfWan("all", 0) weightedIndexTup = indexOfWans[0] routedIndexTup = indexOfWans[1] setWeightOfWan(weightedIndexTup[0], 100) # set primary to 100% # configure route in network which uses the second WAN for test.untangle.com routedIP = routedIndexTup[2] routedIPGateway = routedIndexTup[3] appendRouteRule(createRouteRule(ip_address_testdestination,32,routedIPGateway)) result1 = global_functions.get_public_ip_address() print("Routed IP %s and retrieved IP %s" % (routedIP, result1)) # Add WAN route IP to Balancer buildSingleWanRouteRule("DST_ADDR",ip_address_testdestination,weightedIndexTup[0]) result2 = global_functions.get_public_ip_address(extra_options="--no-check-certificate --secure-protocol=auto") print("Routed IP %s and retrieved IP %s" % (routedIP, result2)) uvmContext.networkManager().setNetworkSettings(orig_netsettings) assert (result1 == routedIP) assert (result2 == routedIP)
def test_020_stickySession(self): result = global_functions.get_public_ip_address() print("Initial IP address %s" % result) for x in range(0, 8): result2 = global_functions.get_public_ip_address() print("Test IP address %s" % result2) assert (result == result2)
def test_070_weightVsRoutedWan(self): # Test that route rules override weighted rules if (len(indexOfWans) < 2): raise unittest2.SkipTest("Need at least two WANS for test_070_weightVsRoutedWan") for x in range(0, 2): nukeWanBalancerRouteRules() setWeightOfWan("all", 0) wanIndexTup = indexOfWans[x] wanIndex = wanIndexTup[0] setWeightOfWan(wanIndex, 100) if (x==0): y=1 else: y=0 weightedIndexTup = indexOfWans[x] weightedIP = weightedIndexTup[2] routedIndexTup = indexOfWans[y] routedIP = routedIndexTup[2] # WAN index for route rules is +1 from networking list. Balance is zero buildSingleWanRouteRule("DST_ADDR",ip_address_testdestination,routedIndexTup[0]) for x in range(0, 9): result = global_functions.get_public_ip_address() print("Routed IP %s and retrieved IP %s" % (routedIP, result)) assert (result == routedIP) subprocess.check_output("ip route flush cache", shell=True)
def test_060_one_wan_offline(self): if remote_control.quickTestsOnly: raise unittest2.SkipTest('Skipping a time consuming test') invalidWanIP = None offlineWanIndex = None for upWanIndexTup in indexOfWans: upWanIndex = upWanIndexTup[0] nuke_rules() for wanIndexTup in indexOfWans: wanIndex = wanIndexTup[0] if upWanIndex == wanIndex: # make this interface test disconnected offlineWanIndex = wanIndex build_wan_test(offlineWanIndex, "ping", pingHost="192.168.244.1") invalidWanIP = wanIndexTup[2] print "InvalidIP is %s" % invalidWanIP else: build_wan_test(wanIndex, "ping") wait_for_wan_offline() offline_count = offline_wan_count() assert (offline_count > 0) if (len(indexOfWans) > 1): # Skip the WAN IP address check part of the test if test box only has one WAN for x in range(0, 8): result = global_functions.get_public_ip_address() print "IP address %s and invalidWanIP %s" % (result, invalidWanIP) assert (result != invalidWanIP)
def test_110_networkRouteWanDown(self): # create a network route and then down the wan which the route is set to # if there are more than one WAN if remote_control.quickTestsOnly: raise unittest2.SkipTest('Skipping a time consuming test') if (len(indexOfWans) < 2): raise unittest2.SkipTest( "Need at least two WANS for combination of wan-balancer and wan failover tests" ) netsettings = netsettings = uvmContext.networkManager( ).getNetworkSettings() nukeWanBalancerRules() for wanIndexTup in indexOfWans: # Add networking route which does not handle re-routing if WAN is down # get the WAN IP address which was source routed wanIndex = wanIndexTup[0] # Get the external IP of the interface selected. routedIP = wanIndexTup[2] wanGatewayIP = wanIndexTup[3] netsettings['staticRoutes']['list'] = [] netsettings['staticRoutes']['list'].append( createRouteRule(ip_address_testdestination, 32, wanGatewayIP)) uvmContext.networkManager().setNetworkSettings(netsettings) # Test that only the routed interface is used 5 times subprocess.check_output("ip route flush cache", shell=True) for x in range(0, 5): result = remote_control.run_command( "wget --timeout=4 -q -O - \"$@\" test.untangle.com/cgi-bin/myipaddress.py", stdout=True) print "Network Routed IP %s and retrieved IP %s" % (routedIP, result) assert (result == routedIP) # now down the selected wan and see if traffic flows out the other wan buildWanTestRule(wanIndex, "ping", "192.168.244.1") # Wait for targeted the WAN to be off line before testing that the WAN is off line. timeout = 50000 online = True offlineWanIndex = wanIndex while online and timeout > 0: timeout -= 1 wanStatus = appWanFailover.getWanStatus() for statusInterface in wanStatus['list']: if statusInterface['interfaceId'] == offlineWanIndex: online = statusInterface['online'] time.sleep(10) # Let WAN balancer see that the interface is down subprocess.check_output("ip route flush cache", shell=True) for x in range(0, 5): result = global_functions.get_public_ip_address() print "WAN Down Network Routed IP %s and retrieved IP %s" % ( routedIP, result) assert (result == routedIP) nukeFailoverRules() uvmContext.networkManager().setNetworkSettings(orig_netsettings)
def test_100_wanBalancerRouteWanDown(self): # create a source route and then down the wan which the route is set to # if there are more than one WAN if remote_control.quickTestsOnly: raise unittest2.SkipTest('Skipping a time consuming test') if (len(index_of_wans) < 2): raise unittest2.SkipTest( "Need at least two WANS for combination of wan-balancer and wan failover tests" ) if same_wan_network(index_of_wans): raise unittest2.SkipTest("WANS on same network") netsettings = uvmContext.networkManager().getNetworkSettings() for wanIndexTup in index_of_wans: wanIndex = wanIndexTup[0] nuke_wan_balancer_rules() # Get the external IP of the interface selected. routedIP = wanIndexTup[2] # WAN index for route rules is from networking list. Balance is zero build_single_wan_route_rule("DST_ADDR", ip_address_testdestination, wanIndex) # Test that only the routed interface is used 5 times2 subprocess.check_output("ip route flush cache", shell=True) for x in range(0, 5): result = remote_control.run_command( "wget --timeout=4 -q -O - \"$@\" test.untangle.com/cgi-bin/myipaddress.py", stdout=True) print("WAN Balancer Routed IP %s and retrieved IP %s" % (routedIP, result)) assert (result == routedIP) # now down the selected wan and see if traffic flows out the other wan build_wan_test_rule(wanIndex, "ping", "192.168.244.1") # Wait for targeted the WAN to be off line before testing that the WAN is off line. timeout = 50000 online = True offlineWanIndex = wanIndex while online and timeout > 0: timeout -= 1 wanStatus = app_wan_failover.getWanStatus() for statusInterface in wanStatus['list']: if statusInterface['interfaceId'] == offlineWanIndex: online = statusInterface['online'] time.sleep(10) # Let WAN balancer see that the interface is down subprocess.check_output("ip route flush cache", shell=True) for x in range(0, 5): result = global_functions.get_public_ip_address() print( "WAN Down WAN Balancer Routed IP %s and retrieved IP %s" % (routedIP, result)) assert (result != routedIP) nuke_wan_balancer_rules() nuke_wan_failover_rules()
def test_090_heavyWeightWanDown(self): # Set the one WAN as 100 weight and the other as zero and down the 100 weight wan # if there are more than one WAN if (len(indexOfWans) < 2): raise unittest2.SkipTest( "Need at least two WANS for combination of wan-balancer and wan failover tests" ) # initialize all the weights to 50 nukeWanBalancerRules() # create valid failover tests for wanIndexTup in indexOfWans: buildWanTestRule(wanIndexTup[0]) result = remote_control.is_online() assert (result == 0) for wanIndexTup in indexOfWans: wanIndex = wanIndexTup[0] # set the selected wan to 100 and others to zero setWeightOfWan("all", 0) setWeightOfWan(wanIndex, 100) # Set the weighted interface with invalid rule buildWanTestRule(wanIndex, "ping", "192.168.244.1") # get the WAN IP address which was weighted to 100 weightedIP = wanIndexTup[1] # Wait for targeted the WAN to be off line before testing that the WAN is off line. timeout = 50000 online = True offlineWanIndex = wanIndex while online and timeout > 0: timeout -= 1 wanStatus = appWanFailover.getWanStatus() for statusInterface in wanStatus['list']: if statusInterface['interfaceId'] == offlineWanIndex: online = statusInterface['online'] time.sleep( 10) # Let WAN balancer see that the heavy interface is down # Test that other interfaces are used 10 times for x in range(0, 9): result = global_functions.get_public_ip_address() print "Weighted IP %s and retrieved IP %s" % (weightedIP, result) assert (result != weightedIP) # reset weight to zero and interface to valid rule setWeightOfWan(wanIndex, 0) buildWanTestRule(wanIndex) # return settings to default nukeWanBalancerRules() nukeFailoverRules()
def test_050_routedByIPWan(self): if (len(indexOfWans) < 2): raise unittest2.SkipTest("Need at least two WANS for test_050_routedByIPWan") # Set weighting to default setWeightOfWan("all", 50) for wanIndexTup in indexOfWans: wanIndex = wanIndexTup[0] nukeWanBalancerRouteRules() # Get the external IP of the interface selected. routedIP = wanIndexTup[2] buildSingleWanRouteRule("DST_ADDR",ip_address_testdestination,wanIndex) # Test that only the routed interface is used 10 times for x in range(0, 9): result = global_functions.get_public_ip_address() print("Routed IP %s and retrieved IP %s" % (routedIP, result)) assert (result == routedIP) nukeWanBalancerRouteRules()
def test_030_heavyWeightWan(self): # Set the one WAN as 100 weight and the other as zero and vice versa. if (len(indexOfWans) < 2): raise unittest2.SkipTest("Need at least two WANS for test_030_heavyWeightWan") setWeightOfWan("all", 0) for wanIndexTup in indexOfWans: wanIndex = wanIndexTup[0] setWeightOfWan(wanIndex, 100) # get the WAN IP address which was weighted to 100 weightedIP = wanIndexTup[2] # Test that only the weighted interface is used 10 times for x in range(0, 9): result = global_functions.get_public_ip_address() print("Weighted IP %s and retrieved IP %s" % (weightedIP, result)) assert (result == weightedIP) # reset weight to zero setWeightOfWan(wanIndex, 0) # return weight settings to default setWeightOfWan("all", 50)
def test_065_all_wan_offline_but_one(self): if remote_control.quickTestsOnly: raise unittest2.SkipTest('Skipping a time consuming test') if (len(indexOfWans) < 2): raise unittest2.SkipTest( "Need at least two WANS for test_065_downAllButOneWan") pre_count = global_functions.get_app_metric_value(app, "changed") validWanIP = None # loop through the WANs keeping one up and the rest down. for upWanIndexTup in indexOfWans: upWanIndex = upWanIndexTup[0] nuke_rules() for wanIndexTup in indexOfWans: wanIndex = wanIndexTup[0] if upWanIndex != wanIndex: # make this interface test disconnected build_wan_test(wanIndex, "ping", pingHost="192.168.244.1") else: validWanIP = wanIndexTup[2] build_wan_test(upWanIndex, "ping", pingHost="8.8.8.8") print "validIP is %s" % validWanIP wait_for_wan_offline() online_count = online_wan_count() offline_count = offline_wan_count() assert (online_count == 1) assert (offline_count > 0) for x in range(0, 8): result = global_functions.get_public_ip_address() print "IP address %s and validWanIP %s" % (result, validWanIP) assert (result == validWanIP) # Check to see if the faceplate counters have incremented. post_count = global_functions.get_app_metric_value(app, "changed") assert (pre_count < post_count)