krpc 0.1.1.1 → 0.2.0

data/lib/krpc/repl_tools.rb

@@ -9,4 +9,3 @@ module KRPC
 end
 
 include KRPC::REPLTools
-

data/lib/krpc/service.rb

@@ -1,13 +1,14 @@
 require 'krpc/gen'
 require 'krpc/attributes'
 require 'krpc/doc'
+require 'krpc/streaming'
 
 module KRPC
   module Services
     class << self
     
       # Generate classes and methods for the service - see documentation for Client#generate_services_api!
-      def create_service(service_msg, client)
+      def create_service(service_msg)
         service_name = service_msg.name
         
         # Create service class
@@ -16,12 +17,12 @@ module KRPC
         
         # Create service' classes
         service_msg.classes.map(&:name).each do |sc_name|
-          client.type_store.as_type("Class(#{service_name}.#{sc_name})")
+          TypeStore["Class(#{service_name}.#{sc_name})"]
         end
         
         # Create service' enums
         service_msg.enumerations.each do |enum|
-          enum_type = client.type_store.as_type("Enum(#{service_name}.#{enum.name})")
+          enum_type = TypeStore["Enum(#{service_name}.#{enum.name})"]
           enum_type.set_values(enum.values)
         end
         
@@ -29,28 +30,28 @@ module KRPC
         service_msg.procedures.each do |proc|
           if Attributes.is_a_class_method_or_property_accessor(proc.attributes)
             class_name  = Attributes.get_class_name(proc.attributes)
-            class_cls = client.type_store.as_type("Class(#{service_name}.#{class_name})").ruby_type
+            class_cls = TypeStore["Class(#{service_name}.#{class_name})"].ruby_type
             method_name = Attributes.get_class_method_or_property_name(proc.attributes)
             if Attributes.is_a_class_property_accessor(proc.attributes)  # service' class property
               if Attributes.is_a_class_property_getter(proc.attributes)
-                Gen.add_rpc_method(class_cls, method_name, service_name, proc, client, :prepend_self_to_args)
+                Gen.add_rpc_method(class_cls, method_name, service_name, proc, :prepend_self_to_args)
               else
-                Gen.add_rpc_method(class_cls, method_name + '=', service_name, proc, client, :prepend_self_to_args)
+                Gen.add_rpc_method(class_cls, method_name + '=', service_name, proc, :prepend_self_to_args, :no_stream)
               end
             elsif Attributes.is_a_class_method(proc.attributes)  # service' class method
-              Gen.add_rpc_method(class_cls, method_name, service_name, proc, client, :prepend_self_to_args)
+              Gen.add_rpc_method(class_cls, method_name, service_name, proc, :prepend_self_to_args)
             else  # service' static class method
-              Gen.add_rpc_method(class_cls, method_name, service_name, proc, client, :static)
+              Gen.add_rpc_method(class_cls, method_name, service_name, proc, :static)
             end
           elsif Attributes.is_a_property_accessor(proc.attributes)  # service' property
             property_name = Attributes.get_property_name(proc.attributes)
             if Attributes.is_a_property_getter(proc.attributes)
-              Gen.add_rpc_method(service_class, property_name, service_name, proc, client)
+              Gen.add_rpc_method(service_class, property_name, service_name, proc)
             elsif Attributes.is_a_property_setter(proc.attributes)
-              Gen.add_rpc_method(service_class, property_name + '=', service_name, proc, client)
+              Gen.add_rpc_method(service_class, property_name + '=', service_name, proc, :no_stream)
             end
           else  # plain procedure = method available to service class and its instance
-            Gen.add_rpc_method(service_class, proc.name, service_name, proc, client, :static)
+            Gen.add_rpc_method(service_class, proc.name, service_name, proc, :static)
           end
         end
         
@@ -60,8 +61,8 @@ module KRPC
         service_classes = mod.constants.map{|c| mod.const_get(c)}.select {|c| c.is_a? Class}
         service_classes.each(&:add_methods_available_to_class_and_instance)
         
-        # Return service class instance
-        service_class.new(client)
+        # Return service class
+        service_class
       end
       
     end
@@ -71,6 +72,7 @@ module KRPC
     class ServiceBase
       extend Gen::AvailableToClassAndInstanceMethodsHandler
       include Doc::SuffixMethods
+      include Streaming::StreamConstructors
       
       attr_reader :client
   
@@ -83,19 +85,17 @@ module KRPC
     # Core kRPC service, e.g. for querying for the available services.
     class KRPC < ServiceBase
       include Gen::RPCMethodGenerator
-    
+
       def initialize(client)
         super(client)
         unless respond_to? :get_status
-          include_rpc_method("get_status", "KRPC", "GetStatus", return_type: "KRPC.Status")
-          include_rpc_method("get_services", "KRPC", "GetServices", return_type: "KRPC.Services")
-          # TODO: implement me:
-          # include_rpc_method("add_stream", "KRPC", "AddStream", ...)
-          # include_rpc_method("remove_stream", "KRPC", "RemoveStream", ...)
+          include_rpc_method("get_status", "KRPC", "GetStatus", return_type: "KRPC.Status", xmldoc: "<doc><summary>Gets a status message from the server containing information including the server’s version string and performance statistics.</summary></doc>", options: :no_stream)
+          include_rpc_method("get_services", "KRPC", "GetServices", return_type: "KRPC.Services", xmldoc: "<doc><summary>Gets available services and procedures.</summary></doc>", options: :no_stream)
+          include_rpc_method("add_stream", "KRPC", "AddStream", params: [PB::Parameter.new(name: "request", type: "KRPC.Request")], return_type: "uint32", xmldoc: "<doc><summary>Add a streaming request. Returns it's identifier.</summary></doc>", options: :no_stream)
+          include_rpc_method("remove_stream", "KRPC", "RemoveStream", params: [PB::Parameter.new(name: "id", type: "uint32")], xmldoc: "<doc><summary>Remove a streaming request</summary></doc>", options: :no_stream)
         end
       end
     end
     
   end
 end
-

data/lib/krpc/streaming.rb

@@ -0,0 +1,176 @@
+require 'thread'
+require 'colorize'
+
+module KRPC
+  module Streaming
+
+    class StreamsManager
+      attr_reader :client
+      
+      def initialize(client)
+        @client = client
+        @streams = {}
+        @streams_mutex = Mutex.new
+        @streaming_thread = Thread.new {}
+      end
+    
+      # Send a streaming request, create related Stream object and return it. If identical Stream
+      # already exists, doesn't create new Stream and return the existing one.
+      def create_stream(request, return_type, method, *args, **kwargs)
+        raise RuntimeError("Cannot stream a property setter") if method.name.to_s.end_with? '='
+        id = client.krpc.add_stream(request)
+        @streams_mutex.synchronize do
+          if @streams.include? id
+            @streams[id]
+          else
+            value = method.call(*args, **kwargs)
+            @streams[id] = Stream.new(self, id, return_type, value, method, *args, **kwargs)
+          end
+        end
+      end
+      
+      # Remove a streaming request and deactivate the Stream object. Returns `true` if
+      # streaming request is removed or `false` if passed Stream object is already inactive.
+      def remove_stream(stream)
+        return false unless stream.active?
+        @streams_mutex.synchronize do
+          return false unless @streams.include? stream.id
+          client.krpc.remove_stream stream.id
+          @streams.delete stream.id
+        end
+        stream.value = RuntimeError.new("Stream has been removed")
+        stream.mark_as_inactive
+        true
+      end
+
+      # Remove all streams created by this streams manager.
+      def remove_all_streams
+        @streams.each {|_,stream| remove_stream(stream)}
+      end
+      
+      # Start streaming thread. It receives stream data, and updates Stream object's `value` attribute.
+      def start_streaming_thread
+        stop_streaming_thread
+        @streaming_thread = Thread.new do
+          connection = client.stream_connection
+          stream_message_type = TypeStore["KRPC.StreamMessage"]
+          loop do
+            size = connection.recv_varint
+            data = connection.recv(size)
+            stream_msg = Decoder.decode(data, stream_message_type, client)
+            @streams_mutex.synchronize do
+              stream_msg.responses.each do |stream_resp|
+                next unless @streams.include? stream_resp.id
+                stream = @streams[stream_resp.id]
+                if stream_resp.response.has_field?("error")
+                  stream.value = RPCError.new(stream_resp.response.error)
+                else
+                  stream.value = Decoder.decode(stream_resp.response.return_value, stream.return_type, client)
+                end
+              end
+            end
+          end
+        end
+      end
+      
+      # Stop streaming thread.
+      def stop_streaming_thread
+        @streaming_thread.terminate
+      end
+    end
+    
+    class Stream
+      attr_reader :id, :method, :args, :kwargs, :return_type, :manager
+      attr_writer :value
+      
+      def initialize(manager, id, return_type, value, method, *args, **kwargs)
+        @manager = manager
+        @id = id
+        @return_type, @value = return_type, value
+        @method, @args, @kwargs = method, args, kwargs
+        @active = true
+      end
+      
+      # Get the current stream value. Has alias method `value`.
+      def get
+        raise @value if @value.is_a?(Exception)
+        @value
+      end
+      alias_method :value, :get
+
+      # Remove stream. Has alias method `close`.
+      def remove
+        manager.remove_stream self
+      end
+      alias_method :close, :remove
+      
+      # Check if stream is active (i.e. not removed).
+      def active?; @active end
+
+      # Mark stream as inactive.
+      # WARNING: This method does not remove the stream. To remove the stream call Stream#remove instead.
+      def mark_as_inactive; @active = false end
+      
+      def to_s
+        inspect.gsub(/\n|\t/," ").squeeze(" ").uncolorize
+      end
+      
+      def inspect
+        def coderay(x)
+          require 'coderay'
+          if x.is_a?(Array) then "[" + x.map{|e| e.is_a?(Gen::ClassBase) ? e.inspect : coderay(e.inspect)}.join(", ") + "]"
+          elsif x.is_a?(Hash) then "{" + x.map{|k,v| coderay(k.inspect) + "=>" + (v.is_a?(Gen::ClassBase) ? v.inspect : coderay(v.inspect))}.join(", ") + "}"
+          else CodeRay.scan(x, :ruby).term end
+        rescue Exception
+         x.inspect
+        end
+        "#<#{self.class}".green +
+            " @id" + "=".green + id.to_s.bold.blue +
+            " @active" + "=".green + @active.to_s.bold.light_cyan +
+            "\n\t@method" + "=".green + method.inspect.green +
+            (args.empty? ? "" : "\n\t@args" + "=".green + coderay(args)) +
+            (kwargs.empty? ? "" : "\n\t@kwargs" + "=".green + coderay(kwargs)) +
+            "\n\treturn_ruby_type" + "=".green + coderay(return_type.ruby_type) +
+            ">".green
+      end
+    end
+  
+    module StreamConstructors
+      STREAM_METHOD_SUFFIX = "_stream"
+      STREAM_METHOD_REGEX = /^(.+)(?:#{STREAM_METHOD_SUFFIX})$/
+      
+      module ClassMethods
+        def stream_constructors
+          @stream_constructors ||= {}
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.extend self
+      end
+      
+      def method_missing(method, *args, **kwargs, &block)
+        if STREAM_METHOD_REGEX =~ method.to_s
+          if respond_to? $1.to_sym
+            ctors = self.is_a?(Module) ? stream_constructors : self.class.stream_constructors
+            return ctors[$1].call(self, *args, **kwargs) if ctors.include? $1
+          end
+        end
+        super
+      end
+      
+      def respond_to_missing?(method, *)
+        if STREAM_METHOD_REGEX =~ method.to_s
+          if respond_to? $1.to_sym
+            ctors = self.is_a?(Module) ? stream_constructors : self.class.stream_constructors
+            return true if ctors.include? $1
+          end
+        end
+        super
+      end
+      
+    end
+    
+  end
+end

data/lib/krpc/types.rb

@@ -21,93 +21,91 @@ module KRPC
       "bytes"  => String
     }
     PROTOBUF_TO_MESSAGE_TYPE = ProtobufUtils.create_PB_to_PB_message_class_hash("KRPC")
-  
-    class TypeStore
     
-      def initialize
-        @cache = {}
-      end
+    class TypeStore
+      @cache = {}
+      class << self
       
-      def as_type(type_string)
-        return @cache[type_string] if @cache.include? type_string
+        def [](type_string)
+          return @cache[type_string] if @cache.include? type_string
+          
+          type =
+            if PROTOBUF_VALUE_TYPES.include? type_string then ValueType.new(type_string)
+            elsif type_string.start_with? "Class(" || type_string == "Class" then ClassType.new(type_string)
+            elsif type_string.start_with? "Enum("  || type_string == "Enum"  then EnumType.new(type_string)
+            elsif type_string.start_with? "List("  || type_string == "List"  then ListType.new(type_string)
+            elsif type_string.start_with? "Dictionary(" || type_string == "Dictionary" then DictionaryType.new(type_string)
+            elsif type_string.start_with? "Set("   || type_string == "Set"   then SetType.new(type_string)
+            elsif type_string.start_with? "Tuple(" || type_string == "Tuple" then TupleType.new(type_string)
+            else # A message type (eg. type_string = "KRPC.List" or "KRPC.Services")
+              raise(ValueError, "\"#{type_string}\" is not a valid type string") unless /^[A-Za-z0-9_\.]+$/ =~ type_string
+              if PROTOBUF_TO_MESSAGE_TYPE.has_key? type_string
+                MessageType.new(type_string)
+              else
+                raise(ValueError, "\"#{type_string}\" is not a valid type string")
+              end
+            end
+
+          @cache[type_string] = type
+          type      
+        end
         
-        type =
-          if PROTOBUF_VALUE_TYPES.include? type_string then ValueType.new(type_string)
-          elsif type_string.start_with? "Class(" || type_string == "Class" then ClassType.new(type_string)
-          elsif type_string.start_with? "Enum("  || type_string == "Enum"  then EnumType.new(type_string)
-          elsif type_string.start_with? "List("  || type_string == "List"  then ListType.new(type_string, self)
-          elsif type_string.start_with? "Dictionary(" || type_string == "Dictionary" then DictionaryType.new(type_string, self)
-          elsif type_string.start_with? "Set("   || type_string == "Set"   then SetType.new(type_string, self)
-          elsif type_string.start_with? "Tuple(" || type_string == "Tuple" then TupleType.new(type_string, self)
-          else # A message type (eg. type_string = "KRPC.List" or "KRPC.Services")
-            raise(ValueError, "\"#{type_string}\" is not a valid type string") unless /^[A-Za-z0-9_\.]+$/ =~ type_string
-            if PROTOBUF_TO_MESSAGE_TYPE.has_key? type_string
-              MessageType.new(type_string)
-            else
-              raise(ValueError, "\"#{type_string}\" is not a valid type string")
+        def get_parameter_type(pos, type, attrs)
+          type_attrs = Attributes.get_parameter_type_attrs(pos, attrs)
+          type_attrs.each do |ta|
+            begin
+              return self[ta]
+            rescue ValueError
             end
           end
+          self[type]
+        end
 
-        @cache[type_string] = type
-        type      
-      end
-      
-      def get_parameter_type(pos, type, attrs)
-        type_attrs = Attributes.get_parameter_type_attrs(pos, attrs)
-        type_attrs.each do |ta|
-          begin
-            return as_type(ta)
-          rescue ValueError
+        def get_return_type(type, attrs)
+          type_attrs = Attributes.get_return_type_attrs(attrs)
+          type_attrs.each do |ta|
+            begin
+              return self[ta]
+            rescue ValueError
+            end
           end
+          self[type]
         end
-        as_type(type)
-      end
-
-      def get_return_type(type, attrs)
-        type_attrs = Attributes.get_return_type_attrs(attrs)
-        type_attrs.each do |ta|
+        
+        def coerce_to(value, type)
+          return value if type.is_a?(EnumType) && value.class == Symbol # Enum handling
+          return value if value.is_a?(type.ruby_type)
+          # A NilClass can be coerced to a ClassType
+          return nil if type.is_a?(ClassType) && value.nil?
+          # Handle service' class instance
+          if type.is_a?(ClassType) && value.is_a?(Gen::ClassBase) && 
+             type.ruby_type == value.class
+            return value
+          end
+          # -- Collection types --
           begin
-            return as_type(ta)
+            # coerce "list" to array
+            if type.is_a?(ListType) && value.respond_to?(:map) && value.respond_to?(:to_a)
+              return type.ruby_type.new(value.map{|x| coerce_to(x, type.value_type) }.to_a)
+            end
+            # coerce "tuple" to array + check elements count
+            if type.is_a?(TupleType) && value.respond_to?(:map) && value.respond_to?(:to_a) && value.respond_to?(:size)
+              raise ValueError if value.size != type.value_types.size
+              return type.ruby_type.new(value.map.with_index{|x,i| coerce_to(x, type.value_types[i]) }.to_a)
+            end
           rescue ValueError
+            raise(ValueError, "Failed to coerce value #{value.to_s} of type #{value.class} to type #{type}")
           end
-        end
-        as_type(type)
-      end
-      
-      def coerce_to(value, type)
-        return value if type.is_a?(EnumType) && value.class == Symbol # Enum handling
-        return value if value.is_a?(type.ruby_type)
-        # A NilClass can be coerced to a ClassType
-        return nil if type.is_a?(ClassType) && value == nil
-        # Coerce identical class types from different client connections
-        if type.is_a?(ClassType) && value.is_a?(Gen::ClassBase) && 
-           type.ruby_type.service_name == value.class.service_name && 
-           type.ruby_type.name == value.class.name
-          return type.ruby_type.new(value.remote_oid)
-        end
-        # -- Collection types --
-        begin
-          # coerce "list" to array
-          if type.is_a?(ListType) && value.respond_to?(:map) && value.respond_to?(:to_a)
-            return type.ruby_type.new(value.map{|x| coerce_to(x, type.value_type) }.to_a)
-          end
-          # coerce "tuple" to array + check elements count
-          if type.is_a?(TupleType) && value.respond_to?(:map) && value.respond_to?(:to_a) && value.respond_to?(:size)
-            raise ValueError if value.size != type.value_types.size
-            return type.ruby_type.new(value.map.with_index{|x,i| coerce_to(x, type.value_types[i]) }.to_a)
+          # Numeric types
+          if type.ruby_type == Float && value.respond_to?(:to_f)
+            return value.to_f
+          elsif type.ruby_type == Integer && value.respond_to?(:to_i)
+            return value.to_i
           end
-        rescue ValueError
           raise(ValueError, "Failed to coerce value #{value.to_s} of type #{value.class} to type #{type}")
         end
-        # Numeric types
-        if type.ruby_type == Float && value.respond_to?(:to_f)
-          return value.to_f
-        elsif type.ruby_type == Integer && value.respond_to?(:to_i)
-          return value.to_i
-        end
-        raise(ValueError, "Failed to coerce value #{value.to_s} of type #{value.class} to type #{type}")
-      end
       
+      end
     end
     
     
@@ -121,7 +119,7 @@ module KRPC
       protected
       
       def parse_type_string(type)
-        raise ValueError.new if type == nil
+        raise ValueError.new if type.nil?
         result = ""
         level  = 0
         type.each_char do |x|
@@ -181,25 +179,25 @@ module KRPC
     
     class ListType < TypeBase
       attr_reader :value_type
-      def initialize(type_string, type_store)
+      def initialize(type_string)
         m = /^List\((.+)\)$/.match type_string
         raise(ValueError, "\"#{type_string}\" is not a valid type string for a list type") unless m
-        @value_type = type_store.as_type(m[1])
+        @value_type = TypeStore[m[1]]
         super(type_string, Array)
       end
     end
     
     class DictionaryType < TypeBase
       attr_reader :key_type, :value_type
-      def initialize(type_string, type_store)
+      def initialize(type_string)
         m = /^Dictionary\((.+)\)$/.match type_string
         raise(ValueError, "\"#{type_string}\" is not a valid type string for a dictionary type") unless m
 
         key_string, type   = parse_type_string(m[1])
         value_string, type = parse_type_string(type)
-        raise(ValueError, "\"#{type_string}\" is not a valid type string for a dictionary type") if type != nil
-        @key_type   = type_store.as_type(key_string)
-        @value_type = type_store.as_type(value_string)
+        raise(ValueError, "\"#{type_string}\" is not a valid type string for a dictionary type") unless type.nil?
+        @key_type   = TypeStore[key_string]
+        @value_type = TypeStore[value_string]
 
         super(type_string, Hash)
       end
@@ -207,25 +205,25 @@ module KRPC
     
     class SetType < TypeBase
       attr_reader :value_type
-      def initialize(type_string, type_store)
+      def initialize(type_string)
         m = /^Set\((.+)\)$/.match type_string
         raise(ValueError, "\"#{type_string}\" is not a valid type string for a set type") unless m
-        @value_type = type_store.as_type(m[1])
+        @value_type = TypeStore[m[1]]
         super(type_string, Set)
       end
     end
     
     class TupleType < TypeBase
       attr_reader :value_types
-      def initialize(type_string, type_store)
+      def initialize(type_string)
         m = /^Tuple\((.+)\)$/.match type_string
         raise(ValueError, "\"#{type_string}\" is not a valid type string for a tuple type") unless m
         
         @value_types = []
         type = m[1]
-        while type != nil
+        until type.nil?
           value_type, type = parse_type_string(type)
-          @value_types << type_store.as_type(value_type)
+          @value_types << TypeStore[value_type]
         end
         
         super(type_string, Array)
@@ -233,5 +231,6 @@ module KRPC
     end
         
   end
+  
+  TypeStore = Types::TypeStore
 end
-