gapic-generator 0.1.1

data/lib/gapic/grpc_service_config/method_config.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Google LLC
+#
+# 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
+#
+#     https://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.
+
+module Gapic
+  module GrpcServiceConfig
+    ##
+    # Method config represents a combination of a timeout and
+    # a retry policy, both of which can be optional
+    # It is applied during a GRPC method call and governs the
+    # client-side timeout/retry policy
+    #
+    class MethodConfig
+      attr_reader :timeout_seconds, :retry_policy
+
+      ##
+      # Create new MethodConfig
+      #
+      # @param timeout_seconds [Float, nil] the value of timeout in seconds if provided
+      # @param retry_policy [Gapic::GrpcServiceConfig::RetryPolicy] the retry policy
+      #
+      def initialize timeout_seconds, retry_policy
+        @timeout_seconds = timeout_seconds
+        @retry_policy    = retry_policy
+      end
+
+      ##
+      # Returns whether MethodConfig is empty (does not contain any values)
+      #
+      # @return [Boolean] whether MethodConfig is empty
+      #
+      def empty?
+        @timeout_seconds.nil? && @retry_policy.empty?
+      end
+    end
+  end
+end

data/lib/gapic/grpc_service_config/parser.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Google LLC
+#
+# 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
+#
+#     https://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 "gapic/grpc_service_config/service_config"
+require "gapic/grpc_service_config/method_config"
+require "gapic/grpc_service_config/retry_policy"
+require "gapic/grpc_service_config/parsing_error"
+
+module Gapic
+  module GrpcServiceConfig
+    ##
+    # Takes a json of a GRPC service Config and parses it into the form
+    # usable by the microgenerator templates
+    #
+    module Parser
+      METHOD_CONFIG_JSON_KEY = "methodConfig"
+      RETRY_POLICY_JSON_KEY = "retryPolicy"
+
+      NAMES_JSON_KEY = "name"
+      SERVICE_NAME_JSON_KEY = "service"
+      METHOD_NAME_JSON_KEY = "method"
+
+      TIMEOUT_JSON_KEY = "timeout"
+
+      INITIAL_DELAY_JSON_KEY = "initialBackoff"
+      MAX_DELAY_JSON_KEY = "maxBackoff"
+      MULTIPLIER_JSON_KEY = "backoffMultiplier"
+      STATUS_CODES_JSON_KEY = "retryableStatusCodes"
+
+
+      ##
+      # Parses ServiceConfig from a json of a GRPC service config
+      #
+      # @param service_config_json [Hash] a hash that results from JSON.parse
+      #
+      # @return [Gapic::GrpcServiceConfig::ServiceConfig] parsed ServiceConfig
+      #
+      def self.parse service_config_json
+        service_level_result = {}
+        service_method_level_result = {}
+
+        if !service_config_json.nil? && key?(service_config_json, METHOD_CONFIG_JSON_KEY)
+          method_configs_json = get service_config_json, METHOD_CONFIG_JSON_KEY
+
+          method_configs_json.each do |method_config_json|
+            method_config = parse_config method_config_json
+            service_names = parse_service_names get(method_config_json, NAMES_JSON_KEY)
+            service_method_names = filter_service_method_names get(method_config_json, NAMES_JSON_KEY)
+
+            service_names.each do |service_name|
+              service_level_result[service_name] = method_config
+            end
+
+            service_method_names.each do |service_method_name|
+              service_name = get service_method_name, SERVICE_NAME_JSON_KEY
+              method_name = get service_method_name, METHOD_NAME_JSON_KEY
+
+              service_method_level_result[service_name] ||= {}
+              service_method_level_result[service_name][method_name] = method_config
+            end
+          end
+        end
+
+        ServiceConfig.new service_level_result, service_method_level_result
+      end
+
+      ##
+      # Parses the names of the services for which the service-level
+      # config is defined from the GRPC service config json.
+      # Within the json the names are arranged in hashes. Each hash contains a
+      # required "service" key and an optional "method" key. Here we select only
+      # the hashes WITHOUT the optional key -- meaning that the config will be
+      # applied on a service-level -- and return just the service names.
+      #
+      # @param method_config_json_names [Array<Hash<String, String>>] "name" hashes from
+      #   the GRPC service config
+      #
+      # @return [Array<String>] parsed names of services
+      #
+      def self.parse_service_names method_config_json_names
+        service_names_jsons = method_config_json_names.select do |names_json|
+          names_json.size == 1 && key?(names_json, SERVICE_NAME_JSON_KEY)
+        end
+
+        service_names_jsons.map { |names_json| get names_json, SERVICE_NAME_JSON_KEY }
+      end
+
+      ##
+      # Filters the "name" hashes from the GRPC service config json
+      # to exclude service-level names
+      # Within the json the names are arranged in hashes. Each hash contains a
+      # required "service" key and an optional "method" key. Here we select only
+      # the hashes WITH the optional key -- meaning that the config will be
+      # applied on a method-level -- and return the hashes in full.
+      #
+      # @param method_config_json_names [Array<Hash<String, String>>] "name" hashes
+      #   from the GRPC service config
+      #
+      # @return [Array<Hash<String, String>>] filtered hashes for methods
+      #
+      def self.filter_service_method_names method_config_json_names
+        method_config_json_names.select do |names_json|
+          names_json.size == 2 && key?(names_json, SERVICE_NAME_JSON_KEY) && key?(names_json, METHOD_NAME_JSON_KEY)
+        end
+      end
+
+      ##
+      # Parses MethodConfig from the GRPC service config json
+      #
+      # @param method_config_json [Hash] a hash of a single "method_config"
+      #   from the GRPC service config
+      #
+      # @return [Gapic::GrpcServiceConfig::MethodConfig] parsed MethodConfig
+      #
+      def self.parse_config method_config_json
+        timeout_seconds = parse_interval_seconds get(method_config_json, TIMEOUT_JSON_KEY)
+        retry_policy = parse_retry_policy get(method_config_json, RETRY_POLICY_JSON_KEY)
+
+        MethodConfig.new timeout_seconds, retry_policy
+      end
+
+      ##
+      # Parses RetryPolicy from the GRPC service config json
+      #
+      # @param retry_policy_json [Hash<String, String>] a hash of a single "retry_policy"
+      #   from the GRPC service config
+      #
+      # @return [Gapic::GrpcServiceConfig::RetryPolicy] parsed RetryPolicy
+      #
+      def self.parse_retry_policy retry_policy_json
+        return nil if retry_policy_json.nil? || retry_policy_json.empty?
+
+        initial_delay_seconds = parse_interval_seconds get(retry_policy_json, INITIAL_DELAY_JSON_KEY)
+        max_delay_seconds = parse_interval_seconds get(retry_policy_json, MAX_DELAY_JSON_KEY)
+        multiplier = get retry_policy_json, MULTIPLIER_JSON_KEY
+        status_codes = get retry_policy_json, STATUS_CODES_JSON_KEY
+
+        RetryPolicy.new initial_delay_seconds, max_delay_seconds, multiplier, status_codes
+      end
+
+      ##
+      # Parses time expressed in secondds from the GRPC service config json
+      # The time is encoded is a string as float or integer with a letter 's' afterwards
+      # If given a nil or an empty string returns nil for 'not set' semantic
+      # If a string sans the 's' cannot be converted throws a ParsingError
+      #
+      # @param timestring [String, nil] a string of a time inerval from the GRPC service config
+      #
+      # @raise [ParsingError] if the time interval string could not be converted
+      #
+      # @return [Float, nil] converted time interval or nil for 'not set'
+      #
+      def self.parse_interval_seconds timestring
+        return nil if timestring.empty?
+
+        timestring_nos = timestring.delete_suffix "s"
+        unless valid_float? timestring_nos
+          error_text = "Was not able to convert the string `#{timestring}` " \
+                        "to a time interval when parsing a grpc service config"
+          raise ParsingError, error_text
+        end
+        Float(timestring_nos)
+      end
+
+      ##
+      # Determines if the key or its underscore form exists
+      #
+      # @param hash [Hash] hash structure
+      # @param key [String] lowerCamelCase string
+      # @return [Boolean]
+      #
+      def self.key? hash, key
+        hash.key?(key) || hash.key?(ActiveSupport::Inflector.underscore(key))
+      end
+
+      ##
+      # Look up a key including checking its underscore form
+      #
+      # @param hash [Hash] hash structure
+      # @param key [String] lowerCamelCase string
+      # @return [Object] the result, or `nil` if not found
+      #
+      def self.get hash, key
+        hash[key] || hash[ActiveSupport::Inflector.underscore(key)]
+      end
+
+      ##
+      # Determines if a given string can be converted to a float
+      #
+      # @param str [String, nil] a given string, can be nil
+      #
+      # @return [Boolean] true, if converstion to float is possible
+      #
+      def self.valid_float? str
+        Float(str)
+        true
+      rescue ::ArgumentError, ::TypeError
+        false
+      end
+
+      private_class_method :parse_service_names, :filter_service_method_names, :parse_config,
+                           :parse_retry_policy, :parse_interval_seconds, :valid_float?
+    end
+  end
+end

data/lib/gapic/grpc_service_config/parsing_error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Google LLC
+#
+# 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
+#
+#     https://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.
+
+module Gapic
+  module GrpcServiceConfig
+    ##
+    # Represents an error occuring during the GRPC config parsing
+    #
+    class ParsingError < StandardError
+    end
+  end
+end

data/lib/gapic/grpc_service_config/retry_policy.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Google LLC
+#
+# 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
+#
+#     https://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.
+
+module Gapic
+  module GrpcServiceConfig
+    ##
+    # RetryPolicy encapsulates the parameters governing the client-side retry
+    # for the GRPC method invocation. It is embedded into the MethodConfig
+    #
+    class RetryPolicy
+      attr_reader :initial_delay_seconds, :max_delay_seconds, :multiplier, :status_codes
+
+      ##
+      # Create new ParsedRetryPolicy.
+      #
+      # @param initial_delay_seconds [Float, nil] the value of initial retry delay in seconds if provided
+      # @param max_delay_seconds [Float, nil] the value of max retry delay in seconds if provided
+      # @param multiplier [Float, nil] the value of retry multiplier if provided
+      # @param status_codes [Array<String>, nil] the retry status codes if provided
+      #
+      def initialize initial_delay_seconds, max_delay_seconds, multiplier, status_codes
+        @initial_delay_seconds = initial_delay_seconds
+        @max_delay_seconds     = max_delay_seconds
+        @multiplier            = multiplier
+        @status_codes          = status_codes
+      end
+
+      ##
+      # Returns whether RetryPolicy is empty (does not contain any values)
+      #
+      # @return [Boolean] whether RetryPolicy is empty
+      #
+      def empty?
+        @initial_delay_seconds.nil? && @max_delay_seconds.nil? && @multiplier.nil? && status_codes.to_a.empty?
+      end
+    end
+  end
+end

data/lib/gapic/grpc_service_config/service_config.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Google LLC
+#
+# 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
+#
+#     https://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.
+
+module Gapic
+  module GrpcServiceConfig
+    ##
+    # Representation of a GRPC service config split into the configurations
+    # applied on the service level (to all the methods) and the configurations
+    # applied to the specific methods
+    #
+    class ServiceConfig
+      attr_reader :service_level_configs, :service_method_level_configs
+
+      ##
+      # Create new ServiceConfig.
+      #
+      # @param service_level_configs [Hash<String, Gapic::GrpcServiceConfig::MethodConfig>] service-level configs
+      #   in a lookup hash by the service full grpc name
+      #
+      # @param service_method_level_configs [Hash<String, Hash<String, Gapic::GrpcServiceConfig::MethodConfig>>]
+      #   method-level configs in a double lookup hash, first by the service full grpc name then by the method name
+      #
+      def initialize service_level_configs, service_method_level_configs
+        @service_level_configs = service_level_configs
+        @service_method_level_configs = service_method_level_configs
+      end
+    end
+  end
+end

data/lib/gapic/path_template.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Copyright 2019 Google LLC
+#
+# 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
+#
+#     https://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 "gapic/path_template/parser"
+
+module Gapic
+  # TODO: Enter docs
+  # Dooooooooocs!!!
+  module PathTemplate
+    # Parse a URI path template.
+    #
+    # @see https://tools.ietf.org/html/rfc6570 URI Template
+    #
+    # @param path_template [String] The URI path template to be parsed.
+    #
+    # @return [Array<PathTemplate::Segment|String>] The segments of the URI
+    #   path template.
+    def self.parse path_template
+      Parser.new(path_template).segments
+    end
+  end
+end

data/lib/gapic/path_template/parser.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# Copyright 2019 Google LLC
+#
+# 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
+#
+#     https://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 "gapic/path_template/segment"
+
+module Gapic
+  module PathTemplate
+    # A URI path template parser.
+    #
+    # @see https://tools.ietf.org/html/rfc6570 URI Template
+    #
+    # @!attribute [r] path_template
+    #   @return [String] The URI path template to be parsed.
+    # @!attribute [r] segments
+    #   @return [Array<Segment|String>] The segments of the parsed URI path
+    #     template.
+    class Parser
+      # @private
+      # /((?<positional>\*\*?)|{(?<name>[^\/]+?)(?:=(?<template>.+?))?})/
+      PATH_TEMPLATE = %r{
+        (
+          (?<positional>\*\*?)
+          |
+          {(?<name>[^\/]+?)(?:=(?<template>.+?))?}
+        )
+      }x.freeze
+
+      attr_reader :path_template, :segments
+
+      # Create a new URI path template parser.
+      #
+      # @param path_template [String] The URI path template to be parsed.
+      def initialize path_template
+        @path_template = path_template
+        @segments = parse! path_template
+      end
+
+      protected
+
+      def parse! path_template
+        # segments contain either Strings or segment objects
+        segments = []
+        segment_pos = 0
+
+        while (match = PATH_TEMPLATE.match path_template)
+          # The String before the match needs to be added to the segments
+          segments << match.pre_match unless match.pre_match.empty?
+
+          segment, segment_pos = segment_and_pos_from_match match, segment_pos
+          segments << segment
+
+          path_template = match.post_match
+        end
+
+        # Whatever String is unmatched needs to be added to the segments
+        segments << path_template unless path_template.empty?
+
+        segments
+      end
+
+      def segment_and_pos_from_match match, pos
+        if match[:positional]
+          [Segment.new(pos, match[:positional]), pos + 1]
+        else
+          [Segment.new(match[:name], match[:template]), pos]
+        end
+      end
+    end
+  end
+end