scriptty 0.5.0-java

data/lib/scriptty/apps/replay_app.rb

@@ -0,0 +1,229 @@
+# = Fake server that replays transcripts to a client
+# 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 'optparse'
+require 'scriptty/net/event_loop'
+require 'scriptty/util/transcript/reader'
+require 'scriptty/term'
+require 'logger'
+require 'stringio'
+
+module ScripTTY
+  module Apps
+    class ReplayApp
+      attr_reader :term
+
+      def initialize(argv)
+        @client_connection = nil
+        @server_connection = nil
+        @output_file = nil
+        @options = parse_options(argv)
+        @console_password = ""   # TODO SECURITY FIXME
+        @attached_consoles = []
+        @log_stringio = StringIO.new
+        @log = Logger.new(@log_stringio)
+        @net = ScripTTY::Net::EventLoop.new
+        @input_transcript = []
+        @last_command = nil
+      end
+
+      def detach_console(console)
+        @attached_consoles.delete(console)
+      end
+
+      def log_messages
+        ([""]*10 + @log_stringio.string.split("\n"))[-10..-1].map{|line| line.sub(/^.*?\]/, '')}
+      end
+
+      def main
+        @output_file = Util::Transcript::Writer.new(File.open(@options[:output], "w")) if @options[:output]
+        @net.on_accept(@options[:console_addrs] || [], :multiple => true) do |conn|
+          p = CaptureApp::PasswordPrompt.new(conn, "Console password: ")
+          p.authenticate { |password| password == @console_password }
+          p.on_fail { conn.write("Authentiation failed.\r\n") { conn.close } }
+          p.on_success {
+            @attached_consoles << CaptureApp::Console.new(conn, self)
+            @attached_consoles.each { |c| c.refresh! }
+          }
+        end
+        @net.on_accept(@options[:listen_addrs], :multiple => true) do |conn|
+          @output_file.client_open(*conn.remote_address) if @output_file
+          @client_connection = conn
+          @client_connection.on_receive_bytes { |bytes| handle_client_receive_bytes(bytes) }
+          @client_connection.on_close { handle_client_close ; @client_connection = nil }
+          handle_client_connected
+        end
+        @net.main
+      ensure
+        if @output_file
+          @output_file.close
+          @output_file = nil
+        end
+      end
+
+      def handle_console_command_entered(cmd)
+        case cmd
+        when /^$/   # repeat last command
+          if @last_command
+            handle_console_command_entered(@last_command)
+          else
+            log.warn("No previous command entered")
+          end
+          return nil
+        when /^(\d*)(n|next)$/i    # replay next step
+          count = $1 ? $1.to_i : 1
+          count.times { replay_next }
+        else
+          log.warn("Unknown console command: #{cmd}")
+        end
+        @last_command = cmd
+      end
+
+      # Instruct the event loop to exit.
+      #
+      # Can be invoked by another thread.
+      def exit
+        @net.exit
+      end
+
+      private
+
+        attr_reader :log
+
+        def handle_client_connected
+          @term = ScripTTY::Term.new(@options[:term])
+          @term.on_unknown_sequence do |sequence|
+            log.debug("Unknown escape sequence: #{sequence.inspect}")
+          end
+          replay_start
+          replay_next
+          refresh_consoles
+        end
+
+        def handle_client_receive_bytes(bytes)
+          log.info("Received from client: #{bytes.inspect}")
+          refresh_consoles
+        end
+
+        def handle_client_close
+          log.info("Client connection closed")
+          refresh_consoles
+        end
+
+        def replay_start
+          @next_bytes_to_send = nil
+          @transcript = []
+          @options[:input_files].each do |filename|
+            @transcript << ["--- File: #{filename} ---", nil]
+            reader = Util::Transcript::Reader.new
+            File.open(filename, "r") do |infile|
+              line_num = 0
+              until infile.eof?
+                line_num += 1
+                line = infile.readline
+                timestamp, type, args = reader.parse_line(line)
+                if type == :from_server
+                  @transcript << ["(#{line_num}) #{line.strip}", args[0]]
+                elsif type == :server_parsed
+                  @transcript << ["(#{line_num}) #{line.strip}", args[1]]
+                else
+                  @transcript << ["(#{line_num}) #{line.strip}", nil]
+                end
+              end
+            end
+          end
+        end
+
+        def replay_next
+          if @next_bytes_to_send
+            @client_connection.write(@next_bytes_to_send) { refresh_consoles }
+            @term.feed_bytes(@next_bytes_to_send)
+            @next_bytes_to_send = nil
+          end
+          until @transcript.empty?
+            display, bytes = @transcript.shift
+            if bytes
+              log.debug("NXTD: #{display}")   # next data
+              @next_bytes_to_send = bytes
+              break
+            else
+              log.debug("INFO: #{display}")
+            end
+          end
+          if @transcript.empty?
+            log.debug("DONE")
+          end
+        end
+
+        def refresh_consoles
+          @attached_consoles.each { |c| c.refresh! }
+        end
+
+        def parse_options(argv)
+          args = argv.dup
+          options = {:listen_addrs => [], :console_addrs => []}
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: #{opts.program_name} [options] FILE"
+            opts.separator "Stream capture application"
+            opts.on("-l", "--listen [HOST]:PORT", "Listen on the specified HOST:PORT") do |optarg|
+              addr = parse_hostport(optarg, :allow_empty_host => true, :allow_zero_port => true)
+              options[:listen_addrs] << addr
+            end
+            opts.on("-C", "--console [HOST]:PORT", "Debug console on the specified HOST:PORT") do |optarg|
+              addr = parse_hostport(optarg, :allow_empty_host => true, :allow_zero_port => true)
+              options[:console_addrs] << addr
+            end
+            opts.on("-t", "--term NAME", "Terminal to emulate") do |optarg|
+              raise ArgumentError.new("Unsupported terminal #{optarg.inspect}") unless ScripTTY::Term::TERMINAL_TYPES.include?(optarg)
+              options[:term] = optarg
+            end
+          end
+          opts.parse!(args)
+          if args.length < 1
+            $stderr.puts "error: No input file(s) specified."
+            exit 1
+          end
+          unless !options[:listen_addrs].empty? and !options[:console_addrs].empty? and options[:term]
+            $stderr.puts "error: --listen, --console, and --term are mandatory"
+            exit 1
+          end
+          options[:input_files] = args
+          options
+        end
+
+        # Parse [HOST:]PORT into separate host and port.  Host is optional, and
+        # might be surrounded by square brackets.
+        def parse_hostport(s, opts={})
+          unless s =~ /\A(\[[^\[\]]*\]|[^\[\]]*):(\d+)\Z/
+            raise ArgumentError.new("Unable to parse host:port")
+          end
+          host, port = [$1, $2]
+          host.gsub!(/\A\[(.*?)\]\Z/, '\1')
+          port = port.to_i
+          raise ArgumentError.new("Invalid port") if port < 0 or port > 0xffff or (port == 0 and !opts[:allow_zero_port])
+          unless opts[:allow_empty_host]
+            raise ArgumentError.new("Host cannot be empty") if host.empty?
+          end
+          [host, port]
+        end
+    end
+  end
+end
+
+require 'scriptty/apps/capture_app/password_prompt'
+require 'scriptty/apps/capture_app/console'

data/lib/scriptty/apps/term_test_app.rb

@@ -0,0 +1,124 @@
+# = Terminal emulation testing app
+# 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 'optparse'
+require 'scriptty/term'
+require 'scriptty/util/transcript/reader'
+
+module ScripTTY
+  module Apps
+    class TermTestApp
+      def initialize(argv)
+        @options = parse_options(argv)
+      end
+
+      def log(message)
+        @log_buffer << message
+        @log_file.puts(message) if @log_file
+      end
+
+      def main
+        @log_buffer = []
+        @log_file = @options[:log] && File.open(@options[:log], "w")
+        @term = ScripTTY::Term.new(@options[:term])
+        @term.on_unknown_sequence do |seq|
+          log "Unknown escape sequence: #{seq.inspect}"
+        end
+        $stdout.print "\ec" # Reset terminal; clear the screen
+        $stdout.flush
+        time_multiplier = @options[:rate] > 0 ? 1.0/@options[:rate] : 0
+        @options[:input_files].each do |inp|
+          File.open(inp[:path], "rb") do |input_file|
+            time0 = Time.now
+            timestamp0 = timestamp = nil
+            reader = Util::Transcript::Reader.new
+            until input_file.eof?
+              # Read a chunk of the input file
+              case inp[:format]
+              when :binary
+                c = input_file.read(1)
+                @term.feed_byte(c)
+              when :capture
+                timestamp, type, args = reader.parse_line(input_file.readline)
+                next unless type == :from_server
+                bytes = args[0]
+
+                # Wait until the time specified in the timestamp passes
+                timestamp0 = timestamp unless timestamp0   # treat the first timestamp as time 0
+                sleep_time = (timestamp-timestamp0)*time_multiplier - (Time.now - time0)
+                sleep(sleep_time) if sleep_time > 0
+
+                @term.feed_bytes(bytes)
+              else
+                raise "BUG: Invalid format: #{inp[:format]}"
+              end
+
+              # Output the screen contents
+              screen_lines = []
+              screen_lines << "Timestamp: #{timestamp}" if timestamp
+              screen_lines << "Cursor position: #{@term.cursor_pos.inspect}"
+              screen_lines += @term.debug_info if @term.respond_to?(:debug_info)
+              screen_lines << "+" + "-"*@term.width + "+"
+              @term.text.each do |line|
+                screen_lines << "|#{line}|"
+              end
+              screen_lines << "+" + "-"*@term.width + "+"
+              screen_lines << "--- Log ---"
+              ([0,@log_buffer.length-10].max..@log_buffer.length-1).each do |i|
+                screen_lines << sprintf("%3d: %s", i+1, @log_buffer[i])
+              end
+              screen_lines << "--- End of log ---"
+              screen_lines << ""
+              $stdout.puts "\e[H" + screen_lines.map{|line| "\e[2K" + line}.join("\n")
+              $stdout.flush
+            end
+          end
+        end
+        @log_file.close if @log_file
+      end
+
+      private
+        def parse_options(argv)
+          args = argv.dup
+          options = {:term => 'xterm', :input_files => [], :rate => 2}
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: #{opts.program_name} [options]"
+            opts.separator "Debug a specified terminal emulator"
+            opts.on("-t", "--term NAME", "Terminal to emulate") do |optarg|
+              raise ArgumentError.new("Unsupported terminal #{optarg.inspect}") unless ScripTTY::Term::TERMINAL_TYPES.include?(optarg)
+              options[:term] = optarg
+            end
+            opts.on("-b", "--binary-input FILE", "Binary file to read") do |optarg|
+              options[:input_files] << {:path => optarg, :format => :binary}
+            end
+            opts.on("-c", "--capture-input FILE", "Capture-format file to read") do |optarg|
+              options[:input_files] << {:path => optarg, :format => :capture}
+            end
+            opts.on("-r", "--rate RATE", "Playback at the specified rate (0 for infinite; default: #{options[:rate]})") do |optarg|
+              options[:rate] = optarg.to_f
+            end
+            opts.on("-L", "--log FILE", "Write log to FILE") do |optarg|
+              options[:log] = optarg
+            end
+          end
+          opts.parse!(args)
+          options
+        end
+    end
+  end
+end

data/lib/scriptty/apps/transcript_parse_app.rb

@@ -0,0 +1,143 @@
+# = Transcript parsing app
+# 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 'optparse'
+require 'scriptty/term'
+require 'scriptty/util/transcript/reader'
+require 'scriptty/util/transcript/writer'
+
+module ScripTTY
+  module Apps
+    class TranscriptParseApp
+      def initialize(argv)
+        @options = parse_options(argv)
+      end
+
+      def main
+        File.open(@options[:output], "w") do |output_file|
+          @writer = ScripTTY::Util::Transcript::Writer.new(output_file)
+          @options[:input_files].each do |input_filename|
+            File.open(input_filename, "rb") do |input_file|
+              reader = ScripTTY::Util::Transcript::Reader.new
+              @last_printable = nil
+              parser_class = ScripTTY::Term.class_by_name(@options[:term]).parser_class
+
+              # Set up server-side FSM
+              @server_parser = parser_class.new :callback => Proc.new { |event_name, fsm|
+                if event_name == :t_printable
+                  # Merge printable character sequences together, rather than writing individual "t_printable" events.
+                  @last_server_printable ||= ""
+                  @last_server_printable += fsm.input_sequence.join
+                else
+                  flush_server_printable
+                  @writer.server_parsed(event_name, fsm.input_sequence.join)
+                end
+              }
+              @server_parser.on_unknown_sequence { |seq| @writer.server_parsed("?", seq) }
+
+              # Set up client-side FSM
+              if @options[:client]
+                @client_parser = parser_class.new :client => true, :callback => Proc.new { |event_name, fsm|
+                  if event_name == :t_printable
+                    # Merge printable character sequences together, rather than writing individual "t_printable" events.
+                    @last_client_printable ||= ""
+                    @last_client_printable += fsm.input_sequence.join
+                  else
+                    flush_client_printable
+                    @writer.client_parsed(event_name, fsm.input_sequence.join)
+                  end
+                }
+                @client_parser.on_unknown_sequence { |seq| @writer.client_parsed("?", seq) }
+              end
+
+              until input_file.eof?
+                timestamp, type, args = reader.parse_line(input_file.readline)
+                @writer.override_timestamp = timestamp
+                if type == :from_server
+                  @writer.send(type, *args) if @options[:keep]
+                  bytes = args[0]
+                  @server_parser.feed_bytes(bytes)
+                elsif type == :from_client and @client_parser
+                  @writer.send(type, *args) if @options[:keep]
+                  bytes = args[0]
+                  @client_parser.feed_bytes(bytes)
+                else
+                  @writer.send(type, *args)
+                end
+              end
+              flush_server_printable
+              flush_client_printable if @client_parser
+            end
+          end
+          @writer.close
+        end
+      end
+
+      private
+
+        def flush_server_printable
+          if @last_server_printable
+            @writer.server_parsed(".", @last_server_printable)
+            @last_server_printable = nil
+          end
+        end
+
+        def flush_client_printable
+          if @last_client_printable
+            @writer.client_parsed(".", @last_client_printable)
+            @last_client_printable = nil
+          end
+        end
+
+        def parse_options(argv)
+          args = argv.dup
+          options = {:input_files => []}
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: #{opts.program_name} [options] FILE..."
+            opts.separator "Parse transcript escape sequences according to a specified terminal emulation,"
+            opts.separator 'converting raw "S" transcript entries into parsed "Sp" entries.'
+
+            opts.on("-t", "--term NAME", "Terminal to emulate") do |optarg|
+              raise ArgumentError.new("Unsupported terminal #{optarg.inspect}") unless ScripTTY::Term::TERMINAL_TYPES.include?(optarg)
+              options[:term] = optarg
+            end
+            opts.on("-k", "--keep", 'Keep original "S" lines in the transcript') do |optarg|
+              options[:keep] = optarg
+            end
+            opts.on("-c", "--[no-]client", "Also parse client (\"C\") entries") do |optarg|
+              options[:client] = optarg
+            end
+            opts.on("-o", "--output FILE", "Write output to FILE") do |optarg|
+              options[:output] = optarg
+            end
+          end
+          opts.parse!(args)
+          if args.length < 1
+            $stderr.puts "error: No input file(s) specified."
+            exit 1
+          end
+          unless options[:output] and options[:term]
+            $stderr.puts "error: --output and --term are mandatory"
+            exit 1
+          end
+          options[:input_files] = args
+          options
+        end
+    end
+  end
+end

data/lib/scriptty/cursor.rb

@@ -0,0 +1,39 @@
+# = Cursor 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/>.
+
+module ScripTTY
+  class Cursor
+    attr_accessor :row, :column
+    def initialize
+      @row = 0
+      @column = 0
+    end
+
+    def pos
+      [@row, @column]
+    end
+
+    def pos=(value)
+      raise TypeError.new("must be 2-element array") unless value.is_a?(Array) and value.length == 2
+      @row, @column = value
+      @row ||= 0
+      @column ||= 0
+      value
+    end
+  end
+end

data/lib/scriptty/exception.rb

@@ -0,0 +1,38 @@
+# = ScripTTY exceptions
+# 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
+  module Exception
+    # Exception base class
+    class Base < StandardError
+    end
+
+    # Raised when a script times out.
+    class Timeout < Base
+    end
+
+    # Raised when a connection error occurs
+    class ConnectError < Base
+      attr_accessor :orig_exception
+      def initialize(exception)
+        @orig_exception = exception
+        super("Connect error (#{exception.class.name}): #{exception}")
+      end
+    end
+  end
+end