grpc 1.30.2-x86-mingw32

data/src/ruby/lib/grpc/generic/service.rb

@@ -0,0 +1,211 @@
+# Copyright 2015 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative 'client_stub'
+require_relative 'rpc_desc'
+
+# GRPC contains the General RPC module.
+module GRPC
+  # Provides behaviour used to implement schema-derived service classes.
+  #
+  # Is intended to be used to support both client and server
+  # IDL-schema-derived servers.
+  module GenericService
+    # creates a new string that is the underscore separate version of s.
+    #
+    # E.g,
+    # PrintHTML -> print_html
+    # AMethod -> a_method
+    # AnRpc -> an_rpc
+    #
+    # @param s [String] the string to be converted.
+    def self.underscore(s)
+      s = +s # Avoid mutating the argument, as it might be frozen.
+      s.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      s.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      s.tr!('-', '_')
+      s.downcase!
+      s
+    end
+
+    # Used to indicate that a name has already been specified
+    class DuplicateRpcName < StandardError
+      def initialize(name)
+        super("rpc (#{name}) is already defined")
+      end
+    end
+
+    # Provides a simple DSL to describe RPC services.
+    #
+    # E.g, a Maths service that uses the serializable messages DivArgs,
+    # DivReply and Num might define its endpoint uses the following way:
+    #
+    # rpc :div DivArgs, DivReply    # single request, single response
+    # rpc :sum stream(Num), Num     # streamed input, single response
+    # rpc :fib FibArgs, stream(Num) # single request, streamed response
+    # rpc :div_many stream(DivArgs), stream(DivReply)
+    #                               # streamed req and resp
+    #
+    # Each 'rpc' adds an RpcDesc to classes including this module, and
+    # #assert_rpc_descs_have_methods is used to ensure the including class
+    # provides methods with signatures that support all the descriptors.
+    module Dsl
+      # This configures the method names that the serializable message
+      # implementation uses to marshal and unmarshal messages.
+      #
+      # - unmarshal_class method must be a class method on the serializable
+      # message type that takes a string (byte stream) and produces and object
+      #
+      # - marshal_class_method is called on a serializable message instance
+      # and produces a serialized string.
+      #
+      # The Dsl verifies that the types in the descriptor have both the
+      # unmarshal and marshal methods.
+      attr_writer(:marshal_class_method, :unmarshal_class_method)
+
+      # This allows configuration of the service name.
+      attr_accessor(:service_name)
+
+      # Adds an RPC spec.
+      #
+      # Takes the RPC name and the classes representing the types to be
+      # serialized, and adds them to the including classes rpc_desc hash.
+      #
+      # input and output should both have the methods #marshal and #unmarshal
+      # that are responsible for writing and reading an object instance from a
+      # byte buffer respectively.
+      #
+      # @param name [String] the name of the rpc
+      # @param input [Object] the input parameter's class
+      # @param output [Object] the output parameter's class
+      def rpc(name, input, output)
+        fail(DuplicateRpcName, name) if rpc_descs.key? name
+        assert_can_marshal(input)
+        assert_can_marshal(output)
+        rpc_descs[name] = RpcDesc.new(name, input, output,
+                                      marshal_class_method,
+                                      unmarshal_class_method)
+        define_method(GenericService.underscore(name.to_s).to_sym) do |*|
+          fail GRPC::BadStatus.new_status_exception(
+            GRPC::Core::StatusCodes::UNIMPLEMENTED)
+        end
+      end
+
+      def inherited(subclass)
+        # Each subclass should have a distinct class variable with its own
+        # rpc_descs
+        subclass.rpc_descs.merge!(rpc_descs)
+        subclass.service_name = service_name
+      end
+
+      # the name of the instance method used to marshal events to a byte
+      # stream.
+      def marshal_class_method
+        @marshal_class_method ||= :marshal
+      end
+
+      # the name of the class method used to unmarshal from a byte stream.
+      def unmarshal_class_method
+        @unmarshal_class_method ||= :unmarshal
+      end
+
+      def assert_can_marshal(cls)
+        cls = cls.type if cls.is_a? RpcDesc::Stream
+        mth = unmarshal_class_method
+        unless cls.methods.include? mth
+          fail(ArgumentError, "#{cls} needs #{cls}.#{mth}")
+        end
+        mth = marshal_class_method
+        return if cls.methods.include? mth
+        fail(ArgumentError, "#{cls} needs #{cls}.#{mth}")
+      end
+
+      # @param cls [Class] the class of a serializable type
+      # @return cls wrapped in a RpcDesc::Stream
+      def stream(cls)
+        assert_can_marshal(cls)
+        RpcDesc::Stream.new(cls)
+      end
+
+      # the RpcDescs defined for this GenericService, keyed by name.
+      def rpc_descs
+        @rpc_descs ||= {}
+      end
+
+      # Creates a rpc client class with methods for accessing the methods
+      # currently in rpc_descs.
+      def rpc_stub_class
+        descs = rpc_descs
+        route_prefix = service_name
+        Class.new(ClientStub) do
+          # @param host [String] the host the stub connects to
+          # @param creds [Core::ChannelCredentials|Symbol] The channel
+          #     credentials to use, or :this_channel_is_insecure otherwise
+          # @param kw [KeywordArgs] the channel arguments, plus any optional
+          #                         args for configuring the client's channel
+          def initialize(host, creds, **kw)
+            super(host, creds, **kw)
+          end
+
+          # Used define_method to add a method for each rpc_desc.  Each method
+          # calls the base class method for the given descriptor.
+          descs.each_pair do |name, desc|
+            mth_name = GenericService.underscore(name.to_s).to_sym
+            marshal = desc.marshal_proc
+            unmarshal = desc.unmarshal_proc(:output)
+            route = "/#{route_prefix}/#{name}"
+            if desc.request_response?
+              define_method(mth_name) do |req, metadata = {}|
+                GRPC.logger.debug("calling #{@host}:#{route}")
+                request_response(route, req, marshal, unmarshal, **metadata)
+              end
+            elsif desc.client_streamer?
+              define_method(mth_name) do |reqs, metadata = {}|
+                GRPC.logger.debug("calling #{@host}:#{route}")
+                client_streamer(route, reqs, marshal, unmarshal, **metadata)
+              end
+            elsif desc.server_streamer?
+              define_method(mth_name) do |req, metadata = {}, &blk|
+                GRPC.logger.debug("calling #{@host}:#{route}")
+                server_streamer(route, req, marshal, unmarshal, **metadata, &blk)
+              end
+            else  # is a bidi_stream
+              define_method(mth_name) do |reqs, metadata = {}, &blk|
+                GRPC.logger.debug("calling #{@host}:#{route}")
+                bidi_streamer(route, reqs, marshal, unmarshal, **metadata, &blk)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def self.included(o)
+      o.extend(Dsl)
+      # Update to the use the service name including module. Provide a default
+      # that can be nil e.g. when modules are declared dynamically.
+      return unless o.service_name.nil?
+      if o.name.nil?
+        o.service_name = 'GenericService'
+      else
+        modules = o.name.split('::')
+        if modules.length > 2
+          o.service_name = modules[modules.length - 2]
+        else
+          o.service_name = modules.first
+        end
+      end
+    end
+  end
+end

data/src/ruby/lib/grpc/google_rpc_status_utils.rb

@@ -0,0 +1,40 @@
+# Copyright 2017 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative './structs'
+
+# GRPC contains the General RPC module.
+module GRPC
+  # GoogleRpcStatusUtils provides utilities to convert between a
+  # GRPC::Core::Status and a deserialized Google::Rpc::Status proto
+  # Returns nil if the grpc-status-details-bin trailer could not be
+  # converted to a GoogleRpcStatus due to the server not providing
+  # the necessary trailers.
+  # Raises an error if the server did provide the necessary trailers
+  # but they fail to deseriliaze into a GoogleRpcStatus protobuf.
+  class GoogleRpcStatusUtils
+    def self.extract_google_rpc_status(status)
+      fail ArgumentError, 'bad type' unless status.is_a? Struct::Status
+      grpc_status_details_bin_trailer = 'grpc-status-details-bin'
+      binstatus = status.metadata[grpc_status_details_bin_trailer]
+      return nil if binstatus.nil?
+
+      # Lazily load grpc_c and protobuf_c.so for users of this method.
+      require_relative './grpc'
+      require 'google/rpc/status_pb'
+
+      Google::Rpc::Status.decode(binstatus)
+    end
+  end
+end

data/src/ruby/lib/grpc/grpc.rb

@@ -0,0 +1,24 @@
+# Copyright 2015 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+begin
+  ruby_version_dirname = /(\d+\.\d+)/.match(RUBY_VERSION).to_s
+  distrib_lib_dir = File.expand_path(ruby_version_dirname,
+                                     File.dirname(__FILE__))
+  if File.directory?(distrib_lib_dir)
+    require "#{distrib_lib_dir}/grpc_c"
+  else
+    require 'grpc/grpc_c'
+  end
+end

data/src/ruby/lib/grpc/logconfig.rb

@@ -0,0 +1,44 @@
+# Copyright 2015 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# GRPC contains the General RPC module.
+module GRPC
+  # DefaultLogger is a module included in GRPC if no other logging is set up for
+  # it.  See ../spec/spec_helpers an example of where other logging is added.
+  module DefaultLogger
+    def logger
+      LOGGER
+    end
+
+    private
+
+    # NoopLogger implements the methods of Ruby's conventional logging interface
+    # that are actually used internally within gRPC with a noop implementation.
+    class NoopLogger
+      def info(_ignored)
+      end
+
+      def debug(_ignored)
+      end
+
+      def warn(_ignored)
+      end
+    end
+
+    LOGGER = NoopLogger.new
+  end
+
+  # Inject the noop #logger if no module-level logger method has been injected.
+  extend DefaultLogger unless methods.include?(:logger)
+end

data/src/ruby/lib/grpc/notifier.rb

@@ -0,0 +1,45 @@
+# Copyright 2015 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# GRPC contains the General RPC module.
+module GRPC
+  # Notifier is useful high-level synchronization primitive.
+  class Notifier
+    attr_reader :payload, :notified
+    alias_method :notified?, :notified
+
+    def initialize
+      @mutex    = Mutex.new
+      @cvar     = ConditionVariable.new
+      @notified = false
+      @payload  = nil
+    end
+
+    def wait
+      @mutex.synchronize do
+        @cvar.wait(@mutex) until notified?
+      end
+    end
+
+    def notify(payload)
+      @mutex.synchronize do
+        return Error.new('already notified') if notified?
+        @payload  = payload
+        @notified = true
+        @cvar.signal
+        return nil
+      end
+    end
+  end
+end

data/src/ruby/lib/grpc/structs.rb

@@ -0,0 +1,15 @@
+# Copyright 2015 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+Struct.new('Status', :code, :details, :metadata, :debug_error_string)

data/src/ruby/lib/grpc/version.rb

@@ -0,0 +1,18 @@
+# Copyright 2015 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# GRPC contains the General RPC module.
+module GRPC
+  VERSION = '1.30.2'
+end

data/src/ruby/pb/README.md

@@ -0,0 +1,42 @@
+Protocol Buffers
+================
+
+This folder contains protocol buffers provided with gRPC ruby, and the generated
+code to them.
+
+PREREQUISITES
+-------------
+
+The code is generated using the protoc (> 3.0.0.alpha.1) and the
+grpc_ruby_plugin.  These must be installed to regenerate the IDL defined
+classes, but that's not necessary just to use them.
+
+health_check/v1
+--------------------
+
+This package defines the surface of a simple health check service that gRPC
+servers may choose to implement, and provides an implementation for it. To
+re-generate the surface.
+
+```bash
+$ # (from this directory)
+$ protoc -I ../../proto ../../proto/grpc/health/v1/health.proto \
+    --grpc_out=. \
+    --ruby_out=. \
+    --plugin=protoc-gen-grpc=`which grpc_ruby_plugin`
+```
+
+test
+----
+
+This package defines the surface of the gRPC interop test service and client
+To re-generate the surface, it's necessary to have checked-out versions of
+the grpc interop test proto, e.g, by having the full gRPC repository. E.g,
+
+```bash
+$ # (from this directory within the grpc repo)
+$ protoc -I../../.. ../../../test/proto/{messages,test,empty}.proto \
+    --grpc_out=. \
+    --ruby_out=. \
+    --plugin=protoc-gen-grpc=`which grpc_ruby_plugin`
+```