deepstream 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cd95fc9f274116e724233dc418e5341bb600504
-  data.tar.gz: 2ba1ca7d05528b7221f264ed6ff133a10ca26425
+  metadata.gz: 7f892fdc582aa7e27a3fe12d61e0f27662fb08dd
+  data.tar.gz: 49ce6f01d3ce6ad8cb382eab79679ac8cbe2a9f9
 SHA512:
-  metadata.gz: 4e8b66da27b17102bd5b52acb98c72638f95df219c767c2b4d5029ca7695f33084c74194cd453bfc2ba3e54d76b79085fc87d1c7e7f667e46c99badd449bb356
-  data.tar.gz: 7d0196f7f8afc7be326827ef1b93496cc2066374ed4f60279ae58e01863eb6bfaa51be66403ce990d9d30a8a809145ebd8c78686f2c909cae459d2afe0c92b9c
+  metadata.gz: 96be6f3399854e1dfe56ed878c5aa42f6389ca11ff3e45b45a82dd74681594899ae3ff41c3af89fd6b01894ed497fb371c6bbe320113e3e7c9666043acb884cf
+  data.tar.gz: 8e313b9736f42b34681f0411e8cc4d13989805abe525563e0ef47e2ff82600282de8e2ae00dedcf92d1aff66f09cd08db8c13577dd3b16647cd725f7e379fa69

data/README.md

@@ -1,43 +1,49 @@
 # deepstream-ruby
 deepstream.io ruby client
 
-
 ### Install
 
 ```
 gem install deepstream
 ```
 
-
 ### Usage
 ```ruby
-ds = Deepstream::Client.new('localhost')
+ds = Deepstream::Client.new('localhost',
+  autologin: false,
+  verbose: true,
+  credentials: { username: 'John', password: 'Doe' })
+# or
+ds = Deepstream::Client.new('ws://localhost:6020')
+# or
+ds = Deepstream::Client.new('ws://localhost:6020/deepstream')
+
+# log in to the server
+ds.login
+# you can use new credentials too
+ds.login(username: 'John', password: 'betterDoe')
+
+# check if the websocket connection is opened
+ds.connected?
+
+# check if the client is logged in
+ds.logged_in?
 
 # Emit events
 ds.emit 'my_event'
 # or
 ds.emit 'my_event', foo: 'bar', bar: 'foo'
-# or
-ds.emit 'my_event', {foo: 'bar', bar: 'foo'}, timeout: 3
-# or
-ds.emit 'my_event', nil, timeout: 3
-
 
 # Subscribe to events
-ds.on('some_event') do |msg|
+ds.on('some_event') do |event_name, msg|
   puts msg
 end
 
-
 # Get a record
 foo = ds.get('foo')
+bar = ds.get('bar', list: 'bar_list') # get a record within a namespace (this one automatically adds it to a list)
 
-# Get a record with a namespace (automaticly add to a list)
-foo = ds.get_record('foo', list: 'bar') # record can also be accessed by ds.get('bar/foo')
-
-# Update record
-foo.bar = 'bar'
-# or
+# Update a record
 foo.set('bar', 'bar')
 
 # Set the whole record
@@ -46,13 +52,15 @@ foo.set(foo: 'foo', bar: 1)
 # Get a list
 foo = ds.get_list('bar')
 
-# Add to list
+# Add to the list
 foo.add('foo')
 
 # Remove from list
 foo.remove('foo')
 
 # Show record names on the list
+foo.data
+# or
 foo.keys
 
 # Access records on the list

data/deepstream.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "deepstream"
-  spec.version       = "0.2.0"
+  spec.version       = "0.2.1"
   spec.authors       = ["Currency-One S.A."]
   spec.email         = ["piotr.szczudlak@currency-one.com"]
 

data/lib/deepstream/client.rb

@@ -10,7 +10,7 @@ require 'deepstream/exceptions'
 
 module Deepstream
   class Client
-    attr_reader :last_hearbeat, :options, :state
+    attr_reader :options, :state
 
     include Celluloid
     include Celluloid::Internals::Logger
@@ -19,7 +19,7 @@ module Deepstream
     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
+    def_delegators :@error_handler, :error, :on_error, :on_exception
     def_delegators :@record_handler, :get, :set, :delete, :discard, :get_list
 
     def initialize(url, options = {})
@@ -34,11 +34,13 @@ module Deepstream
       @failed_reconnect_attempts = 0
       @state = CONNECTION_STATE::CLOSED
       Celluloid.logger.level = @options[:verbose] ? LOG_LEVEL::INFO : LOG_LEVEL::OFF
-      async.connect
+      connect
     end
 
     def on_open
+      info("Websocket connection opened")
       @state = CONNECTION_STATE::AWAITING_CONNECTION
+      @connection_requested, @deliberate_close = false
       @failed_reconnect_attempts = 0
     end
 
@@ -51,19 +53,19 @@ module Deepstream
       when TOPIC::EVENT      then @event_handler.on_message(message)
       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.')
-      else raise UnknownTopic(message.to_s)
+      when TOPIC::RPC        then raise(UnknownTopic, 'RPC is currently not implemented.')
+      else raise(UnknownTopic, message)
       end
     rescue => e
-      @error_handler.on_exception(e)
+      on_exception(e)
     end
 
     def on_close(code, reason)
-      info("Websocket connection closed: #{code.inspect}, #{reason.inspect}")
+      info("Websocket connection closed: code - #{code.inspect}, reason - #{reason.inspect}")
       @state = CONNECTION_STATE::CLOSED
       reconnect unless @deliberate_close
     rescue => e
-      @error_handler.on_exception(e)
+      on_exception(e)
     end
 
     def login(credentials = @options[:credentials])
@@ -79,24 +81,28 @@ module Deepstream
       end
       self
     rescue => e
-      @error_handler.on_exception(e)
+      on_exception(e)
       self
     end
 
     def close
       return unless connected?
+      @state = CONNECTION_STATE::CLOSED
       @deliberate_close = true
       @connection.close
       @connection.terminate
-      @state = CONNECTION_STATE::CLOSED
     rescue => e
-      @error_handler.on_exception(e)
+      on_exception(e)
     end
 
     def connected?
       @state != CONNECTION_STATE::CLOSED
     end
 
+    def reconnecting?
+      @state == CONNECTION_STATE::RECONNECTING
+    end
+
     def logged_in?
       @state == CONNECTION_STATE::OPEN
     end
@@ -107,19 +113,26 @@ module Deepstream
 
     def send_message(*args)
       message = Message.parse(*args)
-      if !logged_in? && message.needs_authentication?
-        info("Placing message #{message.inspect} in buffer, waiting for connection")
-        @message_buffer << message
-      else
-        info("Sending message: #{message.inspect}")
-        @connection.text(message.to_s)
-      end
+      return unable_to_send_message(message) if !logged_in? && message.needs_authentication?
+      info("Sending message: #{message.inspect}")
+      @connection.text(message.to_s)
+    rescue Errno::EPIPE
+      unable_to_send_message(message)
     rescue => e
-      @error_handler.on_exception(e)
+      on_exception(e)
     end
 
     private
 
+    def unable_to_send_message(message)
+      @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
+      end
+      async.reconnect if !connected? && !@connection_requested
+    end
+
     def connection_message(message)
       case message.action
       when ACTION::ACK       then on_connection_ack
@@ -128,7 +141,7 @@ module Deepstream
       when ACTION::PING      then on_ping
       when ACTION::REDIRECT  then on_redirection(message)
       when ACTION::REJECTION then on_rejection
-      else raise UnknownAction(message)
+      else raise(UnknownAction, message)
       end
     end
 
@@ -136,7 +149,7 @@ module Deepstream
       case message.action
       when ACTION::ACK   then on_login
       when ACTION::ERROR then on_error(message)
-      else raise UnknownAction(message)
+      else raise(UnknownAction, message)
       end
     end
 
@@ -157,8 +170,9 @@ module Deepstream
 
     def on_login
       @state = CONNECTION_STATE::OPEN
-      @message_buffer.each { |message| send_message(message) }.clear
+      @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
@@ -177,25 +191,38 @@ module Deepstream
       connect(message.data.last)
     end
 
-    def connect(url = @url, reraise = false)
+    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
-      reraise ? raise : @error_handler.on_exception(e)
+      @connection_requested = false
+      reraise ? raise : on_exception(e)
     end
 
     def reconnect
-      @state = CONNECTION_STATE::RECONNECTING
-      if @failed_reconnect_attempts < @options[:max_reconnect_attempts]
-        connect(@url, true)
-        resubscribe
+      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
+        end
       else
         @state = CONNECTION_STATE::ERROR
       end
-    rescue Errno::ECONNREFUSED
+    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)
-      reconnect
+      retry
+    rescue => e
+      on_exception(e)
     end
 
     def reconnect_interval

data/lib/deepstream/error_handler.rb

@@ -18,13 +18,12 @@ module Deepstream
         else
           message
         end
-      puts @error
+      puts "#{@error}\n" unless @client.options[:debug]
     end
 
     def on_exception(exception)
       raise exception if @client.options[:debug]
-      puts exception.message
-      puts exception.backtrace
+      puts "\n#{exception.message}\n#{exception.backtrace}\n"
     end
   end
 end

data/lib/deepstream/event_handler.rb

@@ -17,6 +17,8 @@ module Deepstream
         @ack_timeout_registry.add(event, "No ACK message received in time for #{event}")
       end
       @callbacks[event] = block
+    rescue => e
+      @client.on_exception(e)
     end
     alias subscribe on
 
@@ -25,12 +27,16 @@ module Deepstream
       @listeners[pattern] = block
       @client.send_message(TOPIC::EVENT, ACTION::LISTEN, pattern)
       @ack_timeout_registry.add(pattern, "No ACK message received in time for #{pattern}")
+    rescue => e
+      @client.on_exception(e)
     end
 
     def unlisten(pattern)
       pattern = pattern.is_a?(Regexp) ? pattern.source : pattern
       @listeners.delete(pattern)
       @client.send_message(TOPIC::EVENT, ACTION::UNLISTEN, pattern)
+    rescue => e
+      @client.on_exception(e)
     end
 
     def on_message(message)
@@ -43,18 +49,24 @@ module Deepstream
       end
     end
 
-    def emit(event, data = nil)
-      @client.send_message(TOPIC::EVENT, ACTION::EVENT, event, Helpers.to_deepstream_type(data))
+    def emit(event, data = nil, timeout: @client.options[:emit_timeout])
+      @client.send_message(TOPIC::EVENT, ACTION::EVENT, event, Helpers.to_deepstream_type(data), timeout: timeout)
+    rescue => e
+      @client.on_exception(e)
     end
 
     def unsubscribe(event)
       @callbacks.delete(event)
       @client.send_message(TOPIC::EVENT, ACTION::UNSUBSCRIBE, event)
+    rescue => e
+      @client.on_exception(e)
     end
 
     def resubscribe
       @callbacks.keys.each { |event| @client.send_message(TOPIC::EVENT, ACTION::SUBSCRIBE, event) }
       @listeners.keys.each { |pattern| @client.send_message(TOPIC::EVENT, ACTION::LISTEN, pattern) }
+    rescue => e
+      @client.on_exception(e)
     end
 
     private

data/lib/deepstream/helpers.rb

@@ -36,9 +36,10 @@ module Deepstream
         autologin: true,
         credentials: {},
         heartbeat_interval: nil,
-        max_reconnect_attempts: 5,
+        max_reconnect_attempts: nil,
         max_reconnect_interval: 30,
         reconnect_interval: 1,
+        emit_timeout: 0,
         verbose: false,
         debug: false
       }

data/lib/deepstream/list.rb

@@ -24,6 +24,10 @@ module Deepstream
       set(@data) if @data.delete(record_name)
     end
 
+    def keys
+      @data
+    end
+
     def all
       @data.map { |record_name| @client.get(record_name) }
     end

data/lib/deepstream/message.rb

@@ -3,16 +3,17 @@ require 'deepstream/constants'
 
 module Deepstream
   class Message
-    attr_reader :topic, :action, :data
+    attr_reader :action, :data, :topic, :sending_deadline
 
     def self.parse(*args)
       args.first.is_a?(self) ? args.first : new(*args)
     end
 
-    def initialize(*args)
+    def initialize(*args, timeout: nil)
       if args.one?
         args = args.first.delete(MESSAGE_SEPARATOR).split(MESSAGE_PART_SEPARATOR)
       end
+      @sending_deadline = Time.now + timeout if timeout
       @topic, @action = args.take(2).map(&:to_sym)
       @data = args.drop(2)
     end
@@ -30,5 +31,9 @@ module Deepstream
     def needs_authentication?
       ![TOPIC::CONNECTION, TOPIC::AUTH].include?(@topic)
     end
+
+    def expired?
+      @sending_deadline && @sending_deadline < Time.now
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deepstream
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Currency-One S.A.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-06 00:00:00.000000000 Z
+date: 2017-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid-websocket-client