def main():
# setup our server
server = Server()
server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
# setup our own namespace, not really necessary but should as spec
server_namespace = "http://examples.freeopcua.github.io"
address_space = server.register_namespace( server_namespace )
# get Objects node, this is where we should put our custom stuff
objects_node = server.get_objects_node()
# Add the ocp objects (vars, features,...)
# cresting the first object
my_first_object = objects_node.add_object(address_space, "MyFirstObject")
# creating 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
my_first_event_generator = server.get_event_generator()
my_first_event_generator.event.Severity = 300
# Creating a custom EVENT
eventType = server.create_custom_event_type(
address_space,
'ThresholdEvent',
ua.ObjectIds.BaseEventType,
[
('value', ua.VariantType.Float),
('alarmEnabled', ua.VariantType.Boolean),
]
)
my_custom_event_generator = server.get_event_generator(eventType, my_first_object)
# starting!
server.start()
print( "Server starting ...")
rndEv = RandomEventsGenerator(my_first_event_generator) # just a stupide class update a variable
rndEv.start()
while True:
time.sleep(1)
sensor_value = random.random()
threshold = 0.9
if sensor_value > threshold:
my_custom_event_generator.event.Message = ua.LocalizedText("Value is graeter than th")
my_custom_event_generator.event.value = ua.Variant(sensor_value, ua.VariantType.Float)
my_custom_event_generator.event.alarmenabled = ua.Variant( outputsEnabled , ua.VariantType.Boolean)
my_custom_event_generator.event.Severity = ua.Variant( 1 , ua.VariantType.Int32)
my_custom_event_generator.trigger()
myarrayvar = myobj.add_variable(idx, "myStronglytTypedVariable",
ua.Variant([], ua.VariantType.UInt32))
myprop = myobj.add_property(idx, "myproperty", "I am a property")
mymethod = myobj.add_method(idx, "mymethod", func, [ua.VariantType.Int64],
[ua.VariantType.Boolean])
multiply_node = myobj.add_method(
idx, "multiply", multiply,
[ua.VariantType.Int64, ua.VariantType.Int64], [ua.VariantType.Int64])
# import some nodes from xml
server.import_xml("custom_nodes.xml")
# creating a default event object
# The event object automatically will have members for all events properties
# you probably want to create a custom event type, see other examples
myevgen = server.get_event_generator()
myevgen.event.Severity = 300
# starting!
server.start()
print("Available loggers are: ", logging.Logger.manager.loggerDict.keys())
vup = VarUpdater(mysin) # just a stupide class update a variable
vup.start()
try:
# enable following if you want to subscribe to nodes on server side
#handler = SubHandler()
#sub = server.create_subscription(500, handler)
#handle = sub.subscribe_data_change(myvar)
# trigger event, all subscribed clients wil receive it
var = myarrayvar.get_value(
) # return a ref to value in db server side! not a copy!
mystringvar.set_writable() # Set MyVariable to be writable by clients
mydtvar = myobj.add_variable(idx, "MyDateTimeVar", datetime.now())
mydtvar.set_writable() # Set MyVariable to be writable by clients
myarrayvar = myobj.add_variable(idx, "myarrayvar", [6.7, 7.9])
myarrayvar = myobj.add_variable(idx, "myStronglytTypedVariable", ua.Variant([], ua.VariantType.UInt32))
myprop = myobj.add_property(idx, "myproperty", "I am a property")
mymethod = myobj.add_method(idx, "mymethod", func, [ua.VariantType.Int64], [ua.VariantType.Boolean])
multiply_node = myobj.add_method(idx, "multiply", multiply, [ua.VariantType.Int64, ua.VariantType.Int64], [ua.VariantType.Int64])
# import some nodes from xml
server.import_xml("custom_nodes.xml")
# creating a default event object
# The event object automatically will have members for all events properties
# you probably want to create a custom event type, see other examples
myevgen = server.get_event_generator()
myevgen.event.Severity = 300
# starting!
server.start()
print("Available loggers are: ", logging.Logger.manager.loggerDict.keys())
try:
# enable following if you want to subscribe to nodes on server side
#handler = SubHandler()
#sub = server.create_subscription(500, handler)
#handle = sub.subscribe_data_change(myvar)
# trigger event, all subscribed clients wil receive it
mydevice_var.set_value("Running")
myevgen.trigger(message="This is BaseEvent")
embed()
# populating our address space
myobj = objects.add_object(idx, "MyObject")
myvar = myobj.add_variable(idx, "MyVariable", ua.Variant(0, ua.VariantType.Double))
myvar.set_writable() # Set MyVariable to be writable by clients
# Creating a custom event: Approach 1
# The custom event object automatically will have members from its parent (BaseEventType)
etype = server.create_custom_event_type(2, 'MyFirstEvent', ua.ObjectIds.BaseEventType,
[('MyNumericProperty', ua.VariantType.Float),
('MyStringProperty', ua.VariantType.String)])
# create second event
etype2 = server.create_custom_event_type(2, 'MySecondEvent', ua.ObjectIds.BaseEventType,
[('MyOtherProperty', ua.VariantType.Float)])
myevgen = server.get_event_generator(etype, myobj)
myevgen.event.Severity = 500
myevgen.event.MyStringProperty = ua.Variant("hello world")
myevgen2 = server.get_event_generator(etype2, myobj)
myevgen2.event.Severity = 123
myevgen2.event.MyOtherProperty = ua.Variant(1.337)
serverevgen = server.get_event_generator()
serverevgen.event.Severity = 111
# Configure server to use sqlite as history database (default is a simple in memory dict)
server.iserver.history_manager.set_storage(HistorySQLite(":memory:"))
# starting!
server.start()
server.set_server_name("OPCUA-Test")
address_space = server.register_namespace("http://andreas-heine.net/UA")
root_node = server.get_root_node()
object_node = server.get_objects_node()
server_node = server.get_server_node()
parameter_obj = object_node.add_object(address_space, "Parameter")
random_node = parameter_obj.add_variable(address_space, "random",
ua.Variant(0, ua.VariantType.UInt64))
etype = server.create_custom_event_type(
address_space, 'MyFirstEvent', ua.ObjectIds.BaseEventType,
[('MyNumericProperty', ua.VariantType.Float),
('MyStringProperty', ua.VariantType.String)])
myevgen = server.get_event_generator(etype, parameter_obj)
vars_obj = object_node.add_object(address_space, "Vars")
var_list = []
for i in range(100):
var = vars_obj.add_variable(
ua.NodeId.from_string(f'ns={address_space};s=DB_DATA.Test.var{i}'),
f'Test.var{i}', 0)
var.set_writable(True)
var_list.append(var)
async def servicelevel_updater(servicelevel_node):
value = 0
while True:
await asyncio.sleep(1)
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)
# populating our address space
obj = objects.add_object(idx, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ")
f1 = obj.add_variable(idx, "F1", 6.7)
f1.set_writable() # Set MyVariable to be writable by clients
f2 = obj.add_variable(idx, "F2", 'hello')
f2.set_writable()
custom_etype = server.nodes.base_event_type.add_object_type(
2, 'MySecondEvent')
custom_etype.add_property(2, 'MyIntProperty',
ua.Variant(0, ua.VariantType.Int32))
custom_etype.add_property(2, 'MyBoolProperty',
ua.Variant(True, ua.VariantType.Boolean))
mysecondevgen = server.get_event_generator(custom_etype, obj)
# starting!
server.start()
try:
count = 0
while True:
time.sleep(1)
count += 0.1
f1.set_value(count)
mysecondevgen.trigger(message="MySecondEvent " + str(count))
finally:
# close connection, remove subcsriptions, etc
server.stop()
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()
class TestServer(unittest.TestCase, CommonTests, SubscriptionTests):
'''
Run common tests on server side
Tests that can only be run on server side must be defined here
'''
@classmethod
def setUpClass(self):
self.srv = Server()
self.srv.set_endpoint('opc.tcp://localhost:%d' % port_num)
add_server_methods(self.srv)
self.srv.start()
self.opc = self.srv
self.discovery = Server()
self.discovery.set_application_uri("urn:freeopcua:python:discovery")
self.discovery.set_endpoint('opc.tcp://localhost:%d' % port_discovery)
self.discovery.start()
@classmethod
def tearDownClass(self):
self.srv.stop()
self.discovery.stop()
def test_discovery(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
try:
servers = client.find_servers()
new_app_uri = "urn:freeopcua:python:server:test_discovery"
self.srv.application_uri = new_app_uri
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 0)
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers) , 1)
self.assertFalse(new_app_uri in [s.ApplicationUri for s in servers])
self.assertTrue(new_app_uri in [s.ApplicationUri for s in new_servers])
finally:
client.disconnect()
def test_find_servers2(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
try:
servers = client.find_servers()
new_app_uri1 = "urn:freeopcua:python:server:test_discovery1"
self.srv.application_uri = new_app_uri1
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), period=0)
new_app_uri2 = "urn:freeopcua:python:test_discovery2"
self.srv.application_uri = new_app_uri2
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), period=0)
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers) , 2)
self.assertFalse(new_app_uri1 in [s.ApplicationUri for s in servers])
self.assertFalse(new_app_uri2 in [s.ApplicationUri for s in servers])
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertTrue(new_app_uri2 in [s.ApplicationUri for s in new_servers])
# now do a query with filer
new_servers = client.find_servers(["urn:freeopcua:python:server"])
self.assertEqual(len(new_servers) - len(servers) , 0)
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertFalse(new_app_uri2 in [s.ApplicationUri for s in new_servers])
# now do a query with filer
new_servers = client.find_servers(["urn:freeopcua:python"])
self.assertEqual(len(new_servers) - len(servers) , 2)
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertTrue(new_app_uri2 in [s.ApplicationUri for s in new_servers])
finally:
client.disconnect()
"""
# not sure if this test is necessary, and there is a lot repetition with previous test
def test_discovery_server_side(self):
servers = self.discovery.find_servers()
self.assertEqual(len(servers), 1)
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 1)
time.sleep(1) # let server register registration
servers = self.discovery.find_servers()
print("SERVERS 2", servers)
self.assertEqual(len(servers), 2)
"""
#def test_register_server2(self):
#servers = self.opc.register_server()
def test_register_namespace(self):
uri = 'http://mycustom.Namespace.com'
idx1 = self.opc.register_namespace(uri)
idx2 = self.opc.get_namespace_index(uri)
self.assertEqual(idx1, idx2)
def test_register_use_namespace(self):
uri = 'http://my_very_custom.Namespace.com'
idx = self.opc.register_namespace(uri)
root = self.opc.get_root_node()
myvar = root.add_variable(idx, 'var_in_custom_namespace', [5])
myid = myvar.nodeid
self.assertEqual(idx, myid.NamespaceIndex)
def test_server_method(self):
def func(parent, variant):
variant.Value *= 2
return [variant]
o = self.opc.get_objects_node()
v = o.add_method(3, 'Method1', func, [ua.VariantType.Int64], [ua.VariantType.Int64])
result = o.call_method(v, ua.Variant(2.1))
self.assertEqual(result, 4.2)
def test_xml_import(self):
self.srv.import_xml("tests/custom_nodes.xml")
o = self.opc.get_objects_node()
v = o.get_child(["MyXMLFolder", "MyXMLObject", "MyXMLVariable"])
val = v.get_value()
self.assertEqual(val, "StringValue")
def test_historize_variable(self):
o = self.opc.get_objects_node()
var = o.add_variable(3, "test_hist", 1.0)
self.srv.iserver.enable_history_data_change(var, timedelta(days=1))
time.sleep(1)
var.set_value(2.0)
var.set_value(3.0)
self.srv.iserver.disable_history_data_change(var)
def test_historize_events(self):
srv_node = self.srv.get_node(ua.ObjectIds.Server)
srvevgen = self.srv.get_event_generator()
self.srv.iserver.enable_history_event(srv_node, period=None)
srvevgen.trigger(message="Message")
self.srv.iserver.disable_history_event(srv_node)
def test_references_for_added_nodes_method(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
nodes = objects.get_referenced_nodes(refs=ua.ObjectIds.Organizes, direction=ua.BrowseDirection.Forward, includesubtypes=False)
self.assertTrue(o in nodes)
nodes = o.get_referenced_nodes(refs=ua.ObjectIds.Organizes, direction=ua.BrowseDirection.Inverse, includesubtypes=False)
self.assertTrue(objects in nodes)
self.assertEqual(o.get_parent(), objects)
self.assertEqual(o.get_type_definition(), ua.ObjectIds.BaseObjectType)
@uamethod
def callback(parent):
return
m = o.add_method(3, 'MyMethod', callback)
nodes = o.get_referenced_nodes(refs=ua.ObjectIds.HasComponent, direction=ua.BrowseDirection.Forward, includesubtypes=False)
self.assertTrue(m in nodes)
nodes = m.get_referenced_nodes(refs=ua.ObjectIds.HasComponent, direction=ua.BrowseDirection.Inverse, includesubtypes=False)
self.assertTrue(o in nodes)
self.assertEqual(m.get_parent(), o)
# This should work for following BaseEvent tests to work (maybe to write it a bit differentlly since they are not independent)
def test_get_event_from_type_node_BaseEvent(self):
ev = opcua.server.event.get_event_from_type_node(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)))
check_base_event(self, ev)
def test_get_event_from_type_node_Inhereted_AuditEvent(self):
ev = opcua.server.event.get_event_from_type_node(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.AuditEventType)))
self.assertIsNot(ev, None) # we did not receive event
self.assertIsInstance(ev, ua.BaseEvent)
self.assertIsInstance(ev, ua.AuditEvent)
self.assertEqual(ev.EventType, ua.NodeId(ua.ObjectIds.AuditEventType))
self.assertEqual(ev.Severity, ua.Variant(1, ua.VariantType.UInt16))
self.assertEqual(ev.ActionTimeStamp, None)
self.assertEqual(ev.Status, False)
self.assertEqual(ev.ServerId, None)
self.assertEqual(ev.ClientAuditEntryId, None)
self.assertEqual(ev.ClientUserId, None)
self.assertEqual(ev._freeze, True)
def test_eventgenerator_default(self):
evgen = self.opc.get_event_generator()
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_object(self):
evgen = self.opc.get_event_generator(ua.BaseEvent())
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_Node(self):
evgen = self.opc.get_event_generator(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_NodeId(self):
evgen = self.opc.get_event_generator(ua.NodeId(ua.ObjectIds.BaseEventType))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_ObjectIds(self):
evgen = self.opc.get_event_generator(ua.ObjectIds.BaseEventType)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_Identifier(self):
evgen = self.opc.get_event_generator(2041)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_Node(self):
evgen = self.opc.get_event_generator(source=opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.Server)))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_NodeId(self):
evgen = self.opc.get_event_generator(source=ua.NodeId(ua.ObjectIds.Server))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_ObjectIds(self):
evgen = self.opc.get_event_generator(source=ua.ObjectIds.Server)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceMyObject(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
evgen = self.opc.get_event_generator(source=o)
check_eventgenerator_BaseEvent(self, evgen)
check_event_generator_object(self, evgen, o)
def test_eventgenerator_source_collision(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
event = ua.BaseEvent(sourcenode=o.nodeid)
evgen = self.opc.get_event_generator(event, ua.ObjectIds.Server)
check_eventgenerator_BaseEvent(self, evgen)
check_event_generator_object(self, evgen, o)
def test_eventgenerator_InheritedEvent(self):
evgen = self.opc.get_event_generator(ua.ObjectIds.AuditEventType)
check_eventgenerator_SourceServer(self, evgen)
ev = evgen.event
self.assertIsNot(ev, None) # we did not receive event
self.assertIsInstance(ev, ua.BaseEvent)
self.assertIsInstance(ev, ua.AuditEvent)
self.assertEqual(ev.EventType, ua.NodeId(ua.ObjectIds.AuditEventType))
self.assertEqual(ev.Severity, ua.Variant(1, ua.VariantType.UInt16))
self.assertEqual(ev.ActionTimeStamp, None)
self.assertEqual(ev.Status, False)
self.assertEqual(ev.ServerId, None)
self.assertEqual(ev.ClientAuditEntryId, None)
self.assertEqual(ev.ClientUserId, None)
self.assertEqual(ev._freeze, True)
def test_create_custom_event_type_ObjectId(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
check_custom_event_type(self, etype)
def test_create_custom_event_type_NodeId(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.NodeId(ua.ObjectIds.BaseEventType), [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
check_custom_event_type(self, etype)
def test_create_custom_event_type_Node(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)), [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
check_custom_event_type(self, etype)
def test_get_event_from_type_node_CustomEvent(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
ev = opcua.server.event.get_event_from_type_node(etype)
check_custom_event(self, ev, etype)
self.assertEqual(ev.PropertyNum, None)
self.assertEqual(ev.PropertyString, None)
def test_eventgenerator_customEvent(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
evgen = self.opc.get_event_generator(etype, ua.ObjectIds.Server)
check_eventgenerator_CustomEvent(self, evgen, etype)
check_eventgenerator_SourceServer(self, evgen)
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
def test_eventgenerator_double_customEvent(self):
event1 = self.opc.create_custom_event_type(3, 'MyEvent1', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
event2 = self.opc.create_custom_event_type(4, 'MyEvent2', event1, [('PropertyBool', ua.VariantType.Boolean), ('PropertyInt', ua.VariantType.Int32)])
evgen = self.opc.get_event_generator(event2, ua.ObjectIds.Server)
check_eventgenerator_CustomEvent(self, evgen, event2)
check_eventgenerator_SourceServer(self, evgen)
# Properties from MyEvent1
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
# Properties from MyEvent2
self.assertEqual(evgen.event.PropertyBool, None)
self.assertEqual(evgen.event.PropertyInt, None)
def test_eventgenerator_customEvent_MyObject(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Float), ('PropertyString', ua.VariantType.String)])
evgen = self.opc.get_event_generator(etype, o)
check_eventgenerator_CustomEvent(self, evgen, etype)
check_event_generator_object(self, evgen, o)
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
myvar = myobj.add_variable(idx, "MyVariable",
ua.Variant(0, ua.VariantType.Double))
myvar.set_writable() # Set MyVariable to be writable by clients
# Creating a custom event: Approach 1
# The custom event object automatically will have members from its parent (BaseEventType)
etype = server.create_custom_event_type(
2, 'MyFirstEvent', ua.ObjectIds.BaseEventType,
[('MyNumericProperty', ua.VariantType.Float),
('MyStringProperty', ua.VariantType.String)])
# create second event
etype2 = server.create_custom_event_type(
2, 'MySecondEvent', ua.ObjectIds.BaseEventType,
[('MyOtherProperty', ua.VariantType.Float)])
myevgen = server.get_event_generator(etype, myobj)
myevgen.event.Severity = 500
myevgen.event.MyStringProperty = ua.Variant("hello world")
myevgen2 = server.get_event_generator(etype2, myobj)
myevgen2.event.Severity = 123
myevgen2.event.MyOtherProperty = ua.Variant(1.337)
serverevgen = server.get_event_generator()
serverevgen.event.Severity = 111
# Configure server to use sqlite as history database (default is a simple in memory dict)
server.iserver.history_manager.set_storage(
HistorySQLite("my_event_history.sql"))
# starting!
# get Objects node, this is where we should put our custom stuff
objects = server.get_objects_node()
# populating our address space
myobj = objects.add_object(idx, "MyObject")
# Creating a custom event: Approach 1
# The custom event object automatically will have members from its parent (BaseEventType)
etype = server.create_custom_event_type(
2,
"MyFirstEvent",
ua.ObjectIds.BaseEventType,
[("MyNumericProperty", ua.VariantType.Float), ("MyStringProperty", ua.VariantType.String)],
)
myevgen = server.get_event_generator(etype, myobj)
myevgen.event.Severity = 500
# Creating a custom event: Approach 2
base_etype = server.get_node(ua.ObjectIds.BaseEventType)
custom_etype = base_etype.add_subtype(2, "MySecondEvent")
custom_etype.add_property(2, "MyIntProperty", ua.Variant(None, ua.VariantType.Int32))
custom_etype.add_property(2, "MyBoolProperty", ua.Variant(None, ua.VariantType.Boolean))
mysecondevgen = server.get_event_generator(custom_etype, myobj)
# starting!
server.start()
try:
# time.sleep is here just because we want to see events in UaExpert
class TestServer(unittest.TestCase, CommonTests, SubscriptionTests):
'''
Run common tests on server side
Tests that can only be run on server side must be defined here
'''
@classmethod
def setUpClass(self):
self.srv = Server()
self.srv.set_endpoint('opc.tcp://localhost:%d' % port_num)
add_server_methods(self.srv)
self.srv.start()
self.opc = self.srv
self.discovery = Server()
self.discovery.set_application_uri("urn:freeopcua:python:discovery")
self.discovery.set_endpoint('opc.tcp://localhost:%d' % port_discovery)
self.discovery.start()
@classmethod
def tearDownClass(self):
self.srv.stop()
self.discovery.stop()
def test_discovery(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
try:
servers = client.find_servers()
new_app_uri = "urn:freeopcua:python:server:test_discovery"
self.srv.application_uri = new_app_uri
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 0)
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers) , 1)
self.assertFalse(new_app_uri in [s.ApplicationUri for s in servers])
self.assertTrue(new_app_uri in [s.ApplicationUri for s in new_servers])
finally:
client.disconnect()
def test_find_servers2(self):
client = Client(self.discovery.endpoint.geturl())
client.connect()
try:
servers = client.find_servers()
new_app_uri1 = "urn:freeopcua:python:server:test_discovery1"
self.srv.application_uri = new_app_uri1
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), period=0)
new_app_uri2 = "urn:freeopcua:python:test_discovery2"
self.srv.application_uri = new_app_uri2
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), period=0)
time.sleep(0.1) # let server register registration
new_servers = client.find_servers()
self.assertEqual(len(new_servers) - len(servers) , 2)
self.assertFalse(new_app_uri1 in [s.ApplicationUri for s in servers])
self.assertFalse(new_app_uri2 in [s.ApplicationUri for s in servers])
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertTrue(new_app_uri2 in [s.ApplicationUri for s in new_servers])
# now do a query with filer
new_servers = client.find_servers(["urn:freeopcua:python:server"])
self.assertEqual(len(new_servers) - len(servers) , 0)
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertFalse(new_app_uri2 in [s.ApplicationUri for s in new_servers])
# now do a query with filer
new_servers = client.find_servers(["urn:freeopcua:python"])
self.assertEqual(len(new_servers) - len(servers) , 2)
self.assertTrue(new_app_uri1 in [s.ApplicationUri for s in new_servers])
self.assertTrue(new_app_uri2 in [s.ApplicationUri for s in new_servers])
finally:
client.disconnect()
"""
# not sure if this test is necessary, and there is a lot repetition with previous test
def test_discovery_server_side(self):
servers = self.discovery.find_servers()
self.assertEqual(len(servers), 1)
self.srv.register_to_discovery(self.discovery.endpoint.geturl(), 1)
time.sleep(1) # let server register registration
servers = self.discovery.find_servers()
print("SERVERS 2", servers)
self.assertEqual(len(servers), 2)
"""
#def test_register_server2(self):
#servers = self.opc.register_server()
def test_register_namespace(self):
uri = 'http://mycustom.Namespace.com'
idx1 = self.opc.register_namespace(uri)
idx2 = self.opc.get_namespace_index(uri)
self.assertEqual(idx1, idx2)
def test_register_existing_namespace(self):
uri = 'http://mycustom.Namespace.com'
idx1 = self.opc.register_namespace(uri)
idx2 = self.opc.register_namespace(uri)
idx3 = self.opc.get_namespace_index(uri)
self.assertEqual(idx1, idx2)
self.assertEqual(idx1, idx3)
def test_register_use_namespace(self):
uri = 'http://my_very_custom.Namespace.com'
idx = self.opc.register_namespace(uri)
root = self.opc.get_root_node()
myvar = root.add_variable(idx, 'var_in_custom_namespace', [5])
myid = myvar.nodeid
self.assertEqual(idx, myid.NamespaceIndex)
def test_server_method(self):
def func(parent, variant):
variant.Value *= 2
return [variant]
o = self.opc.get_objects_node()
v = o.add_method(3, 'Method1', func, [ua.VariantType.Int64], [ua.VariantType.Int64])
result = o.call_method(v, ua.Variant(2.1))
self.assertEqual(result, 4.2)
def test_xml_import(self):
self.srv.import_xml("tests/custom_nodes.xml")
o = self.opc.get_objects_node()
v = o.get_child(["MyXMLFolder", "MyXMLObject", "MyXMLVariable"])
val = v.get_value()
self.assertEqual(val, "StringValue")
node_path = ["Types", "DataTypes", "BaseDataType", "Enumeration",
"1:MyEnum", "0:EnumStrings"]
o = self.opc.get_root_node().get_child(node_path)
self.assertEqual(len(o.get_value()), 3)
# Check if method is imported
node_path = ["Types", "ObjectTypes", "BaseObjectType",
"1:MyObjectType", "1:MyMethod"]
o = self.opc.get_root_node().get_child(node_path)
self.assertEqual(len(o.get_referenced_nodes()), 4)
# Check if InputArgs are imported and can be read
node_path = ["Types", "ObjectTypes", "BaseObjectType",
"1:MyObjectType", "1:MyMethod", "InputArguments"]
o = self.opc.get_root_node().get_child(node_path)
input_arg = o.get_data_value().Value.Value[0]
self.assertEqual(input_arg.Name, 'Context')
def test_historize_variable(self):
o = self.opc.get_objects_node()
var = o.add_variable(3, "test_hist", 1.0)
self.srv.iserver.enable_history_data_change(var, timedelta(days=1))
time.sleep(1)
var.set_value(2.0)
var.set_value(3.0)
self.srv.iserver.disable_history_data_change(var)
def test_historize_events(self):
srv_node = self.srv.get_node(ua.ObjectIds.Server)
srvevgen = self.srv.get_event_generator()
self.srv.iserver.enable_history_event(srv_node, period=None)
srvevgen.trigger(message="Message")
self.srv.iserver.disable_history_event(srv_node)
def test_references_for_added_nodes_method(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
nodes = objects.get_referenced_nodes(refs=ua.ObjectIds.Organizes, direction=ua.BrowseDirection.Forward, includesubtypes=False)
self.assertTrue(o in nodes)
nodes = o.get_referenced_nodes(refs=ua.ObjectIds.Organizes, direction=ua.BrowseDirection.Inverse, includesubtypes=False)
self.assertTrue(objects in nodes)
self.assertEqual(o.get_parent(), objects)
self.assertEqual(o.get_type_definition().Identifier, ua.ObjectIds.BaseObjectType)
@uamethod
def callback(parent):
return
m = o.add_method(3, 'MyMethod', callback)
nodes = o.get_referenced_nodes(refs=ua.ObjectIds.HasComponent, direction=ua.BrowseDirection.Forward, includesubtypes=False)
self.assertTrue(m in nodes)
nodes = m.get_referenced_nodes(refs=ua.ObjectIds.HasComponent, direction=ua.BrowseDirection.Inverse, includesubtypes=False)
self.assertTrue(o in nodes)
self.assertEqual(m.get_parent(), o)
# This should work for following BaseEvent tests to work (maybe to write it a bit differentlly since they are not independent)
def test_get_event_from_type_node_BaseEvent(self):
ev = opcua.common.events.get_event_obj_from_type_node(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)))
check_base_event(self, ev)
def test_get_event_from_type_node_Inhereted_AuditEvent(self):
ev = opcua.common.events.get_event_obj_from_type_node(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.AuditEventType)))
self.assertIsNot(ev, None) # we did not receive event
self.assertIsInstance(ev, BaseEvent)
self.assertIsInstance(ev, AuditEvent)
self.assertEqual(ev.EventType, ua.NodeId(ua.ObjectIds.AuditEventType))
self.assertEqual(ev.Severity, 1)
self.assertEqual(ev.ActionTimeStamp, None)
self.assertEqual(ev.Status, False)
self.assertEqual(ev.ServerId, None)
self.assertEqual(ev.ClientAuditEntryId, None)
self.assertEqual(ev.ClientUserId, None)
def test_eventgenerator_default(self):
evgen = self.opc.get_event_generator()
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_object(self):
evgen = self.opc.get_event_generator(BaseEvent())
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_Node(self):
evgen = self.opc.get_event_generator(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_NodeId(self):
evgen = self.opc.get_event_generator(ua.NodeId(ua.ObjectIds.BaseEventType))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_ObjectIds(self):
evgen = self.opc.get_event_generator(ua.ObjectIds.BaseEventType)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_BaseEvent_Identifier(self):
evgen = self.opc.get_event_generator(2041)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_Node(self):
evgen = self.opc.get_event_generator(source=opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.Server)))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_NodeId(self):
evgen = self.opc.get_event_generator(source=ua.NodeId(ua.ObjectIds.Server))
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceServer_ObjectIds(self):
evgen = self.opc.get_event_generator(source=ua.ObjectIds.Server)
check_eventgenerator_BaseEvent(self, evgen)
check_eventgenerator_SourceServer(self, evgen)
def test_eventgenerator_sourceMyObject(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
evgen = self.opc.get_event_generator(source=o)
check_eventgenerator_BaseEvent(self, evgen)
check_event_generator_object(self, evgen, o)
def test_eventgenerator_source_collision(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
event = BaseEvent(sourcenode=o.nodeid)
evgen = self.opc.get_event_generator(event, ua.ObjectIds.Server)
check_eventgenerator_BaseEvent(self, evgen)
check_event_generator_object(self, evgen, o)
def test_eventgenerator_InheritedEvent(self):
evgen = self.opc.get_event_generator(ua.ObjectIds.AuditEventType)
check_eventgenerator_SourceServer(self, evgen)
ev = evgen.event
self.assertIsNot(ev, None) # we did not receive event
self.assertIsInstance(ev, BaseEvent)
self.assertIsInstance(ev, AuditEvent)
self.assertEqual(ev.EventType, ua.NodeId(ua.ObjectIds.AuditEventType))
self.assertEqual(ev.Severity, 1)
self.assertEqual(ev.ActionTimeStamp, None)
self.assertEqual(ev.Status, False)
self.assertEqual(ev.ServerId, None)
self.assertEqual(ev.ClientAuditEntryId, None)
self.assertEqual(ev.ClientUserId, None)
# For the custom events all posibilites are tested. For other custom types only one test case is done since they are using the same code
def test_create_custom_data_type_ObjectId(self):
type = self.opc.create_custom_data_type(2, 'MyDataType', ua.ObjectIds.BaseDataType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
check_custom_type(self, type, ua.ObjectIds.BaseDataType)
def test_create_custom_event_type_ObjectId(self):
type = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
check_custom_type(self, type, ua.ObjectIds.BaseEventType)
def test_create_custom_object_type_ObjectId(self):
def func(parent, variant):
return [ua.Variant(ret, ua.VariantType.Boolean)]
properties = [('PropertyNum', ua.VariantType.Int32),
('PropertyString', ua.VariantType.String)]
variables = [('VariableString', ua.VariantType.String),
('MyEnumVar', ua.VariantType.Int32, ua.NodeId(ua.ObjectIds.ApplicationType))]
methods = [('MyMethod', func, [ua.VariantType.Int64], [ua.VariantType.Boolean])]
node_type = self.opc.create_custom_object_type(2, 'MyObjectType', ua.ObjectIds.BaseObjectType, properties, variables, methods)
check_custom_type(self, node_type, ua.ObjectIds.BaseObjectType)
variables = node_type.get_variables()
self.assertTrue(node_type.get_child("2:VariableString") in variables)
self.assertEqual(node_type.get_child("2:VariableString").get_data_value().Value.VariantType, ua.VariantType.String)
self.assertTrue(node_type.get_child("2:MyEnumVar") in variables)
self.assertEqual(node_type.get_child("2:MyEnumVar").get_data_value().Value.VariantType, ua.VariantType.Int32)
self.assertEqual(node_type.get_child("2:MyEnumVar").get_data_type(), ua.NodeId(ua.ObjectIds.ApplicationType))
methods = node_type.get_methods()
self.assertTrue(node_type.get_child("2:MyMethod") in methods)
#def test_create_custom_refrence_type_ObjectId(self):
#type = self.opc.create_custom_reference_type(2, 'MyEvent', ua.ObjectIds.Base, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
#check_custom_type(self, type, ua.ObjectIds.BaseObjectType)
def test_create_custom_variable_type_ObjectId(self):
type = self.opc.create_custom_variable_type(2, 'MyVariableType', ua.ObjectIds.BaseVariableType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
check_custom_type(self, type, ua.ObjectIds.BaseVariableType)
def test_create_custom_event_type_NodeId(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.NodeId(ua.ObjectIds.BaseEventType), [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
check_custom_type(self, etype, ua.ObjectIds.BaseEventType)
def test_create_custom_event_type_Node(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.BaseEventType)), [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
check_custom_type(self, etype, ua.ObjectIds.BaseEventType)
def test_get_event_from_type_node_CustomEvent(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
ev = opcua.common.events.get_event_obj_from_type_node(etype)
check_custom_event(self, ev, etype)
self.assertEqual(ev.PropertyNum, None)
self.assertEqual(ev.PropertyString, None)
def test_eventgenerator_customEvent(self):
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
evgen = self.opc.get_event_generator(etype, ua.ObjectIds.Server)
check_eventgenerator_CustomEvent(self, evgen, etype)
check_eventgenerator_SourceServer(self, evgen)
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
def test_eventgenerator_double_customEvent(self):
event1 = self.opc.create_custom_event_type(3, 'MyEvent1', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
event2 = self.opc.create_custom_event_type(4, 'MyEvent2', event1, [('PropertyBool', ua.VariantType.Boolean), ('PropertyInt', ua.VariantType.Int32)])
evgen = self.opc.get_event_generator(event2, ua.ObjectIds.Server)
check_eventgenerator_CustomEvent(self, evgen, event2)
check_eventgenerator_SourceServer(self, evgen)
# Properties from MyEvent1
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
# Properties from MyEvent2
self.assertEqual(evgen.event.PropertyBool, None)
self.assertEqual(evgen.event.PropertyInt, None)
def test_eventgenerator_customEvent_MyObject(self):
objects = self.opc.get_objects_node()
o = objects.add_object(3, 'MyObject')
etype = self.opc.create_custom_event_type(2, 'MyEvent', ua.ObjectIds.BaseEventType, [('PropertyNum', ua.VariantType.Int32), ('PropertyString', ua.VariantType.String)])
evgen = self.opc.get_event_generator(etype, o)
check_eventgenerator_CustomEvent(self, evgen, etype)
check_event_generator_object(self, evgen, o)
self.assertEqual(evgen.event.PropertyNum, None)
self.assertEqual(evgen.event.PropertyString, None)
def test_context_manager(self):
""" Context manager calls start() and stop()
"""
state = [0]
def increment_state(self, *args, **kwargs):
state[0] += 1
# create server and replace instance methods with dummy methods
server = Server()
server.start = increment_state.__get__(server)
server.stop = increment_state.__get__(server)
assert state[0] == 0
with server:
# test if server started
self.assertEqual(state[0], 1)
# test if server stopped
self.assertEqual(state[0], 2)
idx = server.register_namespace(uri)
# get Objects node, this is where we should put our custom stuff
objects = server.get_objects_node()
# populating our address space
myobj = objects.add_object(idx, "张杰MyObject")
# Creating a custom event: Approach 1
# The custom event object automatically will have members from its parent (BaseEventType)
etype = server.create_custom_event_type(
idx, 'MyFirstEvent', ua.ObjectIds.BaseEventType,
[('MyNumericProperty', ua.VariantType.Float),
('MyStringProperty', ua.VariantType.String)])
myevgen = server.get_event_generator(etype, myobj)
# Creating a custom event: Approach 2
custom_etype = server.nodes.base_event_type.add_object_type(
2, 'MySecondEvent')
custom_etype.add_property(2, 'MyIntProperty',
ua.Variant(0, ua.VariantType.Int32))
custom_etype.add_property(2, 'MyBoolProperty',
ua.Variant(True, ua.VariantType.Boolean))
mysecondevgen = server.get_event_generator(custom_etype, myobj)
mythridevgen = server.get_event_generator(custom_etype, myobj)
# starting!
server.start()
def main():
logging.basicConfig(level=logging.WARN)
logger = logging.getLogger("opcua.server.internal_subscription")
logger.setLevel(logging.DEBUG)
# setup our server
server = Server()
server.set_endpoint( Commons.OPC_ENDPOINT )
# setup our own namespace, not really necessary but should as spec
server_namespace = Commons.OPC_NAMESPACE
address_space = server.register_namespace( server_namespace )
# get Objects node, this is where we should put our custom stuff
objects_node = server.get_objects_node()
# populating our address space
ChargeControllerObject = objects_node.add_object(address_space, Commons.MY_OBJECT_NAME)
RelayBoxObject = objects_node.add_object(address_space, "RelayBox")
panelVoltage = ChargeControllerObject.add_variable( address_space, "panelVoltage", 0.0 )
panelCurrent = ChargeControllerObject.add_variable( address_space, "panelCurrent", 0.0 )
batteryVoltage = ChargeControllerObject.add_variable( address_space, "batteryVoltage", 0.0 )
batteryCurrent = ChargeControllerObject.add_variable( address_space, "batteryCurrent", 0.0 )
loadVoltage = ChargeControllerObject.add_variable( address_space, "loadVoltage", 0.0 )
loadCurrent = ChargeControllerObject.add_variable( address_space, "loadCurrent", 0.0 )
inPower = ChargeControllerObject.add_variable( address_space, "inPower", 0.0 )
outPower = ChargeControllerObject.add_variable( address_space, "outPower", 0.0 )
batteryStatus = ChargeControllerObject.add_variable( address_space, "batteryStatus", "" )
batteryCapacity = ChargeControllerObject.add_variable( address_space, "batteryCapacity", 0.0 )
batteryTemperature = ChargeControllerObject.add_variable( address_space, "batteryTemperature", 0.0 )
## To make them writable by the clients
"""
panelVoltage.set_writable()
panelCurrent.set_writable()
batteryCurrent.set_writable()
batteryVoltage.set_writable()
loadVoltage.set_writable()
loadCurrent.set_writable()
inPower.set_writable()
outPower.set_writable()
batteryStatus.set_writable()
batteryCapacity.set_writable()
batteryTemperature.set_writable()
"""
### Creating a custom EVENT
eventType = server.create_custom_event_type(
address_space,
Commons.MY_FIRST_EVENT_NAME,
ua.ObjectIds.BaseEventType,
[
('batteryVoltage', ua.VariantType.Float),
('outputsEnabled', ua.VariantType.Boolean),
]
)
myEventGenerator = server.get_event_generator(eventType, ChargeControllerObject)
##creating an array
plug_A_current_array = ChargeControllerObject.add_variable(address_space, "plug_A_current_array", [6.7, 7.9])
# the variable could be hard typed
plug_B_current_array = ChargeControllerObject.add_variable(address_space, "plug_B_current_array", ua.Variant([], ua.VariantType.Float))
## creating a property
prop_charge_controller_producer = ChargeControllerObject.add_property(address_space, "charge_controller_producer", "Epever")
prop_charge_controller_model = ChargeControllerObject.add_property(address_space, "charge_controller_model", "Tracer 2210A MPPT")
prop_panel = ChargeControllerObject.add_property(address_space, "panel_info", "12V 100 W")
prop_battery = ChargeControllerObject.add_property(address_space, "battery_info", "Bosch 12V")
## Two different methods definitions
# First
plugs_control_node = RelayBoxObject.add_method(address_space, "set_plug_state", set_plug_state, [ua.VariantType.Boolean], [ua.VariantType.Boolean])
# Second
inarg = ua.Argument()
inarg.Name = "inverter_state"
inarg.DataType = ua.NodeId(ua.ObjectIds.Boolean)
inarg.ValueRank = -1
inarg.ArrayDimensions = []
inarg.Description = ua.LocalizedText("Boolean inverter state")
outarg = ua.Argument()
outarg.Name = "Result"
outarg.DataType = ua.NodeId(ua.ObjectIds.Boolean)
outarg.ValueRank = -1
outarg.ArrayDimensions = []
outarg.Description = ua.LocalizedText("Final Inverter State")
inverter_control_node = RelayBoxObject.add_method(address_space, "set_inverter_state", set_inverter_state, [inarg], [outarg])
# starting!
server.start()
print( "Server starting ...")
# creating my machinery objects
chargeController = cc.EpeverChargeController(produce_dummy_data = DUMMY_DATA)
outputsEnabled = True
try:
while True:
time.sleep(1)
data = chargeController.readAllData()
panelVoltage.set_value( data['panelVoltage'] )
panelCurrent.set_value( data['panelCurrent'] )
batteryVoltage.set_value( data['batteryVoltage'] )
batteryCurrent.set_value( data['batteryCurrent'] )
loadVoltage.set_value( data['loadVoltage'] )
loadCurrent.set_value( data['loadCurrent'] )
inPower.set_value( data['inPower'] )
outPower.set_value( data['outPower'] )
batteryStatus.set_value( data['batteryStatus'] )
batteryCapacity.set_value( data['batteryCapacity'] )
batteryTemperature.set_value( data['batteryTemperature'] )
if data['batteryVoltage'] < LOW_BATTERY_VOLTAGE and outputsEnabled:
outputsEnabled = False;
myEventGenerator.event.Message = ua.LocalizedText("Battery Voltage is too low. Outputs will be disconnected")
myEventGenerator.event.batteryVoltage = ua.Variant(float(data['panelVoltage']), ua.VariantType.Float)
myEventGenerator.event.outputsEnabled = ua.Variant( outputsEnabled , ua.VariantType.Boolean)
myEventGenerator.event.Severity = ua.Variant( 1 , ua.VariantType.Int32)
myEventGenerator.trigger()
elif data['batteryVoltage'] > LOW_BATTERY_VOLTAGE and not outputsEnabled:
outputsEnabled = True;
myEventGenerator.event.Message = ua.LocalizedText("Battery Voltage is normal. Outputs will be activated")
myEventGenerator.event.batteryVoltage = ua.Variant(float(data['panelVoltage']), ua.VariantType.Float)
myEventGenerator.event.outputsEnabled = ua.Variant( outputsEnabled , ua.VariantType.Boolean)
myEventGenerator.event.Severity = ua.Variant( 1 , ua.VariantType.Int32)
myEventGenerator.trigger()
## update array variables
burst = [random.random() for _ in range(1024)]
plug_A_current_array.set_value(burst)
plug_B_current_array.set_value(burst)
embed()
finally:
# close connection, remove subcsriptions, etc
server.stop()