rxio 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e280e9488e6a0e8772dc1207a4f9ef2596a75800
+  data.tar.gz: a93e714f68bbf8b1a2b76d5eec9b0944489f8e2d
+SHA512:
+  metadata.gz: ab635aa9b48db9a6fd09d480982187f9ecc7b272d5a94b88c2dd89d5ae960e46c7fe00c55f48ffde01da744ca0c1147c1f615a937ac3558964b106f5ebe7e425
+  data.tar.gz: 06a5b6087190d7ab29e9273b7c651f2c91b09aa9e9cc51782b7c6eb4899ebd59fc68483c18f625a227e93df0fa14ff844da2016643139ed8fe38e2008490a827

data/.gitignore

@@ -0,0 +1,3 @@
+.idea
+Gemfile.lock
+pkg

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Paul Duncan
+
+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,237 @@
+# RxIO
+
+Reactive Sockets for Ruby
+
+## Presentation
+
+This library is an implementation of the [Reactor Pattern](https://en.wikipedia.org/wiki/Reactor_pattern) for Ruby Sockets.
+This allows easy development of fast, non-blocking services.
+
+## Installation
+
+### Gemfile
+```ruby
+gem 'rxio'
+```
+
+### Terminal
+```bash
+gem install -V rxio
+```
+
+## Usage
+
+A simple service is created by spawning an instance of the *RxIO::Service* class, passing a *Handler Module* as argument to its constructor and calling it's _run_ method.
+
+This will execute the service's main loop. The handler module provides the specific protocol implementation through a set of methods.
+
+The _run_ method is blocking and will only return after the service has terminated.
+
+A _stop_ method is also provided to request the service to terminate.
+
+### Running in the background
+
+While the _run_ / _stop_ methods offer a simple way to implement a single service within the current thread, some situations may require the wrapping of the service in a separate thread.
+
+A dedicated interface is provided for exactly this: _startup_ / _shutdown_
+
+#### *startup*
+
+Calling this method will spawn a new thread around the _run_ method, effectively starting the service in the 'background'.
+
+#### *shutdown*
+
+Calling _shutdown_ will request the service to terminate (via the _stop_ method) and wait for the thread to complete (join).
+Once this method returns, the service has completely terminated (thread dead, all clients disconnected).
+
+### Handler Interface
+
+The following is a list of methods that should be implemented by the handler module in order to provide a valid interface to the RxIO::Service class that will use it.
+
+#### *filter_input* _client_, _chunk_
+
+This method is called any time a chunk of data is received from a client.
+Its purpose is usually to filter protocol data and re-assemble messages.
+Complete messages can be enqueued for processing by pushing them into the *client[:msgs]* array.
+
+#### *handle_msg* _client_, _msg_
+
+Messages in the *client[:msgs]* array are regularly de-queued and passed to the *handle_msg* method for handling.
+This is usually the entry point to most of the service logic.
+
+#### (OPTIONAL) *on_join* _client_
+
+As soon as a client is registered by the service, it is passed as argument to the _on_join_ method of the handler module (if available).
+This allows the handler module to perform any necessary initialization tasks related to this client.
+
+#### (OPTIONAL) *on_drop* _client_
+
+Called by the service whenever a client is about to be disconnected (if available).
+This method should release any resources used by the client.
+
+#### (OPTIONAL) *send_msg* _client_, _msg_
+
+This method should wrap the message supplied as argument according to the desired protocol, and then add the result to the output buffer.
+While not actually required by the service class, this method should be considered a best-practice for users to encapsulate data according to a protocol.
+
+### Handler Base
+
+A base module is provided to facilitate implementation of new services and protocols.
+The *RxIO::HandlerBase* module should be extended by the service handler module.
+It provides two simple I/O methods:
+
+#### *write* _client_, _*data_
+
+Used to send one or more data chunks to a client.
+This method pushes the chunk(s) to the output buffer, to be later sent to the client.
+
+This method is *thread-safe* - while in most cases it will be called from within the main service loop (generally as a consequence of service logic in _handle_msg_), it is perfectly safe to call from any other thread. This can be useful in situations where a service might generate messages for the client _outside_ of the normal request-response cycle (such as an event-subscription service).
+
+Note: this method does not perform any encoding or transformation on the data. It is the user's responsibility to provide protocol encoding, usually through the _send_msg_ method.
+
+#### *buffer_input*, _client_, _chunk_
+
+Used to add a data chunk to the client's input buffer.
+
+### Provided Filters
+
+Some generic filters are provided as part of the *RxIO::IOFilters* module.
+These can be extended directly in a custom service handler module to provide immediate handling of a variety of protocol types.
+Most of the provided filters usually provide the _filter_input_ and _send_msg_ methods.
+
+#### Binary-Delimiter (BinDelim)
+
+The binary-delimiter filter is the simplest of all filters, splitting messages according to a fixed binary string.
+After extending the *RxIO::IOFilters::BinDelim* module, the _msg_delim_ method should be called with the desired binary string as argument.
+
+##### Example
+
+```ruby
+require 'rxio'
+
+# Custom Service 'Foo'
+class FooService < RxIO::Service
+
+	# Construct
+	def initialize addr, port
+		super addr, port, FooHandler
+	end
+
+	# Foo Service Handler Module
+	module FooHandler
+		
+		# Extend BinDelim I/O Filter
+		extend RxIO::IOFilters::BinDelim
+		
+		# Set Message Delimiter
+		msg_delim "\n"
+		
+		# ...
+	end
+end
+```
+
+#### Message-Size (MsgSize)
+
+the message-size filter is another very basic generic protocol filter, splitting messages according to a _4-byte unsigned big-endian integer_ *size* field, which prefixes every message and indicates its length in bytes.
+
+##### Example
+
+```ruby
+require 'rxio'
+
+# Custom Service 'Foo'
+class FooService < RxIO::Service
+
+	# Construct
+	def initialize addr, port
+		super addr, port, FooHandler
+	end
+
+	# Foo Service Handler Module
+	module FooHandler
+		
+		# Extend MsgSize I/O Filter
+		extend RxIO::IOFilters::MsgSize
+				
+		# ...
+	end
+end
+```
+
+## Examples
+
+### A simple echo service
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'rxio'
+
+# Echo Service Class
+class EchoService < RxIO::Service
+
+	# Defaults
+	DEFAULT_ADDR = '0.0.0.0'
+	DEFAULT_PORT = 4444
+
+	# Construct
+	def initialize
+		super DEFAULT_ADDR, DEFAULT_PORT, EchoHandler
+	end
+
+	# Echo Service Handler Module
+	module EchoHandler
+
+		# Extend BinDelim I/O Filter
+		extend RxIO::IOFilters::BinDelim
+
+		# Set Message Delimiter
+		msg_delim "\n"
+
+		# On Join
+		def self.on_join client
+			puts "Client connected: #{client[:peer][:name]}:#{client[:peer][:port]}"
+		end
+
+		# On Drop
+		def self.on_drop client
+			puts "Client dropped: #{client[:peer][:name]}:#{client[:peer][:port]}"
+		end
+
+		# Handle Message
+		def self.handle_msg client, msg
+			msg.chomp!				# Clean spurious \r
+			puts "Got message from client: #{client[:peer][:name]}:#{client[:peer][:port]} -> \"#{msg}\""
+			send_msg client, msg	# Echo message back to client
+		end
+	end
+end
+
+# Run the service
+es = EchoService.new
+es.run
+```
+
+### Running a service in the background
+
+```ruby
+# ...
+
+# Run the service in the background
+puts 'Service is starting up...'
+es = EchoService.new
+es.startup
+puts 'Service is online!'
+
+# Do something while the service is running...
+
+# Shutdown the service
+es.shutdown
+puts 'Service has terminated!'
+
+```
+
+## 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,8 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+task :default => :spec
+
+Rake::TestTask.new do |t|
+	t.libs << 'test'
+end

data/lib/rxio/handler_base.rb

@@ -0,0 +1,31 @@
+# RxIO
+# by Eresse <eresse@eresse.net>
+
+# RxIO Module
+module RxIO
+
+	# Handler Base Module
+	# Provides common abstractions to Service Handler implementations.
+	module HandlerBase
+
+		# Write
+		# Writes one or more chunks of data to the client's output buffer (:obuf).
+		# @param [Hash] client
+		# @param [String] data One or more chunks of data to be written to the ouput buffer
+		def write client, *data
+
+			# Add Data Chunks to Buffer
+			data.each { |c| client[:lock].synchronize { client[:obuf] << c } }
+		end
+
+		# Buffer Input Chunk
+		# Writes a chunk of data to the client's input buffer (:ibuf).
+		# @param [Hash] client
+		# @param [String] chunk
+		def buffer_input client, chunk
+
+			# Buffer Chunk
+			client[:ibuf] << chunk
+		end
+	end
+end

data/lib/rxio/io_filters/bin_delim.rb

@@ -0,0 +1,70 @@
+# RxIO
+# by Eresse <eresse@eresse.net>
+
+# Internal Includes
+require 'rxio/handler_base'
+
+# RxIO Module
+module RxIO
+
+	# I/O Filters Module
+	module IOFilters
+
+		# Binary-Delimiter I/O Filter
+		# Splits messages according to a given fixed *binary delimiter*, which can be any number of bytes, defined through the _msg_delim_ method.
+		module BinDelim
+
+			# Inject Dependencies into Extending Module
+			# @param [Module] base
+			def self.extended base
+				base.extend RxIO::HandlerBase
+			end
+
+			# Set Message Delimiter
+			# Used to define the binary string used as message delimiter for this protocol.
+			# @param [String] v The message delimiter string
+			def msg_delim v
+				@msg_delim = v
+			end
+
+			# Filter Input
+			# Buffers data chunks sent by the client and extracts messages from them, according to the delimiter defined through _msg_delim_.
+			# @param [Hash] client
+			# @param [String] chunk
+			def filter_input client, chunk
+
+				# Buffer dat shit
+				buffer_input client, chunk
+
+				# Ensure Last Position is available
+				client[:bin_delim][:last_pos] ||= 0
+
+				# Loop over Messages
+				while true
+
+					# Find Delimiter
+					d = client[:ibuf].index @msg_delim, client[:bin_delim][:last_pos]
+					client[:bin_delim][:last_pos] = client[:ibuf].bytesize
+
+					# Check Delimiter
+					break unless d
+
+					# Slice out Message from Input Buffer
+					m = client[:ibuf].slice!(0, d + @msg_delim.bytesize).slice 0, d
+					client[:bin_delim][:last_pos] = 0
+
+					# Register Message
+					client[:msgs] << m
+				end
+			end
+
+			# Send Message
+			# Buffers a message to be sent to the client, after wrapping it according to the delimiter defined through _msg_delim_.
+			# @param [Hash] client
+			# @param [String] msg
+			def send_msg client, msg
+				write client, msg, @msg_delim
+			end
+		end
+	end
+end

data/lib/rxio/io_filters/msg_size.rb

@@ -0,0 +1,61 @@
+# RxIO
+# by Eresse <eresse@eresse.net>
+
+# Internal Includes
+require 'rxio/handler_base'
+
+# RxIO Module
+module RxIO
+
+	# I/O Filters Module
+	module IOFilters
+
+		# Message-Size I/O Filter
+		# Splits messages according to a _4-byte unsigned big-endian integer_ *size* field, which prefixes every message and indicates its length in bytes.
+		module MsgSize
+
+			# Inject Dependencies into Extending Module
+			# @param [Module] base
+			def self.extended base
+				base.extend RxIO::HandlerBase
+			end
+
+			# Filter Input
+			# Buffers data chunks sent by the client and extracts messages from them, according to the *size* field present at the beginning of each message.
+			# @param [Hash] client
+			# @param [String] chunk
+			def filter_input client, chunk
+
+				# Buffer dat shit
+				buffer_input client, chunk
+
+				# Loop over Messages
+				while true
+
+					# Check Buffer Size (can we at least determine the next message size?)
+					break unless client[:ibuf].bytesize >= 4
+
+					# Acquire Message Size
+					size = client[:ibuf][0, 4].unpack 'N'
+
+					# Check Buffer Size again (is the complete message present in the buffer?)
+					break unless client[:ibuf].bytesize >= 4 + size
+
+					# Slice out Message from Input Buffer
+					m = client[:ibuf].slice!(0, 4 + size)[4, size]
+
+					# Register Message
+					client[:msgs] << m
+				end
+			end
+
+			# Send Message
+			# Buffers a message to be sent to the client, after prefixing it with a _size_ field.
+			# @param [Hash] client
+			# @param [String] msg
+			def send_msg client, msg
+				write client, [msg.bytesize].pack('N'), msg
+			end
+		end
+	end
+end

data/lib/rxio/io_filters.rb

@@ -0,0 +1,14 @@
+# RxIO
+# by Eresse <eresse@eresse.net>
+
+# Internal Includes
+require 'rxio/io_filters/bin_delim'
+
+# RxIO Module
+module RxIO
+
+	# I/O Filters Module
+	# This module provides a set of generic I/O Filters to be used for constructing services.
+	module IOFilters
+	end
+end

data/lib/rxio/service.rb

@@ -0,0 +1,232 @@
+# RxIO
+# by Eresse <eresse@eresse.net>
+
+# External Includes
+require 'thread'
+require 'socket'
+
+# RxIO Module
+module RxIO
+
+	# Service Class
+	class Service
+
+		# Chunk Size
+		CHUNK_SIZE = 1024
+
+		# Construct
+		# Builds a *Service* around a given _service_handler_ module, set to listen for incoming connections @ _addr_ on _port_.
+		# @param [String] addr
+		# @param [Fixnum] port
+		# @param [Module] service_handler
+		def initialize addr, port, service_handler
+
+			# Set Address & Port
+			@addr = addr
+			@port = port
+
+			# Set Service Handler Module
+			@service_handler = service_handler
+
+			# Create Sockets
+			@socks = []
+
+			# Create Clients
+			@clients = []
+
+			# Create Client Map
+			@cmap = {}
+		end
+
+		# Start up
+		# Spawns a new Thread around the _run_ method to execute the service in the background.
+		def startup
+			@thread = Thread.new { run }
+		end
+
+		# Shutdown
+		# Gracefully terminates the service, waiting for all resources to be released (returns once the service thread has completed).
+		def shutdown
+			@stop = true
+			@thread.join
+			@thread = nil
+		end
+
+		# Run
+		# Executes the main service loop, taking care of I/O scheduling, client management and message handling.
+		# Note: this method blocks until the service loop terminates.
+		def run
+
+			# Update Loop
+			begin
+
+				# Create TCP Socket Server
+				@serv = TCPServer.new @addr, @port
+				@socks << @serv
+
+				# Update Service
+				update until @stop
+			rescue Exception => e
+				puts "[!] ERROR - RxIO Service Update failed - #{e.inspect}"
+				e.backtrace.each { |b| puts "    - #{b}" }
+			end
+
+			# Drop all Clients
+			@service_handler.on_drop @clients.pop until @clients.empty?
+			@cmap = {}
+
+			# Close all Sockets
+			@socks.each { |s| s.close }
+			@socks = []
+
+			# Drop Server
+			@serv = nil
+		end
+
+		# Stop
+		# Requests the service loop to stop executing.
+		# The _run_ method should return shortly after calling _stop_
+		def stop
+			@stop = true
+		end
+
+		# Privates
+		private
+
+		# Update
+		# Serves as the service loop main method, performing I/O scheduling, client management and message handling.
+		def update
+
+			# Collect Sockets with Output
+			ws = @clients.reject { |c| c[:lock].synchronize { c[:obuf].empty? } }.collect { |c| c[:sock] }
+
+			# Select Sockets
+			rd, wr = IO.select @socks, ws
+
+			# Handle I/O
+			rd.each { |s| s == @serv ? acpt_sock(s) : read_sock(s) }
+			wr.each { |s| write_sock s }
+		end
+
+		# Process Input
+		# Processes Input from a client, in the form of a data chunk
+		# @param [Hash] client
+		# @param [String] chunk A chunk of data, as received by the socket
+		def process_input client, chunk
+
+			# Pass through Service Handler Module
+			@service_handler.filter_input client, chunk
+
+			# Process Messages
+			@service_handler.handle_msg client, client[:msgs].shift until client[:msgs].empty?
+		end
+
+		# Register Client
+		# Creates a new Client around a given socket _s_ and registers it.
+		# Also, notifies the Handler Module if the _on_join_ method is available.
+		# @param [TCPSocket] s
+		def add_client s
+
+			# Register Socket
+			@socks << s
+
+			# Acquire Peer Address
+			peer = s.peeraddr
+
+			# Create Client
+			c = {
+				sock: s,
+				peer: {
+					port: peer[1],
+					name: peer[2],
+					addr: peer[3]
+				},
+				ibuf: '',
+				obuf: '',
+				lock: Mutex.new,
+			    msgs: []
+			}
+
+			# Register Client
+			@clients << c
+
+			# Map Client
+			@cmap[s] = c
+
+			# Notify Service Handler
+			@service_handler.on_join c if @service_handler.respond_to? :on_join
+		end
+
+		# Drop Client
+		# Unregisters a Client and closes the associated socket.
+		# Also, notifies the Handler Module if the _on_drop_ method is available.
+		# @param [Hash] c
+		def drop_client c
+
+			# Notify Service Handler
+			@service_handler.on_drop c if @service_handler.respond_to? :on_drop
+
+			# Drop Client
+			@cmap.delete c[:sock]
+			@socks.delete c[:sock]
+			@clients.delete c
+
+			# Kill Socket
+			c[:sock].close rescue nil
+		end
+
+		# Accept Socket
+		# Tries to accept any queued connection request in a non-blocking manner.
+		# Registers a new Client through _add_client_ around the newly-accepted socket if present.
+		# @param [TCPServer] s
+		def acpt_sock s
+
+			# Accept
+			ns = s.accept_nonblock
+
+			# Register Client
+			add_client ns if ns
+		end
+
+		# Read Socket
+		# Attempts to read as many bytes as possible (up to CHUNK_SIZE) from a given socket _s_, passing the data chunks to _process_input_.
+		# @param [TCPSocket] s
+		def read_sock s
+
+			# Acquire Client
+			c = @cmap[s]
+
+			# Check Client
+			return unless c
+
+			# Read Chunk from Socket
+			chunk = s.read_nonblock CHUNK_SIZE rescue nil
+
+			# Drop Client & Abort on Error
+			return drop_client c unless chunk
+
+			# Process Input
+			process_input c, chunk
+		end
+
+		# Write Socket
+		# Attempts to write as many bytes as possible to a given socket _s_ from the associated client's output buffer.
+		# @param [TCPSocket] s
+		def write_sock s
+
+			# Acquire Client
+			c = @cmap[s]
+
+			# Check Client
+			return unless c
+
+			# Synchronize Client
+			c[:lock].synchronize do
+
+				# Write as much as possible
+				size = s.write_nonblock c[:obuf]
+				c[:obuf].slice! 0, size if size > 0
+			end
+		end
+	end
+end

data/lib/rxio/version.rb

@@ -0,0 +1,9 @@
+# RxIO
+# by Eresse <eresse@eresse.net>
+
+# RxIO Module
+module RxIO
+
+	# Version
+	VERSION = '0.10.0'
+end

data/lib/rxio.rb

@@ -0,0 +1,13 @@
+# RxIO
+# by Eresse <eresse@eresse.net>
+
+# Internal Includes
+require 'rxio/version'
+require 'rxio/service'
+require 'rxio/handler_base'
+require 'rxio/io_filters'
+
+# RxIO Module
+# Root Module for RxIO
+module RxIO
+end

data/rxio.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rxio/version'
+
+Gem::Specification.new do |spec|
+	spec.name = 'rxio'
+	spec.version = RxIO::VERSION
+	spec.authors = ['Eresse']
+	spec.email = ['eresse@eresse.net']
+
+	spec.summary = 'Reactive Sockets for Ruby'
+	spec.description = 'Provides an implementation of the Reactor Pattern for Ruby Sockets.'
+	spec.homepage = 'http://redmine.eresse.net/projects/rxio'
+	spec.license = 'MIT'
+
+	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'
+	spec.add_development_dependency 'rake'
+	spec.add_runtime_dependency 'minitest'
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: rxio
+version: !ruby/object:Gem::Version
+  version: 0.10.0
+platform: ruby
+authors:
+- Eresse
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-01-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides an implementation of the Reactor Pattern for Ruby Sockets.
+email:
+- eresse@eresse.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rxio.rb
+- lib/rxio/handler_base.rb
+- lib/rxio/io_filters.rb
+- lib/rxio/io_filters/bin_delim.rb
+- lib/rxio/io_filters/msg_size.rb
+- lib/rxio/service.rb
+- lib/rxio/version.rb
+- rxio.gemspec
+homepage: http://redmine.eresse.net/projects/rxio
+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.6.10
+signing_key: 
+specification_version: 4
+summary: Reactive Sockets for Ruby
+test_files: []