morpheus-cli 5.3.1 → 5.3.2.2

data/lib/morpheus/cli/hosts.rb

@@ -32,14 +32,14 @@ class Morpheus::Cli::Hosts
     @api_client = establish_remote_appliance_connection(opts)
     @accounts_interface = @api_client.accounts
     @users_interface = @api_client.users
-    @clouds_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).clouds
-    @options_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).options
-    @tasks_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).tasks
-    @task_sets_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).task_sets
-    @servers_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).servers
-    @server_types_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).server_types
-    @logs_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).logs
-    @accounts_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).accounts
+    @clouds_interface = @api_client.clouds
+    @options_interface = @api_client.options
+    @tasks_interface = @api_client.tasks
+    @task_sets_interface = @api_client.task_sets
+    @servers_interface = @api_client.servers
+    @server_types_interface = @api_client.server_types
+    @logs_interface = @api_client.logs
+    @accounts_interface = @api_client.accounts
     @active_group_id = Morpheus::Cli::Groups.active_groups[@appliance_name]
     @execution_request_interface = @api_client.execution_request
     @clusters_interface = @api_client.clusters

data/lib/morpheus/cli/image_builder_command.rb

@@ -30,15 +30,15 @@ class Morpheus::Cli::ImageBuilderCommand
 
   def connect(opts)
     @api_client = establish_remote_appliance_connection(opts)
-    @image_builder_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).image_builder
+    @image_builder_interface = @api_client.image_builder
     @image_builds_interface = @image_builder_interface.image_builds
     @boot_scripts_interface = @image_builder_interface.boot_scripts
     @preseed_scripts_interface = @image_builder_interface.preseed_scripts
-    @groups_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).groups
-    @clouds_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).clouds
-    @instances_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).instances
-    @instance_types_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).instance_types
-    @options_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).options
+    @groups_interface = @api_client.groups
+    @clouds_interface = @api_client.clouds
+    @instances_interface = @api_client.instances
+    @instance_types_interface = @api_client.instance_types
+    @options_interface = @api_client.options
     @active_group_id = Morpheus::Cli::Groups.active_groups[@appliance_name]
   end
 

data/lib/morpheus/cli/instance_types.rb

@@ -17,7 +17,7 @@ class Morpheus::Cli::InstanceTypes
 
   def connect(opts)
     @api_client = establish_remote_appliance_connection(opts)
-    @instance_types_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).instance_types
+    @instance_types_interface = @api_client.instance_types
   end
 
   def handle(args)

data/lib/morpheus/cli/instances.rb

@@ -130,6 +130,7 @@ class Morpheus::Cli::Instances
       end
       opts.on('-a', '--details', "Display all details: plan, stats, etc" ) do
         options[:details] = true
+        params['details'] = true # get more data from server this way
       end
       build_standard_list_options(opts, options)
       opts.footer = "List instances."
@@ -1201,7 +1202,15 @@ class Morpheus::Cli::Instances
         options[:details] = true
         options[:include_containers] = true
         options[:include_scaling] = true
+        options[:include_costs]
       end
+      opts.on(nil, '--details', "Alias for --all" ) do
+        options[:details] = true
+        options[:include_containers] = true
+        options[:include_scaling] = true
+        options[:include_costs]
+      end
+      opts.add_hidden_option('--details')
       opts.on( nil, '--containers', "Display Instance Containers" ) do
         options[:include_containers] = true
       end
@@ -1216,9 +1225,6 @@ class Morpheus::Cli::Instances
       opts.on( nil, '--scaling', "Display Instance Scaling Settings" ) do
         options[:include_scaling] = true
       end
-      opts.on( nil, '--costs', "Display Cost and Price" ) do
-        options[:include_costs] = true
-      end
       opts.on('--refresh [SECONDS]', String, "Refresh until status is running,failed. Default interval is #{default_refresh_interval} seconds.") do |val|
         options[:refresh_until_status] ||= "running,failed"
         if !val.to_s.empty?
@@ -1250,22 +1256,29 @@ class Morpheus::Cli::Instances
     end
   end
 
-  def _get(arg, options={})
-    
+  def _get(id, options={})
+    params = {}
+    params.merge!(parse_query_options(options))
+    # Use details=true to get more details from the appliance
+    # if options[:details] || options[:include_containers]  || options[:include_scaling]
+    if options[:details] || options[:include_containers]  || options[:include_scaling]
+      params['details'] = true
+    end
+    instance = nil
+    if id.to_s !~ /\A\d{1,}\Z/
+      instance = find_instance_by_name_or_id(id)
+      return 1, "Instance not found by name #{id}" if instance.nil?
+      id = instance['id']
+    end
     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
+      print_dry_run @instances_interface.dry.get(id, params)
+      return 0, nil
     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'])
+    json_response = @instances_interface.get(id, params)
     render_response(json_response, options, "instance") do
       instance = json_response['instance']
+      pricing = instance['instancePrice']
       stats = instance['stats'] || json_response['stats'] || {}
       # load_balancers = json_response['loadBalancers'] || {}
       # metadata tags used to be returned as metadata and are now returned as tags
@@ -1283,7 +1296,12 @@ class Morpheus::Cli::Instances
       # containers are fetched via separate api call
       containers = nil
       if options[:include_containers]
-        containers = @instances_interface.containers(instance['id'])['containers']
+        # todo: can use instance['containerDetails'] in api 5.2.7/5.3.2
+        if instance['containerDetails']
+          containers = instance['containerDetails']
+        else
+          containers = @instances_interface.containers(instance['id'])['containers']
+        end
       end
 
       # threshold is fetched via separate api call too
@@ -1317,8 +1335,20 @@ class Morpheus::Cli::Instances
         "Layout" => lambda {|it| it['layout'] ? it['layout']['name'] : '' },
         "Version" => lambda {|it| it['instanceVersion'] },
         "Plan" => lambda {|it| it['plan'] ? it['plan']['name'] : '' },
-        # "Cost" => lambda {|it| it['hourlyCost'] ? format_money(it['hourlyCost'], (it['currency'] || 'USD'), {sigdig:15}).to_s + ' per hour' : '' },
-        # "Price" => lambda {|it| it['hourlyPrice'] ? format_money(it['hourlyPrice'], (it['currency'] || 'USD'), {sigdig:15}).to_s + ' per hour' : '' },
+        "Price" => lambda {|it|
+          if pricing
+            pricing['price'] ? format_money(pricing['price'], (pricing['currency'] || 'USD')).to_s + ' per ' + pricing['unit'].to_s : ''
+          elsif it['hourlyPrice']
+            format_money(it['hourlyPrice'], (it['currency'] || 'USD')).to_s + ' per hour'
+          end
+        },
+        "Cost" => lambda {|it| 
+          if pricing
+            pricing['cost'] ? format_money(pricing['cost'], (pricing['currency'] || 'USD')).to_s + ' per ' + pricing['unit'].to_s : ''
+          elsif it['hourlyCost']
+            format_money(it['hourlyCost'], (it['currency'] || 'USD')).to_s + ' per hour'
+          end
+        },
         "Environment" => 'instanceContext',
         "Labels" => lambda {|it| labels ? labels.join(',') : '' },
         "Tags" => lambda {|it| tags ? tags.collect {|m| "#{m['name']}: #{m['value']}" }.join(', ') : '' },
@@ -1330,6 +1360,7 @@ class Morpheus::Cli::Instances
           end
         },
         #"Tenant" => lambda {|it| it['tenant'] ? it['tenant']['name'] : '' },
+        "Apps" => lambda {|it| anded_list(it['apps'] ? it['apps'].collect {|app| app['name'] } : [])},
         "Date Created" => lambda {|it| format_local_dt(it['dateCreated']) },
         # "Last Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
         "Power Schedule" => lambda {|it| (it['powerSchedule'] && it['powerSchedule']['type']) ? it['powerSchedule']['type']['name'] : '' },
@@ -1343,12 +1374,17 @@ class Morpheus::Cli::Instances
       }
       description_cols.delete("Labels") if labels.nil? || labels.empty?
       description_cols.delete("Tags") if tags.nil? || tags.empty?
+      description_cols.delete("Apps") if instance['apps'].nil? || instance['apps'].empty?
       description_cols.delete("Power Schedule") if instance['powerSchedule'].nil?
       description_cols.delete("Expire Date") if instance['expireDate'].nil?
       description_cols.delete("Shutdown Date") if instance['shutdownDate'].nil?
       description_cols["Removal Date"] = lambda {|it| format_local_dt(it['removalDate'])} if instance['status'] == 'pendingRemoval'
       description_cols.delete("Last Deployment") if instance['lastDeploy'].nil?
       description_cols.delete("Locked") if instance['locked'] != true
+      price_value = (pricing ? pricing['price'] : instance['hourlyPrice']).to_i
+      cost_value = (pricing ? pricing['cost'] : instance['hourlyCost']).to_i
+      description_cols.delete("Price") if price_value == 0
+      description_cols.delete("Cost") if cost_value == 0 || cost_value == price_value
       #description_cols.delete("Environment") if instance['instanceContext'].nil?
       print_description_list(description_cols, instance)
 
@@ -1380,15 +1416,6 @@ class Morpheus::Cli::Instances
         print_stats_usage(stats)
       end
 
-      if options[:include_costs]
-        print_h2 "Instance Cost"
-        cost_columns = {
-          "Cost" => lambda {|it| it['hourlyCost'] ? format_money(it['hourlyCost'], (it['currency'] || 'USD'), {sigdig:15}).to_s + ' per hour' : '' },
-          "Price" => lambda {|it| it['hourlyPrice'] ? format_money(it['hourlyPrice'], (it['currency'] || 'USD'), {sigdig:15}).to_s + ' per hour' : '' },
-        }
-        print_description_list(cost_columns, instance)
-      end
-
       print reset, "\n"
 
       # if options[:include_lb]
@@ -1478,7 +1505,7 @@ class Morpheus::Cli::Instances
           print cyan, "Refreshing in #{options[:refresh_interval] > 1 ? options[:refresh_interval].to_i : options[:refresh_interval]} seconds"
           sleep_with_dots(options[:refresh_interval])
           print "\n"
-          _get(arg, options)
+          _get(instance['id'], options)
         end
       end
     end
@@ -2538,46 +2565,50 @@ class Morpheus::Cli::Instances
     options = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[instance]")
-      build_common_options(opts, options, [:options, :json, :dry_run, :remote])
+      build_standard_update_options(opts, options)
     end
     optparse.parse!(args)
-    if args.count < 1
-      puts optparse
-      exit 1
-    end
+    verify_args!(args:args, optparse:optparse, count:1)
     connect(options)
-    begin
-      instance = find_instance_by_name_or_id(args[0])
-
-      group_id = instance['group']['id']
-      cloud_id = instance['cloud']['id']
-      layout_id = instance['layout']['id']
-
-      plan_id = instance['plan']['id']
+    instance = find_instance_by_name_or_id(args[0])
+    return 1, "instance not found" if instance.nil?
+    
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!(parse_passed_options(options))
+    else
       payload = {
-        :instance => {:id => instance["id"]}
+        "instance" => {:id => instance["id"]}
       }
+      payload.deep_merge!(parse_passed_options(options))
 
       # avoid 500 error
       # payload[:servicePlanOptions] = {}
 
       puts "\nDue to limitations by most Guest Operating Systems, Disk sizes can only be expanded and not reduced.\nIf a smaller plan is selected, memory and CPU (if relevant) will be reduced but storage will not.\n\n"
 
+      group_id = instance['group']['id']
+      cloud_id = instance['cloud']['id']
+      layout_id = instance['layout']['id']
+      plan_id = instance['plan']['id']
+      current_plan_name = instance['plan']['name']
       # prompt for service plan
       service_plans_json = @instances_interface.service_plans({zoneId: cloud_id, siteId: group_id, layoutId: layout_id})
       service_plans = service_plans_json["plans"]
       service_plans_dropdown = service_plans.collect {|sp| {'name' => sp["name"], 'value' => sp["id"]} } # already sorted
       service_plans_dropdown.each do |plan|
-        if plan['value'] && plan['value'].to_i == plan_id.to_i
-          plan['name'] = "#{plan['name']} (current)"
-        end
+        # if plan['value'] && plan['value'].to_i == plan_id.to_i
+        #   plan['name'] = "#{plan['name']} (current)"
+        #   current_plan_name = plan['name']
+        # end
       end
-      plan_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'servicePlan', 'type' => 'select', 'fieldLabel' => 'Plan', 'selectOptions' => service_plans_dropdown, 'required' => true, 'description' => 'Choose the appropriately sized plan for this instance'}],options[:options])
+      plan_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'servicePlan', 'type' => 'select', 'fieldLabel' => 'Plan', 'selectOptions' => service_plans_dropdown, 'required' => true, 'defaultValue' => current_plan_name, 'description' => 'Choose the appropriately sized plan for this instance'}],options[:options])
       service_plan = service_plans.find {|sp| sp["id"] == plan_prompt['servicePlan'].to_i }
       new_plan_id = service_plan["id"]
       #payload[:servicePlan] = new_plan_id # ew, this api uses servicePlanId instead
       #payload[:servicePlanId] = new_plan_id
-      payload[:instance][:plan] = {id: service_plan["id"]}
+      payload["instance"]["plan"] = {"id" => service_plan["id"]}
 
       volumes_response = @instances_interface.volumes(instance['id'])
       current_volumes = volumes_response['volumes'].sort {|x,y| x['displayOrder'] <=> y['displayOrder'] }
@@ -2585,29 +2616,27 @@ class Morpheus::Cli::Instances
       # prompt for volumes
       volumes = prompt_resize_volumes(current_volumes, service_plan, options)
       if !volumes.empty?
-        payload[:volumes] = volumes
+        payload["volumes"] = volumes
       end
 
       # only amazon supports this option
       # for now, always do this
-      payload[:deleteOriginalVolumes] = true
-      @instances_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @instances_interface.dry.resize(instance['id'], payload)
-        return
-      end
-      json_response = @instances_interface.resize(instance['id'], payload)
-      if options[:json]
-        puts as_json(json_response, options)
-        return 0
-      else
-        print_green_success "Resizing instance #{instance['name']}"
-        #list([])
-      end
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
+      payload["deleteOriginalVolumes"] = true
     end
+    payload.delete("rootVolume")
+    (1..20).each {|i| payload.delete("dataVolume#{i}") }
+    @instances_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @instances_interface.dry.resize(instance['id'], payload)
+      return
+    end
+    json_response = @instances_interface.resize(instance['id'], payload)
+    render_response(json_response, options, 'snapshots') do
+      print_green_success "Resizing instance #{instance['name']}"
+    end
+    return 0, nil
+    
+  
   end
 
   def backup(args)

data/lib/morpheus/cli/integrations_command.rb

@@ -2,12 +2,12 @@ require 'morpheus/cli/cli_command'
 
 class Morpheus::Cli::IntegrationsCommand
   include Morpheus::Cli::CliCommand
-  include Morpheus::Cli::AccountsHelper
 
   set_command_name :'integrations'
   set_command_description "Integrations: View and manage integrations"
 
   register_subcommands :list, :get, :add, :update, :remove, :refresh
+  register_subcommands :list_objects, :get_object, :add_object, :remove_object
   register_subcommands :list_types, :get_type
 
   def connect(opts)
@@ -78,6 +78,9 @@ class Morpheus::Cli::IntegrationsCommand
     options = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[integration]")
+      opts.on('--objects', 'Display exposed objects for the integration.') do
+        options[:show_objects] = true
+      end
       build_standard_get_options(opts, options)
       opts.footer = <<-EOT
 Get details about a specific integration.
@@ -101,6 +104,9 @@ EOT
       return 1, "integration not found for #{id}" if integration.nil?
       id = integration['id']
     end
+    if options[:show_objects]
+      params['objects'] = true
+    end
     @integrations_interface.setopts(options)
     if options[:dry_run]
       print_dry_run @integrations_interface.dry.get(id, params)
@@ -137,6 +143,74 @@ EOT
       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)
+
+      if options[:show_objects]
+        # they are loaded above with ?objects=true
+        integration_objects = integration['objects']
+        if integration_objects.nil?
+          objects_json_response = @integrations_interface.list_objects(integration['id'], {})
+          integration_objects = objects_json_response[integration_object_list_key]
+        end
+        cloud_objects = integration_objects.select {|it| it['refType'] == "ComputeZone" }
+        library_objects = integration_objects.select {|it| it['refType'] == "InstanceTypeLayout" || it['refType'] == "InstanceType" }
+        blueprint_objects = integration_objects.select {|it| it['refType'] == "AppTemplate" }
+        catalog_objects = integration_objects.select {|it| it['refType'] == "CatalogItemType" }
+        if integration_objects.empty?
+          print reset,"\n"
+          print cyan,"No objects found.",reset,"\n"
+        else
+          # Exposed Clouds
+          if !cloud_objects.empty?
+            print_h2 "Exposed Clouds", [], options
+            list_columns = {
+              # "ID" => 'id',
+              "Name" => 'name',
+              # "Category" => 'category',
+              # "Ref Type" => 'refType',
+              # "Cloud ID" => 'refId',
+              "Group" => lambda {|it| it['group']['name'] rescue nil },
+            }.upcase_keys!
+            print as_pretty_table(cloud_objects, list_columns, options)
+          end
+
+          # Exposed Libraries
+          if !library_objects.empty?
+            # print_h2 "Exposed Libraries", [], options
+            print_h2 "Exposed Layouts", [], options
+            list_columns = {
+              # "ID" => 'id',
+              "Name" => 'name',
+              "Version" => lambda {|it| it['layout']['instanceVersion'] rescue nil },
+              "Instance Type" => lambda {|it| it['layout']['instanceType']['name'] rescue nil },
+              "Provision Type" => lambda {|it| it['layout']['provisionType']['name'] rescue nil },
+            }.upcase_keys!
+            print as_pretty_table(library_objects, list_columns, options)
+          end
+
+          # Exposed Blueprints
+          if !blueprint_objects.empty?
+            print_h2 "Exposed Blueprints", [], options
+            list_columns = {
+              # "ID" => 'id',
+              "Name" => 'name',
+              # "Type" => lambda {|it| it['blueprint']['type'] rescue nil },
+              "Blueprint" => lambda {|it| it['blueprint']['name'] rescue nil },
+              "Group" => lambda {|it| it['group']['name'] rescue nil },
+            }.upcase_keys!
+            print as_pretty_table(blueprint_objects, list_columns, options)
+          end
+
+          # Exposed Catalog Items
+          if !catalog_objects.empty?
+            print_h2 "Exposed Catalog Items", [], options
+            list_columns = {
+              # "ID" => 'id',
+              "Name" => 'name',
+            }.upcase_keys!
+            print as_pretty_table(catalog_objects, list_columns, options)
+          end
+        end
+      end
       print reset,"\n"
     end
     return 0, nil
@@ -459,6 +533,409 @@ EOT
     return 0, nil
   end
 
+  ## Integration Objects
+
+  def list_objects(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[integration] [search]")
+      opts.on('-t', '--type CODE', "Filter by types: cloud, layout, blueprint, catalog") do |val|
+        params['type'] = [params['type'], val].compact.flatten.collect {|it| it.to_s.strip.split(",") }.flatten.collect {|it| it.to_s.strip }
+      end
+      build_standard_list_options(opts, options)
+      opts.footer = <<-EOT
+List integration objects.
+[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)
+
+    integration = find_integration_by_name_or_id(args[0])
+    return 1, "integration not found for #{args[0]}" if integration.nil?
+
+    if args.count > 1
+      options[:phrase] = args[1..-1].join(" ")
+    end
+    params.merge!(parse_list_options(options))
+    @integrations_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @integrations_interface.dry.list_objects(integration['id'], params)
+      return 0, nil
+    end
+    json_response = @integrations_interface.list_objects(integration['id'], params)
+    render_response(json_response, options, integration_list_key) do
+      integration_objects = json_response[integration_object_list_key]
+      print_h1 "Integration Objects [#{integration['name']}]", parse_list_subtitles(options), options
+      if integration_objects.empty?
+        print cyan,"No objects found.",reset,"\n"
+      else
+        list_columns = {
+          "ID" => 'id',
+          "Name" => 'name',
+          # "Category" => 'category',
+          # "Ref Type" => 'refType',
+          # "Ref ID" => 'refId',
+          # "Type" => lambda {|it| it['type'] },
+          "Type" => lambda {|it| it['type'].to_s.capitalize },
+          "Ref ID" => 'refId',
+        }.upcase_keys!
+        print as_pretty_table(integration_objects, list_columns, options)
+        print_results_pagination(json_response)
+      end
+      print reset,"\n"
+    end
+    return 0, nil
+  end
+
+  def get_object(args)
+    params = {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[integration] [object]")
+      opts.on( '-c', '--config', "Display config only, for blueprint objects" ) do
+        options[:show_config] = true
+      end
+      build_standard_get_options(opts, options)
+      opts.footer = <<-EOT
+Get details about a specific integration object.
+[integration] is required. This is the name or id of an integration.
+[object] is required. This is the name or id of an integration object.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, min:1)
+    connect(options)
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, min:2)
+    connect(options)
+    integration = find_integration_by_name_or_id(args[0])
+    return 1, "integration not found for #{args[0]}" if integration.nil?
+    params.merge!(parse_query_options(options))
+    id_list = parse_id_list(args[1..-1])
+    return run_command_for_each_arg(id_list) do |arg|
+      _get_object(integration, arg, params, options)
+    end
+  end
+
+  def _get_object(integration, id, params, options)
+    integration_object = nil
+    if id.to_s !~ /\A\d{1,}\Z/
+      integration_object = find_integration_object_by_name_or_id(integration['id'], id)
+      return 1, "integration object not found for #{id}" if integration_object.nil?
+      id = integration_object['id']
+    end
+    @integrations_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @integrations_interface.dry.get_object(integration['id'], id, params)
+      return
+    end
+    json_response = @integrations_interface.get_object(integration['id'], id, params)
+    integration_object = json_response[integration_object_object_key]
+    config = integration_object['config']
+    # export just the config as json (default) or yaml
+    if options[:show_config]
+      unless options[:json] || options[:yaml] || options[:csv]
+        options[:json] = :true
+      end
+      return render_with_format(config, options)
+    end
+    render_response(json_response, options, integration_object_object_key) do
+      print_h1 "Integration Object Details", [], options
+      print cyan
+      if integration_object['type'] == 'cloud'
+        show_columns = {
+          "Integration" => lambda {|it| integration['name'] },
+          "Object ID" => 'id',
+          "Name" => 'name',
+          "Type" => lambda {|it| it['type'].to_s.capitalize },
+          # "Cloud" => lambda {|it| it['cloud']['name'] rescue nil },
+          # "Ref Type" => 'refType',
+          "Ref ID" => 'refId',
+          # "Reference" => lambda {|it| ("#{it['refType']}: #{it['refId']}" rescue nil) },
+          "Group" => lambda {|it| it['group']['name'] rescue nil },
+        }
+        print_description_list(show_columns, integration_object, options)
+        print reset,"\n"
+      elsif integration_object['type'] == 'layout'
+        show_columns = {
+          "Integration" => lambda {|it| integration['name'] },
+          "Object ID" => 'id',
+          "Name" => 'name',
+          "Type" => lambda {|it| it['type'].to_s.capitalize },
+          # "Layout" => lambda {|it| it['layout']['name'] rescue nil },
+          # "Ref Type" => 'refType',
+          "Ref ID" => 'refId',
+          # "Reference" => lambda {|it| ("#{it['refType']}: #{it['refId']}" rescue nil) },
+          "Provision Type" => lambda {|it| it['layout']['provisionType']['name'] rescue nil },
+          "Instance Type" => lambda {|it| it['layout']['instanceType']['name'] rescue nil },
+          "Version" => lambda {|it| it['layout']['instanceVersion'] rescue nil },
+        }
+        print_description_list(show_columns, integration_object, options)
+        print reset,"\n"
+      elsif integration_object['type'] == 'blueprint'
+        show_columns = {
+          "Integration" => lambda {|it| integration['name'] },
+          "Object ID" => 'id',
+          "Name" => 'name',
+          "Type" => lambda {|it| it['type'].to_s.capitalize },
+          # "Ref Type" => 'refType',
+          "Ref ID" => 'refId',
+          # "Reference" => lambda {|it| ("#{it['refType']}: #{it['refId']}" rescue nil) },
+          # "Blueprint Type" => lambda {|it| it['blueprint']['type'] rescue nil },
+          "Blueprint" => lambda {|it| it['blueprint']['name'] rescue nil },
+          "Group" => lambda {|it| it['group']['name'] rescue nil },
+          "Default Cloud" => lambda {|it| it['defaultCloud']['name'] rescue nil },
+          "Environment" => lambda {|it| it['environment'] rescue nil },
+        }
+        print_description_list(show_columns, integration_object, options)
+        # print reset,"\n"
+        # print_h2 "App Spec"
+        print_h2 "Config"
+        if config
+          # config_string = integration_object['config'] || ""
+          config_string = config.is_a?(Hash) ? JSON.pretty_generate(config) : config.to_s
+          #print reset,config_string,"\n",reset
+          config_lines = config_string.split("\n")
+          config_line_count = config_lines.size
+          max_lines = 10
+          if config_lines.size > max_lines
+            config_string = config_lines.first(max_lines).join("\n")
+            config_string << "\n\n"
+            config_string << "#{dark}(#{(config_line_count - max_lines)} more lines were not shown, use -c to show the config)#{reset}"
+            #config_string << "\n"
+          end
+          # strip --- yaml header
+          if config_string[0..3] == "---\n"
+            config_string = config_string[4..-1]
+          end
+          print reset,config_string.chomp("\n"),"\n",reset
+        else
+          print reset,"(blank)","\n",reset
+        end
+        print reset,"\n"
+      elsif integration_object['type'] == 'catalog'
+        show_columns = {
+          "Integration" => lambda {|it| integration['name'] },
+          "Object ID" => 'id',
+          "Name" => 'name',
+          "Type" => lambda {|it| it['type'].to_s.capitalize },
+          "Catalog Item" => lambda {|it| it['catalogItemType']['name'] rescue nil },
+          # "Ref Type" => 'refType',
+          # "Ref ID" => 'refId',
+          # "Reference" => lambda {|it| ("#{it['refType']}: #{it['refId']}" rescue nil) },
+        }
+        print_description_list(show_columns, integration_object, options)
+        print reset,"\n"
+      else
+        # Unknown type?
+        show_columns = {
+          "Integration" => lambda {|it| integration['name'] },
+          "Object ID" => 'id',
+          "Name" => 'name',
+          "Type" => lambda {|it| it['type'].to_s.capitalize },
+          "Ref Type" => 'refType',
+          "Ref ID" => 'refId',
+        }
+        print_description_list(show_columns, integration_object, options)
+        print reset,"\n"
+      end
+    end
+    return 0, nil
+  end
+
+  def add_object(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[integration] [name] -t CODE [options]")
+      # opts.on('-t', '--type CODE', "Integration ObjectType 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_object_option_types)
+      opts.on('--config-file FILE', String, "Config from a local JSON or YAML file") do |val|
+        options[:config_file] = val.to_s
+        file_content = nil
+        full_filename = File.expand_path(options[:config_file])
+        if File.exists?(full_filename)
+          file_content = File.read(full_filename)
+        else
+          print_red_alert "File not found: #{full_filename}"
+          return 1
+        end
+        parse_result = parse_json_or_yaml(file_content)
+        config_map = parse_result[:data]
+        if config_map.nil?
+          # todo: bubble up JSON.parse error message
+          raise_command_error "Failed to parse config as YAML or JSON. Error: #{parse_result[:err]}"
+          #raise_command_error "Failed to parse config as valid YAML or JSON."
+        else
+          params['config'] = config_map
+          options[:options]['config'] = params['config'] # or file_content
+        end
+      end
+      # build_option_type_options(opts, options, add_integration_object_advanced_option_types)
+      build_standard_add_options(opts, options)
+      opts.footer = <<-EOT
+Create a new integration object.
+[integration] is required. This is the name or id of an 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:1, max:2)
+    options[:options]['name'] = args[1] if args[1]
+    connect(options)
+    integration = find_integration_by_name_or_id(args[0])
+    return 1, "integration not found for #{args[0]}" if integration.nil?
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({integration_object_object_key => parse_passed_options(options)})
+    else
+      payload.deep_merge!({integration_object_object_key => parse_passed_options(options)})
+      v_prompt = Morpheus::Cli::OptionTypes.prompt(add_integration_object_option_types(), options[:options], @api_client, options[:params])
+      v_prompt.deep_compact!
+      params.deep_merge!(v_prompt)
+      advanced_config = Morpheus::Cli::OptionTypes.no_prompt(add_integration_object_advanced_option_types, options[:options], @api_client, options[:params])
+      advanced_config.deep_compact!
+      params.deep_merge!(advanced_config)
+      params.booleanize!
+
+      # convert config string to a map
+      # config = params['config']
+      # if config && config.is_a?(String)
+      #   parse_result = parse_json_or_yaml(config)
+      #   config_map = parse_result[:data]
+      #   if config_map.nil?
+      #     # todo: bubble up JSON.parse error message
+      #     raise_command_error "Failed to parse config as YAML or JSON. Error: #{parse_result[:err]}"
+      #     #raise_command_error "Failed to parse config as valid YAML or JSON."
+      #   else
+      #     params['config'] = config_map
+      #   end
+      # end
+      # if params['config']
+      #   config_map = params.delete('config')
+      #   params['config'] = as_json(config_map, {:pretty_json => true})
+      # end
+      # if options[:interactive_config]
+      #   print_h2 "App Config"
+      #   config_map = prompt_app_config(options)
+      #   params['config'] = config_map
+      # end
+
+      payload[integration_object_object_key].deep_merge!(params)
+    end
+    @integrations_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @integrations_interface.dry.create_object(integration['id'], payload)
+      return 0, nil
+    end
+    json_response = @integrations_interface.create_object(integration['id'], payload)
+    integration_object = json_response[integration_object_object_key]
+    render_response(json_response, options, integration_object_object_key) do
+      print_green_success "Added integration_object #{integration_object['name']}"
+      return _get_object(integration, integration_object["id"], {}, options)
+    end
+    return 0, nil
+  end
+
+#   def update_object(args)
+#     options = {}
+#     params = {}
+#     optparse = Morpheus::Cli::OptionParser.new do |opts|
+#       opts.banner = subcommand_usage("[integration] [object] [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
+# Update an integration.
+# [integration] is required. This is the name or id of an integration.
+# [object] is required. This is the name or id of an integration object.
+# EOT
+#     end
+#     optparse.parse!(args)
+#     verify_args!(args:args, optparse:optparse, count:2)
+#     connect(options)
+#     integration = find_integration_by_name_or_id(args[0])
+#     return 1, "integration not found for #{args[0]}" if integration.nil?
+#     integration_object = find_integration_object_by_name_or_id(integration['id'], args[1])
+#     return 1, "integration object not found for #{args[1]}" if integration_object.nil?
+#     payload = {}
+#     if options[:payload]
+#       payload = options[:payload]
+#       payload.deep_merge!({integration_object_object_key => parse_passed_options(options)})
+#     else
+#       payload.deep_merge!({integration_object_object_key => parse_passed_options(options)})
+#       # do not prompt on update
+#       v_prompt = Morpheus::Cli::OptionTypes.no_prompt(update_integration_object_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_object_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_object_key => params})
+#       if payload[integration_object_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_object(integration['id'], integration_object['id'], payload)
+#       return
+#     end
+#     json_response = @integrations_interface.update_object(integration['id'], integration_object['id'], payload)
+#     integration_object = json_response[integration_object_object_key]
+#     render_response(json_response, options, integration_object_object_key) do
+#       print_green_success "Updated integration object #{integration_object['name']}"
+#       return _get_object(integration, integration_object["id"], {}, options)
+#     end
+#     return 0, nil
+#   end
+
+  def remove_object(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 object.
+[integration] is required. This is the name or id of an integration.
+[object] is required. This is the name or id of an integration object.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:2)
+    connect(options)
+    integration = find_integration_by_name_or_id(args[0])
+    return 1, "integration not found for #{args[0]}" if integration.nil?
+    integration_object = find_integration_object_by_name_or_id(integration['id'], args[1])
+    return 1, "integration object not found for #{args[1]}" if integration_object.nil?
+    params.merge!(parse_query_options(options))
+    @integrations_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @integrations_interface.dry.destroy_object(integration['id'], integration_object['id'], params)
+      return
+    end
+    unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to delete the integration object #{integration_object['name']}?")
+      return 9, "aborted command"
+    end
+    json_response = @integrations_interface.destroy_object(integration['id'], integration_object['id'], params)
+    render_response(json_response, options) do
+      print_green_success "Removed integration object #{integration_object['name']}"
+    end
+    return 0, nil
+  end
+
   private
 
   def format_integration_type(integration)
@@ -641,4 +1118,93 @@ EOT
     end
   end
 
+  ## Integration Object helpers
+
+  def add_integration_object_option_types
+    [
+      {'code' => 'integrationObject.type', 'shorthand' => '-t', 'switch' => 'type', 'fieldName' => 'type', 'fieldLabel' => 'Type', 'type' => 'select', 'optionSource' => 'integrationObjectTypes', 'required' => true, 'description' => "Integration Object Type eg. cloud, layout, blueprint, catalog", 'displayOrder' => 1},
+      # {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => false, 'description' => 'Display Name of the integration object, default is the name of the referenced object', 'displayOrder' => 2},
+      {'dependsOnCode' => 'integrationObject.type:cloud', 'switch' => 'group', 'fieldName' => 'group', 'fieldLabel' => 'Group', 'type' => 'select', 'optionSource' => 'groups', 'required' => true, 'description' => 'Group', 'displayOrder' => 3},
+      {'dependsOnCode' => 'integrationObject.type:cloud', 'switch' => 'cloud', 'fieldName' => 'cloud', 'fieldLabel' => 'Cloud', 'type' => 'select', 'optionSource' => 'clouds', 'required' => true, 'description' => 'Cloud', 'displayOrder' => 4},
+      {'dependsOnCode' => 'integrationObject.type:layout', 'switch' => 'instance-type', 'fieldName' => 'instanceType', 'fieldLabel' => 'Instance Type', 'type' => 'select', 'optionSource' => 'instanceTypes', 'required' => true, 'description' => 'Instance Type', 'displayOrder' => 5},
+      {'dependsOnCode' => 'integrationObject.type:layout', 'switch' => 'technology', 'fieldName' => 'zoneType', 'fieldLabel' => 'Cloud Type', 'type' => 'select', 'optionSource' => 'zoneTypes', 'required' => true, 'description' => 'Cloud Type (Technology)', 'displayOrder' => 5},
+      {'dependsOnCode' => 'integrationObject.type:layout', 'switch' => 'layout', 'fieldName' => 'layout', 'fieldLabel' => 'Layout', 'type' => 'select', 'optionSource' => 'layouts', 'required' => true, 'description' => 'Layout', 'displayOrder' => 6},
+      {'dependsOnCode' => 'integrationObject.type:blueprint', 'fieldName' => 'name', 'fieldLabel' => 'Catalog Item Name', 'type' => 'text', 'required' => true, 'description' => 'Display Name of the integration object', 'displayOrder' => 7},
+      {'dependsOnCode' => 'integrationObject.type:blueprint', 'switch' => 'blueprint', 'fieldName' => 'blueprint', 'fieldLabel' => 'Blueprint', 'type' => 'select', 'optionSource' => 'blueprints', 'required' => true, 'description' => 'Blueprint', 'displayOrder' => 8, 'noParams' => true},
+      {'dependsOnCode' => 'integrationObject.type:blueprint', 'switch' => 'group', 'fieldName' => 'group', 'fieldLabel' => 'Group', 'type' => 'select', 'optionSource' => 'groups', 'required' => true, 'description' => 'Group', 'displayOrder' => 9},
+      {'dependsOnCode' => 'integrationObject.type:blueprint', 'switch' => 'default-cloud', 'fieldName' => 'defaultCloud', 'fieldLabel' => 'Default Cloud', 'type' => 'select', 'optionSource' => 'clouds', 'required' => false, 'description' => 'Default Cloud', 'displayOrder' => 10},
+      {'dependsOnCode' => 'integrationObject.type:blueprint', 'switch' => 'environment', 'fieldName' => 'environment', 'fieldLabel' => 'Environment', 'type' => 'select', 'optionSource' => 'environments', 'required' => false, 'description' => 'Environment', 'displayOrder' => 11},
+      {'dependsOnCode' => 'integrationObject.type:blueprint', 'switch' => 'config', 'fieldName' => 'config', 'fieldLabel' => 'Config', 'type' => 'code-editor', 'required' => true, 'description' => 'Config JSON', 'displayOrder' => 12},
+      {'dependsOnCode' => 'integrationObject.type:catalog', 'switch' => 'catalog', 'fieldName' => 'catalog', 'fieldLabel' => 'Catalog Item', 'type' => 'select', 'optionSource' => 'catalogItemTypes', 'required' => true, 'description' => 'Catalog Item', 'displayOrder' => 13},
+    ]
+  end
+
+  def add_integration_object_advanced_option_types
+    []
+  end
+
+  def update_integration_object_option_types
+    list = add_integration_object_option_types.collect {|it|
+      it.delete('required')
+      it.delete('defaultValue')
+      it
+    }
+    list = list.reject {|it| ["type"].include? it['fieldName'] }
+    list
+  end
+
+  def update_integration_object_advanced_option_types
+    add_integration_advanced_option_types.collect {|it|
+      it.delete('required')
+      it.delete('defaultValue')
+      it
+    }
+  end
+
+  def integration_object_object_key
+    'object'
+  end
+
+  def integration_object_list_key
+    'objects'
+  end
+
+  def find_integration_object_by_name_or_id(integration_id, val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_integration_object_by_id(integration_id, val)
+    else
+      return find_integration_object_by_name(integration_id, val)
+    end
+  end
+
+  def find_integration_object_by_id(integration_id, id)
+    begin
+      json_response = @integrations_interface.get_object(integration_id, id.to_i)
+      return json_response[integration_object_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "integration object not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_integration_object_by_name(integration_id, name)
+    json_response = @integrations_interface.list_objects(integration_id, {name: name.to_s})
+    integration_objects = json_response[integration_object_list_key]
+    if integration_objects.empty?
+      print_red_alert "integration object not found by name '#{name}'"
+      return nil
+    elsif integration_objects.size > 1
+      print_red_alert "#{integration_objects.size} integration object found by name '#{name}'"
+      puts_error as_pretty_table(integration_objects, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print reset,"\n"
+      return nil
+    else
+      return integration_objects[0]
+    end
+  end
+
 end