kanrisuru 0.12.0 → 0.15.0

data/lib/kanrisuru/core/ip/commands/route.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      def ip_route(action, opts)
+        case action
+        when 'show', 'list'
+          version = ip_version.to_i
+          command = ip_route_show(opts, version)
+        when 'flush'
+          command = ip_route_flush(opts)
+        when 'add', 'change', 'append', 'del', 'delete', 'replace'
+          command = ip_route_modify(action, opts)
+        when 'get'
+          command = ip_route_get(opts)
+        end
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          Parser::Route.parse(cmd, action, version)
+        end
+      end
+
+      def ip_route_show(opts, version)
+        command = Kanrisuru::Command.new('ip')
+        command.append_flag('-json') if version >= IPROUTE2_JSON_VERSION
+        command.append_arg('-family', opts[:family])
+        command << 'route show'
+
+        ip_route_common_opts(command, opts)
+
+        command
+      end
+
+      def ip_route_modify(action, opts)
+        command = Kanrisuru::Command.new('ip route')
+        command << action
+
+        command.append_arg('to', opts[:to])
+        command.append_arg('tos', opts[:tos])
+        command.append_arg('dsfield', opts[:dsfield])
+        command.append_arg('metric', opts[:metric])
+        command.append_arg('preference', opts[:preference])
+        command.append_arg('table', opts[:table])
+        command.append_arg('vrf', opts[:vrf])
+        command.append_arg('dev', opts[:dev])
+        command.append_arg('via', opts[:via])
+        command.append_arg('src', opts[:src])
+        command.append_arg('realm', opts[:realm])
+
+        if Kanrisuru::Util.present?(opts[:mtu])
+          if Kanrisuru::Util.present?(opts[:mtu_lock])
+            command.append_arg('mtu lock', opts[:mtu])
+          else
+            command.append_arg('mtu', opts[:mtu])
+          end
+        end
+
+        command.append_arg('window', opts[:window])
+        command.append_arg('rtt', opts[:rtt])
+        command.append_arg('rttvar', opts[:rttvar])
+        command.append_arg('rto_min', opts[:rto_min])
+        command.append_arg('ssthresh', opts[:ssthresh])
+        command.append_arg('cwnd', opts[:cwnd])
+        command.append_arg('initcwnd', opts[:initcwnd])
+        command.append_arg('initrwnd', opts[:initrwnd])
+        command.append_arg('features', opts[:features])
+        command.append_arg('quickack', opts[:quickack])
+        command.append_arg('fastopen_no_cookie', opts[:fastopen_no_cookie])
+
+        if Kanrisuru::Util.present?(opts[:congctl])
+          if Kanrisuru::Util.present?(opts[:congctl_lock])
+            command.append_arg('congctl lock', opts[:congctl])
+          else
+            command.append_arg('congctl', opts[:congctl])
+          end
+        end
+
+        command.append_arg('advmss', opts[:advmss])
+        command.append_arg('reordering', opts[:reordering])
+
+        if Kanrisuru::Util.present?(opts[:next_hop])
+          next_hop = opts[:next_hop]
+
+          command << 'next_hop'
+          command.append_arg('via', next_hop[:via])
+          command.append_arg('dev', next_hop[:dev])
+          command.append_arg('weight', next_hop[:weight])
+        end
+
+        command.append_arg('scope', opts[:scope])
+        command.append_arg('protocol', opts[:protocol])
+        command.append_flag('onlink', opts[:onlink])
+        command.append_arg('pref', opts[:pref])
+        command.append_arg('nhid', opts[:nhid])
+        command
+      end
+
+      def ip_route_flush(opts)
+        command = Kanrisuru::Command.new('ip')
+        command.append_arg('-family', opts[:family])
+        command << 'route flush'
+
+        ip_route_common_opts(command, opts)
+
+        command
+      end
+
+      def ip_route_get(opts)
+        command = Kanrisuru::Command.new('ip route get')
+
+        command.append_flag('fibmatch', opts[:fibmatch])
+        command.append_arg('to', opts[:to])
+        command.append_arg('from', opts[:from])
+        command.append_arg('tos', opts[:tos])
+        command.append_arg('dsfield', opts[:dsfield])
+        command.append_arg('iif', opts[:iif])
+        command.append_arg('oif', opts[:oif])
+        command.append_arg('mark', opts[:mark])
+        command.append_arg('vrf', opts[:vrf])
+        command.append_arg('ipproto', opts[:ipproto])
+        command.append_arg('sport', opts[:sport])
+        command.append_arg('dport', opts[:dport])
+
+        command.append_flag('connected', opts[:connected])
+        command
+      end
+
+      def ip_route_common_opts(command, opts)
+        command.append_arg('to', opts[:to])
+        command.append_arg('dev', opts[:dev])
+        command.append_arg('protocol', opts[:protocol])
+        command.append_arg('type', opts[:type])
+        command.append_arg('table', opts[:table])
+        command.append_arg('tos', opts[:tos])
+        command.append_arg('dsfield', opts[:dsfield])
+        command.append_arg('via', opts[:via])
+        command.append_arg('vrf', opts[:vrf])
+        command.append_arg('src', opts[:src])
+
+        command.append_arg('realm', opts[:realm])
+        command.append_arg('realms', opts[:realms])
+        command.append_arg('scope', opts[:scope])
+
+        command.append_flag('cloned', opts[:cloned])
+        command.append_flag('cached', opts[:cached])
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/ip/commands/rule.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      def ip_rule(action, opts)
+        case action
+        when 'show', 'list'
+          version = ip_version.to_i
+          command = ip_rule_show(opts, version)
+        when 'flush'
+          command = ip_rule_flush(opts)
+        when 'add', 'delete', 'del'
+          command = ip_rule_modify(action, opts)
+        end
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          Parser::Rule.parse(cmd, action, version)
+        end
+      end
+
+      def ip_rule_modify(action, opts)
+        command = Kanrisuru::Command.new('ip rule')
+        command << action
+
+        command.append_arg('type', opts[:type])
+        command.append_arg('from', opts[:from])
+        command.append_arg('to', opts[:to])
+        command.append_arg('iif', opts[:iif])
+        command.append_arg('tos', opts[:tos])
+        command.append_arg('dsfield', opts[:dsfield])
+        command.append_arg('fwmark', opts[:fwmark])
+        command.append_arg('priority', opts[:priority])
+        command.append_arg('table', opts[:table])
+        command.append_arg('realms', opts[:realms])
+        command.append_arg('nat', opts[:nat])
+        command
+      end
+
+      def ip_rule_flush(opts)
+        command = Kanrisuru::Command.new('ip rule flush')
+        command.append_arg('protocol', opts[:protocol])
+        command
+      end
+
+      def ip_rule_show(_opts, version)
+        command = Kanrisuru::Command.new('ip')
+        command.append_flag('-json') if version >= IPROUTE2_JSON_VERSION
+
+        command << 'rule show'
+        command
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/ip/commands.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'commands/address'
+require_relative 'commands/address_label'
+require_relative 'commands/link_type_opts'
+require_relative 'commands/link_set_opts'
+require_relative 'commands/link'
+require_relative 'commands/maddress'
+require_relative 'commands/neighbour'
+require_relative 'commands/route'
+require_relative 'commands/rule'
+
+module Kanrisuru
+  module Core
+    module IP
+      def ip_version
+        command = Kanrisuru::Command.new('ip -V')
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          Parser::Version.parse(cmd)
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/ip/constants.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      IPROUTE2_JSON_VERSION = 180_129
+
+      IP_ROUTE_TYPES = %w[
+        unicast unreachable blackhole prohibit local
+        broadcast throw nat via anycast multicast
+      ].freeze
+
+      IP_FAMILIES = %w[inet inet6 link].freeze
+      IP_SCOPES = %w[global site link host].freeze
+      IP_LINK_TYPES = %w[
+        vlan veth vcan vxcan dummy ifb macvlan macvtap
+        bridge bond team ipoib ip6tnl ipip sit vxlan
+        gre gretap erspan ip6gre ip6gretap ip6erspan
+        vti nlmon team_slave bond_slave bridge_slave
+        ipvlan ipvtap geneve vrf macsec netdevsim rmnet
+        xfrm bareudp hsr
+      ].freeze
+    end
+  end
+end

data/lib/kanrisuru/core/ip/parser.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'parsers/base'
+require_relative 'parsers/version'
+require_relative 'parsers/address'
+require_relative 'parsers/address_label'
+require_relative 'parsers/link'
+require_relative 'parsers/maddress'
+require_relative 'parsers/neighbour'
+require_relative 'parsers/route'
+require_relative 'parsers/rule'

data/lib/kanrisuru/core/ip/parsers/address.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      module Parser
+        class Address < Base
+          class << self
+            def parse(command, action, version)
+              return unless %w[show list].include?(action)
+
+              if version >= Kanrisuru::Core::IP::IPROUTE2_JSON_VERSION
+                begin
+                  ip_address_result_json(command.to_json)
+                rescue JSON::ParserError
+                  ip_address_result_parse(command.to_a)
+                end
+              else
+                ip_address_result_parse(command.to_a)
+              end
+            end
+
+            def ip_address_result_parse(lines)
+              rows = []
+              current_row = nil
+
+              lines.each.with_index do |line, index|
+                case line
+                when /^\d+:\s/
+                  rows << current_row unless current_row.nil?
+
+                  current_row = Kanrisuru::Core::IP::IPAddressProperty.new
+                  current_row.address_info = []
+
+                  parse_ip_row(current_row, line)
+                when /^link/
+                  parse_link(current_row, line)
+                when /^inet/
+                  parse_address_info(current_row, line)
+                when /^valid_lft/
+                  parse_valid(current_row, line)
+                when /^RX:/
+                  parse_rx(current_row, lines[index + 1])
+                when /^TX:/
+                  parse_tx(current_row, lines[index + 1])
+                end
+              end
+
+              rows << current_row
+              rows
+            end
+
+            def ip_address_result_json(rows)
+              result = []
+              rows.each do |row|
+                next if row['ifindex'].instance_of?(NilClass)
+
+                new_row = Kanrisuru::Core::IP::IPAddressProperty.new(
+                  row['ifindex'], row['ifname'], row['flags'], row['mtu'], row['qdisc'],
+                  row['operstate'], row['group'], row['txqlen'], row['link_type'], row['address'], []
+                )
+
+                if row.key?('stats64')
+                  rx = row['stats64']['rx']
+                  tx = row['stats64']['tx']
+
+                  new_row[:stats] = Kanrisuru::Core::IP::IPStats.new(
+                    Kanrisuru::Core::IP::IPStatRX.new(
+                      rx['bytes'], rx['packets'], rx['errors'],
+                      rx['dropped'], rx['over_errors'], rx['multicast']
+                    ),
+                    Kanrisuru::Core::IP::IPStatTX.new(
+                      tx['bytes'], tx['packets'], tx['errors'],
+                      tx['dropped'], tx['carrier_errors'], tx['collisions']
+                    )
+                  )
+                end
+
+                addr_info = row['addr_info'] || []
+
+                new_row[:address_info] = addr_info.map do |address|
+                  dynamic = address['dynamic'] == true || address['dynamic'] == 'true'
+
+                  Kanrisuru::Core::IP::IPAddressInfo.new(
+                    address['family'],
+                    IPAddr.new(address['local']),
+                    address['broadcast'],
+                    address['scope'],
+                    dynamic,
+                    address['valid_life_time'], address['preferred_life_time']
+                  )
+                end
+
+                result << new_row
+              end
+
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/ip/parsers/address_label.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      module Parser
+        class AddressLabel < Base
+          class << self
+            def parse(command, action, version)
+              if %w[show list].include?(action)
+                if version >= Kanrisuru::Core::IP::IPROUTE2_JSON_VERSION
+                  begin
+                    ip_address_label_result_json(command.to_json)
+                  rescue JSON::ParserError
+                    ip_address_label_result_parse(command.to_a)
+                  end
+                else
+                  ip_address_label_result_parse(command.to_a)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/ip/parsers/base.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      module Parser
+        class Base
+          class << self
+            def ip_address_label_result_json(rows)
+              result = []
+
+              rows.each do |row|
+                new_row = Kanrisuru::Core::IP::IPAddressLabel.new(
+                  row['address'], row['prefixlen'], row['label']
+                )
+
+                result << new_row
+              end
+
+              result
+            end
+
+            def ip_address_label_result_parse(lines)
+              lines.map do |line|
+                _, addr, _, label = line.split(/\s/)
+                address, prefix_length = addr.split(%r{/})
+
+                Kanrisuru::Core::IP::IPAddressLabel.new(address, prefix_length.to_i, label)
+              end
+            end
+
+            def parse_alias(row, line)
+              _, alias_string = line.split('alias')
+              row.alias = alias_string
+            end
+
+            def parse_ip_maddr_name(row, line)
+              index = line.match(/^\d+/).to_s.to_i
+              _, name = line.split(/^\d+:\s/)
+
+              row.index = index
+              row.name = name
+              row.maddr = []
+            end
+
+            def parse_ip_row(row, line)
+              index = line.match(/^\d+/).to_s.to_i
+              _, string = line.split(/^\d+:\s/)
+              name = string.match(/^\w+/).to_s
+              _, string = string.split(/^\w+:\s/)
+              _, flags, string = string.split(/(<.+>)\s/)
+
+              flags = flags.gsub(/<?>?/, '')
+              flags = flags.split(',')
+
+              row.index = index
+              row.name = name
+              row.flags = flags
+
+              values = string.split(/\s/)
+              values.each.with_index do |_, i|
+                case values[i]
+                when 'mtu'
+                  row.mtu = values[i + 1].to_i
+                when 'qdisc'
+                  row.qdisc = values[i + 1]
+                when 'state'
+                  row.state = values[i + 1]
+                when 'group'
+                  row.group = values[i + 1]
+                when 'qlen'
+                  row.qlen = values[i + 1].to_i
+                when 'mode'
+                  row.link_mode = values[i + 1]
+                end
+              end
+            end
+
+            def parse_link(row, line)
+              _, string = line.split(%r{^link/})
+              link_type, mac_address = string.split
+
+              row.link_type = link_type
+              row.mac_address = mac_address
+            end
+
+            def parse_address_info(row, line)
+              values = line.split
+              address_info = Kanrisuru::Core::IP::IPAddressInfo.new
+
+              values.each.with_index do |_, index|
+                case values[index]
+                when 'inet', 'inet6'
+                  address_info.family = values[index]
+                  address_info.ip = IPAddr.new(values[index + 1].split('/')[0])
+                when 'brd'
+                  address_info.broadcast = values[index + 1]
+                when 'scope'
+                  address_info.scope = values[index + 1]
+                when 'dynamic'
+                  address_info.dynamic = true
+                end
+              end
+
+              row.address_info << address_info
+            end
+
+            def parse_valid(row, line)
+              values = line.split
+
+              values.each.with_index do |_, index|
+                case values[index]
+                when 'valid_lft'
+                  row.address_info.last.valid_life_time = values[index + 1]
+                when 'preferred_lft'
+                  row.address_info.last.preferred_life_time = values[index + 1]
+                end
+              end
+            end
+
+            def parse_rx(row, line)
+              values = line.split
+
+              bytes = values[0].to_i
+              packets = values[1].to_i
+              errors = values[2].to_i
+              dropped = values[3].to_i
+              over_errors = values[4].to_i
+              multicast = values[5].to_i
+
+              row.stats = Kanrisuru::Core::IP::IPStats.new
+              row.stats.rx = Kanrisuru::Core::IP::IPStatRX.new(
+                bytes,
+                packets,
+                errors,
+                dropped,
+                over_errors,
+                multicast
+              )
+            end
+
+            def parse_tx(row, line)
+              values = line.split
+
+              bytes = values[0].to_i
+              packets = values[1].to_i
+              errors = values[2].to_i
+              dropped = values[3].to_i
+              carrier_errors = values[4].to_i
+              collisions = values[5].to_i
+
+              row.stats.tx = Kanrisuru::Core::IP::IPStatTX.new(
+                bytes,
+                packets,
+                errors,
+                dropped,
+                carrier_errors,
+                collisions
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/ip/parsers/link.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      module Parser
+        class Link < Base
+          class << self
+            def parse(command, action, version)
+              return unless %w[show list].include?(action)
+
+              if version >= Kanrisuru::Core::IP::IPROUTE2_JSON_VERSION
+                begin
+                  ip_link_result_json(command.to_json)
+                rescue JSON::ParserError
+                  ip_link_result_parse(command.to_a)
+                end
+              else
+                ip_link_result_parse(command.to_a)
+              end
+            end
+
+            def ip_link_result_parse(lines)
+              rows = []
+              current_row = nil
+
+              lines.each.with_index do |line, index|
+                case line
+                when /^\d+:\s/
+                  rows << current_row unless current_row.nil?
+
+                  current_row = Kanrisuru::Core::IP::IPLinkProperty.new
+                  parse_ip_row(current_row, line)
+                when /^link/
+                  parse_link(current_row, line)
+                when /^alias/
+                  parse_alias(current_row, line)
+                when /^RX:/
+                  parse_rx(current_row, lines[index + 1])
+                when /^TX:/
+                  parse_tx(current_row, lines[index + 1])
+                end
+              end
+
+              rows << current_row
+              rows
+            end
+
+            def ip_link_result_json(rows)
+              result = []
+              rows.each do |row|
+                next if row['ifindex'].instance_of?(NilClass)
+
+                new_row = Kanrisuru::Core::IP::IPLinkProperty.new(
+                  row['ifindex'], row['ifname'], row['flags'], row['mtu'], row['qdisc'],
+                  row['operstate'], row['group'], row['txqlen'], row['linkmode'],
+                  row['link_type'], row['address'], row['ifalias'], nil
+                )
+
+                if row.key?('stats64')
+                  rx = row['stats64']['rx']
+                  tx = row['stats64']['tx']
+
+                  new_row[:stats] = Kanrisuru::Core::IP::IPStats.new(
+                    Kanrisuru::Core::IP::IPStatRX.new(
+                      rx['bytes'], rx['packets'], rx['errors'],
+                      rx['dropped'], rx['over_errors'], rx['multicast']
+                    ),
+                    Kanrisuru::Core::IP::IPStatTX.new(
+                      tx['bytes'], tx['packets'], tx['errors'],
+                      tx['dropped'], tx['carrier_errors'], tx['collisions']
+                    )
+                  )
+                end
+
+                result << new_row
+              end
+
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end