deepstream 0.3.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6a195b77c67902febe4748081ede0bf486630065
-  data.tar.gz: 8663b916c19058e8f74b14d329bf391f5b33bfc1
+SHA256:
+  metadata.gz: a8cafac8651bd0cb90746e47c290919eb51acb2058e24fd345759ffa0a459996
+  data.tar.gz: 29d4d74d4e417afd703e0ad190b138b7145cf8699cd5bb1c90ca0d006b95b83a
 SHA512:
-  metadata.gz: 6a7a86d7cdca2170457a2ce25e73f71d2380106728a69ab0840521dc8900b30820afe2032e6341291f38342953f26c7a3ef9b6076d123fed68c0e95e9711faab
-  data.tar.gz: 8c30325353d28fac3dbf8f7ab4d4cc361d454f6628f0758efd5796f7bb20b5a0ad693b084c4f5c9168c1221263652fb496e2b5879115f31d71fb520ac491a2c2
+  metadata.gz: f6f1f0bec2528e8fc4694b3febf05a036551fed454277bb3e9d655453805d4e938d51d6bc2a6765ee254739c36d7d6634c03f599659dad25c08ee3907085bafc
+  data.tar.gz: 968a2b71039dda4367e1152acb96f5ff164c5c14f4736774ee408cc7daa8c32f3d7661473f1eb63f9f745e5e7bd1cd024a2917a6f2281662a7e39251d5444e79

data/README.md

@@ -1,6 +1,7 @@
 # deepstream-ruby
 
 deepstream.io ruby client
+deepstream version >5 needed
 
 [![Gem Version](https://badge.fury.io/rb/deepstream.svg)](http://badge.fury.io/rb/deepstream)
 [![Gem License](https://img.shields.io/badge/license-Apache-blue.svg)](https://github.com/Currency-One/deepstream-ruby/blob/master/LICENSE)
@@ -19,19 +20,16 @@ ds = Deepstream::Client.new('localhost')
 # or
 ds = Deepstream::Client.new('ws://localhost:6020')
 # or
-ds = Deepstream::Client.new('ws://localhost:6020/deepstream',
+ds = Deepstream::Client.new('ws://localhost:6020/deepstream-v3',
   ack_timeout: nil, # ACK timeout; if nil, then the client never checks ACK timeout errors
-  autologin: false, # authorise the client when a Websocket connection is initialized; you don't need to call login() then
   credentials: { username: 'John', password: 'Doe' }, # credentials used to authorise the client
   heartbeat_interval: nil # when two server heartbeats are missed the client considers the connection to be lost
-  max_reconnect_attempts: nil,
-  max_reconnect_interval: 30, # seconds
-  reconnect_interval: 1, # seconds, the final interval is a lower number from (reconnect_interval * failed_attempts, max_reconnect_interval)
   emit_timeout: 0, # if 0, then events that failed to be emitted are thrown away
                    # if nil, then events are stored in a buffer, waiting for reconnection
                    # if another number, then events are stored in a buffer and sent if the client reconnects in emit_timeout seconds
   verbose: false, # show verbose information about connection, incoming and outgoing messages etc.
-  debug: false # use for testing only; if true, any exception will terminate the client
+  debug: false, # use for testing only; if true, any exception will terminate the client
+  in_thread: true # if true, putting client in separated thread
   )
 # log in to the server
 ds.login
@@ -84,8 +82,13 @@ foo.all
 ```
 
 
-### Development
+## Development
 
 ```bash
 git submodule update --init --recursive
-```
+```
+
+
+## To Do
+
+Adjust tests, to work with new version (without celluloid)

data/deepstream.gemspec

@@ -4,9 +4,9 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "deepstream"
-  spec.version       = "0.3.1"
+  spec.version       = "1.0.3"
   spec.authors       = ["Currency-One S.A."]
-  spec.email         = ["piotr.szczudlak@currency-one.com"]
+  spec.email         = ["ruby@currency-one.com"]
 
   spec.summary       = %q{deepstream.io ruby client}
   spec.description   = %q{Basic ruby client for the deepstream.io server}
@@ -19,7 +19,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.required_ruby_version = '>= 2.3.0'
   spec.license       = "Apache-2.0"
-  spec.add_runtime_dependency 'celluloid-websocket-client', '~> 0'
+  spec.add_runtime_dependency 'async', '~> 1.25.0'
+  spec.add_runtime_dependency 'async-io', '~> 1.29.0'
+  spec.add_runtime_dependency 'async-http', '~> 0.52.1'
+  spec.add_runtime_dependency 'async-websocket', '~> 0.14.0'
   spec.add_development_dependency 'cucumber'
   spec.add_development_dependency 'reel'
   spec.add_development_dependency 'pry'

data/lib/deepstream.rb

@@ -11,4 +11,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'deepstream/client'
+require_relative './deepstream/client'

data/lib/deepstream/ack_timeout_registry.rb

@@ -7,11 +7,15 @@ module Deepstream
 
     def add(name, message)
       return unless (timeout = @client.options[:ack_timeout])
-      @timeouts[name] = Celluloid.after(timeout) { @client.on_error(message) }
+      @timeouts[name] = Thread.new do
+        sleep timeout
+        @client.on_error(message)
+      end
     end
 
     def cancel(name)
-      @timeouts.delete(name)&.cancel
+      @timeouts[name].exit rescue nil
+      @timeouts.delete(name)
     end
   end
 end

data/lib/deepstream/async_patch.rb

@@ -0,0 +1,57 @@
+module Async
+  module WebSocket
+    class Client < ::Protocol::HTTP::Middleware
+      include ::Protocol::WebSocket::Headers
+
+      def self.open(endpoint, *args, &block)
+        client = self.new(HTTP::Client.new(endpoint, *args), mask: true)
+
+        return client unless block_given?
+
+        begin
+          yield client
+        ensure
+          client.close
+        end
+      end
+
+      def self.connect(endpoint, *args, **options, &block)
+        self.open(endpoint, *args) do |client|
+          connection = client.connect(endpoint.path, **options)
+
+          return connection unless block_given?
+
+          begin
+            yield connection
+          ensure
+            connection.close
+          end
+        rescue
+          puts "cant connect to #{endpoint}"
+        end
+      end
+    end
+
+    class Connection < ::Protocol::WebSocket::Connection
+
+      def write(object)
+        super(object)
+      end
+
+      def parse(buffer)
+        buffer
+      end
+    end
+  end
+end
+
+module Protocol
+  module WebSocket
+    class TextFrame
+
+      def unpack
+        encoded_readed_string = super.encode(Encoding::UTF_8)
+      end
+    end
+  end
+end

data/lib/deepstream/client.rb

@@ -1,23 +1,24 @@
 require 'forwardable'
-require 'celluloid/websocket/client'
-require 'deepstream/constants'
-require 'deepstream/error_handler'
-require 'deepstream/event_handler'
-require 'deepstream/record_handler'
-require 'deepstream/helpers'
-require 'deepstream/message'
-require 'deepstream/exceptions'
+require 'async'
+require 'async/io/stream'
+require 'async/http/endpoint'
+require 'async/websocket/client'
+require 'async/logger'
+require_relative './constants'
+require_relative './error_handler'
+require_relative './event_handler'
+require_relative './record_handler'
+require_relative './helpers'
+require_relative './message'
+require_relative './exceptions'
+require_relative './async_patch'
 
 module Deepstream
   class Client
     attr_reader :options, :state
 
-    include Celluloid
-    include Celluloid::Internals::Logger
     extend Forwardable
 
-    execute_block_on_receiver :on, :subscribe, :listen
-
     def_delegators :@event_handler, :on, :emit, :subscribe, :unsubscribe, :listen, :resubscribe, :unlisten
     def_delegators :@error_handler, :error, :on_error, :on_exception
     def_delegators :@record_handler, :get, :get_record, :set, :delete, :discard, :get_list
@@ -30,23 +31,22 @@ module Deepstream
       @options = Helpers.default_options.merge!(options)
       @message_buffer = []
       @last_hearbeat = nil
-      @challenge_denied, @login_requested, @deliberate_close = false
-      @failed_reconnect_attempts = 0
+      @challenge_denied, @@deliberate_close = false
       @state = CONNECTION_STATE::CLOSED
-      Celluloid.logger.level = @options[:verbose] ? LOG_LEVEL::INFO : LOG_LEVEL::OFF
+      @verbose = @options[:verbose]
+      @log = Async.logger
+      @never_connected_before = true
       connect
     end
 
     def on_open
-      info("Websocket connection opened")
+      @log.info "Websocket connection opened" if @verbose
       @state = CONNECTION_STATE::AWAITING_CONNECTION
-      @connection_requested, @deliberate_close = false
-      @failed_reconnect_attempts = 0
     end
 
     def on_message(data)
       message = Message.new(data)
-      info("Incoming message: #{message.inspect}")
+      @log.info "Receiving msg = #{message.inspect}" if @verbose
       case message.topic
       when TOPIC::AUTH       then authentication_message(message)
       when TOPIC::CONNECTION then connection_message(message)
@@ -54,30 +54,19 @@ module Deepstream
       when TOPIC::ERROR      then @error_handler.on_error(message)
       when TOPIC::RECORD     then @record_handler.on_message(message)
       when TOPIC::RPC        then raise(UnknownTopic, 'RPC is currently not implemented.')
+      when nil               then nil
       else raise(UnknownTopic, message)
       end
     rescue => e
       on_exception(e)
     end
 
-    def on_close(code, reason)
-      info("Websocket connection closed: code - #{code.inspect}, reason - #{reason.inspect}")
-      @state = CONNECTION_STATE::CLOSED
-      reconnect unless @deliberate_close
-    rescue => e
-      on_exception(e)
-    end
-
     def login(credentials = @options[:credentials])
-      @login_requested = true
       @options[:credentials] = credentials
       if @challenge_denied
         on_error("this client's connection was closed")
-      elsif !connected?
-        async.connect
       elsif @state == CONNECTION_STATE::AUTHENTICATING
-        @login_requested = false
-        send_message(TOPIC::AUTH, ACTION::REQUEST, @options[:credentials].to_json)
+        send_message(TOPIC::AUTH, ACTION::REQUEST, @options[:credentials].to_json, priority: true)
       end
       self
     rescue => e
@@ -87,14 +76,19 @@ module Deepstream
 
     def close
       return unless connected?
-      @state = CONNECTION_STATE::CLOSED
       @deliberate_close = true
-      @connection.close
-      @connection.terminate
+      log.info 'deliberate closing' if @verbose
     rescue => e
       on_exception(e)
     end
 
+    def reconnect
+      return if connected?
+      @deliberate_close = false
+      @state = CONNECTION_STATE::RECONNECTING
+      @log.info 'Reconnecting' if @verbose
+    end
+
     def connected?
       @state != CONNECTION_STATE::CLOSED
     end
@@ -111,26 +105,27 @@ module Deepstream
       "#{self.class} #{@url} | connection state: #{@state}"
     end
 
-    def send_message(*args)
+    def send_message(*args, **kwargs)
       message = Message.parse(*args)
-      return unable_to_send_message(message) if !logged_in? && message.needs_authentication?
-      info("Sending message: #{message.inspect}")
-      @connection.text(message.to_s)
+      priority = kwargs[:priority] || false
+      timeout = message.topic == TOPIC::EVENT ? kwargs[:timeout] : nil
+      message.set_timeout(timeout) if timeout
+      return unable_to_send_message(message, priority) if !logged_in? && message.needs_authentication?
+      priority ? @message_buffer.unshift(message) : @message_buffer.push(message)
     rescue Errno::EPIPE
-      unable_to_send_message(message)
+      unable_to_send_message(message, priority)
     rescue => e
       on_exception(e)
     end
 
     private
 
-    def unable_to_send_message(message)
+    def unable_to_send_message(message, priority)
       @state = CONNECTION_STATE::CLOSED if logged_in?
       unless message.expired?
-        info("Placing a message #{message.inspect} in the buffer, waiting for authentication")
-        @message_buffer << message
+       @log.info("Placing a message #{message.inspect} in the buffer, waiting for authentication") if @verbose
+       priority ? @message_buffer.unshift(message) : @message_buffer.push(message)
       end
-      async.reconnect if !connected? && !@connection_requested
     end
 
     def connection_message(message)
@@ -160,7 +155,9 @@ module Deepstream
 
     def on_connection_ack
       @state = CONNECTION_STATE::AUTHENTICATING
-      login if @options[:autologin] || @login_requested
+      @message_buffer.delete_if { |msg| msg.action == ACTION::PATCH }
+      @record_handler.reinitialize unless @never_connected_before
+      login
     end
 
     def on_ping
@@ -169,15 +166,22 @@ module Deepstream
     end
 
     def on_login
+      @never_connected_before = false
       @state = CONNECTION_STATE::OPEN
-      @message_buffer.each { |message| send_message(message) unless message.expired? }.clear
       every(@options[:heartbeat_interval]) { check_heartbeat } if @options[:heartbeat_interval]
       resubscribe
     end
 
     def on_rejection
       @challenge_denied = true
-      close
+      on_close
+    end
+
+    def on_close
+      @log.info 'Websocket connection closed' if @verbose
+      @state = CONNECTION_STATE::CLOSED
+    rescue => e
+      on_exception(e)
     end
 
     def check_heartbeat
@@ -187,46 +191,64 @@ module Deepstream
     end
 
     def on_redirection(message)
-      close
-      connect(message.data.last)
+      on_close
+      @url = message.data.last
     end
 
-    def connect(url = @url, reraise = false, force = false)
-      return if @connection_requested && !force
-      info("Trying to connect to #{url}.")
-      @connection_requested = true
-      @connection = Celluloid::WebSocket::Client.new(url, Actor.current)
-    rescue => e
-      @connection_requested = false
-      reraise ? raise : on_exception(e)
+    def connect(in_thread = @options[:in_thread])
+      if in_thread
+        Thread.start { connection_loop }
+      else
+        connection_loop
+      end
     end
 
-    def reconnect
-      info("Trying to reconnect to #{@url}")
-      if @options[:max_reconnect_attempts].nil? || @failed_reconnect_attempts < @options[:max_reconnect_attempts]
-        @state = CONNECTION_STATE::RECONNECTING
-        @login_requested = true
-        connect(@url, true, true)
-        sleep(5)
-        if !logged_in?
-          close
-          reconnect
+    def connection_loop
+      Async do |task|
+        @task = task
+        loop do
+          if @deliberate_close
+            sleep 5
+            next
+          end
+          _connect
+          sleep 5
         end
-      else
-        @state = CONNECTION_STATE::ERROR
       end
-    rescue Errno::ECONNREFUSED, Errno::ECONNRESET
-      @failed_reconnect_attempts += 1
-      on_error("Can't connect! Deepstream server unreachable on #{@url}")
-      info("Can't connect. Next attempt in #{reconnect_interval} seconds.")
-      sleep(reconnect_interval)
-      retry
-    rescue => e
-      on_exception(e)
     end
 
-    def reconnect_interval
-      [@options[:reconnect_interval] * @failed_reconnect_attempts, @options[:max_reconnect_interval]].min
+    def _connect(url = @url)
+      @log.info "Trying to connect to #{url}" if @verbose
+      endpoint = Async::HTTP::Endpoint.parse(url)
+      Async::WebSocket::Client.connect(endpoint) do |connection|
+        on_open
+        @task.async do
+          loop do
+            break if ( connection.closed? || @deliberate_close )
+            while !@message_buffer.empty? && (logged_in? || !@message_buffer[0].needs_authentication?)
+              msg = @message_buffer.shift
+              next if msg.expired?
+              encoded_msg = msg.to_s.encode(Encoding::UTF_8)
+              @log.info "Sending msg = #{msg.inspect}" if @verbose
+              connection.write(encoded_msg)
+              connection.flush rescue @message_buffer.unshift(msg)
+            end
+            @task.sleep 0.001
+          end
+        end
+
+        loop do
+          on_message(connection.read)
+          break if ( connection.closed? || @deliberate_close )
+        end
+
+      rescue => e
+        @log.error "Connection error #{e.message}"
+        on_exception(e)
+      ensure
+        connection.close
+      end
+      on_close
     end
   end
 end

data/lib/deepstream/error_handler.rb

@@ -1,6 +1,6 @@
-require 'deepstream/constants'
-require 'deepstream/helpers'
-require 'deepstream/message'
+require_relative './constants'
+require_relative './helpers'
+require_relative './message'
 
 module Deepstream
   class ErrorHandler

data/lib/deepstream/event_handler.rb

@@ -1,7 +1,7 @@
-require 'deepstream/ack_timeout_registry'
-require 'deepstream/constants'
-require 'deepstream/exceptions'
-require 'deepstream/helpers'
+require_relative './ack_timeout_registry'
+require_relative './constants'
+require_relative './exceptions'
+require_relative './helpers'
 
 module Deepstream
   class EventHandler
@@ -14,7 +14,7 @@ module Deepstream
 
     def on(event, &block)
       unless @callbacks[event]
-        @client.send_message(TOPIC::EVENT, ACTION::SUBSCRIBE, event)
+        @client.send_message(TOPIC::EVENT, ACTION::SUBSCRIBE, event) if @client.state == CONNECTION_STATE::OPEN
         @ack_timeout_registry.add(event, "No ACK message received in time for #{event}")
       end
       @callbacks[event] = block
@@ -75,7 +75,7 @@ module Deepstream
 
     def fire_event_callback(message)
       event, data = message.data
-      Celluloid::Future.new { @callbacks[event].call(Helpers.to_type(data)) }
+      @callbacks[event].call(Helpers.to_type(data))
     end
 
     def fire_listen_callback(message)

data/lib/deepstream/helpers.rb

@@ -4,7 +4,7 @@ module Deepstream
   module Helpers
     SCHEME = 'ws://'
     DEFAULT_PORT = 6020
-    DEFAULT_PATH = 'deepstream'
+    DEFAULT_PATH = 'deepstream-v3'
 
     def self.to_deepstream_type(value)
       case value
@@ -34,13 +34,9 @@ module Deepstream
     def self.default_options
       {
         ack_timeout: nil,
-        autologin: true,
         credentials: {},
         heartbeat_interval: nil,
-        max_reconnect_attempts: nil,
-        max_reconnect_interval: 30,
-        reconnect_interval: 1,
-        emit_timeout: 0,
+        in_thread: true,
         verbose: false,
         debug: false
       }
@@ -48,9 +44,9 @@ module Deepstream
 
     def self.url(url)
       url.tap do |url|
-        url.prepend(SCHEME) unless url.start_with?(SCHEME)
+        url.prepend(SCHEME) unless url.start_with?(/ws(s|)\:\/\//)
         url.concat(":#{DEFAULT_PORT}") unless url[/\:\d+/]
-        url.concat("/#{DEFAULT_PATH}") unless url[/\/\w+$/]
+        url.concat("/#{DEFAULT_PATH}") unless url[/:\d+\/\S+$/]
       end
     end
 

data/lib/deepstream/list.rb

@@ -1,4 +1,4 @@
-require 'deepstream/record'
+require_relative './record'
 
 module Deepstream
   class List < Record
@@ -37,6 +37,12 @@ module Deepstream
       @data.map { |record_name| @client.get(record_name) }
     end
 
+    def end_reinitializing
+      reset_version
+      set
+      @is_reinitializing = false
+    end
+
     private
 
     def set

data/lib/deepstream/message.rb

@@ -1,5 +1,5 @@
 require 'json'
-require 'deepstream/constants'
+require_relative './constants'
 
 module Deepstream
   class Message
@@ -9,18 +9,24 @@ module Deepstream
       args.first.is_a?(self) ? args.first : new(*args)
     end
 
-    def initialize(*args, timeout: nil)
+    def initialize(*args)
       if args.one?
         args = args.first.delete(MESSAGE_SEPARATOR).split(MESSAGE_PART_SEPARATOR)
       end
-      @sending_deadline = Time.now + timeout if timeout
+      @sending_deadline = nil
       @topic, @action = args.take(2).map(&:to_sym)
       @data = args.drop(2)
+    rescue
+      ''
+    end
+
+    def set_timeout(timeout)
+      @sending_deadline = Time.now + timeout
     end
 
     def to_s
       args = [@topic, @action]
-      args << @data unless @data.empty?
+      args << @data unless (@data.nil? || @data.empty?)
       args.join(MESSAGE_PART_SEPARATOR).concat(MESSAGE_SEPARATOR)
     end
 

data/lib/deepstream/record.rb

@@ -1,6 +1,6 @@
 require 'json'
-require 'deepstream/constants'
-require 'deepstream/helpers'
+require_relative './constants'
+require_relative './helpers'
 
 module Deepstream
   class Record
@@ -9,11 +9,29 @@ module Deepstream
       @name = name
       @data = {}
       @version = nil
+      @is_reinitializing = false
+      @data_cache = {}
       @client.send_message(TOPIC::RECORD, ACTION::CREATEORREAD, @name)
     end
 
-    def get_name
-      @name
+    def reset_version
+      @version = 0
+    end
+
+    def is_reinitializing?
+      @is_reinitializing
+    end
+
+    def start_reinitializing
+      @is_reinitializing = true
+      @data_cache = @data
+      @client.send_message(TOPIC::RECORD, ACTION::CREATEORREAD, @name, priority: true)
+    end
+
+    def end_reinitializing
+      reset_version
+      set(@data_cache)
+      @is_reinitializing = false
     end
 
     def inspect

data/lib/deepstream/record_handler.rb

@@ -1,7 +1,7 @@
-require 'deepstream/constants'
-require 'deepstream/exceptions'
-require 'deepstream/list'
-require 'deepstream/record'
+require_relative './constants'
+require_relative './exceptions'
+require_relative './list'
+require_relative './record'
 
 module Deepstream
   class RecordHandler
@@ -10,6 +10,13 @@ module Deepstream
       @records = {}
     end
 
+    def reinitialize
+      @records.map do |record|
+        name, rec = record
+        rec.start_reinitializing
+      end
+    end
+
     def on_message(message)
       case message.action
       when ACTION::ACK then nil
@@ -55,6 +62,7 @@ module Deepstream
 
     def read(message)
       name, *data = message.data
+      return @records[name].end_reinitializing if @records[name]&.is_reinitializing?
       @records[name]&.read(*data)
     end
 

metadata

@@ -1,29 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: deepstream
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.0.3
 platform: ruby
 authors:
 - Currency-One S.A.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-20 00:00:00.000000000 Z
+date: 2021-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: celluloid-websocket-client
+  name: async
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.25.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.25.0
+- !ruby/object:Gem::Dependency
+  name: async-io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.29.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.29.0
+- !ruby/object:Gem::Dependency
+  name: async-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.1
+- !ruby/object:Gem::Dependency
+  name: async-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.0
 - !ruby/object:Gem::Dependency
   name: cucumber
   requirement: !ruby/object:Gem::Requirement
@@ -96,7 +138,7 @@ dependencies:
         version: '0'
 description: Basic ruby client for the deepstream.io server
 email:
-- piotr.szczudlak@currency-one.com
+- ruby@currency-one.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -110,6 +152,7 @@ files:
 - deepstream.gemspec
 - lib/deepstream.rb
 - lib/deepstream/ack_timeout_registry.rb
+- lib/deepstream/async_patch.rb
 - lib/deepstream/client.rb
 - lib/deepstream/constants.rb
 - lib/deepstream/error_handler.rb
@@ -139,8 +182,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: deepstream.io ruby client