pio 0.23.1 → 0.24.0

data/lib/pio/open_flow13/goto_table.rb

@@ -25,6 +25,7 @@ module Pio
     def_delegators :@format, :instruction_type
     def_delegators :@format, :instruction_length
     def_delegators :@format, :table_id
+    def_delegators :@format, :to_binary_s
 
     def initialize(table_id)
       @format = Format.new(table_id: table_id)

data/lib/pio/open_flow13/hello.rb

@@ -1,113 +1,83 @@
-require 'bindata'
-require 'forwardable'
 require 'pio/open_flow'
-require 'pio/parse_error'
 
 # Base module.
 module Pio
-  remove_const :Hello
-
-  # OpenFlow 1.3 Hello message parser and generator
-  class Hello
-    # ofp_hello_elem_header and value
-    class Element < BinData::Record
+  # OpenFlow 1.0 messages
+  module OpenFlow13
+    # OpenFlow 1.3 Hello message parser and generator
+    class Hello < OpenFlow::Message
       VERSION_BITMAP = 1
 
-      endian :big
+      # ofp_hello_elem_header and value
+      class Element < BinData::Record
+        endian :big
 
-      uint16 :element_type
-      uint16 :element_length
-      choice :element_value, selection: :chooser do
-        string 'unknown', read_length: -> { element_length - 4 }
-        uint32 'version_bitmap'
-      end
+        uint16 :element_type
+        uint16 :element_length
+        choice :element_value, selection: :chooser do
+          string 'unknown', read_length: -> { element_length - 4 }
+          uint32 'version_bitmap'
+        end
 
-      def version_bitmap?
-        element_type == VERSION_BITMAP
-      end
+        def version_bitmap?
+          element_type == VERSION_BITMAP
+        end
 
-      private
+        private
 
-      def chooser
-        version_bitmap? ? 'version_bitmap' : 'unknown'
+        def chooser
+          version_bitmap? ? 'version_bitmap' : 'unknown'
+        end
       end
-    end
 
-    # OpenFlow 1.3 Hello message body.
-    class Body < BinData::Record
-      array :elements, type: :element, read_until: :eof
+      # OpenFlow 1.3 Hello message body.
+      class Body < BinData::Record
+        array :elements, type: :element, read_until: :eof
 
-      def length
-        if elements.empty?
-          0
-        else
-          elements.length * 4 + 4
+        def length
+          if elements.empty?
+            0
+          else
+            elements.length * 4 + 4
+          end
         end
       end
-    end
-
-    # OpenFlow 1.3 Hello message format
-    class Format < BinData::Record
-      extend Forwardable
 
-      endian :big
+      # OpenFlow 1.3 Hello message format
+      class Format < BinData::Record
+        extend OpenFlow::Format
 
-      open_flow_header :open_flow_header,
-                       ofp_version_value: 4, message_type_value: 0
-      body :body
+        header version: 4, message_type: 0
+        body :body
 
-      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 :body, :elements
-
-      def supported_versions
-        supported_versions_list.map do |each|
-          "open_flow1#{each - 1}".to_sym
+        def supported_versions
+          supported_versions_list.map do |each|
+            "open_flow1#{each - 1}".to_sym
+          end
         end
-      end
 
-      alias_method :to_binary, :to_binary_s
+        private
 
-      private
-
-      def supported_versions_list
-        (1..32).each_with_object([]) do |each, result|
-          result << each if (version_bitmap >> each & 1) == 1
+        def supported_versions_list
+          (1..32).each_with_object([]) do |each, result|
+            result << each if (version_bitmap >> each & 1) == 1
+          end
         end
-      end
-
-      def version_bitmap
-        bitmap = elements.find(&:version_bitmap?)
-        bitmap ? bitmap.element_value : 0
-      end
-    end
 
-    def self.read(raw_data)
-      allocate.tap do |message|
-        message.instance_variable_set(:@format, Format.read(raw_data))
+        def version_bitmap
+          bitmap = elements.detect(&:version_bitmap?)
+          bitmap ? bitmap.element_value : 0
+        end
       end
-    rescue BinData::ValidityError
-      raise Pio::ParseError, 'Invalid Hello 1.3 message.'
-    end
 
-    def initialize(user_attrs = {})
-      unknown_keywords = user_attrs.keys - [:transaction_id, :xid]
-      unless unknown_keywords.empty?
-        fail "Unknown keyword: #{unknown_keywords.first}"
+      def initialize(user_options = {})
+        validate_user_options user_options
+        header_options = parse_header_options(user_options)
+        body_options = { elements: [{ element_type: VERSION_BITMAP,
+                                      element_length: 8,
+                                      element_value: 0b10000 }] }
+        @format = Format.new(header: header_options, body: body_options)
       end
-
-      header_attrs = OpenFlowHeader::Options.parse(user_attrs)
-      body_attrs = { elements: [{ element_type: 1,
-                                  element_length: 8,
-                                  element_value: 16 }] }
-      @format = Format.new(open_flow_header: header_attrs, body: body_attrs)
-    end
-
-    def method_missing(method, *args, &block)
-      @format.__send__ method, *args, &block
     end
   end
 end

data/lib/pio/open_flow13/match.rb

@@ -13,6 +13,7 @@ module Pio
     # OpenFlow eXtensible Match (OXM)
     class Match
       OXM_CLASS_OPENFLOW_BASIC = 0x8000
+      OXM_CLASS_EXPERIMENTER = 0xFFFF
 
       # The value of OXM_OF_IN_PORT match field.
       class InPort < BinData::Record
@@ -548,17 +549,30 @@ module Pio
 
       # OXM format
       class Oxm < BinData::Record
-        # OXM match field.
+        # Experimenter part, data will use oxm_length
+        class Experimenter < BinData::Record
+          endian :big
+
+          bit7 :oxm_field
+          bit1 :oxm_hasmask
+          uint8 :oxm_length, value: -> { data.length + 4 }
+          uint32 :experimenter
+          string :data, read_length: -> { oxm_length - 4 }
+
+          def length
+            oxm_length + 2
+          end
+        end
+
         # rubocop:disable ClassLength
-        class MatchField < BinData::Record
+        # OpenflowBasic part, tlv_value will use oxm_field, oxm_hasmask
+        class OpenflowBasic < BinData::Record
           endian :big
 
-          uint16 :oxm_class, value: OXM_CLASS_OPENFLOW_BASIC
           bit7 :oxm_field
           bit1 :oxm_hasmask
           uint8 :oxm_length, value: -> { tlv_value.length }
           choice :tlv_value,
-                 read_length: :oxm_length,
                  selection: :choose_tlv_value do
             in_port InPort
             metadata Metadata
@@ -603,7 +617,7 @@ module Pio
           end
 
           def length
-            tlv_value.length + 4
+            tlv_value.length + 2
           end
 
           def masked?
@@ -709,6 +723,44 @@ module Pio
         end
         # rubocop:enable MethodLength
 
+        # OXM match field.
+        class MatchField < BinData::Record
+          endian :big
+
+          uint16 :oxm_class, initial_value: OXM_CLASS_OPENFLOW_BASIC
+          choice :class_payload, selection: :oxm_class do
+            OpenflowBasic OXM_CLASS_OPENFLOW_BASIC
+            Experimenter OXM_CLASS_EXPERIMENTER
+          end
+
+          def oxm_field
+            class_payload.oxm_field
+          end
+
+          def masked?
+            class_payload.oxm_hasmask == 1
+          end
+
+          def oxm_length
+            class_payload.oxm_length
+          end
+
+          def length
+            class_payload.length + 2
+          end
+
+          def method_missing(method, *args, &block)
+            case oxm_class
+            when OXM_CLASS_OPENFLOW_BASIC
+              return class_payload.tlv_value.__send__(method, *args, &block)
+            when OXM_CLASS_EXPERIMENTER
+              return class_payload.__send__(method, *args, &block)
+            else
+              fail NoMethodError, method.to_s
+            end
+          end
+        end
+
         endian :big
 
         uint16 :match_type, value: MATCH_TYPE_OXM
@@ -724,13 +776,18 @@ module Pio
           match_length + padding_length
         end
 
+        # rubocop:disable Next
         def method_missing(method, *args, &block)
           match_fields.each do |each|
-            next unless each.tlv_value.respond_to?(method)
-            return each.tlv_value.__send__(method, *args, &block)
+            if each.oxm_class == OXM_CLASS_OPENFLOW_BASIC
+              next unless each.class_payload.tlv_value.respond_to?(method)
+              return each.class_payload.tlv_value.__send__(
+                method, *args, &block)
+            end
           end
           fail NoMethodError, method.to_s
         end
+        # rubocop:enable Next
 
         private
 
@@ -765,8 +822,9 @@ module Pio
            :icmpv4_type, :icmpv4_code, :arp_op].each do |each|
             next unless user_attrs.key?(each)
             klass = Match.const_get(each.to_s.split('_').map(&:capitalize).join)
-            @match_fields << { oxm_field: klass.const_get(:OXM_FIELD),
-                               tlv_value: { each => user_attrs.fetch(each) } }
+            @match_fields << { class_payload:
+              { oxm_field: klass.const_get(:OXM_FIELD),
+                tlv_value: { each => user_attrs.fetch(each) } } }
           end
 
           [:metadata, :ether_destination_address, :ether_source_address,
@@ -778,11 +836,11 @@ module Pio
             next unless user_attrs.key?(each)
             klass = Match.const_get(each.to_s.split('_').map(&:capitalize).join)
             mask_key = "#{each}_mask".to_sym
-            @match_fields <<
+            @match_fields << { class_payload:
               { oxm_field: klass.const_get(:OXM_FIELD),
                 oxm_hasmask: user_attrs.key?(mask_key) ? 1 : 0,
                 tlv_value: { each => user_attrs[each],
-                             mask_key => user_attrs[mask_key] } }
+                             mask_key => user_attrs[mask_key] } } }
           end
         end
         # rubocop:enable MethodLength

data/lib/pio/open_flow13/meter.rb

@@ -24,6 +24,7 @@ module Pio
     def_delegators :@format, :instruction_type
     def_delegators :@format, :instruction_length
     def_delegators :@format, :meter_id
+    def_delegators :@format, :to_binary_s
 
     def initialize(meter_id)
       @format = Format.new(meter_id: meter_id)

data/lib/pio/open_flow13/packet_in.rb

@@ -1,29 +1,30 @@
+require 'pio/open_flow'
+require 'pio/open_flow13/match'
+require 'pio/parser'
+
 # Base module.
 module Pio
-  remove_const :PacketIn
-
-  # OpenFlow 1.3 PacketIn message parser and generator
-  class PacketIn
-    # OpenFlow 1.3 PacketIn message format
-    class Format < BinData::Record
-      # OpenFlow 1.3 PacketIn message body
-      class Body < BinData::Record
-        # Why is this packet being sent to the controller?
-        # (enum ofp_packet_in_reason)
-        class Reason < BinData::Primitive
-          REASONS = { no_match: 0, action: 1, invalid_ttl: 2 }
-
-          uint8 :reason
-
-          def get
-            REASONS.invert.fetch(reason)
-          end
+  module OpenFlow13
+    # OpenFlow 1.3 PacketIn message parser and generator
+    class PacketIn < 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, invalid_ttl: 2 }
+
+        uint8 :reason
+
+        def get
+          REASONS.invert.fetch(reason)
+        end
 
-          def set(value)
-            self.reason = REASONS.fetch(value)
-          end
+        def set(value)
+          self.reason = REASONS.fetch(value)
         end
+      end
 
+      # OpenFlow 1.3 PacketIn message body
+      class Body < BinData::Record
         endian :big
 
         uint32 :buffer_id
@@ -44,44 +45,31 @@ module Pio
           @data ||= Pio::Parser.read(raw_data)
         end
 
+        def in_port
+          match.in_port
+        end
+
         def method_missing(method, *args)
           data.__send__(method, *args).snapshot
         end
       end
 
-      extend Forwardable
-
-      endian :big
-
-      open_flow_header :open_flow_header,
-                       ofp_version_value: 4, message_type_value: 10
-      body :body
-
-      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
+      # OpenFlow 1.3 PacketIn message format
+      class Format < BinData::Record
+        extend OpenFlow::Format
 
-      def method_missing(method, *args, &block)
-        body.__send__ method, *args, &block
-      end
-    end
+        header version: 4, message_type: 10
+        body :body
 
-    def self.read(raw_data)
-      allocate.tap do |message|
-        message.instance_variable_set(:@format, Format.read(raw_data))
+        attr_accessor :datapath_id
+        alias_method :dpid, :datapath_id
+        alias_method :dpid=, :datapath_id=
       end
-    end
-
-    def initialize(user_attrs = {})
-      header_attrs = OpenFlowHeader::Options.parse(user_attrs)
-      body_attrs = { raw_data: user_attrs[:raw_data] }
-      @format = Format.new(open_flow_header: header_attrs, body: body_attrs)
-    end
 
-    def method_missing(method, *args, &block)
-      @format.__send__ method, *args, &block
+      body_option :buffer_id
+      body_option :in_port
+      body_option :reason
+      body_option :raw_data
     end
   end
 end

data/lib/pio/open_flow13/packet_out.rb

@@ -1,90 +1,65 @@
-require 'bindata'
+require 'pio/open_flow'
 require 'pio/open_flow13/actions'
 require 'pio/open_flow13/buffer_id'
 
 # Base module.
 module Pio
-  remove_const :PacketOut
-
-  # OpenFlow 1.3 PacketOut message parser and generator
-  class PacketOut
-    # Packet's input port or :controller
-    class InPort < BinData::Primitive
-      CONTROLLER = 0xfffffffd
-
-      endian :big
-      uint32 :in_port
-
-      def get
-        (in_port == CONTROLLER) ? :controller : in_port
-      end
-
-      def set(value)
-        self.in_port = (value == :controller ? NO_CONTROLLER : value)
-      end
-    end
-
-    # OpenFlow 1.3 PacketOut message body
-    class Body < BinData::Record
-      endian :big
-
-      buffer_id :buffer_id
-      in_port :in_port
-      uint16 :actions_length, initial_value: -> { actions.binary.length }
-      string :padding, length: 6
-      actions :actions, length: :actions_length
-      string :raw_data, read_length: -> { message_length - 24 - actions_length }
-
-      def length
-        10 + padding.length + actions_length + raw_data.length
-      end
-
-      def data
-        @data ||= Pio::Parser.read(raw_data)
+  module OpenFlow13
+    # OpenFlow 1.3 PacketOut message parser and generator
+    class PacketOut < OpenFlow::Message
+      # Packet's input port or :controller
+      class InPort < BinData::Primitive
+        CONTROLLER = 0xfffffffd
+
+        endian :big
+        uint32 :in_port
+
+        def get
+          (in_port == CONTROLLER) ? :controller : in_port
+        end
+
+        def set(value)
+          self.in_port = (value == :controller ? NO_CONTROLLER : value)
+        end
       end
 
-      def method_missing(method, *args)
-        data.__send__(method, *args).snapshot
+      # OpenFlow 1.3 PacketOut message body
+      class Body < BinData::Record
+        endian :big
+
+        buffer_id :buffer_id
+        in_port :in_port
+        uint16 :actions_length, initial_value: -> { actions.binary.length }
+        string :padding, length: 6
+        actions :actions, length: :actions_length
+        string :raw_data,
+               read_length: -> { message_length - 24 - actions_length }
+
+        def length
+          10 + padding.length + actions_length + raw_data.length
+        end
+
+        def data
+          @data ||= Pio::Parser.read(raw_data)
+        end
+
+        def method_missing(method, *args)
+          data.__send__(method, *args).snapshot
+        end
       end
-    end
-
-    # OpenFlow 1.3 PacketOut message body
-    class Format < BinData::Record
-      extend Forwardable
 
-      endian :big
+      # OpenFlow 1.3 PacketOut message body
+      class Format < BinData::Record
+        extend OpenFlow::Format
 
-      open_flow_header :open_flow_header,
-                       ofp_version_value: 4, message_type_value: 13
-      body :body
-
-      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 method_missing(method, *args, &block)
-        body.__send__ method, *args, &block
+        header version: 4, message_type: 13
+        body :body
       end
-    end
-
-    def self.read(raw_data)
-      allocate.tap do |message|
-        message.instance_variable_set(:@format, Format.read(raw_data))
-      end
-    end
-
-    def initialize(user_attrs = {})
-      header_attrs = OpenFlowHeader::Options.parse(user_attrs)
-      body_attrs = { actions: user_attrs[:actions],
-                     raw_data: user_attrs[:raw_data] }
-      @format = Format.new(open_flow_header: header_attrs,
-                           body: body_attrs)
-    end
 
-    def method_missing(method, *args, &block)
-      @format.__send__ method, *args, &block
+      body_option :buffer_id
+      body_option :in_port
+      body_option :actions
+      body_option :raw_data
     end
   end
 end