forj 1.0.1 → 1.0.2

data/lib/helpers.rb

@@ -1,56 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-# (c) Copyright 2014 Hewlett-Packard Development Company, L.P.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
-require 'fileutils' 
-
-module Helpers
-  def get_home_path
-    File.expand_path('~')
-  end
-
-  def create_directory(path)
-    unless File.directory?(path)
-      Dir.mkdir path
-    end
-  end
-  
-  def dir_exists?(path)
-    if File.exists?(path)
-       if not File.directory?(path)
-          msg = "'%s' is not a directory. Please fix it." % path
-          if $FORJ_LOGGER
-             Logging.fatal(1, msg)
-          else
-             raise msg
-          end
-       end
-       if not File.readable?(path) or not File.writable?(path) or not File.executable?(path)
-          msg = "%s is not a valid directory. Check permissions and fix it." % path
-          if $FORJ_LOGGER
-             Logging.fatal(1, msg)
-          else
-             raise msg
-          end
-       end
-       return true
-    end
-    false
-  end
-  
-
-  
-end

data/lib/lib-forj/lib/core/core.rb

@@ -1,1740 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-# (c) Copyright 2014 Hewlett-Packard Development Company, L.P.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
-
-# Those classes describes :
-# - processes (BaseProcess)   : How to create/delete/edit/query object.
-# - controler (BaseControler) : If a provider is defined, define how will do object creation/etc...
-# - definition(BaseDefinition): Functions to declare objects, query/data mapping and setup
-# this task to make it to work.
-
-module ForjLib
-   def ForjLib::debug(iLevel, sMsg)
-      if iLevel <= $LIB_FORJ_DEBUG
-         Logging.debug("-%s- %s" % [iLevel, sMsg])
-      end
-   end
-end
-
-module ForjLib
-   class ForjLib::Data
-
-      def initialize(oType = :object)
-         # Support :data for single object data
-         #         :list for a list of object data
-         oType = :data if not [:list, :object, :data].include?(oType)
-         @oType = oType
-         case oType
-            when :data, :object
-               @data = new_object
-            when :list
-               @data = new_object_list
-         end
-      end
-
-      def type?()
-         @oType
-      end
-
-      def object_type?()
-         @data[:object_type]
-      end
-
-      def set(oObj, sObjType = nil, hQuery = {})
-         if oObj.is_a?(ForjLib::Data)
-            oType = oObj.type?
-            case oType
-               when :data, :object
-                  @data[:object_type] = ((sObjType.nil?)? (oObj.object_type?) : sObjType)
-                  @data[:object] = oObj.get(:object)
-                  @data[:attrs] = oObj.get(:attrs)
-               when :list
-                  @data[:object_type] = ((sObjType.nil?)? (oObj.object_type?) : sObjType)
-                  @data[:object] = oObj.get(:object)
-                  @data[:list] = oObj.get(:list)
-                  @data[:query] = oObj.get(:query)
-            end
-            return self
-         end
-
-         # while saving the object, a mapping work is done?
-         case @oType
-            when :data, :object
-               @data[:object_type] = sObjType
-               @data[:object] = oObj
-               @data[:attrs] = yield(sObjType, oObj)
-            when :list
-               @data[:object] = oObj
-               @data[:object_type] = sObjType
-               @data[:query] = hQuery
-               unless oObj.nil?
-                  begin
-                     oObj.each { | oObject |
-                        next if oObject.nil?
-                        begin
-                           oDataObject = ForjLib::Data.new(:object)
-
-                           oDataObject.set(oObject, sObjType) { |sObjectType, oObject|
-                              yield(sObjectType, oObject)
-                           }
-                           @data[:list] << oDataObject
-                        rescue => e
-                           raise ForjError.new(), "'%s' Mapping attributes issue.\n%s" % [sObjType, e.message]
-                        end
-                     }
-                  rescue => e
-                     raise ForjError.new(), "each function is not supported by '%s'.\n%s" % [oObj.class, e.message]
-                  end
-               end
-         end
-         self
-      end
-
-      def type=(sObjType)
-         return self if self.empty?
-         @data[:object_type] = sObjType
-         self
-      end
-
-      def [](*key)
-         get(*key)
-      end
-
-      def []=(*key, value)
-         return false if @oType == :list
-         rhSet(@data, value, :attrs, key)
-         true
-      end
-
-      def get(*key)
-         return @data if key.length == 0
-         case @oType
-            when :data, :object # Return only attrs or the real object.
-               return @data[key[0]] if key[0] == :object
-               return rhGet(@data, key) if key[0] == :attrs
-               rhGet(@data, :attrs, key)
-            when :list
-               return @data[key[0]] if [:object, :query].include?(key[0])
-               return @data[:list][key[0]] if key.length == 1
-               @data[:list][key[0]][key[1..-1]] # can Return only attrs or the real object.
-         end
-      end
-
-      def exist?(*key)
-         case @oType
-            when :data, :object
-               return true if key[0] == :object and @data.key?(key[0])
-               return true  if key[0] == :attrs and rhExist?(@data, key)
-               (rhExist?(@data, :attrs, key) == key.length+1)
-            when :list
-               return true if key[0] == :object and @data.key?(key[0])
-               (rhExist?(@data[:list][key[0]], :attrs, key[1..-1]) == key.length)
-         end
-      end
-
-      def empty?()
-         @data[:object].nil?
-      end
-
-      def nil?()
-         # Obsolete Use empty? instead.
-         @data[:object].nil?
-      end
-
-      def length()
-         case @oType
-            when :data
-               return 0 if self.nil?
-               1
-            when :list
-               @data[:list].length
-         end
-      end
-
-      def each(sData = :list)
-         to_remove = []
-         return nil if @oType != :list or not [:object, :list].include?(sData)
-
-         @data[:list].each { |elem|
-            sAction = yield (elem)
-            case sAction
-               when :remove
-                  to_remove << elem
-            end
-         }
-         if to_remove.length > 0
-            to_remove.each { | elem |
-               @data[:list].delete(elem)
-            }
-         end
-      end
-
-      def each_index(sData = :list)
-         to_remove = []
-         return nil if @oType != :list or not [:object, :list].include?(sData)
-
-         @data[:list].each_index { |iIndex|
-            sAction = yield (iIndex)
-            case sAction
-               when :remove
-                  to_remove << @data[:list][iIndex]
-            end
-         }
-         if to_remove.length > 0
-            to_remove.each { | elem |
-               @data[:list].delete(elem)
-            }
-         end
-      end
-
-      def registered?()
-         @bRegister
-      end
-
-      def register()
-         @bRegister = true
-         self
-      end
-
-      def unregister()
-         @bRegister = false
-         self
-      end
-      private
-
-      def new_object_list
-         {
-            :object        => nil,
-            :object_type   => nil,
-            :list          => [],
-            :query         => nil
-         }
-      end
-
-      def new_object
-         oCoreObject = {
-            :object_type => nil,
-            :attrs => {},
-            :object => nil,
-         }
-      end
-
-   end
-end
-
-class ForjError < RuntimeError
-   attr_reader :ForjMsg
-
-   def initialize(message = nil)
-      @ForjMsg = message
-   end
-end
-
-# Class to handle key or keypath on needs
-class KeyPath
-
-   def initialize(sKeyPath = nil)
-
-      @keypath = []
-      self.set sKeyPath
-   end
-
-   def key=(sKeyPath)
-      self.set(sKeyPath)
-   end
-
-   def set(sKeyPath)
-
-      if sKeyPath.is_a?(Symbol)
-         @keypath = [ sKeyPath]
-      elsif sKeyPath.is_a?(Array)
-         @keypath = sKeyPath
-      elsif sKeyPath.is_a?(String)
-         if /[^\\\/]?\/[^\/]/ =~ sKeyPath or /:[^:\/]/ =~ sKeyPath
-            # keypath to interpret
-            aResult = sKeyPath.split('/')
-            aResult.each_index { | iIndex |
-               next if not aResult[iIndex].is_a?(String)
-               aResult[iIndex] = aResult[iIndex][1..-1].to_sym if aResult[iIndex][0] == ":"
-            }
-            @keypath = aResult
-         else
-            @keypath = [sKeyPath]
-         end
-      end
-   end
-
-   def aTree()
-      @keypath
-   end
-
-   def sFullPath()
-      return nil if @keypath.length == 0
-      aKeyAccess = @keypath.clone
-      aKeyAccess.each_index { |iIndex|
-         next if not aKeyAccess[iIndex].is_a?(Symbol)
-         aKeyAccess[iIndex] = ":" + aKeyAccess[iIndex].to_s
-      }
-      aKeyAccess.join('/')
-   end
-
-   def to_s
-      return nil if @keypath.length == 0
-      aKeyAccess = @keypath.clone
-      aKeyAccess.each_index { |iIndex|
-         next if not aKeyAccess[iIndex].is_a?(Symbol)
-         aKeyAccess[iIndex] = aKeyAccess[iIndex].to_s
-      }
-      aKeyAccess.join('/')
-   end
-
-   def sKey(iIndex = -1)
-      return nil if @keypath.length == 0
-      @keypath[iIndex] if self.length >= 1
-   end
-
-   def length()
-      @keypath.length
-   end
-end
-
-# This is the main class definition.
-# It drives creation of High level cloud class object, like servers
-# Initialization requires a Configuration Object (ForjConfig) and the Account to load.
-# Account is loaded with ForjAccount Object.
-# During ForjCloud initialization, general options + account options are loaded.
-
-# For example, to create a server
-
-#   oCloud = ForjCloud.new(oConfig, 'myhpcloud')
-#   oConfig.set(:server_name,'myservername')
-#   oCloud.Create(:server)
-
-# Most of data are predefined from account or general config.
-# If some required value are missing, an error is reported.
-# A Process Object can be defined, in order to add some process features, like :maestro_server
-
-# Based Forj Object to use, with a process and (or not) a controler.
-class ForjObject
-
-   # ForjObject parameters are:
-   # oForjConfig : Required. an instance of a configuration system which HAVE to provide
-   #               2 kind of functions:
-   #               - set (key, value) and []=(key, value)
-   #                 From processes, you can set a runtime data with:
-   #                    config.set(key, value)
-   #                 OR
-   #                    config[key] = value
-   #
-   #               - get (key, default) and [](key, default)
-   #                 default is an optional value.
-   #                 From processes, you can get a data (runtime/account/config.yaml or defaults.yaml) with:
-   #                    config.get(key)
-   #                 OR
-   #                    config[key]
-
-   # sProcessClass: Required. string or symbol. Is the name of ProcessClass to use.
-   #                This class is dynamically loaded and derived from BaseProcess class.
-   #                It loads the Process class content from a file '$CORE_PROCESS_PATH/<sProcessClass>.rb'
-   #                If sProcessClass is a file path, this file will be loaded as a ruby include.
-
-   # <sProcessClass>.rb file name is case sensible and respect RUBY Class name convention
-
-   # sControllerClass: Optional. string or symbol. Is the name of ControlerClass to use.
-   #                  This class is dynamically loaded and derived from BaseControler class.
-   #                  It loads the Controler class content from a file '$PROVIDER_PATH/<sControlerClass>.rb'
-   #
-   #                  The provider can redefine partially or totally some processes
-   #                  ForjObject will load those redefinition from file:
-   #                  '$PROVIDER_PATH/<sControlerClass>Process.rb'
-
-   # <sControllerClass>.rb or <sControllerClass>Process.rb file name is case sensible and respect RUBY Class name convention
-
-   attr_reader :config
-
-
-   def initialize(oForjConfig, processesClass = nil, sControllerClass = nil)
-      # Loading ProcessClass
-      # Create Process derived from respectively BaseProcess
-      @config = oForjConfig
-
-      if processesClass.nil?
-         aProcessesClass = []
-      elsif not processesClass.is_a?(Array)
-         aProcessesClass = [processesClass]
-      else
-         aProcessesClass = processesClass
-      end
-
-      cBaseProcess = BaseProcess
-      cProcessClass = nil
-
-      aProcessesClass.each { | sProcessClass |
-         ForjLib.debug(1, "Loading Process '%s'" % sProcessClass)
-
-         # And load the content from the <sProcessClass>.rb
-         if sProcessClass.is_a?(Symbol)
-            sFile = File.join($CORE_PROCESS_PATH, sProcessClass.to_s + '.rb')
-         else
-            if sProcessClass.include?('/')
-               # Consider a path to the process file. File name is the name of the class.
-               sPath = File.dirname(File.expand_path(sProcessClass))
-               file = File.basename(sProcessClass)
-               file['.rb'] = '' if file['.rb']
-               sProcessClass = file
-               sProcessClass = file.capitalize if (/[A-Z]/ =~ file) != 0
-            else
-               sPath = $CORE_PROCESS_PATH
-            end
-            sFile = File.join(sPath, sProcessClass + '.rb')
-         end
-         if File.exists?(sFile)
-            cNewClass = Class.new(cBaseProcess)
-            sProcessClass = "%sProcess" %  sProcessClass if not /Process$/ =~ sProcessClass
-            ForjLib.debug(1, "Declaring Process '%s'" % sProcessClass)
-            cBaseProcess = Object.const_set(sProcessClass, cNewClass)
-            cProcessClass = sProcessClass
-            BaseDefinition.current_process(cBaseProcess)
-            load sFile
-         else
-            Logging.warning("Process file definition '%s' is missing. " % sFile)
-         end
-      }
-
-      if sControllerClass
-         ForjLib.debug(1, "Loading Controler/definition '%s'" % sControllerClass)
-         # Add Provider Object -------------
-         sProviderClass = sControllerClass.capitalize
-
-         # Initialize an empty class derived from BaseDefinition.
-         # This to ensure provider Class will be derived from this Base Class
-         # If this class is derived from a different Class, ruby will raise an error.
-
-         # Create Definition and Controler derived from respectively BaseDefinition and BaseControler
-         cBaseDefinition = Class.new(BaseDefinition)
-         # Finally, name that class!
-         Object.const_set sProviderClass, cBaseDefinition
-
-         cBaseControler = Class.new(BaseController)
-         Object.const_set sProviderClass + 'Controller', cBaseControler
-
-         # Loading Provider base file. This file should load a class
-         # which have the same name as the file.
-         if sControllerClass.include?('/')
-            # Consider a path to the process file. File name is the name of the class.
-            sPath = File.dirname(File.expand_path(sControllerClass))
-            file = File.basename(sControllerClass)
-            file['.rb'] = '' if file['.rb']
-            sControllerClass = file
-         else
-            sPath = File.join($PROVIDERS_PATH, sControllerClass)
-         end
-         sFile = File.join(sPath, sProviderClass + '.rb')
-         if File.exists?(sFile)
-            load sFile
-         else
-            raise ForjError.new(), "Provider file definition '%s' is missing. Cannot go on" % sFile
-         end
-
-         #cForjBaseCloud = Class.new(ForjBaseCloud)
-         # Finally, name that class!
-         #Object.const_set sProviderClass, cForjBaseCloud
-
-         # Identify Provider Classes. Search for
-         # - Definition Class (sProviderClass) - Contains ForjClass Object
-         # - Controller Class (sProviderClass + 'Controller') - Provider Cloud controler object
-
-         # Search for Definition Class
-         begin
-            # Get it from Objects
-            oDefClass = Object.const_get(sProviderClass)
-         rescue
-            raise ForjError.new(), 'ForjCloud: Unable to find class "%s"' % sProviderClass
-         end
-
-         # Search for Controler Class
-         # - Process Class (sProviderClass + 'Process') - Provider Process object if defined
-         begin
-            # Get the same one suffixed with 'Provider' from Objects
-            oCoreObjectControllerClass = Object.const_get(sProviderClass + 'Controller')
-         rescue
-            raise ForjError.new(), 'ForjCloud: Unable to find class "%s"' % sProviderClass + 'Controller'
-         end
-
-         # Then, we create an BaseCloud Object with 2 objects joined:
-         # ForjAccount and a BaseControler Object type
-
-
-      else
-         oCoreObjectControllerClass = nil
-      end
-
-      # Add Process management object ---------------
-      unless cProcessClass.nil?
-         begin
-            oBaseProcessDefClass = Object.const_get(cProcessClass)
-         rescue
-            raise ForjError.new(), 'ForjCloud: Unable to find class "%s"' % cProcessClass
-         end
-      else
-         raise ForjError.new(), 'ForjCloud: No valid process loaded. Aborting.'
-      end
-      # Ex: Hpcloud(ForjAccount, HpcloudProvider)
-      if oCoreObjectControllerClass
-         @oCoreObject = oDefClass.new(oForjConfig, oBaseProcessDefClass.new(), oCoreObjectControllerClass.new())
-      else
-         @oCoreObject = oDefClass.new(oForjConfig, oBaseProcessDefClass.new())
-      end
-
-   end
-
-   def Connect(oCloudObj)
-      return nil if not oCloudObj or not @oCoreObject
-      @oCoreObject.Connect(oCloudObj)
-   end
-
-   def Create(oCloudObj)
-      return nil if not oCloudObj or not @oCoreObject
-      @oCoreObject.Create(oCloudObj)
-   end
-
-   def Delete(oCloudObj)
-      return nil if not oCloudObj or not @oCoreObject
-
-      @oCoreObject.Delete(oCloudObj)
-   end
-
-   def Query(oCloudObj, sQuery)
-      return nil if not oCloudObj or not @oCoreObject
-
-      @oCoreObject.Query(oCloudObj, sQuery)
-   end
-
-   def Get(oCloudObj, sId)
-      return nil if not oCloudObj or not @oCoreObject or sId.nil?
-
-      @oCoreObject.Get(oCloudObj, sId)
-   end
-
-   def Update(oCloudObj)
-      return nil if not oCloudObj or not @oCoreObject
-
-      @oCoreObject.Update(oCloudObj)
-   end
-
-   # Function used to ask users about setting up his account.
-   def Setup(oCloudObj, sAccountName = nil)
-      return nil if not oCloudObj or not @oCoreObject
-      @oCoreObject.Setup(oCloudObj, sAccountName)
-   end
-end
-
-# This class based on generic ForjObject, defines a Cloud Process to use.
-class ForjCloud < ForjObject
-   def initialize(oConfig, sAccount = nil, aProcesses = [])
-
-      unless oConfig.is_a?(ForjAccount)
-         oForjAccount = ForjAccount.new(oConfig)
-         unless sAccount.nil?
-            oForjAccount.ac_load(sAccount)
-         end
-      else
-         oForjAccount = oConfig
-      end
-      aProcessList = [:CloudProcess]
-
-      sControllerMod = oForjAccount.get(:provider_name)
-      raise ForjError.new(), "Provider_name not set. Unable to create instance ForjCloud." if sControllerMod.nil?
-
-      sControllerProcessMod = File.join($PROVIDERS_PATH, sControllerMod, sControllerMod.capitalize + "Process.rb")
-      if File.exist?(sControllerProcessMod)
-         aProcessList << sControllerProcessMod
-      else
-         ForjLib.debug(1, "No Provider process defined. File '%s' not found." % sControllerProcessMod)
-      end
-
-      super(oForjAccount, aProcessList.concat(aProcesses), sControllerMod)
-   end
-end
-
-
-# class describing generic Object Process
-# Ex: How to get a Network Object (ie: get a network or create it if missing)
-class BaseProcess
-   def initialize()
-      @oDefinition = nil
-   end
-
-   def set_BaseObject(oDefinition)
-      @oDefinition = oDefinition
-   end
-   private
-
-   def query_cache_cleanup(sObjectType)
-      raise ForjError.new(), "No Base object loaded." if not @oDefinition
-      @oDefinition.query_cleanup(sObjectType)
-   end
-
-   def object_cache_cleanup(sObjectType)
-      raise ForjError.new(), "No Base object loaded." if not @oDefinition
-      @oDefinition.object_cleanup(sObjectType)
-   end
-
-   def controler
-      raise ForjError.new(), "No Controler object loaded." if not @oDefinition
-      @oDefinition
-   end
-
-   def object
-      raise ForjError.new(), "No Base object loaded." if not @oDefinition
-      @oDefinition
-   end
-
-   def format_object(sObjectType, oMiscObj)
-
-      raise ForjError.new(), "No Base object loaded." if not @oDefinition
-      @oDefinition.format_object(sObjectType, oMiscObj)
-   end
-
-   def format_query(sObjectType, oMiscObj, hQuery)
-
-      raise ForjError.new(), "No Base object loaded." if not @oDefinition
-      @oDefinition.format_list(sObjectType, oMiscObj, hQuery)
-   end
-
-   def DataObjects(sObjectType, *key)
-      raise ForjError.new(), "No Base object loaded." if not @oDefinition
-      @oDefinition.DataObjects(sObjectType, *key)
-   end
-
-   def get_data(oObj, *key)
-
-      raise ForjError.new(), "No Base object loaded." if not @oDefinition
-      @oDefinition.get_data(oObj, :attrs, key)
-   end
-
-   def register(oObject, sObjectType = nil)
-
-      raise ForjError.new(), "No Base object loaded." if not @oDefinition
-      @oDefinition.register(oObject, sObjectType)
-   end
-
-   def config
-      raise ForjError.new(), "No Base object loaded." if not @oDefinition
-      @oDefinition.config
-   end
-
-   def query_single(sCloudObj, oList, sQuery, name, sInfoMsg = {})
-      oList = controler.query(sCloudObj, sQuery)
-      sInfo = {
-         :notfound   => "No %s '%s' found",
-         :checkmatch => "Found 1 %s. checking exact match for '%s'.",
-         :nomatch    => "No %s '%s' match",
-         :found      => "Found %s '%s'.",
-         :more       => "Found several %s. Searching for '%s'.",
-         :items_form => "%s",
-         :items      => [:name]
-      }
-      sInfo[:notfound]     = sInfoMsg[:notfound]   if sInfoMsg.key?(:notfound)
-      sInfo[:checkmatch]   = sInfoMsg[:checkmatch] if sInfoMsg.key?(:checkmatch)
-      sInfo[:nomatch]      = sInfoMsg[:nomatch]    if sInfoMsg.key?(:nomatch)
-      sInfo[:found]        = sInfoMsg[:found]      if sInfoMsg.key?(:found)
-      sInfo[:more]         = sInfoMsg[:more]       if sInfoMsg.key?(:more)
-      sInfo[:items]        = sInfoMsg[:items]      if sInfoMsg.key?(:items)
-      sInfo[:items_form]   = sInfoMsg[:items_form] if sInfoMsg.key?(:items_form)
-      case oList.length()
-         when 0
-            Logging.info( sInfo[:notfound] % [sCloudObj, name] )
-            oList
-         when 1
-            ForjLib.debug(2, sInfo[:checkmatch] % [sCloudObj, name])
-            element = nil
-            oList.each { | oElem |
-               bFound = true
-               sQuery.each { | key, value |
-                  if oElem[key] != value
-                     bFound = false
-                     break
-                  end
-               }
-               :remove if not bFound
-            }
-            if oList.length == 0
-               Logging.info(sInfo[:nomatch] % [sCloudObj, name])
-            else
-               sItems = []
-               if sInfo[:items].is_a?(Array)
-                  sInfo[:items].each { | key |
-                     sItems << oList[0, key]
-                  }
-               else
-                  sItems << oList[0, sInfo[:items]]
-               end
-               sItem = sInfo[:items_form] % sItems
-               Logging.info(sInfo[:found] % [sCloudObj, sItem])
-            end
-            oList
-         else
-            ForjLib.debug(2, sInfo[:more] % [sCloudObj, name])
-            # Looping to find the one corresponding
-            element = nil
-            oList.each { | oElem |
-               bFound = true
-               sQuery.each { | key, value |
-                  if oElem[key] != value
-                     bFound = false
-                     break
-                  end
-               }
-               :remove if not bFound
-            }
-            if oList.length == 0
-               Logging.info(sInfo[:notfound] % [sCloudObj, name])
-            else
-               sItems = []
-               if sInfo[:items].is_a?(Array)
-                  sInfo[:items].each { | key |
-                     sItems << oList[0, key]
-                  }
-               else
-                  sItems << oList[0, sInfo[:items]]
-               end
-               sItem = sInfo[:items_form] % sItems
-               Logging.info(sInfo[:found] % [sCloudObj, sItem])
-            end
-            oList
-      end
-   end
-end
-
-
-class BaseController
-   # Default handlers which needs to be defined by the cloud controller,
-   # called by BaseDefinition Create, Delete, Get, Query and Update functions.
-   def connect(sObjectType, hParams)
-      raise ForjError.new(), "connect has not been redefined by the controller '%s'" % self.class
-   end
-
-   def create(sObjectType, hParams)
-      raise ForjError.new(), "create_object has not been redefined by the controller '%s'" % self.class
-   end
-
-   def delete(sObjectType, hParams)
-      raise ForjError.new(), "delete_object has not been redefined by the controller '%s'" % self.class
-   end
-
-   def get(sObjectType, sUniqId, hParams)
-      raise ForjError.new(), "get_object has not been redefined by the controller '%s'" % self.class
-   end
-
-   def query(sObjectType, sQuery, hParams)
-      raise ForjError.new(), "query_object has not been redefined by the controller '%s'" % self.class
-   end
-
-   def update(sObjectType, oObject, hParams)
-      raise ForjError.new(), "update_object has not been redefined by the controller '%s'" % self.class
-   end
-
-   def forjError(msg)
-      raise ForjError.new(), "%s: %s" % [self.class, msg]
-   end
-
-   def required?(oParams, key)
-      raise ForjError.new(), "%s: %s is not set." % [self.class, key] if not oParams.exist?(key)
-   end
-end
-
-# represent an object or a list of object
-
-# Collection of DataObject
-# This class represents Object Parameters
-class ObjectData
-   def initialize(bInternal = false)
-
-      @hParams = {}
-      @hParams[:hdata] = {} unless bInternal
-      @bInternal = bInternal
-   end
-
-   def [] (*key)
-
-      key = key.flatten
-      # Return ObjectData Element if asked. Ignore additional keys.
-      return @hParams[key[0]] if key[1] == :ObjectData
-
-      return @hParams if key.length == 0
-
-      oObject = rhGet(@hParams, key[0])
-      return nil if oObject.nil?
-
-      # Return attributes if asked
-      return oObject[:attrs,  key[2..-1]] if key[1] == :attrs
-
-      if oObject.is_a?(ForjLib::Data)
-         if @bInternal
-            # params are retrieved in process context
-            # By default, if key is detected as a framework object, return its data.
-            return oObject[:attrs,  key[1..-1]]
-         else
-            # params are retrieved in controller context
-            # By default, if key is detected as a controller object, return its data.
-            return oObject[:object,  key[1..-1]]
-         end
-      end
-
-      # otherwise, simply return what is found in keys hierarchy.
-      rhGet(@hParams, key)
-   end
-
-   # Functions used to set simple data/Object for controller/process function call.
-   # TODO: to revisit this function, as we may consider simple data, as ForjLib::Data object
-   def []= (*key, value)
-      return nil if [:object, :query].include?(key[0])
-      rhSet(@hParams, value, key)
-   end
-
-   def add(oDataObject)
-      # Requires to be a valid framework object.
-      raise ForjError.new, "Invalid Framework object type '%s'." % oDataObject.class unless oDataObject.is_a?(ForjLib::Data)
-
-      sObjectType = oDataObject.object_type?
-
-      if oDataObject.type? == :list
-         oOldDataObject = rhGet(@hParams, :query, sObjectType)
-         oOldDataObject.unregister if oOldDataObject
-         rhSet(@hParams, oDataObject, :query, sObjectType)
-      else
-         oOldDataObject = rhGet(@hParams, sObjectType)
-         oOldDataObject.unregister if oOldDataObject
-         @hParams[sObjectType] = oDataObject
-      end
-      oDataObject.register
-   end
-
-   def delete(oObj)
-      if oObj.is_a?(Symbol)
-         sObjectType = oObj
-         @hParams[sObjectType] = nil
-      else
-         raise ForjError.new(), "ObjectData: delete error. oObj is not a framework data Object." unless oObj.is_a?(ForjLib::Data)
-         if oObj[:object_type] == :object_list
-            rhSet(@hParams, nil, :query, sObjectType)
-         else
-            sObjectType = oObj[:object_type]
-            @hParams[sObjectType] = nil
-         end
-      end
-      oObj.unregister
-   end
-
-   def << (hHash)
-      @hParams.merge!(hHash)
-   end
-
-   def exist?(*key)
-      raise ForjError.new, "ObjectData: key is not list of values (string/symbol or array)" if not [Array, String, Symbol].include?(key.class)
-
-      key = [key] if key.is_a?(Symbol) or key.is_a?(String)
-
-      key = key.flatten
-
-      oObject = rhGet(@hParams, key[0])
-      return false if oObject.nil?
-
-      if oObject.is_a?(ForjLib::Data)
-         # Return true if ObjectData Element is found when asked.
-         return true if key[1] == :ObjectData and oObject.type?(key[0]) == :object
-
-         # Return true if attritutes or controller object attributes found when asked.
-         return oObject.exist?(key[2..-1]) if key[1] == :attrs
-         return oObject.exist?(key[1..-1]) if key.length > 1
-         true
-      else
-         # By default true if found key hierarchy
-         (rhExist?(@hParams, key) == key.length)
-      end
-   end
-
-   #~ def get(*key)
-      #~ rhGet(@hParams, key)
-   #~ end
-
-   def type?(key)
-      return nil if rhExist?(@hParams, key) != 1
-      :data
-      :DataObject if @hParams[key].type?() == :object
-   end
-
-   def cObj(*key)
-      rhGet(@hParams, key, :object) if rhExist?(@hParams, key, :object) == 2
-   end
-
-end
-
-# Following class defines class levels function to
-# declare framework objects.
-# As each process needs to define new object to deal with
-# require that process to define it with definition functions
-# See definition.rb for functions to use.
-
-class BaseDefinition
-   # Capitalized function are called to start a process. It is done by ForjObject.
-
-   # BaseCloud Object available functions.
-   def Create(sCloudObj)
-      return nil if not sCloudObj
-      raise ForjError.new(), "%s.Create: '%s' is not a known object type." % [self.class, sCloudObj] if rhExist?(@@meta_obj, sCloudObj) != 1
-
-      pProc = rhGet(@@meta_obj, sCloudObj, :lambdas, :create_e)
-
-      # Check required parameters
-      oObjMissing = _check_required(sCloudObj, :create_e, pProc).reverse
-
-      while oObjMissing.length >0
-         sElem = oObjMissing.pop
-
-         raise ForjError.new(),"Unable to create Object '%s'" % sElem if not Create(sElem)
-         oObjMissing = _check_required(sCloudObj, :create_e, pProc).reverse
-
-         raise ForjError.new(), "loop detection: '%s' is required but Create(%s) did not loaded it." % [sElem, sElem] if oObjMissing.include?(sElem)
-      end
-      @RuntimeContext[:oCurrentObj] = sCloudObj # Context: Default object used.
-
-      if pProc.nil?
-         # This object is a meta object, without any data.
-         # Used to build other kind of objects.
-         oObject = ForjLib::Data.new
-         oObject.set({}, sCloudObj) {}
-      else
-         # build Function params to pass to the event handler.
-         aParams = _get_object_params(sCloudObj, :create_e, pProc,)
-         ForjLib.debug(2, "Create Object '%s' - Running '%s'" % [sCloudObj, pProc])
-
-         # Call the process function.
-         # At some point, the process will call the controller, via the framework.
-         # This controller call via the framework has the role to
-         # create an ObjectData well formatted, with _return_map function
-         # See Definition.connect/create/update/query/get functions (lowercase)
-         oObject = @oForjProcess.method(pProc).call(sCloudObj, aParams)
-         # return usually is the main object that the process called should provide.
-         # Save Object if the object has been created by the process, without controller
-      end
-
-      unless oObject.nil?
-         @ObjectData.add(oObject)
-      end
-   end
-
-   def Delete(sCloudObj)
-      return nil if not sCloudObj
-
-      raise ForjError.new(), "%s.Delete: '%s' is not a known object type." % [self.class, sCloudObj] if rhExist?(@@meta_obj, sCloudObj) != 1
-
-      pProc = rhGet(@@meta_obj, sCloudObj, :lambdas, :delete_e)
-
-      return nil if pProc.nil?
-
-      # Check required parameters
-      oObjMissing = _check_required(sCloudObj, :delete_e, pProc).reverse
-
-      while oObjMissing.length >0
-         sElem = oObjMissing.pop
-         raise ForjError.new(),"Unable to create Object '%s'" % sElem if not Create(sElem)
-         oObjMissing = _check_required(sCloudObj, :delete_e, pProc).reverse
-         raise ForjError.new(), "loop detection: '%s' is required but Delete(%s) did not loaded it." % [sElem, sElem] if oObjMissing.include?(sElem)
-      end
-      @RuntimeContext[:oCurrentObj] = sCloudObj # Context: Default object used.
-
-      # build Function params to pass to the event handler.
-      aParams = _get_object_params(sCloudObj, :delete_e, pProc)
-
-      bState = @oForjProcess.method(pProc).call(sCloudObj, aParams)
-      # return usually is the main object that the process called should provide.
-      if bState
-         @ObjectData.del(sCloudObj)
-      end
-
-   end
-
-   def query_cleanup(sCloudObj)
-      oList = @ObjectData[:query, sCloudObj]
-      unless oList.nil?
-         @ObjectData.delete(oList)
-      end
-   end
-
-   def object_cleanup(sCloudObj)
-      oObject = @ObjectData[sCloudObj, :ObjectData]
-      unless oObject.nil?
-         @ObjectData.delete(oObject)
-      end
-   end
-
-
-   # This function returns a list of objects
-   def Query(sCloudObj, hQuery)
-
-      return nil if not sCloudObj
-
-      raise ForjError.new(), "$s.Get: '%s' is not a known object type." % [self.class, sCloudObj] if rhExist?(@@meta_obj, sCloudObj) != 1
-
-      # Check if we can re-use a previous query
-      oList = @ObjectData[:query, sCloudObj]
-      unless oList.nil?
-         if oList[:query] == hQuery
-            ForjLib.debug(3, "Using Object '%s' query cache : %s" % [sCloudObj, hQuery])
-            return oList
-         end
-      end
-
-      pProc = rhGet(@@meta_obj, sCloudObj, :lambdas, :query_e)
-
-      return nil if pProc.nil?
-
-      # Check required parameters
-      oObjMissing = _check_required(sCloudObj, :query_e, pProc).reverse
-
-      while oObjMissing.length >0
-         sElem = oObjMissing.pop
-         raise ForjError.new(),"Unable to create Object '%s'" % sElem if not Create(sElem)
-         oObjMissing = _check_required(sCloudObj, :query_e, pProc).reverse
-         raise ForjError.new(), "loop detection: '%s' is required but Query(%s) did not loaded it." % [sElem, sElem] if oObjMissing.include?(sElem)
-      end
-      @RuntimeContext[:oCurrentObj] = sCloudObj # Context: Default object used.
-
-      # build Function params to pass to the Process Event handler.
-      aParams = _get_object_params(sCloudObj, :query_e, pProc)
-
-      # Call the process function.
-      # At some point, the process will call the controller, via the framework.
-      # This controller call via the framework has the role to
-      # create an ObjectData well formatted, with _return_map function
-      # See Definition.connect/create/update/query/get functions (lowercase)
-      oObject = @oForjProcess.method(pProc).call(sCloudObj, hQuery, aParams)
-      # return usually is the main object that the process called should provide.
-      unless oObject.nil?
-         # Save Object if the object has been created by the process, without controller
-         @ObjectData.add(oObject)
-      end
-   end
-
-   def Get(sCloudObj, sUniqId)
-
-      return nil if not sCloudObj
-
-      raise ForjError.new(), "$s.Get: '%s' is not a known object type." % [self.class, sCloudObj] if rhExist?(@@meta_obj, sCloudObj) != 1
-
-      pProc = rhGet(@@meta_obj, sCloudObj, :lambdas, :get_e)
-
-      return nil if pProc.nil?
-
-      # Check required parameters
-      oObjMissing = _check_required(sCloudObj, :get_e, pProc).reverse
-
-      while oObjMissing.length >0
-         sElem = oObjMissing.pop
-         raise ForjError.new(),"Unable to create Object '%s'" % sElem if not Create(sElem)
-         oObjMissing = _check_required(sCloudObj, :get_e, pProc).reverse
-         raise ForjError.new(), "loop detection: '%s' is required but Get(%s) did not loaded it." % [sElem, sElem] if oObjMissing.include?(sElem)
-      end
-      @RuntimeContext[:oCurrentObj] = sCloudObj # Context: Default object used.
-
-      # build Function params to pass to the Process Event handler.
-      aParams = _get_object_params(sCloudObj, :get_e, pProc)
-
-      # Call the process function.
-      # At some point, the process will call the controller, via the framework.
-      # This controller call via the framework has the role to
-      # create an ObjectData well formatted, with _return_map function
-      # See Definition.connect/create/update/query/get functions (lowercase)
-      oObject = @oForjProcess.method(pProc).call(sCloudObj, sUniqId, aParams)
-      # return usually is the main object that the process called should provide.
-      unless oObject.nil?
-         # Save Object if the object has been created by the process, without controller
-         @ObjectData.add(oObject)
-      end
-   end
-
-   def Update(sCloudObj)
-
-      return nil if not sCloudObj
-
-      raise ForjError.new(), "$s.Update: '%s' is not a known object type." % [self.class, sCloudObj] if rhExist?(@@meta_obj, sCloudObj) != 1
-
-      pProc = rhGet(@@meta_obj, sCloudObj, :lambdas, :update_e)
-
-      return nil if pProc.nil?
-
-      # Check required parameters
-      oObjMissing = _check_required(sCloudObj, :update_e, pProc).reverse
-
-      while oObjMissing.length >0
-         sElem = oObjMissing.pop
-         raise ForjError.new(),"Unable to create Object '%s'" % sElem if not Create(sElem)
-         oObjMissing = _check_required(sCloudObj, :update_e, pProc).reverse
-         raise ForjError.new(), "loop detection: '%s' is required but Update(%s) did not loaded it." % [sElem, sElem] if oObjMissing.include?(sElem)
-      end
-      @RuntimeContext[:oCurrentObj] = sCloudObj # Context: Default object used.
-
-      # build Function params to pass to the event handler.
-      aParams = _get_object_params(sCloudObj, :update_e, pProc)
-
-      oObject = @oForjProcess.method(pProc).call(sCloudObj, aParams)
-      # return usually is the main object that the process called should provide.
-      unless oObject.nil?
-         # Save Object if the object has been created by the process, without controller
-         @ObjectData.add(oObject)
-      end
-   end
-
-   def Setup(sObjectType, sAccountName)
-      # Loop in dependencies to get list of data object to setup
-      raise ForjError,new(), "Setup: '%s' not a valid object type." if rhExist?(@@meta_obj, sObjectType) != 1
-
-      hAskStep = ForjDefault.get(:ask_step, :setup)
-      aSetup = []
-      hAskStep.each{ | value |
-         aSetup << {
-            :desc => value[:desc],
-            :explanation => value[:explanation],
-            :pre_step_handler => value[:pre_step_function],
-            :order => [[]],
-            :post_step_handler => value[:post_step_function]
-         }
-
-      }
-      oInspectedObjects = []
-      oInspectObj = [sObjectType]
-
-      @oForjConfig.ac_load(sAccountName) if sAccountName
-
-      ForjLib.debug(2, "Setup is identifying account data to ask for '%s'" % sObjectType)
-      while oInspectObj.length() >0
-         # Identify data to ask
-         # A data to ask is a data needs from an object type
-         # which is declared in section of defaults.yaml
-         # and is declared :account to true (in defaults.yaml or in process declaration - define_data)
-
-         sObjectType = oInspectObj.pop
-         sAsk_step = 0
-         ForjLib.debug(1, "Checking '%s'" % sObjectType)
-         hTopParams = rhGet(@@meta_obj,sObjectType, :params)
-         if hTopParams[:keys].nil?
-            ForjLib.debug(1, "Warning! Object '%s' has no data/object needs. Check the process" % sObjectType)
-            next
-         end
-         hTopParams[:keys].each { |sKeypath, hParams|
-            oKeyPath = KeyPath.new(sKeypath)
-            sKey = oKeyPath.sKey
-            case hParams[:type]
-               when :data
-                  hMeta = _get_meta_data(sKey)
-                  next if hMeta.nil?
-                  sAsk_step = hMeta[:ask_step] if rhExist?(hMeta, :ask_step) == 1 and hMeta[:ask_step].is_a?(Fixnum)
-                  ForjLib.debug(3, "#{sKey} is part of setup step #{sAsk_step}")
-                  aOrder = aSetup[sAsk_step][:order]
-
-                  if oInspectedObjects.include?(sKey)
-                     ForjLib.debug(2, "#{sKey} is already asked. Ignored.")
-                     next
-                  end
-                  if hMeta[:account].is_a?(TrueClass)
-                     if not hMeta[:depends_on].is_a?(Array)
-                        Logging.warning("'%s' depends_on definition have to be an array." % oKeyPath.sFullPath) unless hMeta[:depends_on].nil?
-                        iLevel = 0
-                        bFound = true
-                     else
-                        # Searching highest level from dependencies.
-                        bFound = false
-                        iLevel = 0
-                        hMeta[:depends_on].each { |depend_key|
-                           aOrder.each_index { |iCurLevel|
-                              if aOrder[iCurLevel].include?(depend_key)
-                                 bFound = true
-                                 iLevel = [iLevel, iCurLevel + 1].max
-                              end
-                           }
-                              aOrder[iLevel] = [] if aOrder[iLevel].nil?
-                        }
-                     end
-                     if bFound
-                        if not aOrder[iLevel].include?(sKey)
-                           if hMeta[:ask_sort].is_a?(Fixnum)
-                              iOrder = hMeta[:ask_sort]
-                              if aOrder[iLevel][iOrder].nil?
-                                 aOrder[iLevel][iOrder] = sKey
-                              else
-                                 aOrder[iLevel].insert(iOrder, sKey)
-                              end
-                              ForjLib.debug(3, "S%s/L%s/O%s: '%s' added in setup list. " % [sAsk_step, iLevel, iOrder, sKey])
-                           else
-                              aOrder[iLevel] << sKey
-                              ForjLib.debug(3, "S%s/L%s/Last: '%s' added in setup list." % [sAsk_step, iLevel, sKey])
-                           end
-                        end
-                     end
-                     oInspectedObjects << sKey
-                  else
-                     ForjLib.debug(2, "#{sKey} used by #{sObjectType} won't be asked during setup. :account = true not set.")
-                  end
-               when :CloudObject
-                  oInspectObj << sKey if not oInspectObj.include?(sKey) and not oInspectedObjects.include?(sKey)
-            end
-         }
-         oInspectedObjects << sObjectType
-      end
-      ForjLib.debug(2, "Setup check if needs to add unrelated data in the process")
-      hAskStep.each_index{ | iStep |
-         value = hAskStep[iStep]
-         if rhExist?(value, :add) == 1
-            sKeysToAdd = rhGet(value, :add)
-            sKeysToAdd.each { | sKeyToAdd |
-               bFound = false
-               aSetup[iStep][:order].each_index { | iOrder |
-                  sKeysToAsk = aSetup[iStep][:order][iOrder]
-                  unless sKeysToAsk.index(sKeyToAdd).nil?
-                     bFound = true
-                     break
-                  end
-               }
-               next if bFound
-               iLevel = 0
-               iOrder = aSetup[iStep][:order].length
-               iAtStep = iStep
-               hMeta = _get_meta_data(sKeyToAdd)
-               if rhExist?(hMeta, :after) == 1
-                  sAfterKeys = hMeta[:after]
-                  sAfterKeys = [ sAfterKeys ] if not sAfterKeys.is_a?(Array)
-                  sAfterKeys.each{ |sAfterKey |
-                     bFound = false
-                     aSetup.each_index { |iStepToCheck|
-                        aSetup[iStepToCheck][:order].each_index { | iLevelToCheck |
-                           sKeysToAsk = aSetup[iStepToCheck][:order][iLevelToCheck]
-                           iOrderToCheck = sKeysToAsk.index(sAfterKey)
-                           unless iOrderToCheck.nil?
-                              iAtStep = iStepToCheck if iStepToCheck > iAtStep
-                              iLevel = iLevelToCheck if iLevelToCheck > iLevel
-                              iOrder = iOrderToCheck + 1 if iOrderToCheck + 1 > iOrder
-                              bFound = true
-                              break
-                           end
-                        }
-                     }
-                  }
-               end
-               aSetup[iAtStep][:order][iLevel].insert(iOrder, sKeyToAdd)
-               ForjLib.debug(3, "S%s/L%s/O%s: '%s' added in setup list at  position." % [iAtStep, iLevel, iOrder, sKeyToAdd])
-            }
-         end
-      }
-
-      ForjLib.debug(2, "Setup will ask for :\n %s" % aSetup.to_yaml)
-
-      Logging.info("Configuring account : '#{config[:account_name]}', provider '#{config[:provider_name]}'")
-
-      # Ask for user input
-      aSetup.each_index { | iStep |
-         ForjLib.debug(2, "Ask step %s:" % iStep)
-         puts "%s%s%s" % [ANSI.bold, aSetup[iStep][:desc], ANSI.clear] unless aSetup[iStep][:desc].nil?
-         puts "%s\n\n" % ANSI.yellow(aSetup[iStep][:explanation]) unless aSetup[iStep][:explanation].nil?
-         aOrder = aSetup[iStep][:order]
-         aOrder.each_index { | iIndex |
-         ForjLib.debug(2, "Ask order %s:" % iIndex)
-            aOrder[iIndex].each { | sKey |
-               hParam = _get_meta_data(sKey)
-               hParam = {} if hParam.nil?
-
-               bOk = false
-
-               if hParam[:pre_step_function]
-                  pProc = hParam[:pre_step_function]
-                  bOk = not(@oForjProcess.method(pProc).call(sKey))
-               end
-
-
-               sDesc = "'%s' value" % sKey
-               puts "#{sKey}: %s" % [hParam[:explanation]] unless rhGet(hParam, :explanation).nil?
-               sDesc = hParam[:desc] unless hParam[:desc].nil?
-               sDefault = @oForjConfig.get(sKey, hParam[:default_value])
-               rValidate = nil
-
-               rValidate = hParam[:validate] unless hParam[:validate].nil?
-               bRequired = (hParam[:required] == true)
-               while not bOk
-                  bOk = true
-                  if not hParam[:list_values].nil?
-                     hValues = hParam[:list_values]
-                     sObjectToLoad = hValues[:object]
-
-                     bListStrict = (hValues[:validate] == :list_strict)
-
-                     case hValues[:query_type]
-                        when :controller_call
-                           oObject = @ObjectData[sObjectToLoad, :ObjectData]
-                           Logging.state("Loading #{sObjectToLoad}.")
-                           oObject = Create(sObjectToLoad) if oObject.nil?
-                           return nil if oObject.nil?
-                           oParams = ObjectData.new
-                           oParams.add(oObject)
-                           oParams << hValues[:query_params]
-                           raise ForjError.new(), "#{sKey}: query_type => :controller_call requires missing :query_call declaration (Controller function)" if hValues[:query_call].nil?
-                           pProc = hValues[:query_call]
-                           begin
-                              aList = @oProvider.method(pProc).call(sObjectToLoad, oParams)
-                           rescue => e
-                              raise ForjError.new(), "Error during call of '%s':\n%s" % [pProc, e.message]
-                           end
-                        when :query_call
-                           sQuery = {}
-                           sQuery = hValues[:query_params] unless hValues[:query_params].nil?
-                           Logging.state("Querying #{sObjectToLoad}.")
-                           oObjectList = Query(sObjectToLoad, sQuery)
-                           aList = []
-                           oObjectList.each { | oElem |
-                              aList << oElem[hValues[:value]]
-                           }
-                           aList.sort!
-                        when :process_call
-                           raise ForjError.new(), "#{sKey}: query_type => :process_call requires missing :query_call declaration (Provider function)" if hValues[:query_call].nil?
-                           pProc = hValues[:query_call]
-                           sObjectToLoad = hValues[:object]
-                           oParams = ObjectData.new
-                           oParams.add(oObject)
-                           oParams << hValues[:query_params]
-                           begin
-                              aList = @oForjProcess.method(pProc).call(sObjectToLoad, oParams)
-                           rescue => e
-                              raise ForjError.new(), "Error during call of '%s':\n%s" % [pProc, e.message]
-                           end
-                        else
-                           raise ForjError.new, "'%s' invalid. %s/list_values/values_type supports %s. " % [hValues[:values_type], sKey, [:provider_function]]
-                     end
-                     Logging.fatal(1, "%s requires a value from the '%s' query which is empty." % [sKey, sObjectToLoad])if aList.nil? and bListStrict
-                     aList = [] if aList.nil?
-                     if not bListStrict
-                        aList << "other"
-                     end
-                     say("Enter %s" % ((sDefault.nil?)? sDesc : sDesc + " |%s|" % sDefault))
-                     value = choose { | q |
-                        q.choices(*aList)
-                        q.default = sDefault if sDefault
-                     }
-                     if not bListStrict and value == "other"
-                        value = _ask(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                     end
-                  else
-                     pValidateProc = hParam[:validate_function]
-                     pAskProc = hParam[:ask_function]
-
-                     if pAskProc.nil?
-                        unless pValidateProc.nil?
-                           value = _ask(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                           while not @oForjProcess.method(pValidateProc).call(value)
-                              value = _ask(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                           end
-                        else
-                           value = _ask(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                        end
-                     else
-                        unless pValidateProc.nil?
-                           value = @oForjProcess.method(pAskProc).call(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                           while not @oForjProcess.method(pValidateProc).call(value)
-                              value = @oForjProcess.method(pAskProc).call(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                           end
-                        else
-                           value = @oForjProcess.method(pAskProc).call(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                        end
-                     end
-                  end
-
-                  @oForjConfig.set(sKey, value)
-                  if hParam[:post_step_function]
-                     pProc = hParam[:post_step_function]
-                     bOk = @oForjProcess.method(pProc).call()
-                  end
-               end
-            }
-         }
-      }
-   end
-
-   # Initialize Cloud object Data
-
-   def initialize(oForjConfig, oForjProcess, oForjProvider = nil)
-      # Object Data object. Contains all loaded object data.
-      # This object is used to build hParams as well.
-      @ObjectData = ObjectData.new(true)
-      #
-      @RuntimeContext = {
-         :oCurrentObj => nil
-      }
-
-      @oForjConfig = oForjConfig
-      raise ForjError.new(), "'%s' is not a valid ForjAccount or ForjConfig Object." % [oForjConfig.class] if not oForjConfig.is_a?(ForjAccount) and not oForjConfig.is_a?(ForjConfig)
-
-      @oProvider = oForjProvider
-      if oForjProvider
-         raise ForjError.new(), "'%s' is not a valid ForjProvider Object type." % [oForjProvider.class] if not oForjProvider.is_a?(BaseController)
-      end
-
-      @oForjProcess = oForjProcess
-      raise ForjError.new(), "'%s' is not a valid BaseProcess Object type." % [oForjProcess.class] if not oForjProcess.is_a?(BaseProcess)
-
-      @oForjProcess.set_BaseObject(self)
-   end
-
-   # ------------------------------------------------------
-   # Functions used by processes functions
-   # ------------------------------------------------------
-   # Ex: object.set_data(...)
-   #     config
-
-
-   # Function to manipulate the config object.
-   # 2 kind of functions:
-   # - set (key, value) and []=(key, value)
-   #   From processes, you can set a runtime data with:
-   #     config.set(key, value)
-   #   OR
-   #     config[key] = value
-   #
-   # - get (key, default) and [](key, default)
-   #   default is an optional value.
-   #   From processes, you can get a data (runtime/account/config.yaml or defaults.yaml) with:
-   #     config.get(key)
-   #   OR
-   #     config[key]
-
-   def config
-      raise ForjError.new(), "No config object loaded." if not @oForjConfig
-      @oForjConfig
-   end
-
-   def format_query(sObjectType, oControlerObject, hQuery)
-      {
-         :object        => oControlerObject,
-         :object_type   => :object_list,
-         :list_type     => sObjectType,
-         :list          => [],
-         :query         => hQuery
-      }
-   end
-
-   def format_object(sCloudObj, oMiscObject)
-      return nil if not sCloudObj or not [String, Symbol].include?(sCloudObj.class)
-
-      sCloudObj = sCloudObj.to_sym if sCloudObj.class == String
-
-      oCoreObject = {
-         :object_type => sCloudObj,
-         :attrs => {},
-         :object => oMiscObject,
-      }
-   end
-
-   def get_data_metadata(sKey)
-      _get_meta_data(sKey)
-   end
-
-   # Before doing a query, mapping fields
-   # Transform Object query field to Provider query Fields
-   def query_map(sCloudObj, hParams)
-      return nil if not sCloudObj or not [String, Symbol].include?(sCloudObj.class)
-      return {} if not hParams
-
-      sCloudObj = sCloudObj.to_sym if sCloudObj.class == String
-
-      hReturn = {}
-      hMap = rhGet(@@meta_obj, sCloudObj, :query_mapping)
-      hParams.each { |key, value|
-         oKeyPath = KeyPath.new(key)
-         sKeyPath = oKeyPath.sFullPath
-         raise ForjError.new(), "Forj query field '%s.%s' not defined by class '%s'" % [sCloudObj, oKeyPath.sKey, self.class] if not hMap.key?(oKeyPath.sFullPath)
-         oMapPath = KeyPath.new(hMap[oKeyPath.sFullPath])
-         hValueMapping = rhGet(@@meta_obj, sCloudObj, :value_mapping, sKeyPath)
-         if hValueMapping
-            raise ForjError.new(), "'%s.%s': No value mapping for '%s'" % [sCloudObj, oKeyPath.sKey, value] if rhExist?(hValueMapping, value) != 1
-
-            rhSet(hReturn, hValueMapping[value], oMapPath.aTree)
-         else
-            rhSet(hReturn, value, oMapPath.aTree)
-         end
-      }
-      hReturn
-   end
-
-   # Used by the Process.
-   # Ask controller get_attr to get a data
-   # The result is the data of a defined data attribute.
-   # If the value is normally mapped (value mapped), the value is
-   # returned as a recognized data attribute value.
-   def get_attr(oObject, key)
-
-      raise ForjError.new(), "'%s' is not a valid Object type. " % [oObject.class] if not oObject.is_a?(Hash) and rhExist?(oObject, :object_type) != 1
-      sCloudObj = oObject[:object_type]
-      oKeyPath = KeyPath.new(key)
-      raise ForjError.new(), "'%s' key is not declared as data of '%s' CloudObject. You may need to add obj_needs..." % [oKeyPath.sKey, sCloudObj] if rhExist?(@@meta_obj, sCloudObj, :returns, oKeyPath.sFullPath) != 3
-      begin
-         oMapPath = KeyPath.new(rhGet(@@meta_obj, sCloudObj, :returns, oKeyPath.sFullPath))
-         hMap = oMapPath.sFullPath
-         value = @oProvider.get_attr(get_cObject(oObject), hMap)
-
-         hValueMapping = rhGet(@@meta_obj, sCloudObj, :value_mapping, oKeyPath.sFullPath)
-
-         if hValueMapping
-            hValueMapping.each { | found_key, found_value |
-               if found_value == value
-                  value = found_key
-                  break
-               end
-            }
-         end
-      rescue => e
-         raise ForjError.new(), "'%s.get_attr' fails to provide value of '%s'" % [oProvider.class, key]
-      end
-   end
-
-   # Register the object to the internal @ObjectData instance
-   def register(oObject, sObjectType = nil, sDataType = :object)
-      if oObject.is_a?(ForjLib::Data)
-         oDataObject = oObject
-      else
-         raise ForjError.new(), "Unable to register an object '%s' as ForjLib::Data object if ObjectType is not given." % [ oObject.class ] if not sObjectType
-         oDataObject = ForjLib::Data.new(sDataType)
-         oDataObject.set(oObject, sObjectType) { | sObjType, oControlerObject |
-            _return_map(sObjType, oControlerObject)
-         }
-      end
-      @ObjectData.add oDataObject
-   end
-
-   def DataObjects(sObjectType, *key)
-      @ObjectData[sObjectType, key]
-   end
-
-   # get an attribute/object/... from an object.
-   def get_data(oObj, *key)
-      if oObj.is_a?(Hash) and oObj.key?(:object_type)
-         oObjData = ObjectData.new
-         oObjData << oObj
-      else
-         oObjData = @ObjectData
-      end
-      oObjData[oObj, *key]
-   end
-
-   #~ def hParams(sCloudObj, hParams)
-      #~ aParams = _get_object_params(sCloudObj, ":ObjectData.hParams")
-   #~ end
-
-   def get_cObject(oObject)
-      return nil if rhExist?(oObject, :object) != 1
-      rhGet(oObject, :object)
-   end
-
-   # a Process can execute any kind of predefined controler task.
-   # Those function build hParams with Provider compliant data (mapped)
-   # Results are formatted as usual framework Data object and stored.
-   def connect(sObjectType)
-
-      hParams = _get_object_params(sObjectType, :create_e, :connect, true)
-      oControlerObject = @oProvider.connect(sObjectType, hParams)
-      oDataObject = ForjLib::Data.new
-      oDataObject.set(oControlerObject, sObjectType) { | sObjType, oObject |
-         begin
-            _return_map(sObjType, oObject)
-         rescue => e
-            raise ForjError.new(), "connect %s.%s : %s" % [@oForjProcess.class, sObjectType, e.message]
-         end
-      }
-      @ObjectData.add oDataObject
-      oDataObject
-   end
-
-   def create(sObjectType)
-      # The process ask the controller to create the object.
-      # hParams have to be fully readable by the controller.
-      hParams = _get_object_params(sObjectType, :create_e, :create, true)
-      oControlerObject = @oProvider.create(sObjectType, hParams)
-      oDataObject = ForjLib::Data.new
-      oDataObject.set(oControlerObject, sObjectType) { | sObjType, oObject |
-         begin
-            _return_map(sObjType, oObject)
-         rescue => e
-            raise ForjError.new(), "create %s.%s : %s" % [@oForjProcess.class, sObjectType, e.message]
-         end
-      }
-      @ObjectData.add oDataObject
-
-      oDataObject
-   end
-
-   # The controller must return true to inform about the real deletion
-   def delete(sObjectType)
-      hParams = _get_object_params(sObjectType, :delete_e, :delete, true)
-      bState = @oProvider.delete(sObjectType, hParams)
-      @ObjectData.delete(sCloudObj) if bState
-      bState
-   end
-
-   def get(sObjectType, sUniqId)
-
-      hParams = _get_object_params(sObjectType, :get_e, :get, true)
-
-      oControlerObject = @oProvider.get(sObjectType, sUniqId, hParams)
-      oDataObject = ForjLib::Data.new
-      oDataObject.set(oControlerObject, sObjectType) { | sObjType, oObject |
-         begin
-            _return_map(sObjType, oObject)
-         rescue => e
-            raise ForjError.new(), "get %s.%s : %s" % [@oForjProcess.class, sObjectType, e.message]
-         end
-      }
-      @ObjectData.add oDataObject
-
-      oDataObject
-   end
-
-   def query(sObjectType, hQuery)
-
-      # Check if we can re-use a previous query
-      oList = @ObjectData[:query, sObjectType]
-      unless oList.nil?
-         if oList[:query] == hQuery
-            ForjLib.debug(3, "Using Object '%s' query cache : %s" % [sObjectType, hQuery])
-            return oList
-         end
-      end
-
-
-      hParams = _get_object_params(sObjectType, :query_e, :query, true)
-      sProviderQuery = query_map(sObjectType, hQuery)
-
-      oControlerObject = @oProvider.query(sObjectType, sProviderQuery, hParams)
-
-      oDataObjects = ForjLib::Data.new :list
-      oDataObjects.set(oControlerObject, sObjectType, hQuery) { | sObjType, key |
-         begin
-            _return_map(sObjType, key)
-         rescue => e
-            raise ForjError.new(), "query %s.%s : %s" % [@oForjProcess.class, sObjectType, e.message]
-         end
-      }
-
-      ForjLib.debug(2, "Object %s - queried. Found %s object(s)." % [sObjectType, oDataObjects.length()])
-
-      @ObjectData.add oDataObjects
-      oDataObjects
-   end
-
-   def update(sObjectType)
-      # Need to detect data updated and update the Controler object with the controler
-
-      hParams = _get_object_params(sObjectType, :update_e, :update, true)
-
-      oObject = @ObjectData[sObjectType, :ObjectData]
-      oControlerObject = oObject[:object]
-
-      bUpdated = false
-      oObject[:attrs].each { |key, value |
-         oKeyPath = KeyPath.new(key)
-         oMapPath = KeyPath.new(rhGet(@@meta_obj, sObjectType, :returns, oKeyPath.sFullPath))
-         old_value = @oProvider.get_attr(oControlerObject, oMapPath.aTree)
-         if value != old_value
-            bUpdated = true
-            @oProvider.set_attr(oControlerObject, oMapPath.aTree, value)
-            ForjLib.debug(2, "%s.%s - Updating: %s = %s (old : %s)" % [@oForjProcess.class, sObjectType, key, value, old_value])
-         end
-      }
-
-      bDone = @oProvider.update(sObjectType, oObject, hParams) if bUpdated
-
-      raise ForjError.new, "Controller function 'update' must return True or False. Class returned: '%s'" % bDone.class if not [TrueClass, FalseClass].include?(bDone.class)
-
-      ForjLib.debug(1, "%s.%s - updated." % [@oForjProcess.class, sObjectType]) if bDone
-      oObject.set(oControlerObject, sObjectType) { | sObjType, oObject |
-         begin
-            _return_map(sObjType, oObject)
-         rescue => e
-            raise ForjError.new(), "update %s.%s : %s" % [@oForjProcess.class, sObjectType, e.message]
-         end
-      }
-      bDone
-   end
-
-
-   private
-
-   # -------------------------------------------------------------------------
-   # Functions available for Process to communicate with the controler Object
-   # -------------------------------------------------------------------------
-   def cloud_obj_requires(sCloudObj, res = {})
-      aCaller = caller
-      aCaller.pop
-
-      return res if @ObjectData.exist?(sCloudObj)
-      #~ return res if rhExist?(@CloudData, sCloudObj) == 1
-
-      rhGet(@@meta_obj,sCloudObj, :params).each { |key, hParams|
-         case hParams[:type]
-            when :data
-               if  hParams.key?(:array)
-                  hParams[:array].each{ | aElem |
-                     aElem = aElem.clone
-                     aElem.pop # Do not go until last level, as used to loop next.
-                     rhGet(hParams, aElem).each { | subkey, hSubParam |
-                        next if aElem.length == 0 and [:array, :type].include?(subkey)
-                        if hSubParams[:required] and @oForjConfig.get(subkey).nil?
-                           res[subkey] = hSubParams
-                        end
-                     }
-                  }
-               else
-                  if hParams[:required] and @oForjConfig.get(key).nil?
-                     res[key] = hParams
-                  end
-               end
-            when :CloudObject
-               #~ if hParams[:required] and rhExist?(@CloudData, sCloudObj) != 1
-               if hParams[:required] and not @ObjectData.exist?(sCloudObj)
-                  res[key] = hParams
-                  cloud_obj_requires(key, res)
-               end
-         end
-      }
-      res
-   end
-
-   def get_object(sCloudObj)
-      #~ return nil if rhExist?(@CloudData, sCloudObj) != 1
-      return nil if not @ObjectData.exist?(sCloudObj)
-      @ObjectData[sCloudObj, :ObjectData]
-      #~ rhGet(@CloudData, sCloudObj)
-   end
-
-   def objectExist?(sCloudObj)
-      @ObjectData.exist?(sCloudObj)
-      #~ (rhExist?(@CloudData, sCloudObj) != 1)
-   end
-
-   def get_forjKey(oCloudData, key)
-      return nil if not @ObjectData.exist?(sCloudObj)
-      @ObjectData[sCloudObj, :attrs, key]
-      #~ return nil if rhExist?(oCloudData, sCloudObj) != 1
-      #~ rhGet(oCloudData, sCloudObj, :attrs, key)
-   end
-end