krpc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dd2789a9c287acf5c0102288bf37d79551d85bf1
+  data.tar.gz: c4135dc71e1b1e11ee8b75978ebeaf0d014e779d
+SHA512:
+  metadata.gz: 45bab162e5b7402b9553fc2e4fef9a1bbb8a048c40985e14b9fb53f1fe69580ae84da35813709b1cd8424100bdb67b1e2a5d2a304fda27efab38c5ef66110bb7
+  data.tar.gz: c2c5c2cf56506d4cb0df4940ed87945a464f64610aed0d47443dd0d3a1b74669f832f77e84256a2e33fb3fec5e6a6f8478e436d714bd4ddd75099d6a724ac81a

data/.gitignore

@@ -0,0 +1,6 @@
+*.*~
+
+*.gem
+Gemfile.lock
+.bundle
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in krpc.gemspec
+gemspec

data/krpc.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |s|
+  s.name          = "krpc"
+  s.version       = "0.1.0"
+  s.authors       = ["Tomasz Więch"]
+  s.email         = ["tewu.dev@gmail.com"]
+  
+  s.summary       = "Client library for kRPC"
+  s.homepage      = "https://github.com/TeWu/krpc-rb"
+  s.license       = "GPL-3.0"
+  
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.require_paths = ["lib"]
+  
+  s.add_runtime_dependency "ruby_protobuf", "~> 0.4"
+  s.add_runtime_dependency "colorize", "~> 0.7"
+  
+  s.add_development_dependency "bundler", "~> 1.10"
+end
+

data/lib/krpc.rb

@@ -0,0 +1 @@
+require 'krpc/client'

data/lib/krpc/KRPC.pb.rb

@@ -0,0 +1,125 @@
+
+### Generated by rprotoc. DO NOT EDIT!
+
+require 'protobuf/message/message'
+require 'protobuf/message/enum'
+require 'protobuf/message/service'
+require 'protobuf/message/extend'
+
+module KRPC
+  module PB
+    class Request < ::Protobuf::Message
+      defined_in __FILE__
+      required :string, :service, 1
+      required :string, :procedure, 2
+      repeated :Argument, :arguments, 3
+    end
+    class Argument < ::Protobuf::Message
+      defined_in __FILE__
+      required :uint32, :position, 1
+      required :bytes, :value, 2
+    end
+    class Response < ::Protobuf::Message
+      defined_in __FILE__
+      required :double, :time, 1
+      optional :string, :error, 2
+      optional :bytes, :return_value, 3
+    end
+    class StreamMessage < ::Protobuf::Message
+      defined_in __FILE__
+      repeated :StreamResponse, :responses, 1
+    end
+    class StreamResponse < ::Protobuf::Message
+      defined_in __FILE__
+      required :uint32, :id, 1
+      required :Response, :response, 2
+    end
+    class Services < ::Protobuf::Message
+      defined_in __FILE__
+      repeated :Service, :services, 1
+    end
+    class Service < ::Protobuf::Message
+      defined_in __FILE__
+      required :string, :name, 1
+      repeated :Procedure, :procedures, 2
+      repeated :Class, :classes, 3
+      repeated :Enumeration, :enumerations, 4
+      optional :string, :documentation, 5
+    end
+    class Procedure < ::Protobuf::Message
+      defined_in __FILE__
+      required :string, :name, 1
+      repeated :Parameter, :parameters, 2
+      optional :string, :return_type, 3
+      repeated :string, :attributes, 4
+      optional :string, :documentation, 5
+    end
+    class Parameter < ::Protobuf::Message
+      defined_in __FILE__
+      required :string, :name, 1
+      required :string, :type, 2
+      optional :bytes, :default_argument, 3
+    end
+    class Class < ::Protobuf::Message
+      defined_in __FILE__
+      required :string, :name, 1
+      optional :string, :documentation, 2
+    end
+    class Enumeration < ::Protobuf::Message
+      defined_in __FILE__
+      required :string, :name, 1
+      repeated :EnumerationValue, :values, 2
+      optional :string, :documentation, 3
+    end
+    class EnumerationValue < ::Protobuf::Message
+      defined_in __FILE__
+      required :string, :name, 1
+      required :int32, :value, 2
+      optional :string, :documentation, 3
+    end
+    class List < ::Protobuf::Message
+      defined_in __FILE__
+      repeated :bytes, :items, 1
+    end
+    class Dictionary < ::Protobuf::Message
+      defined_in __FILE__
+      repeated :DictionaryEntry, :entries, 1
+    end
+    class DictionaryEntry < ::Protobuf::Message
+      defined_in __FILE__
+      required :bytes, :key, 1
+      required :bytes, :value, 2
+    end
+    class Set < ::Protobuf::Message
+      defined_in __FILE__
+      repeated :bytes, :items, 1
+    end
+    class Tuple < ::Protobuf::Message
+      defined_in __FILE__
+      repeated :bytes, :items, 1
+    end
+    class Status < ::Protobuf::Message
+      defined_in __FILE__
+      required :string, :version, 1
+      required :uint64, :bytes_read, 2
+      required :uint64, :bytes_written, 3
+      required :float, :bytes_read_rate, 4
+      required :float, :bytes_written_rate, 5
+      required :uint64, :rpcs_executed, 6
+      required :float, :rpc_rate, 7
+      required :bool, :one_rpc_per_update, 8
+      required :uint32, :max_time_per_update, 9
+      required :bool, :adaptive_rate_control, 10
+      required :bool, :blocking_recv, 11
+      required :uint32, :recv_timeout, 12
+      required :float, :time_per_rpc_update, 13
+      required :float, :poll_time_per_rpc_update, 14
+      required :float, :exec_time_per_rpc_update, 15
+      required :uint32, :stream_rpcs, 16
+      required :uint64, :stream_rpcs_executed, 17
+      required :float, :stream_rpc_rate, 18
+      required :float, :time_per_stream_update, 19
+    end
+  end  
+end
+

data/lib/krpc/attributes.rb

@@ -0,0 +1,81 @@
+require 'krpc/error'
+
+module KRPC
+  module Attributes
+    class << self
+
+      def is_any_start_with?(attrs, prefix)
+        attrs.any?{|a| a.start_with? prefix }
+      end
+      alias_method :asw?, :is_any_start_with?
+      
+      def is_a_property_accessor(attrs) asw?(attrs,"Property.")  end
+      def is_a_property_getter(attrs) asw?(attrs,"Property.Get(") end
+      def is_a_property_setter(attrs) asw?(attrs,"Property.Set(") end
+      def is_a_class_method_or_property_accessor(attrs) asw?(attrs,"Class.") end
+      def is_a_class_method(attrs) asw?(attrs,"Class.Method(") end
+      def is_a_class_static_method(attrs) asw?(attrs,"Class.StaticMethod(") end    
+      def is_a_class_property_accessor(attrs) asw?(attrs,"Class.Property.") end
+      def is_a_class_property_getter(attrs) asw?(attrs,"Class.Property.Get(") end
+      def is_a_class_property_setter(attrs) asw?(attrs,"Class.Property.Set(") end
+      
+      def get_service_name(attrs)
+        if is_a_class_method(attrs) || is_a_class_static_method(attrs)
+          attrs.each do |a| 
+            return $1 if /^Class\.(?:Static)?Method\(([^,\.]+)\.[^,]+,[^,]+\)$/ =~ a
+          end
+        elsif is_a_class_property_accessor(attrs)
+          attrs.each do |a| 
+            return $1 if /^Class\.Property.(?:Get|Set)\(([^,\.]+)\.[^,]+,[^,]+\)$/ =~ a
+          end
+        end
+        raise(ValueError, "Procedure attributes are not a class method or property accessor")
+      end
+      
+      def get_class_name(attrs)
+        if is_a_class_method(attrs) || is_a_class_static_method(attrs)
+          attrs.each do |a| 
+            return $1 if /^Class\.(?:Static)?Method\([^,\.]+\.([^,\.]+),[^,]+\)$/ =~ a
+          end
+        elsif is_a_class_property_accessor(attrs)
+          attrs.each do |a| 
+            return $1 if /^Class\.Property.(?:Get|Set)\([^,\.]+\.([^,]+),[^,]+\)$/ =~ a
+          end
+        end
+        raise(ValueError, "Procedure attributes are not a class method or property accessor")
+      end
+      
+      def get_property_name(attrs)
+        if is_a_property_accessor(attrs)
+          attrs.each do |a| 
+            return $1 if /^Property\.(?:Get|Set)\((.+)\)$/ =~ a
+          end
+        end
+        raise(ValueError, "Procedure attributes are not a property accessor")
+      end
+      
+      def get_class_method_or_property_name(attrs)
+        if is_a_class_method(attrs) || is_a_class_static_method(attrs) || is_a_class_property_accessor(attrs)
+          attrs.each do |a| 
+            return $1 if /^Class\.(?:(?:Static)?Method|Property\.(?:Get|Set))\([^,]+,([^,]+)\)$/ =~ a
+          end
+        end
+        raise(ValueError, "Procedure attributes are not a class method or class property accessor")
+      end
+      
+      def get_parameter_type_attrs(pos, attrs)
+        attrs.map do |a| 
+          (/^ParameterType\(#{pos}\).(.+)$/ =~ a) ? $1 : nil
+        end.compact
+      end
+      
+      def get_return_type_attrs(attrs)
+        attrs.map do |a| 
+          (/^ReturnType.(.+)$/ =~ a) ? $1 : nil
+        end.compact
+      end
+      
+    end
+  end
+end
+

data/lib/krpc/client.rb

@@ -0,0 +1,130 @@
+require 'krpc/connection'
+require 'krpc/service'
+require 'krpc/types'
+require 'krpc/encoder'
+require 'krpc/decoder'
+require 'krpc/error'
+require 'krpc/core_extensions'
+require 'krpc/KRPC.pb'
+
+module KRPC
+  class Client
+    DEFAULT_NAME = ""
+
+    include Doc::SuffixMethods
+
+    attr_reader :name, :rpc_connection, :stream_connection, :type_store, :krpc
+    
+    def initialize(name = DEFAULT_NAME, host = Connection::DEFAULT_SERVER_HOST, rpc_port = Connection::DEFAULT_SERVER_RPC_PORT, stream_port = Connection::DEFAULT_SERVER_STREAM_PORT)
+      @name = name
+      @rpc_connection = RPCConncetion.new(name, host, rpc_port)
+      @stream_connection = StreamConncetion.new(rpc_connection, host, stream_port)
+      @type_store = Types::TypeStore.new
+      @krpc = Services::KRPC.new(self)
+      Doc.add_docstring_info(false, self.class, "krpc", return_type: @krpc.class)
+    end
+    
+    def connect
+      rpc_connection.connect
+      stream_connection.connect
+      self
+    end
+    
+    def connect!
+      connect
+      generate_services_api!
+      self
+    end
+    
+    def close
+      stream_connection.close
+      rpc_connection.close
+    end
+
+    def connected?
+      rpc_connection.connected?
+    end
+        
+    def generate_services_api!
+      return self if services_api_generated?
+      raise(Exception, "Can't generate services API while not connected to server -- call Client#connect! to connect to server and generate services API in one call") if not connected?
+      
+      resp = krpc.get_services
+      resp.services.each do |service_msg|
+        next if service_msg.name == "KRPC"
+        service = Services.create_service(service_msg, self)
+        method_name = service.class.class_name.underscore
+        self.class.instance_eval do
+          define_method method_name do service end
+        end
+        Doc.add_docstring_info(false, self.class, method_name, return_type: service.class)
+      end
+      self
+    end
+    
+    def services_api_generated?
+      respond_to? :space_center
+    end
+    
+    def rpc(service, procedure, args=[], kwargs={}, param_names=[], param_types=[], required_params_count=0, param_default=[], return_type: nil)
+      # Send request
+      req = build_request(service, procedure, args, kwargs, param_names, param_types, required_params_count, param_default)
+      rpc_connection.send Encoder.encode_request(req)
+      # Receive response
+      resp_length = rpc_connection.recv_varint
+      resp_data = rpc_connection.recv resp_length
+      resp = PB::Response.new
+      resp.parse_from_string resp_data
+      # Check for an error response
+      raise(RPCError, resp.error) if resp.has_field? "error"
+      # Optionally decode and return the response' return value
+      if return_type == nil
+        nil
+      else
+        Decoder.decode(resp.return_value, return_type, type_store)
+      end
+    rescue IOError => e
+      raise(Exception, "RPC call attempt while not connected to server -- call Client#connect first") if not connected?
+      raise e
+    end
+    
+    protected #----------------------------------
+
+    def build_request(service, procedure, args=[], kwargs={}, param_names=[], param_types=[], required_params_count=0, param_default=[])
+      begin
+        raise(ArgumentError, "param_names and param_types should be equal length\n\tparam_names = #{param_names}\n\tparam_types = #{param_types}") unless param_names.size == param_types.size
+        raise ArgumentsNumberErrorSig.new(args.count, required_params_count..param_names.count) unless args.count <= param_names.count
+        kwargs_remaining = kwargs.count
+        
+        param_names_symbols = param_names.map(&:to_sym)
+        req_args = param_names_symbols.map.with_index do |name,i|
+          is_kwarg = kwargs.has_key? name
+          raise ArgumentErrorSig.new("there are both positional and keyword arguments for parameter \"#{name}\"") if is_kwarg && i < args.count 
+          kwargs_remaining -= 1 if is_kwarg
+          unless i >= required_params_count && 
+                 (!is_kwarg && i >= args.count ||
+                  !is_kwarg && args[i] == param_default[i] ||
+                  is_kwarg  && kwargs[name] == param_default[i])
+            arg = if is_kwarg then kwargs[name]
+                  elsif i < args.count then args[i]
+                  else raise ArgumentErrorSig.new("missing argument for parameter \"#{name}\"") 
+                  end
+            begin
+              arg = type_store.coerce_to(arg, param_types[i])
+            rescue ValueError
+              raise ArgumentErrorSig.new("argument for parameter \"#{name}\" must be a #{param_types[i].ruby_type} -- got #{args[i]} of type #{args[i].class}")
+            end
+            v = Encoder.encode(arg, param_types[i], type_store)
+            PB::Argument.new(position: i, value: v)
+          end
+        end.compact
+        raise ArgumentErrorSig.new("keyword arguments for non existing parameters: #{(kwargs.keys - param_names_symbols).join(", ")}") unless kwargs_remaining == 0
+      rescue ArgumentErrorSig => err
+        raise err.with_signature(Doc.docstring_for_procedure(service, procedure))
+      end
+      PB::Request.new(service: service, procedure: procedure, arguments: req_args)
+    end
+    
+  end
+end
+

data/lib/krpc/connection.rb

@@ -0,0 +1,108 @@
+require 'krpc/encoder'
+require 'krpc/decoder'
+require 'socket'
+
+module KRPC
+
+  class Connection
+    DEFAULT_SERVER_HOST = "127.0.0.1"
+    DEFAULT_SERVER_RPC_PORT = 50000
+    DEFAULT_SERVER_STREAM_PORT = 50001
+    
+    attr_reader :host, :port, :socket
+    
+    def initialize(host, port)
+      @host, @port = host, port
+    end
+    
+    def connect
+      if connected? then raise(ConnectionError, "Already connected")
+      else 
+        @socket = TCPSocket.open(host, port) 
+        begin
+          handshake
+        rescue Exception => e
+          close
+          raise e
+        end
+      end
+      self
+    end
+    
+    def close
+      if connected?
+        socket.close
+        cleanup
+        true
+      else false end
+    end
+    
+    def connected?
+      !socket.nil? && !socket.closed?
+    end
+    
+    def handshake; end
+    def cleanup; end
+    
+    def send(msg) @socket.send(msg,0) end
+    def recv(maxlen = 1) @socket.recv(maxlen) end
+    
+    def recv_varint
+      int_val = 0
+      shift = 0
+      loop do
+        byte = recv.ord
+        int_val |= (byte & 0b0111_1111) << shift
+        return int_val if (byte & 0b1000_0000) == 0
+        shift += 7
+        raise(RuntimeError, "too many bytes when decoding varint") if shift >= 64
+        sleep 0.1
+      end
+    end
+    
+    protected #----------------------------------
+    
+    def trim_fill(str, len, fill_char = "\x00")
+      str = str.encode("UTF-8")[0,len]
+      str + fill_char*(len-str.length)
+    end
+  end
+
+  class RPCConncetion < Connection
+    attr_reader :name, :client_id
+    
+    def initialize(name, host = DEFAULT_SERVER_HOST, port = DEFAULT_SERVER_RPC_PORT)
+      super host, port
+      @name = name
+    end
+
+    def handshake
+      send Encoder::RPC_HELLO_MESSAGE
+      send trim_fill(name, Encoder::NAME_LENGTH)
+      @client_id = recv Decoder::GUID_LENGTH
+    end
+    
+    def cleanup
+      @client_id = nil
+    end
+  end
+
+  class StreamConncetion < Connection
+    attr_reader :rpc_connection
+    
+    def initialize(rpc_connection, host = DEFAULT_SERVER_HOST, port = DEFAULT_SERVER_STREAM_PORT)
+      super host, port
+      @rpc_connection = rpc_connection
+    end
+    
+    def handshake
+      raise(ConnectionError, "RPC connection must optain client_id before stream connection can perform valid handshake - closing stream connection") if rpc_connection.client_id.nil? 
+      send Encoder::STREAM_HELLO_MESSAGE
+      send rpc_connection.client_id
+      resp = recv Decoder::OK_LENGTH
+      raise ConnectionError unless resp == Decoder::OK_MESSAGE
+    end
+  end
+  
+end
+