morpheus-cli 5.2.4.1 → 5.3.1

data/lib/morpheus/cli/instances.rb

@@ -84,6 +84,16 @@ class Morpheus::Cli::Instances
       opts.on('--status STATUS', "Filter by status i.e. provisioning,running,starting,stopping") do |val|
         params['status'] = (params['status'] || []) + val.to_s.split(',').collect {|s| s.strip }.select {|s| s != "" }
       end
+      opts.on( '--type CODE', String, "Filter by Instance Type code" ) do |val|
+        # commas used in names a lot so use --plan one --plan two
+        params['instanceType'] ||= []
+        params['instanceType'] << val
+      end
+      opts.on( '--environment CODE', String, "Filter by Environment code(s)" ) do |val|
+        # commas used in names a lot so use --plan one --plan two
+        params['environment'] ||= []
+        params['environment'] << val
+      end
       opts.on('--pending-removal', "Include instances pending removal.") do
         options[:showDeleted] = true
       end
@@ -121,7 +131,7 @@ class Morpheus::Cli::Instances
       opts.on('-a', '--details', "Display all details: plan, stats, etc" ) do
         options[:details] = true
       end
-      build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
+      build_standard_list_options(opts, options)
       opts.footer = "List instances."
     end
     optparse.parse!(args)
@@ -130,159 +140,150 @@ class Morpheus::Cli::Instances
       options[:phrase] = args.join(" ")
     end
     connect(options)
-    begin
-      params.merge!(parse_list_options(options))
-      group = options[:group] ? find_group_by_name_or_id_for_provisioning(options[:group]) : nil
-      if group
-        params['siteId'] = group['id']
-      end
 
-      # argh, this doesn't work because group_id is required for options/clouds
-      # cloud = options[:cloud] ? find_cloud_by_name_or_id_for_provisioning(group_id, options[:cloud]) : nil
-      cloud = options[:cloud] ? find_zone_by_name_or_id(nil, options[:cloud]) : nil
-      if cloud
-        params['zoneId'] = cloud['id']
-      end
+    params.merge!(parse_list_options(options))
+    group = options[:group] ? find_group_by_name_or_id_for_provisioning(options[:group]) : nil
+    if group
+      params['siteId'] = group['id']
+    end
 
-      host = options[:host] ? find_host_by_name_or_id(options[:host]) : options[:host]
-      if host
-        params['serverId'] = host['id']
-      end
+    # argh, this doesn't work because group_id is required for options/clouds
+    # cloud = options[:cloud] ? find_cloud_by_name_or_id_for_provisioning(group_id, options[:cloud]) : nil
+    cloud = options[:cloud] ? find_zone_by_name_or_id(nil, options[:cloud]) : nil
+    if cloud
+      params['zoneId'] = cloud['id']
+    end
 
-      account = nil
-      #todo: user = find_available_user_option(owner_id)
+    host = options[:host] ? find_host_by_name_or_id(options[:host]) : options[:host]
+    if host
+      params['serverId'] = host['id']
+    end
 
-      if options[:owner]
-        created_by_ids = find_all_user_ids(account ? account['id'] : nil, options[:owner])
-        return if created_by_ids.nil?
-        params['createdBy'] = created_by_ids
-        params['ownerId'] = created_by_ids # 4.2.1+
+    account = nil
+    #todo: user = find_available_user_option(owner_id)
+
+    if options[:owner]
+      created_by_ids = find_all_user_ids(account ? account['id'] : nil, options[:owner])
+      return if created_by_ids.nil?
+      params['createdBy'] = created_by_ids
+      params['ownerId'] = created_by_ids # 4.2.1+
+    end
+
+    params['showDeleted'] = true if options[:showDeleted]
+    params['deleted'] = true if options[:deleted]
+    params['labels'] = options[:labels] if options[:labels]
+    if options[:tags]
+      options[:tags].each do |k,v|
+        params['tags.' + k] = v
       end
+    end
 
-      params['showDeleted'] = true if options[:showDeleted]
-      params['deleted'] = true if options[:deleted]
-      params['labels'] = options[:labels] if options[:labels]
-      if options[:tags]
-        options[:tags].each do |k,v|
-          params['tags.' + k] = v
+    @instances_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @instances_interface.dry.list(params)
+      return 0
+    end
+    json_response = @instances_interface.list(params)
+    all_stats = json_response['stats'] || {}
+    # merge stats into each record just to be nice...
+    if options[:include_fields] || options[:all_fields]
+      if json_response['instances']
+        if all_stats
+          json_response['instances'].each do |it|
+            it['stats'] ||= all_stats[it['id'].to_s] || all_stats[it['id']]
+          end
         end
       end
+    end
+    render_response(json_response, options, "instances") do
+      instances = json_response['instances']
 
-      @instances_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @instances_interface.dry.list(params)
-        return 0
+      title = "Morpheus Instances"
+      subtitles = []
+      if group
+        subtitles << "Group: #{group['name']}".strip
       end
-      json_response = @instances_interface.list(params)
-      if options[:json]
-        puts as_json(json_response, options, "instances")
-        return 0
-      elsif options[:yaml]
-        puts as_yaml(json_response, options, "instances")
-        return 0
-      elsif options[:csv]
-        # merge stats to be nice here..
-        if json_response['instances']
-          all_stats = json_response['stats'] || {}
-          if all_stats
-            json_response['instances'].each do |it|
-              it['stats'] ||= all_stats[it['id'].to_s] || all_stats[it['id']]
+      if cloud
+        subtitles << "Cloud: #{cloud['name']}".strip
+      end
+      if host
+        subtitles << "Host: #{host['name']}".strip
+      end
+      if options[:owner]
+        subtitles << "Created By: #{options[:owner]}"
+      end
+      subtitles += parse_list_subtitles(options)
+      print_h1 title, subtitles, options
+      if instances.empty?
+        print cyan,"No instances found.",reset,"\n"
+      else
+        # print_instances_table(instances)
+        # server returns stats in a separate key stats => {"id" => {} }
+        # the id is a string right now..for some reason..
+        all_stats = json_response['stats'] || {} 
+        if all_stats
+          instances.each do |it|
+            if !it['stats']
+              found_stats = all_stats[it['id'].to_s] || all_stats[it['id']]
+              it['stats'] = found_stats # || {}
             end
           end
         end
-        puts records_as_csv(json_response['instances'], options)
-      else
-        instances = json_response['instances']
 
-        title = "Morpheus Instances"
-        subtitles = []
-        if group
-          subtitles << "Group: #{group['name']}".strip
-        end
-        if cloud
-          subtitles << "Cloud: #{cloud['name']}".strip
-        end
-        if host
-          subtitles << "Host: #{host['name']}".strip
-        end
-        if options[:owner]
-          subtitles << "Created By: #{options[:owner]}"
-        end
-        subtitles += parse_list_subtitles(options)
-        print_h1 title, subtitles, options
-        if instances.empty?
-          print cyan,"No instances found.",reset,"\n"
-        else
-          # print_instances_table(instances)
-          # server returns stats in a separate key stats => {"id" => {} }
-          # the id is a string right now..for some reason..
-          all_stats = json_response['stats'] || {} 
-          if all_stats
-            instances.each do |it|
-              if !it['stats']
-                found_stats = all_stats[it['id'].to_s] || all_stats[it['id']]
-                it['stats'] = found_stats # || {}
-              end
+        rows = instances.collect {|instance| 
+          stats = instance['stats']
+          cpu_usage_str = !stats ? "" : generate_usage_bar((stats['usedCpu'] || stats['cpuUsage']).to_f, 100, {max_bars: 10})
+          memory_usage_str = !stats ? "" : generate_usage_bar(stats['usedMemory'], stats['maxMemory'], {max_bars: 10})
+          storage_usage_str = !stats ? "" : generate_usage_bar(stats['usedStorage'], stats['maxStorage'], {max_bars: 10})
+          if options[:details] || options[:stats]
+            if stats['maxMemory'] && stats['maxMemory'].to_i != 0
+              memory_usage_str = memory_usage_str + cyan + format_bytes_short(stats['usedMemory']).strip.rjust(8, ' ')  + " / " + format_bytes_short(stats['maxMemory']).strip
             end
-          end
-
-          rows = instances.collect {|instance| 
-            stats = instance['stats']
-            cpu_usage_str = !stats ? "" : generate_usage_bar((stats['usedCpu'] || stats['cpuUsage']).to_f, 100, {max_bars: 10})
-            memory_usage_str = !stats ? "" : generate_usage_bar(stats['usedMemory'], stats['maxMemory'], {max_bars: 10})
-            storage_usage_str = !stats ? "" : generate_usage_bar(stats['usedStorage'], stats['maxStorage'], {max_bars: 10})
-            if options[:details] || options[:stats]
-              if stats['maxMemory'] && stats['maxMemory'].to_i != 0
-                memory_usage_str = memory_usage_str + cyan + format_bytes_short(stats['usedMemory']).strip.rjust(8, ' ')  + " / " + format_bytes_short(stats['maxMemory']).strip
-              end
-              if stats['maxStorage'] && stats['maxStorage'].to_i != 0
-                storage_usage_str = storage_usage_str + cyan + format_bytes_short(stats['usedStorage']).strip.rjust(8, ' ') + " / " + format_bytes_short(stats['maxStorage']).strip
-              end
+            if stats['maxStorage'] && stats['maxStorage'].to_i != 0
+              storage_usage_str = storage_usage_str + cyan + format_bytes_short(stats['usedStorage']).strip.rjust(8, ' ') + " / " + format_bytes_short(stats['maxStorage']).strip
             end
-            row = {
-              id: instance['id'],
-              name: instance['name'],
-              connection: format_instance_connection_string(instance),
-              environment: instance['instanceContext'],
-              user: (instance['owner'] ? (instance['owner']['username'] || instance['owner']['id']) : (instance['createdBy'].is_a?(Hash) ? instance['createdBy']['username'] : instance['createdBy'])),
-              tenant: (instance['owner'] ? (instance['owner']['username'] || instance['owner']['id']) : (instance['createdBy'].is_a?(Hash) ? instance['createdBy']['username'] : instance['createdBy'])),
-              nodes: instance['containers'].count,
-              status: format_instance_status(instance, cyan),
-              type: instance['instanceType']['name'],
-              group: instance['group'] ? instance['group']['name'] : nil,
-              cloud: instance['cloud'] ? instance['cloud']['name'] : nil,
-              plan: instance['plan'] ? instance['plan']['name'] : '',
-              version: instance['instanceVersion'] ? instance['instanceVersion'] : '',
-              created: format_local_dt(instance['dateCreated']),
-              cpu: cpu_usage_str + cyan,
-              memory: memory_usage_str + cyan, 
-              storage: storage_usage_str + cyan
-            }
-            row
-          }
-          columns = [:id, {:name => {:max_width => 50}}, :group, :cloud, 
-              :type, :version, :environment, 
-              {:created => {:display_name => "CREATED"}}, 
-              # {:tenant => {:display_name => "TENANT"}}, 
-              {:user => {:display_name => "OWNER", :max_width => 20}}, 
-              :plan,
-              :nodes, {:connection => {:max_width => 30}}, :status, :cpu, :memory, :storage]
-          # custom pretty table columns ... this is handled in as_pretty_table now(), 
-          # todo: remove all these.. and try to always pass rows as the json data itself..
-          if options[:details] != true
-            columns.delete(:plan)
           end
-          print cyan
-          print as_pretty_table(rows, columns, options)
-          print reset
-          print_results_pagination(json_response)
+          row = {
+            id: instance['id'],
+            name: instance['name'],
+            connection: format_instance_connection_string(instance),
+            environment: instance['instanceContext'],
+            user: (instance['owner'] ? (instance['owner']['username'] || instance['owner']['id']) : (instance['createdBy'].is_a?(Hash) ? instance['createdBy']['username'] : instance['createdBy'])),
+            tenant: (instance['owner'] ? (instance['owner']['username'] || instance['owner']['id']) : (instance['createdBy'].is_a?(Hash) ? instance['createdBy']['username'] : instance['createdBy'])),
+            nodes: instance['containers'].count,
+            status: format_instance_status(instance, cyan),
+            type: instance['instanceType']['name'],
+            group: instance['group'] ? instance['group']['name'] : nil,
+            cloud: instance['cloud'] ? instance['cloud']['name'] : nil,
+            plan: instance['plan'] ? instance['plan']['name'] : '',
+            version: instance['instanceVersion'] ? instance['instanceVersion'] : '',
+            created: format_local_dt(instance['dateCreated']),
+            cpu: cpu_usage_str + cyan,
+            memory: memory_usage_str + cyan, 
+            storage: storage_usage_str + cyan
+          }
+          row
+        }
+        columns = [:id, {:name => {:max_width => 50}}, :group, :cloud, 
+            :type, :version, :environment, 
+            {:created => {:display_name => "CREATED"}}, 
+            # {:tenant => {:display_name => "TENANT"}}, 
+            {:user => {:display_name => "OWNER", :max_width => 20}}, 
+            :plan,
+            :nodes, {:connection => {:max_width => 30}}, :status, :cpu, :memory, :storage]
+        # custom pretty table columns ... this is handled in as_pretty_table now(), 
+        # todo: remove all these.. and try to always pass rows as the json data itself..
+        if options[:details] != true
+          columns.delete(:plan)
         end
-        print reset,"\n"
+        print cyan
+        print as_pretty_table(rows, columns, options)
+        print reset
+        print_results_pagination(json_response)
       end
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
+      print reset,"\n"
     end
+    return 0, nil
   end
 
   def count(args)
@@ -436,7 +437,7 @@ class Morpheus::Cli::Instances
       opts.on("--create-backup [on|off]", String, "Automation: Create Backups.") do |val|
         options[:create_backup] = ['on','true','1',''].include?(val.to_s.downcase) ? 'on' : 'off'
       end
-      opts.on("--security-groups LIST", String, "Security Groups, comma sepearated list of security group IDs") do |val|
+      opts.on("--security-groups LIST", String, "Security Groups, comma separated list of security group IDs") do |val|
         options[:security_groups] = val.split(",").collect {|s| s.strip }.select {|s| !s.to_s.empty? }
       end
       opts.on('--refresh [SECONDS]', String, "Refresh until status is running,failed. Default interval is #{default_refresh_interval} seconds.") do |val|
@@ -1233,7 +1234,7 @@ class Morpheus::Cli::Instances
       # opts.on( nil, '--lb', "Display Load Balancer Details" ) do
       #   options[:include_lb] = true
       # end
-      build_common_options(opts, options, [:query, :json, :yaml, :csv, :fields, :dry_run, :remote])
+      build_standard_get_options(opts, options)
       opts.footer = "Get details about an instance.\n" + 
                     "[instance] is required. This is the name or id of an instance. Supports 1-N [instance] arguments."
     end
@@ -1250,34 +1251,20 @@ class Morpheus::Cli::Instances
   end
 
   def _get(arg, options={})
-    begin
-      if options[:dry_run]
-        @instances_interface.setopts(options)
-        if arg.to_s =~ /\A\d{1,}\Z/
-          print_dry_run @instances_interface.dry.get(arg.to_i)
-        else
-          print_dry_run @instances_interface.dry.get({name:arg})
-        end
-        return
-      end
-      instance = find_instance_by_name_or_id(arg =~ /\A\d{1,}\Z/ ? arg.to_i : arg)
+    
+    if options[:dry_run]
       @instances_interface.setopts(options)
-      json_response = @instances_interface.get(instance['id'])
-      if options[:quiet]
-        return 0
-      end
-      if options[:json]
-        puts as_json(json_response, options, "instance")
-        return 0
-      elsif options[:yaml]
-        puts as_yaml(json_response, options, "instance")
-        return 0
-      end
-
-      if options[:csv]
-        puts records_as_csv([json_response['instance']], options)
-        return 0
+      if arg.to_s =~ /\A\d{1,}\Z/
+        print_dry_run @instances_interface.dry.get(arg.to_i)
+      else
+        print_dry_run @instances_interface.dry.get({name:arg})
       end
+      return
+    end
+    instance = find_instance_by_name_or_id(arg =~ /\A\d{1,}\Z/ ? arg.to_i : arg)
+    @instances_interface.setopts(options)
+    json_response = @instances_interface.get(instance['id'])
+    render_response(json_response, options, "instance") do
       instance = json_response['instance']
       stats = instance['stats'] || json_response['stats'] || {}
       # load_balancers = json_response['loadBalancers'] || {}
@@ -1494,12 +1481,8 @@ class Morpheus::Cli::Instances
           _get(arg, options)
         end
       end
-
-      return 0
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
     end
+    return 0, nil
   end
 
   def list_containers(args)

data/lib/morpheus/cli/integrations_command.rb

@@ -5,13 +5,15 @@ class Morpheus::Cli::IntegrationsCommand
   include Morpheus::Cli::AccountsHelper
 
   set_command_name :'integrations'
+  set_command_description "Integrations: View and manage integrations"
 
-  register_subcommands :list
-  set_default_subcommand :list
+  register_subcommands :list, :get, :add, :update, :remove, :refresh
+  register_subcommands :list_types, :get_type
 
   def connect(opts)
     @api_client = establish_remote_appliance_connection(opts)
     @integrations_interface = @api_client.integrations
+    @integration_types_interface = @api_client.integration_types
   end
 
   def handle(args)
@@ -22,68 +24,535 @@ class Morpheus::Cli::IntegrationsCommand
     options = {}
     params = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
-      opts.banner = subcommand_usage()
-      build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
+      opts.banner = subcommand_usage("[search]")
+      opts.on('-t', '--type CODE', "Filter by type code(s), see `list-types` for available type codes") do |val|
+        params['type'] = val
+      end
+      opts.on('--url URL', String, "Filter by url") do |val|
+        params['url'] = val
+      end
+      build_standard_list_options(opts, options)
       opts.footer = "List integrations."
     end
     optparse.parse!(args)
+    # verify_args!(args:args, optparse:optparse, count:0)
+    if args.count > 0
+      options[:phrase] = args.join(" ")
+    end
     connect(options)
-    if args.count != 0
-      raise_command_error "wrong number of arguments, expected 0 and got (#{args.count}) #{args}\n#{optparse}"
-      return 1
+    params.merge!(parse_list_options(options))
+    @integrations_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @integrations_interface.dry.list(params)
+      return
     end
+    json_response = @integrations_interface.list(params)
+    render_response(json_response, options, integration_list_key) do
+      integrations = json_response[integration_list_key]
+      print_h1 "Morpheus Integrations", parse_list_subtitles(options), options
+      if integrations.empty?
+        print cyan,"No integrations found.",reset,"\n"
+      else
+        list_columns = {
+          "ID" => 'id',
+          "Name" => 'name',
+          "Type" => lambda {|it| format_integration_type(it) },
+          "URL" => lambda {|it| it['url'] },
+          "Username" => lambda {|it| it['username'] },
+          "Enabled" => lambda {|it| format_boolean(it['enabled']) },
+          "Status Date" => lambda {|it| format_local_dt(it['statusDate']) },
+          "Status" => lambda {|it| format_integration_status(it) },
+          # "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+          # "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
+        }.upcase_keys!
+        print as_pretty_table(integrations, list_columns, options)
+        print_results_pagination(json_response)
+      end
+      print reset,"\n"
+    end
+    return 0, nil
+  end
 
-    begin
-      params.merge!(parse_list_options(options))
-      @integrations_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @integrations_interface.dry.list(params)
-        return
+  def get(args)
+    params = {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[integration]")
+      build_standard_get_options(opts, options)
+      opts.footer = <<-EOT
+Get details about a specific integration.
+[integration] is required. This is the name or id of an integration.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, min:1)
+    connect(options)
+    params.merge!(parse_query_options(options))
+    id_list = parse_id_list(args)
+    return run_command_for_each_arg(id_list) do |arg|
+      _get(arg, params, options)
+    end
+  end
+
+  def _get(id, params, options)
+    integration = nil
+    if id.to_s !~ /\A\d{1,}\Z/
+      integration = find_integration_by_name_or_id(id)
+      return 1, "integration not found for #{id}" if integration.nil?
+      id = integration['id']
+    end
+    @integrations_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @integrations_interface.dry.get(id, params)
+      return
+    end
+    json_response = @integrations_interface.get(id, params)
+    integration = json_response[integration_object_key]
+    render_response(json_response, options, integration_object_key) do
+      print_h1 "Integration Details", [], options
+      print cyan
+      show_columns = {
+        "ID" => 'id',
+        "Name" => 'name',
+        "Type" => lambda {|it| format_integration_type(it) },
+        "URL" => lambda {|it| it['url'] },
+        "Host" => lambda {|it| it['host'] },
+        "Port" => lambda {|it| it['port'] },
+        "Username" => lambda {|it| it['username'] },
+        "Password" => lambda {|it| it['password'] },
+        "Token" => lambda {|it| it['token'] },
+        "Service Key" => lambda {|it| it['serviceKey'] ? it['serviceKey']['name'] : nil },
+        "Auth Key" => lambda {|it| it['authKey'] ? it['authKey']['name'] : nil },
+        "Enabled" => lambda {|it| format_boolean(it['enabled']) },
+        "Status Date" => lambda {|it| format_local_dt(it['statusDate']) },
+        "Status" => lambda {|it| format_integration_status(it) },
+        # "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+        # "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
+      }
+      show_columns.delete("URL") if integration['url'].nil?
+      show_columns.delete("Host") if integration['host'].nil?
+      show_columns.delete("Port") if integration['port'].nil?
+      show_columns.delete("Password") if integration['password'].nil?
+      show_columns.delete("Token") if integration['token'].nil?
+      show_columns.delete("Service Key") if integration['serviceKey'].nil?
+      show_columns.delete("Auth Key") if integration['authKey'].nil?
+      print_description_list(show_columns, integration, options)
+      print reset,"\n"
+    end
+    return 0, nil
+  end
+
+  def add(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[name] -t CODE [options]")
+      # opts.on('-t', '--type CODE', "Integration Type code, see `#{command_name} list-types` for available type codes") do |val|
+      #   options[:options]['type'] = val
+      # end
+      build_option_type_options(opts, options, add_integration_option_types)
+      build_option_type_options(opts, options, add_integration_advanced_option_types)
+      build_standard_add_options(opts, options)
+      opts.footer = <<-EOT
+Create a new integration.
+[name] is required. This is the name of the new integration
+Configuration options vary by integration type.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, min:0, max:1)
+    options[:options]['name'] = args[0] if args[0]
+    connect(options)
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({integration_object_key => parse_passed_options(options)})
+    else
+      payload.deep_merge!({integration_object_key => parse_passed_options(options)})
+      # Type prompt first
+      #params['type'] = Morpheus::Cli::OptionTypes.no_prompt([{'fieldName' => 'type', 'fieldLabel' => 'Type', 'type' => 'select', 'selectOptions' => [{'name' => 'Instance', 'value' => 'instance'}, {'name' => 'Blueprint', 'value' => 'blueprint'}, {'name' => 'Workflow', 'value' => 'workflow'}], 'defaultValue' => 'instance', 'required' => true}], options[:options], @api_client, options[:params])['type']
+      v_prompt = Morpheus::Cli::OptionTypes.prompt(add_integration_option_types(), options[:options], @api_client, options[:params])
+      params.deep_merge!(v_prompt)
+      advanced_config = Morpheus::Cli::OptionTypes.no_prompt(add_integration_advanced_option_types, options[:options], @api_client, options[:params])
+      advanced_config.deep_compact!
+      params.deep_merge!(advanced_config)
+
+      # lookup type by name or code to validate it exists and to prompt for its optionTypes
+      # set integration.type=code because the api expects it that way.
+      if params['type'].to_s.empty?
+        raise_command_error "missing required option: --type TYPE", args, optparse
+      end
+      integration_type = find_integration_type_by_name_or_code_id(params['type'])
+      if integration_type.nil?
+        return 1, "integration type not found for #{params['type']}"
+      end
+      params['type'] = integration_type['code']
+      config_option_types = integration_type['optionTypes']
+      if config_option_types.nil?
+        config_option_types = @integration_types_interface.option_types(integration_type['id'])['optionTypes']
+      end
+      if config_option_types.nil?
+        print yellow,"No option types found for integration type: #{integration_type['name']} (#{integration_type['code']})", reset, "\n"
+      end
+      if config_option_types && config_option_types.size > 0
+        # optionTypes do not need fieldContext: 'integration'
+        config_option_types.each do |opt|
+          if opt['fieldContext'] == 'integration' || opt['fieldContext'] == 'domain'
+            opt['fieldContext'] = nil
+          end
+        end
+        config_prompt = Morpheus::Cli::OptionTypes.prompt(config_option_types, options[:options], @api_client, options[:params])
+        config_prompt.deep_compact!
+        params.deep_merge!(config_prompt)
       end
-      json_response = @integrations_interface.list(params)
+      # convert checkbox "on" and "off" to true and false
+      params.booleanize!
+      payload[integration_object_key].deep_merge!(params)
+    end
+    @integrations_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @integrations_interface.dry.create(payload)
+      return 0, nil
+    end
+    json_response = @integrations_interface.create(payload)
+    integration = json_response[integration_object_key]
+    render_response(json_response, options, integration_object_key) do
+      print_green_success "Added integration #{integration['name']}"
+      return _get(integration["id"], {}, options)
+    end
+    return 0, nil
+  end
 
-      render_result = render_with_format(json_response, options, 'integrations')
-      return 0 if render_result
+  def update(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[integration] [options]")
+      build_option_type_options(opts, options, update_integration_option_types)
+      build_option_type_options(opts, options, update_integration_advanced_option_types)
+      opts.on(nil, '--no-refresh', "Skip refresh on update.") do
+        params['refresh'] = 'false'
+      end
+      build_standard_update_options(opts, options)
+      opts.footer = <<-EOT
+Update an integration.
+[integration] is required. This is the name or id of an integration.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    integration = find_integration_by_name_or_id(args[0])
+    return 1 if integration.nil?
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({integration_object_key => parse_passed_options(options)})
+    else
+      payload.deep_merge!({integration_object_key => parse_passed_options(options)})
+      # do not prompt on update
+      v_prompt = Morpheus::Cli::OptionTypes.no_prompt(update_integration_option_types, options[:options], @api_client, options[:params])
+      v_prompt.deep_compact!
+      params.deep_merge!(v_prompt)
+      advanced_config = Morpheus::Cli::OptionTypes.no_prompt(update_integration_advanced_option_types, options[:options], @api_client, options[:params])
+      advanced_config.deep_compact!
+      params.deep_merge!(advanced_config)
+      # convert checkbox "on" and "off" to true and false
+      params.booleanize!
+      # massage association params a bit
+      
+      payload.deep_merge!({integration_object_key => params})
+      if payload[integration_object_key].empty? # || options[:no_prompt]
+        raise_command_error "Specify at least one option to update.\n#{optparse}"
+      end
+    end
+    @integrations_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @integrations_interface.dry.update(integration['id'], payload)
+      return
+    end
+    json_response = @integrations_interface.update(integration['id'], payload)
+    integration = json_response[integration_object_key]
+    render_response(json_response, options, integration_object_key) do
+      print_green_success "Updated integration #{integration['name']}"
+      return _get(integration["id"], {}, options)
+    end
+    return 0, nil
+  end
+
+  def refresh(args)
+    options = {}
+    query_params = {}
+    params = {}
+    payload = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[integration] [options]")
+      build_option_type_options(opts, options, update_integration_option_types)
+      build_option_type_options(opts, options, update_integration_advanced_option_types)
+      build_standard_update_options(opts, options)
+      opts.footer = <<-EOT
+Refresh an integration.
+[integration] is required. This is the name or id of an integration.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    query_params.merge!(parse_query_options(options))
+    integration = find_integration_by_name_or_id(args[0])
+    return 1 if integration.nil?
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({integration_object_key => parse_passed_options(options)})
+    else
+      payload.deep_merge!({integration_object_key => parse_passed_options(options)})
+    end
+    @integrations_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @integrations_interface.dry.refresh(integration['id'], query_params, payload)
+      return
+    end
+    json_response = @integrations_interface.refresh(integration['id'], query_params, payload)
+    integration = json_response[integration_object_key]
+    render_response(json_response, options, integration_object_key) do
+      print_green_success "Refreshed integration #{integration['name']}"
+      return _get(integration["id"], {}, options)
+    end
+    return 0, nil
+  end
 
-      title = "Morpheus Integrations"
-      subtitles = []
-      subtitles += parse_list_subtitles(options)
-      print_h1 title, subtitles
+  def remove(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[integration] [options]")
+      build_standard_remove_options(opts, options)
+      opts.footer = <<-EOT
+Delete an integration.
+[integration] is required. This is the name or id of an integration.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    integration = find_integration_by_name_or_id(args[0])
+    return 1 if integration.nil?
+    @integrations_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @integrations_interface.dry.destroy(integration['id'], params)
+      return
+    end
+    unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to delete the integration #{integration['name']}?")
+      return 9, "aborted command"
+    end
+    json_response = @integrations_interface.destroy(integration['id'], params)
+    render_response(json_response, options) do
+      print_green_success "Removed integration #{integration['name']}"
+    end
+    return 0, nil
+  end
 
-      integrations = json_response['integrations']
 
-      if integrations.empty?
-        print cyan,"No integrations found.",reset,"\n"
+  def list_types(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[search]")
+      opts.on('--optionTypes [true|false]', String, "Include optionTypes in the response. Default is false.") do |val|
+        params['optionTypes'] = (val.to_s == '' || val.to_s == 'on' || val.to_s == 'true')
+      end
+      build_standard_list_options(opts, options)
+      opts.footer = "List integration types."
+    end
+    optparse.parse!(args)
+    connect(options)
+    # verify_args!(args:args, optparse:optparse, count:0)
+    if args.count > 0
+      options[:phrase] = args.join(" ")
+    end
+    params.merge!(parse_list_options(options))
+    @integration_types_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @integration_types_interface.dry.list(params)
+      return
+    end
+    json_response = @integration_types_interface.list(params)
+    render_response(json_response, options, integration_type_list_key) do
+      integration_types = json_response[integration_type_list_key]
+      print_h1 "Morpheus Integration Types", parse_list_subtitles(options), options
+      if integration_types.empty?
+        print cyan,"No integration types found.",reset,"\n"
       else
-        rows = integrations.collect do |it|
-          {
-              id: it['id'],
-              name: it['name'],
-              status: format_integration_status(it),
-              last_updated: format_local_dt(it['statusDate']),
-              type: it['integrationType'] ? it['integrationType']['name'] : ''
-          }
-        end
-        columns = [ :id, :name, :status, :last_updated, :type]
-        print as_pretty_table(rows, columns)
+        list_columns = integration_type_column_definitions.upcase_keys!
+        print as_pretty_table(integration_types, list_columns, options)
+        print_results_pagination(json_response)
       end
       print reset,"\n"
-      return 0
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
     end
+    return 0, nil
+  end
+
+  def get_type(args)
+    params = {'optionTypes' => true}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[type]")
+      build_standard_get_options(opts, options)
+      opts.on('--optionTypes [true|false]', String, "Include optionTypes in the response. Default is true.") do |val|
+        params['optionTypes'] = (val.to_s == '' || val.to_s == 'on' || val.to_s == 'true')
+      end
+      opts.footer = <<-EOT
+Get details about a specific integration type.
+[type] is required. This is the name or id of an integration type.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, min:1)
+    connect(options)
+    params.merge!(parse_query_options(options))
+    id_list = parse_id_list(args)
+    return run_command_for_each_arg(id_list) do |arg|
+      _get_type(arg, params, options)
+    end
+  end
+
+  def _get_type(id, params, options)
+    integration_type = nil
+    if id.to_s !~ /\A\d{1,}\Z/
+      integration_type = find_integration_type_by_name_or_code(id)
+      return 1, "integration type not found for name or code '#{id}'" if integration_type.nil?
+      id = integration_type['id']
+    end
+    # /api/integration-types does not return optionTypes by default, use ?optionTypes=true
+    @integration_types_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @integration_types_interface.dry.get(id, params)
+      return
+    end
+    json_response = @integration_types_interface.get(id, params)
+    integration_type = json_response[integration_type_object_key]
+    render_response(json_response, options, integration_type_object_key) do
+      print_h1 "Integration Type Details", [], options
+      print cyan
+      show_columns = integration_type_column_definitions
+      print_description_list(show_columns, integration_type)
+
+      if integration_type['optionTypes'] && integration_type['optionTypes'].size > 0
+        print_h2 "Option Types"
+        opt_columns = [
+          # {"ID" => lambda {|it| it['id'] } },
+          {"FIELD NAME" => lambda {|it| (it['fieldContext'] && it['fieldContext'] != 'integration') ? [it['fieldContext'], it['fieldName']].join('.') : it['fieldName']  } },
+          {"FIELD LABEL" => lambda {|it| it['fieldLabel'] } },
+          {"TYPE" => lambda {|it| it['type'] } },
+          {"DEFAULT" => lambda {|it| it['defaultValue'] } },
+          {"REQUIRED" => lambda {|it| format_boolean it['required'] } },
+          # {"DESCRIPTION" => lambda {|it| it['description'] }, # do it!
+        ]
+        print as_pretty_table(integration_type['optionTypes'], opt_columns)
+      else
+        # print cyan,"No option types found for this integration type.","\n",reset
+      end
+
+      print reset,"\n"
+    end
+    return 0, nil
   end
 
   private
 
+  def format_integration_type(integration)
+    (integration['integrationType']['name'] || integration['integrationType']['code']) rescue integration['integrationType'].to_s
+  end
+
+  def add_integration_option_types
+    [
+      {'code' => 'integration.type', 'shorthand' => '-t', 'fieldName' => 'type', 'fieldLabel' => 'Type', 'type' => 'select', 'optionSource' => lambda { |api_client, api_params|
+        # @integration_types_interface.list(max:-1)[integration_list_key].collect {|it|
+        get_available_integration_types().collect {|it|
+          {'name' => it['name'], 'value' => it['code']}
+        } }, 'required' => true, 'description' => "Integration Type code, see `#{command_name} list-types` for available type codes"},
+      {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'description' => 'Name of the integration'},
+      # {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text'},
+      {'fieldName' => 'enabled', 'fieldLabel' => 'Enabled', 'type' => 'checkbox', 'defaultValue' => true, 'description' => 'Can be used to disable an integration'}
+    ]
+  end
+
+  def add_integration_advanced_option_types
+    []
+  end
+
+  def update_integration_option_types
+    list = add_integration_option_types.collect {|it|
+      it.delete('required')
+      it.delete('defaultValue')
+      it
+    }
+    list = list.reject {|it| ["type"].include? it['fieldName'] }
+    list
+  end
+
+  def update_integration_advanced_option_types
+    add_integration_advanced_option_types.collect {|it|
+      it.delete('required')
+      it.delete('defaultValue')
+      it
+    }
+  end
+
+  def integration_object_key
+    'integration'
+  end
+
+  def integration_list_key
+    'integrations'
+  end
+
+  def find_integration_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_integration_by_id(val)
+    else
+      return find_integration_by_name(val)
+    end
+  end
+
+  def find_integration_by_id(id)
+    begin
+      json_response = @integrations_interface.get(id.to_i)
+      return json_response[integration_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "integration not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_integration_by_name(name)
+    json_response = @integrations_interface.list({name: name.to_s})
+    integrations = json_response[integration_list_key]
+    if integrations.empty?
+      print_red_alert "integration not found by name '#{name}'"
+      return nil
+    elsif integrations.size > 1
+      print_red_alert "#{integrations.size} integrations found by name '#{name}'"
+      puts_error as_pretty_table(integrations, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print reset,"\n"
+      return nil
+    else
+      return integrations[0]
+    end
+  end
+
   def format_integration_status(integration, return_color=cyan)
     out = ""
     status_string = integration['status']
-    if integration['enabled'] == false
-      out << "#{red}DISABLED#{integration['statusMessage'] ? "#{return_color} - #{integration['statusMessage']}" : ''}#{return_color}"
-    elsif status_string.nil? || status_string.empty? || status_string == "unknown"
+    if status_string.nil? || status_string.empty? || status_string == "unknown"
       out << "#{white}UNKNOWN#{integration['statusMessage'] ? "#{return_color} - #{integration['statusMessage']}" : ''}#{return_color}"
+    # elsif integration['enabled'] == false
+    #   out << "#{red}DISABLED#{integration['statusMessage'] ? "#{return_color} - #{integration['statusMessage']}" : ''}#{return_color}"
     elsif status_string == 'ok'
       out << "#{green}#{status_string.upcase}#{return_color}"
     elsif status_string == 'error' || status_string == 'offline'
@@ -94,4 +563,82 @@ class Morpheus::Cli::IntegrationsCommand
     out
   end
 
+
+  def integration_type_column_definitions()
+    {
+      "ID" => 'id',
+      "Code" => 'code',
+      "Name" => 'name',
+      # "Description" => 'description',
+      "Category" => 'category',
+      # "Enabled" => lambda {|it| format_boolean(it['enabled']) },
+      "Creatable" => lambda {|it| format_boolean(it['creatable']) },
+    }
+  end
+
+  def integration_type_object_key
+    'integrationType'
+  end
+
+  def integration_type_list_key
+    'integrationTypes'
+  end
+
+  def find_integration_type_by_name_or_code_id(val, params={})
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_integration_type_by_id(val, params)
+    else
+      return find_integration_type_by_name_or_code(val)
+    end
+  end
+
+  def find_integration_type_by_id(id, params={})
+    begin
+      json_response = @integration_types_interface.get(id.to_i, params)
+      return json_response[integration_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "integration not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_integration_type_by_name(name, params={})
+    json_response = @integration_types_interface.list(params.merge({name: name.to_s}))
+    integration_types = json_response[integration_type_list_key]
+    if integration_types.empty?
+      print_red_alert "integration type not found by name '#{name}'"
+      return nil
+    elsif integration_types.size > 1
+      print_red_alert "#{integration_types.size} integration types found by name '#{name}'"
+      puts_error as_pretty_table(integration_types, [:id, :code, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print reset,"\n"
+      return nil
+    else
+      return integration_types[0]
+    end
+  end
+
+  def get_available_integration_types(refresh=false)
+    if !@available_integration_types || refresh
+      @available_integration_types = @integration_types_interface.list(max:10000)[integration_type_list_key]
+    end
+    return @available_integration_types
+  end
+  
+  def find_integration_type_by_name_or_code(name)
+    records = get_available_integration_types()
+    record = records.find { |z| z['name'].downcase == name.downcase || z['code'].downcase == name.downcase}
+    record = record ? record : records.find { |z| z['id'].to_s == name.to_s }
+    if record
+      return record
+    else
+      print_red_alert "integration type not found by '#{name}'"
+      return nil
+    end
+  end
+
 end