pio 0.8.1 → 0.8.2

data/lib/pio/echo/message.rb

@@ -1,48 +1,23 @@
-# encoding: utf-8
-
-require 'forwardable'
-require 'bindata'
-
 module Pio
   class Echo
     # Base class of Echo request and reply.
-    class Message
-      extend Forwardable
-
-      def_delegators :@echo, :ofp_version
-      def_delegators :@echo, :message_type
-      def_delegators :@echo, :message_length
-      def_delegators :@echo, :transaction_id
-      def_delegator :@echo, :transaction_id, :xid
-      def_delegator :@echo, :body, :data
-      def_delegator :@echo, :to_binary_s, :to_binary
-
-      def self.create_from(echo)
-        message = allocate
-        message.instance_variable_set :@echo, echo
-        message
-      end
-
-      def initialize(message_type, user_options = {})
-        if user_options.respond_to?(:to_i)
-          @options = { transaction_id: user_options.to_i,
-                       message_type: message_type }
-        elsif user_options.respond_to?(:[])
-          @options = user_options.dup.merge(message_type: message_type)
-          handle_user_hash_options
-        else
-          fail TypeError
-        end
-        @echo = Format.new(@options)
-      end
-
-      private
-
-      def handle_user_hash_options
-        @options[:body] = @options[:data]
-        @options[:transaction_id] ||= @options[:xid]
-        @options[:transaction_id] = 0 unless @options[:transaction_id]
+    class Message < Pio::OpenFlow::Message
+      # @reek This method smells of :reek:FeatureEnvy
+      # rubocop:disable Metrics/MethodLength
+      def initialize(user_options = {})
+        options = if user_options.respond_to?(:to_i)
+                    { open_flow_header: { transaction_id: user_options.to_i } }
+                  elsif user_options.respond_to?(:fetch)
+                    transaction_id =
+                      user_options[:transaction_id] || user_options[:xid] || 0
+                    { open_flow_header: { transaction_id: transaction_id },
+                      body: user_options[:user_data] }
+                  else
+                    fail TypeError
+                  end
+        @format = self.class.const_get(:Format).new(options)
       end
+      # rubocop:enable Metrics/MethodLength
     end
   end
 end

data/lib/pio/echo/reply.rb

@@ -1,13 +1,17 @@
-# encoding: utf-8
-
+require 'forwardable'
 require 'pio/echo/format'
 require 'pio/echo/message'
+require 'pio/open_flow'
 
 module Pio
-  # OpenFlow Echo Request and Reply message parser.
   class Echo
-    # OpenFlow 1.0 Echo Reply message.
+    # OpenFlow 1.0 Echo Reply message generator.
     class Reply < Message
+      # OpenFlow 1.0 Echo reply message generator.
+      class Format < Pio::Echo::Format
+        default_parameters message_type_value: Pio::OpenFlow::Type::ECHO_REPLY
+      end
+
       # Creates an EchoReply OpenFlow message. This message can be
       # used to measure the bandwidth of a controller/switch
       # connection as well as to verify its liveness.
@@ -37,9 +41,6 @@ module Pio
       #     timestamp to check latency, various lengths to measure
       #     bandwidth or zero-size(nil) to verify liveness between the
       #     switch and controller.
-      def initialize(user_options = {})
-        super REPLY, user_options
-      end
     end
   end
 end

data/lib/pio/echo/request.rb

@@ -1,13 +1,16 @@
-# encoding: utf-8
-
 require 'pio/echo/format'
 require 'pio/echo/message'
+require 'pio/open_flow'
 
 module Pio
-  # OpenFlow Echo Request and Reply message parser.
   class Echo
     # OpenFlow 1.0 Echo Request message.
     class Request < Message
+      # OpenFlow 1.0 Echo request message generator.
+      class Format < Pio::Echo::Format
+        default_parameters message_type_value: Pio::OpenFlow::Type::ECHO_REQUEST
+      end
+
       # Creates an EchoRequest OpenFlow message. This message can be
       # used to measure the bandwidth of a controller/switch
       # connection as well as to verify its liveness.
@@ -37,9 +40,6 @@ module Pio
       #     timestamp to check latency, various lengths to measure
       #     bandwidth or zero-size(nil) to verify liveness between the
       #     switch and controller.
-      def initialize(user_options = {})
-        super REQUEST, user_options
-      end
     end
   end
 end

data/lib/pio/features.rb

@@ -1,18 +1,24 @@
-# encoding: utf-8
-
-require 'pio/features/format'
 require 'pio/features/reply'
 require 'pio/features/request'
-require 'pio/message_type_selector'
+require 'pio/open_flow'
+require 'pio/parse_error'
 
 module Pio
   # OpenFlow 1.0 Features messages
   class Features
-    extend MessageTypeSelector
-
-    REQUEST = 5
-    REPLY = 6
+    include Pio::OpenFlow::Type
 
-    message_type REQUEST => Request, REPLY => Reply
+    # @reek This method smells of :reek:TooManyStatements
+    def self.read(raw_data)
+      header = Pio::Type::OpenFlow::OpenFlowHeader.read(raw_data)
+      klass = { FEATURES_REQUEST => Request,
+                FEATURES_REPLY => Reply }.fetch(header.message_type)
+      format = klass.const_get(:Format).read(raw_data)
+      message = klass.allocate
+      message.instance_variable_set :@format, format
+      message
+    rescue KeyError
+      raise Pio::ParseError, 'Invalid features request/reply message.'
+    end
   end
 end

data/lib/pio/features/reply.rb

@@ -1,15 +1,50 @@
-# encoding: utf-8
-
 require 'bindata'
-require 'forwardable'
-require 'pio/features/message'
+require 'pio/open_flow'
 
 module Pio
   # OpenFlow 1.0 Features messages
   class Features
     # OpenFlow 1.0 Features Reply message
-    class Reply < Message
-      # Message body of Features Reply
+    class Reply < Pio::OpenFlow::Message
+      # enum ofp_capabilities
+      class Capabilities < BinData::Primitive
+        extend Flags
+
+        endian :big
+
+        flags :capabilities,
+              flow_stats: 1 << 0,
+              table_stats: 1 << 1,
+              port_stats: 1 << 2,
+              stp: 1 << 3,
+              reserved: 1 << 4,
+              ip_reasm: 1 << 5,
+              queue_stats: 1 << 6,
+              arp_match_ip: 1 << 7
+      end
+
+      # enum ofp_action_type
+      class Actions < BinData::Primitive
+        extend Flags
+
+        endian :big
+
+        flags :actions,
+              output: 1 << 0,
+              set_vlan_vid: 1 << 1,
+              set_vlan_pcp: 1 << 2,
+              strip_vlan: 1 << 3,
+              set_dl_src: 1 << 4,
+              set_dl_dst: 1 << 5,
+              set_nw_src: 1 << 6,
+              set_nw_dst: 1 << 7,
+              set_nw_tos: 1 << 8,
+              set_tp_src: 1 << 9,
+              set_tp_dst: 1 << 10,
+              enqueue: 1 << 11
+      end
+
+      # Message body of features reply.
       class Body < BinData::Record
         endian :big
 
@@ -17,56 +52,56 @@ module Pio
         uint32 :n_buffers
         uint8 :n_tables
         uint24 :padding
-        uint32 :capabilities
-        uint32 :actions
+        hide :padding
+        capabilities :capabilities
+        actions :actions
         array :ports, type: :phy_port, read_until: :eof
-      end
-
-      extend Forwardable
 
-      def_delegators :@features, :ofp_version
-      def_delegators :@features, :message_type
-      def_delegators :@features, :message_length
-      def_delegators :@features, :transaction_id
-      def_delegator :@features, :transaction_id, :xid
-      def_delegators :@features, :body
+        def empty?
+          false
+        end
 
-      def initialize(user_options = {})
-        @options = user_options.dup.merge(datapath_id: user_options[:dpid])
-        body = Body.new(@options)
-        @features = Format.new(@options.merge(message_type: 6,
-                                              body: body.to_binary_s))
+        def length
+          24 + ports.to_binary_s.length
+        end
       end
 
-      def datapath_id
-        @body ||= Body.read(@features.body)
-        @body.datapath_id
-      end
-      alias_method :dpid, :datapath_id
+      # OpenFlow 1.0 Features request message.
+      class Format < BinData::Record
+        include Pio::OpenFlow::Type
 
-      def n_buffers
-        @body ||= Body.read(@features.body)
-        @body.n_buffers
-      end
+        endian :big
 
-      def n_tables
-        @body ||= Body.read(@features.body)
-        @body.n_tables
-      end
+        open_flow_header :open_flow_header, message_type_value: FEATURES_REPLY
+        virtual assert: -> { open_flow_header.message_type == FEATURES_REPLY }
 
-      def capabilities
-        @body ||= Body.read(@features.body)
-        @body.capabilities
+        body :body
       end
 
-      def actions
-        @body ||= Body.read(@features.body)
-        @body.actions
+      def datapath_id
+        @format.body.datapath_id
       end
 
-      def ports
-        @body ||= Body.read(@features.body)
-        @body.ports
+      def_delegators :body, :datapath_id
+      def_delegator :body, :datapath_id, :dpid
+      def_delegators :body, :n_buffers
+      def_delegators :body, :n_tables
+      def_delegators :body, :capabilities
+      def_delegators :body, :actions
+      def_delegators :body, :ports
+
+      # @reek This method smells of :reek:FeatureEnvy
+      def initialize(user_options)
+        body_options =
+          {
+            datapath_id: user_options[:dpid],
+            n_buffers: user_options[:n_buffers],
+            n_tables: user_options[:n_tables],
+            capabilities: user_options[:capabilities],
+            actions: user_options[:actions],
+            ports: user_options[:ports]
+          }
+        @format = Format.new(user_options.merge(body: body_options))
       end
     end
   end

data/lib/pio/features/request.rb

@@ -1,22 +1,24 @@
-# encoding: utf-8
-
 require 'forwardable'
-require 'pio/features/message'
+require 'pio/open_flow'
 
 module Pio
   # OpenFlow 1.0 Features messages
   class Features
     # OpenFlow 1.0 Features Request message
-    class Request < Message
-      extend Forwardable
+    class Request < Pio::OpenFlow::Message
+      # OpenFlow 1.0 Features Request format
+      class Format < BinData::Record
+        include Pio::OpenFlow::Type
+
+        endian :big
+
+        open_flow_header :open_flow_header, message_type_value: FEATURES_REQUEST
+        virtual assert: -> { open_flow_header.message_type == FEATURES_REQUEST }
 
-      def_delegators :@features, :ofp_version
-      def_delegators :@features, :message_type
-      def_delegators :@features, :message_length
-      def_delegators :@features, :transaction_id
-      def_delegator :@features, :transaction_id, :xid
-      def_delegators :@features, :body
-      def_delegator :@features, :to_binary_s, :to_binary
+        def body
+          ''
+        end
+      end
 
       # Creates a Features Request OpenFlow message.
       #
@@ -39,25 +41,25 @@ module Pio
       #     The options to create a message with.
       #   @option user_options [Number] :transaction_id
       #   @option user_options [Number] :xid An alias to transaction_id.
+      #
+      # @reek This method smells of :reek:FeatureEnvy
+      # rubocop:disable MethodLength
       def initialize(user_options = {})
-        if user_options.respond_to?(:to_i)
-          @options = { transaction_id: user_options.to_i,
-                       message_type: 5 }
-        elsif user_options.respond_to?(:[])
-          @options = user_options.dup.merge(message_type: 5)
-          handle_user_hash_options
-        else
-          fail TypeError
+        options = if user_options.respond_to?(:to_i)
+                    { open_flow_header: { transaction_id: user_options.to_i } }
+                  elsif user_options.respond_to?(:fetch)
+                    transaction_id =
+                      user_options[:transaction_id] || user_options[:xid] || 0
+                    { open_flow_header: { transaction_id: transaction_id } }
+                  else
+                    fail TypeError
+                  end
+        if options[:open_flow_header][:transaction_id] >= 2**32
+          fail ArgumentError, 'Transaction ID >= 2**32'
         end
-        @features = Format.new(@options)
-      end
-
-      private
-
-      def handle_user_hash_options
-        @options[:transaction_id] ||= @options[:xid]
-        @options[:transaction_id] = 0 unless @options[:transaction_id]
+        @format = Format.new(options)
       end
+      # rubocop:enable MethodLength
     end
   end
 end

data/lib/pio/hello.rb

@@ -1,22 +1,11 @@
-# encoding: utf-8
-
 require 'English'
-require 'forwardable'
 require 'pio/hello/format'
+require 'pio/parse_error'
+require 'pio/open_flow'
 
 module Pio
   # OpenFlow 1.0 Hello message
-  class Hello
-    extend Forwardable
-
-    def_delegators :@data, :ofp_version
-    def_delegators :@data, :message_type
-    def_delegators :@data, :message_length
-    def_delegators :@data, :transaction_id
-    def_delegator :@data, :transaction_id, :xid
-    def_delegators :@data, :body
-    def_delegator :@data, :to_binary_s, :to_binary
-
+  class Hello < Pio::OpenFlow::Message
     # Parses +raw_data+ binary string into a Hello message object.
     #
     # @example
@@ -24,12 +13,10 @@ module Pio
     # @return [Pio::Hello]
     def self.read(raw_data)
       hello = allocate
-      begin
-        hello.instance_variable_set :@data, Format.read(raw_data)
-      rescue BinData::ValidityError
-        raise ParseError, $ERROR_INFO.message
-      end
+      hello.instance_variable_set :@format, Format.read(raw_data)
       hello
+    rescue BinData::ValidityError
+      raise Pio::ParseError, $ERROR_INFO.message
     end
 
     # Creates a Hello OpenFlow message.
@@ -52,17 +39,18 @@ module Pio
     #   @param [Hash] user_options The options to create a message with.
     #   @option user_options [Number] :transaction_id
     #   @option user_options [Number] :xid An alias to transaction_id.
+    #
+    # @reek This method smells of :reek:FeatureEnvy
     def initialize(user_options = {})
-      if user_options.respond_to?(:to_i)
-        @options = { transaction_id: user_options.to_i }
-      elsif user_options.respond_to?(:[])
-        @options = user_options.dup
-        @options[:transaction_id] ||= @options[:xid]
-        @options[:transaction_id] = 0 unless @options[:transaction_id]
-      else
-        fail TypeError
-      end
-      @data = Format.new(@options)
+      options = if user_options.respond_to?(:to_i)
+                  { transaction_id: user_options.to_i }
+                elsif user_options.respond_to?(:fetch)
+                  { transaction_id: user_options[:transaction_id] ||
+                                    user_options[:xid] || 0 }
+                else
+                  fail TypeError
+                end
+      @format = Format.new(open_flow_header: options)
     end
   end
 end