pomelo-citrus-admin 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a3cf2960e29ed5e8afa845d8d11e7e19ed7ab69c
+  data.tar.gz: f06a63aa30a903d6781370a7bbae0848d5b44c52
+SHA512:
+  metadata.gz: 5afb2d8016d05f06e079407be8565b0636fe155ac4164764b3236bd3c89ff673668ee53d1156fff3d16a9fcb26aea7715ddc0da1a97e510e1d13e0445854bd93
+  data.tar.gz: fead007deb6e5bcdae62f3b19ce7b9a499919f35607ca8f79c3b53deae53301f19e3f9277b0a96341c2a1ce2c67c6bab15514799c2289f6f830378be1bbf5e94

data/README.md

@@ -0,0 +1,20 @@
+## Welcome to pomelo-citrus-admin
+
+pomelo-citrus-admin is a simple clone of pomelo-admin written in Ruby using EventMachine.
+
+## Motivation
+
+Since NodeJS is influenced by Ruby EventMachine and Python's Twisted model, Ruby should also be able to have its own game server framework like pomelo.
+
+Ruby is a very expressive and eloquent programming language. I was an RoR programmer before and I really like Ruby, When developing this project, I have used many skills like meta-programming and they give me the real pleasures.
+
+Recently, I would focus on my daily work, so I open source this project and hope to have more people participate in this project.
+
+## Todo
+
+This gem is the very first gem I have done in my whole work, it needs to be improved but it already has the ablity to provide the basic infrastructure to other gems, other gems exist in my own repository.
+
+## Links
+
+* [EventMachine](https://github.com/eventmachine/eventmachine)
+* [pomelo-admin](https://github.com/NetEase/pomelo-admin)

data/citrus-admin.gemspec

@@ -0,0 +1,34 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 8 July 2014
+
+$:.push File.expand_path('../lib', __FILE__)
+
+require 'citrus-admin/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'pomelo-citrus-admin'
+  spec.version     = CitrusAdmin::VERSION
+  spec.platform    = Gem::Platform::RUBY
+  spec.authors     = ['MinixLi']
+  spec.email       = 'MinixLi1986@gmail.com'
+  spec.description = %q{pomelo-citrus-admin is a simple clone of pomelo-admin, it provides an admin module for pomelo monitor system}
+  spec.summary     = %q{pomelo-admin clone written in Ruby using EventMachine}
+  spec.homepage    = 'https://github.com/minixli/pomelo-citrus-admin'
+  spec.license     = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency('eventmachine', '~> 0')
+  spec.add_dependency('json', '~> 0')
+  spec.add_dependency('websocket-eventmachine-client', '~> 0')
+  spec.add_dependency('websocket-eventmachine-server', '~> 0')
+
+  spec.add_dependency('pomelo-citrus-loader', '~> 0')
+  spec.add_dependency('pomelo-citrus-logger', '~> 0')
+  spec.add_dependency('pomelo-citrus-monitor', '~> 0')
+  spec.add_dependency('pomelo-citrus-scheduler', '~> 0')
+end

data/lib/citrus-admin.rb

@@ -0,0 +1,21 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 8 July 2014
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'eventmachine'
+require 'json'
+require 'websocket-eventmachine-client'
+require 'websocket-eventmachine-server'
+
+require 'pomelo-citrus-monitor'
+
+require 'citrus-admin/util/protocol'
+require 'citrus-admin/util/utils'
+require 'citrus-admin/console_service'
+
+# Load all the console modules
+Dir.glob(File.expand_path('../citrus-admin/modules/*.rb', __FILE__)).each { |filepath|
+  require filepath
+}

data/lib/citrus-admin/client/client.rb

@@ -0,0 +1,142 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 12 July 2014
+
+module CitrusAdmin
+  # Client
+  #
+  #
+  class Client
+    include Protocol
+    include Utils::EventEmitter
+
+    # Create a new client
+    #
+    # @param [Hash] args Options
+    #
+    # @option args [String]  :username
+    # @option args [String]  :password
+    # @option args [Boolean] :md5
+    def initialize args={}
+      @client_id = ''
+      @req_id = 1
+      @callbacks = {}
+      @state = :state_inited
+      @username = args[:username] || ''
+      @password = args[:password] || ''
+      @md5 = args[:md5] || false
+    end
+
+    # Connect to master server
+    #
+    # @param [String] client_id
+    # @param [String] host
+    # @param [String] port
+    def connect client_id, host, port, &block
+      @client_id = client_id
+      @ws = WebSocket::EventMachine::Client.connect :uri => 'ws://' + host + ':' + port.to_s
+      @ws.onopen {
+        @state = :state_connected
+        @password = Utils.md5 @password if @md5
+        @ws.send ['register', {
+          :type => 'client',
+          :client_id => @client_id,
+          :username => @username,
+          :password => @password,
+          :md5 => @md5
+        }].to_json
+      }
+      @ws.onmessage { |msg, type|
+        begin
+          event, msg = parse msg
+          case event
+          when 'register'
+            process_register_msg msg, &block
+          when 'client'
+            process_client_msg msg
+          else
+          end
+        rescue => err
+        end
+      }
+      @ws.onclose { |code, reason|
+        @state = :state_closed
+        emit 'close'
+      }
+      @ws.onerror { |err|
+        if @state == :state_inited
+          block_given? and yield err
+        end
+        emit 'error', err
+      }
+    end
+
+    # Request master server with callback
+    #
+    # @param [String] module_id
+    # @param [Object] msg
+    def request module_id, msg, &block
+      req_id = @req_id
+      @req_id += 1
+      @callbacks[req_id] = block
+      msg[:client_id] = @client_id
+      msg[:username] = @username
+      @ws.send ['client', compose_request(req_id, module_id, msg)].to_json
+    end
+
+    # Notify master server without callback
+    #
+    # @param [String] module_id
+    # @param [Object] msg
+    def notify module_id, msg
+      msg[:client_id] = @client_id
+      msg[:username] = @username
+      @ws.send ['client', compose_request(nil, module_id, msg)].to_json
+    end
+
+    # Command
+    #
+    # @param [String] command
+    # @param [String] module_id
+    # @param [Object] msg
+    def command command, module_id, msg, &block
+      req_id = @req_id
+      @req_id += 1
+      @callbacks[req_id] = block
+      msg[:client_id] = @client_id
+      msg[:username] = @username
+      @ws.send ['client', compose_command(req_id, command, module_id, msg)].to_json
+    end
+
+    private
+
+    # Process register message
+    #
+    # @param [Object] msg
+    #
+    # @private
+    def process_register_msg msg, &block
+      if msg[:code] != PRO_OK
+        block_given? and yield msg[:msg]
+        return
+      end
+      @state = :state_registered
+      block_given? and yield
+    end
+
+    # Process client message
+    #
+    # @param [Object] msg
+    #
+    # @private
+    def process_client_msg msg
+      if resp_id = msg[:resp_id]
+        callback = @callbacks[resp_id]
+        @callbacks.delete resp_id
+        callback.call msg[:err], msg[:body]
+      elsif module_id = msg[:module_id]
+        emit module_id, msg
+      end
+    end
+  end
+end

data/lib/citrus-admin/console_service.rb

@@ -0,0 +1,374 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 8 July 2014
+
+require 'citrus-admin/master_agent'
+require 'citrus-admin/monitor_agent'
+
+module CitrusAdmin
+  # ConsoleService
+  #
+  #
+  class ConsoleService
+    include Protocol
+    include Utils; include Utils::EventEmitter
+
+    attr_reader :env, :master, :agent, :auth_user, :auth_server
+
+    # Create a new console service
+    #
+    # @param [Hash] args Options
+    #
+    # @option args [Boolean] :master
+    # @option args [String]  :host
+    # @option args [Integer] :port
+    # @option args [String]  :server_id
+    # @option args [String]  :server_type
+    # @option args [Object]  :server_info
+    # @option args [#call]   :auth_user
+    # @option args [#call]   :auth_server
+    def initialize args={}
+      @env = args[:env]
+      @master = args[:master]
+      @port = args[:port]
+      @console_modules = {}
+      @commands = {
+        :list => methods(:list_command),
+        :enable => methods(:enable_command),
+        :disable => methods(:disable_command)
+      }
+      if @master
+        @auth_user = args[:auth_user] || method(:df_auth_user)
+        @auth_server = args[:auth_server] || method(:df_auth_server_master)
+        args[:console_service] = self
+        @agent = MasterAgent.new args
+      else
+        @host = args[:host]
+        @server_id = args[:server_id]
+        @server_type = args[:server_type]
+        @auth_server = args[:auth_server] || method(:df_auth_server_monitor)
+        @agent = MonitorAgent.new({
+          :console_service => self,
+          :server_id => @server_id,
+          :server_type => @server_type,
+          :server_info => args[:server_info]
+        })
+      end
+    end
+
+    # Start master agent or monitor agent
+    def start &block
+      if @master
+        @agent.listen(@port) { |err|
+          if err
+            block_given? and yield err
+            return
+          end
+
+          @agent.on('register') { |*args| emit 'register', *args }
+          @agent.on('disconnect') { |*args| emit 'disconnect', *args }
+          @agent.on('reconnect') { |*args| emit 'reconnect', *args }
+
+          EM.next_tick {
+            block_given? and yield
+          }
+        }
+      else
+        @agent.connect @port, @host, &block
+      end
+      @console_modules.each { |module_id, console_module|
+        enable_module module_id
+      }
+    end
+
+    # Stop master agent or monitor agent
+    def stop
+      @console_modules.each { |module_id, console_module|
+        disable_module module_id
+      }
+      @agent.close
+    end
+
+    # Register console module
+    #
+    # @param [String] module_id
+    # @param [Object] module_entity
+    def register module_id, module_entity
+      console_module = {
+        :module_id => module_id,
+        :module_entity => module_entity,
+        :enable => false
+      }
+
+      if type = module_entity.type
+        if @master && type == 'pull' || !@master && type == 'push'
+          delay = module_entity.delay
+          interval = module_entity.interval
+          console_module[:delay] = delay ? (delay > 0 ? delay : 0) : 0
+          console_module[:interval] = interval ? (interval > 0 ? interval : 0) : 1
+          console_module[:schedule] = true
+        end
+      end
+
+      @console_modules[module_id] = console_module
+    end
+
+    # Enable console module
+    #
+    # @param [String] module_id
+    def enable_module module_id
+      console_module = @console_modules[module_id]
+      if console_module && !console_module[:enable]
+        console_module[:enable] = true
+        if console_module[:schedule]
+          add_to_scheduler console_module
+        end
+        return true
+      end
+      return false
+    end
+
+    # Disable console module
+    #
+    # @param [String] module_id
+    def disable_module module_id
+      console_module = @console_modules[module_id]
+      if console_module && console_module[:enable]
+        console_module[:enable] = false
+        if console_module[:schedule] && console_module[:job_id]
+          remove_from_scheduler console_module
+        end
+        return true
+      end
+      return false
+    end
+
+    # Execute console module's handler (monitor_handler, master_handler, client_handler)
+    #
+    # @param [String] module_id
+    # @param [String] method
+    # @param [Object] msg
+    def execute module_id, method, msg, &block
+      if !block_given?
+        raise ArgumentError 'expected a code block'
+      end
+
+      console_module = @console_modules[module_id]
+      if !console_module
+        yield 'unknown module id: ' + module_id
+        return
+      end
+      if !console_module[:enable]
+        yield 'module ' + module_id + ' is disabled'
+        return
+      end
+      module_entity = console_module[:module_entity]
+      if !module_entity
+        yield 'module ' + module_id + ' does not exist'
+        return
+      end
+      if !module_entity.respond_to? method
+        yield 'module ' + module_id + ' does not have such method: ' + method
+        return
+      end
+      acl_msg = acl_control 'execute', method, module_id, msg
+      if acl_msg != 0 && acl_msg != 1
+        yield Exception.new acl_msg
+        return
+      end
+      module_entity.send method, @agent, msg, &block
+    end
+
+    # Execute command
+    #
+    # @param [String] command
+    # @param [String] module_id
+    # @param [Object] msg
+    def command command, module_id, msg, &block
+      if !block_given?
+        raise ArgumentError 'expected a code block'
+      end
+
+      method = @commands[command.to_sym]
+      if !method
+        yield 'unknown command: ' + command
+        return
+      end
+      if !method.respond_to? :call
+        yield 'unknown command: ' + command
+        return
+      end
+
+      acl_msg = acl_control 'command', nil, module_id, msg
+      if acl_msg != 0 && acl_msg != 1
+        yield Exception.new acl_msg
+        return
+      end
+
+      method.call module_id, msg, &block
+    end
+
+    private
+
+    # Add console module to scheduler
+    #
+    # @param [Object] console_module
+    #
+    # @private
+    def add_to_scheduler console_module
+      args = [
+        # job_cb
+        method(:schedule_job_cb),
+        # job_cb_args
+        { :console_module => console_module },
+        # trigger_args
+        {
+          :start_time => Time.now.to_f + console_module[:delay],
+          :interval => console_module[:interval]
+        }
+      ]
+      console_module[:job_id] = CitrusScheduler.schedule_job *args
+    end
+
+    # Remove console module from scheduler
+    #
+    # @param [Object] console_module
+    #
+    # @private
+    def remove_from_scheduler console_module
+      CitrusScheduler.cancel_job console_module[:job_id]
+      console_module[:job_id] = nil
+    end
+
+    # Schedule job callback
+    #
+    # @param [Hash] args Options
+    #
+    # @option args [Object] :console_module
+    #
+    # @private
+    def schedule_job_cb args={}
+      console_module = args[:console_module]
+      return if !console_module || !console_module[:enable]
+
+      module_entity = console_module[:module_entity]
+      return if !module_entity
+
+      if @master
+        module_entity.master_handler(@agent, nil) { |err| }
+      else
+        module_entity.monitor_handler(@agent, nil) { |err| }
+      end
+    end
+
+    # List console modules
+    #
+    # @param [String] module_id
+    # @param [Object] msg
+    #
+    # @private
+    def list_command module_id, msg, &block
+      block.call nil, @console_modules.select { |module_id, console_module|
+        !(module_id =~ /^__\w+__$/)
+      }
+    end
+
+    # Enable console module
+    #
+    # @param [String] module_id
+    # @param [Object] msg
+    #
+    # @private
+    def enable_command module_id, msg, &block
+      if !block_given?
+        raise ArgumentError 'expected a code block'
+      end
+      if !@console_modules[module_id]
+        yield nil, PRO_FAIL
+        return
+      end
+      enable_module module_id
+      if @master
+        @agent.broadcast_command 'enable', module_id, msg
+      end
+      yield nil, PRO_OK
+    end
+
+    # Disable console module
+    #
+    # @param [String] module_id
+    # @param [Object] msg
+    #
+    # @private
+    def disable_command module_id, msg, &block
+      if !block_given?
+        raise ArgumentError 'expected a code block'
+      end
+      if !@console_modules[module_id]
+        yield nil, PRO_FAIL
+        return
+      end
+      disable_module module_id
+      if @master
+        @agent.broadcast_command 'disable', module_id, msg
+      end
+      yield nil, PRO_OK
+    end
+
+    # ACL control
+    #
+    # @param [String] action
+    # @param [String] method
+    # @param [String] module_id
+    # @param [Object] msg
+    #
+    # @private
+    def acl_control action, method, module_id, msg
+      if action == 'execute'
+        if method != 'client_handler' || module_id != '__console__'
+          return 0
+        end
+        signal = msg[:signal]
+        if !signal || !(['stop', 'add', 'kill'].include? signal)
+          return 0
+        end
+      end
+      if !client_id = msg[:client_id]
+        return 'unknown client id'
+      end
+      client = @agent.get_client_by_id client_id
+      if client && client[:user_info] && client[:user_info][:level]
+        level = client[:user_info][:level]
+        if level > 1
+          return 'command permission denied'
+        end
+      else
+        return 'unknown client info'
+      end
+      return 1
+    end
+
+    # Create master console service
+    #
+    # @param [Hash] args Options
+    #
+    # @option args [Integer] :port
+    def self.create_master_console args={}
+      args[:master] = true
+      ConsoleService.new args
+    end
+
+    # Create monitor console service
+    #
+    # @param [Hash] args Options
+    #
+    # @option args [String]  :host
+    # @option args [Integer] :port
+    # @option args [String]  :server_id
+    # @option args [String]  :server_type
+    # @option args [Object]  :server_info
+    def self.create_monitor_console args={}
+      ConsoleService.new args
+    end
+  end
+end