em-simple_telnet 0.0.1 → 0.0.6

data/README.rdoc

@@ -0,0 +1,47 @@
+== EventMachine::Protocols::SimpleTelnet
+
+Provides telnet client functionality.
+
+This class derived from the Net::Telnet class in Ruby's standard library.
+It was developed with simplicity in mind. It tries to hide the complexity
+that normally comes with asynchronous programming using the Fiber class
+found in Ruby 1.9.
+
+== Overview
+
+The telnet protocol allows a client to login remotely to a user account on a
+server and execute commands via a shell.  The equivalent is done by creating
+a EventMachine::Protocols::SimpleTelnet instance with the <tt>:host</tt>
+option set to your host along with a block which defines the task to be done
+on the host. Inside the task you can issue one or more #cmd calls. After the
+block is executed, #close is automatically called.
+
+This class can also be used to connect to non-telnet services, such as SMTP
+or HTTP.  In this case, you normally want to provide the <tt>:port</tt>
+option to specify the port to connect to, and set the <tt>:telnet_mode</tt>
+option to +false+ to prevent the client from attempting to interpret telnet
+command sequences.  Generally, #login will not work with other protocols,
+and you have to handle authentication yourself.
+
+== Examples
+
+  EventMachine.run do
+
+    opts = {
+      host: "localhost",
+      username: "user",
+      password: "secret",
+    }
+
+    EM::P::SimpleTelnet.new(opts) do |host|
+      # already logged in
+      puts host.cmd("ls -la")
+    end
+  end
+
+== References
+
+There are a large number of RFCs relevant to the Telnet protocol.
+RFCs 854-861 define the base protocol.  For a complete listing
+of relevant RFCs, see
+http://www.omnifarious.org/~hopper/technical/telnet-rfc.html

data/lib/em-simple_telnet.rb

@@ -15,27 +15,18 @@ require "eventmachine"
 # still working on a deferred action or not.
 #
 module EventMachine # :nodoc:
-  def self.defers_finished?
-    (not defined? @threadqueue or (tq=@threadqueue).nil? or tq.empty? ) and
-    (not defined? @resultqueue or (rq=@resultqueue).nil? or rq.empty? ) and
-    (not defined? @threadpool  or (tp=@threadpool).nil? or tp.none? {|t|t[:working]})
-  end
+  # ensure they're always defined
+  @threadpool = @threadqueue = @resultqueue = nil
 
-  def self.spawn_threadpool
-    until @threadpool.size == @threadpool_size.to_i
-      thread = Thread.new do
-        Thread.current.abort_on_exception = true
-        while true
-          Thread.current[:working] = false
-          op, cback = *@threadqueue.pop
-          Thread.current[:working] = true
-          result = op.call
-          @resultqueue << [result, cback]
-          EventMachine.signal_loopbreak
-        end
-      end
-      @threadpool << thread
-    end
+  ##
+  # Returns +true+ if all deferred actions are done executing and their
+  # callbacks have been fired.
+  #
+  def self.defers_finished?
+    return false if @threadqueue and not @threadqueue.empty?
+    return false if @resultqueue and not @resultqueue.empty?
+    return false if @threadpool and @threadqueue.num_waiting != @threadpool.size
+    return true
   end
 end
 
@@ -261,32 +252,39 @@ class EventMachine::Protocols::SimpleTelnet < EventMachine::Connection
         opts
       ]
 
-      # start establishing the connection
-      connection = EventMachine.connect(*params)
+      begin
+        # start establishing the connection
+        connection = EventMachine.connect(*params)
 
-      # set callback to be executed when connection establishing
-      # fails/succeeds
-      f = Fiber.current
-      connection.connection_state_callback = lambda do |obj=nil|
-        @connection_state_callback = nil
-        f.resume obj
-      end
+        # set callback to be executed when connection establishing
+        # fails/succeeds
+        f = Fiber.current
+        connection.connection_state_callback = ->(o){ f.resume(o) }
 
-      # block here and get result from establishing connection
-      state = Fiber.yield
+        # block here and get result from establishing connection
+        state = Fiber.yield
 
-      # raise if exception (e.g. Telnet::ConnectionFailed)
-      raise state if state.is_a? Exception
+        # raise if exception (e.g. Telnet::ConnectionFailed)
+        raise state if state.is_a? Exception
 
-      # login
-      connection.instance_eval { login }
+        # login
+        connection.instance_eval { login }
 
-      begin
-        yield connection
+        begin
+          yield connection
+        ensure
+          # Use #close so a subclass can execute some kind of logout command
+          # before the connection is closed.
+          connection.close
+        end
       ensure
-        # Use #close so a subclass can execute some kind of logout command
-        # before the connection is closed.
-        connection.close
+        # close the connection in any case
+        if connection
+          connection.close_connection_after_writing
+
+          # give some time to send the remaining data, which should be nothing
+          EventMachine.add_timer(2) { connection.close_connection }
+        end
       end
 
       return connection
@@ -574,7 +572,7 @@ class EventMachine::Protocols::SimpleTelnet < EventMachine::Connection
     # we only need to do something if there's a connection state callback
     return unless @connection_state_callback
 
-    # we ensure there's no timer running to check the input buffer
+    # we ensure there's no timer running for checking the input buffer
     if @check_input_buffer_timer
       @check_input_buffer_timer.cancel
       @check_input_buffer_timer = nil
@@ -588,9 +586,9 @@ class EventMachine::Protocols::SimpleTelnet < EventMachine::Connection
       # We postpone checking the input buffer by one second because the regular
       # expression matches can get quite slow.
       #
-      # So as long as data is received (continuously), the input buffer is not
-      # checked. It's only checked one second after the whole output has been
-      # received.
+      # So as long as data is being received (continuously), the input buffer
+      # is not checked. It's only checked one second after the whole output
+      # has been received.
       @check_input_buffer_timer = EventMachine::Timer.new(1) do
         @check_input_buffer_timer = nil
         check_input_buffer
@@ -607,33 +605,32 @@ class EventMachine::Protocols::SimpleTelnet < EventMachine::Connection
 
   ##
   # Checks the input buffer (<tt>@input_buffer</tt>) for the prompt we're
-  # waiting for. Calls the proc in <tt>@connection_state_callback</tt> if the
+  # waiting for. Calls #call_connection_state_callback with the output if the
   # prompt has been found. Thus, call this method *only* if
   # <tt>@connection_state_callback</tt> is set!
   #
-  # If <tt>@telnet_options[:wait_time]</tt> is set, this amount of seconds is
-  # waited (call to <tt>@connection_state_callback</tt> is scheduled) after
-  # seeing what looks like the prompt before firing the
-  # <tt>@connection_state_callback</tt> is fired, so more data can come until
-  # the real prompt is reached. This is useful for commands which will cause
-  # multiple prompts to be sent.
+  # If <tt>@telnet_options[:wait_time]</tt> is set, it will wait this amount
+  # of seconds after seeing what looks like the prompt before calling
+  # #call_connection_state_callback.  This way, more data can be received
+  # until the real prompt is received. This is useful for commands that send
+  # multiple prompts.
   #
   def check_input_buffer
-    if md = @input_buffer.match(@telnet_options[:prompt])
-      blk = lambda do
-        @last_prompt = md.to_s # remember last prompt
-        output = md.pre_match + @last_prompt
-        @input_buffer = md.post_match
-        @connection_state_callback.call(output)
-      end
+    return unless md = @input_buffer.match(@telnet_options[:prompt])
 
-      if s = @telnet_options[:wait_time]
-        # fire @connection_state_callback after s seconds
-        @wait_time_timer = EventMachine::Timer.new(s, &blk)
-      else
-        # fire @connection_state_callback now
-        blk.call
-      end
+    blk = lambda do
+      @last_prompt = md.to_s # remember last prompt
+      output = md.pre_match + @last_prompt
+      @input_buffer = md.post_match
+      call_connection_state_callback(output)
+    end
+
+    if s = @telnet_options[:wait_time] and s > 0
+      # fire @connection_state_callback after s seconds
+      @wait_time_timer = EventMachine::Timer.new(s, &blk)
+    else
+      # fire @connection_state_callback now
+      blk.call
     end
   end
 
@@ -675,10 +672,7 @@ class EventMachine::Protocols::SimpleTelnet < EventMachine::Connection
     f = Fiber.current
 
     # will be called by #receive_data to resume at "Fiber.yield" below
-    @connection_state_callback = lambda do |output|
-      @connection_state_callback = nil
-      f.resume(output)
-    end
+    @connection_state_callback = ->(output){ f.resume(output) }
 
     result = Fiber.yield
 
@@ -769,8 +763,7 @@ class EventMachine::Protocols::SimpleTelnet < EventMachine::Connection
     log_command(opts[:hide] ? "<hidden command>" : command)
 
     # send the command
-    sendcmd = opts[:raw_command] ? :print : :puts
-    self.__send__(sendcmd, command)
+    opts[:raw_command] ? print(command) : puts(command)
 
     # wait for the output
     waitfor(opts[:prompt], opts)
@@ -855,10 +848,10 @@ class EventMachine::Protocols::SimpleTelnet < EventMachine::Connection
   # Decreases <tt>@@_telnet_connection_count</tt> by one and calls #close_logs.
   #
   # After that and if <tt>@connection_state_callback</tt> is set, it takes a
-  # look on <tt>@connection_state</tt>. If it was <tt>:connecting</tt>, calls
-  # <tt>@connection_state_callback</tt> with a new instance of
-  # ConnectionFailed. If it was <tt>:waiting_for_prompt</tt>, calls the
-  # callback with a new instance of TimeoutError.
+  # look at <tt>@connection_state</tt>. If it was <tt>:connecting</tt>, calls
+  # #call_connection_state_callback with a new instance of ConnectionFailed.
+  # If it was <tt>:waiting_for_prompt</tt>, calls the same method with a new
+  # instance of TimeoutError.
   #
   # Finally, the <tt>@connection_state</tt> is set to +closed+.
   #
@@ -888,23 +881,31 @@ class EventMachine::Protocols::SimpleTelnet < EventMachine::Connection
     @connection_state = :closed
   end
 
+  ##
+  # Calls the @connection_state_callback with _obj_ and sets it to +nil+.
+  #
+  # Call this method *only* if <tt>@connection_state_callback</tt> is set!
+  #
+  def call_connection_state_callback(obj=nil)
+    callback, @connection_state_callback = @connection_state_callback, nil
+    callback.call(obj)
+  end
+
   ##
   # Called by EventMachine after the connection is successfully established.
   #
   def connection_completed
     @connection_state = :connected
-    @connection_state_callback.call if @connection_state_callback
+    call_connection_state_callback if @connection_state_callback
   end
 
   ##
-  # Tells EventMachine to close the connection after sending what's in the
-  # output buffer. Redefine this method to execute some logout command like
-  # +exit+ or +logout+ before the connection is closed. Don't forget: The
-  # command will probably not return a prompt, so use #puts, which doesn't
-  # wait for a prompt.
+  # Redefine this method to execute some logout command like +exit+ or
+  # +logout+ before the connection is closed. Don't forget: The command will
+  # probably not return a prompt, so use #puts, which doesn't wait for a
+  # prompt.
   #
   def close
-    close_connection_after_writing
   end
 
   ##

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: em-simple_telnet
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -10,16 +10,34 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2011-11-21 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.2
 description: This library provides a very simple way to connect to telnet servers
   using EventMachine in a seemingly synchronous manner.
 email:
 - paddor@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.rdoc
 files:
 - lib/em-simple_telnet.rb
+- README.rdoc
 homepage: http://github.com/paddor/em-simple_telnet
 licenses: []
 post_install_message: 
@@ -40,9 +58,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Simple telnet client on EventMachine
 test_files: []
-has_rdoc: