live_console 0.2.1 → 0.2.4

data/{doc/LICENSE → LICENSE}

@@ -4,16 +4,16 @@ 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 
+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 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 
+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/{doc/README → README}

@@ -11,13 +11,12 @@ For example, you can:
 	* Patch code on the fly, without a restart.
 	* Let anyone on the net 0wn you if you bind to a public interface. :)
 It's useful as a diagnostic tool, a debugging tool, and a way to impress your
-friends or get those Lisp guys off your back.  You know the ones I mean.
+friends.
 
 == Stern Security Warning.  Grrr.
 
 Have a look at the bugs section.  It should be pretty apparent that incorrect
-use of this library could create a large security hole, especially before
-authentication is implemented.
+use of this library could create a large security hole.
 
 == Installation
 
@@ -25,10 +24,6 @@ You can install via rubygems,
 
   gem install live_console
 
-or plain old setup.rb:
-
-  ruby setup.rb install
-
 == How to use LiveConsole
 
 LiveConsole is very easy to use in your own app:
@@ -59,17 +54,17 @@ LiveConsole is very easy to use in your own app:
 	# Of course, you must restart before IRB will see the new binding:
 	lc.restart
 
-Have a look at doc/lc_example.rb or doc/lc_unix_example.rb for brief examples
+Have a look at examples/lc_example.rb or examples/lc_unix_example.rb for brief examples
 of how to use LiveConsole.
 
 Try just running it:
 
-	$ ruby doc/lc_example.rb 4000 test
+	$ ruby examples/lc_example.rb 4000 test
 	# Then, in a different shell:
 	$ netcat localhost 4000
 	irb(main):001:0> puts 'Wow, magic!'
 
-	$ ruby doc/lc_unix_example.rb /tmp/live-console.sock
+	$ ruby examples/lc_unix_example.rb /tmp/live-console.sock
 	# Then, in a different shell:
 	$ udscat /tmp/live-console.sock
 	irb(main):001:0> puts 'Words cannot describe the joy I feel.'
@@ -80,11 +75,11 @@ you've diagnosed and fixed whatever the problem was.
 
 Additionally, if you want to run LiveConsole on a server, but run netcat
 locally, you can use SSH port forwarding to avoid having to open LiveConsole
-to the world:  
+to the world:
 
 	ssh -L4000:localhost:4000 you@server
 
-Then, locally, you can do 
+Then, locally, you can do
 
 	netcat localhost 4000
 
@@ -93,26 +88,27 @@ only works for the TCP socket mode.
 
 == Bugs
 
-LiveConsole lacks many of the niceties of IRB on the console, like Readline
-support.
+LiveConsole lacks many of the niceties of IRB on the console, like full Readline
+support.  LiveConsole does offer tab completion if you write a client that sends
+the phrase to complete, ending with a tab and newline.  LiveConsole will activate the IRB
+completion proc and send back the results, terminated by newline.
+
+Readline history support can be added if anyone finds it useful to manage history
+remotely.
+
+For full Readline support, you can actually use the wonderful rlwrap program, which
+wraps an arbitrary interactive program in readline.  For example, to connect to
+a LiveConsole on localhost:3333, use
+	rlwrap netcat localhost 3333
+rlwrap is available with most Linux distributions or at
+http://utopia.knoware.nl/~hlub/uck/rlwrap/ .  It is seriously an incredibly
+useful piece of software.
+
 
 Typing exit, hitting ^D, or sending signals (like INT or STOP) doesn't work.
 Just exit the program you used to connect to it.  This has more to do with the
 program you use to connect to the socket.
 
-For TCP connections, there is no authentication support yet, although it is
-planned for the near future.  This creates a security risk:  anyone that can
-connect to the socket can run arbitrary Ruby code as the user who owns the
-process.  In fact, even binding to localhost can be a security issue if you're
-on a box with any untrusted users.  If there's a chance you don't know what
-you're doing, avoid using this library.  The Unix Domain Socket version is more
-secure, as you can control access via filesystem permissions.
-
-Only one client can connect at a time.  I don't think anyone needs multiple LC
-connections to serve multiple instances of IRB to various clients, but if you
-need it, let me know.
-
-The README contains a slur against Lisp guys.  Please stop hitting me with that PDP-10 manual.  I love your language and the lambda tattoo on your chest.  
 
 Other than that, LiveConsole doesn't have any known bugs, but it is odd
 software that also monkey-patches IRB, so they are likely to be there.  Bug
@@ -120,8 +116,9 @@ reports and patches gratefully accepted.
 
 == Credits
 
-Pete Elmore -- (pete.elmore(a)gmail.com)
+Jennifer Hickey, project owner -- (jencompgeek(a)gmail.com)
 
-== Home page
+Pete Elmore, original author -- (pete.elmore(a)gmail.com)
 
-http://debu.gs/live-console
+Roger D. Pack (http://betterlogic.com/roger/) provided patches and Windows
+support

data/lib/live_console.rb

@@ -1,227 +1,295 @@
 # LiveConsole
 # Pete Elmore (pete.elmore@gmail.com), 2007-10-18
-# debu.gs/live-console
+# Jennifer Hickey
 # See doc/LICENSE.
 
 require 'irb'
 require 'irb/frame'
 require 'socket'
-require 'live_console_config'
+require 'irb/completion'
 
 # LiveConsole provides a socket that can be connected to via netcat or telnet
-# to use to connect to an IRB session inside a running process.  It creates a
-# thread that listens on the specified address/port or Unix Domain Socket path,
+# to use to connect to an IRB session inside a running process.  It listens on the
+# specified address/port or Unix Domain Socket path,
 # and presents connecting clients with an IRB shell.  Using this, you can
 # execute code on a running instance of a Ruby process to inspect the state or
-# even patch code on the fly.  There is currently no readline support.
+# even patch code on the fly.
 class LiveConsole
-	include Socket::Constants
-	autoload :IOMethods, 'live_console/io_methods'
-
-	attr_accessor :io_method, :io, :thread, :bind
-	private :io_method=, :io=, :thread=
-	
-	# call-seq:
-	#	# Bind a LiveConsole to localhost:3030 (only allow clients on this 
-	#	# machine to connect):
-	#	LiveConsole.new :socket, :port => 3030
-	#	# Accept connections from anywhere on port 3030.  Ridiculously insecure:
-	#	LiveConsole.new(:socket, :port => 3030, :host => '0.0.0.0')
-	#	# Use a Unix Domain Socket (which is more secure) instead:
-	#	LiveConsole.new(:unix_socket, :path => '/tmp/my_liveconsole.sock',
-	#	                :mode => 0600, :uid => Process.uid, :gid => Process.gid)
-	#	# By default, the mode is 0600, and the uid and gid are those of the 
-	#	# current process.  These three options are for the file's permissions.
-	#	# You can also supply a binding for IRB's toplevel:
-	#	LiveConsole.new(:unix_socket, 
-	#		:path => "/tmp/live_console_#{Process.pid}.sock", :bind => binding)
-	#
-	# Creates a new LiveConsole.  You must next call LiveConsole#start when you
-	# want to spawn the thread to accept connections and start the console.
-	def initialize(io_method, opts = {})
-		self.io_method = io_method.to_sym
-		self.bind = opts.delete :bind
-		unless IOMethods::List.include?(self.io_method)
-			raise ArgumentError, "Unknown IO method: #{io_method}" 
-		end
-
-		init_io opts
-	end
-
-	# LiveConsole#start spawns a thread to listen for, accept, and provide an
-	# IRB console to new connections.  If a thread is already running, this
-	# method simply returns false; otherwise, it returns the new thread.
-	def start
-		if thread 
-			if thread.alive?
-				return false
-			else
-				thread.join
-				self.thread = nil
-			end
-		end
-
-		self.thread = Thread.new { 
-			loop {
-				Thread.pass
-				if io.start
-					irb_io = GenericIOMethod.new io.raw_input, io.raw_output
-					begin
-						IRB.start_with_io(irb_io, bind)
-					rescue Errno::EPIPE => e
-						io.stop
-					end
-				end
-			}
-		}
-		thread
-	end
-
-	# Ends the running thread, if it exists.  Returns true if a thread was
-	# running, false otherwise.
-	def stop
-		if thread
-			if thread == Thread.current
-				self.thread = nil
-				Thread.current.exit!
-			end
-
-			thread.exit
-			if thread.join(0.1).nil?
-				thread.exit!
-			end
-			self.thread = nil
-			true
-		else
-			false
-		end
-	end
-
-	# Restarts.  Useful for binding changes.  Return value is the same as for 
-	# LiveConsole#start.
-	def restart
-		r = lambda { stop; start }
-		if thread == Thread.current
-			Thread.new &r # Leaks a thread, but works.
-		else
-			r.call
-		end
-	end
-
-	private
-
-	def init_irb
-		return if @@irb_inited_already
-		IRB.setup nil
-		@@irb_inited_already = true
-	end
-
-	def init_io opts
-		self.io = IOMethods.send(io_method).new opts
-	end
+  include Socket::Constants
+  autoload :IOMethods, 'live_console/io_methods'
+
+  attr_accessor :io_method, :io, :thread, :bind, :authenticate, :readline
+  private :io_method=, :io=, :thread=, :authenticate=, :readline=
+
+  # call-seq:
+  ## Bind a LiveConsole to localhost:3030 (only allow clients on this
+  ## machine to connect):
+  # LiveConsole.new :socket, :port => 3030
+  ## Accept connections from anywhere on port 3030.  Ridiculously insecure:
+  # LiveConsole.new(:socket, :port => 3030, :host => '0.0.0.0')
+  ## Accept connections from anywhere on port 3030, secured with a plain-text credentials file
+  ## credentials_file should be of the form:
+  ### username: <username>
+  ### password: <password>
+  # LiveConsole.new(:socket, :port => 3030, :host => '0.0.0.0', :authenticate=>true,
+  #                 :credentials_file='/path/to/.consoleaccess)
+  ## Use a Unix Domain Socket (which is more secure) instead:
+  # LiveConsole.new(:unix_socket, :path => '/tmp/my_liveconsole.sock',
+  #	            :mode => 0600, :uid => Process.uid, :gid => Process.gid)
+  ## By default, the mode is 0600, and the uid and gid are those of the
+  ## current process.  These three options are for the file's permissions.
+  ## You can also supply a binding for IRB's toplevel:
+  # LiveConsole.new(:unix_socket,
+  #		    :path => "/tmp/live_console_#{Process.pid}.sock", :bind => binding)
+  #
+  # Creates a new LiveConsole.  You must next call LiveConsole#start or LiveConsole#start_blocking
+  # when you want to accept connections and start the console.
+  def initialize(io_method, opts = {})
+    self.io_method = io_method.to_sym
+    self.bind = opts.delete :bind
+    self.authenticate = opts.delete :authenticate
+    self.readline = opts.delete :readline
+    unless IOMethods::List.include?(self.io_method)
+      raise ArgumentError, "Unknown IO method: #{io_method}"
+    end
+    init_io opts
+  end
+
+  # LiveConsole#start spawns a thread to listen for, accept, and provide an
+  # IRB console to new connections.  If a thread is already running, this
+  # method simply returns false; otherwise, it returns the new thread.
+  def start
+    if thread
+      if thread.alive?
+        return false
+      else
+        thread.join
+        self.thread = nil
+      end
+    end
+
+    self.thread = Thread.new {
+      start_blocking
+    }
+    thread
+  end
+
+  # LiveConsole#start_blocking executes a loop to listen for, accept,
+  # and provide an IRB console to new connections.
+  # This is a blocking call and the only way to stop it is to kill the process
+  def start_blocking
+    loop {
+      conn = io.get_connection
+      #This will block until a connection is made or a failure occurs
+      if conn.start
+        #fork a new process for the session to redirect stdout/stderr
+        pid = fork {
+          begin
+            start_irb = true
+            if authenticate && !conn.authenticate
+              conn.stop
+              start_irb = false
+            end
+            if start_irb
+              irb_io = GenericIOMethod.new conn.raw_input, conn.raw_output, readline
+              begin
+                IRB.start_with_io(irb_io, bind)
+              rescue Errno::EPIPE => e
+                conn.stop
+              end
+            end
+          rescue Exception => e
+            puts "Error during connection: #{e.message}"
+            conn.stop
+          end
+        }
+        Process.detach(pid)
+      end
+    }
+  end
+
+  # Ends the running thread, if it exists.  Returns true if a thread was
+  # running, false otherwise.
+  def stop
+    if thread
+      if thread == Thread.current
+        self.thread = nil
+        Thread.current.exit!
+      end
+
+      thread.exit
+      if thread.join(0.1).nil?
+        thread.exit!
+      end
+      self.thread = nil
+      true
+    else
+      false
+    end
+  end
+
+  # Restarts.  Useful for binding changes.  Return value is the same as for
+  # LiveConsole#start.
+  def restart
+    r = lambda { stop; start }
+    if thread == Thread.current
+      Thread.new &r # Leaks a thread, but works.
+    else
+      r.call
+    end
+  end
+
+  private
+
+  def init_irb
+    return if @@irb_inited_already
+    IRB.setup nil
+    @@irb_inited_already = true
+  end
+
+  def init_io opts
+    self.io = IOMethods.send(io_method).new opts
+  end
 end
 
 # We need to make a couple of changes to the IRB module to account for using a
-# weird I/O method and re-starting IRB from time to time.  
+# weird I/O method and re-starting IRB from time to time.
 module IRB
-	@inited = false
-
-	ARGV = []
-
-	# Overridden a la FXIrb to accomodate our needs.
-	def IRB.start_with_io(io, bind, &block)
-		unless @inited
-			setup '/dev/null'
-			IRB.parse_opts
-			IRB.load_modules
-			@inited = true
-		end
-
-		bind ||= IRB::Frame.top(1)
-		ws = IRB::WorkSpace.new(bind)
-		irb = Irb.new(ws, io, io)
-
-		@CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
-		@CONF[:MAIN_CONTEXT] = irb.context
-		@CONF[:PROMPT_MODE] = :INF_RUBY
-
-		catch(:IRB_EXIT) { 
-			begin
-				irb.eval_input
-			rescue StandardError => e
-				irb.print([e.to_s, e.backtrace].flatten.join("\n") + "\n")
-				retry
-			end
-		}
-		irb.print "\n"
-	end
-
-	class Context
-		# Fix an IRB bug; it ignores your output method.
-		def output *args
-			@output_method.print *args
-		end
-	end
-
-	class Irb
-		# Fix an IRB bug; it ignores your output method.
-		def printf(*args)
-			context.output(sprintf(*args))
-		end
-
-		# Fix an IRB bug; it ignores your output method.
-		def print(*args)
-			context.output *args
-		end
-	end
+  @inited = false
+
+  ARGV = []
+
+  # Overridden a la FXIrb to accomodate our needs.
+  def IRB.start_with_io(io, bind, &block)
+    unless @inited
+      setup '/dev/null'
+      IRB.parse_opts
+      IRB.load_modules
+      @inited = true
+    end
+
+    #Redirect stdout and stderr to cover output of Ruby commands like puts
+    $stdout.sync=true
+    $stderr.sync=true
+    $stdout.reopen(io.output)
+    $stderr.reopen(io.output)
+    ws = IRB::WorkSpace.new(bind)
+
+    @CONF[:PROMPT_MODE] = :DEFAULT
+    #Remove the context from all prompts-can be too long depending on binding
+    @CONF[:PROMPT][:DEFAULT][:PROMPT_I] = "%N():%03n:%i> "
+    @CONF[:PROMPT][:DEFAULT][:PROMPT_N] = "%N():%03n:%i> "
+    #Add > to S and C as they don't get picked up by telnet prompt scan
+    @CONF[:PROMPT][:DEFAULT][:PROMPT_S] = "%N():%03n:%i%l> "
+    @CONF[:PROMPT][:DEFAULT][:PROMPT_C] = "%N():%03n:%i*> "
+
+    @CONF[:USE_READLINE] = false
+    irb = Irb.new(ws, io, io)
+    bind ||= IRB::Frame.top(1) rescue TOPLEVEL_BINDING
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+
+    catch(:IRB_EXIT) {
+      begin
+        irb.eval_input
+      rescue StandardError => e
+        irb.print([e.to_s, e.backtrace].flatten.join("\n") + "\n")
+        retry
+      end
+    }
+    irb.print "\n"
+  end
+
+  class Context
+    # Fix an IRB bug; it ignores your output method.
+    def output *args
+      @output_method.print *args
+    end
+  end
+
+  class Irb
+    # Fix an IRB bug; it ignores your output method.
+    def printf(*args)
+      context.output(sprintf(*args))
+    end
+
+    # Fix an IRB bug; it ignores your output method.
+    def print(*args)
+      context.output *args
+    end
+  end
 end
 
 # The GenericIOMethod is a class that wraps I/O for IRB.
 class GenericIOMethod < IRB::StdioInputMethod
-	# call-seq:
-	# 	GenericIOMethod.new io
-	# 	GenericIOMethod.new input, output
-	#
-	# Creates a GenericIOMethod, using either a single object for both input
-	# and output, or one object for input and another for output.
-	def initialize(input, output = nil)
-		@input, @output = input, output
-		@line = []
-		@line_no = 0
-	end
-
-	attr_reader :input
-	def output
-		@output || input
-	end
-
-	def gets
-		output.print @prompt
-		output.flush
-		@line[@line_no += 1] = input.gets
-		# @io.flush	# Not sure this is needed.
-		@line[@line_no]
-	end
-
-	# Returns the user input history.
-	def lines
-		@line.dup
-	end
-
-	def print(*a)
-		output.print *a
-	end
-
-	def file_name
-		input.inspect
-	end
-
-	def eof?
-		input.eof?
-	end
-
-	def close
-		input.close
-		output.close if @output
-	end
+  # call-seq:
+  # 	GenericIOMethod.new io
+  # 	GenericIOMethod.new input, output
+  #
+  # Creates a GenericIOMethod, using either a single object for both input
+  # and output, or one object for input and another for output.
+  def initialize(input, output = nil, readline=false)
+    @input, @output = input, output
+    @line = []
+    @line_no = 0
+    @readline = readline
+  end
+
+  attr_reader :input
+  def output
+    @output || input
+  end
+
+  def gets
+    output.print @prompt
+    output.flush
+    line = input.gets
+    if @readline
+      #Return tab completion data as long as we receive input that ends in '\t'
+      while line.chomp =~ /\t\z/n
+        run_completion_proc line.chomp.chop
+        line = input.gets
+      end
+    end
+    @line[@line_no += 1] = line
+    @line[@line_no]
+  end
+
+  # Returns the user input history.
+  def lines
+    @line.dup
+  end
+
+  def print(*a)
+    output.print *a
+  end
+
+  def file_name
+    input.inspect
+  end
+
+  def eof?
+    input.eof?
+  end
+
+  def encoding
+    input.external_encoding
+  end
+
+  def close
+    input.close
+    output.close if @output
+  end
+
+  private
+  # Runs the IRB CompletionProc with the given argument and writes the array to output stream as
+  # a comma-separated String, terminated by newline (so clients know when all data received)
+  def run_completion_proc(line)
+    opts = IRB::InputCompletor::CompletionProc.call(line)
+    opts.compact!
+    optstrng = opts.join(",") + "\n"
+    output.print optstrng
+    output.flush
+  end
 end

data/lib/live_console/io_methods.rb

@@ -1,53 +1,46 @@
 module LiveConsole::IOMethods
-	List = []
-
-	Dir[File.join(File.dirname(__FILE__), 'io_methods', '*.rb')].each { |entry|
-		fname = entry.sub /\.rb$/, ''
-		classname = File.basename(entry, '.rb').capitalize.
-			gsub(/_(\w)/) { $1.upcase }.sub(/io$/i, 'IO').to_sym
-		mname = File.basename(fname).sub(/_io$/, '').to_sym
-
-		autoload classname, fname
-		List << mname
-
-		define_method(mname) {
-			const_get classname
-		}
-	}
-	List.freeze
-
-	extend self
-
-	module IOMethod
-		def initialize(opts)
-			self.opts = self.class::DefaultOpts.merge opts
-			unless missing_opts.empty?
-				raise ArgumentError, "Missing opts for " \
-					"#{self.class.name}:  #{missing_opts.inspect}"
-			end
-		end
-
-		def missing_opts
-			self.class::RequiredOpts - opts.keys
-		end
-
-		def self.included(other)
-			other.instance_eval {
-				readers = [:opts, :raw_input, :raw_output]
-				attr_accessor *readers
-				private *readers.map { |r| (r.to_s + '=').to_sym }
-
-				other::RequiredOpts.each { |opt| 
-					define_method(opt) { opts[opt] } 
-				}
-			}
-		end
-
-		def select
-			IO.select [server], [], [], 1 if server
-		end
-
-		private
-		attr_accessor :server
-	end
+  List = []
+
+  Dir[File.join(File.dirname(__FILE__), 'io_methods', '*')].each { |dir|
+    entry = dir + '/' + File.basename(dir)
+    fname = entry.sub /\.rb$/, ''
+    classname = File.basename(entry,'.rb').capitalize.
+    gsub(/_(\w)/) { $1.upcase }.sub(/io$/i, 'IO').to_sym
+    mname = File.basename(fname).sub(/_io$/, '').to_sym
+
+    autoload classname, fname
+    List << mname
+
+    define_method(mname) {
+      const_get classname
+    }
+  }
+  List.freeze
+
+  extend self
+
+  module IOMethod
+    def initialize(opts)
+      self.opts = self.class::DefaultOpts.merge opts
+      unless missing_opts.empty?
+        raise ArgumentError, "Missing opts for " \
+          "#{self.class.name}:  #{missing_opts.inspect}"
+      end
+    end
+
+    def missing_opts
+      self.class::RequiredOpts - opts.keys
+    end
+
+    def self.included(other)
+      other.instance_eval {
+        readers = [:opts]
+        attr_accessor *readers
+        private *readers.map { |r| (r.to_s + '=').to_sym }
+          other::RequiredOpts.each { |opt|
+          define_method(opt) { opts[opt] }
+        }
+      }
+    end
+  end
 end

data/lib/live_console/io_methods/socket_io/connection.rb

@@ -0,0 +1,52 @@
+require 'yaml'
+
+class LiveConsole::IOMethods::SocketIOConnection
+
+  attr_accessor :raw_input, :raw_output
+
+  def initialize(server, opts)
+    @server = server
+    @opts = opts
+  end
+
+  def start
+    begin
+      IO.select([@server])
+      self.raw_input = self.raw_output = @server.accept
+      return true
+    rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EPROTO,
+      Errno::EINTR => e
+      select
+      retry
+    end
+  end
+
+  def stop
+    select
+    raw_input.close rescue nil
+  end
+
+  def select
+    IO.select [@server], [], [], 1 if @server
+  end
+
+  # Retrieves credentials from I/O and matches them against the specified file
+  # credentials_file should be of the form:
+  # username: <username>
+  # password: <password>
+  def authenticate
+    authenticated = true
+    raw_output.print "Login: "
+    raw_output.flush
+    username = raw_input.gets
+    raw_output.print "Password: "
+    password = raw_input.gets
+    credentials_file= @opts[:credentials_file] || '.consoleaccess'
+    credentials =YAML.load_file(credentials_file)
+    if username.chomp != credentials['username'] || password.chomp != credentials['password']
+      raw_output.puts "Login failed."
+      authenticated = false
+    end
+    authenticated
+  end
+end

data/lib/live_console/io_methods/socket_io/socket_io.rb

@@ -0,0 +1,19 @@
+require 'live_console/io_methods/socket_io/connection'
+
+class LiveConsole::IOMethods::SocketIO
+  DefaultOpts = {
+    :host => '127.0.0.1',
+  }.freeze
+  RequiredOpts = DefaultOpts.keys + [:port]
+
+  include LiveConsole::IOMethods::IOMethod
+
+  def initialize(opts)
+    super opts
+    @server = TCPServer.new host, port
+  end
+
+  def get_connection
+    LiveConsole::IOMethods::SocketIOConnection.new(@server, opts)
+  end
+end

data/lib/live_console/io_methods/unix_socket/connection.rb

@@ -0,0 +1,36 @@
+require 'socket'
+
+class LiveConsole::IOMethods::UnixSocketConnection
+
+  attr_accessor :raw_input, :raw_output
+
+  def initialize(server, opts)
+    @server = server
+    @opts = opts
+  end
+
+  def start
+    begin
+      self.raw_input = self.raw_output = @server.accept_nonblock
+      raw_input.sync = true
+      return true
+    rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EPROTO,
+      Errno::EINTR => e
+      select
+      retry
+    end
+  end
+
+  def stop
+    select
+    raw_input.close
+  end
+
+  def select
+    IO.select [@server], [], [], 1 if @server
+  end
+
+  def authenticate
+    true
+  end
+end

data/lib/live_console/io_methods/unix_socket/unix_socket.rb

@@ -0,0 +1,22 @@
+require 'live_console/io_methods/unix_socket/connection'
+require 'socket'
+
+class LiveConsole::IOMethods::UnixSocket
+  DefaultOpts = {
+    :mode => 0600,
+    :uid => Process.uid,
+    :gid => Process.gid,
+  }
+  RequiredOpts = DefaultOpts.keys + [:path]
+
+  include LiveConsole::IOMethods::IOMethod
+
+  def initialize(opts)
+    super opts
+    @server = UNIXServer.new path
+  end
+
+  def get_connection
+    LiveConsole::IOMethods::UnixSocketConnection.new(@server,opts)
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module LiveConsole
+  VERSION = '0.2.4'
+end

metadata

@@ -1,68 +1,62 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: live_console
-version: !ruby/object:Gem::Version 
-  version: 0.2.1
+version: !ruby/object:Gem::Version
+  version: 0.2.4
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Pete Elmore
+- Jennifer Hickey
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2009-02-18 00:00:00 -08:00
-default_executable: 
+date: 2012-03-11 00:00:00.000000000Z
 dependencies: []
-
-description: 
-email: pete.elmore@gmail.com
-executables: 
+description: A library to support adding an irb console to your running application.
+email: jencompgeek@gmail.com
+executables:
 - udscat
 extensions: []
-
-extra_rdoc_files: 
-- doc/README
-- doc/lc_example.rb
-- doc/lc_unix_example.rb
-- doc/LICENSE
-files: 
-- lib/live_console_config.rb
-- lib/live_console.rb
-- lib/live_console
-- lib/live_console/io_methods
-- lib/live_console/io_methods/unix_socket_io.rb
-- lib/live_console/io_methods/socket_io.rb
-- lib/live_console/io_methods.rb
-- doc/README
-- doc/lc_example.rb
-- doc/lc_unix_example.rb
-- doc/LICENSE
+extra_rdoc_files:
+- LICENSE
+- README
+- examples/lc_example.rb
+- examples/lc_unix_example.rb
+files:
+- LICENSE
+- README
+- examples/lc_example.rb
+- examples/lc_unix_example.rb
 - bin/udscat
-- Rakefile
-has_rdoc: true
-homepage: http://debu.gs/live-console
+- lib/live_console/io_methods/socket_io/connection.rb
+- lib/live_console/io_methods/socket_io/socket_io.rb
+- lib/live_console/io_methods/unix_socket/connection.rb
+- lib/live_console/io_methods/unix_socket/unix_socket.rb
+- lib/live_console/io_methods.rb
+- lib/live_console.rb
+- lib/version.rb
+homepage: https://github.com/jencompgeek/live-console
+licenses: []
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: live-console
-rubygems_version: 1.3.1
+rubyforge_project: 
+rubygems_version: 1.8.17
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A library to support adding an irb console to your running application.
 test_files: []
-

data/Rakefile

@@ -1,88 +0,0 @@
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
-require 'lib/live_console_config'
-require 'fileutils'
-
-$: << "#{File.dirname(__FILE__)}/lib"
-
-spec = Gem::Specification.new { |s|
-	s.name = LiveConsoleConfig::PkgName
-	s.version = LiveConsoleConfig::Version
-	s.author = LiveConsoleConfig::Authors
-	s.email = LiveConsoleConfig::Email
-	s.homepage = LiveConsoleConfig::URL
-	s.rubyforge_project = LiveConsoleConfig::Project
-
-	s.platform = Gem::Platform::RUBY
-
-	s.files = Dir["{lib,doc,bin,ext}/**/*"].delete_if {|f| 
-		/\/rdoc(\/|$)/i.match f
-	} + %w(Rakefile)
-	s.require_path = 'lib'
-	s.has_rdoc = true
-	s.extra_rdoc_files = Dir['doc/*'].select(&File.method(:file?))
-	s.extensions << 'ext/extconf.rb' if File.exist? 'ext/extconf.rb'
-	Dir['bin/*'].map(&File.method(:basename)).map(&s.executables.method(:<<))
-
-	s.summary =	'A library to support adding an irb console to your ' \
-		'running application.'
-	%w().each &s.method(:add_dependency)
-}
-
-Rake::RDocTask.new(:doc) { |t|
-	t.main = 'doc/README'
-	t.rdoc_files.include 'lib/**/*.rb', 'doc/*', 'bin/*', 'ext/**/*.c', 
-		'ext/**/*.rb'
-	t.options << '-S' << '-N'
-	t.rdoc_dir = 'doc/rdoc'
-}
-
-Rake::GemPackageTask.new(spec) { |pkg|
-	pkg.need_tar_bz2 = true
-}
-
-desc "Builds and installs the gem for #{spec.name}"
-task(:install => :package) { 
-	g = "pkg/#{spec.name}-#{spec.version}.gem"
-	system "sudo gem install -l #{g}"
-}
-
-desc "Runs IRB, automatically require()ing #{spec.name}."
-task(:irb) {
-	exec "irb -Ilib -r#{spec.name}"
-}
-
-desc "Cleans up the pkg directory."
-task(:clean) {
-	FileUtils.rm_rf 'pkg'
-}
-
-
-desc "Generates a static gemspec file; useful for github."
-task(:static_gemspec) {
-	# This whole thing is hacky.
-	spec.validate
-	spec_attrs = %w(
-		platform author email files require_path has_rdoc extra_rdoc_files
-		extensions executables name summary homepage
-	).map { |attr|
-		"\ts.#{attr} = #{spec.send(attr).inspect}\n"
-	}.join << 
-		"\ts.version = #{spec.version.to_s.inspect}\n" <<
-		spec.dependencies.map { |dep|
-			"\ts.add_dependency #{dep.inspect}\n"
-		}.join
-
-	File.open("#{spec.name}.gemspec", 'w') { |f|
-		f.print <<-EOGEMSPEC
-# This is a static gempsec automatically generated by rake.  It's better to
-# edit the Rakefile than this file.  It is kept in the repository for the
-# benefit of github.
-
-spec = Gem::Specification.new { |s|
-#{spec_attrs}}
-
-Gem::Builder.new(spec).build if __FILE__ == $0
-		EOGEMSPEC
-	}
-}

data/lib/live_console/io_methods/socket_io.rb

@@ -1,27 +0,0 @@
-class LiveConsole::IOMethods::SocketIO
-	DefaultOpts = {
-		:host => '127.0.0.1',
-	}.freeze
-	RequiredOpts = DefaultOpts.keys + [:port]
-
-	include LiveConsole::IOMethods::IOMethod
-
-	def start
-		@server ||= TCPServer.new host, port
-
-		begin
-			self.raw_input = self.raw_output = server.accept_nonblock
-			return true
-		rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EPROTO,
-			   Errno::EINTR => e
-			select
-			retry
-		end
-	end
-
-	def stop
-		select
-		raw_input.close rescue nil
-	end
-
-end

data/lib/live_console/io_methods/unix_socket_io.rb

@@ -1,31 +0,0 @@
-require 'socket'
-
-class LiveConsole::IOMethods::UnixSocketIO
-	DefaultOpts = {
-		:mode => 0600,
-		:uid => Process.uid,
-		:gid => Process.gid,
-	}
-	RequiredOpts = DefaultOpts.keys + [:path]
-
-	include LiveConsole::IOMethods::IOMethod
-
-	def start
-		@server ||= UNIXServer.new path
-		
-		begin
-			self.raw_input = self.raw_output = server.accept_nonblock
-			raw_input.sync = true
-			return true
-		rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EPROTO,
-			   Errno::EINTR => e
-			select
-			retry
-		end
-	end
-
-	def stop
-		select
-		raw_input.close
-	end
-end

data/lib/live_console_config.rb

@@ -1,9 +0,0 @@
-# This module houses a pile of informative constants for LiveConsole.
-module LiveConsoleConfig
-	Authors = 'Pete Elmore'
-	Email = 'pete.elmore@gmail.com'
-	PkgName = 'live_console'
-	Version = '0.2.1'
-	URL = 'http://debu.gs/live-console'
-	Project = 'live-console'
-end