trepanning 0.0.9 → 0.1.0

data/interface/comcodes.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Communication status codes
+module Trepanning
+  # Most of these go from debugged process to front-end
+  # client interface. COMMAND goes the other way.
+  module RemoteCommunication
+    PRINT         = '.'
+    COMMAND       = 'C'
+    CONFIRM_TRUE  = 'Y'
+    CONFIRM_FALSE = 'N'
+    CONFIRM_REPLY = '?'
+    QUIT          = 'q'
+    PROMPT        = 'p'
+    RESTART       = 'r'
+  end
+end

data/interface/server.rb

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Our local modules
+require_relative 'base_intf'
+require_relative 'comcodes'
+require_relative '../io/input'
+require_relative '../io/tcpserver'
+
+# Mfifoserver = import_relative('fifoserver', '..io', 'pydbgr')
+
+# Interface for debugging a program but having user control
+# reside outside of the debugged process, possibly on another
+# computer
+class Trepan::ServerInterface < Trepan::Interface
+
+  include Trepanning::RemoteCommunication
+
+  DEFAULT_INIT_CONNECTION_OPTS = {
+    :io => 'TCP'
+  } unless defined?(DEFAULT_INIT_CONNECTION_OPTS)
+
+  def initialize(inout=nil, out=nil, connection_opts={})
+
+    @connection_opts = DEFAULT_INIT_CONNECTION_OPTS.merge(connection_opts)
+
+    at_exit { finalize }
+    @inout = 
+      if inout
+        inout
+      else
+        server_type = @connection_opts[:io]
+        # FIXME: complete this.
+        # if 'FIFO' == server_type
+        #     FIFOServer.new
+        # else
+        Trepan::TCPDbgServer.new(@connection_opts)
+        # end
+      end
+    # For Compatability 
+    @output = @inout
+    @input  = @inout
+    @interactive = true # Or at least so we think initially
+  end
+  
+  # Closes both input and output
+  def close
+    if @inout && @inout.connected?
+      @inout.write(QUIT + 'bye')
+      @inout.close 
+    end
+  end
+  
+  # Called when a dangerous action is about to be done to make sure
+  # it's okay. `prompt' is printed; user response is returned.
+  # FIXME: make common routine for this and user.rb
+  def confirm(prompt, default)
+    while true
+      begin
+        write_confirm(prompt, default)
+        reply = readline(nil).strip.downcase
+      rescue EOFError
+        return default
+      end
+      if YES.member?(reply)
+        return true
+      elsif NO.member?(reply)
+        return false
+      else
+        msg "Please answer 'yes' or 'no'. Try again."
+      end
+    end
+    return default
+  end
+  
+  # Return true if we are connected
+  def connected?
+    :connected == @inout.state
+  end
+    
+  # print exit annotation
+  def finalize(last_wishes=QUIT)
+    @inout.writeline(last_wishes) if connected?
+    close
+  end
+  
+  def input_eof?
+    false
+  end
+
+  # used to write to a debugger that is connected to this
+  # server; `str' written will have a newline added to it
+  def msg(msg)
+    @inout.writeline(PRINT + msg)
+  end
+
+  # used to write to a debugger that is connected to this
+  # server; `str' written will not have a newline added to it
+  def msg_nocr(msg)
+    @inout.write(PRINT +  msg)
+  end
+  
+  def read_command(prompt)
+    readline(prompt)
+  end
+  
+  def read_data
+    @inout.read_dat
+  end
+  
+  def readline(prompt, add_to_history=true)
+    if prompt
+      write_prompt(prompt)
+    end
+    coded_line = @inout.read_msg()
+    @read_ctrl = coded_line[0..0]
+    coded_line[1..-1]
+  end
+  
+  # Return connected
+  def state
+    @inout.state
+  end
+  
+  def write_prompt(prompt)
+    @inout.write(PROMPT + prompt)
+  end
+  
+  def write_confirm(prompt, default)
+    if default
+      code = CONFIRM_TRUE
+    else
+      code = CONFIRM_FALSE
+    end
+    @inout.write(code + prompt)
+  end
+end
+    
+# Demo
+if __FILE__ == $0
+  intf = Trepan::ServerInterface.new(nil, nil, :open => false)
+end

data/io/base_io.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 # classes to support communication to and from the debugger.  This
 # communcation might be to/from another process or another computer.
 # And reading may be from a debugger command script.
@@ -60,8 +60,8 @@ class Trepan
     attr_reader   :output
     def initialize(out, opts={})
       @output = out
-      @eof    = false
       @flush_after_write = false
+      @eof    = false
     end
 
     def close
@@ -86,9 +86,63 @@ class Trepan
     # used to write to a debugger that is connected to this
     # `str' written will have a newline added to it
     #
-    def writeline( msg)
+    def writeline(msg)
       @output.write("%s\n" % msg)
     end
   end
+
+  # This is an abstract class that specifies debugger input output when
+  # handled by the same channel, e.g. a socket or tty.
+  #
+  class InOutBase
+    
+    def initialize(inout, opts={})
+      @opts = DEFAULT_OPTS.merge(opts)
+      @inout = inout
+    end
+    
+    def close
+      @inout.close() if @inout
+    end
+    
+    def eof? 
+      begin
+        @input.eof?
+      rescue IOError
+        true
+      end
+    end
+
+    def flush
+      @inout.flush
+    end
+    
+    # Read a line of input. EOFError will be raised on EOF.  
+    # 
+    # Note that we don't support prompting first. Instead, arrange to
+    # call DebuggerOutput.write() first with the prompt. If `use_raw'
+    # is set raw_input() will be used in that is supported by the
+    # specific input input. If this option is left nil as is normally
+    # expected the value from the class initialization is used.
+    def readline(use_raw=nil)
+      @input.readline
+    end
+
+    # Use this to set where to write to. output can be a 
+    # file object or a string. This code raises IOError on error.
+    # 
+    # Use this to set where to write to. output can be a 
+    # file object or a string. This code raises IOError on error.
+    def write(*args)
+      @inout.write(*args)
+    end
+    
+    # used to write to a debugger that is connected to this
+    # server; `str' written will have a newline added to it
+    def writeline( msg)
+      @inout.write("%s\n" % msg)
+    end
+  end
+
 end
 

data/io/tcpclient.rb

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Debugger Socket Input/Output Interface.
+
+require 'socket'
+require_relative 'base_io'
+require_relative 'tcpfns'
+
+class Trepan 
+  # Debugger Client Input/Output Socket.
+  class TCPDbgClient < Trepan::InOutBase
+
+    include Trepanning::TCPPacking
+
+    DEFAULT_INIT_OPTS = {:open => true}
+
+    CLIENT_SOCKET_OPTS = {
+      :host    => 'localhost', # Symbolic name
+      :port    => 1027,  # Arbitrary non-privileged port
+    }
+
+    def initialize(opts={})
+      @opts      = CLIENT_SOCKET_OPTS.merge(opts)
+      @addr      = nil
+      @buf       = ''
+      @line_edit = false # Our name for GNU readline capability
+      @state     = :disconnected
+      @inout     = nil
+      open(@opts) if @opts[:open]
+    end
+
+    # Closes both input and output
+    def close
+      @state = :closing
+      @inout.close if @inout
+      @state = :disconnnected
+    end
+
+    def open(opts={})
+      @opts = CLIENT_SOCKET_OPTS.merge(opts)
+      @host = @opts[:host]
+      @port = @opts[:port]
+      begin
+        @inout = TCPSocket.new(@host, @port)
+        @state = :connected
+      rescue SystemCallError => e
+        raise IOError, 
+        ('Open client for host %s on port %s gives error: %s' %
+         [@host, @port, e])
+      end
+    end
+    
+    # Read one message unit. It's possible however that
+    # more than one message will be set in a receive, so we will
+    # have to buffer that for the next read.
+    # EOFError will be raised on EOF.
+    def read_msg
+      if @state == :connected
+        if !@buf || @buf.empty?
+          @buf = @inout.recv(TCP_MAX_PACKET)
+          if @buf.empty?
+            @state = :disconnected
+            raise EOFError
+          end
+        end
+        @buf, data = unpack_msg(@buf)
+        return data
+      else
+        raise IOError, ("read_msg called in state: %s." % @state.to_s)
+      end
+    end
+
+    # This method the debugger uses to write a message unit.
+    def write(msg)
+      # FIXME: do we have to check the size of msg and split output? 
+      @inout.write(pack_msg(msg))
+    end
+
+    def writeline(msg)
+      write(msg + "\n")
+    end
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  client = Trepan::TCPDbgClient.new({'open' => false})
+  if ARGV.size > 0
+    threads = []
+    Thread.new do
+      server = TCPServer.new('localhost', 1027)
+      session = server.accept
+      while 'quit' != (line = session.gets)
+        session.puts line 
+      end
+      session.close
+    end
+
+    threads << Thread.new do
+      print 'Connecting...'
+      client.open()
+      puts 'connected.'
+      while true
+        print "input? "
+        line = STDIN.gets
+        break if line.chomp == 'quit'
+        begin
+          line = client.writeline(line)
+          puts "Got: #{client.read_msg.chomp}"
+        rescue EOFError
+          puts "Got EOF"
+          break
+        rescue Exception => e
+          puts "Got #{e}"
+          break
+        end
+      end
+    end
+    threads.each {|t| t.join }
+  end
+  client.close
+end

data/io/tcpfns.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Subsidiary routines used to "pack" and "unpack" TCP messages.
+
+module Trepanning
+  module TCPPacking
+
+    TCP_MAX_PACKET = 8192 # Largest size for a recv
+    LOG_MAX_MSG    = Math.log10(TCP_MAX_PACKET).ceil
+
+    def pack_msg(msg)
+      fmt = '%%%dd' % LOG_MAX_MSG # A funny way of writing: '%4d'
+      (fmt % msg.size) + msg
+    end
+
+    def unpack_msg(buf)
+      length  = Integer(buf[0...LOG_MAX_MSG])
+      data    = buf[LOG_MAX_MSG..LOG_MAX_MSG+length]
+      buf     = buf[LOG_MAX_MSG+length..-1]
+      [buf, data]
+    end
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  include Trepanning::TCPPacking
+  msg = "Hi there!"
+  puts unpack_msg(pack_msg(msg))[1] == msg
+end
+

data/io/tcpserver.rb

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Debugger Server Input/Output interface.
+
+require 'socket'
+require_relative '../app/default' # For host and port
+require_relative 'base_io'
+require_relative 'tcpfns'
+
+class Trepan 
+  # Debugger Server Input/Output Socket.
+  class TCPDbgServer < Trepan::InOutBase
+
+    include Trepanning::TCPPacking
+    
+    DEFAULT_INIT_OPTS = {:open => true}
+    
+    SERVER_SOCKET_OPTS = {
+      :host    => Trepan::DEFAULT_SETTINGS[:host],
+      :port    => Trepan::DEFAULT_SETTINGS[:port], # A non-privileged port
+      :timeout => 5,     # FIXME: not used
+      :reuse   => true,  # FIXME: not used. Allow port to be resued on close?
+                         # Python has: 'posix' == os.name 
+    }
+
+    attr_reader :state
+
+    def initialize(opts={})
+      @opts    = DEFAULT_INIT_OPTS.merge(opts)
+      @input = @output = @session = nil
+      @buf     = ''    # Read buffer
+      @state   = :disconnected
+      @port    = nil   # Current port in use
+      @host    = nil   # current host in use
+      open(@opts) if @opts[:open]
+    end
+
+    def connected?
+      :connected == @state
+    end
+    
+
+    # Closes server connection.
+    def close
+      @state = :closing
+      @session.close if @session
+      @state = :disconnected
+    end
+
+    def open(opts={})
+      @opts   = SERVER_SOCKET_OPTS.merge(opts)
+      @host   = @opts[:host]
+      @port   = @opts[:port]
+      @server = TCPServer.new(@host, @port)
+      # @server.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, 5)
+      #                   # @opts[:timeout])
+      @state  = :listening
+    end
+    
+    # Read one message unit. It's possible however that
+    # more than one message will be set in a receive, so we will
+    # have to buffer that for the next read.
+    # EOFError will be raised on EOF.
+    def read_msg
+      wait_for_connect unless connected?
+      while !@buf || @buf.empty?
+        @buf, info = @session.recvfrom(TCP_MAX_PACKET)
+      end
+      @buf, data = unpack_msg(@buf)
+      data
+    end
+
+    def wait_for_connect
+      @input = @output = @session = @server.accept
+      @state = :connected
+    end
+    
+    # This method the debugger uses to write. In contrast to
+    # writeline, no newline is added to the end to `str'. Also
+    # msg doesn't have to be a string.
+    def write(msg)
+      wait_for_connect() unless connected?
+      # FIXME: do we have to check the size of msg and split output? 
+      @session.print(pack_msg(msg))
+    end
+
+    def writeline(msg)
+      write(msg + "\n")
+    end
+
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  include Trepanning::TCPPacking
+  server = Trepan::TCPDbgServer.new({ :open => false,
+                                      :port => 1027,
+                                      :host => 'localhost'
+                                    })
+  if ARGV.size > 0
+    puts 'Listening for connection...'
+    server.open
+    threads = []
+    Thread.new do
+      while true do
+        begin
+          line = server.read_msg.chomp
+          puts "got #{line}"
+        rescue EOFError
+          puts 'Got EOF'
+          break
+        end
+      end
+    end
+    threads << Thread.new do 
+      t = TCPSocket.new('localhost', 1027)
+      while true do
+        begin
+          print "input? "
+          line = STDIN.gets
+          break if !line || line.chomp == 'quit'
+          t.puts(pack_msg(line))
+        rescue EOFError
+          puts "Got EOF"
+          break
+        rescue Exception => e
+          puts "Got #{e}"
+          break
+        end
+      end
+      t.close
+    end
+    threads.each {|t| t.join }
+    server.close
+  end
+end