예제 #1
0
파일: PktgenTx.py 프로젝트: jpirko/lnst
    def run(self):
        dev_names = self.get_multi_mopt("netdev_name")
        pktgen_options = self.get_multi_mopt("pktgen_option")
        thread_options = self.get_multi_opt("thread_option")

        default_pktgen_options = ["count 10000000", "clone_skb 100000", "pkt_size 60"]
        pktgen_options = pktget_options_merge(pktgen_options, default_pktgen_options)

        exec_cmd("modprobe pktgen")

        pktgen_devices_remove()

        pgctl = Pktgen("/proc/net/pktgen/pgctrl")
        pgwrkr = PktgenWorkers()

        try:
            for idx, dev_name in enumerate(dev_names):
                pgwrkr.add_device(dev_name)
                pg = Pktgen("/proc/net/pktgen/%s" % dev_name)
                for pktgen_option in pktgen_options:
                    pg.set(pktgen_option)
                if not thread_options:
                    continue
                for thread_option in re.split(",", thread_options[idx]):
                    pg.set(thread_option)

            pgctl.set("start")
        except ExecCmdFail:
            res_data = {"msg": "pktgen failed"}
            return self.set_fail(res_data)

        return self.set_pass()
예제 #2
0
    def create(self):
        dev_cfg = self._dev_config
        br_name = dev_cfg["name"]
        exec_cmd("ovs-vsctl add-br %s" % br_name)

        self._add_internal_ports()
        self._add_tunnels()
예제 #3
0
    def destroy(self):
        self._del_tunnels()
        self._del_internal_ports()

        dev_cfg = self._dev_config
        br_name = dev_cfg["name"]
        exec_cmd("ovs-vsctl del-br %s" % br_name)
예제 #4
0
    def create(self):
        config = self._dev_config
        dev_name = config["name"]
        params = []

        slaves = get_slaves(config)
        if len(slaves) == 1:
            ul_id = slaves[0]
            ul_name = self._if_manager.get_mapped_device(ul_id).get_name()
            params.append(" dev %s" % ul_name)

        for k in ("ttl", "tos", "key", "ikey", "okey",
                  "local_ip", "remote_ip"):
            v = get_option(config, k)
            if v is not None:
                flag = {"local_ip": "local",
                        "remote_ip": "remote"}.get(k, k)
                params.append(" %s %s" % (flag, v))

        for k in ("seq", "iseq", "oseq",
                  "csum", "icsum", "ocsum"):
            v = get_option(config, k)
            if v is not None and bool_it(v):
                params.append(" " + k)

        exec_cmd("ip tunnel add name %s mode gre%s"
                 % (dev_name, "".join(params)))
예제 #5
0
    def create(self):
        config = self._dev_config

        slaves = get_slaves(config)
        if len(slaves) == 1:
            realdev_id = slaves[0]
            name = self._if_manager.get_mapped_device(realdev_id).get_name()
            dev_param = "dev %s" % name
        else:
            dev_param = ""

        dev_name = config["name"]
        vxlan_id = int(get_option(config, "id"))
        group_ip = get_option(config, "group_ip")
        remote_ip = get_option(config, "remote_ip")

        if group_ip:
            group_or_remote = "group %s" % group_ip
        elif remote_ip:
            group_or_remote = "remote %s" % remote_ip
        else:
            raise Exception("group or remote must be specified for vxlan")

        dstport = get_option(config, "dstport")
        if not dstport:
            dstport = 0
        else:
            dstport = int(dstport)

        exec_cmd("ip link add %s type vxlan id %d %s %s dstport %d"
                                % (dev_name,
                                   vxlan_id,
                                   dev_param,
                                   group_or_remote,
                                   dstport))
예제 #6
0
    def hello(self, recipe_path):
        self.machine_cleanup()
        self.restore_nm_option()

        logging.info("Recieved a controller connection.")
        self.clear_resource_table()
        self._cache.del_old_entries()
        self.reset_file_transfers()

        self._if_manager.rescan_devices()

        date = datetime.datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
        self._log_ctl.set_recipe(recipe_path, expand=date)
        sleep(1)

        slave_desc = {}
        if check_process_running("NetworkManager"):
            logging.warning("=============================================")
            logging.warning("NetworkManager is running on a slave machine!")
            if lnst_config.get_option("environment", "use_nm"):
                logging.warning("Support of NM is still experimental!")
            else:
                logging.warning("Usage of NM is disabled!")
            logging.warning("=============================================")
            slave_desc["nm_running"] = True
        else:
            slave_desc["nm_running"] = False

        k_release, _ = exec_cmd("uname -r", False, False, False)
        r_release, _ = exec_cmd("cat /etc/redhat-release", False, False, False)
        slave_desc["kernel_release"] = k_release.strip()
        slave_desc["redhat_release"] = r_release.strip()

        return ("hello", slave_desc)
예제 #7
0
    def configure(self):
        config = self._dev_config
        exec_cmd("ethtool -A %s rx off tx off" % config["name"], die_on_err=False, log_outputs=False)

        hw_addr = self._convert_hwaddr(config)

        s_eth = dbus.Dictionary({"mac-address": hw_addr}, signature="sv")
        s_con = dbus.Dictionary(
            {
                "type": "802-3-ethernet",
                "autoconnect": dbus.Boolean(False),
                "uuid": str(uuid.uuid4()),
                "id": "lnst_ethcon",
            },
            signature="sv",
        )

        connection = dbus.Dictionary(
            {
                "802-3-ethernet": s_eth,
                "connection": s_con,
                "ipv4": dbus.Dictionary({"method": "disabled"}, signature="sv"),
                "ipv6": dbus.Dictionary({"method": "ignore"}, signature="sv"),
            },
            signature="sa{sv}",
        )

        self._connection = connection
        self._nm_add_connection()
        if config["netem"] is not None:
            cmd = "tc qdisc add dev %s root netem %s" % (config["name"], parse_netem(config["netem"]))
            exec_cmd(cmd)
            config["netem_cmd"] = cmd
예제 #8
0
 def set_mcast_flood(self, on = True):
     cmd = "ip link set dev %s type bridge_slave mcast_flood " % self._name
     if on:
         cmd += "on"
     else:
         cmd += "off"
     exec_cmd(cmd)
예제 #9
0
    def deconfigure(self):
        for slave_id in get_slaves(self._dev_config):
            self.slave_del(slave_id)

        dev_name = self._dev_config["name"]

        exec_cmd("teamd -k -t %s" % dev_name)
예제 #10
0
 def _configure_service(self, service, start=True):
     action = "start" if start else "stop"
     if self._is_systemd():
         exec_cmd("systemctl {} {}".format(action, service))
     else:
         exec_cmd("service {} {}".format(service, action))
     return True
예제 #11
0
    def configure(self):
        config = self._dev_config
        exec_cmd("ethtool -A %s rx off tx off" % config["name"],
                 die_on_err=False, log_outputs=False)

        hw_addr = self._convert_hwaddr(config)

        s_eth = dbus.Dictionary({'mac-address': hw_addr}, signature='sv')
        s_con = dbus.Dictionary({
            'type': '802-3-ethernet',
            'autoconnect': dbus.Boolean(False),
            'uuid': str(uuid.uuid4()),
            'id': 'lnst_ethcon'}, signature='sv')

        connection = dbus.Dictionary({
            '802-3-ethernet': s_eth,
            'connection': s_con,
            'ipv4': dbus.Dictionary({'method': 'disabled'}, signature='sv'),
            'ipv6': dbus.Dictionary({'method': 'ignore'}, signature='sv'),
            }, signature='sa{sv}')

        self._connection = connection
        self._nm_add_connection()
        if config["netem"] is not None:
            cmd = "tc qdisc add dev %s root netem %s" % (config["name"], parse_netem(config["netem"]))
            exec_cmd(cmd)
            config["netem_cmd"] = cmd
예제 #12
0
 def down(self):
     config = self._dev_config
     if "addresses" in config:
         for address in config["addresses"]:
             exec_cmd("ip addr del %s dev %s" % (address, config["name"]),
                      die_on_err=False)
     exec_cmd("ip link set %s down" % config["name"])
예제 #13
0
    def set_device_down(self, hwaddr):
        devs = self.get_devices_by_hwaddr(hwaddr)

        for dev in devs:
            if is_nm_managed_by_name(dev["name"]):
                bus = dbus.SystemBus()
                nm_obj = bus.get_object("org.freedesktop.NetworkManager",
                                        "/org/freedesktop/NetworkManager")
                nm_if = dbus.Interface(nm_obj, "org.freedesktop.NetworkManager")
                dev_obj_path = nm_if.GetDeviceByIpIface(dev["name"])
                dev_obj = bus.get_object("org.freedesktop.NetworkManager",
                                         dev_obj_path)
                dev_props = dbus.Interface(dev_obj,
                                        "org.freedesktop.DBus.Properties")
                if dev_props.Get("org.freedesktop.NetworkManager.Device",
                                 "ActiveConnection") != "/":
                    dev_if = dbus.Interface(dev_obj,
                                        "org.freedesktop.NetworkManager.Device")
                    logging.debug("Disconnecting device %s: %s" %
                                            (dev["name"], dev_obj_path))
                    dev_if.Disconnect()
            else:
                exec_cmd("ip link set %s down" % dev["name"])

        return True
예제 #14
0
 def deconfigure(self):
     config = self._dev_config
     exec_cmd("ethtool -s %s autoneg on" % config["name"])
     if "netem_cmd" in config:
         exec_cmd(config["netem_cmd"].replace("add", "del"))
     if "lldp" in config:
         self.deconfigure_lldp()
예제 #15
0
    def down(self):
        int_ports = self._dev_config["ovs_conf"]["internals"]
        br_name = self._dev_config["name"]
        for iport in int_ports:
            exec_cmd("ip link set %s down" % iport["name"])

        super(NetConfigDeviceOvsBridge, self).down()
예제 #16
0
파일: PktgenTx.py 프로젝트: aloughlam/lnst
    def run(self):
        dev_names = self.get_multi_mopt("netdev_name")
        pktgen_options = self.get_multi_mopt("pktgen_option")

        default_pktgen_options = [
            "count 10000000",
            "clone_skb 100000",
            "pkt_size 60",
        ]
        pktgen_options = pktget_options_merge(pktgen_options,
                                              default_pktgen_options)

        exec_cmd("modprobe pktgen")

        pgctl = Pktgen("/proc/net/pktgen/pgctrl")
        pgwrkr = PktgenWorkers()

        try:
            for dev_name in dev_names:
                pgwrkr.add_device(dev_name)
                pg = Pktgen("/proc/net/pktgen/%s" % dev_name)
                for pktgen_option in pktgen_options:
                    pg.set(pktgen_option)
            pgctl.set("start")
        except ExecCmdFail:
            res_data = {"msg": "pktgen failed"}
            return self.set_fail(res_data)

        return self.set_pass()
예제 #17
0
    def _add_ports(self):
        slaves = self._dev_config["slaves"]
        vlans = self._dev_config["ovs_conf"]["vlans"]

        br_name = self._dev_config["name"]

        bond_ports = []
        for bond in self._dev_config["ovs_conf"]["bonds"].itervalues():
            for slave_id in bond["slaves"]:
                bond_ports.append(slave_id)

        for slave_id in slaves:
            if slave_id in bond_ports:
                continue
            slave_dev = self._if_manager.get_mapped_device(slave_id)
            slave_name = slave_dev.get_name()

            options = ""
            for opt in get_slave_options(self._dev_config, slave_id):
                options += " %s=%s" % (opt[0], opt[1])

            vlan_tags = []
            for tag, vlan in vlans.iteritems():
                if slave_id in vlan["slaves"]:
                    vlan_tags.append(tag)
            if len(vlan_tags) == 0:
                tags = ""
            elif len(vlan_tags) == 1:
                tags = " tag=%s" % vlan_tags[0]
            elif len(vlan_tags) > 1:
                tags = " trunks=" + ",".join(vlan_tags)
            exec_cmd("ovs-vsctl add-port %s %s%s" % (br_name, slave_name, tags))

            if options != "":
                exec_cmd("ovs-vsctl set Interface %s%s" % (slave_name, options))
예제 #18
0
 def _add_rm_slaves(self, mark):
     for slave in get_slaves(self._netdev):
         slavenetdev = self._config[slave]
         slave_name = slavenetdev["name"]
         if (mark == "+"):
             NetConfigDevice(slavenetdev, self._config).down()
         exec_cmd('echo "%s%s" > %s/slaves' % (mark, slave_name,
                                               self._get_bond_dir()))
예제 #19
0
    def create(self):
        teamd_config = get_option(self._dev_config, "teamd_config")
        teamd_config = prepare_json_str(teamd_config)

        dev_name = self._dev_config["name"]

        dbus_option = " -D" if self._should_enable_dbus() else ""
        exec_cmd("teamd -r -d -c \"%s\" -t %s %s" % (teamd_config, dev_name, dbus_option))
예제 #20
0
파일: BridgeTool.py 프로젝트: eladraz/lnst
 def set_state(self, br_state_info):
     cmd = "bridge link set dev %s state %s" % (self._dev_name,
                                                br_state_info["state"])
     if br_state_info["self"]:
         cmd += " self"
     if br_state_info["master"]:
         cmd += " master"
     exec_cmd(cmd)
예제 #21
0
    def deconfigure(self):
        dev_cfg = self._dev_config

        self._del_bonds()

        self._del_ports()

        br_name = dev_cfg["name"]
        exec_cmd("ovs-vsctl del-br %s" % br_name)
예제 #22
0
    def address_setup(self):
        super(NetConfigDeviceOvsBridge, self).up()

        int_ports = self._dev_config["ovs_conf"]["internals"]
        br_name = self._dev_config["name"]
        for iport in int_ports:
            if "addresses" in iport:
                for address in iport["addresses"]:
                    exec_cmd("ip addr add %s dev %s" % (address, iport["name"]))
예제 #23
0
    def _setup_options(self):
        if not "options" in self._dev_config:
            return
        options = self._dev_config["options"]

        for option, value in options:
            exec_cmd('echo "%s" > %s/%s' % (value,
                                            self._get_bridge_dir(),
                                            option))
예제 #24
0
    def _add_bonds(self):
        br_name = self._dev_config["name"]

        bonds = self._dev_config["ovs_conf"]["bonds"]
        for bond_id, bond in bonds.iteritems():
            ifaces = ""
            for slave in bond["slaves"]:
                ifaces += " %s" % slave
            exec_cmd("ovs-vsctl add-bond %s %s %s" % (br_name, bond_id, ifaces))
예제 #25
0
    def configure(self):
        dev_cfg = self._dev_config

        br_name = dev_cfg["name"]
        exec_cmd("ovs-vsctl add-br %s" % br_name)

        self._add_ports()

        self._add_bonds()
예제 #26
0
 def _add_rm_slaves(self, mark):
     for slave_id in get_slaves(self._dev_config):
         slave_dev = self._if_manager.get_mapped_device(slave_id)
         slave_conf = slave_dev.get_conf_dict()
         slave_name = slave_dev.get_name()
         if (mark == "+"):
             slave_dev.down()
         exec_cmd('echo "%s%s" > %s/slaves' % (mark, slave_name,
                                               self._get_bond_dir()))
예제 #27
0
파일: BridgeTool.py 프로젝트: eladraz/lnst
 def _add_del_fdb(self, op, br_fdb_info):
     cmd = "bridge fdb %s %s dev %s" % (op, br_fdb_info["hwaddr"],
                                        self._dev_name)
     if br_fdb_info["self"]:
         cmd += " self"
     if br_fdb_info["master"]:
         cmd += " master"
     if br_fdb_info["vlan_id"]:
         cmd += " vlan %s" % br_fdb_info["vlan_id"]
     exec_cmd(cmd)
예제 #28
0
    def _del_ports(self):
        slaves = self._dev_config["slaves"]

        br_name = self._dev_config["name"]

        for slave_id in slaves:
            slave_dev = self._if_manager.get_mapped_device(slave_id)
            slave_name = slave_dev.get_name()

            exec_cmd("ovs-vsctl del-port %s %s" % (br_name, slave_name))
예제 #29
0
    def down(self):
        int_ports = self._dev_config["ovs_conf"]["internals"]
        br_name = self._dev_config["name"]
        for iport in int_ports:
            if "addresses" in iport:
                for address in iport["addresses"]:
                    exec_cmd("ip addr del %s dev %s" % (address, iport["name"]))
            exec_cmd("ip link set %s down" % iport["name"])

        super(NetConfigDeviceOvsBridge, self).down()
예제 #30
0
    def address_cleanup(self):
        super(NetConfigDeviceOvsBridge, self).down()
        super(NetConfigDeviceOvsBridge, self).address_cleanup()

        int_ports = self._dev_config["ovs_conf"]["internals"]
        br_name = self._dev_config["name"]
        for iport in int_ports:
            if "addresses" in iport:
                for address in iport["addresses"]:
                    exec_cmd("ip addr del %s dev %s" % (address, iport["name"]),
                             die_on_err=False)
예제 #31
0
 def get_fdbs(_self):
     output = exec_cmd("bridge fdb show dev %s" % _self._dev_name,
                       die_on_err=False)[0]
     br_fdb_info_list = []
     for line in output.split("\n"):
         match = re.match(
             r'([0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2})',
             line)
         if match:
             hwaddr = normalize_hwaddr(match.groups()[0])
             match = re.match(r'.*\s+vlan (\d+)', line)
             vlan_id = int(match.groups()[0]) if match else 0
             self = True if re.match(r'.*\s+self', line) else False
             master = True if re.match(r'.*\s+master', line) else False
             offload = True if re.match(r'.*\s+offload', line) else False
             extern_learn = True if re.match(r'.*\s+extern_learn',
                                             line) else False
             br_fdb_info = {
                 "hwaddr": hwaddr,
                 "vlan_id": vlan_id,
                 "self": self,
                 "master": master,
                 "offload": offload,
                 "extern_learn": extern_learn
             }
             br_fdb_info_list.append(br_fdb_info)
     return br_fdb_info_list
예제 #32
0
    def qdisc_red_stats(self, parent = None):
        try:
            out, _ = exec_cmd("tc -s qdisc show dev %s" % self._name)
        except ExecCmdFail:
            return {}

        if parent:
            parent = "parent 3:%d" % parent
        else:
            parent = "root"

        p = r"[.\n]*?qdisc red.+?%s.+?(offloaded)? limit.*?\n\s*Sent " \
            r"(?P<tx_bytes>\d+) bytes (?P<tx_packets>\d+) pkt \(dropped " \
            r"(?P<drops>\d+), overlimits (?P<overlimits>\d+).*\n\s*backlog " \
            r"(?P<backlog>\d+\w?)b.*\n.*?marked (?P<marked>\d+) early " \
            r"(?P<early>\d+) pdrop (?P<pdrop>\d+)" % parent
        red_pattern = re.compile(p, re.MULTILINE)
        stats_raw = red_pattern.search(out)
        if not stats_raw:
            return {}

        stats = {key: int(val.replace("K", "000").replace("M", "000000"))
                for key, val in stats_raw.groupdict().iteritems()}

        stats["offload"] = "offloaded" in stats_raw.groups()
        stats["devname"] = self._name
        stats["hwaddr"] = self._hwaddr
        return stats
예제 #33
0
    def link_stats(self):
        stats = {"devname": self._name, "hwaddr": self._hwaddr}
        try:
            out, _ = exec_cmd("ip -s link show %s" % self._name)
        except:
            return {}

        lines = iter(out.split("\n"))
        for line in lines:
            if (len(line.split()) == 0):
                continue
            if (line.split()[0] == 'vf'):
                break
            if (line.split()[0] == "RX:"):
                rx_stats = map(int, lines.next().split())
                stats.update({
                    "rx_bytes": rx_stats[0],
                    "rx_packets": rx_stats[1],
                    "rx_errors": rx_stats[2],
                    "rx_dropped": rx_stats[3],
                    "rx_overrun": rx_stats[4],
                    "rx_mcast": rx_stats[5]
                })
            if (line.split()[0] == "TX:"):
                tx_stats = map(int, lines.next().split())
                stats.update({
                    "tx_bytes": tx_stats[0],
                    "tx_packets": tx_stats[1],
                    "tx_errors": tx_stats[2],
                    "tx_dropped": tx_stats[3],
                    "tx_carrier": tx_stats[4],
                    "tx_collsns": tx_stats[5]
                })
        return stats
예제 #34
0
    def run(self):
        cmd = self.compose_cmd()
        logging.debug("%s" % cmd)

        limit_rate = self.get_opt("limit_rate ", default=80)
        data_stdout = exec_cmd(cmd, die_on_err=False)[0]

        stat_pttr1 = r'(\d+) packets transmitted, (\d+) received'
        stat_pttr2 = r' rtt min/avg/max/mdev = \
            (\d+\.\d+)/(\d+\.\d+)/(\d+\.\d+)/(\d+\.\d+) ms'

        match = re.search(stat_pttr1, data_stdout)
        if not match:
            return self.set_fail("expected pattern not found")

        trans_pkts, recv_pkts = match.groups()
        rate = int(round((float(recv_pkts) / float(trans_pkts)) * 100))
        logging.debug("Transmitted \"%s\", received \"%s\", " \
            "rate \"%d%%\", limit_rate \"%d%%\"" \
            % (trans_pkts, recv_pkts, rate, limit_rate ))

        match = re.search(stat_pttr2, data_stdout)
        if match:
            tmin, tavg, tmax, tmdev = [float(x) for x in match.groups()]
            logging .debug("rtt min \"%.3f\", avg \"%.3f\", max \"%.3f\", "
                  "mdev \"%.3f\"" % (tmin, tavg, tmax, tmdev))

        if rate < limit_rate :
            return self.set_fail("rate is lower that limit")

        return self.set_pass()
예제 #35
0
    def exec_from(self, tools_name, cmd, *args, **kwargs):
        if not tools_name in self._resource_table["tools"]:
            msg = "Tools '%s' not found" % tools_name
            raise CommandException(msg)

        tools_path = self._resource_table["tools"][tools_name]
        return exec_cmd("cd \"%s\" && %s" % (tools_path, cmd), *args, **kwargs)
예제 #36
0
    def link_cpu_ifstat(self):
        stats = {"devname": self._name,
                 "hwaddr": self._hwaddr}
        if len(self._slaves) != 0:
            return self.link_cpu_ifstat_from_slaves()

        try:
            out, _ = exec_cmd("ifstat -x c %s" % self._name)
        except:
            return {}
        lines = iter(out.split("\n"))
        line_first = ""
        line_decond = ""
        for line in lines:
            if (len(line.split()) == 0):
                continue
            if (line.split()[0] == self._name):
                break
        else:
            return {}
        stats_data = line.split()[1:]
        for i in range(len(stats_data)):
            stats_data[i] = stats_data[i].replace("K",  "000")
            stats_data[i] = stats_data[i].replace("M", "000000")

        stats_data = map(int, stats_data)
        stats["rx_packets"] = stats_data[0]
        stats["tx_packets"] = stats_data[2]
        stats["rx_bytes"] = stats_data[4]
        stats["tx_bytes"] = stats_data[6]
        return stats
예제 #37
0
파일: Agent.py 프로젝트: Axonis/lnst
    def hello(self):
        logging.info("Recieved a controller connection.")

        agent_desc = {}
        if check_process_running("NetworkManager"):
            agent_desc["nm_running"] = True
        else:
            agent_desc["nm_running"] = False

        k_release, _ = exec_cmd("uname -r", False, False, False)
        r_release, _ = exec_cmd("cat /etc/redhat-release", False, False, False)
        agent_desc["kernel_release"] = k_release.strip()
        agent_desc["redhat_release"] = r_release.strip()
        agent_desc["lnst_version"] = lnst_version

        return ("hello", agent_desc)
예제 #38
0
 def _check_ip_link_add(self):
     output = exec_cmd("ip link help", die_on_err=False,
                       log_outputs=False)[1]
     for line in output.split("\n"):
         if re.match(r'^.*ip link add [\[]{0,1}link.*$', line):
             return True
     return False
예제 #39
0
파일: TRexServer.py 프로젝트: yuvalmin/lnst
    def run(self):
        cfg_file = tempfile.NamedTemporaryFile(delete=False)
        yaml.dump(self._trex_config, cfg_file)

        exec_cmd(
            "unset TMUX; tmux new-session -d -s trex 'cd {trex_dir}; ./t-rex-64 --cfg {cfg_path} -i'"
            .format(trex_dir=self._trex_path, cfg_path=cfg_file.name))

        self.wait_on_interrupt()

        exec_cmd("unset TMUX; tmux kill-session -t trex")
        os.remove(cfg_file.name)

        res_data = {}
        res_data["msg"] = ""
        return self.set_pass(res_data)
예제 #40
0
    def _del_ports(self):
        slaves = self._dev_config["slaves"]

        br_name = self._dev_config["name"]

        bond_ports = []
        for bond in self._dev_config["ovs_conf"]["bonds"].values():
            for slave_id in bond["slaves"]:
                bond_ports.append(slave_id)

        for slave_id in slaves:
            if slave_id in bond_ports:
                continue
            slave_dev = self._if_manager.get_mapped_device(slave_id)
            slave_name = slave_dev.get_name()

            exec_cmd("ovs-vsctl del-port %s %s" % (br_name, slave_name))
예제 #41
0
파일: Utils.py 프로젝트: yuvalmin/lnst
def create_tar_archive(input_path, target_path, compression=False):
    if compression:
        args = "cfj"
    else:
        args = "cf"

    input_path = input_path.rstrip("/")
    input_file = os.path.basename(input_path)
    parent = os.path.dirname(input_path)

    if os.path.isdir(target_path):
        target_path += "/%s.tar.bz" % os.path.basename(input_file.rstrip("/"))

    exec_cmd("cd \"%s\" && tar %s \"%s\" \"%s\"" % \
                (parent, args, target_path, input_file))

    return target_path
예제 #42
0
    def _add_tunnels(self):
        tunnels = self._dev_config["ovs_conf"]["tunnels"]
        br_name = self._dev_config["name"]

        for i in tunnels:
            i["name"] = self._if_manager.assign_name_generic(prefix=i["type"])

            options = ""
            for opt in i["options"]:
                options += " %s=%s" % (opt["name"], opt["value"])

                if opt["name"] == "name":
                    i["name"] = opt["value"]

            exec_cmd("ovs-vsctl add-port %s %s -- set Interface %s "\
                     "type=%s %s" % (br_name, i["name"], i["name"],
                                     i["type"], options))
예제 #43
0
    def set_qdisc_red(self, limit, avpkt, _min, _max, prob = 0, ecn = False,
                      change = False, burst = None, parent = None):
        cmd = "change" if change else "add"
        if parent:
            parent = "parent 3:%d" % parent
        else:
            parent = "root"

        cmd = "tc qdisc %s dev %s %s red limit %d avpkt %d min %d max %d" % \
              (cmd, self._name, parent, limit, avpkt, _min, _max)
        if prob:
            cmd += " prob %d" % prob
        if ecn:
            cmd += " ecn"
        if burst:
            cmd += " burst %d" % burst
        exec_cmd(cmd)
예제 #44
0
    def set_if_netns(self, if_id, netns):
        netns_pid = self._net_namespaces[netns]["pid"]

        device = self._if_manager.get_mapped_device(if_id)
        dev_name = device.get_name()
        device.set_netns(netns)
        hwaddr = device.get_hwaddr()

        exec_cmd("ip link set %s netns %d" % (dev_name, netns_pid))
        msg = {
            "type": "command",
            "method_name": "map_if_by_hwaddr",
            "args": [if_id, hwaddr]
        }
        self._server_handler.send_data_to_netns(netns, msg)
        result = self._slave_server.wait_for_result(netns)
        return result
예제 #45
0
    def internal_port_add(self, **kwargs):
        name = self._if_manager.assign_name("int")

        options = ""
        for opt_name, opt_value in kwargs.items():
            if opt_name == "name":
                name = opt_value
                continue

            options += " %s=%s" % (opt_name, opt_value)

        exec_cmd("ovs-vsctl add-port %s %s -- set Interface %s "\
                 "type=internal %s" % (self.name, name,
                                       name, options))

        dev = self._if_manager.get_device_by_name(name)
        return dev
예제 #46
0
 def deconfigure_lldp(self):
     config = self._dev_config
     up2tc_def = ','.join(["{}:0".format(x) for x in range(8)])
     tsa_def = ','.join(["{}:strict".format(x) for x in range(8)])
     exec_cmd("lldptool -i %s -V ETS-CFG -T up2tc=%s" %
              (config["name"], up2tc_def))
     exec_cmd("lldptool -i %s -V ETS-CFG -T tsa=%s" %
              (config["name"], tsa_def))
     exec_cmd("lldptool -i %s -V PFC -T enabled=none" % config["name"])
     exec_cmd("lldptool -i %s -L adminStatus=disabled" % config["name"])
예제 #47
0
파일: Job.py 프로젝트: omaciel/lnst
 def run(self):
     try:
         stdout, stderr = exec_cmd(self._what["command"], self._what["json"])
         self._result["passed"] = True
         self._result["res_data"] = {"stdout": stdout, "stderr": stderr}
     except ExecCmdFail as e:
         self._result["passed"] = False
         self._result["res_data"] = res_data = {"stdout": e.get_stdout(),
                                                "stderr": e.get_stderr()}
예제 #48
0
 def _ethtool_get_driver(self):
     if self._ifi_type == 772:  #loopback ifi type
         return 'loopback'
     out, _ = exec_cmd("ethtool -i %s" % self._name, False, False, False)
     match = re.search("^driver: (.*)$", out, re.MULTILINE)
     if match is not None:
         return match.group(1)
     else:
         return None
예제 #49
0
    def _clear_tc_qdisc(self):
        try:
            #checks device existence as it might have been removed by
            #calling self.deconfigure()
            exec_cmd("ip l show %s" % self._name, log_outputs=False)
        except:
            return

        exec_cmd("tc qdisc del dev %s root" % self._name, die_on_err=False)
        out, _ = exec_cmd("tc filter show dev %s" % self._name)
        ingress_handles = re.findall("ingress (\\d+):", out)
        for ingress_handle in ingress_handles:
            exec_cmd("tc qdisc del dev %s handle %s: ingress" %
                     (self._name, ingress_handle))
        out, _ = exec_cmd("tc qdisc show dev %s" % self._name)
        ingress_qdiscs = re.findall("qdisc ingress (\\w+):", out)
        if len(ingress_qdiscs) != 0:
                exec_cmd("tc qdisc del dev %s ingress" % self._name)
예제 #50
0
    def _add_internal_ports(self):
        int_ports = self._dev_config["ovs_conf"]["internals"]
        br_name = self._dev_config["name"]

        for i in int_ports:
            i["name"] = self._if_manager.assign_name_generic(prefix="int")

            options = ""
            if "options" in i:
                for opt in i["options"]:
                    options += " %s=%s" % (opt["name"], opt["value"])

                    if opt["name"] == "name":
                        i["name"] = opt["value"]

            exec_cmd("ovs-vsctl add-port %s %s -- set Interface %s "\
                     "type=internal %s" % (br_name, i["name"],
                                           i["name"], options))
예제 #51
0
    def get_ethtool_stats(self):
        stdout, _ = exec_cmd("ethtool -S %s" % self._name)

        d = {}
        # First and last lines don't contain stats.
        for line in stdout.split('\n')[1:-1]:
            stat, count = line.split(':')
            d[stat.strip()] = int(count)
        return d
예제 #52
0
파일: Device.py 프로젝트: omaciel/lnst
 def _clear_tc_qdisc(self):
     exec_cmd("tc qdisc del dev %s root" % self.name, die_on_err=False)
     out, _ = exec_cmd("tc filter show dev %s" % self.name)
     ingress_handles = re.findall("ingress (\\d+):", out)
     for ingress_handle in ingress_handles:
         exec_cmd("tc qdisc del dev %s handle %s: ingress" %
                  (self.name, ingress_handle))
     out, _ = exec_cmd("tc qdisc show dev %s" % self.name)
     ingress_qdiscs = re.findall("qdisc ingress (\\w+):", out)
     if len(ingress_qdiscs) != 0:
         exec_cmd("tc qdisc del dev %s ingress" % self.name)
예제 #53
0
    def port_add(self, device=None, port_options={}, interface_options={}):
        if device is None:
            dev_name = interface_options.get(
                'name',
                self._if_manager.assign_name(interface_options['type']))
        else:
            dev_name = device.name

        exec_cmd("ovs-vsctl add-port {} {}{}{}".format(
            self.name, dev_name, self._dict_to_keyvalues(port_options),
            self._interface_cmd(dev_name, interface_options)))

        iface = None
        if 'type' in interface_options and interface_options[
                'type'] == 'internal':
            iface = self._if_manager.get_device_by_name(dev_name)
            iface._enable()

        return iface
예제 #54
0
    def add_cache_entry(self, entry_hash, filepath, entry_name, entry_type):
        if entry_hash in self._entries:
            raise ResourceCacheError("File already in cache")

        entry_dir = "%s/%s" % (self._root, entry_hash)
        if os.path.exists(entry_dir):
            try:
                shutil.rmtree(entry_dir)
            except OSError as e:
                if e.errno != 2:
                    raise
        os.makedirs(entry_dir)

        shutil.move(filepath, entry_dir)
        entry_path = "%s/%s" % (entry_dir, os.path.basename(filepath))

        if entry_type == "module":
            filename = "%s.py" % entry_name
            shutil.move(entry_path, "%s/%s" % (entry_dir, filename))
        elif entry_type == "tools":
            filename = entry_name
            tools_dir = "%s/%s" % (entry_dir, filename)

            exec_cmd("tar xjmf \"%s\" -C \"%s\"" % (entry_path, entry_dir))

            if os.path.exists("%s/%s" % (tools_dir, SETUP_SCRIPT_NAME)):
                exec_cmd("cd \"%s\" && ./%s" % (tools_dir, SETUP_SCRIPT_NAME))
            else:
                msg = "%s not found in %s tools, skipping initialization." % \
                           (SETUP_SCRIPT_NAME, entry_name)
                logging.warn(msg)

        entry = {
            "type": entry_type,
            "name": entry_name,
            "last_used": int(time.time()),
            "path": "%s/%s" % (entry_hash, filename)
        }
        self._entries[entry_hash] = entry

        self._save_index()

        return entry_hash
예제 #55
0
    def _get_port_info(self):
        numbered_ports = {}
        port_lines = []

        dumped_ports = exec_cmd("ovs-ofctl dump-ports-desc %s" % self.name,
                                log_outputs=False)[0]

        for match in re.finditer(r'(\w+)\((\w*)\)', dumped_ports):
            numbered_ports[match.groups()[1]] = match.groups()[0]

        ovs_show = exec_cmd("ovs-vsctl show", log_outputs=False)[0]
        regex = r'(Port[\w\W]*?)(?=Port|ovs_version)'

        for match in re.finditer(regex, ovs_show):
            line = match.groups()[0].replace('\n', ' ')
            line = self._port_format(line)
            port_lines.append(line)

        return numbered_ports, port_lines
예제 #56
0
파일: Device.py 프로젝트: omaciel/lnst
    def _read_adaptive_coalescing(self):
        res, _ = exec_cmd("ethtool -c %s" % self.name, die_on_err=False)

        regex = "Adaptive RX: (on|off)  TX: (on|off)"
        try:
            res = re.search(regex, res).groups()
        except AttributeError:
            raise DeviceFeatureNotSupported(
                "No values for coalescence of %s." % self.name)
        return list(res)
예제 #57
0
 def is_up(self, max_time):
     start_time = time()
     while(time() - start_time < max_time):
         out, _ = exec_cmd("ip l show dev %s up | grep 'state UP'" % self._name, die_on_err = False)
         if out == "":
             logging.info("sleep 20!")
             sleep(20)
         else:
             logging.info("port up!")
             return True
     raise IfMgrError("Time out - device %s not up." % self._name)
예제 #58
0
    def create(self):
        conf = self._dev_config
        local = ''
        remote = ''
        key = None
        for opt, val in conf['options']:
            if opt == 'local':
                local = 'local ' + val
            elif opt == 'remote':
                remote = 'remote ' + val
            elif opt == 'key':
                key = val
            else:
                pass

        if key == None:
            raise Exception("Option 'key' not set for a vti device")

        exec_cmd("ip link add %s type vti %s %s key %s" %
                 (conf["name"], local, remote, key))
예제 #59
0
    def restore_system_config(self):
        logging.info("Restoring system configuration")
        for option, values in self._system_config.iteritems():
            try:
                cmd_str = "echo \"%s\" >%s" % (values["initial_val"], option)
                (stdout, stderr) = exec_cmd(cmd_str)
            except ExecCmdFail:
                logging.warn("Unable to restore '%s' config option!", option)
                return False

        self._system_config = {}
        return True
예제 #60
0
    def _setup_options(self):
        if not "options" in self._dev_config:
            return
        options = self._dev_config["options"]

        #Make sure that the device is down before configuring options
        #this is a temporary workaround for NM setting the device IFF_UP on
        #creation, which means that there is still a race condition here.
        #Related to RH bgz #1114685
        exec_cmd('ip link set %s down' % self._dev_config["name"])

        for option, value in options:
            if option == "primary":
                '''
                "primary" option is not direct value but it's
                index of netdevice. So take the appropriate name from config
                '''
                slave_dev = self._if_manager.get_mapped_device(value)
                value = slave_dev.get_name()
            exec_cmd('echo "%s" > %s/%s' %
                     (value, self._get_bond_dir(), option))