services

type CloudFunctionAction ¶

type CloudFunctionAction struct {
	// Command to call the action
	Cmd string
	// Schema to validate action parameters
	Schema *cvalid.Schema
	// Action to be executed
	Action http.HandlerFunc
}

type CloudFunctionController ¶

type CloudFunctionController struct {
	Overrides ICloudFunctionControllerOverrides
	// The dependency resolver.
	DependencyResolver *crefer.DependencyResolver
	// The logger.
	Logger *clog.CompositeLogger
	// The performance counters.
	Counters *ccount.CompositeCounters
	// The tracer.
	Tracer *ctrace.CompositeTracer
	// contains filtered or unexported fields
}

Abstract service that receives remove calls via Google Function protocol.

This service is intended to work inside CloudFunction container that exposes registered actions externally.

Configuration parameters
	- dependencies:
		- service:	override for Service dependency

References
	- *:logger:*:*:1.0			(optional) ILogger components to pass log messages
	- *:counters:*:*:1.0		(optional) ICounters components to pass collected measurements

Example:
	type MyCloudFunctionController struct {
		*services.CloudFunctionController
		service IMyService
	}

	func NewMyCloudFunctionController() *MyCloudFunctionController {
		c := MyCloudFunctionController{}

		c.CloudFunctionController = services.InheritCloudFunctionController(&c, "v1.mycontroller")
		c.DependencyResolver.Put(context.Background(), "service", refer.NewDescriptor("mygroup", "controller", "default", "*", "1.0"))

		return &c
	}

	func (c *MyCloudFunctionController) SetReferences(ctx context.Context, references refer.IReferences) {
		c.CloudFunctionController.SetReferences(ctx, references)
		depRes, depErr := c.DependencyResolver.GetOneRequired("service")

		if depErr == nil && depRes != nil {
			c.service = depRes.(IMyService)
		}
	}

	func (c *MyCloudFunctionController) Register() {
		c.RegisterAction(
			"get_mydata",
			nil,
			func(w http.ResponseWriter, r *http.Request) {
				var body map[string]any

				err := CloudFunctionRequestHelper.DecodeBody(r, &body)
				defer r.Body.Close()

				result, err := c.service.DeleteById(
					cctx.NewContextWithTraceId(r.Context(), c.GetTraceId(c)),
					body,
				)
				HttpResponseSender.SendDeletedResult(w, r, result, err)
			},
		)
	}

	...

	controller := NewMyCloudFunctionController()
	controller.Configure(ctx, config.NewConfigParamsFromTuples(
		"connection.protocol", "http",
		"connection.host", "localhost",
		"connection.port", 8080,
	))

	controller.SetReferences(ctx, refer.NewReferencesFromTuples(
		refer.NewDescriptor("mygroup", "service", "default", "default", "1.0"), service,
	))
	controller.Open(ctx, "123")
	fmt.Println("The Google Function controller is running")

func InheritCloudFunctionController(overrides ICloudFunctionControllerOverrides, name string) *CloudFunctionController

func NewCloudFunctionService(name string) *CloudFunctionController

func (c *CloudFunctionController) ApplyInterceptors(action http.HandlerFunc) http.HandlerFunc

func (c *CloudFunctionController) ApplyValidation(schema *cvalid.Schema, action http.HandlerFunc) http.HandlerFunc

func (c *CloudFunctionController) Close(ctx context.Context) error

Parameters:
	- ctx context.Context a context to trace execution through call chain.
Returns: error or nil no errors occurred.

func (c *CloudFunctionController) Configure(ctx context.Context, config *cconf.ConfigParams)

see ConfigParams
Parameters:
	- ctx context.Context
	- config *conf.ConfigParams configuration parameters to set.

func (c *CloudFunctionController) GenerateActionCmd(name string) string

func (c *CloudFunctionController) GetActions() []*CloudFunctionAction

func (c *CloudFunctionController) GetCommand(r *http.Request) (string, error)

func (c *CloudFunctionController) GetTraceId(r *http.Request) string

func (c *CloudFunctionController) Instrument(ctx context.Context, name string) *rpctrace.InstrumentTiming

Parameters:
	- ctx context.Context a context to trace execution through call chain.
	- name              a method name.
Returns: Timing object to end the time measurement.

func (c *CloudFunctionController) IsOpen() bool

Returns: bool true if the component has been opened and false otherwise.

func (c *CloudFunctionController) Open(ctx context.Context) error

Parameters:
	- ctx context.Context a context to trace execution through call chain.
Returns: error or nil no errors occured.

func (c *CloudFunctionController) Register()

func (c *CloudFunctionController) RegisterAction(name string, schema *cvalid.Schema, action http.HandlerFunc)

func (c *CloudFunctionController) RegisterActionWithAuth(name string, schema *cvalid.Schema, authorize func(w http.ResponseWriter, r *http.Request, next http.HandlerFunc),
	action http.HandlerFunc)

func (c *CloudFunctionController) RegisterInterceptor(cmd string, action func(w http.ResponseWriter, r *http.Request, next http.HandlerFunc))

func (c *CloudFunctionController) SetReferences(ctx context.Context, references crefer.IReferences)

see IReferences
Parameters:
	- ctx context.Context
	- references IReferences references to locate the component dependencies.

type CommandableCloudFunctionController ¶

type CommandableCloudFunctionController struct {
	*CloudFunctionController
	// contains filtered or unexported fields
}

Abstract service that receives commands via Google Function protocol to operations automatically generated for commands defined in ccomand.ICommandable components. Each command is exposed as invoke method that receives command name and parameters.

Commandable services require only 3 lines of code to implement a robust external Google Function-based remote interface.

This service is intended to work inside Google Function container that exploses registered actions externally.

Configuration parameters:
	- dependencies:
		- service:            override for Service dependency
References
	- *:logger:*:*:1.0			(optional) ILogger components to pass log messages
	- *:counters:*:*:1.0		(optional) ICounters components to pass collected measurements

see CloudFunctionService

Example:
	type MyCommandableCloudFunctionController struct {
		*gcpsrv.CommandableCloudFunctionController
	}

	func NewMyCommandableCloudFunctionController() *MyCommandableCloudFunctionController {
		c := MyCommandableCloudFunctionController{}
		c.CommandableCloudFunctionController = gcpsrv.NewCommandableCloudFunctionService("mydata")
		c.DependencyResolver.Put(context.Background(), "service", crefer.NewDescriptor("mygroup", "service", "default", "*", "*"))
		return &c
	}

/ ...

service := NewMyCommandableCloudFunctionController()
service.SetReferences(crefer.NewReferencesFromTuples(
	crefer.NewDescriptor("mygroup","controller","default","default","1.0"), controller,
))
service.Open(ctx, "123")
fmt.Println("The Google Function service is running")

func NewCommandableCloudFunctionController(name string) *CommandableCloudFunctionController

func (c *CommandableCloudFunctionController) GetParameters(req *http.Request) *cexec.Parameters

func (c *CommandableCloudFunctionController) Register()

type ICloudFunctionController ¶

type ICloudFunctionController interface {

	// Get all actions supported by the service.
	// Returns an array with supported actions.
	GetActions() []*CloudFunctionAction
}

An interface that allows to integrate Google Function services into Google Function containers and connect their actions to the function calls.

type ICloudFunctionControllerOverrides ¶

type ICloudFunctionControllerOverrides interface {
	Register()
}