controllers

type CommandableLambdaController ¶

type CommandableLambdaController struct {
	*LambdaController
	// contains filtered or unexported fields
}

Abstract service that receives commands via AWS Lambda protocol to operations automatically generated for commands defined in 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 Lambda-based remote interface.

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

Configuration parameters ¶

- dependencies:

• controller: override for Controller dependency

References

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

See CommandableLambdaClient See LambdaController

Example:

type MyCommandableLambdaController struct  {
	*CommandableLambdaController
}

func NewMyCommandableLambdaController() *MyCommandableLambdaController {
	c:= &MyCommandableLambdaController{
		CommandableLambdaController: NewCommandableLambdaController("v1.service")
	}
	c.DependencyResolver.Put(context.Background(),
		"controller",
		cref.NewDescriptor("mygroup","controller","*","*","1.0")
	)
	return c
}

service := NewMyCommandableLambdaController();
service.SetReferences(context.Background(), NewReferencesFromTuples(
   NewDescriptor("mygroup","controller","default","default","1.0"), controller
))

service.Open(context.Background(),"123")
fmt.Println("The AWS Lambda 'v1.service' service is running")

func InheritCommandableLambdaController(overrides ILambdaControllerOverrides, name string) *CommandableLambdaController

func (c *CommandableLambdaController) Register()

type ILambdaController ¶

type ILambdaController interface {
	// Get all actions supported by the service.
	// Returns an array with supported actions.
	GetActions() []*LambdaAction
}

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

type ILambdaControllerOverrides ¶

type ILambdaControllerOverrides interface {
	Register()
}

type LambdaAction ¶

type LambdaAction struct {

	// Command to call the action
	Cmd string

	// Schema to validate action parameters
	Schema *cvalid.Schema

	// Action to be executed
	Action func(ctx context.Context, params map[string]any) (any, error)
}

type LambdaController ¶

type LambdaController struct {
	Overrides ILambdaControllerOverrides

	// The dependency resolver.
	DependencyResolver *cref.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 AWS Lambda protocol.

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

Configuration parameters

• dependencies:
• controller: override for Controller dependency

References:

• *:logger:*:*:1.0 (optional) [[ILogger]] components to pass log messages
• *:counters:*:*:1.0 (optional) [[ICounters]] components to pass collected measurements

See LambdaClient ¶

Example

   struct MyLambdaController struct  {
      *LambdaController
      service IMyService
   }
      ...
	func NewMyLambdaController()* MyLambdaController {
	   c:= &MyLambdaController{}
	   c.LambdaController = NewLambdaController("v1.mycontroller")
	   c.DependencyResolver.Put(
		   context.Background(),
	       "controller",
	       cref.NewDescriptor("mygroup","controller","*","*","1.0")
	   )
	   return c
	}

	func (c * LambdaController)  SetReferences(ctx context.Context, references IReferences){
	   c.LambdaController.SetReferences(references)
	   ref := c.DependencyResolver.GetRequired("controller")
	   c.service = ref.(IMyService)
	}

	func (c * LambdaController)  Register() {
		c.RegisterAction("get_mydata", nil,  func(ctx context.Context, params map[string]any)(any, error) {
	        traceId := params.GetAsString("trace_id")
	        id := params.GetAsString("id")
			return  c.controller.GetMyData(cctx.NewContextWithTraceId(ctx), id)
	    })
	    ...
	}

	controller := NewMyLambdaController();
	controller.Configure(ctx context.Context, NewConfigParamsFromTuples(
	    "connection.protocol", "http",
	    "connection.host", "localhost",
	    "connection.port", 8080
	))
	controller.SetReferences(context.Background(), cref.NewReferencesFromTuples(
	   cref.NewDescriptor("mygroup","service","default","default","1.0"), service
	))

	controller.Open(context.Background())
	fmt.Println("The Lambda 'v1.myservice' controller is running on port 8080");

func InheritLambdaController(overrides ILambdaControllerOverrides, name string) *LambdaController

func (c *LambdaController) Act(ctx context.Context, params map[string]any) (any, error)

Parameters:
	- ctx context.Context	operation context.
	-  params action parameters.

func (c *LambdaController) ApplyInterceptors(action func(context.Context, map[string]any) (any, error)) func(context.Context, map[string]any) (any, error)

func (c *LambdaController) ApplyValidation(schema *cvalid.Schema, action func(ctx context.Context, params map[string]any) (any, error)) func(context.Context, map[string]any) (any, error)

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

Parameters:
	- ctx context.Context	execution context to trace execution through call chain.

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

Parameters:
	- ctx context.Context	operation context.
	-  config    configuration parameters to be set.

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

func (c *LambdaController) GetActions() []*LambdaAction

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

Parameters:
	- ctx context.Context	execution context to trace execution through call chain.
	-  name              a method name.

func (c *LambdaController) IsOpen() bool

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

Parameters:
	- ctx context.Context	execution context to trace execution through call chain.

func (c *LambdaController) Register()

func (c *LambdaController) RegisterAction(name string, schema *cvalid.Schema, action func(ctx context.Context, params map[string]any) (any, error))

Parameters:
	- ctx context.Context	operation context.
	- name          an action name
	- schema        a validation schema to validate received parameters.
	- action        an action function that is called when operation is invoked.

func (c *LambdaController) RegisterActionWithAuth(name string, schema *cvalid.Schema,
	authorize func(ctx context.Context, params map[string]any, next func(context.Context, map[string]any) (any, error)) (any, error),
	action func(ctx context.Context, params map[string]any) (any, error))

Parameters:
	-  name          an action name
	-  schema        a validation schema to validate received parameters.
	-  authorize     an authorization interceptor
	-  action        an action function that is called when operation is invoked.

func (c *LambdaController) RegisterInterceptor(action func(ctx context.Context, params map[string]any, next func(ctx context.Context, params map[string]any) (any, error)) (any, error))

func (c *LambdaController) SetReferences(ctx context.Context, references cref.IReferences)

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