mtncloud-cli 1.0.0

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

@@ -0,0 +1,20 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::NetworkSecurityServerTypes
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::RestCommand
+  include MtnCloud::Cli::InfrastructureHelper
+
+  set_command_description "View network security server types"
+  set_command_name :'network-security-server-types'
+  register_subcommands :list, :get
+
+  # hidden in favor of get-type and list-types
+  set_command_hidden
+
+  # register_interfaces :network_security_server_types
+
+  protected
+
+end
+

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

@@ -0,0 +1,222 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::NetworkServerGroups
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::WhoamiHelper
+  include MtnCloud::Cli::RestCommand
+  include MtnCloud::Cli::SecondaryRestCommand
+  include MtnCloud::Cli::ProvisioningHelper
+
+  set_command_description "View and manage network server groups."
+  set_command_name :'network-server-groups'
+  register_subcommands :list, :get, :add, :update, :remove
+  register_interfaces :network_servers, :network_server_groups, :accounts
+  set_rest_perms_config({enabled:true, excludes:['groups', 'plans', 'visibility', 'resource'], context: 'permissions'})
+
+  protected
+
+  NSXT_CRITERIA_TYPES = ['Condition', 'NestedExpression'] unless defined? NSXT_CRITERIA_TYPES
+  NSXT_MEMBER_TYPES = ['Path', 'ExternalID'] unless defined? NSXT_MEMBER_TYPES
+  NSXT_IP_TYPES = ['IPAddress', 'MACAddress'] unless defined? NSXT_IP_TYPES
+  NSXT_AD_GROUP_TYPES = ['IdentityGroup'] unless defined? NSXT_AD_GROUP_TYPES
+
+  def network_server_group_list_key
+    'groups'
+  end
+
+  def network_server_group_object_key
+    'group'
+  end
+
+  def network_server_group_field_context
+    network_server_group_object_key
+  end
+
+  def load_option_types_for_network_server_group(record_type, parent_record)
+    parent_record['type']['groupOptionTypes']
+  end
+
+  def network_server_group_list_column_definitions(options)
+    if options[:parent_record]['type']['code'] == 'nsx-t'
+      members_lambda = lambda do |group|
+        members = []
+        {
+          'Criteria' => NSXT_CRITERIA_TYPES,
+          'Members' => NSXT_MEMBER_TYPES,
+          'IPS / MACS' => NSXT_IP_TYPES,
+          'AD Groups' => NSXT_AD_GROUP_TYPES
+        }.each do |label, types|
+          if (count = group['members'].select{|member| types.include?(member['type'])}.count) > 0
+            members << "#{count} #{label}"
+          end
+        end
+        members.join(', ')
+      end
+    else
+      members_lambda = lambda do |group|
+        group['members'].collect{|member| member['type']}.join(', ')
+      end
+    end
+
+    columns = {
+      'ID' => 'id',
+      'Name' => 'name',
+      'Description' => {:label => 'Description', :max_width => 50, :display_method => lambda {|group| group['description']}},
+      'Members' => members_lambda
+    }
+
+    if is_master_account
+      columns['Visibility'] = lambda {|it| it['visibility'].capitalize}
+      columns['Tenants'] = lambda do |it|
+        tenants = []
+        if it['permissions'] and it['permissions']['tenantPermissions']
+          tenants = @accounts_interface.list({:ids => it['permissions']['tenantPermissions']['accounts']})['accounts'].collect{|account| account['name']}
+        end
+        tenants.join(', ')
+      end
+    end
+    columns
+  end
+
+  def network_server_group_column_definitions(options)
+    if options[:parent_record]['type']['code'] == 'nsx-t'
+      tags_lambda = lambda{|group|
+        (group['tags'] || []).collect{|tag|
+          "#{tag['name']}#{(tag['value'] || '').length > 0 ? " (scope: #{tag['value']})" : ''}"
+        }.join(', ')
+      }
+    else
+      tags_lambda = lambda {|group| group['tags'] ? format_metadata(group['tags']) : '' }
+    end
+    columns = {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Description" => 'description',
+      "Tags" => tags_lambda
+    }
+    columns
+  end
+
+  def network_server_group_add_prompt(record_payload, record_type, parent_record, options)
+    unless parent_record['type']['code'] != 'nsx-t' or options[:no_prompt]
+      nsxt_add_prompt(record_payload, record_type, parent_record, options)
+    end
+  end
+
+  def nsxt_add_prompt(record_payload, record_type, parent_record, options)
+    # criteria
+    criteria = []
+    while criteria.count < 5 && MtnCloud::Cli::OptionTypes.confirm("Add#{criteria.count == 0 ? '': ' another'} criteria?", {:default => false})
+      if true #members.count == 0 or members.last['memberValue'] == 'OR' # Can't have nested follow AND conjunction
+        type = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'fieldLabel' => 'Criteria Type', 'type' => 'select', 'selectOptions' => ['Condition', 'Nested Expression'].map{|it| {'name' => it, 'value' => it.sub(' ', '')}}, 'required' => true, 'defaultValue' => 'Condition'}], options[:options])['type']
+      end
+      prompt_condition = lambda do
+        compare_type = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'memberType', 'fieldLabel' => 'Criteria Item', 'type' => 'select', 'selectOptions' => ['Virtual Machine', 'Segment Port', 'Segment', 'IP Set'].map{|it| {'name' => it, 'value' => it.sub(' ', '')}}, 'required' => true, 'defaultValue' => 'VirtualMachine'}], options[:options])['memberType']
+        compare_key = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'key', 'fieldLabel' => "#{compare_type} Field", 'type' => 'select', 'selectOptions' => (compare_type == 'VirtualMachine' ? ['Name', 'Tag', 'OS Name', 'Computer Name'] : ['Tag'] ).map{|it| {'name' => it, 'value' => it.sub(' ', '')}}, 'required' => true, 'defaultValue' => 'Tag'}], options[:options])['key']
+        compare_operator = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'operator', 'fieldLabel' => "#{compare_key} Operator", 'type' => 'select', 'selectOptions' => (compare_type == 'VirtualMachine' ? ['Equals', 'Contains', 'Starts With', 'Ends With'] : ['Equals']).map{|it| {'name' => it, 'value' => it.sub(' ', '').upcase}}, 'required' => true, 'defaultValue' => 'EQUALS'}], options[:options])['operator']
+        compare_value = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'value', 'type' => 'text', 'fieldLabel' => "#{compare_key} Value", 'required' => true, 'description' => 'Value to compare.'}], options[:options])['value']
+        compare_scope = nil
+        if compare_key == 'Tag'
+          compare_scope = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'scope', 'type' => 'text', 'fieldLabel' => "#{compare_key} Scope", 'required' => false}], options[:options], @api_client, {}, false, true)['scope']
+        end
+        compare_expr = {key: compare_key, operator: compare_operator, value: compare_value}
+        compare_expr.merge!({scope: compare_scope}) if compare_scope
+        {'type' => 'Condition', 'memberType' => compare_type, 'memberExpression' => JSON.generate(compare_expr)}
+      end
+
+      if criteria.count > 0
+        criteria.last['memberValue'] = 'OR'
+      end
+
+      if type == 'Condition'
+        prev_criteria = criteria.count > 0 ? criteria.last : nil
+        criteria << prompt_condition.call
+        if prev_criteria and prev_criteria['type'] != 'NestedExpression' and prev_criteria['memberType'] == criteria.last['memberType']
+          prev_criteria['memberValue'] = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'memberValue', 'fieldLabel' => 'And/Or', 'type' => 'select', 'selectOptions' => ['and', 'or'].map{|it| {'name' => it, 'value' => it.upcase}}, 'required' => true, 'defaultValue' => 'AND', 'description' => 'Conjunction to use between this condition and the previous condition'}], options[:options])['memberValue']
+        end
+      else
+        # just prompt for conditions w/
+        nested_members = [prompt_condition.call]
+        while nested_members.count < 5 && MtnCloud::Cli::OptionTypes.confirm("Add another criteria to nested expression?", {:default => false})
+          nested_members.last['memberValue'] = 'AND'
+          nested_members << prompt_condition.call
+        end
+        criteria << {'type' => type, 'members' => nested_members}
+      end
+    end
+
+    members = []
+    while members.count < 500 && MtnCloud::Cli::OptionTypes.confirm("Add#{members.count == 0 ? '': ' another'} member?", {:default => false})
+      member_type = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'memberType', 'fieldLabel' => 'Member Type', 'type' => 'select', 'selectOptions' => ['Group', 'Segment', 'Segment Port', 'Virtual Network Interface', 'Virtual Machine', 'Physical Server'].map{|it| {'name' => it, 'value' => it.gsub(' ', '')}}, 'required' => true, 'defaultValue' => 'Group'}], options[:options])['memberType']
+      member_value = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'memberValue', 'fieldLabel' => member_type, 'type' => 'select', 'optionSource' => 'nsxtGroupMembers', 'optionSourceType' => 'nsxt', 'required' => true}], options[:options], @api_client, {networkServerId: parent_record['id'], memberType: member_type}, false, true)['memberValue']
+      type = ['Group', 'Segment', 'SegmentPort'].include?(member_type) ? 'Path' : 'ExternalID'
+      members << {'type' => type, 'memberType' => member_type, 'memberValue' => member_value}
+    end
+
+    # ip/mac
+    ips = []
+    while members.count + ips.count < 500 && MtnCloud::Cli::OptionTypes.confirm("Add#{ips.count == 0 ? '': ' another'} IP/MAC address?", {:default => false})
+      member_value = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'ipAddress', 'type' => 'text', 'fieldLabel' => "IP/MAC Address", 'required' => true, 'description' => 'Enter an IP or MAC address. x.x.x.x'}], options[:options])['ipAddress']
+      type = member_value.match(/[a-fA-F0-9]{2}(:[a-fA-F0-9]{2}){5}/) ? 'MACAddress' : 'IPAddress'
+      ips << {'type' => type, 'memberValue' => member_value}
+    end
+
+    # ad groups
+    ad_groups = []
+    while members.count + ips.count + ad_groups.count < 500 && MtnCloud::Cli::OptionTypes.confirm("Add#{ad_groups.count == 0 ? '': ' another'} AD Group?", {:default => false})
+      member_value = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'identityGroup', 'type' => 'select', 'optionSource' => 'nsxtIdentityGroups', 'optionSourceType' => 'nsxt', 'required' => true, 'fieldLabel' => "AD Group"}], options[:options], @api_client, {networkServerId: parent_record['id'], memberType: member_type}, false, true)['identityGroup']
+      ad_groups << {'type' => 'IdentityGroup', 'memberValue' => member_value}
+    end
+
+    record_payload['members'] = criteria + members + ips + ad_groups
+    record_payload
+  end
+
+  def render_response_details_for_get(record, options)
+    if options[:parent_record]['type']['code'] == 'nsx-t'
+      members = record['members'].select{|member| NSXT_CRITERIA_TYPES.include?(member['type'])}
+      if members.count > 0
+        cond_criteria = lambda do |member|
+          expr = JSON.parse(member['memberExpression'])
+          "#{member['memberType']} #{expr['key']} #{expr['operator']} #{expr['value']}#{expr['scope'].nil? ? '' : " w/ #{expr['scope']} scope"}"
+        end
+        criteria_parts = []
+        members.each_with_index do |member, index|
+          if member['type'] == 'NestedExpression'
+            criteria_parts << "("
+            member['members'].each do |child_member|
+              criteria_parts << "  #{cond_criteria.call(child_member)}"
+              criteria_parts << "  #{child_member['memberValue']}"
+            end
+            criteria_parts.pop # remove last conjunction
+            criteria_parts << ")"
+          else
+            criteria_parts << cond_criteria.call(member)
+            criteria_parts << member['memberValue']
+          end
+        end
+        criteria_parts.pop if ['AND', 'OR'].include?(criteria_parts.last) # remove last conjunction
+        print_h2 "Criteria (#{members.count})", options
+        print "#{cyan}#{criteria_parts.join("\n")}\n"
+      end
+
+      members = record['members'].select{|member| NSXT_MEMBER_TYPES.include?(member['type'])}
+      if members.count > 0
+        print_h2 "Members (#{members.count})", options
+        print as_pretty_table(members, {'Type' => 'memberType', 'Path/ExternalID' => 'memberValue'}, options)
+      end
+
+      members = record['members'].select{|member| NSXT_IP_TYPES.include?(member['type'])}
+      if members.count > 0
+        print_h2 "IP/MAC Addresses (#{members.count})", options
+        print "#{cyan}#{members.collect{|member| "#{member['memberValue']}"}.join("\n")}\n"
+      end
+
+      members = record['members'].select{|member| NSXT_AD_GROUP_TYPES.include?(member['type'])}
+      if members.count > 0
+        print_h2 "AD Groups (#{members.count})", options
+        print "#{cyan}#{members.collect{|member| "#{member['memberValue']}"}.join("\n")}\n"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::NetworkServerTypes
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::RestCommand
+  include MtnCloud::Cli::InfrastructureHelper
+
+  set_command_description "View network server types"
+  set_command_name :'network-server-types'
+  register_subcommands :list, :get
+
+  # hidden in favor of get-type and list-types 
+  set_command_hidden
+
+  register_interfaces :network_server_types
+
+  protected
+
+end
+

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

@@ -0,0 +1,398 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::NetworkServersCommand
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::RestCommand
+  include MtnCloud::Cli::InfrastructureHelper
+
+  set_command_description "View and manage network servers"
+  set_command_name :'network-servers'
+
+  register_subcommands :list, :get, :add, :update, :remove, :refresh
+  register_subcommands :list_types, :get_type
+  alias_subcommand :types, :'list-types'
+  alias_subcommand :type, :'get-type'
+  
+  # RestCommand settings
+  register_interfaces :network_servers, :network_server_types, :clouds, :options
+  set_rest_has_type true
+  set_rest_type :network_server_types
+
+  def handle(args)
+    handle_subcommand(args)
+  end
+
+  def add(args)
+    options = {params: {}}
+    params = options[:params]
+    ip_range_list = nil
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[name]")
+      opts.on('--name VALUE', String, "Name for this network server") do |val|
+        params['name'] = val
+      end
+      opts.on('--type VALUE', String, "Network Server Type code") do |val|
+        params['type'] = val
+      end
+      # opts.on('--enabled [on|off]', String, "Can be used to disable the network server") do |val|
+      #   params['enabled'] = val.to_s == 'on' || val.to_s == 'true' || val.to_s.empty?
+      # end
+      # ['name', 'serviceUsername', 'servicePassword', 'servicePort', 'serviceHost', 'serviceUrl', 'serviceMode', 'networkFilter', 'tenantMatch']
+      #build_option_type_options(opts, options, add_network_server_option_types)
+      build_option_type_options(opts, options, add_network_server_advanced_option_types)
+      build_standard_add_options(opts, options)
+      opts.footer = <<-EOT
+Create a new network server.
+[name] is required and can be passed as --name instead.
+Configuration options vary by network server type.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, max: 1)
+    connect(options)
+
+    # support [name] as first argument
+    if args[0]
+      params['name'] = args[0]
+    end
+
+    # merge -O options into normally parsed options
+    #params.deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) }) if options[:options]
+
+    # construct payload
+    payload = nil
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({rest_object_key => parse_passed_options(options)})
+      payload.deep_merge!({rest_object_key => params})
+    else
+      payload = {}
+      payload.deep_merge!({rest_object_key => parse_passed_options(options)})
+      # Name
+      if !params['name']
+        params['name'] = prompt_value({'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'description' => 'Name for this network server.'}, options)
+        # params['name'] = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'description' => 'Name for this network server.'}], params, @api_client, {}, options[:no_prompt])['name']
+      end
+
+      # Network Server Type
+      network_type_id = nil
+      # use this optionSource networkServices which is really network service 
+      # where the response data is categories, each with a list ofservices (service types)
+      network_services_options = @options_interface.options_for_source('networkServices',{})['data']
+      networking_category = network_services_options.find {|it| it['value'] == 'networkServer'}
+      service_types = networking_category ? networking_category['services'] : []
+      network_server_type_options = service_types.collect {|it| {'name' => it['name'], 'value' => it['code'], 'code' => it['code'], 'id' => it['id']} }
+      if network_server_type_options.empty?
+        raise_command_error "No available network server types found"
+      end
+      # v_prompt = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'fieldLabel' => 'Network Server Type', 'type' => 'select', 'optionSource' => 'networkServerTypes', 'required' => true, 'description' => 'Choose a network server type.'}], options, @api_client, {})
+      #network_type_id = v_prompt['type']
+      # allow matching type by id, name or code
+      selected_type = nil
+      if params['type'] && params['type'].to_s =~ /\A\d{1,}\Z/
+        network_type_id = params['type'].to_i
+        selected_type = network_server_type_options.find {|it| it['id'] == network_type_id }
+        if selected_type.nil?
+          raise_command_error "Network Server Type not found by id '#{params['type']}'"
+        end
+        network_type_code = selected_type['code']
+      else
+        network_type_code = prompt_value({'fieldName' => 'type', 'fieldLabel' => 'Network Server Type', 'type' => 'select', 'selectOptions' => network_server_type_options, 'required' => true, 'description' => 'Choose a network server type.'}, options.merge(params))
+        #network_type_code = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'fieldLabel' => 'Network Server Type', 'type' => 'select', 'selectOptions' => network_server_type_options, 'required' => true, 'description' => 'Choose a network server type.'}], options, @api_client, {}, options[:no_prompt])['type']
+        selected_type = network_server_type_options.find {|it| it['code'] == network_type_code }
+        if selected_type.nil?
+          raise_command_error "Network Server Type not found by name or code '#{params['type']}'"
+        end
+        network_type_id = selected_type['id']
+      end
+      params['type'] = network_type_code
+      
+      # prompt options by type
+      network_server_type = @network_server_types_interface.get(network_type_id.to_i)['networkServerType']
+      # params['type'] = network_server_type['code']
+      type_options_types = network_server_type['optionTypes'] || []
+      type_options_types.reject! {|it| it['fieldName'] == 'visibility' } # skip visibility, its under advanced now
+      option_result = prompt(network_server_type['optionTypes'], options.merge({:context_map => {'networkServer' => ''}}))
+      params.deep_merge!(option_result)
+
+      # advanced options
+      advanced_option_types = add_network_server_advanced_option_types
+      if advanced_option_types && !advanced_option_types.empty?
+        v_prompt = MtnCloud::Cli::OptionTypes.prompt(advanced_option_types, options[:options], @api_client, {})
+        v_prompt.deep_compact!
+        v_prompt.booleanize! # 'on' => true
+        params.deep_merge!(v_prompt)
+      end
+      payload.deep_merge!({rest_object_key => params})
+    end
+    @network_servers_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @network_servers_interface.dry.create(payload)
+      return
+    end
+    json_response = @network_servers_interface.create(payload)
+    render_response(json_response, options, 'networkServer') do
+      network_server = json_response['networkServer']
+      print_green_success "Added network server #{network_server['name']}"
+      _get(network_server['id'], {}, options)
+    end
+  end
+
+  def update(args)
+    options = {}
+    params = {}
+    ip_range_list = nil
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[network server] [options]")
+      opts.on('--name VALUE', String, "Name for this network server") do |val|
+        params['name'] = val
+      end
+      # opts.on('--enabled [on|off]', String, "Can be used to enable or disable the network server") do |val|
+      #   params['enabled'] = val.to_s == 'on' || val.to_s == 'true' || val.to_s.empty?
+      # end
+      # ['name', 'serviceUsername', 'servicePassword', 'servicePort', 'serviceHost', 'serviceUrl', 'serviceMode', 'networkFilter', 'tenantMatch']
+      #build_option_type_options(opts, options, update_network_server_option_types)
+      build_option_type_options(opts, options, update_network_server_advanced_option_types)
+      build_standard_update_options(opts, options)
+      opts.footer = <<-EOT
+Update a network server.
+[network server] is required. This is the name or id of a network server.
+Configuration options vary by network server type.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count: 1)
+    connect(options)
+    # find network server to be updated
+    network_server = find_network_server_by_name_or_id(args[0])
+    return 1 if network_server.nil?
+    
+    # merge -O options into normally parsed options
+    params.deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) }) if options[:options]
+
+    # params['tenants'] = options['tenants'].collect {|it| {'id': it}}
+    # advanced options
+    advanced_option_types = update_network_server_advanced_option_types
+    if advanced_option_types && !advanced_option_types.empty?
+      v_prompt = MtnCloud::Cli::OptionTypes.no_prompt(advanced_option_types, options[:options], @api_client, {})
+      v_prompt.deep_compact!
+      v_prompt.booleanize! # 'on' => true
+      params.deep_merge!(v_prompt)
+    end
+
+    # construct payload
+    payload = nil
+    if options[:payload]
+      payload = options[:payload]
+    else
+      payload = {
+        'networkServer' => params
+      }
+    end
+    @network_servers_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @network_servers_interface.dry.update(network_server["id"], payload)
+      return
+    end
+    json_response = @network_servers_interface.update(network_server["id"], payload)
+    render_response(json_response, options, 'networkServer') do
+      network_server = json_response['networkServer']
+      print_green_success "Updated network server #{network_server['name']}"
+      _get(network_server['id'], {}, options)
+    end
+  end
+
+  def refresh(args)
+    options = {}
+    params = {}
+    ip_range_list = nil
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[network server]")
+      # ['name', 'serviceUsername', 'servicePassword', 'servicePort', 'serviceHost', 'serviceUrl', 'serviceMode', 'networkFilter', 'tenantMatch']
+            build_standard_update_options(opts, options, [:query])
+      opts.footer = <<-EOT
+Refresh a network server.
+[network server] is required. This is the name or id of a network server.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count: 1)
+    connect(options)
+    # find network server to be updated
+    network_server = find_network_server_by_name_or_id(args[0])
+    return 1 if network_server.nil?
+    # construct query parameters
+    params.merge!(parse_query_options(options))
+    # construct payload
+    payload = nil
+    if options[:payload]
+      payload = options[:payload]
+    else
+      payload = options[:options].reject {|k,v| k.is_a?(Symbol) }
+    end
+    @network_servers_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @network_servers_interface.dry.refresh(network_server["id"], params, payload)
+      return
+    end
+    json_response = @network_servers_interface.refresh(network_server["id"], params, payload)
+    render_response(json_response, options, 'networkServer') do
+      #network_server = json_response['networkServer']
+      print_green_success "Refreshing network server #{network_server['name']}"
+      #_get(network_server['id'], {}, options)
+    end
+  end
+
+  private
+
+  def network_server_list_key
+    'networkServers'
+  end
+
+  def network_server_object_key
+    'networkServer'
+  end
+
+  def render_response_for_get(json_response, options)
+    record = json_response[rest_object_key]
+    options[:exclude_tenants] = record['tenants'].nil?
+    super(json_response, options)
+  end
+
+  def find_network_server_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_network_server_by_id(val)
+    else
+      return find_network_server_by_name(val)
+    end
+  end
+
+  def find_network_server_by_id(id)
+    begin
+      json_response = @network_servers_interface.get(id.to_i)
+      return json_response['networkServer']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Network Server not found by id #{id}"
+        return nil
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_network_server_by_name(name)
+    json_response = @network_servers_interface.list({name: name.to_s})
+    network_servers = json_response['networkServers']
+    if network_servers.empty?
+      print_red_alert "Network Server not found by name #{name}"
+      return nil
+    elsif network_servers.size > 1
+      print_red_alert "#{network_servers.size} network servers found by name #{name}"
+      # print_networks_table(networks, {color: red})
+      rows = network_servers.collect do |it|
+        {id: it['id'], name: it['name']}
+      end
+      puts as_pretty_table(rows, [:id, :name], {color:red})
+      return nil
+    else
+      return network_servers[0]
+    end
+  end
+
+  def add_network_server_option_types()
+    [
+      {'shorthand' => '-t', 'fieldName' => 'type', 'fieldLabel' => 'Network Server Type', 'type' => 'select', 'optionSource' => lambda {|api_client, api_params| 
+        api_client.network_server_types.list({max:10000})['networkServerTypes'].collect { |it| {"name" => it["name"], "value" => it["code"]} }
+      }, 'required' => true},
+      {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true},
+      {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text', 'required' => false},
+      {'fieldName' => 'enabled', 'fieldLabel' => 'Enabled', 'type' => 'checkbox', 'required' => false, 'defaultValue' => true},
+    ]
+  end
+
+  def add_network_server_advanced_option_types()
+    [
+      {'fieldName' => 'visibility', 'fieldLabel' => 'Visibility', 'type' => 'select', 'selectOptions' => [{'name' => 'Private', 'value' => 'private'},{'name' => 'Public', 'value' => 'public'}], 'required' => false, 'description' => 'Visibility', 'category' => 'permissions', 'defaultValue' => 'private'},
+      {'fieldName' => 'tenants', 'fieldLabel' => 'Tenants', 'fieldGroup' => 'Advanced', 'type' => 'multiSelect', 'resultValueField' => 'id', 'optionSource' => lambda { |api_client, api_params|
+        api_client.options.options_for_source("allTenants", {})['data']
+      }},
+    ]
+  end
+
+  def update_network_server_option_types()
+    list = add_network_server_option_types.collect {|it|
+      it.delete('required')
+      it.delete('defaultValue')
+      it
+    }
+    list = list.reject {|it| ["type"].include? it['fieldName'] }
+    list
+  end
+
+  def update_network_server_advanced_option_types()
+    list = add_network_server_advanced_option_types.collect {|it|
+      it.delete('required')
+      it.delete('defaultValue')
+      it
+    }
+    list
+  end
+
+  def network_server_list_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => lambda {|it| it['name'] },
+      "Type" => lambda {|it| it['type'] ? it['type']['name'] : '' },
+      "URL" => lambda {|it| it['serviceUrl'] },
+      # "Enabled" => lambda {|it| format_boolean(it['enabled']) },
+      "Status" => lambda {|it| format_network_server_status(it) },
+      "Date Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+      "Last Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
+    }
+  end
+
+  def network_server_column_definitions(options)
+    columns = {
+      "ID" => 'id',
+      "Name" => lambda {|it| it['name'] },
+      "Type" => lambda {|it| it['type'] ? it['type']['name'] : '' },
+      "URL" => lambda {|it| it['serviceUrl'] },
+      "Credentials" => lambda {|it| it['credential'] ? (it['credential']['type'] == 'local' ? '(Local)' : it['credential']['name']) : nil },
+      "Username" => lambda {|it| it['serviceUsername'] },
+      "Password" => lambda {|it| it['servicePassword'] },
+      "Service Mode" => lambda {|it| it['serviceMode'] },
+      "Service Path" => lambda {|it| it['servicePath'] },
+      "Network Filter" => lambda {|it| it['networkFilter'] },
+      "Tenant Match" => lambda {|it| it['tenantMatch'] },
+      #"Enabled" => lambda {|it| format_boolean(it['enabled']) },
+      "Visibility" => lambda {|it| it['visibility'] ? it['visibility'].capitalize() : '' },
+      "Tenants" => lambda { |it| it['tenants'].collect {|tenant| tenant['name']}.join(', ') rescue '' },
+      "Status" => lambda {|it| format_network_server_status(it) },
+      "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+      "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) }
+    }
+    if options[:exclude_tenants]
+      columns.delete("Tenants")
+    end
+    columns
+  end
+
+  def format_network_server_status(network_server, return_color=cyan)
+    out = ""
+    status_string = network_server['status']
+    if status_string.nil? || status_string.empty? || status_string == "unknown"
+      out << "#{white}UNKNOWN#{network_server['statusMessage'] ? "#{return_color} - #{network_server['statusMessage']}" : ''}#{return_color}"
+    # elsif network_server['enabled'] == false
+    #   out << "#{red}DISABLED#{network_server['statusMessage'] ? "#{return_color} - #{network_server['statusMessage']}" : ''}#{return_color}"
+    elsif status_string == 'ok'
+      out << "#{green}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'error' || status_string == 'offline'
+      out << "#{red}#{status_string ? status_string.upcase : 'N/A'}#{network_server['statusMessage'] ? "#{return_color} - #{network_server['statusMessage']}" : ''}#{return_color}"
+    else
+      out << "#{yellow}#{status_string.upcase}#{return_color}"
+    end
+    out
+  end
+
+end