morpheus-cli 5.4.0 → 5.4.1

data/lib/morpheus/cli/commands/load_balancer_virtual_servers.rb

@@ -3,31 +3,82 @@ require 'morpheus/cli/cli_command'
 class Morpheus::Cli::LoadBalancerVirtualServers
   include Morpheus::Cli::CliCommand
   include Morpheus::Cli::RestCommand
-  # include Morpheus::Cli::SecondaryRestCommand
+  include Morpheus::Cli::SecondaryRestCommand
   include Morpheus::Cli::LoadBalancersHelper
 
-  set_command_hidden # hide until ready
+  set_command_hidden
+  set_command_description "View and manage load balancer virtual servers."
   set_command_name :'load-balancer-virtual-servers'
   register_subcommands :list, :get, :add, :update, :remove
 
   register_interfaces :load_balancer_virtual_servers,
                       :load_balancers, :load_balancer_types
 
-  # set_rest_parent_name :load_balancers
-
-  # set_rest_interface_name :load_balancer_virtual_servers
-  # set_parent_rest_interface_name :load_balancers
-  
-  # todo: a configurable way to load the optionTypes
-  # option_types = loadBalancer['vipOptionTypes']
-  # set_rest_has_type true
-  # set_rest_type :load_balancer_virtual_server_types
-
+  set_rest_parent_name :load_balancers
   set_rest_arg 'vipName'
 
+  # overridden to provide global list functionality without requiring parent argument
+  def list(args)
+    parent_id, parent_record = nil, nil
+    params = {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[#{rest_parent_arg}] [search]")
+      build_list_options(opts, options, params)
+      opts.footer = <<-EOT
+List #{rest_label_plural.downcase}.
+[#{rest_parent_arg}] is optional. This is the #{rest_parent_has_name ? 'name or id' : 'id'} of #{a_or_an(rest_parent_label)} #{rest_parent_label.downcase}.
+[search] is optional. This is a search phrase to filter the results.
+EOT
+    end
+    optparse.parse!(args)
+    parent_id = args[0]
+    connect(options)
+    if parent_id
+      args = args[1..-1]
+      parent_record = rest_parent_find_by_name_or_id(parent_id)
+      if parent_record.nil?
+        return 1, "#{rest_parent_label} not found for '#{parent_id}"
+      end
+      parent_id = parent_record['id']
+    end
+    parse_list_options!(args, options, params)
+    rest_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run rest_interface.dry.list(parent_id, params)
+      return
+    end
+    json_response = rest_interface.list(parent_id, params)
+    render_response(json_response, options, rest_list_key) do
+      records = json_response[rest_list_key]
+      print_h1 "Morpheus #{rest_label_plural}"
+      if records.nil? || records.empty?
+        print cyan,"No #{rest_label_plural.downcase} found.",reset,"\n"
+      else
+        print as_pretty_table(records, rest_list_column_definitions(options).upcase_keys!, options)
+        print_results_pagination(json_response) if json_response['meta']
+      end
+      print reset,"\n"
+    end
+    return 0, nil
+  end
+
   protected
 
-  def load_balancer_virtual_server_list_column_definitions()
+  def build_list_options(opts, options, params)
+    opts.on('--load-balancer LB', String, "Load Balancer Name or ID") do |val|
+      options[:load_balancer] = val
+    end
+    # build_standard_list_options(opts, options)
+    super
+  end
+
+  def parse_list_options!(args, options, params)
+    parse_parameter_as_resource_id!(:load_balancer, options, params)
+    super
+  end
+
+  def load_balancer_virtual_server_list_column_definitions(options)
     {
       "ID" => 'id',
       "Name" => 'vipName',
@@ -43,7 +94,7 @@ class Morpheus::Cli::LoadBalancerVirtualServers
     }
   end
 
-  def load_balancer_virtual_server_column_definitions()
+  def load_balancer_virtual_server_column_definitions(options)
     {
       "ID" => 'id',
       "Name" => 'vipName',
@@ -63,11 +114,11 @@ class Morpheus::Cli::LoadBalancerVirtualServers
   end
 
   def load_balancer_virtual_server_object_key
-    'virtualServer'
+    'loadBalancerInstance'
   end
 
   def load_balancer_virtual_server_list_key
-    'virtualServers'
+    'loadBalancerInstances'
   end
 
   def load_balancer_virtual_server_label
@@ -78,52 +129,12 @@ class Morpheus::Cli::LoadBalancerVirtualServers
     'Virtual Servers'
   end
 
-  def find_load_balancer_virtual_server_by_name_or_id(val)
-    if val.to_s =~ /\A\d{1,}\Z/
-      return find_load_balancer_virtual_server_by_id(val)
-    else
-      return find_load_balancer_virtual_server_by_name(val)
-    end
-  end
-
-  def find_load_balancer_virtual_server_by_id(id)
-    begin
-      json_response = load_balancer_virtual_servers_interface.get(id.to_i)
-      return json_response[load_balancer_virtual_server_object_key]
-    rescue RestClient::Exception => e
-      if e.response && e.response.code == 404
-        print_red_alert "#{load_balancer_virtual_server_label} not found by id #{id}"
-        return nil
-      else
-        raise e
-      end
-    end
-  end
-
-  def find_load_balancer_virtual_server_by_name(name)
-    json_response = load_balancer_virtual_servers_interface.list({name: name.to_s})
-    load_balancer_virtual_servers = json_response[load_balancer_virtual_server_list_key]
-    if load_balancer_virtual_servers.empty?
-      print_red_alert "#{load_balancer_virtual_server_label_plural} not found by name #{name}"
-      return load_balancer_virtual_servers
-    elsif load_balancer_virtual_servers.size > 1
-      print_red_alert "#{load_balancer_virtual_servers.size} #{load_balancer_virtual_server_label_plural.downcase} found by name #{name}"
-      rows = load_balancer_virtual_servers.collect do |it|
-        {id: it['id'], name: it['name']}
-      end
-      puts as_pretty_table(rows, [:id, :name], {color:red})
-      return nil
-    else
-      return load_balancer_virtual_servers[0]
-    end
-  end
-
   def format_virtual_server_status(virtual_server, return_color=cyan)
     out = ""
     status_string = virtual_server['vipStatus'] || virtual_server['status']
     if status_string.nil? || status_string.empty? || status_string == "unknown"
       out << "#{white}UNKNOWN#{return_color}"
-    elsif status_string == 'ok'
+    elsif status_string == 'online'
       out << "#{green}#{status_string.upcase}#{return_color}"
     elsif status_string == 'syncing'
       out << "#{yellow}#{status_string.upcase}#{return_color}"
@@ -133,4 +144,13 @@ class Morpheus::Cli::LoadBalancerVirtualServers
     out
   end
 
+  def load_option_types_for_load_balancer_virtual_server(type_record, parent_record)
+    load_balancer = parent_record
+    load_balancer_type_id = load_balancer['type']['id']
+    load_balancer_type = find_by_id(:load_balancer_type, load_balancer_type_id)
+    load_balancer_type['vipOptionTypes']
+  end
+
+  ## using CliCommand's generic find_by methods
+
 end

data/lib/morpheus/cli/commands/load_balancers.rb

@@ -5,8 +5,10 @@ class Morpheus::Cli::LoadBalancers
   include Morpheus::Cli::RestCommand
   include Morpheus::Cli::LoadBalancersHelper
 
+  set_command_hidden
+  set_command_description "View and manage load balancers."
   set_command_name :'load-balancers'
-  register_subcommands :list, :get, :add, :update, :remove
+  register_subcommands :list, :get, :add, :update, :remove, :refresh
 
   # deprecated the `load-balancers types` command in 5.3.2, it moved to `load-balancer-types list`
   register_subcommands :types
@@ -22,7 +24,7 @@ class Morpheus::Cli::LoadBalancers
       record = json_response[rest_object_key]
       print_h1 rest_label, [], options
       print cyan
-      print_description_list(rest_column_definitions, record, options)
+      print_description_list(rest_column_definitions(options), record, options)
       # show LB Ports
       ports = record['ports']
       if ports && ports.size > 0
@@ -41,6 +43,48 @@ class Morpheus::Cli::LoadBalancers
     end
   end
 
+  def refresh(args)
+    id = args[0]
+    record_type = nil
+    record_type_id = nil
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[#{rest_arg}] [options]")
+      build_standard_update_options(opts, options)
+      opts.footer = <<-EOT
+Refresh an existing #{rest_label.downcase}.
+[#{rest_arg}] is required. This is the #{rest_has_name ? 'name or id' : 'id'} of #{a_or_an(rest_label)} #{rest_label.downcase}.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    record = rest_find_by_name_or_id(id)
+    if record.nil?
+      return 1, "#{rest_name} not found for '#{id}'"
+    end
+    passed_options = parse_passed_options(options)
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({rest_object_key => passed_options}) unless passed_options.empty?
+    else
+      record_payload = passed_options
+      payload[rest_object_key] = record_payload
+    end
+    rest_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run rest_interface.dry.refresh(record['id'], payload)
+      return
+    end
+    json_response = rest_interface.refresh(record['id'], payload)
+    render_response(json_response, options, rest_object_key) do
+      print_green_success "Refreshing #{rest_label.downcase} #{record['name'] || record['id']}"
+      _get(record["id"], {}, options)
+    end
+    return 0, nil
+  end
+
   # deprecated, to be removed in the future.
   def types(args)
     print_error yellow,"[DEPRECATED] The command `load-balancers types` is deprecated and replaced by `load-balancer-types list`.",reset,"\n"
@@ -49,7 +93,7 @@ class Morpheus::Cli::LoadBalancers
 
   protected
 
-  def load_balancer_list_column_definitions()
+  def load_balancer_list_column_definitions(options)
     {
       "ID" => 'id',
       "Name" => 'name',
@@ -59,7 +103,7 @@ class Morpheus::Cli::LoadBalancers
     }
   end
 
-  def load_balancer_column_definitions()
+  def load_balancer_column_definitions(options)
     {
       "ID" => 'id',
       "Name" => 'name',
@@ -80,10 +124,53 @@ class Morpheus::Cli::LoadBalancers
   end
 
   # overridden to work with name or code
-  def find_load_balancer_type_by_name_or_id(name)
-    load_balancer_type_for_name_or_id(name)
+  # nope, api works with name=code now too
+  # def find_load_balancer_type_by_name_or_id(name)
+  #   load_balancer_type_for_name_or_id(name)
+  # end
+
+#   def add_load_balancer_option_types()
+#     [
+#       {'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},
+# #      {'fieldName' => 'type', 'fieldLabel' => 'Storage Server Type', 'type' => 'select', 'optionSource' => 'loadBalancerTypes', 'required' => true},
+#     ]
+#   end
+
+  def add_load_balancer_advanced_option_types()
+    [
+      {'fieldName' => 'visibility', 'fieldLabel' => 'Visibility', 'fieldGroup' => 'Advanced', 'type' => 'select', 'selectOptions' => [{'name' => 'Private', 'value' => 'private'},{'name' => 'Public', 'value' => 'public'}], 'required' => false, 'description' => 'Visibility', 'category' => 'permissions', 'defaultValue' => 'public'},
+      {'fieldName' => 'tenants', 'fieldLabel' => 'Tenants', 'fieldGroup' => 'Advanced', 'type' => 'multiSelect', 'optionSource' => lambda { |api_client, api_params|
+        api_client.options.options_for_source("allTenants", {})['data']
+      }},
+    ]
   end
 
+  # def update_load_balancer_option_types()
+  #   [
+  #     {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text'},
+  #     {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text'},
+  #     {'fieldName' => 'enabled', 'fieldLabel' => 'Enabled', 'type' => 'checkbox'},
+  #   ]
+  # end
+
+  def update_load_balancer_advanced_option_types()
+    add_load_balancer_advanced_option_types()
+  end
 
+  def load_option_types_for_load_balancer(type_record, parent_record)
+    load_balancer_type = type_record
+    # reload it by id to get optionTypes
+    option_types = load_balancer_type['optionTypes']
+    if option_types.nil?
+      load_balancer_type = find_by_id(:load_balancer_type, load_balancer_type['id'])
+      if load_balancer_type.nil?
+        raise_command_error("Load balancer type not found for id '#{id}'")
+      end
+      option_types = load_balancer_type['optionTypes']
+    end
+    return option_types
+  end
 
 end

data/lib/morpheus/cli/commands/network_firewalls_command.rb

@@ -4,7 +4,7 @@ class Morpheus::Cli::NetworkFirewallsCommand
   include Morpheus::Cli::CliCommand
   include Morpheus::Cli::ProvisioningHelper
   include Morpheus::Cli::WhoamiHelper
-  set_command_hidden #hide until api ready
+
   set_command_name :'network-firewalls'
   register_subcommands :list_rules, :get_rule, :add_rule, :update_rule, :remove_rule
   register_subcommands :list_rule_groups, :get_rule_group, :add_rule_group, :update_rule_group, :remove_rule_group
@@ -65,7 +65,7 @@ class Morpheus::Cli::NetworkFirewallsCommand
           id: it['id'], group: it['groupName'], name: it['name'], description: it['description'],
           priority: it['priority'], enabled: format_boolean(it['enabled']), policy: it['policy'], direction: it['direction'],
           source: it['sources'].kind_of?(Array) && it['sources'].count > 0 ? it['sources'].collect {|it| it['name']}.join(', ') : (it['sources'].nil? || it['sources'].empty? ? 'any' : it['source']),
-          destination: it['destinations'].count > 0 ? it['destinations'].collect {|it| it['name']}.join(', ') : (it['destinations'].nil? || it['destinations'].empty? ? 'any' : it['destination'])
+          destination: it['destinations'].kind_of?(Array) && it['destinations'].count > 0 ? it['destinations'].collect {|it| it['name']}.join(', ') : (it['destinations'].nil? || it['destinations'].empty? ? 'any' : it['destination'])
         }
 
         if it['applications'].count
@@ -78,9 +78,9 @@ class Morpheus::Cli::NetworkFirewallsCommand
 
         applied_to = []
         if server['type']['supportsFirewallRuleAppliedTarget']
-          applied_to << 'All Edges' if row['config']['applyToAllEdges']
-          applied_to << 'Distributed Firewall' if row['config']['applyToAllDistributed']
-          applied_to += rule['appliedTargets'].collect {|it| it['name']}
+          applied_to << 'All Edges' if it['config']['applyToAllEdges']
+          applied_to << 'Distributed Firewall' if it['config']['applyToAllDistributed']
+          applied_to += it['appliedTargets'].collect {|target| target['name']}
           row[:applied_to] = applied_to.join(', ')
         end
         row
@@ -483,6 +483,11 @@ class Morpheus::Cli::NetworkFirewallsCommand
         server['type']['firewallGroupOptionTypes'].reject {|it| it['type'] == 'hidden'}.sort_by {|it| it['displayOrder']}.each do |option_type|
           description_cols[option_type['fieldLabel']] = lambda {|it| Morpheus::Cli::OptionTypes.get_option_value(it, option_type, true)}
         end
+
+        if is_master_account
+          description_cols["Visibility"] = lambda {|it| it['visibility']}
+          description_cols["Tenants"] = lambda {|it| it['tenants'].collect {|tenant| tenant['name']}.join(', ')}
+        end
         print_description_list(description_cols, group)
       end
     else
@@ -505,6 +510,7 @@ class Morpheus::Cli::NetworkFirewallsCommand
       opts.on('--priority VALUE', Integer, "Priority for this firewall rule group") do |val|
         options[:options]['priority'] = val
       end
+      add_perms_options(opts, options, ['plans', 'groups'])
       build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote])
       opts.footer = "Create a network firewall rule group." + "\n" +
         "[server] is optional. This is the name or id of a network server.\n";
@@ -537,6 +543,11 @@ class Morpheus::Cli::NetworkFirewallsCommand
 
       # prompt options
       option_result = Morpheus::Cli::OptionTypes.prompt(option_types, options[:options].deep_merge({:context_map => {'ruleGroup' => ''}}), @api_client, {'networkServerId' => server['id']}, nil, true)
+
+      # prompt perms
+      if is_master_account
+        params.merge!(prompt_permissions_v2(options, ['plans', 'groups']))
+      end
       payload = {'ruleGroup' => params.deep_merge(option_result)}
     end
 
@@ -568,6 +579,7 @@ class Morpheus::Cli::NetworkFirewallsCommand
       opts.on('--priority VALUE', Integer, "Priority for this firewall rule group") do |val|
         options[:options]['priority'] = val
       end
+      add_perms_options(opts, options, ['plans', 'groups'])
       build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote])
       opts.footer = "Update a network firewall rule group.\n" +
         "[server] is optional. This is the name or id of an existing network server.\n" +
@@ -592,6 +604,11 @@ class Morpheus::Cli::NetworkFirewallsCommand
     group = find_rule_group(server['id'], group_id)
     return 1 if group.nil?
 
+    if is_master_account
+      params['visibility'] = options[:visibility] if !options[:visibility].nil?
+      params['tenants'] = options[:tenants].collect {|it| {'id' => it}} if !options[:tenants].nil?
+    end
+
     payload = parse_payload(options) || {'ruleGroup' => params}
     payload['ruleGroup'].deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) }) if options[:options] && !payload['ruleGroup'].nil?
 

data/lib/morpheus/cli/commands/network_routers_command.rb

@@ -634,59 +634,51 @@ class Morpheus::Cli::NetworkRoutersCommand
   end
 
   def _firewall_rule_group(router_id, group_id, options)
-    begin
-      @network_routers_interface.setopts(options)
-      if options[:dry_run]
-        if args[0].to_s =~ /\A\d{1,}\Z/
-          print_dry_run @network_routers_interface.dry.get(router_id.to_i)
+    @network_routers_interface.setopts(options)
+    if options[:dry_run]
+      if router_id.to_s =~ /\A\d{1,}\Z/
+        print_dry_run @network_routers_interface.dry.list({name:router_id})
+      else
+        if group_id.to_s =~ /\A\d{1,}\Z/
+          print_dry_run @network_routers_interface.dry.get_firewall_rule_group(router_id.to_i, group_id)
         else
-          print_dry_run @network_routers_interface.dry.list({name:router_id})
+          print_dry_run @network_routers_interface.dry.list_firewall_rule_groups(router_id.to_i, {phrase:router_id})
         end
-        return
       end
-      router = find_router(router_id)
-      if router.nil?
-        return 1
-      end
-
-      if router['type']['hasFirewallGroups']
-        group = (router['firewall']['ruleGroups'] || []).find {|it| it['id'].to_s == group_id.to_s || it['name'] == group_id.to_s}
+      return
+    end
+    router = find_router(router_id)
+    if router.nil?
+      return 1
+    end
 
-        if group
-          json_response = {'ruleGroup' => group}
+    if router['type']['hasFirewallGroups']
+      group = find_firewall_rule_group(router['id'], group_id)
+      return 1 if group.nil?
 
-          if options[:json]
-            puts as_json(json_response, options, "ruleGroup")
-            return 0
-          elsif options[:yaml]
-            puts as_yaml(json_response, options, "ruleGroup")
-            return 0
-          elsif options[:csv]
-            puts records_as_csv([json_response['ruleGroup']], options)
-            return 0
-          end
+      render_response({ruleGroup: group}, options, 'ruleGroup') do
+        print_h1 "Firewall Rule Group Details"
+        print cyan
+        description_cols = {
+          "ID" => lambda {|it| it['id'] },
+          "Name" => lambda {|it| it['name'] },
+          "Description" => lambda {|it| it['description']},
+          "Priority" => lambda {|it| it['priority']},
+          "Category" => lambda {|it| it['groupLayer']}
+        }
+        print_description_list(description_cols, group)
 
-          print_h1 "Firewall Rule Group Details"
-          print cyan
-          description_cols = {
-            "ID" => lambda {|it| it['id'] },
-            "Name" => lambda {|it| it['name'] },
-            "Description" => lambda {|it| it['description']},
-            "Priority" => lambda {|it| it['priority']},
-            "Category" => lambda {|it| it['groupLayer']}
-          }
-          print_description_list(description_cols, group)
-        else
-          print_red_alert "Firewall rule group #{group_id} not found for router #{router['name']}"
+        if is_master_account
+          description_cols["Visibility"] = lambda {|it| it['visibility']}
+          description_cols["Tenants"] = lambda {|it| it['tenants'].collect {|tenant| tenant['name']}.join(', ')}
         end
-      else
-        print_h1 "No Firewall Rule Groups"
+        print_description_list(description_cols, group)
       end
-      println reset
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
+    else
+      print_red_alert "Firewall rule groups not supported for #{router['type']['name']}"
       return 1
     end
+    println reset
   end
 
   def add_firewall_rule_group(args)
@@ -703,6 +695,7 @@ class Morpheus::Cli::NetworkRoutersCommand
       opts.on('--priority VALUE', Integer, "Priority for this firewall rule group (not applicable to all firewall types)") do |val|
         params['priority'] = val
       end
+      add_perms_options(opts, options, ['plans', 'groups'])
       build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote])
       opts.footer = "Create a network router firewall rule group."
     end
@@ -742,7 +735,14 @@ class Morpheus::Cli::NetworkRoutersCommand
 
         # prompt options
         option_result = Morpheus::Cli::OptionTypes.prompt(option_types, options[:options].deep_merge({:context_map => {'group' => ''}}), @api_client, {}, nil, true)
-        payload = {'ruleGroup' => params.deep_merge(option_result)}
+
+        rule_group = params.deep_merge(option_result)
+
+        # prompt perms
+        if is_master_account
+          rule_group.merge!(prompt_permissions_v2(options, ['plans', 'groups']))
+        end
+        payload = {'ruleGroup' => rule_group}
       end
 
       @network_routers_interface.setopts(options)
@@ -779,6 +779,7 @@ class Morpheus::Cli::NetworkRoutersCommand
       opts.on('--priority VALUE', Integer, "Priority for this firewall rule group (not applicable to all firewall types)") do |val|
         params['priority'] = val
       end
+      add_perms_options(opts, options, ['plans', 'groups'])
       build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote])
       opts.footer = "Update a network router firewall rule group.\n" +
         "[router] is required. This is the name or id of an existing network router.\n" +
@@ -810,6 +811,11 @@ class Morpheus::Cli::NetworkRoutersCommand
         exit 1
       end
 
+      if is_master_account
+        params['visibility'] = options[:visibility] if !options[:visibility].nil?
+        params['tenants'] = options[:tenants].collect {|it| {'id' => it}} if !options[:tenants].nil?
+      end
+
       payload = parse_payload(options) || {'ruleGroup' => params}
       payload['ruleGroup'].deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) }) if options[:options]
 
@@ -2564,8 +2570,53 @@ class Morpheus::Cli::NetworkRoutersCommand
         end
       end
     else
-      rule = router['firewall'] && router['firewall']['rules'] ? router['firewall']['rules'].find {|it| it['name'] == args[1] || it['id'] == args[1].to_i} : nil
+      rule = router['firewall'] && router['firewall']['rules'] ? router['firewall']['rules'].find {|it| it['name'] == rule_id || it['id'] == rule_id.to_i} : nil
     end
     rule
   end
+
+  def find_firewall_rule_group(router_id, val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_firewall_rule_group_by_id(router_id, val)
+    else
+      if group = find_firewall_rule_group_by_name(router_id, val)
+        return find_firewall_rule_group_by_id(router_id, group['id'])
+      end
+    end
+  end
+
+  def find_firewall_rule_group_by_id(router_id, group_id)
+    begin
+      json_response = @network_routers_interface.get_firewall_rule_group(router_id, group_id.to_i)
+      return json_response['ruleGroup']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Network firewall rule group not found by id #{group_id}"
+        return nil
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_firewall_rule_group_by_name(router_id, name)
+    groups = search_firewall_rule_groups(router_id, name)
+    if groups.empty?
+      print_red_alert "Network firewall rule group not found by name #{name}"
+      return nil
+    elsif groups.size > 1
+      print_red_alert "#{scopes.size} network firewall rule groups found by name #{name}"
+      rows = groups.collect do |it|
+        {id: it['id'], name: it['name']}
+      end
+      puts as_pretty_table(rows, [:id, :name], {color:red})
+      return nil
+    else
+      return groups[0]
+    end
+  end
+
+  def search_firewall_rule_groups(router_id, phrase = nil)
+    @network_routers_interface.list_firewall_rule_groups(router_id, phrase ? {phrase: phrase.to_s} : {})['ruleGroups']
+  end
 end