pio 0.30.0 → 0.30.1

data/lib/pio/monkey_patch/bindata_record.rb

@@ -0,0 +1,6 @@
+module BinData
+  # Add BinData::Record#to_binary
+  class Record
+    alias to_binary to_binary_s
+  end
+end

data/lib/pio/monkey_patch/bindata_string.rb

@@ -0,0 +1,10 @@
+module BinData
+  # Add BinData::String#to_bytes
+  class String
+    def to_bytes
+      to_s.unpack('H*').pop.scan(/[0-9a-f]{2}/).map do |each|
+        "0x#{each}"
+      end.join(', ')
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ module MonkeyPatch
     # to_hex etc.
     module BaseConversions
       def to_hex
-        format '%#x', self
+        format '0x%02x', self
       end
     end
   end

data/lib/pio/monkey_patch/uint.rb

@@ -0,0 +1,9 @@
+require 'bindata'
+require 'pio/monkey_patch/uint/base_conversions'
+
+# BinData's base module
+module BinData
+  Uint8.__send__ :include, MonkeyPatch::Uint::BaseConversions
+  Uint16be.__send__ :include, MonkeyPatch::Uint::BaseConversions
+  Uint32be.__send__ :include, MonkeyPatch::Uint::BaseConversions
+end

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

@@ -0,0 +1,14 @@
+module MonkeyPatch
+  module Uint
+    # Uint8#to_bytes, Uintxxbe#to_bytes
+    module BaseConversions
+      def to_bytes
+        /Uint(8|\d+be)$/=~ self.class.name
+        nbyte = Regexp.last_match(1).to_i / 4
+        format("%0#{nbyte}x", to_i).scan(/.{1,2}/).map do |each|
+          '0x' + each
+        end.join(', ')
+      end
+    end
+  end
+end

data/lib/pio/open_flow.rb

@@ -1,67 +1,53 @@
-require 'pio/open_flow/datapath_id'
-require 'pio/open_flow/error'
-require 'pio/open_flow/flags'
-require 'pio/open_flow/message'
-require 'pio/open_flow/open_flow_header'
-require 'pio/open_flow10'
-require 'pio/open_flow13'
+require 'active_support/core_ext/array/access'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/module/introspection'
+require 'pio/open_flow/header'
+require 'pio/open_flow/parser'
 
 module Pio
   # Common OpenFlow modules/classes.
   module OpenFlow
-    def self.version
-      fail unless @version
-      @version
-    end
+    mattr_reader :version, instance_reader: false
 
-    def self.switch_version(version)
-      [:Barrier, :Echo, :Features, :FlowMod, :Hello, :Match,
-       :PacketIn, :FlowRemoved, :PacketOut, :SendOutPort,
-       :SetSourceMacAddress, :SetDestinationMacAddress, :PortStatus, :Stats,
-       :FlowStats, :DescriptionStats, :AggregateStats, :TableStats, :PortStats,
-       :QueueStats, :Error, :SetArpOperation, :SetArpSenderProtocolAddress,
-       :SetArpSenderHardwareAddress, :NiciraRegMove, :SetMetadata,
-       :NiciraRegLoad, :NiciraSendOutPort].each do |each|
-        set_message_class_name each, version
-        @version = version.to_s
+    def self.version=(version)
+      return if OpenFlow.version == version.to_sym
+      find_all_class_by_version(version).each do |each|
+        alias_open_flow_class each
       end
+      @@version = version.to_sym # rubocop:disable ClassVars
+    rescue NameError
+      raise "#{version} is not supported yet."
     end
 
-    # rubocop:disable MethodLength
     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,
-        11 => Pio::FlowRemoved,
-        12 => Pio::PortStatus,
-        13 => Pio::PacketOut,
-        14 => Pio::FlowMod,
-        16 => Pio::Stats::Request,
-        17 => Pio::Stats::Reply,
-        18 => Pio::Barrier::Request,
-        19 => Pio::Barrier::Reply
-      }
-      header = OpenFlowHeaderParser.read(binary)
-      parser.fetch(header.message_type).read(binary)
+      header = OpenFlow::Header.read(binary)
+      self.version = header.version
+      Parser.find_by_type!(header.type).read(binary)
     end
-    # rubocop:enable MethodLength
 
-    def self.set_message_class_name(klass_name, version)
-      open_flow_module = Pio.const_get(version)
-      return unless open_flow_module.const_defined?(klass_name)
-      Pio.__send__ :remove_const, klass_name if Pio.const_defined?(klass_name)
-      Pio.const_set(klass_name, open_flow_module.const_get(klass_name))
-    rescue NameError
-      raise "#{version} is not supported yet."
+    def self.find_all_class_by_version(version)
+      all_class = [Message, Instruction, Action, FlowMatch].
+                  inject([]) do |result, each|
+        result + each.descendants
+      end
+      all_class.select do |each|
+        each.parents.include?(Class.const_get("Pio::#{version}"))
+      end
     end
-    private_class_method :set_message_class_name
+    private_class_method :find_all_class_by_version
 
-    # The default OpenFlow version is 1.0
-    switch_version 'OpenFlow10'
+    # Pio::OpenFlow10::Hello -> Pio::Hello
+    def self.alias_open_flow_class(klass)
+      version = klass.name.split('::').second
+      class_name = klass.name.split('::').third
+      if Pio.const_defined?(class_name)
+        Pio.module_eval { remove_const class_name }
+      end
+      Pio.const_set(class_name, "Pio::#{version}::#{class_name}".constantize)
+    end
+    private_class_method :alias_open_flow_class
   end
 end
+
+# The default OpenFlow version is 1.0
+Pio::OpenFlow.version = :OpenFlow10

data/lib/pio/open_flow/action.rb

@@ -1,12 +1,11 @@
+require 'active_support/descendants_tracker'
 require 'bindata'
 
 module Pio
   module OpenFlow
     # OpenFlow actions.
     class Action
-      def self.inherited(child_klass)
-        child_klass.const_set :Format, Class.new(BinData::Record)
-      end
+      extend ActiveSupport::DescendantsTracker
 
       def self.action_header(options)
         module_eval do
@@ -24,7 +23,12 @@ module Pio
       end
 
       def self.method_missing(method, *args, &block)
-        const_get(:Format).__send__ method, *args, &block
+        begin
+          const_get(:Format).__send__ method, *args, &block
+        rescue NameError
+          const_set :Format, Class.new(BinData::Record)
+          retry
+        end
         return if method == :endian || method == :virtual
         define_method(args.first) { @format.__send__ args.first }
       end

data/lib/pio/open_flow/buffer_id.rb

@@ -0,0 +1,19 @@
+module Pio
+  module OpenFlow
+    # 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
+  end
+end

data/lib/pio/open_flow/datapath_id.rb

@@ -12,14 +12,14 @@ module Pio
 
       def set(value)
         unless value.unsigned_64bit?
-          fail(ArgumentError,
-               'Datapath ID should be an unsigned 64-bit integer.')
+          raise(ArgumentError,
+                'Datapath ID should be an unsigned 64-bit integer.')
         end
         self.datapath_id = value
       end
 
       def get
-        datapath_id
+        datapath_id.to_i
       end
     end
   end

data/lib/pio/open_flow/error_message.rb

@@ -0,0 +1,32 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/string/inflections'
+
+module Pio
+  module OpenFlow
+    # Error message parser
+    module ErrorMessage
+      mattr_reader(:type) { 1 }
+
+      # rubocop:disable AbcSize
+      def read(binary)
+        body = OpenFlow::Header.read(binary).body
+        error = const_get(:BodyParser).read(body)
+        klass = error_classes.find do |each|
+          each.name.split('::').last.underscore == error.error_type.to_s
+        end
+        unless klass
+          raise 'Unknown error message '\
+               "(type=#{error.error_type}, code=#{error.error_code})"
+        end
+        klass.read binary
+      end
+      # rubocop:enable AbcSize
+
+      def error_classes
+        OpenFlow::Message.descendants.select do |each|
+          each.parents.include? parent.const_get(:Error)
+        end
+      end
+    end
+  end
+end

data/lib/pio/open_flow/flags.rb

@@ -3,17 +3,21 @@ module Pio
     # bitmap functions.
     # This class smells of :reek:DataClump
     module Flags
+      def define_flags_32bit(name, flags)
+        _define_flags name, 32, flags
+      end
+
       def flags_32bit(name, flags)
-        _def_flags name, 32, flags
+        _flags name, 32, flags
       end
 
       def flags_16bit(name, flags)
-        _def_flags name, 16, flags
+        _flags name, 16, flags
       end
 
       # rubocop:disable MethodLength
       # This method smells of :reek:TooManyStatements
-      def _def_flags(name, size, flags)
+      def _define_flags(name, size, flags)
         flag_value = case flags
                      when Array
                        shift = 0
@@ -29,7 +33,7 @@ module Pio
         klass_name = name.to_s.split('_').map(&:capitalize).join
         flags_hash = flag_value.inspect
 
-        code = %{
+        module_eval <<-end_eval, __FILE__, __LINE__
           class #{klass_name} < BinData::Primitive
             endian :big
 
@@ -53,8 +57,13 @@ module Pio
                              v.map { |each| list[each] }.inject(:|)
             end
           end
-        }
-        module_eval code
+        end_eval
+      end
+      # rubocop:enable MethodLength
+
+      def _flags(name, size, flags_)
+        _define_flags name, size, flags_
+        module_eval "#{name} :#{name}", __FILE__, __LINE__
       end
     end
   end

data/lib/pio/open_flow/flow_match.rb

@@ -0,0 +1,10 @@
+require 'active_support/descendants_tracker'
+
+module Pio
+  module OpenFlow
+    # Flow match
+    class FlowMatch
+      extend ActiveSupport::DescendantsTracker
+    end
+  end
+end

data/lib/pio/open_flow/header.rb

@@ -0,0 +1,26 @@
+require 'bindata'
+require 'pio/monkey_patch/uint'
+require 'pio/open_flow/transaction_id'
+require 'pio/open_flow/version'
+
+module Pio
+  module OpenFlow
+    # OpenFlow message header parser
+    class Header < BinData::Record
+      endian :big
+
+      version :version
+      uint8 :type
+      uint16 :message_length
+      transaction_id :transaction_id
+      rest :body
+
+      def to_bytes
+        [version,
+         type,
+         message_length,
+         transaction_id].map(&:to_bytes).join(', ')
+      end
+    end
+  end
+end

data/lib/pio/open_flow/hello_failed_code.rb

@@ -4,7 +4,7 @@ module Pio
   module OpenFlow
     # enum ofp_hello_failed_code
     class HelloFailedCode < BinData::Primitive
-      ERROR_CODES = { incompatible: 0, permissions_error: 1 }
+      ERROR_CODES = { incompatible: 0, permissions_error: 1 }.freeze
 
       endian :big
       uint16 :error_code

data/lib/pio/open_flow/instruction.rb

@@ -0,0 +1,10 @@
+require 'active_support/descendants_tracker'
+
+module Pio
+  module OpenFlow
+    # Flow instruction
+    class Instruction
+      extend ActiveSupport::DescendantsTracker
+    end
+  end
+end

data/lib/pio/open_flow/message.rb

@@ -1,15 +1,19 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/descendants_tracker'
 require 'bindata'
+require 'pio/open_flow/flags'
+require 'pio/open_flow/header'
 require 'pio/parse_error'
-require 'pio/open_flow/open_flow_header'
+require 'pio/ruby_dumper'
 
 module Pio
   module OpenFlow
     # OpenFlow messages.
     class Message
-      def self.inherited(child_klass)
-        child_klass.const_set :Format, Class.new(BinData::Record)
-        child_klass.class_variable_set(:@@valid_options, [])
-      end
+      attr_reader :format
+
+      extend ActiveSupport::DescendantsTracker
+      extend OpenFlow::Flags
 
       def self.read(raw_data)
         allocate.tap do |message|
@@ -21,31 +25,62 @@ module Pio
         raise Pio::ParseError, "Invalid #{message_name} message."
       end
 
+      # rubocop:disable MethodLength
+      # rubocop:disable AbcSize
       def self.method_missing(method, *args, &block)
-        const_get(:Format).__send__ method, *args, &block
+        begin
+          const_get(:Format).__send__ method, *args, &block
+        rescue NameError
+          klass = Class.new(BinData::Record)
+          const_set :Format, klass
+          klass.class_eval do
+            include RubyDumper
+            define_method(:header_length) { 8 }
+            define_method(:length) { _length }
+          end
+          class_variable_set(:@@valid_options, [])
+          retry
+        end
 
         return if method == :endian || method == :virtual
+
         define_method(args.first) do
-          @format.__send__ args.first
+          snapshot = @format.snapshot.__send__(args.first)
+          if snapshot.class == BinData::Struct::Snapshot
+            @format.__send__(args.first)
+          else
+            snapshot
+          end
         end
         class_variable_set(:@@valid_options,
                            class_variable_get(:@@valid_options) + [args.first])
       end
+      # rubocop:enable MethodLength
+      # rubocop:enable AbcSize
 
       # rubocop:disable AbcSize
       # rubocop:disable MethodLength
       def self.open_flow_header(opts)
         module_eval do
+          cattr_reader(:type) { opts.fetch(:type) }
+
           endian :big
 
-          uint8 :ofp_version, value: opts.fetch(:version)
-          virtual assert: -> { ofp_version == opts.fetch(:version) }
-          uint8 :message_type, value: opts.fetch(:message_type)
-          virtual assert: -> { message_type == opts.fetch(:message_type) }
-          uint16 :message_length,
-                 initial_value: opts[:message_length] || -> { 8 + body.length }
+          uint8 :version, value: opts.fetch(:version)
+          uint8 :type, value: opts.fetch(:type)
+          uint16(:_length,
+                 initial_value: opts[:length] || lambda do
+                   begin
+                     8 + body.length
+                   rescue
+                     8
+                   end
+                 end)
           transaction_id :transaction_id, initial_value: 0
 
+          virtual assert: -> { version == opts.fetch(:version) }
+          virtual assert: -> { type == opts.fetch(:type) }
+
           alias_method :xid, :transaction_id
         end
       end
@@ -71,7 +106,7 @@ module Pio
         unknown_options =
           user_options.keys - self.class.class_variable_get(:@@valid_options)
         return if unknown_options.empty?
-        fail "Unknown option: #{unknown_options.first}"
+        raise "Unknown option: #{unknown_options.first}"
       end
 
       def parse_options(user_options)