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 )