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