pio 0.20.1 → 0.21.0

data/features/open_flow13/meter.feature

@@ -0,0 +1,26 @@
+Feature: Pio::Meter
+  Background:
+    Given I use OpenFlow 1.3
+
+  Scenario: new(1)
+    When I try to create an OpenFlow instruction with:
+    """
+    Pio::Meter.new(1)
+    """
+    Then it should finish successfully
+    And the message have the following fields and values:
+    | field              |      value |
+    | class              | Pio::Meter |
+    | instruction_type   |          6 |
+    | instruction_length |          8 |
+    | meter_id           |          1 |
+
+  Scenario: read
+    When I try to parse a file named "open_flow13/instruction_meter.raw" with "Pio::Meter" class
+    Then it should finish successfully
+    And the message have the following fields and values:
+      | field              |      value |
+      | class              | Pio::Meter |
+      | instruction_type   |          6 |
+      | instruction_length |          8 |
+      | meter_id           |          1 |

data/features/open_flow13/send_out_port.feature

@@ -0,0 +1,28 @@
+Feature: Pio::SendOutPort
+  Background:
+    Given I use OpenFlow 1.3
+
+  Scenario: new(1)
+    When I try to create an OpenFlow action with:
+      """
+      Pio::SendOutPort.new(1)
+      """
+    Then it should finish successfully
+    And the message have the following fields and values:
+      | field         |            value |
+      | class         | Pio::SendOutPort |
+      | action_type   |                0 |
+      | action_length |               16 |
+      | port          |                1 |
+      | max_length    |       :no_buffer |
+
+  Scenario: read
+    When I try to parse a file named "open_flow13/send_out_port.raw" with "Pio::SendOutPort" class
+    Then it should finish successfully
+    And the message have the following fields and values:
+      | field         |            value |
+      | class         | Pio::SendOutPort |
+      | action_type   |                0 |
+      | action_length |               16 |
+      | port          |                1 |
+      | max_length    |       :no_buffer |

data/features/open_flow13/write_metadata.feature

@@ -0,0 +1,28 @@
+Feature: Pio::WriteMetadata
+  Background:
+    Given I use OpenFlow 1.3
+
+  Scenario: new(metadata: 1)
+    When I try to create an OpenFlow instruction with:
+      """
+      Pio::WriteMetadata.new(metadata: 1)
+      """
+    Then it should finish successfully
+    And the message have the following fields and values:
+      | field              |              value |
+      | class              | Pio::WriteMetadata |
+      | instruction_type   |                  2 |
+      | instruction_length |                 24 |
+      | metadata           |                  1 |
+      | metadata_mask      |                  0 |
+
+  Scenario: read
+    When I try to parse a file named "open_flow13/instruction_write_metadata.raw" with "Pio::WriteMetadata" class
+    Then it should finish successfully
+    And the message have the following fields and values:
+      | field              |              value |
+      | class              | Pio::WriteMetadata |
+      | instruction_type   |                  2 |
+      | instruction_length |                 24 |
+      | metadata           |                  1 |
+      | metadata_mask      |                  1 |

data/features/step_definitions/open_flow_steps.rb

@@ -1,3 +1,23 @@
 Given(/^I use OpenFlow 1\.3$/) do
   require 'pio/open_flow13'
 end
+
+When(/^I try to create a packet with:$/) do |ruby_code|
+  begin
+    @result = Pio.module_eval(ruby_code)
+  rescue
+    @last_error = $ERROR_INFO
+  end
+end
+
+When(/^I try to create an OpenFlow message with:$/) do |ruby_code|
+  step 'I try to create a packet with:', ruby_code
+end
+
+When(/^I try to create an OpenFlow action with:$/) do |ruby_code|
+  step 'I try to create a packet with:', ruby_code
+end
+
+When(/^I try to create an OpenFlow instruction with:$/) do |ruby_code|
+  step 'I try to create a packet with:', ruby_code
+end

data/features/step_definitions/packet_data_steps.rb

@@ -1,15 +1,3 @@
-When(/^I try to create a packet with:$/) do |ruby_code|
-  begin
-    @result = Pio.module_eval(ruby_code)
-  rescue
-    @last_error = $ERROR_INFO
-  end
-end
-
-When(/^I try to create an OpenFlow message with:$/) do |ruby_code|
-  step 'I try to create a packet with:', ruby_code
-end
-
 # rubocop:disable LineLength
 When(/^I try to parse a file named "(.*?\.raw)" with "(.*?)" class$/) do |path, klass|
   full_path = File.expand_path(File.join(__dir__, '..', path))
@@ -54,10 +42,12 @@ end
 
 Then(/^the packet have the following fields and values:$/) do |table|
   table.hashes.each do |each|
-    output = each['field'].split('.').inject(@result) do |memo, method|
-      memo.__send__(method)
+    output = @result.instance_eval("self.#{each['field']}")
+    if /^:/ =~ output.inspect
+      expect(output.inspect).to eq(each['value'])
+    else
+      expect(output.to_s).to eq(each['value'])
     end
-    expect(output.to_s).to eq(each['value'])
   end
 end
 

data/lib/pio/monkey_patch/integer.rb

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

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

@@ -0,0 +1,10 @@
+module MonkeyPatch
+  module Integer
+    # to_hex etc.
+    module BaseConversions
+      def to_hex
+        format '%#x', self
+      end
+    end
+  end
+end

data/lib/pio/open_flow.rb

@@ -14,9 +14,7 @@ module Pio
   end
 end
 
-require 'pio/open_flow/actions'
 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'

data/lib/pio/open_flow10.rb

@@ -5,6 +5,7 @@ module Pio
   end
 end
 
+require 'pio/open_flow10/actions'
 require 'pio/open_flow10/echo'
 require 'pio/open_flow10/exact_match'
 require 'pio/open_flow10/features'

data/lib/pio/{open_flow → open_flow10}/actions.rb

@@ -1,6 +1,6 @@
 require 'bindata'
 require 'pio/enqueue'
-require 'pio/send_out_port'
+require 'pio/open_flow10/send_out_port'
 require 'pio/set_ether_address'
 require 'pio/set_ip_address'
 require 'pio/set_ip_tos'

data/lib/pio/open_flow10/echo.rb

@@ -1,5 +1,6 @@
 require 'forwardable'
 require 'pio/open_flow'
+require 'pio/open_flow10/message'
 
 module Pio
   # OpenFlow 1.0 Echo Request and Reply message.

data/lib/pio/{open_flow → open_flow10}/message.rb

@@ -1,6 +1,7 @@
 require 'English'
 require 'bindata'
 require 'forwardable'
+require 'pio/open_flow/open_flow_header'
 require 'pio/parse_error'
 
 module Pio

data/lib/pio/open_flow13.rb

@@ -6,11 +6,17 @@ module Pio
   end
 end
 
+require 'pio/open_flow13/apply'
+require 'pio/open_flow13/goto_table'
+require 'pio/open_flow13/write_metadata'
+require 'pio/open_flow13/meter'
 require 'pio/open_flow13/echo'
 require 'pio/open_flow13/features_reply'
 require 'pio/open_flow13/features_request'
+require 'pio/open_flow13/flow_mod'
 require 'pio/open_flow13/hello'
 require 'pio/open_flow13/match'
+require 'pio/open_flow13/send_out_port'
 
 # Base module.
 module Pio

data/lib/pio/open_flow13/apply.rb

@@ -0,0 +1,74 @@
+require 'bindata'
+require 'forwardable'
+
+module Pio
+  # An instruction to apply a list of actions to a packet in-order.
+  class Apply
+    # Actions not yet implemented.
+    class UnsupportedAction < BinData::Record
+      endian :big
+
+      uint16 :action_type
+      uint16 :action_length
+    end
+
+    # Actions list of actions-apply instruction.
+    class Actions < BinData::Primitive
+      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
+      def get
+        actions = []
+        tmp = binary
+        while tmp.length > 0
+          action = case BinData::Uint16be.read(tmp)
+                   when 0
+                     SendOutPort.read(tmp)
+                   else
+                     UnsupportedAction.read(tmp)
+                   end
+          tmp = tmp[action.action_length..-1]
+          actions << action
+        end
+        actions
+      end
+      # rubocop:enable MethodLength
+    end
+
+    # OpenFlow 1.3.4 OFPIT_APPLY_ACTIONS instruction format.
+    class Format < BinData::Record
+      endian :big
+
+      uint16 :instruction_type, value: 4
+      uint16 :instruction_length,
+             initial_value: -> { 8 + actions.binary.length }
+      string :padding, length: 4
+      actions :actions, length: -> { instruction_length - 8 }
+    end
+
+    def self.read(raw_data)
+      allocate.tap do |apply|
+        apply.instance_variable_set :@format, Format.read(raw_data)
+      end
+    end
+
+    extend Forwardable
+
+    def_delegators :@format, :instruction_type
+    def_delegators :@format, :instruction_length
+    def_delegators :@format, :actions
+    def_delegators :@format, :to_binary_s
+
+    def initialize(actions = [])
+      @format = Format.new(actions: actions)
+    end
+  end
+end

data/lib/pio/open_flow13/flow_mod.rb

@@ -0,0 +1,195 @@
+require 'forwardable'
+require 'pio/open_flow'
+require 'pio/open_flow13/match'
+
+# Base module.
+module Pio
+  remove_const :FlowMod if const_defined?(:FlowMod)
+
+  # OpenFlow 1.3 FlowMod message parser and generator
+  class FlowMod
+    # enum ofp_flow_mod_command
+    class Command < BinData::Primitive
+      COMMANDS = {
+        add: 0,
+        modify: 1,
+        modify_strict: 2,
+        delete: 3,
+        delete_strict: 4
+      }
+
+      uint8 :command
+
+      def get
+        COMMANDS.invert.fetch(command)
+      end
+
+      def set(value)
+        self.command = COMMANDS.fetch(value)
+      end
+    end
+
+    # Buffered packet to apply to, or :no_buffer.
+    class BufferId < BinData::Primitive
+      NO_BUFFER = 0xffffffff
+
+      endian :big
+      uint32 :buffer_id, initial_value: NO_BUFFER
+
+      def get
+        (buffer_id == NO_BUFFER) ? :no_buffer : buffer_id
+      end
+
+      def set(value)
+        self.buffer_id = (value == :no_buffer ? NO_BUFFER : value)
+      end
+    end
+
+    # For delete commands, require matching entries to include this as
+    # an output port.
+    class OutPort < BinData::Primitive
+      ANY = 0xffffffff
+
+      endian :big
+      uint32 :out_port, initial_value: ANY
+
+      def get
+        (out_port == ANY) ? :any : out_port
+      end
+
+      def set(value)
+        self.out_port = (value == :any ? ANY : value)
+      end
+    end
+
+    # For delete commands, require matching entries to include this as
+    # an output group.
+    class OutGroup < BinData::Primitive
+      ANY = 0xffffffff
+
+      endian :big
+      uint32 :out_group, initial_value: ANY
+
+      def get
+        (out_group == ANY) ? :any : out_group
+      end
+
+      def set(value)
+        self.out_group = (value == :any ? ANY : value)
+      end
+    end
+
+    # OpenFlow 1.3 instructions
+    class Instructions < BinData::Primitive
+      endian :big
+
+      count_bytes_remaining :instructions_length
+      string :instructions, read_length: :instructions_length
+
+      def set(object)
+        self.instructions = [object].flatten.map(&:to_binary_s).join
+      end
+
+      # rubocop:disable MethodLength
+      def get
+        list = []
+        tmp = instructions
+        while tmp.length > 0
+          instruction_type = BinData::Uint16be.read(tmp)
+          instruction = case instruction_type
+                        when 1
+                          GotoTable.read(tmp)
+                        when 2
+                          WriteMetadata.read(tmp)
+                        when 4
+                          Apply.read(tmp)
+                        when 6
+                          Meter.read(tmp)
+                        else
+                          fail "Unsupported instruction #{instruction_type}"
+                        end
+          tmp = tmp[instruction.instruction_length..-1]
+          list << instruction
+        end
+        list
+      end
+      # rubocop:enable MethodLength
+
+      def length
+        instructions.length
+      end
+    end
+
+    # OpenFlow 1.3 FlowMod message body
+    class Body < BinData::Record
+      extend OpenFlow::Flags
+      flags_16bit :flags,
+                  [:send_flow_rem,
+                   :check_overwrap,
+                   :reset_counts,
+                   :no_packet_counts,
+                   :no_byte_counts]
+
+      endian :big
+
+      uint64 :cookie
+      uint64 :cookie_mask
+      uint8 :table_id
+      command :command
+      uint16 :idle_timeout
+      uint16 :hard_timeout
+      uint16 :priority, initial_value: 0xffff
+      buffer_id :buffer_id
+      out_port :out_port
+      out_group :out_group
+      flags :flags
+      string :padding, length: 2
+      hide :padding
+      oxm :match
+      instructions :instructions
+
+      def length
+        40 + match.length + instructions.length
+      end
+    end
+
+    # OpenFlow 1.3 FlowMod message format
+    class Format < BinData::Record
+      extend Forwardable
+
+      endian :big
+
+      open_flow_header :open_flow_header,
+                       ofp_version_value: 4,
+                       message_type_value: OpenFlow::FLOW_MOD
+      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
+      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 = { match: user_attrs[:match],
+                     instructions: user_attrs[:instructions] }
+      @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