def expires(self, lvar_id, etime=0):
"""
set lvar expiration time
Args:
lvar_id: lvar id
Optional:
etime: time (in seconds), default is 0 (never expires)
Raises:
FunctionFailed: lvar expiration set error
ResourceNotFound: lvar is not found
"""
lvar = eva.lm.controller.get_lvar(lvar_id)
if not lvar:
raise ResourceNotFound
try:
result = lvar.set_prop('expires', etime, save=False)
if not result:
raise FunctionFailed('lvar expire set error')
return result
except:
raise FunctionFailed('lvar expire set error')
return True
def create_data_puller(name,
cmd,
timeout=None,
event_timeout=None,
save=False):
try:
if datapullers[name].active:
raise FunctionFailed('Data puller exists and is active')
except KeyError:
pass
dp = DataPuller(name,
cmd,
polldelay=eva.core.config.polldelay,
timeout=timeout,
event_timeout=event_timeout)
datapullers[name] = dp
try:
dp_destroyed.remove(name)
except KeyError:
pass
if timeout is not None and timeout <= 0:
raise InvalidParameter('timeout must be greater than zero')
if event_timeout is not None and event_timeout <= 0:
raise InvalidParameter('event timeout must be greater than zero')
if save:
if not eva.core.prepare_save():
raise FunctionFailed('prepare save error')
eva.registry.key_set(f'config/uc/datapullers/{name}', {
'cmd': cmd,
'timeout': timeout,
'event-timeout': event_timeout
})
if not eva.core.finish_save():
raise FunctionFailed('finish save error')
dp.saved = True
def load_driver(lpi_id, lpi_mod_id, phi_id, lpi_cfg=None, start=True):
if get_phi(phi_id) is None:
raise ResourceNotFound(
'Unable to load LPI, unknown PHI: {}'.format(phi_id))
if not lpi_id: raise InvalidParameter('LPI id not specified')
if not re.match("^[A-Za-z0-9_-]*$", lpi_id):
raise InvalidParameter(
'LPI {} id contains forbidden symbols'.format(lpi_id))
try:
lpi_mod = importlib.import_module('eva.uc.drivers.lpi.' + lpi_mod_id)
# doesn't work but we hope
importlib.reload(lpi_mod)
_api = lpi_mod.__api__
_author = lpi_mod.__author__
_version = lpi_mod.__version__
_description = lpi_mod.__description__
_license = lpi_mod.__license__
_logic = lpi_mod.__logic__
logging.info('LPI loaded %s v%s, author: %s, license: %s' %
(lpi_mod_id, _version, _author, _license))
logging.debug('%s: %s' % (lpi_mod_id, _description))
if _logic == 'abstract':
logging.error(
'Unable to activate LPI %s: ' % lpi_mod_id + \
'abstract module'
)
return False
if _api > __api__:
logging.error(
'Unable to activate LPI %s: ' % lpi_mod_id + \
'controller driver API version is %s, ' % __api__ + \
'LPI driver API version is %s' % _api)
return False
except Exception as e:
raise FunctionFailed('unable to load LPI mod {}: {}'.format(
lpi_mod_id, e))
lpi = lpi_mod.LPI(lpi_cfg=lpi_cfg, phi_id=phi_id)
if not lpi.ready:
raise FunctionFailed('unable to init LPI mod %s' % lpi_mod_id)
lpi.lpi_id = lpi_id
lpi.driver_id = phi_id + '.' + lpi_id
lpi.oid = 'driver:uc/%s/%s' % (eva.core.config.system_name, lpi.driver_id)
if lpi.driver_id in drivers:
try:
drivers[lpi.driver_id]._stop()
except:
eva.core.log_traceback()
drivers[lpi.driver_id] = lpi
if start:
try:
lpi._start()
except:
eva.core.log_traceback()
return lpi
def load_phi(phi_id, phi_mod_id, phi_cfg=None, start=True):
if not phi_id: raise InvalidParameter('PHI id not specified')
if not re.match("^[A-Za-z0-9_-]*$", phi_id):
raise InvalidParameter('PHI %s id contains forbidden symbols' % phi_id)
try:
phi_mod = importlib.import_module('eva.uc.drivers.phi.' + phi_mod_id)
# doesn't work but we hope
importlib.reload(phi_mod)
_api = phi_mod.__api__
_author = phi_mod.__author__
_version = phi_mod.__version__
_description = phi_mod.__description__
_license = phi_mod.__license__
_equipment = phi_mod.__equipment__
logging.info('PHI loaded %s v%s, author: %s, license: %s' %
(phi_mod_id, _version, _author, _license))
logging.debug('%s: %s' % (phi_mod_id, _description))
if _equipment == 'abstract':
logging.error(
'Unable to activate PHI %s: ' % phi_mod_id + \
'abstract module'
)
raise FunctionFailed('PHI module is abstract')
if _api > __api__:
logging.error(
'Unable to activate PHI %s: ' % phi_mod_id + \
'controller driver API version is %s, ' % __api__ + \
'PHI driver API version is %s' % _api)
raise FunctionFailed('unsupported driver API version')
except Exception as e:
raise FunctionFailed('unable to load PHI mod {}: {}'.format(
phi_mod_id, e))
phi = phi_mod.PHI(phi_cfg=phi_cfg)
if not phi.ready:
raise FunctionFailed('unable to init PHI mod %s' % phi_mod_id)
phi.phi_id = phi_id
phi.oid = 'phi:uc/%s/%s' % (eva.core.config.system_name, phi_id)
if phi_id in phis:
try:
phis[phi_id]._stop()
except:
eva.core.log_traceback()
phis[phi_id] = phi
if not phi_id in items_by_phi:
items_by_phi[phi_id] = set()
if start:
try:
phi._start()
except:
eva.core.log_traceback()
ld = phi.get_default_lpi()
if ld:
load_driver('default', ld, phi_id, start=True)
return phi
def load_ext(ext_id,
ext_mod_id,
cfg=None,
start=True,
rebuild=True,
config_validated=False,
_o=None,
set_modified=True):
if not ext_id:
raise InvalidParameter('ext id not specified')
if not re.match("^[A-Za-z0-9_-]*$", ext_id):
raise InvalidParameter('ext %s id contains forbidden symbols' % ext_id)
if _o is None:
# import module
try:
ext_mod = import_x(_get_ext_module_fname(ext_mod_id))
_api = ext_mod.__api__
_author = ext_mod.__author__
_version = ext_mod.__version__
_description = ext_mod.__description__
_license = ext_mod.__license__
_functions = ext_mod.__functions__
logging.info('Extension loaded %s v%s, author: %s, license: %s' %
(ext_mod_id, _version, _author, _license))
logging.debug('%s: %s' % (ext_mod_id, _description))
if _api > __api__:
logging.error(
'Unable to activate extension %s: ' % ext_mod_id + \
'controller extension API version is %s, ' % __api__ + \
'extension API version is %s' % _api)
raise FunctionFailed('unsupported ext API version')
except Exception as e:
raise FunctionFailed('unable to load ext mod {}: {}'.format(
ext_mod_id, e))
else:
ext_mod = _o.__xmod__
ext = ext_mod.LMExt(cfg=cfg,
config_validated=config_validated,
_xmod=ext_mod)
if not ext.ready:
raise FunctionFailed('unable to init ext mod %s' % ext_mod_id)
ext.ext_id = ext_id
if ext_id in exts:
exts[ext_id].stop()
exts[ext_id] = ext
if set_modified:
_d.modified.add(ext_id)
ext.load()
if start:
ext.start()
if rebuild:
rebuild_env()
return ext
def send(subject=None, text=None, rcp=None):
"""
send email message
The function uses *[mailer]* section of the :ref:`LM PLC
configuration<lm_ini>` to get sender address and list of the recipients (if
not specified).
Optional:
subject: email subject
text: email text
rcp: recipient or array of the recipients
Raises:
FunctionFailed: mail is not sent
"""
if subject is None: s = ''
else: s = subject
if text is None: t = s
else: t = text
if not rcp:
if not config.default_rcp:
raise FunctionFailed('Neither recipient nor default ' +
'recipient in config not specified')
else:
_rcp = config.default_rcp
else:
if isinstance(_rcp, str): _rcp = [rcp]
else: _rcp = rcp
try:
msg = MIMEText(t)
msg['Subject'] = s
msg['From'] = config.sender
if len(_rcp) == 1:
msg['To'] = _rcp[0]
sm = smtplib.SMTP(config.smtp_host, config.smtp_port)
sm.sendmail(config.sender, _rcp, msg.as_string())
logging.debug('sending mail to %s, subject "%s"' %
(', '.join(_rcp), s))
sm.quit()
return True
except Exception as e:
eva.core.log_traceback()
raise FunctionFailed(e)
def send(subject=None, text=None, rcp=None):
"""
send email message
The function uses config/common/mailer :doc:`registry</registry>` key get
sender address and list of the recipients (if not specified).
Optional:
subject: email subject
text: email text
rcp: recipient or array of the recipients
Raises:
FunctionFailed: mail is not sent
"""
if subject is None:
s = ''
else:
s = subject
if text is None:
t = s
else:
t = text
if not rcp:
if not config.default_rcp:
raise FunctionFailed('Neither recipient nor default ' +
'recipient in config not specified')
else:
_rcp = config.default_rcp
else:
_rcp = rcp
if isinstance(_rcp, list) and len(_rcp) == 1:
_rcp = _rcp[0]
try:
smtp = SMTP(host=config.smtp_host,
port=config.smtp_port,
tls=config.tls,
ssl=config.ssl,
login=config.login,
password=config.password)
logging.debug(f'sending mail to {_rcp}')
smtp.sendmail(config.sender, _rcp, subject=s, text=t)
return True
except Exception as e:
eva.core.log_traceback()
raise FunctionFailed(e)
def set(self, lvar_id, value=None):
"""
set lvar value
Args:
lvar_id: lvar id
Optional:
value: lvar value (if not specified, lvar is set to null)
Raises:
FunctionFailed: lvar value set error
ResourceNotFound: lvar is not found
"""
lvar = eva.lm.controller.get_lvar(lvar_id)
if not lvar:
raise ResourceNotFound
if value is None:
v = ''
else:
v = str(value)
result = lvar.update_set_state(value=v)
if not result:
raise FunctionFailed('lvar set error: %s, value = "%s"' % \
(lvar_id, v))
return True
def api_call(method, key_id=None, **kwargs):
"""
Call controller API method
Args:
key_id: API key ID. If key_id is None, masterkey is used
other: passed to API method as-is
Returns:
API function result
Raises:
eva.exceptions
"""
if not eva.api.jrpc:
raise FunctionFailed('API not initialized')
f = eva.api.jrpc._get_api_function(method)
if not f:
raise MethodNotFound
auth_bak = get_aci('auth')
set_aci('auth', 'key')
result = f(k=key_by_id(key_id) if key_id is not None else get_masterkey(),
**kwargs)
set_aci('auth', auth_bak)
if isinstance(result, tuple):
res, data = result
if res is True:
return data
elif res is False:
raise FunctionFailed
elif res is None:
raise ResourceNotFound
else:
return result
def remove_lm(controller_id):
if controller_id not in remote_lms:
raise ResourceNotFound
if not controller_lock.acquire(timeout=eva.core.config.timeout):
logging.critical('controller_lock locking broken')
eva.core.critical()
return
try:
i = remote_lms[controller_id]
i.destroy()
if (eva.core.config.db_update == 1
or eva.core.config.auto_save) and i.config_file_exists:
try:
eva.registry.key_delete(i.get_rkn())
except:
logging.error('Can not remove controller %s config' % \
controller_id)
eva.core.log_traceback()
elif i.config_file_exists:
configs_to_remove.add(i.get_rkn())
del (remote_lms[controller_id])
logging.info('controller lm/%s removed' % controller_id)
return True
except Exception as e:
eva.core.log_traceback()
raise FunctionFailed(e)
finally:
controller_lock.release()
def create_modbus_port(port_id, params, **kwargs):
"""Create new modbus port
Args:
port_id: port ID
params: port params (i.e. tcp:localhost:502, rtu:/dev/ttyS0:9600:8:N:1)
lock: should the port be locked, True/False (default: True)
timeout: port timeout (default: EVA timeout)
delay: delay between operations (default: 0.02 sec)
retries: retry attempts for port read/write operations (default: 0)
"""
try:
p = ModbusPort(port_id, params, **kwargs)
if not p.client:
raise FunctionFailed
except InvalidParameter:
raise
except:
raise FunctionFailed(
'Failed to create modbus port {}, params: {}'.format(
port_id, params))
else:
if port_id in ports:
ports[port_id].stop()
ports[port_id] = p
logging.info('created modbus port {} : {}'.format(port_id, params))
return True
def open_newest(self, mask, mode='r', alt=True):
"""
open newest file by mask
Args:
mask: path and mask (e.g. /opt/data/\*.jpg)
Optional:
mode: file open mode (default: 'r')
Returns:
file descriptor
Raises:
Exception: exceptions equal to Python "open" function
"""
try:
fls = [x for x in glob.glob(mask) if os.path.isfile(x)]
if not fls: return None
_f = max(fls, key=os.path.getmtime)
fls.remove(_f)
if fls: _f_alt = max(fls, key=os.path.getmtime)
else: _f_alt = None
try:
o = open(_f, mode)
except:
if not alt or not _f_alt: raise
o = open(_f_alt, mode)
return o
except:
raise FunctionFailed('file open error')
def remove_controller(controller_id):
_controller_id = oid_to_id(controller_id, 'remote_uc')
if not _controller_id: raise InvalidParameter('controller id not specified')
if _controller_id.find('/') != -1:
_controller_id = _controller_id.split('/')[-1]
if _controller_id not in remote_ucs:
raise ResourceNotFound
controller_lock.acquire()
try:
i = remote_ucs[_controller_id]
i.destroy()
if eva.core.config.db_update == 1 and i.config_file_exists:
try:
os.unlink(i.get_fname())
except:
logging.error('Can not remove controller %s config' % \
_controller_id)
eva.core.log_traceback()
elif i.config_file_exists:
configs_to_remove.add(i.get_fname())
del (remote_ucs[_controller_id])
logging.info('controller %s removed' % _controller_id)
return True
except Exception as e:
eva.core.log_traceback()
raise FunctionFailed(e)
finally:
controller_lock.release()
def toggle(self, item_id, wait=None, uuid=None, priority=None):
"""
toggle lvar value
Change lvar value to opposite boolean (0->1, 1->0)
Args:
lvar_id: lvar id
Raises:
FunctionFailed: lvar value set error
ResourceNotFound: lvar is not found
"""
if is_oid(item_id) and oid_type(item_id) == 'unit':
return self.action_toggle(unit_id=item_id,
wait=wait,
uuid=uuid,
priority=priority)
v = self.lvar_value(item_id)
if v is None:
raise FunctionFailed('lvar value is null')
if v:
return self.clear(item_id)
else:
return self.reset(item_id)
def create_owfs_bus(bus_id, location, **kwargs):
"""Create new owfs bus
Args:
bus_id: bus ID
location: bus location (e.g. --i2c=/dev/i2c-1:ALL or localhost:4302 for
owfs server)
lock: should bus be locked, True/False (default: True)
timeout: bus timeout (default: EVA timeout)
delay: delay between operations (default: 0.02 sec)
retries: retry attempts for bus read/write operations (default: 0)
"""
try:
if not bus_id or not re.match(eva.core.ID_ALLOWED_SYMBOLS, bus_id):
raise InvalidParameter('bus id')
bus = OWFSBus(bus_id, location, **kwargs)
if not bus._ow:
raise FunctionFailed
except InvalidParameter:
raise
except:
raise FunctionFailed(
'Failed to create owfs bus {}, location: {}'.format(
bus_id, location))
else:
if bus_id in owbus:
owbus[bus_id].stop()
owbus[bus_id] = bus
set_modified(bus_id)
logging.info('owfs bus {} : {}'.format(bus_id, location))
return True
def phi_discover(mod, interface, wait):
try:
return get_x_iobj(_get_phi_module_fname(mod),
'PHI').discover(interface, wait)
except AttributeError:
raise MethodNotImplemented
except Exception as e:
raise FunctionFailed(e)
def remove_controller(controller_id):
c = get_controller(controller_id)
if not c: raise ResourceNotFound
if c.item_type == 'remote_uc':
return remove_uc(c.item_id)
elif c.item_type == 'remote_lm':
return remove_lm(c.item_id)
else:
raise FunctionFailed('controller type unknown')
def rpvt(self, **kwargs):
k, f, ic, nocache = parse_function_params(kwargs,
['k', 'f', 'ic', 'nocache'],
'.S..')
if not eva.apikey.check(k, rpvt_uri=f):
logging.warning('rpvt uri %s access forbidden' % (f))
eva.core.log_traceback()
raise AccessDenied
try:
import requests
if f.find('//') == -1: _f = 'http://' + f
else: _f = f
r = requests.get(_f, timeout=eva.core.config.timeout)
except:
eva.core.log_traceback()
raise FunctionFailed('remote error')
if r.status_code != 200:
raise FunctionFailed('remote response %s' % r.status_code)
ctype = r.headers.get('Content-Type', 'text/html')
result = r.content
if ic:
try:
icmd, args, fmt = ic.split(':')
if icmd == 'resize':
x, y, q = args.split('x')
x = int(x)
y = int(y)
q = int(q)
from PIL import Image
from io import BytesIO
image = Image.open(BytesIO(result))
image.thumbnail((x, y))
result = image.tobytes(fmt, 'RGB', q)
ctype = 'image/' + fmt
else:
eva.core.log_traceback()
raise FunctionFailed('image processing failed')
except FunctionFailed:
eva.core.log_traceback()
raise
except:
eva.core.log_traceback()
raise FunctionFailed
return result, ctype
def modhelp(mod, context):
try:
result = serialize_x(_get_ext_module_fname(mod),
'LMExt',
helpinfo=context)
except Exception as e:
raise FunctionFailed(e)
if result is None:
raise ResourceNotFound('Help context')
return result
def finish_save():
if not config.exec_after_save: return True
logging.debug('executing after save command "%s"' % \
config.exec_after_save)
code = os.system(config.exec_after_save)
if code:
logging.error('after save command exited with code %u' % \
code)
raise FunctionFailed('exec_before_save failed')
return True
def destroy_data_puller(name):
try:
if datapullers[name].active:
raise FunctionFailed('Data puller is active')
except KeyError:
raise ResourceNotFound
del datapullers[name]
if eva.core.config.auto_save:
eva.registry.key_delete(f'config/uc/datapullers/{name}')
else:
dp_destroyed.add(name)
def modinfo(mod):
try:
result = serialize_x(_get_ext_module_fname(mod), 'LMExt', full=True)
if result:
try:
del result['id']
except:
pass
return result
except Exception as e:
raise FunctionFailed(e)
def regenerate_key(key_id, k=None, save=False):
if key_id is None or key_id not in keys_by_id:
raise ResourceNotFound
if keys_by_id[key_id].master or not keys_by_id[key_id].dynamic:
raise FunctionFailed('Master and static keys can not be changed')
key = keys_by_id[key_id]
old_key = key.key
key.set_key(gen_random_str() if k is None else k)
keys[key.key] = keys.pop(old_key)
key.set_modified(save)
return key.key
def put_phi_mod(mod, content, force=False):
if mod.find('/') != -1:
raise InvalidParameter('Invalid module file name')
if mod == 'generic_phi':
raise ResourceAlreadyExists('generic PHI can not be overriden')
fname = _get_phi_module_fname(mod)
if os.path.isfile(fname) and not force:
raise ResourceAlreadyExists('PHI module {}'.format(fname))
valid = False
try:
# verify code compilation
compile(content, fname, 'exec')
# save module code
try:
eva.core.prepare_save()
with open(fname, 'w') as fd:
fd.write(content)
eva.core.finish_save()
except Exception as e:
raise FunctionFailed('Unable to put PHI module {}: {}'.format(
fname, e))
# verify saved module
if 'mod' not in serialize_x(fname, 'PHI', full=True):
raise FunctionFailed('Unable to verify module')
valid = True
return True
except FunctionFailed:
raise
except:
raise FunctionFailed(
'Unable to check PHI module {}, invalid module code'.format(mod))
finally:
if not valid:
try:
eva.core.prepare_save()
os.unlink(fname)
eva.core.finish_save()
except:
logging.warning(
'Unable to delete invalid module {}'.format(fname))
eva.core.log_traceback()
def put_phi_mod(mod, content, force=False):
if mod.find('/') != -1: raise InvalidParameter('Invalid module file name')
if mod == 'generic_phi':
raise ResourceAlreadyExists('generic PHI can not be overriden')
fname = '{}/drivers/phi/{}.py'.format(eva.core.dir_xc, mod)
if os.path.isfile(fname) and not force:
raise ResourceAlreadyExists('PHI module {}'.format(fname))
valid = False
try:
compile(content, fname, 'exec')
try:
eva.core.prepare_save()
with open(fname, 'w') as fd:
fd.write(content)
eva.core.finish_save()
except Exception as e:
raise FunctionFailed('Unable to put PHI module {}: {}'.format(
fname, e))
d = {}
code = 'from eva.uc.drivers.phi.%s import PHI;' % mod + \
' s=PHI(info_only=True).serialize(full=True)'
exec(code, d)
if 's' not in d or 'mod' not in d['s']:
raise FunctionFailed('Unable to verify module')
valid = True
return True
except FunctionFailed:
raise
except:
raise FunctionFailed(
'Unable to check PHI module {}, invalid module code'.format(mod))
finally:
if not valid:
try:
eva.core.prepare_save()
os.unlink(fname)
eva.core.finish_save()
except:
logging.warning(
'Unable to delete invalid module {}'.format(fname))
eva.core.log_traceback()
def schedule(self):
self.every = ''
if not self.every_set:
self.unschedule()
return
x = re.split('[\ \t]+', self.every_set)
if not x:
self.unschedule()
return
try:
x[0] = int(x[0])
except:
x = [1] + x
interval = x[0]
period = x[1].lower()
err = 'Invalid schedule: {}'.format(self.every_set)
if period not in [
'second', 'seconds', 'minute', 'minutes', 'hour', 'hours',
'day', 'days', 'week', 'weeks', 'monday', 'tuesday',
'wednesday', 'thursday', 'friday', 'saturday', 'sunday'
]:
self.unschedule()
raise FunctionFailed(err)
job = schedule.every(interval)
job.tag(self.item_id)
getattr(job, period)
if len(x) > 2:
if x[2].lower() != 'at' or len(x) != 4:
self.unschedule()
raise FunctionFailed(err)
try:
job.at(x[3])
except:
self.unschedule()
raise FunctionFailed(err)
at_interval = ' at {}'.format(x[3])
else:
at_interval = ''
job.do(self.perform)
self.every = '{} {}'.format(interval, period) + at_interval
return True
def load_ext(ext_id, ext_mod_id, cfg=None, start=True, rebuild=True):
if not ext_id: raise InvalidParameter('ext id not specified')
if not re.match("^[A-Za-z0-9_-]*$", ext_id):
raise InvalidParameter('ext %s id contains forbidden symbols' % ext_id)
try:
ext_mod = importlib.import_module('eva.lm.extensions.' + ext_mod_id)
importlib.reload(ext_mod)
_api = ext_mod.__api__
_author = ext_mod.__author__
_version = ext_mod.__version__
_description = ext_mod.__description__
_license = ext_mod.__license__
_functions = ext_mod.__functions__
logging.info('Extension loaded %s v%s, author: %s, license: %s' %
(ext_mod_id, _version, _author, _license))
logging.debug('%s: %s' % (ext_mod_id, _description))
if not _functions:
logging.error(
'Unable to activate extension %s: ' % ext_mod_id + \
'does not provide any functions'
)
raise FunctionFailed('ext module does not provide any functions')
if _api > __api__:
logging.error(
'Unable to activate extension %s: ' % ext_mod_id + \
'controller extension API version is %s, ' % __api__ + \
'extension API version is %s' % _api)
raise FunctionFailed('unsupported ext API version')
except Exception as e:
raise FunctionFailed('unable to load ext mod {}: {}'.format(
ext_mod_id, e))
ext = ext_mod.LMExt(cfg=cfg)
if not ext.ready:
raise FunctionFailed('unable to init ext mod %s' % ext_mod_id)
ext.ext_id = ext_id
if ext_id in exts:
exts[ext_id].stop()
exts[ext_id] = ext
if start: ext.start()
if rebuild: rebuild_env()
return ext
def modhelp_phi(mod, context):
code = 'from eva.uc.drivers.phi.%s import PHI;' % mod + \
' s=PHI(info_only=True).serialize(helpinfo=\'%s\')' % context
try:
d = {}
exec(code, d)
result = d.get('s')
except Exception as e:
raise FunctionFailed(e)
if result is None:
raise ResourceNotFound('Help context not found')
return result
def phi_discover(mod, interface, wait):
code = 'from eva.uc.drivers.phi.{} import PHI;'.format(mod) + \
' s=PHI(info_only=True).discover(interface, {})'.format(wait)
try:
d = {'interface': interface}
exec(code, d)
result = d.get('s')
return result
except AttributeError:
raise MethodNotImplemented
except Exception as e:
raise FunctionFailed(e)
def modhelp(mod, context):
code = 'from eva.lm.extensions.%s import LMExt;' % mod + \
' s=LMExt(info_only=True).serialize(helpinfo=\'%s\')' % context
try:
d = {}
exec(code, d)
result = d.get('s')
except Exception as e:
raise FunctionFailed(e)
if result is None:
raise ResourceNotFound('Help context not found')
return result