/// <summary>
/// Updates the object with the results of a modify monitored item request.
/// </summary>
internal void SetModifyResult(
MonitoredItemModifyRequest request,
MonitoredItemModifyResult result,
ServiceResult error)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
m_error = error;
if (ServiceResult.IsGood(error))
{
m_clientHandle = request.RequestedParameters.ClientHandle;
m_samplingInterval = request.RequestedParameters.SamplingInterval;
m_queueSize = request.RequestedParameters.QueueSize;
m_discardOldest = request.RequestedParameters.DiscardOldest;
m_filter = null;
if (request.RequestedParameters.Filter != null)
{
m_filter = Utils.Clone(request.RequestedParameters.Filter.Body) as MonitoringFilter;
}
m_samplingInterval = result.RevisedSamplingInterval;
m_queueSize = result.RevisedQueueSize;
}
}
/// <summary>
/// Modifies a monitored item.
/// </summary>
public void ModifyMonitoredItem(
OperationContext context,
IEventMonitoredItem monitoredItem,
TimestampsToReturn timestampsToReturn,
MonitoredItemModifyRequest itemToModify,
EventFilter filter)
{
lock (m_lock) {
// should never be called with items that it does not own.
if (!m_monitoredItems.ContainsKey(monitoredItem.Id))
{
return;
}
// limit the queue size.
uint queueSize = itemToModify.RequestedParameters.QueueSize;
if (queueSize > m_maxEventQueueSize)
{
queueSize = m_maxEventQueueSize;
}
// modify the attributes.
monitoredItem.ModifyAttributes(
context.DiagnosticsMask,
timestampsToReturn,
itemToModify.RequestedParameters.ClientHandle,
filter,
filter,
null,
itemToModify.RequestedParameters.SamplingInterval,
queueSize,
itemToModify.RequestedParameters.DiscardOldest);
}
}
/// <summary>
/// Does any processing after a monitored item is created.
/// </summary>
protected override void OnModifyMonitoredItem(
ISystemContext systemContext,
MonitoredItemModifyRequest itemToModify,
MonitoredNode monitoredNode,
DataChangeMonitoredItem monitoredItem,
double previousSamplingInterval)
{
// TBD
}
/// <summary>
/// Modifies the parameters for a monitored item.
/// </summary>
protected override ServiceResult ModifyMonitoredItem(
ISystemContext context,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
IMonitoredItem monitoredItem,
MonitoredItemModifyRequest itemToModify,
out MonitoringFilterResult filterError)
{
filterError = null;
// check for valid handle.
MemoryBufferState buffer = monitoredItem.ManagerHandle as MemoryBufferState;
if (buffer == null)
{
return(base.ModifyMonitoredItem(
context,
diagnosticsMasks,
timestampsToReturn,
monitoredItem,
itemToModify,
out filterError));
}
// owned by this node manager.
itemToModify.Processed = true;
// get the monitored item.
MemoryBufferMonitoredItem datachangeItem = monitoredItem as MemoryBufferMonitoredItem;
if (datachangeItem == null)
{
return(StatusCodes.BadMonitoredItemIdInvalid);
}
// validate parameters.
MonitoringParameters parameters = itemToModify.RequestedParameters;
// no filters supported at this time.
MonitoringFilter filter = (MonitoringFilter)ExtensionObject.ToEncodeable(parameters.Filter);
if (filter != null)
{
return(StatusCodes.BadFilterNotAllowed);
}
// modify the monitored item parameters.
ServiceResult error = datachangeItem.Modify(
diagnosticsMasks,
timestampsToReturn,
itemToModify.RequestedParameters.ClientHandle,
itemToModify.RequestedParameters.SamplingInterval);
return(ServiceResult.Good);
}
/// <summary>
/// Updates the object with the results of a modify monitored item request.
/// </summary>
public void SetModifyResult(
MonitoredItemModifyRequest request,
MonitoredItemModifyResult result,
int index,
DiagnosticInfoCollection diagnosticInfos,
ResponseHeader responseHeader)
{
ServiceResult error = null;
if (StatusCode.IsBad(result.StatusCode))
{
error = ClientBase.GetResult(result.StatusCode, index, diagnosticInfos, responseHeader);
}
m_status.SetModifyResult(request, result, error);
m_attributesModified = false;
}
/// <summary>
/// Does any processing after a monitored item is created.
/// </summary>
protected virtual void OnModifyMonitoredItem(
ISystemContext systemContext,
MonitoredItemModifyRequest itemToModify,
MonitoredNode monitoredNode,
DataChangeMonitoredItem monitoredItem,
double previousSamplingInterval)
{
// does nothing.
}
/// <summary>
/// Modifies the parameters for a monitored item.
/// </summary>
protected virtual ServiceResult ModifyMonitoredItem(
ISystemContext context,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
IMonitoredItem monitoredItem,
MonitoredItemModifyRequest itemToModify,
out MonitoringFilterResult filterError)
{
filterError = null;
ServiceResult error = null;
// check for valid handle.
MonitoredNode monitoredNode = monitoredItem.ManagerHandle as MonitoredNode;
if (monitoredNode == null)
{
return ServiceResult.Good;
}
if (IsHandleInNamespace(monitoredNode.Node) == null)
{
return ServiceResult.Good;
}
// owned by this node manager.
itemToModify.Processed = true;
// check for valid monitored item.
DataChangeMonitoredItem datachangeItem = monitoredItem as DataChangeMonitoredItem;
// validate parameters.
MonitoringParameters parameters = itemToModify.RequestedParameters;
// validate the data change filter.
DataChangeFilter filter = null;
Range range = null;
if (!ExtensionObject.IsNull(parameters.Filter))
{
error = ValidateDataChangeFilter(
context,
monitoredNode.Node,
datachangeItem.AttributeId,
parameters.Filter,
out filter,
out range);
if (ServiceResult.IsBad(error))
{
return error;
}
}
double previousSamplingInterval = datachangeItem.SamplingInterval;
// check if the variable needs to be sampled.
double samplingInterval = itemToModify.RequestedParameters.SamplingInterval;
if (datachangeItem.AttributeId == Attributes.Value)
{
BaseVariableState variable = monitoredNode.Node as BaseVariableState;
if (variable.MinimumSamplingInterval > 0)
{
samplingInterval = CalculateSamplingInterval(variable, samplingInterval);
}
}
// modify the monitored item parameters.
error = datachangeItem.Modify(
diagnosticsMasks,
timestampsToReturn,
itemToModify.RequestedParameters.ClientHandle,
samplingInterval,
itemToModify.RequestedParameters.QueueSize,
itemToModify.RequestedParameters.DiscardOldest,
filter,
range);
// do any post processing.
OnModifyMonitoredItem(
context,
itemToModify,
monitoredNode,
datachangeItem,
previousSamplingInterval);
return ServiceResult.Good;
}
/// <summary>
/// Updates the object with the results of a modify monitored item request.
/// </summary>
public void SetModifyResult(
MonitoredItemModifyRequest request,
MonitoredItemModifyResult result,
int index,
DiagnosticInfoCollection diagnosticInfos,
ResponseHeader responseHeader)
{
ServiceResult error = null;
if (StatusCode.IsBad(result.StatusCode))
{
error = ClientBase.GetResult(result.StatusCode, index, diagnosticInfos, responseHeader);
}
m_status.SetModifyResult(request, result, error);
m_attributesModified = false;
}
/// <summary>
/// Modifies a monitored item and calls ModifyMonitoring().
/// </summary>
public virtual ServiceResult ModifyMonitoredItem(
OperationContext context,
TimestampsToReturn timestampsToReturn,
ISampledDataChangeMonitoredItem monitoredItem,
MonitoredItemModifyRequest itemToModify,
Range range)
{
// use existing interval as sampling interval.
double samplingInterval = itemToModify.RequestedParameters.SamplingInterval;
if (samplingInterval < 0)
{
samplingInterval = monitoredItem.SamplingInterval;
}
// limit the sampling interval.
double minimumSamplingInterval = monitoredItem.MinimumSamplingInterval;
if (minimumSamplingInterval > 0 && samplingInterval < minimumSamplingInterval)
{
samplingInterval = minimumSamplingInterval;
}
// calculate queue size.
uint queueSize = itemToModify.RequestedParameters.QueueSize;
if (queueSize == 0)
{
queueSize = monitoredItem.QueueSize;
}
if (queueSize > m_maxQueueSize)
{
queueSize = m_maxQueueSize;
}
// get filter.
MonitoringFilter filter = null;
if (!ExtensionObject.IsNull(itemToModify.RequestedParameters.Filter))
{
filter = (MonitoringFilter)itemToModify.RequestedParameters.Filter.Body;
}
// update limits for event filters.
if (filter is EventFilter)
{
samplingInterval = 0;
}
// modify the item attributes.
ServiceResult error = monitoredItem.ModifyAttributes(
context.DiagnosticsMask,
timestampsToReturn,
itemToModify.RequestedParameters.ClientHandle,
filter,
filter,
range,
samplingInterval,
queueSize,
itemToModify.RequestedParameters.DiscardOldest);
// state of item did not change if an error returned here.
if (ServiceResult.IsBad(error))
{
return error;
}
// update sampling.
ModifyMonitoring(context, monitoredItem);
// everything is ok.
return ServiceResult.Good;
}
/// <summary>
/// Modifies a monitored item and calls ModifyMonitoring().
/// </summary>
public virtual ServiceResult ModifyMonitoredItem(
OperationContext context,
TimestampsToReturn timestampsToReturn,
ISampledDataChangeMonitoredItem monitoredItem,
MonitoredItemModifyRequest itemToModify,
Range range)
{
// use existing interval as sampling interval.
double samplingInterval = itemToModify.RequestedParameters.SamplingInterval;
if (samplingInterval < 0)
{
samplingInterval = monitoredItem.SamplingInterval;
}
// limit the sampling interval.
double minimumSamplingInterval = monitoredItem.MinimumSamplingInterval;
if (minimumSamplingInterval > 0 && samplingInterval < minimumSamplingInterval)
{
samplingInterval = minimumSamplingInterval;
}
// calculate queue size.
uint queueSize = itemToModify.RequestedParameters.QueueSize;
if (queueSize == 0)
{
queueSize = monitoredItem.QueueSize;
}
if (queueSize > m_maxQueueSize)
{
queueSize = m_maxQueueSize;
}
// get filter.
MonitoringFilter filter = null;
if (!ExtensionObject.IsNull(itemToModify.RequestedParameters.Filter))
{
filter = (MonitoringFilter)itemToModify.RequestedParameters.Filter.Body;
}
// update limits for event filters.
if (filter is EventFilter)
{
samplingInterval = 0;
}
// modify the item attributes.
ServiceResult error = monitoredItem.ModifyAttributes(
context.DiagnosticsMask,
timestampsToReturn,
itemToModify.RequestedParameters.ClientHandle,
filter,
filter,
range,
samplingInterval,
queueSize,
itemToModify.RequestedParameters.DiscardOldest);
// state of item did not change if an error returned here.
if (ServiceResult.IsBad(error))
{
return(error);
}
// update sampling.
ModifyMonitoring(context, monitoredItem);
// everything is ok.
return(ServiceResult.Good);
}
/// <summary>
/// Validates a monitored item modify request parameter.
/// </summary>
protected static ServiceResult ValidateMonitoredItemModifyRequest(MonitoredItemModifyRequest item)
{
// check for null structure.
if (item == null)
{
return new ServiceResult(StatusCodes.BadStructureMissing);
}
// check for null structure.
MonitoringParameters attributes = item.RequestedParameters;
ServiceResult error = ValidateMonitoringAttributes(attributes);
if (ServiceResult.IsBad(error))
{
return error;
}
// validate monitoring filter.
error = ValidateMonitoringFilter(attributes.Filter);
if (ServiceResult.IsBad(error))
{
return error;
}
// passed basic validation.
return null;
}
/// <summary>
/// Modifies a monitored item.
/// </summary>
public void ModifyMonitoredItem(
OperationContext context,
IEventMonitoredItem monitoredItem,
TimestampsToReturn timestampsToReturn,
MonitoredItemModifyRequest itemToModify,
EventFilter filter)
{
lock (m_lock)
{
// should never be called with items that it does not own.
if (!m_monitoredItems.ContainsKey(monitoredItem.Id))
{
return;
}
// limit the queue size.
uint queueSize = itemToModify.RequestedParameters.QueueSize;
if (queueSize > m_maxEventQueueSize)
{
queueSize = m_maxEventQueueSize;
}
// modify the attributes.
monitoredItem.ModifyAttributes(
context.DiagnosticsMask,
timestampsToReturn,
itemToModify.RequestedParameters.ClientHandle,
filter,
filter,
null,
itemToModify.RequestedParameters.SamplingInterval,
queueSize,
itemToModify.RequestedParameters.DiscardOldest);
}
}
/// <summary>
/// Updates the object with the results of a modify monitored item request.
/// </summary>
internal void SetModifyResult(
MonitoredItemModifyRequest request,
MonitoredItemModifyResult result,
ServiceResult error)
{
if (request == null) throw new ArgumentNullException("request");
if (result == null) throw new ArgumentNullException("result");
m_error = error;
if (ServiceResult.IsGood(error))
{
m_clientHandle = request.RequestedParameters.ClientHandle;
m_samplingInterval = request.RequestedParameters.SamplingInterval;
m_queueSize = request.RequestedParameters.QueueSize;
m_discardOldest = request.RequestedParameters.DiscardOldest;
m_filter = null;
if (request.RequestedParameters.Filter != null)
{
m_filter = Utils.Clone(request.RequestedParameters.Filter.Body) as MonitoringFilter;
}
m_samplingInterval = result.RevisedSamplingInterval;
m_queueSize = result.RevisedQueueSize;
}
}