functions_framework 0.3.1 → 0.5.2

data/lib/functions_framework/function.rb

@@ -16,22 +16,59 @@ module FunctionsFramework
   ##
   # Representation of a function.
   #
-  # A function has a name, a type, and a code definition.
+  # A function has a name, a type, and an implementation.
+  #
+  # The implementation in general is an object that responds to the `call`
+  # method. For a function of type `:http`, the `call` method takes a single
+  # `Rack::Request` argument and returns one of various HTTP response types.
+  # See {FunctionsFramework::Registry.add_http}. For a function of type
+  # `:cloud_event`, the `call` method takes a single
+  # [CloudEvent](https://cloudevents.github.io/sdk-ruby/latest/CloudEvents/Event)
+  # argument, and does not return a value.
+  # See {FunctionsFramework::Registry.add_cloud_event}.
+  #
+  # If a callable object is provided directly, its `call` method is invoked for
+  # every function execution. Note that this means it may be called multiple
+  # times concurrently in separate threads.
+  #
+  # Alternately, the implementation may be provided as a class that should be
+  # instantiated to produce a callable object. If a class is provided, it should
+  # either subclass {FunctionsFramework::Function::CallBase} or respond to the
+  # same constructor interface, i.e. accepting arbitrary keyword arguments. A
+  # separate callable object will be instantiated from this class for every
+  # function invocation, so each instance will be used for only one invocation.
+  #
+  # Finally, an implementation can be provided as a block. If a block is
+  # provided, it will be recast as a `call` method in an anonymous subclass of
+  # {FunctionsFramework::Function::CallBase}. Thus, providing a block is really
+  # just syntactic sugar for providing a class. (This means, for example, that
+  # the `return` keyword will work within the block because it is treated as a
+  # method.)
   #
   class Function
     ##
     # Create a new function definition.
     #
     # @param name [String] The function name
-    # @param type [Symbol] The type of function. Valid types are
-    #     `:http`, `:event`, and `:cloud_event`.
-    # @param block [Proc] The function code as a proc
+    # @param type [Symbol] The type of function. Valid types are `:http` and
+    #     `:cloud_event`.
+    # @param callable [Class,#call] A callable object or class.
+    # @param block [Proc] The function code as a block.
     #
-    def initialize name, type, &block
+    def initialize name, type, callable = nil, &block
       @name = name
       @type = type
-      @execution_context_class = Class.new do
-        define_method :call, &block
+      @callable = @callable_class = nil
+      if callable.respond_to? :call
+        @callable = callable
+      elsif callable.is_a? ::Class
+        @callable_class = callable
+      elsif block_given?
+        @callable_class = ::Class.new CallBase do
+          define_method :call, &block
+        end
+      else
+        raise ::ArgumentError, "No callable given for function"
       end
     end
 
@@ -46,26 +83,48 @@ module FunctionsFramework
     attr_reader :type
 
     ##
-    # Call the function. You must pass an argument appropriate to the type
-    # of function.
+    # Get a callable for performing a function invocation. This will either
+    # return the singleton callable object, or instantiate a new callable from
+    # the configured class.
     #
-    #  *  A `:http` type function takes a `Rack::Request` argument, and returns
-    #     a Rack response type. See {FunctionsFramework::Registry.add_http}.
-    #  *  A `:cloud_event` type function takes a
-    #     {FunctionsFramework::CloudEvents::Event} argument, and does not
-    #     return a value. See {FunctionsFramework::Registry.add_cloud_event}.
+    # @param logger [::Logger] The logger for use by function executions. This
+    #     may or may not be used by the callable.
+    # @return [#call]
     #
-    # @param argument [Rack::Request,FunctionsFramework::CloudEvents::Event]
-    # @return [Object]
+    def new_call logger: nil
+      return @callable unless @callable.nil?
+      logger ||= FunctionsFramework.logger
+      @callable_class.new logger: logger, function_name: name, function_type: type
+    end
+
+    ##
+    # A base class for a callable object that provides calling context.
     #
-    def call argument
-      execution_context = @execution_context_class.new
-      case type
-      when :event
-        execution_context.call argument.data, argument
-      else
-        execution_context.call argument
+    # An object of this class is `self` while a function block is running.
+    #
+    class CallBase
+      ##
+      # Create a callable object with the given context.
+      #
+      # @param context [keywords] A set of context arguments. See {#context} for
+      #     a list of keys that will generally be passed in. However,
+      #     implementations should be prepared to accept any abritrary keys.
+      #
+      def initialize **context
+        @context = context
       end
+
+      ##
+      # A keyed hash of context information. Common context keys include:
+      #
+      #  *  **:logger** (`Logger`) A logger for use by this function call.
+      #  *  **:function_name** (`String`) The name of the running function.
+      #  *  **:function_type** (`Symbol`) The type of the running function,
+      #     either `:http` or `:cloud_event`.
+      #
+      # @return [Hash]
+      #
+      attr_reader :context
     end
   end
 end

data/lib/functions_framework/legacy_event_converter.rb

@@ -23,19 +23,17 @@ module FunctionsFramework
     # Decode an event from the given Rack environment hash.
     #
     # @param env [Hash] The Rack environment
-    # @return [FunctionsFramework::CloudEvents::Event] if the request could
-    #     be converted
+    # @return [::CloudEvents::Event] if the request could be converted
     # @return [nil] if the event format was not recognized.
     #
     def decode_rack_env env
-      content_type = CloudEvents::ContentType.new env["CONTENT_TYPE"]
-      return nil unless content_type.media_type == "application" && content_type.subtype_prefix == "json"
+      content_type = ::CloudEvents::ContentType.new env["CONTENT_TYPE"]
+      return nil unless content_type.media_type == "application" && content_type.subtype_base == "json"
       input = read_input_json env["rack.input"], content_type.charset
       return nil unless input
-      raw_context = input["context"] || input
-      context = normalized_context raw_context
+      context = normalized_context input
       return nil unless context
-      construct_cloud_event context, input["data"]
+      construct_cloud_event context, input["data"], content_type.charset
     end
 
     private
@@ -50,27 +48,27 @@ module FunctionsFramework
       nil
     end
 
-    def normalized_context raw_context
-      id = raw_context["eventId"]
-      return nil unless id
-      timestamp = raw_context["timestamp"]
-      return nil unless timestamp
-      type = raw_context["eventType"]
-      return nil unless type
-      service, resource = analyze_resource raw_context["resource"], type
-      return nil unless service && resource
+    def normalized_context input
+      raw_context = input["context"]
+      id = raw_context&.[]("eventId") || input["eventId"]
+      timestamp = raw_context&.[]("timestamp") || input["timestamp"]
+      type = raw_context&.[]("eventType") || input["eventType"]
+      service, resource = analyze_resource raw_context&.[]("resource") || input["resource"]
+      service ||= service_from_type type
+      return nil unless id && timestamp && type && service && resource
       { id: id, timestamp: timestamp, type: type, service: service, resource: resource }
     end
 
-    def analyze_resource raw_resource, type
+    def analyze_resource raw_resource
+      service = resource = nil
       case raw_resource
       when ::Hash
-        [raw_resource["service"], raw_resource["name"]]
+        service = raw_resource["service"]
+        resource = raw_resource["name"]
       when ::String
-        [service_from_type(type), raw_resource]
-      else
-        [nil, nil]
+        resource = raw_resource
       end
+      [service, resource]
     end
 
     def service_from_type type
@@ -80,19 +78,20 @@ module FunctionsFramework
       nil
     end
 
-    def construct_cloud_event context, data
+    def construct_cloud_event context, data, charset
       source, subject = convert_source context[:service], context[:resource]
       type = LEGACY_TYPE_TO_CE_TYPE[context[:type]]
       return nil unless type && source
       ce_data = convert_data context[:service], data
-      CloudEvents::Event.new id:                context[:id],
-                             source:            source,
-                             type:              type,
-                             spec_version:      "1.0",
-                             data_content_type: "application/json",
-                             data:              ce_data,
-                             subject:           subject,
-                             time:              context[:timestamp]
+      content_type = "application/json; charset=#{charset}"
+      ::CloudEvents::Event.new id:                context[:id],
+                               source:            source,
+                               type:              type,
+                               spec_version:      "1.0",
+                               data_content_type: content_type,
+                               data:              ce_data,
+                               subject:           subject,
+                               time:              context[:timestamp]
     end
 
     def convert_source service, resource

data/lib/functions_framework/registry.rb

@@ -75,27 +75,13 @@ module FunctionsFramework
       self
     end
 
-    ##
-    # This is an obsolete interface that defines an event function taking two
-    # arguments (data and context) rather than one.
-    #
-    # @deprecated Use {Registry#add_cloud_event} instead.
-    #
-    def add_event name, &block
-      name = name.to_s
-      synchronize do
-        raise ::ArgumentError, "Function already defined: #{name}" if @functions.key? name
-        @functions[name] = Function.new name, :event, &block
-      end
-      self
-    end
-
     ##
     # Add a CloudEvent function to the registry.
     #
     # You must provide a name for the function, and a block that implemets the
     # function. The block should take _one_ argument: the event object of type
-    # {FunctionsFramework::CloudEvents::Event}. Any return value is ignored.
+    # [`CloudEvents::Event`](https://cloudevents.github.io/sdk-ruby/latest/CloudEvents/Event).
+    # Any return value is ignored.
     #
     # @param name [String] The function name
     # @param block [Proc] The function code as a proc

data/lib/functions_framework/server.rb

@@ -47,7 +47,7 @@ module FunctionsFramework
         case function.type
         when :http
           HttpApp.new function, @config
-        when :event, :cloud_event
+        when :cloud_event
           EventApp.new function, @config
         else
           raise "Unrecognized function type: #{function.type}"
@@ -149,8 +149,12 @@ module FunctionsFramework
         ::Signal.trap "SIGINT" do
           Server.signal_enqueue "SIGINT", @config.logger, @server
         end
-        ::Signal.trap "SIGHUP" do
-          Server.signal_enqueue "SIGHUP", @config.logger, @server
+        begin
+          ::Signal.trap "SIGHUP" do
+            Server.signal_enqueue "SIGHUP", @config.logger, @server
+          end
+        rescue ::ArgumentError # rubocop:disable Lint/HandleExceptions
+          # Not available on all systems
         end
         @signals_installed = true
       end
@@ -340,7 +344,7 @@ module FunctionsFramework
           string_response response, "text/plain", 200
         when ::Hash
           string_response ::JSON.dump(response), "application/json", 200
-        when CloudEvents::CloudEventsError
+        when ::CloudEvents::CloudEventsError
           cloud_events_error_response response
         when ::StandardError
           error_response "#{response.class}: #{response.message}\n#{response.backtrace}\n"
@@ -384,10 +388,11 @@ module FunctionsFramework
         return notfound_response if excluded_path? env
         response =
           begin
-            logger = env["rack.logger"] = @config.logger
+            logger = env["rack.logger"] ||= @config.logger
             request = ::Rack::Request.new env
             logger.info "FunctionsFramework: Handling HTTP #{request.request_method} request"
-            @function.call request
+            calling_context = @function.new_call logger: logger
+            calling_context.call request
           rescue ::StandardError => e
             e
           end
@@ -400,21 +405,21 @@ module FunctionsFramework
       def initialize function, config
         super config
         @function = function
-        @cloud_events = CloudEvents::HttpBinding.default
+        @cloud_events = ::CloudEvents::HttpBinding.default
         @legacy_events = LegacyEventConverter.new
       end
 
       def call env
         return notfound_response if excluded_path? env
-        logger = env["rack.logger"] = @config.logger
+        logger = env["rack.logger"] ||= @config.logger
         event = decode_event env
         response =
           case event
-          when CloudEvents::Event
+          when ::CloudEvents::Event
             handle_cloud_event event, logger
           when ::Array
-            CloudEvents::HttpContentError.new "Batched CloudEvents are not supported"
-          when CloudEvents::CloudEventsError
+            ::CloudEvents::HttpContentError.new "Batched CloudEvents are not supported"
+          when ::CloudEvents::CloudEventsError
             event
           else
             raise "Unexpected event type: #{event.class}"
@@ -427,14 +432,15 @@ module FunctionsFramework
       def decode_event env
         @cloud_events.decode_rack_env(env) ||
           @legacy_events.decode_rack_env(env) ||
-          raise(CloudEvents::HttpContentError, "Unrecognized event format")
-      rescue CloudEvents::CloudEventsError => e
+          raise(::CloudEvents::HttpContentError, "Unrecognized event format")
+      rescue ::CloudEvents::CloudEventsError => e
         e
       end
 
       def handle_cloud_event event, logger
         logger.info "FunctionsFramework: Handling CloudEvent"
-        @function.call event
+        calling_context = @function.new_call logger: logger
+        calling_context.call event
         "ok"
       rescue ::StandardError => e
         e

data/lib/functions_framework/testing.rb

@@ -87,7 +87,7 @@ module FunctionsFramework
       function = ::FunctionsFramework.global_registry[name]
       case function&.type
       when :http
-        Testing.interpret_response { function.call request }
+        Testing.interpret_response { function.new_call.call request }
       when nil
         raise "Unknown function name #{name}"
       else
@@ -97,17 +97,17 @@ module FunctionsFramework
 
     ##
     # Call the given event function for testing. The underlying function must
-    # be of type `:event` or `:cloud_event`.
+    # be of type :cloud_event`.
     #
     # @param name [String] The name of the function to call
-    # @param event [FunctionsFramework::CloudEvets::Event] The event to send
+    # @param event [::CloudEvents::Event] The event to send
     # @return [nil]
     #
     def call_event name, event
       function = ::FunctionsFramework.global_registry[name]
       case function&.type
-      when :event, :cloud_event
-        function.call event
+      when :cloud_event
+        function.new_call.call event
         nil
       when nil
         raise "Unknown function name #{name}"
@@ -174,23 +174,35 @@ module FunctionsFramework
     # @param source [String,URI] Event source (optional)
     # @param type [String] Event type (optional)
     # @param spec_version [String] Spec version (optional)
-    # @param data_content_type [String,FunctionsFramework::CloudEvents::ContentType]
+    # @param data_content_type [String,::CloudEvents::ContentType]
     #     Content type for the data (optional)
     # @param data_schema [String,URI] Data schema (optional)
     # @param subject [String] Subject (optional)
     # @param time [String,DateTime] Event timestamp (optional)
-    # @return [FunctionsFramework::CloudEvents::Event]
+    # @return [::CloudEvents::Event]
     #
     def make_cloud_event data,
-                         id: nil, source: nil, type: nil, spec_version: nil,
-                         data_content_type: nil, data_schema: nil, subject: nil, time: nil
+                         id: nil,
+                         source: nil,
+                         type: nil,
+                         spec_version: nil,
+                         data_content_type: nil,
+                         data_schema: nil,
+                         subject: nil,
+                         time: nil
       id ||= "random-id-#{rand 100_000_000}"
       source ||= "functions-framework-testing"
       type ||= "com.example.test"
       spec_version ||= "1.0"
-      CloudEvents::Event.new id: id, source: source, type: type, spec_version: spec_version,
-                             data_content_type: data_content_type, data_schema: data_schema,
-                             subject: subject, time: time, data: data
+      ::CloudEvents::Event.new id:                id,
+                               source:            source,
+                               type:              type,
+                               spec_version:      spec_version,
+                               data_content_type: data_content_type,
+                               data_schema:       data_schema,
+                               subject:           subject,
+                               time:              time,
+                               data:              data
     end
 
     extend self

data/lib/functions_framework/version.rb

@@ -17,5 +17,5 @@ module FunctionsFramework
   # Version of the Ruby Functions Framework
   # @return [String]
   #
-  VERSION = "0.3.1".freeze
+  VERSION = "0.5.2".freeze
 end

metadata

@@ -1,142 +1,61 @@
 --- !ruby/object:Gem::Specification
 name: functions_framework
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Daniel Azuma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-27 00:00:00.000000000 Z
+date: 2020-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: puma
+  name: cloud_events
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: puma
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '4.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
-- !ruby/object:Gem::Dependency
-  name: google-style
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.24.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.24.0
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.13'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.13'
-- !ruby/object:Gem::Dependency
-  name: minitest-focus
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-- !ruby/object:Gem::Dependency
-  name: minitest-rg
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.2'
-- !ruby/object:Gem::Dependency
-  name: redcarpet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.5'
-- !ruby/object:Gem::Dependency
-  name: toys
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.10.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: '4.3'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.24
-  type: :development
+        version: '2.1'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.24
-description: The Functions Framework implementation for Ruby.
+        version: '2.1'
+description: The Functions Framework is an open source framework for writing lightweight,
+  portable Ruby functions that run in a serverless environment. Functions written
+  to this Framework will run Google Cloud Google Cloud Functions, Google Cloud Run,
+  or any other Knative-based environment.
 email:
 - dazuma@google.com
 executables:
@@ -158,13 +77,6 @@ files:
 - docs/writing-functions.md
 - lib/functions_framework.rb
 - lib/functions_framework/cli.rb
-- lib/functions_framework/cloud_events.rb
-- lib/functions_framework/cloud_events/content_type.rb
-- lib/functions_framework/cloud_events/errors.rb
-- lib/functions_framework/cloud_events/event.rb
-- lib/functions_framework/cloud_events/event/v1.rb
-- lib/functions_framework/cloud_events/http_binding.rb
-- lib/functions_framework/cloud_events/json_format.rb
 - lib/functions_framework/function.rb
 - lib/functions_framework/legacy_event_converter.rb
 - lib/functions_framework/registry.rb
@@ -174,7 +86,11 @@ files:
 homepage: https://github.com/GoogleCloudPlatform/functions-framework-ruby
 licenses:
 - Apache-2.0
-metadata: {}
+metadata:
+  changelog_uri: https://googlecloudplatform.github.io/functions-framework-ruby/v0.5.2/file.CHANGELOG.html
+  source_code_uri: https://github.com/GoogleCloudPlatform/functions-framework-ruby
+  bug_tracker_uri: https://github.com/GoogleCloudPlatform/functions-framework-ruby/issues
+  documentation_uri: https://googlecloudplatform.github.io/functions-framework-ruby/v0.5.2
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -190,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Functions Framework for Ruby