Implement parameter references.

conduct.py

@@ -88,7 +88,7 @@ def main(argv=None):
     # configure logging
     initLogging(args.chain)
 
-    chain = Chain(args.chain)
+    chain = Chain(args.chain, {'sourcedir' : '/tmp'})
     chain.build()
 
 

conduct/buildsteps.py

@@ -23,7 +23,7 @@
 import os
 
 import conduct
-from conduct.util import systemCall
+from conduct.util import systemCall, Referencer
 from conduct.loggers import LOGLEVELS, INVLOGLEVELS
 from conduct.param import Parameter, oneof, none_or
 
@@ -79,7 +79,15 @@ def _createProperty(mcls, paramName, paramDef, attrs):
         def readFunc(self):
             if hasattr(self, 'doRead%s' % capitalParamName):
                 return getattr(self, 'doRead%s' % capitalParamName)()
-            return self._params.get(paramName, paramDef.default)
+
+            value = self._params.get(paramName, paramDef.default)
+
+            # resolve references
+            if isinstance(value, Referencer):
+                # resolve and validate
+                value = paramDef.type(value.resolve(self.chain))
+
+            return value
         readFunc.__name__ = '_readParam%s' % capitalParamName
 
         # create parameter write function
@@ -89,7 +97,10 @@ def writeFunc(self, value):
                 if hasattr(self, 'doWrite%s' % capitalParamName):
                     getattr(self, 'doWrite%s' % capitalParamName)(validValue)
                 else:
-                    self._params[paramName] = paramDef.type(value)
+                    # special handling for references
+                    if not isinstance(value, Referencer):
+                        value = paramDef.type(value)
+                    self._params[paramName] = value
             except ValueError as e:
                 raise ValueError('Cannot set %s: %s' % (paramName, e))
         writeFunc.__name__ = '_writeParam%s' % capitalParamName
@@ -112,8 +123,9 @@ class BuildStep(object):
     outparameters = {
     }
 
-    def __init__(self, name, paramValues):
+    def __init__(self, name, paramValues, chain=None):
         self.name = name
+        self.chain = chain # Maintain a reference to the chain (for refs)
 
         self._params = {}
 

conduct/chain.py

@@ -22,25 +22,41 @@
 
 import pprint
 from os import path
+from collections import OrderedDict
 
 import conduct
 from conduct.param import Parameter
-from conduct.util import AttrStringifier, ObjectiveOrderedDict
+from conduct.util import AttrStringifier, ObjectiveOrderedDict, Referencer
 
 
 class Chain(object):
-    def __init__(self, name):
+    def __init__(self, name, paramValues):
         self.name = name
+        self.steps = OrderedDict()
+        self.params = {}
+
         self._chainDef = {}
-        self._steps = []
 
         self._loadChainFile()
+        self._applyParamValues(paramValues)
 
 
     def build(self):
-        for step in self._steps:
+        for step in self.steps.values():
             step.build()
 
+    @property
+    def parameters(self):
+        return self._chainDef['parameters']
+
+    def _applyParamValues(self, values):
+        for name, definition in self.parameters.iteritems():
+            if name in values:
+                self.params[name] = values[name]
+            elif definition.default is not None:
+                self.params[name] = definition.default
+            else:
+                raise RuntimeError('Mandatory parameter %s is missing' % name)
 
     def _loadChainFile(self):
         # determine chain file location
@@ -58,7 +74,8 @@ def _loadChainFile(self):
             'Parameter' : Parameter,
             'Step' : lambda cls, **params: ('step:%s' % cls, params),
             'Chain' : lambda cls, **params: ('chain:%s' % cls, params),
-            'steps' : ObjectiveOrderedDict()
+            'steps' : ObjectiveOrderedDict(),
+            'ref' : lambda refAdr: Referencer(refAdr),
         }
 
         # execute and extract all the interesting data
@@ -83,10 +100,10 @@ def _createSteps(self):
                 mod = __import__(clsMod)
                 cls = getattr(mod, clsName)
 
-                step = cls(name, definition[1])
-                self._steps.append(step)
+                self.steps[name] = cls(name, definition[1], self)
             else:
-                self._steps.append(Chain(entryName))
+                # TODO parameter forwarding
+                self.steps[name] = Chain(entryName)
 
 
 

conduct/util.py

@@ -27,6 +27,24 @@
 
 ## Utils classes
 
+class Referencer(object):
+    def __init__(self, adr):
+        self.adr = adr
+
+    def resolve(self, chain):
+        parts = self.adr.split('.')
+        # chain.parameter
+        # or
+        # steps.stepname.parameter
+
+        if parts[0] == 'chain':
+            return chain.params[parts[1]]
+        elif parts[0] == 'steps':
+            step = chain.steps[parts[1]]
+            return getattr(step, parts[2])
+
+        raise RuntimeError('Could not resolve reference: %s' % self.adr)
+
 class AttrStringifier(object):
     def __getattr__(self, name):
         return name

etc/chains/compile_autotools.py

@@ -39,15 +39,15 @@
 # Build steps
 steps.autogen   = Step('conduct.SystemCallStep',
                         description='Generate configure via autogen.sh',
-                        #workingdir=ref.params.sourcedir,
+                        workingdir=ref('chain.sourcedir'),
                         command='./autogen.sh')
 steps.configure = Step('conduct.SystemCallStep',
                         description='Execute configure script',
-                        #workingdir=params.sourcedir,
+                        workingdir=ref('chain.sourcedir'),
                         command='./configure')
 steps.make      = Step('conduct.SystemCallStep',
                         description='Build software via make',
-                        #workingdir=params.sourcedir,
+                        workingdir=ref('chain.sourcedir'),
                         command='make')