/// <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)); }
/// <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> /// Finishes an asynchronous invocation of the CreateMonitoredItems service. /// </summary> public ResponseHeader EndCreateMonitoredItems( IAsyncResult result, out MonitoredItemCreateResultCollection results, out DiagnosticInfoCollection diagnosticInfos) { CreateMonitoredItemsResponse response = null; try { if (UseTransportChannel) { IServiceResponse genericResponse = TransportChannel.EndSendRequest(result); if (genericResponse == null) { throw new ServiceResultException(StatusCodes.BadUnknownResponse); } ValidateResponse(genericResponse.ResponseHeader); response = (CreateMonitoredItemsResponse)genericResponse; } else { CreateMonitoredItemsResponseMessage responseMessage = InnerChannel.EndCreateMonitoredItems(result); 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(null, response, "CreateMonitoredItems"); } return response.ResponseHeader; }
/// <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); } } }