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)
