krpc 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 72fc8c65a38c811d413b6e3e58b7c491782aa6b2
-  data.tar.gz: b7c500d7de5a6a180db400705ba28b7852919a20
+  metadata.gz: 4fe29f9b4d79df0423649f00f97a4f0635e34b55
+  data.tar.gz: 46a7add0e30b35ec3b33ba61b0f023052e97de9b
 SHA512:
-  metadata.gz: 7d4a82b16e0c0abbf5ba15c60705613d92f5fa54ae82f05635c82876899137391c1ff5f6cf17ec3c68bc02290be19201db8934ea11ca85c5a882ddd3bc9d3dbf
-  data.tar.gz: 5fcb55225c85ee5ead411aba691bd2de30bf8f0d105542b5c7b472e358ac78141e3e8f0befbe7aa45fd7003a63ff0b049306b0eb241eef3a540d570b85b8b42f
+  metadata.gz: b9f121f1a6d61dbf3e441124beee9eb83c7ae8303a15e342d723628c5bd6a7e5da28937e20506a7d99eced2c605e6b89c949e6ea0ccf7a1e97fb35a8240915c0
+  data.tar.gz: b79787bda276c3fb9332a97f9b8391de2a1e37df6e90494d8f7be28841014e45bfeeb5da6a60cdbe7922726d60880de3773ab0dc873935229ff75f5ac44daf4c

data/CHANGELOG.md

@@ -1,8 +1,14 @@
+v0.3.0  (15 Feb 2016)
+========
++ **Updated to work with kRPC server version 0.2.x** (#6):
+  + Using *google-protobuf* gem instead of *ruby_protobuf*, for protocol buffers version 3
++ Turned development dependency on *hanna-nouveau* into runtime dependency (Fix #5)
 
 v0.2.2  (30 Oct 2015)
 ========
-+ Static methods now require KRPC::Client instance as first argument
++ Static methods now require `KRPC::Client` instance as first argument (Fix #4)
 + Improved parameters default value handling
++ Improved collections encoding
 + Fixed few minor bugs
 
 v0.2.0  (26 Sep 2015)

data/krpc.gemspec

@@ -23,13 +23,13 @@ Gem::Specification.new do |s|
                     "--title"  << "kRPC-rb API Docs" <<
                     "--main"   << "README.md"
   
-  s.required_ruby_version = '>= 2.1.0'
+  s.required_ruby_version = ">= 2.1.0"
 
-  s.add_runtime_dependency "ruby_protobuf", "~> 0.4"
+  s.add_runtime_dependency "google-protobuf", "~> 3.0.0.alpha.5"
   s.add_runtime_dependency "colorize", "~> 0.7"
   s.add_runtime_dependency "nokogiri", "~> 1.6"
-  s.add_development_dependency 'bundler', '~> 1.7', '>= 1.7.0'
+  s.add_runtime_dependency "hanna-nouveau", "~> 0.4"
+  s.add_development_dependency "bundler", "~> 1.11"
   s.add_development_dependency "pry", "~> 0.10"
-  s.add_development_dependency "rspec", "~> 3.0"
-  s.add_development_dependency "hanna-nouveau", "~> 0.4"
+  s.add_development_dependency "rspec", "~> 3.4"
 end

data/lib/krpc.rb

@@ -1,4 +1,5 @@
 require 'krpc/version'
+require 'krpc/protobuf_extensions'
 require 'krpc/client'
 
 module KRPC

data/lib/krpc/client.rb

@@ -6,7 +6,7 @@ require 'krpc/decoder'
 require 'krpc/streaming'
 require 'krpc/error'
 require 'krpc/core_extensions'
-require 'krpc/KRPC.pb'
+require 'krpc/krpc.pb'
 
 module KRPC
   
@@ -133,7 +133,7 @@ module KRPC
     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_field? "error"
+      raise(RPCError, resp.error) if resp.has_error
       unless return_type.nil?
         Decoder.decode(resp.return_value, return_type, self)
       else
@@ -202,8 +202,7 @@ module KRPC
     def 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
+      resp = PB::Response.decode(resp_data)
     end
     
     def call_block_and_close(block)

data/lib/krpc/connection.rb

@@ -50,7 +50,9 @@ module KRPC
     def cleanup; end
     
     def send(msg) @socket.send(msg, 0) end
-    def recv(maxlen = 1) @socket.recv(maxlen) end
+    def recv(maxlen = 1)
+      maxlen == 0 ? "" : @socket.recv(maxlen)
+    end
     
     def recv_varint
       int_val = 0

data/lib/krpc/decoder.rb

@@ -43,9 +43,7 @@ module KRPC
       end
       
       def decode_message(data, type)
-        msg = type.ruby_type.new
-        msg.parse_from_string data.to_s
-        msg
+        type.ruby_type.decode(data.to_s)
       end
       
     end

data/lib/krpc/encoder.rb

@@ -1,4 +1,5 @@
 require 'krpc/protobuf_utils'
+require 'krpc/types'
 
 module KRPC
   module Encoder
@@ -10,7 +11,7 @@ module KRPC
       
       # Given a type object, and ruby object, encode the ruby object
       def encode(obj, type)
-        if type.is_a?(Types::MessageType) then obj.serialize_to_string
+        if type.is_a?(Types::MessageType) then type.ruby_type.encode(obj)
         elsif type.is_a?(Types::ValueType) then encode_value(obj, type)
         elsif type.is_a?(Types::EnumType)
           enum_value = type.ruby_type[obj]
@@ -19,27 +20,34 @@ module KRPC
           remote_oid = if obj == nil then 0 else obj.remote_oid end
           encode_value(remote_oid, TypeStore["uint64"])
         elsif type.is_a?(Types::ListType)
-          msg = TypeStore["KRPC.List"].ruby_type.new
-          msg.items = obj.map{|x| encode( TypeStore.coerce_to(x, type.value_type), type.value_type )}.to_a
-          msg.serialize_to_string
+          ruby_type = TypeStore["KRPC.List"].ruby_type
+          msg = ruby_type.new(
+            items: obj.map{|x| encode(TypeStore.coerce_to(x, type.value_type), type.value_type)}.to_a
+          )
+          ruby_type.encode(msg)
         elsif type.is_a?(Types::DictionaryType)
+          ruby_type = TypeStore["KRPC.Dictionary"].ruby_type
           entry_type = TypeStore["KRPC.DictionaryEntry"].ruby_type
-          msg = TypeStore["KRPC.Dictionary"].ruby_type.new
-          msg.entries = obj.map do |k,v|
-            entry = entry_type.new
-            entry.key = encode( TypeStore.coerce_to(k, type.key_type), type.key_type )
-            entry.value = encode( TypeStore.coerce_to(v, type.value_type), type.value_type )
-            entry
+          entries = obj.map do |k,v|
+            entry_type.new(
+              key: encode(TypeStore.coerce_to(k, type.key_type), type.key_type),
+              value: encode(TypeStore.coerce_to(v, type.value_type), type.value_type)
+            )
           end
-          msg.serialize_to_string
+          msg = ruby_type.new(entries: entries)
+          ruby_type.encode(msg)
         elsif type.is_a?(Types::SetType)
-          msg = TypeStore["KRPC.Set"].ruby_type.new
-          msg.items = obj.map{|x| encode( TypeStore.coerce_to(x, type.value_type), type.value_type )}.to_a
-          msg.serialize_to_string
+          ruby_type = TypeStore["KRPC.Set"].ruby_type
+          msg = ruby_type.new(
+            items: obj.map{|x| encode( TypeStore.coerce_to(x, type.value_type), type.value_type )}.to_a
+          )
+          ruby_type.encode(msg)
         elsif type.is_a?(Types::TupleType)
-          msg = TypeStore["KRPC.Tuple"].ruby_type.new
-          msg.items = obj.zip(type.value_types).map{|x,t| encode( TypeStore.coerce_to(x, t), t )}.to_a
-          msg.serialize_to_string
+          ruby_type = TypeStore["KRPC.Tuple"].ruby_type
+          msg = ruby_type.new(
+            items: obj.zip(type.value_types).map{|x,t| encode( TypeStore.coerce_to(x, t), t )}.to_a
+          )
+          ruby_type.encode(msg)
         else raise(RuntimeError, "Cannot encode object #{obj} of type #{type}")
         end
       end
@@ -49,7 +57,7 @@ module KRPC
       end
       
       def encode_request(req)
-        data = req.serialize_to_string
+        data = PB::Request.encode(req)
         length = ProtobufUtils::Encoder.encode_nonnegative_varint(data.length)
         length + data
       end

data/lib/krpc/gen.rb

@@ -97,12 +97,12 @@ module KRPC
           TypeStore.get_parameter_type(i, p.type, proc.attributes)
         end
         param_default = proc.parameters.zip(param_types).map do |param, type|
-          if param.has_field?("default_argument")
+          if param.has_default_argument
             Decoder.decode(param.default_argument, type, :clientless)
           else :no_default_value
           end
         end
-        return_type = if proc.has_field?("return_type")
+        return_type = if proc.has_return_type
                         TypeStore.get_return_type(proc.return_type, proc.attributes)
                       else nil end
         [param_names, param_types, param_default, return_type]
@@ -111,7 +111,7 @@ module KRPC
     
     module RPCMethodGenerator
       def include_rpc_method(method_name, service_name, procedure_name, params: [], return_type: nil, xmldoc: "", options: [])
-        Gen.add_rpc_method(self.class, method_name, service_name, PB::Procedure.new(name: procedure_name, parameters: params, return_type: return_type, documentation: xmldoc), options)
+        Gen.add_rpc_method(self.class, method_name, service_name, PB::Procedure.new(name: procedure_name, parameters: params, has_return_type: return_type != nil, return_type: return_type != nil ? return_type : "", documentation: xmldoc), options)
       end
     end
     

data/lib/krpc/krpc.pb.rb

@@ -0,0 +1,128 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: krpc.proto
+
+require 'google/protobuf'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "krpc.schema.Request" do
+    optional :service, :string, 1
+    optional :procedure, :string, 2
+    repeated :arguments, :message, 3, "krpc.schema.Argument"
+  end
+  add_message "krpc.schema.Argument" do
+    optional :position, :uint32, 1
+    optional :value, :bytes, 2
+  end
+  add_message "krpc.schema.Response" do
+    optional :time, :double, 1
+    optional :has_error, :bool, 2
+    optional :error, :string, 3
+    optional :has_return_value, :bool, 4
+    optional :return_value, :bytes, 5
+  end
+  add_message "krpc.schema.StreamMessage" do
+    repeated :responses, :message, 1, "krpc.schema.StreamResponse"
+  end
+  add_message "krpc.schema.StreamResponse" do
+    optional :id, :uint32, 1
+    optional :response, :message, 2, "krpc.schema.Response"
+  end
+  add_message "krpc.schema.Services" do
+    repeated :services, :message, 1, "krpc.schema.Service"
+  end
+  add_message "krpc.schema.Service" do
+    optional :name, :string, 1
+    repeated :procedures, :message, 2, "krpc.schema.Procedure"
+    repeated :classes, :message, 3, "krpc.schema.Class"
+    repeated :enumerations, :message, 4, "krpc.schema.Enumeration"
+    optional :documentation, :string, 5
+  end
+  add_message "krpc.schema.Procedure" do
+    optional :name, :string, 1
+    repeated :parameters, :message, 2, "krpc.schema.Parameter"
+    optional :has_return_type, :bool, 3
+    optional :return_type, :string, 4
+    repeated :attributes, :string, 5
+    optional :documentation, :string, 6
+  end
+  add_message "krpc.schema.Parameter" do
+    optional :name, :string, 1
+    optional :type, :string, 2
+    optional :has_default_argument, :bool, 3
+    optional :default_argument, :bytes, 4
+  end
+  add_message "krpc.schema.Class" do
+    optional :name, :string, 1
+    optional :documentation, :string, 2
+  end
+  add_message "krpc.schema.Enumeration" do
+    optional :name, :string, 1
+    repeated :values, :message, 2, "krpc.schema.EnumerationValue"
+    optional :documentation, :string, 3
+  end
+  add_message "krpc.schema.EnumerationValue" do
+    optional :name, :string, 1
+    optional :value, :int32, 2
+    optional :documentation, :string, 3
+  end
+  add_message "krpc.schema.List" do
+    repeated :items, :bytes, 1
+  end
+  add_message "krpc.schema.Dictionary" do
+    repeated :entries, :message, 1, "krpc.schema.DictionaryEntry"
+  end
+  add_message "krpc.schema.DictionaryEntry" do
+    optional :key, :bytes, 1
+    optional :value, :bytes, 2
+  end
+  add_message "krpc.schema.Set" do
+    repeated :items, :bytes, 1
+  end
+  add_message "krpc.schema.Tuple" do
+    repeated :items, :bytes, 1
+  end
+  add_message "krpc.schema.Status" do
+    optional :version, :string, 1
+    optional :bytes_read, :uint64, 2
+    optional :bytes_written, :uint64, 3
+    optional :bytes_read_rate, :float, 4
+    optional :bytes_written_rate, :float, 5
+    optional :rpcs_executed, :uint64, 6
+    optional :rpc_rate, :float, 7
+    optional :one_rpc_per_update, :bool, 8
+    optional :max_time_per_update, :uint32, 9
+    optional :adaptive_rate_control, :bool, 10
+    optional :blocking_recv, :bool, 11
+    optional :recv_timeout, :uint32, 12
+    optional :time_per_rpc_update, :float, 13
+    optional :poll_time_per_rpc_update, :float, 14
+    optional :exec_time_per_rpc_update, :float, 15
+    optional :stream_rpcs, :uint32, 16
+    optional :stream_rpcs_executed, :uint64, 17
+    optional :stream_rpc_rate, :float, 18
+    optional :time_per_stream_update, :float, 19
+  end
+end
+
+module KRPC
+  module PB
+    Request = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Request").msgclass
+    Argument = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Argument").msgclass
+    Response = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Response").msgclass
+    StreamMessage = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.StreamMessage").msgclass
+    StreamResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.StreamResponse").msgclass
+    Services = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Services").msgclass
+    Service = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Service").msgclass
+    Procedure = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Procedure").msgclass
+    Parameter = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Parameter").msgclass
+    Class = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Class").msgclass
+    Enumeration = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Enumeration").msgclass
+    EnumerationValue = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.EnumerationValue").msgclass
+    List = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.List").msgclass
+    Dictionary = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Dictionary").msgclass
+    DictionaryEntry = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.DictionaryEntry").msgclass
+    Set = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Set").msgclass
+    Tuple = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Tuple").msgclass
+    Status = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Status").msgclass
+  end
+end

data/lib/krpc/protobuf_extensions.rb

@@ -0,0 +1,20 @@
+require 'krpc/krpc.pb'
+
+module KRPC
+  module ProtobufExtensions
+
+    module MessageExtensions
+      def ==(other)
+        super
+      rescue TypeError
+        false
+      end
+    end
+
+  end
+end
+
+KRPC::PB.constants(false).map {|const_name| KRPC::PB.const_get(const_name,true)}.each do |msgclass|
+  msgclass.prepend KRPC::ProtobufExtensions::MessageExtensions
+end
+

data/lib/krpc/protobuf_utils.rb

@@ -1,12 +1,11 @@
-require 'krpc/KRPC.pb'
+require 'krpc/krpc.pb'
 
 module KRPC
   module ProtobufUtils
     class << self
       def create_PB_to_PB_message_class_hash(package)
         protobuf_module = Kernel.const_get(package.gsub(".","::") + "::PB")
-        msg_classes_names = protobuf_module.constants.select{|c| protobuf_module.const_get(c,false).superclass == ::Protobuf::Message}
-        msg_classes_names.map do |name|
+        protobuf_module.constants.map do |name|
           [package + "." + name.to_s, protobuf_module.const_get(name,false)]
         end.to_h
       end    
@@ -60,11 +59,11 @@ module KRPC
         end
         def decode_string(bytes)
           size, pos = decode_varint_pos(bytes)
-          bytes[pos..(pos+size)]
+          bytes[pos..(pos+size)].force_encoding(Encoding::UTF_8)
         end
         def decode_bytes(bytes)
           size, pos = decode_varint_pos(bytes)
-          bytes[pos..(pos+size)]
+          bytes[pos..(pos+size)].bytes
         end
         
       end

data/lib/krpc/streaming.rb

@@ -62,7 +62,7 @@ module KRPC
               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")
+                if stream_resp.response.has_error
                   stream.value = RPCError.new(stream_resp.response.error)
                 else
                   stream.value = Decoder.decode(stream_resp.response.return_value, stream.return_type, client)

data/lib/krpc/types.rb

@@ -37,7 +37,6 @@ module KRPC
             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)
-            elsif type_string == "Test.TestEnum" then ValueType.new("int32")
             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

data/lib/krpc/version.rb

@@ -1,3 +1,3 @@
 module KRPC
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: krpc
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Tomasz Więch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-30 00:00:00.000000000 Z
+date: 2016-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ruby_protobuf
+  name: google-protobuf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 3.0.0.alpha.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 3.0.0.alpha.5
 - !ruby/object:Gem::Dependency
   name: colorize
   requirement: !ruby/object:Gem::Requirement
@@ -53,67 +53,61 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: hanna-nouveau
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.7.0
-  type: :development
+        version: '0.4'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.7.0
+        version: '0.4'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '1.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '1.11'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0.10'
 - !ruby/object:Gem::Dependency
-  name: hanna-nouveau
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '3.4'
 description: kRPC-rb is a Ruby client library for kRPC, a Kerbal Space Program mod
   that allows you to control KSP from external scripts running outside of the game.
 email:
@@ -129,7 +123,6 @@ files:
 - README.md
 - krpc.gemspec
 - lib/krpc.rb
-- lib/krpc/KRPC.pb.rb
 - lib/krpc/attributes.rb
 - lib/krpc/client.rb
 - lib/krpc/connection.rb
@@ -139,6 +132,8 @@ files:
 - lib/krpc/encoder.rb
 - lib/krpc/error.rb
 - lib/krpc/gen.rb
+- lib/krpc/krpc.pb.rb
+- lib/krpc/protobuf_extensions.rb
 - lib/krpc/protobuf_utils.rb
 - lib/krpc/repl_tools.rb
 - lib/krpc/service.rb
@@ -173,7 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Client library for kRPC

data/lib/krpc/KRPC.pb.rb

@@ -1,124 +0,0 @@
-
-### 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