socketclusterclient 0.1.0

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'socketclusterclient'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

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

data/examples/authentication.rb

@@ -0,0 +1,22 @@
+require 'socketclusterclient'
+
+on_connect = -> { puts 'on connect got called' }
+
+on_disconnect = -> { puts 'on disconnect got called' }
+
+on_connect_error = -> { puts 'on connect error got called' }
+
+on_set_authentication = lambda do |socket, token|
+  puts "Token received #{token}"
+  socket.set_auth_token(token)
+end
+
+on_authentication = lambda do |socket, is_authenticated|
+  puts "Authenticated is #{is_authenticated}"
+  socket.disconnect
+end
+
+socket = ScClient.new('ws://localhost:8000/socketcluster/')
+socket.set_basic_listener(on_connect, on_disconnect, on_connect_error)
+socket.set_authentication_listener(on_set_authentication, on_authentication)
+socket.connect

data/examples/channel.rb

@@ -0,0 +1,49 @@
+require 'socketclusterclient'
+
+on_connect = -> { puts 'on connect got called' }
+
+on_disconnect = -> { puts 'on disconnect got called' }
+
+on_connect_error = -> { puts 'on connect error got called' }
+
+ack_subscribe = lambda do |channel, error, _object|
+  puts "Subscribed successfully to channel => #{channel}" if error == ''
+end
+
+ack_publish = lambda do |channel, error, _object|
+  puts "Publish sent successfully to channel => #{channel}" if error == ''
+end
+
+channel_message = lambda do |key, object|
+  puts "Got data => #{object} from key => #{key}"
+end
+
+ack_unsubscribe = lambda do |channel, error, _object|
+  puts "Unsubscribed to channel => #{channel}" if error == ''
+end
+
+on_set_authentication = lambda do |socket, token|
+  puts "Token received #{token}"
+  socket.set_auth_token(token)
+end
+
+on_authentication = lambda do |socket, is_authenticated|
+  puts "Authenticated is #{is_authenticated}"
+
+  # channel communication
+  socket.subscribe('yell')
+  socket.publish('yell', 'Hi')
+  socket.onchannel('yell', channel_message)
+  socket.unsubscribe('yell')
+
+  # channel communication with acknowledgment
+  socket.subscribeack('yell', ack_subscribe)
+  socket.publishack('yell', 'Hi dudies', ack_publish)
+  socket.onchannel('yell', channel_message)
+  socket.unsubscribeack('yell', ack_unsubscribe)
+end
+
+socket = ScClient.new('ws://localhost:8000/socketcluster/')
+socket.set_basic_listener(on_connect, on_disconnect, on_connect_error)
+socket.set_authentication_listener(on_set_authentication, on_authentication)
+socket.connect

data/examples/emitter.rb

@@ -0,0 +1,31 @@
+require 'socketclusterclient'
+
+on_connect = -> { puts 'on connect got called' }
+
+on_disconnect = -> { puts 'on disconnect got called' }
+
+on_connect_error = -> { puts 'on connect error got called' }
+
+ack_emit = lambda do |key, error, object|
+  puts "Got ack data => #{object} and error => #{error} and key => #{key}"
+end
+
+on_set_authentication = lambda do |socket, token|
+  puts "Token received #{token}"
+  socket.set_auth_token(token)
+end
+
+on_authentication = lambda do |socket, is_authenticated|
+  puts "Authenticated is #{is_authenticated}"
+
+  # emit event chat and message Hi to ScServer
+  socket.emit('chat', 'Hi')
+
+  # emit event chat and message Hi with acknowledgment to ScServer
+  socket.emitack('chat', 'Hello', ack_emit)
+end
+
+socket = ScClient.new('ws://localhost:8000/socketcluster/')
+socket.set_basic_listener(on_connect, on_disconnect, on_connect_error)
+socket.set_authentication_listener(on_set_authentication, on_authentication)
+socket.connect

data/examples/receiver.rb

@@ -0,0 +1,36 @@
+require 'socketclusterclient'
+
+on_connect = -> { puts 'on connect got called' }
+
+on_disconnect = -> { puts 'on disconnect got called' }
+
+on_connect_error = -> { puts 'on connect error got called' }
+
+message = lambda do |key, object|
+  puts "Got data => #{object} from key => #{key}"
+end
+
+ack_message = lambda do |key, object, block_ack_message|
+  puts "Got ack data => #{object} from key => #{key}"
+  block_ack_message.call('error lorem', 'data ipsum')
+end
+
+on_set_authentication = lambda do |socket, token|
+  puts "Token received #{token}"
+  socket.set_auth_token(token)
+end
+
+on_authentication = lambda do |socket, is_authenticated|
+  puts "Authenticated is #{is_authenticated}"
+
+  # bind ping event on ScServer
+  socket.on('yell', message)
+
+  # bind ping event on ScServer with acknowledgment
+  socket.onack('ping', ack_message)
+end
+
+socket = ScClient.new('ws://localhost:8000/socketcluster/')
+socket.set_basic_listener(on_connect, on_disconnect, on_connect_error)
+socket.set_authentication_listener(on_set_authentication, on_authentication)
+socket.connect

data/examples/reconnection.rb

@@ -0,0 +1,25 @@
+require 'socketclusterclient'
+
+on_connect = -> { puts 'on connect got called' }
+
+on_disconnect = -> { puts 'on disconnect got called' }
+
+on_connect_error = -> { puts 'on connect error got called' }
+
+on_set_authentication = lambda do |socket, token|
+  puts "Token received #{token}"
+  socket.set_auth_token(token)
+end
+
+on_authentication = lambda do |_socket, is_authenticated|
+  puts "Authenticated is #{is_authenticated}"
+end
+
+socket = ScClient.new('ws://localhost:8000/socketcluster/')
+socket.set_basic_listener(on_connect, on_disconnect, on_connect_error)
+socket.set_authentication_listener(on_set_authentication, on_authentication)
+socket.set_reconnection_listener(3000, 30_000) # (reconnect_inverval, max_reconnect_interval)
+socket.set_reconnection_listener(3000, 30_000, 10) # (reconnect_inverval, max_reconnect_interval, max_attempts)
+socket.set_reconnection(true) # to allow reconnection, default reconnection is disabled
+socket.max_attempts = 5 # set maximum attempts allowed
+socket.connect

data/examples/ssl_connect.rb

@@ -0,0 +1,12 @@
+require 'socketclusterclient'
+
+on_connect = -> { puts 'on connect got called' }
+
+on_disconnect = -> { puts 'on disconnect got called' }
+
+on_connect_error = -> { puts 'on connect error got called' }
+
+# connection to ssl server at websocket.org
+socket = ScClient.new('wss://echo.websocket.org/')
+socket.set_basic_listener(on_connect, on_disconnect, on_connect_error)
+socket.connect

data/lib/sc_client.rb

@@ -0,0 +1,365 @@
+require 'websocket-eventmachine-client'
+require 'json'
+require 'logger'
+
+require_relative './socketclusterclient/emitter'
+require_relative './socketclusterclient/parser'
+require_relative './socketclusterclient/data_models'
+require_relative './socketclusterclient/reconnect'
+require_relative './socketclusterclient/log'
+
+#
+# Class ScClient provides an interface to connect to the socketcluster server
+#
+# @author Maanav Shah <shahmaanav07@gmail.com>
+#
+class ScClient
+  include Emitter
+  include DataModels
+  include Reconnect
+  include Log
+
+  attr_accessor :reconnect_interval, :max_reconnect_interval, :max_attempts
+
+  #
+  # Initializes instance variables in socketcluster client
+  #
+  # @param [String] url ScServer connection URL
+  #
+  def initialize(url)
+    @id = ''
+    @cnt = 0
+    @url = url
+    @acks = {}
+    @channels = []
+    @enable_reconnection = false
+    @delay = 3
+    initialize_emitter
+    initialize_reconnect
+    initialize_logger
+  end
+
+  #
+  # Adds handler for connect, disconnect and error
+  #
+  # @param [Lambda] on_connected Block to execute on connected
+  # @param [Lambda] on_disconnected Block to execute on disconnected
+  # @param [Lambda] on_connect_error Block to execute on connection error
+  #
+  #
+  #
+  def set_basic_listener(on_connected, on_disconnected, on_connect_error)
+    @on_connected = on_connected
+    @on_disconnected = on_disconnected
+    @on_connect_error = on_connect_error
+  end
+
+  #
+  # Adds handler for authentication
+  #
+  # @param [Lambda] on_set_authentication Block to set authentication token
+  # @param [Lambda] on_authentication Block to execute on authentication
+  #
+  #
+  #
+  def set_authentication_listener(on_set_authentication, on_authentication)
+    @on_set_authentication = on_set_authentication
+    @on_authentication = on_authentication
+  end
+
+  #
+  # Method to set the authentication token
+  #
+  # @param [String] token Authentication token provided by ScServer
+  #
+  #
+  #
+  def set_auth_token(token)
+    @auth_token = token.to_s
+  end
+
+  #
+  # Get the list of all subscribed channels
+  #
+  #
+  #
+  #
+  def subscribed_channels
+    @channels
+  end
+
+  #
+  # Subscribe all the channels available
+  #
+  #
+  #
+  #
+  def subscribe_channels
+    @channels.each { |channel| subscribe(channel) }
+  end
+
+  #
+  # Acknowledment block to be executed on event
+  #
+  # @param [String] cid @cnt id received from ScServer
+  #
+  # @return [Lambda] Acknowledgment to be sent to ScServer
+  #
+  def ack_block(cid)
+    ws = @ws
+    lambda do |error, data|
+      ws.send(get_ack_object(error, data, cid))
+    end
+  end
+
+  #
+  # Connects to the ScServer
+  #
+  #
+  #
+  #
+  def connect
+    EM.epoll
+
+    EM.run do
+      trap('TERM') do
+        @enable_reconnection = false
+        disconnect
+      end
+
+      trap('INT') do
+        @enable_reconnection = false
+        disconnect
+      end
+
+      @ws = WebSocket::EventMachine::Client.connect(uri: @url)
+
+      @ws.onopen do
+        reset_value
+        @ws.send(get_handshake_object(increment_cnt).to_json)
+        @on_connected.call if @on_connected
+      end
+
+      @ws.onmessage do |message, _type|
+        @logger.info("Message received : #{message}") if @logger
+        if message == '#1'
+          @ws.send('#2')
+        else
+          main_object = JSON.parse(message)
+          data_object = main_object['data']
+          rid = main_object['rid']
+          cid = main_object['cid']
+          event = main_object['event']
+          result = Parser.parse(event, rid)
+          if result == Parser::CHECK_AUTHENTICATION
+            if @on_authentication
+              @id = data_object['id']
+              @on_authentication.call(self, data_object['isAuthenticated'])
+            end
+            subscribe_channels
+          elsif result == Parser::PUBLISH
+            execute(data_object['channel'], data_object['data'])
+          elsif result == Parser::REMOVE_AUTHENTICATION
+            @auth_token = nil
+          elsif result == Parser::SET_AUTHENTICATION
+            if @on_set_authentication
+              @on_set_authentication.call(self, data_object['token'])
+            end
+          elsif result == Parser::EVENT
+            if haseventack(event)
+              executeack(event, data_object, ack_block(cid))
+            else
+              execute(event, data_object)
+            end
+          else # Parser::ACKNOWLEDGEMENT
+            tuple = @acks[rid] if @acks.include?(rid)
+            if tuple
+              ack = tuple[1]
+              ack.call(tuple[0], String(main_object['error']), String(main_object['data']))
+            end
+          end
+        end
+      end
+
+      @ws.onerror do |error|
+        @on_connect_error.call(error) if @on_connect_error
+      end
+
+      @ws.onclose do
+        if should_reconnect
+          @reconnect_interval = @max_reconnect_interval if @reconnect_interval > @max_reconnect_interval
+          sleep(@reconnect_interval / 1000)
+          @attempts_made += 1
+          @logger.info("Attempting to reconnect : #{@attempts_made}") if @logger
+          connect
+        else
+          stop
+        end
+      end
+
+      def stop
+        EventMachine.stop
+      end
+    end
+  end
+
+  #
+  # Set the delay for reconnection to ScServer
+  #
+  # @param [Integer] delay Delay in seconds to reconnect
+  #
+  #
+  #
+  def set_delay(delay)
+    @delay = delay
+  end
+
+  #
+  # Allows to reconnect to ScServer
+  #
+  # @param [Boolean] enable True to reconnect to server, False to disconnect
+  #
+  #
+  #
+  def set_reconnection(enable)
+    @enable_reconnection = enable
+  end
+
+  #
+  # Disconnects the connection with ScServer
+  #
+  #
+  #
+  #
+  def disconnect
+    @on_disconnected.call if @on_disconnected
+    @enable_reconnection = false
+    @ws.close
+  end
+
+  #
+  # Emits the specified event on the corresponding server-side socket
+  #
+  # @param [String] event Event
+  # @param [String] object Data for the specified event
+  #
+  #
+  #
+  def emit(event, object)
+    @ws.send(get_emit_object(event, object).to_json)
+  end
+
+  #
+  # Emits the specified event on the corresponding server-side socket with acknowledgment
+  #
+  # @param [String] event Event
+  # @param [String] object Data for the specified event
+  # @param [Lambda] ack Block to execute on event acknowledgment
+  #
+  # @return [<type>] <description>
+  #
+  def emitack(event, object, ack)
+    @ws.send(get_emit_ack_object(event, object, increment_cnt).to_json)
+    @acks[@cnt] = [event, ack]
+  end
+
+  #
+  # Subscribes to a particular channel
+  #
+  # @param [String] channel A channel name
+  #
+  #
+  #
+  def subscribe(channel)
+    @ws.send(get_subscribe_object(channel, increment_cnt).to_json)
+    @channels << channel unless @channels.include?(channel)
+  end
+
+  #
+  # Subscribes to a particular channel with acknowledgment
+  #
+  # @param [String] channel A channel name
+  # @param [Lambda] ack Block to execute on subscribe acknowledgment
+  #
+  #
+  #
+  def subscribeack(channel, ack)
+    @ws.send(get_subscribe_object(channel, increment_cnt).to_json)
+    @channels << channel
+    @acks[@cnt] = [channel, ack]
+  end
+
+  #
+  # Unsubscribes to a particular channel
+  #
+  # @param [String] channel A channel name
+  #
+  #
+  #
+  def unsubscribe(channel)
+    @ws.send(get_unsubscribe_object(channel, increment_cnt).to_json)
+    @channels.delete(channel)
+  end
+
+  #
+  # Unsubscribes to a particular channel with acknowledgment
+  #
+  # @param [String] channel A channel name
+  # @param [Lambda] ack Block to execute on unsubscribe acknowledgment
+  #
+  #
+  #
+  def unsubscribeack(channel, ack)
+    @ws.send(get_unsubscribe_object(channel, increment_cnt).to_json)
+    @channels.delete(channel)
+    @acks[@cnt] = [channel, ack]
+  end
+
+  #
+  # Publish data to the specified channel name
+  #
+  # @param [String] channel A channel name
+  # @param [String] data Data to be published on the channel
+  #
+  #
+  #
+  def publish(channel, data)
+    @ws.send(get_publish_object(channel, data, increment_cnt).to_json)
+  end
+
+  #
+  # Publish data to the specified channel name
+  #
+  # @param [String] channel A channel name
+  # @param [String] data Data to be published on the channel
+  # @param [Lambda] ack Block to execute on publish acknowledgment
+  #
+  #
+  #
+  def publishack(channel, data, ack)
+    @ws.send(get_publish_object(channel, data, increment_cnt).to_json)
+    @acks[@cnt] = [channel, ack]
+  end
+
+  private
+
+  #
+  # Resets the value of @cnt
+  #
+  #
+  #
+  #
+  def reset_value
+    @cnt = 0
+  end
+
+  #
+  # Increments the value of @cnt
+  #
+  #
+  #
+  #
+  def increment_cnt
+    @cnt += 1
+  end
+end