mtncloud-cli 1.0.0

data/lib/mtncloud/cli/commands/guidance_command.rb

@@ -0,0 +1,529 @@
+require 'mtncloud/cli/cli_command'
+require 'date' #needed?
+
+class MtnCloud::Cli::GuidanceCommand
+  include MtnCloud::Cli::CliCommand
+
+  set_command_name :'guidance'
+
+  register_subcommands :list, :get, :stats, :execute, :ignore, :types
+  
+  def connect(opts)
+    @api_client = establish_remote_appliance_connection(opts)
+    @guidance_interface = @api_client.guidance
+  end
+
+  def handle(args)
+    handle_subcommand(args)
+  end
+
+  def stats(args)
+    options = {}
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      build_standard_get_options(opts, options)
+      opts.footer = "Get guidance stats."
+    end
+    optparse.parse!(args)
+    connect(options)
+    if args.count != 0
+      raise_command_error "wrong number of arguments, expected 0 and got (#{args.count}) #{args}\n#{optparse}"
+      return 1
+    end
+
+    begin
+      @guidance_interface.setopts(options)
+
+      if options[:dry_run]
+        print_dry_run @guidance_interface.dry.stats()
+        return
+      end
+      json_response = @guidance_interface.stats()
+      if options[:json]
+        puts as_json(json_response, options, "stats")
+        return 0
+      elsif options[:yaml]
+        puts as_yaml(json_response, options, "stats")
+        return 0
+      elsif options[:csv]
+        puts records_as_csv([json_response['stats']], options)
+        return 0
+      end
+
+      stats = json_response['stats']
+
+      print_h1 "Guidance Stats"
+      print cyan
+      description_cols = {
+          "Total Actions" => lambda {|it| it['total'] },
+          "Savings Available" => lambda {|it| format_money(it['savings']['amount'], it['savings']['currency'], {:minus_color => red}) }
+      }
+      print_description_list(description_cols, stats)
+
+      print_h2 "Severity Totals"
+      {'info'=>white, 'low'=>yellow, 'warning'=>bright_yellow, 'critical'=>red}.each do |level, color|
+        print "#{cyan}#{level.capitalize}".rjust(14, ' ') + ": " + stats['severity'][level].to_s.ljust(10, ' ')
+        # print "#{cyan} #{guidance['stats']['severity'][level]} of #{guidance['stats']['severity'].collect{|k, v| v}.reduce(:+)}".ljust(20, ' ')
+        println generate_usage_bar(stats['severity'][level], stats['severity'].collect{|k, v| v}.reduce(:+), {:max_bars => 20, :bar_color => color})
+      end
+
+      # "size": 13, "shutdown": 15, "move": 0, "schedule"
+      print_h2 "Action Totals"
+      {'size'=>green, 'move'=>magenta, 'shutdown'=>red, 'schedule'=>bright_yellow}.each do |level, color|
+        print "#{cyan}#{level.capitalize}".rjust(14, ' ') + ": " + stats['type'][level].to_s.ljust(10, ' ')
+        println generate_usage_bar(stats['type'][level], stats['type'].collect{|k, v| v}.reduce(:+), {:max_bars => 20, :bar_color => color})
+      end
+      print reset, "\n"
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      return 1
+    end
+  end
+
+  def types(args)
+    options = {}
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      build_standard_get_options(opts, options)
+      opts.footer = "List discovery types."
+    end
+    optparse.parse!(args)
+    connect(options)
+    if args.count != 0
+      raise_command_error "wrong number of arguments, expected 0 and got (#{args.count}) #{args}\n#{optparse}"
+      return 1
+    end
+
+    begin
+      @guidance_interface.setopts(options)
+
+      if options[:dry_run]
+        print_dry_run @guidance_interface.dry.types()
+        return
+      end
+      json_response = @guidance_interface.types()
+      if options[:json]
+        puts as_json(json_response, options, "types")
+        return 0
+      elsif options[:yaml]
+        puts as_yaml(json_response, options, "types")
+        return 0
+      elsif options[:csv]
+        puts records_as_csv([json_response['types']], options)
+        return 0
+      end
+
+      types = json_response['types']
+
+      print_h1 "Discovery Types"
+      print cyan
+
+      cols = [
+          {"ID" => lambda {|it| it['id']}},
+          {"NAME" => lambda {|it| it['name']}},
+          {"TITLE" => lambda {|it| it['title']}},
+          {"CODE" => lambda {|it| it['code']}}
+      ];
+      print as_pretty_table(types, cols, options)
+      print reset, "\n"
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      return 1
+    end
+  end
+
+  def list(args)
+    options = {}
+    params = {}
+    ref_ids = []
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      opts.on('-l', '--severity LEVEL', String, "Filter by Severity Level: info, low, warning, critical" ) do |val|
+        params['severity'] = val
+      end
+      opts.on('-t', '--type TYPE', String, "Filter by Type") do |val|
+        options[:type] = val
+      end
+      opts.on('-i', '--ignored', String, "Include Ignored Discoveries") do |val|
+        params['state'] = 'ignored'
+      end
+      opts.on('-p', '--processed', String, "Include Processed Discoveries") do |val|
+        params['state'] = 'processed'
+      end
+      opts.on('-a', '--any', String, "Include Processed and Ignored Discoveries") do |val|
+        params['state'] = 'any'
+      end
+      build_standard_list_options(opts, options)
+      opts.footer = "List discoveries"
+    end
+    optparse.parse!(args)
+    connect(options)
+    if args.count > 0
+      print_error MtnCloud::Terminal.angry_prompt
+      puts_error  "wrong number of arguments, expected 0 and got (#{args.count}) #{args.join(', ')}\n#{optparse}"
+      return 1
+    end
+    begin
+      if options[:type]
+        type = find_discovery_type(options[:type])
+
+        if !type
+          print_red_alert "Type #{options[:type]} not found"
+          exit 1
+        end
+        params['code'] = type['code']
+      end
+
+      params.merge!(parse_list_options(options))
+      @guidance_interface.setopts(options)
+      if options[:dry_run]
+        print_dry_run @guidance_interface.dry.list(params)
+        return
+      end
+      json_response = @guidance_interface.list(params)
+      render_result = render_with_format(json_response, options, 'discoveries')
+      return 0 if render_result
+
+      discoveries = json_response['discoveries']
+
+      subtitles = params['state'] ? ["state: #{params['state']}"] : []
+      subtitles += parse_list_subtitles(options)
+      print_h1 "Discoveries", subtitles
+
+      if discoveries.empty?
+        print cyan,"No discoveries found.",reset,"\n"
+      else
+        cols = [
+            {"ID" => lambda {|it| it['id']}},
+            {"SEVERITY" => lambda {|it| (it['severity'] || '').capitalize}},
+            {"TYPE/METRIC" => lambda {|it| it['type'] ? "#{it['type']['name']}: #{it['actionCategory'].capitalize || ''}" : ''}},
+            {"ACTION" => lambda {|it| it['actionType'].capitalize}},
+            {"CLOUD" => lambda {|it| it['zone'] ? it['zone']['name'] : ''}},
+            {"RESOURCE" => lambda {|it| it['refName']}},
+            {"SAVINGS" => lambda {|it| format_money(it['savings']['amount'], it['savings']['currency'], {:minus_color => red})}},
+            {"DATE" => lambda {|it| format_local_date(it['dateCreated'], {:format => DEFAULT_TIME_FORMAT})}}
+        ];
+        if params['state'] == 'any'
+          cols << {"STATE" => lambda {|it| (it['state'] == 'processed' ? green : (it['state'] == 'ignored' ? white : '')) + it['state'].capitalize + cyan}}
+        end
+        print as_pretty_table(discoveries, cols, options)
+        print_results_pagination(json_response, {:label => "discovery", :n_label => "discoveries"})
+      end
+      print reset,"\n"
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      return 1
+    end
+  end
+
+  def get(args)
+    options = {}
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[id]")
+      build_standard_get_options(opts, options)
+      opts.footer = "Get details about a specific discovery."
+    end
+    optparse.parse!(args)
+    if args.count < 1
+      puts optparse
+      return 1
+    end
+    connect(options)
+    id_list = parse_id_list(args)
+    return run_command_for_each_arg(id_list) do |arg|
+      _get(arg, options)
+    end
+  end
+
+  def _get(id, options)
+    params = {}
+    begin
+      @guidance_interface.setopts(options)
+      if options[:dry_run]
+        print_dry_run @guidance_interface.dry.get(id, params)
+        return
+      end
+      json_response = @guidance_interface.get(id, params)
+      discovery = json_response['discovery']
+      render_result = render_with_format(json_response, options, 'discovery')
+      return 0 if render_result
+
+      print_h1 "Discovery Info"
+      print cyan
+
+      description_cols = {
+          "ID" => lambda {|it| it['id']},
+          #"Ref ID" => lambda {|it| it['refId'] },
+          "Resource" => lambda {|it| it['refName'] },
+          "Action" => lambda {|it| action_title(it['type'])},
+          "Date" => lambda {|it| format_local_date(it['dateCreated'], {:format => DEFAULT_TIME_FORMAT})},
+          "State" => lambda {|it| (it['state'] == 'processed' ? green : (it['state'] == 'ignored' ? white : cyan)) + it['state'].capitalize + cyan}
+      }
+      description_cols['Cloud'] = lambda {|it| it['zone']['name']} if discovery['refType'] == 'computeServer'
+      description_cols.merge!({
+          "Action Category" => lambda {|it| it['actionCategory'].capitalize},
+          "Action Type" => lambda {|it| it['actionType'].capitalize},
+          "Savings" => lambda {|it| format_money(it['savings']['amount'], it['savings']['currency']) + '/month'}
+      })
+      print_description_list(description_cols, discovery)
+
+      if discovery['resource']
+        print_h2 "Resource Info"
+
+        if discovery['refType'] == 'computeServer'
+          cols = [
+              {"Power State" => lambda {|it| format_status(it['resource']['powerState'])}},
+              {"Status" => lambda {|it| (format_status(it['resource']['status']))}},
+              {"Type" => lambda {|it| it['resource']['computeServerType']['name']}},
+              {"Platform" => lambda {|it| ((it['resource']['serverOs'] ? it['resource']['serverOs']['platform'] : it['resource']['osType']) || 'unknown').capitalize}},
+              {"Cloud Type" => lambda {|it| it['zone']['zoneType']['name']}}
+          ]
+        elsif discovery['refType'] == 'computeZone'
+          cols = [
+              {"Status" => lambda {|it| format_status(it['resource']['status'])}},
+              {"Cloud Type" => lambda {|it| it['zone']['zoneType']['name']}}
+          ]
+        end
+        print as_pretty_table(discovery, cols, options)
+      end
+
+      max_bars = 20
+
+      if discovery['type']['code'] == 'size'
+        print_h2 "Usage"
+        cols = [
+            {"Plan" => lambda {|it| it['planBeforeAction'] ? it['planBeforeAction']['name'] : '--'}},
+            {"Compute Usage" => lambda {|it|
+              usage = (it['config'] ? it['config']['cpuUsageAvg'] || 0 : 0)
+              "#{format_percent(usage)} of 100%".ljust(25, ' ') + generate_usage_bar(usage.round(2), 100, {:max_bars => max_bars}) + cyan
+            }},
+            {"Memory Usage" => lambda {|it|
+              max = (it['resource'] || {})['maxMemory'] || (it['planBeforeAction'] || {})['maxMemory']
+              usage = max > 0 ? (it['config']['usedMemoryAvg'] || 0).to_f / max * 100.0 : 0
+              usage = 200.0 if usage > 200
+              "#{format_bytes((it['config'] || {})['usedMemoryAvg'] || 0, 'auto', 1)} of #{format_bytes(max, 'auto', 1)}".ljust(25, ' ') + generate_usage_bar(usage, 100, {:max_bars => max_bars}) + cyan
+            }}
+        ]
+        print_description_list(cols, discovery, options.merge({:wrap => false}))
+        print_h2 "After Resize"
+
+        if discovery['planAfterAction'] && discovery['planAfterAction']['id'] != (discovery['planBeforeAction'] || {})['id']
+          cols = [
+              {"Plan" => lambda {|it| it['planAfterAction'] ? it['planAfterAction']['name'] : '--'}},
+              {"Compute Usage" => lambda {|it|
+                usage = ((it['planAfterAction'] || {})['maxCores'] || 0) > 0 ? (((it['resource'] || {})['maxCores'] || (it['planBeforeAction'] || {})['maxCores']) || 0).to_f / it['planAfterAction']['maxCores'] * (it['config']['cpuUsageAvg'] || 0) : 0
+                "#{format_percent(usage)} of 100%".ljust(25, ' ') + generate_usage_bar(usage.round(2), 100, {:max_bars => max_bars}) + cyan
+              }},
+              {"Memory Usage" => lambda {|it|
+                max = (it['planAfterAction'] || {})['maxMemory'] || 0
+                usage = max > 0 ? ((it['config'] || {})['usedMemoryAvg'] || 0).to_f / it['planAfterAction']['maxMemory'] * 100.0 : 0
+                usage = 200.0 if usage > 200
+                "#{format_bytes((it['config'] || {})['usedMemoryAvg'] || 0, 'auto', 1)} of #{format_bytes(max, 'auto', 1)}".ljust(25, ' ') + generate_usage_bar(usage, 100, {:max_bars => max_bars}) + cyan
+              }}
+          ]
+        else
+          if discovery['actionValueType'] == 'memory'
+            cols = [
+                {"Memory" => lambda {|it| format_bytes(it['actionValue'].to_i, 'auto')}},
+                {"Compute Usage" => lambda {|it|
+                  usage = (it['config'] ? it['config']['cpuUsageAvg'] || 0 : 0).round(2)
+                  "#{format_percent(usage)} of 100%".ljust(25, ' ') + generate_usage_bar(usage, 100, {:max_bars => max_bars}) + cyan
+                }},
+                {"Memory Usage" => lambda {|it|
+                  max = (it['actionValue'] || 0).to_f
+                  usage = max > 0 ? ((it['config'] || {})['usedMemoryAvg'] || 0) / max * 100.0 : 0
+                  usage = 200.0 if usage > 200
+                  "#{format_bytes((it['config'] || {})['usedMemoryAvg'] || 0, 'auto', 1)} of #{format_bytes(max, 'auto', 1)}".ljust(25, ' ') + generate_usage_bar(usage, 100, {:max_bars => max_bars}) + cyan
+                }}
+            ]
+          elsif discovery['actionValueType'] == 'cpu'
+            cols = [
+                {"Cores" => lambda {|it| it['actionValue']}},
+                {"Compute Usage" => lambda {|it|
+                  cores_before = it['beforeValue'] || (it['resource'] || {})['maxCores'] || (it['planBeforeAction'] || {})['maxCores'] || 0
+                  usage = (it['actionValue'] || 0).to_f > 0 ? cores_before / it['actionValue'].to_f * ((it['config'] || {})['cpuUsageAvg'] || 0) : 0
+                  "#{format_percent(usage)} of 100%".ljust(25, ' ') + generate_usage_bar(usage.round(2), 100, {:max_bars => max_bars}) + cyan
+                }},
+                {"Memory Usage" => lambda {|it|
+                  max = (it['resource'] || {})['maxMemory'] || (it['planAfterAction'] || {})['maxMemory']
+                  usage = max > 0 ? ((it['config'] || {})['usedMemoryAvg'] || 0) / max.to_f * 100.0 : 0
+                  usage = 200.0 if usage > 200
+                  "#{format_bytes((it['config'] || {})['usedMemoryAvg'] || 0, 'auto', 1)} of #{format_bytes(max, 'auto', 1)}".ljust(25, ' ') + generate_usage_bar(usage, 100, {:max_bars => max_bars}) + cyan
+                }}
+            ]
+          end
+        end
+        print_description_list(cols, discovery, options.merge({:wrap => false}))
+      elsif discovery['type']['code'] == 'shutdown'
+        print_h2 "Usage"
+        cols = [
+            {"Plan" => lambda {|it| it['planBeforeAction'] ? it['planBeforeAction']['name'] : '--'}},
+            {"Compute Usage" => lambda {|it|
+              usage = (it['config'] ? it['config']['cpuUsageAvg'] || 0 : 0).round(2).to_s
+              "#{format_percent(usage)} of 100%".ljust(25, ' ') + generate_usage_bar(usage, 100, {:max_bars => max_bars}) + cyan
+            }},
+            {"Network Usage" => lambda {|it|
+              max = 1024 * 1024 * 1024
+              usage = (it['config']['networkBandwidthAvg'] || 0) > 0 ? ((it['config']['networkBandwidthAvg'] || 0) / max.to_f) * 100 : 0
+              "#{format_bytes((it['config']['networkBandwidthAvg'] || 0), 'auto', 1)} of #{format_bytes(max, 'auto', 1)}".ljust(25, ' ') + generate_usage_bar( usage, 100, {:max_bars => max_bars}) + cyan
+            }}
+        ]
+
+        print_description_list(cols, discovery, options.merge({:wrap => false}))
+
+        print_h2 "After Shutdown"
+        cols = [
+            {"Plan" => lambda {|it| it['planAfterAction'] ? it['planAfterAction']['name'] : '--'}},
+            {"Monthly Savings" => lambda {|it| format_money(it['savings']['amount'], it['savings']['currency'], {:minus_color => red})}}
+        ]
+        print_description_list(cols, discovery, options)
+      elsif discovery['type']['code'] == 'reservations'
+        print_h2 "Current Cost"
+        cols = [
+            {"Current Cost" => lambda {|it| format_money((it['onDemandCost'] || 0) + (it['reservedCost'] || 0), discovery['savings']['currency'], {:minus_color => red})}},
+            {"On-Demand Cost" => lambda {|it| format_money((it['onDemandCost'] || 0), discovery['savings']['currency'], {:minus_color => red})}},
+            #{"Proposed Cost" => lambda {|it| format_money((it['recommendedCost'] || 0), discovery['savings']['currency'], {:minus_color => red})}}
+        ]
+
+        print_description_list(cols, discovery['config']['summary'], options)
+
+        print_h2 "After Reservations"
+        cols = [
+            {"Proposed Cost" => lambda {|it| format_money((it['recommendedCost'] || 0), discovery['savings']['currency'], {:minus_color => red})}},
+            {"Monthly Savings" => lambda {|it| format_money(discovery['savings']['amount'], discovery['savings']['currency'], {:minus_color => red})}},
+            {"Savings Percent" => lambda {|it| format_percent(it['totalSavingsPercent'] * 100.0)}}
+        ]
+        print_description_list(cols, discovery['config']['summary'], options)
+
+        cols = [
+            {"Name" => lambda {|it| it['name']}},
+            {"Region" => lambda {|it| it['region']}},
+            {"Term" => lambda {|it| it['term']}},
+            {"Current Cost" => lambda {|it| format_money(it['onDemandCost'], discovery['savings']['currency'], {:minus_color => red})}},
+            {"Quantity" => lambda {|it| it['recommendedCount']}},
+            {"Proposed Cost" => lambda {|it| format_money(it['recommendedCost'], discovery['savings']['currency'], {:minus_color => red})}},
+            {"Savings" => lambda {|it| format_money(it['totalSavings'], discovery['savings']['currency'], {:minus_color => red})}}
+        ]
+        print_h2 "Details"
+        print as_pretty_table(discovery['config']['detailList'], cols, options)
+      end
+
+      print reset,"\n"
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      return 1
+    end
+  end
+
+  def execute(args)
+    options = {}
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[id]")
+      build_standard_remove_options(opts, options)
+      opts.footer = "Get details about a specific discovery."
+    end
+    optparse.parse!(args)
+    if args.count < 1
+      puts optparse
+      return 1
+    end
+    connect(options)
+    _resolve_action(args[0], options)
+  end
+
+  def ignore(args)
+    options = {}
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[id]")
+      build_standard_remove_options(opts, options)
+      opts.footer = "Ignore discovery."
+    end
+    optparse.parse!(args)
+    if args.count < 1
+      puts optparse
+      return 1
+    end
+    connect(options)
+    _resolve_action(args[0], options, false)
+  end
+
+  private
+
+  def _resolve_action(id, options, is_exec=true)
+    begin
+      discovery = find_discovery(id)
+
+      if !discovery
+        print_red_alert "Discovery #{id} not found"
+        exit 1
+      end
+
+      if discovery['state'] != 'open'
+        print_green_success "#{discovery['actionTitle'].capitalize} action for #{discovery['refName']} already #{discovery['state']}."
+        return 0
+      end
+
+      unless options[:yes] || ::MtnCloud::Cli::OptionTypes::confirm("Are you sure you would like to #{is_exec ? 'execute' : 'ignore'} the #{discovery['actionTitle'].capitalize} action for #{discovery['refName']}?", options)
+        return 9, "aborted command"
+      end
+
+      @guidance_interface.setopts(options)
+      if options[:dry_run]
+        print_dry_run (is_exec ? @guidance_interface.dry.exec(discovery['id']) : @guidance_interface.dry.ignore(discovery['id']))
+        return
+      end
+
+      json_response = (is_exec ? @guidance_interface.exec(discovery['id']) : @guidance_interface.ignore(discovery['id']))
+
+      if options[:json]
+        puts as_json(json_response, options)
+      elsif !options[:quiet]
+        if json_response['success']
+          print_green_success  "Discovery successfully #{is_exec ? 'queued' : 'ignored'}"
+        else
+          print_red_alert "Error #{is_exec ? 'executing' : 'ignoring'} the #{discovery['actionTitle'].capitalize} action: #{json_response['msg'] || json_response['errors']}"
+        end
+      end
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      return 1
+    end
+  end
+
+  def find_discovery(id)
+    @guidance_interface.get(id)['discovery']
+  end
+
+  def find_discovery_type(id)
+    @guidance_interface.types()['types'].find {|it| it['id'].to_s == id.to_s || it['code'] == id || it['name'] == id}
+  end
+
+  def format_status(status)
+    color = white
+    if ['on', 'ok', 'provisioned', 'success', 'complete'].include? status
+      color = green
+    elsif ['off', 'failed', 'denied', 'cancelled', 'error'].include? status
+      color = red
+    elsif ['suspended', 'warning', 'deprovisioning', 'expired'].include? status
+      color = yellow
+    elsif ['available'].include? status
+      color = blue
+    end
+    "#{color}#{status.capitalize}#{cyan}"
+  end
+
+  def action_title(type)
+    {
+        'shutdown' => 'Shutdown Resource',
+        'size' => 'Resize Resource',
+        'hostCapacity' => 'Add Capacity',
+        'hostBalancing' => 'Balance Host',
+        'datastoreCapacity' => 'Add Capacity',
+        'reservations' => 'Reserve Compute'
+    }[type['code']] || type['title']
+  end
+end

data/lib/mtncloud/cli/commands/guidance_settings.rb

@@ -0,0 +1,148 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::GuidanceSettings
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::AccountsHelper
+
+  set_command_name :'guidance-settings'
+  set_command_description "View and manage guidance settings"
+  register_subcommands :get, :update
+
+  def connect(opts)
+    @api_client = establish_remote_appliance_connection(opts)
+    @guidance_settings_interface = @api_client.guidance_settings
+    @options_interface = @api_client.options
+  end
+
+  def handle(args)
+    handle_subcommand(args)
+  end
+
+  def get(args)
+    params = {}
+    options = {}
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      build_standard_get_options(opts, options)
+      opts.footer = "Get guidance settings."
+    end
+    optparse.parse!(args)
+    connect(options)
+    verify_args!(args:args, optparse:optparse, count:0)
+    params.merge!(parse_query_options(options))
+    @guidance_settings_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @guidance_settings_interface.dry.get(options)
+      return
+    end
+    json_response = @guidance_settings_interface.get(options)
+    render_response(json_response, options, object_key) do
+      guidance_settings = json_response[object_key]
+      print_h1 "Guidance Settings", options
+      print_h2 "Power Settings", options.merge(:border_style => :thin)
+      #Power shutdown will be suggested when all of the following baseline thresholds are exceeded for a resource
+      print_description_list({
+        "Average CPU (%)" => lambda {|it| it['cpuAvgCutoffPower'] }, # #Lower limit for average CPU usage
+        "Maximum CPU (%)" => lambda {|it| it['cpuMaxCutoffPower'] }, #Lower limit for peak CPU usage
+        "Network threshold (bytes)" => lambda {|it| it['networkCutoffPower'] }, #Lower limit for average network bandwidth
+      }, guidance_settings, options)
+      #print reset, "\n"
+
+      print_h2 "CPU Up-size Settings", options.merge(:border_style => :thin)
+      #Up-size will be suggested when all of the following baseline thresholds are exceeded for a resource
+      print_description_list({
+        "Average CPU (%)" => lambda {|it| it['cpuUpAvgStandardCutoffRightSize'] }, #Upper limit for CPU usage
+        "Maximum CPU (%)" => lambda {|it| it['cpuUpMaxStandardCutoffRightSize'] }, #Upper limit for peak CPU usage
+      }, guidance_settings, options)
+      #print reset, "\n"
+    
+      print_h2 "Memory Up-size Settings", options.merge(:border_style => :thin)
+      #Up-size is suggested when all of the following baseline thresholds are exceeded for a resource
+      print_description_list({
+        "Minimum Free Memory (%)" => lambda {|it| it['memoryUpAvgStandardCutoffRightSize'] }, #Lower limit for average free memory usage
+      }, guidance_settings, options)
+      #print reset, "\n"
+
+      print_h2 "Memory Down-size Settings", options.merge(:border_style => :thin)
+      #Down-size is suggested when all of the following baseline thresholds are exceeded for a resource
+      print_description_list({
+        #Upper limit for average free memory
+        "Average Free Memory (%)" => lambda {|it| it['memoryDownAvgStandardCutoffRightSize'] },
+        #Upper limit for peak memory usage
+        "Maximum Free Memory (%)" => lambda {|it| it['memoryDownMaxStandardCutoffRightSize'] },
+      }, guidance_settings, options)
+      print reset, "\n"
+    end
+    return 0, nil
+  end
+
+  def update(args)
+    params = {}
+    options = {}
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = opts.banner = subcommand_usage()
+      opts.on('--power-cpu-avg PERCENT', String, "Power Shutdown Average CPU (%). Lower limit for average CPU usage") do |val|
+        params['cpuAvgCutoffPower'] = val.to_i
+      end
+      opts.on('--power-cpu-max PERCENT', String, "Power Shutdown Maximum CPU (%). Lower limit for peak CPU usage") do |val|
+        params['cpuMaxCutoffPower'] = val.to_i
+      end
+      opts.on('--power-network BYTES', String, "Power Shutdown Network threshold (bytes). Lower limit for average network bandwidth") do |val|
+        params['networkCutoffPower'] = val.to_i
+      end
+      opts.on('--cpu-up-avg PERCENT', String, "CPU Up-size Average CPU (%). Upper limit for CPU usage") do |val|
+        params['cpuUpAvgStandardCutoffRightSize'] = val.to_i
+      end
+      opts.on('--cpu-up-max PERCENT', String, "CPU Up-size Maximum CPU (%). Upper limit for peak CPU usage") do |val|
+        params['cpuUpMaxStandardCutoffRightSize'] = val.to_i
+      end
+      opts.on('--memory-up-avg PERCENT', String, "Memory Up-size Minimum Free Memory (%). Lower limit for average free memory usage") do |val|
+        params['memoryUpAvgStandardCutoffRightSize'] = val.to_i
+      end
+      opts.on('--memory-down-avg PERCENT', String, "Memory Down-size Maximum Free Memory (%). Upper limit for average free memory") do |val|
+        params['memoryDownAvgStandardCutoffRightSize'] = val.to_i
+      end
+      opts.on('--memory-down-max PERCENT', String, "Memory Down-size Maximum Free Memory (%). Upper limit for peak memory usage") do |val|
+        params['memoryDownMaxStandardCutoffRightSize'] = val.to_i
+      end
+      build_standard_update_options(opts, options)
+      opts.footer = "Update guidance settings."
+    end
+    optparse.parse!(args)
+    connect(options)
+    verify_args!(args:args, optparse:optparse, count:0)
+    payload = parse_payload(options)
+    if !payload
+      payload = {}
+      payload.deep_merge!({object_key => parse_passed_options(options)}) # inject options passed with -O foo=bar
+      payload.deep_merge!({object_key => params}) # inject options --foo bar
+    end
+    if payload[object_key].empty?
+      raise_command_error "Specify at least one option to update.\n#{optparse}"
+    end
+    @guidance_settings_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @guidance_settings_interface.dry.update(payload)
+      return
+    end
+    json_response = @guidance_settings_interface.update(payload)
+    exit_code, err = 0, nil
+    render_response(json_response, options, object_key) do
+      if json_response['success']
+        print_green_success "Updated guidance settings"
+        get([] + (options[:remote] ? ["-r",options[:remote]] : []))
+      else
+        exit_code, err = 1, "Error updating guidance settings: #{json_response['msg'] || json_response['errors']}"
+        print_rest_errors(json_response)
+      end
+    end
+    return exit_code, err
+  end
+
+  private
+
+  def object_key
+    'guidanceSettings'
+  end
+
+end