phut 0.7.7 → 0.7.8

data/lib/phut/open_vswitch.rb

@@ -1,148 +1,150 @@
-require 'active_support/core_ext/class/attribute_accessors'
-require 'pio'
-require 'phut/null_logger'
-require 'phut/setting'
+# frozen_string_literal: true
+
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/module/delegation'
+require 'phut/finder'
+require 'phut/link'
 require 'phut/shell_runner'
+require 'phut/vsctl'
+require 'pio'
 
 module Phut
-  # Open vSwitch controller.
+  # Open vSwitch controller
   # rubocop:disable ClassLength
   class OpenVswitch
-    cattr_accessor(:all, instance_reader: false) { [] }
-
-    def self.create(dpid, port_number = 6653, name = nil,
-                    logger = NullLogger.new)
-      new(dpid, port_number, name, logger).tap do |vswitch|
-        conflict = find_by(name: vswitch.name)
-        fail "The name #{vswitch.name} conflicts with #{conflict}." if conflict
-        all << vswitch
-      end
-    end
+    extend ShellRunner
+    extend Finder
+
+    class_attribute :bridge_prefix
+    self.bridge_prefix = ''
 
-    def self.dump_flows(dpid, port_number = 6653, name = nil,
-                        logger = NullLogger.new)
-      OpenVswitch.new(dpid, port_number, name, logger).dump_flows
+    def self.create(args)
+      found = find_by(name: args[:name]) || find_by(dpid: args[:dpid])
+      raise "a Vswitch #{found.inspect} already exists" if found
+      new(args).__send__ :start
     end
 
-    def self.shutdown(dpid, port_number = 6653, name = nil,
-                      logger = NullLogger.new)
-      OpenVswitch.new(dpid, port_number, name, logger).stop!
+    def self.destroy(name)
+      find_by!(name: name).destroy
     end
 
-    def self.find_by(queries)
-      queries.inject(all) do |memo, (attr, value)|
-        memo.find_all { |vswitch| vswitch.__send__(attr) == value }
-      end.first
+    def self.destroy_all
+      all.each(&:destroy)
     end
 
-    def self.each(&block)
-      all.each(&block)
+    def self.all
+      Vsctl.list_br(bridge_prefix).map do |bridge_attrs|
+        new(bridge_attrs)
+      end.sort_by(&:dpid)
     end
 
     def self.select(&block)
       all.select(&block)
     end
 
-    class AlreadyRunning < StandardError; end
+    def self.dump_flows(name)
+      find_by!(name: name).dump_flows
+    end
 
     include ShellRunner
 
-    attr_reader :dpid
-    alias_method :datapath_id, :dpid
-    attr_reader :network_devices
+    private_class_method :new
 
-    def initialize(dpid, port_number, name, logger)
+    def initialize(dpid:, openflow_version: 1.0, name: nil, tcp_port: 6653)
       @dpid = dpid
-      @port_number = port_number
       @name = name
-      @network_devices = []
-      @logger = logger
-    end
-
-    def name
-      @name || format('%#x', @dpid)
+      @openflow_version = openflow_version
+      @tcp_port = tcp_port
+      @vsctl = Vsctl.new(name: default_name, bridge: default_bridge)
     end
 
     def to_s
       "vswitch (name = #{name}, dpid = #{format('%#x', @dpid)})"
     end
 
-    # rubocop:disable MethodLength
-    # rubocop:disable AbcSize
-    def run
-      sh "sudo ovs-vsctl add-br #{bridge_name}"
-      sh "sudo /sbin/sysctl -w net.ipv6.conf.#{bridge_name}.disable_ipv6=1 -q"
-      @network_devices.each do |each|
-        sh "sudo ovs-vsctl add-port #{bridge_name} #{each}"
-      end
-      sh "sudo ovs-vsctl set bridge #{bridge_name}" \
-         " protocols=#{Pio::OpenFlow.version}" \
-         " other-config:datapath-id=#{dpid_zero_filled}"
-      sh "sudo ovs-vsctl set-controller #{bridge_name} "\
-         "tcp:127.0.0.1:#{@port_number} "\
-         "-- set controller #{bridge_name} connection-mode=out-of-band"
-      sh "sudo ovs-vsctl set-fail-mode #{bridge_name} secure"
-    rescue
-      raise AlreadyRunning, "Open vSwitch (dpid = #{@dpid}) is already running!"
-    end
-    alias_method :start, :run
-    # rubocop:enable MethodLength
-    # rubocop:enable AbcSize
-
-    def stop
-      return unless running?
-      stop!
+    def inspect
+      "#<Vswitch name: \"#{name}\", "\
+      "dpid: #{@dpid.to_hex}, "\
+      "openflow_version: #{openflow_version}, "\
+      "tcp_port: #{tcp_port}>"
     end
 
-    def stop!
-      fail "Open vSwitch (dpid = #{@dpid}) is not running!" unless running?
-      sh "sudo ovs-vsctl del-br #{bridge_name}"
+    def name
+      /^#{bridge_prefix}(\S+)$/ =~ bridge
+      Regexp.last_match(1)
     end
-    alias_method :shutdown, :stop!
 
-    def bring_port_up(port_number)
-      sh "sudo ovs-ofctl mod-port #{bridge_name} #{port_number} up"
-    end
+    delegate :bridge_prefix, to: 'self.class'
+    delegate :bridge, to: :@vsctl
+    delegate :dpid, to: :@vsctl
+    alias datapath_id dpid
+    delegate :openflow_version, to: :@vsctl
+    delegate :tcp_port, to: :@vsctl
+
+    delegate :add_numbered_port, to: :@vsctl
+    delegate :add_port, to: :@vsctl
+    delegate :bring_port_down, to: :@vsctl
+    delegate :bring_port_up, to: :@vsctl
+    delegate :ports, to: :@vsctl
+    delegate :delete_bridge, to: :@vsctl
+    alias destroy delete_bridge
+    delegate :delete_controller, to: :@vsctl
+    alias stop delete_controller
 
-    def bring_port_down(port_number)
-      sh "sudo ovs-ofctl mod-port #{bridge_name} #{port_number} down"
+    def run(port)
+      raise "An Open vSwitch #{inspect} is already running" if @vsctl.tcp_port
+      @vsctl.tcp_port = port
     end
 
+    # rubocop:disable MethodLength
+    # rubocop:disable LineLength
     def dump_flows
-      output =
-        `sudo ovs-ofctl dump-flows #{bridge_name} -O #{Pio::OpenFlow.version}`
-      output.split("\n").inject('') do |memo, each|
-        memo + ((/^(NXST|OFPST)_FLOW reply/=~ each) ? '' : each.lstrip + "\n")
+      openflow_version = case @vsctl.openflow_version
+                         when 1.0
+                           :OpenFlow10
+                         when 1.3
+                           :OpenFlow13
+                         else
+                           raise "Unknown OpenFlow version: #{@vsctl.openflow_version}"
+                         end
+      sudo("ovs-ofctl dump-flows #{bridge} -O #{openflow_version}").
+        split("\n").inject('') do |memo, each|
+        memo + (/^(NXST|OFPST)_FLOW reply/ =~ each ? '' : each.lstrip + "\n")
       end
     end
+    # rubocop:enable MethodLength
+    # rubocop:enable LineLength
 
-    def running?
-      system "sudo ovs-vsctl br-exists #{bridge_name}"
-    end
-
-    def add_network_device(network_device)
-      network_device.port_number = @network_devices.size + 1
-      @network_devices << network_device
+    def <=>(other)
+      dpid <=> other.dpid
     end
 
     private
 
-    def bridge_name
-      'br' + name
-    end
-
-    def restart
-      stop
-      start
+    # rubocop:disable LineLength
+    def default_name
+      if @name
+        if (bridge_prefix + @name).length > Vsctl::MAX_BRIDGE_NAME_LENGTH
+          raise "Name '#{@name}' is too long (should be <= #{Vsctl::MAX_BRIDGE_NAME_LENGTH - bridge_prefix.length} chars)"
+        end
+        return @name
+      end
+      raise 'DPID is not set' unless @dpid
+      format('%#x', @dpid)
     end
+    # rubocop:enable LineLength
 
-    def network_device
-      "vsw_#{name}"
+    def default_bridge
+      bridge_prefix + default_name
     end
 
-    def dpid_zero_filled
-      hex = format('%x', @dpid)
-      '0' * (16 - hex.length) + hex
+    def start
+      @vsctl.add_bridge
+      @vsctl.openflow_version = @openflow_version
+      @vsctl.dpid = @dpid
+      @vsctl.tcp_port = @tcp_port
+      @vsctl.set_fail_mode_secure
+      self
     end
   end
   # rubocop:enable ClassLength

data/lib/phut/parser.rb

@@ -1,19 +1,50 @@
-require 'phut/configuration'
-require 'phut/null_logger'
+# frozen_string_literal: true
+
+require 'phut/link'
 require 'phut/syntax'
+require 'phut/vhost'
+require 'phut/vswitch'
 
 module Phut
   # Configuration DSL parser.
   class Parser
-    def initialize(logger = NullLogger.new)
-      @logger = logger
+    def initialize(file)
+      @file = file
+      @netns = []
+    end
+
+    def parse
+      Syntax.new(@netns).instance_eval IO.read(@file), @file
+      Link.all.each do |link|
+        Vswitch.all.each do |vswitch|
+          device = link.device(vswitch.name)
+          vswitch.add_port device if device
+        end
+      end
+      Vhost.all.each(&:set_default_arp_table)
+      Vhost.connect_link
+      update_netns_interfaces
+    end
+
+    private
+
+    def update_netns_interfaces
+      @netns.each do |each|
+        netns =
+          Netns.create(name: each[:name],
+                       ip_address: each[:ip], netmask: each[:netmask],
+                       route: { net: each[:net], gateway: each[:gateway] },
+                       mac_address: each[:mac_address], vlan: each[:vlan])
+        netns.device = find_network_device(each.name)
+      end
     end
 
-    def parse(file)
-      Configuration.new do |config|
-        Syntax.new(config, @logger).instance_eval IO.read(file), file
-        config.update_connections
+    def find_network_device(name)
+      Link.all.each do |each|
+        device = each.device(name)
+        return device if device
       end
+      nil
     end
   end
 end

data/lib/phut/raw_socket.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'socket'
 
 module Phut
@@ -19,8 +21,10 @@ module Phut
         end
     end
 
+    # rubocop:disable MethodMissing
     def method_missing(method, *args)
       @socket.__send__ method, *args
     end
+    # rubocop:enable MethodMissing
   end
 end

data/lib/phut/route.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'phut/shell_runner'
+
+module Phut
+  # routing table entry
+  class Route
+    extend ShellRunner
+
+    def self.read(netns)
+      sudo("ip netns exec #{netns} route -n").split("\n").each do |each|
+        match = /^(\S+)\s+(\S+)\s+\S+\s+UG\s+/.match(each)
+        next unless match
+        return new(net: match[1], gateway: match[2])
+      end
+      nil
+    end
+
+    attr_reader :net
+    attr_reader :gateway
+
+    def initialize(net:, gateway:)
+      @net = net
+      @gateway = gateway
+    end
+
+    include ShellRunner
+
+    def add(netns)
+      return unless @net && @gateway
+      sudo "ip netns exec #{netns} route add -net #{@net} gw #{@gateway}"
+    end
+  end
+end

data/lib/phut/setting.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'logger'
 require 'tmpdir'
 
 # Base module.
@@ -6,10 +9,14 @@ module Phut
   class Setting
     DEFAULTS = {
       root: File.expand_path(File.join(File.dirname(__FILE__), '..', '..')),
+      logger: Logger.new($stderr).tap do |logger|
+                logger.formatter = proc { |_sev, _dtm, _name, msg| msg + "\n" }
+                logger.level = Logger::INFO
+              end,
       pid_dir: Dir.tmpdir,
       log_dir: Dir.tmpdir,
       socket_dir: Dir.tmpdir
-    }
+    }.freeze
 
     def initialize
       @options = DEFAULTS.dup
@@ -19,12 +26,20 @@ module Phut
       @options.fetch :root
     end
 
+    def logger
+      @options.fetch :logger
+    end
+
+    def logger=(logger)
+      @options[:logger] = logger
+    end
+
     def pid_dir
       @options.fetch :pid_dir
     end
 
     def pid_dir=(path)
-      fail "No such directory: #{path}" unless FileTest.directory?(path)
+      raise "No such directory: #{path}" unless FileTest.directory?(path)
       @options[:pid_dir] = File.expand_path(path)
     end
 
@@ -33,7 +48,7 @@ module Phut
     end
 
     def log_dir=(path)
-      fail "No such directory: #{path}" unless FileTest.directory?(path)
+      raise "No such directory: #{path}" unless FileTest.directory?(path)
       @options[:log_dir] = File.expand_path(path)
     end
 
@@ -42,7 +57,7 @@ module Phut
     end
 
     def socket_dir=(path)
-      fail "No such directory: #{path}" unless FileTest.directory?(path)
+      raise "No such directory: #{path}" unless FileTest.directory?(path)
       @options[:socket_dir] = File.expand_path(path)
     end
   end
@@ -50,8 +65,10 @@ module Phut
   SettingSingleton = Setting.new
 
   class << self
+    # rubocop:disable MethodMissing
     def method_missing(method, *args)
       SettingSingleton.__send__ method, *args
     end
+    # rubocop:enable MethodMissing
   end
 end

data/lib/phut/shell_runner.rb

@@ -1,9 +1,20 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'phut/setting'
+
 module Phut
   # Provides sh method.
   module ShellRunner
+    def sudo(command)
+      sh "sudo #{command}"
+    end
+
     def sh(command)
-      system(command) || fail("#{command} failed.")
-      @logger.debug(command) if @logger
+      Phut.logger.debug(command)
+      stdout, stderr, status = Open3.capture3(command)
+      raise %(Command '#{command}' failed: #{stderr}) unless status.success?
+      stdout
     end
   end
 end