forj 1.0.1 → 1.0.2

data/lib/security.rb

@@ -1,207 +0,0 @@
-#!/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 'highline/import'
-
-#
-# SecurityGroup module
-#
-
-# TODO: Introduce most of HPCloud task in an hpcloud object.
-module SecurityGroup
-
-  def get_or_create_security_group(oFC, name)
-    Logging.state("Searching for security group '%s'..." % [name])
-    security_group = get_security_group(oFC, name)
-    security_group = create_security_group(oFC, name) if not security_group
-    security_group
-  end
-
-  def create_security_group(oFC, name)
-    Logging.debug("creating security group '%s'" % [name])
-    begin
-      description = "Security group for blueprint '%s'" % [name]
-      oFC.oNetwork.security_groups.create(
-            :name => name,
-            :description => description
-        )
-    rescue => e
-      Logging.error("%s\n%s" % [e.message, e.backtrace.join("\n")])
-    end
-  end
-
-  def get_security_group(oFC, name)
-    Logging.state("Searching for security group '%s'" % [name])
-    oSSLError=SSLErrorMgt.new
-    begin
-      sgroups = oFC.oNetwork.security_groups.all({:name => name})
-    rescue => e
-      if not oSSLError.ErrorDetected(e.message,e.backtrace)
-         retry
-      end
-      Logging.fatal(1, "Unable to get list of security groups.", e)
-    end
-    case sgroups.length()
-      when 0
-        Logging.debug("No security group '%s' found" % [name] )
-        nil
-      when 1
-        Logging.debug("Found security group '%s'" % [sgroups[0].name])
-        sgroups[0]  
-    end
-  end
-
-  def delete_security_group(oFC, security_group)
-    oSSLError=SSLErrorMgt.new
-    begin
-      sec_group = get_security_group(oFC, security_group)
-      oFC.oNetwork.security_groups.get(sec_group.id).destroy
-    rescue => e
-      if not oSSLError.ErrorDetected(e.message,e.backtrace)
-         retry
-      end
-    end
-  end
-
-  def create_security_group_rule(oFC, security_group_id, protocol, port_min, port_max)
-    Logging.debug("Creating ingress rule '%s:%s - %s to 0.0.0.0/0'" % [protocol, port_min, port_max])
-    oSSLError=SSLErrorMgt.new
-    begin
-      oFC.oNetwork.security_group_rules.create(
-          :security_group_id => security_group_id,
-          :direction => 'ingress',
-          :protocol => protocol,
-          :port_range_min => port_min,
-          :port_range_max => port_max,
-          :remote_ip_prefix => '0.0.0.0/0'
-      )
-    rescue StandardError => e
-      if not oSSLError.ErrorDetected(e.message,e.backtrace)
-         retry
-      end
-      msg = 'error creating the rule for port %s' % [port_min]
-      Logging.error msg
-    end
-  end
-
-  def delete_security_group_rule(oFC, rule_id)
-    oSSLError=SSLErrorMgt.new
-    begin
-      oFC.oNetwork.security_group_rules.get(rule_id).destroy
-    rescue => e
-      if not oSSLError.ErrorDetected(e.message,e.backtrace)
-         retry
-      end
-    end
-  end
-
-  def get_security_group_rule(oFC, security_group_id, port_min, port_max)
-    Logging.state("Searching for rule '%s - %s'" % [ port_min, port_max])
-    oSSLError = SSLErrorMgt.new
-    begin
-      sgroups = oFC.oNetwork.security_group_rules.all({:port_range_min => port_min, :port_range_max => port_max, :security_group_id => security_group_id})
-      case sgroups.length()
-        when 0
-          Logging.debug("No security rule '%s - %s' found" % [ port_min, port_max ] )
-          nil
-        else
-          Logging.debug("Found security rule '%s - %s'." % [ port_min, port_max ])
-          sgroups
-      end      
-   rescue => e
-      if not oSSLError.ErrorDetected(e.message,e.backtrace)
-         retry
-      end
-    end
-  end
-
-  def get_or_create_rule(oFC, security_group_id, protocol, port_min, port_max)
-    rule = get_security_group_rule(oFC, security_group_id, port_min, port_max)
-    if not rule
-      rule = create_security_group_rule(oFC, security_group_id, protocol, port_min, port_max)
-    end
-    rule
-  end
-
-   def keypair_detect(keypair_name, key_fullpath)
-      # Build key data information structure.
-      # Take care of priv with or without .pem and pubkey with pub.
-	
-      key_basename = File.basename(key_fullpath)
-      key_path = File.expand_path(File.dirname(key_fullpath))
-    
-      mObj = key_basename.match(/^(.*?)(\.pem|\.pub)?$/)
-      key_basename = mObj[1]
-    
-      private_key_ext = nil
-      private_key_ext = "" if File.exists?(File.join(key_path, key_basename))
-      private_key_ext = '.pem' if File.exists?(File.join(key_path, key_basename + '.pem'))
-      if private_key_ext
-         private_key_exist = true
-         private_key_name = key_basename + private_key_ext
-      else
-         private_key_exist = false
-         private_key_name = key_basename
-      end
-    
-      public_key_exist = File.exists?(File.join(key_path, key_basename + '.pub'))
-      public_key_name = key_basename + '.pub'
-    
-    
-      {:keypair_name     => keypair_name,
-       :keypair_path     => key_path,         :key_basename       => key_basename,
-       :private_key_name => private_key_name, :private_key_exist? => private_key_exist,
-       :public_key_name  => public_key_name,  :public_key_exist?  => public_key_exist,
-      }
-   end
-
-  def hpc_import_key(oForjAccount)
-
-    keys = keypair_detect(oForjAccount.get('keypair_name'), oForjAccount.get('keypair_path'))
-    account = oForjAccount.getAccountData(:account, :name)
-
-    Logging.fatal(1, "'keypair_path' undefined. check your config.yaml file.") if not keys[:keypair_path]
-    Logging.fatal(1, "'keypair_name' undefined. check your config.yaml file.") if not keys[:keypair_name]
-    Logging.fatal(1, "keypair '%s' are missing. Please call 'forj setup %s' to create the missing key pair required." % [keys[:keypair_name], account]) if not keys[:public_key_exist?]
-    
-    public_key_path = File.join(keys[:keypair_path], keys[:public_key_name])
-    private_key_path = File.join(keys[:keypair_path], keys[:private_key_name])
-
-    if not File.exists?(File.join($HPC_KEYPAIRS, keys[:keypair_name] + '.pub'))
-       Logging.info("Importing your forj public key '%s' to hpcloud." % keys[:public_key_name])
-       command = 'hpcloud keypairs:import %s %s -a %s' % [keys[:keypair_name], public_key_path , account]
-       Logging.debug("Executing command '%s'" % command)
-       Kernel.system(command)
-    else
-       Logging.info("Using '%s' as public key." % public_key_path)
-    end
-    
-    if not File.exists?(File.join($HPC_KEYPAIRS, keys[:keypair_name] + '.pem'))
-       if keys[:private_key_exist?]
-          Logging.info("Importing your forj private key '%s' to hpcloud." % private_key_path)
-          command = 'hpcloud keypairs:private:add %s %s' % [keys[:keypair_name], private_key_path]
-          Logging.debug("Executing command '%s'" % command)
-          Kernel.system(command)
-       else   
-          Logging.warning('Unable to find the private key. This will be required to access with ssh to Maestro and any blueprint boxes.')
-       end
-    else
-       Logging.info("Using '%s' as private key." % private_key_path)
-    end
-  end
-end

data/lib/ssh.sh

@@ -1,185 +0,0 @@
-#!/bin/bash
-#vim: setlocal ft=sh:
-RST="\e[0m"
-RED="\e[31m"
-BLU="\e[34m"
-GRE="\e[92m"
-
-# (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.
-
-NOW=$(date +%Y-%m-%d.%H%M%S)
-logpath=~/.forj/
-DB=~/.forj/hosts
-#key_path=~/.ssh/
-#key_path=~/.hpcloud/keypairs/
-init_config=~/ssh_init
-key="nova.pem"
-
-if [ ! -f $DB ]; then
-	cat > $DB <<'EOF'
-
-#Custom Servers - (Won't be deleted when updating list)
-#<name.id>         <public ip>       <date>           <key>
-
-#### Below list are updated
-
-EOF
-fi
-
-##No parameters sent
-if (( $# < 1 )); then
-	echo -e "${RED}Error, no parameter was sent.$RST"
-	echo "Use this script as:"
-	echo "  -rm <id> : Removes all nodes that match the id."
-	echo "  -f <text>: Finds the text in the log files."
-	echo "  -u       : Updates the hosts list querying nova server."
-	echo "  -l       : Lists the current hosts."
-	echo "  <IP>     : Connects directly to the IP using default key"
-	echo "<id> <name>: Queries the hosts list looking for the id and name."
-	echo -e "\n ${GRE}OPTIONS${RST}"
-	echo "  -i {par} : Applies initialization script to the server."
-	exit 1
-fi
-
-if [ $1 == '-i' ]; then
-	if [ ! -f $init_config ]; then
-		echo "${RED}Error, config file: $init_config does not exists."
-		exit 1
-	fi
-	shift
-	is_init='true'
-fi
-
-#Finds text in logs
-if [ $1 == '-f' ]; then
-	grep --include=*.log -rnw $logpath -e "$2" --color=always
-	exit 0
-fi
-
-if [ $1 == '-rm' ] && [ "$2" != '' ]; then
-	echo "Removing $2..."
-	cat $DB | grep -iE "[a-z]+\.$2" --color=always
-	sed -i -E "/[a-z]+\.$2/d" $DB
-	exit 0
-fi
-
-##Just Lists the hosts db
-if [ $1 == '-l' ]; then
-	echo "List of hosts:"
-	if [ "$2" != "" ]; then #kit
-		result=$(cat $DB | grep -iE "\.$2" --color=always)
-	else #All Maestros
-		result=$(cat $DB | grep -E "maestro\.")
-	fi
-	echo "$result"
-	exit 0
-fi
-
-##Just list the hosts db
-if [ $1 == '-u' ]; then
-	linenum=$(cat $DB | grep -E -n "#### Below list are updated" | awk -F: '{print $1}')
-	old_serversnum=$(tail -n +$linenum $DB | grep -E " .*\..* " | wc -l)
-
-	sed -i -n '/\#\#\#\# Below list are updated/q;p' $DB
-	sed -i '/^$/d' $DB
-	echo -e "\n#### Below list are updated" >> $DB
-
-	hpcloud servers -a $2 | awk -F"\|" '{print $3","$6","$9","$7}' | awk -F, '{print $1$3$4$5}' >> $DB
-	echo -e "\033[1;32m$DB Updated\033[00m"
-	linenum=$(cat $DB | grep -E -n "#### Below list are updated" | awk -F: '{print $1}')
-	new_serversnum=$(tail -n +$linenum $DB | grep -E " .*\..* " | wc -l)
-	diff=$(echo "$new_serversnum - $old_serversnum" | bc)
-	echo "Old Servers: $old_serversnum, New Servers: $new_serversnum, Diff: $diff"
-	exit 0
-fi
-
-#parameter is IP
-if [[ $1 =~ ([0-9]{1,3}\.){3}[0-9]{1,3} ]]; then
-	ip=$1
-	#Check if has URL and clean it if so
-	if [[ $ip =~ 'http' ]]; then
-		ip=$(echo "$ip" | grep -oE '([0-9]{1,3}\.){3}[0-9]{1,3}')
-	fi
-	#Check if IP exists in db and show info
-	host_name=$(cat $DB | grep $ip | awk '{print $1}')
-	if [[ "$host_name" != "" ]]; then
-		echo -e "Host: \033[33m$host_name${RST}"
-	fi
-	message="$ip"
-#parameter is ID NODE
-else
-	id=$1
-	node=$2
-	key=$3
-
-	if [ "$node" == "" ]; then
-		echo -e "${RED}Error, no server name sent.$RST"
-		exit 1
-	fi
-
-	#Alias handling
-	alias=$(cat ~/hosts | grep -iE '^alias:' | grep -iE ' '$node | awk '{print $2}')
-	if [ "$alias" != "" ] && [ "$alias" != "$node" ]; then
-		echo "Using alias $node, converting to $alias"
-		node=$alias
-	fi
-
-	ip=$(cat $DB | grep -iE "[a-ZA-Z]+\.$id" | grep -i $node | awk '{print $2}' | tr -d ' ')
-	if [ "$ip" == "" ]; then
-		echo -e "${RED}Error, the kit ${GRE}$node${RED} with id ${GRE}$id${RED} was not found.${RST}"
-		exit 1
-	fi
-	#key=$(cat $DB | grep -iEw "$ip" | awk '{print $4}' | tr -d ' ')
-	message="$node.$id"
-	extended="($ip)"
-
-	if [ "$ip" == "" ] || [ "$key" == "" ]; then
-		echo -e "${RED}Error, combination was not found, maybe you should update the db.$RST"
-		exit 1
-	fi
-fi
-
-if [ "$node" != "" ]; then
-	logname="$node.$id"
-else
-	logname="$ip"
-fi
-#key="$key_path$key.pem"
-
-echo -e "Connecting to $GRE$message$RST using $BLU$key$RST $extended"
-
-if [[ ! -f $key ]]; then
-	echo -e "${RED}Key doesn't exists$RST"
-	exit 1
-fi
-
-logfile="${logpath}sshlog.$logname.$NOW.log"
-
-echo -e "$RED══════════════════════════════════════════════════════════════════════════$RST"
-#echo "ssh -o StrictHostKeyChecking=no -o ServerAliveInterval=180 -i $key ubuntu@$ip"
-if [ "$is_init" == 'true' ]; then
-	username=$(id -u -n)
-	username=${username^^} #convert to upper
-	grep -q "$username" $init_config
-	if [ $? != 0 ]; then
-		echo "Writing username to $init_config file."
-		sed -i "s/^owner='.*'$/owner='$username'/g" $DB
-	fi
-	ssh -o StrictHostKeyChecking=no -o ServerAliveInterval=180 -i $key ubuntu@$ip < $init_config
-	echo -e "Reconnecting..."
-fi
-ssh -o StrictHostKeyChecking=no -o ServerAliveInterval=180 -i $key ubuntu@$ip | tee -a $logfile
-echo -e "$RED══════════════════════════════════════════════════════════════════════════$RST"
-echo -e "${GRE}Log file: ${RST}$logfile"

data/spec/connection_spec.rb

@@ -1,52 +0,0 @@
-#!/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 'bundler/setup'
-require 'spec_helper'
-
-require 'fog'
-
-$APP_PATH = File.dirname(__FILE__)
-$LIB_PATH = File.expand_path(File.join(File.dirname($APP_PATH),'lib'))
-
-$LOAD_PATH << $LIB_PATH
-
-require 'appinit.rb' # Load generic Application level function
-
-# Initialize forj paths
-AppInit::forj_initialize()
-
-# Initialize global Log object
-$FORJ_LOGGER=ForjLog.new('forj-rspec.log', Logger::FATAL)
-
-require 'forj-config.rb' # Load class ForjConfig
-require 'connection.rb' # Load class ForjConnection
-require 'forj-account.rb'
-
-
-describe 'Module: forj-connection' do
-
-  it 'should connect to hpcloud (smoke test)' do
-
-    Fog.mock!
-    conn = ForjConnection.new(ForjAccount.new(ForjConfig.new()))
-    expect(conn).to be
-
-    Fog::Mock.reset
-  end
-end

data/spec/forj-config_spec.rb

@@ -1,237 +0,0 @@
-#!/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 'bundler/setup'
-
-$APP_PATH = File.dirname(__FILE__)
-$LIB_PATH = File.expand_path(File.join(File.dirname($APP_PATH),'lib'))
-$FORJ_DATA_PATH= File.expand_path('~/.forj')
-
-$LOAD_PATH << './lib'
-
-require 'forj-config.rb' # Load class ForjConfig
-require 'log.rb' # Load default loggers
-require 'ansi'
-
-include Logging
-
-$FORJ_LOGGER=ForjLog.new('forj-rspec.log', Logger::FATAL)
-
-
-describe "class: forj-config," do
-    context "when creating a new instance" do
-
-      it 'should be loaded' do
-         @test_config=ForjConfig.new()
-         expect(@test_config).to be
-      end
-
-    end
-
-    context "when starting, forj-config" do
-      before(:all) do
-         @config=ForjConfig.new()
-      end
-
-      it 'should be able to create a key/value in local config' do
-         @config.LocalSet(:test1,'value')
-         expect(@config.LocalGet(:test1)).to eq('value')
-      end
-
-      it 'should be able to remove the previously created key/value from local config' do
-         @config.LocalDel(:test1)
-         expect(@config.exist?(:test1)).to equal(false)
-      end
-    end
-
-    context "while updating local config file, forj-config" do
-      before(:all) do
-         @config=ForjConfig.new()
-      end
-
-      after(:all)  do
-        @config.LocalDel(:test1)
-        @config.SaveConfig()
-      end
-
-      it 'should save a key/value in local config' do
-         @config.LocalSet(:test1,'value')
-         expect(@config.SaveConfig()).to equal(true)
-
-         oConfig=ForjConfig.new()
-         expect(@config.LocalGet(:test1)).to eq('value')
-      end
-
-    end
-
-    context "With another config file - test1.yaml, forj-config" do
-
-      before(:all) do
-        if File.exists?('~/.forj/test.yaml')
-           File.delete(File.expand_path('~/.forj/test.yaml'))
-        end
-        File.open(File.expand_path('~/.forj/test1.yaml'), 'w+') { |file| file.write(":default:\n") }
-        @config=ForjConfig.new('test.yaml')
-        @config2=ForjConfig.new('test1.yaml')
-      end
-
-      after(:all)  do
-        File.delete(File.expand_path('~/.forj/test1.yaml'))
-      end
-
-      it 'won\'t create a new file If we request to load \'test.yaml\'' do
-         expect(File.exists?(File.expand_path('~/.forj/test.yaml'))).to equal(false)
-      end
-
-      it 'will load the default config file if we request to load \'test.yaml\'' do
-         expect(File.basename(@config.sConfigName)).to eq('config.yaml')
-      end
-
-      it 'will confirm \'test1.yaml\' config to be loaded.' do
-         expect(File.basename(@config2.sConfigName)).to eq('test1.yaml')
-      end
-
-      it 'can save \'test2=value\'' do
-         @config2.LocalSet('test2','value')
-         expect(@config2.SaveConfig()).to equal(true)
-         config3=ForjConfig.new('test1.yaml')
-         expect(config3.LocalGet('test2')).to eq('value')
-      end
-
-    end
-
-   context "with get/set/exists?," do
-      before(:all) do
-         @config=ForjConfig.new()
-         @url = @config.get('maestro_url')
-      end
-
-      it 'can set and get data,' do
-         expect(@config.set(nil, nil)).to equal(false)
-         expect(@config.set(:test, nil)).to equal(true)
-         expect(@config.get(:test)).to equal(nil)
-
-         expect(@config.set(:test, 'data')).to equal(true)
-         expect(@config.get(:test)).to eq('data')
-      end
-      
-      context 'from defaults,' do
-         it 'can get application defaults' do
-            expect(@config.get(:maestro_url).class).to equal(String)
-            expect(@config.getAppDefault(:default, :maestro_url).class).to equal(String)
-            expect(@config.getAppDefault(:description, 'FORJ_HPC').class).to equal(String)
-
-         end
-         it 'can get Local defaults instead of application' do
-            expect(@config.LocalSet(:maestro_url,'local')).to equal(true)
-            expect(@config.LocalGet(:maestro_url)).to eq('local')
-            expect(@config.get(:maestro_url)).to eq('local')
-         end
-
-         it 'can get runtime defaults instead of Local/application' do
-            expect(@config.set(:maestro_url, 'runtime')).to equal(true)
-            expect(@config.get(:maestro_url)).to eq('runtime')
-            expect(@config.LocalGet(:maestro_url)).to eq('local')
-         end
-
-         it 'can get runtime defaults instead of application' do
-            expect(@config.LocalDel(:maestro_url)).to equal(true)
-            expect(@config.get(:maestro_url)).to eq('runtime')
-            expect(@config.LocalGet(:maestro_url)).to equal(nil)
-         end
-
-         it 'can get defaults if no key' do
-            expect(@config.set(:test1, nil)).to equal(true)
-            expect(@config.get(:test1, 'default')).to eq('default')
-            expect(@config.get(:test1, nil)).to equal(nil)
-            expect(@config.set(:maestro_url,nil)).to equal(true)
-            expect(@config.get(:maestro_url)).to eq(@url)
-         end
-      end
-      
-      context 'with intermediates,' do
-         before(:all) do
-            @yYAML1={ :maestro_url => 'url1' }
-            @aArray1=[]
-            @aArray1[0]={ :maestro_url => 'url2' }
-            @aArray1[1]=@yYAML1
-            @aArray2=[]
-            @aArray2[0] = @aArray1[1]
-            @aArray2[1] = @aArray1[0]
-            @aArray3=[]
-            @aArray3[0] = { :hash_1 => { :maestro_url => 'url3'  }}
-            @aArray3[1] = { :hash_2 => { :keypair_name => 'nova' }}
-            @aArray4=[]
-            @aArray4[0] = { :hash_1 => { :keypair_name => 'nova' }}
-            @aArray4[1] = { :hash_2 => { :maestro_url => 'url4'  }}
-         end
-
-         # Obsolete.
-         #~ it 'can get data from one hash' do
-            #~ expect(@config.get(:maestro_url, @yYAML1)).to eq('url1')
-            #~ @config.set(:maestro_url, 'runtime')
-            #~ expect(@config.get(:maestro_url, @yYAML1)).to eq('runtime')
-         #~ end
-         #~ 
-         #~ it 'can get data from array of hash' do
-            #~ @config.set(:maestro_url, nil)
-            #~ expect(@config.get(:maestro_url, @aArray1)).to eq('url2')
-            #~ expect(@config.get(:maestro_url, @aArray2)).to eq('url1')
-         #~ end
-         #~ it 'can get data from array of hashes' do
-            #~ @config.set('maestro_url', nil)
-            #~ expect(@config.exist?(:maestro_url, @aArray3)).to eq('hash_1')
-            #~ expect(@config.exist?(:maestro_url, @aArray4)).to eq('hash_2')
-            #~ expect(@config.get(:maestro_url, @aArray3)).to eq('url3')
-            #~ expect(@config.get(:maestro_url, @aArray4)).to eq('url4')
-         #~ end
-      end
-   end
-end
-
-describe 'Recursive Hash functions,' do
-   context "With recursive Hash functions" do
-      it 'can create a 3 levels of hash' do
-         yYAML = rhSet(nil, 'level4', :level1, :level2, :level3)
-         expect(yYAML[:level1][:level2][:level3]).to eq('level4')
-      end
-
-      it 'can add a 3 levels of hash in an existing hash' do
-         yYAML = rhSet(nil, 'level4', :level1, :level2, :level3)
-         yYAML = rhSet(yYAML, 'level1.1', :level1_1)
-         expect(yYAML[:level1][:level2][:level3]).to eq('level4')
-         expect(yYAML[:level1_1]).to eq('level1.1')
-      end
-
-      it 'can get each levels of hash data' do
-         yYAML = rhSet(nil, 'level4', :level1, :level2, :level3)
-         expect(rhGet(yYAML, :level1).class).to equal(Hash)
-         expect(rhGet(yYAML, :level1, :level2).class).to equal(Hash)
-         expect(rhGet(yYAML, :level1, :level2, :level3).class).to equal(String)
-      end
-
-      it 'can check existence of each levels of hash data' do
-         yYAML = rhSet(nil, 'level4', :level1, :level2, :level3)
-         expect(rhExist?(yYAML, :level1)).to eq(1)
-         expect(rhExist?(yYAML, :level1, :level2)).to eq(2)
-         expect(rhExist?(yYAML, :level1, :level2, :level3)).to eq(3)
-         expect(rhExist?(yYAML, :level1_1, :level2, :level3)).to eq(0)
-
-      end
-   end
-end