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)
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 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()
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()
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)
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 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 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()
