em-ruby-sockets 0.0.1

data/lib/em-ruby-sockets.rb

@@ -0,0 +1,28 @@
+require "eventmachine"
+require "kgio"
+require "iobuffer"
+
+require "em-ruby-sockets/version"
+require "em-ruby-sockets/errors"
+require "em-ruby-sockets/tcp_connection"
+require "em-ruby-sockets/tcp_client"
+require "em-ruby-sockets/file_streamer"
+
+
+
+module EventMachine::RubySockets
+
+  def self.tcp_connect ip, port, klass=EM::RubySockets::TcpClient
+    raise EM::RubySockets::Error, "EventMachine is not running" unless EM.reactor_running?
+
+    sock = ::Kgio::TCPSocket.start(ip, port)
+
+    conn = EM.watch sock, klass
+    conn.post_init
+    conn.send :init
+
+    block_given? and yield conn
+    conn
+  end
+
+end

data/lib/em-ruby-sockets/errors.rb

@@ -0,0 +1,3 @@
+module EventMachine::RubySockets
+  class Error < ::StandardError ; end
+end

data/lib/em-ruby-sockets/tcp_client.rb

@@ -0,0 +1,223 @@
+module EventMachine::RubySockets
+
+  class TcpClient < ::EM::Connection
+
+    include TcpConnection
+
+    def init
+      self.notify_writable = true
+      self.notify_readable = true
+      @buffer = ::IO::Buffer.new
+      @connected = false
+      @error = false
+    end
+    private :init
+
+    def notify_writable
+      return  if @error
+      self.notify_writable = false
+
+      unless @connected
+        begin
+          case @io.kgio_trywrite("")
+          when nil
+            @connected = true
+            on_connected()
+          end
+
+        rescue => e
+          connection_terminated e
+          return
+        end
+      end
+
+      try_send_data nil  unless @error or @buffer.empty?
+    end
+    private :notify_writable
+
+    def notify_readable
+      return  if @error
+
+      case buf = @io.kgio_tryread(4096)
+      # Reads at most maxlen bytes from the stream socket.
+      when ::String
+        receive_data buf
+      # Returns nil on EOF.
+      when nil
+        connection_terminated :remote_close
+      end
+
+    rescue => e
+      connection_terminated e
+    end
+    private :notify_readable
+
+    def try_send_data data
+      if data
+        if @buffer.empty?
+          @buffer << data
+        # If the buffer is not empty then there is a pending EM tick to send it,
+        # so don't add a new one and just append new data to the buffer.
+        else
+          @buffer << data
+          return
+        end
+      end
+
+      # Don't send the data now but in next EM iteration.
+      EM.next_tick do
+        unless @error
+          begin
+            case buf = @io.kgio_trywrite(@buffer.read)
+            # Returns nil if the write was completed in full.
+            when nil
+              @buffer.clear
+              self.notify_writable = false  if self.notify_writable?
+            # Returns :wait_writable if EAGAIN is encountered and nothing
+            # was written. It could occur *after* the connection is
+            # established.
+            when :wait_writable
+              self.notify_writable = true  unless self.notify_writable?
+            # Returns a String containing the unwritten portion if EAGAIN was
+            # encountered, but some portion was successfully written.
+            when ::String
+              @buffer << buf
+              self.notify_writable = true  unless self.notify_writable?
+            end
+
+          rescue => e
+            connection_terminated e
+          end
+        end
+      end
+    end
+    private :try_send_data
+
+    def connection_terminated cause
+      return  if @error
+
+      @error = true
+      detach
+      @io.close  unless @io.closed?
+      @buffer.clear
+      if @connected
+        on_disconnected cause
+      else
+        on_connection_error cause
+      end
+    end
+    private :connection_terminated
+
+    # Access to the Ruby socket itself. A good place for socket settings is
+    # the post_init method.
+    def io
+      @io
+    end
+
+    # Sends the given _data_ to the remote peer. It can be safely called
+    # before the connection is established (the data is then stored within
+    # an internal buffer).
+    # Returns true if the connection is established or trying to connect.
+    # False if the connection has been closed or if an unrecoverable error
+    # occurred while writting into the socket.
+    #
+    # Arguments:
+    # - [data] a String.
+    def send_data data
+      raise ::ArgumentError, "argument must be a String"  unless data.is_a?(::String)
+      return false  if @error
+
+      if @connected
+        try_send_data data
+      else
+        @buffer << data
+      end
+      true
+    end
+
+    # Terminates the connection regardless it's been sucessfuly connected
+    # or not. The callback on_disconnected will be called with argument
+    # _nil_.
+    def disconnect
+      return if @error
+      @error = true
+      detach
+      @io.close  unless @io.closed?
+      @buffer.clear
+      on_disconnected nil
+    end
+    alias :close_connection :disconnect
+    alias :close_connection_after_writing :disconnect
+
+    # Sets the duration after which a TCP connection in a connecting state
+    # will fail. After the given duration on_connection_error() is called
+    # with argument :pending_connect_timeout.
+    #
+    # Arguments:
+    # - [duration] Value in seconds (float).
+    def pending_connect_timeout= duration
+      return false  if @pending_connect_timeout
+
+      EM.add_timer(@pending_connect_timeout = duration.to_f) do
+        unless @error or @connected
+          connection_terminated :pending_connect_timeout
+        end
+      end
+      @pending_connect_timeout
+    end
+    alias :set_pending_connect_timeout :pending_connect_timeout=
+
+    # Gets the duration after which a TCP connection in a connecting state
+    # will fail. Returns nil if not set.
+    def pending_connect_timeout
+      @pending_connect_timeout
+    end
+
+    # Returns the number of bytes to be sent by the socket.
+    def get_outbound_data_size
+      @buffer.size
+    end
+
+    # Executed upon instance initialization and before the connection
+    # is attempted. Good place for defining custom attributes.
+    #
+    # This method must be defined in the user's inherinted class.
+    def post_init
+    end
+
+    # Called upon connection is established.
+    #
+    # This method must be defined in the user's inherinted class.
+    def on_connected
+    end
+
+    # Called when the connection attemp failed. _cause_ can be:
+    # - [:pending_connect_timeout] Connection not established within pending_connect_timeout value.
+    # - [exception] An exception.
+    #
+    # This method must be defined in the user's inherinted class.
+    def on_connection_error cause
+    end
+
+    # Called when TCP data is received in the socket.
+    #
+    # This method must be defined in the user's inherinted class.
+    def receive_data data
+    end
+
+    # Called when the connection is terminated by the peer (and it was
+    # already established) or when it is terminated locally (by calling
+    # disconnect so cause becomes _nil_).
+    #
+    # _cause_ can be:
+    # - [nil] Local disconnection via disconnect method.
+    # - [:remote_close] Remote normal close.
+    # - [exception] Some other cause.
+    #
+    # This method must be defined in the user's inherinted class.
+    def on_disconnected cause
+    end
+
+  end
+
+end

data/lib/em-ruby-sockets/tcp_connection.rb

@@ -0,0 +1,48 @@
+#$debug = true
+
+module EventMachine::RubySockets
+
+  module TcpConnection
+
+    # Access to the Ruby socket itself. A good place for socket settings is
+    # the post_init() method.
+    def io
+      @io
+    end
+
+    # Returns true if the socket has been closed or failed to connect.
+    def error?
+      @error
+    end
+
+    # Returns the number of bytes to be sent by the socket.
+    def get_outbound_data_size
+      @buffer.size
+    end
+
+    # Returns an array of [ port, ip ] with the local address used
+    # for this socket.
+    # It returns nil in case the socket has been closed or failed to connect.
+    def local_address
+      return nil  if @error
+      ::Socket.unpack_sockaddr_in @io.getsockname
+    end
+
+    # Returns an array of [ port, ip ] with the remote connected address.
+    # It returns nil in case the socket is not connected.
+    def remote_address
+      return nil  unless @connected
+      ::Socket.unpack_sockaddr_in @io.getpeername
+    end
+
+    # Streams the given _filename_ through this connection. It does not set callback or
+    # errback. For a more powerful usage create a EventMachine::RubySockets::FileStreamer
+    # instance.
+    def stream_file_data filename, args={}
+      EM::RubySockets::FileStreamer.new(self, filename, args).run
+    end
+    alias :send_file_data :stream_file_data
+
+  end
+
+end

data/lib/em-ruby-sockets/version.rb

@@ -0,0 +1,5 @@
+module EventMachine
+  module RubySockets
+    VERSION = "0.0.1"
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: em-ruby-sockets
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- "I\xC3\xB1aki Baz Castillo"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-14 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: kgio
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 7
+        - 4
+        version: 2.7.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: iobuffer
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 2
+        version: 1.1.2
+  type: :runtime
+  version_requirements: *id002
+description: em-ruby-sockets uses Ruby sockets within EventMachine::watch()
+email: ibc@aliax.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/em-ruby-sockets.rb
+- lib/em-ruby-sockets/version.rb
+- lib/em-ruby-sockets/errors.rb
+- lib/em-ruby-sockets/tcp_connection.rb
+- lib/em-ruby-sockets/tcp_client.rb
+has_rdoc: true
+homepage: https://github.com/ibc/em-ruby-sockets
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby sockets integrated within EventMachine
+test_files: []
+