413 lines
14 KiB
Python
413 lines
14 KiB
Python
import getpass
|
|
import sys
|
|
from abc import ABC, abstractmethod
|
|
from backend.recorder_adapters import telnetlib, TelnetAdapter
|
|
|
|
# HOST = "localhost"
|
|
# HOST = "129.13.51.102" # Audimax SMP 351
|
|
# HOST = "129.13.51.106" # Tulla SMP 351
|
|
HOST = "172.22.246.207" # Test SMP MZ
|
|
|
|
USER = "admin"
|
|
PW = "123mzsmp"
|
|
|
|
|
|
class SMP(TelnetAdapter):
|
|
def __init__(self, address, admin_password):
|
|
super().__init__(address)
|
|
self.admin_pw = admin_password
|
|
|
|
def login(self):
|
|
self.tn = telnetlib.Telnet(HOST)
|
|
self.tn.read_until("\r\nPassword:")
|
|
#password = getpass.getpass()
|
|
password = self.admin_pw
|
|
self.tn.write(password + "\n\r")
|
|
|
|
out = self.tn.assert_string_in_output("Login Administrator")
|
|
if not out[0]:
|
|
print(out[1])
|
|
if "Password:" in out[1]:
|
|
# TODO: loop until logged in...
|
|
print("re-enter pw")
|
|
self.tn.write("123mzsmp\n\r")
|
|
print(self.tn.assert_string_in_output("Login Administrator"))
|
|
print("WRONG (admin) password!! Exiting!")
|
|
self.tn = None
|
|
raise Exception("Could not login as administrator with given pw!")
|
|
print("OK, we have admin rights!")
|
|
|
|
def get_version(self, include_build=False, verbose_info=False):
|
|
if verbose_info:
|
|
self.tn.write("0Q")
|
|
else:
|
|
if include_build:
|
|
self.tn.write("*Q\n")
|
|
else:
|
|
self.tn.write("1Q\n")
|
|
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_bootstrap_version(self):
|
|
self.tn.write("2Q")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_factory_firmware_version(self):
|
|
self.tn.write("3Q")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_updated_firmware_version(self):
|
|
self.tn.write("4Q")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_part_number(self):
|
|
self.tn.write("N")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_model_name(self):
|
|
self.tn.write("1I")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_model_description(self):
|
|
self.tn.write("2I")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_system_memory_usage(self):
|
|
self.tn.write("3I")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_number_of_connected_users(self):
|
|
self.tn.write("10I")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_system_processer_usage(self):
|
|
self.tn.write("11I")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_system_processor_idle(self):
|
|
self.tn.write("12I")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_eth0_link_status(self):
|
|
self.tn.write("13I")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_file_transfer_config(self):
|
|
self.tn.write("38I")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_active_alarms(self):
|
|
self.tn.write("39I")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def set_unit_name(self, name):
|
|
# TODO: check name (must comply with internet host name standards)
|
|
self.tn.write(self.esc_char + name + "CN\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def reset_unit_name(self):
|
|
self.tn.write(self.esc_char + " CN\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_unit_name(self):
|
|
self.tn.write(self.esc_char + "CN\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
|
|
def get_telnet_connections(self):
|
|
self.tn.write(self.esc_char + "CC\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
|
|
def set_verbose_mode(self, mode:int):
|
|
"""
|
|
Mode:
|
|
0=clear/none (default for telnet connections
|
|
1=verbose mode (default for USB and RS-232 host control)
|
|
2=tagged responses for queries
|
|
3=verbose mode and tagged responses for queries
|
|
:param mode:
|
|
:return:
|
|
"""
|
|
if mode not in range(4):
|
|
raise Exception("Only values from 0 to 3 are allowed!")
|
|
self.tn.write(self.esc_char + str(mode) + "CV\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_verbose_mode(self):
|
|
self.tn.write(self.esc_char + "CV\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
|
|
def save_configuration(self):
|
|
pass
|
|
|
|
def restore_configuration(self):
|
|
pass
|
|
|
|
def reboot(self):
|
|
self.tn.write(self.esc_char + "1BOOT\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def restart_network(self):
|
|
self.tn.write(self.esc_char + "2BOOT\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def reset_flash(self):
|
|
"""
|
|
Reset flash memory (excludes recording files).
|
|
:return:
|
|
"""
|
|
self.tn.write(self.esc_char + "ZFFF\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def system_reset(self):
|
|
"""
|
|
Resets device to default and deletes recorded files
|
|
:return:
|
|
"""
|
|
self.tn.write(self.esc_char + "ZXXX\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def reset_settings_and_delete_all_files(self):
|
|
"""
|
|
Reset to default except IP address, delete all user and recorded files
|
|
:return:
|
|
"""
|
|
self.tn.write(self.esc_char + "ZY\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def absolute_reset(self):
|
|
"""
|
|
Same as System Reset, plus returns the IP address and subnet mask to defaults.
|
|
:return:
|
|
"""
|
|
self.tn.write(self.esc_char + "ZQQQ\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def set_front_panel_lock(self, mode):
|
|
"""
|
|
0=Off
|
|
1=complete lockout (no front panel control)
|
|
2=menu lockout
|
|
3=recording controls
|
|
:param mode: Execute mode int code
|
|
:return:
|
|
"""
|
|
if mode not in range(4):
|
|
raise Exception("Only values from 0 to 3 are allowed!")
|
|
self.tn.write(str(mode) + "X\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_front_panel_lock(self):
|
|
"""
|
|
View executive mode.
|
|
0=Off
|
|
1=complete lockout (no front panel control)
|
|
2=menu lockout
|
|
3=recording controls
|
|
:return:
|
|
"""
|
|
self.tn.write("X\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
"""
|
|
A lot of stuff related to network settings (ports of services, SNMP, IP, DHCP, etc.)
|
|
Only some stuff will be implemented here!
|
|
"""
|
|
|
|
def get_date_time(self):
|
|
pass
|
|
|
|
def get_time_zone(self):
|
|
pass
|
|
|
|
def get_dhcp_mode(self):
|
|
pass
|
|
|
|
def get_network_settings(self):
|
|
pass
|
|
|
|
def get_ip_address(self):
|
|
pass
|
|
|
|
def get_mac_address(self):
|
|
pass
|
|
|
|
def get_subnet_mask(self):
|
|
pass
|
|
|
|
def get_gateway_ip(self):
|
|
pass
|
|
|
|
def get_dns_server_ip(self):
|
|
pass
|
|
|
|
"""
|
|
RS-232 / serial port related stuff not implemented.
|
|
Password and security related stuff not implemented.
|
|
File related stuff not implemented. (-> use sftp)
|
|
"""
|
|
|
|
def set_input(self, input_num: int, channel_num: int):
|
|
"""
|
|
Switches input # (1 to 5) to output channel (1=A [input 1 and 2], 2=B [input 3, 4 and 5])
|
|
:param input_num:
|
|
:param channel_num:
|
|
:return:
|
|
"""
|
|
if input_num not in range(1,6):
|
|
raise Exception("input_num must be a value between 1 and 5!")
|
|
if channel_num not in range(1,3):
|
|
raise Exception("input_num must be a value between 1 and 2!")
|
|
self.tn.write("{}*{}!\n".format(input_num, channel_num))
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_input(self, channel_num: int):
|
|
if channel_num not in range(1,2):
|
|
raise Exception("input_num must be a value between 1 and 2!")
|
|
self.tn.write("{}!\n".format(channel_num))
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def set_input_format(self, input_num: int, input_format: int):
|
|
"""
|
|
Sets the input to the format, where the input_format parameter may be:
|
|
1 = YUVp / HDTV (default)
|
|
2 = YUVi
|
|
3 = Composite
|
|
:param input_num:
|
|
:param input_format:
|
|
:return:
|
|
"""
|
|
if input_num not in range(1,6):
|
|
raise Exception("input_num must be a value between 1 and 5!")
|
|
if input_format not in range(1,4):
|
|
raise Exception("input_num must be a value between 1 and 3!")
|
|
self.tn.write("{}*{}\\\n".format(input_num, input_format))
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_input_format(self, input_num: int):
|
|
if input_num not in range(1,6):
|
|
raise Exception("input_num must be a value between 1 and 5!")
|
|
self.tn.write("{}\\\n".format(input_num))
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def set_input_name(self, input_num: int, input_name: str):
|
|
if input_num not in range(1,6):
|
|
raise Exception("input_num must be a value between 1 and 5!")
|
|
if len(input_name) > 16:
|
|
raise Exception("input_name must be not longer than 16 chars")
|
|
try:
|
|
input_name.encode('ascii')
|
|
except UnicodeDecodeError:
|
|
raise Exception("input_name must only contain ascii characters")
|
|
self.tn.write("{}{},{}NI\n".format(self.esc_char, input_num, input_name))
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_input_name(self, input_num: int):
|
|
if input_num not in range(1,6):
|
|
raise Exception("input_num must be a value between 1 and 5!")
|
|
self.tn.write("{}{}NI\n".format(self.esc_char, input_num))
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_input_selction_per_channel(self):
|
|
self.tn.write("32I\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
"""
|
|
Input configuration part skipped
|
|
"""
|
|
|
|
def stop_recording(self):
|
|
self.tn.write("{}Y0RCDR\n".format(self.esc_char))
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def start_recording(self):
|
|
self.tn.write("{}Y1RCDR\n".format(self.esc_char))
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def pause_recording(self):
|
|
self.tn.write("{}Y2RCDR\n".format(self.esc_char))
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_recording_status(self):
|
|
"""
|
|
Status may be one of:
|
|
0=stop
|
|
1=record
|
|
2=pause
|
|
:return: status
|
|
"""
|
|
self.tn.write("{}YRCDR\n".format(self.esc_char))
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def extent_recording_time(self, extension_time: int):
|
|
"""
|
|
Extends a scheduled recording by extension_time minutes
|
|
:param extension_time: must be an int from 0 to 99
|
|
:return:
|
|
"""
|
|
if extension_time not in range(0,100):
|
|
raise Exception("extension_time must be a value between 0 and 99!")
|
|
self.tn.write("{}E{}RCDR\n".format(self.esc_char, extension_time))
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def add_chapter_marker(self):
|
|
self.tn.write("{}BRCDR\n".format(self.esc_char))
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def swap_channel_positions(self):
|
|
self.tn.write("%\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_recording_status_text(self):
|
|
self.tn.write("I\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_elapsed_recording_time(self):
|
|
self.tn.write("35I\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_remaining_recording_time(self):
|
|
self.tn.write("36I\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
def get_recording_destination(self):
|
|
self.tn.write("37I\n")
|
|
return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line())
|
|
|
|
"""
|
|
Metadata part skipped
|
|
"""
|
|
|
|
def recall_user_preset(self, channel_number, preset_number):
|
|
pass # TODO
|
|
|
|
|
|
smp = SMP(HOST, PW)
|
|
print(smp)
|
|
smp.login()
|
|
print(smp.get_version(verbose_info=False))
|
|
|
|
print(smp.get_bootstrap_version())
|
|
print(smp.get_part_number())
|
|
print(smp.get_model_name())
|
|
print(smp.get_model_description())
|
|
|
|
print(smp.get_system_memory_usage())
|
|
|
|
print(smp.get_file_transfer_config())
|
|
|
|
|
|
# print(smp.get_unit_name())
|
|
# print(smp.set_unit_name("mzsmp"))
|
|
# print(smp.get_unit_name())
|
|
# print(smp.reset_unit_name())
|
|
|
|
print(smp.set_front_panel_lock(0))
|
|
print(smp.get_front_panel_lock())
|
|
|
|
print(smp.get_input_name(1))
|
|
print(smp.get_input_selction_per_channel())
|
|
print(smp.get_recording_status())
|