def _post_send_command(raw_response: bytes, processed_response: bytes,
response: Response) -> Response:
"""
Handle post "send_command" tasks for consistency between sync/async versions
Args:
raw_response: raw response returned from the channel
processed_response: processed response returned from the channel
response: response object to update with channel results
Returns:
Response: Scrapli Response object
Raises:
N/A
"""
response._record_response(result=processed_response) # pylint: disable=W0212
response.raw_result = raw_response
return response
def send_command(
self,
command: str,
strip_prompt: bool = True,
failed_when_contains: Optional[Union[str, List[str]]] = None,
) -> Response:
"""
Send a command
Args:
command: string to send to device in privilege exec mode
strip_prompt: True/False strip prompt from returned output
failed_when_contains: string or list of strings indicating failure if found in response
Returns:
Response: Scrapli Response object
Raises:
TypeError: if command is anything but a string
"""
if not isinstance(command, str):
raise TypeError(
f"`send_command` expects a single string, got {type(command)}. "
"to send a list of commands use the `send_commands` method instead."
)
response = Response(
host=self.transport.host,
channel_input=command,
failed_when_contains=failed_when_contains,
)
raw_response, processed_response = self.channel.send_input(
channel_input=command, strip_prompt=strip_prompt
)
response._record_response(result=processed_response) # pylint: disable=W0212
response.raw_result = raw_response
return response
def send_inputs_interact(self,
channel_inputs: List[str],
hidden_response: bool = False) -> Response:
"""
Send inputs in an interactive fashion, used to handle prompts that occur after an input.
Args:
channel_inputs: list of four string elements representing...
channel_input - initial input to send
expected_prompt - prompt to expect after initial input
response - response to prompt
final_prompt - final prompt to expect
hidden_response: True/False response is hidden (i.e. password input)
Returns:
Response: scrapli Response object
Raises:
TypeError: if inputs is not tuple or list
"""
if not isinstance(channel_inputs, list):
raise TypeError(
f"`send_inputs_interact` expects a List, got {type(channel_inputs)}"
)
channel_input, expectation, channel_response, finale = channel_inputs
response = Response(
self.transport.host,
channel_input,
expectation=expectation,
channel_response=channel_response,
finale=finale,
)
raw_result, processed_result = self._send_input_interact(
channel_input, expectation, channel_response, finale,
hidden_response)
response.raw_result = raw_result.decode()
response.record_response(processed_result.decode().strip())
return response
def send_interactive(
self,
interact_events: List[Tuple[str, str, Optional[bool]]],
failed_when_contains: Optional[Union[str, List[str]]] = None,
privilege_level: str = "",
) -> Response:
"""
Interact with a device with changing prompts per input.
Used to interact with devices where prompts change per input, and where inputs may be hidden
such as in the case of a password input. This can be used to respond to challenges from
devices such as the confirmation for the command "clear logging" on IOSXE devices for
example. You may have as many elements in the "interact_events" list as needed, and each
element of that list should be a tuple of two or three elements. The first element is always
the input to send as a string, the second should be the expected response as a string, and
the optional third a bool for whether or not the input is "hidden" (i.e. password input)
An example where we need this sort of capability:
```
3560CX#copy flash: scp:
Source filename []? test1.txt
Address or name of remote host []? 172.31.254.100
Destination username [carl]?
Writing test1.txt
Password:
Password:
Sink: C0644 639 test1.txt
!
639 bytes copied in 12.066 secs (53 bytes/sec)
3560CX#
```
To accomplish this we can use the following:
```
interact = conn.channel.send_inputs_interact(
[
("copy flash: scp:", "Source filename []?", False),
("test1.txt", "Address or name of remote host []?", False),
("172.31.254.100", "Destination username [carl]?", False),
("carl", "Password:"******"super_secure_password", prompt, True),
]
)
```
If we needed to deal with more prompts we could simply continue adding tuples to the list of
interact "events".
Args:
interact_events: list of tuples containing the "interactions" with the device
each list element must have an input and an expected response, and may have an
optional bool for the third and final element -- the optional bool specifies if the
input that is sent to the device is "hidden" (ex: password), if the hidden param is
not provided it is assumed the input is "normal" (not hidden)
failed_when_contains: list of strings that, if present in final output, represent a
failed command/interaction
privilege_level: ignored in this base class; for LSP reasons for subclasses
Returns:
Response: scrapli Response object
Raises:
N/A
"""
_ = privilege_level
joined_input = ", ".join([event[0] for event in interact_events])
response = Response(
self.transport.host,
channel_input=joined_input,
failed_when_contains=failed_when_contains,
)
raw_response, processed_response = self.channel.send_inputs_interact(
interact_events=interact_events
)
response._record_response(result=processed_response) # pylint: disable=W0212
response.raw_result = raw_response
return response
