phut 0.1.0

data/lib/phut/configuration.rb

@@ -0,0 +1,64 @@
+require 'forwardable'
+require 'phut/null_logger'
+require 'phut/open_vswitch'
+
+module Phut
+  # Parsed DSL data.
+  class Configuration
+    extend Forwardable
+
+    def_delegators :@all, :fetch
+
+    def initialize(logger = NullLogger.new)
+      @all = {}
+      @logger = logger
+    end
+
+    def vswitches
+      @all.values.select { |each| each.is_a? OpenVswitch }
+    end
+
+    def vhosts
+      @all.values.select { |each| each.is_a? Phost }
+    end
+
+    def links
+      @all.values.select { |each| each.is_a? VirtualLink }
+    end
+
+    def run
+      links.each(&:run)
+      vswitches.each(&:run)
+      vhosts.each { |each| each.run vhosts }
+    end
+
+    def stop
+      vswitches.each(&:maybe_stop)
+      vhosts.each(&:maybe_stop)
+      links.each(&:maybe_stop)
+    end
+
+    def add_vswitch(name, attrs)
+      check_name_conflict name
+      @all[name] = OpenVswitch.new(attrs[:dpid], name, @logger)
+    end
+
+    def add_vhost(name, attrs)
+      check_name_conflict name
+      @all[name] = Phost.new(attrs[:ip], attrs[:promisc], name, @logger)
+    end
+
+    # This method smells of :reek:LongParameterList
+    def add_link(name_a, device_a, name_b, device_b)
+      @all[[name_a, name_b]] =
+        VirtualLink.new(name_a, device_a, name_b, device_b, @logger)
+    end
+
+    private
+
+    def check_name_conflict(name)
+      conflict = @all[name]
+      fail "The name #{name} conflicts with #{conflict}." if conflict
+    end
+  end
+end

data/lib/phut/null_logger.rb

@@ -0,0 +1,14 @@
+require 'logger'
+
+module Phut
+  # Null logger
+  class NullLogger < Logger
+    def initialize(*_args)
+      # noop
+    end
+
+    def add(*_args, &_block)
+      # noop
+    end
+  end
+end

data/lib/phut/open_vswitch.rb

@@ -0,0 +1,116 @@
+require 'phut/null_logger'
+require 'phut/setting'
+require 'phut/shell_runner'
+
+module Phut
+  # Open vSwitch controller.
+  class OpenVswitch
+    include ShellRunner
+
+    OPENFLOWD =
+      "#{Phut.root}/vendor/openvswitch-1.2.2.trema1/tests/test-openflowd"
+    OFCTL =
+      "#{Phut.root}/vendor/openvswitch-1.2.2.trema1/utilities/ovs-ofctl"
+
+    attr_reader :dpid
+    alias_method :datapath_id, :dpid
+    attr_writer :interfaces
+
+    def initialize(dpid, name = nil, logger = NullLogger.new)
+      @dpid = dpid
+      @name = name
+      @interfaces = []
+      @logger = logger
+    end
+
+    def name
+      @name || format('%#x', @dpid)
+    end
+
+    def to_s
+      "vswitch (name = #{name}, dpid = #{format('%#x', @dpid)})"
+    end
+
+    def run
+      sh "sudo #{OPENFLOWD} #{options.join ' '}"
+    rescue
+      raise "Open vSwitch (dpid = #{@dpid}) is already running!"
+    end
+    alias_method :start, :run
+
+    def stop
+      fail "Open vSwitch (dpid = #{@dpid}) is not running!" unless running?
+      pid = IO.read(pid_file).chomp
+      sh "sudo kill #{pid}"
+    end
+    alias_method :shutdown, :stop
+
+    def maybe_stop
+      return unless running?
+      stop
+    end
+
+    def bring_port_up(port_number)
+      sh "sudo #{OFCTL} mod-port #{network_device} #{port_number} up"
+    end
+
+    def bring_port_down(port_number)
+      sh "sudo #{OFCTL} mod-port #{network_device} #{port_number} down"
+    end
+
+    def dump_flows
+      sh "sudo #{OFCTL} dump-flows #{network_device}"
+    end
+
+    def running?
+      FileTest.exists?(pid_file)
+    end
+
+    private
+
+    def restart
+      stop
+      start
+    end
+
+    def pid_file
+      "#{Phut.pid_dir}/open_vswitch.#{name}.pid"
+    end
+
+    def network_device
+      "vsw_#{name}"
+    end
+
+    # rubocop:disable MethodLength
+    def options
+      %W(--detach
+         --out-of-band
+         --fail=closed
+         --inactivity-probe=180
+         --rate-limit=40000
+         --burst-limit=20000
+         --pidfile=#{pid_file}
+         --verbose=ANY:file:#{logging_level}
+         --verbose=ANY:console:err
+         --log-file=#{Phut.log_dir}/open_vswitch.#{name}.log
+         --datapath-id=#{dpid_zero_filled}
+         --unixctl=#{Phut.socket_dir}/open_vswitch.#{name}.ctl
+         netdev@#{network_device} tcp:127.0.0.1:6633) +
+        ports_option
+    end
+    # rubocop:enable MethodLength
+
+    def dpid_zero_filled
+      hex = format('%x', @dpid)
+      '0' * (16 - hex.length) + hex
+    end
+
+    def logging_level
+      @logger.level == Logger::DEBUG ? 'dbg' : 'info'
+    end
+
+    def ports_option
+      @interfaces.empty? ? [] : ["--ports=#{@interfaces.join(',')}"]
+    end
+  end
+end

data/lib/phut/parser.rb

@@ -0,0 +1,51 @@
+require 'phut/configuration'
+require 'phut/null_logger'
+require 'phut/syntax'
+
+module Phut
+  # Configuration DSL parser.
+  class Parser
+    def initialize(logger = NullLogger.new)
+      @config = Configuration.new(logger)
+    end
+
+    def parse(file)
+      Syntax.new(@config).instance_eval IO.read(file), file
+      assign_vswitch_interfaces
+      assign_vhost_interface
+      @config
+    end
+
+    private
+
+    def assign_vswitch_interfaces
+      @config.vswitches.each do |each|
+        each.interfaces = find_interfaces_by_name(each.name)
+      end
+    end
+
+    def assign_vhost_interface
+      @config.vhosts.each do |each|
+        each.interface = find_host_interface_by_name(each.name)
+      end
+    end
+
+    def find_interfaces_by_name(name)
+      find_device_by_name(name, :name_a, :device_a) +
+        find_device_by_name(name, :name_b, :device_b)
+    end
+
+    def find_host_interface_by_name(name)
+      find_interfaces_by_name(name).tap do |interface|
+        fail "No link found for host #{name}" if interface.empty?
+        fail "Multiple links connect to host #{name}" if interface.size > 1
+      end.first
+    end
+
+    def find_device_by_name(name, name_type, device_type)
+      @config.links.select do |each|
+        each.__send__(name_type) == name
+      end.map(&device_type)
+    end
+  end
+end

data/lib/phut/phost.rb

@@ -0,0 +1,92 @@
+require 'phut/cli'
+require 'phut/null_logger'
+require 'phut/setting'
+require 'phut/shell_runner'
+require 'pio/mac'
+
+module Phut
+  # An interface class to phost emulation utility program.
+  class Phost
+    include ShellRunner
+
+    attr_reader :ip
+    attr_reader :mac
+    attr_accessor :interface
+
+    def initialize(ip_address, promisc, name = nil, logger = NullLogger.new)
+      @ip = ip_address
+      @promisc = promisc
+      @name = name
+      @mac = Pio::Mac.new(rand(0xffffffffffff + 1))
+      @logger = logger
+    end
+
+    def name
+      @name || @ip
+    end
+
+    def to_s
+      "vhost (name = #{name}, ip = #{@ip})"
+    end
+
+    def run(hosts = [])
+      sh "sudo #{executable} #{options.join ' '}"
+      sleep 1
+      set_ip_and_mac_address
+      maybe_enable_promisc
+      add_arp_entries hosts
+    end
+
+    def stop
+      fail "phost (name = #{name}) is not running!" unless running?
+      pid = IO.read(pid_file)
+      sh "sudo kill #{pid}"
+    end
+
+    def maybe_stop
+      return unless running?
+      stop
+    end
+
+    def netmask
+      '255.255.255.255'
+    end
+
+    def running?
+      FileTest.exists?(pid_file)
+    end
+
+    private
+
+    def set_ip_and_mac_address
+      Phut::Cli.new(self, @logger).set_ip_and_mac_address
+    end
+
+    def maybe_enable_promisc
+      return unless @promisc
+      Phut::Cli.new(self).enable_promisc
+    end
+
+    def add_arp_entries(hosts)
+      hosts.each do |each|
+        Phut::Cli.new(self).add_arp_entry each
+      end
+    end
+
+    def pid_file
+      "#{Phut.pid_dir}/phost.#{name}.pid"
+    end
+
+    def executable
+      "#{Phut.root}/vendor/phost/src/phost"
+    end
+
+    def options
+      %W(-p #{Phut.pid_dir}
+         -l #{Phut.log_dir}
+         -n #{name}
+         -i #{interface}
+         -D)
+    end
+  end
+end

data/lib/phut/setting.rb

@@ -0,0 +1,54 @@
+require 'tmpdir'
+
+# Base module.
+module Phut
+  # Central configuration repository.
+  class Setting
+    DEFAULTS = {
+      root: File.expand_path(File.join(__dir__, '..', '..')),
+      pid_dir: Dir.tmpdir,
+      log_dir: Dir.tmpdir,
+      socket_dir: Dir.tmpdir
+    }
+
+    def initialize
+      @options = DEFAULTS.dup
+    end
+
+    def root
+      @options.fetch :root
+    end
+
+    def pid_dir
+      @options.fetch :pid_dir
+    end
+
+    def pid_dir=(path)
+      @options[:pid_dir] = File.expand_path(path)
+    end
+
+    def log_dir
+      @options.fetch :log_dir
+    end
+
+    def log_dir=(path)
+      @options[:log_dir] = File.expand_path(path)
+    end
+
+    def socket_dir
+      @options.fetch :socket_dir
+    end
+
+    def socket_dir=(path)
+      @options[:socket_dir] = File.expand_path(path)
+    end
+  end
+
+  SettingSingleton = Setting.new
+
+  class << self
+    def method_missing(method, *args)
+      SettingSingleton.__send__ method, *args
+    end
+  end
+end

data/lib/phut/shell_runner.rb

@@ -0,0 +1,9 @@
+module Phut
+  # Provides sh method.
+  module ShellRunner
+    def sh(command)
+      system(command) || fail("#{command} failed.")
+      @logger.debug(command) if @logger
+    end
+  end
+end

data/lib/phut/syntax.rb

@@ -0,0 +1,123 @@
+require 'phut/phost'
+require 'phut/virtual_link'
+
+module Phut
+  # DSL syntax definitions.
+  class Syntax
+    # The 'vswitch(name) { ...attributes... }' directive.
+    class VswitchDirective
+      def initialize(alias_name, &block)
+        @attributes = { name: alias_name }
+        instance_eval(&block)
+      end
+
+      def dpid(value)
+        dpid = if value.is_a?(String) && /^0x/=~ value
+                 value.hex
+               else
+                 value.to_i
+               end
+        @attributes[:dpid] = dpid
+        @attributes[:name] ||= format('%#x', @attributes[:dpid])
+      end
+      alias_method :datapath_id, :dpid
+
+      def [](key)
+        @attributes[key]
+      end
+    end
+
+    # The 'vhost(name) { ...attributes... }' directive.
+    class VhostDirective
+      # Generates an unused IP address
+      class UnusedIpAddress
+        def initialize
+          @index = 0
+        end
+
+        def generate
+          @index += 1
+          "192.168.0.#{@index}"
+        end
+      end
+
+      UnusedIpAddressSingleton = UnusedIpAddress.new
+
+      def initialize(alias_name, &block)
+        @attributes = { name: alias_name }
+        if block
+          instance_eval(&block) if block
+        else
+          @attributes[:ip] = UnusedIpAddressSingleton.generate
+        end
+      end
+
+      def ip(value)
+        @attributes[:ip] = value
+        @attributes[:name] ||= value
+      end
+
+      def promisc(on_off)
+        @attributes[:promisc] = on_off
+      end
+
+      def [](key)
+        @attributes[key]
+      end
+    end
+
+    # The 'link name_a, name_b' directive.
+    class LinkDirective
+      # Generates an unique Link ID
+      class LinkId
+        def initialize
+          init
+        end
+
+        def init
+          @index = 0
+        end
+
+        def generate
+          @index += 1
+        end
+      end
+
+      LinkIdSingleton = LinkId.new
+
+      def initialize(name_a, name_b, link_id)
+        @attributes = {}
+        @attributes[:name_a] = name_a
+        @attributes[:name_b] = name_b
+        link_id = LinkIdSingleton.generate
+        @attributes[:device_a] = "link#{link_id}-0"
+        @attributes[:device_b] = "link#{link_id}-1"
+      end
+
+      def [](key)
+        @attributes[key]
+      end
+    end
+
+    def initialize(config)
+      @config = config
+      LinkDirective::LinkIdSingleton.init
+    end
+
+    def vswitch(alias_name = nil, &block)
+      attrs = VswitchDirective.new(alias_name, &block)
+      @config.add_vswitch attrs[:name], attrs
+    end
+
+    def vhost(alias_name = nil, &block)
+      attrs = VhostDirective.new(alias_name, &block)
+      @config.add_vhost attrs[:name], attrs
+    end
+
+    def link(name_a, name_b)
+      link_id = @config.links.size
+      attrs = LinkDirective.new(name_a, name_b, link_id)
+      @config.add_link name_a, attrs[:device_a], name_b, attrs[:device_b]
+    end
+  end
+end