forj 1.0.3 → 1.0.4

data/lib/destroy.rb

@@ -0,0 +1,97 @@
+#!/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 'highline/import'
+require 'cloud_connection.rb'
+#
+# Destroy module
+#
+module Forj
+  #  This module provides the behavior to destroy your forge's server(s)
+  module Destroy
+    def self.destroy(name, options)
+      account = Lorj::Account.new(options[:config])
+
+      # Setting account at runtime layer
+      account[:account_name] = options[:account_name] if options[:account_name]
+      # Setting account at account layer
+      account.ac_load account[:account_name]
+
+      o_cloud = Forj::CloudConnection.connect(account)
+
+      o_forge = o_cloud.get(:forge, name)
+
+      if o_forge[:servers].count > 0
+        destroy_server(o_cloud, o_forge, options, account)
+      else
+        PrcLib.high_level_msg("No server(s) found on forge instance '%s'.\n",
+                              name)
+      end
+    end
+
+    def self.destroy_server(o_cloud, o_forge, options, account)
+      if options[:force]
+        # Destroy all servers found
+        o_cloud.delete(:forge)
+      else
+        server_list = get_server_list(o_forge)
+
+        o_server_number = get_server_index(server_list)
+
+        if o_server_number >= 0 && o_server_number < o_forge[:servers].count
+          # Destroy selected server
+          account.set(:forge_server, o_forge[:servers][o_server_number][:id])
+          o_cloud.delete(:forge)
+        end
+
+        # Destroy all servers found
+        o_cloud.delete(:forge) if o_server_number ==  server_list.index('all')
+        # esc
+        PrcLib.high_level_msg("No server destroyed on your demand.\n",
+                              name
+                             ) if o_server_number ==  server_list.index('esc')
+      end
+    end
+
+    def self.get_server_list(o_forge)
+      # Ask the user to get server(s) to destroy
+      server_list = []
+      index = 0
+
+      o_forge[:servers].each do |server|
+        server_list[index] = server[:name]
+        index += 1
+      end
+
+      server_list << 'all'
+      server_list << 'esc'
+
+      server_list
+    end
+
+    def self.get_server_index(server_list)
+      say('Select the index of the server you want to destroy')
+      value = choose do |q|
+        q.choices(*server_list)
+      end
+
+      o_server_number = server_list.index(value)
+
+      o_server_number
+    end
+  end
+end

data/lib/forj-settings.rb

@@ -15,208 +15,391 @@
 #    limitations under the License.
 
 module Forj
-   module Settings
-
-      def Settings.common_options(options)
-         PrcLib.set_level(Logger::INFO) if options[:verbose]
-         PrcLib.set_level(Logger::DEBUG) if options[:debug]
-         unless options[:lorj_debug].nil?
-            PrcLib.core_level = options[:lorj_debug].to_i
-            PrcLib.set_level(Logger::DEBUG)
-         end
+  # This module helps you to setup your forge's account
+  module Settings
+    def self.common_options(options)
+      PrcLib.level = Logger::INFO if options[:verbose]
+      PrcLib.level = Logger::DEBUG if options[:debug]
+      unless options[:lorj_debug].nil?
+        PrcLib.core_level = options[:lorj_debug].to_i
+        PrcLib.level = Logger::DEBUG
       end
-
-      def Settings.account_show_all(oConfig, account_name)
-         oConfig.set(:account_name, account_name)
-
-         oForjAccount = Lorj::Account.new(oConfig)
-         oForjAccount.ac_load()
-         puts "List of account settings for provider '%s': " % [oForjAccount.get(:provider)]
-         puts "%-15s %-12s :\n------------------------------" % ['key', 'section name']
-
-         oForjAccount.metadata_each { |section, found_key, hValue|
-            next if Lorj::rhGet(hValue, :readonly)
-            sDesc = Lorj::rhGet(hValue, :desc)
-            puts "%-15s %-12s : %s" % [found_key, section, sDesc]
-            }
-         puts "\nUse `forj set KeyName=Value -a %s` to set one." % [ account_name]
-         puts "Use `forj get -a %s`               to check current values." % [ account_name]
+    end
+
+    def self.account_show_all(account_name)
+      config = Lorj::Account.new
+
+      config[:account_name] = account_name
+
+      config.ac_load config[:account_name]
+      puts format(
+        "List of account settings for provider '%s': ",
+        config.get(:provider)
+           )
+      puts format(
+        "%-15s %-12s :\n------------------------------",
+        'key',
+        'section name'
+           )
+
+      config.meta_each do |section, found_key, hValue|
+        next if hValue.rh_get(:readonly)
+        s_desc = hValue.rh_get(:desc)
+        puts format('%-15s %-12s : %s', found_key, section, s_desc)
       end
-
-      def Settings.config_show_all(oConfig)
-         puts "List of available FORJ default settings:"
-         puts "%-15s %-12s :\n------------------------------" % ['key', 'section name']
-         oConfig.meta_each { |section, found_key, hValue|
-            next if Lorj::rhGet(hValue, :readonly)
-            sDesc = Lorj::rhGet(hValue, :desc)
-            puts "%-15s %-12s : %s" % [found_key, section, sDesc]
-            }
-         puts "\nUse `forj set KeyName=Value` to set one. "
-         puts "Use `forj get`               to get current values. "
+      puts format(
+        "\nUse `forj set KeyName=Value -a %s` to set one.",
+        [account_name]
+           )
+      puts format(
+        'Use `forj get -a %s`               to check current values.',
+        account_name
+           )
+    end
+
+    def self.config_show_all
+      config = Lorj::Account.new
+      puts 'List of available FORJ default settings:'
+      puts format(
+        "%-15s %-12s :\n------------------------------",
+        'key',
+        'section name'
+           )
+      config.meta_each do |section, found_key, hValue|
+        next if hValue.rh_get(:readonly)
+        s_desc = hValue.rh_get(:desc)
+        puts format('%-15s %-12s : %s', found_key, section, s_desc)
       end
+      puts "\nUse `forj set KeyName=Value` to set one. "
+      puts 'Use `forj get`               to get current values. '
+    end
+
+    def self.validate_account_set(account, account_name, account_key)
+      PrcLib.fatal(1,
+                   "Unable to update protected '%s'. use `forj setup`," \
+                   ' to update it.',
+                   account_key) if account.readonly?(account_key)
+
+      if account.meta_type?(account_key) == :default
+        PrcLib.fatal(1, "Unable set '%s' value. To update this one, use forj" \
+                     ' set %s, WITHOUT -a %s',
+                     account_key, account_key, account_name)
+      end
+    end
 
-      def Settings.account_set(oConfig, account_name, *p)
-         bDirty = false
+    def self.format_old_key(account, old_value, key_to_set)
+      s_bef = 'unset'
 
-         oConfig[:account_name] = account_name
+      s_bef = format(
+        "'%s' (%s)",
+        old_value,
+        account.exist?(key_to_set)
+      ) if account.exist?(key_to_set)
 
-         oForjAccount = Lorj::Account.new(oConfig)
-         oForjAccount.ac_load()
+      s_bef
+    end
 
-         p.flatten!
-         p.each { | key_val |
-            mkey_val = key_val.match(/^(.*) *= *(.*)$/)
+    def self.format_new_key(_o_forj_account, key_to_set)
+      s_aft = 'unset'
 
-            PrcLib.fatal(1, "Syntax error. Please set your value like: 'key=value' and retry.") if not mkey_val
+      s_aft = format(
+        "'%s' (%s)",
+        account.get(key_to_set),
+        account.exist?(key_to_set)
+      ) if account.exist?(key_to_set)
 
-            key_to_set = mkey_val[1]
-            key_value = mkey_val[2]
+      s_aft
+    end
 
-            sBef = "unset"
-            sAft = "unset"
+    def self.account_set(account_name, *p)
+      config = Lorj::Account.new
 
-            PrcLib.fatal(1, "Unable to update protected '%s'. use `forj setup`, to update it." % key_to_set) if oForjAccount.readonly?(key_to_set)
-            if oForjAccount.meta_type?(key_to_set) == :default
-               PrcLib.fatal(1, "Unable set '%s' value. To update this one, use forj set %s, WITHOUT -a %s" % [key_to_set, key_to_set, account_name])
-            end
+      b_dirty = false
 
-            full_key = '%s/%s' % [Lorj::Default.get_meta_section(key_to_set), key_to_set]
+      config[:account_name] = account_name
 
-            old_value = oForjAccount.get(key_to_set)
-            sBef = "'%s' (%s)" % [old_value, oForjAccount.exist?(key_to_set)] if oForjAccount.exist?(key_to_set)
+      config.ac_load config[:account_name]
 
-            if old_value == key_value
-               puts "%-25s: No update" % [full_key]
-               next
-            end
-            bDirty = true
+      p.flatten!
+      p.each do |key_val|
+        mkey_val = valid_key_value?(key_val)
 
-            if key_value == ""
-               oForjAccount.del(key_to_set)
-            else
-               oForjAccount.set(key_to_set, key_value)
-            end
+        key_to_set = mkey_val[1]
+        key_value = mkey_val[2]
 
-            sAft = "'%s' (%s)" % [oForjAccount.get(key_to_set), oForjAccount.exist?(key_to_set)] if oForjAccount.exist?(key_to_set)
-            puts "%-25s: %s => %s" % [full_key, sBef, ANSI.bold+sAft+ANSI.clear]
-            }
-         oForjAccount.ac_save() if bDirty
-      end
+        validate_account_set(config, account_name, key_to_set)
 
-      def Settings.config_set(oConfig, *p)
-         bDirty = false
+        full_key = format(
+          '%s/%s',
+          Lorj::Default.get_meta_auto(key_to_set),
+          key_to_set
+        )
 
-         p.flatten!
-         p.each { | key_val |
-            mkey_val = key_val.match(/^(.*) *= *(.*)$/)
+        old_value = config.get(key_to_set)
+        s_bef = format_old_key(config, old_value, key_to_set)
 
-            PrcLib.fatal(1, "Syntax error. Please set your value like: 'key=value' and retry.") if not mkey_val
+        if old_value == key_value
+          puts format('%-25s: No update', full_key)
+          next
+        end
+        b_dirty = true
 
-            key_to_set = mkey_val[1]
-            key_value = mkey_val[2]
+        if key_value == ''
+          config.del(key_to_set)
+        else
+          config.set(key_to_set, key_value)
+        end
 
-            sBef = "unset"
-            sAft = "unset"
-            if Lorj::Default.get_meta_section(key_to_set).nil?
-               PrcLib.warning("key '%s' is not a recognized default key by forj process. " % key_to_set)
-            end
+        s_aft = format_new_key(config, key_to_set)
 
-            old_value = oConfig.get(key_to_set)
-            sBef = "%s: '%s'" % [oConfig.exist?(key_to_set), oConfig.get(key_to_set)] if oConfig.exist?(key_to_set)
+        puts format(
+          '%-25s: %s => %s',
+          full_key,
+          s_bef,
+          ANSI.bold + s_aft + ANSI.clear
+             )
+      end
+      config.ac_save if b_dirty
+    end
 
-            if old_value == key_value
-               puts "%-15s: No update" % [key_to_set]
-               next
-            end
+    def self.valid_key_value?(key_val)
+      mkey_val = key_val.match(/^(.*) *= *(.*)$/)
 
-            bDirty = true
+      PrcLib.fatal(
+        1,
+        "Syntax error. Please set your value like: 'key=value' and retry."
+      ) unless mkey_val
 
-            if key_value != ""
-               oConfig.localSet(key_to_set, key_value)
-            else
-               oConfig.localDel(key_to_set)
-            end
+      mkey_val
+    end
 
-            sAft = "%s: '%s'" % [oConfig.exist?(key_to_set), oConfig.get(key_to_set)] if oConfig.exist?(key_to_set)
-            puts "%-15s: %s => %s" % [key_to_set, sBef, ANSI.bold+sAft+ANSI.clear]
-            }
-         oConfig.saveConfig() if bDirty
-      end
+    def self.valid_key?(key)
+      key = key.to_sym if key.is_a?(String)
+
+      return nil unless key.is_a?(Symbol)
 
-      def Settings.account_get_all(oConfig, account_name)
-         oConfig.set(:account_name, account_name)
-         oForjAccount = Lorj::Account.new(oConfig)
-         PrcLib.fatal(1, "Unable to load account '%s'. Not found." % account_name) if not oForjAccount.ac_load
-
-         puts "legend: default = Application defaults, local = Local default config, %s = '%s' account config\n\n" % [account_name, account_name]
-         puts "%s %-15s(%-7s) %-12s:\n----------------------------------------" % ['U', 'key', 'origin', 'section name']
-         oForjAccount.metadata_each { | section, mykey, hValue |
-            key_exist = oForjAccount.exist?(mykey)
-
-            sUpdMsg = '+'
-            sUpdMsg = ' ' if Lorj::rhGet(hValue, :readonly)
-
-            if key_exist
-               highlight = ''
-               highlight = ANSI.bold if key_exist == account_name
-               highlight = ANSI.bold + ANSI.yellow if key_exist == 'local'
-               default_key = nil
-               default_key = " (from default key '%s')" % Lorj::rhGet(hValue, :default) if Lorj::rhExist?(hValue, :default) == 1 and key_exist != account_name
-               puts "%s %-15s(%s%-7s%s) %-12s: '%s'%s" % [sUpdMsg, mykey, highlight, key_exist, ANSI.clear, section, oForjAccount.get(mykey), default_key]
-            else
-               puts "%s %-15s(       ) %-12s: unset" % [sUpdMsg, mykey, section]
-            end
-            }
-         puts "\nOn values identified by '+' you can:"
-         puts "Use `forj set <key>=<value> -a %s` to update account data." % account_name
-         puts "Or  `forj set <key>= -a %s`        to restore key default value." % account_name
+      if Lorj.defaults.get_meta_auto(key).nil?
+        PrcLib.warning("key '%s' is not a recognized default key by forj"\
+                       ' model. ', key)
       end
 
-      def Settings.config_get_all(oConfig)
-         puts "legend: default = Application defaults, local = Local default config\n\n"
-         puts "%s %-15s(%-7s) %-12s:\n----------------------------------------" % ['U', '''key', 'origin', 'section name']
-
-         oConfig.meta_each { |section, found_key, hValue|
-            sUpdMsg = '+'
-            sUpdMsg = ' ' if Lorj::rhGet(hValue, :readonly)
-            found_key = Lorj::rhGet(hValue, :default) if Lorj::rhExist?(hValue, :default) == 1
-
-            where = oConfig.exist?(found_key)
-            if where
-               highlight = ''
-               highlight = ANSI.bold + ANSI.yellow if where == 'local'
-               puts "%s %-15s(%s%-7s%s) %-12s: '%s'" % [sUpdMsg, found_key, highlight, where, ANSI.clear, section, oConfig.get(found_key) ]
-            else
-               puts "%s %-15s(       ) %-12s: unset" % [sUpdMsg, found_key, section]
-            end
-            }
-         puts "\nUse 'forj set <key>=<value>' to update defaults on values identified with '+'"
+      key
+    end
 
-      end
+    def self.config_set(*p)
+      config = Lorj::Account.new
+      b_dirty = false
+
+      p.flatten!
+
+      p.each do |key_val|
+        mkey_val = valid_key_value?(key_val)
+
+        key_to_set = mkey_val[1]
+        key_value = mkey_val[2]
+
+        s_bef = 'unset'
+        s_aft = 'unset'
+
+        key_to_set = valid_key?(key_to_set)
 
-      def Settings.account_get(oConfig, account_name, key)
+        old_value = config.get(key_to_set)
+        s_bef = format("%s: '%s'", config.where?(key_to_set)[0],
+                       config.get(key_to_set)) if config.exist?(key_to_set)
 
-         oConfig.set(:account_name, account_name)
-         oForjAccount = Lorj::Account.new(oConfig)
+        next if _no_update?(key_to_set, old_value, key_value, config)
 
-         PrcLib.fatal(1, "Unable to load account '%s'. Not found." % account_name) if not oForjAccount.ac_load
+        b_dirty = true
+
+        if key_value != ''
+          config.local_set(key_to_set, key_value)
+        else
+          config.local_del(key_to_set)
+        end
+
+        s_aft = format("%s: '%s'", config.where?(key_to_set)[0],
+                       config.get(key_to_set)) if config.exist?(key_to_set)
+
+        puts format('%-15s: %s => %s', key_to_set, s_bef, ANSI.bold(s_aft))
+      end
+      config.save_local_config if b_dirty
+    end
+
+    def self._no_update?(key_to_set, old_value, key_value, config)
+      if key_value == '' && config.where?(key_to_set)[0] != 'local'
+        puts format('%-15s: No update', key_to_set)
+        return true
+      end
+
+      if old_value == key_value
+        puts format('%-15s: No update', key_to_set)
+        return true
+      end
+      false
+    end
+
+    def self.format_highlight(account_name, config_where, where_format)
+      return format(where_format, config_where) if config_where == 'default'
+
+      return ANSI.bold(format(where_format,
+                              account_name)) if config_where == 'account'
+      ANSI.bold(ANSI.yellow(format(where_format, config_where)))
+    end
+
+    def self.get_account_values(account, account_name)
+      Lorj.defaults.meta_each do |section, mykey, hValue|
+        config_where = account.where?(mykey,
+                                      :names => %w(account local default))
+
+        s_upd_msg = '+'
+        s_upd_msg = ' ' if hValue.rh_get(:readonly)
+
+        if config_where
+          where_highlight = format_highlight(account_name,
+                                             config_where[0], '%-7s')
+          default_key = nil
+          if hValue.rh_exist?(:default) && config_where[0] != 'account'
+            default_key = format(" (from default key '%s')",
+                                 hValue.rh_get(:default))
+          end
+          puts format("%s %-15s(%s) %-12s: '%s'%s",
+                      s_upd_msg, mykey, where_highlight, section,
+                      account.get(mykey), default_key)
+        else
+          puts format(
+            '%s %-15s(       ) %-12s: unset',
+            s_upd_msg,
+            mykey,
+            section
+               )
+        end
+      end
+    end
+
+    def self.account_get_all(oConfig, account_name)
+      oConfig[:account_name] = account_name
+
+      PrcLib.fatal(1, "Unable to load account '%s'. Not found.",
+                   account_name) unless oConfig.ac_load oConfig[:account_name]
+
+      puts format(
+        'legend: default = Application defaults, local = Local' \
+          " default config, %s = '%s' account config\n\n",
+        account_name,
+        account_name)
+
+      puts format(
+        '%s %-15s(%-7s) %-12s:' + "\n" + '--------------------------' \
+          '--------------', 'U',
+        'key', 'origin',
+        'section name'
+           )
+
+      get_account_values(oConfig, account_name)
+
+      puts "\nOn values identified by '+' you can:"
+
+      puts format(
+        'Use `forj set <key>=<value> -a %s` to update account data.',
+        account_name
+           )
+      puts format(
+        'Or  `forj set <key>= -a %s`        '\
+          'to restore key default value.',
+        account_name
+           )
+    end
+
+    def self.config_get_all(oConfig)
+      puts 'legend: default = Application defaults, local = Local default' \
+           " config\n\n"
+      puts format(
+        "%s %-19s(%-7s) %-12s:\n-----------------------------------" \
+          '-----', 'U',
+        '''key', 'origin',
+        'section name'
+           )
+
+      oConfig.meta_each do |section, found_key, hValue|
+        s_upd_msg = '+'
+        s_upd_msg = ' ' if hValue.rh_get(:readonly)
+        found_key = hValue.rh_get(:default) if hValue.rh_exist?(:default)
+
+        where = oConfig.where?(found_key)
+        if where
+          where = where[0]
+          highlight = ''
+          highlight = ANSI.bold + ANSI.yellow if where == 'local'
+          puts format(
+            "%s %-19s(%s%-7s%s) %-12s: '%s'",
+            s_upd_msg,
+            found_key,
+            highlight,
+            where,
+            ANSI.clear,
+            section,
+            oConfig.get(found_key)
+               )
+        else
+          puts format(
+            '%s %-19s(       ) %-12s: unset',
+            s_upd_msg,
+            found_key,
+            section
+               )
+        end
+      end
+      puts "\nUse 'forj set <key>=<value>' to update defaults on values" \
+        " identified with '+'"
+    end
+
+    def self.account_get(oConfig, account_name, key)
+      oConfig[:account_name] = account_name
+
+      PrcLib.fatal(1, "Unable to load account '%s'. Not found.",
+                   account_name) unless oConfig.ac_load oConfig[:account_name]
+
+      if oConfig.where?(key)
+        puts format(
+          "%s: '%s'",
+          oConfig.where?(key)[0],
+          oConfig.get(key)
+             )
+      elsif oConfig.where?(key.parameterize.underscore.to_sym)
+        key_symb = key.parameterize.underscore.to_sym
+        puts format(
+          "%s: '%s'",
+          oConfig.where?(key_symb)[0],
+          oConfig.get(key_symb)
+             )
+      else
+        PrcLib.message("key '%s' not found", key)
+      end
+    end
+
+    def self.config_get(oConfig, key)
+      where = oConfig.where?(key)
+      if where
+        puts format("%s:'%s'", where[0], oConfig[key])
+      else
+        PrcLib.message("key '%s' not found", key)
+      end
+    end
 
-         if oForjAccount.exist?(key)
-            puts "%s: '%s'" % [oForjAccount.exist?(key), oForjAccount.get(key)]
-         elsif oForjAccount.exist?(key.parameterize.underscore.to_sym)
-            key_symb = key.parameterize.underscore.to_sym
-            puts "%s: '%s'" % [oForjAccount.exist?(key_symb), oForjAccount.get(key_symb)]
-         else
-            PrcLib.message("key '%s' not found"% [key])
-         end
+    def self.show_settings(options)
+      if !options[:account_name]
+        config_show_all
+      else
+        account_show_all(options[:account_name])
       end
+    end
 
-      def Settings.config_get(oConfig, key)
-         if oConfig.exist?(key)
-            puts "%s:'%s'" % [oConfig.exist?(key), oConfig.get(key)]
-         else
-            PrcLib.message("key '%s' not found" % [key])
-         end
+    def self.set_settings(options, p)
+      if options[:account_name]
+        account_set(options[:account_name], p)
+      else
+        config_set(p)
       end
-   end
+    end
+  end
 end