def outlet_update(
self, upd_linked=False, refresh=False, key="defined", outlets=None
):
"""
Called by consolepi-menu refresh
"""
pwr = self.pwr
if config.power:
outlets = pwr.data if outlets is None else outlets
if not self.pwr_init_complete or refresh:
_outlets = pwr.pwr_get_outlets(
outlet_data=outlets.get("defined", {}),
upd_linked=upd_linked,
failures=outlets.get("failures", {}),
)
pwr.data = _outlets
else:
_outlets = outlets
if key in _outlets:
return _outlets[key]
else:
msg = (
f'Invalid key ({key}) passed to outlet_update. Returning "defined"'
)
log.error(msg, show=True)
return _outlets["defined"]
def get_adapters_via_api(self,
ip: str,
port: int = 5000,
rename: bool = False,
log_host: str = None):
"""Send RestFul GET request to Remote ConsolePi to collect adapter info
params:
ip(str): ip address or FQDN of remote ConsolePi
rename(bool): TODO
log_host(str): friendly string for logging purposes "hostname(ip)"
returns:
adapter dict for remote if successful and adapters exist
status_code 200 if successful but no adapters or Falsey or response status_code if an error occurred.
"""
if not log_host:
log_host = ip
url = f"http://{ip}:{port}/api/v1.0/adapters"
if rename:
url = f"{url}?refresh=true"
log.debug(url)
headers = {
"Accept": "*/*",
"Cache-Control": "no-cache",
"Host": f"{ip}:{port}",
"accept-encoding": "gzip, deflate",
"Connection": "keep-alive",
"cache-control": "no-cache",
}
try:
response = requests.request("GET",
url,
headers=headers,
timeout=config.remote_timeout)
except (OSError, TimeoutError):
log.warning(
f"[API RQST OUT] Remote ConsolePi: {log_host} TimeOut when querying via API - Unreachable."
)
return False
if response.ok:
ret = response.json()
ret = ret["adapters"] if ret["adapters"] else response.status_code
_msg = f"Adapters Successfully retrieved via API for Remote ConsolePi: {log_host}"
log.info("[API RQST OUT] {}".format(_msg))
log.debugv("[API RQST OUT] Response: \n{}".format(
json.dumps(ret, indent=4, sort_keys=True)))
else:
ret = response.status_code
log.error(
f"[API RQST OUT] Failed to retrieve adapters via API for Remote ConsolePi: {log_host}\n{ret}:{response.text}"
)
return ret
def get_adapters_via_api(self, ip: str, rename: bool = False):
"""Send RestFul GET request to Remote ConsolePi to collect adapter info
params:
ip(str): ip address or FQDN of remote ConsolePi
returns:
adapter dict for remote if successful
Falsey or response status_code if an error occured.
"""
# log = self.config.log
if rename:
url = f"http://{ip}:5000/api/v1.0/adapters?refresh=true"
else:
url = f"http://{ip}:5000/api/v1.0/adapters"
log.info(url) # DEBUG
headers = {
"Accept": "*/*",
"Cache-Control": "no-cache",
"Host": f"{ip}:5000",
"accept-encoding": "gzip, deflate",
"Connection": "keep-alive",
"cache-control": "no-cache",
}
try:
response = requests.request("GET",
url,
headers=headers,
timeout=config.remote_timeout)
except (OSError, TimeoutError):
log.warning(
"[API RQST OUT] Remote ConsolePi @ {} TimeOut when querying via API - Unreachable."
.format(ip))
return False
if response.ok:
ret = response.json()
ret = ret["adapters"] if ret["adapters"] else response.status_code
_msg = "Adapters Successfully retrieved via API for Remote ConsolePi @ {}".format(
ip)
log.info("[API RQST OUT] {}".format(_msg))
log.debugv("[API RQST OUT] Response: \n{}".format(
json.dumps(ret, indent=4, sort_keys=True)))
else:
ret = response.status_code
log.error(
"[API RQST OUT] Failed to retrieve adapters via API for Remote ConsolePi @ {}\n{}:{}"
.format(ip, ret, response.text))
return ret
def exec_request(self, _request):
result = None
attempt = 0
while True:
attempt += 1
try:
result = _request.execute()
break
except Exception as e:
log.error(('[GDRIVE]: Exception while communicating with Gdrive\n {}'.format(e)))
if attempt > 2:
log.error(('[GDRIVE]: Giving up after {} attempts'.format(attempt)))
break
return result
def auth(self):
if utils.is_reachable('www.googleapis.com', 443):
try:
if self.creds is None:
self.creds = self.get_credentials()
if self.sheets_svc is None:
self.sheets_svc = discovery.build('sheets', 'v4', credentials=self.creds, cache_discovery=False)
if self.file_id is None:
self.file_id = self.get_file_id()
if self.file_id is None:
self.file_id = self.create_sheet()
return True
except (ConnectionError, TimeoutError, OSError) as e:
log.error('Exception Occurred Connecting to Gdrive {}'.format(e))
return False
else:
log.error('Google Drive is not reachable - Aborting')
return False
def wait_for_threads(self, name="init", timeout=10, thread_type="power"):
"""wait for parallel async threads to complete
returns:
bool: True if threads are still running indicating a timeout
None indicates no threads found ~ they have finished
"""
start = time.time()
do_log = False
found = False
while True:
found = False
for t in threading.enumerate():
if name in t.name:
found = do_log = True
t.join(timeout - 1)
if not found:
if name == "init" and thread_type == "power":
if self.pwr and not self.pwr.data or not self.pwr.data.get(
"dli_power"):
self.pwr.dli_exists = False
self.pwr_init_complete = True
if do_log:
log.info(
"[{0} {1} WAIT] {0} Threads have Completed, elapsed time: {2}"
.format(
name.strip("_").upper(),
thread_type.upper(),
time.time() - start,
))
break
elif time.time() - start > timeout:
log.error(
"[{0} {1} WAIT] Timeout Waiting for {0} Threads to Complete, elapsed time: {2}"
.format(
name.strip("_").upper(),
thread_type.upper(),
time.time() - start,
),
show=True,
)
return True
def do_api_request(self, ip: str, path: str, *args, **kwargs):
"""Send RestFul GET request to Remote ConsolePi to collect data
params:
ip(str): ip address or FQDN of remote ConsolePi
path(str): path beyond /api/v1.0/
returns:
response object
"""
url = f"http://{ip}:5000/api/v1.0/{path}"
log.debug(f'[do_api_request] URL: {url}')
headers = {
"Accept": "*/*",
"Cache-Control": "no-cache",
"Host": f"{ip}:5000",
"accept-encoding": "gzip, deflate",
"Connection": "keep-alive",
"cache-control": "no-cache",
}
try:
response = requests.request("GET",
url,
headers=headers,
timeout=config.remote_timeout)
except (OSError, TimeoutError):
log.warning(
f"[API RQST OUT] Remote ConsolePi @ {ip} TimeOut when querying via API - Unreachable."
)
return False
if response.ok:
log.info(f"[API RQST OUT] {url} Response: OK")
log.debugv(
f"[API RQST OUT] Response: \n{json.dumps(response.json(), indent=4, sort_keys=True)}"
)
else:
log.error(f"[API RQST OUT] API Request Failed {url}")
return response
def run(self, connection_args):
'''Establish Connection to device and run CLI commands provided via ztp config
Args:
connection_args (dict): Arguments passed to paramiko to establish connection
'''
result = dict(
changed=False,
cli_output=[],
message=''
)
_start_time = time.time()
while True:
try:
go = False
# Connect to Switch via SSH
self.ssh_client.connect(**connection_args)
self.prompt = ''
# SSH Command execution not allowed, therefore using the following paramiko functionality
self.shell_chanel = self.ssh_client.invoke_shell()
self.shell_chanel.settimeout(8)
# AOS-CX specific
self.get_prompt()
go = True
break
except socket.timeout:
log.error(f'ZTP CLI Operations Failed, TimeOut Connecting to {self.ip}')
except paramiko.ssh_exception.NoValidConnectionsError as e:
log.error(f'ZTP CLI Operations Failed, {e}')
except paramiko.ssh_exception.AuthenticationException:
log.error('ZTP CLI Operations Failed, CLI Authentication Failed verify creds in config')
if time.time() - _start_time >= ZTP_CLI_LOGIN_MAX_WAIT:
break # Give Up
else:
time.sleep(10)
if go:
try:
result['cli_output'] = self.execute_command(self.cmd_list)
result['changed'] = True
if self.fail_msg:
result['message'] += self.fail_msg.get('msg')
finally:
self.logout()
# Format log entries and exit
_res = " -- // Command Results \\ -- \n"
_cmds = [c for c in self.cmd_list if 'SLEEP' not in c]
for cmd, out in zip(_cmds, result['cli_output']):
if "progress:" in out and f"progress: {out.count('progress:')}/{out.count('progress:')}" in out:
out = out.split("progress:")[0] + f"progress: {out.count('progress:')}/{out.count('progress:')}"
_res += "{}:{} {}\n".format(cmd, '\n' if '\n' in out else '', out)
_res += " --------------------------- \n"
_res += ''.join([f"{k}: {v}\n" for k, v in result.items() if k != "cli_output" and v])
log.info(f"Post ZTP CLI Operational Result for {ip}:\n{_res}")
def main():
cpi = ConsolePi()
cloud_svc = config.cfg.get("cloud_svc", "error")
local = cpi.local
remotes = cpi.remotes
cpiexec = cpi.cpiexec
log.info('[CLOUD TRIGGER (IP)]: Cloud Update triggered by IP Update')
CLOUD_CREDS_FILE = config.static.get(
"CLOUD_CREDS_FILE",
'/etc/ConsolePi/cloud/gdrive/.credentials/credentials.json')
if not utils.is_reachable("www.googleapis.com", 443):
log.error(f"Not Updating {cloud_svc} due to connection failure")
sys.exit(1)
if not utils.valid_file(CLOUD_CREDS_FILE):
log.error('Credentials file not found or invalid')
sys.exit(1)
# -- // Get details from Google Drive - once populated will skip \\ --
if cloud_svc == "gdrive" and remotes.cloud is None:
remotes.cloud = GoogleDrive(hostname=local.hostname)
if cpiexec.wait_for_threads(thread_type="remotes") and (
config.power and cpiexec.wait_for_threads(name="_toggle_refresh")):
log.error(
'IP Change Cloud Update Trigger: TimeOut Waiting for Threads to Complete'
)
remote_consoles = remotes.cloud.update_files(local.data)
if remote_consoles and "Gdrive-Error:" in remote_consoles:
log.error(remote_consoles)
else:
for r in remote_consoles:
# -- Convert Any Remotes with old API schema to new API schema --
if isinstance(remote_consoles[r].get("adapters", {}), list):
remote_consoles[r]["adapters"] = remotes.convert_adapters(
remote_consoles[r]["adapters"])
log.warning(
f"Adapter data for {r} retrieved from cloud in old API format... Converted"
)
if len(remote_consoles) > 0:
remotes.update_local_cloud_file(remote_consoles)
def get_remote(self, data=None, rename=False):
spin = self.spin
def verify_remote_thread(remotepi, data, rename):
"""sub to verify reachability and api data for remotes
params:
remotepi: The hostname currently being processed
data: dict remote ConsolePi dict with hostname as key
"""
this = data[remotepi]
res = self.api_reachable(remotepi, this, rename=rename)
this = res.data
if res.update:
self.cache_update_pending = True
if not res.reachable:
log.warning(
f"[GET REM] Found {remotepi} in Local Cloud Cache: UNREACHABLE"
)
this["fail_cnt"] = (1 if not this.get("fail_cnt") else
this["fail_cnt"] + 1)
self.pop_list.append(remotepi)
self.cache_update_pending = True
else:
self.connected = True
if this.get("fail_cnt"):
this["fail_cnt"] = 0
self.cache_update_pending = True
if res.update:
log.info(
f"[GET REM] Updating Cache - Found {remotepi} in Local Cloud Cache, "
f"reachable via {this['rem_ip']}")
data[remotepi] = this
if data is None or len(data) == 0:
data = config.remotes # remotes from local cloud cache
if not data:
# print(self.log_sym_warn + " No Remotes in Local Cache")
log.info("No Remotes found in Local Cache")
data = {} # convert None type to empy dict
else:
# if self is in the remote-data remove and warn user (can occur in rare scenarios i.e. hostname changes)
if socket.gethostname() in data:
del data[socket.gethostname()]
log.show(
"Local cache included entry for self - do you have other ConsolePis using the same hostname?"
)
# Verify Remote ConsolePi details and reachability
if stdin.isatty():
spin.start(
"Querying Remotes via API to verify reachability and adapter data"
)
for remotepi in data:
# -- // Launch Threads to verify all remotes in parallel \\ --
threading.Thread(
target=verify_remote_thread,
args=(remotepi, data, rename),
name=f"vrfy_{remotepi}",
).start()
# verify_remote_thread(remotepi, data) # Non-Threading DEBUG
# -- wait for threads to complete --
if not self.cpiexec.wait_for_threads(name="vrfy_",
thread_type="remote"):
if config.remotes:
if stdin.isatty():
spin.succeed(
"[GET REM] Querying Remotes via API to verify reachability and adapter data\n\t"
f"Found {len(config.remotes)} Remote ConsolePis")
else:
if stdin.isatty():
spin.warn(
"[GET REM] Querying Remotes via API to verify reachability and adapter data\n\t"
"No Reachable Remote ConsolePis Discovered")
else:
log.error(
"[GET REM] Remote verify threads Still running / exceeded timeout"
)
if stdin.isatty():
spin.stop()
# update local cache if any ConsolePis found UnReachable
if self.cache_update_pending:
if self.pop_list:
for remotepi in self.pop_list:
if (
data[remotepi]["fail_cnt"] >= 3
): # NoQA remove from local cache after 3 failures (cloud or mdns will repopulate if discovered)
removed = data.pop(remotepi)
log.warning(
"[GET REM] {} has been removed from Local Cache after {} failed attempts"
.format(remotepi, removed["fail_cnt"]),
show=True,
)
else:
log.show("Cached Remote '{}' is unreachable".format(
remotepi))
# update local cache file if rem_ip or adapter data changed
data = self.update_local_cloud_file(data)
self.pop_list = []
self.cache_update_pending = False
return data
def do_rename_adapter(self, from_name):
'''Rename USB to Serial Adapter
Creates new or edits existing udev rules and ser2net conf
for USB to serial adapters detected by the system.
params:
from_name(str): Devices current name passed in from rename_menu()
returns:
None type if no error, or Error (str) if Error occurred
'''
from_name = from_name.replace('/dev/', '')
local = self.cpi.local
c = {
'green': '\033[1;32m', # Bold with normal ForeGround
'red': '\033[1;31m',
'norm': '\033[0m', # Reset to Normal
}
c_from_name = '{}{}{}'.format(c['red'], from_name, c['norm'])
error = False
use_def = True
try:
to_name = None
while not to_name:
print(
" Press 'enter' to keep the same name and change baud/parity/..."
)
to_name = input(
f' [rename {c_from_name}]: Provide desired name: ')
print("")
to_name = to_name or from_name
to_name = to_name.replace(
'/dev/',
'') # strip /dev/ if they thought they needed to include it
# it's ok to essentialy rename with same name (to chg baud etc.), but not OK to rename to a name that is already
# in use by another adapter
# TODO collect not connected adapters as well to avoid dups
if from_name != to_name and f"/dev/{to_name}" in local.adapters:
return f"There is already an adapter using alias {to_name}"
for _name in self.reserved_names:
if to_name.startswith(_name):
return f"You can't start the alias with {_name}. Matches system root device prefix"
if ' ' in to_name or ':' in to_name or '(' in to_name or ')' in to_name:
print(
'\033[1;33m!!\033[0m Spaces, Colons and parentheses are not allowed by the associated config files.\n'
'\033[1;33m!!\033[0m Swapping with valid characters\n')
to_name = to_name.replace(' ', '_').replace('(', '_').replace(
')', '_') # not allowed in udev
to_name = to_name.replace(
':', '-'
) # replace any colons with - as it's the field delim in ser2net
except (KeyboardInterrupt, EOFError):
return 'Rename Aborted based on User Input'
c_to_name = f'{c["green"]}{to_name}{c["norm"]}'
log_c_to_name = "".join(["{{green}}", to_name, "{{norm}}"])
go, con_only = True, False
if from_name == to_name:
log.show(
f"Keeping {log_c_to_name}. Changing connection settings Only.")
con_only = True
use_def = False
elif utils.user_input_bool(' Please Confirm Rename {} --> {}'.format(
c_from_name, c_to_name)) is False:
go = False
if go:
for i in local.adapters:
if i == f'/dev/{from_name}':
break
_dev = local.adapters[i].get('config') # type: ignore # dict
# -- these values are always safe, values set by config.py if not extracted from ser2net.conf
baud = _dev['baud']
dbits = _dev['dbits']
flow = _dev['flow']
sbits = _dev['sbits']
parity = _dev['parity']
word = 'keep existing'
for _name in self.reserved_names:
if from_name.startswith(_name):
word = 'Use default'
# -- // Ask user if they want to update connection settings \\ --
if not con_only:
use_def = utils.user_input_bool(
' {} connection values [{} {}{}1 Flow: {}]'.format(
word, baud, dbits, parity.upper(),
self.flow_pretty[flow]))
if not use_def:
self.con_menu(rename=True,
con_dict={
'baud': baud,
'data_bits': dbits,
'parity': parity,
'flow': flow,
'sbits': sbits
})
baud = self.baud
parity = self.parity
dbits = self.data_bits
parity = self.parity
flow = self.flow
sbits = self.sbits
# restore defaults back to class attribute if we flipped them when we called con_menu
# TODO believe this was an old hack, and can be removed
if hasattr(self, 'con_dict') and self.con_dict:
self.baud = self.con_dict['baud']
self.data_bits = self.con_dict['data_bits']
self.parity = self.con_dict['parity']
self.flow = self.con_dict['flow']
self.sbits = self.con_dict['sbits']
self.con_dict = None
if word == 'Use default': # see above word is set if from_name matches a root_dev pfx
devs = local.detect_adapters()
if f'/dev/{from_name}' in devs:
_tty = devs[f'/dev/{from_name}']
id_prod = _tty.get('id_model_id')
id_model = _tty.get('id_model') # NoQA pylint: disable=unused-variable
id_vendorid = _tty.get('id_vendor_id')
id_vendor = _tty.get('id_vendor') # NoQA pylint: disable=unused-variable
id_serial = _tty.get('id_serial_short')
id_ifnum = _tty.get('id_ifnum')
id_path = _tty.get('id_path') # NoQA
lame_devpath = _tty.get('lame_devpath')
root_dev = _tty.get('root_dev')
else:
return 'ERROR: Adapter no longer found'
# -- // ADAPTERS WITH ALL ATTRIBUTES AND GPIO UART (TTYAMA) \\ --
if id_prod and id_serial and id_vendorid:
if id_serial not in devs['_dup_ser']:
udev_line = (
'ATTRS{{idVendor}}=="{}", ATTRS{{idProduct}}=="{}", '
'ATTRS{{serial}}=="{}", SYMLINK+="{}"'.format(
id_vendorid, id_prod, id_serial, to_name))
error = None
while not error:
error = self.add_to_udev(udev_line,
'# END BYSERIAL-DEVS')
error = self.do_ser2net_line(from_name=from_name,
to_name=to_name,
baud=baud,
dbits=dbits,
parity=parity,
flow=flow)
break
# -- // MULTI-PORT ADAPTERS WITH COMMON SERIAL (different ifnums) \\ --
else:
# SUBSYSTEM=="tty", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6011", ATTRS{serial}=="FT4XXXXP", GOTO="FTXXXXP" # NoQA
udev_line = (
'ATTRS{{idVendor}}=="{0}", ATTRS{{idProduct}}=="{1}", '
'ATTRS{{serial}}=="{2}", GOTO="{2}"'.format(
id_vendorid, id_prod, id_serial))
error = None
while not error:
error = self.add_to_udev(udev_line,
'# END BYPORT-POINTERS')
# ENV{ID_USB_INTERFACE_NUM}=="00", SYMLINK+="FT4232H_port1", GOTO="END"
udev_line = (
'ENV{{ID_USB_INTERFACE_NUM}}=="{}", SYMLINK+="{}"'
.format(id_ifnum, to_name))
error = self.add_to_udev(udev_line,
'# END BYPORT-DEVS',
label=id_serial)
error = self.do_ser2net_line(from_name=from_name,
to_name=to_name,
baud=baud,
dbits=dbits,
parity=parity,
flow=flow)
break
else:
if f'/dev/{from_name}' in devs:
devname = devs[f'/dev/{from_name}'].get('devname', '')
# -- // local ttyAMA adapters \\ --
if 'ttyAMA' in devname:
udev_line = ('KERNEL=="{}", SYMLINK+="{}"'.format(
devname.replace('/dev/', ''), to_name))
# Testing simplification not using separate file for ttyAMA
error = None
while not error:
error = self.add_to_udev(
udev_line, '# END TTYAMA-DEVS')
error = self.do_ser2net_line(
from_name=from_name,
to_name=to_name,
baud=baud,
dbits=dbits,
parity=parity,
flow=flow)
break
else:
# -- // LAME ADAPTERS NO SERIAL NUM (map usb port) \\ --
log.warning(
'[ADD ADAPTER] Lame adapter missing key detail: idVendor={}, idProduct={}, serial#={}'
.format( # NoQA
id_vendorid, id_prod, id_serial))
print(
'\n\n This Device Does not present a serial # (LAME!). So the adapter itself can\'t be '
'uniquely identified.\n There are 2 options for naming this device:'
)
mlines = [
'1. Map it to the USB port it\'s plugged in to'
'\n\tAnytime a {} {} tty device is plugged into the port it\n\tis currently plugged into it will '
'adopt the {} alias'.format(
_tty['id_vendor_from_database'],
_tty['id_model_from_database'], to_name),
'2. Map it by vedor ({0}) and model ({1}) alone.'
'\n\tThis will only work if this is the only {0} {1} adapter you plan to plug in'
.format(_tty['id_vendor_from_database'],
_tty['id_model_from_database'])
# 'Temporary mapping' \
# '\n\tnaming will only persist during this menu session\n'
]
print(self.menu.format_subhead(mlines))
print('\n b. back (abort rename)\n')
valid_ch = {'1': 'by_path', '2': 'by_id'}
valid = False
ch = ''
while not valid:
print(' Please Select an option')
ch = self.wait_for_input()
if ch.lower == 'b':
log.show(
f'Rename {from_name} --> {to_name} Aborted'
)
return
elif ch.lower in valid_ch:
valid = True
else:
print(
'invalid choice {} Try Again.'.format(
ch.orig))
udev_line = None
if valid_ch[ch.lower] == 'temp':
error = True
print(
'The Temporary rename feature is not yet implemented'
)
elif valid_ch[ch.lower] == 'by_path':
udev_line = (
'ATTRS{{idVendor}}=="{0}", ATTRS{{idProduct}}=="{1}", GOTO="{0}_{1}"'.format( # NoQA
id_vendorid, id_prod), 'ATTRS{{devpath}}=="{}", ENV{{ID_USB_INTERFACE_NUM}}=="{}", '\
'SYMLINK+="{}"'.format(lame_devpath, id_ifnum, to_name),
)
elif valid_ch[ch.lower] == 'by_id':
udev_line = (
'SUBSYSTEM=="tty", ATTRS{{idVendor}}=="{0}", ATTRS{{idProduct}}=="{1}", GOTO="{0}_{1}"'
.format( # NoQA
id_vendorid, id_prod),
'ENV{{ID_USB_INTERFACE_NUM}}=="{}", SYMLINK+="{}", GOTO="END"'
.format(id_ifnum, to_name) # NoQA
)
else:
error = [
'Unable to add udev rule adapter missing details',
'idVendor={}, idProduct={}, serial#={}'.
format( # NoQA
id_vendorid, id_prod, id_serial)
]
while udev_line:
error = self.add_to_udev(
udev_line[0], '# END BYPATH-POINTERS')
error = self.add_to_udev(udev_line[1],
'# END BYPATH-DEVS',
label='{}_{}'.format(
id_vendorid,
id_prod)) # NoQA
error = self.do_ser2net_line(
from_name=from_name,
to_name=to_name,
baud=baud,
dbits=dbits,
parity=parity,
flow=flow)
break
else:
log.error(f'Device {from_name} No Longer Found',
show=True)
# TODO simplify once ser2net existing verified
else: # renaming previously named port.
# -- // local ttyAMA adapters \\ --
devname = local.adapters[f'/dev/{from_name}']['udev'].get(
'devname', '')
rules_file = self.rules_file if 'ttyAMA' not in devname else self.ttyama_rules_file
cmd = 'sudo sed -i "s/{0}{3}/{1}{3}/g" {2} && grep -q "{1}{3}" {2} && [ $(grep -c "{0}{3}" {2}) -eq 0 ]'.format(
from_name, to_name, rules_file, '')
error = utils.do_shell_cmd(cmd, shell=True)
if not error:
error = self.do_ser2net_line(from_name=from_name,
to_name=to_name,
baud=baud,
dbits=dbits,
parity=parity,
flow=flow)
else:
return [
error.split('\n'),
'Failed to change {} --> {} in {}'.format(
from_name, to_name, self.ser2net_file)
]
if not error:
# Update adapter variables with new_name
local.adapters[f'/dev/{to_name}'] = local.adapters[
f'/dev/{from_name}']
local.adapters[f'/dev/{to_name}']['config'][
'port'] = config.ser2net_conf[f'/dev/{to_name}'].get(
'port', 0)
local.adapters[f'/dev/{to_name}']['config'][
'cmd'] = config.ser2net_conf[f'/dev/{to_name}'].get('cmd')
local.adapters[f'/dev/{to_name}']['config'][
'line'] = config.ser2net_conf[f'/dev/{to_name}'].get(
'line')
local.adapters[f'/dev/{to_name}']['config'][
'log'] = config.ser2net_conf[f'/dev/{to_name}'].get('log')
local.adapters[f'/dev/{to_name}']['config'][
'log_ptr'] = config.ser2net_conf[f'/dev/{to_name}'].get(
'log_ptr')
_config_dict = local.adapters[f'/dev/{to_name}']['config']
if not use_def: # overwrite con settings if they were changed
updates = {
'baud': baud,
'dbits': dbits,
'flow': flow,
'parity': parity,
'sbits': sbits,
}
local.adapters[f'/dev/{to_name}']['config'] = {
**_config_dict,
**updates
}
if from_name != to_name: # facilitates changing con settings without actually renaming
del local.adapters[f'/dev/{from_name}']
self.udev_pending = True # toggle for exit function if they exit directly from rename memu
# update first item in first section of menu_body menu uses it to determine if section is a continuation
try:
self.cur_menu.body_in[0][0] = self.cur_menu.body_in[0][
0].replace(from_name, to_name)
if self.menu.body_in is not None: # Can be none when called via rename directly
self.menu.body_in[0][0] = self.menu.body_in[0][
0].replace(from_name, to_name)
except Exception as e:
log.exception(
f"[DEV NOTE menu_body update after rename caused exception.\n{e}",
show=False)
else:
return 'Aborted based on user input'
def pwr_get_outlets(self, outlet_data={}, upd_linked=False, failures={}):
'''Get Details for Outlets defined in ConsolePi.yaml power section
On Menu Launch this method is called in parallel (threaded) for each outlet
On Refresh all outlets are passed to the method
params: - All Optional
outlet_data:dict, The outlets that need to be updated, if not provided will get all outlets defined in ConsolePi.yaml
upd_linked:Bool, If True will update just the linked ports, False is for dli and will update
all ports for the dli.
failures:dict: when refreshing outlets pass in previous failures so they can be re-tried
'''
# re-attempt connection to failed power controllers on refresh
if not failures:
failures = outlet_data.get('failures') if outlet_data.get('failures') else self.data.get('failures')
outlet_data = self.data.get('defined') if not outlet_data else outlet_data
if failures:
outlet_data = {**outlet_data, **failures}
failures = {}
dli_power = self.data.get('dli_power', {})
for k in outlet_data:
outlet = outlet_data[k]
_start = time.time()
# -- // GPIO \\ --
if outlet['type'].upper() == 'GPIO':
if not is_rpi:
log.warning('GPIO Outlet Defined, GPIO Only Supported on RPi - ignored', show=True)
continue
noff = True if 'noff' not in outlet else outlet['noff']
GPIO.setup(outlet['address'], GPIO.OUT)
outlet_data[k]['is_on'] = bool(GPIO.input(outlet['address'])) if noff \
else not bool(GPIO.input(outlet['address']))
# -- // tasmota \\ --
elif outlet['type'] == 'tasmota':
response = self.do_tasmota_cmd(outlet['address'])
outlet['is_on'] = response
if response not in [0, 1, True, False]:
failures[k] = outlet_data[k]
failures[k]['error'] = f'[PWR-TASMOTA] {k}:{failures[k]["address"]} {response} - Removed'
log.warning(failures[k]['error'], show=True)
# -- // esphome \\ --
elif outlet['type'] == 'esphome':
# TODO have do_esphome accept list, slice, or str for one or multiple relays
relays = utils.listify(outlet.get('relays', k)) # if they have not specified the relay try name of outlet
outlet['is_on'] = {}
for r in relays:
response = self.do_esphome_cmd(outlet['address'], r)
outlet['is_on'][r] = {'state': response, 'name': r}
if response not in [True, False]:
failures[k] = outlet_data[k]
failures[k]['error'] = f'[PWR-ESP] {k}:{failures[k]["address"]} {response} - Removed'
log.warning(failures[k]['error'], show=True)
# -- // dli \\ --
elif outlet['type'].lower() == 'dli':
if TIMING:
dbg_line = '------------------------ // NOW PROCESSING {} \\\\ ------------------------'.format(k)
print('\n{}'.format('=' * len(dbg_line)))
print('{}\n{}\n{}'.format(dbg_line, outlet_data[k], '-' * len(dbg_line)))
print('{}'.format('=' * len(dbg_line)))
# -- // VALIDATE CONFIG FILE DATA FOR DLI \\ --
all_good = True # initial value
for _ in ['address', 'username', 'password']:
if not outlet.get(_):
all_good = False
failures[k] = outlet_data[k]
failures[k]['error'] = f'[PWR-DLI {k}] {_} missing from {failures[k]["address"]} ' \
'configuration - skipping'
log.error(f'[PWR-DLI {k}] {_} missing from {failures[k]["address"]} '
'configuration - skipping', show=True)
break
if not all_good:
continue
(this_dli, _update) = self.load_dli(outlet['address'], outlet['username'], outlet['password'])
if this_dli is None or this_dli.dli is None:
failures[k] = outlet_data[k]
failures[k]['error'] = '[PWR-DLI {}] {} Unreachable - Removed'.format(k, failures[k]['address'])
log.warning(f"[PWR-DLI {k}] {failures[k]['address']} Unreachable - Removed", show=True)
else:
if TIMING:
xstart = time.time()
print('this_dli.outlets: {} {}'.format(this_dli.outlets, 'update' if _update else 'init'))
print(json.dumps(dli_power, indent=4, sort_keys=True))
# upd_linked is for faster update in power menu only refreshes data for linked ports vs entire dli
if upd_linked and self.data['dli_power'].get(outlet['address']):
if outlet.get('linked_devs'):
(outlet, _p) = self.update_linked_devs(outlet)
if k in outlet_data:
outlet_data[k]['is_on'] = this_dli[_p]
else:
log.error(f'[PWR GET_OUTLETS] {k} appears to be unreachable')
# TODO not actually using the error returned this turned into a hot mess
if isinstance(outlet['is_on'], dict) and not outlet['is_on']:
all_good = False
# update dli_power for the refreshed / linked ports
else:
for _ in outlet['is_on']:
dli_power[outlet['address']][_] = outlet['is_on'][_]
else:
if _update:
dli_power[outlet['address']] = this_dli.get_dli_outlets() # data may not be fresh trigger dli update
# handle error connecting to dli during refresh - when connect worked on menu launch
if not dli_power[outlet['address']]:
failures[k] = outlet_data[k]
failures[k]['error'] = f"[PWR-DLI] {k} {failures[k]['address']} Unreachable - Removed"
log.warning(f'[PWR-DLI {k}] {failures[k]["address"]} Unreachable - Removed',
show=True)
continue
else: # dli was just instantiated data is fresh no need to update
dli_power[outlet['address']] = this_dli.outlets
if outlet.get('linked_devs'):
(outlet, _p) = self.update_linked_devs(outlet)
if TIMING:
print('[TIMING] this_dli.outlets: {}'.format(time.time() - xstart)) # TIMING
log.debug(f'dli {k} Updated. Elapsed Time(secs): {time.time() - _start}')
# -- END for LOOP for k in outlet_data --
# Move failed outlets from the keys that populate the menu to the 'failures' key
# failures are displayed in the footer section of the menu, then re-tried on refresh
# TODO this may be causing - RuntimeError: dictionary changed size during iteration
# in pwr_start_update_threads. witnessed on mdnsreg daemon on occasion (Move del logic after wait_for_threads?)
for _dev in failures:
if outlet_data.get(_dev):
del outlet_data[_dev]
if self.data['defined'].get(_dev):
del self.data['defined'][_dev]
if failures[_dev]['address'] in dli_power:
del dli_power[failures[_dev]['address']]
self.data['failures'][_dev] = failures[_dev]
# restore outlets that failed on menu launch but found reachable during refresh
for _dev in outlet_data:
if _dev not in self.data['defined']:
self.data['defined'][_dev] = outlet_data[_dev]
if _dev in self.data['failures']:
del self.data['failures'][_dev]
self.data['dli_power'] = dli_power
return self.data
def detect_adapters(self, key=None):
"""Detect Locally Attached Adapters.
Returns
-------
dict
udev alias/symlink if defined/found as key or root device if not.
/dev/ is stripped: (ttyUSB0 | AP515). Each device has it's attrs
in a dict.
"""
if key is not None:
key = '/dev/' + key.split('/')[
-1] # key can be provided with or without /dev/ prefix
context = pyudev.Context()
devs = {'_dup_ser': {}}
usb_list = [
dev.properties['DEVPATH'].split('/')[-1]
for dev in context.list_devices(ID_BUS='usb', subsystem='tty')
]
pci_list = [
dev.properties['DEVPATH'].split('/')[-1]
for dev in context.list_devices(ID_BUS='pci', subsystem='tty')
]
ama_list = [
dev.replace('/dev/', '')
for dev in config.cfg_yml.get('TTYAMA', {})
]
root_dev_list = usb_list + pci_list + ama_list
for root_dev in root_dev_list:
# determine if the device already has a udev alias & collect available path options for use on lame adapters
dev_name = by_path = by_id = None
try:
_dev = pyudev.Devices.from_name(context, 'tty', root_dev)
except pyudev._errors.DeviceNotFoundByNameError:
log.error(f'pyudev Ubable to find {root_dev}')
continue # TODO Catching error as have seen it in consolepi-mdnsreg not sure if continue is appropriate
_devlinks = _dev.get('DEVLINKS', '').split()
if not _devlinks: # skip occurs on non rpi and ttyAMA
if not root_dev.startswith('ttyAMA'):
continue
else:
for _d in _devlinks:
if '/dev/serial' not in _d:
dev_name = _d.replace('/dev/', '')
elif '/dev/serial/by-path/' in _d:
by_path = _d
elif '/dev/serial/by-id/' in _d:
by_id = _d
dev_name = f'/dev/{root_dev}' if not dev_name else f'/dev/{dev_name}'
devs[dev_name] = {'by_path': by_path, 'by_id': by_id}
devs[dev_name][
'root_dev'] = True if dev_name == f'/dev/{root_dev}' else False
# Gather all available properties from device
_props = {
p.lower() if p != 'ID_USB_INTERFACE_NUM' else 'id_ifnum':
_dev.properties[p]
for p in _dev.properties
}
devs[dev_name] = {**devs[dev_name], **_props}
# -- no need for remaining logic on ttyAMA adapters (local UART)
if 'ttyAMA' in root_dev:
# TODO clean up logic this is copy paste from below
# clean up some redundant or less useful properties
rm_list = [
'devlinks', 'id_mm_candidate', 'id_model_enc',
'id_path_tag', 'tags', 'major', 'minor',
'usec_initialized', 'id_vendor_enc',
'id_pci_interface_from_database', 'id_revision'
]
devs[dev_name] = {
k: v
for k, v in devs[dev_name].items() if k not in rm_list
}
continue
# with some multi-port adapters the model_id and vendor_id need to be pulled from higher in stack
this_dev = _dev
while '0x' in this_dev.properties.get(
'ID_MODEL_ID', '0x') and hasattr(this_dev, 'parent'):
this_dev = this_dev.parent
# -- Collect path for mapping to specific USB port
# TODO clean this up not efficient could combine search for ID_MODEL_ID and devpath
lame_devpath = this_dev.attributes.get('devpath')
if lame_devpath and isinstance(lame_devpath, bytes):
lame_devpath = lame_devpath.decode('UTF-8')
else:
for p in _dev.ancestors:
if 'devpath' in p.attributes.available_attributes:
lame_devpath = p.attributes.get('devpath')
if lame_devpath and isinstance(lame_devpath, bytes):
lame_devpath = lame_devpath.decode('UTF-8')
break
devs[dev_name]['lame_devpath'] = lame_devpath
fallback_ser = this_dev.properties.get('ID_SERIAL_SHORT')
devs[dev_name]['id_model_id'] = this_dev.properties['ID_MODEL_ID']
devs[dev_name]['id_vendor_id'] = this_dev.properties[
'ID_VENDOR_ID']
devs[dev_name]['time_since_init'] = f'{_dev.properties.device.time_since_initialized} ' \
f"as of {time.strftime('%x %I:%M:%S %p %Z', time.localtime(time.time()))}"
# clean up some redundant or less useful properties
rm_list = [
'devlinks', 'id_mm_candidate', 'id_model_enc', 'id_path_tag',
'tags', 'major', 'minor', 'usec_initialized', 'id_vendor_enc',
'id_pci_interface_from_database', 'id_revision'
]
devs[dev_name] = {
k: v
for k, v in devs[dev_name].items() if k not in rm_list
}
# --- // Handle Multi-Port adapters that use same serial for all interfaces \\ ---
# Capture the dict in dup_ser it's later del if no additional devices present with the same serial
# Capture path and ifnum for any subsequent devs if ser is already in the dup_ser dict
_ser = devs[dev_name]['id_serial_short'] = _dev.get(
'ID_SERIAL_SHORT', fallback_ser)
if _ser not in devs['_dup_ser']:
devs['_dup_ser'][_ser] = {'id_paths': [], 'id_ifnums': []}
devs['_dup_ser'][_ser]['id_paths'].append(
devs[dev_name]['id_path'])
devs['_dup_ser'][_ser]['id_ifnums'].append(
devs[dev_name]['id_ifnum'])
# --- // Clean up detection of Multi-Port adapters that use same serial for all interfaces \\ ---
# all dev serial #s are added to dup_ser as they are discovered
# remove any serial #s that only appeared once.
del_list = [
_ser for _ser in devs['_dup_ser']
if len(devs['_dup_ser'][_ser]['id_paths']) == 1
]
for i in del_list:
del devs['_dup_ser'][i]
return devs if key is None else devs[key]
def menu_formatting(self,
section,
sub=None,
text=None,
footer={},
width=MIN_WIDTH,
l_offset=1,
index=1,
do_print=True,
do_format=True):
mlines = []
max_len = None
# footer options also supports an optional formatting dict
# place '_rjust' in the list and the subsequent item should be a dict
#
# _rjust: {dict} right justify addl text on same line with
# one of the other footer options.
# i.e.
footer_options = {
'power': ['p', 'Power Control Menu'],
'dli': ['d', '[dli] Web Power Switch Menu'],
'rshell': ['rs', 'Remote Shell Menu'],
'key': ['k', 'Distribute SSH public Key to Remote Hosts'],
'shell': ['sh', 'Enter Local Shell'],
'rn': ['rn', 'Rename Adapters'],
'refresh': ['r', 'Refresh'],
'sync': ['s', 'Sync with cloud'],
'con': [
'c',
'Change Default Serial Settings (devices marked with ** only)'
],
'picohelp': ['h', 'Display Picocom Help'],
'back': ['b', 'Back'],
'x': ['x', 'Exit']
}
# -- append any errors from menu builder
# self.error_msgs += self.menu.error_msgs
# self.menu.error_msgs = []
# -- Adjust width if there is an error msg longer then the current width
# -- Delete any errors defined in ignore errors
# TODO Move all menu formatting to it's own library - clean this up
# Think I process errors here and maybe in print_mlines as well
# addl processing in FOOTER
if log.error_msgs:
# TODO maybe move to log class
_error_lens = []
for _error in log.error_msgs:
for e in self.ignored_errors:
_e = _error.strip('\r\n')
if hasattr(e, 'match') and e.match(_e):
log.error_msgs.remove(_error)
break
elif isinstance(e, str) and (e == _error or e in _error):
log.error_msgs.remove(_error)
break
else:
_error_lens.append(self.format_line(_error).len)
if _error_lens:
width = width if width >= max(_error_lens) + 5 else max(
_error_lens) + 5
width = width if width <= self.cols else self.cols
# --// HEADER \\--
if section == 'header':
# ---- CLEAR SCREEN -----
if not config.debug:
os.system('clear')
mlines.append('=' * width)
line = self.format_line(text)
_len = line.len
fmtd_header = line.text
a = width - _len
b = (a / 2) - 2
if text:
c = int(b) if b == int(b) else int(b) + 1
if isinstance(text, list):
for t in text:
mlines.append(' {0} {1} {2}'.format(
'-' * int(b), t, '-' * c))
else:
mlines.append(' {0} {1} {2}'.format(
'-' * int(b), fmtd_header, '-' * c))
mlines.append('=' * width)
# --// BODY \\--
elif section == 'body':
max_len = 0
blines = list(text) if isinstance(text, str) else text
pad = True if len(blines) + index > 10 else False
indent = l_offset + 4 if pad else l_offset + 3
width_list = []
for _line in blines:
# -- format spacing of item entry --
_i = str(index) + '. ' if not pad or index > 9 else str(
index) + '. '
# -- generate line and calculate line length --
_line = ' ' * l_offset + _i + _line
line = self.format_line(_line)
width_list.append(line.len)
mlines.append(line.text)
index += 1
max_len = 0 if not width_list else max(width_list)
if sub:
# -- Add sub lines to top of menu item section --
x = ((max_len - len(sub)) / 2) - (l_offset + (indent / 2))
mlines.insert(0, '')
width_list.insert(0, 0)
if do_format:
mlines.insert(
1, '{0}{1} {2} {3}'.format(
' ' * indent, '-' * int(x), sub, '-' *
int(x) if x == int(x) else '-' * (int(x) + 1)))
width_list.insert(1, len(mlines[1]))
else:
mlines.insert(1, ' ' * indent + sub)
width_list.insert(1, len(mlines[1]))
max_len = max(
width_list
) # update max_len in case subheading is the longest line in the section
mlines.insert(2, ' ' * indent + '-' * (max_len - indent))
width_list.insert(2, len(mlines[2]))
# -- adding padding to line to full width of longest line in section --
mlines = self.pad_lines(mlines, max_len,
width_list) # Refactoring in progress
# --// FOOTER \\--
elif section == 'footer':
#######
# Being Depricated. Remove once converted
#######
if text and isinstance(text, (str, list)):
mlines.append('')
text = [text] if isinstance(text, str) else text
for t in text:
if '{{r}}' in t:
_t = t.split('{{r}}')
mlines.append('{}{}'.format(
_t[0], _t[1].rjust(width - len(_t[0]))))
else:
# mlines.append(self.format_line(t)[1])
mlines.append(self.format_line(t).text)
# TODO temp indented this to be under text to avoid conflict during refactor
mlines += [' x. exit', '']
mlines.append('=' * width)
########
# REDESIGNED FOOTER LOGIC
########
if footer:
opts = utils.listify(footer.get('opts', []))
if 'x' not in opts:
opts.append('x')
no_match_overrides = no_match_rjust = [] # init
pre_text = post_text = foot_text = [] # init
# replace any pre-defined options with those passed in as overrides
if footer.get('overrides') and isinstance(
footer['overrides'], dict):
footer_options = {**footer_options, **footer['overrides']}
no_match_overrides = [
e for e in footer['overrides']
if e not in footer_options
and e not in footer.get('rjust', {})
]
# update footer_options with any specially formmated (rjust) additions
if footer.get('rjust'):
r = footer.get('rjust')
f = footer_options
foot_overrides = {
k: [
f[k][0], '{}{}'.format(
f[k][1], r[k].rjust(width - len(
f' {f[k][0]}.{" " if len(f[k][0]) == 2 else " "}{f[k][1]}'
)))
]
for k in r if k in f
}
footer_options = {**footer_options, **foot_overrides}
no_match_rjust = [
e for e in footer['rjust'] if e not in footer_options
]
if footer.get('before'):
footer['before'] = [footer['before']] if isinstance(
footer['before'], str) else footer['before']
pre_text = [f' {line}' for line in footer['before']]
if opts:
f = footer_options
foot_text = [
f' {f[k][0]}.{" " if len(f[k][0]) == 2 else " "}{f[k][1]}'
for k in opts if k in f
]
if footer.get('after'):
footer['after'] = [footer['after']] if isinstance(
footer['after'], str) else footer['after']
post_text = [f' {line}' for line in footer['after']]
mlines = mlines + [''] + pre_text + foot_text + post_text + [
''
] + ['=' * width]
# TODO probably simplify to make this a catch all at the end of this method
# mlines = [self.format_line(line)[1] for line in mlines]
mlines = [self.format_line(line).text for line in mlines]
# log errors if non-match overrides/rjust options were sent
if no_match_overrides + no_match_rjust:
log.error(
f'menu_formatting passed options ({",".join(no_match_overrides + no_match_rjust)})'
' that lacked a match in footer_options = No impact to menu',
log=True,
level='error')
# --// ERRORs - append to footer \\-- #
if len(log.error_msgs) > 0:
errors = log.error_msgs
for _error in errors:
error = self.format_line(_error)
x = ((width - (error.len + 4)) / 2)
mlines.append('{0}{1}{2}{3}{0}'.format(
self.log_sym_2bang, ' ' * int(x), error.text,
' ' * int(x) if x == int(x) else ' ' * (int(x) + 1)))
if errors: # TODO None Type added to list after rename why
mlines.append('=' * width)
if do_print:
log.error_msgs = [] # clear error messages after print
else:
log.error_msgs.append(
'formatting function passed an invalid section')
# --// DISPLAY THE MENU \\--
if do_print:
for _line in mlines:
print(_line)
self.menu_rows += 1 # TODO DEBUGGING make easier then remove
# TODO refactor max_len to widest_line as thats what it is
return mlines, max_len
def on_service_state_change(self, zeroconf: Zeroconf, service_type: str,
name: str,
state_change: ServiceStateChange) -> None:
cpi = self.cpi
mdns_data = None
update_cache = False
if state_change is ServiceStateChange.Added:
info = zeroconf.get_service_info(service_type, name)
if info:
if info.server.split('.')[0] != cpi.local.hostname:
if info.properties:
properties = info.properties
mdns_data = {
k.decode('UTF-8'): v.decode('UTF-8')
if not v.decode('UTF-8')[0] in ['[', '{'] else
json.loads(v.decode('UTF-8')) # NoQA
for k, v in properties.items()
}
hostname = mdns_data.get('hostname')
interfaces = mdns_data.get('interfaces', [])
# interfaces = json.loads(properties[b'interfaces'].decode("utf-8"))
log_out = json.dumps(mdns_data,
indent=4,
sort_keys=True)
log.debug(
f'[MDNS DSCVRY] {hostname} Properties Discovered via mdns:\n{log_out}'
)
rem_ip = mdns_data.get('rem_ip')
if not rem_ip:
if len(mdns_data.get('interfaces', [])) == 1:
rem_ip = [
interfaces[i]['ip'] for i in interfaces
]
rem_ip = rem_ip[0]
else:
rem_ip = None if hostname not in cpi.remotes.data or 'rem_ip' not in cpi.remotes.data[hostname] \
else cpi.remotes.data[hostname]['rem_ip']
cur_known_adapters = cpi.remotes.data.get(
hostname, {
'adapters': None
}).get('adapters')
# -- Log new entry only if this is the first time it's been discovered --
if hostname not in self.d_discovered:
self.d_discovered.append(hostname)
log.info(
'[MDNS DSCVRY] {}({}) Discovered via mdns'.
format(hostname,
rem_ip if rem_ip is not None else '?'))
from_mdns_adapters = mdns_data.get('adapters')
mdns_data['rem_ip'] = rem_ip
mdns_data[
'adapters'] = from_mdns_adapters if from_mdns_adapters is not None else cur_known_adapters
mdns_data['source'] = 'mdns'
mdns_data['upd_time'] = int(time.time())
mdns_data = {hostname: mdns_data}
# update from API only if no adapter data exists either in cache or from mdns that triggered this
# adapter data is updated on menu_launch
if not mdns_data[hostname][
'adapters'] or hostname not in cpi.remotes.data:
log.info(
'[MDNS DSCVRY] {} provided no adapter data Collecting via API'
.format(info.server.split('.')[0]))
# TODO check this don't think needed had a hung process on one of my Pis added it to be safe
try:
res = cpi.remotes.api_reachable(
hostname, mdns_data[hostname])
update_cache = res.update
mdns_data[hostname] = res.data
# reachable = res.reachable
except Exception as e:
log.error(
f'Exception occured verifying reachability via API for {hostname}:\n{e}'
)
if self.show:
if hostname in self.discovered:
self.discovered.remove(hostname)
self.discovered.append('{}{}'.format(
hostname, '*' if update_cache else ''))
print(hostname +
'({}) Discovered via mdns.'.format(
rem_ip if rem_ip is not None else '?'))
try:
print('{}\n{}'.format(
'mdns: None' if from_mdns_adapters is None
else 'mdns: {}'.format([
d.replace('/dev/', '')
for d in from_mdns_adapters
] if not isinstance(
from_mdns_adapters, list) else [
d['dev'].replace('/dev/', '')
for d in from_mdns_adapters
]),
'cache: None' if cur_known_adapters is None
else 'cache: {}'.format([
d.replace('/dev/', '')
for d in cur_known_adapters
] if not isinstance(
cur_known_adapters, list) else [
d['dev'].replace('/dev/', '')
for d in cur_known_adapters
])))
except TypeError as e:
print(f'EXCEPTION: {e}')
print(
f'\nDiscovered ConsolePis: {self.discovered}')
print("press Ctrl-C to exit...\n")
log.debug(
'[MDNS DSCVRY] {} Final data set:\n{}'.format(
hostname,
json.dumps(mdns_data, indent=4,
sort_keys=True)))
if update_cache:
if 'hostname' in mdns_data[hostname]:
del mdns_data[hostname]['hostname']
cpi.remotes.data = cpi.remotes.update_local_cloud_file(
remote_consoles=mdns_data)
log.info(
f'[MDNS DSCVRY] {hostname} Local Cache Updated after mdns discovery'
)
else:
log.warning(
f'[MDNS DSCVRY] {hostname}: No properties found')
else:
log.warning(f'[MDNS DSCVRY] {info}: No info found')
def auto_pwron_thread(self, pwr_key):
"""Ensure any outlets linked to device are powered on
Called by consolepi_menu exec_menu function and remote_launcher (for sessions to remotes)
when a connection initiated with adapter. Powers any linked outlets associated with the
adapter on.
params:
menu_dev:str, The tty device user is connecting to.
Returns:
No Return - Updates class attributes
"""
if self.wait_for_threads("init"):
return
outlets = self.pwr.data
if "linked" not in outlets:
_msg = "Error linked key not found in outlet dict\nUnable to perform auto power on"
log.show(_msg, show=True)
return
if not outlets["linked"].get(pwr_key):
return
# -- // Perform Auto Power On (if not already on) \\ --
for o in outlets["linked"][pwr_key]:
outlet = outlets["defined"].get(o.split(":")[0])
if outlet:
ports = [] if ":" not in o else json.loads(
o.replace("'", '"').split(":")[1])
_addr = outlet["address"]
else:
log.error(
f"Skipping Auto Power On {pwr_key} for {o}. Unable to pull outlet details from defined outlets.",
show=True,
)
log.debugv(f"Outlet Dict:\n{json.dumps(outlets)}")
continue
# -- // DLI web power switch Auto Power On \\ --
#
# TODO combine all ports from same pwr_key and sent to pwr_toggle once
# TODO Update outlet if return is OK, then run refresh in the background to validate
# TODO Add class attribute to cpi_menu ~ cpi_menu.new_data = "power", "main", etc
# Then in wait_for_input run loop to check for updates and re-display menu
# TODO power_menu and dli_menu wait_for_threads auto power ... check cpiexec.autopwr_wait first
#
if outlet["type"].lower() == "dli":
for p in ports:
log.debug(
f"[Auto PwrOn] Power ON {pwr_key} Linked Outlet {outlet['type']}:{_addr} p{p}"
)
if not outlet["is_on"][p][
"state"]: # This is just checking what's in the dict not querying the DLI
r = self.pwr.pwr_toggle(outlet["type"],
_addr,
desired_state=True,
port=p)
if isinstance(r, bool):
if r:
threading.Thread(
target=self.outlet_update,
kwargs={
"refresh": True,
"upd_linked": True
},
name="auto_pwr_refresh_dli",
).start()
self.autopwr_wait = True
else:
log.warning(
f"{pwr_key} Error operating linked outlet @ {o}",
show=True,
)
# -- // esphome Auto Power On \\ --
elif outlet["type"].lower() == "esphome":
for p in ports:
log.debug(
f"[Auto PwrOn] Power ON {pwr_key} Linked Outlet {outlet['type']}:{_addr} p{p}"
)
if not outlet["is_on"][p][
"state"]: # This is just checking what's in the dict
r = self.pwr.pwr_toggle(outlet["type"],
_addr,
desired_state=True,
port=p)
if isinstance(r, bool):
self.pwr.data["defined"][o.split(
":")[0]]["is_on"][p]["state"] = r
else:
log.show(r)
log.warning(
f"{pwr_key} Error operating linked outlet @ {o}",
show=True,
)
# -- // GPIO & TASMOTA Auto Power On \\ --
else:
log.debug(
f"[Auto PwrOn] Power ON {pwr_key} Linked Outlet {outlet['type']}:{_addr}"
)
r = self.pwr.pwr_toggle(
outlet["type"],
_addr,
desired_state=True,
noff=outlet.get("noff", True)
if outlet["type"].upper() == "GPIO" else True,
)
if isinstance(r, int) and r > 1: # return is an error
r = False
else: # return is bool which is what we expect
if r:
self.pwr.data["defined"][o]["state"] = r
self.autopwr_wait = True
# self.pwr.pwr_get_outlets(upd_linked=True)
else:
# self.config.log_and_show(f"Error operating linked outlet {o}:{outlet['address']}", log=log.warning)
log.show(
f"Error operating linked outlet {o}:{outlet['address']}",
show=True,
)
def do_ser2net_line(self,
from_name: str = None,
to_name: str = None,
baud: int = None,
dbits: int = None,
parity: str = None,
flow: str = None,
sbits: int = None):
'''Process Adapter Configuration Changes in ser2net.conf.
Keyword Arguments:
from_name {str} -- The Adapters existing name/alias (default: {None})
to_name {str} -- The Adapters new name/alias (default: {None})
baud {int} -- Adapter baud (default: {self.baud})
dbits {int} -- Adapter databits (default: {self.data_bits})
parity {str} -- Adapter Parity (default: {self.parity})
flow {str} -- Adapter flow (default: {self.flow})
sbits {int} -- Adapter stop bits (default: {self.sbits})
Returns:
{str|None} -- Returns error text if an error occurs or None if no issues.
'''
# don't add the new entry to ser2net if one already exists for the alias
if from_name != to_name and config.ser2net_conf.get(f"/dev/{to_name}"):
log.info(
f"ser2net: {to_name} already mapped to port {config.ser2net_conf[f'/dev/{to_name}'].get('port')}",
show=True)
return
ser2net_parity = {'n': 'NONE', 'e': 'EVEN', 'o': 'ODD'}
ser2net_flow = {'n': '', 'x': ' XONXOFF', 'h': ' RTSCTS'}
baud = self.baud if not baud else baud
dbits = self.data_bits if not dbits else dbits
parity = self.parity if not parity else parity
flow = self.flow if not flow else flow
sbits = self.sbits if not sbits else sbits
log_ptr = ''
cur_line = config.ser2net_conf.get(f'/dev/{from_name}', {}).get('line')
if cur_line and '/dev/ttyUSB' not in cur_line and '/dev/ttyACM' not in cur_line:
new_entry = False
next_port = next_port = cur_line.split(':')[0] # Renaming existing
log_ptr = config.ser2net_conf[f'/dev/{from_name}'].get('log_ptr')
if not log_ptr:
log_ptr = ''
else:
new_entry = True
if utils.valid_file(self.ser2net_file):
ports = [
a['port'] for a in config.ser2net_conf.values()
if 7000 < a.get('port', 0) <= 7999
]
next_port = 7001 if not ports else int(max(ports)) + 1
else:
next_port = 7001
error = utils.do_shell_cmd(
f'sudo cp {self.ser2net_file} /etc/', handle_errors=False)
if error:
log.error(
f'Rename Menu Error while attempting to cp ser2net.conf from src {error}'
)
return error # error added to display in calling method
ser2net_line = (
'{telnet_port}:telnet:0:/dev/{alias}:{baud} {dbits}DATABITS {parity} '
'{sbits}STOPBIT {flow} banner {log_ptr}'.format(
telnet_port=next_port,
alias=to_name,
baud=baud,
dbits=dbits,
sbits=sbits,
parity=ser2net_parity[parity],
flow=ser2net_flow[flow],
log_ptr=log_ptr))
# -- // Append to ser2net.conf \\ --
if new_entry:
error = utils.append_to_file(self.ser2net_file, ser2net_line)
# -- // Rename Existing Definition in ser2net.conf \\ --
# -- for devices with existing definitions cur_line is the existing line
else:
ser2net_line = ser2net_line.strip().replace('/', r'\/')
cur_line = cur_line.replace('/', r'\/')
cmd = "sudo sed -i 's/^{}$/{}/' {}".format(
cur_line, ser2net_line, self.ser2net_file)
error = utils.do_shell_cmd(cmd, shell=True)
if not error:
config.ser2net_conf = config.get_ser2net()
else:
return error
def on_service_state_change(self,
zeroconf: Zeroconf, service_type: str, name: str, state_change: ServiceStateChange) -> None:
if self.cpi.local.hostname == name.split(".")[0]:
return
if state_change is not ServiceStateChange.Added:
return
info = zeroconf.get_service_info(service_type, name)
if not info:
log.warning(f'[MDNS DSCVRY] {name}: No info found')
return
if not hasattr(info, "properties") or not info.properties:
log.warning(f'[MDNS DSCVRY] {name}: No properties found')
return
properties = info.properties
cpi = self.cpi
mdns_data = None
update_cache = False
try:
mdns_data = {
k.decode('UTF-8'):
v.decode('UTF-8') if len(v) == 0 or not v.decode('UTF-8')[0] in ['[', '{'] else json.loads(v.decode('UTF-8')) # NoQA
for k, v in properties.items()
}
except Exception as e:
log.exception(
f"[MDNS DSCVRY] {e.__class__.__name__} occured while parsing mdns_data:\n {mdns_data}\n"
f"Exception: \n{e}"
)
log.error(f"[MDNS DSCVRY] entry from {name} ignored due to parsing exception.")
return
hostname = mdns_data.get('hostname')
interfaces = mdns_data.get('interfaces', [])
log_out = json.dumps(mdns_data, indent=4, sort_keys=True)
log.debug(f'[MDNS DSCVRY] {hostname} Properties Discovered via mdns:\n{log_out}')
rem_ip = mdns_data.get('rem_ip')
if not rem_ip:
if len(mdns_data.get('interfaces', [])) == 1:
rem_ip = [interfaces[i]['ip'] for i in interfaces]
rem_ip = rem_ip[0]
else:
rem_ip = None if hostname not in cpi.remotes.data or 'rem_ip' not in cpi.remotes.data[hostname] \
else cpi.remotes.data[hostname]['rem_ip']
cur_known_adapters = cpi.remotes.data.get(hostname, {'adapters': None}).get('adapters')
# -- Log new entry only if this is the first time it's been discovered --
if hostname not in self.d_discovered:
self.d_discovered += [hostname]
log.info('[MDNS DSCVRY] {}({}) Discovered via mdns'.format(
hostname, rem_ip if rem_ip is not None else '?'))
from_mdns_adapters = mdns_data.get('adapters')
mdns_data['rem_ip'] = rem_ip
mdns_data['adapters'] = from_mdns_adapters if from_mdns_adapters else cur_known_adapters
mdns_data['source'] = 'mdns'
mdns_data['upd_time'] = int(time.time())
mdns_data = {hostname: mdns_data}
# update from API only if no adapter data exists either in cache or from mdns that triggered this
# adapter data is updated on menu_launch either way
if (not mdns_data[hostname]['adapters'] and hostname not in self.no_adapters) or \
hostname not in cpi.remotes.data:
log.info(f"[MDNS DSCVRY] {info.server.split('.')[0]} provided no adapter data Collecting via API")
# TODO check this don't think needed had a hung process on one of my Pis added it to be safe
try:
# TODO we are setting update time here so always result in a cache update with the restart timer
res = cpi.remotes.api_reachable(hostname, mdns_data[hostname])
update_cache = res.update
if not res.data.get('adapters'):
self.no_adapters.append(hostname)
elif hostname in self.no_adapters:
self.no_adapters.remove(hostname)
mdns_data[hostname] = res.data
except Exception as e:
log.exception(f'Exception occurred verifying reachability via API for {hostname}:\n{e}')
if self.show:
if hostname in self.discovered:
self.discovered.remove(hostname)
self.discovered.append('{}{}'.format(hostname, '*' if update_cache else ''))
print(hostname + '({}) Discovered via mdns.'.format(rem_ip if rem_ip is not None else '?'))
try:
print(
'{}\n{}\n{}'.format(
'mdns: None' if from_mdns_adapters is None else 'mdns: {}'.format(
[d.replace('/dev/', '') for d in from_mdns_adapters]
if not isinstance(from_mdns_adapters, list) else
[d['dev'].replace('/dev/', '') for d in from_mdns_adapters]
),
'api (mdns trigger): None' if not mdns_data[hostname]['adapters'] else 'api (mdns trigger): {}'.format(
[d.replace('/dev/', '') for d in mdns_data[hostname]['adapters']]
if not isinstance(mdns_data[hostname]['adapters'], list) else
[d['dev'].replace('/dev/', '') for d in mdns_data[hostname]['adapters']]
),
'cache: None' if cur_known_adapters is None else 'cache: {}'.format(
[d.replace('/dev/', '') for d in cur_known_adapters]
if not isinstance(cur_known_adapters, list) else
[d['dev'].replace('/dev/', '') for d in cur_known_adapters]
)
)
)
except TypeError as e:
print(f'EXCEPTION: {e}')
print(f'\nDiscovered ConsolePis: {self.discovered}')
print("press Ctrl-C to exit...\n")
log.debugv(
f"[MDNS DSCVRY] {hostname} Final data set:\n{json.dumps(mdns_data, indent=4, sort_keys=True)}"
)
# TODO could probably just put the call to cache update in the api_reachable method
if update_cache:
if 'hostname' in mdns_data[hostname]:
del mdns_data[hostname]['hostname']
cpi.remotes.data = cpi.remotes.update_local_cloud_file(remote_consoles=mdns_data)
log.info(f'[MDNS DSCVRY] {hostname} Local Cache Updated after mdns discovery')
