oterm 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c57083633eb77e165e8331ee3b28ce62a2a25c41
+  data.tar.gz: db9c45d79b15fa85e8c5a82c413e29108e7e1d41
+SHA512:
+  metadata.gz: 59fb9a821cde9ba1c4974ecf18fa32cef38a1db7d3c187b8a274273c4459d225be3f308d4132cb4f4f126751d1a75eb786869542ffedb88f830ed63f2855d6df
+  data.tar.gz: 5702073e0ce8e0afe661019d0da7f8c42a845cbd2d9c09297332290996217b954ad7b063b944d4d1d13575225c0c55fef8ab941d9db8a1720e4c8369d224ac5c

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Peter Ohler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+oterm
+=====
+
+Operations Terminal
+
+# OTerm gem
+
+A VT100 terminal (mostly) server that can be placed in an application to allow
+telnet access to exposed features. Some of the features includes are:
+
+ - Line editing
+
+ - VT100 support with graphics and color
+
+ - Configurable help and command registration
+
+ - Auto completion
+
+ - History
+
+The driver for writing this gem was to be able to control, inspect, and debug
+multi-threaded applications while the application is running. Look for it's use
+soon in the ODisk application and later in a more interesting project.
+
+## <a name="installation">Installation</a>
+    gem install oterm
+
+## <a name="documentation">Documentation</a>
+
+*Documentation*: http://www.ohler.com/oterm
+
+## <a name="source">Source</a>
+
+*GitHub* *repo*: https://github.com/ohler55/oterm
+
+*RubyGems* *repo*: https://rubygems.org/gems/oterm
+
+Follow [@peterohler on Twitter](http://twitter.com/#!/peterohler) for announcements and news about the Oj gem.
+
+## <a name="build_status">Build Status</a>
+
+[![Build Status](https://secure.travis-ci.org/ohler55/oterm.png?branch=master)](http://travis-ci.org/ohler55/oterm)
+
+### Current Release 1.0.0 - December 22, 2013
+
+ - First release. There will be rough edges.
+
+## <a name="description">Description</a>
+
+## Examples
+
+TBD for now, look for a sample in the test directory.

data/lib/oterm.rb

@@ -0,0 +1,13 @@
+
+module OTerm
+end # OTerm
+
+require 'oterm/version'
+require 'oterm/errors'
+require 'oterm/telnet'
+require 'oterm/vt100'
+require 'oterm/output'
+require 'oterm/listener'
+require 'oterm/executor'
+require 'oterm/server'
+require 'oterm/mock100'

data/lib/oterm/errors.rb

@@ -0,0 +1,10 @@
+
+module OTerm
+  # 
+  class CommandError < Exception
+    def initialize(cmd)
+      super("#{cmd} is not a valid command")
+    end
+  end # CommandError
+
+end # OTerm

data/lib/oterm/executor.rb

@@ -0,0 +1,117 @@
+
+module OTerm
+
+  class Executor
+
+    def initialize()
+      @cmds = {}
+      register('help', self, :help, '[<command>] this help screen or help on a command',
+               %|Show help on a specific command or a list of all commands if a specific command is not specified.|)
+      register('shutdown', self, :shutdown, 'shuts down the application',
+               %|Shuts down the application.|)
+      register('close', self, :close, 'closes the connection',
+               %|Closes the connection to the application.|)
+    end
+
+    def greeting()
+      nil
+    end
+
+    def execute(cmd, listener)
+      name, args = cmd.split(' ', 2)
+      c = @cmds[name]
+      if nil == c
+        missing(cmd, listener)
+        return
+      end
+      c.target.send(c.op, listener, args)
+    end
+
+    def help(listener, arg=nil)
+      listener.out.pl()
+      if nil != arg
+        c = @cmds[arg]
+        if nil != c
+          listener.out.pl("#{arg} - #{c.summary}")
+          c.desc.each do |line|
+            listener.out.pl("  #{line}")
+          end
+          return
+        end
+      end
+      max = 1
+      @cmds.each do |name,cmd|
+        max = name.size if max < name.size
+      end
+      @cmds.each do |name,cmd|
+        listener.out.pl("  %1$*2$s - %3$s" % [name, -max, cmd.summary])
+      end
+    end
+
+    def close(listener, args)
+      listener.out.pl("Closing connection")
+      listener.close()
+    end
+
+    def shutdown(listener, args)
+      listener.out.pl("Shutting down")
+      listener.server.shutdown()
+    end
+
+    # This evaluates cmd as a Ruby expression. This is great for debugging but
+    # not a wise move for a public interface. To hide this just create a methid
+    # with the same name in the subclass of this one.
+    def missing(cmd, listener)
+      begin
+        result = "#{eval(cmd)}".split("\n")
+      rescue Exception => e
+        result = ["#{e.class}: #{e.message}"]
+        e.backtrace.each do |line|
+          break if line.include?('oterm/executor.rb')
+          result << "\t" + line
+        end
+      end
+      result.each do |line|
+        listener.out.pl(line)
+      end
+    end
+
+    def tab(cmd, listener)
+      comp = []
+      @cmds.each_key do |name|
+        comp << name if name.start_with?(cmd)
+      end
+      if 1 == comp.size
+        listener.move_col(1000)
+        listener.insert(comp[0][listener.buf.size..-1])
+        listener.out.prompt()
+        listener.out.p(listener.buf)
+      else
+        listener.out.pl()
+        comp.each do |name|
+          listener.out.pl(name)
+        end
+        listener.update_cmd(0)
+      end
+    end
+
+    def register(cmd, target, op, summary, desc)
+      @cmds[cmd] = Cmd.new(target, op, summary, desc)
+    end
+
+    class Cmd
+      attr_accessor :target
+      attr_accessor :op
+      attr_accessor :summary
+      attr_accessor :desc
+
+      def initialize(target, op, summary, desc)
+        @target = target
+        @op = op
+        @summary = summary
+        @desc = desc.split("\n")
+      end
+    end # Cmd
+
+  end # Executor
+end # OTerm

data/lib/oterm/listener.rb

@@ -0,0 +1,257 @@
+
+module OTerm
+
+  class Listener
+
+    attr_accessor :server
+    attr_accessor :con
+    attr_accessor :executor
+    attr_accessor :buf
+    attr_accessor :history
+    attr_accessor :hp # history pointer
+    attr_accessor :out
+    attr_accessor :debug
+
+    def initialize(server, con, executor)
+      @debug = server.debug()
+      @server = server
+      @con = con
+      @executor = executor
+      @buf = ''
+      @kill_buf = nil
+      @history = []
+      @hp = 0
+      @out = Output.new(con)
+      @col = 0
+      @echo = false
+      @done = false
+
+      greeting = executor.greeting()
+      @out.pl(greeting) if nil != greeting
+
+      # initiate negotiations for single character mode and no echo
+      @out.p(Telnet.msg(Telnet::DO, Telnet::SGA) + Telnet.msg(Telnet::DO, Telnet::ECHO))
+
+      out.prompt()
+      while !@done
+        line = con.recv(100)
+        begin
+          len = line.size()
+          break if 0 == len
+          if @debug
+            line.each_byte { |x| print("#{x} ") }
+            plain = line.gsub(/./) { |c| c.ord < 32 || 127 <= c.ord  ? '*' : c }
+            puts "[#{line.size()}] #{plain}"
+          end
+          # determine input type (telnet command, char mode, line mode)
+          o0 = line[0].ord()
+          case o0
+          when 255 # telnet command
+            process_telnet_cmd(line)
+          when 27 # escape, vt100 sequence
+            vt100_cmd(line)
+          when 13 # new line
+            exec_cmd(@buf)
+          when 0..12, 14..26, 28..31, 127 # other control character
+            process_ctrl_cmd(o0)
+          else
+            if 1 == len || (2 == len && "\000" == line[1]) # single char mode
+              @hp = 0
+              insert(line[0])
+            else # line mode
+              exec_cmd(line)
+            end
+          end
+        rescue Exception => e
+          puts "#{e.class}: #{e.message}"
+          e.backtrace.each { |bline| puts '  ' + bline }
+        end
+      end
+    end
+
+    def close()
+      @done = true
+    end
+
+    def process_telnet_cmd(line)
+      reply = ''
+      Telnet.parse(line).each do |v,f|
+        case f
+        when Telnet::ECHO
+          case v
+          when Telnet::WILL
+            @echo = false
+            reply += Telnet.msg(Telnet::WONT, f)
+          when Telnet::WONT
+            @echo = true
+            reply += Telnet.msg(Telnet::WILL, f)
+          end
+        when Telnet::SGA
+          case v
+          when Telnet::WILL
+            reply += Telnet.msg(Telnet::WILL, f)
+          when Telnet::WONT
+            reply += Telnet.msg(Telnet::WONT, f)
+          end
+        end
+      end
+      if 0 < reply.size
+        @con.print(reply)
+      else
+        # Done negotiating with telnet. Initiate negotiation for vt100 ANSI support.
+        @out.identify()
+      end
+    end
+
+    def vt100_cmd(line)
+      puts "*** vt100 command"
+      # TBD
+    end
+
+    def exec_cmd(cmd)
+      @hp = 0
+      cmd.strip!()
+      if 0 == cmd.size()
+        @out.pl()
+        @out.prompt()
+        @col = 0
+        return
+      end
+      @buf = ""
+      @out.pl()
+      @history << cmd if 0 < cmd.size() && (0 == @history.size() || @history[-1] != cmd)
+      executor.execute(cmd, self)
+      @out.prompt()
+      @col = 0
+    end
+
+    def process_ctrl_cmd(o)
+      case o
+      when 1 # ^a
+        move_col(-@col)
+      when 2 # ^b
+        move_col(-1)
+      when 4 # ^d
+        @hp = 0
+        if @col < @buf.size 
+          @col += 1
+          delete_char()
+        end
+      when 5 # ^e
+        move_col(@buf.size() - @col)
+      when 6 # ^f
+        move_col(1)
+      when 8, 127 # backspace or delete
+        @hp = 0
+        delete_char()
+      when 9 # tab
+        @hp = 0
+        @executor.tab(@buf, self)
+      when 11 # ^k
+        @hp = 0
+        if @col < @buf.size()
+          @kill_buf = @buf[@col..-1]
+          blen = @buf.size()
+          @buf = @buf[0...@col]
+          update_cmd(blen)
+        end
+      when 14 # ^n
+        if 0 < @hp && @hp <= @history.size()
+          @hp -= 1
+          blen = @buf.size()
+          if 0 == @hp
+            @buf = ''
+          else
+            @buf = @history[-@hp]
+          end
+          update_cmd(blen)
+        end
+      when 16 # ^p
+        if @hp < @history.size()
+          @hp += 1
+          blen = @buf.size()
+          @buf = @history[-@hp]
+          update_cmd(blen)
+        end
+      when 21 # ^u
+        @hp -= 1
+        @buf = ''
+      when 25 # ^y
+        insert(@kill_buf)
+      end
+    end
+
+    def update_cmd(blen)
+      @out.cr()
+      @out.prompt()
+      @out.p(@buf)
+      # erase to end of line and come back
+      if @buf.size() < blen
+        dif = blen - @buf.size()
+        @out.p(' ' * dif + "\b" * dif)
+      end
+      @col = @buf.size
+    end
+
+    def move_col(dif)
+      if 0 > dif
+        while 0 > dif && 0 < @col
+          @col -= 1
+          @out.p("\b")
+          dif += 1
+        end
+      else
+        max = @buf.size
+        while 0 < dif && @col < max
+          @out.p(@buf[@col])
+          @col += 1
+          dif -= 1
+        end
+      end
+    end
+
+    def insert(str)
+      # TBD be smarter with vt100
+      if 0 == @col
+        @buf = str + @buf
+        @out.p("\r")
+        @out.prompt()
+        @out.p(@buf)
+        @out.p("\r")
+        @out.prompt()
+        @out.p(@buf[0...str.size])
+      elsif @buf.size <= @col
+        @buf << str
+        @out.pc(str)
+        @col = @buf.size
+      else
+        @buf = @buf[0...@col] + str + @buf[@col..-1]
+        @out.p("\r")
+        @out.prompt()
+        @out.p(@buf)
+        @out.p("\r")
+        @out.prompt()
+        @out.p(@buf[0...@col + str.size])
+      end
+      @col += str.size
+    end
+
+    def delete_char()
+      return if 0 == @col || 0 == @buf.size
+      if @buf.size <= @col
+        @buf.chop!()
+        @out.p("\x08 \x08")
+      else
+        @buf = @buf[0...@col - 1] + @buf[@col..-1]
+        @out.p("\r")
+        @out.prompt()
+        @out.p(@buf)
+        @out.p(" \r")
+        @out.prompt()
+        @out.p(@buf[0...@col - 1])
+      end
+      @col -= 1
+    end
+
+  end # Listener
+end # OTerm

data/lib/oterm/mock100.rb

@@ -0,0 +1,11 @@
+
+module OTerm
+
+  class Mock100
+
+    def initialize()
+
+    end
+
+  end # Mock100
+end # OTerm

data/lib/oterm/output.rb

@@ -0,0 +1,31 @@
+
+module OTerm
+
+  class Output < VT100
+    def initialize(con)
+      super(con)
+    end
+
+    def prompt()
+      @con.print("\r> ")
+    end
+
+    def p(str)
+      @con.print(str)
+    end
+
+    def pc(c)
+      @con.putc(c)
+    end
+
+    def pl(line='')
+      @con.puts(line + "\r")
+    end
+
+    def cr()
+      @con.print("\r")
+    end
+
+  end # Output
+end # OTerm
+

data/lib/oterm/server.rb

@@ -0,0 +1,36 @@
+
+require 'socket'
+
+module OTerm
+
+  class Server
+
+    attr_accessor :acceptThread
+    attr_accessor :stop
+    attr_accessor :listeners
+    attr_accessor :debug
+
+    def initialize(executor, port=6060, debug=false)
+      @debug = debug
+      @stop = false
+      @listeners = []
+      @acceptThread = Thread.start() do
+        server = TCPServer.new(port)
+        while !stop do
+          Thread.start(server.accept()) do |con|
+            @listeners << Listener.new(self, con, executor)
+          end
+        end
+      end
+    end
+
+    def shutdown()
+      @acceptThread.exit()
+    end
+
+    def remove_listener(listener)
+      @listeners.delete(listener)
+    end
+
+  end # Server
+end # OTerm

data/lib/oterm/telnet.rb

@@ -0,0 +1,37 @@
+
+module OTerm
+
+  class Telnet
+    IAC = 255.chr
+
+    # verbs
+    WILL = 251.chr
+    WONT = 252.chr
+    DO   = 253.chr
+    DONT = 254.chr
+
+    # features
+    BIN  = 0.chr
+    ECHO = 1.chr
+    SGA  = 3.chr # one character at a time
+
+    def self.msg(verb, feature)
+      [IAC, verb, feature].join('')
+    end
+
+    def self.parse(line)
+      msgs = []
+      v = nil
+      line.each_char do |c|
+        if nil == v
+          v = c unless IAC == c
+        else
+          msgs << [v, c]
+          v = nil
+        end
+      end
+      msgs
+    end
+
+  end # Telnet
+end # OTerm

data/lib/oterm/version.rb

@@ -0,0 +1,4 @@
+module OTerm
+  # Current version of the module. 
+  VERSION = '1.0.0'
+end

data/lib/oterm/vt100.rb

@@ -0,0 +1,282 @@
+
+module OTerm
+
+  class VT100
+    ESC = 27.chr
+    MAX_DIM = 10000
+
+    # graphic font characters
+    BLANK = '_'
+    DIAMOND = '`'
+    CHECKER = 'a'
+    HT = 'b'
+    FF = 'c'
+    CR = 'd'
+    LF = 'e'
+    DEGREE = 'f'
+    PLUS_MINUS = 'g'
+    NL = 'h'
+    VT = 'i'
+    LOW_RIGHT = 'j'
+    UP_RIGHT = 'k'
+    UP_LEFT = 'l'
+    LOW_LEFT = 'm'
+    CROSS = 'n'
+    DASH1 = 'o'
+    DASH3 = 'p'
+    DASH5 = 'q'
+    DASH7 = 'r'
+    DASH9 = 's'
+    LEFT_T = 't'
+    RIGHT_T = 'u'
+    LOW_T = 'v'
+    UP_T = 'w'
+    BAR = 'x'
+    LTE = 'y'
+    GTE = 'z'
+    PI = '{'
+    NE = '|'
+    DOT = '~'
+
+    # colors
+    BLACK = 30
+    RED = 31
+    GREEN = 32
+    YELLOW = 33
+    BLUE = 34
+    MAGENTA = 35
+    CYAN = 36
+    WHITE = 37
+
+    attr_accessor :con
+
+    def initialize(con)
+      @con = con
+      @is_vt100 = false
+    end
+
+    def is_vt100?()
+      return @is_vt100
+    end
+
+    def identify()
+      @con.print("\x1b[c")
+      # expect: ^[[?1;<n>0c
+      rx = /^\x1b\[\?1;.+c/
+      m = recv_wait(10, 1.0, rx)
+      # Don't care about the type, just that the reply is valid for a vt100.
+      @is_vt100 = nil != m
+    end
+
+    def get_cursor()
+      v, h = 0, 0
+      if @is_vt100
+        @con.print("\x1b[6n")
+        # expect: ^[<v>;<h>R
+        rx = /^\x1b\[(\d+);(\d+)R/
+        m = recv_wait(16, 1.0, rx)
+        v, h = m.captures.map { |s| s.to_i }
+      end
+      return v, h
+    end
+
+    # Move cursor to screen location v, h.
+    def set_cursor(v, h)
+      @con.print("\x1b[#{v};#{h}H") if @is_vt100
+    end
+
+    # Save cursor position and attributes.
+    def save_cursor()
+      @con.print("\x1b7") if @is_vt100
+    end
+
+    # Restore cursor position and attributes.
+    def restore_cursor()
+      @con.print("\x1b8") if @is_vt100
+    end
+
+    # Reset terminal to initial state.
+    def reset()
+      @con.print("\x1bc") if @is_vt100
+    end
+
+    def graphic_font()
+      @con.print("\x1b(2") if @is_vt100
+    end
+
+    def default_font()
+      # TBD allow to set to specific character set for original terminal, for now US font
+      @con.print("\x1b(B") if @is_vt100
+    end
+
+    def clear_screen()
+      @con.print("\x1b[2J") if @is_vt100
+    end
+
+    def clear_line()
+      @con.print("\x1b[2K") if @is_vt100
+    end
+
+    def clear_to_end()
+      @con.print("\x1b[0K") if @is_vt100
+    end
+
+    def clear_to_start()
+      @con.print("\x1b[1K") if @is_vt100
+    end
+
+    def relative_origin()
+      @con.print("\x1b[?6h") if @is_vt100
+    end
+
+    def absolute_origin()
+      @con.print("\x1b[?6l") if @is_vt100
+    end
+
+    def attrs_off()
+      @con.print("\x1b[m") if @is_vt100
+    end
+
+    def bold()
+      @con.print("\x1b[1m") if @is_vt100
+    end
+    alias bright bold
+
+    def dim()
+      @con.print("\x1b[2m") if @is_vt100
+    end
+
+    def underline()
+      @con.print("\x1b[4m") if @is_vt100
+    end
+
+    def blink()
+      @con.print("\x1b[5m") if @is_vt100
+    end
+
+    def reverse()
+      @con.print("\x1b[7m") if @is_vt100
+    end
+
+    def big_top()
+      @con.print("\x1b#3") if @is_vt100
+    end
+
+    def big_bottom()
+      @con.print("\x1b#4") if @is_vt100
+    end
+
+    def narrow()
+      @con.print("\x1b#5") if @is_vt100
+    end
+
+    def wide()
+      @con.print("\x1b#6") if @is_vt100
+    end
+
+    def set_colors(fg, bg)
+      return unless @is_vt100
+      if nil == fg
+        if nil != bg
+          bg += 10
+          @con.print("\x1b[#{bg}m")
+        end
+      else
+        if nil != bg
+          bg += 10
+          @con.print("\x1b[#{fg};#{bg}m")
+        else
+          @con.print("\x1b[#{fg}m")
+        end
+      end
+    end
+
+    def up(n)
+      @con.print("\x1b[#{n}A") if @is_vt100
+    end
+
+    def down(n)
+      @con.print("\x1b[#{n}B") if @is_vt100
+    end
+
+    def left(n)
+      @con.print("\x1b[#{n}D") if @is_vt100
+    end
+
+    def right(n)
+      @con.print("\x1b[#{n}C") if @is_vt100
+    end
+
+    def home()
+      @con.print("\x1b[H") if @is_vt100
+    end
+
+    def scroll(n)
+      return unless @is_vt100
+      if 0 > n
+        n = -n
+        n.times { @con.print("\x1b[D") }
+      elsif 0 < n
+        n.times { @con.print("\x1b[M") }
+      end
+    end
+
+    def screen_size()
+      save_cursor()
+      set_cursor(MAX_DIM, MAX_DIM)
+      h, w = get_cursor()
+      restore_cursor()
+      return h, w
+    end
+
+    def frame(y, x, h, w)
+      return if 2 > h || 2 > w
+      graphic_font()
+      set_cursor(y, x)
+      @con.print(UP_LEFT + DASH5 * (w - 2) + UP_RIGHT)
+      (h - 2).times do |i|
+        i += 1
+        set_cursor(y + i, x)
+        @con.print(BAR)
+        set_cursor(y + i, x + w - 1)
+        @con.print(BAR)
+      end
+      set_cursor(y + h - 1, x)
+      @con.print(LOW_LEFT + DASH5 * (w - 2) + LOW_RIGHT)
+      default_font()
+    end
+
+    def recv_wait(max, timeout, pat)
+      giveup = Time.now + timeout
+      reply = ''
+      begin
+        while nil == pat.match(reply)
+          # just peek incase the string is not what we want
+          reply = @con.recv_nonblock(max, Socket::MSG_PEEK)
+
+          # DEBUG
+          # reply.each_byte { |x| print("#{x} ") }
+          # plain = reply.gsub(/./) { |c| c.ord < 32 || 127 <= c.ord  ? '*' : c }
+          # puts "[#{reply.size()}] #{plain}"
+
+        end
+      rescue IO::WaitReadable
+        now = Time.now
+        if now < giveup
+          IO.select([@con], [], [], giveup - now)
+          retry
+        end
+      end
+      m = pat.match(reply)
+      if nil != m
+        # There was a match so read the characters we already peeked.
+        cnt = m.to_s().size
+        if 0 < cnt
+          @con.recv_nonblock(cnt)
+        end
+      end
+      m
+    end
+
+  end # VT100
+end # OTerm

data/test/server_test.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
+# required. That can be set in the RUBYOPT environment variable.
+# export RUBYOPT=-w
+
+$VERBOSE = true
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+
+require 'oterm'
+
+class Ex < OTerm::Executor
+
+  def initialize()
+    super()
+    register('box', self, :box, 'draws a box',
+             %|Draws a box at the location described with the dimensions given.
+> box <inset> <height> <width>|)
+  end
+
+  def greeting()
+    "Hello!"
+  end
+
+  def box(listener, args)
+    o = listener.out
+    # TBD get values for x, h, and w from args
+    x = 20
+    h = 4
+    w = 20
+    cy, _ = o.get_cursor()
+    (h - cy + 1).times { listener.out.pl() } if cy <= h
+    cy, _ = o.get_cursor()
+    o.save_cursor()
+    o.set_colors(OTerm::VT100::RED, nil)
+    o.frame(cy - h, x, h, w)
+    o.restore_cursor()
+  end
+
+  def missing(cmd, listener)
+    listerner.out.pl("'#{cmd}' is not a recognized command.")
+  end
+
+end # Ex
+
+executor = Ex.new()
+
+server = OTerm::Server.new(executor, 6060, true)
+server.acceptThread.join()

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: oterm
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Peter Ohler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-22 00:00:00.000000000 Z
+dependencies: []
+description: 'A remote terminal that can be used for interacting with an application
+  and invoking operations remotely. Telnet and VT100 over a telnet connection are
+  supported. '
+email: peter@ohler.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- lib/oterm/errors.rb
+- lib/oterm/executor.rb
+- lib/oterm/listener.rb
+- lib/oterm/mock100.rb
+- lib/oterm/output.rb
+- lib/oterm/server.rb
+- lib/oterm/telnet.rb
+- lib/oterm/version.rb
+- lib/oterm/vt100.rb
+- lib/oterm.rb
+- test/server_test.rb
+- LICENSE
+- README.md
+homepage: http://www.ohler.com/oterm
+licenses:
+- MIT
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --main
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: oterm
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A operations terminal server.
+test_files: []