def set_calibrators(self, parameter, calibrators): """ Apply an ordered set of calibrators for the specified parameter. This replaces existing calibrators (if any). Each calibrator may have a context, which indicates when it its effects may be applied. Only the first matching calibrator is applied. A calibrator with context ``None`` is the *default* calibrator. There can be only one such calibrator, and is always applied at the end when no other contextual calibrator was applicable. :param str parameter: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. :param .Calibrator[] calibrators: List of calibrators (either contextual or not) """ req = mdb_pb2.UpdateParameterRequest() req.action = mdb_pb2.UpdateParameterRequest.SET_CALIBRATORS for c in calibrators: if c.context: context_calib = req.contextCalibrator.add() context_calib.context = c.context calib_info = context_calib.calibrator else: calib_info = req.defaultCalibrator _add_calib(calib_info, c.type, c.data) parameter = adapt_name_for_rest(parameter) url = "/mdb/{}/{}/parameters{}".format( self._instance, self._processor, parameter ) self.ctx.patch_proto(url, data=req.SerializeToString())
def issue_command(self, command, args=None, dry_run=False, comment=None): """ Issue the given command :param str command: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. :param dict args: named arguments (if the command requires these) :param bool dry_run: If ``True`` the command is not actually issued. This can be used to check if the server would generate errors when preparing the command (for example because an argument is missing). :param str comment: Comment attached to the command. :return: An object providing access to properties of the newly issued command. :rtype: .IssuedCommand """ req = rest_pb2.IssueCommandRequest() req.sequenceNumber = SequenceGenerator.next() req.origin = socket.gethostname() req.dryRun = dry_run if comment: req.comment = comment if args: for key in args: assignment = req.assignment.add() assignment.name = key assignment.value = str(args[key]) command = adapt_name_for_rest(command) url = '/processors/{}/{}/commands{}'.format(self._instance, self._processor, command) response = self._client.post_proto(url, data=req.SerializeToString()) proto = rest_pb2.IssueCommandResponse() proto.ParseFromString(response.content) return IssuedCommand(proto, self)
def get_parameter_value(self, parameter, from_cache=True, timeout=10): """ Retrieve the current value of the specified parameter. :param str parameter: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. :param bool from_cache: If ``False`` this call will block until a fresh value is received on the processor. If ``True`` the server returns the latest value instead (which may be ``None``). :param float timeout: The amount of seconds to wait for a fresh value. (ignored if ``from_cache=True``). :rtype: .ParameterValue """ params = { "fromCache": from_cache, "timeout": int(timeout * 1000), } parameter = adapt_name_for_rest(parameter) url = "/processors/{}/{}/parameters{}".format( self._instance, self._processor, parameter ) response = self.ctx.get_proto(url, params=params) proto = pvalue_pb2.ParameterValue() proto.ParseFromString(response.content) # Server returns ParameterValue with only 'id' set if no # value existed. Convert this to ``None``. if proto.HasField("rawValue") or proto.HasField("engValue"): return ParameterValue(proto) return None
def reset_alarm_ranges(self, parameter): """ Reset all alarm limits for the specified parameter to their original MDB value. """ req = mdb_override_service_pb2.UpdateParameterRequest() req.action = mdb_override_service_pb2.UpdateParameterRequest.RESET_ALARMS parameter = adapt_name_for_rest(parameter) url = f"/mdb/{self._instance}/{self._processor}/parameters{parameter}" self.ctx.patch_proto(url, data=req.SerializeToString())
def set_default_alarm_ranges( self, parameter, watch=None, warning=None, distress=None, critical=None, severe=None, min_violations=1, ): """ Generate out-of-limit alarms for a parameter using the specified alarm ranges. This replaces any previous default alarms on this parameter. .. note:: Contextual range sets take precedence over the default alarm ranges. See :meth:`set_alarm_range_sets` for setting contextual range sets. :param str parameter: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. :param (float,float) watch: Range expressed as a tuple ``(lo, hi)`` where lo and hi are assumed exclusive. :param (float,float) warning: Range expressed as a tuple ``(lo, hi)`` where lo and hi are assumed exclusive. :param (float,float) distress: Range expressed as a tuple ``(lo, hi)`` where lo and hi are assumed exclusive. :param (float,float) critical: Range expressed as a tuple ``(lo, hi)`` where lo and hi are assumed exclusive. :param (float,float) severe: Range expressed as a tuple ``(lo, hi)`` where lo and hi are assumed exclusive. :param int min_violations: Minimum violations before an alarm is generated. """ req = mdb_pb2.UpdateParameterRequest() req.action = mdb_pb2.UpdateParameterRequest.SET_DEFAULT_ALARMS if watch or warning or distress or critical or severe: _add_alarms( req.defaultAlarm, watch, warning, distress, critical, severe, min_violations, ) parameter = adapt_name_for_rest(parameter) url = "/mdb/{}/{}/parameters{}".format( self._instance, self._processor, parameter ) self.ctx.patch_proto(url, data=req.SerializeToString())
def reset_alarm_ranges(self, parameter): """ Reset all alarm limits for the specified parameter to their original MDB value. """ req = mdb_pb2.ChangeParameterRequest() req.action = mdb_pb2.ChangeParameterRequest.RESET_ALARMS parameter = adapt_name_for_rest(parameter) url = '/mdb/{}/{}/parameters{}'.format(self._instance, self._processor, parameter) self._client.post_proto(url, data=req.SerializeToString())
def reset_calibrators(self, parameter): """ Reset all calibrators for the specified parameter to their original MDB value. """ req = mdb_pb2.UpdateParameterRequest() req.action = mdb_pb2.UpdateParameterRequest.RESET_CALIBRATORS parameter = adapt_name_for_rest(parameter) url = "/mdb/{}/{}/parameters{}".format( self._instance, self._processor, parameter ) self.ctx.patch_proto(url, data=req.SerializeToString())
def set_parameter_value(self, parameter, value): """ Sets the value of the specified parameter. :param str parameter: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. :param value: The value to set """ parameter = adapt_name_for_rest(parameter) url = '/processors/{}/{}/parameters{}'.format( self._instance, self._processor, parameter) req = _build_value_proto(value) self._client.put_proto(url, data=req.SerializeToString())
def reset_algorithm(self, parameter): """ Reset the algorithm text to its original definition from MDB :param str parameter: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. """ req = mdb_override_service_pb2.UpdateAlgorithmRequest() req.action = mdb_override_service_pb2.UpdateAlgorithmRequest.RESET parameter = adapt_name_for_rest(parameter) url = f"/mdb/{self._instance}/{self._processor}/algorithms{parameter}" self.ctx.patch_proto(url, data=req.SerializeToString())
def unshelve_alarm(self, alarm, comment=None): """ Unshelve an alarm. :param alarm: Alarm instance :type alarm: :class:`.Alarm` :param str comment: Optional comment to associate with the state change. """ name = adapt_name_for_rest(alarm.name) url = f"/processors/{self._instance}/{self._processor}" url += f"/alarms{name}/{alarm.sequence_number}:unshelve" req = alarms_service_pb2.UnshelveAlarmRequest() self.ctx.post_proto(url, data=req.SerializeToString())
def reset_algorithm(self, parameter): """ Reset the algorithm text to its original definition from MDB :param str parameter: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. """ req = mdb_pb2.ChangeAlgorithmRequest() req.action = mdb_pb2.ChangeAlgorithmRequest.RESET parameter = adapt_name_for_rest(parameter) url = '/mdb/{}/{}/algorithms{}'.format(self._instance, self._processor, parameter) self._client.post_proto(url, data=req.SerializeToString())
def get_parameter(self, name): """ Gets a single parameter by its name. :param str name: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. :rtype: .Parameter """ name = adapt_name_for_rest(name) url = f"/mdb/{self._instance}/parameters{name}" response = self.ctx.get_proto(url) message = mdb_pb2.ParameterInfo() message.ParseFromString(response.content) return Parameter(message)
def get_algorithm(self, name): """ Gets a single algorithm by its unique name. :param str name: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. :rtype: .Algorithm """ name = adapt_name_for_rest(name) url = f"/mdb/{self._instance}/algorithms{name}" response = self.ctx.get_proto(url) message = mdb_pb2.AlgorithmInfo() message.ParseFromString(response.content) return Algorithm(message)
def get_command(self, name): """ Gets a single command by its unique name. :param str name: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. :rtype: .Command """ name = adapt_name_for_rest(name) url = '/mdb/{}/commands{}'.format(self._instance, name) response = self._client.get_proto(url) message = mdb_pb2.CommandInfo() message.ParseFromString(response.content) return Command(message)
def unshelve_alarm(self, alarm, comment=None): """ Unshelve an alarm. :param alarm: Alarm instance :type alarm: :class:`.Alarm` :param str comment: Optional comment to associate with the state change. """ name = adapt_name_for_rest(alarm.name) url = '/processors/{}/{}/alarms{}/{}'.format( self._instance, self._processor, name, alarm.sequence_number) req = alarms_pb2.EditAlarmRequest() req.state = 'unshelved' self._client.patch_proto(url, data=req.SerializeToString())
def set_algorithm(self, parameter, text): """ Change an algorithm text. Can only be peformed on JavaScript or Python algorithms. :param string text: new algorithm text (as it would appear in excel or XTCE) :param str parameter: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. """ req = mdb_override_service_pb2.UpdateAlgorithmRequest() req.action = mdb_override_service_pb2.UpdateAlgorithmRequest.SET req.algorithm.text = text parameter = adapt_name_for_rest(parameter) url = f"/mdb/{self._instance}/{self._processor}/algorithms{parameter}" self.ctx.patch_proto(url, data=req.SerializeToString())
def acknowledge_alarm(self, alarm, comment=None): """ Acknowledges a specific alarm. :param alarm: Alarm instance :type alarm: :class:`.Alarm` :param str comment: Optional comment to associate with the state change. """ name = adapt_name_for_rest(alarm.name) url = f"/processors/{self._instance}/{self._processor}" url += f"/alarms{name}/{alarm.sequence_number}:acknowledge" req = alarms_service_pb2.AcknowledgeAlarmRequest() if comment is not None: req.comment = comment self.ctx.post_proto(url, data=req.SerializeToString())
def set_algorithm(self, parameter, text): """ Change an algorithm text. Can only be peformed on JavaScript or Python algorithms. :param string text: new algorithm text (as it would appear in excel or XTCE) :param str parameter: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. """ req = mdb_pb2.ChangeAlgorithmRequest() req.action = mdb_pb2.ChangeAlgorithmRequest.SET req.algorithm.text = text parameter = adapt_name_for_rest(parameter) url = '/mdb/{}/{}/algorithms{}'.format(self._instance, self._processor, parameter) self._client.post_proto(url, data=req.SerializeToString())
def acknowledge_alarm(self, alarm, comment=None): """ Acknowledges a specific alarm associated with a parameter. :param alarm: Alarm instance :type alarm: :class:`.Alarm` :param str comment: Optional comment to associate with the state change. """ name = adapt_name_for_rest(alarm.name) url = '/processors/{}/{}/parameters{}/alarms/{}'.format( self._instance, self._processor, name, alarm.sequence_number) req = rest_pb2.EditAlarmRequest() req.state = 'acknowledged' if comment is not None: req.comment = comment self._client.put_proto(url, data=req.SerializeToString())
def shelve_alarm(self, alarm, comment=None): """ Shelve an alarm. :param alarm: Alarm instance :type alarm: :class:`.Alarm` :param str comment: Optional comment to associate with the state change. """ name = adapt_name_for_rest(alarm.name) url = "/processors/{}/{}/alarms{}/{}".format( self._instance, self._processor, name, alarm.sequence_number ) req = alarms_service_pb2.EditAlarmRequest() req.state = "shelved" if comment is not None: req.comment = comment self.ctx.patch_proto(url, data=req.SerializeToString())
def set_alarm_range_sets(self, parameter, sets): """ Apply an ordered list of alarm range sets for the specified parameter. This replaces existing alarm sets (if any). Each RangeSet may have a context, which indicates when its effects may be applied. Only the first matching set is applied. A RangeSet with context ``None`` represents the *default* set of alarm ranges. There can be only one such set, and it is always applied at the end when no other set of contextual ranges is applicable. :param str parameter: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. :param .RangeSet[] sets: List of range sets (either contextual or not) """ req = mdb_pb2.UpdateParameterRequest() req.action = mdb_pb2.UpdateParameterRequest.SET_ALARMS for rs in sets: if rs.context: context_alarm = req.contextAlarm.add() context_alarm.context = rs.context alarm_info = context_alarm.alarm else: alarm_info = req.defaultAlarm _add_alarms( alarm_info, rs.watch, rs.warning, rs.distress, rs.critical, rs.severe, rs.min_violations, ) parameter = adapt_name_for_rest(parameter) url = "/mdb/{}/{}/parameters{}".format( self._instance, self._processor, parameter ) self.ctx.patch_proto(url, data=req.SerializeToString())
def clear_alarm(self, alarm, comment=None): """ Clear an alarm. .. note:: If the reason that caused the alarm is still present, a new alarm instance will be generated. :param alarm: Alarm instance :type alarm: :class:`.Alarm` :param str comment: Optional comment to associate with the state change. """ name = adapt_name_for_rest(alarm.name) url = f"/processors/{self._instance}/{self._processor}" url += f"/alarms{name}/{alarm.sequence_number}:clear" req = alarms_service_pb2.ClearAlarmRequest() if comment is not None: req.comment = comment self.ctx.post_proto(url, data=req.SerializeToString())
def clear_alarm(self, alarm, comment=None): """ Clear an alarm. .. note:: If the reason that caused the alarm is still present, a new alarm instance will be generated. :param alarm: Alarm instance :type alarm: :class:`.Alarm` :param str comment: Optional comment to associate with the state change. """ name = adapt_name_for_rest(alarm.name) url = '/processors/{}/{}/alarms{}/{}'.format( self._instance, self._processor, name, alarm.sequence_number) req = alarms_pb2.EditAlarmRequest() req.state = 'cleared' if comment is not None: req.comment = comment self._client.patch_proto(url, data=req.SerializeToString())
def set_default_calibrator(self, parameter, type, data): """ Apply a calibrator while processing raw values of the specified parameter. If there is already a default calibrator associated to this parameter, that calibrator gets replaced. .. note:: Contextual calibrators take precedence over the default calibrator See :meth:`set_calibrators` for setting contextual calibrators. Two types of calibrators can be applied: * Polynomial calibrators apply a polynomial expression of the form: `y = a + bx + cx^2 + ...`. The `data` argument must be an array of floats ``[a, b, c, ...]``. * Spline calibrators interpolate the raw value between a set of points which represent a linear curve. The `data` argument must be an array of ``[x, y]`` points. :param str parameter: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. :param str type: One of ``polynomial`` or ``spline``. :param data: Calibration definition for the selected type. """ req = mdb_pb2.UpdateParameterRequest() req.action = mdb_pb2.UpdateParameterRequest.SET_DEFAULT_CALIBRATOR if type: _add_calib(req.defaultCalibrator, type, data) parameter = adapt_name_for_rest(parameter) url = "/mdb/{}/{}/parameters{}".format( self._instance, self._processor, parameter ) self.ctx.patch_proto(url, data=req.SerializeToString())
def issue_command( self, command, args=None, dry_run=False, comment=None, verification=None, extra=None, ): """ Issue the given command :param str command: Either a fully-qualified XTCE name or an alias in the format ``NAMESPACE/NAME``. :param dict args: named arguments (if the command requires these) :param bool dry_run: If ``True`` the command is not actually issued. This can be used to test if the server would generate errors when preparing the command (for example because an argument is missing). :param str comment: Comment attached to the command. :param .VerificationConfig verification: Overrides to the default verification handling of this command. :param dict extra: Extra command options for interpretation by non-core extensions (custom preprocessor, datalinks, command listeners). Note that Yamcs will refuse command options that it does now know about. Extensions should therefore register available options. :return: An object providing access to properties of the newly issued command. :rtype: .IssuedCommand """ req = commands_service_pb2.IssueCommandRequest() req.sequenceNumber = SequenceGenerator.next() req.dryRun = dry_run if comment: req.comment = comment if args: for key in args: assignment = req.assignment.add() assignment.name = key assignment.value = _to_argument_value(args[key]) if verification: if verification._disable_all: req.disableVerifiers = True else: for verifier in verification._disabled: req.verifierConfig[verifier].disable = True for verifier in verification._check_windows: window = verification._check_windows[verifier] if window["start"]: start = int(window["start"] * 1000) req.verifierConfig[ verifier ].checkWindow.timeToStartChecking = start if window["stop"]: stop = int(window["stop"] * 1000) req.verifierConfig[ verifier ].checkWindow.timeToStopChecking = stop if extra: for key in extra: req.extra[key].MergeFrom(_build_value_proto(extra[key])) command = adapt_name_for_rest(command) url = "/processors/{}/{}/commands{}".format( self._instance, self._processor, command ) response = self.ctx.post_proto(url, data=req.SerializeToString()) proto = commands_service_pb2.IssueCommandResponse() proto.ParseFromString(response.content) return IssuedCommand(proto)