trema 0.4.7 → 0.4.8

data/lib/trema.rb

@@ -0,0 +1,4 @@
+require 'trema/controller'
+require 'trema/dirs'
+require 'trema/drb'
+require 'trema/version'

data/lib/trema/command.rb

@@ -0,0 +1,184 @@
+require 'English'
+
+module Trema
+  # trema command
+  # rubocop:disable ClassLength
+  class Command
+    def self.unix_domain_socket(name = nil, check = false)
+      file_name = name ? "trema.#{name}.ctl" : 'trema.ctl'
+      path = File.expand_path(File.join Phut.socket_dir, file_name)
+      if check && !FileTest.socket?(path)
+        fail "Socket file #{path} does not exist."
+      end
+      'drbunix:' + path
+    end
+
+    attr_reader :controller
+
+    # rubocop:disable AbcSize
+    # rubocop:disable MethodLength
+    def run(args, options)
+      @args = args
+      @daemon = options[:daemonize]
+
+      Controller.logging_level =
+        options[:verbose] ? ::Logger::DEBUG : ::Logger::INFO
+      $LOAD_PATH.unshift File.expand_path(File.dirname(@args.first))
+      load @args.first
+      port_number = (options[:port] || Controller::DEFAULT_TCP_PORT).to_i
+      @controller = Controller.create(port_number)
+
+      trap_signals
+      create_pid_file
+      start_phut(options[:conf])
+
+      if options[:daemonize]
+        run_as_daemon { start_controller_and_drb_threads }
+      else
+        start_controller_and_drb_threads
+      end
+    end
+    # rubocop:enable MethodLength
+    # rubocop:enable AbcSize
+
+    def kill(name)
+      @phut.fetch(name).stop
+    end
+
+    def delete_link(endpoint1, endpoint2)
+      target = @phut.fetch([endpoint1, endpoint2])
+      begin
+        target.stop
+      rescue
+        true
+      end
+    end
+
+    # rubocop:disable CyclomaticComplexity
+    def killall
+      @controller.logger.debug 'Shutting down...' if @controller
+      @controller.stop
+      @controller_thread.kill if @controller_thread
+      @phut_run_thread.kill if @phut_run_thread
+      @phut.stop if @phut
+      FileUtils.rm pid_file if FileTest.exists?(pid_file)
+      DRb.stop_service
+      exit 0 if @daemon
+    end
+    # rubocop:enable CyclomaticComplexity
+
+    def up(name)
+      @phut.fetch(name).run
+    end
+
+    def port_up(switch_name, port)
+      switch = @phut.fetch(switch_name)
+      switch.bring_port_up(port)
+    end
+
+    def port_down(switch_name, port)
+      switch = @phut.fetch(switch_name)
+      switch.bring_port_down(port)
+    end
+
+    def fetch(name)
+      @phut.fetch(name)
+    rescue KeyError
+      raise "Host not found: #{name}"
+    end
+
+    private
+
+    # rubocop:disable MethodLength
+    def start_phut(config_file)
+      return unless config_file
+      system 'sudo -v'
+      @phut = Phut::Parser.new(@controller.logger).parse(config_file)
+      @phut_run_thread = Thread.start { @phut.run }
+      @phut_run_thread.join
+      Thread.start { start_sudo_credential_update }
+    rescue ScriptError, NameError
+      killall
+      raise $ERROR_INFO
+    rescue StandardError
+      raise $ERROR_INFO unless @stop
+    end
+    # rubocop:enable MethodLength
+
+    def start_controller_and_drb_threads
+      @controller_thread = Thread.new { @controller.run @args[1..-1] }
+      @controller_thread.abort_on_exception = true
+      DRb.start_service Command.unix_domain_socket(@controller.name), self
+      DRb.thread.join
+    rescue
+      killall
+      raise $ERROR_INFO
+    end
+
+    def run_as_daemon
+      fork do
+        redirect_stdio_to_devnull
+        update_pid_file
+        yield
+      end
+    end
+
+    def redirect_stdio_to_devnull
+      open('/dev/null', 'r+') do |devnull|
+        $stdin.reopen devnull
+        $stdout.reopen devnull
+        $stderr.reopen devnull
+      end
+    end
+
+    def stop
+      @stop = true
+    end
+
+    # rubocop:disable MethodLength
+    def trap_signals
+      @killall_thread = Thread.start do
+        loop do
+          if @stop
+            killall
+            break
+          end
+          sleep 1
+        end
+      end
+      @killall_thread.abort_on_exception = true
+      Signal.trap(:TERM) { stop }
+      Signal.trap(:INT) { stop }
+    end
+    # rubocop:enable MethodLength
+
+    def create_pid_file
+      fail "#{name} is already running." if running?
+      update_pid_file
+    end
+
+    def update_pid_file
+      File.open(pid_file, 'w') { |file| file << Process.pid }
+    end
+
+    def pid_file
+      File.join Phut.pid_dir, "#{name}.pid"
+    end
+
+    def running?
+      FileTest.exists? pid_file
+    end
+
+    def name
+      @controller.name
+    end
+
+    def start_sudo_credential_update
+      loop do
+        system 'sudo -v'
+        sleep 60
+      end
+    end
+  end
+  # rubocop:enable ClassLength
+end

data/lib/trema/controller.rb

@@ -0,0 +1,289 @@
+require 'logger'
+require 'phut'
+require 'pio'
+require 'socket'
+require 'trema/command'
+require 'trema/logger'
+require 'trema/monkey_patch/integer'
+
+module Trema
+  # The base class of Trema controller. Subclass and override handlers
+  # to implement a custom OpenFlow controller.
+  #
+  # rubocop:disable ClassLength
+  class Controller
+    # Pio::FlowMod.new argument
+    class FlowModAddOption
+      def initialize(user_options)
+        @user_options = user_options
+      end
+
+      def to_hash
+        {
+          command: :add,
+          transaction_id: rand(0xffffffff),
+          hard_timeout: @user_options[:hard_timeout] || 0,
+          buffer_id: @user_options[:buffer_id] || 0xffffffff,
+          match: @user_options.fetch(:match),
+          actions: @user_options[:actions] || []
+        }
+      end
+    end
+
+    # Pio::FlowMod.new argument
+    class FlowModDeleteOption
+      def initialize(user_options)
+        @user_options = user_options
+      end
+
+      def to_hash
+        {
+          command: :delete,
+          transaction_id: rand(0xffffffff),
+          buffer_id: @user_options[:buffer_id] || 0xffffffff,
+          match: @user_options.fetch(:match),
+          out_port: @user_options[:out_port] || 0xffff
+        }
+      end
+    end
+
+    # Pio::PacketOut.new argument
+    class PacketOutOption
+      def initialize(user_options)
+        @user_options = user_options
+      end
+
+      # rubocop:disable MethodLength
+      def to_hash
+        if @user_options[:packet_in]
+          {
+            transaction_id: rand(0xffffffff),
+            buffer_id: 0xffffffff,
+            actions: @user_options[:actions],
+            in_port: @user_options.fetch(:packet_in).in_port,
+            raw_data: @user_options.fetch(:packet_in).raw_data
+          }
+        else
+          {
+            transaction_id: rand(0xffffffff),
+            buffer_id: 0xffffffff,
+            actions: @user_options[:actions],
+            raw_data: @user_options.fetch(:raw_data)
+          }
+        end
+      end
+      # rubocop:enable MethodLength
+    end
+
+    class << self
+      attr_accessor :logging_level
+    end
+
+    include Pio
+
+    SWITCH = {}
+    DEFAULT_TCP_PORT = 6653
+
+    # @return [Logger]
+    attr_reader :logger
+
+    def self.timer_event(handler, options)
+      @timer_handlers ||= {}
+      @timer_handlers[handler] = options.fetch(:interval)
+    end
+
+    def self.timer_handlers
+      @timer_handlers || {}
+    end
+
+    # @private
+    def self.inherited(subclass)
+      @controller_klass = subclass
+    end
+
+    # @private
+    def self.create(port_number = DEFAULT_TCP_PORT)
+      @controller_klass.new(port_number)
+    end
+
+    # @private
+    def initialize(port_number = DEFAULT_TCP_PORT)
+      @port_number = port_number
+      @threads = []
+      @logger = Logger.new(name)
+      @logger.level = Controller.logging_level
+    end
+
+    # @private
+    # Starts this controller. Usually you do not need to invoke
+    # explicitly, because this is called implicitly by "trema run"
+    # command.
+    def run(args)
+      drb_socket_file =
+        File.expand_path(File.join(Phut.socket_dir, "#{name}.ctl"))
+      @drb = DRb::DRbServer.new 'drbunix:' + drb_socket_file, self
+      maybe_send_handler :start, args
+      socket = TCPServer.open('<any>', @port_number)
+      start_timers
+      loop { start_switch_thread(socket.accept) }
+    end
+
+    def name
+      self.class.name
+    end
+
+    def stop
+      @drb.stop_service if @drb
+      @threads.map(&:kill)
+    end
+
+    # @!group OpenFlow Message
+
+    def send_flow_mod_add(datapath_id, options)
+      flow_mod = FlowMod.new(FlowModAddOption.new(options).to_hash)
+      send_message datapath_id, flow_mod
+    end
+
+    def send_flow_mod_delete(datapath_id, options)
+      flow_mod = FlowMod.new(FlowModDeleteOption.new(options).to_hash)
+      send_message datapath_id, flow_mod
+    end
+
+    def send_packet_out(datapath_id, options)
+      packet_out = PacketOut.new(PacketOutOption.new(options).to_hash)
+      send_message datapath_id, packet_out
+    end
+
+    def send_message(datapath_id, message)
+      SWITCH.fetch(datapath_id).write message
+    rescue KeyError, Errno::ECONNRESET, Errno::EPIPE
+      logger.debug "Switch #{datapath_id} is disconnected."
+    end
+
+    # @!endgroup
+
+    # @!group Handlers
+
+    # @private Just a placeholder for YARD.
+    def self._handler(_name)
+      # Noop.
+    end
+
+    # @!method start(argv)
+    #
+    # Start event handler. Override this to implement a custom
+    # handler.
+    _handler :start
+
+    # @!method switch_ready(datapath_id)
+    #
+    # Switch Ready event handler. Override this to implement a custom
+    # handler.
+    _handler :switch_ready
+
+    # The default handler for echo request messages.
+    # Override this to implement a custom handler.
+    def echo_request(datapath_id, message)
+      echo_reply = Echo::Reply.new(xid: message.xid)
+      send_message datapath_id, echo_reply
+    end
+
+    # @!method packet_in(datapath_id, message)
+    #
+    # Packet In message handler. Override this to implement a custom
+    # handler.
+    _handler :packet_in
+
+    # @!endgroup
+
+    private
+
+    def start_timers
+      self.class.timer_handlers.each do |handler, interval|
+        th = Thread.start(handler, interval) do |method, sec|
+          loop do
+            send_handler method
+            sleep sec
+          end
+        end
+        th.abort_on_exception = true
+        @threads << th
+      end
+    end
+
+    def start_switch_thread(socket)
+      th = Thread.start(socket) do |sock|
+        switch = create_and_register_new_switch(sock)
+        start_switch_main switch.datapath_id
+      end
+      th.abort_on_exception = true
+      @threads << th
+    end
+
+    def start_switch_main(datapath_id)
+      maybe_send_handler :switch_ready, datapath_id
+      loop { handle_openflow_message datapath_id }
+    rescue EOFError, IOError
+      unregister_switch datapath_id
+    end
+
+    def create_and_register_new_switch(socket)
+      switch = Switch.new(socket).init
+      SWITCH[switch.datapath_id] = switch
+    end
+
+    def unregister_switch(datapath_id)
+      SWITCH.delete datapath_id
+      maybe_send_handler :switch_disconnected, datapath_id
+    end
+
+    # rubocop:disable MethodLength
+    # rubocop:disable AbcSize
+    # rubocop:disable CyclomaticComplexity
+    def handle_openflow_message(datapath_id)
+      begin
+        message = SWITCH.fetch(datapath_id).read
+      rescue KeyError
+        logger.debug "Switch #{datapath_id} is disconnected."
+      end
+
+      case message
+      when Echo::Request
+        maybe_send_handler :echo_request, datapath_id, message
+      when Features::Reply
+        maybe_send_handler :features_reply, datapath_id, message
+      when PacketIn
+        message.datapath_id = datapath_id
+        maybe_send_handler :packet_in, datapath_id, message
+      when PortStatus
+        message.datapath_id = datapath_id
+        case message.reason
+        when :add
+          maybe_send_handler :port_add, datapath_id, message
+        when :delete
+          maybe_send_handler :port_delete, datapath_id, message
+        when :modify
+          maybe_send_handler :port_modify, datapath_id, message
+        else
+          fail "Invalid Port Status message: #{message.inspect}"
+        end
+      else
+        fail "Unknown OpenFlow message: #{message.inspect}"
+      end
+    end
+    # rubocop:enable MethodLength
+    # rubocop:enable AbcSize
+    # rubocop:enable CyclomaticComplexity
+
+    def send_handler(handler, *args)
+      @handler_mutex ||= Mutex.new
+      @handler_mutex.synchronize { __send__(handler, *args) }
+    end
+
+    def maybe_send_handler(handler, *args)
+      return unless respond_to?(handler)
+      send_handler(handler, *args)
+    end
+  end
+  # rubocop:enable ClassLength
+end