tla-sbuilder 0.1.0

data/lib/sbuilder.rb

@@ -0,0 +1,52 @@
+
+require_relative "utils/hash_inject"
+require_relative "utils/string_inject"
+
+require_relative "utils/version"
+require_relative "utils/logger"
+require_relative "utils/netio"
+
+require_relative "sbuilder/constants.rb"
+
+require_relative "sbuilder/exception.rb"
+
+require_relative "sbuilder/domain.rb"
+require_relative "sbuilder/domain_value.rb"
+require_relative "sbuilder/domain_cardinality.rb"
+
+require_relative "sbuilder/parameter.rb"
+require_relative "sbuilder/parameter_container.rb"
+require_relative "sbuilder/parameter_dom.rb"
+require_relative "sbuilder/parameter_ref.rb"
+
+
+require_relative "sbuilder/param_set.rb"
+require_relative "sbuilder/param_set_db.rb"
+require_relative "sbuilder/param_set_def.rb"
+require_relative "sbuilder/param_set_if.rb"
+require_relative "sbuilder/param_set_step.rb"
+
+require_relative "sbuilder/param_sets.rb"
+
+require_relative "sbuilder/resolver_rule.rb"
+require_relative "sbuilder/resolver_rule_ref.rb"
+require_relative "sbuilder/resolver_rule_match.rb"
+require_relative "sbuilder/resolver.rb"
+
+require_relative "sbuilder/resolver_loader.rb"
+require_relative "sbuilder/resolver_loader_yaml.rb"
+
+require_relative "sbuilder/param_set_loader.rb"
+require_relative "sbuilder/param_set_loader_swagger.rb"
+
+require_relative "sbuilder/model.rb"
+
+require_relative "sbuilder/extension_loader.rb"
+
+require_relative "sbuilder/factory.rb"
+require_relative "sbuilder/controller.rb"
+
+
+require_relative "sbuilder/mustache/template_reader"
+require_relative "sbuilder/mustache/template_reader_context"
+require_relative "sbuilder/mustache/template"

data/lib/sbuilder/constants.rb

@@ -0,0 +1,72 @@
+module Sbuilder
+
+  class Constants
+
+    # supported domain types
+    TYPE_DOMAIN = "domain"
+    TYPE_VALUE_DOMAIN = "value-domain"
+    TYPE_CARDINALITY_DOMAIN = "cardinality-domain"    
+
+    # supported extension loader types
+    EXTENSION_LOADER_YAML = "default-yaml"
+    
+    # supported paramter set types
+    SWAGGER = "swagger"
+    SWAGGER_DEFINITION="definition"
+    PARAM_SET_STEPS = "steps"
+
+    # supported mapper types
+    MAPPER_YAML = "resolver_yaml"
+
+    # supported mapper_rules
+    MAPPER_RULE_MATCH = "match"
+    MAPPER_RULE_REF   = "ref"
+
+    # supported paremters
+    PARAMETER                = "param"
+    PARAMETER_REF            = "param-ref"
+
+    # direcotory where to manual source files are
+    SRC_DIR = "src"
+    
+    # Default template generation 
+    # Notice directory names end with slash indicating that they are directories (and not gem-names)
+
+    TEMPLATE_GEM='tla-sbuilder'
+    TEMPLATE_PATH='mustache/'
+    
+    SRC_PATH="#{SRC_DIR}/"         # i.e. src_dir with ending '/', see option --templates
+
+    # default log-file
+    LOGFILE="sbuilder.log"
+
+    # configurations 
+    CNF_DIR = "cnf"
+
+    # main configuration file
+    CNF_FILE="sbuilder.yaml"
+
+    # directory to cache loaded files
+    CACHE_DIR = "tmp"
+
+    # direcotory where to output rendered templates
+    GEN_DIR = "gen"
+
+    # direcotory where to output build results
+    BUILD_DIR = "build"
+
+    # namespace
+    TYPE_NAMESPACE_DOM = "d_"
+    TYPE_NAMESPACE_REF = "t_"    
+
+    # Location of resources
+    RESOURCES_DIR = File.expand_path '../../../resources/', __FILE__
+    SWAGGER_SCHEMA = File.expand_path 'schema/swagger/2.0/schema.json', RESOURCES_DIR
+    JSON_SCHEMA = File.expand_path 'schema/json_schema/draft-04.json', RESOURCES_DIR
+
+    # Default options
+    OPT_VERBOSITY = 1     # output leve
+
+  end
+
+end  

data/lib/sbuilder/controller.rb

@@ -0,0 +1,798 @@
+require 'forwardable'
+
+module Sbuilder
+
+  class Controller
+
+
+
+    extend Forwardable                      # for easy delegation
+
+    attr_reader   :factory                    # factory pattern
+    attr_reader   :mappers                    # array of loader 'Resolver' objects
+
+    # model parts
+    attr_reader   :model                      # which contain values loaded
+    def_delegators :model, :extendDomain, :extendInterface, :interfaceEncountered, :definitionEncountered,
+                   :domainEncountered, :templateData, :getInterface, :extendStep
+    
+    def_delegators :factory, :createParameter, :createParamSet
+
+    
+
+    # ------------------------------------------------------------------
+    # validate configuration properties
+
+
+    DEFAULT_PREFERENCES = {
+      "debug-output" => true,                     # print debug output e.g. in interface processes
+    }
+    
+
+    @@validSetups_required    = [ "setupDirectory", ]
+    @@validSetups_allowed    = @@validSetups_required + [ 'extensions', "desc", "preferences", "possibilities" ]
+
+    @@extensionLoaderDef_required = ['type' ]
+    @@extensionLoaderDef_oneof = ["url", "file"]
+    @@extensionLoaderDef_allowed = @@extensionLoaderDef_required + @@extensionLoaderDef_oneof
+
+    @@interfaceLoaderDef_required = ['type',]
+    @@interfaceLoaderDef_oneof = [  'url', "file", ]
+    @@interfaceLoaderDef_allowed = @@interfaceLoaderDef_required + ["cache", "infrastructureServices" ]  + @@interfaceLoaderDef_oneof
+    
+    
+    @@validGenerateConfigs = ["output", "inputs"]
+    @@allowedGenerateConfigs       = @@validGenerateConfigs + ['category']
+    @@validGenerateDef_required    = [ "template", "desc", "modelData" ]
+    @@validGenerateDef_allowed     =  @@validGenerateDef_required + [ "templateParameters" ]
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "Controller"             # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+
+    # ------------------------------------------------------------------
+    # constructore
+    
+    def initialize( factory, options = {} )
+      
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized, options=#{options}" )
+
+      # init configs
+      @opts = { :gen_dir => options[:gen_dir] || Sbuilder::Constants::GEN_DIR,
+                # :src_dir => options[:src_dir] || Sbuilder::Constants::SRC_DIR,
+                :cnf_dir => options[:cnf_dir] || Sbuilder::Constants::CNF_DIR,
+                :cache_dir => options[:cache_dir] || Sbuilder::Constants::CACHE_DIR,
+                :cnf_file => options[:cnf_file] || Sbuilder::Constants::CNF_FILE,
+                :verbosity => options[:verbosity].nil? ? Sbuilder::Constants::OPT_VERBOSITY : options[:verbosity],
+                :filter_src => options[:filter_src] || false,
+                :templates => options[:templates],
+              } #.merge( options[PROGNAME] || {} )
+      @factory = factory
+      start
+    end
+
+    # @param possibilities [String:Array] possibilities defined in setup
+    def start
+      # init state
+      @mappers = []
+      @model = factory.createModel()
+
+    end
+
+    # ------------------------------------------------------------------
+    # build controller: load (domain) resolvers
+    
+    def loadResolvers( arrOfmappersTypePath )
+      !arrOfmappersTypePath.nil? && arrOfmappersTypePath.each do |mapperDef|
+        @logger.debug( "#{__method__} mapperDef=#{mapperDef} " )      
+        
+        # find correct loader based on type
+        loader  = factory.getResolverLoader( getResolverDefType( mapperDef ) )
+        
+        # load an put array
+        loaded = loader.load( getFileUrlOrPath( mapperDef ), self )        
+        # @mappers= mappers.concat(loaded) if loaded && loaded.any?
+        @logger.info( "#{__method__} @mappers.length=#{@mappers.length}" )              
+        @logger.debug( "mappers=#{mappers.map { |mapper| mapper.name }}")
+      end
+      @logger.info( "#{__method__} loaded #{mappers.size} mappers" )
+    end
+
+    # controllers gets informed that mapper is created
+    def mapperCreated( mapper )
+      @mappers << mapper
+    end
+
+    def findResolver( name )
+      @mappers.select{  |mapper| mapper.name == name }.first
+    end
+
+    # ------------------------------------------------------------------
+    # load extensions
+
+    # create load && add let it load
+    def loadExtensions( arrayOfExtensionDefs )
+
+      arrayOfExtensionDefs && arrayOfExtensionDefs.each do |extensionLoaderDef|
+        validateProperties( extensionLoaderDef, @@extensionLoaderDef_required, @@extensionLoaderDef_allowed )
+        validateOne( extensionLoaderDef, @@extensionLoaderDef_oneof )
+        
+
+        @logger.info( "#{__method__} extensionLoaderDef=#{extensionLoaderDef}" )
+        loader = factory.getExtensionLoader( extensionLoaderDef['type'] )
+        begin
+          loader.load( getFileUrlOrPath( extensionLoaderDef ), self  )
+        rescue Exception => ee
+          msg = "Error #{ee} caused by #{ee.backtrace.join("\n")} when loading '#{extensionLoaderDef['url']}'\n\n"
+          @logger.error( "#{__method__} #{msg}" )        
+          raise ControllerException.new msg
+        end
+      end
+      # domainLoader = factory.get
+    end
+
+    # ------------------------------------------------------------------
+    # load interfaces
+    
+    def loadInterfaces( arrOfparamsetTypePath )
+      !arrOfparamsetTypePath.nil? && arrOfparamsetTypePath.each do |interfaceParamsetDef|
+
+        validateProperties( interfaceParamsetDef, @@interfaceLoaderDef_required, @@interfaceLoaderDef_allowed )
+        validateOne( interfaceParamsetDef, @@interfaceLoaderDef_oneof )
+        
+        
+        # find correct loader based on type & configure it
+        loader = factory.getParamSetLoader( getParamsetType( interfaceParamsetDef ))
+        loader.configure( interfaceParamsetDef )
+        # load an put array
+        loader.load( self, getFileUrlOrPath( interfaceParamsetDef ), getParamsetCacheFilePath(interfaceParamsetDef) )
+        # @paramSets = paramSets.concat( loaded ) if loaded && loaded.any?
+      end
+    end
+
+    # # accept parameters set to model
+    # def interfaceEncountered( paramSet )
+    #   model.interfaceEncountered( paramSet )
+    # end
+
+    # def paramSets
+    #   model.paramSets
+    # end
+
+    # ------------------------------------------------------------------
+    # manages domains
+
+    # # called when loading mappers for each domain encountered, return domain
+    # def domainEncountered( domainName )
+    #   model.domainEncountered( domainName )
+    # end
+
+    # # delegate to domains
+    # def  domains
+    #   model.domains
+    # end
+
+
+    # load paremSets and mappers
+    def load
+      @logger.info( "#{__method__} load started" )      
+      loadResolvers( getResolversConfig )
+      loadInterfaces( getInterfaceConfig   )
+    end
+    
+
+    def extend
+      loadExtensions( getExtensionConfigs  )
+    end
+
+    # ------------------------------------------------------------------
+    # iterate setups
+    
+    def setup( setupDirectory=nil )
+
+      @logger.info( "#{__method__} getSetups=#{getSetups.join( " ------------  " )}, #{getSetups.length}" )                    
+      generated=false
+
+      # deep down makes a new call to getSetups --> interation fails
+      setups = Marshal.load( Marshal.dump( getSetups ))
+      setups.each_with_index do |setupDef,i|
+        
+        validateProperties( setupDef, @@validSetups_required, @@validSetups_allowed )
+        @logger.info( "#{__method__} -->next" ) if setupDirectory && (setupDef['setupDirectory'] != setupDirectory)
+        next if setupDirectory && setupDef['setupDirectory'] != setupDirectory 
+          
+        # process one setupDirectory
+        @logger.info( "#{__method__} start to generate setupDirectory=#{setupDirectory} for #{setupDef}" )
+
+        output( 1, "------------------------------------------------------------------" ) if isOptFilterSrc
+        output( 1, "generate setup: #{setupDef['setupDirectory']}" )
+        generate( setupDef['setupDirectory'], setupDef['setupDirectory'], setupDef['extensions'], setupDef['possibilities']  )
+        @logger.info( "#{__method__} done to generate setupDirectory=#{setupDirectory} for #{setupDef}" )                      
+        output( 2, "\n" ) 
+        
+        generated=true
+
+      end
+      
+      raise ControllerException.new <<-EOS if !generated && setupDirectory
+
+      Setup #{setupDirectory} not found - Nothing generated
+
+      Valid setups: #{getSetups.map {|setupDef| setupDef['setupDirectory']}.join(',')}
+
+      EOS
+
+      
+    end
+    
+
+    # ------------------------------------------------------------------
+    # resolve
+    def findResolverForParameterSet( paramSet )
+      mappers.each do |mapper|
+        if paramSet.matchesWithParamSet( mapper.matcher ) then
+          return mapper
+        end
+      end
+      return nil
+    end
+
+    def resolveDomains
+      @logger.info( "#{__method__} resolve started" )      
+      model.paramSets.each do |paramSet|
+        # @logger.info( "#{__method__} paramSet id=#{paramSet.getId}" )      
+        resolver = findResolverForParameterSet( paramSet )
+        if resolver.nil? then
+          msg = "Could not locate resolver for paramSet #{paramSet.getId}"
+          @logger.error( "#{__method__} #{msg}" )        
+          raise msg
+        end
+        @logger.info( "#{__method__} resolved resolver.matcher #{resolver.matcher} for paramset id #{paramSet.getId}" )
+        # delegate action
+        begin
+          resolver.resolveDomains( paramSet, model )
+         rescue ResolverException => e
+          msg = "Error '#{e}' when mapping domains for parameter set '#{paramSet.getId}'"
+          puts msg
+          @logger.error( "#{__method__} #{msg}" )        
+          raise
+        end
+      end
+      
+    end
+
+    def resolve
+      resolveDomains
+    end
+
+    # ------------------------------------------------------------------
+    # start, load, resolve, extend && output
+    #
+    # @param setupName [String] name of setup, currently = extensionDirectory
+    # @param extensionDirectory [String]  directory where setup generated
+    # @arrayOfExtensionDefs [Hash:Array] of extenstions to load
+    
+    def generate( setupName="default", extensionDirectory="default", arrayOfExtensionDefs=[], possibilities=[] )
+      @logger.info( "#{__method__} setupName=#{setupName}, extensionDirectory=#{extensionDirectory}" )
+      @logger.debug( "#{__method__} arrayOfExtensionDefs=#{arrayOfExtensionDefs}, possibilities=#{possibilities}" )      
+
+      # init state
+      start
+
+      # load configs
+      load
+
+      # resolve domain
+      resolve
+
+      # extensions
+      loadExtensions( arrayOfExtensionDefs )
+
+      # config model - before config rendering
+      model.setPossibilities( possibilities )
+      
+      # config && get renderes
+      mustache = prepareRender( setupName )
+
+      # path to directory where setup output is done
+      directoryPath = prepareSetupDir( extensionDirectory )
+      
+      # output 'normal templates' - one generate def/one output
+      generateCase( setupName, directoryPath, nil, mustache )
+
+      # For 'possibities': map array of possibilities to array
+      # of filenames created using an output -property on
+      # 'generate' definition
+      possibilities && generateCase( setupName, directoryPath, 'possibility', mustache ) do |output|
+        # use output as template rendering
+        possibilities.map do |p|
+          {
+            :possibility => p,
+            :outputFile => mustache.render_str( output, { "possibility" =>  p } ),
+          }
+        end # map
+      end
+      
+    end
+
+
+    # Ensure that directory 'extensionDirectory' exists under
+    # 'getGenerateDir'
+    #
+    # @return [String] directoryPath where extension should be written
+    def  prepareSetupDir( extensionDirectory )
+      # Ensure that 'extensionDirectory' exists
+      raise ControllerException.new "Directory #{getGenerateDir} does not exist"  unless File.exist?( getGenerateDir )
+      # directory for setupName create automatically
+      directoryPath = "#{getGenerateDir}/#{extensionDirectory}"
+      Dir.mkdir( directoryPath ) unless File.exist?( directoryPath )
+      return directoryPath  
+
+    end
+
+    # @return  [Sbuilder::Template] mustache template generator
+    def prepareRender( setupName )
+      
+      # access template generator from factory
+      reader = factory.getTemplateReader( self )
+      # configure reader if it is ready to accept 'setupName'
+      reader.setSetupName( setupName ) if reader.respond_to?( :setSetupName )
+      # pass reader to template generator
+      mustache = factory.getTemplate( reader )
+
+      return mustache
+    end
+
+    # Output setup for 'setupName' to 'extensionDirectory'.
+    #
+    # @param setupName [String] identitying setup to process
+    #
+    # @param directoryPath [String] path to directory under which
+    # outputting files
+    #
+    # @param generateCategory [Nil|String] choose templates in
+    # 'generateCategory', Nil = no category defined. Intended
+    # usage for to generate possibitilies
+    #
+    # @param mustache [Sbuilder::Template] generator to render
+    #
+    # @param blk [Block] to use indirection in output files stuff
+    #
+    def generateCase( setupName, directoryPath, generateCategory, mustache, &blk )
+      
+      @logger.info( "#{__method__} directoryPath=#{directoryPath}" )
+
+      # configs in 'generate' -property with correct 'category'
+      generateConfigs = getGenerateConfig( generateCategory )
+
+      # create all files defined in 'generateConfigs'
+      generateConfigs.each do |generateFile|
+
+        # validate generate configuration 
+        validateProperties( generateFile, @@validGenerateConfigs, @@allowedGenerateConfigs )
+
+        # use 'output' config or indirection using blk
+        outputDefinitions = blk ?
+                             yield(  generateFile['output'] ) :
+                             [
+                               {
+                                 :possibility => nil,
+                                 :outputFile => generateFile['output'],
+                               }
+                             ]
+        @logger.debug( "#{__method__}: outputDefinitions=#{outputDefinitions}" )
+
+        # one config in 'generateFile['output']' may result to sevaral files (possiblity)
+        outputDefinitions.each do |outputDefinition|
+
+          # set model data - to be able to access in template
+          model.setPossibility( outputDefinition[:possibility] )
+          
+          # Ensure directory for 'outputFile' exists
+          outputFile = outputDefinition[:outputFile]
+          outputPath = "#{directoryPath}/#{outputFile}"
+          # create sub directory for output if it does not exist
+          outputDirectory = File.dirname( outputPath )
+          Dir.mkdir( outputDirectory ) unless File.exist?( outputDirectory )
+
+          # header for file
+          output( 2, "--> generate: #{outputPath}" )
+          
+          # open file and output in 'generateTemplate'
+          f = File.open( outputPath, "w" )
+          begin
+            # one output file get generates using multiple 'inputs'
+            generateFile['inputs'].each do |generateDef|
+              generateTemplate( setupName, outputPath, f, generateDef, mustache )
+            end
+          ensure
+            f.close
+          end
+          output( 3, "\n" )
+        end # each outputFiles
+
+      end
+      
+    end
+
+    # Expand template 'generateDef["template"]' using 'templateData'
+    # 
+    # Create templateData to pass to rendering: (CONFIG,META,
+    # PARAMETERS,PREFERENCES, filter), render template(s) named in
+    # 'generateDef.template', output to 'fileHandle'.
+    #
+    # @param outputPath [String] path of file to output
+    #
+    # @param f [File] file handle (for 'outputPath' to output )
+    #
+    # @param mustache [Sbuilder::Template] mustache template generator
+    # 
+    # @param generateDef [Hash] configuration
+    # {:template,:desc,:modelData,:templateParameters} controlling
+    # output
+    # 
+    def generateTemplate( setupName, outputPath, fileHandle, generateDef, mustache )
+
+      # validate configuration
+      validateProperties( generateDef, @@validGenerateDef_required, @@validGenerateDef_allowed )
+
+      # access data to output - and filter it
+      renderData = templateData( generateDef['modelData'] )
+      # e.g. prune interfaces not used in setup
+      renderData = setupFilter( generateDef['modelData'], renderData )
+      
+      # Iterate each 'template' in one 'generateDef' array (most often just one template)
+      templates = generateDef['template'].is_a?( Array ) ? generateDef['template'] : [ generateDef['template'] ]
+
+      # Support paramters to template
+      templateParameters = generateDef['templateParameters'].nil? ? {} : generateDef['templateParameters']
+      
+      # optional parameters added in generate -section
+      renderData['PARAMETERS'] = templateParameters
+
+      # META-data added to data to render
+      templates.each do |template|
+
+        renderData['CONFIG'] = @opts
+
+        renderData['META'] =
+          {
+            :desc => generateDef['desc'],
+            :modelData => generateDef['modelData'],
+            :template => template,
+            :version => Sbuilder::version,
+            :model_version => Sbuilder::model_version,            
+            :timestamp => Time.new.strftime( "%Y-%m-%d %H:%M:%S" ),
+            :setup => setupName,
+            :outputDirectory => File.dirname( outputPath ),            
+            :outputFile => File.basename( outputPath ),
+            :outputModule => File.basename( outputPath, ".*" ),
+          }
+
+        renderData['ACTIONS'] = {
+          :cat => lambda do |path_template|
+            path = mustache.render_str( path_template, renderData )
+            File.readlines( path.strip ).join('')
+          end
+        }
+
+        # support 'PREFERENCES'
+        renderData.merge!( getPreferencesData(setupName ))
+
+        # finally render i.e. create string to output
+        str = mustache.to_str( template, renderData )
+        
+        # output to file
+        @logger.info( "#{__method__} templateName=#{template}" )
+        output( 3, "    ---> #{generateDef['desc']} (#{template})" )
+        fileHandle.puts str
+        
+      end # templates.each
+
+    end
+    
+
+
+    # Decide whether 'dataElement' should be passed to template
+    # rendering.
+    # 
+    # Implementation: Default 'true', however when
+    # 'options[:filter_src]' && 'modelData' == "interface" show only
+    # if included in 'getSetupStepInterfaceOperations'
+    #
+    #
+    # @param modelData [String] type of data (see model#templateData)
+    #
+    # @param d [Hash] data element, content depends on 'modelData'
+    #
+    # @return [Boolean] true when show the elmement
+    def setupFilter( modelData, renderData )
+    case modelData
+    when "interfaces"
+      return renderData unless isOptFilterSrc
+      # show only interfaces_operations referenced in 'steps'
+      interface_operations = getSetupStepInterfaceOperations
+      renderData['interfaces'] = renderData['interfaces'].select{ |d| interface_operations.include?( d[:interface_operation] ) }
+      @logger.info( "#{__method__}: filtered renderData['interfaces']=#{renderData['interfaces'].map{|i| i[:interface_operation]}}" )
+      return renderData
+    else
+      # default is to show all
+      renderData
+    end
+    end
+
+    # Read model#templateData('steps') and return array interface
+    # operations reference in model steps.
+    # 
+    # @return [String:Array] of interface operation names
+    def getSetupStepInterfaceOperations
+      interface_operations = {}
+      model.templateData( "steps" )['steps'].each  {|s| interface_operations[s[:interface_operation]] = true }
+      ret = interface_operations.keys
+      @logger.info( "#{__method__}: interface_operations=#{ret}" )
+      return ret
+    end
+
+    # Return names defined in mode (definitions)
+    #
+    # @return [String:Array] of names in define in model
+    def getModelNames
+      ret = []
+      
+      # definition map to types 't_:defintion_name'
+      ret += templateData( "definitions" )['definitions'].map { |d| "t_#{d[:definition_name]}"}
+
+      # domain --> 'd_:domain_name'
+      ret += templateData( "domains" )['domains'].map { |d| "d_#{d[:domain_name]}"}      
+      
+      @logger.debug( "#{__method__} ret=#{ret.join(',')}" )
+      ret
+    end
+
+    # Return entry_points such that
+    # interfaces[steps.interface_operation ==
+    # intertafaces.interface_operation].implementation
+    #
+    # @return [String:Array] names of interface[:implementation]
+    #
+    def getEntryPoints
+      setup_operations = {}
+      
+      steps = model.templateData( "steps" )['steps']
+      interfaces = model.templateData( "interfaces" )['interfaces']
+      
+      steps.each { |s| setup_operations[s[:interface_operation]] = true }
+      @logger.debug( "#{__method__}:  setup_operations= #{setup_operations}" )
+      entry_points = interfaces.
+                      select {|i| setup_operations[i[:interface_operation]] }.
+                      map { |i|  i[:implementation] }
+      @logger.info( "#{__method__}:  entry_points= #{entry_points}" )      
+      entry_points
+      
+    end
+
+    # Return possibilities for current setup.
+    #
+    # @return [String:Array] of possibiliy operator names
+    def getSetupPossibilities
+      setupPossis = model.possibilities
+      @logger.info( "#{__method__}:  setupPossis= #{setupPossis}" )
+      return setupPossis
+    end
+
+    # create data to pass to template generateion
+    # def templateData
+    #   return model.templateData
+    # end
+
+    # ------------------------------------------------------------------
+    # configuration
+
+
+    # cache '@controller_config' read 'getConfigFilePath' and 'getInternalConfigFilePath', merge 'generate'
+    def getConfig
+
+      return @controller_config if @controller_config
+      
+      @logger.info( "#{__method__} loading config from #{getConfigFilePath}" )
+      yaml_lines = Sbuilder::Utils::NetIo.read_lines( getConfigFilePath )
+      @controller_config = YAML.load( yaml_lines )
+      # allow empty generate section
+      @controller_config = {} if @controller_config.nil?
+      @controller_config['generate'] = [] unless @controller_config['generate']
+      @logger.debug( "#{__method__} config in #{getConfigFilePath} controller_config= #{@controller_config.to_yaml}" )
+
+      yaml_lines = Sbuilder::Utils::NetIo.read_lines( getInternalConfigFilePath )
+      internal_config = YAML.load( yaml_lines )
+      internal_config['generate'] = [] unless internal_config['generate']
+      @logger.debug( "#{__method__} internal_config= #{internal_config.to_yaml}" )      
+
+      @logger.debug( "#{__method__} config in #{getInternalConfigFilePath} internal_config= #{internal_config.to_yaml}" )      
+      @controller_config['generate'] = @controller_config['generate'] + internal_config['generate']
+      @logger.debug( "#{__method__} @controller_config=#{@controller_config.to_yaml}" )            
+      @controller_config
+    end
+
+    def getSetups
+      getConfig()['setups']
+    end
+
+    # @param setupName [String] name of setup to get
+    # @return [Hash] hash of set in sbuilder configuration
+    def getSetup( setupName )
+      setup = getSetups.select { |setup| setup['setupDirectory'] == setupName }.first
+      @logger.debug( "#{__method__} setupName=#{setupName}, setup=#{setup} " )      
+      setup
+    end
+    
+
+    def getPreferencesData( setupName )
+      renderData = {}
+      renderData['PREFERENCES'] = getPreferencesWithDefaults( setupName )
+      return renderData
+    end
+
+    # Get prefecnces with default setttings
+    # @return preferences [Hash]  with values for all known preferences
+    def getPreferencesWithDefaults( setupName )
+      DEFAULT_PREFERENCES.merge( getPreferences ).merge( getSetupPrefences( setupName ))
+    end
+    
+    # Access preferences in main configuration file 'sbuilder.yaml'
+    #
+    # @return preferences [Hash] possible empty (but definitely
+    # non-nil)
+    def getPreferences
+      getConfig()['preferences'] || {}
+    end
+
+    # @param setupName [String] name of setup in 'setups' propertys
+    # @return [Hash] preferences in setup[setupName] or {}
+    def getSetupPrefences( setupName )
+      getSetup(setupName)['preferences'] || {}
+    end
+
+    # Currently uses first element in template as code repostirory
+    # @return [String] path to code repository
+    def getCodeRepository
+      getOpt( :templates ).first
+    end
+
+    private
+
+    # path to configuration file 
+    def getConfigFilePath()
+      "#{getOpt(:cnf_dir)}/#{getOpt(:cnf_file)}"
+    end
+
+    # path to interal configuration file 
+    def getInternalConfigFilePath()
+      File.join File.dirname( __FILE__), "default-sbuilder.yaml"
+    end
+
+    def getInterfaceConfig
+      getConfig()['interfaces']
+    end
+    
+    def getExtensionConfigs    
+      getConfig()['extensions']
+    end
+
+
+    def getResolversConfig
+      getConfig()['resolvers']
+    end
+
+    # @param generateCategory [Nil|String] choose templates in
+    # 'generateCategory', @return [Hash:Array] of {'output', 'inputs'}
+    # defining a file to render using templates in 'inputs'
+    def getGenerateConfig( generateCategory )
+      ret = getConfig()['generate']
+      if ret.nil? then
+        warn <<-EOS
+        Could not locate section 'generate' in sbuilder configuration
+
+
+        #{getConfig().to_yaml}
+        EOS
+        return [] 
+      end
+      
+      #  Screen category
+      ret.select { |c| c['category'] == generateCategory }
+    end
+
+    # return uri whero load from
+    def getFileUrlOrPath( paramSetDef )
+      @logger.info( "#{__method__} paramSetDef=#{paramSetDef}" )
+      if paramSetDef['file'] then
+        return "#{getOpt(:cnf_dir)}/#{paramSetDef['file']}"
+      elsif paramSetDef['url'] then
+        return paramSetDef['url']
+      else
+        raise "Param set definition #{paramSetDef} should defined 'file' or 'url'"
+      end
+        
+    end
+
+    # return optional cacheFilePath from paramSetDef, nil if no 'cache' -property
+    def getParamsetCacheFilePath( paramSetDef )
+      return "#{getOpt(:cache_dir)}/#{paramSetDef['cache']}" if paramSetDef['cache'] && getOpt(:cache_dir)
+      return paramSetDef['cache']  if paramSetDef['cache']
+      return nil
+    end
+    
+    def getParamsetType( paramSetDef )
+      paramSetDef['type']
+    end
+
+    # def getResolverDefPath( mapperDef )
+    #   if mapperDef['file'] then
+    #     return "#{getOpt(:cnf_dir)}/#{mapperDef['file']}"
+    #   elsif mapperDef['url'] then
+    #     return mapperDef['url']
+    #   else
+    #     raise "Resolver definition #{mapperDef} should defined 'file' or 'url'"
+    #   end
+    # end
+
+    def getResolverDefType( resolverDef )
+      resolverDef['type']
+    end
+    
+    def getGenerateDir
+      getOpt(:gen_dir)
+    end
+
+
+    # return option for a key
+    def getOpt( optKey )
+      @opts[ optKey ]
+    end
+
+    # @return [boolean] true when should filter specifcation model
+    def isOptFilterSrc
+      getOpt( :filter_src )
+    end
+
+    # ------------------------------------------------------------------
+    # output
+    
+    def output( level,  msg, nl=true )
+      if nl
+        puts msg if output_show( level )
+      elsif output_show( level )
+        print msg
+        $stdout.flush
+      end
+    end
+
+    # @return [Boolean] true if output on level
+    def output_show( level )
+      level <= @opts[:verbosity]
+    end
+
+    # validate 'defintionHash' all 'required'/only 'allowed' props set
+    private def validateProperties( defintionHash, required, allowed=nil )
+
+      allowed = required unless allowed
+      
+      missingProps = required - defintionHash.keys
+      raise ControllerException.new "Missing properties #{missingProps} in #{defintionHash} - required #{required}" if missingProps.any?
+
+      invalidProps = defintionHash.keys - allowed 
+      raise ControllerException.new "Unknown properties #{invalidProps} in #{defintionHash} - allowed #{allowed}" if invalidProps.any?
+
+    end
+
+    private def validateOne( defintionHash, propList )
+      raise ControllerException.new "Must give one  #{propList} in #{defintionHash}" unless propList.select {|prop| defintionHash.has_key?(prop) }.length == 1
+    end
+    
+    
+    
+  end # class
+
+end