Initial QSfera import

Server/pkg/registry/expiry.go

@@ -0,0 +1,33 @@
+package registry
+
+import (
+	"os"
+	"time"
+)
+
+const (
+	_registryRegisterIntervalEnv = "EXPERIMENTAL_REGISTER_INTERVAL"
+	_registryRegisterTTLEnv      = "EXPERIMENTAL_REGISTER_TTL"
+
+	// Note: _defaultRegisterInterval should always be lower than _defaultRegisterTTL
+	_defaultRegisterInterval = time.Second * 25
+	_defaultRegisterTTL      = time.Second * 30
+)
+
+// GetRegisterInterval returns the register interval from the environment.
+func GetRegisterInterval() time.Duration {
+	d, err := time.ParseDuration(os.Getenv(_registryRegisterIntervalEnv))
+	if err != nil {
+		return _defaultRegisterInterval
+	}
+	return d
+}
+
+// GetRegisterTTL returns the register TTL from the environment.
+func GetRegisterTTL() time.Duration {
+	d, err := time.ParseDuration(os.Getenv(_registryRegisterTTLEnv))
+	if err != nil {
+		return _defaultRegisterTTL
+	}
+	return d
+}

Server/pkg/registry/register.go

@@ -0,0 +1,61 @@
+package registry
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	mRegistry "go-micro.dev/v4/registry"
+
+	"github.com/qsfera/server/pkg/log"
+)
+
+// RegisterService publishes an arbitrary endpoint to the service-registry. This allows querying nodes of
+// non-micro services like reva. No health-checks are done, thus the caller is responsible for canceling.
+func RegisterService(ctx context.Context, logger log.Logger, service *mRegistry.Service, debugAddr string) error {
+	registry := GetRegistry()
+	node := service.Nodes[0]
+
+	logger.Info().Msgf("registering external service %v@%v", node.Id, node.Address)
+
+	rOpts := []mRegistry.RegisterOption{mRegistry.RegisterTTL(GetRegisterTTL())}
+	if err := registry.Register(service, rOpts...); err != nil {
+		logger.Fatal().Err(err).Msgf("Registration error for external service %v", service.Name)
+	}
+
+	t := time.NewTicker(GetRegisterInterval())
+
+	go func() {
+		// check if the service is ready
+		delay := 500 * time.Millisecond
+		for {
+			resp, err := http.DefaultClient.Get("http://" + debugAddr + "/readyz")
+			if err == nil && resp.StatusCode == http.StatusOK {
+				resp.Body.Close()
+				break
+			}
+			time.Sleep(delay)
+			delay *= 2
+		}
+		for {
+			select {
+			case <-t.C:
+				logger.Debug().Interface("service", service).Msg("refreshing external service-registration")
+				err := registry.Register(service, rOpts...)
+				if err != nil {
+					logger.Error().Err(err).Msgf("registration error for external service %v", service.Name)
+				}
+			case <-ctx.Done():
+				logger.Debug().Interface("service", service).Msg("unregistering")
+				t.Stop()
+				err := registry.Deregister(service)
+				if err != nil {
+					logger.Err(err).Msgf("Error unregistering external service %v", service.Name)
+				}
+				return
+			}
+		}
+	}()
+
+	return nil
+}

Server/pkg/registry/registry.go

@@ -0,0 +1,103 @@
+package registry
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	memr "github.com/go-micro/plugins/v4/registry/memory"
+	"github.com/qsfera/server/pkg/natsjsregistry"
+	rRegistry "github.com/opencloud-eu/reva/v2/pkg/registry"
+	mRegistry "go-micro.dev/v4/registry"
+	"go-micro.dev/v4/registry/cache"
+)
+
+const (
+	_registryEnv        = "MICRO_REGISTRY"
+	_registryAddressEnv = "MICRO_REGISTRY_ADDRESS"
+)
+
+var (
+	_once sync.Once
+	_reg  mRegistry.Registry
+)
+
+// Config is the config for a registry
+type Config struct {
+	Type         string        `mapstructure:"type"`
+	Addresses    []string      `mapstructure:"addresses"`
+	Username     string        `mapstructure:"username"`
+	Password     string        `mapstructure:"password"`
+	DisableCache bool          `mapstructure:"disable_cache"`
+	RegisterTTL  time.Duration `mapstructure:"register_ttl"`
+}
+
+// Option allows configuring the registry
+type Option func(*Config)
+
+// Inmemory overrides env values to use an in-memory registry
+func Inmemory() Option {
+	return func(c *Config) {
+		c.Type = "memory"
+	}
+}
+
+// GetRegistry returns a configured micro registry based on Micro env vars.
+// It defaults to mDNS, so mind that systems with mDNS disabled by default (i.e SUSE) will have a hard time
+// and it needs to explicitly use etcd. Os awareness for providing a working registry out of the box should be done.
+func GetRegistry(opts ...Option) mRegistry.Registry {
+	_once.Do(func() {
+		cfg := getEnvs(opts...)
+
+		switch cfg.Type {
+		default:
+			fmt.Println("Attention: unknown registry type, using default nats-js-kv")
+			fallthrough
+		case "natsjs", "nats-js", "nats-js-kv": // for backwards compatibility - we will stick with one of those
+			_reg = natsjsregistry.NewRegistry(
+				mRegistry.Addrs(cfg.Addresses...),
+				natsjsregistry.DefaultTTL(cfg.RegisterTTL),
+				natsjsregistry.ServiceName("_oc"),
+			)
+		case "memory":
+			_reg = memr.NewRegistry()
+			cfg.DisableCache = true // no cache needed for in-memory registry
+		}
+
+		// Disable cache if wanted
+		if !cfg.DisableCache {
+			_reg = cache.New(_reg, cache.WithTTL(30*time.Second))
+		}
+
+		// fixme: lazy initialization of reva registry, needs refactor to a explicit call per service
+		_ = rRegistry.Init(_reg)
+	})
+	// always use cached registry to prevent registry
+	// lookup for every request
+	return _reg
+}
+
+func getEnvs(opts ...Option) *Config {
+	cfg := &Config{
+		Type:      "nats-js-kv",
+		Addresses: []string{"127.0.0.1:9233"},
+	}
+
+	if s := os.Getenv(_registryEnv); s != "" {
+		cfg.Type = s
+	}
+
+	if s := strings.Split(os.Getenv(_registryAddressEnv), ","); len(s) > 0 && s[0] != "" {
+		cfg.Addresses = s
+	}
+
+	cfg.RegisterTTL = GetRegisterTTL()
+
+	for _, o := range opts {
+		o(cfg)
+	}
+
+	return cfg
+}

Server/pkg/registry/service.go

@@ -0,0 +1,90 @@
+package registry
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+
+	mRegistry "go-micro.dev/v4/registry"
+	"go-micro.dev/v4/server"
+	mAddr "go-micro.dev/v4/util/addr"
+)
+
+func BuildGRPCService(serviceID, transport, address, version string) *mRegistry.Service {
+	var host string
+	var port int
+
+	parts := strings.Split(address, ":")
+	if len(parts) > 1 {
+		host = strings.Join(parts[:len(parts)-1], ":")
+		port, _ = strconv.Atoi(parts[len(parts)-1])
+	} else {
+		host = parts[0]
+	}
+
+	addr := host
+	if transport != "unix" {
+		var err error
+		addr, err = mAddr.Extract(host)
+		if err != nil {
+			addr = host
+		}
+		addr = net.JoinHostPort(addr, strconv.Itoa(port))
+	}
+
+	node := &mRegistry.Node{
+		Id:       serviceID + "-" + server.DefaultId,
+		Address:  addr,
+		Metadata: make(map[string]string),
+	}
+
+	node.Metadata["registry"] = GetRegistry().String()
+	node.Metadata["server"] = "grpc"
+	node.Metadata["transport"] = transport
+	node.Metadata["protocol"] = "grpc"
+
+	return &mRegistry.Service{
+		Name:      serviceID,
+		Version:   version,
+		Nodes:     []*mRegistry.Node{node},
+		Endpoints: make([]*mRegistry.Endpoint, 0),
+	}
+}
+
+func BuildHTTPService(serviceID, address string, version string) *mRegistry.Service {
+	var host string
+	var port int
+
+	parts := strings.Split(address, ":")
+	if len(parts) > 1 {
+		host = strings.Join(parts[:len(parts)-1], ":")
+		port, _ = strconv.Atoi(parts[len(parts)-1])
+	} else {
+		host = parts[0]
+	}
+
+	addr, err := mAddr.Extract(host)
+	if err != nil {
+		addr = host
+	}
+
+	node := &mRegistry.Node{
+		// This id is read by the registry watcher
+		Id:       serviceID + "-" + server.DefaultId,
+		Address:  net.JoinHostPort(addr, fmt.Sprint(port)),
+		Metadata: make(map[string]string),
+	}
+
+	node.Metadata["registry"] = GetRegistry().String()
+	node.Metadata["server"] = "http"
+	node.Metadata["transport"] = "http"
+	node.Metadata["protocol"] = "http"
+
+	return &mRegistry.Service{
+		Name:      serviceID,
+		Version:   version,
+		Nodes:     []*mRegistry.Node{node},
+		Endpoints: make([]*mRegistry.Endpoint, 0),
+	}
+}