phut 0.7.7 → 0.7.8

data/lib/phut/syntax.rb

@@ -1,36 +1,53 @@
+# frozen_string_literal: true
+
+require 'phut/link'
 require 'phut/netns'
 require 'phut/syntax/netns_directive'
 require 'phut/syntax/vhost_directive'
 require 'phut/syntax/vswitch_directive'
 require 'phut/vhost'
-require 'phut/virtual_link'
 
 module Phut
   # DSL syntax definitions.
   class Syntax
-    def initialize(config, logger)
-      @config = config
-      @logger = logger
+    def initialize(netns)
+      @netns = netns
     end
 
+    # rubocop:disable MethodLength
+    # rubocop:disable LineLength
     def vswitch(alias_name = nil, &block)
       attrs = VswitchDirective.new(alias_name, &block)
-      OpenVswitch.create(attrs[:dpid], attrs[:port], attrs[:name], @logger)
+      openflow_version = case Pio::OpenFlow.version
+                         when :OpenFlow10
+                           1.0
+                         when :OpenFlow13
+                           1.3
+                         else
+                           raise "Unknown OpenFlow version: #{Pio::OpenFlow.version}"
+                         end
+      Vswitch.create(dpid: attrs[:dpid],
+                     name: attrs[:name],
+                     tcp_port: attrs[:port],
+                     openflow_version: openflow_version)
     end
+    # rubocop:enable MethodLength
+    # rubocop:enable LineLength
 
-    def vhost(alias_name = nil, &block)
-      attrs = VhostDirective.new(alias_name, &block)
-      Vhost.create(attrs[:ip], attrs[:mac], attrs[:promisc], attrs[:name],
-                   @logger)
+    def vhost(name = nil, &block)
+      attrs = VhostDirective.new(name, &block)
+      Vhost.create(name: attrs[:name],
+                   ip_address: attrs[:ip],
+                   mac_address: attrs[:mac],
+                   promisc: attrs[:promisc])
     end
 
-    def netns(name, &block)
-      attrs = NetnsDirective.new(name, &block)
-      Netns.create(attrs, attrs[:name], @logger)
+    def link(name_a, name_b)
+      Link.create(name_a, name_b)
     end
 
-    def link(name_a, name_b)
-      VirtualLink.create(name_a, name_b, @logger)
+    def netns(name, &block)
+      @netns << NetnsDirective.new(name, &block)
     end
   end
 end

data/lib/phut/syntax/directive.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Phut
   class Syntax
     # Common DSL directive
@@ -9,8 +11,14 @@ module Phut
       end
 
       def [](key)
-        @attributes.fetch(key)
+        @attributes[key]
+      end
+
+      # rubocop:disable MethodMissing
+      def method_missing(name)
+        @attributes.fetch name.to_sym
       end
+      # rubocop:enable MethodMissing
     end
   end
 end

data/lib/phut/syntax/netns_directive.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'phut/syntax/directive'
 
 module Phut
@@ -7,8 +9,9 @@ module Phut
       attribute :netmask
 
       def initialize(alias_name, &block)
-        @attributes = { name: alias_name }
-        instance_eval(&block)
+        @attributes = { name: alias_name,
+                        netmask: '255.255.255.255' }
+        instance_eval(&block) if block
       end
 
       def ip(value)
@@ -20,6 +23,14 @@ module Phut
         @attributes[:net] = options.fetch(:net)
         @attributes[:gateway] = options.fetch(:gateway)
       end
+
+      def mac(value)
+        @attributes[:mac_address] = value
+      end
+
+      def vlan(value)
+        @attributes[:vlan] = value
+      end
     end
   end
 end

data/lib/phut/syntax/vhost_directive.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'phut/syntax/directive'
 
 module Phut

data/lib/phut/syntax/vswitch_directive.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'phut/syntax/directive'
 
 module Phut
@@ -20,7 +22,7 @@ module Phut
         @attributes[:dpid] = dpid
         @attributes[:name] ||= format('%#x', @attributes[:dpid])
       end
-      alias_method :datapath_id, :dpid
+      alias datapath_id dpid
     end
   end
 end

data/lib/phut/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 # Base module.
 module Phut
-  VERSION = '0.7.7'
+  VERSION = '0.7.8'
 end

data/lib/phut/veth.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'ipaddr'
+require 'phut/shell_runner'
+
+module Phut
+  # Virtual eth device
+  class Veth
+    PREFIX = 'L'
+
+    extend ShellRunner
+
+    # rubocop:disable Metrics/AbcSize
+    def self.all
+      link_devices = sh('ip link show').split("\n").map do |each|
+        case each
+        when /^\d+: #{PREFIX}(\d+)_(\h{8})[@:]/
+          ip_addr = IPAddr.new($LAST_MATCH_INFO[2].hex, Socket::AF_INET)
+          new(name: ip_addr, link_id: $LAST_MATCH_INFO[1].to_i)
+        when /^\d+: #{PREFIX}(\d+)_([^:]*?)[@:]/
+          new(name: $LAST_MATCH_INFO[2], link_id: $LAST_MATCH_INFO[1].to_i)
+        end
+      end
+      (Netns.all.map(&:device) + link_devices).compact
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    attr_reader :link_id
+
+    def initialize(name:, link_id:)
+      @name = valid_ipaddress?(name) ? IPAddr.new(name, Socket::AF_INET) : name
+      @link_id = link_id
+    end
+
+    def name
+      @name.to_s
+    end
+
+    def device
+      if @name.is_a?(IPAddr)
+        hex = format('%x', @name.to_i)
+        "#{PREFIX}#{@link_id}_#{hex}"
+      else
+        "#{PREFIX}#{@link_id}_#{@name}"
+      end
+    end
+    alias to_s device
+    alias to_str device
+
+    def ==(other)
+      name == other.name && link_id == other.link_id
+    end
+
+    def <=>(other)
+      device <=> other.device
+    end
+
+    private
+
+    def valid_ipaddress?(string)
+      IPAddr.new(string, Socket::AF_INET)
+      true
+    rescue
+      false
+    end
+  end
+end

data/lib/phut/vhost.rb

@@ -1,102 +1,143 @@
-require 'active_support/core_ext/class/attribute_accessors'
-require 'phut/null_logger'
+# frozen_string_literal: true
+
+require 'phut/finder'
 require 'phut/setting'
 require 'phut/shell_runner'
-require 'pio/mac'
+require 'phut/vhost_daemon'
 
 module Phut
-  # An interface class to vhost emulation utility program.
+  # Virtual host for NetTester
+  # rubocop:disable ClassLength
   class Vhost
-    cattr_accessor(:all, instance_reader: false) { [] }
-
-    def self.create(ip_address, mac_address, promisc, name = nil,
-                    logger = NullLogger.new)
-      new(ip_address, mac_address, promisc, name, logger).tap do |vhost|
-        conflict = find_by(name: vhost.name)
-        fail "The name #{vhost.name} conflicts with #{conflict}." if conflict
-        all << vhost
+    extend Finder
+
+    attr_reader :ip_address
+    attr_reader :mac_address
+
+    def self.all
+      Dir.glob(File.join(Phut.socket_dir, 'vhost.*.ctl')).map do |each|
+        vhost = DRbObject.new_with_uri("drbunix:#{each}")
+        new(name: vhost.name,
+            ip_address: vhost.ip_address,
+            mac_address: vhost.mac_address,
+            device: vhost.device)
       end
     end
 
-    # This method smells of :reek:NestedIterators but ignores them
-    def self.find_by(queries)
-      queries.inject(all) do |memo, (attr, value)|
-        memo.find_all { |vhost| vhost.__send__(attr) == value }
-      end.first
+    def self.create(*args)
+      new(*args).tap(&:start)
     end
 
-    def self.each(&block)
-      all.each(&block)
+    def self.destroy_all
+      ::Dir.glob(File.join(Phut.socket_dir, 'vhost.*.ctl')).each do |each|
+        /vhost\.(\S+)\.ctl/=~ each
+        VhostDaemon.process(Regexp.last_match(1), Phut.socket_dir).kill
+      end
     end
 
-    include ShellRunner
-
-    attr_reader :ip_address
-    attr_reader :mac_address
-    attr_accessor :network_device
+    def self.connect_link
+      all.each do |each|
+        Link.all.each do |link|
+          device = link.device(each.name)
+          each.device = device if device
+        end
+      end
+    end
 
-    def initialize(ip_address, mac_address, promisc, name, logger)
-      @ip_address = ip_address
-      @promisc = promisc
+    # rubocop:disable ParameterLists
+    def initialize(name:, ip_address:, mac_address:,
+                   device: nil, promisc: false, arp_entries: nil)
       @name = name
+      @ip_address = ip_address
       @mac_address = mac_address
-      @logger = logger
+      @device = device
+      @promisc = promisc
+      @arp_entries = arp_entries
     end
+    # rubocop:enable ParameterLists
+
+    include ShellRunner
 
     def name
       @name || @ip_address
     end
 
-    def to_s
-      "vhost (name = #{name}, IP address = #{@ip_address})"
-    end
-
-    def run(all_hosts = Vhost.all)
-      @all_hosts ||= all_hosts
+    # rubocop:disable LineLength
+    def start
       if ENV['rvm_path']
         sh "rvmsudo vhost run #{run_options}"
       else
-        vhost = File.join(__dir__, '..', '..', 'bin', 'vhost')
-        sh "bundle exec sudo #{vhost} run #{run_options}"
+        vhost = File.expand_path('../../bin/vhost', __dir__)
+        sh "bundle exec sudo env PATH=#{ENV['PATH']} #{vhost} run #{run_options}"
       end
+      sleep 1
+      self.device = @device if @device
+    end
+    alias run start
+    # rubocop:enable LineLength
+
+    def running?
+      VhostDaemon.process(name, Phut.socket_dir).running?
     end
 
     def stop
-      return unless running?
-      stop!
+      VhostDaemon.process(name, Phut.socket_dir).stop
     end
 
-    def stop!
-      fail "vhost (name = #{name}) is not running!" unless running?
-      sh "vhost stop -n #{name} -S #{Phut.socket_dir}"
+    def kill
+      sh "bundle exec vhost stop -n #{name} -S #{Phut.socket_dir}"
+      sleep 1
     end
 
-    def running?
-      FileTest.exists?(pid_file)
+    def device
+      VhostDaemon.process(name, Phut.socket_dir).device
+    end
+
+    def device=(device_name)
+      VhostDaemon.process(name, Phut.socket_dir).device = device_name
+    end
+
+    def send_packet(destination)
+      VhostDaemon.process(name, Phut.socket_dir).send_packets(destination, 1)
+    end
+
+    def packets_sent_to(dest)
+      VhostDaemon.process(name, Phut.socket_dir).stats[:tx].select do |each|
+        (each[:destination_mac].to_s == dest.mac_address) &&
+          (each[:destination_ip_address].to_s == dest.ip_address)
+      end
+    end
+
+    def packets_received_from(source)
+      VhostDaemon.process(name, Phut.socket_dir).stats[:rx].select do |each|
+        (each[:source_mac].to_s == source.mac_address) &&
+          (each[:source_ip_address].to_s == source.ip_address)
+      end
+    end
+
+    def set_default_arp_table
+      arp_table = Vhost.all.each_with_object({}) do |each, hash|
+        hash[each.ip_address] = each.mac_address
+      end
+      VhostDaemon.process(name, Phut.socket_dir).arp_table = arp_table
+    end
+
+    def to_s
+      "vhost (name = #{name}, IP address = #{@ip_address})"
     end
 
     private
 
     def run_options
       ["-n #{name}",
-       "-I #{@network_device}",
-       "-i #{@ip_address}",
-       "-m #{@mac_address}",
-       "-a #{arp_entries}",
+       "-i #{ip_address}",
+       "-m #{mac_address}",
+       @arp_entries ? "-a #{@arp_entries}" : nil,
        @promisc ? '--promisc' : nil,
-       "-P #{Phut.pid_dir}",
        "-L #{Phut.log_dir}",
+       "-P #{Phut.pid_dir}",
        "-S #{Phut.socket_dir}"].compact.join(' ')
     end
-
-    def arp_entries
-      @all_hosts.map do |each|
-        "#{each.ip_address}/#{each.mac_address}"
-      end.join(',')
-    end
-
-    def pid_file
-      "#{Phut.pid_dir}/vhost.#{name}.pid"
-    end
   end
+  # rubocop:enable ClassLength
 end

data/lib/phut/vhost_daemon.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'drb'
 require 'logger'
 require 'phut/raw_socket'
@@ -16,22 +18,55 @@ module Phut
     end
 
     def initialize(options)
-      @options = options
+      @options = options.dup
+      @options[:device] = @options.fetch(:interface)
+      @options[:log_dir] = File.expand_path(@options[:log_dir])
+      @options[:pid_dir] = File.expand_path(@options[:pid_dir])
+      @options[:socket_dir] = File.expand_path(@options[:socket_dir])
       reset_stats
     end
 
+    def name
+      @options.fetch :name
+    end
+
+    def ip_address
+      @options.fetch :ip_address
+    end
+
+    def mac_address
+      @options.fetch :mac_address
+    end
+
+    def device
+      @options[:device]
+    end
+
+    def device=(name)
+      @options[:device] = name
+    end
+
     def run
       start_logging
       create_pid_file
       start_daemon
+      @stop = false
     rescue
       shutdown
     end
 
+    def running?
+      FileTest.exists?(pid_file)
+    end
+
     def stop
       @stop = true
     end
 
+    def kill
+      @kill = true
+    end
+
     def send_packets(dest, npackets)
       return unless lookup_arp_table(dest.ip_address)
       udp = create_udp_packet(dest)
@@ -50,19 +85,23 @@ module Phut
       @packets_received = []
     end
 
+    def arp_table=(arp_table)
+      @options[:arp_table] = arp_table
+    end
+
     private
 
     def start_logging
       @logger = Logger.new(File.open(log_file, 'a'))
       @logger.info("#{@options.fetch(:name)} started " \
-                   "(interface = #{@options.fetch(:interface)}," \
+                   "(interface = #{@options.fetch(:device)}," \
                    " IP address = #{@options.fetch(:ip_address)}," \
                    " MAC address = #{@options.fetch(:mac_address)}," \
                    " arp_entries = #{@options.fetch(:arp_entries)})")
     end
 
     def raw_socket
-      @raw_socket ||= RawSocket.new(@options.fetch(:interface))
+      @raw_socket ||= RawSocket.new(@options.fetch(:device))
     end
 
     def lookup_arp_table(ip_address)
@@ -89,11 +128,17 @@ module Phut
     end
 
     # rubocop:disable MethodLength
+    # rubocop:disable AbcSize
     def read_loop
       loop do
+        unless @options.fetch(:device)
+          sleep 0.1
+          next
+        end
         begin
           raw_data, = raw_socket.recvfrom(8192)
           udp = Pio::Udp.read(raw_data)
+          next if @stop
           unless @options[:promisc]
             next if udp.destination_ip_address != @options.fetch(:ip_address)
           end
@@ -106,6 +151,7 @@ module Phut
       end
     end
     # rubocop:enable MethodLength
+    # rubocop:enable AbcSize
 
     def start_daemon
       Process.daemon
@@ -118,7 +164,7 @@ module Phut
       unix_domain_socket =
         self.class.unix_domain_socket(@options.fetch(:name),
                                       @options.fetch(:socket_dir))
-      DRb.start_service(unix_domain_socket, self, UNIXFileMode: 0666)
+      DRb.start_service(unix_domain_socket, self, UNIXFileMode: 0o666)
       Thread.start { read_loop }.abort_on_exception = true
       DRb.thread.join
     end
@@ -128,7 +174,7 @@ module Phut
       @logger.info 'Shutting down...'
       FileUtils.rm pid_file if running?
       DRb.stop_service
-      fail $ERROR_INFO if $ERROR_INFO
+      raise $ERROR_INFO if $ERROR_INFO
     end
 
     def trap_sigint
@@ -138,14 +184,14 @@ module Phut
 
     def shutdown_loop
       loop do
-        break if @stop
+        break if @kill
         sleep 0.1
       end
       shutdown
     end
 
     def create_pid_file
-      fail "#{@options.fetch(:name)} is already running." if running?
+      raise "#{@options.fetch(:name)} is already running." if running?
       update_pid_file
     end
 
@@ -153,10 +199,6 @@ module Phut
       File.open(pid_file, 'w') { |file| file << Process.pid }
     end
 
-    def running?
-      FileTest.exists?(pid_file)
-    end
-
     def pid_file
       File.join @options.fetch(:pid_dir), "vhost.#{@options.fetch(:name)}.pid"
     end