cisco_node_utils 1.0.1 → 1.1.0

data/lib/cisco_node_utils/bgp_neighbor.rb

@@ -0,0 +1,425 @@
+# BGP neighbor provider class
+#
+# August 2015, Jie Yang
+#
+# Copyright (c) 2015 Cisco and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'ipaddr'
+require_relative 'cisco_cmn_utils'
+require_relative 'node_util'
+require_relative 'bgp'
+
+module Cisco
+  # RouterBgpNeighbor - node utility class for BGP neighbor configs
+  class RouterBgpNeighbor < NodeUtil
+    attr_reader :nbr, :vrf, :asn
+
+    def initialize(asn, vrf, nbr, instantiate=true)
+      fail TypeError unless nbr.is_a?(String)
+      # for IP/prefix format, such as "1.1.1.1/24" or "2000:123:38::34/64",
+      # we need to mask the address using prefix length, so that it becomes
+      # something like "1.1.1.0/24" or "2000:123:38::/64"
+      @nbr = Utils.process_network_mask(nbr)
+      @asn = asn
+      @vrf = vrf
+      @get_args = @set_args = { asnum: @asn, nbr: @nbr }
+      @get_args[:vrf] = @set_args[:vrf] = vrf if vrf != 'default'
+
+      create if instantiate
+    end
+
+    def self.neighbors
+      hash = {}
+      RouterBgp.routers.each do |asn, vrf|
+        hash[asn] = {}
+        vrf.each_key do |vrf_id|
+          get_args = { asnum: asn }
+          get_args[:vrf] = vrf_id unless vrf_id == 'default'
+          neighbor_list = config_get('bgp_neighbor', 'all_neighbors', get_args)
+          next if neighbor_list.nil?
+
+          hash[asn][vrf_id] = {}
+          neighbor_list.each do |nbr|
+            hash[asn][vrf_id][nbr] = RouterBgpNeighbor.new(asn, vrf_id,
+                                                           nbr, false)
+          end
+        end
+      end
+      hash
+    rescue Cisco::CliError => e
+      # Raise the error unless the error message contains "Syntax error", which
+      # means the error was caused by feature is not enabled.
+      raise unless e.clierror =~ /Syntax error/
+      return {}
+    end
+
+    def create
+      set_args_keys(state: '')
+      config_set('bgp', 'create_destroy_neighbor', @set_args)
+    end
+
+    def destroy
+      set_args_keys(state: 'no')
+      config_set('bgp', 'create_destroy_neighbor', @set_args)
+    end
+
+    def set_args_keys_default
+      keys = { asnum: @asn, nbr: @nbr }
+      keys[:vrf] = @vrf unless @vrf == 'default'
+      @set_args = keys
+    end
+
+    def set_args_keys(hash={}) # rubocop:disable Style/AccessorMethodName
+      set_args_keys_default
+      @set_args = @set_args.merge!(hash) unless hash.empty?
+    end
+
+    def description=(desc)
+      fail TypeError unless desc.is_a?(String)
+      desc.strip!
+      set_args_keys(state: desc.empty? ? 'no' : '',
+                    desc:  desc)
+      config_set('bgp_neighbor', 'description', @set_args)
+    end
+
+    def description
+      desc = config_get('bgp_neighbor', 'description', @get_args)
+      return '' if desc.nil?
+      desc.shift.strip
+    end
+
+    def default_description
+      config_get_default('bgp_neighbor', 'description')
+    end
+
+    def connected_check=(val)
+      # the cli is "disable-connected-check", therefore when val is true, we
+      # need to set set state to "no"
+      set_args_keys(state: (val) ? 'no' : '')
+      config_set('bgp_neighbor', 'connected_check', @set_args)
+    end
+
+    def connected_check
+      result = config_get('bgp_neighbor', 'connected_check', @get_args)
+      result ? false : true
+    end
+
+    def default_connected_check
+      config_get_default('bgp_neighbor', 'connected_check')
+    end
+
+    def capability_negotiation=(val)
+      # the cli is "dont-capability-negotiate". Therefore when val is true, we
+      # need to set state to "no"
+      set_args_keys(state: (val) ? 'no' : '')
+      config_set('bgp_neighbor', 'capability_negotiation', @set_args)
+    end
+
+    def capability_negotiation
+      result = config_get('bgp_neighbor', 'capability_negotiation', @get_args)
+      result ? false : true
+    end
+
+    def default_capability_negotiation
+      config_get_default('bgp_neighbor', 'capability_negotiation')
+    end
+
+    def dynamic_capability=(val)
+      set_args_keys(state: (val) ? '' : 'no')
+      config_set('bgp_neighbor', 'dynamic_capability', @set_args)
+    end
+
+    def dynamic_capability
+      result = config_get('bgp_neighbor', 'dynamic_capability', @get_args)
+      result ? true : false
+    end
+
+    def default_dynamic_capability
+      config_get_default('bgp_neighbor', 'dynamic_capability')
+    end
+
+    def ebgp_multihop=(ttl)
+      set_args_keys(state: (ttl == default_ebgp_multihop) ? 'no' : '',
+                    ttl:   (ttl == default_ebgp_multihop) ? '' : ttl)
+      config_set('bgp_neighbor', 'ebgp_multihop', @set_args)
+    end
+
+    def ebgp_multihop
+      result = config_get('bgp_neighbor', 'ebgp_multihop', @get_args)
+      result.nil? ? default_ebgp_multihop : result.first.to_i
+    end
+
+    def default_ebgp_multihop
+      config_get_default('bgp_neighbor', 'ebgp_multihop')
+    end
+
+    def local_as=(val)
+      asnum = RouterBgp.process_asnum(val)
+      if asnum == default_local_as
+        set_args_keys(state: 'no', local_as: '')
+      else
+        set_args_keys(state: '', local_as: val)
+      end
+      config_set('bgp_neighbor', 'local_as', @set_args)
+    end
+
+    def local_as
+      result = config_get('bgp_neighbor', 'local_as', @get_args)
+      return default_local_as if result.nil?
+      return result.first.to_i unless /\d+\.\d+$/.match(result.first)
+      result.first
+    end
+
+    def default_local_as
+      config_get_default('bgp_neighbor', 'local_as')
+    end
+
+    def log_neighbor_changes=(val)
+      val = val.to_sym
+      if val == default_log_neighbor_changes
+        set_args_keys(state: 'no', disable: '')
+      else
+        set_args_keys(state:   '',
+                      disable: (val == :enable) ? '' : 'disable')
+      end
+      config_set('bgp_neighbor', 'log_neighbor_changes', @set_args)
+    end
+
+    def log_neighbor_changes
+      result = config_get('bgp_neighbor', 'log_neighbor_changes', @get_args)
+      return default_log_neighbor_changes if result.nil?
+      return :disable if /disable/.match(result.first)
+      :enable
+    end
+
+    def default_log_neighbor_changes
+      result = config_get_default('bgp_neighbor', 'log_neighbor_changes')
+      result.to_sym
+    end
+
+    def low_memory_exempt=(val)
+      set_args_keys(state: (val) ? '' : 'no')
+      config_set('bgp_neighbor', 'low_memory_exempt', @set_args)
+    end
+
+    def low_memory_exempt
+      result = config_get('bgp_neighbor', 'low_memory_exempt', @get_args)
+      result ? true : false
+    end
+
+    def default_low_memory_exempt
+      config_get_default('bgp_neighbor', 'low_memory_exempt')
+    end
+
+    def maximum_peers=(val)
+      set_args_keys(state: (val == default_maximum_peers) ? 'no' : '',
+                    num:   (val == default_maximum_peers) ? '' : val)
+      config_set('bgp_neighbor', 'maximum_peers', @set_args)
+    end
+
+    def maximum_peers
+      result = config_get('bgp_neighbor', 'maximum_peers', @get_args)
+      result.nil? ? default_maximum_peers : result.first.to_i
+    end
+
+    def default_maximum_peers
+      config_get_default('bgp_neighbor', 'maximum_peers')
+    end
+
+    def password_set(val, type=nil)
+      val = val.to_s
+      if val.strip.empty?
+        set_args_keys(state: 'no', type: '', passwd: '')
+      elsif type.nil?
+        set_args_keys(state:  '',
+                      type:   Encryption.symbol_to_cli(default_password_type),
+                      passwd: val.to_s)
+      else
+        set_args_keys(state:  '',
+                      type:   Encryption.symbol_to_cli(type),
+                      passwd: val.to_s)
+      end
+      config_set('bgp_neighbor', 'password', @set_args)
+    end
+
+    def password
+      result = config_get('bgp_neighbor', 'password', @get_args)
+      result.nil? ? '' : result.first.to_s
+    end
+
+    def default_password
+      config_get_default('bgp_neighbor', 'password')
+    end
+
+    def password_type
+      result = config_get('bgp_neighbor', 'password_type', @get_args)
+      if result.nil?
+        default_password_type
+      else
+        Encryption.cli_to_symbol(result.first.to_i)
+      end
+    end
+
+    def default_password_type
+      result = config_get_default('bgp_neighbor', 'password_type')
+      Encryption.cli_to_symbol(result)
+    end
+
+    def remote_as=(val)
+      asnum = RouterBgp.process_asnum(val)
+      if asnum == default_remote_as
+        set_args_keys(state: 'no', remote_as: '')
+      else
+        set_args_keys(state: '', remote_as: val)
+      end
+      config_set('bgp_neighbor', 'remote_as', @set_args)
+    end
+
+    def remote_as
+      result = config_get('bgp_neighbor', 'remote_as', @get_args)
+      return default_remote_as if result.nil?
+      return result.first.to_i unless /\d+\.\d+$/.match(result.first)
+      result.first
+    end
+
+    def default_remote_as
+      config_get_default('bgp_neighbor', 'remote_as')
+    end
+
+    def remove_private_as=(val)
+      val = val.to_sym
+      if val == default_remove_private_as
+        set_args_keys(state: 'no', option: '')
+      else
+        set_args_keys(state:  '',
+                      option: (val == :enable) ? '' : val.to_s)
+      end
+      config_set('bgp_neighbor', 'remove_private_as', @set_args)
+    end
+
+    def remove_private_as
+      result = config_get('bgp_neighbor', 'remove_private_as', @get_args)
+      return default_remove_private_as if result.nil?
+      result.first.nil? ? :enable : result.first.to_sym
+    end
+
+    def default_remove_private_as
+      result = config_get_default('bgp_neighbor', 'remove_private_as')
+      result.to_sym
+    end
+
+    def shutdown=(val)
+      set_args_keys(state: (val) ? '' : 'no')
+      config_set('bgp_neighbor', 'shutdown', @set_args)
+    end
+
+    def shutdown
+      result = config_get('bgp_neighbor', 'shutdown', @get_args)
+      result ? true : false
+    end
+
+    def default_shutdown
+      config_get_default('bgp_neighbor', 'shutdown')
+    end
+
+    def suppress_4_byte_as=(val)
+      set_args_keys(state: (val) ? '' : 'no')
+      config_set('bgp_neighbor', 'suppress_4_byte_as', @set_args)
+    end
+
+    def suppress_4_byte_as
+      result = config_get('bgp_neighbor', 'suppress_4_byte_as', @get_args)
+      result ? true : false
+    end
+
+    def default_suppress_4_byte_as
+      config_get_default('bgp_neighbor', 'suppress_4_byte_as')
+    end
+
+    def timers_set(keepalive, hold)
+      if keepalive == default_timers_keepalive &&
+         hold == default_timers_holdtime
+        set_args_keys(state: 'no', keepalive: timers_keepalive,
+                      hold: timers_holdtime)
+      else
+        set_args_keys(state: '', keepalive: keepalive,
+                      hold: hold)
+      end
+      config_set('bgp_neighbor', 'timers_keepalive_hold', @set_args)
+    end
+
+    def timers_keepalive_hold
+      match = config_get('bgp_neighbor', 'timers_keepalive_hold', @get_args)
+      match.nil? ? default_timers_keepalive_hold : match.first
+    end
+
+    def timers_keepalive
+      keepalive, _hold = timers_keepalive_hold
+      return default_timers_keepalive if keepalive.nil?
+      keepalive.to_i
+    end
+
+    def timers_holdtime
+      _keepalive, hold = timers_keepalive_hold
+      return default_timers_holdtime if hold.nil?
+      hold.to_i
+    end
+
+    def default_timers_keepalive
+      config_get_default('bgp_neighbor', 'timers_keepalive')
+    end
+
+    def default_timers_holdtime
+      config_get_default('bgp_neighbor', 'timers_holdtime')
+    end
+
+    def default_timers_keepalive_hold
+      ["#{default_timers_keepalive}", "#{default_timers_holdtime}"]
+    end
+
+    def transport_passive_only=(val)
+      set_args_keys(state: (val) ? '' : 'no')
+      config_set('bgp_neighbor', 'transport_passive_only', @set_args)
+    end
+
+    def transport_passive_only
+      result = config_get('bgp_neighbor', 'transport_passive_only', @get_args)
+      result ? true : false
+    end
+
+    def default_transport_passive_only
+      config_get_default('bgp_neighbor', 'transport_passive_only')
+    end
+
+    def update_source=(val)
+      if val.strip == default_update_source
+        set_args_keys(state: 'no', interface: update_source)
+      else
+        set_args_keys(state: '', interface: val)
+      end
+      config_set('bgp_neighbor', 'update_source', @set_args)
+    end
+
+    def update_source
+      result = config_get('bgp_neighbor', 'update_source', @get_args)
+      return default_update_source if result.nil? || result.first.nil?
+      result.first.downcase.strip
+    end
+
+    def default_update_source
+      config_get_default('bgp_neighbor', 'update_source')
+    end
+  end # class
+end # module

data/lib/cisco_node_utils/bgp_neighbor_af.rb

@@ -0,0 +1,709 @@
+#
+# NXAPI implementation of RouterBgpNeighborAF class
+#
+# August 2015 Chris Van Heuveln
+#
+# Copyright (c) 2015 Cisco and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative 'cisco_cmn_utils'
+require_relative 'node_util'
+require_relative 'bgp'
+
+module Cisco
+  # RouterBgpNeighborAF - node utility class for BGP per-neighbor, per-AF config
+  class RouterBgpNeighborAF < NodeUtil
+    def initialize(asn, vrf, nbr, af, instantiate=true)
+      validate_args(asn, vrf, nbr, af)
+      create if instantiate
+    end
+
+    def self.afs
+      af_hash = {}
+      RouterBgp.routers.each do |asn, vrfs|
+        af_hash[asn] = {}
+
+        vrfs.keys.each do |vrf|
+          af_hash[asn][vrf] = {}
+          get_args = { asnum: asn }
+          get_args[:vrf] = vrf unless (vrf == 'default')
+
+          nbrs = config_get('bgp_neighbor', 'all_neighbors', get_args)
+          next if nbrs.nil?
+          nbrs.each do |nbr|
+            af_hash[asn][vrf][nbr] = {}
+            get_args[:nbr] = nbr
+            afs = config_get('bgp_neighbor_af', 'all_afs', get_args)
+
+            next if afs.nil?
+            afs.each do |af|
+              af_hash[asn][vrf][nbr][af] =
+                RouterBgpNeighborAF.new(asn, vrf, nbr, af, false)
+            end
+          end
+        end
+      end
+      af_hash
+    rescue Cisco::CliError => e
+      # cmd will syntax reject when feature is not enabled
+      raise unless e.clierror =~ /Syntax error/
+      return {}
+    end
+
+    def validate_args(asn, vrf, nbr, af)
+      asn = RouterBgp.process_asnum(asn)
+      fail ArgumentError unless
+        vrf.is_a?(String) && (vrf.length > 0)
+      fail ArgumentError unless
+        nbr.is_a?(String) && (nbr.length > 0)
+      fail ArgumentError, "'af' must be an array specifying afi and safi" unless
+        af.is_a?(Array) || af.length == 2
+
+      nbr = Utils.process_network_mask(nbr)
+      @asn = asn
+      @vrf = vrf
+      @nbr = nbr
+      @afi, @safi = af
+      set_args_keys_default
+    end
+
+    def set_args_keys_default
+      keys = { asnum: @asn, nbr: @nbr, afi: @afi, safi: @safi }
+      keys[:vrf] = @vrf unless @vrf == 'default'
+      @get_args = @set_args = keys
+    end
+
+    # rubocop:disable Style/AccessorMethodName
+    def set_args_keys(hash={})
+      set_args_keys_default
+      @set_args = @get_args.merge!(hash) unless hash.empty?
+    end
+    # rubocop:enable Style/AccessorMethodNamefor
+
+    def create
+      set_args_keys(state: '')
+      config_set('bgp_neighbor', 'af', @set_args)
+    end
+
+    def destroy
+      set_args_keys(state: 'no')
+      config_set('bgp_neighbor', 'af', @set_args)
+    end
+
+    ########################################################
+    #                      PROPERTIES                      #
+    ########################################################
+
+    # -----------------------
+    # <state> advertise-map <map1> exist-map <map2>
+
+    # Returns ['<map1>', '<map2>']
+    def advertise_map_exist
+      arr = config_get('bgp_neighbor_af', 'advertise_map_exist', @get_args)
+      return default_advertise_map_exist if arr.nil?
+      arr.shift
+    end
+
+    def advertise_map_exist=(arr)
+      if arr.empty?
+        state = 'no'
+        map1, map2 = advertise_map_exist
+      else
+        map1, map2 = arr
+      end
+      set_args_keys(state: state, map1: map1, map2: map2)
+      config_set('bgp_neighbor_af', 'advertise_map_exist', @set_args)
+    end
+
+    def default_advertise_map_exist
+      config_get_default('bgp_neighbor_af', 'advertise_map_exist')
+    end
+
+    # -----------------------
+    # <state> advertise-map <map1> non-exist-map <map2> }
+
+    # Returns ['<map1>', '<map2>']
+    def advertise_map_non_exist
+      arr = config_get('bgp_neighbor_af', 'advertise_map_non_exist', @get_args)
+      return default_advertise_map_non_exist if arr.nil?
+      arr.shift
+    end
+
+    def advertise_map_non_exist=(arr)
+      if arr.empty?
+        state = 'no'
+        map1, map2 = advertise_map_non_exist
+      else
+        map1, map2 = arr
+      end
+      set_args_keys(state: state, map1: map1, map2: map2)
+      config_set('bgp_neighbor_af', 'advertise_map_non_exist', @set_args)
+    end
+
+    def default_advertise_map_non_exist
+      config_get_default('bgp_neighbor_af', 'advertise_map_non_exist')
+    end
+
+    # -----------------------
+    # <state> allowas-in <max>
+    # Nvgens as True -OR- max-occurrences integer
+    def allowas_in_get
+      val = config_get('bgp_neighbor_af', 'allowas_in', @get_args)
+      return nil if val.nil?
+      val.shift.split.last.to_i
+    end
+
+    def allowas_in
+      allowas_in_get.nil? ? false : true
+    end
+
+    def allowas_in_max
+      val = allowas_in_get
+      # val.zero? check below is needed to handle a cli defect wherein the
+      # default max value does not reliably nvgen
+      val = default_allowas_in_max if val.nil? || val.zero?
+      val
+    end
+
+    def allowas_in_set(state, max=nil)
+      set_args_keys(state: (state ? '' : 'no'), max: max)
+      config_set('bgp_neighbor_af', 'allowas_in', @set_args)
+    end
+
+    def default_allowas_in
+      config_get_default('bgp_neighbor_af', 'allowas_in')
+    end
+
+    def default_allowas_in_max
+      config_get_default('bgp_neighbor_af', 'allowas_in_max')
+    end
+
+    # -----------------------
+    # <state> as-override
+    def as_override
+      state = config_get('bgp_neighbor_af', 'as_override', @get_args)
+      state ? true : false
+    end
+
+    def as_override=(state)
+      set_args_keys(state: (state ? '' : 'no'))
+      config_set('bgp_neighbor_af', 'as_override', @set_args)
+    end
+
+    def default_as_override
+      config_get_default('bgp_neighbor_af', 'as_override')
+    end
+
+    # -----------------------
+    # <state> capability additional-paths receive <disable>
+    #   :enable  = capability additional-paths receive
+    #   :disable = capability additional-paths receive disable
+    #   :inherit = no capability additional-paths receive
+    def additional_paths_receive
+      val = config_get('bgp_neighbor_af', 'additional_paths_receive', @get_args)
+      return default_additional_paths_receive if val.nil?
+      /disable/.match(val.first) ? :disable : :enable
+    end
+
+    def additional_paths_receive=(val)
+      val = val.to_sym
+      if val == default_additional_paths_receive
+        set_args_keys(state: 'no', disable: '')
+      else
+        set_args_keys(state: '', disable: (val == :enable) ? '' : 'disable')
+      end
+      config_set('bgp_neighbor_af', 'additional_paths_receive', @set_args)
+    end
+
+    def default_additional_paths_receive
+      config_get_default('bgp_neighbor_af', 'additional_paths_receive').to_sym
+    end
+
+    # -----------------------
+    # <state> capability additional-paths send <disable>
+    #   :enable  = capability additional-paths send
+    #   :disable = capability additional-paths send disable
+    #   :inherit = no capability additional-paths send
+    def additional_paths_send
+      val = config_get('bgp_neighbor_af', 'additional_paths_send', @get_args)
+      return default_additional_paths_send if val.nil?
+      /disable/.match(val.first) ? :disable : :enable
+    end
+
+    def additional_paths_send=(val)
+      val = val.to_sym
+      if val == default_additional_paths_send
+        set_args_keys(state: 'no', disable: '')
+      else
+        set_args_keys(state: '', disable: (val == :enable) ? '' : 'disable')
+      end
+      config_set('bgp_neighbor_af', 'additional_paths_send', @set_args)
+    end
+
+    def default_additional_paths_send
+      config_get_default('bgp_neighbor_af', 'additional_paths_send').to_sym
+    end
+
+    # -----------------------
+    # <state> default-originate [ route-map <map> ]
+    # Nvgens as True with optional 'route-map <map>'
+    def default_originate_get
+      val = config_get('bgp_neighbor_af', 'default_originate', @get_args)
+      return nil if val.nil?
+      val = val.shift
+      (val[/route-map/]) ? val.split.last : true
+    end
+
+    def default_originate
+      default_originate_get.nil? ? false : true
+    end
+
+    def default_originate_route_map
+      val = default_originate_get
+      return default_default_originate_route_map if val.nil?
+      val.is_a?(String) ? val : nil
+    end
+
+    def default_originate_set(state, map=nil)
+      map = "route-map #{map}" unless map.nil?
+      set_args_keys(state: (state ? '' : 'no'), map: map)
+      config_set('bgp_neighbor_af', 'default_originate', @set_args)
+    end
+
+    def default_default_originate
+      config_get_default('bgp_neighbor_af', 'default_originate')
+    end
+
+    def default_default_originate_route_map
+      config_get_default('bgp_neighbor_af', 'default_originate_route_map')
+    end
+
+    # -----------------------
+    # <state> disable-peer-as-check
+    def disable_peer_as_check
+      state = config_get('bgp_neighbor_af', 'disable_peer_as_check', @get_args)
+      state ? true : default_disable_peer_as_check
+    end
+
+    def disable_peer_as_check=(state)
+      set_args_keys(state: (state ? '' : 'no'))
+      config_set('bgp_neighbor_af', 'disable_peer_as_check', @set_args)
+    end
+
+    def default_disable_peer_as_check
+      config_get_default('bgp_neighbor_af', 'disable_peer_as_check')
+    end
+
+    # -----------------------
+    # <state> filter-list <str> in
+    def filter_list_in
+      str = config_get('bgp_neighbor_af', 'filter_list_in', @get_args)
+      return default_filter_list_in if str.nil?
+      str.shift.strip
+    end
+
+    def filter_list_in=(str)
+      str.strip! unless str.nil?
+      if str == default_filter_list_in
+        state = 'no'
+        # Current filter-list name is required for removal
+        str = filter_list_in
+        return if str.nil?
+      end
+      set_args_keys(state: state, str: str)
+      config_set('bgp_neighbor_af', 'filter_list_in', @set_args)
+    end
+
+    def default_filter_list_in
+      config_get_default('bgp_neighbor_af', 'filter_list_in')
+    end
+
+    # -----------------------
+    # <state> filter-list <str> out
+    def filter_list_out
+      str = config_get('bgp_neighbor_af', 'filter_list_out', @get_args)
+      return default_filter_list_out if str.nil?
+      str.shift.strip
+    end
+
+    def filter_list_out=(str)
+      str.strip! unless str.nil?
+      if str == default_filter_list_out
+        state = 'no'
+        # Current filter-list name is required for removal
+        str = filter_list_out
+      end
+      set_args_keys(state: state, str: str)
+      config_set('bgp_neighbor_af', 'filter_list_out', @set_args)
+    end
+
+    def default_filter_list_out
+      config_get_default('bgp_neighbor_af', 'filter_list_out')
+    end
+
+    # -----------------------
+    # <state> maximum-prefix <limit> <threshold> <opt>
+    #
+    # <threshold> : optional
+    # <opt> : optional = [ restart <interval> | warning-only ]
+    #
+    def max_prefix_get
+      str = config_get('bgp_neighbor_af', 'max_prefix', @get_args)
+      return nil if str.nil?
+
+      regexp = Regexp.new('maximum-prefix (?<limit>\d+)' \
+                          ' *(?<threshold>\d+)?' \
+                          ' *(?<opt>restart|warning-only)?' \
+                          ' *(?<interval>\d+)?')
+      regexp.match(str.shift)
+    end
+
+    def max_prefix_set(limit, threshold=nil, opt=nil)
+      state = limit.nil? ? 'no' : ''
+      unless opt.nil?
+        opt = opt.respond_to?(:to_i) ? "restart #{opt}" : 'warning-only'
+      end
+      set_args_keys(state: state, limit: limit,
+                    threshold: threshold, opt: opt)
+      config_set('bgp_neighbor_af', 'max_prefix', @set_args)
+    end
+
+    def max_prefix_limit
+      val = max_prefix_get
+      return default_max_prefix_limit if val.nil?
+      val[:limit].to_i
+    end
+
+    def max_prefix_interval
+      val = max_prefix_get
+      return default_max_prefix_interval if val.nil?
+      (val[:interval].nil?) ? nil : val[:interval].to_i
+    end
+
+    def max_prefix_threshold
+      val = max_prefix_get
+      return default_max_prefix_threshold if val.nil?
+      (val[:threshold].nil?) ? nil : val[:threshold].to_i
+    end
+
+    def max_prefix_warning
+      val = max_prefix_get
+      return default_max_prefix_warning if val.nil?
+      (val[:opt] == 'warning-only') ? true : nil
+    end
+
+    def default_max_prefix_limit
+      config_get_default('bgp_neighbor_af', 'max_prefix_limit')
+    end
+
+    def default_max_prefix_interval
+      config_get_default('bgp_neighbor_af', 'max_prefix_interval')
+    end
+
+    def default_max_prefix_threshold
+      config_get_default('bgp_neighbor_af', 'max_prefix_threshold')
+    end
+
+    def default_max_prefix_warning
+      config_get_default('bgp_neighbor_af', 'max_prefix_warning')
+    end
+
+    # -----------------------
+    # <state> next-hop-self
+    def next_hop_self
+      state = config_get('bgp_neighbor_af', 'next_hop_self', @get_args)
+      state ? true : false
+    end
+
+    def next_hop_self=(state)
+      set_args_keys(state: (state ? '' : 'no'))
+      config_set('bgp_neighbor_af', 'next_hop_self', @set_args)
+    end
+
+    def default_next_hop_self
+      config_get_default('bgp_neighbor_af', 'next_hop_self')
+    end
+
+    # -----------------------
+    # <state> next-hop-third-party
+    def next_hop_third_party
+      state = config_get('bgp_neighbor_af', 'next_hop_third_party', @get_args)
+      state ? true : false
+    end
+
+    def next_hop_third_party=(state)
+      set_args_keys(state: (state ? '' : 'no'))
+      config_set('bgp_neighbor_af', 'next_hop_third_party', @set_args)
+    end
+
+    def default_next_hop_third_party
+      config_get_default('bgp_neighbor_af', 'next_hop_third_party')
+    end
+
+    # -----------------------
+    # <state> prefix-list <str> in
+    def prefix_list_in
+      str = config_get('bgp_neighbor_af', 'prefix_list_in', @get_args)
+      return default_prefix_list_in if str.nil?
+      str.shift.strip
+    end
+
+    def prefix_list_in=(str)
+      str.strip! unless str.nil?
+      if str == default_prefix_list_in
+        state = 'no'
+        # Current prefix-list name is required for removal
+        str = prefix_list_in
+        return if str.nil?
+      end
+      set_args_keys(state: state, str: str)
+      config_set('bgp_neighbor_af', 'prefix_list_in', @set_args)
+    end
+
+    def default_prefix_list_in
+      config_get_default('bgp_neighbor_af', 'prefix_list_in')
+    end
+
+    # -----------------------
+    # <state> prefix-list <str> out
+    def prefix_list_out
+      str = config_get('bgp_neighbor_af', 'prefix_list_out', @get_args)
+      return default_prefix_list_out if str.nil?
+      str.shift.strip
+    end
+
+    def prefix_list_out=(str)
+      str.strip! unless str.nil?
+      if str == default_prefix_list_out
+        state = 'no'
+        # Current prefix-list name is required for removal
+        str = prefix_list_out
+      end
+      set_args_keys(state: state, str: str)
+      config_set('bgp_neighbor_af', 'prefix_list_out', @set_args)
+    end
+
+    def default_prefix_list_out
+      config_get_default('bgp_neighbor_af', 'prefix_list_out')
+    end
+
+    # -----------------------
+    # <state> route-map <str> in
+    def route_map_in
+      str = config_get('bgp_neighbor_af', 'route_map_in', @get_args)
+      return default_route_map_in if str.nil?
+      str.shift.strip
+    end
+
+    def route_map_in=(str)
+      str.strip! unless str.nil?
+      if str == default_route_map_in
+        state = 'no'
+        # Current route-map name is required for removal
+        str = route_map_in
+        return if str.nil?
+      end
+      set_args_keys(state: state, str: str)
+      config_set('bgp_neighbor_af', 'route_map_in', @set_args)
+    end
+
+    def default_route_map_in
+      config_get_default('bgp_neighbor_af', 'route_map_in')
+    end
+
+    # -----------------------
+    # <state> route-map <str> out
+    def route_map_out
+      str = config_get('bgp_neighbor_af', 'route_map_out', @get_args)
+      return default_route_map_out if str.nil?
+      str.shift.strip
+    end
+
+    def route_map_out=(str)
+      str.strip! unless str.nil?
+      if str == default_route_map_out
+        state = 'no'
+        # Current route-map name is required for removal
+        str = route_map_out
+      end
+      set_args_keys(state: state, str: str)
+      config_set('bgp_neighbor_af', 'route_map_out', @set_args)
+    end
+
+    def default_route_map_out
+      config_get_default('bgp_neighbor_af', 'route_map_out')
+    end
+
+    # -----------------------
+    # <state route-reflector-client
+    def route_reflector_client
+      state = config_get('bgp_neighbor_af', 'route_reflector_client', @get_args)
+      state ? true : false
+    end
+
+    def route_reflector_client=(state)
+      set_args_keys(state: (state ? '' : 'no'))
+      config_set('bgp_neighbor_af', 'route_reflector_client', @set_args)
+    end
+
+    def default_route_reflector_client
+      config_get_default('bgp_neighbor_af', 'route_reflector_client')
+    end
+
+    # -----------------------
+    # <state> send-community [ both | extended | standard ]
+    # NOTE: 'standard' is default but does not nvgen on some platforms
+    # Returns: none, both, extended, or standard
+    def send_community
+      val = config_get('bgp_neighbor_af', 'send_community', @get_args)
+      return default_send_community if val.nil?
+      val = val.shift.split.last
+      return 'standard' if val[/send-community/] # Workaround
+      val
+    end
+
+    def send_community=(val)
+      if val[/none/]
+        state = 'no'
+        val = 'both'
+      end
+      if val[/extended|standard/]
+        case send_community
+        when /both/
+          state = 'no'
+          # Unset the opposite property
+          val = val[/extended/] ? 'standard' : 'extended'
+
+        when /extended|standard/
+          # This is an additive property therefore remove the entire command
+          # when switching from: ext <--> std
+          set_args_keys(state: 'no', attr: 'both')
+          config_set('bgp_neighbor_af', 'send_community', @set_args)
+          state = ''
+        end
+      end
+      set_args_keys(state: state, attr: val)
+      config_set('bgp_neighbor_af', 'send_community', @set_args)
+    end
+
+    def default_send_community
+      config_get_default('bgp_neighbor_af', 'send_community')
+    end
+
+    # -----------------------
+    # <state> soft-reconfiguration inbound <always>
+    #   :enable  = soft-reconfiguration inbound
+    #   :always = soft-reconfiguration inbound always
+    #   :inherit = no soft-reconfiguration inbound
+    def soft_reconfiguration_in
+      val = config_get('bgp_neighbor_af', 'soft_reconfiguration_in', @get_args)
+      return default_soft_reconfiguration_in if val.nil?
+      /always/.match(val.first) ? :always : :enable
+    end
+
+    def soft_reconfiguration_in=(val)
+      val = val.to_sym
+      if val == default_soft_reconfiguration_in
+        set_args_keys(state: 'no', always: '')
+      else
+        set_args_keys(state: '', always: (val == :enable) ? '' : 'always')
+      end
+      config_set('bgp_neighbor_af', 'soft_reconfiguration_in', @set_args)
+    end
+
+    def default_soft_reconfiguration_in
+      config_get_default('bgp_neighbor_af', 'soft_reconfiguration_in').to_sym
+    end
+
+    # -----------------------
+    # <state> soo <str>
+    def soo
+      str = config_get('bgp_neighbor_af', 'soo', @get_args)
+      return default_soo if str.nil?
+      str.shift.strip
+    end
+
+    def soo=(str)
+      str.strip! unless str.nil?
+      if str == default_soo
+        state = 'no'
+        str = soo
+      end
+      set_args_keys(state: state, str: str)
+      config_set('bgp_neighbor_af', 'soo', @set_args)
+    end
+
+    def default_soo
+      config_get_default('bgp_neighbor_af', 'soo')
+    end
+
+    # -----------------------
+    # <state> suppress-inactive
+    def suppress_inactive
+      state = config_get('bgp_neighbor_af', 'suppress_inactive', @get_args)
+      state ? true : false
+    end
+
+    def suppress_inactive=(state)
+      set_args_keys(state: (state ? '' : 'no'))
+      config_set('bgp_neighbor_af', 'suppress_inactive', @set_args)
+    end
+
+    def default_suppress_inactive
+      config_get_default('bgp_neighbor_af', 'suppress_inactive')
+    end
+
+    # -----------------------
+    # <state> unsuppress-map <str>
+    def unsuppress_map
+      str = config_get('bgp_neighbor_af', 'unsuppress_map', @get_args)
+      return default_unsuppress_map if str.nil?
+      str.shift.strip
+    end
+
+    def unsuppress_map=(str)
+      str.strip! unless str.nil?
+      if str == default_unsuppress_map
+        state = 'no'
+        str = unsuppress_map
+      end
+      set_args_keys(state: state, str: str)
+      config_set('bgp_neighbor_af', 'unsuppress_map', @set_args)
+    end
+
+    def default_unsuppress_map
+      config_get_default('bgp_neighbor_af', 'unsuppress_map')
+    end
+
+    # -----------------------
+    # <state> weight <int>
+    def weight
+      int = config_get('bgp_neighbor_af', 'weight', @get_args)
+      int.nil? ? default_weight : int.shift
+    end
+
+    def weight=(int)
+      if int == default_weight
+        state = 'no'
+        int = ''
+      end
+      set_args_keys(state: state, int: int)
+      config_set('bgp_neighbor_af', 'weight', @set_args)
+    end
+
+    def default_weight
+      config_get_default('bgp_neighbor_af', 'weight')
+    end
+  end
+end