pakyow-realtime 0.11.3 → 1.0.0.rc1

data/pakyow-realtime/lib/pakyow/realtime/redis_subscription.rb

@@ -1,61 +0,0 @@
-require 'redis'
-require 'concurrent'
-
-module Pakyow
-  module Realtime
-    # Manages channel subscriptions for this application instance's WebSockets.
-    #
-    # @api private
-    class RedisSubscription
-      SIGNAL_UNSUBSCRIBE = 'unsubscribe'
-
-      def initialize
-        @redis = ::Redis.new(Config.realtime.redis)
-      end
-
-      def subscribe(channels = [])
-        channels << signal_channel
-
-        Concurrent::Future.execute {
-          @redis.subscribe(*channels) do |on|
-            on.message do |channel, msg|
-              begin
-                msg = JSON.parse(msg)
-
-                if channel == signal_channel
-                  if msg['signal'] == SIGNAL_UNSUBSCRIBE
-                    @resubscribe_channels = msg['resubscribe_channels']
-                    @redis.unsubscribe
-                  end
-                end
-
-                if msg.is_a?(Hash)
-                  msg[:__propagated] = true
-                elsif msg.is_a?(Array)
-                  msg << :__propagated
-                end
-
-                context = Pakyow::Realtime::Context.new(Pakyow.app)
-
-                if msg.key?('key')
-                  context.push_message_to_socket_with_key(msg['message'], msg['channel'], msg['key'], true)
-                else
-                  context.push(msg, channel)
-                end
-              rescue StandardError => e
-                Pakyow.logger.error "RedisSubscription encountered a fatal error:"
-                Pakyow.logger.error e.message
-              end
-            end
-          end
-
-          subscribe(@resubscribe_channels) if @resubscribe_channels
-        }
-      end
-
-      def signal_channel
-        "pw:#{object_id}:signal"
-      end
-    end
-  end
-end

data/pakyow-realtime/lib/pakyow/realtime/registries/redis_registry.rb

@@ -1,107 +0,0 @@
-require 'json'
-require 'redis'
-require 'singleton'
-
-require 'pakyow/realtime/redis_subscription'
-require 'pakyow/realtime/registries/simple_registry'
-
-module Pakyow
-  module Realtime
-    def self.redis
-      $redis ||= Redis.new(Config.realtime.redis)
-    end
-    # Manages WebSocket connections and their subscriptions in Redis.
-    #
-    # This is the default registry in production systems and is required in
-    # deployments with more than one app instance.
-    #
-    # @api private
-    class RedisRegistry < SimpleRegistry
-      attr_reader :subscriber
-
-      def channels_for_key(key)
-        value = Pakyow::Realtime.redis.hget(channel_key, key)
-        value ? JSON.parse(value) : []
-      end
-
-      def unregister_key(key)
-        super
-
-        Pakyow::Realtime.redis.hdel(channel_key, key)
-        resubscribe
-      end
-
-      def subscribe_to_channels_for_key(channels, key)
-        channels << "pw:socket:#{key}"
-        super
-
-        resubscribe
-
-        new_channels = channels_for_key(key).concat(Array.ensure(channels)).uniq
-        Pakyow::Realtime.redis.hset(channel_key, key, new_channels.to_json)
-      end
-
-      def unsubscribe_to_channels_for_key(channels, key)
-        super
-
-        resubscribe
-
-        new_channels = channels_for_key(key) - Array.ensure(channels)
-        Pakyow::Realtime.redis.hset(channel_key, key, new_channels.to_json)
-      end
-
-      def propagates?
-        true
-      end
-
-      def propagate(message, channels)
-        message_json = message.to_json
-
-        channels.each do |channel|
-          Pakyow::Realtime.redis.publish(channel, message_json)
-        end
-      end
-
-      def subscribe_for_propagation(channels, key)
-        @channels[key] ||= []
-        @channels[key].concat(Array.ensure(channels)) << "pw:socket:#{key}"
-        @channels[key].uniq!
-
-        resubscribe
-      end
-
-      def push_message_to_socket_with_key(message, channel, key)
-        propagate({
-            key: key,
-            channel: channel,
-            message: message
-          },
-
-          ["pw:socket:#{key}"])
-      end
-
-      private
-
-      # Tells the subscription to unsubscribe from the current
-      # list of channels, then subscribes it to the new list.
-      def resubscribe
-        channels = @channels.values.flatten.uniq
-
-        if @subscriber
-          Pakyow::Realtime.redis.publish(@subscriber.signal_channel, {
-            'signal' => RedisSubscription::SIGNAL_UNSUBSCRIBE,
-            'resubscribe_channels' => channels
-          }.to_json)
-        else
-          @subscriber = RedisSubscription.new
-          @subscriber.subscribe(channels)
-        end
-      end
-
-      # Returns the key used to store channels.
-      def channel_key
-        Config.realtime.redis_key
-      end
-    end
-  end
-end

data/pakyow-realtime/lib/pakyow/realtime/registries/simple_registry.rb

@@ -1,40 +0,0 @@
-require 'singleton'
-
-module Pakyow
-  module Realtime
-    # Manages WebSocket connections and their subscriptions in memory.
-    #
-    # Intended only for use in development or single app-instance deployments.
-    #
-    # @api private
-    class SimpleRegistry
-      include Singleton
-
-      def initialize
-        @channels = {}
-      end
-
-      def channels_for_key(key)
-        @channels.fetch(key, [])
-      end
-
-      def unregister_key(key)
-        @channels.delete(key)
-      end
-
-      def subscribe_to_channels_for_key(channels, key)
-        @channels[key] ||= []
-        @channels[key].concat(Array.ensure(channels)).uniq!
-      end
-
-      def unsubscribe_to_channels_for_key(channels, key)
-        @channels[key] ||= []
-        @channels[key] = @channels[key] - Array.ensure(channels)
-      end
-
-      def propagates?
-        false
-      end
-    end
-  end
-end

data/pakyow-realtime/lib/pakyow/realtime/websocket.rb

@@ -1,209 +0,0 @@
-require 'concurrent'
-require 'websocket'
-
-require_relative 'connection'
-
-module Pakyow
-  module Realtime
-    # Hijacks a request, performs the handshake, and creates an async object
-    # for handling incoming and outgoing messages in an asynchronous manner.
-    #
-    # @api private
-    class Websocket < Connection
-      attr_reader :parser, :socket, :key
-
-      @event_handlers = {}
-
-      def initialize(req, key)
-        @req = req
-        @key = key
-
-        @socket = hijack(req)
-        @server = handshake(req)
-        setup
-      end
-
-      def registered
-        handle_ws_join
-      end
-
-      def shutdown
-        delegate.unregister(@key)
-        self.class.handle_event(:leave, @req)
-
-        @socket.close if @socket && !@socket.closed?
-        @shutdown = true
-
-        @reader = nil
-      end
-
-      def shutdown?
-        @shutdown == true
-      end
-
-      def push(msg)
-        json = JSON.pretty_generate(msg)
-        logger.debug "(ws.#{@key}) sending message: #{json}\n"
-
-        frame = WebSocket::Frame::Outgoing::Server.new(
-          version: @server.version,
-          data: json,
-          type: :text)
-        @socket.write(frame.to_s)
-      rescue StandardError => e
-        logger.error "(#{@key}): WebSocket encountered a fatal error:"
-        logger.error e.message
-
-        # something went wrong (like a broken pipe); shutdown
-        # and let the socket reconnect if it's still around
-        shutdown
-      end
-
-      def self.on(event, &block)
-        (@event_handlers[event.to_sym] ||= []) << block
-      end
-
-      private
-
-      def hijack(req)
-        if req.env['rack.hijack']
-          req.env['rack.hijack'].call
-          return req.env['rack.hijack_io']
-        else
-          logger.info "there's no socket to hijack :("
-        end
-      end
-
-      def handshake(req)
-        data = "#{req.env['REQUEST_METHOD']} #{req.env['REQUEST_URI']} #{req.env['SERVER_PROTOCOL']}\r\n"
-        req.env.each_pair do |key, val|
-          if key =~ /^HTTP_(.*)/
-            name = rack_env_key_to_http_header_name($1)
-            data << "#{name}: #{val}\r\n"
-          end
-        end
-        data << "\r\n"
-
-        server = WebSocket::Handshake::Server.new
-        server << data
-
-        fail HandshakeError, "(ws.#{@key}) error during handshake" unless server.valid?
-        @socket.write(server.to_s)
-
-        server
-      end
-
-      def rack_env_key_to_http_header_name(key)
-        name = key.downcase.gsub('_', '-')
-        name[0] = name[0].upcase
-        name.gsub!(/-(.)/) do |chr|
-          chr.upcase
-        end
-        name
-      end
-
-      def setup
-        logger.info "(ws.#{@key}) client established connection"
-
-        @parser = Parser.new(version: @server.version)
-
-        @parser.on :message do |message|
-          handle_ws_message(message)
-        end
-
-        @parser.on :error do |error|
-          logger.error "(ws.#{@key}) encountered error #{error}"
-          handle_ws_error(error)
-        end
-
-        @parser.on :close do |status, message|
-          logger.info "(ws.#{@key}) client closed connection"
-          handle_ws_close(status, message)
-        end
-
-        Concurrent::Future.execute {
-          begin
-            loop do
-              break if shutdown?
-              @parser << @socket.read_nonblock(1024)
-            end
-          rescue ::IO::WaitReadable
-            IO.select([@socket])
-            retry
-          end
-        }
-      end
-
-      def handle_ws_message(message)
-        parsed = JSON.parse(message)
-        logger.debug "(ws.#{@key}) received message: #{JSON.pretty_generate(parsed)}\n"
-        push(MessageHandler.handle(parsed, @req.env['rack.session']))
-      rescue StandardError => e
-        logger.error "(#{@key}): WebSocket encountered an error:"
-        logger.error e.message
-
-        e.backtrace.each do |line|
-          logger.error line
-        end
-      end
-
-      def handle_ws_error(_error)
-        shutdown
-      end
-
-      def handle_ws_join
-        self.class.handle_event(:join, @req)
-      end
-
-      def handle_ws_close(_status, _message)
-        shutdown
-      end
-
-      def self.handle_event(event, req)
-        context = CallContext.new(req.env)
-
-        event_handlers(event).each do |block|
-          context.instance_exec(&block)
-        end
-      end
-
-      def self.event_handlers(event = nil)
-        @event_handlers.fetch(event, [])
-      end
-    end
-
-    class Parser
-      def initialize(version: nil)
-        @parser = WebSocket::Frame::Incoming::Server.new(version: version)
-        @handlers = {}
-      end
-
-      def on(event, &block)
-        @handlers[event] = block
-      end
-
-      def <<(data)
-        @parser << data
-        process
-      end
-
-      private
-
-      def process
-        while (frame = @parser.next)
-          case frame.type
-          when :text
-            handle :message, frame
-          when :close
-            handle :close, frame
-          end
-        end
-      end
-
-      def handle(event, frame)
-        return unless @handlers.keys.include?(event)
-        @handlers[event].call(frame.data)
-      end
-    end
-  end
-end

data/pakyow-realtime/lib/pakyow/realtime.rb

@@ -1,19 +0,0 @@
-require 'securerandom'
-require 'json'
-
-require 'pakyow/support'
-require 'pakyow/core'
-require 'pakyow/realtime/helpers'
-require 'pakyow/realtime/hooks'
-require 'pakyow/realtime/context'
-require 'pakyow/realtime/delegate'
-require 'pakyow/realtime/registries/simple_registry'
-require 'pakyow/realtime/registries/redis_registry'
-require 'pakyow/realtime/redis_subscription'
-require 'pakyow/realtime/websocket'
-require 'pakyow/realtime/config'
-require 'pakyow/realtime/exceptions'
-require 'pakyow/realtime/message_handler'
-require 'pakyow/realtime/message_handlers/call_route'
-require 'pakyow/realtime/message_handlers/ping'
-require 'pakyow/realtime/ext/request'

data/pakyow-realtime/lib/pakyow-realtime.rb

@@ -1 +0,0 @@
-require 'pakyow/realtime'