client

Documentation

Index

• func OutputsWatch(ctx context.Context, fcs outputs.Service_SubClient, cb OutputsWatchCallback, ...) error
• type Client
  • func NewForConfig(ctx context.Context, config *Config) (*Client, error)
  • func (c *Client) Close() error
  • func (c *Client) Outputs() (outputs.ServiceClient, error)
  • func (c *Client) OutputsWatch(ctx context.Context, cb OutputsWatchCallback, timeout time.Duration, ...) error
  • func (c *Client) Version() (version.ServiceClient, error)
• type Config
• type OutputsWatchCallback

Examples

• Client
• Client (OutputsGet)
• Client (Version)

Functions

func OutputsWatch

func OutputsWatch(ctx context.Context,
	fcs outputs.Service_SubClient,
	cb OutputsWatchCallback,
	timeout time.Duration) error

OutputsWatch allows to watch and process a stream of *outputs.Response using a callback function of type OutputsWatchCallback.

The timeout parameter specifies the frequency of the watch operation.

Types

type Client

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

Client is a wrapper for the gRPC connection it allows to connect to a Diginfra gRPC server. It is created using the function `NewForConfig(context.Context, *Config)`.

Example

The simplest use of a Client, just create and Close it.

package main

import (
	"context"
	"log"

	"github.com/diginfra/client-go/pkg/client"
)

func main() {
	//Set up a connection to the server.
	c, err := client.NewForConfig(context.Background(), &client.Config{
		Hostname:   "localhost",
		Port:       5060,
		CertFile:   "/etc/diginfra/certs/client.crt",
		KeyFile:    "/etc/diginfra/certs/client.key",
		CARootFile: "/etc/diginfra/certs/ca.crt",
	})
	if err != nil {
		log.Fatalf("unable to create a Diginfra client: %v", err)
	}
	defer c.Close()
}

Example (OutputsGet)

A client that is created and then used to get the Diginfra output events.

package main

import (
	"context"
	"fmt"
	"io"
	"log"

	"github.com/diginfra/client-go/pkg/api/outputs"
	"github.com/diginfra/client-go/pkg/client"
)

func main() {
	// Set up a connection to the server.
	c, err := client.NewForConfig(context.Background(), &client.Config{
		Hostname:   "localhost",
		Port:       5060,
		CertFile:   "/etc/diginfra/certs/client.crt",
		KeyFile:    "/etc/diginfra/certs/client.key",
		CARootFile: "/etc/diginfra/certs/ca.crt",
	})
	if err != nil {
		log.Fatalf("unable to create a Diginfra client: %v", err)
	}
	defer c.Close()
	outputsClient, err := c.Outputs()
	if err != nil {
		log.Fatalf("unable to obtain an output client: %v", err)
	}

	ctx := context.Background()
	fcs, err := outputsClient.Get(ctx, &outputs.Request{})
	if err != nil {
		log.Fatalf("could not subscribe: %v", err)
	}

	for {
		res, err := fcs.Recv()
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatalf("error closing stream after EOF: %v", err)
		}
		fmt.Printf("rule: %s\n", res.Rule)
	}
}

Example (Version)

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/diginfra/client-go/pkg/api/version"
	"github.com/diginfra/client-go/pkg/client"
)

func main() {
	// Set up a connection to the server.
	c, err := client.NewForConfig(context.Background(), &client.Config{
		Hostname:   "localhost",
		Port:       5060,
		CertFile:   "/etc/diginfra/certs/client.crt",
		KeyFile:    "/etc/diginfra/certs/client.key",
		CARootFile: "/etc/diginfra/certs/ca.crt",
	})
	if err != nil {
		log.Fatalf("unable to create a Diginfra client: %v", err)
	}
	defer c.Close()
	versionClient, err := c.Version()
	if err != nil {
		log.Fatalf("unable to obtain a version client: %v", err)
	}

	ctx := context.Background()
	res, err := versionClient.Version(ctx, &version.Request{})
	if err != nil {
		log.Fatalf("error obtaining the Diginfra version: %v", err)
	}
	fmt.Printf("%v\n", res)
}

func NewForConfig

func NewForConfig(ctx context.Context, config *Config) (*Client, error)

NewForConfig is used to create a new Diginfra gRPC client.

func (*Client) Close

func (c *Client) Close() error

Close the connection to the diginfra gRPC server.

func (*Client) Outputs

func (c *Client) Outputs() (outputs.ServiceClient, error)

Outputs is the client for Diginfra Outputs. When using it you can use `Sub()` or `Get()` to receive a stream of Diginfra output events.

func (*Client) OutputsWatch

func (c *Client) OutputsWatch(ctx context.Context,
	cb OutputsWatchCallback,
	timeout time.Duration,
	opts ...grpc.CallOption) error

OutputsWatch subscribes to a stream of Diginfra outputs and allows to watch and process a stream of *outputs.Response using a callback function of type OutputsWatchCallback.

The timeout parameter specifies the frequency of the watch operation.

func (*Client) Version

func (c *Client) Version() (version.ServiceClient, error)

Version it the client for Diginfra Version API. When using it you can use `version()` to receive the Diginfra version.

type Config

type Config struct {
	Hostname                  string
	Port                      uint16
	CertFile                  string
	KeyFile                   string
	CARootFile                string
	UnixSocketPath            string
	DialOptions               []grpc.DialOption
	InsecureSkipMutualTLSAuth bool
}

Config is the configuration definition for connecting to a Diginfra gRPC server.

type OutputsWatchCallback

type OutputsWatchCallback func(res *outputs.Response) error

OutputsWatchCallback is passed to OutputsWatch to perform an action for each *outputs.Response while retrieving a stream outputs