tamashii-manager 0.1.4

data/lib/tamashii/manager/authorization.rb

@@ -0,0 +1,19 @@
+require "tamashii/manager/errors/authorization_error"
+require "tamashii/manager/authorizator/token"
+require "tamashii/common"
+
+module Tamashii
+  module Manager
+    class Authorization < Tamashii::Handler
+      def resolve(data = nil)
+        type, client_id = case @type
+                          when Tamashii::Type::AUTH_TOKEN
+                            Authorizator::Token.new.verify!(data)
+                          else
+                            raise AuthorizationError.new("Invalid authorization type.")
+                          end
+        @env[:client].accept(type, client_id)
+      end
+    end
+  end
+end

data/lib/tamashii/manager/authorizator/token.rb

@@ -0,0 +1,26 @@
+require "tamashii/manager/errors/authorization_error"
+require "tamashii/manager/config"
+
+module Tamashii
+  module Manager
+    module Authorizator
+      class Token
+        attr_reader :client_id
+
+        def initialize
+          @client_id = nil
+          @authorized = false
+          @type = Type::CLIENT[:agent]
+        end
+
+        def verify!(data)
+          @type, @client_id, token = data.split(",")
+          Manager.logger.debug("Client #{@client_id} try to verify token: #{Config.env.production? ? "FILTERED" : token}")
+          raise AuthorizationError.new("Token mismatch!") unless @authorized = Config.token == token
+          raise AuthorizationError.new("Device type not available!") unless Type::CLIENT.values.include?(@type.to_i)
+          [@type.to_i, @client_id]
+        end
+      end
+    end
+  end
+end

data/lib/tamashii/manager/channel.rb

@@ -0,0 +1,84 @@
+require 'tamashii/manager/channel_pool'
+
+module Tamashii
+  module Manager
+    class Channel < Set
+      SERVER_ID = 0
+
+      class << self
+        def pool
+          @pool ||= ChannelPool.new
+        end
+
+        def get(id)
+          pool[id]
+        end
+
+        def servers
+          @servers ||= Channel.new(SERVER_ID)
+        end
+
+        def select_channel(client)
+          case client.type
+          when :checkin
+            servers
+          else
+            return pool.get_idle || pool.create! if pool[client.tag].nil?
+            pool[client.tag]
+          end
+        end
+
+        def subscribe(client)
+          channel = select_channel(client)
+          channel.add(client)
+          client.tag = channel.id
+
+          pool.ready(channel)
+
+          Manager.logger.info("Client #{client.id} subscribe to Channel ##{channel.id}")
+
+          channel
+        end
+
+        def unsubscribe(client)
+          channel = select_channel(client)
+          channel.delete(client)
+
+          Manager.logger.info("Client #{client.id} unsubscribe to Channel ##{channel.id}")
+
+          if channel.empty? && channel.id != SERVER_ID
+            pool.idle(channel.id)
+            Manager.logger.debug("Channel Pool add - ##{channel.id}, available channels: #{pool.idle.size}")
+          end
+        end
+      end
+
+      attr_reader :id
+
+      def initialize(id, *args)
+        super(*args)
+        @id = id
+      end
+
+      def send_to(channel_id, packet)
+        return unless channel = Channel.pool[channel_id]
+        channel.broadcast(packet)
+      end
+
+      def broadcast(packet, exclude_server = false)
+        Manager.logger.info("Broadcast \"#{packet}\" to Channel ##{@id}")
+        each do |client|
+          client.send(packet)
+        end
+        Channel.servers.broadcast(packet) unless id == SERVER_ID || exclude_server
+      end
+
+      def broadcast_all(packet)
+        Channel.pool.each do |id, channel|
+          channel.broadcast(packet, true) unless channel.nil?
+        end
+        Channel.servers.broadcast(packet) unless id == SERVER_ID
+      end
+    end
+  end
+end

data/lib/tamashii/manager/channel_pool.rb

@@ -0,0 +1,43 @@
+require 'tamashii/manager/channel'
+
+module Tamashii
+  module Manager
+    class ChannelPool < Hash
+      def initialize(size = 10)
+        @idle = []
+        @ptr = 1
+
+        size.times { create! }
+      end
+
+      def create!
+        @idle << Channel.new(@ptr)
+        @ptr += 1
+      end
+
+      def idle(channel_id = nil)
+        return @idle if channel_id.nil?
+        return unless self[channel_id]&.empty?
+        @idle << self[channel_id]
+        self[channel_id] = nil
+      end
+
+      def ready(channel)
+        return if channel.empty?
+        self[channel.id] = channel
+        if @idle.include?(channel)
+          @idle.delete(channel)
+        end
+        channel
+      end
+
+      def available?
+        !@idle.empty?
+      end
+
+      def get_idle
+        @idle.first
+      end
+    end
+  end
+end

data/lib/tamashii/manager/client.rb

@@ -0,0 +1,140 @@
+require "websocket/driver"
+require "tamashii/manager/stream"
+require "tamashii/manager/channel"
+require "tamashii/manager/authorization"
+require "tamashii/common"
+
+module Tamashii
+  module Manager
+    class Client
+
+      attr_reader :env, :url
+      attr_reader :channel
+
+      attr_reader :last_beat_timestamp
+      attr_reader :last_response_time
+
+      attr_accessor :tag
+
+      def self.accepted_clients
+        Clients.instance
+      end
+
+      def initialize(env, event_loop)
+        @env = env
+        @id = nil
+        @type = Type::CLIENT[:agent]
+        @last_beat_timestamp = Time.at(0)
+        @last_response_time = Float::INFINITY
+
+        secure = Rack::Request.new(env).ssl?
+        scheme = secure ? 'wss:' : 'ws:'
+        @url = "#{scheme}//#{env['HTTP_HOST']}#{env['REQUEST_URI']}"
+
+        Manager.logger.info("Accept connection from #{env['REMOTE_ADDR']}")
+
+        @driver = WebSocket::Driver.rack(self)
+
+        env['rack.hijack'].call
+        @io = env['rack.hijack_io']
+
+        Connection.register(self)
+        @stream = Stream.new(event_loop, @io, self)
+
+        @driver.on(:open)    { |e| on_open }
+        @driver.on(:message) { |e| receive(e.data) }
+        @driver.on(:close)   { |e| on_close(e) }
+        @driver.on(:error)   { |e| emit_error(e.message) }
+
+        @driver.start
+      end
+
+      def id
+        return "<Unauthorized : #{@env['REMOTE_ADDR']}>" if @id.nil?
+        @id
+      end
+
+      def type
+        Type::CLIENT.key(@type)
+      end
+
+      def write(buffer)
+        @io.write(buffer)
+      end
+
+      def send(packet)
+        packet = packet.dump if packet.is_a?(Tamashii::Packet)
+        @driver.binary(packet)
+      end
+
+      def parse(buffer)
+        @driver.parse(buffer)
+      end
+
+      def authorized?
+        !@id.nil?
+      end
+
+      def accept(type, id)
+        @id = id
+        @type = type
+        @channel = Channel.subscribe(self)
+        Clients.register(self)
+        send(Tamashii::Packet.new(Tamashii::Type::AUTH_RESPONSE, @channel.id, true).dump)
+      end
+
+      def close
+        @driver.close
+      end
+
+      def shutdown
+        Connection.unregister(self)
+        if authorized?
+          Channel.unsubscribe(self)
+          Clients.unregister(self)
+        end
+      end
+      
+      def beat
+        beat_time = Time.now
+        @driver.ping("heart-beat-at-#{beat_time}") do
+          heartbeat_callback(beat_time)
+        end
+      end
+
+      def heartbeat_callback(beat_time)
+        @last_beat_timestamp = Time.now
+        @last_response_time = @last_beat_timestamp - beat_time
+        Manager.logger.debug "[#{@id}] Heart beat #{beat_time} returns at #{@last_beat_timestamp}! Delay: #{(@last_response_time * 1000).round} ms" 
+      end
+
+      private
+      def on_open
+        Manager.logger.info("Client #{id} is ready")
+      end
+
+      def receive(data)
+        Manager.logger.debug("Receive Data: #{data}")
+        return unless data.is_a?(Array)
+        Tamashii::Resolver.resolve(Tamashii::Packet.load(data), client: self)
+      rescue AuthorizationError => e
+        Manager.logger.error("Client #{id} authentication failed => #{e.message}")
+        send(Tamashii::Packet.new(Tamashii::Type::AUTH_RESPONSE, 0, false))
+        @driver.close
+      rescue => e
+        Manager.logger.error("Error when receiving data from client #{id}: #{e.message}")
+        Manager.logger.debug("Backtrace:")
+        e.backtrace.each {|msg| Manager.logger.debug(msg)}
+      end
+
+      def on_close(e)
+        Manager.logger.info("Client #{id} closed connection")
+        @stream.close
+      end
+
+      def emit_error(message)
+        Manager.logger.error("Client #{id} has error => #{message}")
+      end
+    end
+  end
+end

data/lib/tamashii/manager/clients.rb

@@ -0,0 +1,23 @@
+module Tamashii
+  module Manager
+    class Clients < Hash
+      class << self
+        def method_missing(name, *args, &block)
+          self.instance.send(name, *args, &block)
+        end
+
+        def instance
+          @instance ||= new
+        end
+      end
+
+      def register(client)
+        self[client.id] = client
+      end
+
+      def unregister(client)
+        self.delete(client.id)
+      end
+    end
+  end
+end

data/lib/tamashii/manager/config.rb

@@ -0,0 +1,24 @@
+require 'tamashii/common'
+
+module Tamashii
+  module Manager
+    class Config < Tamashii::Config
+      AUTH_TYPES = [:none, :token]
+
+      register :auth_type, :none
+      register :log_file, STDOUT
+      register :heartbeat_interval, 3
+
+      def auth_type(type = nil)
+        return self[:auth_type] if type.nil?
+        return unless AUTH_TYPES.include?(type)
+        self[:auth_type] = type
+      end
+
+      def log_level(level = nil)
+        return Manager.logger.level if level.nil?
+        Manager.logger.level = level
+      end
+    end
+  end
+end

data/lib/tamashii/manager/connection.rb

@@ -0,0 +1,23 @@
+module Tamashii
+  module Manager
+    class Connection < Set
+      class << self
+        def instance
+          @instance ||= Connection.new
+        end
+
+        def register(client)
+          instance.add(client)
+        end
+
+        def unregister(client)
+          instance.delete(client)
+        end
+
+        def available?
+          !instance.empty?
+        end
+      end
+    end
+  end
+end

data/lib/tamashii/manager/errors/authorization_error.rb

@@ -0,0 +1,6 @@
+module Tamashii
+  module Manager
+    class AuthorizationError < RuntimeError
+    end
+  end
+end

data/lib/tamashii/manager/handler/broadcaster.rb

@@ -0,0 +1,16 @@
+require 'tamashii/common'
+
+module Tamashii
+  module Manager
+    module Handler
+      class Broadcaster < Tamashii::Handler
+        def resolve(data = nil)
+          client = @env[:client]
+          if client.authorized?
+            client.channel.broadcast(Packet.new(@type, client.tag , data).dump)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tamashii/manager/server.rb

@@ -0,0 +1,81 @@
+require "json"
+require "securerandom"
+require "websocket/driver"
+
+require "tamashii/manager/client"
+require "tamashii/manager/stream"
+require "tamashii/manager/stream_event_loop"
+
+module Tamashii
+  module Manager
+    class Server
+      class << self
+        attr_reader :instance
+
+        LOCK = Mutex.new
+
+        def compile
+          @instance ||= new
+        end
+
+        def call(env)
+          LOCK.synchronize { compile } unless instance
+          call!(env)
+        end
+
+        def call!(env)
+          instance.call(env)
+        end
+      end
+
+      def initialize
+        @event_loop = StreamEventLoop.new
+        setup_heartbeat_timer
+
+        Manager.logger.info("Server is created, read for accept connection")
+      end
+
+      def setup_heartbeat_timer
+        @heartbeat_timer = @event_loop.timer(Config.heartbeat_interval) do
+          @event_loop.post { Connection.instance.map(&:beat) }
+        end
+      end
+
+      def call(env)
+        if WebSocket::Driver.websocket?(env)
+          Client.new(env, @event_loop)
+          # A dummy rack response
+          body = {
+            message: "WS connected",
+            version: Tamashii::Manager::VERSION
+          }.to_json
+
+          [
+            200,
+            {
+              "Content-Type" => "application/json",
+              "Content-Length" => body.bytesize
+            },
+            [body]
+          ]
+        else
+
+          # TODO: Handle HTTP API
+          body = {
+            message: "Invalid protocol or api request",
+            version: Tamashii::Manager::VERSION
+          }.to_json
+
+          [
+            404,
+            {
+              "Content-Type" => "application/json",
+              "Content-Length" => body.bytesize
+            },
+            [body]
+          ]
+        end
+      end
+    end
+  end
+end