openflow-controller 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21f97d89fd5cca91d616a17cc08cb2923bc04752
-  data.tar.gz: f1025ee07213791f7d3472d8b76026a0ac9ba00f
+  metadata.gz: f74e50e943f426a39779802e1598be2a3ec7e718
+  data.tar.gz: 5bf304ebd253f6dc4978b92db08b4468c0c433f8
 SHA512:
-  metadata.gz: 38f589db1750a5395e5b32efa14a249d06b0530c178fcf649a9c5933ae63cba3f1ce9f3b482f996fc979b6e38e017d4c75d5aa551f82aee3ef201c270fa795c0
-  data.tar.gz: 6ed5c77459538dd5a16fabe2689886a1a6360b41512998f62d284fe2b19f43ea9b843649ea4d3ea2544c2c3a97954be8be898562d85d680692678ae51fe39545
+  metadata.gz: ac6728d86881f6aaad177fc65ba88d96b7dc7490cce185f35f13d4c46ee46f70a15cf5c535892f67e4b027ec4b218f7b9ba7aa437ecf751001faa2c4c86c3a2f
+  data.tar.gz: 510b7f3df83fc98ed7dbb137f5e8f68278e6b1a2ebf58954624db81c5a4ae1efba98e0d125cd2140abcfbcefb593c0a404d9260164b5945825bfd212ea2c914c

data/bin/ofctl

@@ -1,73 +1,4 @@
 #!/usr/bin/env ruby
-require 'cri'
-require 'readline'
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require 'openflow-controller'
-
-PROMPT = '> '
-BYE_MSG = 'Bye!'
-
-command = Cri::Command.define do
-  name        'ofctl'
-  usage       'ofctl [options] [args]'
-  summary     'OpenFlow Controller command-line tool'
-  description 'OpenFlow Controller command-line tool'
-
-  flag :h, :help, 'show help for this command' do |value, cmd|
-    puts cmd.help
-    exit 0
-  end
-  flag :d, :debug, 'run controller in debug mode'
-
-  option :i, :ip,         'IP address of the controller',  argument: :optional
-  option :p, :port,       'port number of the controller', argument: :optional
-  option :c, :controller, 'custom controller file',        argument: :optional
-
-  run do |opts, args, _cmd|
-    load opts[:controller] unless opts[:controller].nil?
-
-    debug = opts[:debug] || false
-
-    ctl = OpenFlow::Controller::Controller.create(debug)
-
-    init_form = ctl.logger.formatter
-    ctl.logger.formatter = proc do |severity, datetime, progname, msg|
-      buf = PROMPT + Readline::line_buffer
-      "\r" + ' ' * buf.length + "\r" +
-      init_form.call(severity, datetime, progname, msg).blue +
-      buf
-    end
-
-    ip   = opts[:ip]   || OpenFlow::Controller::Controller::DEFAULT_IP_ADDRESS
-    port = opts[:port] || OpenFlow::Controller::Controller::DEFAULT_TCP_PORT
-
-    Thread.abort_on_exception = true
-    Thread.new do
-      begin
-        ctl.run ip, port, args
-      rescue StandardError => e
-        puts "#{e.class}: #{e.message}".red
-        exit 1
-      end
-    end
-
-    loop do
-      begin
-        input = Readline.readline(PROMPT, true)
-        if input == 'exit'
-          puts BYE_MSG
-          exit
-        end
-        output = ctl.eval(input).inspect
-        puts " => #{output}".green
-      rescue StandardError => e
-        puts "#{e.class}: #{e.message}".red
-      rescue SignalException => e
-        puts "\n#{BYE_MSG}"
-        exit
-      end
-    end
-  end
-end
-
-command.run(ARGV)
+require 'openflow-controller/cli'
+OpenFlow::Controller::CLI.run

data/lib/openflow-controller/cli.rb

@@ -0,0 +1,95 @@
+require 'cri'
+require 'openflow-controller/completion'
+require 'openflow-controller/controller'
+
+module OpenFlow
+  module Controller
+    class CLI
+      PROMPT = '> '
+      BYE_MSG = 'Bye!'
+
+      def self.run
+        create_command.run(ARGV)
+      end
+
+      private
+
+      def self.print_error(e)
+        puts "#{e.class}: #{e.message}".red
+        puts e.backtrace.join("\n\t").red
+      end
+
+      def self.run_controller_on_thread(ctl, ip, port, args)
+        Thread.abort_on_exception = true
+        Thread.new do
+          begin
+            ctl.run ip, port, args
+          rescue StandardError => e
+            CLI.print_error e
+            exit 1
+          end
+        end
+      end
+
+      def self.run_cli(ctl)
+        loop do
+          begin
+            input = Readline.readline(PROMPT, true)
+            if input.nil? || input == 'exit'
+              puts if input.nil?
+              puts BYE_MSG
+              exit
+            end
+            output = eval(input, ctl.get_binding).inspect
+            # output = ctl.eval(input).inspect
+            puts " => #{output}".green
+          rescue StandardError, SyntaxError => e
+            print_error e
+          rescue SignalException
+            puts
+          end
+        end
+      end
+
+      def self.create_command
+        Cri::Command.define do
+          name        'ofctl'
+          usage       'ofctl [options] [args]'
+          summary     'OpenFlow Controller command-line tool'
+          description 'OpenFlow Controller command-line tool'
+
+          flag :h, :help, 'show help for this command' do |_value, cmd|
+            puts cmd.help
+            exit 0
+          end
+          flag :d, :debug, 'run controller in debug mode'
+
+          option :i, :ip,         'IP address of the controller',  argument: :optional
+          option :p, :port,       'port number of the controller', argument: :optional
+          option :c, :controller, 'custom controller file',        argument: :optional
+
+          run do |opts, args, _cmd|
+            load opts[:controller] unless opts[:controller].nil?
+
+            ctl = Controller.create
+            ctl.set_debug if opts[:debug]
+
+            init_form = ctl.logger.formatter
+            ctl.logger.formatter = proc do |severity, datetime, progname, msg|
+              buf = PROMPT + Readline::line_buffer
+              "\r" + ' ' * buf.length + "\r" +
+              init_form.call(severity, datetime, progname, msg).blue +
+              buf
+            end
+
+            ip   = opts[:ip]   || Controller::DEFAULT_IP_ADDRESS
+            port = opts[:port] || Controller::DEFAULT_TCP_PORT
+
+            CLI.run_controller_on_thread ctl, ip, port, args
+            CLI.run_cli ctl
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openflow-controller/completion.rb

@@ -0,0 +1,219 @@
+require 'readline'
+require 'openflow-controller/controller'
+
+module OpenFlow
+  module Controller
+    module Completion
+      # Set of reserved words used by Ruby, you should not use these for
+      # constants or variables
+      RESERVED_WORDS = %w[
+        BEGIN END
+        alias and
+        begin break
+        case class
+        def defined do
+        else elsif end ensure
+        false for
+        if in
+        module
+        next nil not
+        or
+        redo rescue retry return
+        self super
+        then true
+        undef unless until
+        when while
+        yield
+      ]
+
+      Proc = proc do |input|
+        bind = Controller.instance.get_binding
+
+        case input
+        when /^((["'`]).*\2)\.([^.]*)$/
+          # String
+          receiver = $1
+          message = Regexp.quote($3)
+
+          candidates = String.instance_methods.map(&:to_s)
+          select_message(receiver, message, candidates)
+
+        when /^(\/[^\/]*\/)\.([^.]*)$/
+          # Regexp
+          receiver = $1
+          message = Regexp.quote($2)
+
+          candidates = Regexp.instance_methods.map(&:to_s)
+          select_message(receiver, message, candidates)
+
+        when /^([^\]]*\])\.([^.]*)$/
+          # Array
+          receiver = $1
+          message = Regexp.quote($2)
+
+          candidates = Array.instance_methods.map(&:to_s)
+          select_message(receiver, message, candidates)
+
+        when /^([^\}]*\})\.([^.]*)$/
+          # Proc or Hash
+          receiver = $1
+          message = Regexp.quote($2)
+
+          candidates = Proc.instance_methods.map(&:to_s)
+          candidates |= Hash.instance_methods.map(&:to_s)
+          select_message(receiver, message, candidates)
+
+        when /^(:[^:.]*)$/
+          # Symbol
+          if Symbol.respond_to?(:all_symbols)
+            sym = $1
+            candidates = Symbol.all_symbols.map { |s| ':' + s.id2name }
+            candidates.grep(/^#{Regexp.quote(sym)}/)
+          else
+            []
+          end
+
+        when /^::([A-Z][^:\.\(]*)$/
+          # Absolute Constant or class methods
+          receiver = $1
+          candidates = Object.constants.map(&:to_s)
+          candidates.grep(/^#{receiver}/).map { |s| '::' + s }
+
+        when /^([A-Z].*)::([^:.]*)$/
+          # Constant or class methods
+          receiver = $1
+          message = Regexp.quote($2)
+          begin
+            candidates = eval("#{receiver}.constants.map(&:to_s)", bind)
+            candidates |= eval("#{receiver}.methods.map(&:to_s)", bind)
+          rescue Exception
+            candidates = []
+          end
+          select_message(receiver, message, candidates, '::')
+
+        when /^(:[^:.]+)(\.|::)([^.]*)$/
+          # Symbol
+          receiver = $1
+          sep = $2
+          message = Regexp.quote($3)
+
+          candidates = Symbol.instance_methods.map(&:to_s)
+          select_message(receiver, message, candidates, sep)
+
+        when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)(\.|::)([^.]*)$/
+          # Numeric
+          receiver = $1
+          sep = $5
+          message = Regexp.quote($6)
+
+          begin
+            candidates = eval(receiver, bind).methods.map(&:to_s)
+          rescue Exception
+            candidates = []
+          end
+          select_message(receiver, message, candidates, sep)
+
+        when /^(-?0x[0-9a-fA-F_]+)(\.|::)([^.]*)$/
+          # Numeric(0xFFFF)
+          receiver = $1
+          sep = $2
+          message = Regexp.quote($3)
+
+          begin
+            candidates = eval(receiver, bind).methods.map(&:to_s)
+          rescue Exception
+            candidates = []
+          end
+          select_message(receiver, message, candidates, sep)
+
+        when /^(\$[^.]*)$/
+          # global var
+          regmessage = Regexp.new(Regexp.quote($1))
+          candidates = global_variables.map(&:to_s).grep(regmessage)
+
+        when /^([^."].*)(\.|::)([^.]*)$/
+          # variable.func or func.func
+          receiver = $1
+          sep = $2
+          message = Regexp.quote($3)
+
+          gv = eval('global_variables', bind).map(&:to_s)
+          lv = eval('local_variables', bind).map(&:to_s)
+          iv = eval('instance_variables', bind).map(&:to_s)
+          cv = eval('self.class.constants', bind).map(&:to_s)
+
+          if (gv | lv | iv | cv).include?(receiver) or /^[A-Z]/ =~ receiver && /\./ !~ receiver
+            # foo.func and foo is var. OR
+            # foo::func and foo is var. OR
+            # foo::Const and foo is var. OR
+            # Foo::Bar.func
+            begin
+              candidates = []
+              rec = eval(receiver, bind)
+              if sep == '::' and rec.kind_of?(Module)
+                candidates = rec.constants.map(&:to_s)
+              end
+              candidates |= rec.methods.map(&:to_s)
+            rescue Exception
+              candidates = []
+            end
+          else
+            # func1.func2
+            candidates = []
+            ObjectSpace.each_object(Module) do |m|
+              begin
+                name = m.name
+              rescue Exception
+                name = ''
+              end
+              begin
+                next if name != "IRB::Context" and
+                  /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
+              rescue Exception
+                next
+              end
+              candidates.concat m.instance_methods(false).map(&:to_s)
+            end
+            candidates.sort!
+            candidates.uniq!
+          end
+          select_message(receiver, message, candidates, sep)
+
+        when /^\.([^.]*)$/
+          # unknown(maybe String)
+          receiver = ''
+          message = Regexp.quote($1)
+
+          candidates = String.instance_methods(true).map(&:to_s)
+          select_message(receiver, message, candidates)
+
+        else
+          candidates = eval('methods | private_methods | local_variables | instance_variables | self.class.constants | Object.constants | OpenFlow.constants | OpenFlow::Controller.constants', bind).map(&:to_s)
+
+          (candidates | RESERVED_WORDS).grep(/^#{Regexp.quote(input)}/)
+        end
+      end
+
+      # Set of available operators in Ruby
+      OPERATORS = %w[% & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ ! != !~]
+
+      def self.select_message(receiver, message, candidates, sep = '.')
+        candidates.grep(/^#{message}/).map do |e|
+          case e
+          when /^[a-zA-Z_]/
+            receiver + sep + e
+          when /^[0-9]/
+          when *OPERATORS
+            #receiver + " " + e
+          end
+        end
+      end
+    end
+  end
+end
+
+if Readline.respond_to?('basic_word_break_characters=')
+  Readline.basic_word_break_characters = " \t\n`><=;|&{("
+end
+Readline.completion_append_character = nil
+Readline.completion_proc = OpenFlow::Controller::Completion::Proc

data/lib/openflow-controller/controller.rb

@@ -10,6 +10,7 @@ module OpenFlow
   module Controller
     class Controller
       include Protocol
+      include PacketProtocols
 
       DEFAULT_IP_ADDRESS = '0.0.0.0'
       DEFAULT_TCP_PORT   = 6633
@@ -18,8 +19,12 @@ module OpenFlow
         @controller_class = subclass
       end
 
-      def self.create(*args)
-        (@controller_class || self).new(*args)
+      def self.create
+        @instance = (@controller_class || self).new
+      end
+
+      def self.instance
+        @instance
       end
 
       def self.timer_event(handler, options)
@@ -33,19 +38,23 @@ module OpenFlow
 
       attr_reader :logger
 
-      def initialize(debug = false)
+      def initialize
         @switches = {}
         @messages = {}
         @logger = Logger.new($stdout).tap do |logger|
           logger.formatter = proc do |severity, datetime, _progname, msg|
             "#{datetime} (#{severity}) -- #{msg}\n"
           end
-          logger.level = debug ? Logger::DEBUG : Logger::INFO
+          logger.level = Logger::INFO
         end
       end
 
-      def eval(input)
-        binding.eval(input)
+      def set_debug
+        @logger.level = Logger::DEBUG
+      end
+
+      def get_binding
+        binding
       end
 
       def run(ip = DEFAULT_IP_ADDRESS, port = DEFAULT_TCP_PORT, *args)

data/lib/openflow-controller/version.rb

@@ -1,5 +1,5 @@
 module OpenFlow
   module Controller
-    VERSION = '0.1.9'
+    VERSION = '0.1.10'
   end
 end

data/spec/controller_spec.rb

@@ -18,6 +18,7 @@ describe Controller do
   end
 
   it 'should handle start' do
+    sleep(0.001)
     expect(@ctl.start_args).to eq(['Hello World!', 42])
   end
 

data/spec/spec_helper.rb

@@ -1,3 +1,6 @@
+require 'coveralls'
+Coveralls.wear!
 require 'openflow-controller'
+
 include OpenFlow::Controller
 include OpenFlow::Protocol

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openflow-controller
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Jérémy Pagé
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-12 00:00:00.000000000 Z
+date: 2016-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: openflow-protocol
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.8
+        version: 0.1.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.8
+        version: 0.1.9
 - !ruby/object:Gem::Dependency
   name: colored
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +56,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.4'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.4'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: An OpenFlow Controller.
 email:
 - contact@jeremypage.me
@@ -90,6 +104,8 @@ extra_rdoc_files: []
 files:
 - bin/ofctl
 - lib/openflow-controller.rb
+- lib/openflow-controller/cli.rb
+- lib/openflow-controller/completion.rb
 - lib/openflow-controller/controller.rb
 - lib/openflow-controller/switch.rb
 - lib/openflow-controller/version.rb