morpheus-cli 4.2.8 → 4.2.10

data/lib/morpheus/cli/mixins/remote_helper.rb

@@ -0,0 +1,139 @@
+require 'morpheus/cli/mixins/print_helper'
+
+# Mixin for Morpheus::Cli command classes
+# Provides common methods for working with remotes
+module Morpheus::Cli::RemoteHelper
+
+  def self.included(klass)
+    klass.send :include, Morpheus::Cli::PrintHelper
+  end
+
+  def format_appliance_name(appliance)
+    app_name = appliance[:name]
+    if app_name == 'remote-url'
+      "(remote-url)"
+    else
+      app_name
+    end
+  end
+
+  def format_appliance_slug(appliance)
+    "[#{format_appliance_name(appliance)}] #{appliance[:url]}"
+  end
+
+  def format_appliance_status(appliance, return_color=cyan, show_current=false)
+    return "" if !appliance
+    status_str = appliance[:status] || appliance['status'] || "unknown" # get_object_value(appliance, :status)
+    status_str = status_str.to_s # Symbols getting in here?
+    status_str = status_str.empty? ? "unknown" : status_str.to_s.downcase
+    status_str = status_str.gsub("-", " ") # change "http-error" to "http error"
+    out = ""
+    status_color = format_appliance_status_color(appliance)
+    out << "#{status_color}#{status_str.upcase}#{return_color}"
+    # meh, probably keep this separate
+    if show_current && appliance[:active]
+      out << " " + format_is_current() + return_color
+    end
+    out
+  end
+
+  def format_appliance_status_color(appliance)
+    status = appliance[:status].to_s.downcase
+    if status == 'ready'
+      green
+    elsif status == 'fresh'
+      magenta
+    elsif status == 'new'
+      cyan
+    elsif ['error', 'http-error', 'net-error', 'ssl-error', 'http-timeout', 'unreachable', 'unrecognized'].include?(status)
+      red
+    else
+      yellow
+    end
+  end
+
+  def format_is_current(return_color=cyan)
+    "#{cyan}#{bold}(current)#{reset}#{return_color}"
+  end
+
+  def format_appliance_secure(app_map, return_color=cyan)
+    return "" if !app_map
+    out = ""
+    app_url = (app_map[:url] || app_map[:host]).to_s
+    is_ssl = app_url =~ /^https/
+    if !is_ssl
+      # out << "No (no SSL)"
+      out << "No"
+    else
+      if app_map[:insecure]
+        # out << "No (Ignore SSL Errors)"
+        out << "No"
+      else
+        # should have a flag that gets set when everything actually looks good..
+        out << "Yes"
+      end
+    end
+    out
+  end
+
+  # get display info about the current and past sessions
+  # 
+  def get_appliance_session_blurbs(app_map)
+    # app_map = OStruct.new(app_map)
+    blurbs = []
+    # Current User
+    # 
+    username = app_map[:username]
+    
+    # if app_map[:active]
+    #   blurbs << "(current)"
+    # end
+    if app_map[:status] == 'ready'
+
+      if app_map[:authenticated]
+        #blurbs << app_map[:username] ? "Authenticated as #{app_map[:username]}" : "Authenticated"
+        # blurbs << "Authenticated."
+        if app_map[:last_login_at]
+          blurbs << "Logged in #{format_duration_ago(app_map[:last_login_at])}"
+        end
+      else
+        if app_map[:last_logout_at]
+          blurbs << "Logged out #{format_duration_ago(app_map[:last_logout_at])}"
+        else
+          #blurbs << "Logged out"
+        end
+        if app_map[:last_login_at]
+          blurbs << "Last login #{format_duration_ago(app_map[:last_login_at])}"
+        end
+      end
+
+      if app_map[:last_success_at]
+        blurbs << "Last success #{format_duration_ago(app_map[:last_success_at])}"
+      end
+
+    else
+      
+      if app_map[:last_check]
+        if app_map[:last_check][:timestamp]
+          blurbs << "Last checked #{format_duration_ago(app_map[:last_check][:timestamp])}"
+        end
+        if app_map[:last_check][:error]
+          last_error_msg = truncate_string(app_map[:last_check][:error], 250)
+          blurbs << "Error: #{last_error_msg}"
+        end
+        if app_map[:last_check][:http_status]
+          blurbs << "HTTP #{app_map[:last_check][:http_status]}"
+        end
+      end
+
+      if app_map[:last_success_at]
+        blurbs << "Last Success: #{format_duration_ago(app_map[:last_success_at])}"
+      end
+
+    end
+
+    return blurbs
+  end
+
+
+end

data/lib/morpheus/cli/monitoring_checks_command.rb

@@ -28,9 +28,10 @@ class Morpheus::Cli::MonitoringChecksCommand
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage()
       # todo: api to load type id by name
-      # opts.on('--type VALUE', Array, "Filter by status. error,healthy,warning,muted") do |val|
-      #   params['checkType'] = val
-      # end
+      opts.on('-t', '--type TYPE', String, "Filter by Check Type") do |val|
+        options[:type] ||= []
+        options[:type] << val
+      end
       opts.on('--status VALUE', Array, "Filter by status. error,healthy,warning,muted") do |val|
         params['status'] = val
       end
@@ -40,6 +41,10 @@ class Morpheus::Cli::MonitoringChecksCommand
     connect(options)
     begin
       params.merge!(parse_list_options(options))
+      if options[:type]
+        # API works with type code or name
+        params['type'] = options[:type]
+      end
       @monitoring_checks_interface.setopts(options)
       if options[:dry_run]
         print_dry_run @monitoring_checks_interface.dry.list(params)
@@ -59,6 +64,9 @@ class Morpheus::Cli::MonitoringChecksCommand
       checks = json_response['checks']
       title = "Morpheus Monitoring Checks"
       subtitles = []
+      if options[:type]
+        subtitles << "Type: #{options[:type].join(',')}"
+      end
       subtitles += parse_list_subtitles(options)
       print_h1 title, subtitles, options
       if checks.empty?

data/lib/morpheus/cli/network_groups_command.rb

@@ -246,7 +246,7 @@ class Morpheus::Cli::NetworkGroupsCommand
         end
       end
       opts.on('--group-access-all [on|off]', String, "Toggle Access for all groups.") do |val|
-        group_access_all = val.to_s == 'on' || val.to_s == 'true'
+        group_access_all = val.to_s == 'on' || val.to_s == 'true' || val.to_s == ''
       end
       opts.on('--group-access LIST', Array, "Group Access, comma separated list of group IDs.") do |list|
         if list.size == 1 && list[0] == 'null' # hacky way to clear it
@@ -442,7 +442,7 @@ class Morpheus::Cli::NetworkGroupsCommand
         end
       end
       opts.on('--group-access-all [on|off]', String, "Toggle Access for all groups.") do |val|
-        group_access_all = val.to_s == 'on' || val.to_s == 'true'
+        group_access_all = val.to_s == 'on' || val.to_s == 'true' || val.to_s == ''
       end
       opts.on('--group-access LIST', Array, "Group Access, comma separated list of group IDs.") do |list|
         if list.size == 1 && list[0] == 'null' # hacky way to clear it
@@ -579,6 +579,12 @@ class Morpheus::Cli::NetworkGroupsCommand
           payload['networkGroup']['active'] = options['active']
         end
         
+        # pre 4.2.1, would error with data not found unless you pass something in here
+        # so pass foo=bar so you can update just resourcePermissions
+        if payload['networkGroup'] && payload['networkGroup'].empty? && payload['resourcePermissions']
+          payload['networkGroup']['foo'] = 'bar'
+        end
+
       end
       @network_groups_interface.setopts(options)
       if options[:dry_run]

data/lib/morpheus/cli/option_types.rb

@@ -320,7 +320,7 @@ module Morpheus
             select_options = load_source_options(option_type['optionSource'], api_client, grails_params(api_params || {}))
           end
         else
-          raise "select_prompt() requires selectOptions or optionSource!"
+          raise "option '#{field_key}' is type: 'select' and missing selectOptions or optionSource!"
         end
 
         # ensure the preselected value (passed as an option) is in the dropdown

data/lib/morpheus/cli/ping.rb

@@ -0,0 +1,252 @@
+# require 'yaml'
+require 'io/console'
+require 'rest_client'
+require 'optparse'
+require 'morpheus/cli/cli_command'
+require 'morpheus/cli/mixins/whoami_helper'
+require 'morpheus/cli/mixins/accounts_helper'
+require 'json'
+
+class Morpheus::Cli::Ping
+  include Morpheus::Cli::CliCommand
+  include Morpheus::Cli::RemoteHelper
+
+  set_command_name :ping
+
+  def connect(options={})
+    @api_client = establish_remote_appliance_connection({:no_authorization => true}.merge(options))
+    @ping_interface = @api_client.ping
+    @setup_interface = @api_client.setup
+  end
+
+  def handle(args)
+    get(args)
+  end
+
+  def get(args)
+    exit_code, err = 0, nil
+    params, options = {}, {}
+    status_only, time_only, setup_check_only = false, false, false
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = usage
+      opts.on( '-s', '--status', "Print only the status." ) do
+        status_only = true
+      end
+      opts.on( '-t', '--time', "Print only the response time." ) do
+        time_only = true
+      end
+      opts.on( '--setup-needed?', "Print only if setup is needed or not, exit 1 if not." ) do
+        setup_check_only = true
+      end
+      # --timeout always works, this would just make it show up?
+      # opts.on( '--timeout SECONDS', "Timeout for api requests. Default is 5 seconds." ) do |val|
+      #   options[:timeout] = val ? val.to_f : nil
+      #   # note that setting :timeout works via interface.setopts(options)
+      # end
+      build_standard_get_options(opts, options, [:quiet])
+      opts.footer = <<-EOT
+Ping the remote morpheus appliance.
+Prints the remote version and status and the time it took to get a response.
+
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, count:0, optparse:optparse)
+    connect(options)
+    took_sec = nil
+    begin
+      # construct parameters
+      params.merge!(parse_query_options(options))
+
+      # error if we could not determine a remote, this should happen by in connect()
+      # if !@remote_appliance
+      #   raise_command_error "#{command_name} requires a remote to be specified, use -r [remote] or set the active remote with `remote use`"
+      # end
+      appliance = @remote_appliance
+      
+      # set api client options
+      @ping_interface.setopts(options)
+      @setup_interface.setopts(options)
+
+      # dry run, print the would be request
+      if options[:dry_run]
+        print_dry_run @ping_interface.dry.get(params)
+        return 0
+      end
+      # execute the api request
+      # /api/ping is new in 4.2.1, so fallback to /api/setup/check, the data is the same-ish
+      api_exception = nil
+      json_response = nil
+      start_time = Time.now
+      begin
+        json_response = @ping_interface.get(params)
+      rescue RestClient::Exception => e
+        # api_exception = e
+        # fallback to older /api/setup/check, which is also public and looks just about the same
+        if e.response.code == 404
+          start_time = Time.now
+          begin
+            json_response = @setup_interface.check(params)
+          rescue RestClient::Exception => e2
+            begin
+              json_response = JSON.parse(e2.response.to_s)
+            rescue TypeError, JSON::ParserError => ex
+              #print_error red, "Failed to parse JSON response: #{ex}", reset, "\n"
+              json_response = nil
+            end
+          end
+        end
+      rescue => e
+        api_exception = e
+      ensure
+        took_sec = (Time.now - start_time)
+      end
+
+      # update appliance settings with /ping response (or /setup/check) ie. buildVersion
+      # this also happens in save_remote_last_check() but remote_url doesnt use that
+      if json_response
+        # update buildVersion
+        if json_response['buildVersion']
+          appliance[:build_version] = json_response['buildVersion']
+        end
+        # update applianceUrl
+        if json_response['applianceUrl']
+          appliance[:appliance_url] = json_response['applianceUrl']
+        end
+        # set status to ready if we have a version but no status yet for some reason
+        if appliance[:build_version] && appliance[:status].nil?
+          appliance[:status] = 'ready'
+        end
+        # update setupNeeded? 
+        if json_response['setupNeeded'] == true
+          # appliance[:setup_needed] = true
+          appliance[:status] = 'fresh'
+        end
+        # if took_sec
+        #   appliance[:last_check] ||= {}
+        #   appliance[:last_check][:took] = took_sec
+        # end
+      else
+        # appliance[:status] = 'error'
+      end
+
+      # don't ever save with --remote-url
+      if options[:remote_url].nil?
+        # save response to appliance data
+        Morpheus::Cli::Remote.save_remote_last_check(appliance, json_response, api_exception, took_sec)
+        # reload needed?
+        # appliance = ::Morpheus::Cli::Remote.appliances[@appliance_name.to_sym]
+        appliance = ::Morpheus::Cli::Remote.load_remote(@appliance_name)
+      end
+      
+      # determine exit status, 0 is good
+      exit_code, err = 0, nil
+      if appliance[:status] != 'ready' && appliance[:status] != 'fresh'
+        exit_code = 1
+        # err = appliance[:error]
+      end
+      
+      # render
+      render_response(json_response, options) do
+        if json_response.nil?
+          json_response = {}
+        end
+        if false && json_response.nil?
+          print_error yellow, "No ping data returned.",reset,"\n"
+        else
+          # print output
+          if status_only
+            if exit_code == 0
+              print format_appliance_status(appliance, cyan), reset, "\n"
+            else
+              print_error format_appliance_status(appliance, cyan), reset, "\n"
+            end
+            return exit_code, err
+          elsif time_only
+            status_color = format_appliance_status_color(appliance)
+            if exit_code == 0
+              print status_color, format_duration_seconds(took_sec), reset, "\n"
+            else
+              print_error status_color, format_duration_seconds(took_sec), reset, "\n"
+            end
+            return exit_code, err
+          elsif setup_check_only
+            status_color = format_appliance_status_color(appliance)
+            remote_status_string = format_appliance_status(appliance, cyan)
+            if appliance[:status] != 'fresh'
+              exit_code = 1
+            end
+            if appliance[:status] == 'fresh'
+              print cyan, "Yes, remote #{appliance[:name]} status is #{remote_status_string}","\n"
+            elsif appliance[:status] == 'ready'
+              print cyan, "No, remote #{appliance[:name]} status is #{remote_status_string} (already setup)","\n"
+            else
+              print_error cyan,"Uh oh, remote #{appliance[:name]} status is #{remote_status_string}",reset,"\n"
+            end
+            return exit_code, err
+          else
+            title = "Morpheus Ping"
+            subtitles = []
+            print_h1 title, subtitles, options
+            #print_green_success "Completed ping of #{appliance[:name]} (#{format_duration_seconds(took_sec)})"
+            #print "\n"
+            error_string = appliance[:last_check] ? appliance[:last_check][:error] : nil
+            columns = {
+              "Name" => lambda {|it| appliance[:name] },
+              #"Name" => lambda {|it| appliance[:active] ? "#{appliance[:name]} #{bold}(current)#{reset}#{cyan}" : appliance[:name] },
+              "URL" => lambda {|it| appliance[:url] },
+              #"Appliance URL" => lambda {|it| it['applianceUrl'] },
+              "Version" => lambda {|it| appliance[:build_version] },
+              # "Active" => lambda {|it| it[:active] ? "Yes " + format_is_current() : "No" },
+              "Response Time" => lambda {|it| format_duration_seconds(took_sec) },
+              #"Response Time" => lambda {|it| format_sig_dig(took_sec, 3) + "s" rescue "" },
+              # "Error" => lambda {|it| error_string },
+              "Status" => lambda {|it| format_appliance_status(appliance, cyan) },
+            }
+            if error_string.to_s.empty?
+              columns.delete("Error")
+            end
+
+            print_description_list(columns, json_response, options)
+
+            if error_string.to_s != ""
+              #print_h2 "Error", options
+              print "\n"
+              print red, error_string, "\n",reset
+            end
+          end
+          print reset, "\n"
+        end
+      end
+      return exit_code, err
+
+
+    rescue RestClient::Exception => e
+      # don't ever save with --remote-url
+      if options[:remote_url].nil?
+        # save response to appliance data
+        Morpheus::Cli::Remote.save_remote_last_check(appliance, json_response, e, took_sec)
+        # reload?
+        appliance = ::Morpheus::Cli::Remote.load_remote(appliance[:name])
+      end
+      # print output
+      if status_only
+        print format_appliance_status(appliance, cyan), reset, "\n"
+        return exit_code, err
+      elsif time_only
+        status_color = format_appliance_status_color(appliance)
+        print status_color, format_duration_seconds(took_sec), reset, "\n"
+        return exit_code, err
+      else
+        if e.response
+          print_red_alert "ping failed in #{format_duration_seconds(took_sec)} (HTTP #{e.response.code})"
+        else
+          print_red_alert "ping failed in #{format_duration_seconds(took_sec)}"
+        end
+      end
+      print_rest_exception(e, options)
+      return 1, e.message
+    end
+  end
+
+end