python/ovstest/tests.py

   1 # Licensed under the Apache License, Version 2.0 (the "License");
   2 # you may not use this file except in compliance with the License.
   3 # You may obtain a copy of the License at:
   4 #
   5 #     http://www.apache.org/licenses/LICENSE-2.0
   6 #
   7 # Unless required by applicable law or agreed to in writing, software
   8 # distributed under the License is distributed on an "AS IS" BASIS,
   9 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 # See the License for the specific language governing permissions and
  11 # limitations under the License.
  12
  13 import math
  14 import time
  15
  16 import ovstest.util as util
  17
  18 DEFAULT_TEST_BRIDGE = "ovstestbr0"
  19 DEFAULT_TEST_PORT = "ovstestport0"
  20 DEFAULT_TEST_TUN = "ovstestport1"
  21 NO_HANDLE = -1
  22
  23
  24 def do_udp_tests(receiver, sender, tbwidth, duration, port_sizes):
  25     """Schedule UDP tests between receiver and sender"""
  26     server1 = util.rpc_client(receiver[0], receiver[1])
  27     server2 = util.rpc_client(sender[0], sender[1])
  28
  29     udpformat = '{0:>15} {1:>15} {2:>15} {3:>15} {4:>15}'
  30
  31     print ("UDP test from %s:%u to %s:%u with target bandwidth %s" %
  32                             (sender[0], sender[1], receiver[0], receiver[1],
  33                              util.bandwidth_to_string(tbwidth)))
  34     print udpformat.format("Datagram Size", "Snt Datagrams", "Rcv Datagrams",
  35                             "Datagram Loss", "Bandwidth")
  36
  37     for size in port_sizes:
  38         listen_handle = NO_HANDLE
  39         send_handle = NO_HANDLE
  40         try:
  41             packetcnt = (tbwidth * duration) / size
  42
  43             listen_handle = server1.create_udp_listener(receiver[3])
  44             if listen_handle == NO_HANDLE:
  45                 print ("Server could not open UDP listening socket on port"
  46                         " %u. Try to restart the server.\n" % receiver[3])
  47                 return
  48             send_handle = server2.create_udp_sender(
  49                                             (util.ip_from_cidr(receiver[2]),
  50                                              receiver[3]), packetcnt, size,
  51                                              duration)
  52
  53             # Using sleep here because there is no other synchronization
  54             # source that would notify us when all sent packets were received
  55             time.sleep(duration + 1)
  56
  57             rcv_packets = server1.get_udp_listener_results(listen_handle)
  58             snt_packets = server2.get_udp_sender_results(send_handle)
  59
  60             loss = math.ceil(((snt_packets - rcv_packets) * 10000.0) /
  61                                                         snt_packets) / 100
  62             bwidth = (rcv_packets * size) / duration
  63
  64             print udpformat.format(size, snt_packets, rcv_packets,
  65                           '%.2f%%' % loss, util.bandwidth_to_string(bwidth))
  66         finally:
  67             if listen_handle != NO_HANDLE:
  68                 server1.close_udp_listener(listen_handle)
  69             if send_handle != NO_HANDLE:
  70                 server2.close_udp_sender(send_handle)
  71     print "\n"
  72
  73
  74 def do_tcp_tests(receiver, sender, duration):
  75     """Schedule TCP tests between receiver and sender"""
  76     server1 = util.rpc_client(receiver[0], receiver[1])
  77     server2 = util.rpc_client(sender[0], sender[1])
  78
  79     tcpformat = '{0:>15} {1:>15} {2:>15}'
  80     print "TCP test from %s:%u to %s:%u (full speed)" % (sender[0], sender[1],
  81                                                     receiver[0], receiver[1])
  82     print tcpformat.format("Snt Bytes", "Rcv Bytes", "Bandwidth")
  83
  84     listen_handle = NO_HANDLE
  85     send_handle = NO_HANDLE
  86     try:
  87         listen_handle = server1.create_tcp_listener(receiver[3])
  88         if listen_handle == NO_HANDLE:
  89             print ("Server was unable to open TCP listening socket on port"
  90                     " %u. Try to restart the server.\n" % receiver[3])
  91             return
  92         send_handle = server2.create_tcp_sender(util.ip_from_cidr(receiver[2]),
  93                                                 receiver[3], duration)
  94
  95         time.sleep(duration + 1)
  96
  97         rcv_bytes = long(server1.get_tcp_listener_results(listen_handle))
  98         snt_bytes = long(server2.get_tcp_sender_results(send_handle))
  99
 100         bwidth = rcv_bytes / duration
 101
 102         print tcpformat.format(snt_bytes, rcv_bytes,
 103                                util.bandwidth_to_string(bwidth))
 104     finally:
 105         if listen_handle != NO_HANDLE:
 106             server1.close_tcp_listener(listen_handle)
 107         if send_handle != NO_HANDLE:
 108             server2.close_tcp_sender(send_handle)
 109     print "\n"
 110
 111
 112 def do_l3_tests(node1, node2, bandwidth, duration, ps, type):
 113     """
 114     Do L3 tunneling tests. Each node is given as 4 tuple - physical
 115     interface IP, control port, test IP and test port.
 116     """
 117     server1 = util.rpc_client(node1[0], node1[1])
 118     server2 = util.rpc_client(node2[0], node2[1])
 119     servers_with_bridges = []
 120     try:
 121         server1.create_bridge(DEFAULT_TEST_BRIDGE)
 122         servers_with_bridges.append(server1)
 123         server2.create_bridge(DEFAULT_TEST_BRIDGE)
 124         servers_with_bridges.append(server2)
 125
 126         server1.interface_up(DEFAULT_TEST_BRIDGE)
 127         server2.interface_up(DEFAULT_TEST_BRIDGE)
 128
 129         server1.interface_assign_ip(DEFAULT_TEST_BRIDGE, node1[2], None)
 130         server2.interface_assign_ip(DEFAULT_TEST_BRIDGE, node2[2], None)
 131
 132         server1.add_port_to_bridge(DEFAULT_TEST_BRIDGE, DEFAULT_TEST_TUN)
 133         server2.add_port_to_bridge(DEFAULT_TEST_BRIDGE, DEFAULT_TEST_TUN)
 134
 135         server1.ovs_vsctl_set("Interface", DEFAULT_TEST_TUN, "type",
 136                               None, type)
 137         server2.ovs_vsctl_set("Interface", DEFAULT_TEST_TUN, "type",
 138                               None, type)
 139         server1.ovs_vsctl_set("Interface", DEFAULT_TEST_TUN, "options",
 140                               "remote_ip", node2[0])
 141         server2.ovs_vsctl_set("Interface", DEFAULT_TEST_TUN, "options",
 142                               "remote_ip", node1[0])
 143
 144         do_udp_tests(node1, node2, bandwidth, duration, ps)
 145         do_udp_tests(node2, node1, bandwidth, duration, ps)
 146         do_tcp_tests(node1, node2, duration)
 147         do_tcp_tests(node2, node1, duration)
 148
 149     finally:
 150         for server in servers_with_bridges:
 151             server.del_bridge(DEFAULT_TEST_BRIDGE)
 152
 153
 154 def do_vlan_tests(node1, node2, bandwidth, duration, ps, tag):
 155     """
 156     Do VLAN tests between node1 and node2. Each node is given
 157     as 4 tuple - physical interface IP, control port, test IP and
 158     test port.
 159     """
 160     server1 = util.rpc_client(node1[0], node1[1])
 161     server2 = util.rpc_client(node2[0], node2[1])
 162
 163     br_name1 = None
 164     br_name2 = None
 165
 166     servers_with_test_ports = []
 167
 168     try:
 169         interface_node1 = server1.get_interface(node1[0])
 170         interface_node2 = server2.get_interface(node2[0])
 171
 172         if server1.is_ovs_bridge(interface_node1):
 173             br_name1 = interface_node1
 174         else:
 175             br_name1 = DEFAULT_TEST_BRIDGE
 176             server1.create_test_bridge(br_name1, interface_node1)
 177
 178         if server2.is_ovs_bridge(interface_node2):
 179             br_name2 = interface_node2
 180         else:
 181             br_name2 = DEFAULT_TEST_BRIDGE
 182             server2.create_test_bridge(br_name2, interface_node2)
 183
 184         server1.add_port_to_bridge(br_name1, DEFAULT_TEST_PORT)
 185         servers_with_test_ports.append(server1)
 186         server2.add_port_to_bridge(br_name2, DEFAULT_TEST_PORT)
 187         servers_with_test_ports.append(server2)
 188
 189         server1.ovs_vsctl_set("Port", DEFAULT_TEST_PORT, "tag", None, tag)
 190         server2.ovs_vsctl_set("Port", DEFAULT_TEST_PORT, "tag", None, tag)
 191
 192         server1.ovs_vsctl_set("Interface", DEFAULT_TEST_PORT, "type", None,
 193                               "internal")
 194         server2.ovs_vsctl_set("Interface", DEFAULT_TEST_PORT, "type", None,
 195                               "internal")
 196
 197         server1.interface_assign_ip(DEFAULT_TEST_PORT, node1[2], None)
 198         server2.interface_assign_ip(DEFAULT_TEST_PORT, node2[2], None)
 199
 200         server1.interface_up(DEFAULT_TEST_PORT)
 201         server2.interface_up(DEFAULT_TEST_PORT)
 202
 203         do_udp_tests(node1, node2, bandwidth, duration, ps)
 204         do_udp_tests(node2, node1, bandwidth, duration, ps)
 205         do_tcp_tests(node1, node2, duration)
 206         do_tcp_tests(node2, node1, duration)
 207
 208     finally:
 209         for server in servers_with_test_ports:
 210             server.del_port_from_bridge(DEFAULT_TEST_PORT)
 211         if br_name1 == DEFAULT_TEST_BRIDGE:
 212             server1.del_test_bridge(br_name1, interface_node1)
 213         if br_name2 == DEFAULT_TEST_BRIDGE:
 214             server2.del_test_bridge(br_name2, interface_node2)
 215
 216
 217 def do_direct_tests(node1, node2, bandwidth, duration, ps):
 218     """
 219     Do tests between outer IPs without involving Open vSwitch. Each
 220     node is given as 4 tuple - physical interface IP, control port,
 221     test IP and test port. Direct tests will use physical interface
 222     IP as the test IP address.
 223     """
 224     n1 = (node1[0], node1[1], node1[0], node1[3])
 225     n2 = (node2[0], node2[1], node2[0], node2[3])
 226
 227     do_udp_tests(n1, n2, bandwidth, duration, ps)
 228     do_udp_tests(n2, n1, bandwidth, duration, ps)
 229     do_tcp_tests(n1, n2, duration)
 230     do_tcp_tests(n2, n1, duration)
 231
 232
 233 def configure_l3(conf, tunnel_mode):
 234     """
 235     This function creates a temporary test bridge and adds an L3 tunnel.
 236     """
 237     s = util.start_local_server(conf[1][1])
 238     server = util.rpc_client("127.0.0.1", conf[1][1])
 239     server.create_bridge(DEFAULT_TEST_BRIDGE)
 240     server.add_port_to_bridge(DEFAULT_TEST_BRIDGE, DEFAULT_TEST_PORT)
 241     server.interface_up(DEFAULT_TEST_BRIDGE)
 242     server.interface_assign_ip(DEFAULT_TEST_BRIDGE, conf[1][0],
 243                                None)
 244     server.ovs_vsctl_set("Interface", DEFAULT_TEST_PORT, "type",
 245                          None, tunnel_mode)
 246     server.ovs_vsctl_set("Interface", DEFAULT_TEST_PORT, "options",
 247                          "remote_ip", conf[0])
 248     return s