def __init__(self,
connection,
prompt=None,
newline_chars=None,
options=None,
path=None,
runner=None):
"""
Unix command ls
:param connection: Moler connection to device, terminal when command is executed.
:param prompt: prompt (on system where command runs).
:param newline_chars: Characters to split lines - list.
:param options: Options of unix ls command
:param path: path to list
:param runner: Runner to run command.
"""
super(Ls, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self._converter_helper = ConverterHelper()
self.current_ret["files"] = dict()
# Parameters defined by calling the command
self.options = options
self.path = path
def __init__(self,
connection,
prompt=None,
newline_chars=None,
options=None,
runner=None):
super(Ls, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self._converter_helper = ConverterHelper()
# Parameters defined by calling the command
self.options = options
self.matched = 0
def test_converterhelper_number_wrong_format():
from moler.util.converterhelper import ConverterHelper
converter = ConverterHelper.get_converter_helper()
with pytest.raises(ValueError):
converter.to_number(value="abc", raise_exception=True)
val = converter.to_number(value="abc", raise_exception=False)
assert val == 0
def test_converterhelper_seconds():
from moler.util.converterhelper import ConverterHelper
converter = ConverterHelper.get_converter_helper()
value, value_in_units, unit = converter.to_seconds_str("3m")
assert 180 == value
assert 3 == value_in_units
assert 'm' == unit
def test_converterhelper_m():
from moler.util.converterhelper import ConverterHelper
converter = ConverterHelper.get_converter_helper()
bytes_value, value_in_units, unit = converter.to_bytes(".3m", False)
assert 300000 == bytes_value
assert 0.3 == value_in_units
assert 'm' == unit
def test_converterhelper_k():
from moler.util.converterhelper import ConverterHelper
converter = ConverterHelper.get_converter_helper()
bytes_value, value_in_units, unit = converter.to_bytes("2.5K")
assert 2560 == bytes_value
assert 2.5 == value_in_units
assert 'k' == unit
def __init__(self,
connection,
destination,
options=None,
prompt=None,
newline_chars=None,
runner=None):
"""
Traceroute command.
:param connection: moler connection to device, terminal when command is executed.
:param destination: address.
:param options: options of traceroute command for unix.
:param prompt: prompt on system where traceroute is executed.
:param newline_chars: characters to split lines.
:param runner: Runner to run command
"""
super(Traceroute, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
# Parameters defined by calling the command
self.options = options
self.destination = destination
self._converter_helper = ConverterHelper.get_converter_helper()
self.current_ret['hops'] = list()
def test_converterhelper_number():
from moler.util.converterhelper import ConverterHelper
converter = ConverterHelper.get_converter_helper()
val = converter.to_number(value="1")
assert 1 == val
val = converter.to_number(value="0.1")
assert val == 0.1
def __init__(self,
connection=None,
options='',
prompt=None,
newline_chars=None,
runner=None):
"""
Represents Unix command ps.
:param connection: moler connection to device, terminal where command is executed
:param options: ps command options as string
:param prompt: prompt (on system where command runs).
:param newline_chars: characters to split lines
:param runner: Runner to run command
"""
super(Ps, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self.current_ret = list()
self.options = options
self._headers = None
self._header_pos = None
self.ret_required = False
self._converter_helper = ConverterHelper.get_converter_helper()
def __init__(self,
connection,
destination,
options=None,
prompt=None,
newline_chars=None,
runner=None):
"""
Nping command.
:param connection: moler connection to device, terminal when command is executed.
:param destination: address (IP v4 or v6) of unit to ping.
:param options: options of ping command for unix.
:param prompt: prompt on system where ping is executed.
:param newline_chars: characters to split lines.
:param runner: Runner to run command
"""
super(Nping, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
# Parameters defined by calling the command
self.options = options
self.destination = destination
self._converter_helper = ConverterHelper.get_converter_helper()
self._current_statistics = None
def __init__(self,
connection,
target,
measurement,
outlet=None,
output_format=None,
prompt=">",
newline_chars=None,
runner=None):
"""
Class for command read meter for PDU Aten device.
:param connection: connection to device.
:param outlet: outlet id.
:param output_format: format of output. Maybe be None for simple format.
: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.
"""
super(ReadMeter, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self.outlet = outlet
self.format = output_format
self.target = target
self.measurement = measurement
self._converter_helper = ConverterHelper.get_converter_helper()
def __init__(self,
connection,
ip,
is_ping=False,
options=None,
prompt=None,
newline_chars=None,
runner=None):
"""
:param connection: Moler connection to device, terminal when command is executed.
:param ip: IP address of host.
:param is_ping: If True then skip host discovery.
:param options: Options of command nmap.
:param prompt: prompt (on system where command runs).
:param newline_chars: Characters to split lines - list.
:param runner: Runner to run command.
"""
super(Nmap, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self.options = options
self.ip = ip
self.is_ping = is_ping
self.timeout = 120 # Time in seconds
self._converter_helper = ConverterHelper.get_converter_helper()
def __init__(self,
connection,
prompt=None,
newline_chars=None,
runner=None,
is_ipv6=False,
addr_get=None,
addr_from=None):
"""
Unix command ip route.
:param connection: Moler connection to device, terminal when command is executed.
:param prompt: prompt (on system where command runs).
:param newline_chars: Characters to split lines - list.
:param runner: Runner to run command.
:param is_ipv6: Set True if IP v6 or False for IP v4.
:param addr_get: Address get, parameter of unix ip route command.
:param addr_from: From address, parameter of unix ip route command.
"""
super(IpRoute, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self._converter_helper = ConverterHelper()
# Parameters defined by calling the command
self.is_ipv6 = is_ipv6
self.addr_get = addr_get
self.addr_from = addr_from
self.current_ret["VIA"] = dict()
self.current_ret["ALL"] = []
self.current_ret["ADDRESS"] = dict()
def __init__(self,
connection,
options,
prompt=None,
newline_chars=None,
runner=None):
super(Iperf, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self.options = options
self.current_ret['CONNECTIONS'] = dict()
self.current_ret['INFO'] = list()
# private values
self._connection_dict = dict()
self._list_of_connections = dict()
self._converter_helper = ConverterHelper()
def __init__(self,
connection,
prompt=None,
newline_chars=None,
runner=None):
super(Df, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self._converter_helper = ConverterHelper()
def __init__(self,
connection,
options=None,
prompt=None,
newline_chars=None,
runner=None):
"""
Unix command du.
:param connection: moler connection to device, terminal when command is executed
:param options: Options of unix du command
:param prompt: expected prompt sending by device after command execution
:param newline_chars: Characters to split lines
:param runner: Runner to run command
"""
super(Du, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self.options = options
self._converter_helper = ConverterHelper()
def __init__(self, connection, options=None, prompt=None, newline_chars=None, runner=None):
"""
:param connection: Moler connection to device, terminal when command is executed.
:param options: uptime unix command options
:param prompt: prompt (on system where command runs).
:param newline_chars: Characters to split lines - list.
:param runner: Runner to run command.
"""
super(Uptime, self).__init__(connection=connection, prompt=prompt, newline_chars=newline_chars, runner=runner)
# Parameters defined by calling the command
self.options = options
self._converter_helper = ConverterHelper.get_converter_helper()
def __init__(self, connection, options=None, prompt=None, newline_chars=None, runner=None, n=1):
"""
Top command.
:param connection: moler connection to device, terminal when command is executed.
:param options: options of top command for unix.
:param prompt: prompt on system where ping is executed.
:param newline_chars: characters to split lines.
:param runner: Runner to run command.
:param n: Specifies number of measurements.
"""
super(Top, self).__init__(connection=connection, prompt=prompt, newline_chars=newline_chars, runner=runner)
self.options = options
self._processes_list_headers = list()
self.current_ret = dict()
self.n = n
self._converter_helper = ConverterHelper.get_converter_helper()
def __init__(self,
connection,
options,
prompt=None,
newline_chars=None,
runner=None):
super(Grep, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self._convert_helper = ConverterHelper()
# Parameters defined by calling the command
self.options = options
self.ret_required = False
self.current_ret["LINES"] = []
self.line_no = 0
def __init__(self,
connection,
prompt=None,
newline_chars=None,
runner=None,
is_ipv6=False,
addr_get=None,
addr_from=None):
super(IpRoute, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self._converter_helper = ConverterHelper()
# Parameters defined by calling the command
self.is_ipv6 = is_ipv6
self.addr_get = addr_get
self.addr_from = addr_from
self.current_ret["VIA"] = dict()
self.current_ret["ALL"] = []
self.current_ret["ADDRESS"] = dict()
def test_converterhelper_seconds_ms():
from moler.util.converterhelper import ConverterHelper
converter = ConverterHelper.get_converter_helper()
value = converter.to_seconds(0.408, "ms")
assert pytest.approx(0.000408, 0.000001) == value
class Ls(GenericUnixCommand):
_re_files_list = re.compile(r"\S{2,}")
_re_total = re.compile(r"total\s+(\d+\S*)")
_re_long = re.compile(
r"([\w-]{10})\s+(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S.*\S)\s+(\S+)\s*$")
_re_long_links = re.compile(
r"([\w-]{10})\s+(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S.*\S)\s+(\S+)\s+->\s+(\S+)\s*$"
)
def __init__(self,
connection,
prompt=None,
newline_chars=None,
options=None,
runner=None):
super(Ls, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self._converter_helper = ConverterHelper()
# Parameters defined by calling the command
self.options = options
self.matched = 0
def build_command_string(self):
cmd = "ls"
if self.options:
cmd = cmd + " " + self.options
return cmd
def on_new_line(self, line, is_full_line):
if not is_full_line:
return super(Ls, self).on_new_line(line, is_full_line)
if self._regex_helper.search_compiled(Ls._re_total, line):
if "total" not in self.current_ret:
self.current_ret["total"] = dict()
self.current_ret["total"]["raw"] = self._regex_helper.group(1)
self.current_ret["total"][
"bytes"] = self._converter_helper.to_bytes(
self._regex_helper.group(1))[0]
elif self._regex_helper.search_compiled(Ls._re_long_links, line):
self._add_new_file_long(True)
elif self._regex_helper.search_compiled(Ls._re_long, line):
self._add_new_file_long(False)
elif self._regex_helper.search_compiled(Ls._re_files_list, line):
files = line.split()
if "files" not in self.current_ret:
self.current_ret["files"] = dict()
for filename in files:
self.current_ret["files"][filename] = dict()
self.current_ret["files"][filename]["name"] = filename
return super(Ls, self).on_new_line(line, is_full_line)
def _add_new_file_long(self, islink):
filename = self._regex_helper.group(7)
if "files" not in self.current_ret:
self.current_ret["files"] = dict()
self.current_ret["files"][filename] = dict()
self.current_ret["files"][filename][
"permissions"] = self._regex_helper.group(1)
self.current_ret["files"][filename]["hard_links_count"] = int(
self._regex_helper.group(2))
self.current_ret["files"][filename][
"owner"] = self._regex_helper.group(3)
self.current_ret["files"][filename][
"group"] = self._regex_helper.group(4)
self.current_ret["files"][filename][
"size_raw"] = self._regex_helper.group(5)
self.current_ret["files"][filename]["size_bytes"] = \
self._converter_helper.to_bytes(self._regex_helper.group(5))[0]
self.current_ret["files"][filename]["date"] = self._regex_helper.group(
6)
self.current_ret["files"][filename]["name"] = self._regex_helper.group(
7)
if islink:
self.current_ret["files"][filename][
"link"] = self._regex_helper.group(8)
def _get_types(self, requested_type):
if not self.done():
raise ResultNotAvailableYet("Command not executed already")
requested_type = requested_type.lower()
ret = dict()
result = self.result()
if 'files' in result:
for file_name in result["files"]:
file_dict = result["files"][file_name]
permissions = file_dict["permissions"]
current_type = permissions[0]
if requested_type == current_type:
ret[file_name] = file_dict
return ret
def get_dirs(self):
return self._get_types('d')
def get_links(self):
return self._get_types('l')
def get_files(self):
return self._get_types('-')
class Ls(GenericUnixCommand):
"""Unix command ls"""
_re_files_list = re.compile(r"\S{2,}")
_re_total = re.compile(r"total\s+(\d+\S*)")
_re_long = re.compile(
r"([\w-]{10}[\.\+]?)\s+(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S.*\S)\s+(\S+)\s*$"
)
_re_long_links = re.compile(
r"([\w-]{10}[\.\+]?)\s+(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S.*\S)\s+(\S+)\s+->\s+(\S+)\s*$"
)
def __init__(self,
connection,
prompt=None,
newline_chars=None,
options=None,
path=None,
runner=None):
"""
Unix command ls
:param connection: Moler connection to device, terminal when command is executed.
:param prompt: prompt (on system where command runs).
:param newline_chars: Characters to split lines - list.
:param options: Options of unix ls command
:param path: path to list
:param runner: Runner to run command.
"""
super(Ls, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self._converter_helper = ConverterHelper()
self.current_ret["files"] = dict()
# Parameters defined by calling the command
self.options = options
self.path = path
def get_dirs(self):
"""
Returns only directories (folders) from command output
:return: Dict, key is item, value is parsed information about item
"""
return self._get_types('d')
def get_links(self):
"""
Returns only links from command output
:return: Dict, key is item, value is parsed information about item
"""
return self._get_types('l')
def get_files(self):
"""
Returns only files from command output
:return: Dict, key is item, value is parsed information about item
"""
return self._get_types('-')
def build_command_string(self):
"""
Builds command string from parameters passed to object.
:return: String representation of command to send over connection to device.
"""
cmd = "ls"
if self.options:
cmd = "{} {}".format(cmd, self.options)
if self.path:
cmd = "{} {}".format(cmd, self.path)
return cmd
def on_new_line(self, line, is_full_line):
"""
Processes line from output form connection/device.
:param line: Line to process, can be only part of line. New line chars are removed from line.
:param is_full_line: True if line had new line chars, False otherwise
:return: None
"""
if is_full_line:
try:
self._parse_total(line)
self._parse_long_links(line)
self._parse_long_file(line)
self._parse_files_list(line)
except ParsingDone:
pass
return super(Ls, self).on_new_line(line, is_full_line)
def _parse_files_list(self, line):
"""
Parses list of files.
:param line: Line from device.
:return: None but raises ParsingDone if matches success.
"""
if self._regex_helper.search_compiled(Ls._re_files_list, line):
files = line.split()
for filename in files:
self.current_ret["files"][filename] = dict()
self.current_ret["files"][filename]["name"] = filename
raise ParsingDone()
def _parse_long_file(self, line):
"""
Parses line with long information with file or directory.
:param line: Line from device.
:return: None but raises ParsingDone if matches success.
"""
if self._regex_helper.search_compiled(Ls._re_long, line):
self._add_new_file_long(False)
raise ParsingDone()
def _parse_long_links(self, line):
"""
Parses line with long information with link.
:param line: Line from device.
:return: None but raises ParsingDone if matches success.
"""
if self._regex_helper.search_compiled(Ls._re_long_links, line):
self._add_new_file_long(True)
raise ParsingDone()
def _parse_total(self, line):
"""
Parses information about total in ls output.
:param line: Line from device.
:return: None but raises ParsingDone if matches success.
"""
if self._regex_helper.search_compiled(Ls._re_total, line):
if "total" not in self.current_ret:
self.current_ret["total"] = dict()
self.current_ret["total"]["raw"] = self._regex_helper.group(1)
self.current_ret["total"][
"bytes"] = self._converter_helper.to_bytes(
self._regex_helper.group(1))[0]
raise ParsingDone()
def _add_new_file_long(self, islink):
"""
Adds parsed output to command ret.
:param islink: True if parsed output is link or False otherwise.
:return: None.
"""
filename = self._regex_helper.group(7)
self.current_ret["files"][filename] = dict()
self.current_ret["files"][filename][
"permissions"] = self._regex_helper.group(1)
self.current_ret["files"][filename]["hard_links_count"] = int(
self._regex_helper.group(2))
self.current_ret["files"][filename][
"owner"] = self._regex_helper.group(3)
self.current_ret["files"][filename][
"group"] = self._regex_helper.group(4)
self.current_ret["files"][filename][
"size_raw"] = self._regex_helper.group(5)
self.current_ret["files"][filename]["size_bytes"] = \
self._converter_helper.to_bytes(self._regex_helper.group(5))[0]
self.current_ret["files"][filename]["date"] = self._regex_helper.group(
6)
self.current_ret["files"][filename]["name"] = self._regex_helper.group(
7)
if islink:
self.current_ret["files"][filename][
"link"] = self._regex_helper.group(8)
def _get_types(self, requested_type):
"""
Method to return only object of specific type.
:param requested_type: Type of object. Available values: 'd', 'l', '-'
:return: Dict of files
"""
if not self.done():
raise ResultNotAvailableYet("Command not executed already")
requested_type = requested_type.lower()
ret = dict()
result = self.result()
if 'files' in result:
for file_name in result["files"]:
file_dict = result["files"][file_name]
permissions = file_dict["permissions"]
current_type = permissions[0]
if requested_type == current_type:
ret[file_name] = file_dict
return ret
class Iperf(GenericUnixCommand):
def __init__(self,
connection,
options,
prompt=None,
newline_chars=None,
runner=None):
super(Iperf, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self.options = options
self.current_ret['CONNECTIONS'] = dict()
self.current_ret['INFO'] = list()
# private values
self._connection_dict = dict()
self._list_of_connections = dict()
self._converter_helper = ConverterHelper()
def build_command_string(self):
cmd = 'iperf ' + str(self.options)
return cmd
def on_new_line(self, line, is_full_line):
if is_full_line:
try:
self._command_failure(line)
self._parse_connection_name_and_id(line)
self._parse_headers(line)
self._parse_connection_info(line)
self._parse_connection_headers(line)
except ParsingDone:
pass
return super(Iperf, self).on_new_line(line, is_full_line)
_re_command_failure = re.compile(
r"(?P<FAILURE_MSG>.*failed.*|.*error.*|.*command not found.*|.*iperf:.*)"
)
def _command_failure(self, line):
if self._regex_helper.search_compiled(Iperf._re_command_failure, line):
self.set_exception(
CommandFailure(
self, "ERROR: {}".format(
self._regex_helper.group("FAILURE_MSG"))))
raise ParsingDone
_re_connection_name_and_id = re.compile(
r"(?P<ID>\[\s*\d*\])\s*(?P<ID_NAME>.*port\s*\d*\s*connected with.*)")
def _parse_connection_name_and_id(self, line):
if self._regex_helper.search_compiled(Iperf._re_connection_name_and_id,
line):
connection_id = self._regex_helper.group("ID")
connection_name = self._regex_helper.group("ID_NAME")
connection_dict = {connection_id: connection_name}
self._connection_dict.update(connection_dict)
raise ParsingDone
_re_headers = re.compile(r"(?P<HEADERS>\[\s+ID\].*)")
def _parse_headers(self, line):
if self._regex_helper.search_compiled(Iperf._re_headers, line):
matched = line.split()[2:]
self._list_of_connections = [header.strip() for header in matched]
raise ParsingDone
_re_connection_info = re.compile(
r"(?P<CONNECTION_ID>\[\s*\d*\])\s*(?P<CONNECTION_REPORT>.*)")
def _parse_connection_info(self, line):
if self._regex_helper.search_compiled(Iperf._re_connection_info, line):
connection_id = self._regex_helper.group("CONNECTION_ID")
connection_report = self._regex_helper.group(
"CONNECTION_REPORT").split(' ')
connection_report = [
report.strip() for report in connection_report
]
connection_name = self._connection_dict[connection_id]
info_dict = dict(zip(self._list_of_connections, connection_report))
self._normalise_units(connection_report, info_dict)
self._update_current_ret(connection_name, info_dict)
raise ParsingDone
def _update_current_ret(self, connection_name, info_dict):
if connection_name in self.current_ret['CONNECTIONS']:
self.current_ret['CONNECTIONS'][connection_name].append(info_dict)
else:
connection_dict = {connection_name: [info_dict]}
self.current_ret['CONNECTIONS'].update(connection_dict)
_re_ornaments = re.compile(r"(?P<ORNAMENTS>----*|\[\s*ID\].*)",
re.IGNORECASE)
def _parse_connection_headers(self, line):
if not self._regex_helper.search_compiled(Iperf._re_ornaments, line):
self.current_ret['INFO'].append(line.strip())
raise ParsingDone
def _normalise_units(self, report, dictionary_to_update):
for (index, item) in enumerate(report):
if 'Bytes' in item or 'bits' in item:
header = self._list_of_connections[index]
raw_bites = self._converter_helper.to_bytes(item)[0]
new_column_title = header + " Raw"
read_bites = dictionary_to_update[header]
dictionary_to_update[header] = raw_bites
dictionary_to_update.update({new_column_title: read_bites})
def test_converterhelper_seconds_wrong_unit():
from moler.util.converterhelper import ConverterHelper
converter = ConverterHelper.get_converter_helper()
with pytest.raises(ValueError):
converter.to_seconds_str("3UU")
class Du(GenericUnixCommand):
"""Unix command du."""
def __init__(self,
connection,
options=None,
prompt=None,
newline_chars=None,
runner=None):
"""
Unix command du.
:param connection: moler connection to device, terminal when command is executed
:param options: Options of unix du command
:param prompt: expected prompt sending by device after command execution
:param newline_chars: Characters to split lines
:param runner: Runner to run command
"""
super(Du, self).__init__(connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner)
self.options = options
self._converter_helper = ConverterHelper()
def build_command_string(self):
"""
Build command string from parameters passed to object.
:return: String representation of command to send over connection to device.
"""
cmd = "du"
if self.options:
cmd = '{} {}'.format(cmd, self.options)
return cmd
def on_new_line(self, line, is_full_line):
"""
Put your parsing code here.
:param line: Line to process, can be only part of line. New line chars are removed from line.
:param is_full_line: True if line had new line chars, False otherwise
:return: Nothing
"""
if is_full_line:
try:
self._parse_du(line)
self._parse_du_bytes(line)
except ParsingDone:
pass
return super(Du, self).on_new_line(line, is_full_line)
# 4 ./directory/directory2
_re_du = re.compile(r"(?P<NUMBER>^\d+)\s+(?P<DIRECTORY>\S*$)")
def _parse_du(self, line):
if self._regex_helper.search_compiled(Du._re_du, line):
self.current_ret[self._regex_helper.group('DIRECTORY')] = dict()
self.current_ret[self._regex_helper.group(
'DIRECTORY')]["size_bytes"] = 1024 * int(
self._regex_helper.group('NUMBER'))
self.current_ret[self._regex_helper.group(
'DIRECTORY')]["size_raw"] = self._regex_helper.group('NUMBER')
raise ParsingDone
# 4.0K ./directory2/directory3
_re_du_bytes = re.compile(
r"(?P<NUMBER>^\d+\.?\d*\w)\s+(?P<DIRECTORY>\S*$)")
def _parse_du_bytes(self, line):
if self._regex_helper.search_compiled(Du._re_du_bytes, line):
self.current_ret[self._regex_helper.group('DIRECTORY')] = dict()
self.current_ret[self._regex_helper.group('DIRECTORY')]["size_bytes"] = \
self._converter_helper.to_bytes(self._regex_helper.group('NUMBER'))[0]
self.current_ret[self._regex_helper.group(
'DIRECTORY')]["size_raw"] = self._regex_helper.group('NUMBER')
raise ParsingDone
def __init__(self,
connection,
host,
login=None,
password=None,
newline_chars=None,
prompt=None,
runner=None,
port=0,
expected_prompt=r'^>\s*',
set_timeout=r'export TMOUT=\"2678400\"',
set_prompt=None,
term_mono="TERM=xterm-mono",
encrypt_password=True,
target_newline="\n",
allowed_newline_after_prompt=False,
repeat_password=True,
failure_exceptions_indication=None,
prompt_after_login=None,
send_enter_after_connection=True,
username=None):
"""
Base Moler class of Unix commands telnet and ssh.
:param connection: moler connection to device, terminal when command is executed.
:param host: address of telnet server.
:param login: login to telnet server.
:param password: password to telnet server.
:param port: port to listen on server.
:param prompt: prompt on start system (where command telnet starts).
:param expected_prompt: prompt on server (where command telnet connects).
:param set_timeout: Command to set timeout after telnet connects.
:param set_prompt: Command to set prompt after telnet connects.
:param term_mono: Params to set ssh mono connection (useful in script).
:param newline_chars: characters to split lines.
:param encrypt_password: If True then * will be in logs when password is sent, otherwise plain text.
:param runner: Runner to run command.
: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 repeat_password: If True then repeat last password if no more provided. If False then exception is set.
:param failure_exceptions_indication: String with regex or regex object to omit failure even if failed string
was found.
:param prompt_after_login: prompt after login before send export PS1. If you do not change prompt exporting PS1
then leave it None.
:param send_enter_after_connection: set True to send new line char(s) after connection is established, False
otherwise.
"""
super(GenericTelnetSsh, self).__init__(
connection=connection,
prompt=prompt,
newline_chars=newline_chars,
runner=runner,
expected_prompt=expected_prompt,
set_timeout=set_timeout,
set_prompt=set_prompt,
target_newline=target_newline,
allowed_newline_after_prompt=allowed_newline_after_prompt,
prompt_after_login=prompt_after_login)
self.timeout = 90
# Parameters defined by calling the command
self._re_failure_exceptions_indication = None
if failure_exceptions_indication:
self._re_failure_exceptions_indication = CommandTextualGeneric._calculate_prompt(
failure_exceptions_indication)
self.login = login
if isinstance(password, six.string_types):
self._passwords = [password]
elif password is None:
self._passwords = []
else:
self._passwords = copy_list(
password,
deep_copy=False) # copy of list of passwords to modify
self.host = host
self.port = port
self.term_mono = term_mono
self.encrypt_password = encrypt_password
self.repeat_password = repeat_password
self.send_enter_after_connection = send_enter_after_connection
# Internal variables
self._sent_login = False
self._last_password = ""
if login and username:
self.command_string = self.__class__.__name__
raise CommandFailure(
self,
"Please set login ('{}') or username ('{}') but not both.".
format(login, username))
elif username:
self.login = username
self.current_ret['LINES'] = list()
self.current_ret['LAST_LOGIN'] = dict()
self.current_ret['FAILED_LOGIN_ATTEMPTS'] = None
self._converter_helper = ConverterHelper.get_converter_helper()
