services

type CommandableGrpcService ¶

type CommandableGrpcService struct {
	GrpcService
	// contains filtered or unexported fields
}

CommandableGrpcService abstract service that receives commands via GRPC 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 GRPC-based remote interface.

Configuration parameters:

• dependencies:
• endpoint: override for HTTP Endpoint dependency
• controller: override for Controller dependency
• connection(s):
• discovery_key: (optional) a key to retrieve the connection from IDiscovery
• protocol: connection protocol: http or https
• host: host name or IP address
• port: port number
• uri: resource URI or connection string with all parameters in it

References:

- *:logger:*:*:1.0 (optional) ILogger components to pass log messages - *:counters:*:*:1.0 (optional) ICounters components to pass collected measurements - *:discovery:*:*:1.0 (optional) IDiscovery services to resolve connection - *:endpoint:grpc:*:1.0 (optional) GrpcEndpoint reference

See CommandableGrpcClient See GrpcService

Example:

    type MyCommandableGrpcService struct {
        *CommandableGrpcService
    }

	func NewCommandableGrpcService() *CommandableGrpcService {
        c := DummyCommandableGrpcService{}
        c.CommandableGrpcService = grpcservices.NewCommandableGrpcService("myservice")
        c.DependencyResolver.Put("controller", cref.NewDescriptor("mygroup", "controller", "default", "*", "*"))
        return &c
    }

    service := NewMyCommandableGrpcService();
    service.Configure(cconf.NewConfigParamsFromTuples(
        "connection.protocol", "http",
        "connection.host", "localhost",
        "connection.port", "8080",
    ));
    service.SetReferences(cref.NewReferencesFromTuples(
       cref.NewDescriptor("mygroup","controller","default","default","1.0"), controller
    ));

    opnErr:= service.Open("123")
    if opnErr == nil {
        console.log("The GRPC service is running on port 8080");
    }

func InheritCommandableGrpcService(overrides IGrpcServiceOverrides, name string) *CommandableGrpcService

func (c *CommandableGrpcService) Register()

type GrpcEndpoint ¶

type GrpcEndpoint struct {
	// contains filtered or unexported fields
}

GrpcEndpoint used for creating GRPC endpoints. An endpoint is a URL, at which a given service can be accessed by a client.

Configuration parameters:

Parameters to pass to the configure method for component configuration:

- connection(s) - the connection resolver"s connections:

• "connection.discovery_key" - the key to use for connection resolving in a discovery service;
• "connection.protocol" - the connection"s protocol;
• "connection.host" - the target host;
• "connection.port" - the target port;
• "connection.uri" - the target URI.

- credential - the HTTPS credentials:

• "credential.ssl_key_file" - the SSL private key in PEM
• "credential.ssl_crt_file" - the SSL certificate in PEM
• "credential.ssl_ca_file" - the certificate authorities (root cerfiticates) in PEM

References:

A logger, counters, and a connection resolver can be referenced by passing the following references to the object"s setReferences method:

- logger: "*:logger:*:*:1.0"; - counters: "*:counters:*:*:1.0"; - discovery: "*:discovery:*:*:1.0" (for the connection resolver).

Examples:

func (c* Endpoint) MyMethod(config ConfigParams, references IReferences) {
    endpoint := NewGrpcEndpoint();
    if c.config != nil {
        endpoint.Configure(c._config);
    }
    if c.references != nil {
        endpoint.SetReferences(c.references);
    }
    ...

    err := c.endpoint.Open(correlationId)
    if err != nil {
        // error ocured
        return err
    }
    c.Opened = true
    return nil
    ...
}

func NewGrpcEndpoint() *GrpcEndpoint

func (c *GrpcEndpoint) AddInterceptors(interceptors ...grpc.ServerOption)

func (c *GrpcEndpoint) Close(correlationId string) (err error)

func (c *GrpcEndpoint) Configure(config *cconf.ConfigParams)

func (c *GrpcEndpoint) GetServer() *grpc.Server

func (c *GrpcEndpoint) IsOpen() bool

func (c *GrpcEndpoint) Open(correlationId string) (err error)

func (c *GrpcEndpoint) Register(registration IRegisterable)

func (c *GrpcEndpoint) RegisterCommadableMethod(method string, schema *cvalid.Schema,
	action func(correlationId string, args *crun.Parameters) (result interface{}, err error))

func (c *GrpcEndpoint) RegisterService(sd *grpc.ServiceDesc, implementation interface{})

func (c *GrpcEndpoint) SetReferences(references cref.IReferences)

func (c *GrpcEndpoint) Unregister(registration IRegisterable)

type GrpcService ¶

type GrpcService struct {
	Overrides IGrpcServiceOverrides

	//  The GRPC endpoint that exposes c service.
	Endpoint *GrpcEndpoint
	//  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
}

GrpcService abstract service that receives remove calls via GRPC protocol.

Configuration parameters:

• dependencies:
• endpoint: override for GRPC Endpoint dependency
• controller: override for Controller dependency
• connection(s):
• discovery_key: (optional) a key to retrieve the connection from connect.idiscovery.html IDiscovery
• protocol: connection protocol: http or https
• host: host name or IP address
• port: port number
• uri: resource URI or connection string with all parameters in it
• credential - the HTTPS credentials:
• ssl_key_file: the SSL private key in PEM
• ssl_crt_file: the SSL certificate in PEM
• ssl_ca_file: the certificate authorities (root cerfiticates) in PEM

References:

- *:logger:*:*:1.0 (optional) ILogger components to pass log messages - *:counters:*:*:1.0 (optional) ICounters components to pass collected measurements - *:discovery:*:*:1.0 (optional) IDiscovery services to resolve connection - *:endpoint:grpc:*:1.0 (optional) GrpcEndpoint reference

See GrpcClient ¶

Example:

type MyGrpcService struct{
   *GrpcService
   controller IMyController;
}
...

   func NewMyGrpcService() *MyGrpcService {
       c := NewMyGrpcService{}
       c.GrpcService = grpcservices.NewGrpcService("Mydata.Mydatas")
       c.GrpcService.IRegisterable = &c
       c.numberOfCalls = 0
       c.DependencyResolver.Put("controller", cref.NewDescriptor("mygroup", "controller", "*", "*", "*"))
       return &c
   }

   func (c*MyGrpcService) SetReferences(references: IReferences) {
        c.GrpcService.SetReferences(references);
        resolv, err := c.DependencyResolver.GetOneRequired("controller")
        if err == nil && resolv != nil {
            c.controller = resolv.(grpctest.IMyController)
            return
        }
        panic("Can't resolve 'controller' reference")
   }

   func (c*MyGrpcService) Register() {
       protos.RegisterMyDataServer(c.Endpoint.GetServer(), c)
       ...
   }

service := NewMyGrpcService();
service.Configure(cconf.NewConfigParamsFromTuples(
    "connection.protocol", "http",
    "connection.host", "localhost",
    "connection.port", 8080,
));
service.SetReferences(cref.NewReferencesFromTuples(
   cref.NewDescriptor("mygroup","controller","default","default","1.0"), controller
));

err := service.Open("123")
if  err == nil {
   fmt.Println("The GRPC service is running on port 8080");
}

func InheritGrpcService(overrides IGrpcServiceOverrides, serviceName string) *GrpcService

func (c *GrpcService) Close(correlationId string) (err error)

func (c *GrpcService) Configure(config *cconf.ConfigParams)

func (c *GrpcService) Instrument(correlationId string, name string) *rpcserv.InstrumentTiming

func (c *GrpcService) IsOpen() bool

func (c *GrpcService) Open(correlationId string) (err error)

func (c *GrpcService) Register()

func (c *GrpcService) RegisterCommadableMethod(method string, schema *cvalid.Schema,
	action func(correlationId string, data *crun.Parameters) (result interface{}, err error))

func (c *GrpcService) RegisterUnaryInterceptor(action func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error))

func (c *GrpcService) SetReferences(references cref.IReferences)

func (c *GrpcService) UnsetReferences()

func (c *GrpcService) ValidateRequest(request interface{}, schema *cvalid.Schema) error

type IGrpcServiceOverrides ¶ added in v1.1.0

type IGrpcServiceOverrides interface {
	Register()
}

type IRegisterable ¶

type IRegisterable interface {
	// Perform required registration steps.
	Register()
}

IRegisterable is interface to perform on-demand registrations.

type InvokeComandMediator ¶

type InvokeComandMediator struct {
	InvokeFunc func(ctx context.Context, request *grpcproto.InvokeRequest) (response *grpcproto.InvokeReply, err error)
	grpcproto.CommandableServer
}

InvokeComandMediator Helper class for implements invoke method in CommandableGrpc

func (c *InvokeComandMediator) Invoke(ctx context.Context, request *grpcproto.InvokeRequest) (response *grpcproto.InvokeReply, err error)