lorj 0.2.0 → 1.0.0

data/lib/core/core_setup_encrypt.rb

@@ -0,0 +1,146 @@
+# (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 'highline/import'
+
+# 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 encrypt core functions.
+  class BaseDefinition
+    # internal runtime function for process call
+    # Get encrypted value hidden by *
+    #
+    # *parameters*:
+    #   - +sDesc+       : data description
+    #   - +default+     : encrypted default value
+    #   - +entropy+     : Entropy Hash
+    #
+    # *return*:
+    # - value : encrypted value.
+    #
+    # *raise*:
+    #
+    def _get_encrypt_key
+      # Checking key file used to encrypt/decrypt passwords
+      key_file = File.join(PrcLib.pdata_path, '.key')
+      if !File.exist?(key_file)
+        # Need to create a random key.
+        random_iv = OpenSSL::Cipher::Cipher.new('aes-256-cbc').random_iv
+        entr = {
+          :key => rand(36**10).to_s(36),
+          :salt => Time.now.to_i.to_s,
+          :iv => Base64.strict_encode64(random_iv)
+        }
+
+        Lorj.debug(2, "Writing '%s' key file", key_file)
+        File.open(key_file, 'w') do |out|
+          out.write(Base64.encode64(entr.to_yaml))
+        end
+      else
+        Lorj.debug(2, "Loading '%s' key file", key_file)
+        encoded_key = IO.read(key_file)
+        entr = YAML.load(Base64.decode64(encoded_key))
+      end
+      entr
+    end
+
+    # internal runtime function for process call
+    # Get encrypted value hidden by *
+    #
+    # *parameters*:
+    #   - +sDesc+       : data description
+    #   - +default+     : encrypted default value
+    #   - +entropy+     : Entropy Hash
+    #
+    # *return*:
+    # - value : encrypted value.
+    #
+    # *raise*:
+    #
+    def _get_encrypted_value_hidden(sDesc, enc_value, entr)
+      return '' if enc_value.nil?
+      value_hidden = ''
+      begin
+        value_hidden = '*' * Encryptor.decrypt(
+           :value => Base64.strict_decode64(enc_value),
+           :key => entr[:key],
+           :iv => Base64.strict_decode64(entr[:iv]),
+           :salt => entr[:salt]
+        ).length
+      rescue
+        Lorj.error('Unable to decrypt your %s. You will need to re-enter it.',
+                   sDesc)
+      else
+        value_hidden = format('[%s]', value_hidden)
+        PrcLib.message("'%s' is already set. If you want to keep it,"\
+                       ' just press Enter', sDesc)
+      end
+      value_hidden
+    end
+
+    # internal runtime function for process call
+    # Ask encrypted function executed by _ask
+    #
+    # *parameters*:
+    #   - +sDesc+       : data description
+    #   - +default+     : encrypted default value
+    #
+    # *return*:
+    # - value : encrypted value.
+    #
+    # *raise*:
+    #
+    def _ask_encrypted(sDesc, default)
+      entr = _get_encrypt_key
+
+      enc_value = default
+
+      value_hidden = _get_encrypted_value_hidden(sDesc, default, entr)
+
+      value_free = ''
+      while value_free == ''
+        # ask for encrypted data.
+        value_free = ask(format('Enter %s: [%s]', sDesc, value_hidden)) do |q|
+          q.echo = '*'
+        end
+        if value_free == '' && enc_value
+          value_free = Encryptor.decrypt(
+            :value => Base64.strict_decode64(enc_value),
+            :key => entr[:key],
+            :iv => Base64.strict_decode64(entr[:iv]),
+            :salt => entr[:salt]
+          )
+        else
+          PrcLib.message('%s cannot be empty.', sDesc) if value_free == ''
+        end
+      end
+      Base64.strict_encode64(
+         Encryptor.encrypt(
+            :value => value_free,
+            :key => entr[:key],
+            :iv => Base64.strict_decode64(entr[:iv]),
+            :salt => entr[:salt]
+         )
+      )
+    end
+  end
+end

data/lib/core/core_setup_init.rb

@@ -0,0 +1,229 @@
+# (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 'highline/import'
+require 'erb'
+
+# 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 process core functions.
+  class BaseDefinition
+    # Load /:setup/:ask_step section of the defaults.yaml
+    #
+    # See lib/core/core_model.rb
+    #
+    # * *Returns*:
+    #   - hash : setup data structure.
+    #
+    # * *Raises* :
+    #
+    def _setup_load
+      ask_steps = Lorj.defaults.get[:setup, :ask_step]
+      setup_steps = []
+      ask_steps.each do | value |
+        setup_steps << {
+          :desc => value[:desc],
+          :explanation => value[:explanation],
+          :pre_step_handler => value[:pre_step_function],
+          :order => [[]], # attributes in array of level/order
+          :post_step_handler => value[:post_step_function]
+        }
+      end
+      setup_steps
+    end
+
+    # check for any additional data to ask to the user
+    # thanks to the /:setup/:ask_step/<steps>/:add option of each steps
+    #
+    # * *Args* :
+    #   - setup_steps : Hash. setup data structure to update.
+    #                   It will update setup_steps:/:order 2 dimensions array
+    #
+    # * *Returns*:
+    #
+    # * *Raises* :
+    #
+    def _setup_check_additional(setup_steps)
+      setup_steps.each_index do | step |
+        value = setup_steps[step]
+        next unless value.rh_exist?(:add)
+
+        datas_to_add = value.rh_get(:add)
+        datas_to_add.each do | data_to_add |
+          order_array = setup_steps[step][:order]
+          next if _setup_attr_already_added?(order_array, data_to_add)
+
+          _setup_data_insert(setup_steps, data_to_add, step, order_array.length)
+        end
+      end
+    end
+
+    # Loop on object dependencies to determine the list of attributes to setup.
+    #
+    #
+    # * *Args* :
+    #   - setup_steps : Hash. setup data structure to update.
+    #                   It will update setup_steps:/:order 2 dimensions array
+    #
+    # * *Returns*:
+    #   - Nothing. But setup_steps is updated.
+    #
+    # * *Raises* :
+    #
+    def _setup_identify(sObjectType, setup_steps)
+      objs_to_inspect = [sObjectType]
+      inspected_objects = []
+
+      while objs_to_inspect.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)
+
+        object_type = objs_to_inspect.pop
+
+        Lorj.debug(1, "Checking '%s'", object_type)
+        attributes = PrcLib.model.meta_obj.rh_get(object_type,
+                                                  :params, :keys)
+        if attributes.nil?
+          Lorj.debug(1, "Warning! Object '%s' has no data/object needs. Check"\
+                        ' the process', object_type)
+          next
+        end
+        attributes.each do |attr_path, attr_params|
+          attr_name = KeyPath.new(attr_path).key
+          _setup_identify_obj_params(setup_steps,
+                                     inspected_objects, objs_to_inspect,
+                                     attr_name, attr_params)
+        end
+      end
+    end
+
+    # Internal setup function to identify data to ask
+    # Navigate through objects dependencies to determine the need.
+    def _setup_identify_obj_params(setup_steps,
+                                   inspected_objects, objs_to_inspect,
+                                   attr_name, attr_params)
+
+      attr_type = attr_params[:type]
+
+      case attr_type
+      when :data
+        return unless _setup_obj_param_is_data(setup_steps,
+                                               inspected_objects, attr_name)
+        inspected_objects << attr_name
+        return
+      when :CloudObject
+        return if objs_to_inspect.include?(attr_name) ||
+                  inspected_objects.include?(attr_name)
+        # New object to inspect
+        objs_to_inspect << attr_name
+      end
+    end
+
+    def _setup_display_step(setup_step, step)
+      Lorj.debug(2, 'Ask step %s:', step)
+      puts ANSI.bold(setup_step[:desc]) unless setup_step[:desc].nil?
+      begin
+        erb_msg = ANSI.yellow(erb(setup_step[:explanation]))
+      rescue => e
+        PrcLib.Error "setup step '%d/:explanation' : %s", step, e.message
+      end
+      puts format("%s\n\n", erb_msg) unless setup_step[:explanation].nil?
+    end
+
+    # internal setup function to display step information
+    #
+    # * *Args* :
+    #  - +data+    : data name to ask.
+    #  - +options+ : data options
+    #
+    # * *Returns*:
+    #  - +desc+ : Description of the data to ask.
+    #
+    # * *Raises* :
+    #
+    def _setup_display_data(data, options)
+      desc = format("'%s' value", data)
+
+      unless options[:explanation].nil?
+        begin
+          puts format('%s: %s',
+                      data,
+                      erb(options[:explanation]))
+        rescue => e
+          PrcLib.Error "setup key '%s/:explanation' : %s", data, e.message
+        end
+      end
+
+      begin
+        desc = erb(options[:desc]) unless options[:desc].nil?
+      rescue => e
+        PrcLib.Error "setup key '%s/:desc' : %s", data, e.message
+      end
+
+      desc
+    end
+
+    # internal setup core function which ask user to enter values.
+    # looping step by step and presenting sorted data to set.
+    #
+    # It execute pre-process if defined by:
+    # /:section/<section name>/<data>/:pre_step_function
+    #
+    # If pre-process returns true, end user interaction is canceled.
+    #
+    # * *Args* :
+    #  - +setup_steps+ : setup data structure.
+    #
+    # * *Returns*:
+    #
+    # * *Raises* :
+    #
+    def _setup_ask(setup_steps)
+      # Ask for user input
+      setup_steps.each_index do | iStep |
+        _setup_display_step(setup_step, iStep)
+
+        order_array = setup_steps[iStep][:order]
+
+        order_array.each_index do | iIndex |
+          Lorj.debug(2, 'Ask order %s:', iIndex)
+          order_array[iIndex].each do | data |
+            options = _get_meta_data(data)
+            options = {} if options.nil?
+
+            data_desc = _setup_display_data(data, options)
+
+            if options[:pre_step_function]
+              proc = options[:pre_step_function]
+              next unless @oForjProcess.method(proc).call(data)
+            end
+
+            _setup_ask_data(data_desc, data, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/core_setup_list.rb

@@ -0,0 +1,160 @@
+# (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 'highline/import'
+
+# 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 process core functions.
+  class BaseDefinition
+    # Internal setup function to build the list from a controller call.
+    #
+    # * *Args* :
+    #  - +obj_to_load+ : Object to get list from.
+    #  - +list_options+: list and validation options
+    #
+    # * *Returns*:
+    #   - Hash : list of possible values and default.
+    #     :default_value : Value pre-selected.
+    #     :list          : list of possible values
+    #
+    # * *Raises* :
+    #
+    def _setup_list_from_controller_call(obj_to_load, list_options)
+      PrcLib.message("Loading #{obj_to_load}.")
+
+      object = @object_data[obj_to_load, :ObjectData]
+      object = Create(obj_to_load) if object.nil?
+      return nil if object.nil?
+
+      params = ObjectData.new
+      params.add(object)
+      params << list_options[:query_params]
+
+      runtime_fail '%s: query_type => :controller_call '\
+                   'requires missing :query_call declaration'\
+                   ' (Controller function)',
+                   data if list_options[:query_call].nil?
+
+      proc = list_options[:query_call]
+      begin
+        list = @controller.method(proc).call(obj_to_load, params)
+      rescue => e
+        runtime_fail "Error during call of '%s':\n%s", proc, e.message
+      end
+      { :list => list, :default_value => nil }
+    end
+
+    # Internal setup function to build the list from a query call.
+    #
+    # * *Args* :
+    #  - +obj_to_load+ : Object to get list from.
+    #  - +list_options+: list and validation options
+    #
+    # * *Returns*:
+    #   - Hash : list of possible values and default.
+    #     :default_value : Value pre-selected.
+    #     :list          : list of possible values
+    #
+    # * *Raises* :
+    #
+    def _setup_list_from_query_call(obj_to_load, list_options)
+      PrcLib.message("Querying #{obj_to_load}.")
+
+      query_hash = list_options[:query_params]
+      query_hash = {} if query_hash.nil?
+
+      object_list = query(obj_to_load, query_hash)
+
+      list = []
+      object_list.each { | oElem | list << oElem[list_options[:value]] }
+
+      { :list => list.sort!, :default_value => nil }
+    end
+
+    def _setup_build_process_params(option_params, params)
+      return if option_params.nil?
+
+      option_params.each do | key, value |
+        match_res = value.match(/lorj::config\[(.*)\]/)
+        if match_res
+          extract = match_res[1].split(', ')
+          extract.map! { | v | v[1..-1].to_sym if v[0] == ':' }
+          params << { key => config[extract] }
+        else
+          params << { key => value }
+        end
+      end
+    end
+
+    # Internal setup function to build the list from a process call.
+    #
+    # * *Args* :
+    #  - +obj_to_load+ : Object to get list from.
+    #  - +list_options+: list and validation options
+    #
+    # * *Returns*:
+    #   - Hash : list of possible values and default.
+    #     :default_value : Value pre-selected.
+    #     :list          : list of possible values
+    #
+    # * *Raises* :
+    #
+    def _setup_list_from_process_call(obj_to_load, list_options)
+      runtime_fail '%s: query_type => :process_call'\
+                   ' requires missing :query_call declaration'\
+                   ' (Provider function)',
+                   data if list_options[:query_call].nil?
+      proc = list_options[:query_call]
+      obj_to_load = list_options[:object]
+      PrcLib.debug(2, "Running process '#{proc}' on '#{obj_to_load}'.")
+
+      # Building Process function attr_params parameter
+      params = ObjectData.new
+      params << { :default_value => default }
+
+      _setup_build_process_params(list_options[:query_params], params)
+
+      begin
+        proc_method = @process.method(proc)
+        result = proc_method.call(obj_to_load, params)
+      rescue => e
+        runtime_fail "Error during call of '%s':\n%s",
+                     proc, e.message
+      end
+
+      if result.is_a?(Hash)
+        if result[:list].nil? ||
+           !result[:list].is_a?(Array)
+          PrcLib.debug("Process function '%s' did not return an"\
+                       ' :list => Array of list_options.',
+                       list_options[:query_call])
+        end
+      else
+        PrcLib.debug("Process function '%s' did not return an"\
+                     ' Hash with :list and :default_value')
+        result = { :list => [], :default_value => nil }
+      end
+      result
+    end
+  end
+end