def get_attribute_values(self, attrs):
"""
"""
log.debug("get_attribute_values: attrs=%s", attrs)
if not isinstance(attrs, (list, tuple)):
raise PlatformException(
'get_attribute_values: attrs argument must be a '
'list [(attrName, from_time), ...]. Given: %s', attrs)
# convert the ION system time from_time to NTP, as this is the time
# format used by the RSN OMS interface:
attrs_ntp = [(attr_id, ion_ts_2_ntp(from_time))
for (attr_id, from_time) in attrs]
try:
retval = self._rsn_oms.attr.get_platform_attribute_values(
self._platform_id, attrs_ntp)
except Exception as e:
raise PlatformConnectionException(
msg="Cannot get_platform_attribute_values: %s" % str(e))
if not self._platform_id in retval:
raise PlatformException("Unexpected: response does not include "
"requested platform '%s'" %
self._platform_id)
attr_values = retval[self._platform_id]
# reported timestamps are already in NTP. Just return the dict:
return attr_values
def _verify_platform_id_in_response(self, response):
"""
Verifies the presence of my platform_id in the response.
@param response Dictionary returned by _rsn_oms
@retval response[self._platform_id]
"""
if not self._platform_id in response:
msg = "unexpected: response does not contain entry for %r" % self._platform_id
log.error(msg)
raise PlatformException(msg=msg)
if response[self._platform_id] == InvalidResponse.PLATFORM_ID:
msg = "response reports invalid platform_id for %r" % self._platform_id
log.error(msg)
raise PlatformException(msg=msg)
else:
return response[self._platform_id]
def _verify_port_id_in_response(self, port_id, dic):
"""
Verifies the presence of port_id in the dic.
@param port_id The ID to verify
@param dic Dictionary returned by _rsn_oms
@return dic[port_id]
"""
if not port_id in dic:
msg = "unexpected: dic does not contain entry for %r" % port_id
log.error(msg)
raise PlatformException(msg=msg)
if dic[port_id] == InvalidResponse.PORT_ID:
msg = "%r: response reports invalid port_id for %r" % (
self._platform_id, port_id)
log.error(msg)
raise PlatformException(msg=msg)
else:
return dic[port_id]
def set_attribute_values(self, attrs):
"""
"""
log.debug("set_attribute_values: attrs = %s", attrs)
self._assert_rsn_oms()
error_vals = self._validate_set_attribute_values(attrs)
if len(error_vals) > 0:
# remove offending attributes for the request below
attrs_dict = dict(attrs)
for bad_attr_name in error_vals:
del attrs_dict[bad_attr_name]
# no good attributes at all?
if len(attrs_dict) == 0:
# just immediately return with the errors:
return error_vals
# else: update attrs with the good attributes:
attrs = attrs_dict.items()
# ok, now make the request to RSN OMS:
try:
retval = self._rsn_oms.attr.set_platform_attribute_values(self._platform_id,
attrs)
except Exception as e:
raise PlatformConnectionException(msg="Cannot set_platform_attribute_values: %s" % str(e))
log.debug("set_platform_attribute_values = %s", retval)
if not self._platform_id in retval:
raise PlatformException("Unexpected: response does not include "
"requested platform '%s'" % self._platform_id)
attr_values = retval[self._platform_id]
# Note that the reported timestamps are in NTP.
# (Timestamps indicate the time when the value was set for each attribute.)
# ret_attr_values: dictionary to return, initialized with the error ones
# determined above, if any:
ret_attr_values = error_vals
# add the info returned from RSN OMS:
for attr_name, attr_val_ts in attr_values.iteritems():
ret_attr_values[attr_name] = attr_val_ts
log.debug("set_attribute_values: returning %s", ret_attr_values)
return ret_attr_values
def get_metadata(self):
"""
"""
self._assert_rsn_oms()
retval = self._rsn_oms.get_platform_metadata(self._platform_id)
log.debug("get_platform_metadata = %s", retval)
if not self._platform_id in retval:
raise PlatformException("Unexpected: response does not include "
"requested platform '%s'" %
self._platform_id)
md = retval[self._platform_id]
return md
def _do_launch_gate(self, platform_id, agent_config, timeout_spawn):
"""
The method for when using the ProcessStateGate pattern, which is the
one used by test_oms_launch2 to launch the root platform.
"""
log.debug("_do_launch_gate: platform_id=%r, timeout_spawn=%s",
platform_id, timeout_spawn)
pa_name = 'PlatformAgent_%s' % platform_id
pdef = ProcessDefinition(name=pa_name)
pdef.executable = {'module': PA_MOD, 'class': PA_CLS}
pdef_id = self._pd_client.create_process_definition(
process_definition=pdef)
log.debug("using schedule_process directly %r", platform_id)
pid = self._pd_client.schedule_process(process_definition_id=pdef_id,
schedule=None,
configuration=agent_config)
if timeout_spawn:
# ProcessStateGate used as indicated in its pydoc (9/21/12)
gate = ProcessStateGate(self._pd_client.read_process, pid,
ProcessStateEnum.RUNNING)
err_msg = None
try:
if not gate. await (timeout_spawn):
err_msg = "The platform agent instance did not spawn in " \
"%s seconds. gate.wait returned false. " % \
timeout_spawn
log.error(err_msg)
except Exception as e:
log.error(
"Exception while waiting for platform agent instance "
"(platform_id=%r) "
"to spawn in %s seconds: %s", platform_id, timeout_spawn,
str(e)) #,exc_Info=True)
if err_msg:
raise PlatformException(err_msg)
log.debug(
"_do_launch_gate: platform_id=%r: agent spawned, pid=%r "
"(ProcessStateGate pattern used)", platform_id, pid)
return pid
def _verify_instrument_id_in_response(self, port_id, instrument_id, dic):
"""
Verifies the presence of instrument_id in the dic.
@param port_id Used for error reporting
@param instrument_id The ID to verify
@param dic Dictionary returned by _rsn_oms
@return dic[instrument_id]
"""
if not instrument_id in dic:
msg = "unexpected: dic does not contain entry for %r" % instrument_id
log.error(msg)
raise PlatformException(msg=msg)
return dic[instrument_id]
def get_metadata(self):
"""
"""
self._assert_rsn_oms()
try:
retval = self._rsn_oms.config.get_platform_metadata(self._platform_id)
except Exception as e:
raise PlatformConnectionException(msg="Cannot get_platform_metadata: %s" % str(e))
log.debug("get_platform_metadata = %s", retval)
if not self._platform_id in retval:
raise PlatformException("Unexpected: response does not include "
"requested platform '%s'" % self._platform_id)
md = retval[self._platform_id]
return md
def get_attribute_values(self, attr_names, from_time):
"""
"""
if log.isEnabledFor(logging.DEBUG):
log.debug("get_attribute_values: attr_names=%s from_time=%s" %
(str(attr_names), from_time))
self._assert_rsn_oms()
# convert the ION system time from_time to NTP, as this is the time
# format used by the RSN OMS interface:
ntp_from_time = ion_ts_2_ntp(from_time)
retval = self._rsn_oms.get_platform_attribute_values(
self._platform_id, attr_names, ntp_from_time)
if not self._platform_id in retval:
raise PlatformException("Unexpected: response does not include "
"requested platform '%s'" %
self._platform_id)
attr_values = retval[self._platform_id]
# reported timestamps are already in NTP. Just return the dict:
return attr_values
def _got_device_aggregate_status_event(self, evt, *args, **kwargs):
"""
Reacts to a DeviceAggregateStatusEvent from a platform's child.
- notifies platform that child is running in case of any needed revalidation
- updates the local image of the child status for the corresponding status name
- updates the rollup status for that status name
- if this rollup status changes, then a subsequent DeviceAggregateStatusEvent
is published.
The consolidation operation is taken from observatory_util.py.
@param evt DeviceAggregateStatusEvent from child.
"""
with self._lock:
if not self._active:
log.warn(
"%r: _got_device_aggregate_status_event called but "
"manager has been destroyed", self._platform_id)
return
log.debug("%r: _got_device_aggregate_status_event: %s",
self._platform_id, evt)
if evt.type_ != "DeviceAggregateStatusEvent":
# should not happen.
msg = "%r: Got event for different event_type=%r but subscribed to %r" % (
self._platform_id, evt.type_, "DeviceAggregateStatusEvent")
log.error(msg)
raise PlatformException(msg)
if evt.origin not in self.aparam_child_agg_status:
# should not happen.
msg = "%r: got event from unrecognized origin=%s" % (
self._platform_id, evt.origin)
log.error(msg)
raise PlatformException(msg)
status_name = evt.status_name
child_origin = evt.origin
child_status = evt.status
# tell platform this child is running in case of any needed revalidation:
self._agent._child_running(child_origin)
with self._lock:
old_status = self.aparam_child_agg_status[child_origin][
status_name]
if child_status == old_status:
#
# My image of the child status is not changing, so nothing to do:
#
return
# update the specific status
self.aparam_child_agg_status[child_origin][
status_name] = child_status
new_rollup_status = self._update_rollup_status_and_publish(
status_name, child_origin)
if new_rollup_status and log.isEnabledFor(
logging.TRACE): # pragma: no cover
self._log_agg_status_update(log.trace, evt, new_rollup_status)
