add pyOpenSSL to the list of packages to pip2 install for sfa

[tests.git] / system / TestMapper.py

diff --git a/system/TestMapper.py b/system/TestMapper.py
index 1d2dd3c..f07ed1b 100644 (file)
--- a/system/TestMapper.py
+++ b/system/TestMapper.py
@@ -1,67 +1,87 @@
 #
-# Thierry Parmentelat - INRIA Sophia Antipolis 
+# Thierry Parmentelat <thierry.parmentelat@inria.fr>
+# Copyright (C) 2010 INRIA 
+#
 #
 # mapper class
 # 
 # this works on a spec as defined in a config file
-# and allows to remap various fields, typically to another testbox 
-# see an example in config-testbox2.py
+# and allows to remap various fields on the local substrate
 # 
 
-import re
 import utils
 
 class TestMapper:
 
-    def __init__ (self,plcs,mapper,options):
-        self.plcs=plcs
-        self.mapper=mapper
-        self.options=options
-
-    @staticmethod
-    def match (name,key):
-        key=key.replace("*",".*")
-        return re.compile(key).match(name)
+    def __init__(self,plcs,options):
+        self.plcs = plcs
+        self.options = options
 
     @staticmethod
-    def plc_name (plc):
+    def plc_name(plc):
         return plc['name']
 
     @staticmethod
-    def node_name (node):
-        return node['node_fields']['hostname']
+    def node_name(node):
+        return node['name']
+
+    def node_names(self):
+        result = []
+        for plc in self.plcs:
+            for site in plc['sites']:
+                for node in site['nodes']:
+                    result.append(node['name'])
+        return result
 
-    def apply_first_map (self, obj, name, type, maplist):
-        for (key,dict) in maplist:
-            if TestMapper.match (name,key):
-                utils.header("TestMapper/%s : applying match key %s on plc %s"%(type,key,name))
-                for (k,v) in dict.iteritems():
-                    if not obj.has_key(k):
-                        utils.header ("WARNING : no such key %s in %s %s",k,type,name)
-                    else:
-                        # apply formatting if found
-                        if v.find('%s')>=0:
-                            v=v%obj[k]
-                        if self.options.verbose:
-                            utils.header("mapping %s->%s towards %s"%(name,k,v))
-                        obj[k]=v
-                break
+    def apply_first_map(self, type, name, obj, maplist):
+        for (map_pattern,rename_dict) in maplist:
+            if utils.match (name,map_pattern):
+                if self.options.verbose:
+                    utils.header("TestMapper/{} : applying rules '{}' on {}"\
+                                 .format(type, map_pattern, name))
+                for (k,v) in rename_dict.items():
+                    # apply : separator
+                    path = k.split(':')
+                    # step down but last step in path
+                    o = obj
+                    for step in path[:-1]:
+                        if step not in o:
+                            o[step] = {}
+                            if self.options.verbose:
+                                utils.header ("WARNING : created step {} in path {} on {} {}"\
+                                              .format(step,path,type,name))
+                        o = o[step]
+                    # last step is the one for side-effect
+                    step = path[-1]
+                    if self.options.verbose:
+                        if step not in o:
+                            utils.header ("WARNING : inserting key {} for path {} on {} {}"\
+                                          .format(step, path, type, name))
+                    # apply formatting if '%s' found in the value
+                    if v is None:
+                        if self.options.verbose: print("TestMapper WARNING - None value - ignored, key=",k)
+                        continue
+                    if v.find('%s') >= 0:
+                        v = v % obj[k]
+                    if self.options.verbose:
+                        print(("TestMapper, rewriting {}: {} into {}"\
+                              .format(name, k, v)))
+                    o[step] = v
+                # only apply first rule
+                return
 
-    def map (self):
+    def map(self, mapper):
 
-        plc_maps = self.mapper['plc']
+        plc_maps  = mapper.get('plc',[])
+        node_maps = mapper.get('node',[])
 
         for plc in self.plcs:
-            name=TestMapper.plc_name(plc)
-            self.apply_first_map (plc,name,'plc',plc_maps)
-
-            node_maps = self.mapper['node']
+            name = TestMapper.plc_name(plc)
+            self.apply_first_map('plc', name, plc, plc_maps)
 
             for site in plc['sites']:
                 for node in site['nodes']:
                     nodename = TestMapper.node_name(node)
-                    self.apply_first_map(node,nodename,"node",node_maps)
+                    self.apply_first_map('node', nodename, node, node_maps)
 
         return self.plcs
-                                               
-