pio 0.23.1 → 0.24.0

data/lib/pio/open_flow10/flow_mod.rb

@@ -1,89 +1,96 @@
 require 'pio/open_flow'
+require 'pio/open_flow10/actions'
 require 'pio/open_flow10/match'
 
 # Base module.
 module Pio
-  # OpenFlow 1.0 Flow Mod message.
-  class FlowMod
-    # enum ofp_flow_mod_command
-    class Command < BinData::Primitive
-      COMMANDS = {
-        add: 0,
-        modify: 1,
-        modify_strict: 2,
-        delete: 3,
-        delete_strict: 4
-      }
-
-      endian :big
-      uint16 :command
-
-      def get
-        COMMANDS.invert.fetch(command)
-      end
+  module OpenFlow10
+    # OpenFlow 1.0 Flow Mod message.
+    class FlowMod < OpenFlow::Message
+      # enum ofp_flow_mod_command
+      class Command < BinData::Primitive
+        COMMANDS = {
+          add: 0,
+          modify: 1,
+          modify_strict: 2,
+          delete: 3,
+          delete_strict: 4
+        }
 
-      def set(value)
-        self.command = COMMANDS.fetch(value)
-      end
-    end
-
-    # Message body of FlowMod.
-    class Body < BinData::Record
-      # Pio::MatchFormat wrapper.
-      class Match < BinData::Primitive
         endian :big
+        uint16 :command
 
-        string :match, read_length: 40
-
-        def set(object)
-          self.match = object.to_binary_s
+        def get
+          COMMANDS.invert.fetch(command)
         end
 
-        def get
-          Pio::Match.read match
+        def set(value)
+          self.command = COMMANDS.fetch(value)
         end
       end
 
-      extend OpenFlow::Flags
+      # Message body of FlowMod.
+      class Body < BinData::Record
+        # Pio::MatchFormat wrapper.
+        class Match < BinData::Primitive
+          endian :big
+
+          string :match, read_length: 40
+
+          def set(object)
+            self.match = object.to_binary_s
+          end
+
+          def get
+            Pio::OpenFlow10::Match.read match
+          end
+        end
+
+        extend OpenFlow::Flags
 
-      flags_16bit :flags,
-                  [:send_flow_rem,
-                   :check_overwrap,
-                   :emerg]
+        flags_16bit :flags,
+                    [:send_flow_rem,
+                     :check_overwrap,
+                     :emerg]
 
-      endian :big
+        endian :big
 
-      match :match
-      uint64 :cookie
-      command :command
-      uint16 :idle_timeout
-      uint16 :hard_timeout
-      uint16 :priority
-      uint32 :buffer_id
-      uint16 :out_port
-      flags :flags
-      actions :actions, length: -> { open_flow_header.message_length - 72 }
+        match :match
+        uint64 :cookie
+        command :command
+        uint16 :idle_timeout
+        uint16 :hard_timeout
+        uint16 :priority
+        uint32 :buffer_id
+        uint16 :out_port
+        flags :flags
+        actions :actions, length: -> { header.message_length - 72 }
+
+        def empty?
+          false
+        end
 
-      def empty?
-        false
+        def length
+          64 + actions.binary.length
+        end
       end
 
-      def length
-        64 + actions.binary.length
+      # OpenFlow 1.0 Flow Mod message format.
+      class Format < BinData::Record
+        extend OpenFlow::Format
+
+        header version: 1, message_type: 14
+        body :body
       end
-    end
-  end
 
-  OpenFlow::Message.factory(FlowMod, OpenFlow::FLOW_MOD) do
-    def_delegators :body, :match
-    def_delegators :body, :cookie
-    def_delegators :body, :command
-    def_delegators :body, :idle_timeout
-    def_delegators :body, :hard_timeout
-    def_delegators :body, :priority
-    def_delegators :body, :buffer_id
-    def_delegators :body, :out_port
-    def_delegators :body, :flags
-    def_delegators :body, :actions
+      body_option :actions
+      body_option :buffer_id
+      body_option :command
+      body_option :cookie
+      body_option :flags
+      body_option :match
+      body_option :out_port
+      body_option :priority
+    end
   end
 end

data/lib/pio/open_flow10/hello.rb

@@ -1,8 +1,23 @@
-require 'pio/open_flow'
+require 'pio/open_flow/format'
+require 'pio/open_flow/message'
 
 # Base module.
 module Pio
-  # OpenFlow 1.0 Hello message
-  class Hello; end
-  OpenFlow::Message.factory(Hello, OpenFlow::HELLO)
+  # OpenFlow 1.0 messages
+  module OpenFlow10
+    # OpenFlow 1.0 Hello message
+    class Hello < OpenFlow::Message
+      # OpenFlow 1.0 Hello message format
+      class Format < BinData::Record
+        extend OpenFlow::Format
+
+        header version: 1, message_type: 0
+        string :body
+
+        def user_data
+          body
+        end
+      end
+    end
+  end
 end

data/lib/pio/open_flow10/match.rb

@@ -5,159 +5,161 @@ require 'pio/type/ip_address'
 require 'pio/type/mac_address'
 
 module Pio
-  # Fields to match against flows
-  class Match
-    # Flow wildcards
-    class Wildcards < BinData::Primitive
-      BITS = {
-        in_port: 1 << 0,
-        vlan_vid: 1 << 1,
-        ether_source_address: 1 << 2,
-        ether_destination_address: 1 << 3,
-        ether_type: 1 << 4,
-        ip_protocol: 1 << 5,
-        transport_source_port: 1 << 6,
-        transport_destination_port: 1 << 7,
-        ip_source_address: 0,
-        ip_source_address0: 1 << 8,
-        ip_source_address1: 1 << 9,
-        ip_source_address2: 1 << 10,
-        ip_source_address3: 1 << 11,
-        ip_source_address4: 1 << 12,
-        ip_source_address_all: 1 << 13,
-        ip_destination_address: 0,
-        ip_destination_address0: 1 << 14,
-        ip_destination_address1: 1 << 15,
-        ip_destination_address2: 1 << 16,
-        ip_destination_address3: 1 << 17,
-        ip_destination_address4: 1 << 18,
-        ip_destination_address_all: 1 << 19,
-        vlan_priority: 1 << 20,
-        ip_tos: 1 << 21
-      }
-      NW_FLAGS = [:ip_source_address, :ip_destination_address]
-      FLAGS = BITS.keys.select { |each| !(/^ip_(source|destination)/=~ each) }
-
-      endian :big
-
-      uint32 :flags
+  module OpenFlow10
+    # Fields to match against flows
+    class Match
+      # Flow wildcards
+      class Wildcards < BinData::Primitive
+        BITS = {
+          in_port: 1 << 0,
+          vlan_vid: 1 << 1,
+          ether_source_address: 1 << 2,
+          ether_destination_address: 1 << 3,
+          ether_type: 1 << 4,
+          ip_protocol: 1 << 5,
+          transport_source_port: 1 << 6,
+          transport_destination_port: 1 << 7,
+          ip_source_address: 0,
+          ip_source_address0: 1 << 8,
+          ip_source_address1: 1 << 9,
+          ip_source_address2: 1 << 10,
+          ip_source_address3: 1 << 11,
+          ip_source_address4: 1 << 12,
+          ip_source_address_all: 1 << 13,
+          ip_destination_address: 0,
+          ip_destination_address0: 1 << 14,
+          ip_destination_address1: 1 << 15,
+          ip_destination_address2: 1 << 16,
+          ip_destination_address3: 1 << 17,
+          ip_destination_address4: 1 << 18,
+          ip_destination_address_all: 1 << 19,
+          vlan_priority: 1 << 20,
+          ip_tos: 1 << 21
+        }
+        NW_FLAGS = [:ip_source_address, :ip_destination_address]
+        FLAGS = BITS.keys.select { |each| !(/^ip_(source|destination)/=~ each) }
+
+        endian :big
+
+        uint32 :flags
+
+        # This method smells of :reek:FeatureEnvy
+        def get
+          BITS.each_with_object(Hash.new(0)) do |(key, bit), memo|
+            next if flags & bit == 0
+            if /(ip_source_address|ip_destination_address)(\d)/=~ key
+              memo[$LAST_MATCH_INFO[1].intern] |= 1 << $LAST_MATCH_INFO[2].to_i
+            else
+              memo[key] = true
+            end
+          end
+        end
 
-      # This method smells of :reek:FeatureEnvy
-      def get
-        BITS.each_with_object(Hash.new(0)) do |(key, bit), memo|
-          next if flags & bit == 0
-          if /(ip_source_address|ip_destination_address)(\d)/=~ key
-            memo[$LAST_MATCH_INFO[1].intern] |= 1 << $LAST_MATCH_INFO[2].to_i
-          else
-            memo[key] = true
+        def set(params)
+          self.flags = params.inject(0) do |memo, (key, val)|
+            memo | case key
+                   when :ip_source_address, :ip_destination_address
+                     (params.fetch(key) & 31) <<
+                       (key == :ip_source_address ? 8 : 14)
+                   else
+                     val ? BITS.fetch(key) : 0
+                   end
           end
         end
-      end
 
-      def set(params)
-        self.flags = params.inject(0) do |memo, (key, val)|
-          memo | case key
-                 when :ip_source_address, :ip_destination_address
-                   (params.fetch(key) & 31) <<
-                     (key == :ip_source_address ? 8 : 14)
-                 else
-                   val ? BITS.fetch(key) : 0
-                 end
+        def ip_source_address
+          get.fetch(:ip_source_address)
+        rescue KeyError
+          0
         end
-      end
 
-      def ip_source_address
-        get.fetch(:ip_source_address)
-      rescue KeyError
-        0
+        def ip_destination_address
+          get.fetch(:ip_destination_address)
+        rescue KeyError
+          0
+        end
       end
 
-      def ip_destination_address
-        get.fetch(:ip_destination_address)
-      rescue KeyError
-        0
-      end
-    end
+      # IP address
+      class MatchIpAddress < BinData::Primitive
+        default_parameter bitcount: 0
 
-    # IP address
-    class MatchIpAddress < BinData::Primitive
-      default_parameter bitcount: 0
+        array :octets, type: :uint8, initial_length: 4
 
-      array :octets, type: :uint8, initial_length: 4
+        def set(value)
+          self.octets = IPv4Address.new(value).to_a
+        end
 
-      def set(value)
-        self.octets = IPv4Address.new(value).to_a
-      end
+        def get
+          ipaddr = octets.map { |each| format('%d', each) }.join('.')
+          prefixlen = 32 - eval_parameter(:bitcount)
+          IPv4Address.new(ipaddr + "/#{prefixlen}")
+        end
 
-      def get
-        ipaddr = octets.map { |each| format('%d', each) }.join('.')
-        prefixlen = 32 - eval_parameter(:bitcount)
-        IPv4Address.new(ipaddr + "/#{prefixlen}")
+        def ==(other)
+          get == other
+        end
       end
 
-      def ==(other)
-        get == other
+      # ofp_match format
+      class MatchFormat < BinData::Record
+        endian :big
+
+        wildcards :wildcards
+        uint16 :in_port
+        mac_address :ether_source_address
+        mac_address :ether_destination_address
+        uint16 :vlan_vid
+        uint8 :vlan_priority
+        uint8 :padding1
+        hide :padding1
+        uint16 :ether_type
+        uint8 :ip_tos
+        uint8 :ip_protocol
+        uint16 :padding2
+        hide :padding2
+        match_ip_address :ip_source_address,
+                         bitcount: -> { wildcards.ip_source_address }
+        match_ip_address :ip_destination_address,
+                         bitcount: -> { wildcards.ip_destination_address }
+        uint16 :transport_source_port
+        uint16 :transport_destination_port
       end
-    end
 
-    # ofp_match format
-    class MatchFormat < BinData::Record
-      endian :big
-
-      wildcards :wildcards
-      uint16 :in_port
-      mac_address :ether_source_address
-      mac_address :ether_destination_address
-      uint16 :vlan_vid
-      uint8 :vlan_priority
-      uint8 :padding1
-      hide :padding1
-      uint16 :ether_type
-      uint8 :ip_tos
-      uint8 :ip_protocol
-      uint16 :padding2
-      hide :padding2
-      match_ip_address :ip_source_address,
-                       bitcount: -> { wildcards.ip_source_address }
-      match_ip_address :ip_destination_address,
-                       bitcount: -> { wildcards.ip_destination_address }
-      uint16 :transport_source_port
-      uint16 :transport_destination_port
-    end
-
-    def self.read(binary)
-      MatchFormat.read binary
-    end
-
-    # rubocop:disable MethodLength
-    # This method smells of :reek:FeatureEnvy
-    # This method smells of :reek:DuplicateMethodCall
-    def initialize(user_options)
-      flags = Wildcards::FLAGS.each_with_object({}) do |each, memo|
-        memo[each] = true unless user_options.key?(each)
+      def self.read(binary)
+        MatchFormat.read binary
       end
-      Wildcards::NW_FLAGS.each_with_object(flags) do |each, memo|
-        if user_options.key?(each)
-          memo[each] = 32 - IPv4Address.new(user_options[each]).prefixlen
-        else
-          memo["#{each}_all".intern] = true
+
+      # rubocop:disable MethodLength
+      # This method smells of :reek:FeatureEnvy
+      # This method smells of :reek:DuplicateMethodCall
+      def initialize(user_options)
+        flags = Wildcards::FLAGS.each_with_object({}) do |each, memo|
+          memo[each] = true unless user_options.key?(each)
+        end
+        Wildcards::NW_FLAGS.each_with_object(flags) do |each, memo|
+          if user_options.key?(each)
+            memo[each] = 32 - IPv4Address.new(user_options[each]).prefixlen
+          else
+            memo["#{each}_all".intern] = true
+          end
         end
+        @format = MatchFormat.new({ wildcards: flags }.merge user_options)
       end
-      @format = MatchFormat.new({ wildcards: flags }.merge user_options)
-    end
-    # rubocop:enable MethodLength
+      # rubocop:enable MethodLength
 
-    def to_binary
-      @format.to_binary_s
-    end
+      def to_binary
+        @format.to_binary_s
+      end
 
-    def ==(other)
-      return false unless other
-      to_binary == other.to_binary
-    end
+      def ==(other)
+        return false unless other
+        to_binary == other.to_binary
+      end
 
-    def method_missing(method, *args, &block)
-      @format.__send__ method, *args, &block
+      def method_missing(method, *args, &block)
+        @format.__send__ method, *args, &block
+      end
     end
   end
 end