kanrisuru 0.11.1 → 0.14.0

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      def ip_link(action, opts)
+        command = nil
+
+        case action
+        when 'show', 'list'
+          version = ip_version
+
+          command = Kanrisuru::Command.new('ip')
+          command.append_flag('-json') if version >= IPROUTE2_JSON_VERSION
+          command.append_flag('-s', opts[:stats])
+          command.append_arg('-family', opts[:family])
+          command << 'link show'
+
+          command.append_arg('dev', opts[:dev])
+          command.append_arg('group', opts[:group])
+          command.append_arg('master', opts[:master])
+          command.append_arg('type', opts[:type])
+          command.append_arg('vrf', opts[:vrf])
+
+          command.append_flag('up', opts[:up])
+        when 'set'
+          command = Kanrisuru::Command.new('ip link set')
+
+          raise ArgumentError, 'no device defined' unless opts[:dev]
+
+          command.append_arg('dev', opts[:dev])
+
+          case opts[:direction]
+          when 'up'
+            command.append_flag('up')
+          when 'down'
+            command.append_flag('down')
+          end
+
+          command.append_arg('arp', opts[:arp])
+          command.append_arg('multicast', opts[:multicast])
+          command.append_arg('dynamic', opts[:dynamic])
+          command.append_arg('name', opts[:name])
+          command.append_arg('txqueuelen', opts[:txqueuelen])
+          command.append_arg('txqlen', opts[:txqlen])
+          command.append_arg('mtu', opts[:mtu])
+          command.append_arg('address', opts[:address])
+          command.append_arg('broadcast', opts[:broadcast])
+          command.append_arg('brd', opts[:brd])
+          command.append_arg('peer', opts[:peer])
+          command.append_arg('netns', opts[:netns])
+
+          if Kanrisuru::Util.present?(opts[:vf])
+            command.append_arg('vf', opts[:vf])
+            command.append_arg('mac', opts[:mac])
+
+            if Kanrisuru::Util.present?(opts[:vlan])
+              command.append_arg('vlan', opts[:vlan])
+              command.append_arg('qos', opts[:qos])
+            end
+
+            command.append_arg('rate', opts[:rate])
+          end
+        end
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          Parser::Link.parse(cmd, action, version)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      def ip_maddress(action, opts)
+        case action
+        when 'show', 'list'
+          command = Kanrisuru::Command.new('ip')
+
+          version = ip_version
+          command.append_flag('-json') if version >= IPROUTE2_JSON_VERSION
+          command.append_arg('-family', opts[:family])
+          command << 'maddress show'
+
+          command.append_arg('dev', opts[:dev])
+        when 'add', 'delete', 'del'
+          command = Kanrisuru::Command.new('ip maddress')
+          command << action
+
+          command.append_arg('address', opts[:lladdress])
+          command.append_arg('dev', opts[:dev])
+        end
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          Parser::Maddress.parse(cmd, action, version)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      def ip_neighbour(action, opts)
+        case action
+        when 'add', 'change', 'replace', 'del', 'delete'
+          command = Kanrisuru::Command.new('ip neighbour')
+          command << action
+
+          command.append_arg('to', opts[:to])
+          command.append_arg('dev', opts[:dev])
+
+          if action != 'del' && action != 'delete'
+            command.append_arg('lladdr', opts[:lladdr])
+            command.append_arg('nud', opts[:nud])
+          end
+
+          command.append_flag('permanent', opts[:permanent])
+          command.append_flag('noarp', opts[:noarp])
+          command.append_flag('reachable', opts[:reachable])
+          command.append_flag('stale', opts[:stale])
+        when 'show', 'list'
+          version = ip_version
+
+          command = Kanrisuru::Command.new('ip')
+          command.append_flag('-json') if version >= Kanrisuru::Core::IP::IPROUTE2_JSON_VERSION
+          command.append_flag('-s', opts[:stats])
+
+          command << 'neighbour show'
+
+          command.append_arg('to', opts[:to])
+          command.append_arg('dev', opts[:dev])
+          command.append_arg('nud', opts[:nud])
+
+          command.append_flag('unused', opts[:unused])
+        when 'flush'
+          command = Kanrisuru::Command.new('ip neighbour flush')
+          command.append_arg('to', opts[:to])
+          command.append_arg('dev', opts[:dev])
+          command.append_arg('nud', opts[:nud])
+
+          command.append_flag('unused', opts[:unused])
+        end
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          Parser::Neighbour.parse(cmd, action, version)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      def ip_route(action, opts)
+        case action
+        when 'show', 'list'
+          version = ip_version
+
+          command = Kanrisuru::Command.new('ip')
+          command.append_flag('-json') if version >= IPROUTE2_JSON_VERSION
+          command.append_arg('-family', opts[:family])
+          command << 'route show'
+
+          command.append_arg('to', opts[:to])
+          command.append_arg('dev', opts[:dev])
+          command.append_arg('proto', opts[:proto])
+          command.append_arg('type', opts[:type])
+          command.append_arg('via', opts[:via])
+          command.append_arg('src', opts[:src])
+          command.append_arg('realms', opts[:realms])
+        when 'flush'
+          command = Kanrisuru::Command.new('ip')
+          command.append_arg('-family', opts[:family])
+          command << 'route flush'
+
+          command.append_arg('to', opts[:to])
+          command.append_arg('dev', opts[:dev])
+          command.append_arg('proto', opts[:proto])
+          command.append_arg('type', opts[:type])
+          command.append_arg('via', opts[:via])
+          command.append_arg('src', opts[:src])
+          command.append_arg('realm', opts[:realm])
+          command.append_arg('realms', opts[:realm])
+        when 'add', 'change', 'append', 'del', 'delete'
+          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])
+
+          command.append_arg('mtu', opts[:mtu])
+          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', opts[:congctl])
+            else
+              command.append_arg('congctl lock', 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])
+        when 'get'
+          command = Kanrisuru::Command.new('ip route get')
+
+          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])
+        end
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          Parser::Route.parse(cmd, action, version)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      def ip_rule(action, opts)
+        case action
+        when 'show', 'list'
+          version = ip_version
+
+          command = Kanrisuru::Command.new('ip')
+          command.append_flag('-json') if version >= IPROUTE2_JSON_VERSION
+
+          command << 'rule show'
+        when 'flush'
+          command = Kanrisuru::Command.new('ip rule flush')
+        when 'add', 'delete'
+          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])
+        end
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          Parser::Rule.parse(cmd, action, version)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'commands/address'
+require_relative 'commands/address_label'
+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)
+
+        raise 'ip command not found' if command.failure?
+
+        command.to_s.split('ip utility, iproute2-ss')[1].to_i
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# 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
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'parsers/base'
+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