mrpin-sdk 0.3.141 → 1.0.2

data/lib/mrpin/core/remote/socket/base/extensions/manager_remote_socket_disconnect.rb

@@ -0,0 +1,69 @@
+module ManagerRemoteSocketDisconnect
+
+  #
+  # properties
+  # 
+
+  #
+  # methods
+  #
+
+  protected
+  def send_response_and_close(session, response)
+    session.should_disconnect_session = false
+    session.send_response(response)
+    session.close_connection_after_writing
+
+    nil
+  end
+
+  public
+  def disconnect_inactive
+    response             = Api::ResponseSessionEnd.new
+    response.description = EStringTypeBase::EST_ERROR_PLAYER_INACTIVE
+
+    inactive_players_count = 0
+
+    @sessions_locker.synchronize do
+
+      time_last_request = Time.now.to_i - 20.minutes
+
+      @sessions.reject! do |session|
+
+        result = session.time_last_request < time_last_request
+
+        if result
+          send_response_and_close(session, response)
+
+          inactive_players_count += 1
+        end #if
+
+        result
+      end #reject!
+
+    end #mutex
+
+    @logger.info "disconnect inactive #{inactive_players_count} players"
+
+    nil
+  end
+
+  public
+  def disconnect_all_with_message(message)
+    response             = Api::ResponseSessionEnd.new
+    response.description = message
+
+    @logger.info "disconnect all with #{message}"
+
+    @sessions_locker.synchronize do
+      @sessions.each do |session|
+        send_response_and_close(session, response)
+      end
+
+      @sessions.clear
+    end
+
+    nil
+  end
+
+end

data/lib/mrpin/core/remote/socket/base/extensions/manager_remote_socket_handle.rb

@@ -0,0 +1,155 @@
+module ManagerRemoteSocketHandle
+
+  #
+  # properties
+  #
+
+  public
+  def requests_pending
+    result = 0
+
+    @sessions_with_requests_locker.synchronize do
+      result = @sessions_with_requests.size
+    end
+
+    result
+  end
+
+  #
+  # events
+  #
+
+  protected
+  def on_request_handler_is_nil(session, request, request_id)
+    error = "can't find handler for request: #{request.class}"
+
+    AppInfo.instance.on_server_error(error)
+
+    session.send_response_error(request_id, error)
+
+    nil
+  end
+
+  #
+  # methods
+  #
+
+  private
+  def init_handle
+    @sessions_with_requests        = []
+    @sessions_with_requests_locker = Mutex.new
+
+    nil
+  end
+
+  protected
+  def create_handler(index)
+    result = ThreadWithTask.new(0.01, "thread_remote_handler_#{index}", 0.01)
+
+    result.run do
+      session = nil
+
+      @sessions_with_requests_locker.synchronize do
+        session = @sessions_with_requests.shift
+      end
+
+      next if session.nil?
+
+      requests = session.get_requests
+
+      requests.each do |request|
+
+        if Rails.env.development?
+          request.report_log("received\t") if request.respond_to?(:report_log)
+        end
+
+        try_handle_request(session, request)
+
+      end #synchronize
+
+      nil #for prevent return other value
+
+    end #thread
+
+    result
+  end
+
+
+  protected
+  def try_handle_request(session, request)
+    if request.nil?
+      AppInfo.instance.on_server_error('request should be non nil')
+      return
+    end
+
+    begin
+
+      handler = @handlers_map[request.class]
+
+      if handler.nil? #something wrong
+
+        request_id = -1
+
+        if request.is_a? AMF::HashWithType
+          request_id = request[:request_id]
+
+          @logger.warn "you forgot register class #{request.class_type}"
+        elsif request.respond_to?(:request_id)
+          request_id = request.request_id
+        end
+
+        on_request_handler_is_nil(session, request, request_id)
+
+      else #just handle request
+        handler.handle_request(session, request)
+        handler.post_handle(Time.now)
+      end
+
+    rescue Exception => e
+
+      player_id = nil
+
+      if session.respond_to?(:player) && !session.player.nil?
+        player_id = session.player.id
+      end
+
+      if player_id.nil?
+        player_id = request.player_id if request.respond_to?(:player_id)
+      end
+
+      AppInfo.instance.on_server_error(e.to_s, e, request, player_id)
+
+      request_id = request.respond_to?(:request_id) ? request.request_id : -1
+
+      #send error if can't handle
+      session.send_response_error(request_id, EStringTypeBase::EST_ERROR_UNKNOWN)
+
+    end
+
+    nil
+  end
+
+  protected
+  def check_request_class(request)
+    return if request.is_a?(Api::RequestBase)
+
+    if request.is_a?(AMF::HashWithType)
+      assert(false, "You forgot register request class #{request.class_type}")
+    else
+      assert(false, "Unsupported request class #{request.class}")
+    end
+
+    nil
+  end
+
+  public
+  def handle_data_from(session)
+    @sessions_with_requests_locker.synchronize do
+      @sessions_with_requests << session
+    end
+
+    nil
+  end
+
+
+end

data/lib/mrpin/core/remote/socket/base/extensions/manager_remote_socket_sessions.rb

@@ -0,0 +1,41 @@
+module ManagerRemoteSocketSessions
+
+  #
+  # properties
+  #
+
+  #
+  # events
+  #
+
+  public
+  def on_client_connected(session)
+    @sessions_locker.synchronize do
+      @sessions << session
+    end
+
+    nil
+  end
+
+  public
+  def on_client_disconnected(session)
+    @sessions_locker.synchronize do
+      @sessions.delete(session)
+    end
+
+    nil
+  end
+
+  #
+  # methods
+  #
+
+  public
+  def init_sessions
+    @sessions        = []
+    @sessions_locker = Mutex.new
+
+    nil
+  end
+
+end

data/lib/mrpin/core/remote/socket/base/extensions/manager_remote_socket_statistic.rb

@@ -0,0 +1,41 @@
+module ManagerRemoteSocketStatistic
+
+  #
+  # properties
+  # 
+
+  #
+  # methods
+  #
+
+  public
+  def store_handler_profiler_data
+    return unless Rails.env.production?
+
+    timestamp = Time.now.to_i
+
+    handlers = @handlers_map.values
+
+    handlers.each do |handler|
+
+      next if handler.requests_count == 0
+
+      handle_stats = SystemHandlerProfiler.new
+
+      handle_stats.handler                      = handler.class.to_s
+      handle_stats.requests_count               = handler.requests_count
+      handle_stats.requests_handle_duration_ms  = handler.handle_duration_total
+      handle_stats.requests_handle_duration_max = handler.handle_duration_max
+      handle_stats.requests_handle_duration_min = handler.handle_duration_min
+      handle_stats.requests_handle_duration_avg = handler.handle_duration_total / handle_stats.requests_count
+
+      handle_stats.timestamp = timestamp
+
+      handle_stats.save!
+
+      handler.reset_handler_stats
+
+    end
+  end
+
+end

data/lib/mrpin/core/remote/socket/base/extensions/network_interface_helper.rb

@@ -0,0 +1,53 @@
+module NetworkInterfaceHelper
+
+  protected
+  def get_ip
+    result = self.my_first_public_ipv4
+
+    result = self.my_first_private_ipv4 if result.nil?
+
+    result = '127.0.0.1' if result.nil?
+
+    result
+  end
+
+  protected
+  def my_first_private_ipv4
+    result = nil
+
+    addr_info = Socket.ip_address_list.detect do |intf|
+      intf.ipv4_private?
+    end
+
+    result    = addr_info.ip_address unless addr_info.nil?
+
+    result
+  end
+
+  protected
+  def my_first_public_ipv4
+    result = nil
+
+    addr_info = Socket.ip_address_list.detect do |intf|
+      intf.ipv4? and !intf.ipv4_loopback? and !intf.ipv4_multicast? and !intf.ipv4_private?
+    end
+
+    result    = addr_info.ip_address unless addr_info.nil?
+
+    result
+  end
+
+  protected
+  def my_public_ipv4_aws
+    result = nil
+
+    begin
+      result = `wget -qO- http://instance-data/latest/meta-data/public-ipv4`
+    rescue Exception => e
+      AppInfo.instance.on_server_error(e, e)
+    end
+
+    result
+  end
+
+end

data/lib/mrpin/core/remote/socket/base/manager_remote_socket_base.rb

@@ -0,0 +1,131 @@
+class ManagerRemoteSocketBase < ManagerBase
+
+  include ManagerRemoteSocketApi
+  include ManagerRemoteSocketDisconnect
+  include ManagerRemoteSocketHandle
+  include ManagerRemoteSocketSessions
+  include ManagerRemoteSocketStatistic
+  include NetworkInterfaceHelper
+
+  #
+  # Properties
+  #
+
+  attr_reader :ip
+  attr_reader :port
+  attr_reader :port_secure
+
+  attr_reader :sessions
+
+  protected
+  def default_port
+    assert(false, 'please override')
+  end
+
+  protected
+  def server_type
+    'unknown'
+  end
+
+  #
+  # Events
+  #
+
+  public
+  def on_client_request_policy(session)
+    #do nothing
+  end
+
+  public
+  def on_server_shutdown
+    super
+
+    disconnect_all_with_message(EStringTypeBase::EST_ERROR_SERVER_SHUTDOWN)
+
+    nil
+  end
+
+  public
+  def on_server_maintenance_on
+    self.disconnect_all_with_message(EStringTypeBase::EST_ERROR_SERVER_ON_MAINTENANCE)
+
+    nil
+  end
+
+  #
+  # Methods
+  #
+
+  # default constructor
+  public
+  def initialize
+    super
+
+    init_api
+    init_handle
+    init_sessions
+  end
+
+  public
+  def post_init
+    super
+
+    register_classes
+    register_handlers
+
+    Constants::THREADS_HANDLERS_COUNT.times do |n|
+      create_handler(n)
+    end
+
+    nil
+  end
+
+  def start!(callback = nil)
+    begin
+      descriptor_size = EventMachine.set_descriptor_table_size(60000)
+
+      @logger.info "descriptors size is #{descriptor_size}"
+
+    rescue Exception => e
+      AppInfo.instance.on_server_error(e.to_s, e)
+    end
+  end
+
+  protected
+  def start_server_on_port(port, client_class, continue_after_error = true, callback = nil)
+    thread = Thread.new do
+
+      client_class.manager_remote = self if client_class.respond_to?('manager_remote=')
+
+      begin
+
+        EventMachine.epoll
+
+        EventMachine.run do
+
+          ip = '0.0.0.0'
+
+          EventMachine.start_server(ip, port, client_class)
+
+          @logger.info "server #{self.server_type}\t\tstarted on #{ip}:#{port}"
+
+          callback.call unless callback.nil?
+        end
+      rescue Exception => e
+        message = "error on server #{ip}:#{port} thread: #{e}"
+
+        AppInfo.instance.on_server_error(message, e)
+
+        sleep 10
+
+        retry if continue_after_error
+
+      end
+    end
+
+    thread.name = "thread_remote_server_#{ip}:#{port}"
+
+    nil
+  end
+
+end

data/lib/mrpin/core/remote/socket/base/socket_client_base.rb

@@ -0,0 +1,181 @@
+class SocketClientBase < EM::Connection
+
+  #
+  # static fields
+  #
+
+  public
+  def self.manager_remote=(value)
+    @manager_remote = value
+  end
+
+  public
+  def self.manager_remote
+    @manager_remote
+  end
+
+  #
+  # Properties
+  #
+  attr_reader :time_last_request
+  attr_reader :ip
+
+  #use for disconnect_inactive_players and on_application_exit
+  attr_accessor :should_disconnect_session
+
+  attr_accessor :player
+
+  public
+  def is_online?
+    @is_online
+  end
+
+  #
+  # Events
+  #
+
+  protected
+  def on_get_requests_error(e)
+    AppInfo.instance.on_server_error("Error on get_requests #{e}", e)
+  end
+
+  #
+  # Methods
+  #
+
+  # default constructor
+  public
+  def post_init
+    @logger = AppInfo.instance.logger
+
+    @requests_locker = Mutex.new
+
+    @is_online = true
+
+    @time_last_request = Time.now.to_i
+
+    @should_disconnect_session = true
+
+    @manager_remote = self.class.manager_remote
+    @manager_remote.on_client_connected(self)
+
+    @data_buffer = ''
+
+    @player = nil
+
+    init_ip
+
+    nil
+  end
+
+  protected
+  def init_ip
+    init_ip_internal(get_peername)
+
+    nil
+  end
+
+  protected
+  def init_ip_internal(peername)
+    @ip = Socket.unpack_sockaddr_in(get_peername).last rescue '0.0.0.0'
+
+    @logger.info "connection from #{@ip} complete"
+
+    nil
+  end
+
+  public
+  def receive_data(data)
+    @time_last_request = Time.now.to_i
+
+    @requests_locker.synchronize do
+      @data_buffer += data
+    end
+
+    @manager_remote.handle_data_from(self)
+
+    nil
+  end
+
+  public
+  def get_requests
+    result = []
+
+    return result unless @is_online
+
+    @requests_locker.synchronize do
+      begin
+
+        unless @data_buffer.empty?
+          deserialize_data = AMF::Root.deserialize(@data_buffer)
+          result           = deserialize_data[:objects]
+          @data_buffer     = deserialize_data[:incomplete_objects] || ''
+        end
+
+      rescue Exception => e
+        on_get_requests_error(e)
+      end #begin/rescue
+    end #synchronize
+
+    result
+  end
+
+
+  public
+  def send_response(response_obj)
+    return unless @is_online
+
+    report_about_sent_request(response_obj)
+
+    response = AMF::Root.serialize(response_obj)
+
+    send_data(response)
+
+    nil #for prevent return other value
+  end
+
+  if Rails.env.development?
+    protected
+    def report_about_sent_request(value)
+      value.report_log("sent\t\t") if value.respond_to?(:report_log)
+
+      nil
+    end
+  else
+    protected
+    def report_about_sent_request(value)
+      #do nothing
+    end
+  end
+
+
+  public
+  def send_raw_data(raw_data)
+    send_data(raw_data)
+  end
+
+  public
+  def send_response_ok(request_id)
+    response = Api::ResponseOk.new(request_id)
+
+    send_response(response)
+  end
+
+  public
+  def send_response_error(request_id, description = nil)
+    response             = Api::ResponseError.new(request_id)
+    response.description = description
+
+    send_response(response)
+  end
+
+  public
+  def unbind
+    @is_online = false
+
+    @manager_remote.on_client_disconnected(self) if @should_disconnect_session
+
+    nil
+  end
+
+end

data/lib/mrpin/core/remote/socket/base/socket_client_crossdomain.rb

@@ -0,0 +1,33 @@
+class SocketClientCrossdomain < EM::Connection
+
+  #
+  # Properties
+  #
+
+  public
+  def self.manager_remote=(value)
+    @manager_remote = value
+  end
+
+  public
+  def self.manager_remote
+    @manager_remote
+  end
+
+  #
+  # Methods
+  #
+
+  public
+  def post_init
+    @manager_remote = self.class.manager_remote
+  end
+
+  public
+  def receive_data(data)
+    @manager_remote.on_client_request_policy(self)
+
+    AppInfo.instance.logger.info 'use 843 port for crossdomain.xml'
+  end
+
+end