lorj 0.2.0 → 1.0.0

data/lib/core/lorj_basecontroller.rb

@@ -0,0 +1,95 @@
+#!/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.
+
+# Module Lorj which contains several classes.
+#
+# 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 Lorj
+  # Defining basic Controller functions
+  class BaseController
+    # Default handlers which needs to be defined by the controller,
+    # called by BaseDefinition Create functions.
+    def connect(_sObjectType, _hParams)
+      process_error 'connect has not been redefined by the controller.'
+    end
+
+    # Default handlers which needs to be defined by the controller,
+    # called by BaseDefinition Create functions.
+    def create(_sObjectType, _hParams)
+      process_error 'create_object has not been redefined by the controller.'
+    end
+
+    # Default handlers which needs to be defined by the controller,
+    # called by BaseDefinition Delete functions.
+    def delete(_sObjectType, _hParams)
+      process_error 'delete_object has not been redefined by the controller.'
+    end
+
+    # Default handlers which needs to be defined by the controller,
+    # called by BaseDefinition Get functions.
+    def get(_sObjectType, _sUniqId, _hParams)
+      process_error 'get_object has not been redefined by the controller.'
+    end
+
+    # Default handlers which needs to be defined by the controller,
+    # called by BaseDefinition Query functions.
+    def query(_sObjectType, _sQuery, _hParams)
+      process_error 'query_object has not been redefined by the controller.'
+    end
+
+    # Default handlers which needs to be defined by the controller,
+    # called by BaseDefinition Update functions.
+    def update(_sObjectType, _oObject, _hParams)
+      process_error 'update_object has not been redefined by the controller.'
+    end
+
+    # Simply raise an error
+    #
+    # * *Args*    :
+    #   - +Msg+ : Error message to print out.
+    # * *Returns* :
+    #   - nil
+    # * *Raises* :
+    #  - Lorj::PrcError
+    def controller_error(msg, *p)
+      msg = format(msg, *p)
+      runtime_fail '%s: %s', self.class, msg
+    end
+
+    # check if required data is loaded. raise an error if not
+    #
+    # * *Args*    :
+    #   - +Params+ : Lorj::ObjectData object for controller.
+    #   - +key+    : Key to check.
+    # * *Returns* :
+    #   - nil
+    # * *Raises* :
+    #   - +Error+ if the key do not exist.
+    def required?(oParams, *key)
+      return if oParams.exist?(key)
+
+      runtime_fail '%s: %s is not set.', self.class, key
+    end
+  end
+end

data/lib/core/lorj_basedefinition.rb

@@ -0,0 +1,307 @@
+# 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.
+
+# Module Lorj which contains several classes.
+#
+# 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 Lorj
+  # This class limits ERC template to access only to config object data.
+  class ERBConfig
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    # Bind this limited class with ERB templates
+    def get_binding # rubocop: disable AccessorMethodName
+      binding
+    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
+    # Initialize Lorj BaseDefinition object
+    def initialize(oForjConfig, process, controller = nil)
+      # Object Data object. Contains all loaded object data.
+      # This object is used to build hParams as well.
+      @object_data = ObjectData.new(true)
+      #
+      @runtime_context = {
+        :oCurrentObj => nil
+      }
+
+      @config = oForjConfig
+      @erb_config = ERBConfig.new(oForjConfig)
+      fail Lorj::PrcError.new, "'%s' is not a valid ForjAccount or ForjConfig"\
+           ' Object.',
+           [oForjConfig.class] if
+           !oForjConfig.is_a?(Lorj::Account) &&
+
+           !oForjConfig.is_a?(Lorj::Config)
+
+      @controller = controller
+      if controller
+        runtime_fail "'%s' is not a valid ForjProvider Object type.",
+                     controller.class unless controller.is_a?(BaseController)
+      end
+
+      @process = process
+      fail Lorj::PrcError.new, "'%s' is not a valid BaseProcess Object type.",
+           [process.class] unless process.is_a?(BaseProcess)
+
+      @process.base_object(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
+      fail Lorj::PrcError.new, 'No config object loaded.' unless @config
+      @config
+    end
+
+    def format_query(sObjectType, oControlerObject, hQuery)
+      {
+        :object => oControlerObject,
+        :object_type => :object_list,
+        :list_type => sObjectType,
+        :list => [],
+        :query => hQuery
+      }
+    end
+
+    def format_object(object_type, oMiscObject)
+      return nil unless [String, Symbol].include?(object_type.class)
+
+      object_type = object_type.to_sym if object_type.class == String
+
+      { :object_type => object_type,
+        :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(object_type, hParams)
+      return {} unless hParams
+
+      object_type = object_type.to_sym if object_type.class == String
+
+      result = {}
+      maps = PrcLib.model.meta_obj.rh_get(object_type, :query_mapping)
+      hParams.each do |key, value|
+        key_path_obj = KeyPath.new(key)
+        key_path = key_path_obj.fpath
+        PrcLib.runtime_fail "Forj query field '%s.%s' not defined by class"\
+                            " '%s'.\n#{ANSI.bold}ACTION REQUIRED#{ANSI.clear}"\
+                            ":\nMissing data model 'def_attribute' or "\
+                            "'def_query_attribute' for '%s'??? "\
+                            "Check the object '%s' data model.",
+                            object_type, key_path_obj.key,
+                            self.class, key_path_obj.key,
+                            object_type unless maps.key?(key_path_obj.fpath)
+        map_path = KeyPath.new(maps[key_path_obj.fpath])
+        value_mapping = PrcLib.model.meta_obj.rh_get(object_type,
+                                                     :value_mapping, key_path)
+        if value_mapping
+          PrcLib.runtime_fail "'%s.%s': No value mapping for '%s'",
+                              object_type, key_path_obj.key,
+                              value unless value_mapping.rh_exist?(value)
+
+          result.rh_set(value_mapping[value], map_path.tree)
+        else
+          result.rh_set(value, map_path.tree)
+        end
+      end
+      result
+    end
+
+    # Obsolete. 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)
+    #   fail Lorj::PrcError.new, "'%s' is not a valid Object type. " % [oObject.
+    # class] if !oObject.is_a?(Hash) &&
+    #           ! oObject.rh_exist?(:object_type)
+    #   sCloudObj = oObject[:object_type]
+    #   oKeyPath = KeyPath.new(key)
+    #   fail Lorj::PrcError.new, "'%s' key is not declared as data of '%s' "\
+    #                            'CloudObject. You may need to add obj_needs...'
+    # % [oKeyPath.key, sCloudObj] if PrcLib.model.meta_obj.rh_exist?(sClou
+    # dObj, :returns, oKeyPath.fpath) != 3
+    #   begin
+    #     oMapPath = KeyPath.new PrcLib.model.meta_obj.rh_get(sCloudObj, :
+    # returns, oKeyPath.fpath)
+    #     hMap = oMapPath.fpath
+    #     value = @controller.get_attr(get_cObject(oObject), hMap)
+
+    #     hValueMapping = PrcLib.model.meta_obj.rh_get(sCloudObj, :value_m
+    # apping, oKeyPath.fpath)
+
+    #     if hValueMapping
+    #       hValueMapping.each do | found_key, found_value |
+    #         if found_value == value
+    #           value = found_key
+    #           break
+    #         end
+    #       end
+    #     end
+    #  rescue => e
+    #    raise Lorj::PrcError.new, "'%s.get_attr' fails to provide value of '%s'
+    # " % [oProvider.class, key]
+    #   end
+    # end
+
+    # Register the object to the internal @object_data instance
+    def register(oObject, sObjectType = nil, sDataType = :object)
+      if oObject.is_a?(Lorj::Data)
+        data_objects = oObject
+      else
+        runtime_fail "Unable to register an object '%s' "\
+                     'as Lorj::Data object if ObjectType is not given.',
+                     oObject.class unless sObjectType
+        data_objects = Lorj::Data.new(sDataType)
+        data_objects.set(oObject, sObjectType) do | sObjType, oControlerObject |
+          _return_map(sObjType, oControlerObject)
+        end
+      end
+      @object_data.add data_objects
+    end
+
+    def data_objects(sObjectType, *key)
+      @object_data[sObjectType, key]
+    end
+
+    # get an attribute/object/... from an object.
+    def get_data(oObj, *key)
+      if oObj.is_a?(Hash) && oObj.key?(:object_type)
+        object_data = ObjectData.new
+        object_data << oObj
+      else
+        object_data = @object_data
+      end
+      object_data[oObj, *key]
+    end
+
+    # ~ def hParams(sCloudObj, hParams)
+    # ~ aParams = _get_object_params(sCloudObj, ":ObjectData.hParams")
+    # ~ end
+
+    # def get_cObject(oObject)
+    #   return nil unless oObject.rh_exist?(:object)
+    #   oObject.rh_get(:object)
+    # 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 @object_data.exist?(sCloudObj)
+    #   # ~ return res if Lorj::rh_exist?(@CloudData, sCloudObj)
+
+    #   PrcLib.model.meta_obj.rh_get(sCloudObj, :params).each do |
+    #                                         key, hParams|
+    #     case hParams[:type]
+    #     when :data
+    #       if  hParams.key?(:array)
+    #         hParams[:array].each do | aElem |
+    #           aElem = aElem.clone
+    #           aElem.pop # Do not go until last level, as used to loop next.
+    #           hParams.rh_get(aElem).each do | subkey, _hSubParam |
+    #             next if aElem.length == 0 && [:array, :type].include?(subkey)
+    #             if hSubParams[:required] && @config.get(subkey).nil?
+    #               res[subkey] = hSubParams
+    #             end
+    #           end
+    #         end
+    #       else
+    #         if hParams[:required] && @config.get(key).nil?
+    #           res[key] = hParams
+    #         end
+    #       end
+    #     when :CloudObject
+    #       if hParams[:required] && !@object_data.exist?(sCloudObj)
+    #         res[key] = hParams
+    #         cloud_obj_requires(key, res)
+    #       end
+    #     end
+    #   end
+    #   res
+    # end
+
+    def get_object(sCloudObj)
+      # ~ return nil unless Lorj::rh_exist?(@CloudData, sCloudObj)
+      return nil unless @object_data.exist?(sCloudObj)
+      @object_data[sCloudObj, :ObjectData]
+      # ~ Lorj::rh_get(@CloudData, sCloudObj)
+    end
+
+    # def objectExist?(sCloudObj)
+    #   @object_data.exist?(sCloudObj)
+    #   # ~ !(Lorj::rh_exist?(@CloudData, sCloudObj))
+    # end
+
+    # def get_forjKey(sCloudObj, key)
+    #   return nil unless @object_data.exist?(sCloudObj)
+    #   @object_data[sCloudObj, :attrs, key]
+    #   # ~ return nil unless Lorj::rh_exist?(oCloudData, sCloudObj)
+    #   # ~ Lorj::rh_get(oCloudData, sCloudObj, :attrs, key)
+    # end
+  end
+end

data/lib/core/lorj_baseprocess.rb

@@ -0,0 +1,265 @@
+#!/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.
+
+# Module Lorj which contains several classes.
+#
+# 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 Lorj
+  # class describing generic Object Process
+  # with controller calls
+  class BaseProcess
+    def initialize
+      @definition = nil
+    end
+
+    # Simply raise an error
+    #
+    # * *Args*    :
+    #   - +Msg+ : Error message to print out.
+    # * *Returns* :
+    #   - nil
+    # * *Raises* :
+    #  - Lorj::PrcError
+    def process_error(msg, *p)
+      msg = format(msg, *p)
+      runtime_fail '%s: %s', self.class, msg
+    end
+
+    attr_writer :base_object
+
+    def controller_connect(sObjectType, hParams = {})
+      fail Lorj::PrcError.new, 'No Controler object loaded.' unless @definition
+      @definition.controller_connect(sObjectType, hParams)
+    end
+
+    def controller_create(sObjectType, hParams = {})
+      fail Lorj::PrcError.new, 'No Controler object loaded.' unless @definition
+      @definition.controller_create(sObjectType, hParams)
+    end
+
+    def controller_query(sObjectType, sQuery, hParams = {})
+      fail Lorj::PrcError.new, 'No Controler object loaded.' unless @definition
+      @definition.controller_query(sObjectType, sQuery, hParams)
+    end
+
+    def controller_update(sObjectType, hParams = {})
+      fail Lorj::PrcError.new, 'No Controler object loaded.' unless @definition
+      @definition.controller_update(sObjectType, hParams)
+    end
+
+    def controller_delete(sObjectType, hParams = {})
+      fail Lorj::PrcError.new, 'No Controler object loaded.' unless @definition
+      @definition.controller_delete(sObjectType, hParams)
+    end
+
+    def controller_get(sObjectType, sId, hParams = {})
+      fail Lorj::PrcError.new, 'No Controler object loaded.' unless @definition
+      @definition.controller_get(sObjectType, sId, hParams)
+    end
+  end
+
+  # class describing generic Object Process
+  # with process calls
+  class BaseProcess
+    def process_create(sObjectType)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.process_create(sObjectType)
+    end
+
+    def process_query(sObjectType, sQuery)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.process_query(sObjectType, sQuery)
+    end
+
+    def process_update(sObjectType)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.process_update(sObjectType)
+    end
+
+    def process_get(sObjectType, sId)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.process_get(sObjectType, sId)
+    end
+
+    def process_delete(sObjectType)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.process_delete(sObjectType)
+    end
+  end
+
+  # class describing generic Object Process
+  # with additionnal functions
+  class BaseProcess
+    private
+
+    def query_cache_cleanup(sObjectType)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.query_cleanup(sObjectType)
+    end
+
+    def object_cache_cleanup(sObjectType)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.object_cleanup(sObjectType)
+    end
+
+    def controler
+      PrcLib.warning('controler object call is obsolete. Please update your'\
+                     " code. Use controller_<action> instead.\n%s", caller)
+      fail Lorj::PrcError.new, 'No Controler object loaded.' unless @definition
+      @definition
+    end
+
+    def object
+      PrcLib.warning('object call is obsolete. Please update your code.'\
+                     "Use <Action> instead.\n%s", caller)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition
+    end
+
+    def format_object(sObjectType, oMiscObj)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.format_object(sObjectType, oMiscObj)
+    end
+
+    def format_query(sObjectType, oMiscObj, hQuery)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.format_list(sObjectType, oMiscObj, hQuery)
+    end
+
+    def data_objects(sObjectType, *key)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.data_objects(sObjectType, *key)
+    end
+
+    def get_data(oObj, *key)
+      PrcLib.warning('get_data call is obsolete. Please update your code. '\
+                     "Use [] instead.\n%s", caller)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.get_data(oObj, :attrs, key)
+    end
+
+    def register(oObject, sObjectType = nil)
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.register(oObject, sObjectType)
+    end
+
+    def config
+      fail Lorj::PrcError.new, 'No Base object loaded.' unless @definition
+      @definition.config
+    end
+
+    def query_single(sCloudObj, list, sQuery, name, sInfoMsg = {})
+      list = controller_query(sCloudObj, sQuery)
+
+      info = _qs_info_init(sInfoMsg)
+
+      case list.length
+      when 0
+        PrcLib.info(info[:notfound], sCloudObj, name)
+        list
+      when 1
+        Lorj.debug(2, info[:checkmatch], sCloudObj, name)
+
+        _qs_check_match(list, sQuery)
+
+        if list.length == 0
+          PrcLib.info(info[:nomatch], sCloudObj, name)
+          return list
+        end
+
+        item = _qs_info(list, info[:items], info[:items_form])
+
+        PrcLib.info(info[:found], sCloudObj, item)
+
+        list
+      else
+        Lorj.debug(2, info[:more], sCloudObj, name)
+        # Looping to find the one corresponding
+        _qs_check_match(list, sQuery)
+
+        if list.length == 0
+          PrcLib.info(info[:notfound], sCloudObj, name)
+          return list
+        end
+        item = _qs_info(list, info[:items], info[:items_form])
+        PrcLib.info(info[:found], sCloudObj, item)
+
+        list
+      end
+    end
+  end
+
+  # internal functions
+  class BaseProcess
+    private
+
+    def _qs_info(list, items, items_form)
+      items_built = []
+      if items.is_a?(Array)
+        items.each do | key |
+          items_built << list[0, key]
+        end
+      else
+        items_built << list[0, items]
+      end
+      format(items_form, items_built)
+    end
+
+    def _qs_check_match(list, sQuery)
+      list.each do | oElem |
+        is_found = true
+        sQuery.each do | key, value |
+          if oElem[key] != value
+            is_found = false
+            break
+          end
+        end
+        :remove unless is_found
+      end
+    end
+
+    # qs_info_init is not omplex as well described. Disabling rubocop
+    # rubocop: disable PerceivedComplexity, CyclomaticComplexity
+
+    def _qs_info_init(sInfoMsg)
+      info = {
+        :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]
+      }
+      info[:notfound]     = sInfoMsg[:notfound]   if sInfoMsg.key?(:notfound)
+      info[:checkmatch]   = sInfoMsg[:checkmatch] if sInfoMsg.key?(:checkmatch)
+      info[:nomatch]      = sInfoMsg[:nomatch]    if sInfoMsg.key?(:nomatch)
+      info[:found]        = sInfoMsg[:found]      if sInfoMsg.key?(:found)
+      info[:more]         = sInfoMsg[:more]       if sInfoMsg.key?(:more)
+      info[:items]        = sInfoMsg[:items]      if sInfoMsg.key?(:items)
+      info[:items_form]   = sInfoMsg[:items_form] if sInfoMsg.key?(:items_form)
+      info
+    end
+  end
+end