builder

README

Service-host package

This is a very basic package that allows users to create and manage GRPC and REST services.

The service factory allows creating a service instance based on the API configuration. The service manager allows controlling multiple services and provides basic dependency management.

Example of a very basic eds reader service creation and start:

...
edgeAPI  := builder.API{}
edgeAPI.GRPC.ListenAddress  =  "localhost:8080"
edgeAPI.Gateway.ListenAddress  =  "localhost:8081"

edgeDir, err  := eds.New(&directory.Config{DBPath: "/tmp/my.db", Seed: true}, &logger)
if err !=  nil {
  log.Fatal(err)
}

edgeReader, err  := factoryInstance.CreateService(&edgeAPI, opts, func(server *grpc.Server) {
reader.RegisterReaderServer(server, edgeDir)
}, func(ctx context.Context, mux *runtime.ServeMux, grpcEndpoint string, opts []grpc.DialOption) error {
return reader.RegisterReaderHandlerFromEndpoint(ctx, mux, grpcEndpoint, opts)
}, true)

if err !=  nil {
log.Fatal(err)
}
managerInstance.AddGRPCServer(edgeReader)
managerInstance.StartServers(ctx)
...

Documentation

Index

• Variables
• type API
• type GRPCOptions
• type GRPCRegistrations
• type Gateway
  • func (g *Gateway) AddHandler(pattern string, handler http.HandlerFunc)
• type GatewayOptions
• type HandlerRegistrations
• type Health
  • func (h *Health) SetServiceStatus(service string, status healthpb.HealthCheckResponse_ServingStatus)
• type Server
• type ServiceFactory
  • func NewServiceFactory() *ServiceFactory
  • func (f *ServiceFactory) CreateService(config *API, grpcOpts *GRPCOptions, gatewayOpts *GatewayOptions, ...) (*Server, error)
• type ServiceInterface
• type ServiceManager
  • func NewServiceManager(logger *zerolog.Logger) *ServiceManager
  • func (s *ServiceManager) AddGRPCServer(server *Server) error
  • func (s *ServiceManager) SetupHealthServer(address string, certs *certs.TLSCredsConfig) error
  • func (s *ServiceManager) SetupMetricsServer(address string, certs *certs.TLSCredsConfig, enableZpages bool) ([]grpc.ServerOption, error)
  • func (s *ServiceManager) StartServers(ctx context.Context) error
  • func (s *ServiceManager) StopServers(ctx context.Context)
  • func (s *ServiceManager) WithShutdownTimeout(seconds int) *ServiceManager

Variables

var DefaultGatewayAllowedHeaders = []string{headers.Authorization, headers.ContentType, headers.IfMatch, headers.IfNoneMatch, "Depth"}

var DefaultGatewayAllowedMethods = []string{http.MethodGet, http.MethodPost, http.MethodHead, http.MethodDelete, http.MethodPut,
	http.MethodPatch, "PROPFIND", "MKCOL", "COPY", "MOVE"}

var DefaultGatewayAllowedOrigins = []string{
	"http://localhost",
	"http://localhost:*",
	"https://localhost",
	"https://localhost:*",
	"http://127.0.0.1",
	"http://127.0.0.1:*",
	"https://127.0.0.1",
	"https://127.0.0.1:*",
}

Types

type API

type API struct {
	Needs []string `json:"needs"`
	GRPC  struct {
		ListenAddress string `json:"listen_address"`
		// Default connection timeout is 120 seconds
		// https://godoc.org/google.golang.org/grpc#ConnectionTimeout
		ConnectionTimeoutSeconds uint32               `json:"connection_timeout_seconds"`
		Certs                    certs.TLSCredsConfig `json:"certs"`
	} `json:"grpc"`
	Gateway struct {
		ListenAddress     string               `json:"listen_address"`
		AllowedOrigins    []string             `json:"allowed_origins"`
		AllowedHeaders    []string             `json:"allowed_headers"`
		AllowedMethods    []string             `json:"allowed_methods"`
		Certs             certs.TLSCredsConfig `json:"certs"`
		HTTP              bool                 `json:"http"`
		ReadTimeout       time.Duration        `json:"read_timeout"`
		ReadHeaderTimeout time.Duration        `json:"read_header_timeout"`
		WriteTimeout      time.Duration        `json:"write_timeout"`
		IdleTimeout       time.Duration        `json:"idle_timeout"`
	} `json:"gateway"`
}

type GRPCOptions

type GRPCOptions struct {
	ServerOptions []grpc.ServerOption
	Registrations GRPCRegistrations
}

type GRPCRegistrations

type GRPCRegistrations func(server *grpc.Server)

type Gateway

type Gateway struct {
	Server *http.Server
	Mux    *http.ServeMux
	Certs  *certs.TLSCredsConfig
}

func (*Gateway) AddHandler

func (g *Gateway) AddHandler(pattern string, handler http.HandlerFunc)

type GatewayOptions

type GatewayOptions struct {
	HandlerRegistrations HandlerRegistrations
	ErrorHandler         runtime.ErrorHandlerFunc
}

type HandlerRegistrations

type HandlerRegistrations func(ctx context.Context, mux *runtime.ServeMux, grpcEndpoint string, opts []grpc.DialOption) error

type Health

type Health struct {
	Server     *health.Server
	GRPCServer *grpc.Server
}

func (*Health) SetServiceStatus

func (h *Health) SetServiceStatus(service string, status healthpb.HealthCheckResponse_ServingStatus)

type Server

type Server struct {
	Config   *API
	Server   *grpc.Server
	Listener net.Listener
	Gateway  Gateway
	Started  chan bool
	Cleanup  []func()
}

type ServiceFactory

type ServiceFactory struct {
}

func NewServiceFactory

func NewServiceFactory() *ServiceFactory

func (*ServiceFactory) CreateService

func (f *ServiceFactory) CreateService(
	config *API,
	grpcOpts *GRPCOptions,
	gatewayOpts *GatewayOptions,
	cleanup ...func(),
) (*Server, error)

type ServiceInterface

type ServiceInterface interface {
	Start(context.Context) error
	Stop(context.Context) error
}

type ServiceManager

type ServiceManager struct {
	Context context.Context

	Servers       map[string]*Server
	DependencyMap map[string][]string
	HealthServer  *Health
	MetricServer  *http.Server
	// contains filtered or unexported fields
}

func NewServiceManager

func NewServiceManager(logger *zerolog.Logger) *ServiceManager

func (*ServiceManager) AddGRPCServer

func (s *ServiceManager) AddGRPCServer(server *Server) error

func (*ServiceManager) SetupHealthServer

func (s *ServiceManager) SetupHealthServer(address string, certs *certs.TLSCredsConfig) error

func (*ServiceManager) SetupMetricsServer

func (s *ServiceManager) SetupMetricsServer(address string, certs *certs.TLSCredsConfig, enableZpages bool) ([]grpc.ServerOption,
	error)

func (*ServiceManager) StartServers

func (s *ServiceManager) StartServers(ctx context.Context) error

func (*ServiceManager) StopServers

func (s *ServiceManager) StopServers(ctx context.Context)

func (*ServiceManager) WithShutdownTimeout

func (s *ServiceManager) WithShutdownTimeout(seconds int) *ServiceManager