def __init__(self):
self.__base_filter_name = Config().get_setting("buffers",
"base_filter_name")
self.__error_filter_name = Config().get_setting(
"buffers", "error_filter_name")
self.__error_buffer_name = Config().get_setting(
"buffers", "error_buffer_name")
def run(self, command_item, buffer_name=''):
set_variable = command_item.get("set_variable", '')
if set_variable:
interpolated_set_variable = Interpolate.interpolate_variables(
set_variable)
buffer_name = Config().get_editor_wrapper(
).get_current_buffer_name()
Config().set_variable(interpolated_set_variable, buffer_name)
def __process_template_file(self, buffer_name, templates_path, template_filename):
template_loader = jinja2.FileSystemLoader(searchpath=templates_path)
template_env = jinja2.Environment(loader=template_loader)
template = template_env.get_template(template_filename)
config_variables = Config().get_variables()
output_text = template.render(config_variables)
if output_text:
output_text_array = output_text.split('\n')
Config().set_internal_buffer_cache(buffer_name, output_text_array)
def test__can_run_command_and_set_test_buffer():
try:
test_tide = Tide()
command_handler = CommandHandler()
command_handler.spawn_process()
buffer_result = Config().get_internal_buffer_caches()
test_tide.run_config_command('test_command')
assert "test_buffer" in buffer_result.keys()
except Exception as ex:
pytest.fail("error initialising CommandHandler: " + str(ex))
def test__can_run_command_and_set_session_log_buffer():
try:
from tide.config.config import Config
command_handler = CommandHandler()
command_handler.spawn_process()
result = command_handler.run_command("echo hi")
buffer_result = Config().get_internal_buffer_caches()
assert buffer_result.get("vg_session_log") is not None
except Exception as ex:
pytest.fail("error initialising CommandHandler: " + str(ex))
def __init__(self):
self.default_args = Config().get_setting(
"process", "main_process_default_arguments")
self.end_of_output_regex = Config().get_setting(
"process", "end_of_output_regex")
self.find_full_proc_name = Config().get_setting(
"process", "find_full_process_name")
self.main_proc_name = Config().get_setting("process",
"main_process_name")
self.ttl_stream_timeout = Config().get_setting("process",
"ttl_stream_timeout")
def check_set_remote(command_args):
if 'target remote' in command_args["process_command"].lower():
binary_loaded = False
symbols_found = True
for line in command_args["lines"]:
if 'Reading symbols from' in line or '(no debugging symbols found)' in line:
binary_loaded = True
if '(no debugging symbols found)' in line:
symbols_found = False
Config().set_variable('remote_target', 1)
Config().set_variable('binary_loaded', int(binary_loaded))
Config().set_variable('symbols_loaded',
int(symbols_found and binary_loaded))
def run(self, command_item, buffer_name=''):
msg = command_item.get("msg", '')
interpolated_message = Interpolate.interpolate_variables(msg)
buffer_name = command_item.get("buffer_name", 0)
all_config = command_item.get("all_config", 0)
print("print_debug:")
if all_config:
print(" all_config:\n ")
json.dump(Config().get(), sys.stdout, indent=4)
if buffer_name:
print(" buffer name:\n ")
json.dump(Config().get_buffer(buffer_name), sys.stdout, indent=4)
print("" + str(interpolated_message))
def test_does_not_raise_exception_on_initialisation():
try:
config_command_action_list = Config().get(
)["commands"]["test_command"]["steps"][0]
command_action = CommandAction(config_command_action_list, '')
except Exception as ex:
pytest.fail("error initialising CommandAction: " + str(ex))
def __create_config_command_item(self, command, buffer_name, event_name):
config_command_item = ConfigCommandItem()
config_command_item.command = command
config_command_item.buffer_name = buffer_name if buffer_name else Config(
).get_buffer_name_for_command(command)
config_command_item.event_name = event_name
return config_command_item
def run(self, command_item, buffer_name=''):
variable_name = command_item['variable_name']
variable_value = Config().get_variable(variable_name)
PTS.info("RUN_COMMAND_STRING", variable_name, buffer_name,
command_item)
if variable_value:
return CommandHandler().run_command(variable_value, buffer_name)
return None
def test_has_command_action_of_type_run_command():
try:
config_command_action_list = Config().get(
)["commands"]["test_command"]["steps"][0]
command_action = CommandAction(config_command_action_list, '')
assert 'run_command' == command_action.action_name
except Exception as ex:
pytest.fail("error initialising CommandAction: " + str(ex))
def __find_event_input_args(self):
if self.__command and self.__buffer_name and self.__event_name:
event_command_list = Config().get_buffer_events_by_name(
self.__buffer_name, self.__event_name)
for event_command in event_command_list:
if event_command["command"] == self.__command:
return event_command.get("input_args", [])
return None
def __filter_log_string_and_add_to_buffer_cache(log_string):
log_lines = Filter.filter_string(log_string, SESSION_BUFFER_NAME)
full_cache = Config().get_internal_buffer_cache(SESSION_BUFFER_NAME)
if ADD_TIMESTAMP:
full_cache.append(__get_timestamp_separator())
full_cache.extend(log_lines)
Config().set_internal_buffer_cache(SESSION_BUFFER_NAME, full_cache)
def __process_when_condition(self):
when_condition = self.__when_condition
for variable in Config().get_variable_names():
if variable in self.__when_condition:
config_variable = self.__sanitise_config_variable(variable)
when_condition = when_condition.replace(
variable, config_variable)
self.__eval_when_condition = eval(when_condition
or self.__when_condition)
def __iterate_lines_for_bool_match(self, lines, matcher):
match_regex = matcher['regex']
match_variable = matcher["variable_name"]
for line in lines:
match = re.search(match_regex, line)
if match:
PTS.line("MATCH_BOOL", match_variable, match_regex, True, line)
Config().get_variables()[matcher["variable_name"]] = 1
return
PTS.line("MATCH_BOOL", match_variable, match_regex, False, line)
def test__run_command_with_match_on_hex():
try:
tide_handler = Tide('test_mock')
tide_handler.start()
tide_handler.run_config_command("test_command")
result = Config().get_variable("test_match_variable")
tide_handler.stop()
assert result == '0x00001234abcd'
except Exception as ex:
pytest.fail("error in filter tests: " + str(ex))
def test__run_command_with_match_on_array():
try:
tide_handler = Tide()
tide_handler.start()
tide_handler.run_config_command("test_command")
result = Config().get_variable("test_match_array")
tide_handler.stop()
assert '0x00001234abce' in result
assert '0x000000009876' in result
except Exception as ex:
pytest.fail("error in filter tests: " + str(ex))
def stop(self):
try:
Config().get_editor_wrapper().stop_tide()
self.__command_handler.close_command_handler()
del self.__command_handler
self.__command_handler = None
SPC.remove_all()
except Exception as ex:
print(
f"error in TideAction.stop(): {str(ex)}\n Traceback: {traceback.format_exc()}"
)
def __iterate_lines_for_array_match(self, lines, matcher):
matches_list = []
match_regex = matcher['regex']
match_variable = matcher["variable_name"]
for line in lines:
match = re.search(matcher['regex'], line)
if match:
PTS.line("MATCH_ARRAY", match_variable, match_regex, match.group(1), line)
matches_list.append(match.group(1))
else:
PTS.line("MATCH_ARRAY", match_variable, match_regex, None, line)
Config().get_variables()[matcher["variable_name"]] = matches_list
def run(self, command_item, buffer_name=''):
PTS.info("RUN_COMMAND_WITH_MATCH_GROUP", command_item["command"],
buffer_name, command_item)
self.__set_locals(command_item, buffer_name)
self._lines = CommandHandler().run_command(
self._command_item["command"])
temp_dict = {}
for key, value in self._match_dictionary.items():
temp_dict[key] = self.__get_match(value)
self._match_dictionary.update(temp_dict)
for key, value in self._match_dictionary.items():
Config().set_variable(key, value["result"])
def start(self, startup_commands):
try:
self.__command_handler = CommandHandler()
self.__command_handler.spawn_process(startup_commands)
self.__startup_commands.run()
self.__buffer_commands.run()
Config().get_editor_wrapper().send_message_to_editor(
{"startup_complete": True})
except Exception as ex:
print(
f"error in TideAction.start(): {str(ex)}\n Traceback: {traceback.format_exc()}"
)
def test__can_run_command_and_set_test_buffer_has_value_of_line():
try:
test_tide = Tide()
command_handler = CommandHandler()
command_handler.spawn_process()
buffer_result = Config().get_internal_buffer_caches()
test_tide.run_config_command('test_command')
assert buffer_result["test_buffer"][0] == 'echo "hello"\r'
assert buffer_result["test_buffer"][1] == 'hello\r'
assert buffer_result["test_buffer"][
2] == '/work/tide/tests/pytest_tests # \x1b[6n'
except Exception as ex:
pytest.fail("error initialising CommandHandler: " + str(ex))
def to_command_action_list(self):
command_action_list = Config().get_command_steps(self.__command)
updated_command_action_list = []
for command_action_config in command_action_list:
updated_command_action_config = command_action_config.copy()
event_input_args = self.__find_event_input_args()
if event_input_args:
updated_command_action_config[
"event_input_args"] = event_input_args
command_action_object = CommandAction(
updated_command_action_config, self.__buffer_name)
updated_command_action_list.append(command_action_object)
return updated_command_action_list
def info(command_type, command, buffer_name, value):
if Config().get_setting("debugging", "print_to_stdout"):
heading_text = "[INFO]"
command_type_text = "[" + str(command_type) + "]"
command_text = "[" + str(command) + "]"
buffer_text = "[" + str(buffer_name) + "]"
value_text = str(value)
command_type_text = command_type_text.ljust(
30) if ljust else command_type_text
command_text = command_text.ljust(28) if ljust else command_text
buffer_text = buffer_text.ljust(20) if ljust else buffer_text
value_text = (value_text[:110] +
'..') if len(value_text) > 110 else value_text
print(heading_text, command_type_text, command_text, buffer_text,
value_text)
def line(filter_type, process_or_match, process_or_match_on, result,
raw_value):
if Config().get_setting("debugging",
"print_to_stdout") and Config().get_setting(
"debugging", "print_to_stdout_filters"):
heading_text = "[INFO]"
filter_type_text = "[" + str(filter_type) + "]"
process_or_match_text = "[" + str(process_or_match) + "]"
process_or_match_on_text = (
process_or_match_on[:25] +
'..') if len(process_or_match_on) > 25 else process_or_match_on
process_or_match_on_text = "[" + str(process_or_match_on) + "]"
result_text = "[" + str(result) + "]"
raw_value_string = str(raw_value)
raw_value_text = (
raw_value_string[:75] +
'..') if len(raw_value_string) > 75 else raw_value_string
if ljust:
filter_type_text = filter_type_text.ljust(30)
process_or_match_text = process_or_match_text.ljust(30)
process_or_match_on_text = process_or_match_on_text.ljust(28)
result_text = result_text.ljust(10)
print(heading_text, filter_type_text, process_or_match_text,
process_or_match_on_text, result_text, raw_value_text)
def __initialise_buffer_in_config(self, buffer_name):
if buffer_name not in Config().get_internal_buffer_caches():
if not Config().get_internal_buffer_caches():
Config().set_internal("buffer_caches", {})
Config().set_internal_buffer_cache(buffer_name, [])
def set(self, lines, config_command_item, command_action, action_args):
if lines:
internal_buffer_name = config_command_item.buffer_name or self.__get_internal_buffer_name(action_args)
lines = self.__set_lines_where_no_buffer_name(internal_buffer_name, lines, command_action)
Config().set_internal_buffer_cache(internal_buffer_name, lines)
def __sanitise_config_variable(self, variable):
config_variable = str(Config().get_variable(variable))
if " " in config_variable or not config_variable:
config_variable = "'" + str(config_variable) + "'"
return config_variable
def __try_set_variable(self):
if self._match_result:
if self._try_set_var:
Config().get()["variables"][self._try_set_var] = self._match_result
if self._try_set_array_var:
Config().get()["variables"][self._try_set_array_var] = self._match_result
