pio 0.25.0 → 0.26.0

data/features/step_definitions/README.md

@@ -0,0 +1,7 @@
+Cucumber Step Definitions
+=========================
+
+A collection of step definitions for use with [Trema][trema] and Trema apps.
+These steps are highly specific to Trema.
+
+[trema]: https://github.com/trema/trema_ruby

data/features/step_definitions/Rakefile

@@ -0,0 +1,10 @@
+task default: :rubocop
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue LoadError
+  task :rubocop do
+    $stderr.puts 'RuboCop is disabled'
+  end
+end

data/features/step_definitions/dump_flows_steps.rb

@@ -0,0 +1,13 @@
+# rubocop:disable LineLength
+
+Then(/^the switch "(.*?)" has (\d+) flow entr(?:y|ies)$/) do |switch, num_entries|
+  command = "trema dump_flows #{switch} -S."
+  step "I run `#{command}`"
+  expect(output_from(command).split("\n").size - 1).to eq(num_entries.to_i)
+end
+
+Then(/^the switch "(.*?)" has no flow entry$/) do |switch|
+  step %(the switch "#{switch}" has 0 flow entry)
+end
+
+# rubocop:enable LineLength

data/features/step_definitions/packet_data_steps.rb

@@ -59,6 +59,10 @@ Then(/^the message has the following fields and values:$/) do |table|
   step 'the packet has the following fields and values:', table
 end
 
+Then(/^the action has the following fields and values:$/) do |table|
+  step 'the packet has the following fields and values:', table
+end
+
 # rubocop:disable LineLength
 Then(/^the message \#(\d+) have the following fields and values:$/) do |index, table|
   table.hashes.each do |each|

data/features/step_definitions/rest_api_steps.rb

@@ -0,0 +1,40 @@
+begin
+  require 'rack/test'
+
+  World(Rack::Test::Methods)
+
+  Given(/^I send and accept JSON$/) do
+    header 'Accept', 'application/json'
+    header 'Cotent-Type', 'application/json'
+  end
+
+  Given(/^I send a GET request for "([^\"]*)"$/) do |path|
+    in_current_dir { get path }
+  end
+
+  # rubocop:disable LineLength
+  Given(/^I send a POST request for "([^\"]*)" with body "([^\"]*)"$/) do |path, body|
+    in_current_dir { post path, Object.instance_eval(body) }
+  end
+  # rubocop:enable LineLength
+
+  # rubocop:disable LineLength
+  Given(/^I send a DELETE request for "([^\"]*)" with body "([^\"]*)"$/) do |path, body|
+    in_current_dir { delete path, Object.instance_eval(body) }
+  end
+  # rubocop:enable LineLength
+
+  Then(/^the response should be "([^\"]*)"$/) do |status|
+    expect(last_response.status).to eq(status.to_i)
+  end
+
+  Then(/^the JSON response should be "([^\"]*)"$/) do |json|
+    expect(JSON.parse(last_response.body)).to eq(JSON.parse(json))
+  end
+
+  Then(/^the JSON response should be:$/) do |json|
+    expect(JSON.parse(last_response.body)).to eq(JSON.parse(json))
+  end
+rescue LoadError
+  $stderr.puts 'Rack is disabled'
+end

data/features/step_definitions/show_stats_steps.rb

@@ -0,0 +1,83 @@
+# rubocop:disable LineLength
+
+Then(/^the number of packets sent from "(.*?)" should be:$/) do |host_name, table|
+  command = "trema show_stats #{host_name}"
+  step "I run `#{command}`"
+
+  result = {}
+  cd('.') do
+    output_from(command).split("\n").each do |each|
+      case each
+      when /Packets sent/
+        next
+      when /Packets recevied/
+        break
+      when /-> (\S+) = (\d+) packet/
+        result[Regexp.last_match(1)] = Regexp.last_match(2).to_i
+      else
+        fail "Failed to parse line '#{each}'"
+      end
+    end
+  end
+  table.hashes.each do |each|
+    ip_address = each.fetch('destination')
+    expect(result.fetch(ip_address)).to eq(each.fetch('#packets').to_i)
+  end
+end
+
+Then(/^the number of packets received by "(.*?)" should be:$/) do |host_name, table|
+  command = "trema show_stats #{host_name}"
+  step "I run `#{command}`"
+
+  result = Hash.new(0)
+  cd('.') do
+    received = false
+    output_from(command).split("\n").each do |each|
+      case each
+      when /Packets sent/
+        next
+      when /Packets received/
+        received = true
+        next
+      when /(\S+) -> (\S+) = (\d+) packet/
+        next unless received
+        result[Regexp.last_match(1)] = Regexp.last_match(3).to_i
+      else
+        fail "Failed to parse line '#{each}'"
+      end
+    end
+  end
+  table.hashes.each do |each|
+    ip_address = each.fetch('source')
+    expect(result[ip_address]).to eq(each.fetch('#packets').to_i)
+  end
+end
+
+Then(/^the total number of received packets should be:$/) do |table|
+  table.hashes[0].each_pair do |host_name, npackets|
+    command = "trema show_stats #{host_name}"
+    step "I run `#{command}`"
+
+    result = 0
+    cd('.') do
+      received = false
+      output_from(command).split("\n").each do |each|
+        case each
+        when /Packets sent/
+          next
+        when /Packets received/
+          received = true
+          next
+        when /(\S+) -> (\S+) = (\d+) packet/
+          next unless received
+          result += Regexp.last_match(3).to_i
+        else
+          fail "Failed to parse line '#{each}'"
+        end
+      end
+    end
+    expect(result).to eq(npackets.to_i)
+  end
+end
+
+# rubocop:enable LineLength

data/features/step_definitions/trema_steps.rb

@@ -0,0 +1,33 @@
+Given(/^I use OpenFlow 1\.0$/) do
+  @open_flow_version = :open_flow10
+end
+
+Given(/^I use OpenFlow 1\.3$/) do
+  @open_flow_version = :open_flow13
+end
+
+# rubocop:disable LineLength
+When(/^I trema run "([^"]*)"( interactively)? with the configuration "([^"]*)"$/) do |controller_file, interactive, configuration_file|
+  open_flow_option = @open_flow_version == :open_flow13 ? ' --openflow13' : ''
+  run_arguments = "#{File.join '..', '..', controller_file}#{open_flow_option} -c #{configuration_file}"
+  if interactive
+    step %(I run `trema run #{run_arguments}` interactively)
+  else
+    step %(I successfully run `trema run #{run_arguments} -d`)
+  end
+  step %(I successfully run `sleep 3`)
+end
+# rubocop:enable LineLength
+
+When(/^I trema killall "([^"]*)"$/) do |controller_name|
+  step %(I successfully run `trema killall #{controller_name}`)
+end
+
+# rubocop:disable LineLength
+Then(/^the log file "([^"]*)" should contain following messages:$/) do |log_file, messages|
+  step %(a file named "#{log_file}" should exist)
+  messages.rows.flatten.each do |each|
+    step %(the file "#{log_file}" should contain "#{each}")
+  end
+end
+# rubocop:enable LineLength

data/features/step_definitions/virtual_link_steps.rb

@@ -0,0 +1,8 @@
+# rubocop:disable LineLength
+
+Then(/^virtual links should not exist$/) do
+  step %(I run `bash -c 'ifconfig | grep "^link[0-9]\+-[0-9]\+" > virtual_links.txt'`)
+  step 'the file "virtual_links.txt" should not contain "link"'
+end
+
+# rubocop:enable LineLength

data/lib/pio/open_flow.rb

@@ -1,10 +1,9 @@
 require 'pio/open_flow/datapath_id'
+require 'pio/open_flow/error'
 require 'pio/open_flow/flags'
 require 'pio/open_flow/format'
 require 'pio/open_flow/message'
 require 'pio/open_flow/open_flow_header'
-require 'pio/open_flow/phy_port'
-require 'pio/open_flow/port_number'
 require 'pio/open_flow10'
 require 'pio/open_flow13'
 
@@ -19,7 +18,7 @@ module Pio
     def self.switch_version(version)
       [:Barrier, :Echo, :Features, :FlowMod, :Hello, :Match,
        :PacketIn, :PacketOut, :SendOutPort, :PortStatus,
-       :FlowStats].each do |each|
+       :FlowStats, :Error].each do |each|
         set_message_class_name each, version
         @version = version.to_s
       end
@@ -29,12 +28,15 @@ module Pio
     def self.read(binary)
       parser = {
         0 => Pio::Hello,
+        1 => Pio::OpenFlow::Error,
         2 => Pio::Echo::Request,
         3 => Pio::Echo::Reply,
         5 => Pio::Features::Request,
         6 => Pio::Features::Reply,
         10 => Pio::PacketIn,
         12 => Pio::PortStatus,
+        13 => Pio::PacketOut,
+        14 => Pio::FlowMod,
         16 => Pio::FlowStats::Request,
         17 => Pio::FlowStats::Reply,
         18 => Pio::Barrier::Request,
@@ -42,8 +44,6 @@ module Pio
       }
       header = OpenFlowHeaderParser.read(binary)
       parser.fetch(header.message_type).read(binary)
-    rescue
-      raise "Unknown message type #{header.message_type}"
     end
     # rubocop:enable MethodLength
 

data/lib/pio/open_flow/echo.rb

@@ -13,7 +13,7 @@ module Pio
 
             header version: :of_version,
                    message_type: :of_message_type
-            string :body, read_length: -> { message_length - header_length }
+            string :body, read_length: -> { length - header_length }
 
             def user_data
               body

data/lib/pio/open_flow/error.rb

@@ -0,0 +1,19 @@
+module Pio
+  module OpenFlow
+    # Error message parser
+    class Error
+      def self.read(binary)
+        version = OpenFlowHeaderParser.read(binary).ofp_version
+        error_parser = case version
+                       when 1
+                         Pio::OpenFlow10::Error
+                       when 4
+                         Pio::OpenFlow13::Error
+                       else
+                         fail "Unsupported OpenFlow version: #{version}"
+                       end
+        error_parser.read binary
+      end
+    end
+  end
+end

data/lib/pio/open_flow/format.rb

@@ -32,10 +32,11 @@ module Pio
           def_delegators :header, :snapshot
           def_delegators :snapshot, :ofp_version
           def_delegators :snapshot, :message_type
-          def_delegators :snapshot, :message_length
+          def_delegators :snapshot, :_length
           def_delegators :snapshot, :transaction_id
           def_delegator :snapshot, :transaction_id, :xid
 
+          alias_method :length, :_length
           alias_method :to_binary, :to_binary_s
         end
       end

data/lib/pio/open_flow/hello_failed_code.rb

@@ -0,0 +1,21 @@
+require 'bindata'
+
+module Pio
+  module OpenFlow
+    # enum ofp_hello_failed_code
+    class HelloFailedCode < BinData::Primitive
+      ERROR_CODES = { incompatible: 0, permissions_error: 1 }
+
+      endian :big
+      uint16 :error_code
+
+      def get
+        ERROR_CODES.invert.fetch(error_code)
+      end
+
+      def set(value)
+        self.error_code = ERROR_CODES.fetch(value)
+      end
+    end
+  end
+end

data/lib/pio/open_flow/open_flow_header.rb

@@ -8,8 +8,13 @@ module Pio
 
     uint8 :ofp_version
     uint8 :message_type
-    uint16 :message_length
+    uint16 :_length
     transaction_id :transaction_id
+    rest :body
+
+    def length
+      _length
+    end
   end
 
   # OpenFlow message header.
@@ -20,7 +25,11 @@ module Pio
     virtual assert: -> { ofp_version == ofp_version_value }
     uint8 :message_type, value: :message_type_value
     virtual assert: -> { message_type == message_type_value }
-    uint16 :message_length, initial_value: -> { 8 + body.length }
+    uint16 :_length, initial_value: -> { 8 + body.length }
     transaction_id :transaction_id, initial_value: 0
+
+    def length
+      _length
+    end
   end
 end

data/lib/pio/open_flow/port.rb

@@ -0,0 +1,69 @@
+module Pio
+  module OpenFlow
+    # Port numbering.
+    class Port < BinData::Primitive
+      endian :big
+
+      def self.port_size_in_bytes(nbytes)
+        class_eval "uint#{nbytes} :port"
+      end
+
+      def self.max_port_number(port_number)
+        const_set :MAX, port_number
+      end
+
+      def self.reserved_ports(port_name_and_number)
+        @reserved = port_name_and_number
+      end
+
+      def self.reserved_port_number(port_name)
+        @reserved.fetch port_name
+      end
+
+      def self.reserved_port_name?(port_name)
+        @reserved.key? port_name
+      end
+
+      def max
+        self.class.const_get :MAX
+      end
+
+      def reserved_port_number(port_name)
+        self.class.reserved_port_number port_name
+      end
+
+      def reserved_port_name?(port_name)
+        self.class.reserved_port_name? port_name
+      end
+
+      def reserved_port_number?(port_number)
+        self.class.instance_variable_get(:@reserved).invert.key?(port_number)
+      end
+
+      def reserved_port_name(port_number)
+        self.class.instance_variable_get(:@reserved).invert.fetch(port_number)
+      end
+
+      def get
+        if reserved_port_number?(port)
+          reserved_port_name(port)
+        else
+          port
+        end
+      end
+
+      def set(port)
+        if reserved_port_name?(port)
+          self.port = reserved_port_number(port)
+        else
+          port_num = port.to_i
+          fail ArgumentError, 'The port should be > 0' if port_num < 1
+          if port_num >= max
+            fail ArgumentError, "The port should be < #{max.to_hex}"
+          end
+          self.port = port_num
+        end
+      end
+    end
+  end
+end

data/lib/pio/open_flow10.rb

@@ -1,6 +1,9 @@
 require 'pio/open_flow10/barrier_reply'
 require 'pio/open_flow10/barrier_request'
 require 'pio/open_flow10/echo'
+require 'pio/open_flow10/error'
+require 'pio/open_flow10/error/bad_request'
+require 'pio/open_flow10/error/hello_failed'
 require 'pio/open_flow10/exact_match'
 require 'pio/open_flow10/features'
 require 'pio/open_flow10/flow_mod'
@@ -9,5 +12,7 @@ require 'pio/open_flow10/flow_stats_request'
 require 'pio/open_flow10/hello'
 require 'pio/open_flow10/packet_in'
 require 'pio/open_flow10/packet_out'
+require 'pio/open_flow10/phy_port16'
+require 'pio/open_flow10/port16'
 require 'pio/open_flow10/port_status'
 require 'pio/open_flow10/send_out_port'

data/lib/pio/open_flow10/actions.rb

@@ -8,6 +8,7 @@ require 'pio/open_flow10/set_transport_port'
 require 'pio/open_flow10/set_vlan_priority'
 require 'pio/open_flow10/set_vlan_vid'
 require 'pio/open_flow10/strip_vlan_header'
+require 'pio/open_flow10/vendor_action'
 
 module Pio
   module OpenFlow
@@ -18,14 +19,15 @@ module Pio
         1 => Pio::SetVlanVid,
         2 => Pio::SetVlanPriority,
         3 => Pio::StripVlanHeader,
-        4 => Pio::SetEtherSourceAddr,
-        5 => Pio::SetEtherDestinationAddr,
+        4 => Pio::SetEtherSourceAddress,
+        5 => Pio::SetEtherDestinationAddress,
         6 => Pio::SetIpSourceAddress,
         7 => Pio::SetIpDestinationAddress,
         8 => Pio::SetIpTos,
         9 => Pio::SetTransportSourcePort,
         10 => Pio::SetTransportDestinationPort,
-        11 => Pio::Enqueue
+        11 => Pio::Enqueue,
+        0xffff => Pio::VendorAction
       }
 
       mandatory_parameter :length
@@ -34,8 +36,8 @@ module Pio
 
       string :binary, read_length: :length
 
-      def set(value)
-        self.binary = [value].flatten.map(&:to_binary).join
+      def set(actions)
+        self.binary = Array(actions).map(&:to_binary).join
       end
 
       # rubocop:disable MethodLength
@@ -47,7 +49,7 @@ module Pio
           type = BinData::Uint16be.read(tmp)
           begin
             action = ACTION_CLASS.fetch(type).read(tmp)
-            tmp = tmp[action.message_length..-1]
+            tmp = tmp[action.length..-1]
             actions << action
           rescue KeyError
             raise "action type #{type} is not supported."