kanrisuru 0.11.1 → 0.14.0

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

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      module Parser
+        class Maddress < 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_maddress_result_json(command.to_json)
+                rescue JSON::ParserError
+                  ip_maddress_result_parse(command.to_a)
+                end
+              else
+                ip_maddress_result_parse(command.to_a)
+              end
+            end
+
+            def ip_maddress_result_json(rows)
+              rows.map do |row|
+                maddress = Kanrisuru::Core::IP::IPMAddress.new(row['ifindex'], row['ifname'], [])
+
+                entries = row['maddr'] || []
+                entries.each do |entry|
+                  ipmaddress_entry = Kanrisuru::Core::IP::IPMAddressEntry.new
+                  entry.each do |key, value|
+                    ipmaddress_entry[key] = value
+                  end
+
+                  maddress.maddr << ipmaddress_entry
+                end
+
+                maddress
+              end
+            end
+
+            def ip_maddress_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::IPMAddress.new
+                  parse_ip_maddr_name(current_row, line)
+                when /^link/
+                  _, link = line.split
+
+                  entry = Kanrisuru::Core::IP::IPMAddressEntry.new
+                  entry.link = link
+
+                  current_row.maddr << entry
+                when /^inet/
+                  values = line.split
+
+                  entry = Kanrisuru::Core::IP::IPMAddressEntry.new
+                  values.each.with_index do |value, index|
+                    case value
+                    when 'inet', 'inet6'
+                      entry.family = value
+                      entry.address = values[index + 1]
+                    when 'users'
+                      entry.users = values[index + 1].to_i
+                    end
+                  end
+
+                  current_row.maddr << entry
+                end
+              end
+
+              rows << current_row
+              rows
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      module Parser
+        class Neighbour < 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_neighbour_result_json(command.to_json)
+                rescue JSON::ParserError
+                  ip_neighbour_result_parse(command.to_a)
+                end
+              else
+                ip_neighbour_result_parse(command.to_a)
+              end
+            end
+
+            def ip_neighbour_result_json(rows)
+              rows.map do |row|
+                neighbour = Kanrisuru::Core::IP::IPNeighbour.new(
+                  IPAddr.new(row['dst']),
+                  row['dev'],
+                  row['lladdr'],
+                  row['state']
+                )
+
+                if row.key?('used') || row.key?('confirmed') ||
+                   row.key?('refcnt') || row.key?('updated') ||
+                   row.key?('probes')
+                  neighbour.stats = Kanrisuru::Core::IP::IPNeighbourStats.new
+
+                  neighbour.stats.ref_count = row['refcnt']
+                  neighbour.stats.used = row['used']
+                  neighbour.stats.confirmed = row['confirmed']
+                  neighbour.stats.probes = row['probes']
+                  neighbour.stats.updated = row['updated']
+                end
+
+                neighbour
+              end
+            end
+
+            def ip_neighbour_result_parse(lines)
+              rows = []
+              lines.each do |line|
+                values = line.split
+
+                neighbour = Kanrisuru::Core::IP::IPNeighbour.new(IPAddr.new(values[0]))
+                neighbour.state = [values[values.length - 1]]
+
+                if line.include?('probes') || line.include?('used') || line.include?('ref')
+                  neighbour.stats = Kanrisuru::Core::IP::IPNeighbourStats.new
+                end
+
+                values.each.with_index do |value, index|
+                  case value
+                  when 'dev'
+                    neighbour.device = values[index + 1]
+                  when 'lladdr'
+                    neighbour.lladdr = values[index + 1]
+                  when 'ref'
+                    neighbour.stats.ref_count = values[index + 1] ? values[index + 1].to_i : nil
+                  when 'used'
+                    used, confirmed, updated = values[index + 1].split('/')
+
+                    neighbour.stats.used = used ? used.to_i : nil
+                    neighbour.stats.updated = updated ? updated.to_i : nil
+                    neighbour.stats.confirmed = confirmed ? confirmed.to_i : nil
+                  when 'probes'
+                    neighbour.stats.probes = values[index + 1] ? values[index + 1].to_i : nil
+                  end
+                end
+
+                rows << neighbour
+              end
+
+              rows
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      module Parser
+        class Route < 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_route_result_json(command.to_json)
+                rescue JSON::ParserError
+                  ip_route_result_parse(command.to_a)
+                end
+              else
+                ip_route_result_parse(command.to_a)
+              end
+            end
+
+            def ip_route_result_json(rows)
+              rows.map do |row|
+                Kanrisuru::Core::IP::IPRoute.new(
+                  row['dst'],
+                  row['gateway'],
+                  row['dev'],
+                  row['protocol'],
+                  row['scope'],
+                  row['prefsrc'],
+                  row['metric'],
+                  row['flags']
+                )
+              end
+            end
+
+            def ip_route_result_parse(lines)
+              rows = []
+
+              lines.map do |line|
+                values = line.split(/\s/)
+
+                ip_route = Kanrisuru::Core::IP::IPRoute.new(values[0])
+                ip_route.flags = []
+
+                values.each.with_index do |value, index|
+                  case value
+                  when 'via'
+                    ip_route.gateway = values[index + 1]
+                  when 'dev'
+                    ip_route.device = values[index + 1]
+                  when 'proto'
+                    ip_route.protocol = values[index + 1]
+                  when 'src'
+                    ip_route.preferred_source = values[index + 1]
+                  when 'scope'
+                    ip_route.scope = values[index + 1]
+                  when 'flags'
+                    ip_route.flags = values[index + 1]
+                  when 'metric'
+                    ip_route.metric = values[index + 1]
+                  end
+                end
+
+                rows << ip_route
+              end
+
+              rows
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      module Parser
+        class Rule < 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_rule_result_json(command.to_json)
+                rescue JSON::ParserError
+                  ip_rule_result_parse(command.to_a)
+                end
+              else
+                ip_rule_result_parse(command.to_a)
+              end
+            end
+
+            def ip_rule_result_json(rows)
+              rows.map do |row|
+                Kanrisuru::Core::IP::IPRule.new(
+                  row['priority'],
+                  row['src'],
+                  row['table']
+                )
+              end
+            end
+
+            def ip_rule_result_parse(lines)
+              rows = []
+              lines.each do |line|
+                _, priority, string = line.split(/(\d+):\s/)
+                values = string.split(/\s/)
+
+                rule = Kanrisuru::Core::IP::IPRule.new(priority)
+
+                values.each.with_index do |value, index|
+                  case value
+                  when 'from'
+                    rule.source = values[index + 1]
+                  when 'lookup'
+                    rule.table = values[index + 1]
+                  end
+                end
+
+                rows << rule
+              end
+
+              rows
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module IP
+      IPLinkProperty = Struct.new(
+        :index, :name, :flags, :mtu,
+        :qdisc, :state, :group, :qlen,
+        :link_mode, :link_type, :mac_address, :alias,
+        :stats
+      )
+
+      IPAddressProperty = Struct.new(
+        :index, :name, :flags, :mtu,
+        :qdisc, :state, :group, :qlen,
+        :link_type, :mac_address,
+        :address_info, :stats
+      )
+
+      IPAddressInfo = Struct.new(
+        :family, :ip, :broadcast, :scope,
+        :dynamic, :valid_life_time, :preferred_life_time
+      )
+
+      IPAddressLabel = Struct.new(
+        :address, :prefix_length, :label
+      )
+
+      IPRoute = Struct.new(
+        :destination, :gateway, :device, :protocol, :scope, :preferred_source, :metric, :flags
+      )
+
+      IPRule = Struct.new(:priority, :source, :table)
+
+      IPNeighbour = Struct.new(:destination, :device, :lladdr, :state, :stats)
+      IPNeighbourStats = Struct.new(:used, :confirmed, :updated, :probes, :ref_count)
+
+      IPMAddress = Struct.new(:index, :name, :maddr)
+      IPMAddressEntry = Struct.new(:family, :link, :address, :users)
+
+      IPStats = Struct.new(:rx, :tx)
+      IPStatRX = Struct.new(:bytes, :packets, :errors, :dropped, :over_errors, :multicast)
+      IPStatTX = Struct.new(:bytes, :packets, :errors, :dropped, :carrier_errors, :collisions)
+    end
+  end
+end