class FunctionsFramework::Function
Representation of a function.
A function has a name, a type, and an implementation.
## Function
implementations
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}. * For a function of type `:startup_task`, the `call` method takes a single {FunctionsFramework::Function} argument, and does not return a value. See {FunctionsFramework::Registry.add_startup_task}.
The implementation can be specified in one of three ways:
* A callable object can be passed in the `callable` keyword argument. The object's `call` method will be invoked for every function execution. Note that this means it may be called multiple times concurrently in separate threads. * A callable _class_ can be passed in the `callable` keyword argument. This class should subclass {FunctionsFramework::Function::Callable} and define the `call` method. A separate instance of this class will be created for each function invocation. * A block can be provided. It will be used to define the `call` method in an anonymous subclass of {FunctionsFramework::Function::Callable}. Thus, providing a block is really just syntactic sugar for providing a class. (This means, for example, that the `return` keyword will work as expected within the block because it is treated as a method.)
When the implementation is provided as a callable class or block, it is executed in the context of a {FunctionsFramework::Function::Callable} object. This object provides a convenience accessor for the Logger, and access to globals, which are data defined by the application startup process and available to each function invocation. Typically, globals are used for shared global resources such as service connections and clients.
Attributes
@return [String] The function name
@return [Symbol] The function type
Public Class Methods
Create a new CloudEvents function definition.
@param name [String] The function name @param callable [Class,#call] A callable object or class. @param block [Proc] The function code as a block. @return [FunctionsFramework::Function]
# File lib/functions_framework/function.rb, line 81 def self.cloud_event name, callable: nil, &block new name, :cloud_event, callable: callable, &block end
Create a new HTTP function definition.
@param name [String] The function name @param callable [Class,#call] A callable object or class. @param block [Proc] The function code as a block. @return [FunctionsFramework::Function]
# File lib/functions_framework/function.rb, line 69 def self.http name, callable: nil, &block new name, :http, callable: callable, &block end
Create a new function definition.
@param name [String] The function name @param type [Symbol] The type of function. Valid types are `:http`,
`:cloud_event`, and `:startup_task`.
@param callable [Class,#call] A callable object or class. @param block [Proc] The function code as a block.
# File lib/functions_framework/function.rb, line 105 def initialize name, type, callable: nil, &block @name = name @type = type @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 Callable do define_method :call, &block end else raise ::ArgumentError, "No callable given for function" end end
Create a new startup task function definition.
@param callable [Class,#call] A callable object or class. @param block [Proc] The function code as a block. @return [FunctionsFramework::Function]
# File lib/functions_framework/function.rb, line 92 def self.startup_task callable: nil, &block new nil, :startup_task, callable: callable, &block end
Public Instance Methods
Call the function given a set of arguments. Set the given logger and/or globals in the context if the callable supports it.
If the given arguments exceeds what the function will accept, the args are silently truncated. However, if the function requires more arguments than are provided, an ArgumentError is raised.
@param args [Array] Argument to pass to the function. @param logger [Logger] Logger for use by function executions. @param globals [Hash] Globals for the function execution context @return [Object] The function return value.
# File lib/functions_framework/function.rb, line 157 def call *args, globals: nil, logger: nil callable = @callable || @callable_class.new(globals: globals, logger: logger) params = callable.method(:call).parameters.map(&:first) unless params.include? :rest max_params = params.count(:req) + params.count(:opt) args = args.take max_params end callable.call(*args) end
Populate the given globals hash with this function's info.
@param globals [Hash] Initial globals hash (optional). @return [Hash] A new globals hash with this function's info included.
# File lib/functions_framework/function.rb, line 138 def populate_globals globals = nil result = { function_name: name, function_type: type } result.merge! globals if globals result end