Esempio n. 1
0
    def runTTCP(self, remote, arglist, ssh):
        self.ssh = ssh
        self.firewall = False
        self.remote = remote

        mtus = "1496,552"
        buffers = 50000
        size = 8192
        socks = "131072"
        reps = 9
        nomtu = False

        if arglist:
            for arg in arglist:
                l = string.split(arg, "=", 1)
                if l[0] == "mtu":
                    mtus = l[1]
                elif l[0] == "buffers":
                    buffers = int(l[1])
                elif l[0] == "size":
                    size = int(l[1])
                elif l[0] == "reps":
                    reps = int(l[1])
                elif l[0] == "nomtu":
                    nomtu = True

        # Get a TTCP peer
        peer = xenrt.NetworkTestPeer()
        self.peer = peer
        try:
            peer.runCommand("killall ttcp")
        except:
            pass

        self.tec.comment("%u buffers of %u bytes" % (buffers, size))
        self.tec.comment("MTUs %s" % (mtus))
        self.tec.comment("Peer %s" % (peer.getAddress()))

        # Install TTCP on the remote
        self.install(remote)

        # Disable firewalls etc.
        if remote.windows:
            try:
                remote.xmlrpcExec('NETSH firewall set allowedprogram '
                                  'program="%s" name="TTCP" mode=ENABLE' %
                                  (self.ttcp))
            except:
                xenrt.TEC().comment("Error disabling firewall")
        else:
            try:
                if not remote.execcmd("/etc/init.d/iptables status", retval="code"):
                    self.firewall = True
                    remote.execcmd("/etc/init.d/iptables stop")
            except:
                pass

        # Run the tests
        try:
            for mtustr in string.split(mtus, ","):
                if mtustr == "default":
                    mtu = 0
                else:
                    mtu = int(mtustr)
                if not nomtu:
                    if mtu:
                        peer.runCommand("/sbin/ifconfig eth0 mtu %u" % (mtu))
                    else:
                        peer.runCommand("/sbin/ifconfig eth0 mtu 1500")
                for sockstr in string.split(socks, ","):
                    sock = int(sockstr)
                    tx = []
                    rx = []
                    for i in range(reps):
                        v = self.doTX(peer, remote, mtu, sock, buffers, size)
                        tx.append(v)
                        self.tec.appresult("TX:%u:%u (%u) %f" %
                                           (sock, mtu, i, v))
                        v = self.doRX(peer, remote, mtu, sock, buffers, size)
                        rx.append(v)
                        self.tec.appresult("RX:%u:%u (%u) %f" %
                                           (sock, mtu, i, v))
                    v = xenrt.median(tx)
                    self.tec.value("TX:%u:%u" % (sock, mtu), v, "MB/s")
                    v = xenrt.median(rx)
                    self.tec.value("RX:%u:%u" % (sock, mtu), v, "MB/s")
        finally:
            if not nomtu:
                peer.runCommand("/sbin/ifconfig eth0 mtu 1500")
Esempio n. 2
0
                         except xenrt.XRTException, e:
                             failures.append(e)
                 if "UDP" in protocols:
                     try:
                         v, c = self.doTest(peer,
                                            remote,
                                            sock,
                                            duration,
                                            "UDP_STREAM")
                         txudp.append(v)
                         self.tec.appresult("TX:UDP:%u:%u (%u) %f" %
                                            (sock, mtu, i, v))
                     except xenrt.XRTException, e:
                         failures.append(e)
             if "TCP" in protocols:
                 v = xenrt.median(tx)
                 self.tec.value("TX:TCP:%u:%u" % (sock, mtu), v, "MB/s")
                 v = xenrt.median(rx)
                 self.tec.value("RX:TCP:%u:%u" % (sock, mtu), v, "MB/s")
                 if tcprr:
                     v = xenrt.median(rr)
                     self.tec.value("RR:TCP:%u:%u" % (sock, mtu), v, "t/s")
             if "UDP" in protocols:
                 v = xenrt.median(txudp)
                 self.tec.value("TX:UDP:%u:%u" % (sock, mtu), v, "MB/s")
 finally:
     if not nomtu:
         peer.runCommand("/sbin/ifconfig eth0 mtu 1500")
 if len(failures) == 1:
     raise failures[0]
 elif len(failures) > 1: