easy_sockets 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6cda3ce2892a6052d57ed242708f762febe57481
+  data.tar.gz: fa52646d15d1aede1b25c6a612aab869c767d8da
+SHA512:
+  metadata.gz: 4160e8c1d10c54a8998c4d071de8b9f91215c157925814a36f5d097cf0804db2a1e76d58a5c6bb75117ed747d9735d2b4655873438686160a312b17684745e27
+  data.tar.gz: 3324c1006ccc13d583dce4d1aa6d037a94e7e8cacadc0d58aaf411ce8a73ceb88b0f642aadb25d1abaa803c9cafd5ced03b71a2d3aa1a97b41294c1ab59b70ac

data/.gitignore

@@ -0,0 +1,12 @@
+*.gem
+.ruby-version
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/test_logs/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,7 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.12.5
+notifications:
+  email: false

data/.yardopts

@@ -0,0 +1,6 @@
+--no-private
+--protected
+--markup="markdown" lib/**/*.rb
+--main README.md
+-M redcarpet
+--exclude (tcp_server.rb|unix_server.rb|server_utils.rb)

data/CHANGELOG.rb

@@ -0,0 +1,4 @@
+## 0.1.0 (2016-06-28)
+Features:
+    - EasySockets::TcpSocket now reads and writes in a non blocking way.
+    - Adding support to unix sockets.

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+    gem 'rspec'
+    gem "codeclimate-test-reporter", require: nil
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Marcos Ortiz
+
+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,280 @@
+# Easy Sockets
+
+[![Gem Version][GV img]][Gem Version]
+[![Build Status][BS img]][Build Status]
+[![Dependency Status][DS img]][Dependency Status]
+[![Code Climate][CC img]][Code Climate]
+[![Coverage Status][CS img]][Coverage Status]
+
+[Gem Version]: https://rubygems.org/gems/easy_sockets
+[Build Status]: https://travis-ci.org/marcosortiz/easy_sockets
+[Dependency Status]: https://gemnasium.com/marcosortiz/easy_sockets
+[Code Climate]: https://codeclimate.com/github/marcosortiz/easy_sockets
+[Coverage Status]: https://codeclimate.com/github/marcosortiz/easy_sockets/coverage
+
+[GV img]: https://badge.fury.io/rb/easy_sockets.svg
+[BS img]: https://travis-ci.org/marcosortiz/easy_sockets.svg?branch=master
+[DS img]: https://gemnasium.com/marcosortiz/easy_sockets.svg
+[CC img]: https://codeclimate.com/github/marcosortiz/easy_sockets/badges/gpa.svg
+[CS img]: https://codeclimate.com/github/marcosortiz/easy_sockets/badges/coverage.svg
+
+## Description
+
+Over and over I see developers struggling to implement basic sockets with featues available on ruby socket stdlib.
+
+easy_sockets, takes care of basic details that usually are overlooked by developers when implementing TCP/Unix sockets from scratch.
+
+I also strongly recommend [the following book](http://www.jstorimer.com/products/working-with-tcp-sockets) if you want to learn more about TCP sockets.
+
+> UDP socket support is comming soon.
+
+### Dependencies
+
+easy_sockets only uses the following ruby stdlib gems:
+
+- sockets
+- logger
+- timeout (just to raise Timeout::Error)
+
+### Transparent idempotent connect and disconnect operations
+
+You don't needneed to worry about connecting your socket (you can still call it if you want). All you need to do is call `send_msg`. If the socket object is not connected yet, it will automatically try to connect the socket before sending the message. You still need to disconnect your socket after using it.
+
+The `connect` and `disconnect` methods are idempotent methods. That means you can call them over and over again and they will only try to do something (connect and disconnect respectively) when the instance of your socket object is disconnected and connected respectively.
+
+The code bellow illustrates this:
+
+```ruby
+irb(main):001:0> require 'easy_sockets'
+=> true
+irb(main):002:0> s = EasySockets::TcpSocket.new
+=> #<EasySockets::TcpSocket:0x007fd16bb69308 @logger=nil, @timeout=0.5, @separator="\r\n", @connected=false, @port=2000, @host="127.0.0.1">
+irb(main):003:0> s.connected
+=> false
+irb(main):004:0> s.connect
+=> true
+irb(main):005:0> s.connected
+=> true
+irb(main):006:0> s.connect
+=> nil
+irb(main):007:0> s.connect
+=> nil
+irb(main):008:0> s.connected
+=> true
+irb(main):009:0> s.disconnect
+=> true
+irb(main):010:0> s.connected
+=> false
+irb(main):011:0> s.disconnect
+=> nil
+irb(main):012:0> s.disconnect
+=> nil
+```
+
+### Safe connect, read and write timeout implementation
+
+There is a lot of material on the internet saying [why you should not use ruby timeout stdlib](http://www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/). However, over and over I see developers using the timeout stdlib for production code!
+
+easy_sockets implements connect, read and write timeouts using [IO.select](http://ruby-doc.org/core-2.3.1/IO.html#method-c-select).
+
+### Framing Messages
+
+Usually, if you don't want to open and close a new connection everytime you need to send something to the server, you need to implement some sort of message framing. Openning (and closing) a new connection for each message, generates unnecessary overhead. While this might be ok for some communications where the messsage exchange rate is low, it might be a show stopper when this rate needs to be bigger.
+
+Message framing is an agreement between client and server on the message format. That way clients and server can signal that one message is ending and another on is beginning.
+
+There are numerous ways of framing messages. easy_sockets support 2:
+
+1. **Message separators:** When pass the `:separator` option when creating your socket, easy_sockets will add it to the end of the message. For instance, if you setup `separator: "\r\n"` and you call `send_msg("some_message")`, the server will receive `"some_message\r\n"`.
+
+2. **No separators**: When you pass the option `no_separator: true` when creating your socket, easy_sockets will not add anything to the end of the message. This is useful when both client and server uses a more specific protocol. For instance, both client and server know that the first 4 bytes of the message represent and little ending integer, and depending on the value of that integer, the message will have a specific size and format.
+
+Whether to use separators or not, is totally up to what both client and server expects.
+
+> If you decide to use new lines as the message separator, remember that it is `\n` on Unix systems but `\r\n` on Windows. So, be sure that both client and server are using the same separator.
+ 
+## Installation
+
+Add this line to your application's Gemfile:
+```ruby
+gem 'easy_sockets'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install easy_sockets
+
+## Usage
+
+Make sure you have netcat installed on your system. We will use it to emulate our servers.
+
+### TCP Sockets
+
+Open up a terminal window and type the following to start a TCP server:
+```bash
+nc -ckl 2500
+```
+
+On another terminal window, run the following [code](https://github.com/marcosortiz/easy_sockets/blob/master/examples/tcp_socket.rb) to start the client:
+```ruby
+require 'easy_sockets'
+
+host = ARGV[0] || '127.0.0.1'
+
+port = ARGV[1].to_i
+port = 2500 if port <= 0
+
+opts = {
+    host:      host,
+    port:      port,
+    timeout:   300,
+    separator: "\r\n",
+    logger: Logger.new(STDOUT),
+}
+s = EasySockets::TcpSocket.new(opts)
+[:INT, :QUIT, :TERM].each do |signal|
+    Signal.trap(signal) do
+        exit
+    end
+end
+
+loop do
+    puts "Please write the message you want to send and hit ENTER, or type Ctrl+c to quit:"
+    msg = gets.chomp
+    s.send_msg(msg)
+end
+```
+
+Then typing `sample_request` in the client terminal, you should see:
+```
+$ bundle exec ruby examples/tcp_socket.rb 
+Please write the message you want to send and hit ENTER, or type Ctrl+c to quit:
+sample_request
+D, [2016-06-30T15:17:39.648945 #90385] DEBUG -- : Successfully connected to tcp://127.0.0.1:2500.
+D, [2016-06-30T15:17:39.649044 #90385] DEBUG -- : Sending "sample_request\r\n"
+```
+
+And the server terminal window should display:
+```
+$ nc -ckl 2500
+sample_request
+
+```
+
+Then type `sample_response` on the server terminal window, and you should see:
+```
+$ nc -ckl 2500
+sample_request
+sample_response
+
+```
+
+And the client window should show:
+```
+$ bundle exec ruby examples/tcp_socket.rb 
+Please write the message you want to send and hit ENTER, or type Ctrl+c to quit:
+sample_request
+D, [2016-06-30T15:17:39.648945 #90385] DEBUG -- : Successfully connected to tcp://127.0.0.1:2500.
+D, [2016-06-30T15:17:39.649044 #90385] DEBUG -- : Sending "sample_request\r\n"
+D, [2016-06-30T15:19:52.494791 #90385] DEBUG -- : Got "sample_response\r\n"
+Please write the message you want to send and hit ENTER, or type Ctrl+c to quit:
+
+```
+
+Press `Ctrl+c` on the client and server terminal windows to terminate both.
+
+### Unix Sockets
+
+Open up a terminal window and type the following to start a Unix server:
+```bash
+nc -Ul /tmp/test_socket
+```
+
+On another terminal window, run the following [code](https://github.com/marcosortiz/easy_sockets/blob/master/examples/unix_socket.rb) to start the client:
+```ruby
+require 'easy_sockets'
+
+host = ARGV[0] || '127.0.0.1'
+
+socket_path = ARGV[1]
+socket_path ||= '/tmp/test_socket'
+
+opts = {
+    host:      host,
+    socket_path: socket_path,
+    timeout:   300,
+    separator: "\n",
+    logger: Logger.new(STDOUT),
+}
+s = EasySockets::UnixSocket.new(opts)
+[:INT, :QUIT, :TERM].each do |signal|
+    Signal.trap(signal) do
+        exit
+    end
+end
+
+loop do
+    puts "Please write the message you want to send and hit ENTER, or type Ctrl+c to quit:"
+    msg = gets.chomp
+    s.send_msg(msg)
+end
+```
+
+Then typing `sample_request` in the client terminal, you should see:
+```
+marcosortiz@~/dev/easy_sockets$ bundle exec ruby examples/unix_socket.rb 
+Please write the message you want to send and hit ENTER, or type Ctrl+c to quit:
+sample_request
+D, [2016-06-30T15:38:10.303188 #96993] DEBUG -- : Successfully connected to /tmp/test_socket.
+D, [2016-06-30T15:38:10.303265 #96993] DEBUG -- : Sending "sample_request\n"
+```
+
+And the server terminal window should display:
+```
+$ nc -Ul /tmp/test_socket
+sample_request
+
+```
+
+Then type `sample_response` on the server terminal window, and you should see:
+```
+$ nc -Ul /tmp/test_socket
+sample_request
+sample_response    
+
+```
+
+And the client window should show:
+```
+$ bundle exec ruby examples/unix_socket.rb 
+Please write the message you want to send and hit ENTER, or type Ctrl+c to quit:
+sample_request
+D, [2016-06-30T15:38:10.303188 #96993] DEBUG -- : Successfully connected to /tmp/test_socket.
+D, [2016-06-30T15:38:10.303265 #96993] DEBUG -- : Sending "sample_request\n"
+D, [2016-06-30T15:38:23.503411 #96993] DEBUG -- : "sample_response\n"
+D, [2016-06-30T15:38:23.503488 #96993] DEBUG -- : Got "sample_response\n"
+Please write the message you want to send and hit ENTER, or type Ctrl+c to quit:
+
+```
+
+Press `Ctrl+c` on the client and server terminal windows to terminate both. Also, type `rm -rf /tmp/test_socket` to remove the socket file.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## 5. Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/marcosortiz/easy_sockets.
+
+
+## 6. License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "easy_sockets"
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/easy_sockets.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'easy_sockets/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "easy_sockets"
+  spec.version       = EasySockets::VERSION
+  spec.authors       = ["Marcos Ortiz"]
+  spec.email         = ["marcos.ortiz@icloud.com"]
+
+  spec.summary       = %q{Wrapper around ruby socket stdlib to make developer's life easier'.}
+  spec.description   = %q{Over and over I see developers struggling to implement basic sockets with featues available on ruby socket stdlib. easy_sockets, takes care of basic details that usually are overlooked by developers when implementing TCP/Unix sockets from scratch.}
+  spec.homepage      = "https://github.com/marcosortiz/easy_sockets"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = 'http://rubygems.org'
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/examples/tcp_socket.rb

@@ -0,0 +1,26 @@
+require 'easy_sockets'
+
+host = ARGV[0] || '127.0.0.1'
+
+port = ARGV[1].to_i
+port = 2500 if port <= 0
+
+opts = {
+    host:      host,
+    port:      port,
+    timeout:   300,
+    separator: "\r\n",
+    logger: Logger.new(STDOUT),
+}
+s = EasySockets::UnixSocket.new(opts)
+[:INT, :QUIT, :TERM].each do |signal|
+    Signal.trap(signal) do
+        exit
+    end
+end
+
+loop do
+    puts "Please write the message you want to send and hit ENTER, or type Ctrl+c to quit:"
+    msg = gets.chomp
+    s.send_msg(msg)
+end

data/examples/unix_socket.rb

@@ -0,0 +1,26 @@
+require 'easy_sockets'
+
+host = ARGV[0] || '127.0.0.1'
+
+socket_path = ARGV[1]
+socket_path ||= '/tmp/test_socket'
+
+opts = {
+    host:      host,
+    socket_path: socket_path,
+    timeout:   300,
+    separator: "\n",
+    logger: Logger.new(STDOUT),
+}
+s = EasySockets::UnixSocket.new(opts)
+[:INT, :QUIT, :TERM].each do |signal|
+    Signal.trap(signal) do
+        exit
+    end
+end
+
+loop do
+    puts "Please write the message you want to send and hit ENTER, or type Ctrl+c to quit:"
+    msg = gets.chomp
+    s.send_msg(msg)
+end

data/lib/easy_sockets/basic_socket.rb

@@ -0,0 +1,154 @@
+require 'logger'
+require 'socket'
+require 'timeout'
+require 'easy_sockets/constants'
+require 'easy_sockets/utils'
+
+module EasySockets
+    #
+    # @author Marcos Ortiz
+    # @abstract Please check the following subclasses: {EasySockets::TcpSocket} and {EasySockets::UnixSocket}.
+    #
+    class BasicSocket
+        include EasySockets::Utils
+        
+        DEFAULT_TIMEOUT = 0.5
+        
+        attr_reader :logger, :connected
+        alias_method :connected?, :connected
+        
+        #
+        # @param [Hash] opts the options to create a socket with.
+        # @option opts [Logger] :logger (nil) An instance of Logger.
+        # @option opts [Float] :timeout (0.5) Timeout in seconds for socket connect, read and write operations.
+        # @option opts [String] :separator ("\r\n") Message separator.
+        # @option opts [Boolean] :no_msg_separator (nil) If true, the socket will not use message separators.
+        def initialize(opts={})
+            setup_opts(opts)
+            @connected = false
+        end
+        
+        #
+        # Connects to the server. This is an idempotent operation.
+        #
+        def connect
+            return if @connected && (@socket && !@socket.closed?)
+            on_connect
+            @connected = true
+        end
+
+        #
+        # Disconnects to the server. This is an idempotent operation.
+        #
+        def disconnect
+            return unless @connected
+            if @socket && !@socket.closed?
+                @socket.close 
+                log(:debug, "Socket successfully disconnected")
+                @connected = false
+                return true
+            end
+        end
+        
+        #
+        # Sends the message to the server, and reads and return the response if read_response=true.
+        # If you call this method and the socket is not connected yet, it will automatically connect the socket.
+        # @param [String] msg The message to send.
+        # @param [Boolean] read_response Whether or not to read from the server after sending the message. Defaul to true.
+        #
+        #
+        def send_msg(msg, read_response=true)
+            msg_to_send = msg.dup
+            msg_to_send << @separator unless @separator.nil? || msg.end_with?(@separator)
+
+            # This is an idempotent operation
+            connect
+
+            log(:debug, "Sending #{msg_to_send.inspect}")
+            send_non_block(msg_to_send)
+            
+            if read_response
+                resp = receive_non_block 
+                log(:debug, "Got #{resp.inspect}")
+                resp
+            end
+        # Raised by some IO operations when reaching the end of file. Many IO methods exist in two forms,
+        # one that returns nil when the end of file is reached, the other raises EOFError EOFError.
+        # EOFError is a subclass of IOError.
+        rescue EOFError => e
+            log(:info, "Server disconnected.")
+            self.disconnect
+            raise e
+        # "Connection reset by peer" is the TCP/IP equivalent of slamming the phone back on the hook.
+        # It's more polite than merely not replying, leaving one hanging.
+        # But it's not the FIN-ACK expected of the truly polite TCP/IP converseur.
+        rescue Errno::ECONNRESET => e
+            log(:info, 'Connection reset by peer.')
+            self.disconnect
+            raise e
+        rescue Errno::EPIPE => e
+            log(:info, 'Broken pipe.')
+            self.disconnect
+            raise e
+        rescue Errno::ECONNREFUSED => e
+                log(:info, 'Connection refused by peer.')
+                self.disconnect
+                raise e
+        rescue Exception => e
+            @socket.close if @socket && !@socket.closed?
+            raise e
+        end
+        
+        private
+        
+        def setup_opts(opts)
+            @logger = opts[:logger]
+            @timeout = opts[:timeout].to_f || DEFAULT_TIMEOUT
+            @timeout = DEFAULT_TIMEOUT if @timeout <= 0
+            @separator = opts[:separator] || CRLF
+            @separator = nil if opts[:no_msg_separator] == true
+        end
+        
+        def on_connect
+        end
+        
+        def send_non_block(msg)
+            begin
+                loop do
+                    bytes = @socket.write_nonblock(msg)
+                    break if bytes >= msg.size
+                    msg.slice!(0, bytes)
+                    IO.select(nil, [@socket])
+                end
+            rescue Errno::EAGAIN
+                IO.select(nil, [@socket])
+            end
+        end
+        
+        def receive_non_block
+            resp = ''
+            begin
+                resp << @socket.read_nonblock(CHUNK_SIZE)
+                while @separator && !resp.end_with?(@separator) do
+                    resp << @socket.read_nonblock(CHUNK_SIZE)
+                end
+                resp
+            rescue Errno::EAGAIN
+                if IO.select([@socket], nil, nil, @timeout)
+                    retry
+                else
+                    self.disconnect
+                    raise Timeout::Error, "No response in #{@timeout} seconds."
+                end
+            rescue EOFError => e
+                log(:info, "Server disconnected.")
+                self.disconnect
+                raise e
+            rescue Errno::EPIPE => e
+                log(:info, "Broken pipe.")
+                self.disconnect
+                raise e
+            end
+        end
+    end
+end

data/lib/easy_sockets/constants.rb

@@ -0,0 +1,8 @@
+module EasySockets
+    CR           = "\r"
+    LF           = "\n"
+    CRLF         = CR+LF
+    CHUNK_SIZE   = 1024 * 16
+    DEFAULT_HOST = '127.0.0.1'
+    DEFAULT_PORT = 2000
+end

data/lib/easy_sockets/tcp/tcp_server.rb

@@ -0,0 +1,83 @@
+require 'logger'
+require 'socket'
+require 'easy_sockets/constants'
+require 'easy_sockets/utils/server_utils'
+
+module EasySockets
+    #
+    # This class was created for testing purposes only. It should not be used
+    # in production.
+    #
+    class TcpServer
+        include EasySockets::ServerUtils
+
+        attr_reader :connections
+        
+        DEFAULT_TIMEOUT = 0.5 # seconds
+        
+        def initialize(opts={})
+            set_opts(opts)
+            @started = false
+            @stop_requested = false
+            @connections = []
+            register_shutdown_signals
+        end
+        
+        def start
+            return if @started
+            @started = true
+            @server = TCPServer.new(@port)
+            @logger.info "Listening on tcp://127.0.0.1:#{@port}"
+            loop do
+                shutdown if @stop_requested
+                connection = accept_non_block(@server)
+                @connections << connection
+                handle(connection)
+            end
+        end
+        
+        def stop
+            return unless @started
+            @stop_requested = true
+        end
+
+        private
+        
+        def set_opts(opts)
+            @port = opts[:port].to_i
+            @port = DEFAULT_PORT if @port <= 0
+            
+            @logger = opts[:logger] || Logger.new(STDOUT)
+            
+            @separator = opts[:separator]
+            @separator ||= EasySockets::CRLF
+            
+            @sleep_time = opts[:sleep_time].to_f
+            @sleep_time = 0.0001 if @sleep_time <= 0.0
+            
+            @timeout = opts[:timeout].to_f
+            @timeout = DEFAULT_TIMEOUT if @timeout <= 0.0
+        end
+        
+        def handle(connection)
+            loop do
+                shutdown if @stop_requested
+                begin
+                    msg = read_non_block(connection)
+                    next if msg.nil? || msg.empty?
+                    sleep @sleep_time
+                    write_non_block(connection, msg)
+                    if msg.chomp == 'simulate_crash'
+                        connection.close
+                        break
+                    end
+                rescue EOFError, Errno::ECONNRESET
+                    connection.close
+                    @logger.info 'Client disconnected.'
+                    break
+                end
+            end
+        end
+        
+    end
+end

data/lib/easy_sockets/tcp/tcp_socket.rb

@@ -0,0 +1,56 @@
+require 'easy_sockets/basic_socket'
+
+module EasySockets
+    #
+    # @author Marcos Ortiz
+    # Subclass of {EasySockets::BasicSocket} that implement a TCP socket.
+    #
+    class TcpSocket < EasySockets::BasicSocket
+        
+        #
+        # @param [Hash] opts the options to create a socket with.
+        # @option opts [Integer] :port (2000) The tcp port the server is running on.
+        # @option opts [String] :host ('127.0.0.1') The hostname or IP address the server is running on.
+        #
+        # It also accepts all options that {EasySockets::BasicSocket#initialize} accepts
+        def initialize(opts={})
+            super(opts)
+            
+            @port = opts[:port].to_i || '127.0.0.1'
+            @port = DEFAULT_PORT if @port <= 0
+            @host = opts[:host] || DEFAULT_HOST
+        end
+        
+        private
+        
+        def on_connect
+            @socket = Socket.new(:INET, :STREAM)
+            begin
+                # Initiate a nonblocking connection
+                remote_addr = Socket.pack_sockaddr_in(@port, @host)
+                @socket.connect_nonblock(remote_addr)
+
+                rescue Errno::EINPROGRESS
+                    # Indicates that the connect is in progress. We monitor the
+                    # socket for it to become writable, signaling that the connect
+                    # is completed.
+                    #
+                    # Once it retries the above block of code it
+                    # should fall through to the EISCONN rescue block and end up
+                    # outside this entire begin block where the socket can be used.
+                    if IO.select(nil, [@socket], nil, @timeout)
+                        retry
+                    else
+                        @socket.close if @socket && !@socket.closed?
+                        raise Timeout::Error.new("Timeout is set to #{@timeout} seconds.")
+                    end
+                rescue Errno::EISCONN
+                # Indicates that the connect is completed successfully.
+            end
+            log(:debug, "Successfully connected to tcp://#{@host}:#{@port}.")
+        rescue Exception => e
+            @socket.close if @socket && !@socket.closed?
+            raise e
+        end
+    end
+end

data/lib/easy_sockets/unix/unix_server.rb

@@ -0,0 +1,83 @@
+require 'logger'
+require 'socket'
+require 'easy_sockets/constants'
+require 'easy_sockets/utils/server_utils'
+
+module EasySockets
+    #
+    # This class was created for testing purposes only. It should not be used
+    # in production.
+    #
+    class UnixServer
+        include EasySockets::ServerUtils
+
+        attr_reader :connections
+        
+        DEFAULT_TIMEOUT = 0.5 # seconds
+        
+        def initialize(opts={})
+            set_opts(opts)
+            @started = false
+            @stop_requested = false
+            @connections = []
+            register_shutdown_signals
+        end
+        
+        def start
+            return if @started
+            @started = true
+            @server = UNIXServer.new(@socket_path)
+            @logger.info "Listening on #{@socket_path}"
+            loop do
+                shutdown if @stop_requested
+                connection = accept_non_block(@server)
+                @connections << connection
+                handle(connection)
+            end
+        end
+        
+        def stop
+            return unless @started
+            @stop_requested = true
+        end
+
+        private
+        
+        def set_opts(opts)
+            @socket_path = opts[:socket_path]
+            @socket_path ||= '/tmp/unix_server'
+            
+            @logger = opts[:logger] || Logger.new(STDOUT)
+            
+            @separator = opts[:separator]
+            @separator ||= EasySockets::CRLF
+            
+            @sleep_time = opts[:sleep_time].to_f
+            @sleep_time = 0.0001 if @sleep_time <= 0.0
+            
+            @timeout = opts[:timeout].to_f
+            @timeout = DEFAULT_TIMEOUT if @timeout <= 0.0
+        end
+        
+        def handle(connection)
+            loop do
+                shutdown if @stop_requested
+                begin
+                    msg = read_non_block(connection)
+                    next if msg.nil? || msg.empty?
+                    sleep @sleep_time
+                    write_non_block(connection, msg)
+                    if msg.chomp == 'simulate_crash'
+                        connection.close
+                        break
+                    end
+                rescue EOFError, Errno::ECONNRESET, Errno::EPIPE
+                    connection.close
+                    @logger.info 'Client disconnected.'
+                    break
+                end
+            end
+        end
+        
+    end
+end

data/lib/easy_sockets/unix/unix_socket.rb

@@ -0,0 +1,56 @@
+require 'easy_sockets/basic_socket'
+
+module EasySockets
+    #
+    # @author Marcos Ortiz
+    # Subclass of {EasySockets::BasicSocket} that implement a Unix socket.
+    #
+    class UnixSocket < EasySockets::BasicSocket
+        
+        DEFAULT_SOCKET_PATH = '/tmp/unix_socket'
+
+        #
+        # @param [Hash] opts the options to create a socket with.
+        # @option opts [Integer] :socket_path ('/tmp/unix_socket') The unix socket file path.
+        #
+        # It also accepts all options that {EasySockets::BasicSocket#initialize} accepts
+        def initialize(opts={})
+            super(opts)
+            @socket_path = opts[:socket_path] || DEFAULT_SOCKET_PATH
+        end
+        
+        private
+        
+        def on_connect
+            @socket = Socket.new(:UNIX, :STREAM)
+            begin
+                # Initiate a nonblocking connection
+                remote_addr = Socket.pack_sockaddr_un(@socket_path)
+                @socket.connect_nonblock(remote_addr)
+
+                rescue Errno::EINPROGRESS
+                    # Indicates that the connect is in progress. We monitor the
+                    # socket for it to become writable, signaling that the connect
+                    # is completed.
+                    #
+                    # Once it retries the above block of code it
+                    # should fall through to the EISCONN rescue block and end up
+                    # outside this entire begin block where the socket can be used.
+                    if IO.select(nil, [@socket], nil, @timeout)
+                        retry
+                    else
+                        @socket.close if @socket && !@socket.closed?
+                        raise Timeout::Error.new("Timeout is set to #{@timeout} seconds.")
+                    end
+                rescue Errno::EISCONN
+                # Indicates that the connect is completed successfully.
+            end
+            
+            log(:debug, "Successfully connected to #{@socket_path}.")
+        rescue Exception => e
+            @socket.close if @socket && !@socket.closed?
+            raise e
+        end
+    end
+
+end

data/lib/easy_sockets/utils/server_utils.rb

@@ -0,0 +1,69 @@
+module EasySockets
+    module ServerUtils
+        
+        def register_shutdown_signals
+            [:INT, :QUIT, :TERM].each do |signal|
+                Signal.trap(signal) do
+                    t = Thread.new do
+                        stop
+                    end
+                    t.join
+                end
+            end
+        end
+        
+        def accept_non_block(server)
+            begin
+                connection = server.accept_nonblock
+            rescue Errno::EAGAIN
+                shutdown if @stop_requested
+                retry
+            end
+        end
+        
+        def read_non_block(connection)
+            msg = ''
+            begin
+                msg << connection.read_nonblock(EasySockets::CHUNK_SIZE)
+                while !msg.end_with?(@separator) do
+                    msg << connection.read_nonblock(EasySockets::CHUNK_SIZE)
+                end
+            rescue Errno::EAGAIN
+                if IO.select([connection], nil, nil, @timeout)
+                    retry
+                end
+            end
+            @logger.info "Got: #{msg.inspect}" unless msg.nil? || msg.empty?
+            msg
+        end
+        
+        def write_non_block(connection, msg)
+            return 0 unless msg && msg.is_a?(String)
+            total_bytes = 0
+            begin
+                loop do
+                    bytes = connection.write_nonblock(msg)
+                    total_bytes += bytes
+                    break if bytes >= msg.size
+                    msg.slice!(0, bytes)
+                    IO.select(nil, [connection])
+                end
+                @logger.info "Sent: #{msg.inspect}"
+                total_bytes
+            rescue Errno::EAGAIN
+                IO.select(nil, [connection], nil, @timeout)
+            end
+        end
+        
+        def shutdown
+            if @stop_requested
+                @connections.each do |c|
+                    c.close
+                    @logger.info "Server shutting down: closed connection #{c}."
+                end
+                exit
+            end
+        end
+        
+    end
+end

data/lib/easy_sockets/utils.rb

@@ -0,0 +1,7 @@
+module EasySockets
+    module Utils
+        def log(level, msg)
+            logger.send(level, msg) unless logger.nil?
+        end
+    end
+end

data/lib/easy_sockets/version.rb

@@ -0,0 +1,3 @@
+module EasySockets
+  VERSION = "0.1.0"
+end

data/lib/easy_sockets.rb

@@ -0,0 +1,7 @@
+require "easy_sockets/version"
+require "easy_sockets/tcp/tcp_socket"
+require "easy_sockets/unix/unix_socket"
+
+module EasySockets
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: easy_sockets
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Marcos Ortiz
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Over and over I see developers struggling to implement basic sockets
+  with featues available on ruby socket stdlib. easy_sockets, takes care of basic
+  details that usually are overlooked by developers when implementing TCP/Unix sockets
+  from scratch.
+email:
+- marcos.ortiz@icloud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- CHANGELOG.rb
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- easy_sockets.gemspec
+- examples/tcp_socket.rb
+- examples/unix_socket.rb
+- lib/easy_sockets.rb
+- lib/easy_sockets/basic_socket.rb
+- lib/easy_sockets/constants.rb
+- lib/easy_sockets/tcp/tcp_server.rb
+- lib/easy_sockets/tcp/tcp_socket.rb
+- lib/easy_sockets/unix/unix_server.rb
+- lib/easy_sockets/unix/unix_socket.rb
+- lib/easy_sockets/utils.rb
+- lib/easy_sockets/utils/server_utils.rb
+- lib/easy_sockets/version.rb
+homepage: https://github.com/marcosortiz/easy_sockets
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Wrapper around ruby socket stdlib to make developer's life easier'.
+test_files: []