mtncloud-cli 1.0.0

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

@@ -0,0 +1,36 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::CredentialTypesCommand
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::RestCommand
+
+  set_command_description "View credential types"
+  set_command_name :'credential-types'
+  register_subcommands :list, :get
+
+  # register_interfaces :credential_types
+
+  protected
+
+  def credential_type_list_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Code" => 'code',
+    }
+  end
+
+  def credential_type_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Code" => 'code',
+      # "Description" => 'description',
+      "Enabled" => lambda {|it| format_boolean(it['enabled']) },
+      "Creatable" => lambda {|it| format_boolean(it['creatable']) },
+      "Editable" => lambda {|it| format_boolean(it['editable']) },
+    }
+  end
+
+end
+

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

@@ -0,0 +1,124 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::CredentialsCommand
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::RestCommand
+
+  set_command_name :'credentials'
+  set_command_description "View and manage credentials."
+  register_subcommands :list, :get, :add, :update, :remove
+
+  # RestCommand settings
+  register_interfaces :credentials, :credential_types
+  set_rest_has_type true
+  # set_rest_type :credential_types
+
+  protected
+
+  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(credential_column_definitions(options, record), record, options)
+      print reset,"\n"
+    end
+  end
+
+  def credential_list_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Type" => lambda {|it| it['type'] ? it['type']['name'] : '' },
+    }
+  end
+
+  def credential_column_definitions(options, credential)
+    columns = [
+      {"ID" => 'id' },
+      {"Credential Store" => lambda {|it| it['integration'] ? it['integration']['name'] : 'Internal'} },
+      {"Name" => 'name' },
+      {"Description" => 'description' },
+      {"Type" => lambda {|it| it['type'] ? it['type']['name'] : '' } },
+      {"Enabled" => lambda {|it| format_boolean(it['enabled']) } },
+    ]
+    type_code = credential['type']['code']
+    if type_code == "access-key-secret"
+      columns += [
+        {"Access Key" => lambda {|it| it['username'] } },
+        {"Secret Key" => lambda {|it| it['password'] } },
+      ]
+    elsif type_code == "client-id-secret"
+      columns += [
+        {"Client ID" => lambda {|it| it['username'] } },
+        {"Client Secret" => lambda {|it| it['password'] } },
+      ]
+    elsif type_code == "email-private-key"
+      columns += [
+        {"Email" => lambda {|it| it['username'] } },
+        {"Private Key" => lambda {|it| it['authKey'] ? it['authKey']['name'] : '' } },
+      ]
+    elsif type_code == "tenant-username-keypair" || type_code == "tenant-username-key"
+      columns += [
+        {"Tenant" => lambda {|it| it['authPath'] } },
+        {"Username" => lambda {|it| it['username'] } },
+        {"Private Key" => lambda {|it| it['authKey'] ? it['authKey']['name'] : '' } },
+      ]
+    elsif type_code == "username-api-key"
+      columns += [
+        {"Username" => lambda {|it| it['username'] } },
+        {"API Key" => lambda {|it| it['password'] } },
+      ]
+    elsif type_code == "username-keypair" || type_code == "username-key"
+      columns += [
+        {"Username" => lambda {|it| it['username'] } },
+        {"Private Key" => lambda {|it| it['authKey'] ? it['authKey']['name'] : '' } },
+      ]
+    elsif type_code == "username-password"
+      columns += [
+        {"Username" => lambda {|it| it['username'] } },
+        {"Password" => lambda {|it| it['password'] } },
+      ]
+    elsif type_code == "username-password-keypair" || type_code == "username-password-key"
+      columns += [
+        {"Username" => lambda {|it| it['username'] } },
+        {"Password" => lambda {|it| it['password'] } },
+        {"Private Key" => lambda {|it| it['authKey'] ? it['authKey']['name'] : '' } },
+      ]
+    end
+    columns += [
+      {"Created" => lambda {|it| format_local_dt(it['dateCreated']) } },
+      {"Updated" => lambda {|it| format_local_dt(it['lastUpdated']) } },
+    ]
+    return columns
+  end
+
+  def add_credential_option_types()
+    [
+      {'shorthand' => '-t', 'fieldName' => 'type', 'fieldLabel' => 'Credential Type', 'type' => 'select', 'optionSource' => lambda {|api_client, api_params| 
+        api_client.credential_types.list({max:10000})['credentialTypes'].collect { |it| {"name" => it["name"], "value" => it["code"]} }
+      }, 'required' => true},
+      {'fieldName' => 'integration.id', 'fieldLabel' => 'Credential Store', 'type' => 'select', 'optionSource' => 'credentialIntegrations'},
+      {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true},
+      {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text', 'required' => false},
+      {'fieldName' => 'enabled', 'fieldLabel' => 'Enabled', 'type' => 'checkbox', 'required' => false, 'defaultValue' => true},
+    ]
+  end
+
+  def add_credential_advanced_option_types()
+    []
+  end
+
+  def update_credential_option_types()
+    [
+      {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text'},
+      {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text'},
+      {'fieldName' => 'enabled', 'fieldLabel' => 'Enabled', 'type' => 'checkbox'},
+    ]
+  end
+
+  def update_credential_advanced_option_types()
+    add_credential_advanced_option_types()
+  end
+
+end

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

@@ -0,0 +1,168 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::CurlCommand
+  include MtnCloud::Cli::CliCommand
+  set_command_name :curl
+
+  def handle(args)
+    curl_method = nil
+    curl_data = nil
+    show_progress = false
+    options = {}
+    optparse = MtnCloud::Cli::OptionParser.new do|opts|
+      opts.banner = "Usage: #{prog_name} curl [path]"
+      opts.on( '-p', '--pretty', "Print result as parsed JSON. Alias for -j" ) do
+        options[:json] = true
+      end
+      opts.on( '-X', '--request METHOD', "HTTP request method. Default is GET" ) do |val|
+        curl_method = val
+      end
+      opts.on( '--post', "Set the HTTP request method to POST" ) do
+        curl_method = "POST"
+      end
+      opts.on( '--put', "Set the HTTP request method to PUT" ) do
+        curl_method = "POST"
+      end
+      opts.on( '--delete', "Set the HTTP request method to DELETE" ) do
+        curl_method = "DELETE"
+      end
+      opts.on( '--data DATA', String, "HTTP request body for use with POST and PUT, typically JSON." ) do |val|
+        begin
+          options[:payload] = JSON.parse(val.to_s)
+        rescue => ex
+          raise ::OptionParser::InvalidOption.new("Failed to parse payload as JSON. Error: #{ex.message}")
+        end
+      end
+      opts.on('--absolute', "Absolute path, skip the addition of path prefix '/api/'") do
+        options[:absolute_path] = true
+      end
+      opts.on('--inspect', "Inspect response, prints headers. By default only the body is printed.") do
+        options[:inspect_response] = true
+      end
+      build_standard_api_options(opts, options)
+      opts.footer = <<-EOT
+Execute an HTTP request against the remote appliance api to an arbitrary path.
+[path] is required. This is the path to path to request. By default 
+By default the "/api" prefix is included in the request path.
+The --absolute option ban be used to supress this.
+
+Examples: 
+    #{prog_name} curl "/api/whoami"
+    #{prog_name} curl whoami
+    #{prog_name} curl apps -r demo
+
+EOT
+    end
+
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count: 1)
+    
+    # establish api client with connection, skips verification so check for appliance is done afterwards
+    @api_client = establish_remote_appliance_connection(options.merge({:no_prompt => true, :skip_verify_access_token => true, :skip_login => true}))
+    if !@appliance_name
+      raise_command_error "#{command_name} requires a remote to be specified, use -r [remote] or set the active remote with `remote use`"
+    end
+
+    # determine curl url, base_url is automatically applied
+    api_path = args[0].to_s.strip
+    # by default /api/ prefix is prepended
+    if options[:absolute_path] || api_path.start_with?("http:") || api_path.start_with?("https:")
+      api_path = api_path
+    else
+      api_path = "/#{api_path}" unless api_path.start_with?("/")
+      api_path = "/api#{api_path}" unless api_path.start_with?("/api")
+    end
+      
+    # build query parameters from --query k=v
+    query_params = parse_query_options(options)
+
+    # build payload from --payload '{}' and --option k=v
+    payload = parse_payload(options)
+
+    request_opts = {}
+    request_opts[:method] = curl_method ? curl_method.to_s.downcase.to_sym : :get
+    request_opts[:url] = api_path
+    request_opts[:headers] = options[:headers] if options[:headers]
+    request_opts[:params] = query_params
+    request_opts[:payload] = payload # if [:post, :put].include?(request_opts[:method])
+    request_opts[:parse_json] = false
+    @api_client.setopts(options)
+    if options[:dry_run]
+      print_dry_run @api_client.dry.execute(request_opts)
+      return
+    end
+    api_response = nil
+    json_response = nil
+    begin
+      api_response = @api_client.execute(request_opts)
+    rescue ::RestClient::Exception => e
+
+      exit_code = 1
+      err = e.message
+      #raise e
+      api_response = e.response
+      # did not get a response?
+      if api_response.nil?
+        print_rest_exception(e, options)
+        return 1, e.message
+      end
+    end
+    if api_response.nil?
+      print_rest_exception(e, options)
+      return 1, e.message
+    end
+    response_is_ok = (api_response.code.to_i >= 200 && api_response.code.to_i < 400)
+    response_is_json = api_response.headers[:content_type].to_s.start_with?("application/json")
+    if response_is_json && options[:inspect_response] != true
+      # render as json by default, so -f just works
+      # options[:json] = true unless options[:csv] ||  options[:yaml]
+      begin
+        json_response = JSON.parse(api_response.body.to_s)
+      rescue => e
+        puts_error "Failed to parse response as JSON. Error: #{e}"
+        # json_response = {}
+      end
+      # this should be default behavior, but use the first key if it is a Hash or Array
+      object_key = nil
+      if json_response && json_response.keys.first && [Hash,Array].include?(json_response[json_response.keys.first].class)
+        object_key = json_response.keys.first
+      end
+      render_response(json_response, options, object_key) do
+        output = ""
+        output << red if !response_is_ok
+        # just render the json by default, non pretty..
+        output << JSON.fast_generate(json_response)
+        output << "\n"
+        output << reset
+        if exit_code == 1
+          print output
+        elsif
+          print_error output
+        end
+      end
+    else
+      output = ""
+      output << red if !response_is_ok
+      if options[:inspect_response]
+        # instead http response (version and headers)
+        output << "HTTP/#{api_response.net_http_res.http_version} #{api_response.code}\n"
+        api_response.net_http_res.each_capitalized.each do |k,v|
+          output << "#{k}: #{v}\n"
+        end
+        output << "\n"
+        output << api_response.body.to_s
+      else
+        output << api_response.body.to_s
+      end
+      output << "\n"
+      output << reset
+      if exit_code == 0
+        print output
+      elsif
+        print_error output
+      end
+    end
+    return exit_code, err
+  end
+
+end