/// <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);
}
}
}
