lorj 1.0.9 → 1.0.10

data/lib/core/core_internal.rb

@@ -57,6 +57,7 @@ module Lorj
     #   - model : Basic model.
     def initialize_model
       { :def_class => BaseDefinition,
+        :processes => [],
         :process_class => nil, :process_class_name => nil,
         :controller_class => nil, :controller_class_name => nil }
     end
@@ -115,7 +116,7 @@ module Lorj
       if the_controller.include?('/')
         file = File.expand_path(the_controller)
       else
-        file = controllerfile_from_default(the_controller)
+        file = controllerfile_from_default(model, the_controller)
       end
 
       return PrcLib.warning('Controller not loaded: Controller file '\
@@ -146,7 +147,7 @@ module Lorj
         the_controller_process['.rb'] = '_process.rb'
         file = File.expand_path(the_controller_process)
       else
-        file = controllerfile_from_default(the_controller, '_process')
+        file = controllerfile_from_default(model, the_controller, '_process')
       end
 
       return Lorj.debug(2, 'Process not loaded: Process controller file '\
@@ -197,7 +198,7 @@ module Lorj
     #
     # * *Returns* :
     #   - file : absolute file path.
-    def controllerfile_from_default(the_controller, suffix = '')
+    def controllerfile_from_default(_model, the_controller, suffix = '')
       File.join(PrcLib.controller_path, the_controller,
                 the_controller + suffix + '.rb')
     end
@@ -211,26 +212,120 @@ module Lorj
     #
     # * *Args* :
     #   - +model+ : Application model loaded.
-    #   - +processes+ : Processes to load.
-    #     supports:
-    #              - nil => return []
-    #              - String/Symbol => return [String/Symbol]
-    #              - Array => return Array
+    #   - +processes+ : Array of processes and controller to load
+    #     - each element contains a Hash with:
+    #       If you are using a process module, set the following:
+    #       - :process_module : Name of the process module to load
+    #
+    #       If you are not using a Process module, you need to set the following
+    #       - :process_path   : Path to a local process code.
+    #         This path must contains at least 'process' subdir. And if needed
+    #         a 'controllers' path
+    #       - :process_name   : Name of the local process
+    #
+    #       Optionnally, you can set a controller name to use with the process.
+    #       - :controller_name: Name of the controller to use.
+    #       - :controller_path: Path to the controller file.
     #
     # * *Returns* :
     #   - model : Application model loaded.
     def init_processes(model, processes)
-      process_array = processes_as_array(processes)
+      processes.each do |a_process|
+        my_process = {}
 
-      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)
+        if a_process.key?(:process_module)
+          my_process = _process_module_to_load(my_process, a_process)
+        else
+          my_process = _process_local_to_load(my_process, a_process)
         end
+
+        next if my_process.nil?
+
+        model[:processes] << my_process
+
+        _process_load(model, my_process)
       end
+
       model
     end
 
+    # high level function to load process
+    def _process_load(model, my_process)
+      if load_process(model, my_process[:process_path])
+        controller_class = my_process[:controller_path]
+        controller_class = my_process[:controller_name] if controller_class.nil?
+
+        init_controller(model, controller_class) if controller_class
+      else
+        PrcLib.warning("Process '%s' not properly loaded.",
+                       my_process[:process_path])
+      end
+    end
+
+    # function prepare of loading a local process
+    def _process_local_to_load(my_process, a_process)
+      my_process[:process_path] = a_process[:process_path]
+
+      if a_process[:process_name].nil?
+        my_process[:process_name] = File.basename(a_process[:process_path])
+      else
+        my_process[:process_name] = a_process[:process_name]
+      end
+
+      if a_process[:controller_path]
+        my_process[:controller_path] = a_process[:controller_path]
+      else
+        my_process[:controller_name] = a_process[:controller_name]
+      end
+      my_process
+    end
+
+    # Function prepare of loading a module process.
+    def _process_module_to_load(my_process, a_process)
+      name = a_process[:process_module]
+
+      if name.nil?
+        PrcLib.warning(':process_module is empty. Process not properly loaded.')
+        return
+      end
+
+      name = name.to_s if name.is_a?(Symbol)
+
+      unless Lorj.processes.key?(name)
+        PrcLib.warning("Unable to find Process module '%s'. Process not "\
+                       'properly loaded.', name)
+        return
+      end
+
+      module_process = Lorj.processes[name]
+      my_process[:process_name] = name
+      my_process[:process_path] = module_process.process
+
+      if a_process[:controller_path]
+        my_process[:controller_path] = a_process[:controller_path]
+        return my_process
+      end
+
+      _process_module_set_ctr(my_process, module_process.controllers,
+                              a_process[:controller_name])
+
+      my_process
+    end
+
+    def _process_module_set_ctr(my_process, controllers, controller_name)
+      return if controller_name.nil?
+
+      controller_path = controllers[controller_name]
+
+      if controller_path.nil?
+        PrcLib.warning("Controller '%s' was not found. Please check. The "\
+                       'process may not work.', controller_name)
+        return
+      end
+
+      my_process[:controller_path] = controller_path
+    end
+
     # Function analyzing the process class parameter
     # and return the list of processes in an
     # array of processes.
@@ -266,7 +361,7 @@ module Lorj
       if the_process.include?('/')
         file = File.expand_path(the_process)
       else
-        file = processfile_from_default(the_process)
+        file = processfile_from_default(model, the_process)
       end
 
       return PrcLib.warning("Process file definition '%s' is missing. ",
@@ -311,7 +406,7 @@ module Lorj
     # * *Returns* :
     #   - file : absolute file path composed by:
     #            PrcLib.process_path/the_process_class + '.rb'
-    def processfile_from_default(the_process_class)
+    def processfile_from_default(_model, the_process_class)
       File.join(PrcLib.process_path, the_process_class + '.rb')
     end
 

data/lib/core/core_object_data.rb

@@ -172,7 +172,7 @@ module Lorj
       if obj.is_a?(Symbol)
         object_type = obj
         obj = @params[object_type]
-        @params[object_type] = nil
+        @params.delete(object_type)
       else
         object_data_delete(obj)
       end
@@ -236,8 +236,8 @@ module Lorj
 
     def type?(key)
       return nil unless @params.rh_exist?(key)
+      return :DataObject if @params[key].type == :object
       :data
-      :DataObject if @params[key].type == :object
     end
 
     def to_s
@@ -327,10 +327,10 @@ module Lorj
                            " framework data Object. Is a '%s'",
                           obj.class unless obj.is_a?(Lorj::Data)
       if obj.type == :list
-        @params.rh_set(nil, :query, obj.object_type?)
+        @params.rh_del(:query, obj.object_type?)
       else
         object_type = obj.object_type?
-        @params[object_type] = nil
+        @params.delete(object_type)
       end
     end
 

data/lib/core/core_process_setup.rb

@@ -118,23 +118,19 @@ module Lorj
     #
     # * *Args* :
     #   - +ObjectType+   : Top object type to ask.
-    #   - +sAccountName+ : Optional. Account Name to load if you are using a
-    #                      Lorj::Account Object.
     #
     # * *Returns* :
     #   - nothing.
     #
     # * *Raises* :
     #
-    def process_setup(sObjectType, sAccountName = nil)
+    def process_setup(sObjectType)
       unless PrcLib.model.meta_obj.rh_exist?(sObjectType)
         PrcLib.runtime_fail "Setup: '%s' not a valid object type."
       end
 
       setup_steps = _setup_load
 
-      return nil unless _process_setup_init(sAccountName)
-
       Lorj.debug(2, "Setup is identifying account data to ask for '%s'",
                  sObjectType)
       # Loop in dependencies to get list of data object to setup
@@ -147,35 +143,12 @@ module Lorj
 
       _setup_ask(setup_steps)
 
-      PrcLib.info("Configuring account : '#{sAccountName}',"\
-                  " provider '#{config[:provider_name]}'")
+      PrcLib.info("Configuring account : '#{config[:name]}',"\
+                  " provider '#{config[:provider]}'")
     end
 
     private
 
-    # Internal function to initialize the account.
-    #
-    # return true if initialized, false otherwise.
-    def _process_setup_init(sAccountName)
-      return false unless sAccountName
-
-      if @config.ac_load(sAccountName)
-        if @config[:provider] != @config[:provider_name]
-          s_ask = format("Account '%s' was configured with a different "\
-                         "provider '%s'.\nAre you sure to re-initialize this "\
-                         "account with '%s' provider instead? "\
-                         'All data will be lost',
-                         sAccountName, @config[:provider],
-                         @config[:provider_name])
-          PrcLib.fatal(0, 'Exited by user request.') unless agree(s_ask)
-          @config.ac_new(sAccountName, config[:provider_name])
-        end
-      else
-        @config.ac_new(sAccountName, config[:provider_name])
-      end
-      true
-    end
-
     # Internal function to insert the data after several data to ask.
     #
     # * *Args* :

data/lib/core/lorj_data.rb

@@ -547,7 +547,7 @@ module Lorj
 
     def elem_exist?(*key)
       return true if key[0] == :object && @data.key?(key[0])
-      return true if key[0] == :attrs  && @data.rh_exist?(key)
+      return true if key[0] == :attrs && @data.rh_exist?(key)
       (@data.rh_lexist?(:attrs, key) == key.length + 1)
     end
 

data/lib/core/lorj_keypath.rb

@@ -113,7 +113,9 @@ module Lorj
     private
 
     def string_to_sarray(sKeyPath)
-      if %r{[^\\/]?/[^/]} =~ sKeyPath || /:[^:\/]/ =~ sKeyPath
+      # rubocop: disable Style/RegexpLiteral
+      if %r{[^\\/]?/[^/]} =~ sKeyPath || %r{:[^:/]} =~ sKeyPath
+        # rubocop: enable Style/RegexpLiteral
         # keypath to interpret
         res = sKeyPath.split('/')
         res.each_index do |iIndex|

data/lib/core/process.rb

@@ -0,0 +1,67 @@
+#!/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.
+
+# Define process module management in Lorj
+#
+module Lorj
+  # This class defines a Process module
+  #
+  #
+  class ProcessResource
+    attr_reader :defaults_file, :data_file, :process, :name, :controllers
+
+    def initialize(name, path, props = {})
+      # Determine resources
+      name = name.to_s if name.is_a?(Symbol)
+
+      process_path = File.expand_path(File.join(path, 'process',
+                                                name + '_process.rb'))
+
+      return nil unless File.exist?(process_path)
+      @process = process_path
+      @name = name
+
+      controller_dir = 'controllers'
+      controller_dir = props[:controllers_dir] if props.key?(:controllers_dir)
+      controller_path = File.expand_path(File.join(path, controller_dir))
+
+      _identify_controllers(controller_path)
+
+      defaults_file = File.expand_path(File.join(path, 'defaults.yaml'))
+      @defaults_file = defaults_file if File.exist?(defaults_file)
+
+      data_file = File.expand_path(File.join(path, 'data.yaml'))
+      @data_file = data_file if File.exist?(data_file)
+
+      self
+    end
+
+    private
+
+    def _identify_controllers(controller_path)
+      @controllers = {}
+
+      Dir.foreach(controller_path) do |dir|
+        next if dir.match(/^\.\.?$/)
+
+        next unless File.exist?(File.join(controller_path, dir, dir + '.rb'))
+
+        @controllers[dir] = File.join(controller_path, dir, dir + '.rb')
+      end
+    end
+  end
+end

data/lib/lorj/version.rb

@@ -16,5 +16,6 @@
 
 # Lorj version
 module Lorj
-  VERSION = '1.0.9'
+  VERSION = '1.0.10'
+  DATE = '2015-04-17'
 end

data/lib/lorj.rb

@@ -23,12 +23,10 @@ require 'lorj/version'
 
 # To use it, add require 'lorj'
 
+require 'config_layers'            # ConfigLayers
+
 require 'prc.rb'                   # PrcLib Base module
-require 'rh.rb'                    # recursive Hash
 require 'logging.rb'               # class PrcLib::Logging
-require 'prc_base_config.rb'       # PRC::BaseConfig class
-require 'prc_section_config.rb'    # PRC::SectionConfig class
-require 'prc_core_config.rb'       # PRC::CoreConfig class
 require 'lorj_meta.rb'             # PRC::Meta class - Application defaults
 require 'lorj_defaults.rb'         # PRC::Defaults class - Application defaults
 require 'lorj_config.rb'           # Lorj::Config class -
@@ -54,6 +52,7 @@ require 'core/lorj_basecontroller' # Lorj Lorj::BaseController object
 require 'core/lorj_keypath'        # Lorj Lorj::BaseDefinition object
 require 'core/definition'          # Lorj Process definition
 require 'core/definition_internal' # Lorj internal functions
+require 'core/process'             # Lorj Process Module feature
 
 # lorj module
 module Lorj

data/lib/lorj_account.rb

@@ -139,7 +139,7 @@ module Lorj
     # - local      : Represents the config.yaml located in ~/.forj
     # - account    : Represents an Account data located in ~/.forj/accounts
     # - runtime    : Represents the runtime in memory data settings.
-    def initialize(config_name = nil)
+    def initialize(config_name = nil, latest_version = nil)
       config_layers = []
 
       # Application layer
@@ -149,11 +149,11 @@ module Lorj
       config_layers << define_controller_data_layer
 
       # Local Config layer
-      local = define_local_layer
+      local = define_local_layer(latest_version)
       config_layers << local
 
       # Account config layer
-      config_layers << define_account_layer
+      config_layers << define_account_layer(latest_version)
 
       # runtime Config layer
       config_layers << define_runtime_layer
@@ -650,9 +650,10 @@ module Lorj
       index
     end
 
-    def define_account_layer
+    def define_account_layer(latest_version = nil)
       PRC::CoreConfig.define_layer(:name     => 'account',
-                                   :config   => Lorj::AccountConfig.new,
+                                   :config   => \
+                                   Lorj::AccountConfig.new(nil, latest_version),
                                    :file_set => true,
                                    :load     => true, :save     => true)
     end

data/lib/lorj_config.rb

@@ -138,9 +138,10 @@ module Lorj
                                    :set => false, :load => true)
     end
 
-    def define_local_layer
+    def define_local_layer(latest_version = nil)
       PRC::CoreConfig.define_layer(:name => 'local',
-                                   :config => PRC::SectionConfig.new,
+                                   :config => \
+                                    PRC::SectionConfig.new(nil, latest_version),
                                    :load => true, :save => true)
     end
 

data/lib/providers/templates/compute.rb

@@ -35,6 +35,6 @@ class Mycloud
       :auth_uri => @oForjAccount.get(:auth_uri),
       :project => @oForjAccount.get(:tenant),
       :compute_service => @oForjAccount.get(:compute)
-       )
+    )
   end
 end

data/lorj-spec/controllers/mock/mock.rb

@@ -0,0 +1,144 @@
+# 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.
+
+# This class describes how to process some actions, and will do everything prior
+# this task to make it to work.
+
+# This Mock controller keep the data in memory in hash/Array data.
+class Mock
+  # mock do not need to use any mapping. It adapts itself to what the process
+  # has defined.
+end
+
+# This Mock controller keep the data in memory in hash/Array data.
+class MockController
+  @@data = {} # rubocop: disable ClassVars
+
+  def create(sObjectType, hParams)
+    PrcLib.debug("Mock: create object '%s' with parameters (hdata) '%s'",
+                 sObjectType, hParams[:hdata])
+
+    result = {}
+    hParams[].keys.each do |key|
+      next if key == :hdata
+      result[key] = hParams[key]
+    end
+    result.merge!(hParams[:hdata])
+
+    @@data[sObjectType] = [] unless @@data.key?(sObjectType)
+
+    array = @@data[sObjectType]
+
+    array.each do |value|
+      fail if value.key?(result[:name])
+    end
+    array << result
+
+    result[:id] = array.length - 1
+
+    # Typical code:
+    # ~ case sObjectType
+    # ~ when :public_ip
+    # Following function can be executed to ensure the object :connection exists
+    # ~ required?(hParams, :connection)
+    # ~ required?(hParams, :server)
+    # ~ ... CODE to create
+    # ~ else
+    # ~ controller_error "'%s' is not a valid object for 'create'", sObjectType
+    # ~ end
+    # The code should return some data
+    # This data will be encapsulated in Lorj::Data object.
+    # data will be extracted by the framework with the controller get_attr
+    # function and mapped.
+    PrcLib.debug("Mock: object '%s' = '%s' is created.", sObjectType, result)
+    result
+  end
+
+  # This function return a collection which have to provide:
+  # functions: [], length, each
+  # Used by network process.
+  def query(sObjectType, sQuery, hParams)
+    PrcLib.debug("Mock: query object '%s' with hdata '%s' using query '%s'",
+                 sObjectType, hParams[:hdata], sQuery)
+
+    return [] unless @@data.key?(sObjectType)
+
+    result = []
+
+    @@data[sObjectType].each do |value|
+      elem = value
+      sQuery.each do |query_key, query_value|
+        elem = nil if !value.key?(query_key) || value[query_key] != query_value
+      end
+      result << elem if elem
+    end
+    result
+  end
+
+  def delete(sObjectType, hParams)
+    PrcLib.debug("Mock: delete object '%s' with hdata '%s'",
+                 sObjectType, hParams[:hdata])
+    return nil unless @@data.key?(sObjectType)
+
+    return false if !hParams.exist?(sObjectType) || hParams[sObjectType].nil?
+    @@data[sObjectType].delete(hParams[sObjectType])
+    PrcLib.debug("Mock: object '%s' = '%s' is deleted.",
+                 sObjectType, hParams[sObjectType])
+    true
+  end
+
+  def get(sObjectType, sUniqId, hParams)
+    PrcLib.debug("Mock: Get object '%s' = '%s' with hdata '%s'",
+                 sObjectType, sUniqId, hParams[:hdata])
+    return nil unless @@data.key?(sObjectType)
+    @@data[sObjectType][sUniqId]
+  end
+
+  def get_attr(oControlerObject, key)
+    # This controller function read the data and
+    # extract the information requested by the framework.
+    # Those data will be mapped to the process data model.
+    # The key is an array, to get data from a level tree.
+    # [data_l1, data_l2, data_l3] => should retrieve data from structure like
+    # data[ data_l2[ data_l3 ] ]
+    attributes = oControlerObject
+
+    attributes.rh_get(key)
+ rescue => e
+   controller_error "Unable to map '%s'.\n%s", key, e.message
+  end
+
+  def set_attr(oControlerObject, key, value)
+    attributes = oControlerObject
+
+    attributes.rh_set(value, key)
+ rescue => e
+   controller_error "Unable to map '%s' on '%s'.\n%s",
+                    key, sObjectType, e.message
+  end
+
+  def update(sObjectType, oObject, hParams)
+    PrcLib.debug("Mock: Update object '%s' = '%s' with hdata '%s'",
+                 sObjectType, sUniqId, hParams[:hdata])
+    return false unless @@data.key?(sObjectType)
+
+    return false unless @@data[sObjectType][oObject[:id]].nil?
+    # Considered hash object is already updated.
+    # This action emule the object save which doesn't make sense in this empty
+    # Mock controller.
+    true
+  end
+end

data/lorj-spec/process/mock2_process.rb

@@ -0,0 +1,48 @@
+# 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.
+
+# Students process
+class StudentsProcess
+  def create_student(sObjectType, hParams)
+    PrcLib.state(format("Running creation process for object '%s' = '%s'",
+                        sObjectType, hParams[:student_name]))
+    #  byebug if ENV['BYEBUG'] # rubocop: disable Debugger
+    object = controller_create(sObjectType)
+    PrcLib.runtime_fail "Student '%s' not created.",
+                        hParams[:student_name] if object.nil?
+    PrcLib.info("'%s': '%s' created with id %s",
+                sObjectType, hParams[:student_name], object[:id])
+    object
+  end
+end
+
+# Declaring your data model and handlers.
+class Lorj::BaseDefinition # rubocop: disable Style/ClassAndModuleChildren
+  # We need to define the student object and the handler to use while we need to
+  # create it.
+  define_obj(:student,
+             # The function to call in the class Students
+             :create_e => :create_student,
+             # We use predefined call to the controller query
+             :query_e => :controller_query,
+             # We use predefined call to the controller get
+             :get_e => :controller_get,
+             # We use predefined call to the controller delete
+             :delete_e => :controller_delete
+            )
+
+  obj_needs :data, :student_name, :for => [:create_e], :mapping => :name
+end