def __init__(self,
connection,
prompt,
expected_prompt,
newline_chars=None,
runner=None,
set_timeout=None,
set_prompt=None,
target_newline="\n",
allowed_newline_after_prompt=False,
prompt_after_login=None):
"""
Moler base class for commands that change prompt.
:param connection: moler connection to device, terminal when command is executed.
:param prompt: prompt on start system (where command starts).
:param expected_prompt: prompt on server (where command connects).
:param newline_chars: characters to split lines.
:param runner: Runner to run command.
:param set_timeout: Command to set timeout after telnet connects.
:param set_prompt: Command to set prompt after telnet connects.
:param target_newline: newline chars on remote system where ssh connects.
:param allowed_newline_after_prompt: If True then newline chars may occur after expected (target) prompt.
:param prompt_after_login: prompt after login before send export PS1. If you do not change prompt exporting PS1
then leave it None.
"""
super(CommandChangingPrompt,
self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
# Parameters defined by calling the command
self._re_expected_prompt = CommandTextualGeneric._calculate_prompt(
expected_prompt) # Expected prompt on device
self._re_prompt_after_login = self._re_expected_prompt
if prompt_after_login:
self._re_prompt_after_login = CommandTextualGeneric._calculate_prompt(
prompt_after_login)
self.set_timeout = set_timeout
self.set_prompt = set_prompt
self.target_newline = target_newline
self.allowed_newline_after_prompt = allowed_newline_after_prompt
self.enter_on_prompt_without_anchors = True # Set True to try to match prompt in line without ^ and $.
# Internal variables
self._re_failure_exceptions_indication = None
self._sent_timeout = False
self._sent_prompt = False
self._sent = False
self._finish_on_final_prompt = True # Set True to finish Moler command by this generic after prompt after
# command output. False if you want to finish command in your class.
self._re_expected_prompt_without_anchors = regexp_without_anchors(
self._re_expected_prompt)
self._re_prompt_after_login_without_anchors = regexp_without_anchors(
self._re_prompt_after_login)
def __init__(self, connection, prompt=None, newline_chars=None, runner=None):
"""
Base class for textual commands.
:param connection: connection to device.
:param prompt: expected prompt sending by device after command execution. Maybe String or compiled re.
:param newline_chars: new line chars on device (a list).
:param runner: runner to run command.
"""
self.command_path = None # path to command executable - allow non standard locations like /usr/local/bin/
self._max_index_from_beginning = 20 # Right (from 0 to this) index of substring of command_string passed
# as _cmd_escaped. Set 0 to disable functionality of substring.
self._max_index_from_end = 20 # Left (from this to the end) index of substring of command_string passed
# as _cmd_escaped. Set 0 to disable functionality of substring.
self._multiline_cmd = False
self.__command_string = None # String representing command on device
self._cmd_escaped = None # Escaped regular expression string with command
super(CommandTextualGeneric, self).__init__(connection=connection, runner=runner)
self.terminating_timeout = 3.0 # value for terminating command if it timeouts. Set positive value for command
# if they can do anything if timeout. Set 0 for command if it cannot do
# anything if timeout.
self.current_ret = dict() # Placeholder for result as-it-grows, before final write into self._result
self._cmd_output_started = False # If false parsing is not passed to command
self._regex_helper = RegexHelper() # Object to regular expression matching
self.ret_required = True # # Set False for commands not returning parsed result
self.break_on_timeout = True # If True then Ctrl+c on timeout
self._last_not_full_line = None # Part of line
self._re_prompt = CommandTextualGeneric._calculate_prompt(prompt) # Expected prompt on device
self._newline_chars = newline_chars # New line characters on device
self.do_not_process_after_done = True # Set True if you want to break processing data when command is done. If
# False then on_new_line will be called after done if more lines are in the same data package.
self.newline_after_command_string = True # Set True if you want to send a new line char(s) after command
# string (sendline from connection)- most cases. Set False if you want to sent command string without adding
# new line char(s) - send from connection.
self.wait_for_prompt_on_exception = True # Set True to wait for command prompt on failure. Set False to cancel
# command immediately on failure.
self._concatenate_before_command_starts = True # Set True to concatenate all strings from connection before
# command starts, False to split lines on every new line char
self._stored_exception = None # Exception stored before it is passed to base class when command is done.
self._lock_is_done = Lock()
self._ignore_unicode_errors = True # If True then UnicodeDecodeError will be logged not raised in data_received
self._last_recv_time_data_read_from_connection = None # Time moment when data was really received from
# connection (not when was passed to command). Time is given as datetime.datetime instance
self._remove_ctrlc_chars_for_prompt = True # after sending Ctrl-C response might be concatenated ^Cprompt
# This flag removes "^C" from prompt before processing prompt against self._re_prompt
self._break_exec_regex = None # Regex if not None then command will call break_cmd when this regex is caught
# in on_new_line. Do not set directly, use setter break_exec_regex.
self.break_exec_only_full_line = True # Set True to consider only full lines to match _break_exec_regex or
# False to consider also chunks.
self.enter_on_prompt_without_anchors = False # Set True to try to match prompt in line without ^ and $.
if not self._newline_chars:
self._newline_chars = CommandTextualGeneric._default_newline_chars
self._re_prompt_without_anchors = regexp_without_anchors(self._re_prompt)
def test_regexp_with_right_anchor():
from moler.helpers import regexp_without_anchors
expected = "abc"
regex = re.compile(r"abc$")
assert expected == regexp_without_anchors(regex).pattern
def test_regexp_without_anchors():
from moler.helpers import regexp_without_anchors
expected = "abc"
assert expected == regexp_without_anchors(re.compile(expected)).pattern