pio 0.30.0 → 0.30.2

data/lib/pio/open_flow13/match.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'bindata'
+require 'pio/open_flow/flow_match'
 require 'pio/type/ip_address'
 require 'pio/type/ipv6_address'
 require 'pio/type/mac_address'
@@ -11,7 +14,7 @@ module Pio
     MATCH_TYPE_OXM = 1
 
     # OpenFlow eXtensible Match (OXM)
-    class Match
+    class Match < OpenFlow::FlowMatch
       # OFPXMC_NXM_1 TLV value
       class NiciraMatchExtensionValue < BinData::Record
         OXM_CLASS = 0x1
@@ -22,6 +25,11 @@ module Pio
         OXM_CLASS = 0x8000
       end
 
+      # OFPXMC_PACKET_REGS TLV value
+      class PacketRegistersValue < BinData::Record
+        OXM_CLASS = 0x8001
+      end
+
       # OFPXMC_EXPERIMENTER TLV value
       class ExperimenterValue < BinData::Record
         OXM_CLASS = 0xFFFF
@@ -759,6 +767,105 @@ module Pio
         end
       end
 
+      # OXM_PACKET_REG0 match field
+      class PacketReg0 < PacketRegistersValue
+        OXM_FIELD = 0
+
+        endian :big
+
+        uint64 :packet_reg0
+
+        def length
+          8
+        end
+      end
+
+      # Masked OXM_PACKET_REG0 match field
+      class MaskedPacketReg0 < PacketRegistersValue
+        endian :big
+
+        uint64 :packet_reg0
+        uint64 :packet_reg0_mask
+
+        def length
+          16
+        end
+      end
+      # OXM_PACKET_REG1 match field
+      class PacketReg1 < PacketRegistersValue
+        OXM_FIELD = 1
+
+        endian :big
+
+        uint64 :packet_reg1
+
+        def length
+          8
+        end
+      end
+
+      # Masked OXM_PACKET_REG1 match field
+      class MaskedPacketReg1 < PacketRegistersValue
+        endian :big
+
+        uint64 :packet_reg1
+        uint64 :packet_reg1_mask
+
+        def length
+          16
+        end
+      end
+
+      # OXM_PACKET_REG2 match field
+      class PacketReg2 < PacketRegistersValue
+        OXM_FIELD = 2
+
+        endian :big
+
+        uint64 :packet_reg2
+
+        def length
+          8
+        end
+      end
+
+      # Masked OXM_PACKET_REG2 match field
+      class MaskedPacketReg2 < PacketRegistersValue
+        endian :big
+
+        uint64 :packet_reg2
+        uint64 :packet_reg2_mask
+
+        def length
+          16
+        end
+      end
+
+      # OXM_PACKET_REG3 match field
+      class PacketReg3 < PacketRegistersValue
+        OXM_FIELD = 3
+
+        endian :big
+
+        uint64 :packet_reg3
+
+        def length
+          8
+        end
+      end
+
+      # Masked OXM_PACKET_REG3 match field
+      class MaskedPacketReg3 < PacketRegistersValue
+        endian :big
+
+        uint64 :packet_reg3
+        uint64 :packet_reg3_mask
+
+        def length
+          16
+        end
+      end
+
       # OXM format
       class Oxm < BinData::Record
         # Experimenter part, data will use oxm_length
@@ -840,7 +947,7 @@ module Pio
             when Reg7::OXM_FIELD
               masked? ? MaskedReg7 : Reg7
             else
-              fail "Unknown OXM field value: #{oxm_field}"
+              raise "Unknown OXM field value: #{oxm_field}"
             end
           end
           # rubocop:enable AbcSize
@@ -998,7 +1105,7 @@ module Pio
             when TunnelId::OXM_FIELD
               masked? ? MaskedTunnelId : TunnelId
             else
-              fail "Unknown OXM field value: #{oxm_field}"
+              raise "Unknown OXM field value: #{oxm_field}"
             end
           end
           # rubocop:enable MethodLength
@@ -1008,6 +1115,58 @@ module Pio
         end
         # rubocop:enable MethodLength
 
+        # Packet Register match field.
+        class PacketRegisters < BinData::Record
+          endian :big
+
+          bit7 :oxm_field
+          bit1 :oxm_hasmask
+          uint8 :oxm_length, value: -> { tlv_value.length }
+          choice :tlv_value, selection: :choose_tlv_value do
+            packet_reg0 PacketReg0
+            masked_packet_reg0 MaskedPacketReg0
+            packet_reg1 PacketReg1
+            masked_packet_reg1 MaskedPacketReg1
+            packet_reg2 PacketReg2
+            masked_packet_reg2 MaskedPacketReg2
+            packet_reg3 PacketReg3
+            masked_packet_reg3 MaskedPacketReg3
+          end
+
+          def length
+            tlv_value.length + 2
+          end
+
+          def masked?
+            oxm_hasmask == 1
+          end
+
+          def method_missing(method, *args, &block)
+            tlv_value.__send__ method, *args, &block
+          end
+
+          private
+
+          # rubocop:disable CyclomaticComplexity
+          # rubocop:disable MethodLength
+          def choose_tlv_value
+            case oxm_field
+            when PacketReg0::OXM_FIELD
+              masked? ? MaskedPacketReg0 : PacketReg0
+            when PacketReg1::OXM_FIELD
+              masked? ? MaskedPacketReg1 : PacketReg1
+            when PacketReg2::OXM_FIELD
+              masked? ? MaskedPacketReg2 : PacketReg2
+            when PacketReg3::OXM_FIELD
+              masked? ? MaskedPacketReg3 : PacketReg3
+            else
+              raise "Unknown OXM field value: #{oxm_field}"
+            end
+          end
+          # rubocop:enable CyclomaticComplexity
+          # rubocop:enable MethodLength
+        end
+
         # OXM match field.
         class MatchField < BinData::Record
           endian :big
@@ -1017,6 +1176,7 @@ module Pio
             NiciraMatchExtension NiciraMatchExtensionValue::OXM_CLASS
             OpenflowBasic OpenFlowBasicValue::OXM_CLASS
             Experimenter ExperimenterValue::OXM_CLASS
+            PacketRegisters PacketRegistersValue::OXM_CLASS
           end
 
           def oxm_field
@@ -1038,11 +1198,13 @@ module Pio
           def method_missing(method, *args, &block)
             case oxm_class
             when OpenFlowBasicValue::OXM_CLASS
-              return class_payload.tlv_value.__send__(method, *args, &block)
+              class_payload.tlv_value.__send__(method, *args, &block)
             when ExperimenterValue::OXM_CLASS
-              return class_payload.__send__(method, *args, &block)
+              class_payload.__send__(method, *args, &block)
+            when PacketRegistersValue::OXM_CLASS
+              class_payload.__send__(method, *args, &block)
             else
-              fail NoMethodError, method.to_s
+              raise NoMethodError, method.to_s
             end
           end
         end
@@ -1062,18 +1224,21 @@ module Pio
           match_length + padding_length
         end
 
+        # rubocop:disable AbcSize
         # rubocop:disable Next
         # rubocop:disable LineLength
         def method_missing(method, *args, &block)
           match_fields.each do |each|
-            if each.oxm_class == OpenFlowBasicValue::OXM_CLASS || each.oxm_class == NiciraMatchExtensionValue::OXM_CLASS
+            if each.oxm_class == OpenFlowBasicValue::OXM_CLASS || each.oxm_class == NiciraMatchExtensionValue::OXM_CLASS || each.oxm_class == PacketRegistersValue::OXM_CLASS
               next unless each.class_payload.tlv_value.respond_to?(method)
               return each.class_payload.tlv_value.__send__(
-                method, *args, &block)
+                method, *args, &block
+              )
             end
           end
-          fail NoMethodError, method.to_s
+          raise NoMethodError, method.to_s
         end
+        # rubocop:enable AbcSize
         # rubocop:enable Next
         # rubocop:enable LineLength
 
@@ -1084,7 +1249,7 @@ module Pio
         end
 
         def tlv_total_length
-          if match_fields.size > 0
+          if !match_fields.empty?
             match_fields.map(&:length).inject(&:+)
           else
             0
@@ -1104,11 +1269,11 @@ module Pio
         def initialize(user_attrs)
           @match_fields = []
 
-          [:in_port, :ether_type, :ip_protocol, :vlan_vid, :vlan_pcp,
-           :ip_dscp, :ip_ecn, :tcp_source_port, :tcp_destination_port,
-           :udp_source_port, :udp_destination_port,
-           :sctp_source_port, :sctp_destination_port,
-           :icmpv4_type, :icmpv4_code, :arp_operation].each do |each|
+          %i[in_port ether_type ip_protocol vlan_vid vlan_pcp
+             ip_dscp ip_ecn tcp_source_port tcp_destination_port
+             udp_source_port udp_destination_port
+             sctp_source_port sctp_destination_port
+             icmpv4_type icmpv4_code arp_operation].each do |each|
             next unless user_attrs.key?(each)
             klass = Match.const_get(each.to_s.split('_').map(&:capitalize).join)
             @match_fields << { oxm_class: klass.superclass.const_get(:OXM_CLASS),
@@ -1116,12 +1281,13 @@ module Pio
                                                 tlv_value: { each => user_attrs.fetch(each) } } }
           end
 
-          [:metadata, :destination_mac_address, :source_mac_address,
-           :ipv4_source_address, :ipv4_destination_address,
-           :arp_sender_protocol_address, :arp_target_protocol_address,
-           :arp_sender_hardware_address, :arp_target_hardware_address,
-           :ipv6_source_address, :ipv6_destination_address, :tunnel_id,
-           :reg0, :reg1, :reg2, :reg3, :reg4, :reg5, :reg6, :reg7].each do |each|
+          %i[metadata destination_mac_address source_mac_address
+             ipv4_source_address ipv4_destination_address
+             arp_sender_protocol_address arp_target_protocol_address
+             arp_sender_hardware_address arp_target_hardware_address
+             ipv6_source_address ipv6_destination_address tunnel_id
+             reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7
+             packet_reg0 packet_reg1 packet_reg2 packet_reg3].each do |each|
             next unless user_attrs.key?(each)
             klass = Match.const_get(each.to_s.split('_').map(&:capitalize).join)
             mask_key = "#{each}_mask".to_sym

data/lib/pio/open_flow13/meter.rb

@@ -1,33 +1,38 @@
+# frozen_string_literal: true
+
 require 'forwardable'
+require 'pio/open_flow/instruction'
 
 # Base module.
 module Pio
-  # Apply meter (rate limiter)
-  class Meter
-    # OpenFlow 1.3.4 OFPIT_METER instruction format
-    class Format < BinData::Record
-      endian :big
+  module OpenFlow13
+    # Apply meter (rate limiter)
+    class Meter < OpenFlow::Instruction
+      # OpenFlow 1.3.4 OFPIT_METER instruction format
+      class Format < BinData::Record
+        endian :big
 
-      uint16 :instruction_type, value: 6
-      uint16 :instruction_length, value: 8
-      uint32 :meter_id
-    end
+        uint16 :instruction_type, value: 6
+        uint16 :instruction_length, value: 8
+        uint32 :meter_id
+      end
 
-    def self.read(raw_data)
-      allocate.tap do |meter|
-        meter.instance_variable_set :@format, Format.read(raw_data)
+      def self.read(raw_data)
+        allocate.tap do |meter|
+          meter.instance_variable_set :@format, Format.read(raw_data)
+        end
       end
-    end
 
-    extend Forwardable
+      extend Forwardable
 
-    def_delegators :@format, :instruction_type
-    def_delegators :@format, :instruction_length
-    def_delegators :@format, :meter_id
-    def_delegators :@format, :to_binary_s
+      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)
+      def initialize(meter_id)
+        @format = Format.new(meter_id: meter_id)
+      end
     end
   end
 end

data/lib/pio/open_flow13/nicira_conjunction.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'pio/open_flow/nicira_action'
+
+module Pio
+  module OpenFlow13
+    # NXAST_CONJUNCTION action
+    class NiciraConjunction < OpenFlow::NiciraAction
+      nicira_action_header action_type: 0xffff,
+                           action_length: 16,
+                           subtype: 34
+      uint8 :_clause
+      uint8 :n_clauses
+      uint32 :conjunction_id
+
+      def initialize(options)
+        super(_clause: options[:clause] - 1,
+              n_clauses: options[:n_clauses],
+              conjunction_id: options[:conjunction_id])
+      end
+
+      def clause
+        _clause + 1
+      end
+    end
+  end
+  NiciraConjunction = OpenFlow13::NiciraConjunction
+end

data/lib/pio/open_flow13/nicira_reg_load.rb

@@ -1,43 +1,65 @@
-require 'active_support/core_ext/string/inflections'
-require 'pio/open_flow/action'
+# frozen_string_literal: true
+
+require 'pio/open_flow/nicira_action'
+require 'pio/open_flow13/match'
 
 module Pio
   module OpenFlow13
     # NXAST_REG_LOAD action
-    class NiciraRegLoad < OpenFlow::Action
-      action_header action_type: 0xffff, action_length: 24
-      uint32 :experimenter_id, value: 0x2320
-      uint16 :experimenter_type, value: 7
-      bit10 :offset_internal, initial_value: 0
-      bit6 :n_bits_internal
-      uint32 :destination_internal
-      uint64 :value_internal
-
-      attr_reader :destination
+    class NiciraRegLoad < OpenFlow::NiciraAction
+      nicira_action_header action_type: 0xffff,
+                           action_length: 24,
+                           subtype: 7
+      bit10 :_offset, initial_value: 0
+      bit6 :_n_bits
+      struct :_destination do
+        uint16 :oxm_class
+        bit7 :oxm_field
+        bit1 :oxm_hasmask, value: 0
+        bit8 :oxm_length
+      end
+      uint64 :_value
 
-      # rubocop:disable AbcSize
-      # rubocop:disable LineLength
       def initialize(value, destination, options = {})
         @destination = destination
-        oxm_klass = Match.const_get(destination.to_s.split('_').map(&:capitalize).join)
-        super(value_internal: value,
-              offset_internal: options[:offset] || 0,
-              n_bits_internal: options[:n_bits] ? options[:n_bits] - 1 : oxm_klass.new.length * 8 - 1,
-              destination_internal: ((oxm_klass.superclass.const_get(:OXM_CLASS) << 16) | (oxm_klass.const_get(:OXM_FIELD) << 9) | oxm_klass.new.length))
+        super(_value: value,
+              _offset: options[:offset] || 0,
+              _n_bits: (options[:n_bits] || oxm_length * 8) - 1,
+              _destination: { oxm_class: oxm_class,
+                              oxm_field: oxm_field,
+                              oxm_length: oxm_length })
       end
-      # rubocop:enable AbcSize
-      # rubocop:enable LineLength
+
+      attr_reader :destination
 
       def offset
-        offset_internal
+        _offset
       end
 
       def n_bits
-        n_bits_internal + 1
+        _n_bits + 1
       end
 
       def value
-        value_internal
+        _value
+      end
+
+      private
+
+      def oxm_class
+        destination_oxm_class.const_get(:OXM_CLASS)
+      end
+
+      def oxm_field
+        destination_oxm_class.const_get(:OXM_FIELD)
+      end
+
+      def oxm_length
+        destination_oxm_class.new.length
+      end
+
+      def destination_oxm_class
+        Match.const_get(@destination.to_s.split('_').map(&:capitalize).join)
       end
     end
   end

data/lib/pio/open_flow13/nicira_reg_move.rb

@@ -1,42 +1,86 @@
-require 'active_support/core_ext/string/inflections'
-require 'pio/open_flow/action'
+# frozen_string_literal: true
+
+require 'pio/open_flow/nicira_action'
+require 'pio/open_flow13/match'
 
 module Pio
   module OpenFlow13
     # NXAST_REG_MOVE action
-    class NiciraRegMove < OpenFlow::Action
-      action_header action_type: 0xffff, action_length: 24
-      uint32 :experimenter_id, value: 0x2320
-      uint16 :experimenter_type, value: 6
-      uint16 :n_bits, initial_value: -> { source_oxm_length * 8 }
-      uint16 :source_offset, value: 0
-      uint16 :destination_offset, value: 0
-      uint16 :source_oxm_class
-      bit7 :source_oxm_field
-      bit1 :source_oxm_hasmask, value: 0
-      uint8 :source_oxm_length
-      uint16 :destination_oxm_class
-      bit7 :destination_oxm_field
-      bit1 :destination_oxm_hasmask, value: 0
-      uint8 :destination_oxm_length
-
-      attr_reader :from
-      attr_reader :to
-
-      # rubocop:disable AbcSize
-      def initialize(options)
-        @from = options.fetch(:from)
-        @to = options.fetch(:to)
-        from_klass = Match.const_get(@from.to_s.classify)
-        to_klass = Match.const_get(@to.to_s.classify)
-        super(source_oxm_class: from_klass.superclass.const_get(:OXM_CLASS),
-              source_oxm_field: from_klass.const_get(:OXM_FIELD),
-              source_oxm_length: from_klass.new.length,
-              destination_oxm_class: to_klass.superclass.const_get(:OXM_CLASS),
-              destination_oxm_field: to_klass.const_get(:OXM_FIELD),
-              destination_oxm_length: to_klass.new.length)
-      end
-      # rubocop:enable AbcSize
+    class NiciraRegMove < OpenFlow::NiciraAction
+      nicira_action_header action_type: 0xffff,
+                           action_length: 24,
+                           subtype: 6
+      uint16 :n_bits, initial_value: -> { _source[:oxm_length] * 8 }
+      uint16 :source_offset, initial_value: 0
+      uint16 :destination_offset, initial_value: 0
+      struct :_source do
+        uint16 :oxm_class
+        bit7 :oxm_field
+        bit1 :oxm_hasmask, value: 0
+        uint8 :oxm_length
+      end
+      struct :_destination do
+        uint16 :oxm_class
+        bit7 :oxm_field
+        bit1 :oxm_hasmask, value: 0
+        uint8 :oxm_length
+      end
+
+      # rubocop:disable MethodLength
+      def initialize(arguments)
+        @source = arguments.fetch(:source)
+        @destination = arguments.fetch(:destination)
+        registers = { _source: { oxm_class: source_oxm_class,
+                                 oxm_field: source_oxm_field,
+                                 oxm_length: source_oxm_length },
+                      _destination: { oxm_class: destination_oxm_class,
+                                      oxm_field: destination_oxm_field,
+                                      oxm_length: destination_oxm_length } }
+        options = %i[n_bits
+                     source_offset
+                     destination_offset].each_with_object({}) do |each, opts|
+          opts[each] = arguments[each] if arguments[each]
+        end
+        super registers.merge(options)
+      end
+      # rubocop:enable MethodLength
+
+      attr_reader :source
+      attr_reader :destination
+
+      private
+
+      def source_oxm_class
+        source_class.const_get(:OXM_CLASS)
+      end
+
+      def source_oxm_field
+        source_class.const_get(:OXM_FIELD)
+      end
+
+      def source_oxm_length
+        source_class.new.length
+      end
+
+      def source_class
+        Match.const_get(@source.to_s.split('_').map(&:capitalize).join)
+      end
+
+      def destination_oxm_class
+        destination_class.const_get(:OXM_CLASS)
+      end
+
+      def destination_oxm_field
+        destination_class.const_get(:OXM_FIELD)
+      end
+
+      def destination_oxm_length
+        destination_class.new.length
+      end
+
+      def destination_class
+        Match.const_get(@destination.to_s.split('_').map(&:capitalize).join)
+      end
     end
   end
 end

data/lib/pio/open_flow13/nicira_send_out_port.rb

@@ -1,37 +1,55 @@
-require 'pio/open_flow/action'
+# frozen_string_literal: true
+
+require 'pio/open_flow/nicira_action'
+require 'pio/open_flow13/match'
+require 'pio/open_flow13/send_out_port'
 
 module Pio
   module OpenFlow13
     # NXAST_OUTPUT_REG action
-    class NiciraSendOutPort < OpenFlow::Action
-      action_header action_type: 0xffff, action_length: 24
-      uint32 :experimenter_id, value: 0x2320
-      uint16 :experimenter_type, value: 15
-      bit10 :offset_internal, value: 0
-      bit6 :n_bits_internal
-      uint32 :source_internal
-      uint16 :max_length, value: 0
+    class NiciraSendOutPort < OpenFlow::NiciraAction
+      nicira_action_header action_type: 0xffff,
+                           action_length: 24,
+                           subtype: 15
+      bit10 :_offset
+      bit6 :_n_bits
+      struct :_source do
+        uint16 :oxm_class
+        bit7 :oxm_field
+        bit1 :oxm_hasmask, value: 0
+        bit8 :oxm_length
+      end
+      uint16 :max_length
       string :zero, length: 6
 
-      attr_reader :source
-
-      # rubocop:disable AbcSize
-      # rubocop:disable LineLength
-      def initialize(source)
+      def initialize(source, options = {})
         @source = source
-        oxm_klass = Match.const_get(source.to_s.split('_').map(&:capitalize).join)
-        super(n_bits_internal: oxm_klass.new.length * 8 - 1,
-              source_internal: ((oxm_klass.superclass.const_get(:OXM_CLASS) << 16) | (oxm_klass.const_get(:OXM_FIELD) << 9) | oxm_klass.new.length))
+        super(_n_bits: (options[:n_bits] || oxm_length * 8) - 1,
+              _offset: options[:offset] || 0,
+              _source: { oxm_class: source_oxm_class.const_get(:OXM_CLASS),
+                         oxm_field: source_oxm_class.const_get(:OXM_FIELD),
+                         oxm_length: oxm_length },
+              max_length: options[:max_length] || SendOutPort::NO_BUFFER)
       end
-      # rubocop:enable AbcSize
-      # rubocop:enable LineLength
+
+      attr_reader :source
 
       def offset
-        offset_internal
+        _offset
       end
 
       def n_bits
-        n_bits_internal + 1
+        _n_bits + 1
+      end
+
+      private
+
+      def oxm_length
+        source_oxm_class.new.length
+      end
+
+      def source_oxm_class
+        Match.const_get(@source.to_s.split('_').map(&:capitalize).join)
       end
     end
   end