pio 0.9.0 → 0.10.0

data/lib/pio/hello.rb

@@ -1,11 +1,28 @@
 require 'English'
-require 'pio/hello/format'
-require 'pio/parse_error'
+require 'bindata'
 require 'pio/open_flow'
+require 'pio/parse_error'
 
 module Pio
   # OpenFlow 1.0 Hello message
   class Hello < Pio::OpenFlow::Message
+    # Message body of Hello
+    class Body < BinData::Record
+      endian :big
+
+      string :body # ignored
+
+      def length
+        0
+      end
+
+      def empty?
+        true
+      end
+    end
+
+    def_format Pio::OpenFlow::Type::HELLO
+
     # Parses +raw_data+ binary string into a Hello message object.
     #
     # @example
@@ -41,6 +58,7 @@ module Pio
     #   @option user_options [Number] :xid An alias to transaction_id.
     #
     # @reek This method smells of :reek:FeatureEnvy
+    # rubocop:disable MethodLength
     def initialize(user_options = {})
       options = if user_options.respond_to?(:to_i)
                   { transaction_id: user_options.to_i }
@@ -50,7 +68,11 @@ module Pio
                 else
                   fail TypeError
                 end
+      if options[:transaction_id] >= 2**32
+        fail ArgumentError, 'Transaction ID >= 2**32'
+      end
       @format = Format.new(open_flow_header: options)
     end
+    # rubocop:enable MethodLength
   end
 end

data/lib/pio/monkey_patch/integer.rb

@@ -0,0 +1,6 @@
+require 'pio/monkey_patch/integer/ranges'
+
+# Monkey patch to Ruby's Integer class.
+class Integer
+  include MonkeyPatch::Integer::Ranges
+end

data/lib/pio/monkey_patch/integer/ranges.rb

@@ -0,0 +1,22 @@
+module MonkeyPatch
+  module Integer
+    # Defines Integer#nbit? methods.
+    module Ranges
+      def unsigned_8bit?
+        _within_range? 8
+      end
+
+      def unsigned_16bit?
+        _within_range? 16
+      end
+
+      def unsigned_32bit?
+        _within_range? 32
+      end
+
+      def _within_range?(nbit)
+        (0 <= self) && (self < 2**nbit)
+      end
+    end
+  end
+end

data/lib/pio/open_flow.rb

@@ -2,4 +2,5 @@ require 'pio/open_flow/flags'
 require 'pio/open_flow/message'
 require 'pio/open_flow/open_flow_header'
 require 'pio/open_flow/phy_port'
+require 'pio/open_flow/port_number'
 require 'pio/open_flow/type'

data/lib/pio/open_flow/flags.rb

@@ -1,38 +1,52 @@
 # bitmap functions.
 module Flags
-  def flags(name, flags)
-    def_field name
-    def_get name, flags
-    def_set name, flags
+  # rubocop:disable MethodLength
+  # This method smells of :reek:TooManyStatements
+  def def_flags(name, flags)
+    flag_value = case flags
+                 when Array
+                   shift = 0
+                   flags.each_with_object({}) do |each, result|
+                     result[each] = 1 << shift
+                     shift += 1
+                     result
+                   end
+                 when Hash
+                   flags
+                 end
+    _def_class name, flag_value
   end
+  # rubocop:enable MethodLength
 
-  def def_field(name)
-    module_eval("uint32 :#{name}")
-  end
+  # rubocop:disable MethodLength
+  def _def_class(name, flags)
+    klass_name = name.to_s.split('_').map(&:capitalize).join
+    flags_hash = flags.inspect
+
+    code = %{
+      class #{klass_name} < BinData::Primitive
+        endian :big
+
+        uint32 :#{name}
 
-  def def_get(name, flags)
-    str = %{
-      def get
-        list = #{flags.inspect}
-        list.each_with_object([]) do |(key, value), result|
-          result << key if #{name} & value != 0
-          result
+        def get
+          list = #{flags_hash}
+          list.each_with_object([]) do |(key, value), result|
+            result << key if #{name} & value != 0
+            result
+          end
         end
-      end
-    }
-    module_eval str
-  end
 
-  def def_set(name, flags)
-    str = %{
-      def set(v)
-        list = #{flags.inspect}
-        v.each do |each|
-          fail "Invalid state flag: \#{v}" unless list.keys.include?(each)
+        def set(v)
+          list = #{flags_hash}
+          v.each do |each|
+            fail "Invalid state flag: \#{v}" unless list.keys.include?(each)
+          end
+          self.#{name} = v.empty? ? 0 : v.map { |each| list[each] }.inject(:|)
         end
-        self.#{name} = v.empty? ? 0 : v.map { |each| list[each] }.inject(:|)
       end
     }
-    module_eval str
+    module_eval code
   end
+  # rubocop:enable MethodLength
 end

data/lib/pio/open_flow/message.rb

@@ -15,6 +15,34 @@ module Pio
       def_delegators :@format, :body
       def_delegator :@format, :body, :user_data
       def_delegator :@format, :to_binary_s, :to_binary
+
+      # rubocop:disable MethodLength
+      def self.def_format(message_type)
+        str = %(
+         class Format < BinData::Record
+           endian :big
+
+           open_flow_header :open_flow_header,
+                            message_type_value: #{message_type}
+           virtual assert: -> do
+             open_flow_header.message_type == #{message_type}
+           end
+
+           body :body
+         end
+        )
+        module_eval str
+      end
+      # rubocop:enable MethodLength
+
+      # @reek This method smells of :reek:FeatureEnvy
+      def initialize(user_options)
+        header_options = { transaction_id: user_options[:transaction_id] ||
+                                           user_options[:xid] || 0 }
+        format_klass = self.class.const_get(:Format)
+        @format = format_klass.new(open_flow_header: header_options,
+                                   body: user_options)
+      end
     end
   end
 end

data/lib/pio/open_flow/parser.rb

@@ -0,0 +1,22 @@
+require 'pio/open_flow'
+require 'pio/parse_error'
+
+module Pio
+  module OpenFlow
+    # OpenFlow message parser interface.
+    module Parser
+      # This method smells of :reek:TooManyStatements
+      # This method smells of :reek:FeatureEnvy
+      def read(raw_data)
+        header = Pio::Type::OpenFlow::OpenFlowHeader.read(raw_data)
+        klass = const_get(:KLASS).fetch(header.message_type)
+        format = klass.const_get(:Format).read(raw_data)
+        message = klass.allocate
+        message.instance_variable_set :@format, format
+        message
+      rescue KeyError
+        raise Pio::ParseError, 'Invalid OpenFlow message.'
+      end
+    end
+  end
+end

data/lib/pio/open_flow/phy_port.rb

@@ -4,59 +4,43 @@ require 'pio/type/mac_address'
 module Pio
   module Type
     module OpenFlow
-      # enum ofp_port_config
-      class PortConfig < BinData::Primitive
-        extend Flags
-
-        endian :big
-
-        flags :config,
-              port_down: 1 << 0,
-              no_stp: 1 << 1,
-              no_recv: 1 << 2,
-              no_recv_stp: 1 << 3,
-              no_flood: 1 << 4,
-              no_fwd: 1 << 5,
-              no_packet_in: 1 << 6
-      end
-
-      # enum ofp_port_state
-      class PortState < BinData::Primitive
-        extend Flags
-
-        endian :big
-
-        flags :state,
-              link_down: 1 << 0,
-              stp_listen: 0 << 8,
-              stp_learn: 1 << 8,
-              stp_forward: 2 << 8,
-              stp_block: 3 << 8
-      end
-
-      # enum ofp_port_features
-      class PortFeature < BinData::Primitive
+      # Description of a physical port
+      class PhyPort < BinData::Record
         extend Flags
 
-        endian :big
+        # enum ofp_port_config
+        def_flags :port_config,
+                  [:port_down,
+                   :no_stp,
+                   :no_recv,
+                   :no_recv_stp,
+                   :no_flood,
+                   :no_fwd,
+                   :no_packet_in]
+
+        # enum ofp_port_state
+        def_flags :port_state,
+                  link_down: 1 << 0,
+                  stp_listen: 0 << 8,
+                  stp_learn: 1 << 8,
+                  stp_forward: 2 << 8,
+                  stp_block: 3 << 8
+
+        # enum ofp_port_features
+        def_flags :port_feature,
+                  [:port_10mb_hd,
+                   :port_10mb_fd,
+                   :port_100mb_hd,
+                   :port_100mb_fd,
+                   :port_1gb_hd,
+                   :port_1gb_fd,
+                   :port_10gb_fd,
+                   :port_copper,
+                   :port_fiber,
+                   :port_autoneg,
+                   :port_pause,
+                   :port_pause_asym]
 
-        flags :features,
-              port_10mb_hd: 1 << 0,
-              port_10mb_fd: 1 << 1,
-              port_100mb_hd: 1 << 2,
-              port_100mb_fd: 1 << 3,
-              port_1gb_hd: 1 << 4,
-              port_1gb_fd: 1 << 5,
-              port_10gb_fd: 1 << 6,
-              port_copper: 1 << 7,
-              port_fiber: 1 << 8,
-              port_autoneg: 1 << 9,
-              port_pause: 1 << 10,
-              port_pause_asym: 1 << 11
-      end
-
-      # Description of a physical port
-      class PhyPort < BinData::Record
         endian :big
 
         uint16 :port_no

data/lib/pio/open_flow/port_number.rb

@@ -0,0 +1,39 @@
+module Pio
+  # Port numbering.
+  class PortNumber < BinData::Primitive
+    NUMBERS = {
+      in_port: 0xfff8,
+      table: 0xfff9,
+      normal: 0xfffa,
+      flood: 0xfffb,
+      all: 0xfffc,
+      controller: 0xfffd,
+      local: 0xfffe,
+      none: 0xffff
+    }
+    MAX = 0xff00
+
+    endian :big
+
+    uint16 :port_number
+
+    def get
+      NUMBERS.invert.fetch(port_number)
+    rescue KeyError
+      port_number
+    end
+
+    def set(value)
+      if NUMBERS.key?(value)
+        self.port_number = NUMBERS.fetch(value)
+      else
+        port_number = value.to_i
+        fail ArgumentError, 'The port_number should be > 0' if port_number < 1
+        if port_number >= MAX
+          fail ArgumentError, 'The port_number should be < 0xff00'
+        end
+        self.port_number = port_number
+      end
+    end
+  end
+end

data/lib/pio/open_flow/type.rb

@@ -8,6 +8,7 @@ module Pio
       FEATURES_REQUEST = 5
       FEATURES_REPLY = 6
       PACKET_IN = 10
+      PACKET_OUT = 13
     end
   end
 end

data/lib/pio/packet_in.rb

@@ -1,9 +1,49 @@
-require 'pio/packet_in/format'
+require 'bindata'
+require 'pio/open_flow'
 require 'pio/parse_error'
 
 module Pio
   # OpenFlow 1.0 Packet-In message
-  class PacketIn
+  class PacketIn < Pio::OpenFlow::Message
+    # Why is this packet being sent to the controller?
+    # (enum ofp_packet_in_reason)
+    class Reason < BinData::Primitive
+      REASONS = { no_match: 0, action: 1 }
+
+      uint8 :reason
+
+      def get
+        REASONS.invert.fetch(reason)
+      end
+
+      def set(value)
+        self.reason = REASONS.fetch(value)
+      end
+    end
+
+    # Message body of Packet-In.
+    class Body < BinData::Record
+      endian :big
+
+      uint32 :buffer_id
+      uint16 :total_len, value: -> { data.length }
+      uint16 :in_port
+      reason :reason
+      uint8 :padding
+      hide :padding
+      string :data, read_length: :total_len
+
+      def empty?
+        false
+      end
+
+      def length
+        10 + data.length
+      end
+    end
+
+    def_format Pio::OpenFlow::Type::PACKET_IN
+
     def self.read(raw_data)
       packet_in = allocate
       packet_in.instance_variable_set :@format, Format.read(raw_data)
@@ -17,12 +57,5 @@ module Pio
     def_delegators :body, :in_port
     def_delegators :body, :reason
     def_delegators :body, :data
-
-    # @reek This method smells of :reek:FeatureEnvy
-    def initialize(user_options)
-      header_options = { transaction_id: user_options[:transaction_id] ||
-                                         user_options[:xid] || 0 }
-      @format = Format.new(open_flow_header: header_options, body: user_options)
-    end
   end
 end

data/lib/pio/packet_out.rb

@@ -0,0 +1,102 @@
+require 'bindata'
+require 'pio/enqueue'
+require 'pio/open_flow'
+require 'pio/send_out_port'
+require 'pio/set_eth_addr'
+require 'pio/set_ip_addr'
+require 'pio/set_ip_tos'
+require 'pio/set_transport_port'
+require 'pio/set_vlan_priority'
+require 'pio/set_vlan_vid'
+require 'pio/strip_vlan_header'
+
+module Pio
+  # OpenFlow 1.0 Packet-Out message
+  class PacketOut < Pio::OpenFlow::Message
+    # Actions list.
+    class Actions < BinData::Primitive
+      ACTION_CLASS = {
+        0 => Pio::SendOutPort,
+        1 => Pio::SetVlanVid,
+        2 => Pio::SetVlanPriority,
+        3 => Pio::StripVlanHeader,
+        4 => Pio::SetEthSrcAddr,
+        5 => Pio::SetEthDstAddr,
+        6 => Pio::SetIpSrcAddr,
+        7 => Pio::SetIpDstAddr,
+        8 => Pio::SetIpTos,
+        9 => Pio::SetTransportSrcPort,
+        10 => Pio::SetTransportDstPort,
+        11 => Pio::Enqueue
+      }
+
+      endian :big
+
+      uint16 :actions_len, initial_value: -> { binary.length }
+      string :binary, read_length: :actions_len
+
+      def set(value)
+        self.binary = [value].flatten.map(&:to_binary).join
+      end
+
+      # rubocop:disable MethodLength
+      # This method smells of :reek:TooManyStatements
+      def get
+        actions = []
+        tmp = binary
+        while tmp.length > 0
+          type = BinData::Uint16be.read(tmp)
+          begin
+            action = ACTION_CLASS.fetch(type).read(tmp)
+            tmp = tmp[action.message_length..-1]
+            actions << action
+          rescue KeyError
+            raise "action #{type} is not supported." unless ACTION_CLASS[type]
+          end
+        end
+        actions
+      end
+      # rubocop:enable MethodLength
+
+      def [](index)
+        get[index]
+      end
+    end
+
+    # Message body of Packet-Out
+    class Body < BinData::Record
+      endian :big
+
+      uint32 :buffer_id
+      uint16 :in_port
+      actions :actions
+      rest :data
+
+      def empty?
+        false
+      end
+
+      def length
+        8 + actions_len + data.length
+      end
+
+      def actions_len
+        actions.actions_len
+      end
+    end
+
+    def_format Pio::OpenFlow::Type::PACKET_OUT
+
+    def self.read(raw_data)
+      packet_out = allocate
+      packet_out.instance_variable_set :@format, Format.read(raw_data)
+      packet_out
+    end
+
+    def_delegators :body, :buffer_id
+    def_delegators :body, :in_port
+    def_delegators :body, :actions_len
+    def_delegators :body, :actions
+    def_delegators :body, :data
+  end
+end