def setUp(self): # create a new ClientSettings instance and add the localhost to the URLs to discover settings = pyuaf.client.settings.ClientSettings() settings.discoveryUrls.append(ARGS.demo_url) settings.applicationName = "client" settings.logToStdOutLevel = ARGS.loglevel self.client = MyClient(settings) serverUri = ARGS.demo_server_uri demoNsUri = ARGS.demo_ns_uri self.address_Demo = Address( ExpandedNodeId("Demo", demoNsUri, serverUri)) self.address_Method = Address( self.address_Demo, [RelativePathElement(QualifiedName("Method", demoNsUri))]) self.address_Multiply = Address( self.address_Method, [RelativePathElement(QualifiedName("Multiply", demoNsUri))]) self.address_SetSimulationSpeed = Address(self.address_Demo, [ RelativePathElement(QualifiedName("SetSimulationSpeed", demoNsUri)) ]) self.request = AsyncMethodCallRequest(1) self.request.targets[0].objectAddress = self.address_Method self.request.targets[0].methodAddress = self.address_Multiply self.request.targets[0].inputArguments.append(Double(2.0)) self.request.targets[0].inputArguments.append(Double(3.0))
def test_client_Client_beginCall(self): result = self.client.beginCall(self.address_Method, self.address_Multiply, [Double(2.0), Double(3.0)]) self.assertTrue(result.overallStatus.isGood()) t_timeout = time.time() + 5.0 while time.time() < t_timeout and self.client.noOfCallCompletes == 0: time.sleep(0.01) # assert if the call was received self.assertEqual(self.client.noOfCallCompletes, 1)
def doService(self, service, **kwargs): if service == "read": return self.client.read(self.addresses, **kwargs) elif service == "beginRead": result = self.client.beginRead(self.addresses, **kwargs) time.sleep(0.1) # wait for async responses return result elif service == "write": return self.client.write(self.addresses, self.values, **kwargs) elif service == "beginWrite": result = self.client.beginWrite(self.addresses, self.values, **kwargs) time.sleep(0.1) # wait for async responses return result elif service == "call": return self.client.call(self.address_Method, self.address_Multiply, [Double(2.0), Double(3.0)], **kwargs) elif service == "beginCall": result = self.client.beginCall(self.address_Method, self.address_Multiply, [Double(2.0), Double(3.0)], **kwargs) time.sleep(0.1) # wait for async responses return result elif service == "browse": return self.client.browse(self.addresses, **kwargs) elif service == "createMonitoredData": return self.client.createMonitoredData(self.addresses, **kwargs) elif service == "createMonitoredEvents": return self.client.createMonitoredEvents([self.address_Alarms], **kwargs)
def tearDown(self): # make sure the trigger has its default value again self.client.write([self.address_Trigger], [Double(50.0)]) # delete the client instances manually (now!) instead of letting them be garbage collected # automatically (which may happen during a another test, and which may cause logging output # of the destruction to be mixed with the logging output of the other test). del self.client
def test_client_Client_processRequest_some_method_call_request(self): request = MethodCallRequest(2) request.targets[0].objectAddress = self.address_Method request.targets[0].methodAddress = self.address_Multiply request.targets[0].inputArguments.append(Double(2.0)) request.targets[0].inputArguments.append(Double(3.0)) request.targets[1].objectAddress = self.address_Demo request.targets[1].methodAddress = self.address_SetSimulationSpeed request.targets[1].inputArguments.append(UInt32(20)) result = self.client.processRequest(request) self.assertTrue( result.overallStatus.isGood() ) self.assertAlmostEqual( result.targets[0].outputArguments[0].value , 6.0 )
def test_client_Client_beginCall_with_callback(self): t = TestClass() result = self.client.beginCall(self.address_Method, self.address_Multiply, [Double(2.0), Double(3.0)], callback=t.myCallback) self.assertTrue(result.overallStatus.isGood()) t_timeout = time.time() + 5.0 while time.time( ) < t_timeout and t.noOfSuccessFullyFinishedCallbacks == 0: time.sleep(0.01) # assert if the call was received self.assertEqual(t.noOfSuccessFullyFinishedCallbacks, 1)
def test_client_Client_beginCall_many_times_in_parallel_with_long_lasting_callback( self): t = LongLastingTestClass() # start 30 processes for i in xrange(30): result = self.client.beginCall( self.address_Method, self.address_Multiply, [Double(2.0), Double(3.0)], callback=t.myCallback) self.assertTrue(result.overallStatus.isGood()) t_timeout = time.time() + 10.0 while time.time( ) < t_timeout and t.noOfSuccessFullyFinishedCallbacks < 30: time.sleep(0.01) # assert if the calls were received self.assertEqual(t.noOfSuccessFullyFinishedCallbacks, 30)
def test_client_Client_createMonitoredEvents(self): # create the items self.client.createMonitoredEvents([self.address_Alarms], self.eventFilter) # now write a trigger so that an event will be generated self.client.write([self.address_Trigger], [Double(self.highHighLimit + 1.0)]) # after a few seconds we should at least have received 1 notification t_timeout = time.time() + 5.0 while time.time( ) < t_timeout and self.client.noOfSuccessFullyReceivedNotifications == 0: time.sleep(0.01) self.assertGreaterEqual( self.client.noOfSuccessFullyReceivedNotifications, 1)
# read the triggers (otherwise the dynamic variables won't change) result = myClient.read( [address_LowLow, address_Low, address_High, address_HighHigh]) if result.overallStatus.isNotGood(): raise Exception("Couldn't read the alarm limits!") lowLowLimit = result.targets[0].data.value lowLimit = result.targets[1].data.value highLimit = result.targets[2].data.value highHighLimit = result.targets[3].data.value # set the trigger to a default value result = myClient.write([address_Trigger], [Double(50.0)]) # start monitoring the events result = myClient.createMonitoredEvents(addresses=[address_Alarms], eventFilter=eventFilter, notificationCallbacks=[eventCallback]) # now set the trigger to a high value result = myClient.write([address_Trigger], [Double(highHighLimit + 1.0)]) # now wait a second, so that the alarm-events can arrive! print("Waiting for notifications...") time.sleep(1.0) # delete the client and create a new instance, so we can proceed cleanly with the next step of the tutorial del myClient
def setUp(self): # create a new ClientSettings instance and add the localhost to the URLs to discover settings = pyuaf.client.settings.ClientSettings() settings.discoveryUrls.append(ARGS.demo_url) settings.applicationName = "client" settings.logToStdOutLevel = ARGS.loglevel self.client = MyClient(settings) serverUri = ARGS.demo_server_uri demoNsUri = ARGS.demo_ns_uri opcUaNsIndex = 0 # the namespace index of nodes defined by the OPC UA specs is always 0 self.address_Demo = Address( ExpandedNodeId("Demo", demoNsUri, serverUri)) self.address_Events = Address( self.address_Demo, [RelativePathElement(QualifiedName("Events", demoNsUri))]) self.address_Alarms = Address( self.address_Events, [RelativePathElement(QualifiedName("AlarmsWithNodes", demoNsUri))]) self.address_Alarm = Address(self.address_Alarms, [ RelativePathElement(QualifiedName("ExclusiveLevelAlarm", demoNsUri)) ]) self.address_Trigger = Address(self.address_Alarms, [ RelativePathElement( QualifiedName("ExclusiveLevelAlarmTrigger", demoNsUri)) ]) self.address_LowLow = Address( self.address_Alarm, [RelativePathElement(QualifiedName("LowLowLimit", opcUaNsIndex))]) self.address_Low = Address( self.address_Alarm, [RelativePathElement(QualifiedName("LowLimit", opcUaNsIndex))]) self.address_High = Address( self.address_Alarm, [RelativePathElement(QualifiedName("HighLimit", opcUaNsIndex))]) self.address_HighHigh = Address(self.address_Alarm, [ RelativePathElement(QualifiedName("HighHighLimit", opcUaNsIndex)) ]) # start the simulation (otherwise the dynamic variables won't change) res = self.client.read([ self.address_LowLow, self.address_Low, self.address_High, self.address_HighHigh ]) self.assertTrue(res.overallStatus.isGood()) self.lowLowLimit = res.targets[0].data.value self.lowLimit = res.targets[1].data.value self.highLimit = res.targets[2].data.value self.highHighLimit = res.targets[3].data.value self.eventFilter = EventFilter() self.eventFilter.selectClauses.resize(3) self.eventFilter.selectClauses[0].attributeId = attributeids.Value self.eventFilter.selectClauses[0].browsePath.append( QualifiedName("Message", 0)) self.eventFilter.selectClauses[0].typeId = NodeId( opcuaidentifiers.OpcUaId_BaseEventType, 0) self.eventFilter.selectClauses[1].attributeId = attributeids.Value self.eventFilter.selectClauses[1].browsePath.append( QualifiedName("SourceName", 0)) self.eventFilter.selectClauses[1].typeId = NodeId( opcuaidentifiers.OpcUaId_BaseEventType, 0) self.eventFilter.selectClauses[2].attributeId = attributeids.Value self.eventFilter.selectClauses[2].browsePath.append( QualifiedName("Severity", 0)) self.eventFilter.selectClauses[2].typeId = NodeId( opcuaidentifiers.OpcUaId_BaseEventType, 0) # make sure the trigger has a default value result = self.client.write([self.address_Trigger], [Double(50.0)]) # Check if the write failed due to a BadUserAccessDenied failure # This appears to be the case for the UaServerCpp shipped with the Windows MSVS2008 demo SDK, # probably a bug in the UaServerCpp. if result.targets[0].status.opcUaStatusCode( ) == pyuaf.util.opcuastatuscodes.OpcUa_BadUserAccessDenied: self.skipTest( "Some old versions of the UaServerCpp have non-writeable triggers (bug in UaServerCpp?)" )
def test_client_Client_call_a_single_method(self): result = self.client.call(self.address_Method, self.address_Multiply, [Double(2.0), Double(3.0)]) self.assertTrue( result.overallStatus.isGood() ) self.assertAlmostEqual( result.targets[0].outputArguments[0].value , 6.0 )