mrpin-sdk 0.3.141 → 1.0.2

data/lib/mrpin/controllers/system_controller_base.rb

@@ -0,0 +1,222 @@
+class SystemControllerBase < ApplicationControllerBase
+
+  include ActionView::Helpers::DateHelper
+
+  before_action :authenticate_admin_user!
+
+
+  #
+  # properties
+  #
+
+  protected
+  def get_system_info
+    cpu_load = Vmstat.load_average.to_h
+    cpu_load.each do |key, value|
+      cpu_load[key] = value.round(2)
+    end
+
+    result =
+        {
+            environment:          Rails.env,
+            system:
+                                  {
+                                      'memory, MB'.to_sym  =>
+                                          {
+                                              task:  self.memory_task,
+                                              free:  Vmstat.memory.free_bytes/1024/1024,
+                                              total: Vmstat.memory.total_bytes/1024/1024,
+                                          },
+                                      cpu_load:            cpu_load,
+                                      server_up_time:      get_time(Vmstat.boot_time),
+                                      application_up_time: get_time(AppInfo.instance.boot_time)
+                                  },
+            sdk_version:          Gem.loaded_specs['mrpin-sdk'].version.to_s,
+            available_disk_space: self.available_disk_space,
+            ruby_version:         "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
+        }
+
+    manager_remote = AppInfo.instance.managers_list.detect { |manager| manager.is_a?(ManagerRemoteSocketBase) }
+
+    unless manager_remote.nil?
+      result[:open_sessions]    = manager_remote.sessions.size
+      result[:requests_pending] = manager_remote.requests_pending
+    end
+
+    result
+  end
+
+  protected
+  def available_disk_space
+    begin
+      %x{df -h /}.lines.to_a
+    rescue
+      #do nothing
+    end
+  end
+
+  protected
+  def memory_task
+    begin
+      `ps -o rss -p #{Process::pid}`.chomp.split("\n").last.strip.to_i/1024
+    rescue
+      #do nothing
+    end
+  end
+
+  public
+  def gc_stat
+    result = nil
+
+    begin
+      result = get_response_ok(GC.stat)
+    rescue Exception => e
+      result = get_response_error(e.to_s)
+    end
+
+    render json: result
+  end
+
+  #
+  # methods
+  #
+
+  public
+  def initialize
+    super
+  end
+
+  public
+  def info
+    result = nil
+
+    begin
+      response = get_system_info
+
+      result = get_response_ok(response)
+
+    rescue Exception => e
+      result = get_response_error(e.to_s)
+    end
+
+    render json: result
+  end
+
+  private
+  def get_time(timestamp)
+    result = nil
+
+    unless timestamp.nil?
+      time_ago_in_words(timestamp.utc) + ', ' + timestamp.utc.to_s
+    end
+
+    result
+  end
+
+
+  public
+  def invalidate_cache
+    result = nil
+
+    begin
+      result = AppInfo.instance.invalidate_cache
+    rescue Exception => e
+      result = get_response_error(e.to_s)
+    end
+
+    render json: result
+  end
+
+  public
+  def send_notifications
+    result = nil
+
+    begin
+      manager_notifications = AppInfo.instance.manager_notifications
+
+      unless manager_notifications.nil?
+        manager_notifications.send_notifications
+      end
+
+      result = get_response_ok
+    rescue Exception => e
+      result = get_response_error(e.to_s)
+    end
+
+    render json: result
+  end
+
+  public
+  def cleanup_data
+    result = nil
+
+    begin
+      result = get_response_ok(AppInfo.instance.cleanup_data)
+    rescue Exception => e
+      result = get_response_error(e.to_s)
+    end
+
+    render json: result
+  end
+
+  public
+  def download
+    begin
+      url = get_url_for_download(params['type'])
+
+      assert(!url.nil?, "url is not specified for param #{params['type']}")
+
+      redirect_to(url)
+
+    rescue Exception => e
+      result = get_response_error(e.to_s)
+
+      render json: result
+    end
+
+  end
+
+  private
+  def get_url_for_download(type)
+    result = nil
+
+    case type
+      when 'csv'
+        server_name = AppInfo.instance.server_name
+        result      = authenticated_url(File.join('csv', server_name, "#{server_name}.zip"), 'mrpin-downloads')
+      else
+        result = nil
+    end
+
+    result
+  end
+
+  private
+  def authenticated_url(key, bucket_name, expires_in = 1.hour)
+    s3     = AppInfo.instance.aws_uploader.s3
+    object = s3.buckets[bucket_name].objects[key]
+    object.url_for(:read, expires_in: expires_in).to_s
+  end
+
+  public
+  def generate_client_json
+    begin
+      errors = AppInfo.instance.call_in_all_managers('generate_client_json')
+
+      errors.map!(&:to_s)
+
+      if errors.empty?
+        result = get_response_ok
+      else
+        result = get_response_error(errors)
+      end
+
+    rescue Exception => e
+      result = get_response_error(e.to_s)
+    end
+
+    render json: result
+  end
+
+
+end

data/lib/mrpin/core/admin/admin_user.rb

@@ -0,0 +1,39 @@
+class AdminUser
+  include Mongoid::Document
+  # Include default devise modules. Others available are:
+  # :confirmable, :lockable, :timeoutable and :omniauthable, :registerable, :recoverable,
+  devise :database_authenticatable,
+         :rememberable,
+         :trackable,
+         :validatable
+
+  ## Database authenticatable
+  field :email, type: String, default: ''
+  field :encrypted_password, type: String, default: ''
+
+  ## Recoverable
+  field :reset_password_token, type: String
+  field :reset_password_sent_at, type: Time
+
+  ## Rememberable
+  field :remember_created_at, type: Time
+
+  ## Trackable
+  field :sign_in_count, type: Integer, default: 0
+  field :current_sign_in_at, type: Time
+  field :last_sign_in_at, type: Time
+  field :current_sign_in_ip, type: String
+  field :last_sign_in_ip, type: String
+  field :role, type: String, default: EAdminUserRole::EAUR_ADMIN
+
+  ## Confirmable
+  # field :confirmation_token,   type: String
+  # field :confirmed_at,         type: Time
+  # field :confirmation_sent_at, type: Time
+  # field :unconfirmed_email,    type: String # Only if using reconfirmable
+
+  ## Lockable
+  # field :failed_attempts, type: Integer, default: 0 # Only if lock strategy is :failed_attempts
+  # field :unlock_token,    type: String # Only if unlock strategy is :email or :both
+  # field :locked_at,       type: Time
+end

data/lib/mrpin/core/admin/e_admin_user_role.rb

@@ -0,0 +1,4 @@
+class EAdminUserRole
+  EAUR_ADMIN     = 'admin'
+  EAUR_MODERATOR = 'moderator'
+end

data/lib/mrpin/core/app_config_base.rb

@@ -0,0 +1,48 @@
+class AppConfigBase < ModelBase
+
+  include Mongoid::Document
+
+  #
+  # callbacks
+  #
+
+  after_save :update_config
+
+  #
+  # db
+  #
+
+  store_in collection: 'app_config'
+
+  #
+  # fields
+  #
+
+  field :server_name, type: String
+  field :host, type: String
+
+  field :server_on_maintenance, type: Boolean, default: false
+
+  #
+  # Properties
+  #
+
+  #
+  # Methods
+  #
+
+  # default constructor
+  def initialize(options = nil)
+    super(options)
+  end
+
+  private
+  def update_config
+    AppInfo.instance.on_config_updated
+  end
+
+  #
+  # validates
+  #
+
+end

data/lib/mrpin/core/app_info/app_info_base.rb

@@ -0,0 +1,413 @@
+class AppInfoBase
+
+  include Benchmark
+  include Singleton
+
+  #
+  # Properties
+  #
+
+  attr_reader :logger
+
+  attr_reader :managers_list
+  attr_reader :managers_with_json_list
+
+  attr_reader :managers_bundles_map
+
+  attr_reader :aws_uploader
+
+  attr_reader :boot_time
+
+  attr_reader :config
+
+  attr_reader :state
+
+  protected
+  def state=(value)
+    return if @state == value
+
+    @state = value
+
+    unless @logger.nil?
+      @logger.info("app state is #{@state}")
+    end
+
+    case @state
+      when EAppState::EAS_POST_INIT
+        call_in_all_managers_with_benchmark('[POST_INIT]', 'post_init')
+      when EAppState::EAS_LOAD_INIT_DATA
+        call_in_all_managers_with_benchmark('[LOAD_DATA]', 'load_init_data')
+
+        call_in_all_managers('on_data_loaded')
+      when EAppState::EAS_INIT_PERIODICAL_TASKS
+        init_periodical_tasks
+      when EAppState::EAS_START_MANAGER_TASKS
+        call_in_all_managers('start_tasks', 0.1)
+      when EAppState::EAS_START_REMOTE_SERVERS
+        start_remote_servers
+      when EAppState::EAS_LAUNCH_COMPLETE
+        call_in_all_managers('on_server_started')
+
+        @boot_time = Time.now
+      when EAppState::EAS_MAINTENANCE
+        on_server_maintenance_on
+      when EAppState::EAS_SHUTDOWN_STARTED
+        call_in_all_managers('on_server_shutdown')
+      else
+        #do nothing
+    end
+
+    nil
+  end
+
+  public
+  def host
+    result = nil
+
+    if !@config.nil? && !@config.host.nil?
+      result = @config.host
+    end
+
+    if result.blank?
+      @logger.warn('your forgot setup domain name in AppConfig')
+    end
+
+    if Rails.env.development?
+      result = 'localhost:3000'
+    end
+
+    result
+  end
+
+  public
+  def server_name
+    result = 'unknown'
+
+    unless @config.nil?
+      result = @config.server_name
+    end
+
+    result
+  end
+
+  public
+  def is_server_on_maintenance?
+    @state == EAppState::EAS_MAINTENANCE
+  end
+
+  #
+  # Events
+  #
+
+  public
+  def on_server_shutdown
+    self.state = EAppState::EAS_SHUTDOWN_STARTED
+
+    nil
+  end
+
+  protected
+  def on_server_maintenance_on
+    call_in_all_managers('on_server_maintenance_on')
+
+    nil
+  end
+
+  public
+  def on_config_updated
+    init_config
+  end
+
+
+  public
+  def on_server_error(message, exception = nil, request = nil, player_id = nil)
+    request_class = request.class.to_s
+    player_id     ||= 'unknown'
+
+    exception ||= Exception.new(message)
+
+    stacktrace = exception.backtrace
+
+    stacktrace = caller if stacktrace.nil?
+
+    logger_message = ''
+
+    logger_message += "\nerror message:   #{message}"
+
+    unless request.nil?
+      logger_message += "\nerror request:   #{request}"
+      logger_message += "\nerror request class:   #{request.class}"
+    end
+
+    if Rails.env.development?
+      logger_message += "\nerror player_id: #{player_id}" unless player_id.nil?
+      logger_message += "\nerror stack trace: #{stacktrace}"
+    end
+
+    @logger.error(logger_message)
+
+    if Rails.env.production?
+
+      md5 = Digest::MD5.hexdigest(request_class.to_s + message.to_s)
+
+      error = ErrorServerBase.where(md5: md5).first
+
+      if error.nil?
+        #create
+        error                = ErrorServerBase.new
+        error.first_error_at = Time.now.to_i
+        error.message        = UtilsString.to_utf8(message)
+        error.request_class  = request_class
+        error.md5            = md5
+      end
+
+      player_errors_count = error.players_ids_map[player_id] || 0
+
+      error.last_error_at              = Time.now.to_i
+      error.players_ids_map[player_id] = player_errors_count + 1
+      error.throws_count               += 1
+      error.players_count              = error.players_ids_map.size
+      error.stack_trace                = stacktrace
+
+      error.save!
+    end
+
+
+  end
+
+  #
+  # Methods
+  #
+
+  public
+  def initialize(options = nil)
+    init_logger
+
+    @aws_uploader = AWSUploader.new
+
+    begin
+      init_config
+      init_managers
+    rescue Exception => e
+      on_server_error(e.to_s, e)
+
+      @logger.error "can't start server with error #{e}."
+
+      sleep 60
+
+      exit
+    end
+
+    at_exit do
+      on_server_shutdown
+    end
+
+  end
+
+  private
+  def init_logger
+    @logger           = Logger.new($stdout)
+    @logger.formatter = LoggerSdk.new
+
+    nil
+  end
+
+  protected
+  def init_config
+    config = AppConfigBase.first
+
+    if config.nil?
+      @logger.warn('config is empty')
+      return
+    end
+
+    @config = config
+
+    if @config.server_on_maintenance
+      self.state = EAppState::EAS_MAINTENANCE
+    end
+
+    nil
+  end
+
+  protected
+  def init_managers
+    self.state = EAppState::EAS_INIT_MANAGERS
+
+    @managers_list           = []
+    @managers_with_json_list = []
+    #key - build type, value - manager_bundle
+    @managers_bundles_map    = {}
+
+    @manager_scheduler = nil
+
+    nil
+  end
+
+  public
+  def call_in_all_managers(method_name, delay_between_calls = 0.0)
+    result = []
+
+    @managers_list.each do |manager|
+      next unless manager.respond_to?(method_name)
+
+      begin
+        manager.send(method_name)
+
+        if delay_between_calls > 0
+          sleep(delay_between_calls)
+        end
+
+      rescue Exception => e
+        on_server_error("Error on #{__method__}: #{e.to_s}", e)
+
+        result << e
+      end
+    end
+
+    result
+  end
+
+  public
+  def call_in_all_managers_with_benchmark(benchmark_name, method_name, exit_on_error = true)
+    result = []
+
+    white_spaces_count = 50
+
+    spaces = ' ' * white_spaces_count
+
+    benchmark("#{benchmark_name}\n#{spaces}#{CAPTION}", white_spaces_count, FORMAT) do |benchmark|
+      @managers_list.each do |manager|
+        benchmark.report("#{manager.class.name}") do
+          begin
+            next unless manager.respond_to?(method_name)
+
+            manager.send(method_name)
+          rescue Exception => e
+            on_server_error("Error on #{__method__}: #{e.to_s}", e)
+
+            result << e
+          end
+        end
+      end
+    end
+
+    if !result.empty? && exit_on_error
+      result.each do |e|
+        on_server_error(e.to_s, e)
+      end
+
+      exit
+    end
+
+    result
+  end
+
+  protected
+  def add_manager_bundles(manager)
+    @managers_bundles_map[manager.build_type] = manager
+    @managers_list << manager
+
+    nil
+  end
+
+  protected
+  def create_manager(manager_class)
+    result = manager_class.new
+
+    @managers_list << result
+
+    if result.is_a?(ManagerWithJsonData)
+      @managers_with_json_list << result
+    end
+
+    result
+  end
+
+
+  public
+  def post_init
+
+    self.state = EAppState::EAS_POST_INIT
+
+    self.state = EAppState::EAS_LOAD_INIT_DATA
+
+    self.state = EAppState::EAS_INIT_PERIODICAL_TASKS
+
+    self.state = EAppState::EAS_START_MANAGER_TASKS
+
+    self.state = EAppState::EAS_START_REMOTE_SERVERS
+  end
+
+  protected
+  def start_remote_servers
+    assert(false, 'please override')
+
+    nil
+  end
+
+  #todo:review
+  protected
+  def init_periodical_tasks
+    # Tasks Every
+
+    # @manager_scheduler.scheduler.every '1h', overlap: false, first_in: '30m' do
+
+    # Tasks Cron
+
+    # Minute   Hour   Day of Month       Month          Day of Week
+    # (0-59)  (0-23)     (1-31)    (1-12 or Jan-Dec)  (0-6 or Sun-Sat)
+
+    # every day
+    # @manager_scheduler.scheduler.cron '00 00 * * *' do
+    # every tuesday 14:00
+    # @manager_scheduler.scheduler.cron '00 14 * * 2' do
+  end
+
+  public
+  def invalidate_cache
+    result = nil
+
+    errors = call_in_all_managers_with_benchmark('[INVALIDATE_CACHE]', 'invalidate_cache', false)
+
+    errors.map!(&:to_s)
+
+    if errors.empty?
+      result = get_response_ok
+    else
+      result = get_response_error(errors)
+    end
+
+    result
+  end
+
+  protected
+  def try_create_admin_user(login, password, role)
+    result = AdminUser.where(email: login).first
+
+    if result.nil?
+      result = AdminUser.create!(email: login, password: password, password_confirmation: password, role: role)
+    end
+
+    result
+  end
+
+  public
+  def cleanup_data
+    result = nil
+
+    errors = call_in_all_managers('cleanup_data')
+
+    errors.map!(&:to_s)
+
+    if errors.empty?
+      result = get_response_ok
+    else
+      result = get_response_error(errors)
+    end
+
+    result
+  end
+
+end
+