lorj 0.2.0 → 1.0.0

data/lib/rh.rb

@@ -0,0 +1,339 @@
+#!/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.
+
+require 'rubygems'
+require 'yaml'
+
+# Recursive Hash added to the Hash class
+class Hash
+  # Recursive Hash deep level found counter
+  # This function will returns the count of deep level of recursive hash.
+  # * *Args* :
+  #   - +p+    : Array of string or symbols. keys tree to follow and check
+  #              existence in yVal.
+  #
+  # * *Returns* :
+  #   - +integer+ : Represents how many deep level was found in the recursive
+  #                 hash
+  #
+  # * *Raises* :
+  #   No exceptions
+  #
+  # Example: (implemented in spec)
+  #
+  #    yVal = { :test => {:test2 => 'value1', :test3 => 'value2'},
+  #             :test4 => 'value3'}
+  #
+  # yVal can be represented like:
+  #
+  #   yVal:
+  #     test:
+  #       test2 = 'value1'
+  #       test3 = 'value2'
+  #     test4 = 'value3'
+  #
+  # so:
+  #   # test is found
+  #   yVal.rh_lexist?(:test) => 1
+  #
+  #   # no test5
+  #   yVal.rh_lexist?(:test5) => 0
+  #
+  #   # :test/:test2 tree is found
+  #   yVal.rh_lexist?(:test, :test2) => 2
+  #
+  #   # :test/:test2 is found (value = 2), but :test5 was not found in this tree
+  #   yVal.rh_lexist?(:test, :test2, :test5) => 2
+  #
+  #   # :test was found. but :test/:test5 tree was not found. so level 1, ok.
+  #   yVal.rh_lexist?(:test, :test5 ) => 1
+  #
+  #   # it is like searching for nothing...
+  #   yVal.rh_lexist? => 0
+
+  def rh_lexist?(*p)
+    return 0 if p.length == 0
+
+    p = p.flatten
+    if p.length == 1
+      return 1 if self.key?(p[0])
+      return 0
+    end
+    return 0 unless self.key?(p[0])
+    ret = 0
+    ret = self[p[0]].rh_lexist?(p.drop(1)) if self[p[0]].is_a?(Hash)
+    1 + ret
+  end
+
+  # Recursive Hash deep level existence
+  #
+  # * *Args* :
+  #   - +p+    : Array of string or symbols. keys tree to follow and check
+  #              existence in yVal.
+  #
+  # * *Returns* :
+  #   - +boolean+ : Returns True if the deep level of recursive hash is found.
+  #                 false otherwise
+  #
+  # * *Raises* :
+  #   No exceptions
+  #
+  # Example:(implemented in spec)
+  #
+  #    yVal = { :test => {:test2 => 'value1', :test3 => 'value2'},
+  #             :test4 => 'value3'}
+  #
+  # yVal can be represented like:
+  #
+  #   yVal:
+  #     test:
+  #       test2 = 'value1'
+  #       test3 = 'value2'
+  #     test4 = 'value3'
+  #
+  # so:
+  #   # test is found
+  #   yVal.rh_exist?(:test) => True
+  #
+  #   # no test5
+  #   yVal.rh_exist?(:test5) => False
+  #
+  #   # :test/:test2 tree is found
+  #   yVal.rh_exist?(:test, :test2) => True
+  #
+  #   # :test/:test2 is found (value = 2), but :test5 was not found in this tree
+  #   yVal.rh_exist?(:test, :test2, :test5) => False
+  #
+  #   # :test was found. but :test/:test5 tree was not found. so level 1, ok.
+  #   yVal.rh_exist?(:test, :test5 ) => False
+  #
+  #   # it is like searching for nothing...
+  #   yVal.rh_exist? => nil
+  def rh_exist?(*p)
+    return nil if p.length == 0
+
+    count = p.length
+    (rh_lexist?(*p) == count)
+  end
+
+  # Recursive Hash Get
+  # This function will returns the level of recursive hash was found.
+  # * *Args* :
+  #   - +p+    : Array of string or symbols. keys tree to follow and check
+  #              existence in yVal.
+  #
+  # * *Returns* :
+  #   - +value+ : Represents the data found in the tree. Can be of any type.
+  #
+  # * *Raises* :
+  #   No exceptions
+  #
+  # Example:(implemented in spec)
+  #
+  #    yVal = { :test => {:test2 => 'value1', :test3 => 'value2'},
+  #             :test4 => 'value3'}
+  #
+  # yVal can be represented like:
+  #
+  #   yVal:
+  #     test:
+  #       test2 = 'value1'
+  #       test3 = 'value2'
+  #     test4 = 'value3'
+  #
+  # so:
+  #   yVal.rh_get(:test) => {:test2 => 'value1', :test3 => 'value2'}
+  #   yVal.rh_get(:test5) => nil
+  #   yVal.rh_get(:test, :test2) => 'value1'
+  #   yVal.rh_get(:test, :test2, :test5) => nil
+  #   yVal.rh_get(:test, :test5 ) => nil
+  #   yVal.rh_get => { :test => {:test2 => 'value1', :test3 => 'value2'},
+  #                    :test4 => 'value3'}
+  def rh_get(*p)
+    p = p.flatten
+    return self if p.length == 0
+
+    if p.length == 1
+      return self[p[0]] if self.key?(p[0])
+      return nil
+    end
+    return self[p[0]].rh_get(p.drop(1)) if self[p[0]].is_a?(Hash)
+    nil
+  end
+
+  # Recursive Hash Set
+  # This function will build a recursive hash according to the '*p' key tree.
+  # if yVal is not nil, it will be updated.
+  #
+  # * *Args* :
+  #   - +p+    : Array of string or symbols. keys tree to follow and check
+  #              existence in yVal.
+  #
+  # * *Returns* :
+  #   - +value+ : the value set.
+  #
+  # * *Raises* :
+  #   No exceptions
+  #
+  # Example:(implemented in spec)
+  #
+  #    yVal = {}
+  #
+  #   yVal.rh_set(:test) => nil
+  #   # yVal = {}
+  #
+  #   yVal.rh_set(:test5) => nil
+  #   # yVal = {}
+  #
+  #   yVal.rh_set(:test, :test2) => :test
+  #   # yVal = {:test2 => :test}
+  #
+  #   yVal.rh_set(:test, :test2, :test5) => :test
+  #   # yVal = {:test2 => {:test5 => :test} }
+  #
+  #   yVal.rh_set(:test, :test5 ) => :test
+  #   # yVal = {:test2 => {:test5 => :test}, :test5 => :test }
+  #
+  #   yVal.rh_set('blabla', :test2, 'text') => :test
+  #   # yVal  = {:test2 => {:test5 => :test, 'text' => 'blabla'},
+  #              :test5 => :test }
+  def rh_set(value, *p)
+    return nil if p.length == 0
+
+    p = p.flatten
+    if p.length == 1
+      self[p[0]] = value
+      return value
+    end
+
+    self[p[0]] = {} unless self[p[0]].is_a?(Hash)
+    self[p[0]].rh_set(value, p.drop(1))
+  end
+
+  # Recursive Hash delete
+  # This function will remove the last key defined by the key tree
+  #
+  # * *Args* :
+  #   - +p+    : Array of string or symbols. keys tree to follow and check
+  #              existence in yVal.
+  #
+  # * *Returns* :
+  #   - +value+ : The Hash updated.
+  #
+  # * *Raises* :
+  #   No exceptions
+  #
+  # Example:(implemented in spec)
+  #
+  #   yVal = {{:test2 => { :test5 => :test,
+  #                        'text' => 'blabla' },
+  #            :test5 => :test}}
+  #
+  #
+  #   yVal.rh_del(:test) => nil
+  #   # yVal = no change
+  #
+  #   yVal.rh_del(:test, :test2) => nil
+  #   # yVal = no change
+  #
+  #   yVal.rh_del(:test2, :test5) => {:test5 => :test}
+  #   # yVal = {:test2 => {:test5 => :test} }
+  #
+  #   yVal.rh_del(:test, :test2)
+  #   # yVal = {:test2 => {:test5 => :test} }
+  #
+  #   yVal.rh_del(:test, :test5)
+  #   # yVal = {:test2 => {} }
+  #
+  def rh_del(*p)
+    return nil if p.length == 0
+
+    p = p.flatten
+    return delete(p[0]) if p.length == 1
+
+    return nil if self[p[0]].nil?
+    self[p[0]].rh_del(p.drop(1))
+  end
+
+  # Move levels (default level 1) of tree keys to become symbol.
+  #
+  # * *Args*    :
+  #   - +levels+: level of key tree to update.
+  # * *Returns* :
+  #   - a new hash of hashes updated. Original Hash is not updated anymore.
+  #
+  # examples:
+  #   With hdata = { :test => { :test2 => { :test5 => :test,
+  #                                         'text' => 'blabla' },
+  #                             'test5' => 'test' }}
+  #
+  #  rh_key_to_symbol(1) return no diff
+  #  rh_key_to_symbol(2) return "test5" is replaced by :test5
+  #  # hdata = { :test => { :test2 => { :test5 => :test,
+  #  #                                  'text' => 'blabla' },
+  #  #                      :test5 => 'test' }}
+  #  rh_key_to_symbol(3) return "test5" replaced by :test5, and "text" to :text
+  #  # hdata = { :test => { :test2 => { :test5 => :test,
+  #  #                                  :text => 'blabla' },
+  #  #                      :test5 => 'test' }}
+  #  rh_key_to_symbol(4) same like rh_key_to_symbol(3)
+
+  def rh_key_to_symbol(levels = 1)
+    result = {}
+    each do | key, value |
+      new_key = key
+      new_key = key.to_sym if key.is_a?(String)
+      if value.is_a?(Hash) && levels > 1
+        value = value.rh_key_to_symbol(levels - 1)
+      end
+      result[new_key] = value
+    end
+    result
+  end
+
+  # Check if levels of tree keys are all symbols.
+  #
+  # * *Args*    :
+  #   - +levels+: level of key tree to update.
+  # * *Returns* :
+  #   - true  : one key path is not symbol.
+  #   - false : all key path are symbols.
+  # * *Raises* :
+  #   Nothing
+  #
+  # examples:
+  #   With hdata = { :test => { :test2 => { :test5 => :test,
+  #                                         '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
+  def rh_key_to_symbol?(levels = 1)
+    each do | key, value |
+      return true if key.is_a?(String)
+
+      res = false
+      if levels > 1 && value.is_a?(Hash)
+        res = value.rh_key_to_symbol?(levels - 1)
+      end
+      return true if res
+    end
+    false
+  end
+end

data/lorj-spec/defaults.yaml

@@ -15,6 +15,8 @@
 # Defaults yaml file used for rspec.
 :default:
    :maestro_url: http://example.org
+   :keypair_name: default_key
+   :data: None
 
 :description:
    :FORJ_HPC: Testing extra application default value.
@@ -22,5 +24,7 @@
 :sections:
    :credentials:
       :keypair_name:
+      :data:
+        :account_exclusive: true
    :maestro:
       :maestro_url:

data/lorj.gemspec

@@ -3,6 +3,11 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'lorj/version'
 
+require 'rbconfig'
+ruby_conf = defined?(RbConfig) ? RbConfig::CONFIG : Config::CONFIG
+less_than_one_nine = ruby_conf['MAJOR'].to_i == 1 && ruby_conf['MINOR'].to_i < 9
+less_than_two = ruby_conf['MAJOR'].to_i < 2
+
 Gem::Specification.new do |spec|
   spec.name          = 'lorj'
   spec.version       = Lorj::VERSION
@@ -24,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 'byebug' unless less_than_two
   spec.rdoc_options << \
     '--title Lorj - The Process Controllers framework system' << \
     '--main README.md'

data/spec/00_lorj_log_spec.rb

@@ -0,0 +1,53 @@
+#!/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.
+
+# require 'rubygems'
+#  require 'byebug'
+# require 'bundler/setup'
+
+app_path = File.dirname(File.dirname(__FILE__))
+
+$LOAD_PATH << './lib'
+
+# This spec HAVE to the the first one executed!
+# Do never create a file or rename this file, which will
+# move this spec later in the spec test system
+# as soon as a first message is sent, the object gets created.
+# Any PrcLib::level should be moved in the first test code executed.
+# otherwise, you will break the first test in this file.
+
+describe 'Module: Lorj,' do
+  context 'Initializing' do
+    it 'PrcLib module exist' do
+      require 'lorj' # Load lorj framework
+      expect(PrcLib.class).to equal(Module)
+
+      expect(PrcLib.log).to be_nil
+    end
+
+    it 'create PrcLib.log object at first message' do
+      PrcLib.log_file = 'lorj-rspec.log'
+      PrcLib.level = Logger::FATAL
+      PrcLib.app_name = 'lorj-spec'
+      PrcLib.app_defaults = File.join(app_path, 'lorj-spec')
+
+      PrcLib.debug 'Rspec logging ...'
+
+      expect(PrcLib.log).to_not be_nil
+    end
+  end
+end

data/spec/01_hash_rh_spec.rb

@@ -0,0 +1,243 @@
+#!/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.
+
+$LOAD_PATH << File.join('..', 'lib')
+
+require 'rh'
+
+describe 'Recursive Hash extension,' do
+  context "With { :test => {:test2 => 'value1', :test3 => 'value2'},"\
+          ":test4 => 'value3'}" do
+    before(:all) do
+      @hdata = { :test => { :test2 => 'value1', :test3 => 'value2' },
+                 :test4 => 'value3' }
+    end
+    it 'rh_lexist?(:test) return 1' do
+      expect(@hdata.rh_lexist?(:test)).to eq(1)
+    end
+
+    it 'rh_lexist?(:test5) return 0' do
+      expect(@hdata.rh_lexist?(:test5)).to eq(0)
+    end
+
+    it 'rh_lexist?(:test, :test2) return 2' do
+      expect(@hdata.rh_lexist?(:test, :test2)).to eq(2)
+    end
+
+    it 'rh_lexist?(:test, :test2, :test5) return 2' do
+      expect(@hdata.rh_lexist?(:test, :test2, :test5)).to eq(2)
+    end
+
+    it 'rh_lexist?(:test, :test5 ) return 1' do
+      expect(@hdata.rh_lexist?(:test, :test5)).to eq(1)
+    end
+
+    it 'rh_lexist? return 0' do
+      expect(@hdata.rh_lexist?).to eq(0)
+    end
+  end
+
+  context "With { :test => {:test2 => 'value1', :test3 => 'value2'},"\
+          ":test4 => 'value3'}" do
+    before(:all) do
+      @hdata = { :test => { :test2 => 'value1', :test3 => 'value2' },
+                 :test4 => 'value3' }
+    end
+    it 'rh_exist?(:test) return true' do
+      expect(@hdata.rh_exist?(:test)).to equal(true)
+    end
+
+    it 'rh_exist?(:test5) return false' do
+      expect(@hdata.rh_exist?(:test5)).to equal(false)
+    end
+
+    it 'rh_exist?(:test, :test2) return true' do
+      expect(@hdata.rh_exist?(:test, :test2)).to equal(true)
+    end
+
+    it 'rh_exist?(:test, :test2, :test5) return false' do
+      expect(@hdata.rh_exist?(:test, :test2, :test5)).to equal(false)
+    end
+
+    it 'rh_exist?(:test, :test5 ) return false' do
+      expect(@hdata.rh_exist?(:test, :test5)).to equal(false)
+    end
+
+    it 'rh_exist? return nil' do
+      expect(@hdata.rh_exist?).to eq(nil)
+    end
+  end
+
+  context "With { :test => {:test2 => 'value1', :test3 => 'value2'},"\
+          ":test4 => 'value3'}" do
+    before(:all) do
+      @hdata = { :test => { :test2 => 'value1',
+                            :test3 => 'value2' },
+                 :test4 => 'value3' }
+    end
+    it "rh_get(:test) return {:test2 => 'value1', :test3 => 'value2'}" do
+      expect(@hdata.rh_get(:test)).to eq(:test2 => 'value1',
+                                         :test3 => 'value2')
+    end
+
+    it 'rh_get(:test5) return nil' do
+      expect(@hdata.rh_get(:test5)).to equal(nil)
+    end
+
+    it "rh_get(:test, :test2) return 'value1'" do
+      expect(@hdata.rh_get(:test, :test2)).to eq('value1')
+    end
+
+    it 'rh_get(:test, :test2, :test5) return nil' do
+      expect(@hdata.rh_get(:test, :test2, :test5)).to equal(nil)
+    end
+
+    it 'rh_get(:test, :test5) return nil' do
+      expect(@hdata.rh_get(:test, :test5)).to equal(nil)
+    end
+
+    it 'rh_get return original data' do
+      expect(@hdata.rh_get).to eq(:test => { :test2 => 'value1',
+                                             :test3 => 'value2' },
+                                  :test4 => 'value3')
+    end
+  end
+
+  context 'With hdata = {}' do
+    before(:all) do
+      @hdata = {}
+    end
+    it 'rh_set(:test) return nil, with no change to hdata.' do
+      expect(@hdata.rh_set(:test)).to equal(nil)
+      expect(@hdata).to eq({})
+    end
+
+    it 'rh_set(:test, :test2) add a new element :test2 => :test' do
+      expect(@hdata.rh_set(:test, :test2)).to eq(:test)
+      expect(@hdata).to eq(:test2 => :test)
+    end
+
+    it 'rh_set(:test, :test2, :test5) replace :test2 by :test5 => :test' do
+      expect(@hdata.rh_set(:test, :test2, :test5)).to eq(:test)
+      expect(@hdata).to eq(:test2 => { :test5 => :test })
+    end
+
+    it 'rh_set(:test, :test5 ) add :test5 => :test, colocated with :test2' do
+      expect(@hdata.rh_set(:test, :test5)).to equal(:test)
+      expect(@hdata).to eq(:test2 => { :test5 => :test },
+                           :test5 => :test)
+    end
+
+    it "rh_set('blabla', :test2, 'text') add a 'test' => 'blabla' under"\
+       ' :test2, colocated with ẗest5 ' do
+      expect(@hdata.rh_set('blabla', :test2, 'text')).to eq('blabla')
+      expect(@hdata).to eq(:test2 => { :test5 => :test,
+                                       'text' => 'blabla' },
+                           :test5 => :test)
+    end
+
+    it 'rh_set(nil, :test2) remove :test2 value' do
+      expect(@hdata.rh_set(nil, :test2)).to equal(nil)
+      expect(@hdata).to eq(:test2 => nil,
+                           :test5 => :test)
+    end
+  end
+
+  context 'With hdata = {:test2 => { :test5 => :test,'\
+          "'text' => 'blabla' },"\
+          ':test5 => :test}' do
+    before(:all) do
+      @hdata = { :test2 => { :test5 => :test,
+                             'text' => 'blabla' },
+                 :test5 => :test }
+    end
+    it 'rh_del(:test) return nil, with no change to hdata.' do
+      expect(@hdata.rh_del(:test)).to equal(nil)
+      expect(@hdata).to eq(:test2 => { :test5 => :test,
+                                       'text' => 'blabla' },
+                           :test5 => :test)
+    end
+
+    it 'rh_del(:test, :test2) return nil, with no change to hdata.' do
+      expect(@hdata.rh_del(:test, :test2)).to eq(nil)
+      expect(@hdata).to eq(:test2 => { :test5 => :test,
+                                       'text' => 'blabla' },
+                           :test5 => :test)
+    end
+
+    it 'rh_del(:test2, :test5) remove :test5 keys tree from :test2' do
+      expect(@hdata.rh_del(:test2, :test5)).to eq(:test)
+      expect(@hdata).to eq(:test2 => { 'text' => 'blabla' },
+                           :test5 => :test)
+    end
+
+    it 'rh_del(:test5 ) remove :test5' do
+      expect(@hdata.rh_del(:test5)).to equal(:test)
+      expect(@hdata).to eq(:test2 => { 'text' => 'blabla' })
+    end
+
+    it 'rh_del(:test2) remove the :test2. hdata is now {}.'\
+       ' :test2, colocated with ẗest5 ' do
+      expect(@hdata.rh_del(:test2)).to eq('text' => 'blabla')
+      expect(@hdata).to eq({})
+    end
+  end
+  context 'With hdata = { :test => { :test2 => { :test5 => :test,'\
+          "'text' => 'blabla' },"\
+          "'test5' => 'test' }}" do
+    before(:all) do
+      @hdata = { :test => { :test2 => { :test5 => :test,
+                                        'text' => 'blabla' },
+                            'test5' => 'test' } }
+    end
+    it 'rh_key_to_symbol?(1) return false' do
+      expect(@hdata.rh_key_to_symbol?(1)).to equal(false)
+    end
+    it 'rh_key_to_symbol?(2) return true' do
+      expect(@hdata.rh_key_to_symbol?(2)).to equal(true)
+    end
+    it 'rh_key_to_symbol?(3) return true' do
+      expect(@hdata.rh_key_to_symbol?(3)).to equal(true)
+    end
+    it 'rh_key_to_symbol?(4) return true' do
+      expect(@hdata.rh_key_to_symbol?(4)).to equal(true)
+    end
+
+    it 'rh_key_to_symbol(1) return no diff' do
+      expect(@hdata.rh_key_to_symbol(1)
+            ).to eq(:test => { :test2 => { :test5 => :test,
+                                           'text' => 'blabla' },
+                               'test5' => 'test' })
+    end
+    it 'rh_key_to_symbol(2) return "test5" is replaced by :ẗest5' do
+      expect(@hdata.rh_key_to_symbol(2)
+            ).to eq(:test => { :test2 => { :test5 => :test,
+                                           'text' => 'blabla' },
+                               :test5 => 'test' })
+    end
+    it 'rh_key_to_symbol(3) return "test5" replaced by :ẗest5, '\
+       'and "text" to :text' do
+      expect(@hdata.rh_key_to_symbol(3)
+            ).to eq(:test => { :test2 => { :test5 => :test,
+                                           :text => 'blabla' },
+                               :test5 => 'test' })
+    end
+    it 'rh_key_to_symbol(4) same like rh_key_to_symbol(3)' do
+      expect(@hdata.rh_key_to_symbol(4)).to eq(@hdata.rh_key_to_symbol(3))
+    end
+  end
+end