eventing works between server and client

example-server.py

@@ -60,6 +60,7 @@ if __name__ == "__main__":
 
     #creating an event object
     myevent = server.get_event_object(ObjectIds.BaseEventType)
+    myevent.Message.Text = "This is my event"
     print("My event is", myevent)
     
     # starting!

opcua/subscription.py

@@ -10,6 +10,13 @@ from opcua import ua
 from opcua import Node
 from opcua import ObjectIds
 from opcua import AttributeIds
+from opcua import Event
+
+class EventResult():
+    def __str__(self):
+        return "EventResult({})".format([str(k) + ":" + str(v) for k, v in self.__dict__.items()])
+    __repr__ = __str__
+
 
 
 class SubscriptionItemData():
@@ -65,15 +72,34 @@ class Subscription(object):
     def _call_datachange(self, datachange):
         for item in datachange.MonitoredItems:
             data = self._monitoreditems_map[item.ClientHandle]
-            self._handler.data_change(data.server_handle, data.node, item.Value.Value.Value, data.attribute)
+            try:
+                self._handler.data_change(data.server_handle, data.node, item.Value.Value.Value, data.attribute)
+            except Exception:
+                self.logger.exception("Exception calling data change handler")
 
     def _call_event(self, eventlist):
-        print(eventlist)
-        self.logger.warn("Not implemented")
+        for event in eventlist.Events:
+            data = self._monitoreditems_map[event.ClientHandle]
+            try:
+                #fields = {}
+                result = EventResult()
+                for idx, sattr in enumerate(data.mfilter.SelectClauses):
+
+                    if len(sattr.BrowsePath) == 0:
+                        #fields[ua.AttributeIdsInv[sattr.AttributeId]] = event.EventFields[idx].Value
+                        setattr(result, ua.AttributeIdsInv[sattr.AttributeId], event.EventFields[idx].Value)
+                    else:
+                        setattr(result, sattr.BrowsePath[0].Name, event.EventFields[idx].Value)
+                #self._handler.event(data.server_handle, fields)
+                self._handler.event(data.server_handle, result)
+            except Exception:
+                self.logger.exception("Exception calling event handler")
 
     def _call_status(self, status):
-        print(status)
-        self.logger.warn("Not implemented")
+        try:
+            self._handler.status_change(status.Status)
+        except Exception:
+            self.logger.exception("Exception calling status change handler")
 
     def subscribe_data_change(self, node, attr=ua.AttributeIds.Value):
         return self._subscribe(node, attr)
@@ -101,6 +127,7 @@ class Subscription(object):
     def subscribe_events(self, sourcenode=ObjectIds.Server, evtype=ObjectIds.BaseEventType):
         sourcenode = self._get_node(sourcenode)
         evfilter = self._get_filter_from_event_type(evtype)
+        print("EVFILTER is ", evfilter)
         return self._subscribe(sourcenode, AttributeIds.EventNotifier, evfilter)
 
     def _subscribe(self, node, attr, mfilter=None):
@@ -136,6 +163,7 @@ class Subscription(object):
         data.node = node
         data.attribute = attr
         data.server_handle = result.MonitoredItemId
+        data.mfilter = ua.downcast_extobject(result.FilterResult)
         self._monitoreditems_map[mparams.ClientHandle] = data
 
         return result.MonitoredItemId

opcua/subscription_server.py

@@ -373,8 +373,9 @@ class InternalSubscription(object):
     def trigger_event(self, event):
         with self._lock:
             if not event.SourceNode in self._monitored_events:
-                self.logger.debug("%s has not subscription for events from node: %s", self, event.SourceNode)
+                self.logger.debug("%s has no subscription for events %s from node: %s", self, event, event.SourceNode)
                 return False
+            self.logger.debug("%s has subscription for events %s from node: %s", self, event, event.SourceNode)
             mid = self._monitored_events[event.SourceNode]
             if not mid in self._monitored_items:
                 self.logger.debug("Could not find monitored items for id %s for event %s in subscription %s", mid, event, self)
@@ -382,6 +383,7 @@ class InternalSubscription(object):
             item = self._monitored_items[mid]
             fieldlist = ua.EventFieldList()
             fieldlist.ClientHandle = item.client_handle
+            print("filter is ", item.parameters.FilterResult, " event is ", event)
             fieldlist.EventFields = self._get_event_fields(item.parameters.FilterResult, event)
             self._triggered_events.append(fieldlist)
             return True
@@ -389,6 +391,7 @@ class InternalSubscription(object):
     def _get_event_fields(self, evfilter, event):
         fields = []
         for sattr in evfilter.SelectClauses:
+            print("looking at sattrs", sattr)
             try:
                 if not sattr.BrowsePath:
                     val = getattr(event, ua.AttributeIdsInv[sattr.Attribute])

opcua/uatypes.py

@@ -587,12 +587,18 @@ class Variant(object):
             return VariantType.ByteString
         elif type(val) == datetime:
             return VariantType.DateTime
-        elif type(val) == ExtensionObject:
-            return VariantType.ExtensionObject
-        elif type(val) == Variant:
-            return VariantType.Variant
         else:
-            raise Exception("Could not guess UA type of {} with type {}, specify UA type".format(val, type(val)))
+            if isinstance(val, object):
+                code = "VariantType.{}".format(val.__class__.__name__)
+                return eval(code)
+            else:
+
+        #elif type(val) == ExtensionObject:
+            #return VariantType.ExtensionObject
+        #elif type(val) == Variant:
+            #return VariantType.Variant
+        #else:
+                raise Exception("Could not guess UA type of {} with type {}, specify UA type".format(val, type(val)))
 
     def __str__(self):
         return "Variant(val:{},type:{})".format(self.Value, self.VariantType)