class HelloServer:
def __init__(self, endpoint, name, model_filepath):
self.server = Server()
# This need to be imported at the start or else it will overwrite the data
self.server.import_xml(model_filepath)
self.server.set_endpoint(endpoint)
self.server.set_server_name(name)
objects = self.server.get_objects_node()
freeopcua_namespace = self.server.get_namespace_index(
"urn:freeopcua:python:server")
hellower = objects.get_child("0:Hellower")
hellower_say_hello = hellower.get_child("0:SayHello")
self.server.link_method(hellower_say_hello, say_hello_xml)
hellower.add_method(freeopcua_namespace, "SayHello2", say_hello,
[ua.VariantType.Boolean], [ua.VariantType.String])
hellower.add_method(freeopcua_namespace, "SayHelloArray",
say_hello_array, [ua.VariantType.Boolean],
[ua.VariantType.String])
def __enter__(self):
self.server.start()
return self.server
def __exit__(self, exc_type, exc_val, exc_tb):
self.server.stop()
class HelloServer:
def __init__(self, endpoint, name, model_filepath):
self.server = Server()
# This need to be imported at the start or else it will overwrite the data
self.server.import_xml(model_filepath)
self.server.set_endpoint(endpoint)
self.server.set_server_name(name)
objects = self.server.get_objects_node()
freeopcua_namespace = self.server.get_namespace_index("urn:freeopcua:python:server")
hellower = objects.get_child("0:Hellower")
hellower_say_hello = hellower.get_child("0:SayHello")
self.server.link_method(hellower_say_hello, say_hello_xml)
hellower.add_method(
freeopcua_namespace, "SayHello2", say_hello, [ua.VariantType.Boolean], [ua.VariantType.String])
hellower.add_method(
freeopcua_namespace, "SayHelloArray", say_hello_array, [ua.VariantType.Boolean], [ua.VariantType.String])
def __enter__(self):
self.server.start()
return self.server
def __exit__(self, exc_type, exc_val, exc_tb):
self.server.stop()
class OPCUAServer(object):
def __init__(self):
self.server = None
self.uri = ""
self.idx = 0
self.scan_thread = None
self.scan_enable = False
self.devices = []
# setup our server
self.server = Server()
self.server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
# setup our own namespace, not really necessary but should as spec
uri = "http://examples.freeopcua.github.io"
idx = self.server.register_namespace(uri)
# import address space which has a device object
self.server.import_xml("device.xml")
# get Objects node
objects = self.server.get_objects_node()
# get the device object type so we can find all the devices in the address space
hw_type = self.server.nodes.base_object_type.get_child("2:Device")
device_nodes = find_o_types(objects, hw_type)
# instantiate a device python object and make it an attribute of the server class
# FIXME do your own organization, most likely an object oriented model
for device_node in device_nodes:
device = Device(self.server, device_node)
setattr(self, device.b_name, device)
# keep track of the device because so that we can update it cyclically using the driver
self.devices.append(device)
def _scan(self):
while self.scan_enable:
# update all device data from devices' configured driver, such as modbus)
for device in self.devices:
device.update()
time.sleep(1)
def scan_on(self):
# Start the thread which handles the cyclic updates of devices
self.scan_thread = threading.Thread(target=self._scan)
# self.scan_thread.setDaemon(True)
self.scan_enable = True
self.scan_thread.start()
def scan_off(self):
# Stop the thread which handles cyclic updates
self.scan_enable = False
self.scan_thread.join()
class MyDeviceServer(object):
def __init__(self, endpoint, name):
# Logging configuration
self.logger = logging.getLogger('MyDeviceServer')
self.logger.setLevel(logging.INFO)
# Setup server
self.server = Server()
self.server.import_xml("MyDevice.xml")
self.server.set_endpoint(endpoint)
self.server.set_server_name(name)
self.objects_node = self.server.get_objects_node()
self.my_device_node = self.objects_node.get_child("0:MyDevice")
self.my_device_toggle_b = self.my_device_node.get_child("0:ToggleB")
self.my_device_toggle_c = self.my_device_node.get_child("0:ToggleC")
self.my_device_toggle_d = self.my_device_node.get_child("0:ToggleD")
self.server.link_method(self.my_device_toggle_b, self.toggle_b)
self.server.link_method(self.my_device_toggle_c, self.toggle_c)
self.server.link_method(self.my_device_toggle_d, self.toggle_d)
self.my_variable_a = self.my_device_node.get_child("0:VariableA")
self.my_variable_b = self.my_device_node.get_child("0:VariableB")
self.my_variable_c = self.my_device_node.get_child("0:VariableC")
self.my_variable_d = self.my_device_node.get_child("0:VariableD")
self.my_variable_e = self.my_device_node.get_child("0:VariableE")
@uamethod
def toggle_b(self, parent):
self.logger.info("Call Toggle B method")
self.my_variable_b.set_value(not self.my_variable_b.get_value())
@uamethod
def toggle_c(self, parent):
self.logger.info("Call Toggle C method")
self.my_variable_c.set_value(not self.my_variable_c.get_value())
@uamethod
def toggle_d(self, parent):
self.logger.info("Call Toggle D method")
self.my_variable_d.set_value(not self.my_variable_d.get_value())
def start(self):
self.server.start()
def stop(self):
self.server.stop()
def setVarA(self, intNumber):
self.my_variable_a.set_value(intNumber)
def setVarE(self, intNumber):
self.my_variable_e.set_value(intNumber)
class TestServer(unittest.TestCase, CommonTests):
'''
Run common tests on server side
Tests that can only be run on server side must be defined here
'''
@classmethod
def setUpClass(self):
self.srv = Server()
self.srv.set_endpoint('opc.tcp://localhost:%d' % port_num2)
add_server_methods(self.srv)
self.srv.start()
self.opc = self.srv
@classmethod
def tearDownClass(self):
self.srv.stop()
def test_register_namespace(self):
uri = 'http://mycustom.Namespace.com'
idx1 = self.opc.register_namespace(uri)
idx2 = self.opc.get_namespace_index(uri)
self.assertEqual(idx1, idx2)
def test_register_use_namespace(self):
uri = 'http://my_very_custom.Namespace.com'
idx = self.opc.register_namespace(uri)
root = self.opc.get_root_node()
myvar = root.add_variable(idx, 'var_in_custom_namespace', [5])
myid = myvar.nodeid
self.assertEqual(idx, myid.NamespaceIndex)
def test_server_method(self):
def func(parent, variant):
variant.Value *= 2
return [variant]
o = self.opc.get_objects_node()
v = o.add_method(3, 'Method1', func, [ua.VariantType.Int64], [ua.VariantType.Int64])
result = o.call_method(v, ua.Variant(2.1))
self.assertEqual(result, 4.2)
def test_xml_import(self):
self.srv.import_xml("tests/custom_nodes.xml")
o = self.opc.get_objects_node()
v = o.get_child(["MyXMLFolder", "MyXMLObject", "MyXMLVariable"])
val = v.get_value()
self.assertEqual(val, "StringValue")
class HelloServer:
def __init__(self, endpoint, name, model_filepath):
self.server = Server()
# This need to be imported at the start or else it will overwrite the data
self.server.import_xml(model_filepath)
self.server.set_endpoint(endpoint)
self.server.set_server_name(name)
objects = self.server.get_objects_node()
ESP8266=self.server.get_node("ns=0;i=20005")
print("ESP8266: ")
print(ESP8266)
#death_button=ESP8266.get_children()
watering_status=ESP8266.get_value()
print(watering_status)
switch_method=self.server.get_node("ns=0;i=20006")
freeopcua_namespace = self.server.get_namespace_index("urn:freeopcua:python:server")
# hellower = objects.get_child("0:Hellower")
# hellower_say_hello = hellower.get_child("0:SayHello")
self.server.link_method(switch_method, switch_mtd)
# self.server.link_method(hellower_say_hello, say_hello_xml)
# hellower.add_method(
# freeopcua_namespace, "SayHello2", say_hello, [ua.VariantType.Boolean], [ua.VariantType.String])
# hellower.add_method(
# freeopcua_namespace, "SayHelloArray", say_hello_array, [ua.VariantType.Boolean], [ua.VariantType.String])
def __enter__(self):
self.server.start()
return self.server
def __exit__(self, exc_type, exc_val, exc_tb):
self.server.stop()
class ServerPython(object):
def __init__(self):
self._server = None
self.nodes = None
self.get_node = None
self.get_namespace_array = None
def start_server(self, endpoint):
logger.info("Starting python-opcua server")
self._server = Server()
self._server.set_endpoint(endpoint)
self._server.set_server_name("OpcUa Modeler Server")
self.nodes = self._server.nodes
self.get_node = self._server.get_node
self.get_namespace_array = self._server.get_namespace_array
self.load_type_definitions = self._server.load_type_definitions
self.load_enums = self._server.load_enums
# now remove freeopcua namespace, not necessary when modeling and
# ensures correct idx for exported nodesets
ns_node = self._server.get_node(
ua.NodeId(ua.ObjectIds.Server_NamespaceArray))
nss = ns_node.get_value()
ns_node.set_value(nss[:1])
self._server.start()
def stop_server(self):
if self._server is not None:
self._server.stop()
self._server = None
self.get_node = None
self.get_namespace_array = None
def import_xml(self, path):
return self._server.import_xml(path)
def export_xml(self, nodes, uris, path):
exp = XmlExporter(self._server)
exp.build_etree(nodes, uris=uris)
exp.write_xml(path)
class ServerPython(object):
def __init__(self):
self._server = None
self.nodes = None
self.get_node = None
self.get_namespace_array = None
def start_server(self, endpoint):
logger.info("Starting python-opcua server")
self._server = Server()
self._server.set_endpoint(endpoint)
self._server.set_server_name("OpcUa Modeler Server")
self.nodes = self._server.nodes
self.get_node = self._server.get_node
self.get_namespace_array = self._server.get_namespace_array
self.load_type_definitions = self._server.load_type_definitions
self.load_enums = self._server.load_enums
# now remove freeopcua namespace, not necessary when modeling and
# ensures correct idx for exported nodesets
ns_node = self._server.get_node(ua.NodeId(ua.ObjectIds.Server_NamespaceArray))
nss = ns_node.get_value()
ns_node.set_value(nss[:1])
self._server.start()
def stop_server(self):
if self._server is not None:
self._server.stop()
self._server = None
self.get_node = None
self.get_namespace_array = None
def import_xml(self, path):
return self._server.import_xml(path)
def export_xml(self, nodes, uris, path):
exp = XmlExporter(self._server)
exp.build_etree(nodes, uris=uris)
exp.write_xml(path)
from opcua import ua, Server
if __name__ == "__main__":
# setup our server
server = Server()
server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
# setup our own namespace, not really necessary but should as spec
uri = "http://examples.freeopcua.github.io"
idx = server.register_namespace(uri)
# Import customobject type
server.import_xml('customobject.xml')
# get Objects node, this is where we should put our custom stuff
objects = server.get_objects_node()
# get nodeid of custom object type by :
# 1) Use node ID
# 2) Or Full path
# 3) Or As child from parent
nodeid_a = ua.NodeId.from_string('ns=1;i=1002')
nodeid_b = server.get_root_node().get_child(["0:Types", "0:ObjectTypes", "0:BaseObjectType", "1:MyObjectType"]).nodeid
nodeid_c = server.get_node(ua.ObjectIds.BaseObjectType).get_child(["1:MyObjectType"]).nodeid
myobject_type_nodeid = nodeid_a
def uaserver():
parser = argparse.ArgumentParser(
description=
"Run an example OPC-UA server. By importing xml definition and using uawrite command line, it is even possible to expose real data using this server"
)
# we setup a server, this is a bit different from other tool so we do not reuse common arguments
parser.add_argument(
"-u",
"--url",
help="URL of OPC UA server, default is opc.tcp://0.0.0.0:4840",
default='opc.tcp://0.0.0.0:4840',
metavar="URL")
parser.add_argument(
"-v",
"--verbose",
dest="loglevel",
choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
default='WARNING',
help="Set log level")
parser.add_argument(
"-x",
"--xml",
metavar="XML_FILE",
help="Populate address space with nodes defined in XML")
parser.add_argument("-p",
"--populate",
action="store_true",
help="Populate address space with some sample nodes")
parser.add_argument(
"-c",
"--disable-clock",
action="store_true",
help=
"Disable clock, to avoid seeing many write if debugging an application"
)
parser.add_argument(
"-s",
"--shell",
action="store_true",
help="Start python shell instead of randomly changing node values")
parser.add_argument("--certificate", help="set server certificate")
parser.add_argument("--private_key", help="set server private key")
args = parser.parse_args()
logging.basicConfig(format="%(levelname)s: %(message)s",
level=getattr(logging, args.loglevel))
server = Server()
server.set_endpoint(args.url)
if args.certificate:
server.load_certificate(args.certificate)
if args.private_key:
server.load_private_key(args.private_key)
server.disable_clock(args.disable_clock)
server.set_server_name("FreeOpcUa Example Server")
if args.xml:
server.import_xml(args.xml)
if args.populate:
@uamethod
def multiply(parent, x, y):
print("multiply method call with parameters: ", x, y)
return x * y
uri = "http://examples.freeopcua.github.io"
idx = server.register_namespace(uri)
objects = server.get_objects_node()
myobj = objects.add_object(idx, "MyObject")
mywritablevar = myobj.add_variable(idx, "MyWritableVariable", 6.7)
mywritablevar.set_writable(
) # Set MyVariable to be writable by clients
myvar = myobj.add_variable(idx, "MyVariable", 6.7)
myarrayvar = myobj.add_variable(idx, "MyVarArray", [6.7, 7.9])
myprop = myobj.add_property(idx, "MyProperty", "I am a property")
mymethod = myobj.add_method(
idx, "MyMethod", multiply,
[ua.VariantType.Double, ua.VariantType.Int64],
[ua.VariantType.Double])
server.start()
try:
if args.shell:
embed()
elif args.populate:
count = 0
while True:
time.sleep(1)
myvar.set_value(math.sin(count / 10))
myarrayvar.set_value(
[math.sin(count / 10),
math.sin(count / 100)])
count += 1
else:
while True:
time.sleep(1)
finally:
server.stop()
sys.exit(0)
from opcua import ua, Server
if __name__ == "__main__":
# Setup OPC-UA Server
server = Server()
server.set_endpoint("opc.tcp://192.168.250.200:50895")
# Setup namespace
uri = "http://examples.freeopcua.github.io"
idx = server.register_namespace(uri)
# Get objects node
objects = server.get_objects_node()
# Import customobject type
server.import_xml('KUKA_KR16_2_object.xml')
# Check if client wants communication over KUKAVARPROXY or RSI
kuka_object = objects.get_child("0:KUKA_KR16_2")
ip_adress = kuka_object.get_child("0:IP")
variable_kukavarproxy = kuka_object.get_child("0:KUKAVARPROXY")
variable_rsi = kuka_object.get_child("0:RSI")
# Extracting axis variables and removing KUKAVARPROXU/RSI configuration variables
variables_all = kuka_object.get_children()
for variable in variables_all:
variable.set_writable()
# Removing configuration properties
variables_all.remove(ip_adress)
class TestServer(unittest.TestCase, CommonTests, SubscriptionTests):
'''
Run common tests on server side
Tests that can only be run on server side must be defined here
'''
@classmethod
def setUpClass(self):
self.srv = Server()
self.srv.set_endpoint('opc.tcp://localhost:%d' % port_num)
add_server_methods(self.srv)
self.srv.start()
self.opc = self.srv
self.discovery = Server()
self.discovery.set_application_uri("urn:freeopcua:python:discovery")
self.discovery.set_endpoint('opc.tcp://localhost:%d' % port_discovery)
self.discovery.start()
@classmethod
def tearDownClass(self):
self.srv.stop()
self.discovery.stop()
def test_discovery(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
try:
servers = client.find_servers()
new_app_uri = "urn:freeopcua:python:server:test_discovery"
self.srv.application_uri = new_app_uri
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 0)
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers) , 1)
self.assertFalse(new_app_uri in [s.ApplicationUri for s in servers])
self.assertTrue(new_app_uri in [s.ApplicationUri for s in new_servers])
finally:
client.disconnect()
def test_find_servers2(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
try:
servers = client.find_servers()
new_app_uri1 = "urn:freeopcua:python:server:test_discovery1"
self.srv.application_uri = new_app_uri1
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), period=0)
new_app_uri2 = "urn:freeopcua:python:test_discovery2"
self.srv.application_uri = new_app_uri2
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), period=0)
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers) , 2)
self.assertFalse(new_app_uri1 in [s.ApplicationUri for s in servers])
self.assertFalse(new_app_uri2 in [s.ApplicationUri for s in servers])
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertTrue(new_app_uri2 in [s.ApplicationUri for s in new_servers])
# now do a query with filer
new_servers = client.find_servers(["urn:freeopcua:python:server"])
self.assertEqual(len(new_servers) - len(servers) , 0)
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertFalse(new_app_uri2 in [s.ApplicationUri for s in new_servers])
# now do a query with filer
new_servers = client.find_servers(["urn:freeopcua:python"])
self.assertEqual(len(new_servers) - len(servers) , 2)
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertTrue(new_app_uri2 in [s.ApplicationUri for s in new_servers])
finally:
client.disconnect()
"""
# not sure if this test is necessary, and there is a lot repetition with previous test
def test_discovery_server_side(self):
servers = self.discovery.find_servers()
self.assertEqual(len(servers), 1)
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 1)
time.sleep(1) # let server register registration
servers = self.discovery.find_servers()
print("SERVERS 2", servers)
self.assertEqual(len(servers), 2)
"""
#def test_register_server2(self):
#servers = self.opc.register_server()
def test_register_namespace(self):
uri = 'http://mycustom.Namespace.com'
idx1 = self.opc.register_namespace(uri)
idx2 = self.opc.get_namespace_index(uri)
self.assertEqual(idx1, idx2)
def test_register_use_namespace(self):
uri = 'http://my_very_custom.Namespace.com'
idx = self.opc.register_namespace(uri)
root = self.opc.get_root_node()
myvar = root.add_variable(idx, 'var_in_custom_namespace', [5])
myid = myvar.nodeid
self.assertEqual(idx, myid.NamespaceIndex)
def test_server_method(self):
def func(parent, variant):
variant.Value *= 2
return [variant]
o = self.opc.get_objects_node()
v = o.add_method(3, 'Method1', func, [ua.VariantType.Int64], [ua.VariantType.Int64])
result = o.call_method(v, ua.Variant(2.1))
self.assertEqual(result, 4.2)
def test_xml_import(self):
self.srv.import_xml("tests/custom_nodes.xml")
o = self.opc.get_objects_node()
v = o.get_child(["MyXMLFolder", "MyXMLObject", "MyXMLVariable"])
val = v.get_value()
self.assertEqual(val, "StringValue")
def test_historize_variable(self):
o = self.opc.get_objects_node()
var = o.add_variable(3, "test_hist", 1.0)
self.srv.iserver.enable_history_data_change(var, timedelta(days=1))
time.sleep(1)
var.set_value(2.0)
var.set_value(3.0)
self.srv.iserver.disable_history_data_change(var)
def test_historize_events(self):
srv_node = self.srv.get_node(ua.ObjectIds.Server)
srvevgen = self.srv.get_event_generator()
self.srv.iserver.enable_history_event(srv_node, period=None)
srvevgen.trigger(message="Message")
self.srv.iserver.disable_history_event(srv_node)
def test_references_for_added_nodes_method(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
nodes = objects.get_referenced_nodes(refs=ua.ObjectIds.Organizes, direction=ua.BrowseDirection.Forward, includesubtypes=False)
self.assertTrue(o in nodes)
nodes = o.get_referenced_nodes(refs=ua.ObjectIds.Organizes, direction=ua.BrowseDirection.Inverse, includesubtypes=False)
self.assertTrue(objects in nodes)
self.assertEqual(o.get_parent(), objects)
self.assertEqual(o.get_type_definition(), ua.ObjectIds.BaseObjectType)
@uamethod
def callback(parent):
return
m = o.add_method(3, 'MyMethod', callback)
nodes = o.get_referenced_nodes(refs=ua.ObjectIds.HasComponent, direction=ua.BrowseDirection.Forward, includesubtypes=False)
self.assertTrue(m in nodes)
nodes = m.get_referenced_nodes(refs=ua.ObjectIds.HasComponent, direction=ua.BrowseDirection.Inverse, includesubtypes=False)
self.assertTrue(o in nodes)
self.assertEqual(m.get_parent(), o)
# This should work for following BaseEvent tests to work (maybe to write it a bit differentlly since they are not independent)
def test_get_event_from_type_node_BaseEvent(self):
ev = opcua.common.events.get_event_obj_from_type_node(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)))
check_base_event(self, ev)
def test_get_event_from_type_node_Inhereted_AuditEvent(self):
ev = opcua.common.events.get_event_obj_from_type_node(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.AuditEventType)))
self.assertIsNot(ev, None) # we did not receive event
self.assertIsInstance(ev, BaseEvent)
self.assertIsInstance(ev, AuditEvent)
self.assertEqual(ev.EventType, ua.NodeId(ua.ObjectIds.AuditEventType))
self.assertEqual(ev.Severity, 1)
self.assertEqual(ev.ActionTimeStamp, None)
self.assertEqual(ev.Status, False)
self.assertEqual(ev.ServerId, None)
self.assertEqual(ev.ClientAuditEntryId, None)
self.assertEqual(ev.ClientUserId, None)
def test_eventgenerator_default(self):
evgen = self.opc.get_event_generator()
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_object(self):
evgen = self.opc.get_event_generator(BaseEvent())
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_Node(self):
evgen = self.opc.get_event_generator(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_NodeId(self):
evgen = self.opc.get_event_generator(ua.NodeId(ua.ObjectIds.BaseEventType))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_ObjectIds(self):
evgen = self.opc.get_event_generator(ua.ObjectIds.BaseEventType)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_Identifier(self):
evgen = self.opc.get_event_generator(2041)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_Node(self):
evgen = self.opc.get_event_generator(source=opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.Server)))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_NodeId(self):
evgen = self.opc.get_event_generator(source=ua.NodeId(ua.ObjectIds.Server))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_ObjectIds(self):
evgen = self.opc.get_event_generator(source=ua.ObjectIds.Server)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceMyObject(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
evgen = self.opc.get_event_generator(source=o)
check_eventgenerator_BaseEvent(self, evgen)
check_event_generator_object(self, evgen, o)
def test_eventgenerator_source_collision(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
event = BaseEvent(sourcenode=o.nodeid)
evgen = self.opc.get_event_generator(event, ua.ObjectIds.Server)
check_eventgenerator_BaseEvent(self, evgen)
check_event_generator_object(self, evgen, o)
def test_eventgenerator_InheritedEvent(self):
evgen = self.opc.get_event_generator(ua.ObjectIds.AuditEventType)
check_eventgenerator_SourceServer(self, evgen)
ev = evgen.event
self.assertIsNot(ev, None) # we did not receive event
self.assertIsInstance(ev, BaseEvent)
self.assertIsInstance(ev, AuditEvent)
self.assertEqual(ev.EventType, ua.NodeId(ua.ObjectIds.AuditEventType))
self.assertEqual(ev.Severity, 1)
self.assertEqual(ev.ActionTimeStamp, None)
self.assertEqual(ev.Status, False)
self.assertEqual(ev.ServerId, None)
self.assertEqual(ev.ClientAuditEntryId, None)
self.assertEqual(ev.ClientUserId, None)
def test_create_custom_event_type_ObjectId(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
check_custom_event_type(self, etype)
def test_create_custom_event_type_NodeId(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.NodeId(ua.ObjectIds.BaseEventType), [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
check_custom_event_type(self, etype)
def test_create_custom_event_type_Node(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)), [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
check_custom_event_type(self, etype)
def test_get_event_from_type_node_CustomEvent(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
ev = opcua.common.events.get_event_obj_from_type_node(etype)
check_custom_event(self, ev, etype)
self.assertEqual(ev.PropertyNum, None)
self.assertEqual(ev.PropertyString, None)
def test_eventgenerator_customEvent(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
evgen = self.opc.get_event_generator(etype, ua.ObjectIds.Server)
check_eventgenerator_CustomEvent(self, evgen, etype)
check_eventgenerator_SourceServer(self, evgen)
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
def test_eventgenerator_double_customEvent(self):
event1 = self.opc.create_custom_event_type(3, 'MyEvent1', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
event2 = self.opc.create_custom_event_type(4, 'MyEvent2', event1, [('PropertyBool', ua.VariantType.Boolean), ('PropertyInt', ua.VariantType.Int32)])
evgen = self.opc.get_event_generator(event2, ua.ObjectIds.Server)
check_eventgenerator_CustomEvent(self, evgen, event2)
check_eventgenerator_SourceServer(self, evgen)
# Properties from MyEvent1
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
# Properties from MyEvent2
self.assertEqual(evgen.event.PropertyBool, None)
self.assertEqual(evgen.event.PropertyInt, None)
def test_eventgenerator_customEvent_MyObject(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
evgen = self.opc.get_event_generator(etype, o)
check_eventgenerator_CustomEvent(self, evgen, etype)
check_event_generator_object(self, evgen, o)
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
class TestClass(object):
"""This class only exists for testing the mirror classes with less
overhead than the whole server containing CANopen communication."""
def __init__(self, logger):
self.isinit = False
self.logger = logger
# setup our server
self.server = Server()
self.server.set_endpoint('opc.tcp://localhost:4840/')
self.server.allow_remote_admin(True)
# setup our own namespace, not really necessary but should as spec
uri = "http://yourorganisation.org/DCSControllerDesign/"
self.idx = self.server.register_namespace(uri)
# get Objects node, this is where we should put our nodes
self.objects = self.server.get_objects_node()
# populating our address space; in most real use cases this should be
# imported from UA spec XML.
self.logger.notice('Import UA spec from xml ...')
self.server.import_xml('dcscontrollerdesign.xml')
self.dctni = ua.NodeId.from_string(f'ns={self.idx};i=1003')
self.logger.info(f'{self.dctni}')
self.logger.success('Done')
def __enter__(self):
return self
def __exit__(self, exception_type, exception_value, traceback):
self.server.stop()
if isinstance(exception_value, KeyboardInterrupt):
self.logger.warning('Received Ctrl+C event (KeyboardInterrupt).')
return True
def start(self):
"""Create one mirrored DCS Controller and start the OPC server"""
self.mDC42 = self.objects.add_object(self.idx, 'DCSController42',
self.dctni)
# starting!
self.server.start()
sleep(1)
# after the UA server is started initialize the mirrored object
self.logger.notice('Initialize mirrored object ...')
self.mDC42py = MyDCSController(self, self.mDC42, 42)
sleep(10) # Wait until the class is initialized
self.logger.success('... Done.')
self.isinit = True
self.run()
def run(self):
"""Do nothing"""
while (True):
pass
def uaserver():
parser = argparse.ArgumentParser(description="Run an example OPC-UA server. By importing xml definition and using uawrite command line, it is even possible to expose real data using this server")
# we setup a server, this is a bit different from other tool so we do not reuse common arguments
parser.add_argument("-u",
"--url",
help="URL of OPC UA server, default is opc.tcp://0.0.0.0:4840",
default='opc.tcp://0.0.0.0:4840',
metavar="URL")
parser.add_argument("-v",
"--verbose",
dest="loglevel",
choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
default='WARNING',
help="Set log level")
parser.add_argument("-x",
"--xml",
metavar="XML_FILE",
help="Populate address space with nodes defined in XML")
parser.add_argument("-p",
"--populate",
action="store_true",
help="Populate address space with some sample nodes")
parser.add_argument("-c",
"--disable-clock",
action="store_true",
help="Disable clock, to avoid seeing many write if debugging an application")
parser.add_argument("-s",
"--shell",
action="store_true",
help="Start python shell instead of randomly changing node values")
parser.add_argument("--certificate",
help="set server certificate")
parser.add_argument("--private_key",
help="set server private key")
args = parser.parse_args()
logging.basicConfig(format="%(levelname)s: %(message)s", level=getattr(logging, args.loglevel))
server = Server()
server.set_endpoint(args.url)
if args.certificate:
server.load_certificate(args.certificate)
if args.private_key:
server.load_private_key(args.private_key)
server.disable_clock(args.disable_clock)
server.set_server_name("FreeOpcUa Example Server")
if args.xml:
server.import_xml(args.xml)
if args.populate:
@uamethod
def multiply(parent, x, y):
print("multiply method call with parameters: ", x, y)
return x * y
uri = "http://examples.freeopcua.github.io"
idx = server.register_namespace(uri)
objects = server.get_objects_node()
myobj = objects.add_object(idx, "MyObject")
mywritablevar = myobj.add_variable(idx, "MyWritableVariable", 6.7)
mywritablevar.set_writable() # Set MyVariable to be writable by clients
myvar = myobj.add_variable(idx, "MyVariable", 6.7)
myarrayvar = myobj.add_variable(idx, "MyVarArray", [6.7, 7.9])
myprop = myobj.add_property(idx, "MyProperty", "I am a property")
mymethod = myobj.add_method(idx, "MyMethod", multiply, [ua.VariantType.Double, ua.VariantType.Int64], [ua.VariantType.Double])
server.start()
try:
if args.shell:
embed()
elif args.populate:
count = 0
while True:
time.sleep(1)
myvar.set_value(math.sin(count / 10))
myarrayvar.set_value([math.sin(count / 10), math.sin(count / 100)])
count += 1
else:
while True:
time.sleep(1)
finally:
server.stop()
sys.exit(0)
class TestServer(unittest.TestCase, CommonTests):
'''
Run common tests on server side
Tests that can only be run on server side must be defined here
'''
@classmethod
def setUpClass(self):
self.srv = Server()
self.srv.set_endpoint('opc.tcp://localhost:%d' % port_num2)
add_server_methods(self.srv)
self.srv.start()
self.opc = self.srv
self.discovery = Server()
self.discovery.set_application_uri("urn:freeopcua:python:discovery")
self.discovery.set_endpoint('opc.tcp://localhost:%d' % port_discovery)
self.discovery.start()
@classmethod
def tearDownClass(self):
self.srv.stop()
self.discovery.stop()
def test_discovery(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
try:
servers = client.find_servers()
new_app_uri = "urn:freeopcua:python:server:test_discovery"
self.srv.application_uri = new_app_uri
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 1)
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers), 1)
self.assertFalse(
new_app_uri in [s.ApplicationUri for s in servers])
self.assertTrue(
new_app_uri in [s.ApplicationUri for s in new_servers])
finally:
client.disconnect()
def test_find_servers2(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
try:
servers = client.find_servers()
new_app_uri1 = "urn:freeopcua:python:server:test_discovery1"
self.srv.application_uri = new_app_uri1
self.srv.register_to_discovery(self.discovery.endpoint.geturl())
new_app_uri2 = "urn:freeopcua:python:test_discovery2"
self.srv.application_uri = new_app_uri2
self.srv.register_to_discovery(self.discovery.endpoint.geturl())
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers), 2)
self.assertFalse(
new_app_uri1 in [s.ApplicationUri for s in servers])
self.assertFalse(
new_app_uri2 in [s.ApplicationUri for s in servers])
self.assertTrue(
new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertTrue(
new_app_uri2 in [s.ApplicationUri for s in new_servers])
# now do a query with filer
new_servers = client.find_servers(["urn:freeopcua:python:server"])
self.assertEqual(len(new_servers) - len(servers), 0)
self.assertTrue(
new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertFalse(
new_app_uri2 in [s.ApplicationUri for s in new_servers])
# now do a query with filer
new_servers = client.find_servers(["urn:freeopcua:python"])
self.assertEqual(len(new_servers) - len(servers), 2)
self.assertTrue(
new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertTrue(
new_app_uri2 in [s.ApplicationUri for s in new_servers])
finally:
client.disconnect()
"""
# not sure if this test is necessary, and there is a lot repetition with previous test
def test_discovery_server_side(self):
servers = self.discovery.find_servers()
self.assertEqual(len(servers), 1)
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 1)
time.sleep(1) # let server register registration
servers = self.discovery.find_servers()
print("SERVERS 2", servers)
self.assertEqual(len(servers), 2)
"""
#def test_register_server2(self):
#servers = self.opc.register_server()
def test_register_namespace(self):
uri = 'http://mycustom.Namespace.com'
idx1 = self.opc.register_namespace(uri)
idx2 = self.opc.get_namespace_index(uri)
self.assertEqual(idx1, idx2)
def test_register_use_namespace(self):
uri = 'http://my_very_custom.Namespace.com'
idx = self.opc.register_namespace(uri)
root = self.opc.get_root_node()
myvar = root.add_variable(idx, 'var_in_custom_namespace', [5])
myid = myvar.nodeid
self.assertEqual(idx, myid.NamespaceIndex)
def test_server_method(self):
def func(parent, variant):
variant.Value *= 2
return [variant]
o = self.opc.get_objects_node()
v = o.add_method(3, 'Method1', func, [ua.VariantType.Int64],
[ua.VariantType.Int64])
result = o.call_method(v, ua.Variant(2.1))
self.assertEqual(result, 4.2)
def test_xml_import(self):
self.srv.import_xml("tests/custom_nodes.xml")
o = self.opc.get_objects_node()
v = o.get_child(["MyXMLFolder", "MyXMLObject", "MyXMLVariable"])
val = v.get_value()
self.assertEqual(val, "StringValue")
class TestServer(unittest.TestCase, CommonTests, SubscriptionTests):
'''
Run common tests on server side
Tests that can only be run on server side must be defined here
'''
@classmethod
def setUpClass(self):
self.srv = Server()
self.srv.set_endpoint('opc.tcp://localhost:%d' % port_num)
add_server_methods(self.srv)
self.srv.start()
self.opc = self.srv
self.discovery = Server()
self.discovery.set_application_uri("urn:freeopcua:python:discovery")
self.discovery.set_endpoint('opc.tcp://localhost:%d' % port_discovery)
self.discovery.start()
@classmethod
def tearDownClass(self):
self.srv.stop()
self.discovery.stop()
def test_discovery(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
try:
servers = client.find_servers()
new_app_uri = "urn:freeopcua:python:server:test_discovery"
self.srv.application_uri = new_app_uri
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 0)
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers) , 1)
self.assertFalse(new_app_uri in [s.ApplicationUri for s in servers])
self.assertTrue(new_app_uri in [s.ApplicationUri for s in new_servers])
finally:
client.disconnect()
def test_find_servers2(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
try:
servers = client.find_servers()
new_app_uri1 = "urn:freeopcua:python:server:test_discovery1"
self.srv.application_uri = new_app_uri1
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), period=0)
new_app_uri2 = "urn:freeopcua:python:test_discovery2"
self.srv.application_uri = new_app_uri2
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), period=0)
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers) , 2)
self.assertFalse(new_app_uri1 in [s.ApplicationUri for s in servers])
self.assertFalse(new_app_uri2 in [s.ApplicationUri for s in servers])
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertTrue(new_app_uri2 in [s.ApplicationUri for s in new_servers])
# now do a query with filer
new_servers = client.find_servers(["urn:freeopcua:python:server"])
self.assertEqual(len(new_servers) - len(servers) , 0)
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertFalse(new_app_uri2 in [s.ApplicationUri for s in new_servers])
# now do a query with filer
new_servers = client.find_servers(["urn:freeopcua:python"])
self.assertEqual(len(new_servers) - len(servers) , 2)
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertTrue(new_app_uri2 in [s.ApplicationUri for s in new_servers])
finally:
client.disconnect()
"""
# not sure if this test is necessary, and there is a lot repetition with previous test
def test_discovery_server_side(self):
servers = self.discovery.find_servers()
self.assertEqual(len(servers), 1)
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 1)
time.sleep(1) # let server register registration
servers = self.discovery.find_servers()
print("SERVERS 2", servers)
self.assertEqual(len(servers), 2)
"""
#def test_register_server2(self):
#servers = self.opc.register_server()
def test_register_namespace(self):
uri = 'http://mycustom.Namespace.com'
idx1 = self.opc.register_namespace(uri)
idx2 = self.opc.get_namespace_index(uri)
self.assertEqual(idx1, idx2)
def test_register_use_namespace(self):
uri = 'http://my_very_custom.Namespace.com'
idx = self.opc.register_namespace(uri)
root = self.opc.get_root_node()
myvar = root.add_variable(idx, 'var_in_custom_namespace', [5])
myid = myvar.nodeid
self.assertEqual(idx, myid.NamespaceIndex)
def test_server_method(self):
def func(parent, variant):
variant.Value *= 2
return [variant]
o = self.opc.get_objects_node()
v = o.add_method(3, 'Method1', func, [ua.VariantType.Int64], [ua.VariantType.Int64])
result = o.call_method(v, ua.Variant(2.1))
self.assertEqual(result, 4.2)
def test_xml_import(self):
self.srv.import_xml("tests/custom_nodes.xml")
o = self.opc.get_objects_node()
v = o.get_child(["MyXMLFolder", "MyXMLObject", "MyXMLVariable"])
val = v.get_value()
self.assertEqual(val, "StringValue")
def test_historize_variable(self):
o = self.opc.get_objects_node()
var = o.add_variable(3, "test_hist", 1.0)
self.srv.iserver.enable_history_data_change(var, timedelta(days=1))
time.sleep(1)
var.set_value(2.0)
var.set_value(3.0)
self.srv.iserver.disable_history_data_change(var)
def test_historize_events(self):
srv_node = self.srv.get_node(ua.ObjectIds.Server)
srvevgen = self.srv.get_event_generator()
self.srv.iserver.enable_history_event(srv_node, period=None)
srvevgen.trigger(message="Message")
self.srv.iserver.disable_history_event(srv_node)
def test_references_for_added_nodes_method(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
nodes = objects.get_referenced_nodes(refs=ua.ObjectIds.Organizes, direction=ua.BrowseDirection.Forward, includesubtypes=False)
self.assertTrue(o in nodes)
nodes = o.get_referenced_nodes(refs=ua.ObjectIds.Organizes, direction=ua.BrowseDirection.Inverse, includesubtypes=False)
self.assertTrue(objects in nodes)
self.assertEqual(o.get_parent(), objects)
self.assertEqual(o.get_type_definition(), ua.ObjectIds.BaseObjectType)
@uamethod
def callback(parent):
return
m = o.add_method(3, 'MyMethod', callback)
nodes = o.get_referenced_nodes(refs=ua.ObjectIds.HasComponent, direction=ua.BrowseDirection.Forward, includesubtypes=False)
self.assertTrue(m in nodes)
nodes = m.get_referenced_nodes(refs=ua.ObjectIds.HasComponent, direction=ua.BrowseDirection.Inverse, includesubtypes=False)
self.assertTrue(o in nodes)
self.assertEqual(m.get_parent(), o)
# This should work for following BaseEvent tests to work (maybe to write it a bit differentlly since they are not independent)
def test_get_event_from_type_node_BaseEvent(self):
ev = opcua.server.event.get_event_from_type_node(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)))
check_base_event(self, ev)
def test_get_event_from_type_node_Inhereted_AuditEvent(self):
ev = opcua.server.event.get_event_from_type_node(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.AuditEventType)))
self.assertIsNot(ev, None) # we did not receive event
self.assertIsInstance(ev, ua.BaseEvent)
self.assertIsInstance(ev, ua.AuditEvent)
self.assertEqual(ev.EventType, ua.NodeId(ua.ObjectIds.AuditEventType))
self.assertEqual(ev.Severity, ua.Variant(1, ua.VariantType.UInt16))
self.assertEqual(ev.ActionTimeStamp, None)
self.assertEqual(ev.Status, False)
self.assertEqual(ev.ServerId, None)
self.assertEqual(ev.ClientAuditEntryId, None)
self.assertEqual(ev.ClientUserId, None)
self.assertEqual(ev._freeze, True)
def test_eventgenerator_default(self):
evgen = self.opc.get_event_generator()
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_object(self):
evgen = self.opc.get_event_generator(ua.BaseEvent())
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_Node(self):
evgen = self.opc.get_event_generator(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_NodeId(self):
evgen = self.opc.get_event_generator(ua.NodeId(ua.ObjectIds.BaseEventType))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_ObjectIds(self):
evgen = self.opc.get_event_generator(ua.ObjectIds.BaseEventType)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_Identifier(self):
evgen = self.opc.get_event_generator(2041)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_Node(self):
evgen = self.opc.get_event_generator(source=opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.Server)))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_NodeId(self):
evgen = self.opc.get_event_generator(source=ua.NodeId(ua.ObjectIds.Server))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_ObjectIds(self):
evgen = self.opc.get_event_generator(source=ua.ObjectIds.Server)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceMyObject(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
evgen = self.opc.get_event_generator(source=o)
check_eventgenerator_BaseEvent(self, evgen)
check_event_generator_object(self, evgen, o)
def test_eventgenerator_source_collision(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
event = ua.BaseEvent(sourcenode=o.nodeid)
evgen = self.opc.get_event_generator(event, ua.ObjectIds.Server)
check_eventgenerator_BaseEvent(self, evgen)
check_event_generator_object(self, evgen, o)
def test_eventgenerator_InheritedEvent(self):
evgen = self.opc.get_event_generator(ua.ObjectIds.AuditEventType)
check_eventgenerator_SourceServer(self, evgen)
ev = evgen.event
self.assertIsNot(ev, None) # we did not receive event
self.assertIsInstance(ev, ua.BaseEvent)
self.assertIsInstance(ev, ua.AuditEvent)
self.assertEqual(ev.EventType, ua.NodeId(ua.ObjectIds.AuditEventType))
self.assertEqual(ev.Severity, ua.Variant(1, ua.VariantType.UInt16))
self.assertEqual(ev.ActionTimeStamp, None)
self.assertEqual(ev.Status, False)
self.assertEqual(ev.ServerId, None)
self.assertEqual(ev.ClientAuditEntryId, None)
self.assertEqual(ev.ClientUserId, None)
self.assertEqual(ev._freeze, True)
def test_create_custom_event_type_ObjectId(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
check_custom_event_type(self, etype)
def test_create_custom_event_type_NodeId(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.NodeId(ua.ObjectIds.BaseEventType), [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
check_custom_event_type(self, etype)
def test_create_custom_event_type_Node(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)), [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
check_custom_event_type(self, etype)
def test_get_event_from_type_node_CustomEvent(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
ev = opcua.server.event.get_event_from_type_node(etype)
check_custom_event(self, ev, etype)
self.assertEqual(ev.PropertyNum, None)
self.assertEqual(ev.PropertyString, None)
def test_eventgenerator_customEvent(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
evgen = self.opc.get_event_generator(etype, ua.ObjectIds.Server)
check_eventgenerator_CustomEvent(self, evgen, etype)
check_eventgenerator_SourceServer(self, evgen)
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
def test_eventgenerator_double_customEvent(self):
event1 = self.opc.create_custom_event_type(3, 'MyEvent1', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
event2 = self.opc.create_custom_event_type(4, 'MyEvent2', event1, [('PropertyBool', ua.VariantType.Boolean), ('PropertyInt', ua.VariantType.Int32)])
evgen = self.opc.get_event_generator(event2, ua.ObjectIds.Server)
check_eventgenerator_CustomEvent(self, evgen, event2)
check_eventgenerator_SourceServer(self, evgen)
# Properties from MyEvent1
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
# Properties from MyEvent2
self.assertEqual(evgen.event.PropertyBool, None)
self.assertEqual(evgen.event.PropertyInt, None)
def test_eventgenerator_customEvent_MyObject(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
evgen = self.opc.get_event_generator(etype, o)
check_eventgenerator_CustomEvent(self, evgen, etype)
check_event_generator_object(self, evgen, o)
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
class TestServer(unittest.TestCase, CommonTests, SubscriptionTests):
'''
Run common tests on server side
Tests that can only be run on server side must be defined here
'''
@classmethod
def setUpClass(self):
self.srv = Server()
self.srv.set_endpoint('opc.tcp://localhost:%d' % port_num)
add_server_methods(self.srv)
self.srv.start()
self.opc = self.srv
self.discovery = Server()
self.discovery.set_application_uri("urn:freeopcua:python:discovery")
self.discovery.set_endpoint('opc.tcp://localhost:%d' % port_discovery)
self.discovery.start()
@classmethod
def tearDownClass(self):
self.srv.stop()
self.discovery.stop()
def test_discovery(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
try:
servers = client.find_servers()
new_app_uri = "urn:freeopcua:python:server:test_discovery"
self.srv.application_uri = new_app_uri
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 0)
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers) , 1)
self.assertFalse(new_app_uri in [s.ApplicationUri for s in servers])
self.assertTrue(new_app_uri in [s.ApplicationUri for s in new_servers])
finally:
client.disconnect()
def test_find_servers2(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
try:
servers = client.find_servers()
new_app_uri1 = "urn:freeopcua:python:server:test_discovery1"
self.srv.application_uri = new_app_uri1
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), period=0)
new_app_uri2 = "urn:freeopcua:python:test_discovery2"
self.srv.application_uri = new_app_uri2
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), period=0)
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers) , 2)
self.assertFalse(new_app_uri1 in [s.ApplicationUri for s in servers])
self.assertFalse(new_app_uri2 in [s.ApplicationUri for s in servers])
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertTrue(new_app_uri2 in [s.ApplicationUri for s in new_servers])
# now do a query with filer
new_servers = client.find_servers(["urn:freeopcua:python:server"])
self.assertEqual(len(new_servers) - len(servers) , 0)
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertFalse(new_app_uri2 in [s.ApplicationUri for s in new_servers])
# now do a query with filer
new_servers = client.find_servers(["urn:freeopcua:python"])
self.assertEqual(len(new_servers) - len(servers) , 2)
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertTrue(new_app_uri2 in [s.ApplicationUri for s in new_servers])
finally:
client.disconnect()
"""
# not sure if this test is necessary, and there is a lot repetition with previous test
def test_discovery_server_side(self):
servers = self.discovery.find_servers()
self.assertEqual(len(servers), 1)
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 1)
time.sleep(1) # let server register registration
servers = self.discovery.find_servers()
print("SERVERS 2", servers)
self.assertEqual(len(servers), 2)
"""
#def test_register_server2(self):
#servers = self.opc.register_server()
def test_register_namespace(self):
uri = 'http://mycustom.Namespace.com'
idx1 = self.opc.register_namespace(uri)
idx2 = self.opc.get_namespace_index(uri)
self.assertEqual(idx1, idx2)
def test_register_existing_namespace(self):
uri = 'http://mycustom.Namespace.com'
idx1 = self.opc.register_namespace(uri)
idx2 = self.opc.register_namespace(uri)
idx3 = self.opc.get_namespace_index(uri)
self.assertEqual(idx1, idx2)
self.assertEqual(idx1, idx3)
def test_register_use_namespace(self):
uri = 'http://my_very_custom.Namespace.com'
idx = self.opc.register_namespace(uri)
root = self.opc.get_root_node()
myvar = root.add_variable(idx, 'var_in_custom_namespace', [5])
myid = myvar.nodeid
self.assertEqual(idx, myid.NamespaceIndex)
def test_server_method(self):
def func(parent, variant):
variant.Value *= 2
return [variant]
o = self.opc.get_objects_node()
v = o.add_method(3, 'Method1', func, [ua.VariantType.Int64], [ua.VariantType.Int64])
result = o.call_method(v, ua.Variant(2.1))
self.assertEqual(result, 4.2)
def test_xml_import(self):
self.srv.import_xml("tests/custom_nodes.xml")
o = self.opc.get_objects_node()
v = o.get_child(["MyXMLFolder", "MyXMLObject", "MyXMLVariable"])
val = v.get_value()
self.assertEqual(val, "StringValue")
node_path = ["Types", "DataTypes", "BaseDataType", "Enumeration",
"1:MyEnum", "0:EnumStrings"]
o = self.opc.get_root_node().get_child(node_path)
self.assertEqual(len(o.get_value()), 3)
# Check if method is imported
node_path = ["Types", "ObjectTypes", "BaseObjectType",
"1:MyObjectType", "1:MyMethod"]
o = self.opc.get_root_node().get_child(node_path)
self.assertEqual(len(o.get_referenced_nodes()), 4)
# Check if InputArgs are imported and can be read
node_path = ["Types", "ObjectTypes", "BaseObjectType",
"1:MyObjectType", "1:MyMethod", "InputArguments"]
o = self.opc.get_root_node().get_child(node_path)
input_arg = o.get_data_value().Value.Value[0]
self.assertEqual(input_arg.Name, 'Context')
def test_historize_variable(self):
o = self.opc.get_objects_node()
var = o.add_variable(3, "test_hist", 1.0)
self.srv.iserver.enable_history_data_change(var, timedelta(days=1))
time.sleep(1)
var.set_value(2.0)
var.set_value(3.0)
self.srv.iserver.disable_history_data_change(var)
def test_historize_events(self):
srv_node = self.srv.get_node(ua.ObjectIds.Server)
srvevgen = self.srv.get_event_generator()
self.srv.iserver.enable_history_event(srv_node, period=None)
srvevgen.trigger(message="Message")
self.srv.iserver.disable_history_event(srv_node)
def test_references_for_added_nodes_method(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
nodes = objects.get_referenced_nodes(refs=ua.ObjectIds.Organizes, direction=ua.BrowseDirection.Forward, includesubtypes=False)
self.assertTrue(o in nodes)
nodes = o.get_referenced_nodes(refs=ua.ObjectIds.Organizes, direction=ua.BrowseDirection.Inverse, includesubtypes=False)
self.assertTrue(objects in nodes)
self.assertEqual(o.get_parent(), objects)
self.assertEqual(o.get_type_definition().Identifier, ua.ObjectIds.BaseObjectType)
@uamethod
def callback(parent):
return
m = o.add_method(3, 'MyMethod', callback)
nodes = o.get_referenced_nodes(refs=ua.ObjectIds.HasComponent, direction=ua.BrowseDirection.Forward, includesubtypes=False)
self.assertTrue(m in nodes)
nodes = m.get_referenced_nodes(refs=ua.ObjectIds.HasComponent, direction=ua.BrowseDirection.Inverse, includesubtypes=False)
self.assertTrue(o in nodes)
self.assertEqual(m.get_parent(), o)
# This should work for following BaseEvent tests to work (maybe to write it a bit differentlly since they are not independent)
def test_get_event_from_type_node_BaseEvent(self):
ev = opcua.common.events.get_event_obj_from_type_node(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)))
check_base_event(self, ev)
def test_get_event_from_type_node_Inhereted_AuditEvent(self):
ev = opcua.common.events.get_event_obj_from_type_node(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.AuditEventType)))
self.assertIsNot(ev, None) # we did not receive event
self.assertIsInstance(ev, BaseEvent)
self.assertIsInstance(ev, AuditEvent)
self.assertEqual(ev.EventType, ua.NodeId(ua.ObjectIds.AuditEventType))
self.assertEqual(ev.Severity, 1)
self.assertEqual(ev.ActionTimeStamp, None)
self.assertEqual(ev.Status, False)
self.assertEqual(ev.ServerId, None)
self.assertEqual(ev.ClientAuditEntryId, None)
self.assertEqual(ev.ClientUserId, None)
def test_eventgenerator_default(self):
evgen = self.opc.get_event_generator()
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_object(self):
evgen = self.opc.get_event_generator(BaseEvent())
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_Node(self):
evgen = self.opc.get_event_generator(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_NodeId(self):
evgen = self.opc.get_event_generator(ua.NodeId(ua.ObjectIds.BaseEventType))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_ObjectIds(self):
evgen = self.opc.get_event_generator(ua.ObjectIds.BaseEventType)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_Identifier(self):
evgen = self.opc.get_event_generator(2041)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_Node(self):
evgen = self.opc.get_event_generator(source=opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.Server)))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_NodeId(self):
evgen = self.opc.get_event_generator(source=ua.NodeId(ua.ObjectIds.Server))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_ObjectIds(self):
evgen = self.opc.get_event_generator(source=ua.ObjectIds.Server)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceMyObject(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
evgen = self.opc.get_event_generator(source=o)
check_eventgenerator_BaseEvent(self, evgen)
check_event_generator_object(self, evgen, o)
def test_eventgenerator_source_collision(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
event = BaseEvent(sourcenode=o.nodeid)
evgen = self.opc.get_event_generator(event, ua.ObjectIds.Server)
check_eventgenerator_BaseEvent(self, evgen)
check_event_generator_object(self, evgen, o)
def test_eventgenerator_InheritedEvent(self):
evgen = self.opc.get_event_generator(ua.ObjectIds.AuditEventType)
check_eventgenerator_SourceServer(self, evgen)
ev = evgen.event
self.assertIsNot(ev, None) # we did not receive event
self.assertIsInstance(ev, BaseEvent)
self.assertIsInstance(ev, AuditEvent)
self.assertEqual(ev.EventType, ua.NodeId(ua.ObjectIds.AuditEventType))
self.assertEqual(ev.Severity, 1)
self.assertEqual(ev.ActionTimeStamp, None)
self.assertEqual(ev.Status, False)
self.assertEqual(ev.ServerId, None)
self.assertEqual(ev.ClientAuditEntryId, None)
self.assertEqual(ev.ClientUserId, None)
# For the custom events all posibilites are tested. For other custom types only one test case is done since they are using the same code
def test_create_custom_data_type_ObjectId(self):
type = self.opc.create_custom_data_type(2, 'MyDataType', ua.ObjectIds.BaseDataType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
check_custom_type(self, type, ua.ObjectIds.BaseDataType)
def test_create_custom_event_type_ObjectId(self):
type = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
check_custom_type(self, type, ua.ObjectIds.BaseEventType)
def test_create_custom_object_type_ObjectId(self):
def func(parent, variant):
return [ua.Variant(ret, ua.VariantType.Boolean)]
properties = [('PropertyNum', ua.VariantType.Int32),
('PropertyString', ua.VariantType.String)]
variables = [('VariableString', ua.VariantType.String),
('MyEnumVar', ua.VariantType.Int32, ua.NodeId(ua.ObjectIds.ApplicationType))]
methods = [('MyMethod', func, [ua.VariantType.Int64], [ua.VariantType.Boolean])]
node_type = self.opc.create_custom_object_type(2, 'MyObjectType', ua.ObjectIds.BaseObjectType, properties, variables, methods)
check_custom_type(self, node_type, ua.ObjectIds.BaseObjectType)
variables = node_type.get_variables()
self.assertTrue(node_type.get_child("2:VariableString") in variables)
self.assertEqual(node_type.get_child("2:VariableString").get_data_value().Value.VariantType, ua.VariantType.String)
self.assertTrue(node_type.get_child("2:MyEnumVar") in variables)
self.assertEqual(node_type.get_child("2:MyEnumVar").get_data_value().Value.VariantType, ua.VariantType.Int32)
self.assertEqual(node_type.get_child("2:MyEnumVar").get_data_type(), ua.NodeId(ua.ObjectIds.ApplicationType))
methods = node_type.get_methods()
self.assertTrue(node_type.get_child("2:MyMethod") in methods)
#def test_create_custom_refrence_type_ObjectId(self):
#type = self.opc.create_custom_reference_type(2, 'MyEvent', ua.ObjectIds.Base, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
#check_custom_type(self, type, ua.ObjectIds.BaseObjectType)
def test_create_custom_variable_type_ObjectId(self):
type = self.opc.create_custom_variable_type(2, 'MyVariableType', ua.ObjectIds.BaseVariableType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
check_custom_type(self, type, ua.ObjectIds.BaseVariableType)
def test_create_custom_event_type_NodeId(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.NodeId(ua.ObjectIds.BaseEventType), [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
check_custom_type(self, etype, ua.ObjectIds.BaseEventType)
def test_create_custom_event_type_Node(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)), [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
check_custom_type(self, etype, ua.ObjectIds.BaseEventType)
def test_get_event_from_type_node_CustomEvent(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
ev = opcua.common.events.get_event_obj_from_type_node(etype)
check_custom_event(self, ev, etype)
self.assertEqual(ev.PropertyNum, None)
self.assertEqual(ev.PropertyString, None)
def test_eventgenerator_customEvent(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
evgen = self.opc.get_event_generator(etype, ua.ObjectIds.Server)
check_eventgenerator_CustomEvent(self, evgen, etype)
check_eventgenerator_SourceServer(self, evgen)
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
def test_eventgenerator_double_customEvent(self):
event1 = self.opc.create_custom_event_type(3, 'MyEvent1', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
event2 = self.opc.create_custom_event_type(4, 'MyEvent2', event1, [('PropertyBool', ua.VariantType.Boolean), ('PropertyInt', ua.VariantType.Int32)])
evgen = self.opc.get_event_generator(event2, ua.ObjectIds.Server)
check_eventgenerator_CustomEvent(self, evgen, event2)
check_eventgenerator_SourceServer(self, evgen)
# Properties from MyEvent1
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
# Properties from MyEvent2
self.assertEqual(evgen.event.PropertyBool, None)
self.assertEqual(evgen.event.PropertyInt, None)
def test_eventgenerator_customEvent_MyObject(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
evgen = self.opc.get_event_generator(etype, o)
check_eventgenerator_CustomEvent(self, evgen, etype)
check_event_generator_object(self, evgen, o)
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
def test_context_manager(self):
""" Context manager calls start() and stop()
"""
state = [0]
def increment_state(self, *args, **kwargs):
state[0] += 1
# create server and replace instance methods with dummy methods
server = Server()
server.start = increment_state.__get__(server)
server.stop = increment_state.__get__(server)
assert state[0] == 0
with server:
# test if server started
self.assertEqual(state[0], 1)
# test if server stopped
self.assertEqual(state[0], 2)
import sys
sys.path.insert(0, "..")
import time
from opcua import ua, Server
if __name__ == "__main__":
# setup our server
server = Server()
server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
server.import_xml("../schemas/UA-Nodeset/DI/Opc.Ua.Di.NodeSet2.xml")
server.import_xml(
"../schemas/UA-Nodeset/Robotics/Opc.Ua.Robotics.NodeSet2.xml")
# setup our own namespace, not really necessary but should as spec
uri = "http://examples.freeopcua.github.io"
idx = server.register_namespace(uri)
# get Objects node, this is where we should put our nodes
objects = server.get_objects_node()
# populating our address space
myobj = objects.add_object(idx, "MyObject")
myvar = myobj.add_variable(idx, "MyVariable", 6.7)
myvar.set_writable() # Set MyVariable to be writable by clients
# starting!
server.start()
# create directly some objects and variables
myobj = server.nodes.objects.add_object(idx, "MyObject")
myvar = myobj.add_variable(idx, "MyVariable", 6.7)
myvar.set_writable() # Set MyVariable to be writable by clients
mystringvar = myobj.add_variable(idx, "MyStringVariable", "Really nice string")
mystringvar.set_writable() # Set MyVariable to be writable by clients
mydtvar = myobj.add_variable(idx, "MyDateTimeVar", datetime.now())
mydtvar.set_writable() # Set MyVariable to be writable by clients
myarrayvar = myobj.add_variable(idx, "myarrayvar", [6.7, 7.9])
myarrayvar = myobj.add_variable(idx, "myStronglytTypedVariable", ua.Variant([], ua.VariantType.UInt32))
myprop = myobj.add_property(idx, "myproperty", "I am a property")
mymethod = myobj.add_method(idx, "mymethod", func, [ua.VariantType.Int64], [ua.VariantType.Boolean])
multiply_node = myobj.add_method(idx, "multiply", multiply, [ua.VariantType.Int64, ua.VariantType.Int64], [ua.VariantType.Int64])
# import some nodes from xml
server.import_xml("custom_nodes.xml")
# creating a default event object
# The event object automatically will have members for all events properties
# you probably want to create a custom event type, see other examples
myevgen = server.get_event_generator()
myevgen.event.Severity = 300
# starting!
server.start()
print("Available loggers are: ", logging.Logger.manager.loggerDict.keys())
try:
# enable following if you want to subscribe to nodes on server side
#handler = SubHandler()
#sub = server.create_subscription(500, handler)
#handle = sub.subscribe_data_change(myvar)
import time
from opcua import ua, Server
if __name__ == "__main__":
# setup our server
server = Server()
server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
# setup our own namespace, not really necessary but should as spec
uri = "http://examples.freeopcua.github.io"
idx = server.register_namespace(uri)
# Import customobject type
server.import_xml('customobject.xml')
# get Objects node, this is where we should put our custom stuff
objects = server.get_objects_node()
# get nodeid of custom object type by :
# 1) Use node ID
# 2) Or Full path
# 3) Or As child from parent
nodeid_a = ua.NodeId.from_string('ns=1;i=1002')
nodeid_b = server.get_root_node().get_child(
["0:Types", "0:ObjectTypes", "0:BaseObjectType",
"1:MyObjectType"]).nodeid
nodeid_c = server.get_node(ua.ObjectIds.BaseObjectType).get_child(
["1:MyObjectType"]).nodeid
# server.set_security_policy([
# ua.SecurityPolicyType.NoSecurity,
# ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt,
# ua.SecurityPolicyType.Basic256Sha256_Sign])
# server.load_certificate("my_cert.der")
# server.load_certificate("my_cert.pem")
# server.load_private_key("my_private_key.pem")
# set up namespace
uri = "http://opcfoundation.org/UA/"
idx = server.register_namespace(uri)
# import the command list node from xml
server.import_xml("dobot-node.xml")
# get the command node
objects = server.get_objects_node()
commandListNode = objects.get_child(["0:CommandList"])
connectCommand = commandListNode.get_child(["0:Connect"])
connectCommand.set_writable()
homeCommand = commandListNode.get_child(["0:Home"])
myvar = commandListNode.add_variable(idx, "MyVariable", False)
# starting server
server.start()
try:
handler = SubHandler()
"Really nice string")
mystringvar.set_writable() # Set MyVariable to be writable by clients
mydtvar = myobj.add_variable(idx, "MyDateTimeVar", datetime.utcnow())
mydtvar.set_writable() # Set MyVariable to be writable by clients
myarrayvar = myobj.add_variable(idx, "myarrayvar", [6.7, 7.9])
myarrayvar = myobj.add_variable(idx, "myStronglytTypedVariable",
ua.Variant([], ua.VariantType.UInt32))
myprop = myobj.add_property(idx, "myproperty", "I am a property")
mymethod = myobj.add_method(idx, "mymethod", func, [ua.VariantType.Int64],
[ua.VariantType.Boolean])
multiply_node = myobj.add_method(
idx, "multiply", multiply,
[ua.VariantType.Int64, ua.VariantType.Int64], [ua.VariantType.Int64])
# import some nodes from xml
server.import_xml("custom_nodes.xml")
# creating a default event object
# The event object automatically will have members for all events properties
# you probably want to create a custom event type, see other examples
myevgen = server.get_event_generator()
myevgen.event.Severity = 300
# starting!
server.start()
print("Available loggers are: ", logging.Logger.manager.loggerDict.keys())
vup = VarUpdater(mysin) # just a stupide class update a variable
vup.start()
try:
# enable following if you want to subscribe to nodes on server side
#handler = SubHandler()
class TestServer(unittest.TestCase, CommonTests):
'''
Run common tests on server side
Tests that can only be run on server side must be defined here
'''
@classmethod
def setUpClass(self):
self.srv = Server()
self.srv.set_endpoint('opc.tcp://localhost:%d' % port_num2)
add_server_methods(self.srv)
self.srv.start()
self.opc = self.srv
self.discovery = Server()
self.discovery.set_application_uri("urn:freeopcua:python:discovery")
self.discovery.set_endpoint('opc.tcp://localhost:%d' % port_discovery)
self.discovery.start()
@classmethod
def tearDownClass(self):
self.srv.stop()
self.discovery.stop()
def test_discovery(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
servers = client.find_servers()
new_app_uri = "urn:freeopcua:python:server::test_discovery"
self.srv.application_uri = new_app_uri
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 1)
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers) , 1)
self.assertFalse(new_app_uri in [s.ApplicationUri for s in servers])
self.assertTrue(new_app_uri in [s.ApplicationUri for s in new_servers])
client.disconnect()
"""
# not sure if this test is necessary, and there is a lot repetition with previous test
def test_discovery_server_side(self):
servers = self.discovery.find_servers()
self.assertEqual(len(servers), 1)
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 1)
time.sleep(1) # let server register registration
servers = self.discovery.find_servers()
print("SERVERS 2", servers)
self.assertEqual(len(servers), 2)
"""
#def test_register_server2(self):
#servers = self.opc.register_server()
def test_register_namespace(self):
uri = 'http://mycustom.Namespace.com'
idx1 = self.opc.register_namespace(uri)
idx2 = self.opc.get_namespace_index(uri)
self.assertEqual(idx1, idx2)
def test_register_use_namespace(self):
uri = 'http://my_very_custom.Namespace.com'
idx = self.opc.register_namespace(uri)
root = self.opc.get_root_node()
myvar = root.add_variable(idx, 'var_in_custom_namespace', [5])
myid = myvar.nodeid
self.assertEqual(idx, myid.NamespaceIndex)
def test_server_method(self):
def func(parent, variant):
variant.Value *= 2
return [variant]
o = self.opc.get_objects_node()
v = o.add_method(3, 'Method1', func, [ua.VariantType.Int64], [ua.VariantType.Int64])
result = o.call_method(v, ua.Variant(2.1))
self.assertEqual(result, 4.2)
def test_xml_import(self):
self.srv.import_xml("tests/custom_nodes.xml")
o = self.opc.get_objects_node()
v = o.get_child(["MyXMLFolder", "MyXMLObject", "MyXMLVariable"])
val = v.get_value()
self.assertEqual(val, "StringValue")
