private static void CreateMonitoredItem( IServerTestServices services, RequestHeader requestHeader, uint subscriptionId, NodeId nodeId) { uint queueSize = 5; var itemsToCreate = new MonitoredItemCreateRequestCollection { // add item new MonitoredItemCreateRequest { ItemToMonitor = new ReadValueId { AttributeId = Attributes.Value, NodeId = nodeId }, MonitoringMode = MonitoringMode.Reporting, RequestedParameters = new MonitoringParameters { ClientHandle = 1u, SamplingInterval = -1, Filter = null, DiscardOldest = true, QueueSize = queueSize } } }; var response = services.CreateMonitoredItems(requestHeader, subscriptionId, TimestampsToReturn.Neither, itemsToCreate, out MonitoredItemCreateResultCollection itemCreateResults, out DiagnosticInfoCollection diagnosticInfos); ServerFixtureUtils.ValidateResponse(response); ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticInfos, itemsToCreate); }
/// <summary> /// Creates all items on the server that have not already been created. /// </summary> public async Task <IList <MonitoredItem> > CreateItemsAsync(CancellationToken ct = default) { List <MonitoredItem> itemsToCreate; MonitoredItemCreateRequestCollection requestItems = PrepareItemsToCreate(out itemsToCreate); if (requestItems.Count == 0) { return(itemsToCreate); } // create monitored items. var response = await m_session.CreateMonitoredItemsAsync( null, m_id, m_timestampsToReturn, requestItems, ct).ConfigureAwait(false); MonitoredItemCreateResultCollection results = response.Results; ClientBase.ValidateResponse(results, itemsToCreate); ClientBase.ValidateDiagnosticInfos(response.DiagnosticInfos, itemsToCreate); // update results. for (int ii = 0; ii < results.Count; ii++) { itemsToCreate[ii].SetCreateResult(requestItems[ii], results[ii], ii, response.DiagnosticInfos, response.ResponseHeader); } m_changeMask |= SubscriptionChangeMask.ItemsCreated; ChangesCompleted(); // return the list of items affected by the change. return(itemsToCreate); }
public ResponseHeader CreateMonitoredItems( RequestHeader requestHeader, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemCreateRequestCollection itemsToCreate, out MonitoredItemCreateResultCollection results, out DiagnosticInfoCollection diagnosticInfos) { return(m_session.CreateMonitoredItems(requestHeader, subscriptionId, timestampsToReturn, itemsToCreate, out results, out diagnosticInfos)); }
/// <summary> /// Invokes the CreateMonitoredItems service. /// </summary> public virtual ResponseHeader CreateMonitoredItems( RequestHeader requestHeader, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemCreateRequestCollection itemsToCreate, out MonitoredItemCreateResultCollection results, out DiagnosticInfoCollection diagnosticInfos) { results = null; diagnosticInfos = null; ValidateRequest(requestHeader); // Insert implementation. return(CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported)); }
public static Entry For(MonitoredItemCreateRequestCollection collection) { if (collection == null) { return(new NullEntry()); } else { ArrayEntry array = new ArrayEntry(); MonitoredItemCreateRequestCollection.Enumerator e = collection.GetEnumerator(); while (e.MoveNext()) { ObjectEntry itemToCreate = new ObjectEntry(); itemToCreate.Add("ItemToMonitor", For(e.Current.ItemToMonitor)); itemToCreate.Add("MonitoringMode", For(e.Current.MonitoringMode)); itemToCreate.Add("RequestedParameters", For(e.Current.RequestedParameters)); array.Add(itemToCreate); } return(array); } }
/// <summary> /// Adds monitored items to a subscription. /// </summary> public void CreateMonitoredItems( OperationContext context, TimestampsToReturn timestampsToReturn, MonitoredItemCreateRequestCollection itemsToCreate, out MonitoredItemCreateResultCollection results, out DiagnosticInfoCollection diagnosticInfos) { if (context == null) throw new ArgumentNullException("context"); if (itemsToCreate == null) throw new ArgumentNullException("itemsToCreate"); int count = itemsToCreate.Count; lock (m_lock) { // check session. VerifySession(context); // clear lifetime counter. ResetLifetimeCount(); } // create the monitored items. List<IMonitoredItem> monitoredItems = new List<IMonitoredItem>(count); List<ServiceResult> errors = new List<ServiceResult>(count); List<MonitoringFilterResult> filterResults = new List<MonitoringFilterResult>(count); for (int ii = 0; ii < count; ii++) { monitoredItems.Add(null); errors.Add(null); filterResults.Add(null); } m_server.NodeManager.CreateMonitoredItems( context, this.m_id, m_publishingInterval, timestampsToReturn, itemsToCreate, errors, filterResults, monitoredItems); // allocate results. bool diagnosticsExist = false; results = new MonitoredItemCreateResultCollection(count); diagnosticInfos = null; if ((context.DiagnosticsMask & DiagnosticsMasks.OperationAll) != 0) { diagnosticInfos = new DiagnosticInfoCollection(count); } lock (m_lock) { // check session again after CreateMonitoredItems. VerifySession(context); for (int ii = 0; ii < errors.Count; ii++) { // update results. MonitoredItemCreateResult result = null; if (ServiceResult.IsBad(errors[ii])) { result = new MonitoredItemCreateResult(); result.StatusCode = errors[ii].Code; if (filterResults[ii] != null) { result.FilterResult = new ExtensionObject(filterResults[ii]); } } else { IMonitoredItem monitoredItem = monitoredItems[ii]; if (monitoredItem != null) { monitoredItem.SubscriptionCallback = this; LinkedListNode<IMonitoredItem> node = m_itemsToCheck.AddLast(monitoredItem); m_monitoredItems.Add(monitoredItem.Id, node); errors[ii] = monitoredItem.GetCreateResult(out result); // update sampling interval diagnostics. AddItemToSamplingInterval(result.RevisedSamplingInterval, itemsToCreate[ii].MonitoringMode); } } results.Add(result); // update diagnostics. if ((context.DiagnosticsMask & DiagnosticsMasks.OperationAll) != 0) { DiagnosticInfo diagnosticInfo = null; if (errors[ii] != null && errors[ii].Code != StatusCodes.Good) { diagnosticInfo = ServerUtils.CreateDiagnosticInfo(m_server, context, errors[ii]); diagnosticsExist = true; } diagnosticInfos.Add(diagnosticInfo); } } // clear diagnostics if not required. if (!diagnosticsExist && diagnosticInfos != null) { diagnosticInfos.Clear(); } // update diagnostics. lock (m_diagnostics) { m_diagnostics.MonitoredItemCount = 0; m_diagnostics.DisabledMonitoredItemCount = 0; } // TraceState("ITEMS CREATED"); } }
/// <summary> /// Invokes the CreateMonitoredItems service. /// </summary> public virtual ResponseHeader CreateMonitoredItems( RequestHeader requestHeader, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemCreateRequestCollection itemsToCreate, out MonitoredItemCreateResultCollection results, out DiagnosticInfoCollection diagnosticInfos) { results = null; diagnosticInfos = null; ValidateRequest(requestHeader); // Insert implementation. return CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported); }
/// <summary> /// Invokes the CreateMonitoredItems service. /// </summary> /// <param name="requestHeader">The request header.</param> /// <param name="subscriptionId">The subscription id that will report notifications.</param> /// <param name="timestampsToReturn">The type of timestamps to be returned for the MonitoredItems.</param> /// <param name="itemsToCreate">The list of MonitoredItems to be created and assigned to the specified subscription</param> /// <param name="results">The list of results for the MonitoredItems to create.</param> /// <param name="diagnosticInfos">The diagnostic information for the results.</param> /// <returns> /// Returns a <see cref="ResponseHeader"/> object /// </returns> public override ResponseHeader CreateMonitoredItems( RequestHeader requestHeader, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemCreateRequestCollection itemsToCreate, out MonitoredItemCreateResultCollection results, out DiagnosticInfoCollection diagnosticInfos) { OperationContext context = ValidateRequest(requestHeader, RequestType.CreateMonitoredItems); try { if (itemsToCreate == null || itemsToCreate.Count == 0) { throw new ServiceResultException(StatusCodes.BadNothingToDo); } ServerInternal.SubscriptionManager.CreateMonitoredItems( context, subscriptionId, timestampsToReturn, itemsToCreate, 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> /// Creates the monitored items. /// </summary> private bool CreateMonitoredItems( Subscription subscription, MonitoredItemCreateRequestCollection itemsToCreate, List<MonitoredItem> monitoredItems) { try { RequestHeader requestHeader = new RequestHeader(); requestHeader.ReturnDiagnostics = 0; MonitoredItemCreateResultCollection results; DiagnosticInfoCollection diagnosticInfos; ResponseHeader responseHeader = Session.CreateMonitoredItems( requestHeader, subscription.SubscriptionId, TimestampsToReturn.Both, itemsToCreate, out results, out diagnosticInfos); ClientBase.ValidateResponse(results, itemsToCreate); ClientBase.ValidateDiagnosticInfos(diagnosticInfos, itemsToCreate); if (diagnosticInfos != null && diagnosticInfos.Count > 0) { Log("Returned non-empty DiagnosticInfos array during CreateMonitoredItems."); return false; } bool success = true; DateTime updateTime = responseHeader.Timestamp; for (int ii = 0; ii < itemsToCreate.Count; ii++) { MonitoredItemCreateRequest request = itemsToCreate[ii]; MonitoredItemCreateResult result = results[ii]; Node node = (Node)request.Handle; if (StatusCode.IsBad(result.StatusCode)) { if (!VerifyBadAttribute(node, request.ItemToMonitor.AttributeId, result.StatusCode)) { success = false; } continue; } // check if attribute is not supposed to be valid for node. if (!Attributes.IsValid(node.NodeClass, request.ItemToMonitor.AttributeId)) { Log( "CreateMonitoredItem accepted for invalid attribute Node '{0}'. NodeId = {1}, NodeClass = {2}, Attribute = {3}", node, node.NodeId, node.NodeClass, Attributes.GetBrowseName(request.ItemToMonitor.AttributeId)); success = false; continue; } // check filter result. if (request.RequestedParameters.Filter == null) { if (!ExtensionObject.IsNull(result.FilterResult)) { Log( "Server returned a non-null filter result for Node '{0}', NodeId = {1}, AttributeId = {2}, FilterResult = {3}", node, node.NodeId, Attributes.GetBrowseName(request.ItemToMonitor.AttributeId), result.FilterResult); success = false; continue; } } MonitoredItem monitoredItem = new MonitoredItem(); monitoredItem.MonitoredItemId = result.MonitoredItemId; monitoredItem.Node = node; monitoredItem.TimestampsToReturn = TimestampsToReturn.Both; monitoredItem.DiagnosticsMasks = 0; monitoredItem.AttributeId = request.ItemToMonitor.AttributeId; monitoredItem.MonitoringMode = request.MonitoringMode; monitoredItem.ClientHandle = request.RequestedParameters.ClientHandle; monitoredItem.SamplingInterval = result.RevisedSamplingInterval; monitoredItem.QueueSize = result.RevisedQueueSize; monitoredItem.DiscardOldest = request.RequestedParameters.DiscardOldest; monitoredItem.Filter = ExtensionObject.ToEncodeable(request.RequestedParameters.Filter) as MonitoringFilter; monitoredItem.UpdateTime = updateTime; monitoredItems.Add(monitoredItem); } return success; } catch (Exception e) { Log(e, "CreateMonitoredItems Failed."); return false; } }
/// <summary> /// Adds the items to subscription. Verifies the initial update. /// </summary> private bool Subscribe(Subscription subscription, MonitoredItemCreateRequestCollection itemsToCreate) { bool success = true; try { List<MonitoredItem> monitoredItems = new List<MonitoredItem>(); if (!CreateMonitoredItems(subscription, itemsToCreate, monitoredItems)) { success = false; } if (success) { if (!WaitForUpdates(subscription, monitoredItems, false)) { success = false; } } if (success) { if (!ToogleDisabledState(subscription, monitoredItems)) { success = false; } } if (success) { if (!WaitForUpdates(subscription, monitoredItems, true)) { success = false; } } if (!DeleteMonitoredItems(subscription, monitoredItems)) { success = false; } lock (subscription) { subscription.NotificationMessages.Clear(); subscription.ReceiveTimes.Clear(); } return success; } catch (Exception e) { Log(e, "Error during subscribe test."); return false; } }
/// <summary> /// Adds the MonitoredItems to the request collection. /// </summary> private void AddMonitoredItems( Node node, MonitoredItemCreateRequestCollection itemsToCreate, params uint[] attributeIds) { if (attributeIds != null) { for (int ii = 0; ii < attributeIds.Length; ii++) { MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(); request.ItemToMonitor.NodeId = node.NodeId; request.ItemToMonitor.AttributeId = attributeIds[ii]; request.MonitoringMode = MonitoringMode.Reporting; request.RequestedParameters.ClientHandle = ++m_lastClientHandle; request.RequestedParameters.SamplingInterval = 6000000; request.RequestedParameters.QueueSize = 0; request.RequestedParameters.DiscardOldest = true; request.RequestedParameters.Filter = null; request.Handle = node; itemsToCreate.Add(request); } } }
/// <summary> /// Creates subscription, adds items and verifies that the initial update arrives. /// </summary> private bool DoCreateItemsTest() { // follow tree from each starting node. bool success = true; double increment = MaxProgress/AvailableNodes.Count; double position = 0; Log("Starting CreateItemsTest for {0} Nodes ({1}% Coverage). PipelineDepth = {2}, OutstandingRequests = {3}", AvailableNodes.Values.Count, Configuration.Coverage, m_publishPipelineDepth, m_outstandingPublishRequests); // create subscription. Interlocked.Exchange(ref m_publishCount, 0); Interlocked.Exchange(ref m_stopped, 0); m_errorEvent.Reset(); if (!CreateSubscription(1000, 100, 10, 0, true, 0)) { return false; } uint[] attributeIds = Attributes.GetIdentifiers(); int nodes = 0; int operations = 0; MonitoredItemCreateRequestCollection itemsToCreate = new MonitoredItemCreateRequestCollection(); int counter = 0; foreach (Node node in AvailableNodes.Values) { if (!CheckCoverage(ref counter)) { continue; } nodes++; AddMonitoredItems(node, itemsToCreate, attributeIds); // process batch. if (itemsToCreate.Count > BlockSize) { operations += itemsToCreate.Count; if (!Subscribe(m_subscriptions[0], itemsToCreate)) { Log("WARNING: CreateItemsTest failed. Trying it again do check for random timing errors."); if (!Subscribe(m_subscriptions[0], itemsToCreate)) { success = false; break; } } itemsToCreate.Clear(); if (nodes > AvailableNodes.Count/5) { Log("Subscribed to {0} attribute values for {1} nodes.", operations, nodes); nodes = 0; operations = 0; } } position += increment; ReportProgress(position); } // process final batch. if (success) { if (itemsToCreate.Count > 0) { operations += itemsToCreate.Count; if (!Subscribe(m_subscriptions[0], itemsToCreate)) { Log("WARNING: CreateItemsTest failed. Trying it again do check for random timing errors."); if (!Subscribe(m_subscriptions[0], itemsToCreate)) { success = false; } } if (success) { Log("Subscribed to {0} attribute values for {1} nodes.", operations, nodes); } } } // delete subscriptions. if (!DeleteSubscriptions()) { success = false; } Interlocked.CompareExchange(ref m_stopped, 1, 0); Log("Deleted subscriptions."); lock (m_subscriptions) { m_subscriptions.Clear(); } return success; }
/// <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 CreateMonitoredItems service. /// </summary> public IAsyncResult BeginCreateMonitoredItems( RequestHeader requestHeader, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemCreateRequestCollection itemsToCreate, AsyncCallback callback, object asyncState) { CreateMonitoredItemsRequest request = new CreateMonitoredItemsRequest(); request.RequestHeader = requestHeader; request.SubscriptionId = subscriptionId; request.TimestampsToReturn = timestampsToReturn; request.ItemsToCreate = itemsToCreate; UpdateRequestHeader(request, requestHeader == null, "CreateMonitoredItems"); if (UseTransportChannel) { return TransportChannel.BeginSendRequest(request, callback, asyncState); } return InnerChannel.BeginCreateMonitoredItems(new CreateMonitoredItemsMessage(request), callback, asyncState); }
/// <summary> /// Invokes the CreateMonitoredItems service. /// </summary> public virtual ResponseHeader CreateMonitoredItems( RequestHeader requestHeader, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemCreateRequestCollection itemsToCreate, out MonitoredItemCreateResultCollection results, out DiagnosticInfoCollection diagnosticInfos) { CreateMonitoredItemsRequest request = new CreateMonitoredItemsRequest(); CreateMonitoredItemsResponse response = null; request.RequestHeader = requestHeader; request.SubscriptionId = subscriptionId; request.TimestampsToReturn = timestampsToReturn; request.ItemsToCreate = itemsToCreate; UpdateRequestHeader(request, requestHeader == null, "CreateMonitoredItems"); try { if (UseTransportChannel) { IServiceResponse genericResponse = TransportChannel.SendRequest(request); if (genericResponse == null) { throw new ServiceResultException(StatusCodes.BadUnknownResponse); } ValidateResponse(genericResponse.ResponseHeader); response = (CreateMonitoredItemsResponse)genericResponse; } else { CreateMonitoredItemsResponseMessage responseMessage = InnerChannel.CreateMonitoredItems(new CreateMonitoredItemsMessage(request)); if (responseMessage == null || responseMessage.CreateMonitoredItemsResponse == null) { throw new ServiceResultException(StatusCodes.BadUnknownResponse); } response = responseMessage.CreateMonitoredItemsResponse; ValidateResponse(response.ResponseHeader); } results = response.Results; diagnosticInfos = response.DiagnosticInfos; } finally { RequestCompleted(request, response, "CreateMonitoredItems"); } return response.ResponseHeader; }
/// <summary> /// Adds monitored items to a subscription. /// </summary> public void CreateMonitoredItems( OperationContext context, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemCreateRequestCollection itemsToCreate, out MonitoredItemCreateResultCollection results, out DiagnosticInfoCollection diagnosticInfos) { int monitoredItemCountIncrement = 0; // find subscription. Subscription subscription = null; lock (m_lock) { if (!m_subscriptions.TryGetValue(subscriptionId, out subscription)) { throw new ServiceResultException(StatusCodes.BadSubscriptionIdInvalid); } } int currentMonitoredItemCount = subscription.MonitoredItemCount; // create the items. subscription.CreateMonitoredItems( context, timestampsToReturn, itemsToCreate, out results, out diagnosticInfos); monitoredItemCountIncrement = subscription.MonitoredItemCount - currentMonitoredItemCount; // update diagnostics. if (context.Session != null) { lock (context.Session.DiagnosticsLock) { SessionDiagnosticsDataType diagnostics = context.Session.SessionDiagnostics; UpdateCurrentMonitoredItemsCount(diagnostics, monitoredItemCountIncrement); } } }