Add a proxy operations_parser parameter to select specific parser type

Author: pjkundert

README.org

@@ -1439,6 +1439,51 @@
          sys.exit( 1 )
      #+END_EXAMPLE
 
+**** Forcing .read/write to use CIP Get/Set Attribute Single
+
+     If the target device understands only basic CIP I/O requests, or you wish to perform special
+     processing on the stream of operations generated from the supplied tags, you can specify the
+     =proxy= with a specific =operations_parser=.  The default is to use =client.parse_operations=
+     if data types are provided, and =get_attribute.attribute_operations= otherwise.
+
+     If we know we want to generate EtherNet/IP CIP Get/Set Attribute requests but we wish to pass
+     specific data types (eg. =INT=), create the =proxy_simple= device w/ an appropriate
+     =operations_parser= parameter:
+
+#+BEGIN_EXAMPLE python
+# 
+# Basic CIP I/O Test
+# 
+# Target Simulator:
+#     python3 -m cpppo.server.enip -S -vv SCADA@0x4/0x96/3=INT[18
+# 
+import cpppo
+from cpppo.server.enip.get_attribute import attribute_operations, proxy_simple as device
+from cpppo.server.enip import client
+
+import logging
+cpppo.log_cfg['level'] = logging.DEBUG
+logging.basicConfig( **cpppo.log_cfg )
+
+hostname = 'localhost'
+
+# Our target CIP Attribute contains a 36 bytes == 18 x INT value
+attribute = '@0x4/0x96/3'
+values = "512,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0"
+operations = [attribute + ' = (INT)' + values]
+print( "Raw operations: %r" % operations )
+
+operations_parser = attribute_operations
+operations_out = list( operations_parser( operations ))
+
+assert operations_out == [{'method': 'set_attribute_single', 'path': [{'class': 4}, {'instance': 150}, {'attribute': 3}], 'tag_type': 195, 'data': [512, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'elements': 18}]
+
+# Force basic CIP Get/Set Attribute I/O operations
+via = device( hostname, operations_parser=operations_parser )
+val, = via.write( operations )
+     
+#+END_EXAMPLE
+
 **** Using the =proxy= Context Manager API
 
      There is a simple mechanism provided to ensure that all of the above

server/enip/device.py

@@ -325,8 +325,8 @@ def parse_path( path, elm=None ):
 def parse_path_elements( path, elm=None, cnt=None ):
     """Returns (<path>,<element>,<count>).  If an element is specified (eg. Tag[#]), then it will be
     added to the path (or replace any existing element segment at the end of the path) and returned,
-    otherwise None will be returned.  If a count is specified (eg. Tag[#-#] or ...*#), then it will be
-    returned; otherwise a None will be returned.
+    otherwise None will be returned.  If a count is specified (eg. Tag[#-#] or ...*#), then it will
+    be returned; otherwise a None will be returned.
 
     Any "."-separated EPATH component (except the last) including an element index must specify
     exactly None/one element, eg: "Tag.SubTag[5].AnotherTag[3-4]".

server/enip/get_attribute.py

@@ -107,6 +107,7 @@ def attribute_operations( paths, int_type=None, **kwds ):
             op['method'] = 'set_attribute_single' if 'data' in op else 'get_attribute_single'
         else:
             raise AssertionError( "Path invalid for Attribute services: %r", op['path'] )
+        log.detail( "CIP Operation: %s", parser.enip_format( op ))
         yield op
 
 
@@ -245,7 +246,8 @@ def parameter_substitution( self, iterable, parameters=None, pass_thru=None ):
     def __init__( self, host, port=44818, timeout=None, depth=None, multiple=None,
                   gateway_class=None, route_path=None, send_path=None,
                   priority_time_tick=None, timeout_ticks=None,
-                  identity_default=None, dialect=None, **gateway_kwds ):
+                  identity_default=None, dialect=None, operations_parser=None,
+                  **gateway_kwds ):
         """Capture the desired I/O parameters for the target CIP Device.
 
         By default, the CIP Device will be identified using a List Identity request each time a CIP
@@ -273,6 +275,7 @@ def __init__( self, host, port=44818, timeout=None, depth=None, multiple=None,
         self.identity_default	= identity_default
         self.identity		= identity_default
         self.dialect		= dialect
+        self.operations_parser	= operations_parser
 
     def __str__( self ):
         return "%s at %s" % ( self.identity.product_name if self.identity else None, self.gateway )
@@ -545,7 +548,8 @@ def opp__att_typ_uni( i ):
                     # No conversion of data type if None; use a Read Tag [Fragmented]; works only
                     # for [S]STRING/SINT/INT/DINT/REAL/BOOL.  Otherwise, conversion of data type
                     # desired; get raw data using Get Attribute Single.
-                    parser	= client.parse_operations if typ is None else attribute_operations
+                    parser	= self.operations_parser or ( client.parse_operations if typ is None
+                                                              else attribute_operations )
                     opp,	= parser( ( att, ), route_path=device.parse_route_path( self.route_path ),
                                           send_path=self.send_path, priority_time_tick=self.priority_time_tick,
                                           timeout_ticks=self.timeout_ticks )

server/enip/parser.py

@@ -863,6 +863,7 @@ class EPATH( dfa ):
         'element':	0x28,
         'port':		0x00,
     }
+
     def __init__( self, name=None, **kwds ):
         name 			= name or kwds.setdefault( 'context', self.__class__.__name__ )
 
@@ -1147,8 +1148,7 @@ def produce( cls, data ):
                     assert False, "Invalid value for numeric EPATH segment %r == %d: %r" % (
                         segnam, segval, data )
                 break
-            if not found:
-                assert False, "Invalid EPATH segment %r found in %r" % ( segnam, data )
+            assert found, "Invalid EPATH segment %r found in %r" % ( segnam, data )
             assert len( result ) % 2 == 0, \
                 "Failed to retain even EPATH word length after %r in %r" % ( segnam, data )
 

version.py

@@ -1,2 +1,2 @@
-__version_info__		= ( 4, 4, 1 )
+__version_info__		= ( 4, 4, 2 )
 __version__			= '.'.join( map( str, __version_info__ ))