server: add modify_monitored_items, div fixes

opcua/internal_server.py

@@ -160,6 +160,9 @@ class InternalSession(object):
     def create_monitored_items(self, params):
         return self.submgr.create_monitored_items(params)
 
+    def modify_monitored_items(self, params):
+        return self.submgr.modify_monitored_items(params)
+
     def delete_subscriptions(self, ids):
         for i in ids:
             if i in self.subscriptions:

opcua/subscription_server.py

@@ -104,7 +104,19 @@ class SubscriptionManager(Thread):
                     response.StatusCode = ua.StatusCode(ua.StatusCodes.BadSubscriptionIdInvalid)
                     res.append(response)
                 return res
-            return self.subscriptions[params.SubscriptionId].create_monitored_items(params)
+        return self.subscriptions[params.SubscriptionId].create_monitored_items(params)
+
+    def modify_monitored_items(self, params):
+        self.logger.info("modify monitored items")
+        with self._lock:
+            if not params.SubscriptionId in self.subscriptions:
+                res = []
+                for _ in params.ItemsToModify:
+                    result = ua.MonitoredItemModifyResult()
+                    result.StatusCode = ua.StatusCode(ua.StatusCodes.BadSubscriptionIdInvalid)
+                    res.append(result)
+                return res
+        return self.subscriptions[params.SubscriptionId].modify_monitored_items(params)
 
     def delete_monitored_items(self, params):
         self.logger.info("delete monitored items")
@@ -114,7 +126,7 @@ class SubscriptionManager(Thread):
                 for _ in params.MonitoredItemIds:
                     res.append(ua.StatusCode(ua.StatusCodes.BadSubscriptionIdInvalid))
                 return res
-            return self.subscriptions[params.SubscriptionId].delete_monitored_items(params)
+        return self.subscriptions[params.SubscriptionId].delete_monitored_items(params.MonitoredItemIds)
 
 
 
@@ -174,10 +186,7 @@ class InternalSubscription(object):
             except Exception as ex: #we catch everythin since it seems exceptions are lost in loop
                 print("Exception in {} code:".format(self))
                 print('-'*60)
-                try:
-                    traceback.print_exc(file=sys.stderr)
-                except Exception as ex:
-                    print("RRRRR", ex)
+                traceback.print_exc(file=sys.stderr)
                 print('-'*60)
                 #self.logger.warn("Exception in %s loop: %s", self, ex)
             yield from asyncio.sleep(1)
@@ -228,11 +237,33 @@ class InternalSubscription(object):
             results.append(self._create_monitored_item(item))
         return results
 
+    def modify_monitored_items(self, params):
+        results = []
+        for item in params.ItemsToModify:
+            results.append(self._modify_monitored_item(item))
+        return results
+
+
     def trigger_datachange(self, handle, nodeid, attr):
         self.logger.debug("triggering datachange for handle %s, nodeid %s, and attribute %s", handle, nodeid, attr)
         variant = self.aspace.get_attribute_value(nodeid, attr)
         self.datachange_callback(handle, variant)
 
+    def _modify_monitored_item(self, params):
+        with self._lock:
+            for _, mdata in self._monitored_datachange.items():
+                result = ua.MonitoredItemCreateResult()
+                if mdata.monitored_item_id == params.MonitoredItemId:
+                    result.RevisedSamplingInterval = self.data.RevisedPublishingInterval
+                    result.RevisedQueueSize = params.RequestedParameters.QueueSize #FIXME check and use value
+                    result.FilterResult = params.RequestedParameters.Filter
+                    mdata.parameters = result
+                    return result
+            #FIXME modify event subscriptions
+            result = ua.MonitoredItemCreateResult()
+            result.StatusCode(ua.StatusCodes.BadMonitoredItemIdInvalid)
+            return result
+
     def _create_monitored_item(self, params):
         with self._lock:
             result = ua.MonitoredItemCreateResult()

opcua/uaprocessor.py

@@ -149,13 +149,17 @@ class UAProcessor(object):
             params = ua.ActivateSessionParameters.from_binary(body) 
             
             if not self.session:
-                result = ua.StatusCode(ua.StatusCodes.BadSessionIdInvalid)
+                #result = ua.ActivateSessionResult()
+                #result.Results.append(ua.StatusCode(ua.StatusCodes.BadSessionIdInvalid))
+                response = ua.ServiceFault()
+                response.ResponseHeader.ServiceResult = ua.StatusCode(ua.StatusCodes.BadSessionIdInvalid)
+                self.send_response(requesthdr.RequestHandle, algohdr, seqhdr, response)
             else:
                 result = self.session.activate_session(params)
 
-            response = ua.ActivateSessionResponse()
-            response.Parameters = result
-            self.send_response(requesthdr.RequestHandle, algohdr, seqhdr, response)
+                response = ua.ActivateSessionResponse()
+                response.Parameters = result
+                self.send_response(requesthdr.RequestHandle, algohdr, seqhdr, response)
 
         elif typeid == ua.NodeId(ua.ObjectIds.ReadRequest_Encoding_DefaultBinary):
             self.logger.info("Read request")
@@ -244,8 +248,7 @@ class UAProcessor(object):
 
         elif typeid == ua.NodeId(ua.ObjectIds.CreateMonitoredItemsRequest_Encoding_DefaultBinary):
             self.logger.info("create monitored items request")
-            params = ua.CreateMonitoredItemsParameters.from_binary(body) 
-            
+            params = ua.CreateMonitoredItemsParameters.from_binary(body)
             results = self.session.create_monitored_items(params)
 
             response = ua.CreateMonitoredItemsResponse()
@@ -253,6 +256,18 @@ class UAProcessor(object):
 
             self.send_response(requesthdr.RequestHandle, algohdr, seqhdr, response)
 
+        elif typeid == ua.NodeId(ua.ObjectIds.ModifyMonitoredItemsRequest_Encoding_DefaultBinary):
+            self.logger.info("modify monitored items request")
+            params = ua.ModifyMonitoredItemsParameters.from_binary(body) 
+            results = self.session.modify_monitored_items(params)
+
+            response = ua.ModifyMonitoredItemsResponse()
+            response.Results = results
+
+            self.send_response(requesthdr.RequestHandle, algohdr, seqhdr, response)
+
+
+
         elif typeid == ua.NodeId(ua.ObjectIds.DeleteMonitoredItemsRequest_Encoding_DefaultBinary):
             self.logger.info("delete monitored items request")
             params = ua.DeleteMonitoredItemsParameters.from_binary(body) 
@@ -266,6 +281,9 @@ class UAProcessor(object):
 
         elif typeid == ua.NodeId(ua.ObjectIds.PublishRequest_Encoding_DefaultBinary):
             self.logger.info("publish request")
+
+            if not self.session:
+                return
             
             acks = ua.unpack_array("Int32", body)
             

opcua/uaprotocol_auto.py

@@ -7306,14 +7306,12 @@ class MonitoredItemModifyRequest(FrozenClass):
     '''
     '''
     def __init__(self):
-        self.TypeId = FourByteNodeId(ObjectIds.MonitoredItemModifyRequest_Encoding_DefaultBinary)
         self.MonitoredItemId = 0
         self.RequestedParameters = MonitoringParameters()
         self._freeze()
     
     def to_binary(self):
         packet = []
-        packet.append(self.TypeId.to_binary())
         packet.append(pack_uatype('UInt32', self.MonitoredItemId))
         packet.append(self.RequestedParameters.to_binary())
         return b''.join(packet)
@@ -7321,14 +7319,12 @@ class MonitoredItemModifyRequest(FrozenClass):
     @staticmethod
     def from_binary(data):
         obj = MonitoredItemModifyRequest()
-        obj.TypeId = NodeId.from_binary(data)
         obj.MonitoredItemId = unpack_uatype('UInt32', data)
         obj.RequestedParameters = MonitoringParameters.from_binary(data)
         return obj
     
     def __str__(self):
-        return 'MonitoredItemModifyRequest(' + 'TypeId:' + str(self.TypeId) + ', '  + \
-             'MonitoredItemId:' + str(self.MonitoredItemId) + ', '  + \
+        return 'MonitoredItemModifyRequest(' + 'MonitoredItemId:' + str(self.MonitoredItemId) + ', '  + \
              'RequestedParameters:' + str(self.RequestedParameters) + ')'
     
     __repr__ = __str__
@@ -7435,16 +7431,20 @@ class ModifyMonitoredItemsRequest(FrozenClass):
     
     __repr__ = __str__
     
-class ModifyMonitoredItemsResult(FrozenClass):
+class ModifyMonitoredItemsResponse(FrozenClass):
     '''
     '''
     def __init__(self):
+        self.TypeId = FourByteNodeId(ObjectIds.ModifyMonitoredItemsResponse_Encoding_DefaultBinary)
+        self.ResponseHeader = ResponseHeader()
         self.Results = []
         self.DiagnosticInfos = []
         self._freeze()
     
     def to_binary(self):
         packet = []
+        packet.append(self.TypeId.to_binary())
+        packet.append(self.ResponseHeader.to_binary())
         packet.append(struct.pack('<i', len(self.Results)))
         for fieldname in self.Results:
             packet.append(fieldname.to_binary())
@@ -7455,7 +7455,9 @@ class ModifyMonitoredItemsResult(FrozenClass):
         
     @staticmethod
     def from_binary(data):
-        obj = ModifyMonitoredItemsResult()
+        obj = ModifyMonitoredItemsResponse()
+        obj.TypeId = NodeId.from_binary(data)
+        obj.ResponseHeader = ResponseHeader.from_binary(data)
         length = struct.unpack('<i', data.read(4))[0]
         if length != -1:
             for _ in range(0, length):
@@ -7466,40 +7468,11 @@ class ModifyMonitoredItemsResult(FrozenClass):
                 obj.DiagnosticInfos.append(DiagnosticInfo.from_binary(data))
         return obj
     
-    def __str__(self):
-        return 'ModifyMonitoredItemsResult(' + 'Results:' + str(self.Results) + ', '  + \
-             'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
-    
-    __repr__ = __str__
-    
-class ModifyMonitoredItemsResponse(FrozenClass):
-    '''
-    '''
-    def __init__(self):
-        self.TypeId = FourByteNodeId(ObjectIds.ModifyMonitoredItemsResponse_Encoding_DefaultBinary)
-        self.ResponseHeader = ResponseHeader()
-        self.Parameters = ModifyMonitoredItemsResult()
-        self._freeze()
-    
-    def to_binary(self):
-        packet = []
-        packet.append(self.TypeId.to_binary())
-        packet.append(self.ResponseHeader.to_binary())
-        packet.append(self.Parameters.to_binary())
-        return b''.join(packet)
-        
-    @staticmethod
-    def from_binary(data):
-        obj = ModifyMonitoredItemsResponse()
-        obj.TypeId = NodeId.from_binary(data)
-        obj.ResponseHeader = ResponseHeader.from_binary(data)
-        obj.Parameters = ModifyMonitoredItemsResult.from_binary(data)
-        return obj
-    
     def __str__(self):
         return 'ModifyMonitoredItemsResponse(' + 'TypeId:' + str(self.TypeId) + ', '  + \
              'ResponseHeader:' + str(self.ResponseHeader) + ', '  + \
-             'Parameters:' + str(self.Parameters) + ')'
+             'Results:' + str(self.Results) + ', '  + \
+             'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
     
     __repr__ = __str__
     

schemas/generate_model.py

@@ -14,7 +14,9 @@ IgnoredEnums = []#["IdType", "NodeIdType"]
 #we want to implement som struct by hand, to make better interface or simply because they are too complicated 
 IgnoredStructs = []#["NodeId", "ExpandedNodeId", "Variant", "QualifiedName", "DataValue", "LocalizedText"]#, "ExtensionObject"]
 #by default we split requests and respons in header and parameters, but some are so simple we do not split them
-NoSplitStruct = ["GetEndpointsResponse", "CloseSessionRequest", "AddNodesResponse", "BrowseResponse", "HistoryReadResponse", "HistoryUpdateResponse", "RegisterServerResponse", "CloseSecureChannelRequest", "CloseSecureChannelResponse", "CloseSessionRequest", "CloseSessionResponse", "UnregisterNodesResponse", "MonitoredItemModifyRequest", "MonitoredItemsCreateRequest", "ReadResponse", "WriteResponse", "TranslateBrowsePathsToNodeIdsResponse", "DeleteSubscriptionsResponse", "DeleteMonitoredItemsResponse", "PublishRequest", "CreateMonitoredItemsResponse", "ServiceFault", "AddReferencesRequest", "AddReferencesResponse"]
+NoSplitStruct = ["GetEndpointsResponse", "CloseSessionRequest", "AddNodesResponse", "BrowseResponse", "HistoryReadResponse", "HistoryUpdateResponse", "RegisterServerResponse", "CloseSecureChannelRequest", "CloseSecureChannelResponse", "CloseSessionRequest", "CloseSessionResponse", "UnregisterNodesResponse", "MonitoredItemModifyRequest", "MonitoredItemsCreateRequest", "ReadResponse", "WriteResponse", "TranslateBrowsePathsToNodeIdsResponse", "DeleteSubscriptionsResponse", "DeleteMonitoredItemsResponse", "PublishRequest", "CreateMonitoredItemsResponse", "ServiceFault", "AddReferencesRequest", "AddReferencesResponse", "ModifyMonitoredItemsResponse"]
+#structs that end with Request or Response but are not
+NotRequest = ["MonitoredItemCreateRequest", "MonitoredItemModifyRequest"]
 OverrideTypes = {}#AttributeId": "AttributeID",  "ResultMask": "BrowseResultMask", "NodeClassMask": "NodeClass", "AccessLevel": "VariableAccessLevel", "UserAccessLevel": "VariableAccessLevel", "NotificationData": "NotificationData"}
 OverrideNames = {}#{"RequestHeader": "Header", "ResponseHeader": "Header", "StatusCode": "Status", "NodesToRead": "AttributesToRead"} # "MonitoringMode": "Mode",, "NotificationMessage": "Notification", "NodeIdType": "Type"}
 
@@ -276,7 +278,7 @@ def split_requests(model):
     structs = []
     for struct in model.structs:
         structtype = None
-        if struct.name.endswith("Request") and not struct.name in ("MonitoredItemCreateRequest"):
+        if struct.name.endswith("Request") and not struct.name in NotRequest:
             structtype = "Request"
         elif struct.name.endswith("Response") or struct.name == "ServiceFault":
             structtype = "Response"