tamashii-manager 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3615a69b16faac2730ca38fa2f42161db5e89d50
-  data.tar.gz: 31482ad7e7c1c76fe0dee4651f0b7f21cf53e347
+  metadata.gz: b73434b81719979d45631fb55ee06dbc9c681dfb
+  data.tar.gz: 1271d4bbe0123c2bc284ba716958df9cf3e75f23
 SHA512:
-  metadata.gz: f89bf3e52e8a1121518e385e07b96287d472159e1321ed9ba46dceb484eec2bf5cebd568244f5cf923e7e78307326ca3c9840a6725a352c04c7d9e7d6d1afceb
-  data.tar.gz: c982c585c7088e7e795e28a221c00262d88ad3f88a8d061457002af66a47630b1ad830f37211dc0d345f7e9c4db655c56bb4f81bf1fbf0f1d8c2979faa04a753
+  metadata.gz: da6357c531d820f6f1147c7a8fcf972edaaaedba892db2a75b6553fb96eb09654e063666e4cc8ecaf6334ec5f7a27079ad29273643967bebd28a5c7d1ebe4f9c
+  data.tar.gz: ef266d3eaad776acbb73c66a6f1d3a5c99cc7bace32ec7d2e9b53541a7c13d1af17a26381e63752dd4ded688df3f542e32699c167878e779d57d6ce01a52d37b

data/.ruby-version

@@ -0,0 +1 @@
+2.4.1

data/Gemfile

@@ -2,4 +2,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in codeme-manager.gemspec
 gemspec
-

data/exe/tamashii-manager

@@ -2,36 +2,37 @@
 
 require 'rack'
 require 'optparse'
-require 'tamashii/manager/version'
-require 'tamashii/manager/server'
 require 'tamashii/manager'
 
 options = {
   Port: ENV['PORT'] || 3000,
-  Host: "0.0.0.0",
+  Host: '0.0.0.0',
   AccessLog: []
 }
 
 OptionParser.new do |opts|
-  opts.on("-v", "--version", "Display Tamashii::Manager version") {
+  opts.on('-v', '--version', 'Display Tamashii::Manager version') do
     puts "Tamashii::Manager #{Tamashii::Manager::VERSION}"
     exit
-  }
+  end
 
-  opts.on("-h", "--help") {
+  opts.on('-h', '--help') do
     puts opts
     exit
-  }
-
-  opts.separator ""
-  opts.on("-s", "--server SERVER", "Run Tamashii::Manager server") { |name| handlers.unshift(name.to_s) }
-  opts.on("-o", "--host HOST", "The listen on HOST (default: 0.0.0.0)") { |host| options[:Host] = host.to_s; puts host }
-  opts.on("-p", "--port PORT", "The listen on PORT (default: 3000)") { |port| options[:Port] = port.to_i }
-  opts.on("-C", "--config FILE", "The external configuration file") do |config|
-    if File.exists? config
+  end
+
+  # rubocop:disable Metrics/LineLength
+  opts.separator ''
+  opts.on('-s', '--server SERVER', 'Run Tamashii::Manager server') { |name| handlers.unshift(name.to_s) }
+  opts.on('-o', '--host HOST', 'The listen on HOST (default: 0.0.0.0)') { |host| options[:Host] = host.to_s }
+  opts.on('-p', '--port PORT', 'The listen on PORT (default: 3000)') { |port| options[:Port] = port.to_i }
+  opts.on('-C', '--config FILE', 'The external configuration file') do |config|
+    if File.exist? config
       require config
+      options[:Port] = Tamashii::Manager::Config.port
     end
   end
+  # rubocop:enable Metrics/LineLength
 
   opts.parse! ARGV
 end
@@ -40,10 +41,12 @@ begin
   config = Tamashii::Manager::Config
   case config.auth_type
   when :token
-    raise LoadError.new("Token authorization require to set token") if config.token.nil?
+    # rubocop:disable Metrics/LineLength
+    raise LoadError, 'Token authorization require to set token' if config.token.nil?
+    # rubocop:enable Metrics/LineLength
   end
 
-  Rack::Handler.default.run Tamashii::Manager::Server, options
+  Rack::Handler.default.run Tamashii::Manager.server, options
 rescue LoadError => e
   # TODO: Improve error message
   STDERR.puts e

data/lib/tamashii/manager.rb

@@ -1,23 +1,41 @@
-require "tamashii/manager/server"
-require "tamashii/manager/version"
-require "tamashii/manager/config"
-require "tamashii/manager/authorization"
-require "tamashii/manager/handler/broadcaster"
-require "tamashii/manager/clients"
-require "tamashii/common"
+# frozen_string_literal: true
 
-Tamashii::Resolver.default_handler Tamashii::Manager::Handler::Broadcaster
-Tamashii::Resolver.handle Tamashii::Type::AUTH_TOKEN, Tamashii::Manager::Authorization
+require 'tamashii/server'
+require 'tamashii/common'
+require 'tamashii/manager/version'
+
+require 'tamashii/manager/subscription'
+require 'tamashii/manager/config'
+require 'tamashii/manager/client_manager'
+require 'tamashii/manager/client'
+require 'tamashii/manager/channel'
+require 'tamashii/manager/channel_pool'
+require 'tamashii/manager/authorization'
+require 'tamashii/manager/authorizator'
+require 'tamashii/manager/handler'
+require 'tamashii/manager/error'
+require 'tamashii/manager/server'
 
 module Tamashii
+  # :nodoc:
   module Manager
     def self.config(&block)
-      return Config.class_eval(&block) if block_given?
+      return instance_exec(Config.instance, &block) if block_given?
       Config
     end
 
     def self.logger
-      @logger ||= Tamashii::Logger.new(Config.log_file)
+      @logger ||= ::Logger.new(config.log_file)
+    end
+
+    def self.server
+      @server ||= Tamashii::Manager::Server.new
     end
   end
 end
+
+# TODO: Use block mode to define resolver
+# rubocop:disable Metrics/LineLength
+Tamashii::Resolver.default_handler Tamashii::Manager::Handler::Broadcaster
+Tamashii::Resolver.handle Tamashii::Type::AUTH_TOKEN, Tamashii::Manager::Authorization
+# rubocop:enable Metrics/LineLength

data/lib/tamashii/manager/authorization.rb

@@ -1,16 +1,16 @@
-require "tamashii/manager/errors/authorization_error"
-require "tamashii/manager/authorizator/token"
-require "tamashii/common"
+# frozen_string_literal: true
 
 module Tamashii
   module Manager
+    # :nodoc:
     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.")
+                            raise Error::AuthorizationError,
+                                  'Invalid authorization type.'
                           end
         @env[:client].accept(type, client_id)
       end

data/lib/tamashii/manager/authorizator.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Tamashii
+  module Manager
+    # :nodoc:
+    module Authorizator
+      autoload :Token, 'tamashii/manager/authorizator/token'
+    end
+  end
+end

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

@@ -1,9 +1,9 @@
-require "tamashii/manager/errors/authorization_error"
-require "tamashii/manager/config"
+# frozen_string_literal: true
 
 module Tamashii
   module Manager
     module Authorizator
+      # :nodoc:
       class Token
         attr_reader :client_id
 
@@ -16,8 +16,8 @@ module Tamashii
         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)
+          raise Error::AuthorizationError, "Token mismatch!" unless @authorized = Config.token == token
+          raise Error::AuthorizationError, "Device type not available!" unless Type::CLIENT.values.include?(@type.to_i)
           [@type.to_i, @client_id]
         end
       end

data/lib/tamashii/manager/channel.rb

@@ -1,7 +1,8 @@
-require 'tamashii/manager/channel_pool'
+# frozen_string_literal: true
 
 module Tamashii
   module Manager
+    # :nodoc:
     class Channel < Set
       SERVER_ID = 0
 
@@ -23,7 +24,7 @@ module Tamashii
           when :checkin
             servers
           else
-            return pool.get_idle || pool.create! if pool[client.tag].nil?
+            return pool.idle || pool.create! if pool[client.tag].nil?
             pool[client.tag]
           end
         end
@@ -35,7 +36,9 @@ module Tamashii
 
           pool.ready(channel)
 
-          Manager.logger.info("Client #{client.id} subscribe to Channel ##{channel.id}")
+          Manager.logger.info(
+            "Client #{client.id} subscribe to Channel ##{channel.id}"
+          )
 
           channel
         end
@@ -44,12 +47,18 @@ module Tamashii
           channel = select_channel(client)
           channel.delete(client)
 
-          Manager.logger.info("Client #{client.id} unsubscribe to Channel ##{channel.id}")
+          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
+          idle_channel(channel) if channel.empty? && channel.id != SERVER_ID
+        end
+
+        def idle_channel(channel)
+          pool.idle(channel.id)
+          # rubocop:disable Metrics/LineLength
+          Manager.logger.debug("Channel Pool add - ##{channel.id}, available channels: #{pool.idle.size}")
+          # rubocop:enable Metrics/LineLength
         end
       end
 
@@ -61,7 +70,8 @@ module Tamashii
       end
 
       def send_to(channel_id, packet)
-        return unless channel = Channel.pool[channel_id]
+        channel = Channel.pool[channel_id]
+        return unless channel.nil?
         channel.broadcast(packet)
       end
 
@@ -70,12 +80,15 @@ module Tamashii
         each do |client|
           client.send(packet)
         end
+
+        # rubocop:disable Metrics/LineLength
         Channel.servers.broadcast(packet) unless id == SERVER_ID || exclude_server
+        # rubocop:enable Metrics/LineLength
       end
 
       def broadcast_all(packet)
-        Channel.pool.each do |id, channel|
-          channel.broadcast(packet, true) unless channel.nil?
+        Channel.pool.each do |_id, channel|
+          channel&.broadcast(packet, true)
         end
         Channel.servers.broadcast(packet) unless id == SERVER_ID
       end

data/lib/tamashii/manager/channel_pool.rb

@@ -1,42 +1,39 @@
-require 'tamashii/manager/channel'
+# frozen_string_literal: true
 
 module Tamashii
   module Manager
+    # :nodoc:
     class ChannelPool < Hash
+      attr_reader :idles
+
       def initialize(size = 10)
-        @idle = []
+        @idles = []
         @ptr = 1
 
         size.times { create! }
       end
 
       def create!
-        @idle << Channel.new(@ptr)
+        @idles << Channel.new(@ptr)
         @ptr += 1
       end
 
       def idle(channel_id = nil)
-        return @idle if channel_id.nil?
+        return @idles.first if channel_id.nil?
         return unless self[channel_id]&.empty?
-        @idle << self[channel_id]
+        @idles << 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
+        @idles.delete(channel) if @idles.include?(channel)
         channel
       end
 
       def available?
-        !@idle.empty?
-      end
-
-      def get_idle
-        @idle.first
+        !@idles.empty?
       end
     end
   end

data/lib/tamashii/manager/client.rb

@@ -1,12 +1,10 @@
-require "websocket/driver"
-require "tamashii/manager/stream"
-require "tamashii/manager/channel"
-require "tamashii/manager/authorization"
-require "tamashii/common"
+# frozen_string_literal: true
 
 module Tamashii
   module Manager
-    class Client
+    # :nodoc:
+    class Client < Tamashii::Server::Connection::Base
+      include ClientManager
 
       attr_reader :env, :url
       attr_reader :channel
@@ -16,39 +14,6 @@ module Tamashii
 
       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
@@ -58,17 +23,9 @@ module Tamashii
         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)
+        @socket.transmit(packet)
       end
 
       def authorized?
@@ -79,25 +36,18 @@ module Tamashii
         @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
+        packet = Tamashii::Packet.new(
+          Tamashii::Type::AUTH_RESPONSE,
+          @channel.id,
+          true
+        )
+        Client[id] = self
+        send packet.dump
       end
 
       def beat
         beat_time = Time.now
-        @driver.ping("heart-beat-at-#{beat_time}") do
+        @socket.ping("heart-beat-at-#{beat_time}") do
           heartbeat_callback(beat_time)
         end
       end
@@ -105,36 +55,53 @@ module Tamashii
       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"
+        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)
+      def on_message(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 AuthorizationError => reason
+        close_on_authorize_failed(reason)
       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)}
+        on_message_error(e)
       end
 
-      def on_close(e)
+      def on_close
         Manager.logger.info("Client #{id} closed connection")
-        @stream.close
+        Client[id] = nil
       end
 
       def emit_error(message)
         Manager.logger.error("Client #{id} has error => #{message}")
       end
+
+      private
+
+      def close_on_authorize_failed(reason)
+        Manager.logger.error(
+          "Client #{id} authentication failed => #{reason.message}"
+        )
+        send(Tamashii::Packet.new(Tamashii::Type::AUTH_RESPONSE, 0, false))
+        @socket.close
+      end
+
+      def on_message_error(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
     end
   end
 end

data/lib/tamashii/manager/client_manager.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Tamashii
+  module Manager
+    # :nodoc:
+    module ClientManager
+      # rubocop:disable Metrics/MethodLength
+      def self.included(other)
+        other.class_eval do
+          class << self
+            def accepted_clients
+              @accepted_clients ||= {}
+            end
+
+            def [](name)
+              accepted_clients[name.to_s]
+            end
+
+            def []=(name, client)
+              return unless client.is_a?(Client)
+              accepted_clients[name.to_s] = client
+            end
+
+            def sent_to(id, packet)
+              Manager.server.pubsub.send_to(id, packet)
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/tamashii/manager/config.rb

@@ -1,24 +1,64 @@
+# frozen_string_literal: true
+
 require 'tamashii/common'
+require 'tamashii/configurable'
 
 module Tamashii
   module Manager
-    class Config < Tamashii::Config
-      AUTH_TYPES = [:none, :token]
+    # :nodoc:
+    class Config
+      class << self
+        def instance
+          @instance ||= Config.new
+        end
+
+        def respond_to_missing?(name, _all = false)
+          super
+        end
+
+        def method_missing(name, *args, &block)
+          # rubocop:disable Metrics/LineLength
+          return instance.send(name, *args, &block) if instance.class.exist?(name)
+          # rubocop:enable Metrics/LineLength
+          super
+        end
+      end
+
+      include Tamashii::Configurable
+
+      AUTH_TYPES = %i[none token].freeze
 
       register :auth_type, :none
+      register :token, nil
       register :log_file, STDOUT
+      register :log_level, Logger::INFO
+      register :env, nil
       register :heartbeat_interval, 3
+      register :port, 3000
+
+      def [](key)
+        config(key)
+      end
+
+      def []=(key, value)
+        config(key, value)
+      end
 
       def auth_type(type = nil)
         return self[:auth_type] if type.nil?
         return unless AUTH_TYPES.include?(type)
-        self[:auth_type] = type
+        self.auth_type = type
       end
 
       def log_level(level = nil)
         return Manager.logger.level if level.nil?
         Manager.logger.level = level
       end
+
+      def env(env = nil)
+        return Tamashii::Environment.new(self[:env]) if env.nil?
+        self.env = env.to_s
+      end
     end
   end
 end

data/lib/tamashii/manager/error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Tamashii
+  module Manager
+    # :nodoc:
+    module Error
+      autoload :AuthorizationError, 'tamashii/manager/error/authorization_error'
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Tamashii
+  module Manager
+    module Error
+      class AuthorizationError < RuntimeError
+      end
+    end
+  end
+end

data/lib/tamashii/manager/handler.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Tamashii
+  module Manager
+    # :nodoc:
+    module Handler
+      autoload :Broadcaster, 'tamashii/manager/handler/broadcaster'
+    end
+  end
+end

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

@@ -1,14 +1,18 @@
-require 'tamashii/common'
+# frozen_string_literal: true
 
 module Tamashii
   module Manager
     module Handler
+      # :nodoc:
       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
+          broadcast(client, data) if client.authorized?
+        end
+
+        def broadcast(client, data)
+          packet = Packet.new(@type, client.tag, data)
+          client.channel.broadcast(packet.dump)
         end
       end
     end

data/lib/tamashii/manager/server.rb

@@ -1,80 +1,23 @@
-require "json"
-require "securerandom"
-require "websocket/driver"
-require "monitor"
+# frozen_string_literal: true
 
-require "tamashii/manager/client"
-require "tamashii/manager/stream"
-require "tamashii/manager/stream_event_loop"
+Tamashii::Server.config do |config|
+  config.connection_class = Tamashii::Manager::Client
+  config.pubsub_class = Tamashii::Manager::Subscription
+end
 
 module Tamashii
   module Manager
-    class Server
-      class << self
-        attr_reader :instance
-
-        LOCK = Monitor.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
-
+    # :nodoc:
+    class Server < Tamashii::Server::Base
       def initialize
-        @event_loop = StreamEventLoop.new
+        super
         setup_heartbeat_timer
-
-        Manager.logger.info("Server is created, read for accept connection")
       end
 
+      # NOTE: Move into Tamashii::Server maybe better
       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]
-          ]
+          @event_loop.post { Client.accepted_clients.values.map(&:beat) }
         end
       end
     end

data/lib/tamashii/manager/subscription.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Tamashii
+  module Manager
+    # :nodoc:
+    class Subscription < Tamashii::Server::Subscription::Redis
+      def send_to(id, packet)
+        packet = packet.dump if packet.is_a?(Tamashii::Packet)
+        broadcast([id.bytesize, id.unpack('C*'), packet].flatten)
+      end
+
+      protected
+
+      def process_message(message)
+        operate = unpack(message)
+        head_size = operate.take(1).first
+        return if head_size.zero?
+        target = operate.take(head_size + 1).drop(1)
+        Client[target.pack('C*')]&.send(operate.drop(head_size + 1))
+      end
+    end
+  end
+end

data/lib/tamashii/manager/version.rb

@@ -1,5 +1,5 @@
 module Tamashii
   module Manager
-    VERSION = "0.1.7"
+    VERSION = "0.2.0"
   end
 end

data/tamashii-manager.gemspec

@@ -32,6 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "puma"
   spec.add_runtime_dependency "concurrent-ruby"
   spec.add_runtime_dependency "rack"
+  spec.add_runtime_dependency "tamashii"
   spec.add_runtime_dependency "tamashii-common"
   spec.add_runtime_dependency "websocket-driver"
   spec.add_runtime_dependency "nio4r"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tamashii-manager
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - 蒼時弦也
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-24 00:00:00.000000000 Z
+date: 2017-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: puma
@@ -54,6 +54,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: tamashii
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: tamashii-common
   requirement: !ruby/object:Gem::Requirement
@@ -206,6 +220,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".ruby-version"
 - ".travis.yml"
 - Gemfile
 - Guardfile
@@ -217,18 +232,19 @@ files:
 - exe/tamashii-manager
 - lib/tamashii/manager.rb
 - lib/tamashii/manager/authorization.rb
+- lib/tamashii/manager/authorizator.rb
 - lib/tamashii/manager/authorizator/token.rb
 - lib/tamashii/manager/channel.rb
 - lib/tamashii/manager/channel_pool.rb
 - lib/tamashii/manager/client.rb
-- lib/tamashii/manager/clients.rb
+- lib/tamashii/manager/client_manager.rb
 - lib/tamashii/manager/config.rb
-- lib/tamashii/manager/connection.rb
-- lib/tamashii/manager/errors/authorization_error.rb
+- lib/tamashii/manager/error.rb
+- lib/tamashii/manager/error/authorization_error.rb
+- lib/tamashii/manager/handler.rb
 - lib/tamashii/manager/handler/broadcaster.rb
 - lib/tamashii/manager/server.rb
-- lib/tamashii/manager/stream.rb
-- lib/tamashii/manager/stream_event_loop.rb
+- lib/tamashii/manager/subscription.rb
 - lib/tamashii/manager/version.rb
 - tags
 - tamashii-manager.gemspec

data/lib/tamashii/manager/clients.rb

@@ -1,23 +0,0 @@
-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/connection.rb

@@ -1,23 +0,0 @@
-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

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

data/lib/tamashii/manager/stream.rb

@@ -1,41 +0,0 @@
-require "nio"
-
-require "tamashii/manager/connection"
-
-Thread.abort_on_exception = true
-
-module Tamashii
-  module Manager
-    class Stream
-      
-      attr_reader :event_loop
-
-      def initialize(event_loop, io, client)
-        @client = client
-        @io = io
-        @event_loop = event_loop
-        @event_loop.attach(io, self)
-      end
-
-      def receive(data)
-        @client.parse(data)
-      end
-
-      def shutdown
-        clean_rack_hijack
-      end
-
-      def close
-        shutdown
-        @client.shutdown
-      end
-
-      private
-      def clean_rack_hijack
-        return unless @io
-        @event_loop.detach(@io, self)
-        @io = nil
-      end
-    end
-  end
-end

data/lib/tamashii/manager/stream_event_loop.rb

@@ -1,120 +0,0 @@
-require 'nio'
-require 'thread'
-require 'concurrent'
-
-Thread.abort_on_exception = true
-
-module Tamashii
-  module Manager
-    class StreamEventLoop
-      def initialize
-        @nio = @thread = nil
-        @stopping = false
-        @map = {}
-
-        @todo = Queue.new
-
-        @spawn_mutex = Mutex.new
-      end
-
-      def timer(interval, &block)
-        Concurrent::TimerTask.new(execution_interval: interval, &block).tap(&:execute)
-      end
-
-      def post(task = nil, &block)
-        task ||= block
-        Concurrent.global_io_executor << task
-      end
-
-      def attach(io, stream)
-        @todo << lambda do
-          @map[io] = @nio.register(io, :r)
-          @map[io].value = stream
-        end
-        wakeup
-      end
-
-      def detach(io, stream)
-        @todo << lambda do
-          @nio.deregister io
-          @map.delete io
-          io.close
-        end
-        wakeup
-      end
-
-      def stop
-        @stopping = true
-        wakeup if @nio
-      end
-
-      def stopped?
-        @stopping
-      end
-
-      private
-      def spawn
-        return if @thread && @thread.status
-
-        @spawn_mutex.synchronize do
-          return if @thread && @thread.status
-
-          @nio ||= NIO::Selector.new
-
-          @thread = Thread.new { run }
-
-          return true
-        end
-      end
-
-      def wakeup
-        spawn || @nio.wakeup
-      end
-
-      def run
-        loop do
-          if stopped?
-            @nio.close
-            break
-          end
-
-          until @todo.empty?
-            @todo.pop(true).call
-          end
-
-          next unless monitors = @nio.select
-
-          monitors.each do |monitor|
-            io = monitor.io
-            stream = monitor.value
-
-            begin
-              if monitor.writable?
-                if stream.flush_writer_buffer
-                  monitor.interests = :r
-                end
-                next unless monitor.readable?
-              end
-
-              incoming = io.read_nonblock(4096, exception: false)
-              case incoming
-              when :wait_readable then next
-              when nil then stream.close
-              else
-                stream.receive incoming
-              end
-            rescue
-              begin
-                stream.close
-              rescue
-                @nio.deregister io
-                @map.delete io
-              end
-            end
-          end
-        end
-      end
-
-    end
-  end
-end