clients

type CommandableHttpClient ¶

type CommandableHttpClient struct {
	*RestClient
}

CommandableHttpClient is abstract client that calls commandable HTTP service.

Commandable services are generated automatically for ICommandable objects. Each command is exposed as POST operation that receives all parameters in body object.

Configuration parameters:

base_route:              base route for remote URI
- 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
- options:
  - retries:               number of retries (default: 3)
  - connect_timeout:       connection timeout in milliseconds (default: 10 sec)
  - timeout:               invocation timeout in milliseconds (default: 10 sec)

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

Example:

type MyCommandableHttpClient struct{
    *CommandableHttpClient
    prototype reflect.Type // type of operation data
   ...
}
   result, err := func (c * MyCommandableHttpClient) GetData(correlationId string, id string)(result MyData, err error){

       params:= cdata.NewEmptyStringValueMap()
       params.Set("id",id)
        res, err := c.CallCommand(
            prototype
           "get_data",
           correlationId,
           params)
           ...
           // convert response to MyData
           ...
           return result, err
    }

client = NewMyCommandableHttpClient();
client.Configure(cconf.NewConfigParamsFromTuples(
    "connection.protocol", "http",
    "connection.host", "localhost",
    "connection.port", 8080
));

result, err := client.GetData("123", "1")
...

func NewCommandableHttpClient(baseRoute string) *CommandableHttpClient

func (c *CommandableHttpClient) CallCommand(prototype reflect.Type, name string, correlationId string, params *cdata.AnyValueMap) (result interface{}, err error)

type DirectClient ¶

type DirectClient struct {
	//The controller reference.
	Controller interface{}
	//The open flag.
	Opened bool
	//The logger.
	Logger *clog.CompositeLogger
	//The performance counters
	Counters *ccount.CompositeCounters
	//The dependency resolver to get controller reference.
	DependencyResolver crefer.DependencyResolver
	// The tracer.
	Tracer *ctrace.CompositeTracer
}

DirectClient is bstract client that calls controller directly in the same memory space.

It is used when multiple microservices are deployed in a single container (monolyth) and communication between them can be done by direct calls rather then through the network.

Configuration parameters:

- dependencies:

• controller: override controller descriptor

References:

- *:logger:*:*:1.0 (optional) ILogger components to pass log messages - *:counters:*:*:1.0 (optional) ICounters components to pass collected measurements - *:controller:*:*:1.0 controller to call business methods

Example:

	type MyDirectClient struct {
	*DirectClient
	}
        func MyDirectClient()* MyDirectClient {
		  c:= MyDirectClient{}
		  c.DirectClient = NewDirectClient()
          c.DependencyResolver.Put("controller", cref.NewDescriptor(
              "mygroup", "controller", "*", "*", "*"));
		}

		func (c *MyDirectClient) SetReferences(references cref.IReferences) {
			c.DirectClient.SetReferences(references)
			specificController, ok := c.Controller.(tdata.IMyDataController)
			if !ok {
				panic("MyDirectClient: Cant't resolv dependency 'controller' to IMyDataController")
			}
			c.specificController = specificController
		}
        ...

        func (c * MyDirectClient) GetData(correlationId string, id string)(result MyData, err error) {
           timing := c.Instrument(correlationId, "myclient.get_data")
           cmRes, cmdErr := c.specificController.GetData(correlationId, id)
           timing.EndTiming();
           return  c.InstrumentError(correlationId, "myclient.get_data", cmdRes, cmdErr)
        }
        ...

    client = NewMyDirectClient();
    client.SetReferences(cref.NewReferencesFromTuples(
        cref.NewDescriptor("mygroup","controller","default","default","1.0"), controller,
    ));

    res, err := client.GetData("123", "1")

func NewDirectClient() *DirectClient

func (c *DirectClient) Close(correlationId string) error

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

func (c *DirectClient) Instrument(correlationId string, name string) *service.InstrumentTiming

func (c *DirectClient) IsOpen() bool

func (c *DirectClient) Open(correlationId string) error

func (c *DirectClient) SetReferences(references crefer.IReferences)

type RestClient ¶

type RestClient struct {
	service.ITlsConfigurator

	//The HTTP client.
	Client *http.Client
	//The connection resolver.
	ConnectionResolver *rpccon.HttpConnectionResolver
	//The logger.
	Logger *clog.CompositeLogger
	//The performance counters.
	Counters *ccount.CompositeCounters
	// The tracer.
	Tracer *ctrace.CompositeTracer
	//The configuration options.
	Options cconf.ConfigParams
	//The base route.
	BaseRoute string
	//The number of retries.
	Retries int
	//The default headers to be added to every request.
	Headers cdata.StringValueMap
	//The connection timeout in milliseconds.
	ConnectTimeout int
	//The invocation timeout in milliseconds.
	Timeout int
	//The remote service uri which is calculated on open.
	Uri string
	// contains filtered or unexported fields
}

RestClient is abstract client that calls remove endpoints using HTTP/REST protocol.

Configuration parameters: - credential - the HTTPS credentials:

• ssl_key_file - the SSL func (c *HttpEndpoint )key in PEM

• ssl_crt_file - the SSL certificate in PEM

• ssl_ca_file - the certificate authorities (root cerfiticates) in PEM

- connection:

• 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

- options:

• base_route: base route for remote URI

• connection(s):

• discovery_key: (optional) a key to retrieve the connection from IDiscovery

• options:

• retries: number of retries (default: 3)

• connectTimeout: connection timeout in milliseconds (default: 10 sec)

• timeout: invocation timeout in milliseconds (default: 10 sec)

• correlation_id_place place for adding correalationId, query - in query string, headers - in headers, both - in query and headers (default: query)

• enable_extend_tls - enable extended tls options for custom root certificates

• certificate_server_name - certificates server (default: localhost)

  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

See RestService See CommandableHttpService

 Example:
    type MyRestClient struct {
		*RestClient
	}
    ...
    func (c *MyRestClient) GetData(correlationId string, id string) (result *tdata.MyDataPage, err error) {

		params := cdata.NewEmptyStringValueMap()
		params.Set("id", id)

		calValue, calErr := c.Call(MyDataPageType, "get", "/data", correlationId, params, nil)
		if calErr != nil {
			return nil, calErr
		}

		result, _ = calValue.(*tdata.MyDataPage)
		c.Instrument(correlationId, "myData.get_page_by_filter")
		return result, nil
	}

    client := NewMyRestClient();
    client.Configure(cconf.NewConfigParamsFromTuples(
        "connection.protocol", "http",
        "connection.host", "localhost",
        "connection.port", 8080,
    ));

	result, err := client.GetData("123", "1")
	 ...

func InheritTlsRestClient(configurator service.ITlsConfigurator) *RestClient

func NewRestClient() *RestClient

func (c *RestClient) AddCorrelationId(params *cdata.StringValueMap, correlationId string) *cdata.StringValueMap

func (c *RestClient) AddFilterParams(params *cdata.StringValueMap, filter *cdata.FilterParams) *cdata.StringValueMap

func (c *RestClient) AddPagingParams(params *cdata.StringValueMap, paging *cdata.PagingParams) *cdata.StringValueMap

func (c *RestClient) Call(prototype reflect.Type, method string, route string, correlationId string, params *cdata.StringValueMap,
	data interface{}) (result interface{}, err error)

func (c *RestClient) Close(correlationId string) error

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

func (c *RestClient) GetCaCert() (*x509.CertPool, error)

func (c *RestClient) GetCertificates() ([]tls.Certificate, error)

func (c *RestClient) GetClientAuthType() tls.ClientAuthType

func (c *RestClient) Instrument(correlationId string, name string) *service.InstrumentTiming

func (c *RestClient) InstrumentError(correlationId string, name string, inErr error, inRes interface{}) (result interface{}, err error)

func (c *RestClient) IsOpen() bool

func (c *RestClient) Open(correlationId string) error

func (c *RestClient) SetReferences(references crefer.IReferences)