public ResponseHeader ModifyMonitoredItems(
RequestHeader requestHeader,
uint subscriptionId,
TimestampsToReturn timestampsToReturn,
MonitoredItemModifyRequestCollection itemsToModify,
out MonitoredItemModifyResultCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
return(m_session.ModifyMonitoredItems(requestHeader, subscriptionId, timestampsToReturn, itemsToModify, out results, out diagnosticInfos));
}
/// <summary>
/// Invokes the ModifyMonitoredItems service.
/// </summary>
public virtual ResponseHeader ModifyMonitoredItems(
RequestHeader requestHeader,
uint subscriptionId,
TimestampsToReturn timestampsToReturn,
MonitoredItemModifyRequestCollection itemsToModify,
out MonitoredItemModifyResultCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
results = null;
diagnosticInfos = null;
ValidateRequest(requestHeader);
// Insert implementation.
return(CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported));
}
public static Entry For(MonitoredItemModifyRequestCollection collection)
{
if (collection == null)
{
return(new NullEntry());
}
else
{
ArrayEntry array = new ArrayEntry();
MonitoredItemModifyRequestCollection.Enumerator e = collection.GetEnumerator();
while (e.MoveNext())
{
ObjectEntry itemEntry = new ObjectEntry();
itemEntry.Add("ItemId", For(e.Current.MonitoredItemId));
itemEntry.Add("RequestedParameters", For(e.Current.RequestedParameters));
array.Add(itemEntry);
}
return(array);
}
}
/// <summary>
/// Modies all items that have been changed.
/// </summary>
public async Task <IList <MonitoredItem> > ModifyItemsAsync(CancellationToken ct = default)
{
VerifySubscriptionState(true);
MonitoredItemModifyRequestCollection requestItems = new MonitoredItemModifyRequestCollection();
List <MonitoredItem> itemsToModify = new List <MonitoredItem>();
PrepareItemsToModify(requestItems, itemsToModify);
if (requestItems.Count == 0)
{
return(itemsToModify);
}
// modify the subscription.
var response = await m_session.ModifyMonitoredItemsAsync(
null,
m_id,
m_timestampsToReturn,
requestItems,
ct).ConfigureAwait(false);
MonitoredItemModifyResultCollection results = response.Results;
ClientBase.ValidateResponse(results, itemsToModify);
ClientBase.ValidateDiagnosticInfos(response.DiagnosticInfos, itemsToModify);
// update results.
for (int ii = 0; ii < results.Count; ii++)
{
itemsToModify[ii].SetModifyResult(requestItems[ii], results[ii], ii, response.DiagnosticInfos, response.ResponseHeader);
}
m_changeMask |= SubscriptionChangeMask.ItemsModified;
ChangesCompleted();
// return the list of items affected by the change.
return(itemsToModify);
}
/// <summary>
/// Modifies monitored items in a subscription.
/// </summary>
public void ModifyMonitoredItems(
OperationContext context,
TimestampsToReturn timestampsToReturn,
MonitoredItemModifyRequestCollection itemsToModify,
out MonitoredItemModifyResultCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
if (context == null) throw new ArgumentNullException("context");
if (itemsToModify == null) throw new ArgumentNullException("itemsToModify");
int count = itemsToModify.Count;
// allocate results.
bool diagnosticsExist = false;
results = new MonitoredItemModifyResultCollection(count);
diagnosticInfos = null;
if ((context.DiagnosticsMask & DiagnosticsMasks.OperationAll) != 0)
{
diagnosticInfos = new DiagnosticInfoCollection(count);
}
// build list of items to modify.
List<IMonitoredItem> monitoredItems = new List<IMonitoredItem>(count);
List<ServiceResult> errors = new List<ServiceResult>(count);
List<MonitoringFilterResult> filterResults = new List<MonitoringFilterResult>(count);
double[] originalSamplingIntervals = new double[count];
bool validItems = false;
lock (m_lock)
{
// check session.
VerifySession(context);
// clear lifetime counter.
ResetLifetimeCount();
for (int ii = 0; ii < count; ii++)
{
filterResults.Add(null);
LinkedListNode<IMonitoredItem> node = null;
if (!m_monitoredItems.TryGetValue(itemsToModify[ii].MonitoredItemId, out node))
{
monitoredItems.Add(null);
errors.Add(StatusCodes.BadMonitoredItemIdInvalid);
// update diagnostics.
if ((context.DiagnosticsMask & DiagnosticsMasks.OperationAll) != 0)
{
DiagnosticInfo diagnosticInfo = ServerUtils.CreateDiagnosticInfo(m_server, context, errors[ii]);
diagnosticsExist = true;
diagnosticInfos.Add(diagnosticInfo);
}
continue;
}
IMonitoredItem monitoredItem = node.Value;
monitoredItems.Add(monitoredItem);
originalSamplingIntervals[ii] = monitoredItem.SamplingInterval;
errors.Add(null);
validItems = true;
// update diagnostics.
if ((context.DiagnosticsMask & DiagnosticsMasks.OperationAll) != 0)
{
diagnosticInfos.Add(null);
}
}
}
// update items.
if (validItems)
{
m_server.NodeManager.ModifyMonitoredItems(
context,
timestampsToReturn,
monitoredItems,
itemsToModify,
errors,
filterResults);
}
lock (m_lock)
{
// create results.
for (int ii = 0; ii < errors.Count; ii++)
{
ServiceResult error = errors[ii];
MonitoredItemModifyResult result = null;
if (ServiceResult.IsGood(error))
{
error = monitoredItems[ii].GetModifyResult(out result);
}
if (result == null)
{
result = new MonitoredItemModifyResult();
}
if (error == null)
{
result.StatusCode = StatusCodes.Good;
}
else
{
result.StatusCode = error.StatusCode;
}
// update diagnostics.
if (ServiceResult.IsGood(error))
{
ModifyItemSamplingInterval(originalSamplingIntervals[ii], result.RevisedSamplingInterval, monitoredItems[ii].MonitoringMode);
}
if (filterResults[ii] != null)
{
result.FilterResult = new ExtensionObject(filterResults[ii]);
}
results.Add(result);
if ((context.DiagnosticsMask & DiagnosticsMasks.OperationAll) != 0)
{
if (error != null && error.Code != StatusCodes.Good)
{
diagnosticInfos[ii] = ServerUtils.CreateDiagnosticInfo(m_server, context, error);
diagnosticsExist = true;
}
}
}
// clear diagnostics if not required.
if (!diagnosticsExist && diagnosticInfos != null)
{
diagnosticInfos.Clear();
}
// TraceState("ITEMS MODIFIED");
}
}
/// <summary>
/// Invokes the ModifyMonitoredItems service.
/// </summary>
public virtual ResponseHeader ModifyMonitoredItems(
RequestHeader requestHeader,
uint subscriptionId,
TimestampsToReturn timestampsToReturn,
MonitoredItemModifyRequestCollection itemsToModify,
out MonitoredItemModifyResultCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
results = null;
diagnosticInfos = null;
ValidateRequest(requestHeader);
// Insert implementation.
return CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported);
}
/// <summary>
/// Invokes the ModifyMonitoredItems service.
/// </summary>
/// <param name="requestHeader">The request header.</param>
/// <param name="subscriptionId">The subscription id.</param>
/// <param name="timestampsToReturn">The type of timestamps to be returned for the MonitoredItems.</param>
/// <param name="itemsToModify">The list of MonitoredItems to modify.</param>
/// <param name="results">The list of results for the MonitoredItems to modify.</param>
/// <param name="diagnosticInfos">The diagnostic information for the results.</param>
/// <returns>
/// Returns a <see cref="ResponseHeader"/> object
/// </returns>
public override ResponseHeader ModifyMonitoredItems(
RequestHeader requestHeader,
uint subscriptionId,
TimestampsToReturn timestampsToReturn,
MonitoredItemModifyRequestCollection itemsToModify,
out MonitoredItemModifyResultCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
OperationContext context = ValidateRequest(requestHeader, RequestType.ModifyMonitoredItems);
try
{
if (itemsToModify == null || itemsToModify.Count == 0)
{
throw new ServiceResultException(StatusCodes.BadNothingToDo);
}
ServerInternal.SubscriptionManager.ModifyMonitoredItems(
context,
subscriptionId,
timestampsToReturn,
itemsToModify,
out results,
out diagnosticInfos);
return CreateResponse(requestHeader, context.StringTable);
}
catch (ServiceResultException e)
{
lock (ServerInternal.DiagnosticsLock)
{
ServerInternal.ServerDiagnostics.RejectedRequestsCount++;
if (IsSecurityError(e.StatusCode))
{
ServerInternal.ServerDiagnostics.SecurityRejectedRequestsCount++;
}
}
throw TranslateException(context, e);
}
finally
{
OnRequestComplete(context);
}
}
/// <summary>
/// Worker method to test subscriptions of a server.
/// </summary>
/// <param name="services"></param>
/// <param name="requestHeader"></param>
public static void SubscriptionTest(
IServerTestServices services,
RequestHeader requestHeader)
{
// start time
requestHeader.Timestamp = DateTime.UtcNow;
// create subscription
double publishingInterval = 1000.0;
uint lifetimeCount = 60;
uint maxKeepAliveCount = 2;
uint maxNotificationPerPublish = 0;
byte priority = 128;
bool enabled = false;
uint queueSize = 5;
var response = services.CreateSubscription(requestHeader,
publishingInterval, lifetimeCount, maxKeepAliveCount,
maxNotificationPerPublish, enabled, priority,
out uint id, out double revisedPublishingInterval, out uint revisedLifetimeCount, out uint revisedMaxKeepAliveCount);
Assert.AreEqual(publishingInterval, revisedPublishingInterval);
Assert.AreEqual(lifetimeCount, revisedLifetimeCount);
Assert.AreEqual(maxKeepAliveCount, revisedMaxKeepAliveCount);
ServerFixtureUtils.ValidateResponse(response);
MonitoredItemCreateRequestCollection itemsToCreate = new MonitoredItemCreateRequestCollection();
// check badnothingtodo
var sre = Assert.Throws <ServiceResultException>(() =>
services.CreateMonitoredItems(requestHeader, id, TimestampsToReturn.Neither, itemsToCreate,
out MonitoredItemCreateResultCollection mockResults, out DiagnosticInfoCollection mockInfos));
Assert.AreEqual(StatusCodes.BadNothingToDo, sre.StatusCode);
// add item
uint handleCounter = 1;
itemsToCreate.Add(new MonitoredItemCreateRequest()
{
ItemToMonitor = new ReadValueId()
{
AttributeId = Attributes.Value,
NodeId = VariableIds.Server_ServerStatus_CurrentTime
},
MonitoringMode = MonitoringMode.Reporting,
RequestedParameters = new MonitoringParameters()
{
ClientHandle = ++handleCounter,
SamplingInterval = -1,
Filter = null,
DiscardOldest = true,
QueueSize = queueSize
}
});
response = services.CreateMonitoredItems(requestHeader, id, TimestampsToReturn.Neither, itemsToCreate,
out MonitoredItemCreateResultCollection itemCreateResults, out DiagnosticInfoCollection diagnosticInfos);
ServerFixtureUtils.ValidateResponse(response);
ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticInfos, itemsToCreate);
// modify subscription
response = services.ModifySubscription(requestHeader, id,
publishingInterval, lifetimeCount, maxKeepAliveCount,
maxNotificationPerPublish, priority,
out revisedPublishingInterval, out revisedLifetimeCount, out revisedMaxKeepAliveCount);
Assert.AreEqual(publishingInterval, revisedPublishingInterval);
Assert.AreEqual(lifetimeCount, revisedLifetimeCount);
Assert.AreEqual(maxKeepAliveCount, revisedMaxKeepAliveCount);
ServerFixtureUtils.ValidateResponse(response);
// modify monitored item, just timestamps to return
var itemsToModify = new MonitoredItemModifyRequestCollection();
foreach (var itemCreated in itemCreateResults)
{
itemsToModify.Add(
new MonitoredItemModifyRequest()
{
MonitoredItemId = itemCreated.MonitoredItemId
});
}
;
response = services.ModifyMonitoredItems(requestHeader, id, TimestampsToReturn.Both, itemsToModify,
out MonitoredItemModifyResultCollection modifyResults, out diagnosticInfos);
ServerFixtureUtils.ValidateResponse(response);
ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticInfos, itemsToModify);
// publish request
var acknoledgements = new SubscriptionAcknowledgementCollection();
response = services.Publish(requestHeader, acknoledgements,
out uint subscriptionId, out UInt32Collection availableSequenceNumbers,
out bool moreNotifications, out NotificationMessage notificationMessage,
out StatusCodeCollection statuses, out diagnosticInfos);
ServerFixtureUtils.ValidateResponse(response);
ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticInfos, acknoledgements);
Assert.AreEqual(id, subscriptionId);
Assert.AreEqual(0, availableSequenceNumbers.Count);
// enable publishing
enabled = true;
var subscriptions = new UInt32Collection()
{
id
};
response = services.SetPublishingMode(requestHeader, enabled, subscriptions,
out statuses, out diagnosticInfos);
ServerFixtureUtils.ValidateResponse(response);
ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticInfos, subscriptions);
// wait some time to fill queue
int loopCounter = (int)queueSize;
Thread.Sleep(loopCounter * 1000);
acknoledgements = new SubscriptionAcknowledgementCollection();
do
{
// get publish responses
response = services.Publish(requestHeader, acknoledgements,
out subscriptionId, out availableSequenceNumbers,
out moreNotifications, out notificationMessage,
out statuses, out diagnosticInfos);
ServerFixtureUtils.ValidateResponse(response);
ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticInfos, acknoledgements);
Assert.AreEqual(id, subscriptionId);
var dataChangeNotification = notificationMessage.NotificationData[0].Body as DataChangeNotification;
TestContext.Out.WriteLine("Notification: {0} {1} {2}",
notificationMessage.SequenceNumber,
dataChangeNotification?.MonitoredItems[0].Value.ToString(),
notificationMessage.PublishTime);
acknoledgements.Clear();
acknoledgements.Add(new SubscriptionAcknowledgement()
{
SubscriptionId = id,
SequenceNumber = notificationMessage.SequenceNumber
});
} while (acknoledgements.Count > 0 && --loopCounter > 0);
// republish
response = services.Republish(requestHeader, subscriptionId, notificationMessage.SequenceNumber, out notificationMessage);
ServerFixtureUtils.ValidateResponse(response);
// disable publishing
enabled = false;
response = services.SetPublishingMode(requestHeader, enabled, subscriptions,
out statuses, out diagnosticInfos);
ServerFixtureUtils.ValidateResponse(response);
ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticInfos, subscriptions);
// delete subscription
response = services.DeleteSubscriptions(requestHeader, subscriptions, out statuses, out diagnosticInfos);
ServerFixtureUtils.ValidateResponse(response);
ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticInfos, subscriptions);
}
/// <summary>
/// Begins an asynchronous invocation of the ModifyMonitoredItems service.
/// </summary>
public IAsyncResult BeginModifyMonitoredItems(
RequestHeader requestHeader,
uint subscriptionId,
TimestampsToReturn timestampsToReturn,
MonitoredItemModifyRequestCollection itemsToModify,
AsyncCallback callback,
object asyncState)
{
ModifyMonitoredItemsRequest request = new ModifyMonitoredItemsRequest();
request.RequestHeader = requestHeader;
request.SubscriptionId = subscriptionId;
request.TimestampsToReturn = timestampsToReturn;
request.ItemsToModify = itemsToModify;
UpdateRequestHeader(request, requestHeader == null, "ModifyMonitoredItems");
if (UseTransportChannel)
{
return TransportChannel.BeginSendRequest(request, callback, asyncState);
}
return InnerChannel.BeginModifyMonitoredItems(new ModifyMonitoredItemsMessage(request), callback, asyncState);
}
/// <summary>
/// Invokes the ModifyMonitoredItems service.
/// </summary>
public virtual ResponseHeader ModifyMonitoredItems(
RequestHeader requestHeader,
uint subscriptionId,
TimestampsToReturn timestampsToReturn,
MonitoredItemModifyRequestCollection itemsToModify,
out MonitoredItemModifyResultCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
ModifyMonitoredItemsRequest request = new ModifyMonitoredItemsRequest();
ModifyMonitoredItemsResponse response = null;
request.RequestHeader = requestHeader;
request.SubscriptionId = subscriptionId;
request.TimestampsToReturn = timestampsToReturn;
request.ItemsToModify = itemsToModify;
UpdateRequestHeader(request, requestHeader == null, "ModifyMonitoredItems");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (ModifyMonitoredItemsResponse)genericResponse;
}
else
{
ModifyMonitoredItemsResponseMessage responseMessage = InnerChannel.ModifyMonitoredItems(new ModifyMonitoredItemsMessage(request));
if (responseMessage == null || responseMessage.ModifyMonitoredItemsResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.ModifyMonitoredItemsResponse;
ValidateResponse(response.ResponseHeader);
}
results = response.Results;
diagnosticInfos = response.DiagnosticInfos;
}
finally
{
RequestCompleted(request, response, "ModifyMonitoredItems");
}
return response.ResponseHeader;
}
/// <summary>
/// Modifies monitored items in a subscription.
/// </summary>
public void ModifyMonitoredItems(
OperationContext context,
uint subscriptionId,
TimestampsToReturn timestampsToReturn,
MonitoredItemModifyRequestCollection itemsToModify,
out MonitoredItemModifyResultCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
// find subscription.
Subscription subscription = null;
lock (m_lock)
{
if (!m_subscriptions.TryGetValue(subscriptionId, out subscription))
{
throw new ServiceResultException(StatusCodes.BadSubscriptionIdInvalid);
}
}
// modify the items.
subscription.ModifyMonitoredItems(
context,
timestampsToReturn,
itemsToModify,
out results,
out diagnosticInfos);
}
