def __init__(self): 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) # 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") myvar1 = myobj.add_variable(idx, "MyVariable1", 1) myvar2 = myobj.add_variable(idx, "MyVariable2", 2) myvar3 = myobj.add_variable(idx, "MyVariable3", 3) myvar4 = myobj.add_variable(idx, "MyVariable4", 4) myvar5 = myobj.add_variable(idx, "MyVariable5", 5) myvar1.set_writable() # Set MyVariable to be writable by clients myvar2.set_writable() # Set MyVariable to be writable by clients myvar3.set_writable() # Set MyVariable to be writable by clients myvar4.set_writable() # Set MyVariable to be writable by clients myvar5.set_writable() # Set MyVariable to be writable by clients self.server = server
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()
def run_opcua_server(): """ Creates the OPC/UA server and starts it. """ # setup our server server = Server() server.set_endpoint("opc.tcp://localhost:26543/example/server") # setup our own namespace, not really necessary but should as spec uri = "https://github.com/nathanagood/aws-greengrass-samples" 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() try: count = 0 while True: time.sleep(5) count += 1 logger.debug('Setting value: %s', count) myvar.set_value(count) finally: #close connection, remove subcsriptions, etc server.stop()
def 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 server_namespace = "http://examples.freeopcua.github.io" address_space = server.register_namespace(server_namespace) # get Objects node, this is where we should put our custom stuff objects_node = server.get_objects_node() # Add the ocp objects (vars, features,...) # cresting the first object my_first_object = objects_node.add_object(address_space, "MyFirstObject") ##creating an array my_array = ChargeControllerObject.add_variable(address_space, "MyArray", [6.7, 7.9]) # the variable could be hard typed my_hardtyped_array = ChargeControllerObject.add_variable( address_space, "MyHardtypedArray", ua.Variant([], ua.VariantType.Float)) # starting! server.start() print("Server starting ...") while True: time.sleep(1) ## update array variables burst = [random.random() for _ in range(1024)] my_array.set_value(burst) my_hardtyped_array.set_value(burst)
def createOPCUA(): global server server = Server() url = "opc.tcp://10.148.6.70:4840" server.set_endpoint(url) name = "MOTOR_SIMULATION" addspace = server.register_namespace(name) node = server.get_objects_node() Param = node.add_object(addspace, "Parameters") Temp = Param.add_variable(addspace, "Temperature", 0) Vibr = Param.add_variable(addspace, "Vibration", 0) Curr = Param.add_variable(addspace, "Current", 0) Rpm = Param.add_variable(addspace, "Rate Per Minute", 0) Temp.set_writable() Vibr.set_writable() Curr.set_writable() Rpm.set_writable() server.start() print("Server started at {}".format(url)) return [Temp, Vibr, Curr, Rpm]
class TestClient(unittest.TestCase, CommonTests): ''' Run common tests on client side Of course we need a server so we start a server in another process using python Process module Tests that can only be run on client side must be defined here ''' @classmethod def setUpClass(self): # start our own server self.srv = Server() self.srv.set_endpoint('opc.tcp://localhost:%d' % port_num1) add_server_methods(self.srv) self.srv.start() # start client self.clt = Client('opc.tcp://localhost:%d' % port_num1) self.clt.connect() self.opc = self.clt @classmethod def tearDownClass(self): self.clt.disconnect() # stop the server in its own process self.srv.stop() def test_service_fault(self): request = ua.ReadRequest() request.TypeId = ua.FourByteNodeId(999) # bad type! with self.assertRaises(Exception): self.clt.bclient._send_request(request)
def start_server(url): server = Server() server.set_endpoint(url) name = "OPC UA Simulation Server" addspace = server.register_namespace(name) node = server.get_objects_node() lvl = node.add_object(addspace, "Level Sensors") lvl1 = lvl.add_variable(addspace, "LVL1", 5) lvl2 = lvl.add_variable(addspace, "LVL2", 6) lvl3 = lvl.add_variable(addspace, "LVL3", 7) lvl4 = lvl.add_variable(addspace, "LVL4", 8) lvl5 = lvl.add_variable(addspace, "LVL5", 9) lvl6 = lvl.add_variable(addspace, "LVL6", 10) flow = node.add_object(addspace, "Flow Sensors") flow1 = flow.add_variable(addspace, "FLOW1", 1) flow2 = flow.add_variable(addspace, "FLOW2", 2) flow3 = flow.add_variable(addspace, "FLOW3", 3) flow4 = flow.add_variable(addspace, "FLOW4", 4) pump = node.add_object(addspace, "Pump Actuators") pump1 = pump.add_variable(addspace, "PUMP1", 0.1) pump2 = pump.add_variable(addspace, "PUMP2", 0.2) pump3 = pump.add_variable(addspace, "PUMP3", 0.3) pump4 = pump.add_variable(addspace, "PUMP4", 0.4) pump5 = pump.add_variable(addspace, "PUMP5", 0.5) pump6 = pump.add_variable(addspace, "PUMP6", 0.6) server.start() return server
def __init__(self, port=Opcx.DEFAULT_PORT, name='OpcxServer'): from opcua import Server server = Server() server.set_server_name(name) server.set_endpoint("opc.tcp://0.0.0.0:%d/freeopcua/server/" % port) self.objix = server.register_namespace(Opcx.DEFAULT_URI) self.server = server
def generate_server(): """ GERANDO SERVIDOR - NOME, URL E IP """ server = Server() server.set_endpoint(URL) addspace = server.register_namespace(SERVER_NAME) return server, addspace
def 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 server_namespace = "http://examples.freeopcua.github.io" address_space = server.register_namespace(server_namespace) # get Objects node, this is where we should put our custom stuff objects_node = server.get_objects_node() # Add the ocp objects (vars, features,...) # cresting the first object my_first_object = objects_node.add_object(address_space, "MyFirstObject") ## Two different methods definitions # First method_1_node = my_first_object.add_method(address_space, "method_1_description", odd_or_even, [ua.VariantType.Int32], [ua.VariantType.Boolean]) # Second inarg_1 = ua.Argument() inarg_1.Name = "Argument_1" inarg_1.DataType = ua.NodeId(ua.ObjectIds.Float32) inarg_1.ValueRank = -1 inarg_1.ArrayDimensions = [] inarg_1.Description = ua.LocalizedText("Method argument 1 description") inarg_2 = ua.Argument() inarg_2.Name = "Argument_2" inarg_2.DataType = ua.NodeId(ua.ObjectIds.Float32) inarg_2.ValueRank = -1 inarg_2.ArrayDimensions = [] inarg_2.Description = ua.LocalizedText("Method argument 2 description") outarg = ua.Argument() outarg.Name = "Result" outarg.DataType = ua.NodeId(ua.ObjectIds.Float32) outarg.ValueRank = -1 outarg.ArrayDimensions = [] outarg.Description = ua.LocalizedText("Output argument description") method_2_node = my_first_object.add_method(address_space, "method_2_description", multiply, [inarg_1, inarg_2], [outarg]) # starting! server.start() print("Server starting ...") while True: time.sleep(1)
class TestRefsWidget(unittest.TestCase): def setUp(self): self.server = Server() self.server.set_endpoint("opc.tcp://0.0.0.0:48409/freeopcua/server/") self.server.start() self.widget = RefsWidget(QTableView()) def tearDown(self): self.server.stop() def test_1(self): o = self.server.nodes.objects self.widget.show_refs(o)
def run_OPCUA_server_start(): print("Starting OPC UA SERVER %s:%s" % (OPCUA_HOST, OPCUA_PORT)) # setup our server server = Server() server.set_endpoint("opc.tcp://%s:%s/freeopcua/server/" % (OPCUA_HOST, OPCUA_PORT)) # 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 imms = objects.add_object(idx, "IMMS") imms_date = imms.add_variable(idx, "DATE", 0, varianttype=ua.VariantType.Double) imms_date.set_writable() imms_time = imms.add_variable(idx, "TIME", "", varianttype=ua.VariantType.String) imms_time.set_writable() imms_ActSimPara1 = imms.add_variable(idx, "ActSimPara1", 0, varianttype=ua.VariantType.Double) imms_ActSimPara1.set_writable() imms_ActSimPara2 = imms.add_variable(idx, "ActSimPara2", 0, varianttype=ua.VariantType.Double) imms_ActSimPara2.set_writable() imms_ActCntCyc = imms.add_variable(idx, "ActCntCyc", 0, varianttype=ua.VariantType.Double) imms_ActCntCyc.set_writable() imms_ActCntPrt = imms.add_variable(idx, "ActCntPrt", 0, varianttype=ua.VariantType.Double) imms_ActCntPrt.set_writable() imms_ActStsMach = imms.add_variable(idx, "ActStsMach", "", varianttype=ua.VariantType.String) imms_ActStsMach.set_writable() imms_ActTimCyc = imms.add_variable(idx, "ActTimCyc", 5, varianttype=ua.VariantType.Double) imms_ActTimCyc.set_writable() imms_SetCntMld = imms.add_variable(idx, "SetCntMld", 0, varianttype=ua.VariantType.Double) imms_SetCntMld.set_writable() imms_SetCntPrt = imms.add_variable(idx, "SetCntPrt", 0, varianttype=ua.VariantType.Double) imms_SetCntPrt.set_writable() imms_SetTimCyc = imms.add_variable(idx, "SetTimCyc", 0, varianttype=ua.VariantType.Double) imms_SetTimCyc.set_writable() # starting! server.start()
def test_port_in_use(self): server1 = Server() server1.set_endpoint('opc.tcp://localhost:{0:d}'.format(port_num + 1)) server1.start() server2 = Server() server2.set_endpoint('opc.tcp://localhost:{0:d}'.format(port_num + 1)) try: server2.start() except Exception: pass server1.stop() server2.stop()
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 TestCmdLines(unittest.TestCase): ''' Test command lines ''' @classmethod def setUpClass(self): self.srv = Server() self.srv_url = 'opc.tcp://localhost:%d' % port_num self.srv.set_endpoint(self.srv_url) objects = self.srv.get_objects_node() obj = objects.add_object(4, "directory") var = obj.add_variable(4, "variable", 1.999) var2 = obj.add_variable(4, "variable2", 1.777) var2.set_writable() self.srv.start() def test_uals(self): s = subprocess.check_output(["python", "tools/uals", "--url", self.srv_url]) self.assertIn(b"i=85", s) self.assertNotIn(b"i=89", s) self.assertNotIn(b"1.999", s) s = subprocess.check_output(["python", "tools/uals", "--url", self.srv_url, "-d", "3"]) self.assertIn(b"1.999", s) def test_uaread(self): s = subprocess.check_output(["python", "tools/uaread", "--url", self.srv_url, "--path", "0:Objects,4:directory,4:variable"]) self.assertIn(b"1.999", s) def test_uawrite(self): s = subprocess.check_output(["python", "tools/uawrite", "--url", self.srv_url, "--path", "0:Objects,4:directory,4:variable2", "1.789"]) s = subprocess.check_output(["python", "tools/uaread", "--url", self.srv_url, "--path", "0:Objects,4:directory,4:variable2"]) self.assertIn(b"1.789", s) self.assertNotIn(b"1.999", s) def test_uadiscover(self): s = subprocess.check_output(["python", "tools/uadiscover", "--url", self.srv_url]) self.assertIn(b"opc.tcp://localhost", s) self.assertIn(b"FreeOpcUa", s) self.assertIn(b"urn:freeopcua:python:server", s) @classmethod def tearDownClass(self): self.srv.stop()
class TestClient(unittest.TestCase): def setUp(self): self.server = Server() url = "opc.tcp://localhost:48400/freeopcua/server/" self.server.set_endpoint(url) self.server.start() self.client = Window() self.client.ui.addrComboBox.setCurrentText(url) self.client.connect() def tearDown(self): self.client.disconnect() self.server.stop() def get_attr_value(self, text): idxlist = self.client.attrs_ui.model.match(self.client.attrs_ui.model.index(0, 0), Qt.DisplayRole, text, 1, Qt.MatchExactly | Qt.MatchRecursive) idx = idxlist[0] idx = idx.sibling(idx.row(), 1) item = self.client.attrs_ui.model.itemFromIndex(idx) return item.data(Qt.UserRole).value def test_select_objects(self): objects = self.server.nodes.objects self.client.tree_ui.set_current_node("Objects") self.assertEqual(objects, self.client.tree_ui.get_current_node()) self.assertGreater(self.client.attrs_ui.model.rowCount(), 6) print("REF COUNT", self.client.refs_ui.model.rowCount()) self.assertGreater(self.client.refs_ui.model.rowCount(), 1) data = self.get_attr_value("NodeId") self.assertEqual(data, objects.nodeid) def test_select_server_node(self): self.client.tree_ui.set_current_node("Objects") self.client.tree_ui.expand_current_node() # must be expanded to load children server_node = self.server.nodes.server self.client.tree_ui.set_current_node("Server") self.assertEqual(server_node, self.client.tree_ui.get_current_node()) self.assertGreater(self.client.attrs_ui.model.rowCount(), 6) self.assertGreater(self.client.refs_ui.model.rowCount(), 10) data = self.get_attr_value("NodeId") self.assertEqual(data, server_node.nodeid)
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 mymain(): # 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) # 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() 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)
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() 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")
class AdminTestClient(unittest.TestCase, CommonTests): ''' Run common tests on client side Of course we need a server so we start a server in another process using python Process module Tests that can only be run on client side must be defined here ''' @classmethod def setUpClass(self): # start our own server self.srv = Server() self.srv.set_endpoint('opc.tcp://*****:*****@localhost:%d' % port_num1) self.clt.connect() self.opc = self.clt # start anonymous client self.ro_clt = Client('opc.tcp://localhost:%d' % port_num1) self.ro_clt.connect() @classmethod def tearDownClass(self): #stop our clients self.ro_clt.disconnect() self.clt.disconnect() # stop the server self.srv.stop() def test_service_fault(self): request = ua.ReadRequest() request.TypeId = ua.FourByteNodeId(999) # bad type! with self.assertRaises(Exception): self.clt.bclient._send_request(request) def test_objects_anonymous(self): objects = self.ro_clt.get_objects_node() with self.assertRaises(Exception): objects.set_attribute(ua.AttributeIds.WriteMask, ua.DataValue(999)) with self.assertRaises(Exception): f = objects.add_folder(3, 'MyFolder') def test_folder_anonymous(self): objects = self.clt.get_objects_node() f = objects.add_folder(3, 'MyFolderRO') f_ro = self.ro_clt.get_node(f.nodeid) self.assertEqual(f, f_ro) with self.assertRaises(Exception): f2 = f_ro.add_folder(3, 'MyFolder2') def test_variable_anonymous(self): objects = self.clt.get_objects_node() v = objects.add_variable(3, 'MyROVariable', 6) v.set_value(4) #this should work v_ro = self.ro_clt.get_node(v.nodeid) with self.assertRaises(Exception): v_ro.set_value(2) self.assertEqual(v_ro.get_value(), 4) v.set_writable(True) v_ro.set_value(2) #now it should work self.assertEqual(v_ro.get_value(), 2) v.set_writable(False) with self.assertRaises(Exception): v_ro.set_value(9) self.assertEqual(v_ro.get_value(), 2)
# optional: setup logging logging.basicConfig(level=logging.WARN) # logger = logging.getLogger("opcua.address_space") # logger.setLevel(logging.DEBUG) # logger = logging.getLogger("opcua.internal_server") # logger.setLevel(logging.DEBUG) # logger = logging.getLogger("opcua.binary_server_asyncio") # logger.setLevel(logging.DEBUG) # logger = logging.getLogger("opcua.uaprocessor") # logger.setLevel(logging.DEBUG) # logger = logging.getLogger("opcua.subscription_service") # logger.setLevel(logging.DEBUG) # now setup our server server = Server() server.set_endpoint("opc.tcp://localhost:4841/freeopcua/server/") server.set_server_name("FreeOpcUa Example Server") # setup our own namespace uri = "http://examples.freeopcua.github.io" idx = server.register_namespace(uri) # get Objects node, this is where we should put our custom stuff objects = server.get_objects_node() # populating our address space myfolder = objects.add_folder(idx, "myfolder") myobj = objects.add_object(idx, "NewObject") myvar = myobj.add_variable(idx, "MyVariable", 6.7) myarrayvar = myobj.add_variable(idx, "myarrayvar", [6.7, 7.9]) myprop = myobj.add_property(idx, "myproperty", "I am a property")
def run(nodejson, endpoint, namespace, description): # now setup our server server = Server() #server.set_endpoint("opc.tcp://localhost:4840/freeopcua/server/") server.set_endpoint(endpoint) server.set_server_name(description) # setup our own namespace uri = namespace idx = server.register_namespace(uri) # get Objects node, this is where we should put our custom stuff objects = server.get_objects_node() variables = {} nodeId = 5 def add_variable(f, vals, nodeId): for x in vals: k = x if isinstance(x, str) or isinstance(x, unicode) else x.keys()[0] #v = f.add_variable("ns=6;i=600%d" % nodeId, k, ua.Variant([], ua.VariantType.Float)) v = f.add_variable("ns=6;i=600%d" % nodeId, x, ua.Variant([], ua.VariantType.Float)) # nodeid, browsename, value, [variant type] #v = f.add_variable("ns=6;s=%s" % x, x, ua.Variant([], ua.VariantType.Float)) v.set_writable() variables[k] = v nodeId = nodeId+1 return nodeId def add_folder(p, pid, val, nodeId): for n, v in val.items(): mf = p.add_folder("ns=%d;i=%d00%d" % (pid, pid, nodeId), n) #mf = p.add_folder("ns=%d;s=%s" % (pid, n), n) if isinstance(v, list) or isinstance(v, tuple): nodeId = add_variable(mf, v, nodeId+1) else: nodeId = add_folder(mf, pid+1, v, nodeId+1) return nodeId # populating our address space add_folder(objects, 5, nodejson, nodeId) ''' myobj = objects.add_object(idx, "MyObject") myvar = myobj.add_variable(idx, "MyVariable", 6.7) myvar.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]) inargx = ua.Argument() inargx.Name = "x" inargx.DataType = ua.NodeId(ua.ObjectIds.Int64) inargx.ValueRank = -1 inargx.ArrayDimensions = [] inargx.Description = ua.LocalizedText("First number x") inargy = ua.Argument() inargy.Name = "y" inargy.DataType = ua.NodeId(ua.ObjectIds.Int64) inargy.ValueRank = -1 inargy.ArrayDimensions = [] inargy.Description = ua.LocalizedText("Second number y") outarg = ua.Argument() outarg.Name = "Result" outarg.DataType = ua.NodeId(ua.ObjectIds.Int64) outarg.ValueRank = -1 outarg.ArrayDimensions = [] outarg.Description = ua.LocalizedText("Multiplication result") multiply_node = myobj.add_method(idx, "multiply", multiply, [inargx, inargy], [outarg]) ''' # starting! server.start() #print("Available loggers are: ", logging.Logger.manager.loggerDict.keys()) return server, variables
class TestClient(unittest.TestCase, CommonTests, SubscriptionTests): ''' Run common tests on client side Of course we need a server so we start also start a server Tests that can only be run on client side must be defined in this class ''' @classmethod def setUpClass(self): # start our own server self.srv = Server() self.srv.set_endpoint('opc.tcp://*****:*****@localhost:%d' % port_num1, timeout=10) self.clt.connect() self.opc = self.clt # start anonymous client self.ro_clt = Client('opc.tcp://localhost:%d' % port_num1) self.ro_clt.connect() @classmethod def tearDownClass(self): #stop our clients self.ro_clt.disconnect() self.clt.disconnect() # stop the server self.srv.stop() def test_service_fault(self): request = ua.ReadRequest() request.TypeId = ua.FourByteNodeId(999) # bad type! with self.assertRaises(ua.UaStatusCodeError): self.clt.uaclient._uasocket.send_request(request) def test_objects_anonymous(self): objects = self.ro_clt.get_objects_node() with self.assertRaises(ua.UaStatusCodeError): objects.set_attribute(ua.AttributeIds.WriteMask, ua.DataValue(999)) with self.assertRaises(ua.UaStatusCodeError): f = objects.add_folder(3, 'MyFolder') def test_folder_anonymous(self): objects = self.clt.get_objects_node() f = objects.add_folder(3, 'MyFolderRO') f_ro = self.ro_clt.get_node(f.nodeid) self.assertEqual(f, f_ro) with self.assertRaises(ua.UaStatusCodeError): f2 = f_ro.add_folder(3, 'MyFolder2') def test_variable_anonymous(self): objects = self.clt.get_objects_node() v = objects.add_variable(3, 'MyROVariable', 6) v.set_value(4) #this should work v_ro = self.ro_clt.get_node(v.nodeid) with self.assertRaises(ua.UaStatusCodeError): v_ro.set_value(2) self.assertEqual(v_ro.get_value(), 4) v.set_writable(True) v_ro.set_value(2) #now it should work self.assertEqual(v_ro.get_value(), 2) v.set_writable(False) with self.assertRaises(ua.UaStatusCodeError): v_ro.set_value(9) self.assertEqual(v_ro.get_value(), 2) def test_context_manager(self): """ Context manager calls connect() and disconnect() """ state = [0] def increment_state(self, *args, **kwargs): state[0] += 1 # create client and replace instance methods with dummy methods client = Client('opc.tcp://dummy_address:10000') client.connect = increment_state.__get__(client) client.disconnect = increment_state.__get__(client) assert state[0] == 0 with client: # test if client connected self.assertEqual(state[0], 1) # test if client disconnected self.assertEqual(state[0], 2)
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 OPCServer(object): def __init__(self, settings): super(OPCServer, self).__init__() server_settings = settings.get("server") objects = settings.get("objects") self._endpoint = server_settings["endpoint"] self._name = server_settings["name"] self._namespace = server_settings["namespace"] self._init_server() for o in objects: self._add_object(o["name"]) for variable, value in o["ro_variables"].items(): self._add_variable(o["name"], variable, value) for variable, value in o["rw_variables"].items(): self._add_variable(o["name"], variable, value, True) def start(self): if self._server: self._server.start() def _init_server(self): self._server = Server() self._server.set_endpoint(self._endpoint) self._server.set_server_name(self._name) self._index = self._server.register_namespace(self._namespace) _log.info("Index: %r" % (self._index,)) self._objects_node = self._server.get_objects_node() _log.info("Node: %r" % (self._objects_node)) self._objects = {} _log.info("Endpoints: %r" % (self._server.get_endpoints())) def stop(self): self._server.stop() def _add_object(self, object_name): self._objects[object_name] = { 'object': self._objects_node.add_object(self._index, object_name), 'variables' : {}} def _add_variable(self, object_name, variable_name, value, writable=False): obj = self._objects.get(object_name, None) if obj.get('object', None): var = self._objects_node.add_variable(self._index, variable_name, str(value)) obj['variables'][variable_name] = var if writable: var.set_writable() return True return False def _get_variable(self, object_name, variable_name): obj = self._objects.get(object_name) if obj.get('object', None): var = obj['variables'].get(variable_name, None) return var return None def set_value(self, object_name, variable_name, value): var = self._get_variable(object_name, variable_name) if var: var.set_value(str(value)) return True return False def get_value(self, object_name, variable_name): var = self._get_variable(object_name, variable_name) if var: return var.get_value() return None
class TestCryptoConnect(unittest.TestCase): ''' Test connectino with a server supporting crypto ''' @classmethod def setUpClass(self): # start our own server self.srv_crypto = Server() self.uri_crypto = 'opc.tcp://localhost:%d' % port_num1 self.srv_crypto.set_endpoint(self.uri_crypto) # load server certificate and private key. This enables endpoints # with signing and encryption. self.srv_crypto.load_certificate("examples/certificate-example.der") self.srv_crypto.load_private_key("examples/private-key-example.pem") self.srv_crypto.start() # start a server without crypto self.srv_no_crypto = Server() self.uri_no_crypto = 'opc.tcp://localhost:%d' % port_num2 self.srv_no_crypto.set_endpoint(self.uri_no_crypto) self.srv_no_crypto.start() @classmethod def tearDownClass(self): # stop the server self.srv_no_crypto.stop() self.srv_crypto.stop() def test_nocrypto(self): clt = Client(self.uri_no_crypto) clt.connect() try: clt.get_objects_node().get_children() finally: clt.disconnect() def test_nocrypto_feil(self): clt = Client(self.uri_no_crypto) with self.assertRaises(ua.UaError): clt.set_security_string("Basic256,Sign,examples/certificate-example.der,examples/private-key-example.pem") def test_basic256(self): clt = Client(self.uri_crypto) try: clt.set_security_string("Basic256,Sign,examples/certificate-example.der,examples/private-key-example.pem") clt.connect() self.assertTrue(clt.get_objects_node().get_children()) finally: clt.disconnect() def test_basic256_encrypt(self): clt = Client(self.uri_crypto) try: clt.set_security_string("Basic256,SignAndEncrypt,examples/certificate-example.der,examples/private-key-example.pem") clt.connect() self.assertTrue(clt.get_objects_node().get_children()) finally: clt.disconnect() def test_basic128Rsa15(self): clt = Client(self.uri_crypto) try: clt.set_security_string("Basic128Rsa15,Sign,examples/certificate-example.der,examples/private-key-example.pem") clt.connect() self.assertTrue(clt.get_objects_node().get_children()) finally: clt.disconnect() def test_basic128Rsa15_encrypt(self): clt = Client(self.uri_crypto) try: clt.set_security_string("Basic128Rsa15,SignAndEncrypt,examples/certificate-example.der,examples/private-key-example.pem") clt.connect() self.assertTrue(clt.get_objects_node().get_children()) finally: clt.disconnect() def test_basic256_encrypt_success(self): clt = Client(self.uri_crypto) try: clt.set_security(security_policies.SecurityPolicyBasic256, 'examples/certificate-example.der', 'examples/private-key-example.pem', None, ua.MessageSecurityMode.SignAndEncrypt ) clt.connect() self.assertTrue(clt.get_objects_node().get_children()) finally: clt.disconnect() def test_basic256_encrypt_feil(self): # FIXME: how to make it feil??? clt = Client(self.uri_crypto) with self.assertRaises(ua.UaError): clt.set_security(security_policies.SecurityPolicyBasic256, 'examples/certificate-example.der', 'examples/private-key-example.pem', None, ua.MessageSecurityMode.None_ )
class TestAttrsWidget(unittest.TestCase): def setUp(self): self.server = Server() self.server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/") self.server.start() self.widget = AttrsWidget(QTreeView()) def tearDown(self): self.server.stop() def find_item(self, text): idxlist = self.widget.model.match(self.widget.model.index(0, 0), Qt.DisplayRole, text, 1, Qt.MatchExactly | Qt.MatchRecursive) idx = idxlist[0] return idx def modify_item(self, text, val, match_to_use=0): """ modify the current item and set its displayed value to 'val' """ idxlist = self.widget.model.match(self.widget.model.index(0, 0), Qt.DisplayRole, text, match_to_use + 1, Qt.MatchExactly | Qt.MatchRecursive) if not idxlist: raise RuntimeError("Item with text '{}' not found".format(text)) idx = idxlist[match_to_use] self.widget.view.setCurrentIndex(idx) idx = idx.sibling(idx.row(), 1) self.widget.view.edit(idx) editor = self.widget.view.focusWidget() if not editor: print(app.focusWidget()) print("NO EDITOR WIDGET") #QTest.keyClick(self.widget.view, Qt.Key_Return) from IPython import embed embed() raise RuntimeError("Could not get editor widget!, it does not have the focus") if hasattr(editor, "_current_node"): editor._current_node = val elif hasattr(editor, "setCurrentText"): editor.setCurrentText(val) else: editor.setText(val) self.widget.view.commitData(editor) self.widget.view.closeEditor(editor, QAbstractItemDelegate.NoHint) self.widget.view.reset() def modify_value(self, val): self.modify_item("Value", val, 1) def test_display_objects_node(self): objects = self.server.nodes.objects self.widget.show_attrs(objects) self.modify_item("BrowseName", "5:titi") self.assertEqual(objects.get_browse_name().to_string(), "5:titi") self.modify_item("BrowseName", "0:Objects") # restore states for other tests def test_display_var_double(self): objects = self.server.nodes.objects myvar = objects.add_variable(1, "myvar1", 9.99, ua.VariantType.Double) self.widget.show_attrs(myvar) self.modify_value("8.45") self.assertEqual(myvar.get_value(), 8.45) def test_display_var_bytes(self): objects = self.server.nodes.objects myvar = objects.add_variable(1, "myvar_bytes", b"jkl", ua.VariantType.ByteString) self.widget.show_attrs(myvar) self.modify_value("titi") self.assertEqual(myvar.get_value(), b"titi") def test_change_data_type(self): objects = self.server.nodes.objects myvar = objects.add_variable(1, "myvar1", 9.99, ua.VariantType.Double) self.widget.show_attrs(myvar) dtype = myvar.get_data_type() self.assertEqual(dtype, ua.NodeId(ua.ObjectIds.Double)) new_dtype = ua.NodeId(ua.ObjectIds.String) self.modify_item("DataType", self.server.get_node(new_dtype)) self.assertEqual(myvar.get_data_type(), new_dtype) # now try to write a value which is a string self.modify_value("mystring") self.assertEqual(myvar.get_value(), "mystring") def test_change_value_rank(self): # need to find a way to modify combo box with QTest objects = self.server.nodes.objects myvar = objects.add_variable(1, "myvar1", 9.99, ua.VariantType.Double) self.widget.show_attrs(myvar) rank = myvar.get_value_rank() self.modify_item("ValueRank", "ThreeDimensions") self.assertEqual(myvar.get_value_rank(), ua.ValueRank.ThreeDimensions)
# optional: setup logging logging.basicConfig(level=logging.WARN) #logger = logging.getLogger("opcua.address_space") # logger.setLevel(logging.DEBUG) #logger = logging.getLogger("opcua.internal_server") # logger.setLevel(logging.DEBUG) #logger = logging.getLogger("opcua.binary_server_asyncio") # logger.setLevel(logging.DEBUG) #logger = logging.getLogger("opcua.uaprocessor") # logger.setLevel(logging.DEBUG) # now setup our server server = Server() #server.disable_clock() #server.set_endpoint("opc.tcp://localhost:4840/freeopcua/server/") server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/") server.set_server_name("FreeOpcUa Example Server") # setup our own namespace uri = "http://examples.freeopcua.github.io" idx = server.register_namespace(uri) # create a new node type we can instantiate in our address space dev = server.nodes.base_object_type.add_object_type(0, "MyDevice") dev.add_variable(0, "sensor1", 1.0) dev.add_property(0, "device_id", "0340") ctrl = dev.add_object(0, "controller") ctrl.add_property(0, "state", "Idle") # populating our address space
handler.setFormatter(formatter) logger.addHandler(handler) sys.stdout = MyLogger(logger, logging.INFO) if __name__ == "__main__": #Creamos una instancia del servidor OPC UA server = Server() # Establecemos la comunicación de nuestro servidor opc ua # load server certificate and private key. This enables endpoints #Cargamos el certificado del servidor y la clave privada #esto activa la comunicación con firma y cifrado. if len(sys.argv) == 2: server.set_endpoint("opc.tcp://%s" % sys.argv[1] ) server.load_certificate("certificate-example.der") server.load_private_key("private-key-example.pem") elif len(sys.argv) == 3: server.set_endpoint("opc.tcp://%s" % sys.argv[1] ) server.load_certificate("%s/certificate-example.der" % sys.argv[2]) server.load_private_key("%s/private-key-example.pem" % sys.argv[2]) else: a = len(sys.argv) print ("Numero de argumentos inexperado: %s" %a) print "opcua_server.py ip:puerto (rutacertificado)" sys.exit(1) # Declaración del espacio de nombres (no necesario) uri = "SERVIDOR OPC-UA - ARDUINO:FreeOpcUa:python-opcua" idx = server.register_namespace(uri)