コード例 #1
0
        private static uint CreateSubscription(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;

            var response = services.CreateSubscription(requestHeader,
                                                       publishingInterval, lifetimeCount, maxKeepAliveCount,
                                                       maxNotificationPerPublish, enabled, priority,
                                                       out uint id, out double revisedPublishingInterval, out uint revisedLifetimeCount, out uint revisedMaxKeepAliveCount);

            ServerFixtureUtils.ValidateResponse(response);

            return(id);
        }
コード例 #2
0
        /// <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);
        }