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)
class Servidor_OPCUA: def __init__(self): self.server = Server() self.server.set_endpoint("opc.tcp://localhost:4840/freeopcua/server/") self.server.set_server_name("Stack IIoT") self.namespaces = {} self.objects = self.server.get_objects_node() # Para agregar un nuevo namespace def new_namespace(self, uri, namespace, nombre): idx = self.server.register_namespace(uri) print('New namespace: {}'.format(idx)) Namespace = namespace( self.objects, idx, self.server) # Se declaran todas las variables del nuevo namespace self.namespaces[nombre] = Namespace def start(self): global alarma, valor_alarma, mensaje_alarma self.server.start() for nombre, namespace in self.namespaces.items(): namespace.subscripciones() # Se incia el loop del servidor try: while True: time.sleep(0.1) for nombre, namespace in self.namespaces.items(): namespace.monitorea_alarma() finally: 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 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 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 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 server_opc(): server = Server() server.set_endpoint("opc.tcp://0.0.0.0:4840/vm_opc") server.set_server_name("Servidor notificaciones vm") # setup our own namespace, not really necessary but should as spec uri = "notif VM" 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, "notif_vm") event_id = myobj.add_variable(idx, "ID evento", float(0)) # new_st.set_writable() tss = myobj.add_variable(idx, "Timestamp", datetime.datetime.now()) # new_st.set_writable() progresiva = myobj.add_variable(idx, "Progresiva", float(-1)) estado_alarma = myobj.add_variable(idx, "Estado alarma", 'inicio') criticidad = myobj.add_variable(idx, "Criticidad", float(-1)) ack_bit = myobj.add_variable(idx, "ACK bit", False) ack_bit.set_writable() alarma_activa = myobj.add_variable(idx, "Alarma presente", False) # starting! tags = { 'id': event_id, 'tss': tss, 'prog': progresiva, 'st': estado_alarma, 'crit': criticidad, 'ack': ack_bit, 'active': alarma_activa } server.start() try: while True: if np.random.uniform() >= 0.5: tags['id'].set_value(float(np.random.randint(500))) tags['tss'].set_value(datetime.datetime.now()) tags['st'].set_value(choice(['inicio', 'cambio', 'fin'])) else: print 'Bit ACK: ', tags['ack'].get_value( ), datetime.datetime.now() time.sleep(3) finally: #close connection, remove subcsriptions, etc server.stop()
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()
def start(): mServer = Server() mServer.set_endpoint(URL) mServer.set_security_policy([ ua.SecurityPolicyType.NoSecurity, ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt, ua.SecurityPolicyType.Basic256Sha256_Sign ]) address_space = mServer.register_namespace(NAMESPACE_NAME) root_node = mServer.get_objects_node() params = root_node.add_object(address_space, "Parameters") start_time = params.add_variable(address_space, "start_time", start_timestamp) data = root_node.add_object(address_space, "data") pump = data.add_object(address_space, "Pump") temperature = 20 + random.randint(0, 10) pump_temp_var = pump.add_variable(address_space, "temperature", temperature) pump_temp_vup = VarUpdater( pump_temp_var) # just a dummy class update a variable pump_temp_unit = pump.add_variable(address_space, "unit", "°C") pump_status = pump.add_variable(address_space, "status", False) pump_status.set_writable() level = 12 pump_level = pump.add_variable(address_space, "level", level) pump_level.set_writable() sleep_period = 0.5 # Start the server mServer.start() print("Server started at {}".format(URL)) print("root_node: " + root_node.__str__()) print("params: " + params.__str__()) print("pump: " + pump.__str__()) # print(""+pump) # enable following if you want to subscribe to nodes on server side handler = SubHandler() sub = mServer.create_subscription(500, handler) handle = sub.subscribe_data_change(pump_level) # IMPORTANT: This should be started after the mServer.start() pump_temp_vup.start() try: while True: time.sleep(sleep_period) finally: # close connection, remove subscriptions, etc pump_temp_vup.stop() # should be stopped mServer.stop()
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 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_simulation_server(steps): """ This support function creates a simple OPC UA server with node listed in the config file :param steps: Lifecycle of the server :return: """ with open('../src_test/config_test.yaml') as config_file: cfg = yaml.safe_load(config_file) # setup the server server = Server() server.set_endpoint(cfg['opcua']['url']) # setup the namespace uri = "http://examples.freeopcua.github.io" idx = server.register_namespace(uri) # get objects node objects = server.get_objects_node() # server start server.start() log_event(cfg, 'OPCUA TEST SERVER', '', 'INFO', 'OPC UA server started') # populating the address space myobj = objects.add_object(idx, "TestDataAssembly") nodes = [] metrics = cfg['metrics'] for metric in metrics: metric_id = metric['metric_id'] meas = metric['measurement'] tag = metric['tagname'] var = metric['variable'] ns = metric['nodeNamespace'] id = metric['nodeId'] method = metric['method'] time_interval = metric['interval'] node_str = 'ns=' + str(ns) + '; i=' + str(id) nodes.append(myobj.add_variable(node_str, var, -1)) # update variable time.sleep(1) for it in range(steps): for node in nodes: node.set_value(node.get_value() + 1) time.sleep(0.5) time.sleep(2) server.stop() log_event(cfg, 'OPCUA TEST SERVER', '', 'INFO', 'OPC UA server stopped')
class EFLEXAgent(): def __init__(self, eflex_type=EFLEXAgentType.CONSUMER, port=4840, name="EFLEX Agent"): self.eflex_type = eflex_type self.name = name self.port = port self.server = Server() self.configure_server(self.server) def __str__(self): return "EFLEX AGENT OPC UA Server: %s" % self.port def configure_server(self, server): """ Configure the agent OPC UA Server """ server.set_endpoint("opc.tcp://0.0.0.0:%s/EFlex-Agent" % self.port) server.set_server_name("%s" % self.name) server.set_security_policy([ ua.SecurityPolicyType.NoSecurity, ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt, ua.SecurityPolicyType.Basic256Sha256_Sign ]) server.set_application_uri("urn:fau:faps:OPCUAEFLEXAgent:server") objects = server.get_objects_node() server.import_xml("./IM/Opc.Ua.Di.NodeSet2.xml") server.import_xml("./IM/Opc.Ua.Plc.NodeSet2.xml") server.import_xml("./IM/packmltest.xml") server.import_xml("./IM/packml_eflex_modified.xml") uri = "http://faps.fau.de/OPCUAEFLEXAgent" idx = server.register_namespace(uri) idx_eflex = server.get_namespace_index( "http://siemens.com/PackML_Eflex/") # Configure the method calls method_node = server.get_node(ua.NodeId(9850), idx_eflex) def start(self): """ Start the agent OPC UA Server """ self.server.start() def stop(self): """ Stop the agent OPC UA Server """ self.server.stop()
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()
def main(): FORMAT = '%(asctime)-15s - %(message)s' logging.basicConfig(filename='opcua.log', level=logging.DEBUG, format=FORMAT) # logging.basicConfig(level=logging.DEBUG, format=FORMAT) # log = LoggerUtility.get_logger("dht11.log") # log.info("**************************** START ****************************") # 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://paolopasqua.site" idx = server.register_namespace(uri) # get Objects node, this is where we should put our nodes objects = server.get_objects_node() d = sOPCUA_DHT(sOPCUA_DHT.DHT11, "test", "D24") d.register_to_server(idx, objects) #26 19 13 6 r1 = sOPCUA_Relay(26, "1") r1.register_to_server(idx, objects) r2 = sOPCUA_Relay(19, "2") r2.register_to_server(idx, objects) r3 = sOPCUA_Relay(13, "3") r3.register_to_server(idx, objects) r4 = sOPCUA_Relay(6, "4") r4.register_to_server(idx, objects) shutdown = False try: server.start() while not shutdown: pass finally: #close connection, remove subcsriptions, etc server.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 CustomServer(object): def __init__(self): self.server = Server() # setup our server self.server.set_endpoint(os.environ.get("SERVER_ENDPOINT")) # setup our own namespace, not really necessary but should as spec uri = os.environ.get("NAMESPACE") self.idx = self.server.register_namespace(uri) def start(self): self.server.start() print(self.__class__.__name__, " successful started") def stop(self): self.server.stop() print(self.__class__.__name__, " successful stopped")
def main(): # create Server object server = Server() # define ip address for the server. format: 'opc.tcp://[ip_address]' url = 'opc.tcp://0.0.0.0:4840/freeopcua/server/' server.set_endpoint(url) # define address space name = 'OPCUA_SIMULATION_SERVER' addspace = server.register_namespace(name) # get root node root_node = server.get_objects_node() # define node where we wish to run parameters # assign to address space and name it 'Parameters' obj = root_node.add_object(addspace, 'Parameters') # We will use three parameters: temperature, pressure, time temp_param = obj.add_variable(addspace, 'Temperature', 0) pres_param = obj.add_variable(addspace, 'Pressure', 0) time_param = obj.add_variable(addspace, 'Time', 0) # make variables writable temp_param.set_writable() pres_param.set_writable() time_param.set_writable() server.start() print(f'server started at {url}') try: count = 0 while True: time.sleep(1) count += 0.1 temp_param.set_value(random.random()) pres_param.set_value(random.randint(1, 100)) time_param.set_value(count) finally: # close connection, remove subcsriptions, etc server.stop()
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)
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)
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 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()
def opcua_converter_main(options): # setup our server server = Server() uasecurity = UaSecurity() if uasecurity.get_securitytype() == 'tls': server_cert, client_cert, private_key = uasecurity.get_certificates() if server_cert is None: logger.error( 'tls is enabled, but server cert is missing with current configuration' ) sys.exit(-1) if private_key is None: logger.error( 'tls is enabled, but private key is missing with current configuration' ) sys.exit(-1) server.load_certificate(server_cert) server.load_private_key(private_key) ConfigHistoryStorage(server) server.start() # setup adapter adapter = PlugInAdapter(options.conf_file) handler = SubHandler(server, adapter) handler.run() adapter.subscription(handler.datachange_notification, handler.event_notification) adapter.start() try: while True: logger.debug('opcua converter running......') time.sleep(60) finally: # close connection, remove subcsriptions, etc adapter.stop() server.stop()
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) # trigger event, all subscribed clients wil receive it mydevice_var.set_value("Running") myevgen.trigger(message="This is BaseEvent") embed() finally: server.stop()
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 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 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)
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 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
# setup our own namespace, not really necessary but should as spec uri = "opcv" idx = server.register_namespace(uri) # get Objects node, this is where we should put our nodes objects = server.get_objects_node() # AMK - Here we declare our objects and data! # populating our address space myobj = objects.add_object(idx, "Data") dist = myobj.add_variable(idx, "Xdist", -1) side = myobj.add_variable(idx, "Xdist", -1) # myvar.set_writable() # Set MyVariable to be writable by clients # starting! server.start() try: ### AMK - Here Goes our code! count = 0 while True: time.sleep(1) count += 0.1 # dist.set_value(count) side.set_value(count+10) finally: #close connection, remove subcsriptions, etc server.stop()
class MyGroveOpcTerminalApp: def __init__(self): self.warehouse_state = False self.door_outside_state = False self.door_inside_state = False self.warehouse_button = GroveLedButton(5) self.door_outside_button = GroveLedButton(18) self.door_inside_button = GroveLedButton(16) self.warehouse_button.on_press = self.on_press_main self.door_outside_button.on_press = self.on_press_door_outside self.door_inside_button.on_press = self.on_press_door_inside self.warehouse_relay = GroveRelay(22) self.door_outside_relay = GroveRelay(26) self.door_inside_relay = GroveRelay(24) self.time_stamp = datetime.now() self.temperature_doors = Factory.getTemper("MCP9808-I2C", 0x18) self.temperature_doors.resolution(Temper.RES_1_16_CELSIUS) self.temperature_warehouse = Factory.getTemper("MCP9808-I2C", 0x19) self.temperature_warehouse.resolution(Temper.RES_1_16_CELSIUS) print('starting OPC server ') self.opc_server = Server(shelffile="/home/pi/grove-opc-server") # shelffile is trick with freeopcua to speedup loading of xml object base self.opc_url = "opc.tcp://0.0.0.0:4840" self.opc_server.set_endpoint(self.opc_url) print('starting OPC server ..') self.opc_name = "Grove-opcua-server" self.addspace = self.opc_server.register_namespace(self.opc_name) print('starting OPC server ...') self.opc_node = self.opc_server.get_objects_node() self.param = self.opc_node.add_object(self.addspace, "Parameters") self.opc_time = self.param.add_variable(self.addspace, "Time", 0) self.opc_trigger = self.param.add_variable(self.addspace, "Trigger", 0) self.opc_warehouse_state = self.param.add_variable( self.addspace, "Warehouse state", 0) self.opc_door_outside = self.param.add_variable( self.addspace, "Outside door", 0) self.opc_door_inside = self.param.add_variable(self.addspace, "Inside door", 0) self.opc_temperature_d = self.param.add_variable( self.addspace, "Temperature doorlock", 0.0) self.opc_temperature_w = self.param.add_variable( self.addspace, "Temperature warehouse", 0.0) self.opc_time.set_read_only() self.opc_trigger.set_read_only() self.opc_warehouse_state.set_read_only() self.opc_door_outside.set_read_only() self.opc_door_inside.set_read_only() self.opc_temperature_d.set_read_only() self.opc_temperature_w.set_read_only() print('starting OPC server .....') self.opc_server.start() print("OPC UA Server started at {}".format(self.opc_url)) print("time Doors Warehouse (Celsius)") def closeapp(self): self.warehouse_relay.off() self.door_outside_relay.off() self.door_inside_relay.off() self.warehouse_button.led_off() self.door_outside_button.led_off() self.door_inside_button.led_off() self.opc_server.stop() print("exit") # self.master.destroy() exit(1) def update_opc(self, trigger): self.time_stamp = datetime.now() self.opc_time.set_value(self.time_stamp) self.opc_temperature_d.set_value(self.temperature_doors.temperature) self.opc_temperature_w.set_value( self.temperature_warehouse.temperature) print('{} {:.1f} {:.1f}'.format( self.time_stamp.strftime("%X"), self.temperature_doors.temperature, self.temperature_warehouse.temperature)) self.opc_trigger.set_value(trigger) self.opc_warehouse_state.set_value(self.warehouse_state) self.opc_door_outside.set_value(self.door_outside_state) self.opc_door_inside.set_value(self.door_inside_state) def on_press_main(self): if self.warehouse_state: self.warehouse_state = False self.door_outside_state = False self.door_inside_state = False self.warehouse_relay.off() self.door_outside_relay.off() self.door_inside_relay.off() self.warehouse_button.led_off() self.door_outside_button.led_off() self.door_inside_button.led_off() else: self.warehouse_state = True self.warehouse_relay.on() self.warehouse_button.led_on() self.update_opc(1) def on_press_door_outside(self): if self.warehouse_state: if self.door_outside_state: self.door_outside_state = False self.door_outside_relay.off() self.door_outside_button.led_off() else: if not self.door_inside_state: self.door_outside_state = True self.door_outside_relay.on() self.door_outside_button.led_on() self.update_opc(2) def on_press_door_inside(self): if self.warehouse_state: if self.door_inside_state: self.door_inside_state = False self.door_inside_relay.off() self.door_inside_button.led_off() else: if not self.door_outside_state: self.door_inside_state = True self.door_inside_relay.on() self.door_inside_button.led_on() self.update_opc(3) # start functie is voor terminal-mode, niet voor windows mode def start(self): """Start event system and own cyclic loop.""" while True: try: # dirty temp (client changes every 5 sec opc_warehouse_state) if self.opc_warehouse_state.get_value(): self.warehouse_button.led_on() else: self.warehouse_button.led_off() time.sleep(5) self.update_opc(0) except KeyboardInterrupt: self.closeapp()
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 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)
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)
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 MyServer: ''' initialise opcua server object ''' def __init__(self): self.opc_server = UAServer() # OPC UA server instance self.opc_objects_dict = {} self.opc_variables_dict = {} # self.db_server=Server.query.get( server_id ) # self.initialise() self.instantiate_server_vars() def get_db(self, server_id): self.db_server = Server.query.get(server_id) self.instantiate_server_vars() ''' Instantiate all server related variables from the Sqlite DB server to the opcua server instance ''' def initialise(self): self.instantiate_server_vars() def instantiate_server_vars(self): self.opc_server_endpoint = "opc.tcp://" + self.db_server.server_endpoint_url self.opc_server_name = self.db_server.server_name self.opc_server_uri = self.db_server.server_namespace self.ns_idx = self.opc_server.register_namespace(self.opc_server_uri) self.opc_objects = self.opc_server.get_objects_node() self.opc_server.set_endpoint(self.opc_server_endpoint) self.load_server(self.db_server.server_objects) ''' load opc server with objects and variables from the SQlite DB ''' def load_server(self, db_objects, parent_obj=None): for server_obj in db_objects: if (server_obj.id not in self.opc_objects_dict): if parent_obj is None: self.opc_objects_dict[ server_obj.id] = self.opc_objects.add_object( self.ns_idx, server_obj.object_name) else: self.opc_objects_dict[ server_obj.id] = parent_obj.add_object( self.ns_idx, server_obj.object_name) self.load_object_variables( server_obj.object_variables, self.opc_objects_dict[server_obj.id]) if (server_obj.get_child_objects().count() > 0): self.load_server(server_obj.get_child_objects(), self.opc_objects_dict[server_obj.id]) def load_object_variables(self, variables, object_owner): for variable in variables: self.opc_variables_dict[ variable.variable_address] = object_owner.add_variable( self.ns_idx, variable.variable_name, convert_val(variable.variable_value, variable.variable_type)) if variable.variable_writable: self.opc_variables_dict[ variable.variable_address].set_writable() def start_opc_server(self): self.opc_server.start() def stop_opc_server(self): self.opc_server.stop() @classmethod def kill_all_servers(cls): for addr in addrs: pass
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 OpcUaConnectorGeneralTest(ConnectorTestBase): def test_number_one(self): self._create_connector("connection_test.json") self.assertTrue(self.connector is not None) self.check_or_create_server() self.connector.open() def check_or_create_server(self): if not hasattr(self, "test_server"): self.test_server = Server() self.__server_thread = Thread(target=self.__server_run, name="Test OPC UA server", args=(self.test_server,)) self.assertTrue(self.test_server is not None) def __server_run(self, test_server): self.test_server = test_server class SubHandler(object): def datachange_notification(self, node, val, data): print("Python: New data change event", node, val) def event_notification(self, event): print("Python: New event", event) @uamethod def multiply(parent, x, y): return x * y self.test_server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/") self.test_server.set_server_name("Test Server") self.test_server.set_security_policy([ ua.SecurityPolicyType.NoSecurity, ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt, ua.SecurityPolicyType.Basic256Sha256_Sign]) uri = "http://127.0.0.1" idx = self.test_server.register_namespace(uri) device = self.test_server.nodes.objects.add_object(idx, "Device1") name = self.test_server.nodes.objects.add_variable(idx, "serialNumber", "TEST") name.set_writable() temperature_and_humidity = device.add_object(idx, "TemperatureAndHumiditySensor") temperature = temperature_and_humidity.add_variable(idx, "Temperature", 56.7) humidity = temperature_and_humidity.add_variable(idx, "Humidity", 68.7) battery = device.add_object(idx, "Battery") battery_level = battery.add_variable(idx, "batteryLevel", 24) device.add_method(idx, "multiply", multiply, [ua.VariantType.Int64, ua.VariantType.Int64], [ua.VariantType.Int64]) self.test_server.start() try: while self.server_running: sleep(.1) finally: self.test_server.stop() def stop_test_server(self): self.server_running = False def tearDown(self): super().tearDown() self.stop_test_server()
def stop(self): Server.stop(self)
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")
def main(): # logging.basicConfig(level=logging.ERROR) # logger=logging.getLogger("opcua.server.internal_subscription") # logger.setLevel(logging.ERROR) read = open('config.txt', 'r') configs = read.readlines() read.close() server = Server() endpoint = configs[0].split('@')[1].rstrip('\n') servername = configs[1].split('@')[1].rstrip('\n') kafkaservers = configs[2].split('@')[1].replace("'", "").replace( "\"", "").rstrip('\n') kafkaserver = kafkaservers[1:-1].split(',') kafkatopic = configs[3].split('@')[1].rstrip('\n') eventname = configs[4].split('@')[1].rstrip('\n') # auto_offset_reset='earlist' consumer = KafkaConsumer(kafkatopic, bootstrap_servers=kafkaserver) server.set_endpoint(endpoint) server.set_server_name(servername) print("Program running......") print("Please do not close this page") # 证书 # server.load_certificate("certificate-example.der") # server.load_private_key("private-key-example.pem") # 安全策略 server.set_security_policy([ ua.SecurityPolicyType.NoSecurity, # ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt, # ua.SecurityPolicyType.Basic256Sha256_Sign ]) uri = "http://taiji.com.cn" idx = server.register_namespace(uri) objs = server.get_objects_node() myobj = objs.add_object(idx, "MyObject") # 节点 taglists = readFile("node.csv") for taglist in taglists: # myobj.add_variable(idx, taglist, 6.7).set_writable() myobj.add_variable(idx, taglist, random.random()).set_writable() # myobj.add_variable(idx, taglist, 6.7) attrs = readFile("ae_attr.csv") custom_etype = server.nodes.base_event_type.add_object_type(idx, eventname) for attr in attrs: custom_etype.add_property(2, attr, ua.Variant("", ua.VariantType.String)) myevent = server.get_event_generator(custom_etype, myobj) server.start() try: rootnode = server.get_root_node().get_child( ["0:Objects", "{}:MyObject".format(idx)]) rootnodes = rootnode.get_variables() nodeAll = {} for i in range(len(rootnodes)): nodeId = rootnodes[i] nodeName = rootnodes[i].get_browse_name().Name nodeAll.update({nodeName: nodeId}) for message in consumer: recv = message.value.decode("utf8") # print("recvevent=",recv) if recv[0] == '{' and recv[-1] == '}': nodeKafka = json.loads(recv) # print("nodeKafka=", nodeKafka) comName = nodeKafka.keys() & nodeAll.keys() for row in comName: rootnode.get_child(["2:{}".format(row) ]).set_value(nodeKafka[row]) else: recv = recv.replace('\n', '').replace('\r', '') datas = recv.split("|")[1:] # print("datas=", datas) if len(datas) == 9: for i in range(len(attrs)): # exec("myevent.event.{}='{}'".format(attrs[i], datas[i].replace('\n', '').replace('\r', ''))) exec("myevent.event.{}='{}'".format( attrs[i], datas[i])) myevent.trigger() else: # continue f = open('ErrorAE.bak', 'a', encoding='utf8') f.write(recv) f.write('\n') f.close # print("mysecondevgen=",mysecondevgen) # print("mysecondevgen=", myevent.event) except Exception as e: print(e) finally: server.stop()