pomelo-citrus 0.0.1

data/lib/citrus/common/remote/frontend/session_remote.rb

@@ -0,0 +1,108 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 24 July 2014
+
+module Citrus
+  # Common
+  #
+  #
+  module Common
+    # Remote
+    #
+    #
+    module Remote
+      # Frontend
+      #
+      #
+      module Frontend
+        # SessionRemote
+        #
+        #
+        class SessionRemote
+          # Create a new remote session service
+          #
+          # @param [Object] app
+          def initialize app
+            @app = app
+          end
+
+          # Bind the session with a user id
+          #
+          # @param [Integer] sid
+          # @param [String]  uid
+          def bind sid, uid, &block
+            @app.session_service.bind sid, uid, &block
+          end
+
+          # Unbind the session with a user id
+          #
+          # @param [Integer] sid
+          # @param [String]  uid
+          def unbind sid, uid, &block
+            @app.session_service.unbind sid, uid, &block
+          end
+
+          # Push the key/value into session
+          #
+          # @param [Integer] sid
+          # @param [String]  key
+          # @param [Hash]    value
+          def push sid, key, value, &block
+            @app.session_service.import sid, key, value, &block
+          end
+
+          # Push new value for the existed session
+          #
+          # @param [Integer] sid
+          # @param [Hash]    settings
+          def pushAll sid, settings, &block
+            @app.session_service.import_all sid, settings, &block
+          end
+
+          # Get session information with session id
+          #
+          # @param [Integer] sid
+          def getBackendSessionBySid sid, &block
+            session = @app.session_service.get sid
+            unless session
+              block_given? and yield
+              return
+            end
+            block_given? and yield nil, session.to_frontend_session.export
+          end
+
+          # Get all the session information the specified user id
+          #
+          # @param [String] uid
+          def getBackendSessionByUid uid, &block
+            sessions = @app.session_service.get_by_uid uid
+            unless session
+              block_given? and yield
+              return
+            end
+
+            res = []
+            sessions.each { |session|
+              res << session.to_frontend_session.export
+            }
+            block_given? and yield nil, res
+          end
+
+          # Kick a session by session id
+          #
+          # @param [Integer] sid
+          def kickBySid sid, &block
+            @app.session_service.kick_by_sid sid, &block
+          end
+
+          # Kick sessions by user id
+          #
+          # @param [String] uid
+          def kickByUid uid, &block
+            @app.session_service.kick uid, &block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/citrus/common/service/backend_session_service.rb

@@ -0,0 +1,265 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 28 July 2014
+
+module Citrus
+  # Common
+  #
+  #
+  module Common
+    # Service
+    #
+    #
+    module Service
+      # BackendSessionService
+      #
+      #
+      class BackendSessionService
+        #
+        #
+        #
+        EXPORTED_FIELDS = ['id', 'frontend_id', 'uid', 'settings']
+
+        # Initialize the service
+        #
+        # @param [Object] app
+        def initialize app
+          @app = app
+        end
+
+        # Create a new backend session
+        #
+        # @param [Hash] args
+        def create args={}
+          if args.empty?
+            throw Exception.new 'args should not be empty'
+          end
+          BackendSession.new args, self
+        end
+
+        # Get backend session by frontend server id and session id
+        #
+        # @param [String]  frontend_id
+        # @param [Integer] sid
+        def get frontend_id, sid, &block
+          namespace = 'sys'
+          service = 'sessionRemote'
+          method = 'getBackendSessionBySid'
+          args = [sid]
+          rpc_invoke(frontend_id, namespace, service, method,
+                  args, &backend_session_cb.bind(nil, block))
+        end
+
+        # Get backend sessions by frontend server id and user id
+        #
+        # @param [String] frontend_id
+        # @param [String] uid
+        def get_by_uid frontend_id, uid, &block
+          namespace = 'sys'
+          service = 'sessionRemote'
+          method = 'getBackendSessionByUid'
+          args = [uid]
+          rpc_invoke(server_id, namespace, service, method,
+                  args, &backend_session_cb.bind(nil, block))
+        end
+
+        # Kick a session by session id
+        #
+        # @param [String]  frontend_id
+        # @param [Integer] sid
+        def kick_by_sid frontend_id, sid, &block
+          namespace = 'sys'
+          service = 'sessionRemote'
+          method = 'kickBySid'
+          args = [sid]
+          rpc_invoke(frontend_id, namespace, service, method, args, &block)
+        end
+
+        # Kick sessions by user id
+        #
+        # @param [String] frontend_id
+        # @param [String] uid
+        def kick_by_uid frontend_id, uid, &block
+          namespace = 'sys'
+          service = 'sessionRemote'
+          method = 'kickByUid'
+          args = [uid]
+          rpc_invoke(frontend_id, namespace, service, method, args, &block)
+        end
+
+        # Bind the session with the specified user id
+        #
+        # @param [String]  frontend_id
+        # @param [Integer] sid
+        # @param [String]  uid
+        def bind frontend_id, sid, uid, &block
+          namespace = 'sys'
+          service = 'sessionRemote'
+          method = 'bind'
+          args = [sid, uid]
+          rpc_invoke(frontend_id, namespace, service, method, args, &block)
+        end
+
+        # Unbind the session with the specified user id
+        #
+        # @param [String]  frontend_id
+        # @param [Integer] sid
+        # @param [String]  uid
+        def unbind frontend_id, sid, uid, &block
+          namespace = 'sys'
+          service = 'sessionRemote'
+          method = 'unbind'
+          args = [sid, uid]
+          rpc_invoke(frontend_id, namespace, service, method, args, &block)
+        end
+
+        # Push the specified customized change to the frontend internal session
+        #
+        # @param [String]  frontend_id
+        # @param [Integer] sid
+        # @param [String]  key
+        # @param [Hash]    value
+        def push frontend_id, sid, key, value, &block
+          namespace = 'sys'
+          service = 'sessionRemote'
+          method = 'push'
+          args = [sid, key, value]
+          rpc_invoke(frontend_id, namespace, service, method, args, &block)
+        end
+
+        # Push all the customized changes to the frontend internal session
+        #
+        # @param [String]  frontend_id
+        # @param [Integer] sid
+        # @param [Hash]    settings
+        def push_all frontend_id, sid, settings, &block
+          namespace = 'sys'
+          service = 'sessionRemote'
+          method = 'pushAll'
+          args = [sid, settings]
+          rpc_invoke(frontend_id, namespace, service, method, args, &block)
+        end
+
+        private
+
+        # Backend session callback
+        #
+        # @param [#call]       block
+        # @param [Object]      err
+        # @param [Hash, Array] sinfos
+        #
+        # @private
+        def backend_session_cb block, err, sinfos
+          if err
+            block.respond_to? :call and block.call err
+            return
+          end
+
+          unless sinfos
+            block.respond_to? :call and block.call
+            return
+          end
+          sessions = []
+          if sinfos.instance_of? Array
+            # get_by_uid
+            sinfos.each { |sinfo| sessions << create(sinfo) }
+          else
+            # get
+            sessions = create sinfos
+          end
+          block.respond_to? :call and block.call nil, sessions
+        end
+
+        # Rpc invoke
+        #
+        # @param [String] frontend_id
+        # @param [String] namespace
+        # @param [String] service
+        # @param [String] method
+        # @param [Array]  args
+        #
+        # @private
+        def rpc_invoke frontend_id, namespace, service, method, args, &block
+          @app.rpc_invoke(frontend_id, {
+            :namespace => namespace,
+            :service => service,
+            :method => method,
+            :args => args
+          }, &block)
+        end
+
+        # BackendSession
+        #
+        #
+        class BackendSession
+          # Create a new backend session
+          #
+          # @param [Hash]   args
+          # @param [Object] service
+          def initialize args={}, service
+            args.each_pair { |key, value|
+              instance_eval %Q{ @#{key} = value }
+            }
+            @session_service = service
+          end
+
+          # Bind current session with the user id
+          #
+          # @param [String] uid
+          def bind uid, &block
+            @session_service.bind(@frontend_id, @id, uid) { |err|
+              @uid = uid unless err
+              block_given? and yield err
+            }
+          end
+
+          # Unbind current session with the user id
+          #
+          # @param [String] uid
+          def unbind uid, &block
+            @session_service.unbind(@frontend_id, @id, uid) { |err|
+              @uid = nil unless err
+              block_given? and yield err
+            }
+          end
+
+          # Set the key/value into backend session
+          #
+          # @param [String] key
+          # @param [Hash]   value
+          def set key, value
+            @settings[key] = value
+          end
+
+          # Get the value from backend session by key
+          #
+          # @param [String] key
+          def get key
+            @settings[key]
+          end
+
+          # Push the key/value in backend session to the front internal session
+          #
+          # @param [String] key
+          def push key, &block
+            @session_service.push @frontend_id, @id, key, get(key), &block
+          end
+
+          # Push all the key/values in backend session to the frontend internal session
+          def push_all &block
+            @session_service.push_all @frontend_id, @id, @settings, &block
+          end
+
+          # Export the key/values for serialization
+          def export
+            res = {}
+            EXPORTED_FIELDS.each { |field|
+              instance_eval %Q{ res['#{field}'] = @#{field} }
+            }
+            res
+          end
+        end
+      end
+    end
+  end
+end

data/lib/citrus/common/service/channel_service.rb

@@ -0,0 +1,485 @@
+# Author:: MinixLi (gmail: MinixLi1986)
+# Homepage:: http://citrus.inspawn.com
+# Date:: 29 July 2014
+
+require 'citrus/common/remote/frontend/channel_remote'
+require 'citrus/util/countdown_latch'
+
+module Citrus
+  # Common
+  #
+  #
+  module Common
+    # Service
+    #
+    #
+    module Service
+      # ChannelService
+      #
+      #
+      class ChannelService
+        # Util
+        #
+        #
+        module Util
+          private
+
+          # Add uid and server id into group
+          #
+          # @param [String] uid
+          # @param [String] sid
+          # @param [Hash]   groups
+          #
+          # @private
+          def add uid, sid, groups
+            unless sid
+              return false
+            end
+
+            group = groups[sid]
+            group = []; groups[sid] = group unless group
+
+            group << uid; true
+          end
+
+          # Delete element from array
+          #
+          # @param [String] uid
+          # @param [String] sid
+          # @param [Array]  group
+          #
+          # @private
+          def delete_from uid, sid, group
+            return true unless group
+
+            group.each { |e|
+              group.delete e; return true if e == uid
+            }
+            return false
+          end
+
+          # Push message by group
+          #
+          # @param [Object] service
+          # @param [String] route
+          # @param [Hash]   msg
+          # @param [Hash]   groups
+          # @param [Hash]   args
+          #
+          # @private
+          def send_message_by_group service, route, msg, groups, args, &block
+            app = service.app
+            namespace = 'sys'
+            service = 'channelRemote'
+            method = 'pushMessage'
+            count = groups.length
+            success_flag = false
+            fail_ids = []
+
+            block_given? and yield if count == 0
+
+            latch = Utils::CountDownLatch.new(count) {
+              unless success_flag
+                block_given? and yield Exception.new 'all uids push message fail'
+                return
+              end
+              block_given? and yield nil, fail_ids
+            }
+
+            rpc_cb = Proc.new { |server_id|
+              Proc.new { |err, fails|
+                if err
+                  latch.done
+                  return
+                end
+                fail_ids += fails if fails
+                success_flag = true
+                latch.done
+              }
+            }
+
+            args = { :type => 'push', :user_args => args || {} }
+
+            send_message = Proc.new { |sid|
+              if sid == app.server_id
+                service.channelRemote.send method, route, msg, groups[sid], args, &rpc_cb.call
+              else
+                app.rpc_invoke(sid, {
+                  :namespace => namespace,
+                  :service => service,
+                  :method => method,
+                  :args => [route, msg, groups[sid], args]
+                }, &rpc_cb.call(sid))
+              end
+            }
+
+            groups.each_with_index { |group, sid|
+              if group && group.length > 0
+                send_message sid
+              else
+                EM.next_tick { rpc_cb.call.call }
+              end
+            }
+          end
+
+          # Restore channel
+          #
+          # @param [Object] service
+          #
+          # @private
+          def restore_channel service, &block
+            if service.store
+              block_given? and yield
+              return
+            end
+
+            load_all_from_store(service, gen_key(service)) { |err, list|
+              if err
+                block_given? and yield err
+                return
+              end
+
+              unless (list.instance_of? Array) && list.lenth > 0
+                block_given? and yield
+                return
+              end
+
+              load_p = Proc.new { |key|
+                load_all_from_store(service, key) { |err, items|
+                  items.each { |item|
+                    sid, uid = item.split ':'
+                    channel = service.channels[name]
+                    if add uid, sid, channel.groups
+                      channel.records[uid] = { :sid => sid, :uid => uid }
+                    end
+                  }
+                }
+              }
+
+              list.each_index { |index|
+                name = list[index][gen_key(service).length+1..-1]
+                service.channels[name] = Channel.new name, service
+                load_p.call list[index]
+              }
+              block_given? and yield
+            }
+          end
+
+          # Add to store
+          #
+          # @param [Object] service
+          # @param [String] key
+          # @param [Hash]   value
+          #
+          # @private
+          def add_to_store service, key, value
+            if service.store
+              service.store.add(key, value) { |err|
+                if err
+                end
+              }
+            end
+          end
+
+          # Remove from store
+          #
+          # @param [Object] service
+          # @param [String] key
+          # @param [Hash]   value
+          #
+          # @private
+          def remove_from_store service, key, value
+            if service.store
+              service.store.remove(key, value) { |err|
+                if err
+                end
+              }
+            end
+          end
+
+          # Load all from store
+          #
+          # @param [Object] service
+          # @param [String] key
+          #
+          # @private
+          def load_all_from_store service, key, &block
+            if service.store
+              service.store.load(key) { |err, list|
+                if err
+                  block_given? and yield err
+                else
+                  block_given? and yield nil, list
+                end
+              }
+            end
+          end
+
+          # Remove all from store
+          #
+          # @param [Object] service
+          # @param [String] key
+          #
+          # @private
+          def remove_all_from_store service, key
+            if service.store
+              service.store.remove_all(key) { |err|
+                if err
+                end
+              }
+            end
+          end
+
+          # Generate key
+          #
+          # @param [Object] service
+          # @param [String] name
+          #
+          # @private
+          def gen_key service, name=''
+            unless name.empty?
+              service.prefix + ':' + service.app.server_id + ':' + name
+            else
+              service.prefix + ':' + service.app.server_id
+            end
+          end
+
+          # Generate value
+          #
+          # @param [String] sid
+          # @param [String] uid
+          #
+          # @private
+          def gen_value sid, uid
+            sid + ':' + uid
+          end
+        end
+
+        include Util
+
+        attr_reader :app, :channels, :prefix, :store, :channel_remote
+
+        # Initialize the service
+        #
+        # @param [Object] app
+        # @param [Hash]   args
+        def initialize app, args={}
+          @app = app
+          @channels = {}
+          @prefix = args[:prefix]
+          @store = args[:store]
+          @broadcast_filter = args[:broadcast_filter]
+          @channel_remote = Remote::Frontend::ChannelRemote.new app
+        end
+
+        # Start the service
+        def start &block
+          restore_channel self, &block
+        end
+
+        # Create channel with name
+        #
+        # @param [String] name
+        def create_channel name
+          return @channels[name] if @channels[name]
+
+          c = Channel.new name
+          add_to_store self, gen_key(self), gen_key(self, name)
+          @channels[name] = c
+          c
+        end
+
+        # Get channel by name
+        #
+        # @param [String]  name
+        # @param [Boolean] create
+        def get_channel name, create=false
+          channel = @channels[name]
+          if !channel && create
+            channel = @channels[name] = Channel.new name
+            add_to_store self, gen_key(self), gen_key(self, name)
+          end
+          channel
+        end
+
+        # Destroy channel by name
+        #
+        # @param [String] name
+        def destroy_channel name
+          @channels.delete name
+          remove_from_store self, gen_key(self), gen_key(self, name)
+          remove_all_from_store self, gen_key(self, name)
+        end
+
+        # Push message by uids
+        #
+        # @param [String] route
+        # @param [Hash]   msg
+        # @param [Array]  uids
+        # @param [Hash]   args
+        def push_message_by_uids route, msg, uids, args, &block
+          unless uids && uids.length != 0
+            block_given? and yield Exception.new 'uids should not be empty'
+            return
+          end
+
+          groups = {}
+          uids.each { |record| add record[:uid], record[:sid], groups }
+
+          send_message_by_group self, route, msg, groups, args, &block
+        end
+
+        # Broadcast message to all the connected clients
+        #
+        # @param [String] server_type
+        # @param [String] route
+        # @param [Hash]   message
+        # @param [Hash]   args
+        def broadcast server_type, route, msg, args, &block
+          namespace = 'sys'
+          service = 'channelRemote'
+          method = 'broadcast'
+          servers = @app.get_servers_by_type server_type
+
+          unless servers && servers.length != 0
+            # server list is empty
+            block_given? and yield
+          end
+
+          count = servers.length
+          success_flag = false
+
+          latch = Utils::CountDownLatch.new(count) {
+            unless success_flag
+              block_given? and yield Exception.new 'broadcast failed'
+              return
+            end
+            block_given? and yield nil
+          }
+
+          gen_cb = Proc.new { |server_id|
+            Proc.new { |err|
+              if err
+                latch.done
+                return
+              end
+              success_flag = true
+              latch.done
+            }
+          }
+
+          send_message = Proc.new { |server_id|
+            if server_id == @app.server_id
+              @channel_remote.send method, route, msg, args, &gen_cb.call
+            else
+              @app.rpc_invoke(server_id, {
+                :namespace => namespace,
+                :service => service,
+                :method => method,
+                :args => [route, msg, args]
+              }, &gen_cb.call(server_id))
+            end
+          }
+
+          args = { :type => 'broadcast', :user_args => args || {} }
+
+          servers.each { |server|
+            send_message server[:server_id]
+          }
+        end
+
+        # Channel
+        #
+        #
+        class Channel
+          include Util
+
+          attr_reader :groups, :user_amount
+
+          # Create a new channel
+          #
+          # @param [String] name
+          # @param [Object] service
+          def initialize name, service
+            @name = name
+            @groups = {}
+            @records = {}
+            @channel_service = service
+            @state = :state_inited
+            @user_amount = 0
+          end
+
+          # Add user to channel
+          #
+          # @param [String] uid
+          # @param [String] sid
+          def add uid, sid
+            return false unless @state == :state_inited
+
+            res = add uid, sid, @groups
+            if res
+              @records[uid] = { :sid => sid, :uid => uid }
+              @user_amount += 1
+            end
+
+            add_to_store @channel_service, gen_key(@channel_service, @name), gen_value(sid, uid)
+            res
+          end
+
+          # Remove user from channel
+          #
+          # @param [String] uid
+          # @param [String] sid
+          def leave uid, sid
+            return unless uid && sid
+
+            @records.delete uid
+            @user_amount -= 1
+            @user_amout = 0 if @user_amount < 0
+
+            remove_from_store @channel_service, gen_key(@channel_service, @name), gen_value(sid, uid)
+
+            res = delete_from uid, sid, @groups[sid]
+            if @groups[sid] && @groups[sid].length == 0
+              @groups.delete sid
+            end
+            res
+          end
+
+          # Get channel members
+          def get_members
+            res = []
+            @groups.each { |group| group.each { |e| res << e } }
+            res
+          end
+
+          # Get member info
+          #
+          # @param [String] uid
+          def get_member uid
+            @records[uid]
+          end
+
+          # Destroy channel
+          def destroy
+            @state = :state_destroyed
+            @channel_service.destroy_channel @name
+          end
+
+          # Push message to all the members in the channel
+          #
+          # @param [String] route
+          # @param [Hash]   msg
+          # @param [Hash]   args
+          def push_message route, msg, args, &block
+            unless @state == :state_inited
+              block_given? and yield Exception.new 'channel is not running now'
+              return
+            end
+            send_message_by_group @channel_service, route, msg, @groups, args, &block
+          end
+        end
+      end
+    end
+  end
+end