def set_tc_from_file(logger, config_file_path, is_overwrite): return_code = 0 loader = TcConfigLoader(logger) loader.is_overwrite = is_overwrite try: loader.load_tcconfig(config_file_path) except OSError as e: logger.error(msgfy.to_error_message(e)) return errno.EIO for tcconfig_command in loader.get_tcconfig_commands(): return_code |= spr.SubprocessRunner(tcconfig_command).run() return return_code
def set_tc_from_file(logger, config_file_path, is_overwrite): return_code = 0 loader = TcConfigLoader(logger) loader.is_overwrite = is_overwrite try: loader.load_tcconfig(config_file_path) except IOError as e: logger.error(e) return errno.EIO for tcconfig_command in loader.get_tcconfig_command_list(): return_code |= subprocrunner.SubprocessRunner(tcconfig_command).run() return return_code
def __delete_ifb_device(self): verify_network_interface(self.ifb_device) command_list = [ "tc qdisc del dev {:s} root".format(self.ifb_device), "ip link set dev {:s} down".format(self.ifb_device), "ip link delete {:s} type ifb".format(self.ifb_device), ] if all([ spr.SubprocessRunner(command).run() != 0 for command in command_list ]): return 2 return 0
def ping(self): """ Sending ICMP packets. :return: ``ping`` command execution result. :rtype: :py:class:`.PingResult` :raises ValueError: If parameters not valid. """ self.__validate_ping_param() ping_proc = subprocrunner.SubprocessRunner(self.__get_ping_command()) ping_proc.run() return PingResult(ping_proc.stdout, ping_proc.stderr, ping_proc.returncode)
def _add_filter(self): if self._tc_obj.is_change_shaping_rule: return 0 command_item_list = [ self._tc_obj.get_tc_command(TcSubCommand.FILTER), self._dev, "protocol {:s}".format(self._tc_obj.protocol), "parent {:s}:".format(self._tc_obj.qdisc_major_id_str), "prio 2", ] if self._is_use_iptables(): command_item_list.append("handle {:d} fw".format( self._get_unique_mangle_mark_id())) else: if typepy.is_null_string(self._tc_obj.dst_network): dst_network = get_anywhere_network(self._tc_obj.ip_version) else: dst_network = self._tc_obj.dst_network command_item_list.extend([ "u32", "match {:s} {:s} {:s}".format(self._tc_obj.protocol_match, "dst", dst_network), ]) if typepy.is_not_null_string(self._tc_obj.src_network): command_item_list.append("match {:s} {:s} {:s}".format( self._tc_obj.protocol_match, "src", self._tc_obj.src_network)) if self._tc_obj.src_port: command_item_list.append("match {:s} sport {:d} 0xffff".format( self._tc_obj.protocol_match, self._tc_obj.src_port)) if self._tc_obj.dst_port: command_item_list.append("match {:s} dport {:d} 0xffff".format( self._tc_obj.protocol_match, self._tc_obj.dst_port)) command_item_list.append("flowid {:s}:{:d}".format( self._tc_obj.qdisc_major_id_str, self._get_qdisc_minor_id())) return subprocrunner.SubprocessRunner( " ".join(command_item_list)).run()
def __delete_qdisc(self): logging_msg = "delete {} qdisc".format(self.device) with logging_context(logging_msg): runner = spr.SubprocessRunner("{:s} del dev {:s} root".format( get_tc_base_command(TcSubCommand.QDISC), self.device)) runner.run() if re.search("RTNETLINK answers: No such file or directory", runner.stderr): logger.notice("no qdisc to delete for the outgoing device.") return False elif re.search("Cannot find device", runner.stderr): raise NetworkInterfaceNotFoundError(target=self.device) else: is_success = runner.returncode == 0 if is_success: logger.info(logging_msg) return is_success
def run_command_helper(command, error_regexp, notice_message, exception_class=None): proc = spr.SubprocessRunner(command, error_log_level=logbook.NOTSET) proc.run() if proc.returncode == 0: return 0 match = error_regexp.search(proc.stderr) if match is None: logger.error(proc.stderr) return proc.returncode if typepy.is_not_null_string(notice_message): logger.notice(notice_message) if exception_class is not None: raise exception_class(command) return proc.returncode
def delete_all_tc(self): result_list = [] with logging_context("delete qdisc"): proc = spr.SubprocessRunner("{:s} del dev {:s} root".format( get_tc_base_command(TcSubCommand.QDISC), self.device)) proc.run() if re.search("RTNETLINK answers: No such file or directory", proc.stderr): logger.notice("no qdisc to delete for the outgoing device.") result_list.append(False) elif re.search("Cannot find device", proc.stderr): raise NetworkInterfaceNotFoundError(device=self.device) else: result_list.append(proc.returncode == 0) with logging_context("delete ingress qdisc"): returncode = run_command_helper( "{:s} del dev {:s} ingress".format( get_tc_base_command(TcSubCommand.QDISC), self.device), ignore_error_msg_regexp=re.compile("|".join([ "RTNETLINK answers: Invalid argument", "RTNETLINK answers: No such file or directory", ])), notice_msg="no qdisc to delete for the incoming device.", ) result_list.append(returncode == 0) with logging_context("delete ifb device"): try: result_list.append(self.__delete_ifb_device() == 0) except NetworkInterfaceNotFoundError as e: logger.debug(msgfy.to_debug_message(e)) result_list.append(False) with logging_context("delete iptables mangle table entries"): try: self.iptables_ctrl.clear() except OSError as e: logger.warn("{} (can not delete iptables entries)".format(e)) return any(result_list)
def run_command_helper( command, ignore_error_msg_regexp, notice_msg, msg_log_level="WARNING", exception_class=None ): runner = spr.SubprocessRunner(command, error_log_level="QUIET") runner.run() returncode = runner.returncode if returncode == 0: return 0 if ignore_error_msg_regexp: if ignore_error_msg_regexp.search(runner.stderr) is None: error_msg = "\n".join( [ "command execution failed", " command={}".format(command), " stderr={}".format(runner.stderr), ] ) if re.search("RTNETLINK answers: Operation not permitted", runner.stderr): logger.error(error_msg) sys.exit(returncode) logger.error(error_msg) return returncode else: # ignorable error occurred returncode = 0 if typepy.is_not_null_string(notice_msg): logger.log(msg_log_level, notice_msg) if exception_class is not None: raise exception_class(command) return returncode
def add_filter(self): command_item_list = [ "tc filter add", self.dev, "protocol {:s}".format(self._tc_obj.protocol), "parent {:s}:".format(self._tc_obj.qdisc_major_id_str), "prio 1", ] if self._is_use_iptables(): command_item_list.append("handle {:d} fw".format( self._get_unique_mangle_mark_id())) else: if typepy.is_null_string(self._tc_obj.network): network = get_anywhere_network(self._tc_obj.ip_version) else: network = self._tc_obj.network command_item_list.extend([ "u32", "match {:s} {:s} {:s}".format( self._tc_obj.protocol_match, self._get_network_direction_str(), network), ]) if self._tc_obj.src_port: command_item_list.append("match {:s} sport {:d} 0xffff".format( self._tc_obj.protocol_match, self._tc_obj.src_port)) if self._tc_obj.dst_port: command_item_list.append("match {:s} dport {:d} 0xffff".format( self._tc_obj.protocol_match, self._tc_obj.dst_port)) command_item_list.append("flowid {:s}:{:d}".format( self._tc_obj.qdisc_major_id_str, self.get_qdisc_minor_id())) return subprocrunner.SubprocessRunner( " ".join(command_item_list)).run()
def delete_all_tc(self): result_list = [] with logging_context("delete qdisc"): proc = spr.SubprocessRunner("tc qdisc del dev {:s} root".format( self.device)) proc.run() if re.search("RTNETLINK answers: No such file or directory", proc.stderr): logger.notice("no qdisc to delete for the outgoing device.") result_list.append(False) elif re.search("Cannot find device", proc.stderr): raise NetworkInterfaceNotFoundError(device=self.device) else: result_list.append(proc.returncode == 0) with logging_context("delete ingress qdisc"): returncode = run_command_helper( "tc qdisc del dev {:s} ingress".format(self.device), re.compile("|".join([ "RTNETLINK answers: Invalid argument", "RTNETLINK answers: No such file or directory", ])), "no qdisc to delete for the incoming device.") result_list.append(returncode == 0) with logging_context("delete ifb device"): try: result_list.append(self.__delete_ifb_device() == 0) except NetworkInterfaceNotFoundError as e: logger.debug("{:s}: {}".format(e.__class__.__name__, e)) result_list.append(False) with logging_context("delete iptables mangle table entries"): self.iptables_ctrl.clear() # IptablesMangleController.clear() return any(result_list)
def set_tc_from_file(logger, config_file_path: str, is_overwrite: bool, tc_command_output: Optional[str]) -> int: return_code = 0 loader = TcConfigLoader(logger) loader.is_overwrite = is_overwrite loader.tc_command_output = tc_command_output try: loader.load_tcconfig(config_file_path) except OSError as e: logger.error(msgfy.to_error_message(e)) return errno.EIO for tcconfig_command in loader.get_tcconfig_commands(): runner = spr.SubprocessRunner(tcconfig_command) return_code |= runner.run() if return_code != 0: logger.error(runner.stderr) elif tc_command_output == TcCommandOutput.STDOUT: print(runner.stdout.strip()) return return_code
def main(): options = parse_option() set_log_level(options.log_level) build_dir = options.build_dir try: compiler = CompilerFactory.create(build_dir) except ValueError as e: logger.error("{:s}: {}".format(e.__class__.__name__, e)) return errno.EINVAL if options.action in [BuildAction.CLEAN, BuildAction.REBUILD]: result = compiler.clean() if options.action == BuildAction.CLEAN: return result if options.action in [BuildAction.RECMAKE]: cmake_cache_path = "/".join( [compiler.build_dir_path, "CMakeCache.txt"]) logger.debug("delete {:s}".format(cmake_cache_path)) os.remove(cmake_cache_path) if not os.path.isdir(build_dir): logger.debug("make directory: {:s}".format(build_dir)) os.makedirs(build_dir) if options.action in [ BuildAction.CMAKE, BuildAction.RECMAKE, BuildAction.BUILD, BuildAction.REBUILD, ]: command_builder = CMakeCommandBuilder(options) runner = subprocrunner.SubprocessRunner( command_builder.get_cmake_commmand()) with Cd(build_dir): runner.run() if runner.returncode == 0: logging_func_stdout = logger.info logging_func_stderr = logger.warn else: logging_func_stdout = logger.info logging_func_stderr = logger.error if typepy.is_not_null_string(runner.stdout): logging_func_stdout(runner.stdout) if typepy.is_not_null_string(runner.stderr): logging_func_stderr(runner.stderr) if runner.returncode != 0: return 1 if options.action in [BuildAction.BUILD, BuildAction.REBUILD]: with Cd(build_dir): compiler.build() return 0
def run_tc_show(subcommand, device): runner = spr.SubprocessRunner("tc {:s} show dev {:s}".format( subcommand, device)) runner.run() return runner.stdout
def verify_netem_module(): runner = subprocrunner.SubprocessRunner("lsmod | grep sch_netem") if runner.run() != 0: raise ModuleNotFoundError("sch_netem module not found")
def __get_ifb_from_device(self): filter_runner = subprocrunner.SubprocessRunner( "tc filter show dev {:s} root".format(self.device), dry_run=False) filter_runner.run() return self.__filter_parser.parse_incoming_device(filter_runner.stdout)