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

name[R]

@return [String] The function name

type[R]

@return [Symbol] The function type

Public Class Methods

cloud_event(name, callable: nil, &block) click to toggle source

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
http(name, callable: nil, &block) click to toggle source

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
new(name, type, callable: nil, &block) click to toggle source

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
startup_task(callable: nil, &block) click to toggle source

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(*args, globals: nil, logger: nil) click to toggle source

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_globals(globals = nil) click to toggle source

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