def test_accuracy_2():
"""
:return: true | false
"""
x = ocs_id(False)
y = ocs_mjd_to_iso(x)
z = ocs_iso_to_mjd(y)
conversion_error = float(x) - float(z)
assert conversion_error == 0.0
def test_accuracy_1():
"""
:return: true | false
"""
x = ocs_id(True)
y = ocs_iso_to_mjd(x)
z = ocs_mjd_to_iso(y)
conversion_error = float(y) - float(ocs_iso_to_mjd(z))
assert conversion_error == 0.0
def __del__(self):
# issue an ocsEntityShutdown event
if self._instance_evp:
self._ocsid = ocs_id(False)
self._instance_evp.send_event('ocsEntityShutdown',
Name=self._instance_name,
Identifier=float(self._ocsid),
Timestamp=ocs_mjd_to_iso(
self._ocsid),
Address=id(self),
priority=SAL__EVENT_INFO)
def _get_cmd_status(self, command='', seqnum=-1, retval=-1):
# check known SAL status values
if retval == SAL__CMD_ACK:
self._status = '{0:s} ({1:d}) acknowledged'.format(command, seqnum)
self.logger.info(self._status)
elif retval == SAL__CMD_INPROGRESS:
self._status = '{0:s} ({1:d}) in progress'.format(command, seqnum)
self.logger.info(self._status)
elif retval == SAL__CMD_STALLED:
self._status = '{0:s} ({1:d}) stalled'.format(command, seqnum)
self.logger.info(self._status)
elif retval == SAL__CMD_COMPLETE:
self._status = '{0:s} ({1:d}) complete'.format(command, seqnum)
self.logger.info(self._status)
elif retval == SAL__CMD_NOPERM:
self._status = '{0:s} ({1:d}) no permission'.format(
command, seqnum)
self.logger.info(self._status)
elif retval == SAL__CMD_NOACK:
self._status = '{0:s} ({1:d}) no acknowledgement'.format(
command, seqnum)
self.logger.info(self._status)
elif retval == SAL__CMD_FAILED:
self._status = '{0:s} ({1:d}) failed'.format(command, seqnum)
self.logger.info(self._status)
elif retval == SAL__CMD_ABORTED:
self._status = '{0:s} ({1:d}) aborted'.format(command, seqnum)
self.logger.info(self._status)
elif retval == SAL__CMD_TIMEOUT:
self._status = '{0:s} ({1:d}) timed out'.format(command, seqnum)
self.logger.info(self._status)
else:
self._status = '{0:s} ({1:d}) unknown error'.format(
command, seqnum)
self.logger.critical(self._status)
# issue an ocsCommandStatus event
if self._instance_evp:
self._ocsid = ocs_id(False)
self._instance_evp.send_event('ocsCommandStatus',
CommandSource=self._instance_name,
SequenceNumber=int(seqnum),
Identifier=float(self._ocsid),
Timestamp=ocs_mjd_to_iso(
self._ocsid),
CommandSent=command,
Status=self._status,
StatusValue=int(retval),
priority=SAL__EVENT_INFO)
def test_send_event():
try:
ev = OcsEvents(False)
except OcsEventsException as a:
print(a.errstr)
assert False
if ev is not None:
ocsid2 = ocs_id(False)
ev.send_event('ocsEntityStartup',
Name='Test',
Identifier=float(ocsid2),
Timestamp=ocs_mjd_to_iso(ocsid2),
Address=id(ev),
priority=SAL__EVENT_INFO)
assert True
def test_mjd_to_iso():
"""
:return: true | false
"""
mjd = ocs_id(False)
assert mjd == ocs_iso_to_mjd(ocs_mjd_to_iso(mjd))
def test_iso_to_mjd():
"""
:return: true | false
"""
iso = ocs_id(True)
assert iso == ocs_mjd_to_iso(ocs_iso_to_mjd(iso))
def stop(self, device='', timeout=OCS_GENERIC_COMMAND_TIMEOUT):
self.logger.debug('stop() enter, device={0:s}, timeout={1:s}'.format(
device, str(timeout)))
# check input(s)
if not isinstance(device, str) or device == '':
raise OcsGenericEntityException(OCS_GENERIC_ENTITY_ERROR_NODEV,
'device={0:s}'.format(device))
else:
self._device = device
if not isinstance(timeout, int) or timeout < 0:
raise OcsGenericEntityException(
OCS_GENERIC_ENTITY_ERROR_NOTIM,
'timeout={0:s}'.format(str(timeout)))
else:
self._timeout = timeout
# in simulation, sleep for a random time
if self._simulate:
stime = random.uniform(0, 5)
self.logger.info('stop(), in simulation with sleep={0:s}'.format(
str(stime)))
time.sleep(stime)
# send command
else:
if self.__mgr and self.__stopC:
self._cname = '{0:s}_command_stop'.format(self._entity_lc)
self._ename = '{0:s}_command_stop device={1:s} timeout={2:d}'.format(
self._entity_lc, self._device, self._timeout)
# set up command (cf. mgr.salCommand('camera_command_stop'))
self.logger.debug('setting up: {0:s}'.format(self._ename))
self.__mgr.salCommand(self._cname)
# set up payload (cf. data = camera_command_stopC(); data.state = 'ok')
# self.__stopC.state = '{0:d}-{1:d}'.format(os.getenv('USER'), os.getpid())
self.__stopC.state = int(os.getpid())
# issue command (cf. id = mgr.issueCommand_stop(data))
self.logger.debug('issuing: {0:s}'.format(self._ename))
self.__stop_id = self.__mgr.issueCommand_stop(self.__stopC)
self.logger.debug('issued: {0:s}, id={1:d}'.format(
self._ename, self.__stop_id))
# issue an ocsCommandIssued event
if self._instance_evp:
self._ocsid = ocs_id(False)
self._instance_evp.send_event(
'ocsCommandIssued',
CommandSource=self._instance_name,
SequenceNumber=int(self.__stop_id),
Identifier=float(self._ocsid),
Timestamp=ocs_mjd_to_iso(self._ocsid),
CommandSent=self._ename,
ReturnValue=int(SAL__CMD_ACK),
priority=SAL__EVENT_INFO)
# wait for command (cf. retval = mgr.waitForCompletion_stop(id, timeout))
if self._timeout > 0:
self.logger.debug('waiting for: {0:s}'.format(self._ename))
self.__stop_retval = self.__mgr.waitForCompletion_stop(
self.__stop_id, self._timeout)
self.logger.debug('waited for: {0:s}, retval={1:d}'.format(
self._ename, self.__stop_retval))
self._get_cmd_status(self._ename, self.__stop_id,
self.__stop_retval)
self.logger.debug('stop() exit')
def __init__(self, system='', entity='', simulate=True):
"""
:param system: name of system
:param entity: name of entity
:param simulate: if True, use simulation
:return: None or object representing the entity
"""
# get arguments(s)
self._system = system
self._system_lc = self._system.lower()
self._entity = entity
self._entity_lc = self._entity.lower()
self._simulate = simulate
# check input: system
self._system = ocsGenericEntitySystemDictionary.get(
self._system_lc, '')
if self._system == '':
raise OcsGenericEntityException(OCS_GENERIC_ENTITY_ERROR_NOSYS,
'{0:s}'.format(system))
# check input: entity
self._entity = ''.join(
xi
for xi in ocsGenericEntityEntityDictionary.get(self._system, [])
if xi.lower() == self._entity_lc)
if self._entity == '':
raise OcsGenericEntityException(OCS_GENERIC_ENTITY_ERROR_NOENT,
'{0:s}'.format(entity))
# check input: simulate
if not isinstance(self._simulate, bool):
self._simulate = True
# set up logging
self.logger = OcsLogger(self._system, self._entity).logger
self.logger.info('Starting {0:s} {1:s} commandable entity'.format(
self._system, self._entity))
# set up event publication
self._ocsid = ocs_id(False)
self._instance_evp = OcsEvents(False)
self._instance_name = '{0:1}-{1:s}-{2:.17f}'.format(
self._system, self._entity, float(self._ocsid))
# issue an ocsEntityStartup event
if self._instance_evp:
self._instance_evp.send_event('ocsEntityStartup',
Name=self._instance_name,
Identifier=float(self._ocsid),
Timestamp=ocs_mjd_to_iso(
self._ocsid),
Address=id(self),
priority=SAL__EVENT_INFO)
# declare some variables and initialize them
self.logger.debug('Initializing variables')
self.__sal = None
self.__mgr = None
# container(s)
self.__abortC = None
self.__disableC = None
self.__enableC = None
self.__entercontrolC = None
self.__exitcontrolC = None
self.__setvalueC = None
self.__standbyC = None
self.__startC = None
self.__stopC = None
# ToBeEnabled: self.__ackcmdC = None
# command id(s)
self.__abort_id = None
self.__disable_id = None
self.__enable_id = None
self.__entercontrol_id = None
self.__exitcontrol_id = None
self.__setvalue_id = None
self.__standby_id = None
self.__start_id = None
self.__stop_id = None
# return value(s)
self.__abort_retval = None
self.__disable_retval = None
self.__enable_retval = None
self.__entercontrol_retval = None
self.__exitcontrol_retval = None
self.__setvalue_retval = None
self.__standby_retval = None
self.__start_retval = None
self.__stop_retval = None
# other variable(s)
self._aname = None
self._cname = None
self._device = None
self._ename = None
self._mname = None
self._ocsid = None
self._parameter = None
self._startid = None
self._timeout = None
self._value = None
# import the SAL component (cf. from SALPY_camera import *)
self._mname = 'SALPY_{0:s}'.format(self._entity_lc)
self.logger.debug('Importing {0:s}'.format(self._mname))
self.__sal = ocs_sal_import(self._mname)
if self.__sal:
self.logger.debug('Imported {0:s} ok'.format(self._mname))
# get mgr object (cf. mgr = SAL_camera())
self._aname = 'SAL_{0:s}'.format(self._entity_lc)
self.logger.debug('Getting attribute {0:s}'.format(self._aname))
mgr = ocs_sal_attribute(self.__sal, self._aname)
if mgr:
self.__mgr = mgr()
self.logger.debug('Got attribute {0:s} ok'.format(self._aname))
# get data structure(s) (cf. data = camera_command_abortC())
self.__abortC = self._get_sal_cmd_container('abort')
self.__disableC = self._get_sal_cmd_container('disable')
self.__enableC = self._get_sal_cmd_container('enable')
self.__entercontrolC = self._get_sal_cmd_container('enterControl')
self.__exitcontrolC = self._get_sal_cmd_container('exitControl')
# ToBeEnabled: self.__setvalueC = self._get_sal_cmdC('setValue')
self.__standbyC = self._get_sal_cmd_container('standby')
self.__startC = self._get_sal_cmd_container('start')
self.__stopC = self._get_sal_cmd_container('stop')
# get data structure(s) (cf. ack = camera_ackcmdC())
# ToBeEnabled: self.__ackcmdC = self._get_sal_ackC()
# define generic command(s) help
self.generic_help = (
'abort system={0:s} entity={1:s}'.format(
self._system,
self._entity), 'disable system={0:s} entity={1:s}'.format(
self._system, self._entity),
'enable system={0:s} entity={1:s}'.format(
self._system,
self._entity), 'entercontrol system={0:s} entity={1:s}'.format(
self._system, self._entity),
'exitcontrol system={0:s} entity={1:s}'.format(
self._system, self._entity),
'setvalue system={0:s} entity={1:s} parameter=<string> value=<string>'
.format(self._system, self._entity),
'standby system={0:s} entity={1:s}'.format(
self._system, self._entity),
'start system={0:s} entity={1:s} startid=<string>'.format(
self._system, self._entity),
'stop system={0:s} entity={1:s} device=<string>'.format(
self._system, self._entity))
# set up a default commander (cf. mgr.salCommand('camera_command_abort'))
self._cname = '{0:s}_command_abort'.format(self._entity_lc)
if self.__mgr:
self.__mgr.salCommand(self._cname)
# log message on exit
self.logger.info(
'Started {0:s} {1:s} commandable entity at address {2:s}'.format(
self._system, self._entity, str(hex(id(self)))))
def setvalue(self,
parameter='',
value='',
timeout=OCS_GENERIC_COMMAND_TIMEOUT):
# entry message
self.logger.debug(
'{0:s}.setvalue() enter, parameter={1:s}, value={2:s}, timeout={3:s}'
.format(self._entity_lc, parameter, value, str(timeout)))
# check input(s)
if not isinstance(parameter, str) or parameter == '':
raise OcsGenericEntityException(
OCS_GENERIC_ENTITY_ERROR_NOPAR,
'parameter={0:s}'.format(parameter))
else:
self._parameter = parameter
if not isinstance(value, str) or value == '':
raise OcsGenericEntityException(OCS_GENERIC_ENTITY_ERROR_NOTIM,
'value={0:s}'.format(value))
else:
self._value = value
if not isinstance(timeout, int) or timeout < 0:
raise OcsGenericEntityException(
OCS_GENERIC_ENTITY_ERROR_NOTIM,
'timeout={0:s}'.format(str(timeout)))
else:
self._timeout = timeout
# in simulation, sleep for a random time
if self._simulate:
stime = random.uniform(0, 5)
self.logger.info(
'{0:s}.setvalue(), in simulation with sleep={1:s}'.format(
self._entity_lc, str(stime)))
time.sleep(stime)
# send command
else:
if self.__mgr and self.__setvalueC:
self._cname = '{0:s}_command_setValue'.format(self._entity_lc)
self._ename = '{0:s}_command_setValue parameter={1:s} value={2:s} timeout={3:d}'.format(
self._entity_lc, self._parameter, self._value,
self._timeout)
# set up command (cf. mgr.salCommand('camera_command_setValue'))
self.logger.debug('setting up: {0:s}'.format(self._ename))
self.__mgr.salCommand(self._cname)
# set up payload (cf. data = camera_command_setValueC(); data.parameter = 'myPar'; data.value = 'myVal')
self.__setvalueC.parameter = self._parameter
self.__setvalueC.value = self._value
# issue command (cf. id = mgr.issueCommand_setValue(data))
self.logger.debug('issuing: {0:s}'.format(self._ename))
self.__setvalue_id = self.__mgr.issueCommand_setValue(
self.__setvalueC)
self.logger.debug('issued: {0:s}, id={1:d}'.format(
self._ename, self.__setvalue_id))
# issue an ocsCommandIssued event
if self._instance_evp:
self._ocsid = ocs_id(False)
self._instance_evp.send_event(
'ocsCommandIssued',
CommandSource=self._instance_name,
SequenceNumber=int(self.__setvalue_id),
Identifier=float(self._ocsid),
Timestamp=ocs_mjd_to_iso(self._ocsid),
CommandSent=self._ename,
ReturnValue=int(SAL__CMD_ACK),
priority=SAL__EVENT_INFO)
# wait for command (cf. retval = mgr.waitForCompletion_setValue(id, timeout))
if self._timeout > 0:
self.logger.debug('waiting for: {0:s}'.format(self._ename))
self.__setvalue_retval = self.__mgr.waitForCompletion_setValue(
self.__setvalue_id, self._timeout)
self.logger.debug('waited for: {0:s}, retval={1:d}'.format(
self._ename, self.__setvalue_retval))
self._get_cmd_status(self._ename, self.__setvalue_id,
self.__setvalue_retval)
# exit message
self.logger.debug('{0:s}.setvalue() exit'.format(self._entity_lc))