lorj 1.0.7 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cbe0901bbfa07d90519c83339a77a0e283e205d3
-  data.tar.gz: 813357cfb6091233c16d726148f31745a33bd358
+  metadata.gz: 7b230339c53324a35d70056924d04caf83361556
+  data.tar.gz: 7e40d7041f4999a803f625a850067199ed1296ab
 SHA512:
-  metadata.gz: dcd5cf66499c650e34f0551c43754fb162a6b6dc63dcd0aabec518bfef20d3649b3190ba6b561ef0de70d51b52be1ea6d679d97192496a92318ebc47fa90b66d
-  data.tar.gz: ceb1b16973daa3daaf3093f6093c5aa28d6f4e20639e2afa1133da21d931d4e3acbfd6bd7f6bd6daba2fcce068bbb7b42bad1e6fcc6f6a24f3e049503f495936
+  metadata.gz: 3c4117298308f75daf06230285ec3971e555315c876007f548a3a3207a201655f030f61c52e87ffcb18a9ac10308b9048ee3d1128faff26551da995b573454c5
+  data.tar.gz: b945fafa30d2f087c51a008ec3750d5f70fdb7e3bf05e5bbd161a4c073ff69fd466745c0324822d5be03be99094455ba9cf36942fc4d9ca399842a213bce1d70

data/lib/core/core_process_setup.rb

@@ -89,6 +89,15 @@ module Lorj
     # - :validate:          Regular expression to validate end user input
     #                       during setup.
     # - :list_values:       Additional options to get a list of possible values.
+    # - :post_step_function Function to call after data asked to the user.
+    #   This function must return a boolean:
+    #   - true : The data is accepted and setup will go further.
+    #   - false: The data is NOT accepted and setup will ask the data again.
+    #     setup will loop until the function is happy with (return true)
+    # - :pre_step_function  Function to call before data is asked to the user.
+    #   This function must return a boolean:
+    #   - true : setup will ask the data.
+    #   - false: setup will skip asking the data.
     #
     # For details or more options, see core_model.rb
     #

data/lib/core/core_setup_ask.rb

@@ -159,7 +159,7 @@ module Lorj
       default = result[:default_value] unless result[:default_value].nil?
 
       begin
-        default = erb(default)
+        default = erb(default) unless default.nil?
       rescue => e
         PrcLib.warning("ERB error with :%s/:default_value '%s'.\n%s",
                        data, result[:default_value], e.message)

data/lib/core/core_setup_init.rb

@@ -217,13 +217,13 @@ module Lorj
             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 @process.method(proc).call(data)
             end
 
+            data_desc = _setup_display_data(data, options)
+
             _setup_ask_data(data_desc, data, options)
           end
         end

data/lib/core_process/cloud/process/keypairs.rb

@@ -22,7 +22,7 @@
 class CloudProcess
   # KeyPair Create Process Handler
   # The process implemented is:
-  # * Check local SSH keypairs
+  # * Check local SSH keypairs with given ':keypair_name'
   # * Check remote keypair existence
   # * Compare and warn if needed.
   # * Import public key found if missing remotely and name it.
@@ -40,56 +40,120 @@ class CloudProcess
   #
   def forj_get_or_create_keypair(sCloudObj, hParams)
     keypair_name = hParams[:keypair_name]
-    # setup has configured and copied the appropriate key to forj keypairs.
-
-    loc_kpair = keypair_detect(keypair_name,
-                               File.expand_path(hParams[:keypair_path]))
-
-    private_key_file = File.join(loc_kpair[:keypair_path],
-                                 loc_kpair[:private_key_name])
-    public_key_file = File.join(loc_kpair[:keypair_path],
-                                loc_kpair[:public_key_name])
-
-    PrcLib.info("Found openssh private key file '%s'.",
-                private_key_file) if loc_kpair[:private_key_exist?]
-    PrcLib.info("Found openssh public key file '%s'.",
-                public_key_file) if loc_kpair[:public_key_exist?]
-
     PrcLib.state("Searching for keypair '%s'", keypair_name)
 
-    keypairs = forj_query_keypair(sCloudObj,
-                                  { :name => keypair_name }, hParams)
-
-    if keypairs.length == 0
+    keypair = forj_get_keypair(sCloudObj, keypair_name, hParams)
+    if keypair.empty?
+      loc_kpair = keypair_detect(keypair_name, hParams[:keypair_path],
+                                 hParams[:keypair_base])
       keypair = keypair_import(hParams, loc_kpair)
     else
-      keypair = keypairs[0]
-      keypair[:coherent] = coherent_keypair?(loc_kpair, keypair)
-      # Adding information about key files.
-    end
-    if keypair[:coherent]
-      keypair[:private_key_name] = loc_kpair[:private_key_name]
-      keypair[:public_key_name] = loc_kpair[:public_key_name]
-      keypair[:keypair_path] = loc_kpair[:keypair_path]
+      keypair_display(keypair)
     end
     keypair
   end
 
-  def forj_query_keypair(sCloudObj, sQuery, hParams)
-    key_name = hParams[:keypair_name]
+  # Query cloud keypairs and check coherence with local files
+  # of same name in forj files located by :keypair_path
+  def forj_query_keypairs(sCloudObj, sQuery, hParams)
+    keypair_path = File.expand_path(hParams[:keypair_path])
+    keypair_base = File.expand_path(hParams[:keypair_base])
+
     ssl_error_obj = SSLErrorMgt.new
     begin
-      #  list = controller_query(sCloudObj, sQuery)
-      #  query_single(sCloudObj, list, sQuery, key_name)
-      query_single(sCloudObj, sQuery, key_name)
+      keypairs = controller_query(sCloudObj, sQuery)
     rescue => e
       retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
     end
+    # Looping on keypairs to identify if they have a valid local ssh key.
+    keypairs.each do |keypair|
+      loc_kpair = keypair_detect(keypair_name, keypair_path, keypair_base)
+      keypair_files_detected(keypair, loc_kpair)
+    end
+    keypairs
+  end
+
+  # Get cloud keypair and check coherence with local files
+  # of same name in forj files
+  def forj_get_keypair(sCloudObj, keypair_name, hParams)
+    ssl_error_obj = SSLErrorMgt.new
+    begin
+      keypair = controller_get(sCloudObj, keypair_name)
+    rescue => e
+      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
+    end
+
+    keypair_path = File.expand_path(hParams[:keypair_path])
+    loc_kpair = keypair_detect(keypair_name, keypair_path, keypair_name)
+    keypair_files_detected(keypair, loc_kpair) unless keypair.empty?
+    keypair
   end
 end
 
+# ************************************ keypairs Object
+# Identify keypairs
+class Lorj::BaseDefinition
+  define_obj(:keypairs,
+
+             :create_e => :forj_get_or_create_keypair,
+             :query_e => :forj_query_keypairs,
+             :get_e => :forj_get_keypair
+             #         :delete_e   => :forj_delete_keypair
+             )
+
+  obj_needs :CloudObject,  :compute_connection
+  obj_needs :data,         :keypair_name,        :for => [:create_e]
+  obj_needs :data,         :keypair_path
+  obj_needs :data,         :keypair_base
+
+  # By default optional. But required by the import case if needed.
+  obj_needs_optional
+  obj_needs :data,         :public_key,          :for => [:create_e]
+
+  def_attribute :public_key
+end
+
 # Keypair management: Internal process functions
 class CloudProcess
+  # Function to display information about keypair object found.
+  #
+  def keypair_display(keypair)
+    PrcLib.info("Found keypair '%s'.", keypair[:name])
+
+    private_key_file = File.join(keypair[:keypair_path],
+                                 keypair[:private_key_name])
+    public_key_file = File.join(keypair[:keypair_path],
+                                keypair[:public_key_name])
+
+    PrcLib.info("Found openssh private key file '%s'.",
+                private_key_file) if keypair[:private_key_exist?]
+    PrcLib.info("Found openssh public key file '%s'.",
+                public_key_file) if keypair[:public_key_exist?]
+    if keypair[:coherent]
+      PrcLib.info("keypair '%s' local files are coherent with keypair in "\
+                  'your cloud service. You will be able to use your local '\
+                  'keys to connect to any box configured with this keypair '\
+                  'name, over SSH.', keypair[:name])
+    else
+      PrcLib.warning("Your local public key file '%s' is incoherent with "\
+                     "public key attached to the keypair '%s' in your cloud."\
+                     " You won't be able to access your box with this keypair."\
+                     "\nPublic key found in the cloud:\n%s",
+                     public_key_file, keypair[:name], keypair[:public_key])
+    end
+  end
+
+  # Function to update a keypair object with ssh files found in :keypair_path
+  #
+  def keypair_files_detected(keypair, loc_kpair)
+    keypair[:private_key_exist?] = loc_kpair[:private_key_exist?]
+    keypair[:public_key_exist?] = loc_kpair[:public_key_exist?]
+    keypair[:private_key_name] = loc_kpair[:private_key_name]
+    keypair[:public_key_name] = loc_kpair[:public_key_name]
+    keypair[:keypair_path] = loc_kpair[:keypair_path]
+    keypair[:coherent] = coherent_keypair?(loc_kpair, keypair)
+  end
+
   def keypair_import(hParams, loc_kpair)
     PrcLib.fatal(1, "Unable to import keypair '%s'. "\
                     'Public key file is not found. '\
@@ -100,22 +164,20 @@ class CloudProcess
                                 loc_kpair[:public_key_name])
 
     begin
-      config[:public_key] = File.read(public_key_file)
+      public_key = File.read(public_key_file)
     rescue => e
       PrcLib.fatal(1, "Unable to import keypair '%s'. '%s' is "\
                       "unreadable.\n%s", hParams[:keypair_name],
                    loc_kpair[:public_key_file],
                    e.message)
     end
-    keypair = create_keypair(:keypairs, hParams)
+    keypair = create_keypair(:keypairs, :public_key => public_key)
 
     return nil if keypair.nil?
 
-    if !loc_kpair[:private_key_exist?]
-      keypair[:coherent] = false
-    else
-      keypair[:coherent] = true
-    end
+    # Adding information about SSH key files.
+    keypair_files_detected(keypair, loc_kpair)
+
     keypair
   end
 
@@ -124,7 +186,7 @@ class CloudProcess
     PrcLib.state("Importing keypair '%s'", key_name)
     ssl_error_obj = SSLErrorMgt.new
     begin
-      keypair = controller_create(sCloudObj)
+      keypair = controller_create(sCloudObj, hParams)
       PrcLib.info("Keypair '%s' imported.", keypair[:name])
     rescue StandardError => e
       retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
@@ -136,9 +198,18 @@ class CloudProcess
   # Build keypair data information structure with files found in
   # local filesystem. Take care of priv with or without .pem
   # and pubkey with pub.
-  def keypair_detect(keypair_name, key_fullpath)
-    key_basename = File.basename(key_fullpath)
-    key_path = File.expand_path(File.dirname(key_fullpath))
+  # :keypair_path data settings is changing to become just a path to
+  # the keypair files, the base keypair.
+  # Which will introduce a :keypair_base in the setup.
+  def keypair_detect(keypair_name, key_fullpath, key_basename = nil)
+    # When uses key_basename, we switch to the new model
+    # using :keypair_path and :keypair_base in setup
+    if key_basename.nil?
+      key_basename = File.basename(key_fullpath)
+      key_path = File.expand_path(File.dirname(key_fullpath))
+    else
+      key_path = File.expand_path(key_fullpath)
+    end
 
     obj_match = key_basename.match(/^(.*?)(\.pem|\.pub)?$/)
     key_basename = obj_match[1]
@@ -184,15 +255,6 @@ class CloudProcess
     [found_ext, files]
   end
 
-  def forj_get_keypair(sCloudObj, sName, _hParams)
-    ssl_error_obj = SSLErrorMgt.new
-    begin
-      controller_get(sCloudObj, sName)
-    rescue => e
-      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
-    end
-  end
-
   def get_keypairs_path(hParams, hKeys)
     keypair_name = hParams[:keypair_name]
 
@@ -225,8 +287,6 @@ class CloudProcess
   # - coherent : Boolean. True if same public key.
   def coherent_keypair?(loc_kpair, keypair)
     # send keypairs by parameter
-
-    keypair_name = loc_kpair[:keypair_name]
     is_coherent = false
 
     pub_keypair = keypair[:public_key]
@@ -241,17 +301,7 @@ class CloudProcess
                     loc_kpair[:public_key_file], e.message)
       else
         if loc_pubkey.split(' ')[1].strip == pub_keypair.split(' ')[1].strip
-          PrcLib.info("keypair '%s' local files are coherent with keypair in "\
-                      'your cloud service. You will be able to connect to '\
-                      'your box over SSH.', keypair_name)
           is_coherent = true
-        else
-          PrcLib.warning("Your local keypair file '%s' are incoherent with "\
-                         "public key '%s' found in your cloud. You won't be "\
-                         "able to access your box with this keypair.\nPublic "\
-                         "key found in the cloud:\n%s",
-                         loc_kpair[:public_key_file], keypair_name,
-                         keypair[:public_key])
         end
       end
     else
@@ -261,24 +311,3 @@ class CloudProcess
     is_coherent
   end
 end
-
-# ************************************ keypairs Object
-# Identify keypairs
-class Lorj::BaseDefinition
-  define_obj(:keypairs,
-
-             :create_e => :forj_get_or_create_keypair,
-             :query_e => :forj_query_keypair,
-             :get_e => :forj_get_keypair
-             #         :delete_e   => :forj_delete_keypair
-             )
-
-  obj_needs :CloudObject,  :compute_connection
-  obj_needs :data,         :keypair_name,        :for => [:create_e]
-  obj_needs :data,         :keypair_path,        :for => [:create_e]
-
-  obj_needs_optional
-  obj_needs :data,         :public_key,          :for => [:create_e]
-
-  def_attribute :public_key
-end

data/lib/core_process/cloud/process/public_ip.rb

@@ -34,6 +34,7 @@ class CloudProcess
     end
   end
 
+  # Function to query the list of addresses for one server
   def forj_query_public_address(sCloudObj, sQuery, hParams)
     server_name = hParams[:server, :name]
     ssl_error_obj = SSLErrorMgt.new
@@ -54,6 +55,7 @@ class CloudProcess
     end
   end
 
+  # Function to get the IP address
   def forj_get_public_address(sCloudObj, sId, _hParams)
     ssl_error_obj = SSLErrorMgt.new
     begin

data/lib/lorj/version.rb

@@ -16,5 +16,5 @@
 
 # Lorj version
 module Lorj
-  VERSION = '1.0.7'
+  VERSION = '1.0.8'
 end

data/lib/lorj_account.rb

@@ -161,7 +161,9 @@ module Lorj
     #   - +options+ : Options for get:
     #     - +:section+ : Get will use this section name instead of searching it.
     #     - +:names+   : array of layers name to exclusively get data.
+    #     - +:name+    : layer name to exclusively get data.
     #     - +:indexes+ : array of layers index to exclusively get data.
+    #     - +:index+   : layer index to exclusively get data.
     #       If neither :name or :index is set, get will search
     #       data on all predefined layers, first found.
     # * *Returns* :
@@ -175,9 +177,9 @@ module Lorj
       section = options[:section]
       section = Lorj.data.first_section(key) if section.nil?
 
-      options = { :keys => [key], :section => section }
+      options = options.merge(:keys => [key], :section => section)
 
-      indexes = _identify_array_indexes(options, exclusive?(key, section))
+      indexes = _identify_indexes(options, exclusive?(key, section))
       names = []
       indexes.each { |index| names << @config_layers[index][:name] }
 
@@ -205,11 +207,13 @@ module Lorj
     #   - +options+ : possible options:
     #     - +:section+ : Force to use a specific section name.
     #     - +:names+   : array of layers name to exclusively get data.
+    #     - +:name+    : layer name to exclusively get data.
     #     - +:indexes+ : array of layers index to exclusively get data.
+    #     - +:index+   : layer index to exclusively get data.
     #       If neither :name or :index is set, get will search data on all
     #       predefined layers, first found, first listed.
     # * *Returns* :
-    #   - key value.
+    #   - config name found.
     # * *Raises* :
     #   Nothing
     def where?(key, options = {})
@@ -217,9 +221,9 @@ module Lorj
       options = {} unless options.is_a?(Hash)
 
       section = options[:section]
-      section = Lorj.defaults.get_meta_section(key) if section.nil?
+      section = Lorj.data.first_section(key) if section.nil?
 
-      indexes = _identify_array_indexes(options, exclusive?(key, section))
+      indexes = _identify_indexes(options, exclusive?(key, section))
 
       names = []
       indexes.each { |index| names << @config_layers[index][:name] }
@@ -242,17 +246,20 @@ module Lorj
     #   - +options+ : possible options:
     #     - +:section+ : Force to use a specific section name.
     #     - +:names+   : array of layers name to exclusively get data.
+    #     - +:name+    : layer name to exclusively get data.
     #     - +:indexes+ : array of layers index to exclusively get data.
+    #     - +:index+   : layer index to exclusively get data.
     #       If neither :name or :index is set, get will search data on all
     #       predefined layers, first found.
     #
     # * *Returns* :
-    #   - 'runtime'       : if found in runtime.
-    #   - '<AccountName>' : if found in the Account data structure.
-    #   - 'local'         : if found in the local configuration file.
-    #                       Usually ~/.forj/config.yaml
-    #   - 'default'       : if found in the Application default
-    #                       (File 'defaults.yaml') (class Default)
+    #   - true : if found in runtime.
+    #   - true : if found in the Account data structure.
+    #   - true : if found in the local configuration file.
+    #     Usually ~/.forj/config.yaml
+    #   - true : if found in the Application default
+    #     (File 'defaults.yaml') (class Default)
+    #   - false otherwise.
     # * *Raises* :
     #   Nothing
     def exist?(key, options = nil)
@@ -261,9 +268,9 @@ module Lorj
 
       section = options[:section]
       section = Lorj.data.first_section(key) if section.nil?
-      options = { :keys => [key], :section => section }
+      options = options.merge(:keys => [key], :section => section)
 
-      indexes = _identify_array_indexes(options, exclusive?(key, section))
+      indexes = _identify_indexes(options, exclusive?(key, section))
 
       names = []
       indexes.each { |index| names << @config_layers[index][:name] }
@@ -550,6 +557,8 @@ module Lorj
       indexes = exclusive_indexes(account_exclusive)
       indexes = [index] if !index.nil? && indexes.include?(index)
 
+      return _identify_array_indexes(options, account_exclusive) if index.nil?
+
       options[:indexes] = indexes
       indexes
     end

data/lib/prc_core_config.rb

@@ -424,7 +424,7 @@ module PRC
       return nil if keys.length == 0 || keys[0].nil? || config_layers[0].nil?
 
       config_layers.each_index do |index|
-        config = @config_layers[index][:config]
+        config = config_layers[index][:config]
 
         data_options = options.clone
         data_options.delete_if do |key|

data/spec/04_prc_core_config_spec.rb

@@ -57,6 +57,10 @@ describe 'class: PRC::CoreConfig,' do
           initialize_layers(layers)
         end
 
+        def iexist?(options)
+          p_exist?(options)
+        end
+
         def set(options)
           p_set(options)
         end
@@ -77,6 +81,26 @@ describe 'class: PRC::CoreConfig,' do
       expect(@config.exist?(:test)).to equal(true)
     end
 
+    it 'config.p_exist?(:keys => [:test]) returns true' do
+      expect(@config.iexist?(:keys => [:test])).to equal(true)
+    end
+
+    it 'config.p_exist?(:keys => [:test], :name => "runtime") returns false' do
+      expect(@config.iexist?(:keys => [:test],
+                             :name => 'runtime')).to equal(false)
+    end
+
+    it 'config.p_exist?(:keys => [:test], :names => ["runtime"])'\
+       ' returns false' do
+      expect(@config.iexist?(:keys => [:test],
+                             :names => ['runtime'])).to equal(false)
+    end
+
+    it 'config.p_exist?(:keys => [:test], :names => ["local"]) returns true' do
+      expect(@config.iexist?(:keys => [:test],
+                             :names => ['local'])).to equal(true)
+    end
+
     it 'config.exist?(:test2, :test) returns true' do
       expect(@config.exist?(:test2, :test)).to equal(true)
     end

data/spec/12_lorj_account_spec.rb

@@ -172,11 +172,35 @@ describe 'class: Lorj::Account,' do
       expect(@account.where?(:keypair_name)).to eq(%w(account local default))
     end
 
+    it "account.set(:keypair_name, 'nova_test3') return "\
+       " 'nova_test3'" do
+      expect(@account.set(:keypair_name, 'nova_test3')).to eq('nova_test3')
+      expect(@account.where?(:keypair_name)).to eq(%w(runtime account
+                                                      local default))
+    end
+
     it "account.get(:keypair_name, :name => 'account') return 'nova_test2'" do
-      expect(@account.get(:keypair_name,
+      expect(@account.get(:keypair_name, nil,
                           :name => 'account')).to eq('nova_test2')
     end
 
+    it "account.get(:keypair_name, :names => ['account']) return "\
+       "'nova_test2'" do
+      expect(@account.get(:keypair_name, nil,
+                          :names => ['account'])).to eq('nova_test2')
+    end
+
+    it "account.get(:keypair_name, :name => 'runtime') return 'nova_test3'" do
+      expect(@account.get(:keypair_name, nil,
+                          :name => 'runtime')).to eq('nova_test3')
+    end
+
+    it "account.get(:keypair_name, :names => ['runtime']) return "\
+       "'nova_test3'" do
+      expect(@account.get(:keypair_name, nil,
+                          :names => ['runtime'])).to eq('nova_test3')
+    end
+
     it 'account.ac_save return true' do
       expect(@account.ac_save).to equal(true)
     end
@@ -193,7 +217,7 @@ describe 'class: Lorj::Account,' do
 
     it "account.get(:keypair_name, :name => 'account') return "\
        "saved 'nova_test2'" do
-      expect(@account.get(:keypair_name,
+      expect(@account.get(:keypair_name, nil,
                           :name => 'account')).to eq('nova_test2')
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lorj
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.8
 platform: ruby
 authors:
 - forj team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-24 00:00:00.000000000 Z
+date: 2015-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler