krpc 0.3.2 → 0.4.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef6917b47511f404073511fc327657a34d46967f
-  data.tar.gz: 06ef229097a2524042524b155ff38c3ff110f5ee
+  metadata.gz: f8d2668d37ed41486d38de335c5d77eb9fbf7ea4
+  data.tar.gz: 76ccaf2af65825e916d3202ba06be94cc8c5d9a9
 SHA512:
-  metadata.gz: cf70656dc94287f0d52f00af03d338258779612a56e09957a0b02e740155477baeb0c508e95dcff5dd5d3ebeb5e31949a2eb72b1e2e0296abcf098638ba5b176
-  data.tar.gz: 1e54734369a2c4f72add79e9325e71698f19ba3409bb84747f9351b8df9c72a020be5d1950b516ba6ebe5984351724774e612717d77a65eaa8b5c3555d3fa4e8
+  metadata.gz: fa42767df76f7f37d10e493ecfed5fcde5bb23a7b5e2d07b944f7e15ff1ef98c89c00b997326d318a4503b0159f03e7c681184cefd22e309afa574cabef0d20e
+  data.tar.gz: 449e4c7cd429e6b5bb10e05559ebf1692a59d0a5044f60a71912c19e623ffdd8183391b7f98854308846e17de6b0e2c2e98823ed345bc907ed8e2dba23d48ec4

data/README.md

@@ -10,8 +10,6 @@ Installation
 
     gem install krpc
 
-or install the latest pre-release version (if [available](https://rubygems.org/gems/krpc/versions)): `gem install krpc --pre`
-
 Basic usage
 -------
 
@@ -96,7 +94,7 @@ SpaceCenter.transform_position(
 	to :ReferenceFrame - The reference frame to covert the position vector to.
 ) :Array[Float, Float, Float] - The corresponding position vector in reference frame to.
 
- Converts a position vector from one reference frame to another.
+ Converts a position vector from one reference frame to another. 
 => nil
 ```
 
@@ -135,6 +133,6 @@ pos_stream.remove #note: dead code - just as an example
 Want to know more?
 -------
 * Read official **kRPC documentation** at https://krpc.github.io/krpc, with many great [tutorials and examples](https://krpc.github.io/krpc/tutorials.html).
-* Refer to **kRPC-rb documentation** at https://tewu.github.io/krpc-rb-apidocs
+* Refer to **kRPC-rb API documentation** at https://tewu.github.io/krpc-rb-apidocs
 * See official **kRPC forum thread** at http://forum.kerbalspaceprogram.com/threads/69313
 

data/krpc.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
   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{^(doc|test|spec|features|bin)/|Rakefile|CHANGELOG}) || f.start_with?('.') }
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(doc|test|spec|features|bin/TestServer)/|Rakefile|CHANGELOG}) || f.start_with?('.') }
   s.require_paths = ["lib"]
   s.extra_rdoc_files = ["README.md"]
   s.rdoc_options << "--markup" << "markdown" <<
@@ -24,12 +24,12 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = ">= 2.1.0"
 
-  s.add_runtime_dependency "google-protobuf", "~> 3.3"
+  s.add_runtime_dependency "google-protobuf", "~> 3.1"
   s.add_runtime_dependency "colorize", "~> 0.8"
-  s.add_runtime_dependency "nokogiri", "~> 1.8"
-  s.add_development_dependency "bundler", "~> 1.15"
+  s.add_runtime_dependency "nokogiri", "~> 1.6"
+  s.add_development_dependency "bundler", "~> 1.13"
   s.add_development_dependency "pry", "~> 0.10"
-  s.add_development_dependency "rspec", "~> 3.6"
-  s.add_development_dependency "rake", "~> 12.0"
+  s.add_development_dependency "rspec", "~> 3.5"
+  s.add_development_dependency "rake", "~> 11.3"
   s.add_development_dependency "hanna-nouveau", "~> 1.0"
 end

data/lib/krpc.rb

@@ -4,13 +4,13 @@ require 'krpc/client'
 
 module KRPC
   class << self
-
+  
     # Connect to a kRPC server, generate services API and return Client object. If the block is
     # given, then it's called passing Client object and the connection to kRPC server is closed
     # at the end of the block.
     def connect(*args, &block)
       Client.new(*args).connect!(&block)
     end
-
+    
   end
 end

data/lib/krpc/client.rb

@@ -9,17 +9,17 @@ require 'krpc/core_extensions'
 require 'krpc/krpc.pb'
 
 module KRPC
-
+  
   ##
-  # A kRPC client, through which all Remote Procedure Calls are made. To make RPC calls client
+  # A kRPC client, through which all Remote Procedure Calls are made. To make RPC calls client 
   # must first connect to server. This can be achieved by calling Client#connect or Client#connect!
-  # methods. Client object can connect and disconnect from the server many times during it's
-  # lifetime. RPCs can be made by calling Client#execute_rpc method. After generating services API (with
-  # Client#generate_services_api! call), RPCs can be also made using
+  # methods. Client object can connect and disconnect from the server many times during it's 
+  # lifetime. RPCs can be made by calling Client#execute_rpc method. After generating the services API
+  # (with Client#generate_services_api! call), RPCs can be also made using
   # `client.service_name.procedure_name(parameter, ...)`
   #
   # ### Example:
-  #     client = KRPC::Client.new(name: "my client").connect!
+  #     client = KRPC::Client.new(name: "my client").connect! # Notice that Client#connect! is shorthand for calling Client#connect and Client#generate_services_api! subsequently
   #     ctrl = client.space_center.active_vessel.control
   #     ctrl.activate_next_stage
   #     ctrl.throttle = 1 # Full ahead!
@@ -34,8 +34,8 @@ module KRPC
 
     attr_reader :name, :rpc_connection, :stream_connection, :streams_manager, :core
 
-    # Create new Client object, optionally specifying IP address and port numbers on witch kRPC
-    # server is listening and the name for this client (up to 32 bytes of UTF-8 encoded text).
+    # Create new Client object, optionally specifying IP address and port numbers on witch kRPC 
+    # server is listening and the name for this client.
     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 = RPCConnection.new(name, host, rpc_port)
@@ -43,12 +43,12 @@ module KRPC
       @streams_manager = Streaming::StreamsManager.new(self)
       @services = {}
       @core = Services::Core.new(self)
-      Doc.add_docstring_info(false, self.class, "core", return_type: @core.class, xmldoc: "<doc><summary>Core kRPC service, e.g. for querying for the available services. Most of this functionality is used internally by the Ruby client and therefore does not need to be used directly from application code. This service is hardcoded (in kRPC Ruby client) version of 'krpc' service, so 1) it is available even before services API is generated, but 2) can be out of sync with 'krpc' service.</summary></doc>")
+      Doc.add_docstring_info(false, self.class, "core", return_type: @core.class, xmldoc: "<doc><summary>Core kRPC service, e.g. for querying for the available services. Most of this functionality is used internally by the Ruby client and therefore does not need to be used directly from application code. This service is hardcoded (in kRPC Ruby client) version of 'krpc' service, so 1) it is available even before the services API is generated, but 2) can be out of sync with 'krpc' service.</summary></doc>")
     end
-
+    
     # Connect to a kRPC server on the IP address and port numbers specified during this client
     # object creation and return `self`. Calling this method while the client is already connected
-    # will raise an exception. If the block is given, then it's called passing `self` and the
+    # will raise an exception. If the block is given, then it's called passing `self` and the 
     # connection to kRPC server is closed at the end of the block.
     def connect(&block)
       rpc_connection.connect
@@ -57,9 +57,9 @@ module KRPC
       call_block_and_close(block) if block_given?
       self
     end
-
-    # Connect to a kRPC server, generate services API and return `self`. Shorthand for calling
-    # Client#connect and Client#generate_services_api! subsequently. If the block is given, then
+    
+    # Connect to a kRPC server, generate the services API and return `self`. Shorthand for calling
+    # Client#connect and Client#generate_services_api! subsequently. If the block is given, then 
     # it's called passing `self` and the connection to kRPC server is closed at the end of the block.
     def connect!(&block)
       connect
@@ -67,8 +67,8 @@ module KRPC
       call_block_and_close(block) if block_given?
       self
     end
-
-    # Close connection to kRPC server. Returns `true` if the connection has closed or `false` if
+    
+    # Close connection to kRPC server. Returns `true` if the connection has closed or `false` if 
     # the client had been already disconnected.
     def close
       streams_manager.remove_all_streams
@@ -81,21 +81,21 @@ module KRPC
     def connected?
       rpc_connection.connected?
     end
-
-    # Interrogates the server to find out what functionality it provides and dynamically creates
-    # all of the classes and methods that form services API. For each service that server provides:
-    #
+      
+    # Interrogates the server to find out what functionality it provides and dynamically creates 
+    # all of the classes and methods that form the services API. For each service that server provides:
+    # 
     # 1. Class `KRPC::Services::{service name here}`, and module `KRPC::Gen::{service name here}`
     #    are created.
     # 2. `KRPC::Gen::{service name here}` module is filled with dynamically created classes.
-    # 3. Those classes in turn are filled with dynamically created methods, that form API for
+    # 3. Those classes in turn are filled with dynamically created methods, which form the API for
     #    this service.
-    # 4. Instance method `{service name here}` is created in this client object that returns
+    # 4. Instance method `{service name here}` is created in this client object that returns 
     #    `KRPC::Services::{service name here}` object. This object is entry point for accessing
     #    functionality provided by `{service name here}` service.
     #
-    # Returns `self`. Invoking this method the second and subsequent times doesn't regenerate API.
-    # To regenerate API create new Client object and call #generate_services_api! on it.
+    # Returns `self`. Invoking this method the second and subsequent times doesn't regenerate the API.
+    # To regenerate the API create new Client object and call #generate_services_api! on it.
     #
     # ### Example
     #       client = KRPC::Client.new(name: "my client").connect # Notice that it is 'Client#connect' being called, not 'Client#connect!'
@@ -107,8 +107,8 @@ module KRPC
     #       client.close
     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?
-
+      raise(Exception, "Can't generate the services API while not connected to a server -- call Client#connect! to connect to server and generate the services API in one call") if not connected?
+      
       resp = core.get_services
       resp.services.each do |service_msg|
         service_class = Services.create_service(service_msg)
@@ -122,48 +122,54 @@ module KRPC
       end
       self
     end
-
-    # Returns `true` if services API has been already generated, `false` otherwise.
+    
+    # Returns `true` if the services API has been already generated, `false` otherwise.
     def services_api_generated?
       respond_to? :space_center or respond_to? :test_service
     end
-
+    
     # Execute an RPC.
     def execute_rpc(service, procedure, args=[], kwargs={}, param_names=[], param_types=[], param_default=[], return_type: nil)
       send_request(service, procedure, args, kwargs, param_names, param_types, param_default)
-      resp = receive_response
-      raise(RPCError, resp.error) if resp.has_error
+      result = receive_result
+      raise(RPCError, result.error) unless result.field_empty? :error
       unless return_type.nil?
-        Decoder.decode(resp.return_value, return_type, self)
+        Decoder.decode(result.value, return_type, self)
       else
         nil
       end
     rescue IOError => e
-      raise(Exception, "RPC call attempt while not connected to server -- call Client#connect first") if not connected?
+      raise(Exception, "RPC call attempt while not connected to a server -- call Client#connect first") if not connected?
       raise e
     end
 
     # Build a PB::Request object.
     def build_request(service, procedure, args=[], kwargs={}, param_names=[], param_types=[], param_default=[])
+      call = build_procedure_call(service, procedure, args, kwargs, param_names, param_types, param_default)
+      PB::Request.new(calls: [call])
+    end
+
+    # Build a PB::ProcedureCall object.
+    def build_procedure_call(service, procedure, args=[], kwargs={}, param_names=[], param_types=[], 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.length == param_types.length
         raise(ArgumentError, "param_names and param_default should be equal length\n\tparam_names = #{param_names}\n\tparam_default = #{param_default}") unless param_names.length == param_default.length
         required_params_count = param_default.take_while{|pd| pd == :no_default_value}.count
         raise ArgumentsNumberErrorSig.new(args.count, required_params_count..param_names.count) unless args.count <= param_names.count
-        req_args = construct_arguments(args, kwargs, param_names, param_types, param_default, required_params_count)
+        call_args = construct_arguments(args, kwargs, param_names, param_types, param_default, required_params_count)
       rescue ArgumentErrorSig => err
         raise err.with_signature(Doc.docstring_for_procedure(service, procedure, false))
       end
-      PB::Request.new(service: service, procedure: procedure, arguments: req_args)
+      PB::ProcedureCall.new(service: service, procedure: procedure, arguments: call_args)
     end
 
     protected #----------------------------------
-
+    
     def construct_arguments(args, kwargs, param_names, param_types, param_default, required_params_count)
       param_names_symbols = param_names.map(&:to_sym)
       kwargs_remaining = kwargs.count
-
-      req_args = param_names_symbols.map.with_index do |name, i|
+      
+      call_args = param_names_symbols.map.with_index do |name, i|
         is_kwarg = kwargs.has_key? name
         kwargs_remaining -= 1 if is_kwarg
         raise ArgumentErrorSig.new("there are both positional and keyword arguments for parameter \"#{name}\"") if is_kwarg && i < args.count
@@ -188,25 +194,25 @@ module KRPC
           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
-      req_args
+      call_args
     end
 
     def send_request(service, procedure, args, kwargs, param_names, param_types, param_default)
       req = build_request(service, procedure, args, kwargs, param_names, param_types, param_default)
-      rpc_connection.send Encoder.encode_request(req)
+      rpc_connection.send_message req
     end
-
-    def receive_response
-      resp_length = rpc_connection.recv_varint
-      resp_data = rpc_connection.recv resp_length
-      resp = PB::Response.decode(resp_data)
+    
+    def receive_result
+      resp = rpc_connection.receive_message PB::Response
+      raise(RPCError, resp.error) unless resp.field_empty? :error
+      resp.results[0]
     end
-
+    
     def call_block_and_close(block)
       begin block.call(self) ensure close end
     end
-
+    
   end
 end

data/lib/krpc/connection.rb

@@ -10,18 +10,18 @@ module KRPC
     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
-
+    
     # Connect and perform handshake.
     def connect
       if connected? then raise(ConnectionError, "Already connected")
-      else
-        @socket = TCPSocket.open(host, port)
+      else 
+        @socket = TCPSocket.open(host, port) 
         begin
           handshake
         rescue Exception => e
@@ -31,7 +31,7 @@ module KRPC
       end
       self
     end
-
+    
     # Close connection and clean up.
     def close
       if connected?
@@ -40,20 +40,32 @@ module KRPC
         true
       else false end
     end
-
+    
     # Return `true` if connected to a server, `false` otherwise.
     def connected?
       !socket.nil? && !socket.closed?
     end
-
+    
     def handshake; end
     def cleanup; end
-
-    def send(msg) @socket.send(msg, 0) end
+    
+    def protobuf_handshake(type, **attrs)
+      send_message PB::ConnectionRequest.new(type: type, **attrs)
+      resp = receive_message PB::ConnectionResponse
+      raise(ConnectionError, "#{resp.status} -- #{resp.message}") unless resp.status == :OK
+      resp
+    end
+    
+    def send(data)
+      @socket.send(data, 0)
+    end
+    def send_message(msg)
+      send Encoder.encode_message_with_size(msg)
+    end
+    
     def recv(maxlen = 1)
       maxlen == 0 ? "" : @socket.read(maxlen)
     end
-
     def recv_varint
       int_val = 0
       shift = 0
@@ -65,33 +77,29 @@ module KRPC
         raise(RuntimeError, "too many bytes when decoding varint") if shift >= 64
       end
     end
-
-    protected #----------------------------------
-
-    def trim_fill(str, len, fill_char = "\x00")
-      str = str.encode("UTF-8")[0, len]
-      str + fill_char*(len-str.length)
+    def receive_message(msg_type)
+      msg_length = recv_varint
+      msg_data = recv(msg_length)
+      msg_type.decode(msg_data)
     end
   end
 
   ##
-  # TCP connection for sending RPC calls and retrieving it's results.
+  # TCP connection for sending RPC calls and retrieving its results.
   class RPCConnection < Connection
     attr_reader :name, :client_id
-
-    def initialize(name, host = DEFAULT_SERVER_HOST, port = DEFAULT_SERVER_RPC_PORT)
+    
+    def initialize(name = Client::DEFAULT_NAME, host = DEFAULT_SERVER_HOST, port = DEFAULT_SERVER_RPC_PORT)
       super host, port
       @name = name
     end
 
     # Perform handshake with kRPC server, obtaining `@client_id`.
     def handshake
-      send Encoder::RPC_HELLO_MESSAGE
-      send trim_fill(name, Encoder::NAME_LENGTH)
-      @client_id = recv Decoder::GUID_LENGTH
+      resp = protobuf_handshake(:RPC, client_name: name)
+      @client_id = resp.client_identifier
     end
-
-    # Clean up - sets `@client_id` to `nil`.
+    
     def cleanup
       @client_id = nil
     end
@@ -101,20 +109,17 @@ module KRPC
   # TCP connection for streaming.
   class StreamConnection < 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
-
+    
     # Perform handshake with kRPC server, sending `client_id` retrieved from `rpc_connection`.
     def handshake
-      raise(ConnectionError, "RPC connection must obtain 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
+      raise(ConnectionError, "RPC connection must obtain client_id before stream connection can perform valid handshake - closing stream connection") if rpc_connection.client_id.nil? 
+      protobuf_handshake(:STREAM, client_identifier: rpc_connection.client_id)
     end
   end
-
+  
 end

data/lib/krpc/core_extensions.rb

@@ -3,7 +3,7 @@ class Module
   def class_name
     name.rpartition("::").last
   end
-
+  
   def const_get_or_create(module_name, value = nil, &block)
     return const_get(module_name) if const_defined?(module_name, false)
     value = block.call if block_given?
@@ -26,9 +26,9 @@ class String
   end
 
   def integer?
-    Integer(self) != nil rescue false
+    Integer(self) != nil rescue false 
   end
-
+  
   def numeric?
     Float(self) != nil rescue false
   end