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