pio 0.10.1 → 0.11.0

data/lib/pio/open_flow.rb

@@ -1,3 +1,4 @@
+require 'pio/open_flow/actions'
 require 'pio/open_flow/flags'
 require 'pio/open_flow/message'
 require 'pio/open_flow/open_flow_header'

data/lib/pio/open_flow/actions.rb

@@ -0,0 +1,65 @@
+require 'bindata'
+require 'pio/enqueue'
+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
+  module OpenFlow
+    # 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
+      }
+
+      mandatory_parameter :length
+
+      endian :big
+
+      string :binary, read_length: :length
+
+      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 #{type} is not supported."
+          end
+        end
+        actions
+      end
+      # rubocop:enable MethodLength
+
+      def [](index)
+        get[index]
+      end
+    end
+  end
+end

data/lib/pio/open_flow/flags.rb

@@ -1,8 +1,17 @@
 # bitmap functions.
+# This class smells of :reek:DataClump
 module Flags
+  def flags_32bit(name, flags)
+    _def_flags name, 32, flags
+  end
+
+  def flags_16bit(name, flags)
+    _def_flags name, 16, flags
+  end
+
   # rubocop:disable MethodLength
   # This method smells of :reek:TooManyStatements
-  def def_flags(name, flags)
+  def _def_flags(name, size, flags)
     flag_value = case flags
                  when Array
                    shift = 0
@@ -14,20 +23,15 @@ module Flags
                  when Hash
                    flags
                  end
-    _def_class name, flag_value
-  end
-  # rubocop:enable MethodLength
 
-  # rubocop:disable MethodLength
-  def _def_class(name, flags)
     klass_name = name.to_s.split('_').map(&:capitalize).join
-    flags_hash = flags.inspect
+    flags_hash = flag_value.inspect
 
     code = %{
       class #{klass_name} < BinData::Primitive
         endian :big
 
-        uint32 :#{name}
+        uint#{size} :#{name}
 
         def get
           list = #{flags_hash}
@@ -48,5 +52,4 @@ module Flags
     }
     module_eval code
   end
-  # rubocop:enable MethodLength
 end

data/lib/pio/open_flow/message.rb

@@ -1,4 +1,7 @@
+require 'English'
+require 'bindata'
 require 'forwardable'
+require 'pio/parse_error'
 
 module Pio
   module OpenFlow
@@ -6,43 +9,124 @@ module Pio
     class Message
       extend Forwardable
 
+      # struct ofp_header fields.
       def_delegators :@format, :open_flow_header
       def_delegators :open_flow_header, :ofp_version
       def_delegators :open_flow_header, :message_type
       def_delegators :open_flow_header, :message_length
       def_delegators :open_flow_header, :transaction_id
       def_delegator :open_flow_header, :transaction_id, :xid
+
       def_delegators :@format, :body
       def_delegator :@format, :body, :user_data
+
       def_delegator :@format, :to_binary_s, :to_binary
 
+      def self.factory(message_type)
+        @message_type = message_type
+        self
+      end
+
+      def self.klass(message_type)
+        @messages.fetch(message_type)
+      end
+
+      def self.inherited(child)
+        child.const_set(:MESSAGE_TYPE, @message_type)
+        @messages ||= {}
+        @messages[@message_type] = child
+      end
+
+      def self.read(raw_data)
+        message = allocate
+        message.instance_variable_set(:@format, format.read(raw_data))
+        message
+      rescue BinData::ValidityError
+        message_name = name.split('::')[1..-1].join(' ')
+        raise Pio::ParseError, "Invalid #{message_name} message."
+      end
+
+      def self.format
+        const_get(:Format)
+      rescue NameError
+        define_message_format const_get(:MESSAGE_TYPE)
+        retry
+      end
+
       # 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
+      def self.define_message_format(message_type)
+        code = %(
+          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_type} :body
+          end
         )
-        module_eval str
+        module_eval code
       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)
+      def self.body_type
+        klass_name = name.split('::').last + 'Body'
+        const_get(klass_name)
+        klass_name.sub(/.*::/, '')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+      rescue NameError
+        'string'
+      end
+
+      def initialize(user_options = {})
+        header_options = parse_header_options(user_options)
+        body_options = parse_body_options(user_options)
+        @format = self.class.format.new(open_flow_header: header_options,
+                                        body: body_options)
       end
+
+      private
+
+      # This method smells of :reek:FeatureEnvy
+      def parse_header_options(options)
+        xid = if options.respond_to?(:to_i)
+                options.to_i
+              elsif options.respond_to?(:fetch)
+                options[:transaction_id] || options[:xid] || 0
+              else
+                fail TypeError
+              end
+        return { transaction_id: xid } if xid.unsigned_32bit?
+        fail(ArgumentError,
+             'Transaction ID should be an unsigned 32-bit integer.')
+      end
+
+      # rubocop:disable MethodLength
+      # This method smells of :reek:TooManyStatements
+      # This method smells of :reek:FeatureEnvy
+      # This method smells of :reek:UtilityFunction
+      def parse_body_options(options)
+        if options.respond_to?(:fetch)
+          options.delete :transaction_id
+          options.delete :xid
+          dpid = options[:dpid]
+          options[:datapath_id] = dpid if dpid
+          if options.keys.size > 1
+            options
+          else
+            options[:user_data] || ''
+          end
+        else
+          ''
+        end
+      end
+      # rubocop:enable MethodLength
     end
   end
 end

data/lib/pio/open_flow/phy_port.rb

@@ -9,37 +9,37 @@ module Pio
         extend Flags
 
         # enum ofp_port_config
-        def_flags :port_config,
-                  [:port_down,
-                   :no_stp,
-                   :no_recv,
-                   :no_recv_stp,
-                   :no_flood,
-                   :no_fwd,
-                   :no_packet_in]
+        flags_32bit :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
+        flags_32bit :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_32bit :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]
 
         endian :big
 
@@ -52,6 +52,10 @@ module Pio
         port_feature :advertised
         port_feature :supported
         port_feature :peer
+
+        def mac_address
+          hardware_address
+        end
       end
     end
   end

data/lib/pio/open_flow/type.rb

@@ -9,6 +9,7 @@ module Pio
       FEATURES_REPLY = 6
       PACKET_IN = 10
       PACKET_OUT = 13
+      FLOW_MOD = 14
     end
   end
 end

data/lib/pio/packet_in.rb

@@ -4,7 +4,7 @@ require 'pio/parse_error'
 
 module Pio
   # OpenFlow 1.0 Packet-In message
-  class PacketIn < Pio::OpenFlow::Message
+  class PacketIn < OpenFlow::Message.factory(OpenFlow::Type::PACKET_IN)
     # Why is this packet being sent to the controller?
     # (enum ofp_packet_in_reason)
     class Reason < BinData::Primitive
@@ -22,7 +22,7 @@ module Pio
     end
 
     # Message body of Packet-In.
-    class Body < BinData::Record
+    class PacketInBody < BinData::Record
       endian :big
 
       uint32 :buffer_id
@@ -42,16 +42,6 @@ module Pio
       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)
-      packet_in
-    rescue BinData::ValidityError
-      raise Pio::ParseError, 'Invalid Packet-In message.'
-    end
-
     def_delegators :body, :buffer_id
     def_delegators :body, :total_len
     def_delegators :body, :in_port

data/lib/pio/packet_out.rb

@@ -1,75 +1,17 @@
 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 #{type} is not supported."
-          end
-        end
-        actions
-      end
-      # rubocop:enable MethodLength
-
-      def [](index)
-        get[index]
-      end
-    end
-
+  class PacketOut < OpenFlow::Message.factory(OpenFlow::Type::PACKET_OUT)
     # Message body of Packet-Out
-    class Body < BinData::Record
+    class PacketOutBody < BinData::Record
       endian :big
 
       uint32 :buffer_id
       uint16 :in_port
-      actions :actions
+      uint16 :actions_len, initial_value: -> { actions.binary.length }
+      actions :actions, length: -> { actions_len }
       rest :data
 
       def empty?
@@ -79,18 +21,6 @@ module Pio
       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