iruby 0.3 → 0.7.0

data/lib/iruby/kernel.rb

@@ -1,36 +1,126 @@
 module IRuby
+  ExecutionInfo = Struct.new(:raw_cell, :store_history, :silent)
+
   class Kernel
     RED = "\e[31m"
-    WHITE = "\e[37m"
     RESET = "\e[0m"
 
-    class<< self
+    @events = EventManager.new([:initialized])
+
+    class << self
+      # Return the event manager defined in the `IRuby::Kernel` class.
+      # This event manager can handle the following event:
+      #
+      # - `initialized`: The event occurred after the initialization of
+      #   a `IRuby::Kernel` instance is finished
+      #
+      # @example Registering initialized event
+      #   IRuby::Kernel.events.register(:initialized) do |result|
+      #     STDERR.puts "IRuby kernel has been initialized"
+      #   end
+      #
+      # @see IRuby::EventManager
+      # @see IRuby::Kernel#events
+      attr_reader :events
+
+      # Returns the singleton kernel instance
       attr_accessor :instance
     end
 
+    # Returns a session object
     attr_reader :session
 
-    def initialize(config_file)
+    EVENTS = [
+      :pre_execute,
+      :pre_run_cell,
+      :post_run_cell,
+      :post_execute
+    ].freeze
+
+    def initialize(config_file, session_adapter_name=nil)
       @config = MultiJson.load(File.read(config_file))
       IRuby.logger.debug("IRuby kernel start with config #{@config}")
       Kernel.instance = self
 
-      @session = Session.new(@config)
+      @session = Session.new(@config, session_adapter_name)
       $stdout = OStream.new(@session, :stdout)
       $stderr = OStream.new(@session, :stderr)
 
+      init_parent_process_poller
+
+      @events = EventManager.new(EVENTS)
       @execution_count = 0
-      @backend = create_backend
+      @backend = PlainBackend.new
       @running = true
+
+      self.class.events.trigger(:initialized, self)
     end
 
-    def create_backend
-      PryBackend.new
-    rescue Exception => e
-      IRuby.logger.warn "Could not load PryBackend: #{e.message}\n#{e.backtrace.join("\n")}" unless LoadError === e
-      PlainBackend.new
+    # Returns the event manager defined in a `IRuby::Kernel` instance.
+    # This event manager can handle the following events:
+    #
+    # - `pre_execute`: The event occurred before running the code
+    #
+    # - `pre_run_cell`: The event occurred before running the code and
+    #   if the code execution is not silent
+    #
+    # - `post_execute`: The event occurred after running the code
+    #
+    # - `post_run_cell`: The event occurred after running the code and
+    #   if the code execution is not silent
+    #
+    # The callback functions of `pre_run_cell` event must take one argument
+    # to get an `ExecutionInfo` object.
+    # The callback functions of `post_run_cell` event must take one argument
+    # to get the result of the code execution.
+    #
+    # @example Registering post_run_cell event
+    #   IRuby::Kernel.instance.events.register(:post_run_cell) do |result|
+    #     STDERR.puts "The result of the last execution: %p" % result
+    #   end
+    #
+    # @see IRuby::EventManager
+    # @see IRuby::ExecutionInfo
+    # @see IRuby::Kernel.events
+    attr_reader :events
+
+    # Switch the backend (interactive shell) system
+    #
+    # @param backend [:irb,:plain,:pry] Specify the backend name switched to
+    #
+    # @return [true,false] true if the switching succeeds, otherwise false
+    def switch_backend!(backend)
+      name = case backend
+             when String, Symbol
+               name = backend.downcase
+             else
+               name = backend
+             end
+
+      backend_class = case name
+                      when :irb, :plain
+                        PlainBackend
+                      when :pry
+                        PryBackend
+                      else
+                        raise ArgumentError,
+                          "Unknown backend name: %p" % backend
+                      end
+
+      begin
+        new_backend = backend_class.new
+        @backend = new_backend
+        true
+      rescue Exception => e
+        unless LoadError === e
+          IRuby.logger.warn "Could not load #{backend_class}: " +
+                            "#{e.message}\n#{e.backtrace.join("\n")}"
+        end
+        return false
+      end
     end
 
+    # @private
     def run
       send_status :starting
       while @running
@@ -38,8 +128,10 @@ module IRuby
       end
     end
 
+    # @private
     def dispatch
       msg = @session.recv(:reply)
+      IRuby.logger.debug "Kernel#dispatch: msg = #{msg}"
       type = msg[:header]['msg_type']
       raise "Unknown message type: #{msg.inspect}" unless type =~ /comm_|_request\Z/ && respond_to?(type)
       begin
@@ -50,31 +142,54 @@ module IRuby
       end
     rescue Exception => e
       IRuby.logger.debug "Kernel error: #{e.message}\n#{e.backtrace.join("\n")}"
-      @session.send(:publish, :error, error_message(e))
+      @session.send(:publish, :error, error_content(e))
     end
 
+    # @private
     def kernel_info_request(msg)
       @session.send(:reply, :kernel_info_reply,
                     protocol_version: '5.0',
                     implementation: 'iruby',
-                    banner: "IRuby #{IRuby::VERSION}",
                     implementation_version: IRuby::VERSION,
                     language_info: {
                       name: 'ruby',
                       version: RUBY_VERSION,
                       mimetype: 'application/x-ruby',
                       file_extension: '.rb'
-                    })
+                    },
+                    banner: "IRuby #{IRuby::VERSION} (with #{@session.description})",
+                    help_links: [
+                      {
+                        text: "Ruby Documentation",
+                        url:  "https://ruby-doc.org/"
+                      }
+                    ],
+                    status: :ok)
     end
 
+    # @private
     def send_status(status)
+      IRuby.logger.debug "Send status: #{status}"
       @session.send(:publish, :status, execution_state: status)
     end
 
+    # @private
     def execute_request(msg)
       code = msg[:content]['code']
-      @execution_count += 1 if msg[:content]['store_history']
-      @session.send(:publish, :execute_input, code: code, execution_count: @execution_count)
+      store_history = msg[:content]['store_history']
+      silent = msg[:content]['silent']
+
+      @execution_count += 1 if store_history
+
+      unless silent
+        @session.send(:publish, :execute_input, code: code, execution_count: @execution_count)
+      end
+
+      events.trigger(:pre_execute)
+      unless silent
+        exec_info = ExecutionInfo.new(code, store_history, silent)
+        events.trigger(:pre_run_cell, exec_info)
+      end
 
       content = {
         status: :ok,
@@ -82,30 +197,49 @@ module IRuby
         user_expressions: {},
         execution_count: @execution_count
       }
+
       result = nil
       begin
-        result = @backend.eval(code, msg[:content]['store_history'])
+        result = @backend.eval(code, store_history)
       rescue SystemExit
         content[:payload] << { source: :ask_exit }
       rescue Exception => e
-        content = error_message(e)
+        content = error_content(e)
         @session.send(:publish, :error, content)
+        content[:status] = :error
+        content[:execution_count] = @execution_count
+      end
+
+      unless result.nil? || silent
+        @session.send(:publish, :execute_result,
+                      data: Display.display(result),
+                      metadata: {},
+                      execution_count: @execution_count)
       end
+
+      events.trigger(:post_execute)
+      events.trigger(:post_run_cell, result) unless silent
+
       @session.send(:reply, :execute_reply, content)
-      @session.send(:publish, :execute_result,
-                    data: Display.display(result),
-                    metadata: {},
-                    execution_count: @execution_count) unless result.nil? || msg[:content]['silent']
     end
 
-    def error_message(e)
-      { status: :error,
-        ename: e.class.to_s,
+    # @private
+    def error_content(e)
+      rindex = e.backtrace.rindex{|line| line.start_with?(@backend.eval_path)} || -1
+      backtrace = SyntaxError === e  && rindex == -1 ? [] : e.backtrace[0..rindex]
+      { ename: e.class.to_s,
         evalue: e.message,
-        traceback: ["#{RED}#{e.class}#{RESET}: #{e.message}", *e.backtrace.map { |l| "#{WHITE}#{l}#{RESET}" }],
-        execution_count: @execution_count }
+        traceback: ["#{RED}#{e.class}#{RESET}: #{e.message}", *backtrace] }
+    end
+
+    # @private
+    def is_complete_request(msg)
+      # FIXME: the code completeness should be judged by using ripper or other Ruby parser
+      @session.send(:reply, :is_complete_reply,
+                    status: :unknown)
     end
 
+    # @private
     def complete_request(msg)
       # HACK for #26, only complete last line
       code = msg[:content]['code']
@@ -115,51 +249,85 @@ module IRuby
       end
       @session.send(:reply, :complete_reply,
                     matches: @backend.complete(code),
-                    status: :ok,
                     cursor_start: start.to_i,
-                    cursor_end: msg[:content]['cursor_pos'])
+                    cursor_end: msg[:content]['cursor_pos'],
+                    metadata: {},
+                    status: :ok)
     end
 
+    # @private
     def connect_request(msg)
       @session.send(:reply, :connect_reply, Hash[%w(shell_port iopub_port stdin_port hb_port).map {|k| [k, @config[k]] }])
     end
 
+    # @private
     def shutdown_request(msg)
       @session.send(:reply, :shutdown_reply, msg[:content])
       @running = false
     end
 
+    # @private
     def history_request(msg)
       # we will just send back empty history for now, pending clarification
       # as requested in ipython/ipython#3806
       @session.send(:reply, :history_reply, history: [])
     end
 
+    # @private
     def inspect_request(msg)
-      result = @backend.eval(msg[:content]['code'])
-      @session.send(:reply, :inspect_reply,
-                    status: :ok,
-                    data: Display.display(result),
-                    metadata: {})
-    rescue Exception => e
-      IRuby.logger.warn "Inspection error: #{e.message}\n#{e.backtrace.join("\n")}"
-      @session.send(:reply, :inspect_reply, status: :error)
+      # not yet implemented. See (#119).
+      @session.send(:reply, :inspect_reply, status: :ok, found: false, data: {}, metadata: {})
     end
 
+    # @private
     def comm_open(msg)
       comm_id = msg[:content]['comm_id']
       target_name = msg[:content]['target_name']
       Comm.comm[comm_id] = Comm.target[target_name].new(target_name, comm_id)
     end
 
+    # @private
     def comm_msg(msg)
       Comm.comm[msg[:content]['comm_id']].handle_msg(msg[:content]['data'])
     end
 
+    # @private
     def comm_close(msg)
       comm_id = msg[:content]['comm_id']
       Comm.comm[comm_id].handle_close(msg[:content]['data'])
       Comm.comm.delete(comm_id)
     end
+
+    private
+
+    def init_parent_process_poller
+      pid = ENV.fetch('JPY_PARENT_PID', 0).to_i
+      return unless pid > 1
+
+      case RUBY_PLATFORM
+      when /mswin/, /mingw/
+        # TODO
+      else
+        @parent_poller = start_parent_process_pollar_unix
+      end
+    end
+
+    def start_parent_process_pollar_unix
+      Thread.start do
+        IRuby.logger.warn("parent process poller thread started.")
+        loop do
+          begin
+            current_ppid = Process.ppid
+            if current_ppid == 1
+              IRuby.logger.warn("parent process appears to exited, shutting down.")
+              exit!(1)
+            end
+            sleep 1
+          rescue Errno::EINTR
+            # ignored
+          end
+        end
+      end
+    end
   end
 end

data/lib/iruby/ostream.rb

@@ -25,22 +25,43 @@ module IRuby
     alias_method :next, :read
     alias_method :readline, :read
 
-    def write(s)
-      raise 'I/O operation on closed file' unless @session
-      @session.send(:publish, :stream, name: @name, text: s.to_s)
-      nil
+    def write(*obj)
+      str = build_string { |sio| sio.write(*obj) }
+      session_send(str)
     end
     alias_method :<<, :write
     alias_method :print, :write
 
-    def puts(*lines)
-      lines = [''] if lines.empty?
-      lines.each { |s| write("#{s}\n")}
-      nil
+    def printf(format, *obj)
+      str = build_string { |sio| sio.printf(format, *obj) }
+      session_send(str)
+    end
+
+    def puts(*obj)
+      str = build_string { |sio| sio.puts(*obj) }
+      session_send(str)
     end
 
     def writelines(lines)
       lines.each { |s| write(s) }
     end
+
+    # Called by irb
+    def set_encoding(extern, intern)
+      a = extern
+    end
+
+    private
+
+    def build_string
+      StringIO.open { |sio| yield(sio); sio.string }
+    end
+
+    def session_send(str)
+      raise 'I/O operation on closed file' unless @session
+
+      @session.send(:publish, :stream, name: @name, text: str)
+      nil
+    end
   end
 end

data/lib/iruby/session.rb

@@ -0,0 +1,117 @@
+require 'iruby/session_adapter'
+require 'iruby/session/mixin'
+
+require 'securerandom'
+
+module IRuby
+  class Session
+    include SessionSerialize
+
+    def initialize(config, adapter_name=nil)
+      @config = config
+      @adapter = create_session_adapter(config, adapter_name)
+      @last_recvd_msg = nil
+
+      setup
+      setup_sockets
+      setup_heartbeat
+      setup_security
+    end
+
+    attr_reader :adapter, :config
+
+    def description
+      "#{@adapter.name} session adapter"
+    end
+
+    def setup
+    end
+
+    def setup_sockets
+      protocol, host = config.values_at('transport', 'ip')
+      shell_port = config['shell_port']
+      iopub_port = config['iopub_port']
+      stdin_port = config['stdin_port']
+
+      @shell_socket, @shell_port = @adapter.make_router_socket(protocol, host, shell_port)
+      @iopub_socket, @iopub_port = @adapter.make_pub_socket(protocol, host, iopub_port)
+      @stdin_socket, @stdin_port = @adapter.make_router_socket(protocol, host, stdin_port)
+
+      @sockets = {
+        publish: @iopub_socket,
+        reply:   @shell_socket,
+        stdin:   @stdin_socket
+      }
+    end
+
+    def setup_heartbeat
+      protocol, host = config.values_at('transport', 'ip')
+      hb_port = config['hb_port']
+      @hb_socket, @hb_port = @adapter.make_rep_socket(protocol, host, hb_port)
+      @heartbeat_thread = Thread.start do
+        begin
+          # NOTE: this loop is copied from CZTop's old session code
+          @adapter.heartbeat_loop(@hb_socket)
+        rescue Exception => e
+          IRuby.logger.fatal "Kernel heartbeat died: #{e.message}\n#{e.backtrace.join("\n")}"
+        end
+      end
+    end
+
+    def setup_security
+      @session_id = SecureRandom.uuid
+      unless config['key'].empty? || config['signature_scheme'].empty?
+        unless config['signature_scheme'] =~ /\Ahmac-/
+          raise "Unknown signature_scheme: #{config['signature_scheme']}"
+        end
+        digest_algorithm = config['signature_scheme'][/\Ahmac-(.*)\Z/, 1]
+        @hmac = OpenSSL::HMAC.new(config['key'], OpenSSL::Digest.new(digest_algorithm))
+      end
+    end
+
+    def send(socket_type, message_type, content)
+      sock = check_socket_type(socket_type)
+      idents = if socket_type == :reply && @last_recvd_msg
+                 @last_recvd_msg[:idents]
+               else
+                 message_type == :stream ? "stream.#{content[:name]}" : message_type
+               end
+      header = {
+        msg_type: message_type,
+        msg_id:   SecureRandom.uuid,
+        username: 'kernel',
+        session:  @session_id,
+        version:  '5.0'
+      }
+      @adapter.send(sock, serialize(idents, header, content))
+    end
+
+    def recv(socket_type)
+      sock = check_socket_type(socket_type)
+      data = @adapter.recv(sock)
+      @last_recvd_msg = unserialize(data)
+    end
+
+    def recv_input
+      sock = check_socket_type(:stdin)
+      data = @adapter.recv(sock)
+      unserialize(data)[:content]["value"]
+    end
+
+    private
+
+    def check_socket_type(socket_type)
+      case socket_type
+      when :publish, :reply, :stdin
+        @sockets[socket_type]
+      else
+        raise ArgumentError, "Invalid socket type #{socket_type}"
+      end
+    end
+
+    def create_session_adapter(config, adapter_name)
+      adapter_class = SessionAdapter.select_adapter_class(adapter_name)
+      adapter_class.new(config)
+    end
+  end
+end