lorj 0.2.0 → 1.0.0

data/lib/core/core_controller.rb

@@ -0,0 +1,227 @@
+# (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
+  # Adding controller core functions.
+  class BaseDefinition
+    # a Process can execute any kind of predefined controler task.
+    # Those function build controller_params with Provider compliant data
+    # (mapped)
+    # Results are formatted as usual framework Data object and stored.
+
+    # controller_connect call lorj framework to execute a
+    # controller connection task
+    #
+    # parameters:
+    # - +object_type+: Lorj object type to use for the connection.
+    # - +params+     : Parameters to use for connection.
+    def controller_connect(sObjectType, params = {})
+      controller_params = _get_object_params(sObjectType, :create_e, :connect,
+                                             true, params)
+      controller_obj = @controller.connect(sObjectType, controller_params)
+      data_obj = Lorj::Data.new
+      data_obj.set(controller_obj, sObjectType) do | sObjType, oObject |
+        begin
+          _return_map(sObjType, oObject)
+       rescue => e
+         PrcLib.runtime_fail 'connect %s.%s : %s',
+                             @process.class, sObjectType, e.message
+        end
+      end
+      @object_data.add data_obj
+      data_obj
+    end
+    # controller_create call lorj framework to execute a
+    # controller creation task
+    #
+    # parameters:
+    # - +object_type+: Lorj object type to use for the creation.
+    # - +params+     : Parameters to use for creation.
+    def controller_create(sObjectType, params = {})
+      # The process ask the controller to create the object.
+      # controller_params have to be fully readable by the controller.
+      controller_params = _get_object_params(sObjectType, :create_e, :create,
+                                             true, params)
+      controller_obj = @controller.create(sObjectType, controller_params)
+      data_obj = Lorj::Data.new
+      data_obj.set(controller_obj, sObjectType) do | sObjType, oObject |
+        begin
+          _return_map(sObjType, oObject)
+       rescue => e
+         PrcLib.runtime_fail 'create %s.%s : %s',
+                             @process.class, sObjectType, e.message
+        end
+      end
+      @object_data.add data_obj
+
+      data_obj
+    end
+
+    # controller_delete call lorj framework to execute a
+    # controller deletion task
+    #
+    # parameters:
+    # - +object_type+: Lorj object type to use for the deletion.
+    # - +params+     : Parameters to use for deletion.
+    #
+    # returns:
+    # - The controller must return true to inform about the real deletion
+    def controller_delete(sObjectType, params = {})
+      controller_params = _get_object_params(sObjectType, :delete_e, :delete,
+                                             true, params)
+      PrcLib.runtime_fail "delete Controller - %s: Object '%s' is not loaded.",
+                          @controller.class,
+                          key unless controller_params.exist?(sObjectType)
+      state = @controller.delete(sObjectType, controller_params)
+      @object_data.delete(sObjectType) if state
+      state
+    end
+
+    # controller_get call lorj framework to execute a controller get task
+    #
+    # parameters:
+    # - +object_type+: Lorj object type to use for the get.
+    # - +params+     : Parameters to use for get.
+    #
+    # returns:
+    # - Return a Lorj::Data representing the data retrieved by the controller.
+    def controller_get(sObjectType, sUniqId, params = {})
+      controller_params = _get_object_params(sObjectType, :get_e, :get,
+                                             true, params)
+
+      controller_obj = @controller.get(sObjectType, sUniqId, controller_params)
+      data_obj = Lorj::Data.new
+      data_obj.set(controller_obj, sObjectType) do | sObjType, oObject |
+        begin
+          _return_map(sObjType, oObject)
+       rescue => e
+         PrcLib.runtime_fail 'get %s.%s : %s',
+                             @process.class, sObjectType, e.message
+        end
+      end
+      @object_data.add data_obj
+
+      data_obj
+    end
+
+    # controller_query call lorj framework to execute a controller query task
+    #
+    # parameters:
+    # - +object_type+: Lorj object type to use for the query.
+    # - +params+     : Parameters to use for query.
+    #
+    # returns:
+    # - Returns a Lorj::Data object, containing a list of Lorj::Data element.
+    def controller_query(sObjectType, hQuery, params = {})
+      # Check if we can re-use a previous query
+      list = @object_data[:query, sObjectType]
+      unless list.nil?
+        if list[:query] == hQuery
+          Lorj.debug(3, "Using Object '%s' query cache : %s",
+                     sObjectType, hQuery)
+          return list
+        end
+      end
+
+      controller_params = _get_object_params(sObjectType, :query_e, :query,
+                                             true, params)
+      controller_query = _query_map(sObjectType, hQuery)
+
+      controller_obj = @controller.query(sObjectType, controller_query,
+                                         controller_params)
+
+      data_obj = Lorj::Data.new :list
+      data_obj.set(controller_obj,
+                   sObjectType, hQuery) do | sObjType, key |
+        begin
+          _return_map(sObjType, key)
+       rescue => e
+         PrcLib.runtime_fail 'query %s.%s : %s',
+                             @process.class, sObjectType, e.message
+        end
+      end
+
+      Lorj.debug(2, 'Object %s - queried. Found %s object(s).',
+                 sObjectType, data_obj.length)
+
+      @object_data.add data_obj
+      data_obj
+    end
+
+    # controller_update call lorj framework to execute a controller update task
+    #
+    # parameters:
+    # - +object_type+: Lorj object type to use for the update.
+    # - +params+     : Parameters to use for update.
+    #
+    # returns:
+    # - The controller must return true to inform about the real deletion
+    def controller_update(sObjectType, params = {})
+      # Need to detect data updated and update the Controler object with the
+      # controler
+
+      controller_params = _get_object_params(sObjectType, :update_e, :update,
+                                             true, params)
+
+      data_obj = @object_data[sObjectType, :ObjectData]
+      controller_obj = data_obj[:object]
+
+      is_updated = false
+      attributes = data_obj[:attrs]
+      attributes.each do |key, value |
+        attribute_obj = KeyPath.new(key)
+
+        attribute_map = PrcLib.model.meta_obj.rh_get(sObjectType, :returns,
+                                                     attribute_obj.fpath)
+        attr_map_obj = KeyPath.new(attribute_map)
+        old_value = @controller.get_attr(controller_obj, attr_map_obj.tree)
+
+        next if value == old_value
+
+        is_updated = true
+        @controller.set_attr(controller_obj, attr_map_obj.tree, value)
+        Lorj.debug(2, '%s.%s - Updating: %s = %s (old : %s)',
+                   @process.class, sObjectType, key, value, old_value)
+      end
+
+      is_done = @controller.update(sObjectType, data_obj,
+                                   controller_params) if is_updated
+
+      PrcLib.runtime_fail "Controller function 'update' must return True or "\
+                          "False. Class returned: '%s'",
+                          is_done.class unless is_done.boolean?
+
+      Lorj.debug(1, '%s.%s - updated.',
+                 @process.class, sObjectType) if is_done
+      data_obj.set(controller_obj, sObjectType) do | sObjType, an_object |
+        begin
+          _return_map(sObjType, an_object)
+       rescue => e
+         PrcLib.runtime_fail 'update %s.%s : %s',
+                             @process.class, sObjectType, e.message
+        end
+      end
+      is_done
+    end
+  end
+end

data/lib/core/core_internal.rb

@@ -0,0 +1,339 @@
+# 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.
+
+# rubocop: disable Metrics/AbcSize
+
+# Module Lorj which contains several classes.
+module Lorj
+  # Define private initialize functions for processes
+  class Core
+    private
+
+    # Create core objects
+    # Create a BaseDefinition object => Core
+    # Attach Config, Process and Controller object
+    def initialize_core_object(model)
+      ensure_class_exist(model[:process_class_name])
+
+      # Ex: Hpcloud(ForjAccount, HpcloudProvider)
+      def_class = model[:def_class]
+      if model[:controller_class]
+        @core_object = def_class.new(@config,
+                                     model[:process_class].new,
+                                     model[:controller_class].new)
+      else
+        @core_object = def_class.new(@config,
+                                     model[:process_class].new)
+      end
+    end
+
+    # Function to ensure a Class_name as already been loaded or not
+    # It raises an error if not.
+    def ensure_class_exist(class_name)
+      # Ensure Process class exists ---------------
+      Object.const_get(class_name)
+    rescue => e
+      raise Lorj::PrcError.new, format('Lorj::Core: Unable to find class'\
+                                       " '%s'\n%s", class_name, e.message)
+    end
+
+    # Initialize the Application model structure for Initialization
+    #
+    # * *Returns* :
+    #   - model : Basic model.
+    def initialize_model
+      { :def_class => BaseDefinition,
+        :process_class => nil, :process_class_name => nil,
+        :controller_class => nil, :controller_class_name => nil }
+    end
+
+    # Initialize a basic Config Object and use the one passed
+    # as parameter.
+    # It sets @config instance attribute
+    def init_core_config(the_config)
+      if the_config.nil?
+        @config = Lorj::Config.new
+        Lorj.debug(2, 'Using an internal Lorj::Config object.')
+      else
+        @config = the_config
+      end
+    end
+
+    # Function to initialize itself with application controller.
+    #
+    # * *Args* :
+    #   - +model+      : Application model loaded.
+    #   - +controller+ : Processes to load.
+    #     supports     :
+    #                   - nil => return []
+    #                   - String/Symbol => return [String/Symbol]
+    #                   - Array => return Array
+    #
+    # * *Returns* :
+    #   - model : Application model loaded.
+    def init_controller(model, the_controller)
+      Lorj.debug(1, "Loading Controller/definition '%s'", the_controller)
+
+      ok = load_controller(model, the_controller)
+
+      PrcLib.warning("Controller '%s' not properly loaded.",
+                     the_controller) unless ok
+
+      model
+    end
+
+    # Function to load a controller.
+    # This function helps to load a Controller process
+    # (See load_process_controller_file) if exists
+    # and load the core controller file
+    # (Seeload_controllerfile)
+    #
+    # * *Args* :
+    #   - +the_controller+ : Controller to load. Can be a string or
+    #                      a path to a file
+    #
+    # * *Returns* :
+    #   - load_status : true if loaded, false otherwise
+    def load_controller(model, the_controller)
+      load_process_controller(model, the_controller)
+
+      the_controller = the_controller.to_s unless the_controller.is_a?(String)
+      if the_controller.include?('/')
+        file = File.expand_path(the_controller)
+      else
+        file = controllerfile_from_default(the_controller)
+      end
+
+      return PrcLib.warning('Controller not loaded: Controller file '\
+                            "definition '%s' is missing.",
+                            file) unless File.exist?(file)
+      load_controllerfile(model, file, classname_from_file(file))
+    end
+
+    # Load a Controller process file in ruby.
+    # If controller is a file, the process file name will be suffixed by
+    # _process, before the .rb file name.
+    #
+    # If controller is just a name (String/Symbol), it will load
+    # a file suffixed by _process.rb from PrcLib.controller_path
+    #
+    # * *Args* :
+    #   - +model+      : Application/controller model loaded.
+    #   - +controller+ : Symbol/String. Controller name or file to load.
+    #
+    # * *Returns* :
+    #   - loaded : load status
+    def load_process_controller(model, the_controller)
+      Lorj.debug(1, "Loading process for controller '%s'", the_controller)
+
+      the_controller = the_controller.to_s unless the_controller.is_a?(String)
+      if the_controller.include?('/')
+        the_controller_process = the_controller.clone
+        the_controller_process['.rb'] = '_process.rb'
+        file = File.expand_path(the_controller_process)
+      else
+        file = controllerfile_from_default(the_controller, '_process')
+      end
+
+      return Lorj.debug(2, 'Process not loaded: Process controller file '\
+                          "definition '%s' is missing.",
+                        file) unless File.exist?(file)
+      load_processfile(model, file, classname_from_file(file))
+    end
+
+    # Load a Controller file in ruby.
+    #
+    # * *Args* :
+    #   - +model+      : Application/controller model loaded.
+    #   - +file+       : Process file to load.
+    #   - +controller+ : Controller name or file to load.
+    #
+    # * *Returns* :
+    #   - loaded : load status
+    def load_controllerfile(model, file, the_controller)
+      # 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
+      base_definition_class = Class.new(BaseDefinition)
+      # Finally, name that class!
+      Lorj.debug(2, "Declaring Definition '%s'", the_controller)
+      Object.const_set the_controller, base_definition_class
+
+      model[:controller_class_name] = the_controller + 'Controller'
+      base_controller_class = Class.new(BaseController)
+      Lorj.debug(2, "Declaring Controller '%s'", model[:controller_class_name])
+
+      model[:controller_class] = Object.const_set model[:controller_class_name],
+                                                  base_controller_class
+
+      # Loading Provider base file. This file should load a class
+      # which have the same name as the file.
+      load file
+    end
+
+    # Determine the controller file path from the single name.
+    # Uses PrcLib.controller_path as path to load this process.
+    #
+    # * *Args* :
+    #   - +the_controller_class+ : Controller to load.
+    #
+    # * *Returns* :
+    #   - file : absolute file path.
+    def controllerfile_from_default(the_controller, suffix = '')
+      File.join(PrcLib.controller_path, the_controller,
+                the_controller + suffix + '.rb')
+    end
+  end
+
+  # Define private Initialize functions for controllers
+  class Core
+    private
+
+    # Function to initialize itself with application processes.
+    #
+    # * *Args* :
+    #   - +model+ : Application model loaded.
+    #   - +processes+ : Processes to load.
+    #     supports:
+    #              - nil => return []
+    #              - String/Symbol => return [String/Symbol]
+    #              - Array => return Array
+    #
+    # * *Returns* :
+    #   - model : Application model loaded.
+    def init_processes(model, processes)
+      process_array = processes_as_array(processes)
+
+      process_array.each do | a_process |
+        a_process = a_process.to_s if a_process.is_a?(Symbol)
+        unless load_process(model, a_process)
+          PrcLib.warning("Process '%s' not properly loaded.", a_process)
+        end
+      end
+      model
+    end
+
+    # Function analyzing the process class parameter
+    # and return the list of processes in an
+    # array of processes.
+    #
+    # * *Args* :
+    #   - +processes_parameter+ : Parameter to interpret.
+    #     supports:
+    #              - nil => return []
+    #              - String/Symbol => return [String/Symbol]
+    #              - Array => return Array
+    #
+    # * *Returns* :
+    #   - array_processes : Array of processes.
+    def processes_as_array(processes_parameter)
+      return [] if processes_parameter.nil?
+
+      return [processes_parameter] unless processes_parameter.is_a?(Array)
+
+      processes_parameter
+    end
+
+    # Function to load a process.
+    #
+    # * *Args* :
+    #   - +the_process_+ : Process to load. Can be a string or
+    #                      a path to a file
+    #
+    # * *Returns* :
+    #   - load_status : true if loaded, false otherwise
+    def load_process(model, the_process)
+      Lorj.debug(1, "Loading Process '%s'", the_process)
+
+      if the_process.include?('/')
+        file = File.expand_path(the_process)
+      else
+        file = processfile_from_default(the_process)
+      end
+
+      return PrcLib.warning("Process file definition '%s' is missing. ",
+                            file) unless File.exist?(file)
+
+      load_processfile(model, file, classname_from_file(file))
+    end
+
+    # Function which determine the class name from the file name.
+    # rules:
+    # - First character : Capitalized
+    # - Any character prefixed by '_' : capitalized. '_' is removed.
+    #
+    # * *Args* :
+    #   - +the_process_file+ : Process file to analyze.
+    #
+    # * *Returns* :
+    #   - ProcessClassName : string representing the name of the class.
+    def classname_from_file(file)
+      the_process_class = File.basename(file)
+
+      the_process_class['.rb'] = '' if the_process_class['.rb']
+
+      if (/[A-Z]/ =~ the_process_class) != 0
+        the_process_class = the_process_class.capitalize
+      end
+
+      match_found = the_process_class.scan(/_[a-z]/)
+      if match_found
+        match_found.each { | str | the_process_class[str] = str[1].capitalize }
+      end
+
+      the_process_class
+    end
+
+    # Determine the process file path from the single name.
+    # Uses PrcLib.process_path as path to load this process.
+    #
+    # * *Args* :
+    #   - +the_process_class+ : Process to load.
+    #
+    # * *Returns* :
+    #   - file : absolute file path composed by:
+    #            PrcLib.process_path/the_process_class + '.rb'
+    def processfile_from_default(the_process_class)
+      File.join(PrcLib.process_path, the_process_class + '.rb')
+    end
+
+    # Load a process file in ruby.
+    #
+    # * *Args* :
+    #   - +file+    : Process file to load.
+    #
+    # * *Returns* :
+    #   - loaded : load status
+    def load_processfile(model, file, the_process_class)
+      model[:process_class] = BaseProcess if model[:process_class].nil?
+
+      new_class = Class.new(model[:process_class])
+      unless /Process$/ =~ the_process_class
+        the_process_class = format('%sProcess',  the_process_class)
+      end
+
+      Lorj.debug(1, "Declaring Process '%s'", the_process_class)
+      model[:process_class] = Object.const_set(the_process_class, new_class)
+      model[:process_class_name] = the_process_class
+      BaseDefinition.current_process(model[:process_class])
+      load file
+    end
+  end
+end