lorj 1.0.3 → 1.0.4

data/lib/providers/openstack/openstack_process.rb

@@ -0,0 +1,26 @@
+# 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.
+
+# Specific openstack process added to the application process.
+class OpenstackProcess
+  def openstack_get_tenant(sObjectType, hParams)
+    tenant_name = hParams[:tenant]
+    query = { :name => tenant_name }
+    PrcLib.state("searching for tenant '%s'", tenant_name)
+    list = query_single(sObjectType, query, tenant_name)
+    return list[0] if list.length > 0
+  end
+end

data/lib/providers/openstack/openstack_query.rb

@@ -0,0 +1,96 @@
+# 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.
+
+# Defined Openstack object query.
+class OpenstackController
+  def self.def_basic_query(connection, name, property_name = nil)
+    property_name = property_name.nil? ? name.to_s + 's' : property_name.to_s
+
+    define_method("query_#{name}") do |hParams, _query|
+      required?(hParams, connection)
+      hParams[connection].send(property_name).all
+    end
+  end
+
+  # Implementation of API supporting query Hash
+  def self.def_simple_query(connection, name, property_name = nil)
+    property_name = property_name.nil? ? name.to_s + 's' : property_name.to_s
+
+    define_method("query_#{name}") do |hParams, query|
+      required?(hParams, connection)
+      hParams[connection].send(property_name).all query
+    end
+  end
+
+  # Implementation of API NOT supporting query Hash
+  # The function will filter itself.
+  def self.def_complex_query(connection, name, property_name = nil)
+    property_name = property_name.nil? ? name.to_s + 's' : property_name.to_s
+
+    define_method("query_#{name}") do |hParams, query|
+      required?(hParams, connection)
+
+      key_pairs = hParams[connection].send(property_name).all
+      results = []
+      key_pairs.each do |sElem|
+        selected = true
+        attributes = sElem.instance_variable_get(:@attributes)
+        query.each do |key, value|
+          if attributes[key] != value
+            selected = false
+            break
+          end
+        end
+        results.push sElem if selected
+      end
+      results
+    end
+  end
+
+  def_simple_query :compute_connection, :tenant
+
+  def_simple_query :compute_connection, :image
+
+  def_simple_query :compute_connection, :flavor
+
+  def_simple_query :compute_connection, :server
+
+  def_simple_query :network_connection, :network
+
+  def_simple_query :network_connection, :subnetwork, :subnets
+
+  def_simple_query :network_connection, :router
+
+  def_simple_query :network_connection, :port
+
+  # def_simple_query :network_connection, :security_groups, :security_groups
+
+  def_simple_query :network_connection, :rule, :security_group_rules
+
+  def_complex_query :compute_connection, :keypairs, :key_pairs
+
+  def_complex_query :compute_connection, :public_ip, :addresses
+
+  def_complex_query :compute_connection, :tenants, :tenants
+
+  def query_security_groups(hParams, query)
+    required?(hParams, :network_connection)
+    required?(hParams, :tenants)
+
+    query[:tenant_id] = hParams[:tenants].id
+    hParams[:network_connection].send(:security_groups).all query
+  end
+end

data/lib/providers/openstack/openstack_update.rb

@@ -0,0 +1,35 @@
+# 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 Openstack update controller
+class OpenstackController
+  def update_router(obj_to_save, _hParams)
+    router = obj_to_save[:object]
+    # The optional external_gateway_info must be a The network_id for the
+    # external gateway. It cannot be a Hash
+    # See API : http://developer.openstack.org/api-ref-networking-v2.html
+    router.external_gateway_info = router.external_gateway_info['network_id']
+    # Save will restore the Hash.
+    begin
+      router.save
+      true
+    rescue => e
+      Lorj.error "OpenStack: Router save error.\n%s\n%s",
+                 e.message, e.backtrace.join("\n")
+      false
+    end
+  end
+end

data/lib/rh.rb

@@ -18,6 +18,12 @@
 require 'rubygems'
 require 'yaml'
 
+# Adding rh_clone at object level. This be able to use a generic rh_clone
+# redefined per object Hash and Array.
+class Object
+  alias_method :rh_clone, :clone
+end
+
 # Recursive Hash added to the Hash class
 class Hash
   # Recursive Hash deep level found counter
@@ -125,6 +131,8 @@ class Hash
   #   # it is like searching for nothing...
   #   yVal.rh_exist? => nil
   def rh_exist?(*p)
+    p = p.flatten
+
     return nil if p.length == 0
 
     count = p.length
@@ -283,8 +291,8 @@ class Hash
   #                                         'text' => 'blabla' },
   #                             'test5' => 'test' }}
   #
-  #  rh_key_to_symbol(1) return no diff
-  #  rh_key_to_symbol(2) return "test5" is replaced by :test5
+  #  hdata.rh_key_to_symbol(1) return no diff
+  #  hdata.rh_key_to_symbol(2) return "test5" is replaced by :test5
   #  # hdata = { :test => { :test2 => { :test5 => :test,
   #  #                                  'text' => 'blabla' },
   #  #                      :test5 => 'test' }}
@@ -322,10 +330,10 @@ class Hash
   #                                         'text' => 'blabla' },
   #                             'test5' => 'test' }}
   #
-  #  rh_key_to_symbol?(1) return false
-  #  rh_key_to_symbol?(2) return true
-  #  rh_key_to_symbol?(3) return true
-  #  rh_key_to_symbol?(4) return true
+  #  hdata.rh_key_to_symbol?(1) return false
+  #  hdata.rh_key_to_symbol?(2) return true
+  #  hdata.rh_key_to_symbol?(3) return true
+  #  hdata.rh_key_to_symbol?(4) return true
   def rh_key_to_symbol?(levels = 1)
     each do |key, value|
       return true if key.is_a?(String)
@@ -338,4 +346,81 @@ class Hash
     end
     false
   end
+
+  # return an exact clone of the recursive Array and Hash contents.
+  #
+  # * *Args*    :
+  #
+  # * *Returns* :
+  #   - Recursive Array/Hash cloned. Other kind of objects are kept referenced.
+  # * *Raises* :
+  #   Nothing
+  #
+  # examples:
+  #  hdata = { :test => { :test2 => { :test5 => :test,
+  #                                   'text' => 'blabla' },
+  #                       'test5' => 'test' },
+  #            :array => [{ :test => :value1 }, 2, { :test => :value3 }]}
+  #
+  #  hclone = hdata.rh_clone
+  #  hclone[:test] = "test"
+  #  hdata[:test] == { :test2 => { :test5 => :test,'text' => 'blabla' }
+  #  # => true
+  #  hclone[:array].pop
+  #  hdata[:array].length != hclone[:array].length
+  #  # => true
+  #  hclone[:array][0][:test] = "value2"
+  #  hdata[:array][0][:test] != hclone[:array][0][:test]
+  #  # => true
+  def rh_clone
+    result = {}
+    each do |key, value|
+      if [Array, Hash].include?(value.class)
+        result[key] = value.rh_clone
+      else
+        result[key] = value
+      end
+    end
+    result
+  end
+end
+
+# Defines rh_clone for Array
+class Array
+  # return an exact clone of the recursive Array and Hash contents.
+  #
+  # * *Args*    :
+  #
+  # * *Returns* :
+  #   - Recursive Array/Hash cloned.
+  # * *Raises* :
+  #   Nothing
+  #
+  # examples:
+  #  hdata = { :test => { :test2 => { :test5 => :test,
+  #                                   'text' => 'blabla' },
+  #                       'test5' => 'test' },
+  #            :array => [{ :test => :value1 }, 2, { :test => :value3 }]}
+  #
+  #  hclone = hdata.rh_clone
+  #  hclone[:test] = "test"
+  #  hdata[:test] == { :test2 => { :test5 => :test,'text' => 'blabla' }
+  #  # => true
+  #  hclone[:array].pop
+  #  hdata[:array].length != hclone[:array].length
+  #  # => true
+  #  hclone[:array][0][:test] = "value2"
+  #  hdata[:array][0][:test] != hclone[:array][0][:test]
+  #  # => true
+  def rh_clone
+    result = []
+    each do |value|
+      begin
+        result << value.rh_clone
+      rescue
+        result << value
+      end
+    end
+    result
+  end
 end

data/lorj-spec/defaults.yaml

@@ -14,17 +14,23 @@
 
 # Defaults yaml file used for rspec.
 :default:
-   :maestro_url: http://example.org
-   :keypair_name: default_key
-   :data: None
-
+  :maestro_url: http://example.org
+  :keypair_name: default_key
+  :data: None
 :description:
-   :FORJ_HPC: Testing extra application default value.
-
+  :FORJ_HPC: Testing extra application default value.
+:setup:
+  - :desc: 'Step 1'
+    :explanation: |-
+      My complete explanation is in
+      multiline <%= config['text'] %>
+  - :desc: 'Step 2'
+    :add:
+     - :data
 :sections:
-   :credentials:
-      :keypair_name:
-      :data:
-        :account_exclusive: true
-   :maestro:
-      :maestro_url:
+  :credentials:
+    :keypair_name:
+    :data:
+      :account_exclusive: true
+  :maestro:
+    :maestro_url:

data/lorj.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.1.0'
+  spec.add_development_dependency 'rubocop', '>= 0.29.0'
   spec.add_development_dependency 'byebug' unless less_than_two
   spec.rdoc_options << \
     '--title Lorj - The Process Controllers framework system' << \

data/spec/01_hash_rh_spec.rb

@@ -15,11 +15,13 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
-$LOAD_PATH << File.join('..', 'lib')
+#  require 'byebug'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 
 require 'rh'
 
-describe 'Recursive Hash extension,' do
+describe 'Recursive Hash/Array extension,' do
   context "With { :test => {:test2 => 'value1', :test3 => 'value2'},"\
           ":test4 => 'value3'}" do
     before(:all) do
@@ -196,6 +198,43 @@ describe 'Recursive Hash extension,' do
       expect(@hdata).to eq({})
     end
   end
+
+  context "With hdata = { :test => { :test2 => { :test5 => :test,\n"\
+          "                                        'text' => 'blabla' },\n"\
+          "                            'test5' => 'test' },\n"\
+          '                 :array => [{ :test => :value1 }, '\
+          '2, { :test => :value3 }]}' do
+    before(:all) do
+      @hdata = { :test => { :test2 => { :test5 => :test,
+                                        'text' => 'blabla' },
+                            'test5' => 'test' },
+                 :array => [{ :test => :value1 }, 2, { :test => :value3 }]
+               }
+    end
+    it 'rh_clone is done without error' do
+      expect { @hdata.rh_clone }.to_not raise_error
+    end
+    it 'hclone[:test] = "test" => hdata[:test] != hclone[:test]' do
+      hclone = @hdata.rh_clone
+      hclone[:test] = 'test'
+      expect(@hdata[:test]).to eq(:test2 => { :test5 => :test,
+                                              'text' => 'blabla' },
+                                  'test5' => 'test')
+    end
+    it 'hclone[:array].pop => hdata[:array].length != hclone[:array].length' do
+      hclone = @hdata.rh_clone
+      hclone[:array].pop
+      expect(@hdata[:array].length).not_to eq(hclone[:array].length)
+    end
+
+    it 'hclone[:array][0][:test] = "value2" '\
+       '=> hdata[:array][0][:test] != hclone[:array][0][:test]' do
+      hclone = @hdata.rh_clone
+      hclone[:array][0][:test] = 'value2'
+      expect(@hdata[:array][0][:test]).to eq(:value1)
+    end
+  end
+
   context 'With hdata = { :test => { :test2 => { :test5 => :test,'\
           "'text' => 'blabla' },"\
           "'test5' => 'test' }}" do

data/spec/02_prc_base_config_spec.rb

@@ -17,7 +17,7 @@
 
 # require 'byebug'
 
-$LOAD_PATH << File.join('..', 'lib')
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 
 require 'rh.rb'
 require 'prc.rb'

data/spec/03_prc_section_config_spec.rb

@@ -17,7 +17,7 @@
 
 # require 'byebug'
 
-$LOAD_PATH << File.join('..', 'lib')
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 
 require 'rh.rb'
 require 'prc.rb'

data/spec/04_prc_core_config_spec.rb

@@ -17,7 +17,7 @@
 
 #  require 'byebug'
 
-$LOAD_PATH << File.join('..', 'lib')
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 
 require 'rh.rb'
 require 'prc.rb'
@@ -41,13 +41,14 @@ describe 'class: PRC::CoreConfig,' do
     end
   end
 
-  context 'from a child class, with local layer set to :test => :found_local'\
-          ' and runtime layer' do
+  context 'from a child class, with local layer set to :test => :found_local, '\
+          ':test2 => {:test => :subhash} and runtime layer' do
     before(:all) do
       # Child class definition for rSpec.
       class Test1 < PRC::CoreConfig
         def initialize
-          local = PRC::BaseConfig.new(:test => :found_local)
+          local = PRC::BaseConfig.new(:test => :found_local,
+                                      :test2 => { :test => :subhash })
           layers = []
           layers << PRC::CoreConfig.define_layer(:name => 'local',
                                                  :config => local)
@@ -55,6 +56,14 @@ describe 'class: PRC::CoreConfig,' do
 
           initialize_layers(layers)
         end
+
+        def set(options)
+          p_set(options)
+        end
+
+        def get(options)
+          p_get(options)
+        end
       end
       @config = Test1.new
     end
@@ -64,10 +73,26 @@ describe 'class: PRC::CoreConfig,' do
       expect(@config.layers).to eq(%w(runtime local))
     end
 
+    it 'config.exist?(:test) returns true' do
+      expect(@config.exist?(:test)).to equal(true)
+    end
+
+    it 'config.exist?(:test2, :test) returns true' do
+      expect(@config.exist?(:test2, :test)).to equal(true)
+    end
+
     it 'config.where?(:test) should be ["local"]' do
       expect(@config.where?(:test)).to eq(['local'])
     end
 
+    it 'config.where?(:test2) should be ["local"]' do
+      expect(@config.where?(:test2)).to eq(['local'])
+    end
+
+    it 'config.where?(:test2, :test) should be ["local"]' do
+      expect(@config.where?(:test2, :test)).to eq(['local'])
+    end
+
     it 'config.[:test] = :where set in "runtime".' do
       expect(@config[:test] = :where).to eq(:where)
       expect(@config.where?(:test)).to eq(%w(runtime local))
@@ -131,5 +156,124 @@ describe 'class: PRC::CoreConfig,' do
       expect(@config.layer_remove(:name => 'runtime')).to equal(nil)
       expect(@config.layers).to eq(%w(runtime local))
     end
+
+    it 'a child set(keys, value, name => "local") works.' do
+      value = { :data1 => 'test_data1', :data2 => 'test_data2' }
+      expect(@config.set(:keys => [:merge1],
+                         :value => value,
+                         :name => 'local')).to eq(value)
+      expect(@config.where?(:merge1)).to eq(%w(local))
+    end
+
+    it 'a child set(keys, value, names => ["local"]) works '\
+       'but set in runtime. :names is ignored.' do
+      value = { :data1 => 'test_data1', :data2 => 'test_data3' }
+      expect(@config.set(:keys => [:merge1],
+                         :value => value,
+                         :names => ['local'])).to eq(value)
+      expect(@config.where?(:merge1)).to eq(%w(runtime local))
+    end
+
+    it 'a child set(keys, value, name => "runtime") works.' do
+      value = { :data2 => 'value_runtime', :test_runtime => true }
+      expect(@config.set(:keys => [:merge1],
+                         :value => value,
+                         :name => 'runtime')).to eq(value)
+      expect(@config.where?(:merge1)).to eq(%w(runtime local))
+      expect(@config[:merge1]).to eq(value)
+    end
+
+    it 'a child get(keys, name) can do merge '\
+       'even with only one layer selected.' do
+      value_local = { :data1 => 'test_data1', :data2 => 'test_data2' }
+      expect(@config.get(:keys => [:merge1], :merge => true,
+                         :names => ['local'])).to eq(value_local)
+      value_runtime = { :data2 => 'value_runtime', :test_runtime => true }
+      expect(@config.get(:keys => [:merge1], :merge => true,
+                         :names => ['runtime'])).to eq(value_runtime)
+    end
+
+    context "with config[:merge1] = {:data2 => {:test_runtime => true} }\n"\
+            'and local: :merge1: => {:data1: test_data1, :data2: test_data3}' do
+      before(:all) do
+        @config[:merge1] = { :data2 => { :test_runtime => true } }
+        value = { :data1 => 'test_data1', :data2 => 'test_data3' }
+        @config.set(:keys => [:merge1], :value => value, :name => 'local')
+      end
+
+      it 'config.mergeable?(:keys => [:merge1, :data2]) return false, '\
+         'because the first found in the deepest layers is not a Hash/Array.' do
+        expect(@config.where?(:merge1, :data2)).to eq(%w(runtime local))
+        expect(@config.mergeable?(:keys => [:merge1, :data2])).to equal(false)
+      end
+
+      it 'config.mergeable?(:keys => [:merge1, :data2], '\
+         ':exclusive => true) return false '\
+         '- "runtime" layer :data2 is not a Hash' do
+        expect(@config.where?(:merge1, :data2)).to eq(%w(runtime local))
+        expect(@config.mergeable?(:keys => [:merge1, :data2],
+                                  :exclusive => true)).to equal(false)
+      end
+
+      it 'config.merge() return "test_data3" a single data, first found in '\
+         'the deepest layers.' do
+        expect(@config.merge(:merge1, :data2)).to eq('test_data3')
+      end
+    end
+
+    context "with config[:merge1] = {:data2 => :test_runtime}\n"\
+            'and local: :merge1: => {:data2 => {:test => :test_data2} }' do
+      before(:all) do
+        @config[:merge1] = { :data2 => :test_runtime }
+        value = { :data2 => { :test => :test_data2 } }
+        @config.set(:keys => [:merge1], :value => value, :name => 'local')
+      end
+
+      it 'config.mergeable?(:keys => [:merge1, :data2]) return true, '\
+         'because the first found in the deepest layers is a Hash.' do
+        expect(@config.where?(:merge1)).to eq(%w(runtime local))
+        expect(@config.mergeable?(:keys => [:merge1, :data2])).to equal(true)
+      end
+
+      it 'config.mergeable?(:keys => [:merge1, :data2], '\
+         ':exclusive => true) return false '\
+         '- "runtime" layer :data2 is not a Hash' do
+        expect(@config.mergeable?(:keys => [:merge1, :data2],
+                                  :exclusive => true)).to equal(false)
+      end
+
+      it 'config.merge() return a single data, first found in the '\
+         'deepest layers.' do
+        expect(@config.merge(:merge1, :data2)).to eq(:test => :test_data2)
+      end
+    end
+
+    context "with config[:merge1] = {:data2 => {:test_runtime => true} }\n"\
+            'and local: :merge1: => {:data2 => {:test => :test_data2} }' do
+      before(:all) do
+        @config[:merge1] = { :data2 => { :test_runtime => true } }
+        value = { :data2 => { :test => :test_data2 } }
+        @config.set(:keys => [:merge1], :value => value, :name => 'local')
+      end
+
+      it 'config.mergeable?(:keys => [:merge1, :data2]) return true, '\
+         'because the first found in the deepest layers is a Hash.' do
+        expect(@config.where?(:merge1, :data2)).to eq(%w(runtime local))
+        expect(@config.mergeable?(:keys => [:merge1, :data2])).to equal(true)
+      end
+
+      it 'config.mergeable?(:keys => [:merge1, :data2], '\
+         ':exclusive => true) return true '\
+         '- All layers data found are Hash type.' do
+        expect(@config.mergeable?(:keys => [:merge1, :data2],
+                                  :exclusive => true)).to equal(true)
+      end
+
+      it 'config.merge() return a single data, first found in the '\
+         'deepest layers.' do
+        expect(@config.merge(:merge1, :data2)).to eq(:test_runtime => true,
+                                                     :test => :test_data2)
+      end
+    end
   end
 end