Class: Morpheus::Cli::Clusters

Inherits:

Object

Object
Morpheus::Cli::Clusters

show all

Includes:: AccountsHelper, CliCommand, ProcessesHelper, ProvisioningHelper, WhoamiHelper

Defined in:: lib/morpheus/cli/clusters.rb

Overview

require ‘morpheus/cli/mixins/infrastructure_helper’

Instance Attribute Summary

Attributes included from CliCommand

#no_prompt

Instance Method Summary collapse

Methods included from AccountsHelper

Methods included from CliCommand

Instance Method Details

#_get(arg, options = {}) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 175

def _get(arg, options={})
  
  begin
    @clusters_interface.setopts(options)

    if options[:dry_run]
      if arg.to_s =~ /\A\d{1,}\Z/
        print_dry_run @clusters_interface.dry.get(arg.to_i)
      else
        print_dry_run @clusters_interface.dry.list({name:arg})
      end
      return 0
    end
    cluster = find_cluster_by_name_or_id(arg)
    return 1 if cluster.nil?
    json_response = nil
    if arg.to_s =~ /\A\d{1,}\Z/
      json_response = {'cluster' => cluster}  # skip redundant request
    else
      json_response = @clusters_interface.get(cluster['id'])
    end

    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
      return
    end

    cluster = json_response['cluster']
    worker_stats = cluster['workerStats']
    clusterType = find_cluster_type_by_id(cluster['type']['id'])

    print_h1 "Morpheus Cluster"
    print cyan
    description_cols = {
        "ID" => 'id',
        "Name" => 'name',
        "Type" => lambda { |it| it['type']['name'] },
        #"Group" => lambda { |it| it['site']['name'] },
        "Cloud" => lambda { |it| it['zone']['name'] },
        "Location" => lambda { |it| it['location'] },
        "Layout" => lambda { |it| it['layout'] ? it['layout']['name'] : ''},
        "API Url" => 'serviceUrl',
        "Visibility" => lambda { |it| it['visibility'].to_s.capitalize },
        #"Groups" => lambda {|it| it['groups'].collect {|g| g.instance_of?(Hash) ? g['name'] : g.to_s }.join(', ') },
        #"Owner" => lambda {|it| it['owner'].instance_of?(Hash) ? it['owner']['name'] : it['ownerId'] },
        #"Tenant" => lambda {|it| it['account'].instance_of?(Hash) ? it['account']['name'] : it['accountId'] },
        "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
        "Created By" => lambda {|it| it['createdBy'] ? it['createdBy']['username'] : '' },
        "Enabled" => lambda { |it| format_boolean(it['enabled']) },
        "Status" => lambda { |it| format_cluster_status(it) }
    }
    print_description_list(description_cols, cluster)

    print_h2 "Cluster Details"
    print cyan

    print "Namespaces: #{cluster['namespacesCount']}".center(20) if !cluster['namespacesCount'].nil?
    print "Masters: #{cluster['mastersCount']}".center(20) if !cluster['mastersCount'].nil?
    print "Workers: #{cluster['workersCount']}".center(20) if !clusterType['workersCount'].nil?
    print "Volumes: #{cluster['volumesCount']}".center(20) if !cluster['volumesCount'].nil?
    print "Containers: #{cluster['containersCount']}".center(20) if !cluster['containersCount'].nil?
    print "Services: #{cluster['servicesCount']}".center(20) if !cluster['servicesCount'].nil?
    print "Jobs: #{cluster['jobsCount']}".center(20) if !cluster['jobsCount'].nil?
    print "Pods: #{cluster['podsCount']}".center(20) if !cluster['podsCount'].nil?
    print "Deployments: #{cluster['deploymentsCount']}".center(20) if !cluster['deploymentsCount'].nil?
    print "\n"

    if options[:show_masters]
      masters_json = @clusters_interface.list_masters(cluster['id'], options)
      if masters_json.nil? || masters_json['masters'].empty?
        print_h2 "Masters"
        print cyan,"No masters found.",reset,"\n"
      else
        masters = masters_json['masters']
        print_h2 "Masters"
        rows = masters.collect do |server|
          {
            id: server['id'],
            name: server['name'],
            type: (server['type']['name'] rescue server['type']),
            status: format_server_status(server),
            power: format_server_power_state(server, cyan)
          }
        end
        columns = [:id, :name, :status, :power]
        puts as_pretty_table(rows, columns, options)
      end
    end
    if options[:show_workers]
      workers_json = @clusters_interface.list_workers(cluster['id'], options)
      if workers_json.nil? || workers_json['workers'].empty?
        print_h2 "Workers"
        print cyan,"No workers found.",reset,"\n"
      else
        workers = workers_json['workers']
        print_h2 "Workers"
        rows = workers.collect do |server|
          {
            id: server['id'],
            name: server['name'],
            type: (server['type']['name'] rescue server['type']),
            status: format_server_status(server),
            power: format_server_power_state(server, cyan)
          }
        end
        columns = [:id, :name, :status, :power]
        puts as_pretty_table(rows, columns, options)
      end
    end

    if worker_stats
      print_h2 "Worker Usage"
      print cyan
      # print "CPU Usage: #{worker_stats['cpuUsage']}".center(20)
      # print "Memory: #{worker_stats['usedMemory']}".center(20)
      # print "Storage: #{worker_stats['usedStorage']}".center(20)
      print_stats_usage(worker_stats, {include: [:max_cpu, :avg_cpu, :memory, :storage]})
      print reset,"\n"
    end

    if options[:show_perms]
      permissions = cluster['permissions']
      print_permissions(permissions)
    end

    # refresh until a status is reached
    if options[:refresh_until_status]
      if options[:refresh_interval].nil? || options[:refresh_interval].to_f < 0
        options[:refresh_interval] = default_refresh_interval
      end
      statuses = options[:refresh_until_status].to_s.downcase.split(",").collect {|s| s.strip }.select {|s| !s.to_s.empty? }
      if !statuses.include?(cluster['status'])
        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)
      end
    end

    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#_list_container_groups(args, options, resource_type) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1881

def _list_container_groups(args, options, resource_type)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?

    params = {}
    params.merge!(parse_list_options(options))
    params['resourceLevel'] = options[:resourceLevel] if !options[:resourceLevel].nil?
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.list_container_groups(cluster['id'], resource_type, params)
      return
    end
    json_response = @clusters_interface.list_container_groups(cluster['id'], resource_type, params)

    render_result = render_with_format(json_response, options, 'containers')
    return 0 if render_result

    title = "Morpheus Cluster #{resource_type.capitalize}s: #{cluster['name']}"
    subtitles = []
    subtitles += parse_list_subtitles(options)
    print_h1 title, subtitles
    container_groups = json_response["#{resource_type}s"]
    if container_groups.empty?
      print cyan,"No #{resource_type}s found.",reset,"\n"
    else
      # more stuff to show here
      rows = container_groups.collect do |it|
        stats = it['stats']
        cpu_usage_str = generate_usage_bar((it['totalCpuUsage']).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})
        {
            id: it['id'],
            status: it['status'],
            name: it['name'],
            cpu: cpu_usage_str + cyan,
            memory: memory_usage_str + cyan,
            storage: storage_usage_str + cyan
        }
      end
      columns = [
          :id, :status, :name, :cpu, :memory, :storage
      ]
      print as_pretty_table(rows, columns, options)
    end
    print reset,"\n"
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#_remove_container_group(args, options, resource_type) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1935

def _remove_container_group(args, options, resource_type)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    container_group_id = args[1]

    if container_group_id.empty?
      raise_command_error "missing required container parameter"
    end

    container_group = find_container_group_by_name_or_id(cluster['id'], resource_type, container_group_id)
    if container_group.nil?
      print_red_alert "#{resource_type.capitalize} not found by id '#{container_group_id}'"
      return 1
    end
    unless options[:yes] || ::Morpheus::Cli::OptionTypes::confirm("Are you sure you would like to remove the cluster #{resource_type} '#{container_group['name'] || container_group['id']}'?", options)
      return 9, "aborted command"
    end

    params = {}
    params.merge!(parse_list_options(options))

    if !options[:force].nil?
      params['force'] = options[:force]
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.destroy_container_group(cluster['id'], container_group['id'], resource_type, params)
      return
    end
    json_response = @clusters_interface.destroy_container_group(cluster['id'], container_group['id'], resource_type, params)
    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
    elsif !options[:quiet]
      print_red_alert "Error removing #{resource_type} #{container_group['name']} from cluster #{cluster['name']}: #{json_response['msg']}" if json_response['success'] == false
      print_green_success "#{resource_type.capitalize} #{container_group['name']} is being removed from cluster #{cluster['name']}..." if json_response['success'] == true
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#_restart_container_group(args, options, resource_type) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1980

def _restart_container_group(args, options, resource_type)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    container_group_id = args[1]

    if container_group_id.empty?
      raise_command_error "missing required container parameter"
    end

    container_group = find_container_group_by_name_or_id(cluster['id'], resource_type, container_group_id)
    if container_group.nil?
      print_red_alert "#{resource_type.capitalize} not found by id '#{container_group_id}'"
      return 1
    end

    params = {}
    params.merge!(parse_list_options(options))

    if !options[:force].nil?
      params['force'] = options[:force]
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.restart_container_group(cluster['id'], container_group['id'], resource_type, params)
      return
    end
    json_response = @clusters_interface.restart_container_group(cluster['id'], container_group['id'], resource_type, params)
    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
    elsif !options[:quiet]
      print_red_alert "Error restarting #{resource_type} #{container_group['name']} from cluster #{cluster['name']}: #{json_response['msg']}" if json_response['success'] == false
      print_green_success "#{resource_type.capitalize} #{container_group['name']} is being restarted for cluster #{cluster['name']}..." if json_response['success'] == true
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#_view(arg, options = {}) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 348

def _view(arg, options={})
  begin
    cluster = find_cluster_by_name_or_id(arg)
    return 1 if cluster.nil?

    link = "#{@appliance_url}/login/oauth-redirect?access_token=#{@access_token}\\&redirectUri=/infrastructure/clusters/#{cluster['id']}"
    if options[:link_tab]
      link << "#!#{options[:link_tab]}"
    end

    if options[:dry_run]
      puts Morpheus::Util.open_url_command(link)
      return 0
    end
    return Morpheus::Util.open_url(link)
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#add(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 369

def add(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[name]")
    opts.on( '--name NAME', "Cluster Name" ) do |val|
      options[:name] = val.to_s
    end
    opts.on("--description [TEXT]", String, "Description") do |val|
      options[:description] = val.to_s
    end
    opts.on( '--resource-name NAME', "Resource Name" ) do |val|
      options[:resourceName] = val.to_s
    end
    opts.on('--tags LIST', String, "Tags") do |val|
      options[:tags] = val
    end
    opts.on( '-g', '--group GROUP', "Group Name or ID" ) do |val|
      options[:group] = val
    end
    opts.on( '-t', '--cluster-type TYPE', "Cluster Type Name or ID" ) do |val|
      options[:clusterType] = val
    end
    opts.on( '-l', '--layout LAYOUT', "Layout Name or ID" ) do |val|
      options[:layout] = val
    end
    opts.on('--visibility [private|public]', String, "Visibility") do |val|
      options[:visibility] = val
    end
    opts.on('--refresh [SECONDS]', String, "Refresh until status is provisioned,failed. Default interval is #{default_refresh_interval} seconds.") do |val|
      options[:refresh_interval] = val.to_s.empty? ? default_refresh_interval : val.to_f
    end
    opts.on('--workflow ID', String, "Workflow") do |val|
      options['taskSetId'] = val.to_i
    end
    add_server_options(opts, options)
    build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote])
    opts.footer = "Create a cluster.\n" +
                  "[name] is required. This is the name of the new cluster."
  end

  optparse.parse!(args)
  if args.count > 1
    raise_command_error "wrong number of arguments, expected 0-2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    payload = nil
    if options[:payload]
      payload = options[:payload]
      # support -O OPTION switch on top of --payload
      payload['cluster'] ||= {}
      if options[:options]
        payload['cluster'].deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) })
      end
      if args[0]
        payload['cluster']['name'] = args[0]
      elsif options[:name]
        payload['cluster']['name'] = options[:name]
      end
      # if args[1]
      #   payload['cluster']['description'] = args[1]
      # elsif options[:description]
      #   payload['cluster']['description'] = options[:description]
      # end
      payload['cluster']['server'] ||= {}
      if options[:resourceName]
        payload['cluster']['server']['name'] = options[:resourceName]
      end
      if options[:description]
        payload['cluster']['description'] = options[:description]
      end
    else
      cluster_payload = {}
      server_payload = {"config" => {}}

      # Cluster Type
      cluster_type_id = nil
      cluster_type = options[:clusterType] ? find_cluster_type_by_name_or_id(options[:clusterType]) : nil

      if cluster_type
        cluster_type_id = cluster_type['id']
      else
        available_cluster_types = cluster_types_for_dropdown

        if available_cluster_types.empty?
          print_red_alert "A cluster type is required"
          exit 1
        elsif available_cluster_types.count > 1 && !options[:no_prompt]
          cluster_type_code = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'clusterType', 'type' => 'select', 'fieldLabel' => 'Cluster Type', 'selectOptions' => cluster_types_for_dropdown, 'required' => true, 'description' => 'Select Cluster Type.'}],options[:options],@api_client,{})['clusterType']
        else
          cluster_type_code = available_cluster_types.first['code']
        end
        cluster_type = get_cluster_types.find { |ct| ct['code'] == cluster_type_code }
      end

      cluster_payload['type'] = cluster_type['code'] # {'id' => cluster_type['id']}

      # Cluster Name
      if args.empty? && options[:no_prompt]
        print_red_alert "No cluster name provided"
        exit 1
      elsif !args.empty?
        cluster_payload['name'] = args[0]
      elsif options[:name]
        cluster_payload['name'] = options[:name]
      else
        existing_cluster_names = @clusters_interface.list()['clusters'].collect { |cluster| cluster['name'] }
        while cluster_payload['name'].empty?
          name = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'name', 'type' => 'text', 'fieldLabel' => 'Cluster Name', 'required' => true, 'description' => 'Cluster Name.'}],options[:options],@api_client,{})['name']

          if existing_cluster_names.include?(name)
            print_red_alert "Name must be unique, #{name} already exists"
          else
            cluster_payload['name'] = name
          end
        end
      end

      # Cluster Description
      # if !args.empty? && args.count > 1
      #   cluster_payload['description'] = args[1]
      # elsif options[:description]
      #   cluster_payload['description'] = options[:description]
      # elsif !options[:no_prompt]
      #   cluster_payload['description'] = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'description', 'type' => 'text', 'fieldLabel' => 'Cluster Description', 'required' => false, 'description' => 'Cluster Description.'}],options[:options],@api_client,{})['description']
      # end

      # Resource Name
      resourceName = options[:resourceName]

      if !resourceName
        if options[:no_prompt]
          print_red_alert "No resource name provided"
          exit 1
        else
          resourceName = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'resourceName', 'type' => 'text', 'fieldLabel' => 'Resource Name', 'required' => true, 'description' => 'Resource Name.'}],options[:options],@api_client,{})['resourceName']
        end
      end

      server_payload['name'] = resourceName

      # Resource Description
      description = options[:description] || Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'description', 'type' => 'text', 'fieldLabel' => 'Description', 'required' => false, 'description' => 'Resource Description.'}],options[:options],@api_client,{})['description']
      cluster_payload['description'] = description if description

      tags = options[:tags]

      if !tags && !options[:no_prompt]
        tags = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'tags', 'type' => 'text', 'fieldLabel' => 'Resource Labels', 'required' => false, 'description' => 'Resource Tags.'}],options[:options],@api_client,{})['tags']
      end

      server_payload['tags'] = tags if tags

      # Group / Site
      group = load_group(options)
      cluster_payload['group'] = {'id' => group['id']}

      # Cloud / Zone
      cloud_id = nil
      cloud = options[:cloud] ? find_cloud_by_name_or_id_for_provisioning(group['id'], options[:cloud]) : nil
      if cloud
        # load full cloud
        cloud = @clouds_interface.get(cloud['id'])['zone']
        cloud_id = cloud['id']
      else
        available_clouds = get_available_clouds(group['id'])

        if available_clouds.empty?
          print_red_alert "Group #{group['name']} has no available clouds"
          exit 1
        else
          cloud_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'cloud', 'type' => 'select', 'fieldLabel' => 'Cloud', 'selectOptions' => available_clouds, 'required' => true, 'description' => 'Select Cloud.'}],options[:options],@api_client,{groupId: group['id']})['cloud']
        end
        cloud = @clouds_interface.get(cloud_id)['zone']
      end

      cloud['zoneType'] = get_cloud_type(cloud['zoneType']['id'])
      cluster_payload['cloud'] = {'id' => cloud['id']}

      # Layout
      layout = options[:layout] ? find_layout_by_name_or_id(options[:layout]) : nil

      if !layout
        available_layouts = layouts_for_dropdown(cloud['id'], cluster_type['id'])

        if !available_layouts.empty?
          if available_layouts.count > 1 && !options[:no_prompt]
            layout_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'layout', 'type' => 'select', 'fieldLabel' => 'Layout', 'selectOptions' => available_layouts, 'required' => true, 'description' => 'Select Layout.'}],options[:options],@api_client,{})['layout']
          else
            layout_id = available_layouts.first['id']
          end
          layout = find_layout_by_name_or_id(layout_id)
        end
      end

      cluster_payload['layout'] = {id: layout['id']}

      # Plan
      provision_type = (layout && layout['provisionType'] ? layout['provisionType'] : nil) || get_provision_type_for_zone_type(cloud['zoneType']['id'])
      service_plan = prompt_service_plan(cloud['id'], provision_type, options)

      if service_plan
        server_payload['plan'] = {'id' => service_plan['id'], 'code' => service_plan['code'], 'options' => prompt_service_plan_options(service_plan, options)}
      end

      # Controller type
      server_types = @server_types_interface.list({max:1, computeTypeId: cluster_type['controllerTypes'].first['id'], zoneTypeId: cloud['zoneType']['id'], useZoneProvisionTypes: true})['serverTypes']
      controller_provision_type = nil
      resource_pool = nil

      if !server_types.empty?
        controller_type = server_types.first
        controller_provision_type = controller_type['provisionType'] ? (@provision_types_interface.get(controller_type['provisionType']['id'])['provisionType'] rescue nil) : nil

        if controller_provision_type && resource_pool = prompt_resource_pool(group, cloud, service_plan, controller_provision_type, options)
            server_payload['config']['resourcePool'] = resource_pool['externalId']
        end
      end

      # Multi-disk / prompt for volumes
      volumes = options[:volumes] || prompt_volumes(service_plan, options.merge({'defaultAddFirstDataVolume': true}), @api_client, {zoneId: cloud['id'], siteId: group['id']})

      if !volumes.empty?
        server_payload['volumes'] = volumes
      end

      # Networks
      # NOTE: You must choose subnets in the same availability zone
      if controller_provision_type && controller_provision_type['hasNetworks'] && cloud['zoneType']['code'] != 'esxi'
        server_payload['networkInterfaces'] = options[:networkInterfaces] || prompt_network_interfaces(cloud['id'], provision_type['id'], (resource_pool['id'] rescue nil), options)
      end

      # Security Groups
      server_payload['securityGroups'] = prompt_security_groups_by_cloud(cloud, provision_type, resource_pool, options)

      # Visibility
      server_payload['visibility'] = options[:visibility] || (Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'visibility', 'fieldLabel' => 'Visibility', 'type' => 'select', 'defaultValue' => 'private', 'required' => true, 'selectOptions' => [{'name' => 'Private', 'value' => 'private'},{'name' => 'Public', 'value' => 'public'}]}], options[:options], @api_client, {})['visibility'])

      # Options / Custom Config
      option_type_list = ((controller_type['optionTypes'].reject { |type| !type['enabled'] || type['fieldComponent'] } rescue []) + layout['optionTypes'] +
        (cluster_type['optionTypes'].reject { |type| !type['enabled'] || !type['creatable'] || type['fieldComponent'] } rescue [])).sort { |type| type['displayOrder'] }

      server_payload.deep_merge!(Morpheus::Cli::OptionTypes.prompt(option_type_list, options[:options], @api_client, {zoneId: cloud['id'], siteId: group['id'], layoutId: layout['id']}))

      # Worker count
      default_node_count = layout['computeServers'] ? (layout['computeServers'].find {|it| it['nodeType'] == 'worker'} || {'nodeCount' => 3})['nodeCount'] : 3
      server_payload['nodeCount'] = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => "nodeCount", 'type' => 'number', 'fieldLabel' => "#{cluster_type['code'].include?('docker') ? 'Host' : 'Worker'} Count", 'required' => true, 'defaultValue' => default_node_count}], options[:options], @api_client, {}, options[:no_prompt])["nodeCount"]

      # Create User
      if !options[:createUser].nil?
        server_payload['config']['createUser'] = options[:createUser]
      elsif !options[:no_prompt]
        current_user['windowsUsername'] || current_user['linuxUsername']
        server_payload['config']['createUser'] = (current_user['windowsUsername'] || current_user['linuxUsername']) && Morpheus::Cli::OptionTypes.confirm("Create Your User?", {:default => true})
      end

      # User Groups
      userGroup = options[:userGroup] ? find_user_group_by_name_or_id(nil, options[:userGroup]) : nil

      if userGroup
        server_payload['userGroup'] = userGroup
      elsif !options[:no_prompt]
        userGroupId = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'userGroupId', 'fieldLabel' => 'User Group', 'type' => 'select', 'required' => false, 'optionSource' => 'userGroups'}], options[:options], @api_client, {})['userGroupId']

        if userGroupId
          server_payload['userGroup'] = {'id' => userGroupId}
        end
      end

      # Host / Domain
      server_payload['networkDomain'] = options[:domain] || Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'networkDomain', 'fieldLabel' => 'Network Domain', 'type' => 'select', 'required' => false, 'optionSource' => 'networkDomains'}], options[:options], @api_client, {})['networkDomain']
      server_payload['hostname'] = options[:hostname] || Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'hostname', 'fieldLabel' => 'Hostname', 'type' => 'text', 'required' => true, 'description' => 'Hostname', 'defaultValue' => resourceName}], options[:options], @api_client)['hostname']

      # Workflow / Automation
      task_set_id = options[:taskSetId] || Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'taskSet', 'fieldLabel' => 'Workflow', 'type' => 'select', 'required' => false, 'optionSource' => 'taskSets'}], options[:options], @api_client, {'phase' => 'postProvision'})['taskSet']

      if !task_set_id.nil?
        server_payload['taskSet'] = {'id' => task_set_id}
      end

      cluster_payload['server'] = server_payload
      payload = {'cluster' => cluster_payload}
    end
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.create(payload)
      return
    end
    json_response = @clusters_interface.create(payload)
    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
    elsif json_response['success']
      get_args = [json_response["cluster"]["id"]] + (options[:remote] ? ["-r",options[:remote]] : []) + (options[:refresh_interval] ? ['--refresh', options[:refresh_interval].to_s] : [])
      get(get_args)
    else
      print_rest_errors(json_response, options)
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#add_namespace(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2199

def add_namespace(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster] [name] [options]")
    opts.on("--name NAME", String, "Name of the new namespace") do |val|
      options[:name] = val.to_s
    end
    opts.on("--description [TEXT]", String, "Description") do |val|
      options[:description] = val.to_s
    end
    opts.on('--active [on|off]', String, "Enable namespace") do |val|
      options[:active] = val.to_s == 'on' || val.to_s == 'true' || val.to_s == ''
    end
    add_perms_options(opts, options)
    build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote])
    opts.footer = "Create a cluster namespace.\n" +
                  "[cluster] is required. This is the name or id of an existing cluster.\n" +
                  "[name] is required. This is the name of the new namespace."
  end

  optparse.parse!(args)
  if args.count < 1 || args.count > 3
    raise_command_error "wrong number of arguments, expected 1 to 3 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    payload = nil
    if options[:payload]
      payload = options[:payload]
      # support -O OPTION switch on top of --payload
      if options[:options]
        payload['namespace'] ||= {}
        payload['namespace'].deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) })
      end
    else
      namespace_payload = {'name' => options[:name] || (args.length > 1 ? args[1] : nil) || Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'description' => 'Namespace Name', 'required' => true}], options[:options], @api_client)['name']}
      namespace_payload.deep_merge!(prompt_update_namespace(options).reject {|k,v| k.is_a?(Symbol)})
      payload = {"namespace" => namespace_payload}
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.create_namespace(cluster['id'], payload)
      return
    end
    json_response = @clusters_interface.create_namespace(cluster['id'], payload)
    if options[:json]
      puts as_json(json_response, options)
    elsif !options[:quiet]
      namespace = json_response['namespace']
      print_green_success "Added namespace #{namespace['name']}"
      get_args = [cluster["id"], namespace["id"]] + (options[:remote] ? ["-r",options[:remote]] : [])
      get_namespace(get_args)
    end
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#add_worker(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1059

def add_worker(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster] [options]")
    opts.on("--name NAME", String, "Name of the new worker") do |val|
      options[:name] = val.to_s
    end
    opts.on("--description [TEXT]", String, "Description") do |val|
      options[:description] = val.to_s
    end
    add_server_options(opts, options)
    build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote])
    opts.footer = "Add worker to a cluster.\n" +
                  "[cluster] is required. This is the name or id of an existing cluster.\n" + 
                  "[name] is required. This is the name of the new worker."
  end

  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    payload = nil
    if options[:payload]
      payload = options[:payload]
      # support -O OPTION switch on top of --payload
      if options[:options]
        payload['server'] ||= {}
        payload['server'].deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) })
      end
    else
      server_payload = {'config' => {}}

      cluster_type = find_cluster_type_by_id(cluster['type']['id'])

      # If not available add set type return
      layout = find_layout_by_id(cluster['layout']['id'])

      # currently limiting to just worker types
      available_type_sets = layout['computeServers'].reject {|typeSet| !typeSet['dynamicCount']}

      if available_type_sets.empty?
        print_red_alert "Cluster #{cluster['name']} has no available server types to add"
        exit 1
      else
        type_set = available_type_sets[0]
      end

      # find servers within cluster
      server_matches = cluster['servers'].reject {|server| server['typeSet']['id'] != type_set['id']}
      server_type = find_server_type_by_id(server_matches.count > 0 ? server_matches[0]['computeServerType']['id'] : type_set['computeServerType']['id'])
      server_payload['serverType'] = {'id' => server_type['id']}

      # Name
      if options[:name].empty?
        default_name = (server_matches.count ? server_matches[0]['name'] : nil) || cluster['name']
        default_name.delete_prefix!(type_set['namePrefix']) if !type_set['namePrefix'].empty?
        default_name = default_name[0..(default_name.index(type_set['nameSuffix']) - 1)] if !type_set['nameSuffix'].nil? && default_name.index(type_set['nameSuffix'])
        default_name = (type_set['namePrefix'] || '') + default_name + (type_set['nameSuffix'] || '') + '-' + (server_matches.count + 1).to_s
        server_payload['name'] = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'name', 'type' => 'text', 'fieldLabel' => 'Name', 'required' => true, 'description' => 'Worker Name.', 'defaultValue' => default_name}],options[:options],@api_client,{})['name']
      else
        server_payload['name'] = options[:name]
      end

      # Description
      server_payload['description'] = options[:description] || Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text', 'description' => 'Worker Description'}], options[:options], @api_client)['description']

      # Cloud
      available_clouds = options_interface.options_for_source('clouds', {groupId: cluster['site']['id'], clusterId: cluster['id'], ownerOnly: true})['data']
      cloud_id = nil

      if options[:cloud]
        cloud = available_clouds.find {|it| it['value'].to_s == options[:cloud].to_s || it['name'].casecmp?(options[:cloud].to_s)}

        if !cloud
          print_red_alert "Cloud #{options[:cloud]} is not a valid option for cluster #{cluster['name']}"
          exit 1
        end
        cloud_id = cloud['value']
      end

      if !cloud_id
        default_cloud = available_clouds.find {|it| it['value'] == cluster['zone']['id']}
        cloud_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'cloud', 'fieldLabel' => 'Cloud', 'type' => 'select', 'selectOptions' => available_clouds, 'description' => 'Cloud', 'required' => true, 'defaultValue' => (default_cloud ? default_cloud['name'] : nil)}], options[:options], @api_client)['cloud']
        cloud_id = (default_cloud && cloud_id == default_cloud['name']) ? default_cloud['value'] : cloud_id
      end

      server_payload['cloud'] = {'id' => cloud_id}
      service_plan = prompt_service_plan(cloud_id, server_type['provisionType'], options)

      if service_plan
        server_payload['plan'] = {'code' => service_plan['code'], 'options' => prompt_service_plan_options(service_plan, options)}
      end

      # resources (zone pools)
      cloud = @clouds_interface.get(cloud_id)['zone']
      cloud['zoneType'] = get_cloud_type(cloud['zoneType']['id'])
      group = @groups_interface.get(cluster['site']['id'])['group']

      if resource_pool = prompt_resource_pool(cluster, cloud, service_plan, server_type['provisionType'], options)
        server_payload['config']['resourcePool'] = resource_pool['externalId']
      end

      # Multi-disk / prompt for volumes
      volumes = options[:volumes] || prompt_volumes(service_plan, options.merge({'defaultAddFirstDataVolume': true}), @api_client, {zoneId: cloud['id'], siteId: group['id']})

      if !volumes.empty?
        server_payload['volumes'] = volumes
      end

      # Networks
      # NOTE: You must choose subnets in the same availability zone
      provision_type = server_type['provisionType'] || {}
      if provision_type && cloud['zoneType']['code'] != 'esxi'
        server_payload['networkInterfaces'] = options[:networkInterfaces] || prompt_network_interfaces(cloud['id'], server_type['provisionType']['id'], (resource_pool['id'] rescue nil), options)
      end

      # Security Groups
      server_payload['securityGroups'] = prompt_security_groups_by_cloud(cloud, provision_type, resource_pool, options)

      # Worker count
      default_node_count = layout['computeServers'] ? (layout['computeServers'].find {|it| it['nodeType'] == 'worker'} || {'nodeCount' => 3})['nodeCount'] : 3
      server_payload['nodeCount'] = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => "nodeCount", 'type' => 'number', 'fieldLabel' => "#{cluster_type['code'].include?('docker') ? 'Host' : 'Worker'} Count", 'required' => true, 'defaultValue' => default_node_count}], options[:options], @api_client, {}, options[:no_prompt])["nodeCount"]

      # Options / Custom Config
      option_type_list = (server_type['optionTypes'].reject { |type|
        !type['enabled'] || type['fieldComponent'] ||
        (['provisionType.vmware.host', 'provisionType.scvmm.host'].include?(type['code']) && cloud['config']['hideHostSelection'] == 'on') || # should this be truthy?
        (type['fieldContext'] == 'instance.networkDomain' && type['fieldName'] == 'id')
      } rescue [])

      server_payload.deep_merge!(Morpheus::Cli::OptionTypes.prompt(option_type_list, options[:options], @api_client, {zoneId: cloud['id'], siteId: group['id'], layoutId: layout['id']}))

      # Create User
      if !options[:createUser].nil?
        server_payload['config']['createUser'] = options[:createUser]
      elsif !options[:no_prompt]
        server_payload['config']['createUser'] = (current_user['windowsUsername'] || current_user['linuxUsername']) && Morpheus::Cli::OptionTypes.confirm("Create Your User?", {:default => true})
      end

      # User Groups
      userGroup = options[:userGroup] ? find_user_group_by_name_or_id(nil, options[:userGroup]) : nil

      if userGroup
        server_payload['userGroup'] = userGroup
      elsif !options[:no_prompt]
        userGroupId = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'userGroupId', 'fieldLabel' => 'User Group', 'type' => 'select', 'required' => false, 'optionSource' => 'userGroups'}], options[:options], @api_client, {})['userGroupId']

        if userGroupId
          server_payload['userGroup'] = {'id' => userGroupId}
        end
      end

      # Host / Domain
      server_payload['networkDomain'] = options[:domain] || Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'networkDomain', 'fieldLabel' => 'Network Domain', 'type' => 'select', 'required' => false, 'optionSource' => 'networkDomains'}], options[:options], @api_client, {})['networkDomain']
      server_payload['hostname'] = options[:hostname] || Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'hostname', 'fieldLabel' => 'Hostname', 'type' => 'text', 'required' => true, 'description' => 'Hostname', 'defaultValue' => server_payload['name']}], options[:options], @api_client)['hostname']

      # Workflow / Automation
      if !options[:no_prompt]
        task_set_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'taskSet', 'fieldLabel' => 'Workflow', 'type' => 'select', 'required' => false, 'optionSource' => 'taskSets'}], options[:options], @api_client, {'phase' => 'postProvision', 'taskSetType' => 'provision'})['taskSet']

        if task_set_id
          server_payload['taskSet'] = {'id' => task_set_id}
        end
      end
      payload = {'server' => server_payload}
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.add_server(cluster['id'], payload)
      return
    end
    json_response = @clusters_interface.add_server(cluster['id'], payload)
    if options[:json]
      puts as_json(json_response)
    elsif json_response['success']
      print_green_success "Added worker to cluster #{cluster['name']}"
      #get_args = [json_response["cluster"]["id"]] + (options[:remote] ? ["-r",options[:remote]] : [])
      #get(get_args)
    end
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#api_config(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2707

def api_config(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster]")
    build_common_options(opts, options, [:query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "Display API service settings for a cluster."
  end
  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.api_config(cluster['id'], params)
      return
    end
    json_response = @clusters_interface.api_config(cluster['id'], params)
    
    render_result = render_with_format(json_response, options)
    return 0 if render_result

    title = "Cluster API Config: #{cluster['name']}"
    subtitles = []
    subtitles += parse_list_subtitles(options)
    print_h1 title, subtitles, options

    service_config = json_response
    print cyan
    description_cols = {
        "Url" => 'serviceUrl',
        "Username" => 'serviceUsername',
        #"Password" => 'servicePassword',
        "Token" => 'serviceToken',
        "Access" => 'serviceAccess',
        "Cert" => 'serviceCert',
        #"Config" => 'serviceConfig',
        "Version" => 'serviceVersion',
    }
    print_description_list(description_cols, service_config)
    print reset,"\n"
    return 0

  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#connect(opts) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 32

def connect(opts)
  @api_client = establish_remote_appliance_connection(opts)
  @clusters_interface = @api_client.clusters
  @groups_interface = @api_client.groups
  @cluster_layouts_interface = @api_client.library_cluster_layouts
  @security_groups_interface = @api_client.security_groups
  #@security_group_rules_interface = @api_client.security_group_rules
  @cloud_resource_pools_interface = @api_client.cloud_resource_pools
  @clouds_interface = @api_client.clouds
  @servers_interface = @api_client.servers
  @server_types_interface = @api_client.server_types
  @options_interface = @api_client.options
  @active_group_id = Morpheus::Cli::Groups.active_groups[@appliance_name]
  @provision_types_interface = @api_client.provision_types
  @service_plans_interface = @api_client.service_plans
  @user_groups_interface = @api_client.user_groups
  @accounts_interface = @api_client.accounts
  @logs_interface = @api_client.logs
  #@active_security_group = ::Morpheus::Cli::SecurityGroups.load_security_group_file
end

#count(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 102

def count(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[options]")
    build_common_options(opts, options, [:query, :remote, :dry_run])
    opts.footer = "Get the number of clusters."
  end
  optparse.parse!(args)
  if args.count != 0
    raise_command_error "wrong number of arguments, expected 0 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  begin
    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.get(params)
      return
    end
    json_response = @clusters_interface.get(params)
    # print number only
    if json_response['meta'] && json_response['meta']['total']
      print cyan, json_response['meta']['total'], reset, "\n"
    else
      print yellow, "unknown", reset, "\n"
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#get(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 135

def get(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[id]")
    opts.on( nil, '--hosts', "Display masters and workers" ) do
      options[:show_masters] = true
      options[:show_workers] = true
    end
    opts.on( nil, '--masters', "Display masters" ) do
      options[:show_masters] = true
    end
    opts.on( nil, '--workers', "Display workers" ) do
      options[:show_workers] = true
    end
    opts.on( nil, '--permissions', "Display permissions" ) do
      options[:show_perms] = true
    end
    opts.on('--refresh [SECONDS]', String, "Refresh until status is provisioned,failed. Default interval is #{default_refresh_interval} seconds.") do |val|
      options[:refresh_until_status] ||= "provisioned,failed"
      if !val.to_s.empty?
        options[:refresh_interval] = val.to_f
      end
    end
    opts.on('--refresh-until STATUS', String, "Refresh until a specified status is reached.") do |val|
      options[:refresh_until_status] = val.to_s.downcase
    end
    build_common_options(opts, options, [:json, :dry_run, :remote])
    opts.footer = "Get details about a cluster."
  end
  optparse.parse!(args)
  if args.count < 1
    raise_command_error "wrong number of arguments, expected 1-N and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  id_list = parse_id_list(args)
  return run_command_for_each_arg(id_list) do |arg|
    _get(arg, options)
  end
end

#get_datastore(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2572

def get_datastore(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster] [datastore]")
    build_common_options(opts, options, [:json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "Get details about a cluster datastore.\n" +
        "[cluster] is required. This is the name or id of an existing cluster.\n" +
        "[datastore] is required. This is the name or id of an existing datastore."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    # this finds the namespace in the cluster api response, then fetches it by ID
    datastore = find_datastore_by_name_or_id(cluster['id'], args[1])
    if datastore.nil?
      print_red_alert "Datastore not found for '#{args[1]}'"
      exit 1
    end
    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.get_datastore(cluster['id'], datastore['id'], params)
      return
    end
    json_response = @clusters_interface.get_datastore(cluster['id'], datastore['id'], params)

    render_result = render_with_format(json_response, options, 'datastore')
    return 0 if render_result

    print_h1 "Morpheus Cluster Datastore"
    print cyan
    description_cols = {
        "ID" => 'id',
        "Name" => 'name',
        "Type" => 'type',
        "Capacity" => lambda { |it| format_bytes_short(it['freeSpace']).strip },
        "Online" => lambda { |it| (it['online'] == false ? red : '') + format_boolean(it['online']) + cyan },
        "Active" => lambda { |it| format_boolean(it['active']) },
        "Visibility" => lambda { |it| it['visibility'].nil? ? '' : it['visibility'].to_s.capitalize },
        "Tenants" => lambda { |it| it['tenants'].nil? ? '' : it['tenants'].collect {|it| it['name']}.join(', ') },
        "Cluster" => lambda { |it| cluster['name'] }
    }
    print_description_list(description_cols, datastore)
    print reset,"\n"
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#get_namespace(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2325

def get_namespace(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster] [namespace]")
    opts.on( nil, '--permissions', "Display permissions" ) do
      options[:show_perms] = true
    end
    build_common_options(opts, options, [:query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "Get details about a cluster namespace.\n" +
                  "[cluster] is required. This is the name or id of an existing cluster.\n" +
                  "[namespace] is required. This is the name or id of an existing namespace."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    # this finds the namespace in the cluster api response, then fetches it by ID
    namespace = find_namespace_by_name_or_id(cluster['id'], args[1])
    if namespace.nil?
      print_red_alert "Namespace not found for '#{args[1]}'"
      exit 1
    end
    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.get_namespace(cluster['id'], namespace['id'], params)
      return
    end
    json_response = @clusters_interface.get_namespace(cluster['id'], namespace['id'], params)
    
    render_result = render_with_format(json_response, options, 'namespace')
    return 0 if render_result

    print_h1 "Morpheus Cluster Namespace"
    print cyan
    description_cols = {
        "ID" => 'id',
        "Name" => 'name',
        "Description" => 'description',
        "Cluster" => lambda { |it| cluster['name'] },
        "Status" => 'status',
        "Active" => lambda {|it| format_boolean it['active'] }
        # more stuff to show here
    }
    print_description_list(description_cols, namespace)
    print reset,"\n"

    if options[:show_perms]
      permissions = cluster['permissions']
      print_permissions(permissions)
    end

    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#handle(args) ⇒ `Object`



53
54
55

# File 'lib/morpheus/cli/clusters.rb', line 53

def handle(args)
  handle_subcommand(args)
end

#history(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 3057

def history(args)
  raw_args = args.dup
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster]")
    opts.on( nil, '--events', "Display sub processes (events)." ) do
      options[:show_events] = true
    end
    opts.on( nil, '--output', "Display process output." ) do
      options[:show_output] = true
    end
    opts.on('--details', "Display more details: memory and storage usage used / max values." ) do
      options[:show_events] = true
      options[:show_output] = true
      options[:details] = true
    end
    opts.on('--process-id ID', String, "Display details about a specfic process only." ) do |val|
      options[:process_id] = val
    end
    opts.on('--event-id ID', String, "Display details about a specfic process event only." ) do |val|
      options[:event_id] = val
    end
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "List historical processes for a specific cluster.\n" +
        "[cluster] is required. This is the name or id of an cluster."
  end

  optparse.parse!(args)

  # shortcut to other actions
  if options[:process_id]
    return history_details(raw_args)
  elsif options[:event_id]
    return history_event_details(raw_args)
  end

  if args.count != 1
    puts optparse
    return 1
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    params = {}
    params.merge!(parse_list_options(options))
    # params['query'] = params.delete('phrase') if params['phrase']
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.history(cluster['id'], params)
      return
    end
    json_response = @clusters_interface.history(cluster['id'], params)
    if options[:json]
      puts as_json(json_response, options, "processes")
      return 0
    elsif options[:yaml]
      puts as_yaml(json_response, options, "processes")
      return 0
    elsif options[:csv]
      puts records_as_csv(json_response['processes'], options)
      return 0
    else
      title = "Cluster History: #{cluster['name']}"
      subtitles = []
      if params[:query]
        subtitles << "Search: #{params[:query]}".strip
      end
      subtitles += parse_list_subtitles(options)
      print_h1 title, subtitles, options
      if json_response['processes'].empty?
        print "#{cyan}No process history found.#{reset}\n\n"
      else
        history_records = []
        json_response["processes"].each do |process|
          row = {
              id: process['id'],
              eventId: nil,
              uniqueId: process['uniqueId'],
              name: process['displayName'],
              description: process['description'],
              processType: process['processType'] ? (process['processType']['name'] || process['processType']['code']) : process['processTypeName'],
              createdBy: process['createdBy'] ? (process['createdBy']['displayName'] || process['createdBy']['username']) : '',
              startDate: format_local_dt(process['startDate']),
              duration: format_process_duration(process),
              status: format_process_status(process),
              error: format_process_error(process, options[:details] ? nil : 20),
              output: format_process_output(process, options[:details] ? nil : 20)
          }
          history_records << row
          process_events = process['events'] || process['processEvents']
          if options[:show_events]
            if process_events
              process_events.each do |process_event|
                event_row = {
                    id: process['id'],
                    eventId: process_event['id'],
                    uniqueId: process_event['uniqueId'],
                    name: process_event['displayName'], # blank like the UI
                    description: process_event['description'],
                    processType: process_event['processType'] ? (process_event['processType']['name'] || process_event['processType']['code']) : process['processTypeName'],
                    createdBy: process_event['createdBy'] ? (process_event['createdBy']['displayName'] || process_event['createdBy']['username']) : '',
                    startDate: format_local_dt(process_event['startDate']),
                    duration: format_process_duration(process_event),
                    status: format_process_status(process_event),
                    error: format_process_error(process_event, options[:details] ? nil : 20),
                    output: format_process_output(process_event, options[:details] ? nil : 20)
                }
                history_records << event_row
              end
            else

            end
          end
        end
        columns = [
            {:id => {:display_name => "PROCESS ID"} },
            :name,
            :description,
            {:processType => {:display_name => "PROCESS TYPE"} },
            {:createdBy => {:display_name => "CREATED BY"} },
            {:startDate => {:display_name => "START DATE"} },
            {:duration => {:display_name => "ETA/DURATION"} },
            :status,
            :error
        ]
        if options[:show_events]
          columns.insert(1, {:eventId => {:display_name => "EVENT ID"} })
        end
        if options[:show_output]
          columns << :output
        end
        # custom pretty table columns ...
        if options[:include_fields]
          columns = options[:include_fields]
        end
        print cyan
        print as_pretty_table(history_records, columns, options)
        print_results_pagination(json_response, {:label => "process", :n_label => "processes"})
        print reset, "\n"
        return 0
      end
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#history_details(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 3206

def history_details(args)
  options = {}
  process_id = nil
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [process-id]")
    opts.on('--process-id ID', String, "Display details about a specfic event." ) do |val|
      options[:process_id] = val
    end
    opts.add_hidden_option('process-id')
    build_common_options(opts, options, [:query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "Display history details for a specific process.\n" +
        "[cluster] is required. This is the name or id of a cluster.\n" +
        "[process-id] is required. This is the id of the process."
  end
  optparse.parse!(args)
  if args.count == 2
    process_id = args[1]
  elsif args.count == 1 && options[:process_id]
    process_id = options[:process_id]
  else
    puts_error optparse
    return 1
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.history_details(cluster['id'], process_id, params)
      return
    end
    json_response = @clusters_interface.history_details(cluster['id'], process_id, params)
    if options[:json]
      puts as_json(json_response, options, "process")
      return 0
    elsif options[:yaml]
      puts as_yaml(json_response, options, "process")
      return 0
    elsif options[:csv]
      puts records_as_csv(json_response['process'], options)
      return 0
    else
      process = json_response["process"]
      title = "Cluster History Details"
      subtitles = []
      subtitles << " Process ID: #{process_id}"
      subtitles += parse_list_subtitles(options)
      print_h1 title, subtitles, options
      print_process_details(process)

      print_h2 "Process Events", options
      process_events = process['events'] || process['processEvents'] || []
      history_records = []
      if process_events.empty?
        puts "#{cyan}No events found.#{reset}"
      else
        process_events.each do |process_event|
          event_row = {
              id: process_event['id'],
              eventId: process_event['id'],
              uniqueId: process_event['uniqueId'],
              name: process_event['displayName'], # blank like the UI
              description: process_event['description'],
              processType: process_event['processType'] ? (process_event['processType']['name'] || process_event['processType']['code']) : process['processTypeName'],
              createdBy: process_event['createdBy'] ? (process_event['createdBy']['displayName'] || process_event['createdBy']['username']) : '',
              startDate: format_local_dt(process_event['startDate']),
              duration: format_process_duration(process_event),
              status: format_process_status(process_event),
              error: format_process_error(process_event),
              output: format_process_output(process_event)
          }
          history_records << event_row
        end
        columns = [
            {:id => {:display_name => "EVENT ID"} },
            :name,
            :description,
            {:processType => {:display_name => "PROCESS TYPE"} },
            {:createdBy => {:display_name => "CREATED BY"} },
            {:startDate => {:display_name => "START DATE"} },
            {:duration => {:display_name => "ETA/DURATION"} },
            :status,
            :error,
            :output
        ]
        print cyan
        print as_pretty_table(history_records, columns, options)
        print_results_pagination({size: process_events.size, total: process_events.size})
        print reset, "\n"
        return 0
      end
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#history_event_details(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 3307

def history_event_details(args)
  options = {}
  process_event_id = nil
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [event-id]")
    opts.on('--event-id ID', String, "Display details about a specfic event." ) do |val|
      options[:event_id] = val
    end
    opts.add_hidden_option('event-id')
    build_common_options(opts, options, [:query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "Display history details for a specific process event.\n" +
        "[cluster] is required. This is the name or id of an cluster.\n" +
        "[event-id] is required. This is the id of the process event."
  end
  optparse.parse!(args)
  if args.count == 2
    process_event_id = args[1]
  elsif args.count == 1 && options[:event_id]
    process_event_id = options[:event_id]
  else
    puts_error optparse
    return 1
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.history_event_details(cluster['id'], process_event_id, params)
      return
    end
    json_response = @clusters_interface.history_event_details(cluster['id'], process_event_id, params)
    if options[:json]
      puts as_json(json_response, options, "processEvent")
      return 0
    elsif options[:yaml]
      puts as_yaml(json_response, options, "processEvent")
      return 0
    elsif options[:csv]
      puts records_as_csv(json_response['processEvent'], options)
      return 0
    else
      process_event = json_response['processEvent'] || json_response['event']
      title = "Cluster History Event"
      subtitles = []
      subtitles += parse_list_subtitles(options)
      print_h1 title, subtitles, options
      print_process_event_details(process_event)
      print reset, "\n"
      return 0
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#list(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 57

def list(args)
  options = {}
  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.footer = "List clusters."
  end
  optparse.parse!(args)
  if args.count != 0
    raise_command_error "wrong number of arguments, expected 0 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  begin
    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.list(params)
      return
    end
    json_response = @clusters_interface.list(params)
    
    render_result = render_with_format(json_response, options, 'clusters')
    return 0 if render_result

    title = "Morpheus Clusters"
    subtitles = []
    subtitles += parse_list_subtitles(options)
    print_h1 title, subtitles

    clusters = json_response['clusters']
    
    if clusters.empty?
      print cyan,"No clusters found.",reset,"\n"
    else
      print_clusters_table(clusters, options)
    end
    print reset,"\n"
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#list_containers(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1697

def list_containers(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster]")
    opts.on("--resource-level LEVEL", String, "Resource Level") do |val|
      options[:resourceLevel] = val.to_s
    end
    opts.on("--worker WORKER", String, "Worker") do |val|
      options[:worker] = val
    end
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "List containers for a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster."
  end

  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    if options[:worker]
      worker = find_host_by_name_or_id(options[:worker])
      return 1 if worker.nil?
      params['workerId'] = worker['id']
    end
    params = {}
    params.merge!(parse_list_options(options))
    params['resourceLevel'] = options[:resourceLevel] if !options[:resourceLevel].nil?
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.list_containers(cluster['id'], params)
      return
    end
    json_response = @clusters_interface.list_containers(cluster['id'], params)

    render_result = render_with_format(json_response, options, 'containers')
    return 0 if render_result

    title = "Morpheus Cluster Containers: #{cluster['name']}"
    subtitles = []
    subtitles += parse_list_subtitles(options)
    print_h1 title, subtitles
    containers = json_response['containers']
    if containers.empty?
      print cyan,"No containers found.",reset,"\n"
    else
      # more stuff to show here
      rows = containers.collect do |it|
        {
            id: it['id'],
            status: it['status'],
            name: it['name'],
            instance: it['instance'].nil? ? '' : it['instance']['name'],
            type: it['containerType'].nil? ? '' : it['containerType']['name'],
            location: it['ip'],
            cluster: cluster['name']
        }
      end
      columns = [
          :id, :status, :name, :instance, :type, :location, :cluster => lambda { |it| cluster['name'] }
      ]
      print as_pretty_table(rows, columns, options)
    end
    print reset,"\n"
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#list_datastores(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2508

def list_datastores(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster]")
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "List datastores for a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster."
  end

  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?

    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.list_datastores(cluster['id'], params)
      return
    end
    json_response = @clusters_interface.list_datastores(cluster['id'], params)

    render_result = render_with_format(json_response, options, 'datastores')
    return 0 if render_result

    title = "Morpheus Cluster Datastores: #{cluster['name']}"
    subtitles = []
    subtitles += parse_list_subtitles(options)
    print_h1 title, subtitles
    datastores = json_response['datastores']
    if datastores.empty?
      print cyan,"No datastores found.",reset,"\n"
    else
      # more stuff to show here
      rows = datastores.collect do |ds|
        {
            id: ds['id'],
            name: ds['name'],
            type: ds['type'],
            capacity: format_bytes_short(ds['freeSpace']).strip,
            online: (ds['online'] == false ? red : '') + format_boolean(ds['online']) + cyan,
            active: format_boolean(ds['active']),
            visibility: ds['visibility'].nil? ? '' : ds['visibility'].to_s.capitalize,
            tenants: ds['tenants'].nil? ? '' : ds['tenants'].collect {|it| it['name']}.join(', ')
        }
      end
      columns = [
          :id, :name, :type, :capacity, :online, :active, :visibility, :tenants
      ]
      print as_pretty_table(rows, columns, options)
    end
    print reset,"\n"
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#list_deployments(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2022

def list_deployments(args)
  resource_type = 'deployment'
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster]")
    opts.on("--resource-level LEVEL", String, "Resource Level") do |val|
      options[:resourceLevel] = val.to_s
    end
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "List #{resource_type}s for a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster."
  end
  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  _list_container_groups(args, options,resource_type)
end

#list_jobs(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1582

def list_jobs(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster]")
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "List jobs for a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster."
  end

  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?

    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.list_jobs(cluster['id'], params)
      return
    end
    json_response = @clusters_interface.list_jobs(cluster['id'], params)

    render_result = render_with_format(json_response, options, 'volumes')
    return 0 if render_result

    title = "Morpheus Cluster Jobs: #{cluster['name']}"
    subtitles = []
    subtitles += parse_list_subtitles(options)
    print_h1 title, subtitles
    jobs = json_response['jobs']
    if jobs.empty?
      print cyan,"No jobs found.",reset,"\n"
    else
      # more stuff to show here
      rows = jobs.collect do |job|
        {
            id: job['id'],
            status: job['type'],
            namespace: job['namespace'],
            name: job['name'],
            lastRun: format_local_dt(job['lastRun']),
            cluster: cluster['name']
        }
      end
      columns = [
          :id, :status, :namespace, :name, :lastRun, :cluster => lambda { |it| cluster['name'] }
      ]
      print as_pretty_table(rows, columns, options)
    end
    print reset,"\n"
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#list_masters(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1251

def list_masters(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster]")
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "List masters for a cluster.\n" +
                  "[cluster] is required. This is the name or id of an existing cluster."
  end

  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?

    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.list_masters(cluster['id'], params)
      return
    end
    json_response = @clusters_interface.list_masters(cluster['id'], params)
    
    render_result = render_with_format(json_response, options, 'masters')
    return 0 if render_result

    title = "Morpheus Cluster Masters: #{cluster['name']}"
    subtitles = []
    subtitles += parse_list_subtitles(options)
    print_h1 title, subtitles
    masters = json_response['masters']
    if masters.empty?
      print cyan,"No masters found.",reset,"\n"
    else
      # more stuff to show here
      
      servers = masters
      multi_tenant = false

      # print_servers_table(servers)
      rows = servers.collect {|server|
        stats = server['stats']

        if !stats['maxMemory']
          stats['maxMemory'] = stats['usedMemory'] + stats['freeMemory']
        end
        cpu_usage_str = !stats ? "" : generate_usage_bar((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]
          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
        end
        row = {
          id: server['id'],
          tenant: server['account'] ? server['account']['name'] : server['accountId'],
          name: server['name'],
          platform: server['serverOs'] ? server['serverOs']['name'].upcase : 'N/A',
          cloud: server['zone'] ? server['zone']['name'] : '',
          type: server['computeServerType'] ? server['computeServerType']['name'] : 'unmanaged',
          nodes: server['containers'] ? server['containers'].size : '',
          status: format_server_status(server, cyan),
          power: format_server_power_state(server, cyan),
          cpu: cpu_usage_str + cyan,
          memory: memory_usage_str + cyan,
          storage: storage_usage_str + cyan
        }
        row
      }
      columns = [:id, :name, :type, :cloud, :nodes, :status, :power]
      if multi_tenant
        columns.insert(4, :tenant)
      end
      columns += [:cpu, :memory, :storage]
      # custom pretty table columns ...
      if options[:include_fields]
        columns = options[:include_fields]
      end
      print cyan
      print as_pretty_table(rows, columns, options)
      print reset
      print_results_pagination(json_response)
    end
    print reset,"\n"
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#list_namespaces(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2263

def list_namespaces(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster]")
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "List namespaces for a cluster.\n" +
                  "[cluster] is required. This is the name or id of an existing cluster."
  end

  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?

    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.list_namespaces(cluster['id'], params)
      return
    end
    json_response = @clusters_interface.list_namespaces(cluster['id'], params)
    
    render_result = render_with_format(json_response, options, 'namespaces')
    return 0 if render_result

    title = "Morpheus Cluster Namespaces: #{cluster['name']}"
    subtitles = []
    subtitles += parse_list_subtitles(options)
    print_h1 title, subtitles
    namespaces = json_response['namespaces']
    if namespaces.empty?
      print cyan,"No namespaces found.",reset,"\n"
    else
      # more stuff to show here
      rows = namespaces.collect do |ns|
        {
            id: ns['id'],
            name: ns['name'],
            description: ns['description'],
            status: ns['status'],
            active: format_boolean(ns['active']),
            cluster: cluster['name']
        }
      end
      columns = [
          :id, :name, :description, :status, :active #, :cluster => lambda { |it| cluster['name'] }
      ]
      print as_pretty_table(rows, columns, options)
    end
    print reset,"\n"
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#list_pods(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2140

def list_pods(args)
  resource_type = 'pod'
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster]")
    opts.on("--resource-level LEVEL", String, "Resource Level") do |val|
      options[:resourceLevel] = val.to_s
    end
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "List #{resource_type}s for a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster."
  end
  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  _list_container_groups(args, options, resource_type)
end

#list_services(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1465

def list_services(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster]")
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "List services for a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster."
  end

  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?

    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.list_services(cluster['id'], params)
      return
    end
    json_response = @clusters_interface.list_services(cluster['id'], params)

    render_result = render_with_format(json_response, options, 'volumes')
    return 0 if render_result

    title = "Morpheus Cluster Services: #{cluster['name']}"
    subtitles = []
    subtitles += parse_list_subtitles(options)
    print_h1 title, subtitles
    services = json_response['services']
    if services.empty?
      print cyan,"No services found.",reset,"\n"
    else
      # more stuff to show here
      rows = services.collect do |service|
        {
            id: service['id'],
            name: service['name'],
            type: service['type'],
            externalIp: service['externalIp'],
            externalPort: service['externalPort'],
            internalPort: service['internalPort'],
            status: service['status'],
            cluster: cluster['name']
        }
      end
      columns = [
          :id, :name, :type, :externalIp, :externalPort, :internalPort, :status, :cluster => lambda { |it| cluster['name'] }
      ]
      print as_pretty_table(rows, columns, options)
    end
    print reset,"\n"
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#list_stateful_sets(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2081

def list_stateful_sets(args)
  resource_type = 'statefulset'
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster]")
    opts.on("--resource-level LEVEL", String, "Resource Level") do |val|
      options[:resourceLevel] = val.to_s
    end
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "List #{resource_type}s for a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster."
  end
  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  _list_container_groups(args, options, resource_type)
end

#list_volumes(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1350

def list_volumes(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster]")
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "List volumes for a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster."
  end

  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?

    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.list_volumes(cluster['id'], params)
      return
    end
    json_response = @clusters_interface.list_volumes(cluster['id'], params)

    render_result = render_with_format(json_response, options, 'volumes')
    return 0 if render_result

    title = "Morpheus Cluster Volumes: #{cluster['name']}"
    subtitles = []
    subtitles += parse_list_subtitles(options)
    print_h1 title, subtitles
    volumes = json_response['volumes']
    if volumes.empty?
      print cyan,"No volumes found.",reset,"\n"
    else
      # more stuff to show here
      rows = volumes.collect do |ns|
        {
            id: ns['id'],
            name: ns['name'],
            description: ns['description'],
            status: ns['status'],
            active: ns['active'],
            cluster: cluster['name']
        }
      end
      columns = [
          :id, :name, :description, :status, :active, :cluster => lambda { |it| cluster['name'] }
      ]
      print as_pretty_table(rows, columns, options)
    end
    print reset,"\n"
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#list_workers(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 960

def list_workers(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster]")
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "List workers for a cluster.\n" +
                  "[cluster] is required. This is the name or id of an existing cluster."
  end

  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?

    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.list_workers(cluster['id'], params)
      return
    end
    json_response = @clusters_interface.list_workers(cluster['id'], params)
    
    render_result = render_with_format(json_response, options, 'workers')
    return 0 if render_result

    title = "Morpheus Cluster Workers: #{cluster['name']}"
    subtitles = []
    subtitles += parse_list_subtitles(options)
    print_h1 title, subtitles
    workers = json_response['workers']
    if workers.empty?
      print cyan,"No workers found.",reset,"\n"
    else
      # more stuff to show here
      
      servers = workers
      multi_tenant = false

      # print_servers_table(servers)
      rows = servers.collect {|server|
        stats = server['stats']

        if !stats['maxMemory']
          stats['maxMemory'] = stats['usedMemory'] + stats['freeMemory']
        end
        cpu_usage_str = !stats ? "" : generate_usage_bar((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]
          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
        end
        row = {
          id: server['id'],
          tenant: server['account'] ? server['account']['name'] : server['accountId'],
          name: server['name'],
          platform: server['serverOs'] ? server['serverOs']['name'].upcase : 'N/A',
          cloud: server['zone'] ? server['zone']['name'] : '',
          type: server['computeServerType'] ? server['computeServerType']['name'] : 'unmanaged',
          nodes: server['containers'] ? server['containers'].size : '',
          status: format_server_status(server, cyan),
          power: format_server_power_state(server, cyan),
          cpu: cpu_usage_str + cyan,
          memory: memory_usage_str + cyan,
          storage: storage_usage_str + cyan
        }
        row
      }
      columns = [:id, :name, :type, :cloud, :nodes, :status, :power]
      if multi_tenant
        columns.insert(4, :tenant)
      end
      columns += [:cpu, :memory, :storage]
      # custom pretty table columns ...
      if options[:include_fields]
        columns = options[:include_fields]
      end
      print cyan
      print as_pretty_table(rows, columns, options)
      print reset
      print_results_pagination(json_response)
    end
    print reset,"\n"
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#logs(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 819

def logs(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster]")
    opts.on('--start TIMESTAMP','--start TIMESTAMP', "Start timestamp. Default is 30 days ago.") do |val|
      options[:start] = parse_time(val) #.utc.iso8601
    end
    opts.on('--end TIMESTAMP','--end TIMESTAMP', "End timestamp. Default is now.") do |val|
      options[:end] = parse_time(val) #.utc.iso8601
    end
    opts.on('--level VALUE', String, "Log Level. DEBUG,INFO,WARN,ERROR") do |val|
      params['level'] = params['level'] ? [params['level'], val].flatten : [val]
    end
    opts.on('--table', '--table', "Format ouput as a table.") do
      options[:table] = true
    end
    opts.on('-a', '--all', "Display all details: entire message." ) do
      options[:details] = true
    end
    build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
  end
  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    params = {}
    params['level'] = params['level'].collect {|it| it.to_s.upcase }.join('|') if params['level'] # api works with INFO|WARN
    params.merge!(parse_list_options(options))
    params['query'] = params.delete('phrase') if params['phrase']
    params['startMs'] = (options[:start].to_i * 1000) if options[:start]
    params['endMs'] = (options[:end].to_i * 1000) if options[:end]
    @logs_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @logs_interface.dry.cluster_logs(cluster['id'], params)
      return
    end
    json_response = @logs_interface.cluster_logs(cluster['id'], params)
    render_result = json_response['logs'] ? render_with_format(json_response, options, 'logs') : render_with_format(json_response, options, 'data')
    return 0 if render_result

    logs = json_response
    title = "Cluster Logs: #{cluster['name']}"
    subtitles = parse_list_subtitles(options)
    if options[:start]
      subtitles << "Start: #{options[:start]}".strip
    end
    if options[:end]
      subtitles << "End: #{options[:end]}".strip
    end
    if params[:query]
      subtitles << "Search: #{params[:query]}".strip
    end
    if params['level']
      subtitles << "Level: #{params['level']}"
    end
    logs = json_response['data'] || json_response['logs']
    print_h1 title, subtitles, options
    if logs.empty?
      puts "#{cyan}No logs found.#{reset}"
    else
      logs.each do |log_entry|
        log_level = ''
        case log_entry['level']
        when 'INFO'
          log_level = "#{blue}#{bold}INFO#{reset}"
        when 'DEBUG'
          log_level = "#{white}#{bold}DEBUG#{reset}"
        when 'WARN'
          log_level = "#{yellow}#{bold}WARN#{reset}"
        when 'ERROR'
          log_level = "#{red}#{bold}ERROR#{reset}"
        when 'FATAL'
          log_level = "#{red}#{bold}FATAL#{reset}"
        end
        puts "[#{log_entry['ts']}] #{log_level} - #{log_entry['message'].to_s.strip}"
      end
      print_results_pagination({'meta'=>{'total'=>json_response['total'],'size'=>json_response['data'].size,'max'=>(json_response['max'] || options[:max]),'offset'=>(json_response['offset'] || options[:offset] || 0)}})
    end
    print reset, "\n"
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#remove(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 764

def remove(args)
  options = {}
  query_params = {:removeResources => 'on'}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster]")
    opts.on('--remove-resources [on|off]', ['on','off'], "Remove Infrastructure. Default is on.") do |val|
      query_params[:removeResources] = val.nil? ? 'on' : val
    end
    opts.on('--preserve-volumes [on|off]', ['on','off'], "Preserve Volumes. Default is off.") do |val|
      query_params[:preserveVolumes] = val.nil? ? 'on' : val
    end
    opts.on('--remove-instances [on|off]', ['on','off'], "Remove Associated Instances. Default is off.") do |val|
      query_params[:removeInstances] = val.nil? ? 'on' : val
    end
    opts.on('--release-eips [on|off]', ['on','off'], "Release EIPs, default is on. Amazon only.") do |val|
      params[:releaseEIPs] = val.nil? ? 'on' : val
    end
    opts.on( '-f', '--force', "Force Delete" ) do
      query_params[:force] = 'on'
    end
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Delete a cluster.\n" +
                  "[cluster] is required. This is the name or id of an existing cluster."
  end
  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    
    unless options[:yes] || ::Morpheus::Cli::OptionTypes::confirm("Are you sure you would like to remove the cluster '#{cluster['name']}'?", options)
      return 9, "aborted command"
    end
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.destroy(cluster['id'], query_params)
      return
    end
    json_response = @clusters_interface.destroy(cluster['id'], query_params)
    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
    elsif !options[:quiet]
      print_green_success "Cluster #{cluster['name']} is being removed..."
      #list([])
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#remove_container(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1771

def remove_container(args)
  params = {}
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [container]")
    opts.on( '-f', '--force', "Force Delete" ) do
      options[:force] = 'on'
    end
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Delete a container within a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster.\n" +
        "[container] is required. This is the name or id of an existing container."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    container_id = args[1]

    if container_id.empty?
      raise_command_error "missing required container parameter"
    end

    container = find_container_by_name_or_id(cluster['id'], container_id)
    if container.nil?
      print_red_alert "Container not found by id '#{container_id}'"
      return 1
    end
    unless options[:yes] || ::Morpheus::Cli::OptionTypes::confirm("Are you sure you would like to remove the cluster container '#{container['name'] || container['id']}'?", options)
      return 9, "aborted command"
    end

    if !options[:force].nil?
        params['force'] = options[:force]
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.destroy_container(cluster['id'], container['id'], params)
      return
    end
    json_response = @clusters_interface.destroy_container(cluster['id'], container['id'], params)
    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
    elsif !options[:quiet]
      print_red_alert "Error removing container #{container['name']} from cluster #{cluster['name']}: #{json_response['msg']}" if json_response['success'] == false
      print_green_success "container #{container['name']} is being removed from cluster #{cluster['name']}..." if json_response['success'] == true
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#remove_deployment(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2042

def remove_deployment(args)
  resource_type = 'deployment'
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [#{resource_type}]")
    opts.on( '-f', '--force', "Force Delete" ) do
      options[:force] = 'on'
    end
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Delete a #{resource_type} within a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster.\n" +
        "[#{resource_type}] is required. This is the name or id of an existing #{resource_type}."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  _remove_container_group(args, options, resource_type)
end

#remove_job(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1644

def remove_job(args)
  params = {}
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [job]")
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Delete a job within a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster.\n" +
        "[job] is required. This is the name or id of an existing job."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    job_id = args[1]

    if job_id.empty?
      raise_command_error "missing required job parameter"
    end

    job = find_job_by_name_or_id(cluster['id'], job_id)
    if job.nil?
      print_red_alert "Job not found by id '#{job_id}'"
      return 1
    end
    unless options[:yes] || ::Morpheus::Cli::OptionTypes::confirm("Are you sure you would like to remove the cluster job '#{job['name'] || job['id']}'?", options)
      return 9, "aborted command"
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.destroy_job(cluster['id'], job['id'], params)
      return
    end
    json_response = @clusters_interface.destroy_job(cluster['id'], job['id'], params)
    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
    elsif !options[:quiet]
      print_red_alert "Error removing job #{job['name']} from cluster #{cluster['name']}: #{json_response['msg']}" if json_response['success'] == false
      print_green_success "Job #{job['name']} is being removed from cluster #{cluster['name']}..." if json_response['success'] == true
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#remove_namespace(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2461

def remove_namespace(args)
  options = {}
  query_params = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [namespace]")
    opts.on( '-f', '--force', "Force Delete" ) do
      query_params[:force] = 'on'
    end
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Delete a namespace within a cluster."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    namespace = find_namespace_by_name_or_id(cluster['id'], args[1])
    if namespace.nil?
      print_red_alert "Namespace not found by '#{args[1]}'"
      exit 1
    end
    unless options[:yes] || ::Morpheus::Cli::OptionTypes::confirm("Are you sure you would like to remove the cluster namespace '#{namespace['name']}'?", options)
      return 9, "aborted command"
    end
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.destroy_namespace(cluster['id'], namespace['id'], query_params)
      return
    end
    json_response = @clusters_interface.destroy_namespace(cluster['id'], namespace['id'], query_params)
    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
    elsif !options[:quiet]
      print_green_success "Removed cluster namespace #{namespace['name']}"
      #list([])
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#remove_pod(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2160

def remove_pod(args)
  resource_type = 'pod'
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [#{resource_type}]")
    opts.on( '-f', '--force', "Force Delete" ) do
      options[:force] = 'on'
    end
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Delete a #{resource_type} within a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster.\n" +
        "[#{resource_type}] is required. This is the name or id of an existing #{resource_type}."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  _remove_container_group(args, options, resource_type)
end

#remove_service(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1529

def remove_service(args)
  params = {}
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [service]")
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Delete a service within a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster.\n" +
        "[service] is required. This is the name or id of an existing service."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    service_id = args[1]

    if service_id.empty?
      raise_command_error "missing required service parameter"
    end

    service = find_service_by_name_or_id(cluster['id'], service_id)
    if service.nil?
      print_red_alert "Service not found by id '#{service_id}'"
      return 1
    end
    unless options[:yes] || ::Morpheus::Cli::OptionTypes::confirm("Are you sure you would like to remove the cluster service '#{service['name'] || service['id']}'?", options)
      return 9, "aborted command"
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.destroy_service(cluster['id'], service['id'], params)
      return
    end
    json_response = @clusters_interface.destroy_service(cluster['id'], service['id'], params)
    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
    elsif !options[:quiet]
      print_red_alert "Error removing service #{service['name']} from cluster #{cluster['name']}: #{json_response['msg']}" if json_response['success'] == false
      print_green_success "Service #{service['name']} is being removed from cluster #{cluster['name']}..." if json_response['success'] == true
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#remove_stateful_set(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2101

def remove_stateful_set(args)
  resource_type = 'statefulset'
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [#{resource_type}]")
    opts.on( '-f', '--force', "Force Delete" ) do
      options[:force] = 'on'
    end
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Delete a #{resource_type} within a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster.\n" +
        "[#{resource_type}] is required. This is the name or id of an existing #{resource_type}."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  _remove_container_group(args, options, resource_type)
end

#remove_volume(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1412

def remove_volume(args)
  params = {}
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [volume]")
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Delete a volume within a cluster.\n" +
                  "[cluster] is required. This is the name or id of an existing cluster.\n" +
                  "[volume] is required. This is the name or id of an existing volume."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    volume_id = args[1]

    if volume_id.empty?
      raise_command_error "missing required volume parameter"
    end

    volume = find_volume_by_name_or_id(cluster['id'], volume_id)
    if volume.nil?
      print_red_alert "Volume not found for '#{volume_id}'"
      return 1
    end
    unless options[:yes] || ::Morpheus::Cli::OptionTypes::confirm("Are you sure you would like to remove the cluster volume '#{volume['name'] || volume['id']}'?", options)
      return 9, "aborted command"
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.destroy_volume(cluster['id'], volume['id'], params)
      return
    end
    json_response = @clusters_interface.destroy_volume(cluster['id'], volume['id'], params)
    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
    elsif !options[:quiet]
      print_red_alert "Error removing volume #{volume['name']} from cluster #{cluster['name']}: #{json_response['msg']}" if json_response['success'] == false
      print_green_success "Volume #{volume['name']} is being removed from cluster #{cluster['name']}..." if json_response['success'] == true
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#restart_container(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 1831

def restart_container(args)
  params = {}
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [container]")
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Restart a container within a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster.\n" +
        "[container] is required. This is the name or id of an existing container."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    container_id = args[1]

    if container_id.empty?
      raise_command_error "missing required container parameter"
    end

    container = find_container_by_name_or_id(cluster['id'], container_id)
    if container.nil?
      print_red_alert "Container not found by id '#{container_id}'"
      return 1
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.restart_container(cluster['id'], container['id'], params)
      return
    end
    json_response = @clusters_interface.restart_container(cluster['id'], container['id'], params)
    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
    elsif !options[:quiet]
      print_red_alert "Error restarting container #{container['name']} for cluster #{cluster['name']}: #{json_response['msg']}" if json_response['success'] == false
      print_green_success "Container #{container['name']} is restarting for cluster #{cluster['name']}..." if json_response['success'] == true
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#restart_deployment(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2063

def restart_deployment(args)
  resource_type = 'deployment'
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [#{resource_type}]")
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Restart a #{resource_type} within a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster.\n" +
        "[#{resource_type}] is required. This is the name or id of an existing #{resource_type}."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  _restart_container_group(args, options, resource_type)
end

#restart_pod(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2181

def restart_pod(args)
  resource_type = 'pod'
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [#{resource_type}]")
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Restart a #{resource_type} within a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster.\n" +
        "[#{resource_type}] is required. This is the name or id of an existing #{resource_type}."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  _restart_container_group(args, options, resource_type)
end

#restart_stateful_set(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2122

def restart_stateful_set(args)
  resource_type = 'statefulset'
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [#{resource_type}]")
    build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
    opts.footer = "Restart a #{resource_type} within a cluster.\n" +
        "[cluster] is required. This is the name or id of an existing cluster.\n" +
        "[#{resource_type}] is required. This is the name or id of an existing #{resource_type}."
  end
  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  _restart_container_group(args, options, resource_type)
end

#update(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 674

def update(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster] --name --description --active")
    opts.on("--name NAME", String, "Updates Cluster Name") do |val|
      options[:name] = val.to_s
    end
    opts.on("--description [TEXT]", String, "Updates Cluster Description") do |val|
      options[:description] = val.to_s
    end
    opts.on("--api-url [TEXT]", String, "Updates Cluster API Url") do |val|
      options[:apiUrl] = val.to_s
    end
    opts.on('--active [on|off]', String, "Can be used to enable / disable the cluster. Default is on") do |val|
      options[:active] = val.to_s == 'on' || val.to_s == 'true' || val.to_s == '1' || val.to_s == ''
    end
    opts.on( nil, '--refresh', "Refresh cluster" ) do
      options[:refresh] = true
    end
    opts.on("--tenant ACCOUNT", String, "Account ID or Name" ) do |val|
      options[:tenant] = val
    end
    build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote])
    opts.footer = "Update a cluster.\n" +
                  "[cluster] is required. This is the name or id of an existing cluster."
  end

  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    payload = nil
    cluster = nil

    if options[:payload]
      payload = options[:payload]
      # support -O OPTION switch on top of --payload
      if options[:options]
        payload['cluster'] ||= {}
        payload['cluster'].deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) })
      end

      if !payload['cluster'].empty?
        cluster = find_cluster_by_name_or_id(payload['cluster']['id'] || payload['cluster']['name'])
      end
    else
      cluster = find_cluster_by_name_or_id(args[0])
      cluster_payload = {}
      cluster_payload['name'] = options[:name] if !options[:name].empty?
      cluster_payload['description'] = options[:description] if !options[:description].empty?
      cluster_payload['enabled'] = options[:active] if !options[:active].nil?
      cluster_payload['serviceUrl'] = options[:apiUrl] if !options[:apiUrl].nil?
      cluster_payload['refresh'] = options[:refresh] if options[:refresh] == true
      cluster_payload['tenant'] = options[:tenant] if !options[:tenant].nil?
      payload = {"cluster" => cluster_payload}
    end

    if !cluster
      print_red_alert "No clusters available for update"
      exit 1
    end

    has_field_updates = ['name', 'description', 'enabled', 'serviceUrl'].find {|field| payload['cluster'] && !payload['cluster'][field].nil? && payload['cluster'][field] != cluster[field] ? field : nil}

    if !has_field_updates && cluster_payload['refresh'].nil? && cluster_payload['tenant'].nil?
      print_green_success "Nothing to update"
      exit 1
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.update(cluster['id'], payload)
      return
    end
    json_response = @clusters_interface.update(cluster['id'], payload)
    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
    elsif json_response['success']
      get_args = [json_response["cluster"]["id"]] + (options[:remote] ? ["-r",options[:remote]] : []) + (options[:refresh_interval] ? ['--refresh', options[:refresh_interval].to_s] : [])
      get(get_args)
    else
      print_rest_errors(json_response, options)
    end
  end
end

#update_datastore(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2629

def update_datastore(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster] [datastore] [options]")
    opts.on('--active [on|off]', String, "Enable datastore") do |val|
      options[:active] = val.to_s == 'on' || val.to_s == 'true' || val.to_s == ''
    end
    add_perms_options(opts, options, ['plans', 'groupDefaults'])
    build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote])
    opts.footer = "Update a cluster datastore.\n" +
        "[cluster] is required. This is the name or id of an existing cluster.\n" +
        "[datastore] is required. This is the name or id of an existing datastore."
  end

  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    datastore = find_datastore_by_name_or_id(cluster['id'], args[1])
    if datastore.nil?
      print_red_alert "Datastore not found by '#{args[1]}'"
      exit 1
    end
    payload = nil
    if options[:payload]
      payload = options[:payload]
      # support -O OPTION switch on top of everything
      if options[:options]
        payload.deep_merge!({'datastore' => options[:options].reject {|k,v| k.is_a?(Symbol) }})
      end
    else
      payload = {'datastore' => {}}
      payload['datastore']['active'] = options[:active].nil? ? (Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'active', 'fieldLabel' => 'Active', 'type' => 'checkbox', 'description' => 'Datastore Active', 'defaultValue' => true}], options[:options], @api_client))['active'] == 'on' : options[:active]

      perms = prompt_permissions(options.merge({:available_plans => namespace_service_plans}), datastore['owner']['id'] == current_user['accountId'] ? ['plans', 'groupDefaults'] : ['plans', 'groupDefaults', 'visibility', 'tenants'])
      perms_payload = {}
      perms_payload['resourcePermissions'] = perms['resourcePermissions'] if !perms['resourcePermissions'].nil?
      perms_payload['tenantPermissions'] = perms['tenantPermissions'] if !perms['tenantPermissions'].nil?

      payload['datastore']['permissions'] = perms_payload
      payload['datastore']['visibility'] = perms['resourcePool']['visibility'] if !perms['resourcePool'].nil? && !perms['resourcePool']['visibility'].nil?

      # support -O OPTION switch on top of everything
      if options[:options]
        payload.deep_merge!({'datastore' => options[:options].reject {|k,v| k.is_a?(Symbol) }})
      end

      if payload['datastore'].nil? || payload['datastore'].empty?
        raise_command_error "Specify at least one option to update.\n#{optparse}"
      end
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.update_datastore(cluster['id'], datastore['id'], payload)
      return
    end
    json_response = @clusters_interface.update_datastore(cluster['id'], datastore['id'], payload)
    if options[:json]
      puts as_json(json_response)
    elsif !options[:quiet]
      datastore = json_response['datastore']
      print_green_success "Updated datastore #{datastore['name']}"
      #get_args = [cluster["id"], datastore["id"]] + (options[:remote] ? ["-r",options[:remote]] : [])
      #get_namespace(get_args)
    end
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#update_namespace(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2389

def update_namespace(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster] [namespace] [options]")
    opts.on("--description [TEXT]", String, "Description") do |val|
      options[:description] = val.to_s
    end
    opts.on('--active [on|off]', String, "Enable namespace") do |val|
      options[:active] = val.to_s == 'on' || val.to_s == 'true' || val.to_s == ''
    end
    add_perms_options(opts, options)
    build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote])
    opts.footer = "Update a cluster namespace.\n" +
                  "[cluster] is required. This is the name or id of an existing cluster.\n" +
                  "[namespace] is required. This is the name or id of an existing namespace."
  end

  optparse.parse!(args)
  if args.count != 2
    raise_command_error "wrong number of arguments, expected 2 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    namespace = find_namespace_by_name_or_id(cluster['id'], args[1])
    if namespace.nil?
      print_red_alert "Namespace not found by '#{args[1]}'"
      exit 1
    end
    payload = nil
    if options[:payload]
      payload = options[:payload]
      # support -O OPTION switch on top of everything
      if options[:options]
        payload.deep_merge!({'namespace' => options[:options].reject {|k,v| k.is_a?(Symbol) }})
      end
    else
      payload = {'namespace' => prompt_update_namespace(options)}

      # support -O OPTION switch on top of everything
      if options[:options]
        payload.deep_merge!({'namespace' => options[:options].reject {|k,v| k.is_a?(Symbol) }})
      end

      if payload['namespace'].nil? || payload['namespace'].empty?
        raise_command_error "Specify at least one option to update.\n#{optparse}"
      end
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.update_namespace(cluster['id'], namespace['id'], payload)
      return
    end
    json_response = @clusters_interface.update_namespace(cluster['id'], namespace['id'], payload)
    if options[:json]
      puts as_json(json_response)
    elsif !options[:quiet]
      namespace = json_response['namespace']
      print_green_success "Updated namespace #{namespace['name']}"
      get_args = [cluster["id"], namespace["id"]] + (options[:remote] ? ["-r",options[:remote]] : [])
      get_namespace(get_args)
    end
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#update_permissions(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 908

def update_permissions(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage( "[cluster]")
    add_perms_options(opts, options)
    build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote])
    opts.footer = "Update a clusters permissions.\n" +
        "[cluster] is required. This is the name or id of an existing cluster."
  end

  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?

    if options[:payload]
      payload = options[:payload]
      # support -O OPTION switch on top of --payload
      if options[:options]
        payload['permissions'] ||= {}
        payload['permissions'].deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) })
      end
    else
      payload = {"permissions" => prompt_permissions(options.merge({:available_plans => namespace_service_plans}))}
      # if payload["permissions"] && payload["permissions"]["resourcePool"]
      #   payload["permissions"].delete("resourcePool")
      # end
    end

    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.update_permissions(cluster['id'], payload)
      return
    end
    json_response = @clusters_interface.update_permissions(cluster['id'], payload)
    if options[:json]
      print JSON.pretty_generate(json_response)
      print "\n"
    elsif json_response['success']
      get_args = [json_response["cluster"]["id"], '--permissions'] + (options[:remote] ? ["-r",options[:remote]] : []) + (options[:refresh_interval] ? ['--refresh', options[:refresh_interval].to_s] : [])
      get(get_args)
    else
      print_rest_errors(json_response, options)
    end
  end
end

#update_wiki(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2979

def update_wiki(args)
  options = {}
  params = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster] [options]")
    build_option_type_options(opts, options, update_wiki_page_option_types)
    opts.on('--file FILE', "File containing the wiki content. This can be used instead of --content") do |filename|
      full_filename = File.expand_path(filename)
      if File.exists?(full_filename)
        params['content'] = File.read(full_filename)
      else
        print_red_alert "File not found: #{full_filename}"
        return 1
      end
      # use the filename as the name by default.
      if !params['name']
        params['name'] = File.basename(full_filename)
      end
    end
    opts.on(nil, '--clear', "Clear current page content") do |val|
      params['content'] = ""
    end
    build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote])
  end
  optparse.parse!(args)
  if args.count != 1
    puts_error  "#{Morpheus::Terminal.angry_prompt}wrong number of arguments. Expected 1 and received #{args.count} #{args.inspect}\n#{optparse}"
    return 1
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    # construct payload
    passed_options = options[:options] ? options[:options].reject {|k,v| k.is_a?(Symbol) } : {}
    payload = nil
    if options[:payload]
      payload = options[:payload]
      payload.deep_merge!({'page' => passed_options}) unless passed_options.empty?
    else
      payload = {
        'page' => {
        }
      }
      # allow arbitrary -O options
      payload.deep_merge!({'page' => passed_options}) unless passed_options.empty?
      # prompt for options
      #params = Morpheus::Cli::OptionTypes.prompt(update_wiki_page_option_types, options[:options], @api_client, options[:params])
      #params = passed_options
      params.deep_merge!(passed_options)

      if params.empty?
        raise_command_error "Specify at least one option to update.\n#{optparse}"
      end

      payload.deep_merge!({'page' => params}) unless params.empty?
    end
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.update_wiki(cluster["id"], payload)
      return
    end
    json_response = @clusters_interface.update_wiki(cluster["id"], payload)

    if options[:json]
      puts as_json(json_response, options)
    else
      print_green_success "Updated wiki page for cluster #{cluster['name']}"
      wiki([cluster['id']])
    end
    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#view(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 322

def view(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster]")
    opts.on('-w','--wiki', "Open the wiki tab for this cluster") do
      options[:link_tab] = "wiki"
    end
    opts.on('--tab VALUE', String, "Open a specific tab") do |val|
      options[:link_tab] = val.to_s
    end
    build_common_options(opts, options, [:dry_run, :remote])
    opts.footer = "View a cluster in a web browser" + "\n" +
                  "[cluster] is required. This is the name or id of a cluster. Supports 1-N [cluster] arguments."
  end
  optparse.parse!(args)
  if args.count < 1
    raise_command_error "wrong number of arguments, expected 1-N and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  id_list = parse_id_list(args)
  return run_command_for_each_arg(id_list) do |arg|
    _view(arg, options)
  end
end

#view_api_token(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2809

def view_api_token(args)
  print_token_only = false
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster]")
    build_common_options(opts, options, [:dry_run, :remote])
    opts.on('-t','--token-only', "Print the api token only") do
      print_token_only = true
    end
    opts.footer = "Display api token for a cluster."
  end
  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.api_config(cluster['id'], params)
      return
    end
    json_response = @clusters_interface.api_config(cluster['id'], params)
    
    render_result = render_with_format(json_response, options)
    return 0 if render_result

    service_config = json_response
    service_token = service_config['serviceToken']

    if print_token_only
      if service_token.to_s.empty?
        print yellow,"No api token found.",reset,"\n"
        return 1
      else
        print cyan,service_token,reset,"\n"
        return 0
      end
    end

    title = "Cluster API Token: #{cluster['name']}"
    subtitles = []
    print_h1 title, subtitles, options
    
    if service_token.to_s.empty?
      print yellow,"No api token found.",reset,"\n\n"
      return 1
    else
      print cyan,service_token,reset,"\n\n"
      return 0
    end
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#view_kube_config(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2761

def view_kube_config(args)
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster]")
    build_common_options(opts, options, [:query, :json, :yaml, :csv, :fields, :dry_run, :remote])
    opts.footer = "Display Kubernetes config for a cluster."
  end
  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?
    params = {}
    params.merge!(parse_list_options(options))
    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.api_config(cluster['id'], params)
      return
    end
    json_response = @clusters_interface.api_config(cluster['id'], params)
    
    render_result = render_with_format(json_response, options)
    return 0 if render_result

    title = "Cluster Kube Config: #{cluster['name']}"
    subtitles = []
    subtitles += parse_list_subtitles(options)
    print_h1 title, subtitles, options

    service_config = json_response
    service_access = service_config['serviceAccess']
    if service_access.to_s.empty?
      print yellow,"No kube config found.",reset,"\n\n"
      return 1
    else
      print cyan,service_access,reset,"\n\n"
      return 0
    end

  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#view_wiki(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2948

def view_wiki(args)
  params = {}
  options = {}
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[id]")
    build_common_options(opts, options, [:dry_run, :remote])
    opts.footer = "View cluster wiki page in a web browser" + "\n" +
                  "[cluster] is required. This is the name or id of a cluster."
  end
  optparse.parse!(args)
  if args.count != 1
    raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
  end
  connect(options)
  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?

    link = "#{@appliance_url}/login/oauth-redirect?access_token=#{@access_token}\\&redirectUri=/infrastructure/clusters/#{cluster['id']}#!wiki"

    if options[:dry_run]
      puts Morpheus::Util.open_url_command(link)
      return 0
    end
    return Morpheus::Util.open_url(link)
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

#wiki(args) ⇒ `Object`

# File 'lib/morpheus/cli/clusters.rb', line 2870

def wiki(args)
  options = {}
  params = {}
  open_wiki_link = false
  optparse = Morpheus::Cli::OptionParser.new do |opts|
    opts.banner = subcommand_usage("[cluster]")
    opts.on('--view', '--view', "View wiki page in web browser.") do
      open_wiki_link = true
    end
    build_common_options(opts, options, [:json, :dry_run, :remote])
    opts.footer = "View wiki page details for a cluster." + "\n" +
                  "[cluster] is required. This is the name or id of a cluster."
  end
  optparse.parse!(args)
  if args.count != 1
    puts_error  "#{Morpheus::Terminal.angry_prompt}wrong number of arguments. Expected 1 and received #{args.count} #{args.inspect}\n#{optparse}"
    return 1
  end
  connect(options)

  begin
    cluster = find_cluster_by_name_or_id(args[0])
    return 1 if cluster.nil?


    @clusters_interface.setopts(options)
    if options[:dry_run]
      print_dry_run @clusters_interface.dry.wiki(cluster["id"], params)
      return
    end
    json_response = @clusters_interface.wiki(cluster["id"], params)
    page = json_response['page']

    render_result = render_with_format(json_response, options, 'page')
    return 0 if render_result

    if page

      # my_terminal.exec("wiki get #{page['id']}")

      print_h1 "cluster Wiki Page: #{cluster['name']}"
      # print_h1 "Wiki Page Details"
      print cyan

      print_description_list({
        "Page ID" => 'id',
        "Name" => 'name',
        #"Category" => 'category',
        #"Ref Type" => 'refType',
        #"Ref ID" => 'refId',
        #"Owner" => lambda {|it| it['account'] ? it['account']['name'] : '' },
        "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
        "Created By" => lambda {|it| it['createdBy'] ? it['createdBy']['username'] : '' },
        "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
        "Updated By" => lambda {|it| it['updatedBy'] ? it['updatedBy']['username'] : '' }
      }, page)
      print reset,"\n"

      print_h2 "Page Content"
      print cyan, page['content'], reset, "\n"

    else
      print "\n"
      print cyan, "No wiki page found.", reset, "\n"
    end
    print reset,"\n"

    if open_wiki_link
      return view_wiki([args[0]])
    end

    return 0
  rescue RestClient::Exception => e
    print_rest_exception(e, options)
    exit 1
  end
end

Class: Morpheus::Cli::Clusters

Overview

Instance Attribute Summary

Attributes included from CliCommand

Instance Method Summary collapse

Methods included from AccountsHelper

Methods included from WhoamiHelper

Methods included from ProcessesHelper

Methods included from ProvisioningHelper

Methods included from CliCommand

Instance Method Details

#_get(arg, options = {}) ⇒ Object

#_list_container_groups(args, options, resource_type) ⇒ Object

#_remove_container_group(args, options, resource_type) ⇒ Object

#_restart_container_group(args, options, resource_type) ⇒ Object

#_view(arg, options = {}) ⇒ Object

#add(args) ⇒ Object

#add_namespace(args) ⇒ Object

#add_worker(args) ⇒ Object

#api_config(args) ⇒ Object

#connect(opts) ⇒ Object

#count(args) ⇒ Object

#get(args) ⇒ Object

#get_datastore(args) ⇒ Object

#get_namespace(args) ⇒ Object

#handle(args) ⇒ Object

#history(args) ⇒ Object

#history_details(args) ⇒ Object

#history_event_details(args) ⇒ Object

#list(args) ⇒ Object

#list_containers(args) ⇒ Object

#list_datastores(args) ⇒ Object

#list_deployments(args) ⇒ Object

#list_jobs(args) ⇒ Object

#list_masters(args) ⇒ Object

#list_namespaces(args) ⇒ Object

#list_pods(args) ⇒ Object

#list_services(args) ⇒ Object

#list_stateful_sets(args) ⇒ Object

#list_volumes(args) ⇒ Object

#list_workers(args) ⇒ Object

#logs(args) ⇒ Object

#remove(args) ⇒ Object

#remove_container(args) ⇒ Object

#remove_deployment(args) ⇒ Object

#remove_job(args) ⇒ Object

#remove_namespace(args) ⇒ Object

#remove_pod(args) ⇒ Object

#remove_service(args) ⇒ Object

#remove_stateful_set(args) ⇒ Object

#remove_volume(args) ⇒ Object

#restart_container(args) ⇒ Object

#restart_deployment(args) ⇒ Object

#restart_pod(args) ⇒ Object

#restart_stateful_set(args) ⇒ Object

#update(args) ⇒ Object

#update_datastore(args) ⇒ Object

#update_namespace(args) ⇒ Object

#update_permissions(args) ⇒ Object

#update_wiki(args) ⇒ Object

#view(args) ⇒ Object

#view_api_token(args) ⇒ Object

#view_kube_config(args) ⇒ Object

#view_wiki(args) ⇒ Object

#wiki(args) ⇒ Object

#_get(arg, options = {}) ⇒ `Object`

#_list_container_groups(args, options, resource_type) ⇒ `Object`

#_remove_container_group(args, options, resource_type) ⇒ `Object`

#_restart_container_group(args, options, resource_type) ⇒ `Object`

#_view(arg, options = {}) ⇒ `Object`

#add(args) ⇒ `Object`

#add_namespace(args) ⇒ `Object`

#add_worker(args) ⇒ `Object`

#api_config(args) ⇒ `Object`

#connect(opts) ⇒ `Object`

#count(args) ⇒ `Object`

#get(args) ⇒ `Object`

#get_datastore(args) ⇒ `Object`

#get_namespace(args) ⇒ `Object`

#handle(args) ⇒ `Object`

#history(args) ⇒ `Object`

#history_details(args) ⇒ `Object`

#history_event_details(args) ⇒ `Object`

#list(args) ⇒ `Object`

#list_containers(args) ⇒ `Object`

#list_datastores(args) ⇒ `Object`

#list_deployments(args) ⇒ `Object`

#list_jobs(args) ⇒ `Object`

#list_masters(args) ⇒ `Object`

#list_namespaces(args) ⇒ `Object`

#list_pods(args) ⇒ `Object`

#list_services(args) ⇒ `Object`

#list_stateful_sets(args) ⇒ `Object`

#list_volumes(args) ⇒ `Object`

#list_workers(args) ⇒ `Object`

#logs(args) ⇒ `Object`

#remove(args) ⇒ `Object`

#remove_container(args) ⇒ `Object`

#remove_deployment(args) ⇒ `Object`

#remove_job(args) ⇒ `Object`

#remove_namespace(args) ⇒ `Object`

#remove_pod(args) ⇒ `Object`

#remove_service(args) ⇒ `Object`

#remove_stateful_set(args) ⇒ `Object`

#remove_volume(args) ⇒ `Object`

#restart_container(args) ⇒ `Object`

#restart_deployment(args) ⇒ `Object`

#restart_pod(args) ⇒ `Object`

#restart_stateful_set(args) ⇒ `Object`

#update(args) ⇒ `Object`

#update_datastore(args) ⇒ `Object`

#update_namespace(args) ⇒ `Object`

#update_permissions(args) ⇒ `Object`

#update_wiki(args) ⇒ `Object`

#view(args) ⇒ `Object`

#view_api_token(args) ⇒ `Object`

#view_kube_config(args) ⇒ `Object`

#view_wiki(args) ⇒ `Object`

#wiki(args) ⇒ `Object`