redis_rpc 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b57e11a1d1707de2319945e009d0ddb52cef370d
-  data.tar.gz: c487af813d9c74f14c1e1a337cb48be74714be75
+  metadata.gz: 9446d050ad21ca78739f4d986fd7703a683df9b9
+  data.tar.gz: 2f43f268796cd00c1b77e2fe107ef16fba2ee567
 SHA512:
-  metadata.gz: 3635a11d7b1b7ff4a9e19c9e22ebd2ed59b59b2265021e1e455eeefec3e8cc77f86bc1c160dfd9ba61998788716b08263a07a8afe13a5f1fd1f3e1434a25d509
-  data.tar.gz: ab06cdfef10e8ef1618db0cc3220f64a0aa61298cfade95f73a9835d03e066dcf32f045c2bf945aa6e2aed03735b1e0fdff4f68f9aa3c058ededc9e0678ae99c
+  metadata.gz: d81714bc20bb38db199483e30702b99155916b71ab9bec05262beb20cdb2f5d22812edae1af9308424c254de8ab8a0c3b1f0facad459217145809747b7269bf7
+  data.tar.gz: 274515576b96b3173eccec4d8e04888ed797a732f0e250a6bddbbee474b36d047f9fd852f41e5b7bd0d0a255a94ff4b1e55972073f3d020f8c0f96bf9e9cea56

data/lib/redis_rpc/callback.rb

@@ -1,16 +1,25 @@
+require "redis_rpc/error.rb"
+
 module RedisRpc
 
   class Callback
 
-    def initialize
+    def initialize(logger)
+      @logger = logger
       @funs = {}
     end
 
     def exec_callback(args)
-      _args = JSON.parse(args, symbolize_names: true)
-      # {uuid: uuid, _method: method, result: result}
-      callback = @funs.delete _args[:uuid]
-      callback.call(_args[:result]) if !callback.nil?
+      begin
+        # {uuid: uuid, _method: method, result: result, error: error}
+        callback = @funs.delete args[:uuid]
+        if !callback.nil?
+          callback.call(args[:error].nil? ? nil : FunctionCallbackError.new(args[:error]), args[:result])
+          true
+        end
+      rescue Exception => e
+        @logger.error(e)
+      end
     end
 
     def push(uuid, callback)

data/lib/redis_rpc/client.rb

@@ -8,35 +8,35 @@ module RedisRpc
 
   class Client
 
-    def initialize(url, sub_channel, pub_channel, level: Logger::WARN)
+    attr_accessor :handler
+
+    def initialize(url, sub_channel, pub_channel, level: Logger::WARN, secret_key: nil, timeout: 10.0)
       @redis = Redis.new(url: url)
       @sub_channel = sub_channel
       @pub_channel = pub_channel
-      @res = Response.new(Redis.new(url: url), pub_channel)
-      @callback = Callback.new
-      init_log(level)
+      @timeout = timeout
+      @parser = Parser.new(secret_key)
+      @res = Response.new(Redis.new(url: url), pub_channel, init_log(level), @parser)
+      @callback = Callback.new(init_log(level))
       exec
     end
 
     def exec
-      @thread = Thread.new do
+      @handler = Thread.new do
         begin
-          @redis.subscribe(@sub_channel, RedisRpc::EXCEPTION_CHANNEL) do |on|
+          @redis.subscribe(@sub_channel) do |on|
             on.subscribe do |channel, subscriptions|
               @logger.info("Subscribed to ##{channel} (#{subscriptions} subscriptions)")
             end
 
             on.message do |channel, args|
               @logger.info("##{channel}: #{args}")
-              case channel.to_sym
-              when RedisRpc::EXCEPTION_CHANNEL
-                @logger.error("exception: #{args}")
-              else
-                begin
-                  @callback.exec_callback(args)
-                rescue Exception => e
-                  @logger.error(e.message.to_s)
-                end
+              begin
+                _args = @parser.parse(args)
+                @logger.error(ArgumentError.new("miss method uuid")) and return if _args[:uuid].nil?
+                @res.sync_callback(_args, @timeout) if !@callback.exec_callback(_args)
+              rescue Exception => e
+                @logger.error(e)
               end
             end
             on.unsubscribe do |channel, subscriptions|
@@ -68,13 +68,11 @@ module RedisRpc
         params: args,
         uuid: SecureRandom.uuid
       }
-      @callback.push(request[:uuid], block)
-      @res.publish(request)
+      @callback.push(request[:uuid], block) if !block.nil?
+      _sync_handler = @res.publish(request, @timeout)
+      return block.nil? ? _sync_handler : nil
     end
 
   end
 
-
-
-
 end

data/lib/redis_rpc/error.rb

@@ -0,0 +1,6 @@
+module RedisRpc
+
+  class FunctionCallbackError < StandardError
+  end
+
+end

data/lib/redis_rpc/logic.rb

@@ -5,24 +5,32 @@ module RedisRpc
 
       attr_accessor :res
 
-      def initialize(url, callback, channel)
+      def initialize(url, callback, channel, logger, parser)
         @redis = Redis.new(url: url)
-        @res = Response.new(@redis, channel)
+        @logger = logger
+        @res = Response.new(@redis, channel, logger, parser)
         @callback = callback
+        @parser = parser
       end
 
-      def exec(args)
+      def exec(args, timeout)
         begin
-          _args = JSON.parse(args, symbolize_names: true)
-          raise(ArgumentError, "miss callback uuid")  if _args[:uuid].nil?
-          raise(ArgumentError, "miss method name")  if _args[:method].nil?
+          _args = @parser.parse(args)
+          logger.error(ArgumentError.new("miss method name or uuid")) and return if _args[:uuid].nil? || _args[:method].nil?
 
           result = @callback.send(_args[:method], *_args[:params])
-          @res.publish({uuid: _args[:uuid], _method: _args[:method], result: result})
+          @res.publish({uuid: _args[:uuid], _method: _args[:method], result: result}, timeout)
         rescue Exception => e
-          @res.catch(e)
+          if defined?(_args) && !_args.nil?
+            @res.catch(_args[:uuid], e)
+          else
+            @logger.error(e)
+          end
         end
+      rescue Exception => e
+        @logger.error(e)
       end
+
   end
 
 end

data/lib/redis_rpc/parser.rb

@@ -0,0 +1,50 @@
+require 'openssl'
+require "base64"
+
+module RedisRpc
+
+  class Parser
+
+    attr_accessor :secret_key
+
+    def initialize(secret_key)
+      @secret_key = secret_key
+      @aes = Base64Aes.new(@secret_key) if !@secret_key.nil?
+    end
+
+    def parse(args)
+      args = @aes.decrypt(args) if !@secret_key.nil?
+      _args = JSON.parse(args, symbolize_names: true)
+    end
+
+    def pack(args)
+      args = @aes.encrypt(args) if !@secret_key.nil?
+      args
+    end
+
+  end
+
+  class Base64Aes
+    def initialize(key)
+      @key = key
+      @cipher = OpenSSL::Cipher::AES.new(128, :CBC).encrypt
+      @decipher = OpenSSL::Cipher::AES.new(128, :CBC).decrypt
+    end
+    def encrypt(data)
+      @cipher.key = @key
+      encode64(@cipher.update(data) + @cipher.final)
+    end
+    def decrypt(encrypted)
+      @decipher.key = @key
+      @decipher.update(decode64(encrypted)) + @decipher.final
+    end
+    private
+    def encode64(str)
+      Base64.strict_encode64 str
+    end
+    def decode64(str)
+      Base64.strict_decode64 str
+    end
+  end
+
+end

data/lib/redis_rpc/response.rb

@@ -1,23 +1,65 @@
 require 'json'
+require "redis_rpc/error.rb"
+require "redis_rpc/parser.rb"
+
 module RedisRpc
 
   class Response
 
-    def initialize(redis, channel)
+    def initialize(redis, channel, logger, parser)
       @redis = redis
       @channel = channel
+      @logger = logger
+      @parser = parser
+    end
+
+    def publish(request, timeout)
+      request_str = @parser.pack(request.to_json)
+      @redis.publish(@channel, request_str)
+      SyncHandler.new(@redis, request[:uuid], request[:method], @parser.secret_key, timeout)
+    end
+
+    def sync_callback(args, timeout=5)
+        # {uuid: uuid, _method: method, result: result, error: error}
+        @redis.set(args[:uuid], @parser.pack(args.to_json))
+        @redis.expire(args[:uuid], timeout.to_i)
     end
 
-    def publish(request)
-      @redis.publish(@channel, request.to_json)
+    def catch(uuid, e)
+      @logger.error("#{uuid}: #{e}")
+      request_str = @parser.pack({uuid: uuid, error: e}.to_json)
+      @redis.publish(@channel, request_str)
     end
 
-    def catch(e)
-      publish(RedisRpc::EXCEPTION_CHANNEL, e.message.to_s)
+  end
+
+  class SyncHandler
+
+    SLEEP_TIME = 0.01
+
+    def initialize(redis, uuid, _method, secret_key, timeout=30)
+      @redis = redis
+      @uuid = uuid
+      @_method = _method
+      @expires_at = Time.now + timeout
+      @parser = Parser.new(secret_key)
     end
 
-    def method_missing(m, *args)
-      publish(m, args)
+    def sync
+      while Time.now <= @expires_at
+        result = @redis.get(@uuid)
+        if !result.nil?
+          @redis.del(@uuid)
+          _args = @parser.parse(result)
+          if !_args[:result].nil?
+            return _args[:result]
+          elsif !_args[:error].nil?
+            raise(FunctionCallbackError.new(_args[:error]))
+          end
+        end
+        sleep SLEEP_TIME
+      end
+      raise(Timeout::Error.new("method: #{@_method} wait for timeout"))
     end
 
   end

data/lib/redis_rpc/server.rb

@@ -3,17 +3,19 @@ require 'logger'
 require "redis_rpc/client.rb"
 require "redis_rpc/version.rb"
 require "redis_rpc/logic.rb"
+require "redis_rpc/parser.rb"
 
 module RedisRpc
 
   class Server
 
-    def initialize(url, sub_channel, pub_channel, front_object, level: Logger::WARN, standalone: true)
+    def initialize(url, sub_channel, pub_channel, front_object, level: Logger::WARN, standalone: true, secret_key: nil, timeout: 10.0)
       @redis = Redis.new(url: url)
       @sub_channel = sub_channel
       @pub_channel = pub_channel
-      @logic = Logic.new(url, front_object, pub_channel)
-      init_log(level)
+      @timeout = timeout
+      @parser = Parser.new(secret_key)
+      @logic = Logic.new(url, front_object, pub_channel, init_log(level), @parser)
       standalone ? standalone_exec : exec
     end
 
@@ -25,23 +27,14 @@ module RedisRpc
 
     def exec
       begin
-        @redis.subscribe(@sub_channel, RedisRpc::EXCEPTION_CHANNEL) do |on|
+        @redis.subscribe(@sub_channel) do |on|
           on.subscribe do |channel, subscriptions|
             @logger.info("Subscribed to ##{channel} (#{subscriptions} subscriptions)")
           end
 
           on.message do |channel, args|
             @logger.info("##{channel}: #{args}")
-            case channel.to_sym
-            when RedisRpc::EXCEPTION_CHANNEL
-              @logger.error("exception: #{args}")
-            else
-              begin
-                @logic.exec(args)
-              rescue Exception => e
-                @logger.error(e.message.to_s)
-              end
-            end
+            @logic.exec(args, @timeout)
           end
           on.unsubscribe do |channel, subscriptions|
             @logger.info("Unsubscribed from ##{channel} (#{subscriptions} subscriptions)")

data/lib/redis_rpc/version.rb

@@ -1,3 +1,3 @@
 module RedisRpc
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/redis_rpc.rb

@@ -11,8 +11,32 @@ module RedisRpc
 
   class  << self
 
-    def new
+    # Create a new server instance
+    #
+    # @param [String] :url (value of the environment variable REDIS_URL) a Redis URL, for a TCP connection: `redis://:[password]@[hostname]:[port]/[db]` (password, port and database are optional), for a unix socket connection: `unix://[path to Redis socket]`. This overrides all other options.
+    # @param [String] :sub_channel a channel to listen.
+    # @param [String] :pub_channel a channel to publish.
+    # @param [Object] :front_object The object that handles requests on the server.
+    # @option options [Logger::] :level (Logger::WARN) Logger options.
+    # @option options [Boolean] :standalone (true) set true if use a thread to handle this server.
+    # @option options [String] :secret_key (nil) set a long String greater than 16 when you want to encryt the data.
+    # @option options [Float] :timeout (10.0) timeout in seconds
 
+    def server(*args)
+      RedisRpc::Server.new *args
+    end
+
+    # Create a new client instance
+    #
+    # @param [String] :url (value of the environment variable REDIS_URL) a Redis URL, for a TCP connection: `redis://:[password]@[hostname]:[port]/[db]` (password, port and database are optional), for a unix socket connection: `unix://[path to Redis socket]`. This overrides all other options.
+    # @param [String] :sub_channel a channel to listen.
+    # @param [String] :pub_channel a channel to publish.
+    # @option options [Logger::] :level (Logger::WARN) Logger options.
+    # @option options [String] :secret_key (nil) set a long String greater than 16 when you want to encryt the data.
+    # @option options [Float] :timeout (10.0) timeout in seconds
+
+    def client(*args)
+      RedisRpc::Client.new *args
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_rpc
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - benko
@@ -19,7 +19,9 @@ files:
 - lib/redis_rpc.rb
 - lib/redis_rpc/callback.rb
 - lib/redis_rpc/client.rb
+- lib/redis_rpc/error.rb
 - lib/redis_rpc/logic.rb
+- lib/redis_rpc/parser.rb
 - lib/redis_rpc/response.rb
 - lib/redis_rpc/server.rb
 - lib/redis_rpc/version.rb