scriptty 0.5.0-java

data/lib/scriptty/expect.rb

@@ -0,0 +1,392 @@
+# = Expect object
+# Copyright (C) 2010  Infonium Inc.
+#
+# This file is part of ScripTTY.
+#
+# ScripTTY is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ScripTTY is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ScripTTY.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'scriptty/exception'
+require 'scriptty/net/event_loop'
+require 'scriptty/term'
+require 'scriptty/screen_pattern'
+require 'scriptty/util/transcript/writer'
+require 'set'
+
+module ScripTTY
+  class Expect
+
+    # Methods to export to Evaluator
+    EXPORTED_METHODS = Set.new [:init_term, :term, :connect, :screen, :expect, :on, :wait, :send, :match, :push_patterns, :pop_patterns, :exit, :eval_script_file, :eval_script_inline, :sleep, :set_timeout, :load_screens ]
+
+    attr_reader :term   # The terminal emulation object
+
+    attr_reader :match  # The last non-background expect match.  For a ScreenPattern match, this is a Hash of fields.  For a String or Regexp match, this is a MatchData object.
+
+    attr_accessor :transcript_writer # Set this to an instance of ScripTTY::Util::Transcript::Writer
+
+    # Initialize the Expect object.
+    def initialize(options={})
+      @net = ScripTTY::Net::EventLoop.new
+      @suspended = false
+      @effective_patterns = nil
+      @term_name = nil
+      @effective_patterns = []    # Array of PatternHandle objects
+      @pattern_stack = []
+      @wait_finished = false
+      @evaluator = Evaluator.new(self)
+      @match_buffer = ""
+      @timeout = nil
+      @timeout_timer = nil
+      @transcript_writer = options[:transcript_writer]
+      @screen_patterns = {}
+    end
+
+    def set_timeout(seconds)
+      raise ArgumentError.new("argument to set_timeout must be Numeric or nil") unless seconds.is_a?(Numeric) or seconds.nil?
+      if seconds
+        @timeout = seconds.to_f
+      else
+        @timeout = nil
+      end
+      refresh_timeout
+      nil
+    end
+
+    # Load and evaluate a script from a file.
+    def eval_script_file(path)
+      eval_script_inline(File.read(path), path)
+    end
+
+    # Evaluate a script specified as a string.
+    def eval_script_inline(str, filename=nil, lineno=nil)
+      @evaluator.instance_eval(str, filename || "(inline)", lineno || 1)
+    end
+
+    # Initialize a terminal emulator.
+    #
+    # If a name is specified, use that terminal type.  Otherwise, use the
+    # previous terminal type.
+    def init_term(name=nil)
+      @transcript_writer.info("Script executing command", "init_term", name || "") if @transcript_writer
+      name ||= @term_name
+      @term_name = name
+      raise ArgumentError.new("No previous terminal specified") unless name
+      without_timeout {
+        @term = ScripTTY::Term.new(name)
+        @term.on_unknown_sequence do |seq|
+          @transcript_writer.info("Unknown escape sequence", seq) if @transcript_writer
+        end
+      }
+      nil
+    end
+
+    # Connect to the specified address.  Return true if the connection was
+    # successful.  Otherwise, raise an exception.
+    def connect(remote_address)
+      @transcript_writer.info("Script executing command", "connect", *remote_address.map{|a| a.inspect}) if @transcript_writer
+      connected = false
+      connect_error = nil
+      @conn = @net.connect(remote_address) do |c|
+        c.on_connect { connected = true; handle_connect; @net.suspend }
+        c.on_connect_error { |e| connect_error = e; @net.suspend }
+        c.on_receive_bytes { |bytes| handle_receive_bytes(bytes) }
+        c.on_close { @conn = nil; handle_connection_close }
+      end
+      dispatch until connected or connect_error or @net.done?
+      if connect_error
+        transcribe_connect_error(connect_error)
+        raise ScripTTY::Exception::ConnectError.new(connect_error)
+      end
+      refresh_timeout
+      connected
+    end
+
+    # Add the specified pattern to the effective pattern list.
+    #
+    # Return the PatternHandle for the pattern.
+    #
+    # Options:
+    # [:continue]
+    #   If true, matching this pattern will not cause the wait method to
+    #   return.
+    def on(pattern, opts={}, &block)
+      case pattern
+      when String
+        @transcript_writer.info("Script executing command", "on", "String", pattern.inspect) if @transcript_writer
+        ph = PatternHandle.new(/#{Regexp.escape(pattern)}/n, block, opts[:background])
+      when Regexp
+        @transcript_writer.info("Script executing command", "on", "Regexp", pattern.inspect) if @transcript_writer
+        if pattern.kcode == "none"
+          ph = PatternHandle.new(pattern, block, opts[:background])
+        else
+          ph = PatternHandle.new(/#{pattern}/n, block, opts[:background])
+        end
+      when ScreenPattern
+        @transcript_writer.info("Script executing command", "on", "ScreenPattern", pattern.name, opts[:background] ? "BACKGROUND" : "") if @transcript_writer
+        ph = PatternHandle.new(pattern, block, opts[:background])
+      else
+        raise TypeError.new("Unsupported pattern type: #{pattern.class.inspect}")
+      end
+      @effective_patterns << ph
+      ph
+    end
+
+    # Sleep for the specified number of seconds
+    def sleep(seconds)
+      @transcript_writer.info("Script executing command", "sleep", seconds.inspect) if @transcript_writer
+      sleep_done = false
+      @net.timer(seconds) { sleep_done = true ; @net.suspend }
+      dispatch until sleep_done
+      refresh_timeout
+      nil
+    end
+
+    # Return the named ScreenPattern (or nil if no such pattern exists)
+    def screen(name)
+      @screen_patterns[name.to_sym]
+    end
+
+    # Load screens from the specified filenames
+    def load_screens(filenames_or_glob)
+      if filenames_or_glob.is_a?(String)
+        filenames = Dir.glob(filenames_or_glob)
+      elsif filenames_or_glob.is_a?(Array)
+        filenames = filenames_or_glob
+      else
+        raise ArgumentError.new("load_screens takes a string(glob) or an array, not #{filenames.class.name}")
+      end
+      filenames.each do |filename|
+        ScreenPattern.parse(File.read(filename)).each do |pattern|
+          @screen_patterns[pattern.name.to_sym] = pattern
+        end
+      end
+      nil
+    end
+
+    # Convenience function.
+    #
+    # == Examples
+    #  # Wait for a single pattern to match.
+    #  expect("login: ")
+    #
+    #  # Wait for one of several patterns to match.
+    #  expect {
+    #    on("login successful") { ... }
+    #    on("login incorrect") { ... }
+    #  }
+    def expect(pattern=nil)
+      raise ArgumentError.new("no pattern and no block given") if !pattern and !block_given?
+      @transcript_writer.info("Script expect block BEGIN") if @transcript_writer and block_given?
+      push_patterns
+      begin
+        on(pattern) if pattern
+        yield if block_given?
+        wait
+      ensure
+        pop_patterns
+        @transcript_writer.info("Script expect block END") if @transcript_writer and block_given?
+      end
+    end
+
+    # Push a copy of the effective pattern list to an internal stack.
+    def push_patterns
+      @pattern_stack << @effective_patterns.dup
+    end
+
+    # Pop the effective pattern list from the stack.
+    def pop_patterns
+      raise ArgumentError.new("pattern stack empty") if @pattern_stack.empty?
+      @effective_patterns = @pattern_stack.pop
+    end
+
+    # Wait for an effective pattern to match.
+    #
+    # Clears the character-match buffer on return.
+    def wait
+      @transcript_writer.info("Script executing command", "wait") if @transcript_writer
+      check_expect_match unless @wait_finished
+      dispatch until @wait_finished
+      refresh_timeout
+      @wait_finished = false
+      nil
+    end
+
+    # Send bytes to the remote application.
+    #
+    # NOTE: This method returns immediately, even if not all the bytes are
+    # finished being sent.  Remaining bytes will be sent during an expect,
+    # wait, or sleep call.
+    def send(bytes)
+      @transcript_writer.from_client(bytes) if @transcript_writer
+      @conn.write(bytes)
+      true
+    end
+
+    # Close the connection and exit.
+    def exit
+      @transcript_writer.info("Script executing command", "exit") if @transcript_writer
+      @net.exit
+      dispatch until @net.done?
+      @transcript_writer.close if @transcript_writer
+    end
+
+    private
+
+      # Kick the watchdog timer
+      def refresh_timeout
+        disable_timeout
+        enable_timeout
+      end
+
+      def without_timeout
+        raise ArgumentError.new("no block given") unless block_given?
+        disable_timeout
+        begin
+          yield
+        ensure
+          enable_timeout
+        end
+      end
+
+      # Disable timeout handling
+      def disable_timeout
+        if @timeout_timer
+          @timeout_timer.cancel
+          @timeout_timer = nil
+        end
+        nil
+      end
+
+      # Enable timeout handling (if @timeout is set)
+      def enable_timeout
+        if @timeout
+          @timeout_timer = @net.timer(@timeout, :daemon=>true) { raise ScripTTY::Exception::Timeout.new("Operation timed out") }
+        end
+        nil
+      end
+
+      # Re-enter the dispatch loop
+      def dispatch
+        if @suspended
+          @suspended = @net.resume
+        else
+          @suspended = @net.main
+        end
+      end
+
+      def handle_connection_close   # XXX - we should raise an error when disconnected prematurely
+        @transcript_writer.server_close("connection closed") if @transcript_writer
+        self.exit
+      end
+
+      def handle_connect
+        @transcript_writer.server_open(*@conn.remote_address) if @transcript_writer
+        init_term
+      end
+
+      def transcribe_connect_error(e)
+        if @transcript_writer
+          @transcript_writer.info("Connect error", e.class.name, e.to_s, e.backtrace.join("\n"))
+          # Write the backtrace out as separate records, for the convenience of people reading the logs without a parser.
+          e.backtrace.each do |line|
+            @transcript_writer.info("Connect error backtrace", line)
+          end
+        end
+      end
+
+      def handle_receive_bytes(bytes)
+        @transcript_writer.from_server(bytes) if @transcript_writer
+        @match_buffer << bytes
+        @term.feed_bytes(bytes)
+        check_expect_match
+      end
+
+      # Check for a match.
+      #
+      # If there is a (non-background) match, set @wait_finished and return true.  Otherwise, return false.
+      def check_expect_match
+        found = true
+        while found
+          found = false
+          @effective_patterns.each { |ph|
+            case ph.pattern
+            when Regexp
+              m = ph.pattern.match(@match_buffer)
+              @match_buffer = @match_buffer[m.end(0)..-1] if m    # truncate match buffer
+            when ScreenPattern
+              m = ph.pattern.match_term(@term)
+              @match_buffer = "" if m   # truncate match buffer if a screen matches
+            else
+              raise "BUG: pattern is #{ph.pattern.inspect}"
+            end
+
+            next unless m
+
+            # Matched - Invoke the callback
+            ph.callback.call(m) if ph.callback
+
+            # Make the next wait() call return
+            unless ph.background?
+              @match = m
+              @wait_finished = true
+              @net.suspend
+              return true
+            else
+              found = true
+            end
+          }
+        end
+        false
+      end
+
+    class Evaluator
+      def initialize(expect_object)
+        @_expect_object = expect_object
+      end
+
+      # Define proxy methods
+      EXPORTED_METHODS.each do |m|
+        # We would use define_method, but JRuby 1.4 doesn't support defining
+        # a block that takes a block. http://jira.codehaus.org/browse/JRUBY-4180
+        class_eval("def #{m}(*args, &block) @_expect_object.__send__(#{m.inspect}, *args, &block); end")
+      end
+    end
+
+    class PatternHandle
+      attr_reader :pattern
+      attr_reader :callback
+
+      def initialize(pattern, callback, background)
+        @pattern = pattern
+        @callback = callback
+        @background = background
+      end
+
+      def background?
+        @background
+      end
+    end
+
+    class Match
+      attr_reader :pattern_handle
+      attr_reader :result
+
+      def initialize(pattern_handle, result)
+        @pattern_handle = pattern_handle
+        @result = result
+      end
+    end
+
+  end
+end

data/lib/scriptty/multiline_buffer.rb

@@ -0,0 +1,192 @@
+# = Multi-line character buffer
+# Copyright (C) 2010  Infonium Inc.
+#
+# This file is part of ScripTTY.
+#
+# ScripTTY is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ScripTTY is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ScripTTY.  If not, see <http://www.gnu.org/licenses/>.
+
+module ScripTTY
+  class MultilineBuffer
+    attr_reader :height   # buffer height (in lines)
+    attr_reader :width    # buffer width (in columns)
+    attr_reader :content  # contents of the screen buffer (mainly for debugging/testing)
+    def initialize(height, width)
+      @height = height
+      @width = width
+      clear!
+    end
+
+    # Clear the buffer
+    def clear!
+      @content = []   # Array of mutable Strings
+      @height.times {
+        @content << " "*@width
+      }
+      nil
+    end
+
+    # Write a string (or array of strings) to the specified location.
+    #
+    # row & column are zero-based
+    #
+    # Returns the characters that were replaced
+    def replace_at(row, column, value)
+      if value.is_a?(Array)
+        orig = []
+        value.each_with_index do |string, i|
+          orig << replace_at(row+i, column, string)
+        end
+        orig
+      else
+        # value is a string
+        return nil if row < 0 or row >= height or column < 0 or column >= width # XXX should we raise an exception here?
+        orig = @content[row][column,value.length]
+        @content[row][column,value.length] = value
+        @content[row] = @content[row][0,width]    # truncate to maximum width
+        orig
+      end
+    end
+
+    # Return characters starting at the specified location.
+    #
+    # The limit parameter specifies the maximum number of bytes to return.
+    # If limit is negative, then everything up to the end of the line is returned.
+    def get_at(row, column, limit=1)
+      return nil if row < 0 or row >= height or column < 0 or column >= width # XXX should we raise an exception here?
+      if limit >= 0
+        @content[row][column,limit]
+      else
+        @content[row][column..-1]
+      end
+    end
+
+    # Scroll the specified rectangle up by the specified number of lines.
+    # Return true.
+    def scroll_up_region(row0, col0, row1, col1, count)
+      scroll_region_vertical(:up, row0, col0, row1, col1, count)
+    end
+
+    # Scroll the specified rectangle down by the specified number of lines.
+    # Return true.
+    def scroll_down_region(row0, col0, row1, col1, count)
+      scroll_region_vertical(:down, row0, col0, row1, col1, count)
+    end
+
+    def scroll_left_region(row0, col0, row1, col1, count)
+      scroll_region_horizontal(:left, row0, col0, row1, col1, count)
+    end
+
+    def scroll_right_region(row0, col0, row1, col1, count)
+      scroll_region_horizontal(:right, row0, col0, row1, col1, count)
+    end
+
+    private
+
+      def scroll_region_vertical(direction, row0, col0, row1, col1, count)  # :nodoc:
+        row0, col0, row1, col1, rect_height, rect_width = rect_helper(row0, col0, row1, col1)
+
+        # Clip the count to the rectangle height
+        count = [0, [rect_height, count].min].max
+
+        # Split the region into source and destination ranges
+        if direction == :up
+          dst_rows = (row0..row1-count)
+          src_rows = (row0+count..row1)
+          intermediate_rows = (dst_rows.end+1..src_rows.begin-1)
+        elsif direction == :down
+          src_rows = (row0..row1-count)
+          dst_rows = (row0+count..row1)
+          intermediate_rows = (src_rows.end+1..dst_rows.begin-1)
+        else
+          raise ArgumentError.new("Invalid direction #{direction.inspect}")
+        end
+
+        # Erase any rows that lie between the source and destination rows.
+        # If there are no such rows (e.g. if the source and destination rows
+        # overlap) this will do nothing.
+        intermediate_rows.each do |row|
+          replace_at(row, col0, " "*rect_width)
+        end
+
+        # Move the region that is <count> rows below the top of the rectangle to
+        # the top of the rectangle.  If we're scrolling the entire region off the
+        # screen, this will do nothing.
+        z = src_rows.zip(dst_rows)
+        z.reverse! if direction == :down
+        z.each do |src_row, dst_row|
+          replace_at dst_row, col0, replace_at(src_row, col0, " "*rect_width)
+        end
+        nil
+      end
+
+      def scroll_region_horizontal(direction, row0, col0, row1, col1, count)  # :nodoc:
+        row0, col0, row1, col1, rect_height, rect_width = rect_helper(row0, col0, row1, col1)
+
+        # Clip the count to the rectangle height
+        count = [0, [rect_width, count].min].max
+
+        # Split the region into source and destination ranges
+        if direction == :left
+          dst_cols = (col0..col1-count)
+          src_cols = (col0+count..col1)
+          intermediate_cols = (dst_cols.end+1..src_cols.begin-1)
+        elsif direction == :right
+          src_cols = (col0..col1-count)
+          dst_cols = (col0+count..col1)
+          intermediate_cols = (src_cols.end+1..dst_cols.begin-1)
+        else
+          raise ArgumentError.new("Invalid direction #{direction.inspect}")
+        end
+
+        # Erase any columns that lie between the source and destination columns.
+        # If there are no such columns (e.g. if the source and destination columns
+        # overlap) this will do nothing.
+        intermediate_width = intermediate_cols.end - intermediate_cols.begin + 1
+        if intermediate_width > 0
+          (row0..row1).each do |row|
+            replace_at(row, intermediate_cols.begin, " "*intermediate_width)
+          end
+        end
+
+        # Move the region that is <count> rows below the top of the rectangle to
+        # the top of the rectangle.  If we're scrolling the entire region off the
+        # screen, this will do nothing.
+        move_width = src_cols.end - src_cols.begin + 1
+        if move_width > 0
+          (row0..row1).each do |row|
+            replace_at row, dst_cols.begin, replace_at(row, src_cols.begin, " "*move_width)
+          end
+        end
+        nil
+      end
+
+      def rect_helper(row0, col0, row1, col1) # :nodoc:
+        # Sort coordinates
+        row0, row1 = row1, row0 if row0 > row1
+        col0, col1 = col1, col0 if col0 > col1
+
+        # Clip the rectangle to the screen size
+        row0 = [0, [@height-1, row0].min].max
+        col0 = [0, [@width-1, col0].min].max
+        row1 = [0, [@height-1, row1].min].max
+        col1 = [0, [@width-1, col1].min].max
+
+        # Determine the height and width of the rectangle
+        rect_height = row1 - row0 + 1
+        rect_width = col1 - col0 + 1
+
+        [row0, col0, row1, col1, rect_height, rect_width]
+      end
+  end
+end