mtncloud-cli 1.0.0

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

@@ -0,0 +1,242 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::Ping
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::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 = MtnCloud::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 MTN Cloud 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 && (e.response.code == 404 || e.response.code == 401)
+          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
+        # setupNeeded? 
+        if json_response['setupNeeded'] == true
+          # appliance[:setup_needed] = true
+          appliance[:status] = 'fresh'
+        else
+          appliance[:status] = 'ready'
+        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
+        MtnCloud::Cli::Remote.save_remote_last_check(appliance, json_response, api_exception, took_sec)
+        # reload needed?
+        # appliance = ::MtnCloud::Cli::Remote.appliances[@appliance_name.to_sym]
+        appliance = ::MtnCloud::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 = "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) },
+              # "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
+        MtnCloud::Cli::Remote.save_remote_last_check(appliance, json_response, e, took_sec)
+        # reload?
+        appliance = ::MtnCloud::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

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

@@ -0,0 +1,214 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::PluginsCommand
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::RestCommand
+
+  set_command_name :plugins
+  set_command_description "View and manage plugins."
+  register_subcommands :list, :get, :upload, :update, :remove #, :'check-updates'
+
+  # RestCommand settings
+  register_interfaces :plugins
+
+  def upload(args)
+    options = {}
+    params = {}
+    filename = nil
+    optparse = MtnCloud::Cli::OptionParser.new do|opts|
+      opts.banner = subcommand_usage("[file]")
+      build_standard_post_options(opts, options)
+      opts.footer = <<-EOT
+Upload a plugin file.
+[file] is required. This is the path of the .jar file to upload
+This can be used to install and register a new plugin and also
+to update an existing plugin to a new version.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    filename = args[0]
+    filename = File.expand_path(filename)
+    if !File.exist?(filename)
+      raise_command_error "File not found: #{filename}"
+    elsif !File.file?(filename)
+      raise_command_error "File is a directory: #{filename}"
+    end
+    plugin_file = File.new(filename, 'rb')
+    @plugins_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @plugins_interface.dry.upload(plugin_file)
+      return
+    end
+    json_response = @plugins_interface.upload(plugin_file)
+    render_response(json_response, options) do
+      plugin = json_response[rest_object_key]
+      print_green_success "Uploaded plugin #{plugin['name']} (#{plugin['version']})"
+      # _get(plugin['id'], {}, options)
+    end
+    return 0, nil
+  end
+
+  def check_updates(args)
+    options = {}
+    params = {}
+    filename = nil
+    optparse = MtnCloud::Cli::OptionParser.new do|opts|
+      opts.banner = subcommand_usage("")
+      build_standard_post_options(opts, options)
+      opts.footer = <<-EOT
+Check for installed plugins that have available updates.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:0)
+    connect(options)
+    params.merge!(parse_query_options(options))
+    payload = parse_payload(options) do |data|
+    end
+    @plugins_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @plugins_interface.dry.check_updates(payload, params)
+      return
+    end
+    json_response = @plugins_interface.check_updates(payload, params)
+    render_response(json_response, options) do
+      plugins_to_update = json_response['pluginsToUpdate'] || []
+      if plugins_to_update.size == 1
+        print_green_success("1 plugin has an available update")
+      else
+        print_green_success("#{plugins_to_update.size} plugins have available updates")
+      end
+      if plugins_to_update.size > 0
+        print_h2 "Plugins To Update", options
+        puts as_pretty_table(plugins_to_update, [:id, :name])
+      end
+    end
+    return 0, nil
+  end
+
+  protected
+
+  def build_list_options(opts, options, params)
+    opts.on('--name VALUE', String, "Filter by name") do |val|
+      add_query_parameter(params, 'name', val)
+    end
+    opts.on('--code VALUE', String, "Filter by code") do |val|
+      add_query_parameter(params, 'code', val)
+    end
+    opts.on('--version VALUE', String, "Filter by version") do |val|
+      add_query_parameter(params, 'version', val)
+    end
+    opts.on('--status VALUE', String, "Filter by status") do |val|
+      add_query_parameter(params, 'status', val)
+    end
+    opts.on('--enabled [true|false]', String, "Filter by enabled [true|false]") do |val|
+      params['enabled'] = ['true','on','1',''].include?(val.to_s.downcase)
+    end
+    opts.on('--valid [true|false]', String, "Filter by valid [true|false]") do |val|
+      params['valid'] = ['true','on','1',''].include?(val.to_s.downcase)
+    end
+    opts.on('--has-update [true|false]', String, "Filter by hasValidUpdate [true|false]") do |val|
+      params['hasValidUpdate'] = ['true','on','1',''].include?(val.to_s.downcase)
+    end
+    super
+  end
+
+  def render_response_for_get(json_response, options)
+    render_response(json_response, options, rest_object_key) do
+      record = json_response[rest_object_key]
+      print_h1 rest_label, [], options
+      print cyan
+      print_description_list(rest_column_definitions(options), record, options)
+      if record['statusMessage'].to_s != ''
+        print_h2 "Status Message", options
+        if record['status'].to_s.downcase == 'error'
+          print red, record['statusMessage'], reset, "\n"
+        else
+          print record['statusMessage'], "\n"
+        end
+      end
+      # Plugin Providers
+      providers = record['providers']
+      if providers && !providers.empty?
+        print_h2 "Providers"
+        print as_pretty_table(providers, [:name, :type], options)
+      end
+      # Plugin Configuration
+      option_types = record["optionTypes"].sort {|a,b| a['displayOrder'].to_i <=> b['displayOrder'].to_i}
+      config = record['config'] || {}
+      if option_types && !option_types.empty?
+        print_h2 "Configuration"
+        rows = option_types.collect do |option_type|
+          {:label => option_type['fieldLabel'], :name => option_type['fieldName'], :value => config[option_type['fieldName']]}
+        end
+        print as_pretty_table(rows, [:label, :name, :value], options)
+      end
+      print reset,"\n"
+    end
+  end
+
+  def plugin_list_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      # "Code" => 'code',
+      "Description" => 'description',
+      "Version" => lambda {|it| it['version'] },
+      "Enabled" => lambda {|it| format_boolean it['enabled'] },
+      "Status" => lambda {|it| format_plugin_status(it) },
+    }
+  end
+
+  def plugin_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Code" => 'code',
+      "Description" => 'description',
+      "Version" => lambda {|it| it['version'] },
+      "Author" => 'author',
+      "Enabled" => lambda {|it| format_boolean it['enabled'] },
+      "Valid" => lambda {|it| format_boolean it['valid'] },
+      "Has Update?" => lambda {|it| format_boolean it['hasValidUpdate'] },
+      "Status" => lambda {|it| format_plugin_status(it) },
+      "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+      "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
+    }
+  end
+
+  def add_plugin_option_types()
+    [
+      {'fieldName' => 'enabled', 'fieldLabel' => 'Enabled', 'type' => 'checkbox', 'required' => false, 'defaultValue' => true},
+    ]
+  end
+
+  def add_plugin_advanced_option_types()
+    []
+  end
+
+  def update_plugin_option_types()
+    option_types = add_plugin_option_types.collect {|it| it.delete('required'); it.delete('defaultValue'); it.delete('dependsOnCode'); it }
+    option_types.reject! {|it| it['fieldName'] == 'type' }
+    option_types
+  end
+
+  def update_plugin_advanced_option_types()
+    add_plugin_advanced_option_types().collect {|it| it.delete('required'); it.delete('defaultValue'); it.delete('dependsOnCode'); it }
+  end
+
+  def format_plugin_status(plugin, return_color=cyan)
+    out = ""
+    status_string = plugin['status'].to_s.downcase
+    if status_string == 'loaded'
+      out << "#{green}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'error'
+      out << "#{red}#{status_string ? status_string.upcase : 'N/A'}#{plugin['statusMessage'] ? "#{return_color} - #{plugin['statusMessage']}" : ''}#{return_color}"
+    else
+      out << "#{cyan}#{status_string.upcase}#{return_color}"
+    end
+    out
+  end
+
+end