Initial QSfera import

Server/vendor/go-micro.dev/v4/registry/cache/README.md

@@ -0,0 +1,31 @@
+# Registry Cache
+
+Cache is a library that provides a caching layer for the go-micro [registry](https://godoc.org/github.com/micro/go-micro/registry#Registry).
+
+If you're looking for caching in your microservices use the [selector](https://micro.mu/docs/fault-tolerance.html#caching-discovery).
+
+## Interface
+
+```go
+// Cache is the registry cache interface
+type Cache interface {
+	// embed the registry interface
+	registry.Registry
+	// stop the cache watcher
+	Stop()
+}
+```
+
+## Usage
+
+```go
+import (
+	"github.com/micro/go-micro/registry"
+	"github.com/micro/go-micro/registry/cache"
+)
+
+r := registry.NewRegistry()
+cache := cache.New(r)
+
+services, _ := cache.GetService("my.service")
+```

Server/vendor/go-micro.dev/v4/registry/cache/cache.go

@@ -0,0 +1,515 @@
+// Package cache provides a registry cache
+package cache
+
+import (
+	"math"
+	"math/rand"
+	"sync"
+	"time"
+
+	"golang.org/x/sync/singleflight"
+
+	log "go-micro.dev/v4/logger"
+	"go-micro.dev/v4/registry"
+	util "go-micro.dev/v4/util/registry"
+)
+
+// Cache is the registry cache interface.
+type Cache interface {
+	// embed the registry interface
+	registry.Registry
+	// stop the cache watcher
+	Stop()
+}
+
+type Options struct {
+	Logger log.Logger
+	// TTL is the cache TTL
+	TTL time.Duration
+}
+
+type Option func(o *Options)
+
+type cache struct {
+	opts Options
+
+	registry.Registry
+	// status of the registry
+	// used to hold onto the cache
+	// in failure state
+	status error
+	// used to prevent cache breakdwon
+	sg      singleflight.Group
+	cache   map[string][]*registry.Service
+	ttls    map[string]time.Time
+	nttls   map[string]map[string]time.Time // node ttls
+	watched map[string]bool
+
+	// used to stop the cache
+	exit chan bool
+
+	// indicate whether its running
+	watchedRunning map[string]bool
+
+	// registry cache
+	sync.RWMutex
+}
+
+var (
+	DefaultTTL = time.Minute
+)
+
+func backoff(attempts int) time.Duration {
+	if attempts == 0 {
+		return time.Duration(0)
+	}
+	return time.Duration(math.Pow(10, float64(attempts))) * time.Millisecond
+}
+
+func (c *cache) getStatus() error {
+	c.RLock()
+	defer c.RUnlock()
+	return c.status
+}
+
+func (c *cache) setStatus(err error) {
+	c.Lock()
+	c.status = err
+	c.Unlock()
+}
+
+// isValid checks if the service is valid.
+func (c *cache) isValid(services []*registry.Service, ttl time.Time) bool {
+	// no services exist
+	if len(services) == 0 {
+		return false
+	}
+
+	// ttl is invalid
+	if ttl.IsZero() {
+		return false
+	}
+
+	// time since ttl is longer than timeout
+	if time.Since(ttl) > 0 {
+		return false
+	}
+
+	// a node did not get updated
+	for _, s := range services {
+		for _, n := range s.Nodes {
+			nttl := c.nttls[s.Name][n.Id]
+			if time.Since(nttl) > 0 {
+				delete(c.nttls, s.Name)
+				return false
+			}
+		}
+	}
+
+	// ok
+	return true
+}
+
+func (c *cache) quit() bool {
+	select {
+	case <-c.exit:
+		return true
+	default:
+		return false
+	}
+}
+
+func (c *cache) del(service string) {
+	// don't blow away cache in error state
+	if err := c.status; err != nil {
+		return
+	}
+	// otherwise delete entries
+	delete(c.cache, service)
+	delete(c.ttls, service)
+	delete(c.nttls, service)
+}
+
+func (c *cache) get(service string) ([]*registry.Service, error) {
+	// read lock
+	c.RLock()
+
+	// check the cache first
+	services := c.cache[service]
+	// get cache ttl
+	ttl := c.ttls[service]
+	// make a copy
+	cp := util.Copy(services)
+
+	// got services, nodes && within ttl so return cache
+	if c.isValid(cp, ttl) {
+		c.RUnlock()
+		// return services
+		return cp, nil
+	}
+
+	// get does the actual request for a service and cache it
+	get := func(service string, cached []*registry.Service) ([]*registry.Service, error) {
+		// ask the registry
+		val, err, _ := c.sg.Do(service, func() (interface{}, error) {
+			return c.Registry.GetService(service)
+		})
+		services, _ := val.([]*registry.Service)
+		if err != nil {
+			// check the cache
+			if len(cached) > 0 {
+				// set the error status
+				c.setStatus(err)
+
+				// return the stale cache
+				return cached, nil
+			}
+			// otherwise return error
+			return nil, err
+		}
+
+		// reset the status
+		if err := c.getStatus(); err != nil {
+			c.setStatus(nil)
+		}
+
+		// cache results
+		cp := util.Copy(services)
+		c.Lock()
+		for _, s := range services {
+			c.updateNodeTTLs(service, s.Nodes)
+		}
+		c.set(service, services)
+		c.Unlock()
+
+		return cp, nil
+	}
+
+	// watch service if not watched
+	_, ok := c.watched[service]
+
+	// unlock the read lock
+	c.RUnlock()
+
+	// check if its being watched
+	if c.opts.TTL > 0 && !ok {
+		c.Lock()
+
+		// set to watched
+		c.watched[service] = true
+
+		// only kick it off if not running
+		if !c.watchedRunning[service] {
+			go c.run(service)
+		}
+
+		c.Unlock()
+	}
+
+	// get and return services
+	return get(service, cp)
+}
+
+func (c *cache) set(service string, services []*registry.Service) {
+	c.cache[service] = services
+	c.ttls[service] = time.Now().Add(c.opts.TTL)
+}
+
+func (c *cache) updateNodeTTLs(name string, nodes []*registry.Node) {
+	if c.nttls[name] == nil {
+		c.nttls[name] = make(map[string]time.Time)
+	}
+	for _, node := range nodes {
+		c.nttls[name][node.Id] = time.Now().Add(c.opts.TTL)
+	}
+}
+
+func (c *cache) update(res *registry.Result) {
+	if res == nil || res.Service == nil {
+		return
+	}
+
+	c.Lock()
+	defer c.Unlock()
+
+	// only save watched services
+	if _, ok := c.watched[res.Service.Name]; !ok {
+		return
+	}
+
+	services, ok := c.cache[res.Service.Name]
+	if !ok {
+		// we're not going to cache anything
+		// unless there was already a lookup
+		return
+	}
+
+	if len(res.Service.Nodes) == 0 {
+		switch res.Action {
+		case "delete":
+			c.del(res.Service.Name)
+		}
+		return
+	}
+
+	// existing service found
+	var service *registry.Service
+	var index int
+	for i, s := range services {
+		if s.Version == res.Service.Version {
+			service = s
+			index = i
+		}
+	}
+
+	switch res.Action {
+	case "create", "update":
+		c.updateNodeTTLs(res.Service.Name, res.Service.Nodes)
+		if service == nil {
+			c.set(res.Service.Name, append(services, res.Service))
+			return
+		}
+
+		// append old nodes to new service
+		for _, cur := range service.Nodes {
+			var seen bool
+			for _, node := range res.Service.Nodes {
+				if cur.Id == node.Id {
+					seen = true
+					break
+				}
+			}
+			if !seen {
+				res.Service.Nodes = append(res.Service.Nodes, cur)
+			}
+		}
+
+		services[index] = res.Service
+		c.set(res.Service.Name, services)
+	case "delete":
+		if service == nil {
+			return
+		}
+
+		var nodes []*registry.Node
+
+		// filter cur nodes to remove the dead one
+		for _, cur := range service.Nodes {
+			var seen bool
+			for _, del := range res.Service.Nodes {
+				if del.Id == cur.Id {
+					seen = true
+					break
+				}
+			}
+			if !seen {
+				nodes = append(nodes, cur)
+			}
+		}
+
+		// still got nodes, save and return
+		if len(nodes) > 0 {
+			service.Nodes = nodes
+			services[index] = service
+			c.set(service.Name, services)
+			return
+		}
+
+		// zero nodes left
+
+		// only have one thing to delete
+		// nuke the thing
+		if len(services) == 1 {
+			c.del(service.Name)
+			return
+		}
+
+		// still have more than 1 service
+		// check the version and keep what we know
+		var srvs []*registry.Service
+		for _, s := range services {
+			if s.Version != service.Version {
+				srvs = append(srvs, s)
+			}
+		}
+
+		// save
+		c.set(service.Name, srvs)
+	case "override":
+		if service == nil {
+			return
+		}
+
+		c.del(service.Name)
+	}
+}
+
+// run starts the cache watcher loop
+// it creates a new watcher if there's a problem.
+func (c *cache) run(service string) {
+	c.Lock()
+	c.watchedRunning[service] = true
+	c.Unlock()
+	logger := c.opts.Logger
+	// reset watcher on exit
+	defer func() {
+		c.Lock()
+		c.watched = make(map[string]bool)
+		c.watchedRunning[service] = false
+		c.Unlock()
+	}()
+
+	var a, b int
+
+	for {
+		// exit early if already dead
+		if c.quit() {
+			return
+		}
+
+		// jitter before starting
+		j := rand.Int63n(100)
+		time.Sleep(time.Duration(j) * time.Millisecond)
+
+		// create new watcher
+		w, err := c.Registry.Watch(registry.WatchService(service))
+		if err != nil {
+			if c.quit() {
+				return
+			}
+
+			d := backoff(a)
+			c.setStatus(err)
+
+			if a > 3 {
+				logger.Logf(log.DebugLevel, "rcache: ", err, " backing off ", d)
+				a = 0
+			}
+
+			time.Sleep(d)
+			a++
+
+			continue
+		}
+
+		// reset a
+		a = 0
+
+		// watch for events
+		if err := c.watch(w); err != nil {
+			if c.quit() {
+				return
+			}
+
+			d := backoff(b)
+			c.setStatus(err)
+
+			if b > 3 {
+				logger.Logf(log.DebugLevel, "rcache: ", err, " backing off ", d)
+				b = 0
+			}
+
+			time.Sleep(d)
+			b++
+
+			continue
+		}
+
+		// reset b
+		b = 0
+	}
+}
+
+// watch loops the next event and calls update
+// it returns if there's an error.
+func (c *cache) watch(w registry.Watcher) error {
+	// used to stop the watch
+	stop := make(chan bool)
+
+	// manage this loop
+	go func() {
+		defer w.Stop()
+
+		select {
+		// wait for exit
+		case <-c.exit:
+			return
+		// we've been stopped
+		case <-stop:
+			return
+		}
+	}()
+
+	for {
+		res, err := w.Next()
+		if err != nil {
+			close(stop)
+			return err
+		}
+
+		// reset the error status since we succeeded
+		if err := c.getStatus(); err != nil {
+			// reset status
+			c.setStatus(nil)
+		}
+
+		c.update(res)
+	}
+}
+
+func (c *cache) GetService(service string, opts ...registry.GetOption) ([]*registry.Service, error) {
+	// get the service
+	services, err := c.get(service)
+	if err != nil {
+		return nil, err
+	}
+
+	// if there's nothing return err
+	if len(services) == 0 {
+		return nil, registry.ErrNotFound
+	}
+
+	// return services
+	return services, nil
+}
+
+func (c *cache) Stop() {
+	c.Lock()
+	defer c.Unlock()
+
+	select {
+	case <-c.exit:
+		return
+	default:
+		close(c.exit)
+	}
+}
+
+func (c *cache) String() string {
+	return "cache"
+}
+
+// New returns a new cache.
+func New(r registry.Registry, opts ...Option) Cache {
+	rand.Seed(time.Now().UnixNano())
+
+	options := Options{
+		TTL:    DefaultTTL,
+		Logger: log.DefaultLogger,
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return &cache{
+		Registry:       r,
+		opts:           options,
+		watched:        make(map[string]bool),
+		watchedRunning: make(map[string]bool),
+		cache:          make(map[string][]*registry.Service),
+		ttls:           make(map[string]time.Time),
+		nttls:          make(map[string]map[string]time.Time),
+		exit:           make(chan bool),
+	}
+}

Server/vendor/go-micro.dev/v4/registry/cache/options.go

@@ -0,0 +1,21 @@
+package cache
+
+import (
+	"time"
+
+	"go-micro.dev/v4/logger"
+)
+
+// WithTTL sets the cache TTL.
+func WithTTL(t time.Duration) Option {
+	return func(o *Options) {
+		o.TTL = t
+	}
+}
+
+// WithLogger sets the underline logger.
+func WithLogger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}

Server/vendor/go-micro.dev/v4/registry/mdns_registry.go

@@ -0,0 +1,618 @@
+// Package mdns is a multicast dns registry
+package registry
+
+import (
+	"bytes"
+	"compress/zlib"
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	log "go-micro.dev/v4/logger"
+	"go-micro.dev/v4/util/mdns"
+)
+
+var (
+	// use a .micro domain rather than .local.
+	mdnsDomain = "micro"
+)
+
+type mdnsTxt struct {
+	Metadata  map[string]string
+	Service   string
+	Version   string
+	Endpoints []*Endpoint
+}
+
+type mdnsEntry struct {
+	node *mdns.Server
+	id   string
+}
+
+type mdnsRegistry struct {
+	opts     *Options
+	services map[string][]*mdnsEntry
+
+	// watchers
+	watchers map[string]*mdnsWatcher
+
+	// listener
+	listener chan *mdns.ServiceEntry
+	// the mdns domain
+	domain string
+
+	mtx sync.RWMutex
+
+	sync.Mutex
+}
+
+type mdnsWatcher struct {
+	wo   WatchOptions
+	ch   chan *mdns.ServiceEntry
+	exit chan struct{}
+	// the registry
+	registry *mdnsRegistry
+	id       string
+	// the mdns domain
+	domain string
+}
+
+func encode(txt *mdnsTxt) ([]string, error) {
+	b, err := json.Marshal(txt)
+	if err != nil {
+		return nil, err
+	}
+
+	var buf bytes.Buffer
+	defer buf.Reset()
+
+	w := zlib.NewWriter(&buf)
+	if _, err := w.Write(b); err != nil {
+		return nil, err
+	}
+	w.Close()
+
+	encoded := hex.EncodeToString(buf.Bytes())
+
+	// individual txt limit
+	if len(encoded) <= 255 {
+		return []string{encoded}, nil
+	}
+
+	// split encoded string
+	var record []string
+
+	for len(encoded) > 255 {
+		record = append(record, encoded[:255])
+		encoded = encoded[255:]
+	}
+
+	record = append(record, encoded)
+
+	return record, nil
+}
+
+func decode(record []string) (*mdnsTxt, error) {
+	encoded := strings.Join(record, "")
+
+	hr, err := hex.DecodeString(encoded)
+	if err != nil {
+		return nil, err
+	}
+
+	br := bytes.NewReader(hr)
+	zr, err := zlib.NewReader(br)
+	if err != nil {
+		return nil, err
+	}
+
+	rbuf, err := io.ReadAll(zr)
+	if err != nil {
+		return nil, err
+	}
+
+	var txt *mdnsTxt
+
+	if err := json.Unmarshal(rbuf, &txt); err != nil {
+		return nil, err
+	}
+
+	return txt, nil
+}
+func newRegistry(opts ...Option) Registry {
+	mergedOpts := append([]Option{Timeout(time.Millisecond * 100)}, opts...)
+	options := NewOptions(mergedOpts...)
+
+	// set the domain
+	domain := mdnsDomain
+
+	d, ok := options.Context.Value("mdns.domain").(string)
+	if ok {
+		domain = d
+	}
+
+	return &mdnsRegistry{
+		opts:     options,
+		domain:   domain,
+		services: make(map[string][]*mdnsEntry),
+		watchers: make(map[string]*mdnsWatcher),
+	}
+}
+
+func (m *mdnsRegistry) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(m.opts)
+	}
+	return nil
+}
+
+func (m *mdnsRegistry) Options() Options {
+	return *m.opts
+}
+
+func (m *mdnsRegistry) Register(service *Service, opts ...RegisterOption) error {
+	m.Lock()
+	defer m.Unlock()
+
+	logger := m.opts.Logger
+	entries, ok := m.services[service.Name]
+	// first entry, create wildcard used for list queries
+	if !ok {
+		s, err := mdns.NewMDNSService(
+			service.Name,
+			"_services",
+			m.domain+".",
+			"",
+			9999,
+			[]net.IP{net.ParseIP("0.0.0.0")},
+			nil,
+		)
+		if err != nil {
+			return err
+		}
+
+		srv, err := mdns.NewServer(&mdns.Config{Zone: &mdns.DNSSDService{MDNSService: s}})
+		if err != nil {
+			return err
+		}
+
+		// append the wildcard entry
+		entries = append(entries, &mdnsEntry{id: "*", node: srv})
+	}
+
+	var gerr error
+
+	for _, node := range service.Nodes {
+		var seen bool
+		var e *mdnsEntry
+
+		for _, entry := range entries {
+			if node.Id == entry.id {
+				seen = true
+				e = entry
+				break
+			}
+		}
+
+		// already registered, continue
+		if seen {
+			continue
+			// doesn't exist
+		} else {
+			e = &mdnsEntry{}
+		}
+
+		txt, err := encode(&mdnsTxt{
+			Service:   service.Name,
+			Version:   service.Version,
+			Endpoints: service.Endpoints,
+			Metadata:  node.Metadata,
+		})
+
+		if err != nil {
+			gerr = err
+			continue
+		}
+
+		host, pt, err := net.SplitHostPort(node.Address)
+		if err != nil {
+			gerr = err
+			continue
+		}
+		port, _ := strconv.Atoi(pt)
+
+		logger.Logf(log.DebugLevel, "[mdns] registry create new service with ip: %s for: %s", net.ParseIP(host).String(), host)
+
+		// we got here, new node
+		s, err := mdns.NewMDNSService(
+			node.Id,
+			service.Name,
+			m.domain+".",
+			"",
+			port,
+			[]net.IP{net.ParseIP(host)},
+			txt,
+		)
+		if err != nil {
+			gerr = err
+			continue
+		}
+
+		srv, err := mdns.NewServer(&mdns.Config{Zone: s, LocalhostChecking: true})
+		if err != nil {
+			gerr = err
+			continue
+		}
+
+		e.id = node.Id
+		e.node = srv
+		entries = append(entries, e)
+	}
+
+	// save
+	m.services[service.Name] = entries
+
+	return gerr
+}
+
+func (m *mdnsRegistry) Deregister(service *Service, opts ...DeregisterOption) error {
+	m.Lock()
+	defer m.Unlock()
+
+	var newEntries []*mdnsEntry
+
+	// loop existing entries, check if any match, shutdown those that do
+	for _, entry := range m.services[service.Name] {
+		var remove bool
+
+		for _, node := range service.Nodes {
+			if node.Id == entry.id {
+				entry.node.Shutdown()
+				remove = true
+				break
+			}
+		}
+
+		// keep it?
+		if !remove {
+			newEntries = append(newEntries, entry)
+		}
+	}
+
+	// last entry is the wildcard for list queries. Remove it.
+	if len(newEntries) == 1 && newEntries[0].id == "*" {
+		newEntries[0].node.Shutdown()
+		delete(m.services, service.Name)
+	} else {
+		m.services[service.Name] = newEntries
+	}
+
+	return nil
+}
+
+func (m *mdnsRegistry) GetService(service string, opts ...GetOption) ([]*Service, error) {
+	logger := m.opts.Logger
+	serviceMap := make(map[string]*Service)
+	entries := make(chan *mdns.ServiceEntry, 10)
+	done := make(chan bool)
+
+	p := mdns.DefaultParams(service)
+	// set context with timeout
+	var cancel context.CancelFunc
+	p.Context, cancel = context.WithTimeout(context.Background(), m.opts.Timeout)
+	defer cancel()
+	// set entries channel
+	p.Entries = entries
+	// set the domain
+	p.Domain = m.domain
+
+	go func() {
+		for {
+			select {
+			case e := <-entries:
+				// list record so skip
+				if p.Service == "_services" {
+					continue
+				}
+				if p.Domain != m.domain {
+					continue
+				}
+				if e.TTL == 0 {
+					continue
+				}
+
+				txt, err := decode(e.InfoFields)
+				if err != nil {
+					continue
+				}
+
+				if txt.Service != service {
+					continue
+				}
+
+				s, ok := serviceMap[txt.Version]
+				if !ok {
+					s = &Service{
+						Name:      txt.Service,
+						Version:   txt.Version,
+						Endpoints: txt.Endpoints,
+					}
+				}
+				addr := ""
+				// prefer ipv4 addrs
+				if len(e.AddrV4) > 0 {
+					addr = net.JoinHostPort(e.AddrV4.String(), fmt.Sprint(e.Port))
+					// else use ipv6
+				} else if len(e.AddrV6) > 0 {
+					addr = net.JoinHostPort(e.AddrV6.String(), fmt.Sprint(e.Port))
+				} else {
+					logger.Logf(log.InfoLevel, "[mdns]: invalid endpoint received: %v", e)
+					continue
+				}
+				s.Nodes = append(s.Nodes, &Node{
+					Id:       strings.TrimSuffix(e.Name, "."+p.Service+"."+p.Domain+"."),
+					Address:  addr,
+					Metadata: txt.Metadata,
+				})
+
+				serviceMap[txt.Version] = s
+			case <-p.Context.Done():
+				close(done)
+				return
+			}
+		}
+	}()
+
+	// execute the query
+	if err := mdns.Query(p); err != nil {
+		return nil, err
+	}
+
+	// wait for completion
+	<-done
+
+	// create list and return
+	services := make([]*Service, 0, len(serviceMap))
+
+	for _, service := range serviceMap {
+		services = append(services, service)
+	}
+
+	return services, nil
+}
+
+func (m *mdnsRegistry) ListServices(opts ...ListOption) ([]*Service, error) {
+	serviceMap := make(map[string]bool)
+	entries := make(chan *mdns.ServiceEntry, 10)
+	done := make(chan bool)
+
+	p := mdns.DefaultParams("_services")
+	// set context with timeout
+	var cancel context.CancelFunc
+	p.Context, cancel = context.WithTimeout(context.Background(), m.opts.Timeout)
+	defer cancel()
+	// set entries channel
+	p.Entries = entries
+	// set domain
+	p.Domain = m.domain
+
+	var services []*Service
+
+	go func() {
+		for {
+			select {
+			case e := <-entries:
+				if e.TTL == 0 {
+					continue
+				}
+				if !strings.HasSuffix(e.Name, p.Domain+".") {
+					continue
+				}
+				name := strings.TrimSuffix(e.Name, "."+p.Service+"."+p.Domain+".")
+				if !serviceMap[name] {
+					serviceMap[name] = true
+					services = append(services, &Service{Name: name})
+				}
+			case <-p.Context.Done():
+				close(done)
+				return
+			}
+		}
+	}()
+
+	// execute query
+	if err := mdns.Query(p); err != nil {
+		return nil, err
+	}
+
+	// wait till done
+	<-done
+
+	return services, nil
+}
+
+func (m *mdnsRegistry) Watch(opts ...WatchOption) (Watcher, error) {
+	var wo WatchOptions
+	for _, o := range opts {
+		o(&wo)
+	}
+
+	md := &mdnsWatcher{
+		id:       uuid.New().String(),
+		wo:       wo,
+		ch:       make(chan *mdns.ServiceEntry, 32),
+		exit:     make(chan struct{}),
+		domain:   m.domain,
+		registry: m,
+	}
+
+	m.mtx.Lock()
+	defer m.mtx.Unlock()
+
+	// save the watcher
+	m.watchers[md.id] = md
+
+	// check of the listener exists
+	if m.listener != nil {
+		return md, nil
+	}
+
+	// start the listener
+	go func() {
+		// go to infinity
+		for {
+			m.mtx.Lock()
+
+			// just return if there are no watchers
+			if len(m.watchers) == 0 {
+				m.listener = nil
+				m.mtx.Unlock()
+				return
+			}
+
+			// check existing listener
+			if m.listener != nil {
+				m.mtx.Unlock()
+				return
+			}
+
+			// reset the listener
+			exit := make(chan struct{})
+			ch := make(chan *mdns.ServiceEntry, 32)
+			m.listener = ch
+
+			m.mtx.Unlock()
+
+			// send messages to the watchers
+			go func() {
+				send := func(w *mdnsWatcher, e *mdns.ServiceEntry) {
+					select {
+					case w.ch <- e:
+					default:
+					}
+				}
+
+				for {
+					select {
+					case <-exit:
+						return
+					case e, ok := <-ch:
+						if !ok {
+							return
+						}
+						m.mtx.RLock()
+						// send service entry to all watchers
+						for _, w := range m.watchers {
+							send(w, e)
+						}
+						m.mtx.RUnlock()
+					}
+				}
+			}()
+
+			// start listening, blocking call
+			mdns.Listen(ch, exit)
+
+			// mdns.Listen has unblocked
+			// kill the saved listener
+			m.mtx.Lock()
+			m.listener = nil
+			close(ch)
+			m.mtx.Unlock()
+		}
+	}()
+
+	return md, nil
+}
+
+func (m *mdnsRegistry) String() string {
+	return "mdns"
+}
+
+func (m *mdnsWatcher) Next() (*Result, error) {
+	for {
+		select {
+		case e := <-m.ch:
+			txt, err := decode(e.InfoFields)
+			if err != nil {
+				continue
+			}
+
+			if len(txt.Service) == 0 || len(txt.Version) == 0 {
+				continue
+			}
+
+			// Filter watch options
+			// wo.Service: Only keep services we care about
+			if len(m.wo.Service) > 0 && txt.Service != m.wo.Service {
+				continue
+			}
+			var action string
+			if e.TTL == 0 {
+				action = "delete"
+			} else {
+				action = "create"
+			}
+
+			service := &Service{
+				Name:      txt.Service,
+				Version:   txt.Version,
+				Endpoints: txt.Endpoints,
+			}
+
+			// skip anything without the domain we care about
+			suffix := fmt.Sprintf(".%s.%s.", service.Name, m.domain)
+			if !strings.HasSuffix(e.Name, suffix) {
+				continue
+			}
+
+			var addr string
+			if len(e.AddrV4) > 0 {
+				addr = net.JoinHostPort(e.AddrV4.String(), fmt.Sprint(e.Port))
+			} else if len(e.AddrV6) > 0 {
+				addr = net.JoinHostPort(e.AddrV6.String(), fmt.Sprint(e.Port))
+			} else {
+				addr = e.Addr.String()
+			}
+
+			service.Nodes = append(service.Nodes, &Node{
+				Id:       strings.TrimSuffix(e.Name, suffix),
+				Address:  addr,
+				Metadata: txt.Metadata,
+			})
+
+			return &Result{
+				Action:  action,
+				Service: service,
+			}, nil
+		case <-m.exit:
+			return nil, ErrWatcherStopped
+		}
+	}
+}
+
+func (m *mdnsWatcher) Stop() {
+	select {
+	case <-m.exit:
+		return
+	default:
+		close(m.exit)
+		// remove self from the registry
+		m.registry.mtx.Lock()
+		delete(m.registry.watchers, m.id)
+		m.registry.mtx.Unlock()
+	}
+}
+
+// NewRegistry returns a new default registry which is mdns.
+func NewRegistry(opts ...Option) Registry {
+	return newRegistry(opts...)
+}

Server/vendor/go-micro.dev/v4/registry/memory.go

@@ -0,0 +1,277 @@
+package registry
+
+import (
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	log "go-micro.dev/v4/logger"
+)
+
+var (
+	sendEventTime = 10 * time.Millisecond
+	ttlPruneTime  = time.Second
+)
+
+type node struct {
+	LastSeen time.Time
+	*Node
+	TTL time.Duration
+}
+
+type record struct {
+	Name      string
+	Version   string
+	Metadata  map[string]string
+	Nodes     map[string]*node
+	Endpoints []*Endpoint
+}
+
+type memRegistry struct {
+	options *Options
+
+	records  map[string]map[string]*record
+	watchers map[string]*memWatcher
+
+	sync.RWMutex
+}
+
+func NewMemoryRegistry(opts ...Option) Registry {
+	options := NewOptions(opts...)
+
+	records := getServiceRecords(options.Context)
+	if records == nil {
+		records = make(map[string]map[string]*record)
+	}
+
+	reg := &memRegistry{
+		options:  options,
+		records:  records,
+		watchers: make(map[string]*memWatcher),
+	}
+
+	go reg.ttlPrune()
+
+	return reg
+}
+
+func (m *memRegistry) ttlPrune() {
+	logger := m.options.Logger
+	prune := time.NewTicker(ttlPruneTime)
+	defer prune.Stop()
+
+	for {
+		select {
+		case <-prune.C:
+			m.Lock()
+			for name, records := range m.records {
+				for version, record := range records {
+					for id, n := range record.Nodes {
+						if n.TTL != 0 && time.Since(n.LastSeen) > n.TTL {
+							logger.Logf(log.DebugLevel, "Registry TTL expired for node %s of service %s", n.Id, name)
+							delete(m.records[name][version].Nodes, id)
+						}
+					}
+				}
+			}
+			m.Unlock()
+		}
+	}
+}
+
+func (m *memRegistry) sendEvent(r *Result) {
+	m.RLock()
+	watchers := make([]*memWatcher, 0, len(m.watchers))
+	for _, w := range m.watchers {
+		watchers = append(watchers, w)
+	}
+	m.RUnlock()
+
+	for _, w := range watchers {
+		select {
+		case <-w.exit:
+			m.Lock()
+			delete(m.watchers, w.id)
+			m.Unlock()
+		default:
+			select {
+			case w.res <- r:
+			case <-time.After(sendEventTime):
+			}
+		}
+	}
+}
+
+func (m *memRegistry) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(m.options)
+	}
+
+	// add services
+	m.Lock()
+	defer m.Unlock()
+
+	records := getServiceRecords(m.options.Context)
+	for name, record := range records {
+		// add a whole new service including all of its versions
+		if _, ok := m.records[name]; !ok {
+			m.records[name] = record
+			continue
+		}
+		// add the versions of the service we dont track yet
+		for version, r := range record {
+			if _, ok := m.records[name][version]; !ok {
+				m.records[name][version] = r
+				continue
+			}
+		}
+	}
+
+	return nil
+}
+
+func (m *memRegistry) Options() Options {
+	return *m.options
+}
+
+func (m *memRegistry) Register(s *Service, opts ...RegisterOption) error {
+	m.Lock()
+	defer m.Unlock()
+	logger := m.options.Logger
+	var options RegisterOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	r := serviceToRecord(s, options.TTL)
+
+	if _, ok := m.records[s.Name]; !ok {
+		m.records[s.Name] = make(map[string]*record)
+	}
+
+	if _, ok := m.records[s.Name][s.Version]; !ok {
+		m.records[s.Name][s.Version] = r
+		logger.Logf(log.DebugLevel, "Registry added new service: %s, version: %s", s.Name, s.Version)
+		go m.sendEvent(&Result{Action: "update", Service: s})
+		return nil
+	}
+
+	addedNodes := false
+	for _, n := range s.Nodes {
+		if _, ok := m.records[s.Name][s.Version].Nodes[n.Id]; !ok {
+			addedNodes = true
+			metadata := make(map[string]string)
+			for k, v := range n.Metadata {
+				metadata[k] = v
+			}
+			m.records[s.Name][s.Version].Nodes[n.Id] = &node{
+				Node: &Node{
+					Id:       n.Id,
+					Address:  n.Address,
+					Metadata: metadata,
+				},
+				TTL:      options.TTL,
+				LastSeen: time.Now(),
+			}
+		}
+	}
+
+	if addedNodes {
+		logger.Logf(log.DebugLevel, "Registry added new node to service: %s, version: %s", s.Name, s.Version)
+		go m.sendEvent(&Result{Action: "update", Service: s})
+		return nil
+	}
+
+	// refresh TTL and timestamp
+	for _, n := range s.Nodes {
+		logger.Logf(log.DebugLevel, "Updated registration for service: %s, version: %s", s.Name, s.Version)
+		m.records[s.Name][s.Version].Nodes[n.Id].TTL = options.TTL
+		m.records[s.Name][s.Version].Nodes[n.Id].LastSeen = time.Now()
+	}
+
+	return nil
+}
+
+func (m *memRegistry) Deregister(s *Service, opts ...DeregisterOption) error {
+	m.Lock()
+	defer m.Unlock()
+	logger := m.options.Logger
+	if _, ok := m.records[s.Name]; ok {
+		if _, ok := m.records[s.Name][s.Version]; ok {
+			for _, n := range s.Nodes {
+				if _, ok := m.records[s.Name][s.Version].Nodes[n.Id]; ok {
+					logger.Logf(log.DebugLevel, "Registry removed node from service: %s, version: %s", s.Name, s.Version)
+					delete(m.records[s.Name][s.Version].Nodes, n.Id)
+				}
+			}
+			if len(m.records[s.Name][s.Version].Nodes) == 0 {
+				delete(m.records[s.Name], s.Version)
+				logger.Logf(log.DebugLevel, "Registry removed service: %s, version: %s", s.Name, s.Version)
+			}
+		}
+		if len(m.records[s.Name]) == 0 {
+			delete(m.records, s.Name)
+			logger.Logf(log.DebugLevel, "Registry removed service: %s", s.Name)
+		}
+		go m.sendEvent(&Result{Action: "delete", Service: s})
+	}
+
+	return nil
+}
+
+func (m *memRegistry) GetService(name string, opts ...GetOption) ([]*Service, error) {
+	m.RLock()
+	defer m.RUnlock()
+
+	records, ok := m.records[name]
+	if !ok {
+		return nil, ErrNotFound
+	}
+
+	services := make([]*Service, len(m.records[name]))
+	i := 0
+	for _, record := range records {
+		services[i] = recordToService(record)
+		i++
+	}
+
+	return services, nil
+}
+
+func (m *memRegistry) ListServices(opts ...ListOption) ([]*Service, error) {
+	m.RLock()
+	defer m.RUnlock()
+
+	var services []*Service
+	for _, records := range m.records {
+		for _, record := range records {
+			services = append(services, recordToService(record))
+		}
+	}
+
+	return services, nil
+}
+
+func (m *memRegistry) Watch(opts ...WatchOption) (Watcher, error) {
+	var wo WatchOptions
+	for _, o := range opts {
+		o(&wo)
+	}
+
+	w := &memWatcher{
+		exit: make(chan bool),
+		res:  make(chan *Result),
+		id:   uuid.New().String(),
+		wo:   wo,
+	}
+
+	m.Lock()
+	m.watchers[w.id] = w
+	m.Unlock()
+
+	return w, nil
+}
+
+func (m *memRegistry) String() string {
+	return "memory"
+}

Server/vendor/go-micro.dev/v4/registry/memory_util.go

@@ -0,0 +1,89 @@
+package registry
+
+import (
+	"time"
+)
+
+func serviceToRecord(s *Service, ttl time.Duration) *record {
+	metadata := make(map[string]string, len(s.Metadata))
+	for k, v := range s.Metadata {
+		metadata[k] = v
+	}
+
+	nodes := make(map[string]*node, len(s.Nodes))
+	for _, n := range s.Nodes {
+		nodes[n.Id] = &node{
+			Node:     n,
+			TTL:      ttl,
+			LastSeen: time.Now(),
+		}
+	}
+
+	endpoints := make([]*Endpoint, len(s.Endpoints))
+	for i, e := range s.Endpoints {
+		endpoints[i] = e
+	}
+
+	return &record{
+		Name:      s.Name,
+		Version:   s.Version,
+		Metadata:  metadata,
+		Nodes:     nodes,
+		Endpoints: endpoints,
+	}
+}
+
+func recordToService(r *record) *Service {
+	metadata := make(map[string]string, len(r.Metadata))
+	for k, v := range r.Metadata {
+		metadata[k] = v
+	}
+
+	endpoints := make([]*Endpoint, len(r.Endpoints))
+	for i, e := range r.Endpoints {
+		request := new(Value)
+		if e.Request != nil {
+			*request = *e.Request
+		}
+		response := new(Value)
+		if e.Response != nil {
+			*response = *e.Response
+		}
+
+		metadata := make(map[string]string, len(e.Metadata))
+		for k, v := range e.Metadata {
+			metadata[k] = v
+		}
+
+		endpoints[i] = &Endpoint{
+			Name:     e.Name,
+			Request:  request,
+			Response: response,
+			Metadata: metadata,
+		}
+	}
+
+	nodes := make([]*Node, len(r.Nodes))
+	i := 0
+	for _, n := range r.Nodes {
+		metadata := make(map[string]string, len(n.Metadata))
+		for k, v := range n.Metadata {
+			metadata[k] = v
+		}
+
+		nodes[i] = &Node{
+			Id:       n.Id,
+			Address:  n.Address,
+			Metadata: metadata,
+		}
+		i++
+	}
+
+	return &Service{
+		Name:      r.Name,
+		Version:   r.Version,
+		Metadata:  metadata,
+		Endpoints: endpoints,
+		Nodes:     nodes,
+	}
+}

Server/vendor/go-micro.dev/v4/registry/memory_watcher.go

@@ -0,0 +1,35 @@
+package registry
+
+import (
+	"errors"
+)
+
+type memWatcher struct {
+	wo   WatchOptions
+	res  chan *Result
+	exit chan bool
+	id   string
+}
+
+func (m *memWatcher) Next() (*Result, error) {
+	for {
+		select {
+		case r := <-m.res:
+			if len(m.wo.Service) > 0 && m.wo.Service != r.Service.Name {
+				continue
+			}
+			return r, nil
+		case <-m.exit:
+			return nil, errors.New("watcher stopped")
+		}
+	}
+}
+
+func (m *memWatcher) Stop() {
+	select {
+	case <-m.exit:
+		return
+	default:
+		close(m.exit)
+	}
+}

Server/vendor/go-micro.dev/v4/registry/options.go

@@ -0,0 +1,171 @@
+package registry
+
+import (
+	"context"
+	"crypto/tls"
+	"time"
+
+	"go-micro.dev/v4/logger"
+)
+
+type Options struct {
+	Logger logger.Logger
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context   context.Context
+	TLSConfig *tls.Config
+	Addrs     []string
+	Timeout   time.Duration
+	Secure    bool
+}
+
+type RegisterOptions struct {
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
+	TTL     time.Duration
+}
+
+type WatchOptions struct {
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
+	// Specify a service to watch
+	// If blank, the watch is for all services
+	Service string
+}
+
+type DeregisterOptions struct {
+	Context context.Context
+}
+
+type GetOptions struct {
+	Context context.Context
+}
+
+type ListOptions struct {
+	Context context.Context
+}
+
+func NewOptions(opts ...Option) *Options {
+	options := Options{
+		Context: context.Background(),
+		Logger:  logger.DefaultLogger,
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return &options
+}
+
+// Addrs is the registry addresses to use.
+func Addrs(addrs ...string) Option {
+	return func(o *Options) {
+		o.Addrs = addrs
+	}
+}
+
+func Timeout(t time.Duration) Option {
+	return func(o *Options) {
+		o.Timeout = t
+	}
+}
+
+// Secure communication with the registry.
+func Secure(b bool) Option {
+	return func(o *Options) {
+		o.Secure = b
+	}
+}
+
+// Specify TLS Config.
+func TLSConfig(t *tls.Config) Option {
+	return func(o *Options) {
+		o.TLSConfig = t
+	}
+}
+
+func RegisterTTL(t time.Duration) RegisterOption {
+	return func(o *RegisterOptions) {
+		o.TTL = t
+	}
+}
+
+func RegisterContext(ctx context.Context) RegisterOption {
+	return func(o *RegisterOptions) {
+		o.Context = ctx
+	}
+}
+
+// Watch a service.
+func WatchService(name string) WatchOption {
+	return func(o *WatchOptions) {
+		o.Service = name
+	}
+}
+
+func WatchContext(ctx context.Context) WatchOption {
+	return func(o *WatchOptions) {
+		o.Context = ctx
+	}
+}
+
+func DeregisterContext(ctx context.Context) DeregisterOption {
+	return func(o *DeregisterOptions) {
+		o.Context = ctx
+	}
+}
+
+func GetContext(ctx context.Context) GetOption {
+	return func(o *GetOptions) {
+		o.Context = ctx
+	}
+}
+
+func ListContext(ctx context.Context) ListOption {
+	return func(o *ListOptions) {
+		o.Context = ctx
+	}
+}
+
+type servicesKey struct{}
+
+func getServiceRecords(ctx context.Context) map[string]map[string]*record {
+	memServices, ok := ctx.Value(servicesKey{}).(map[string][]*Service)
+	if !ok {
+		return nil
+	}
+
+	services := make(map[string]map[string]*record)
+
+	for name, svc := range memServices {
+		if _, ok := services[name]; !ok {
+			services[name] = make(map[string]*record)
+		}
+		// go through every version of the service
+		for _, s := range svc {
+			services[s.Name][s.Version] = serviceToRecord(s, 0)
+		}
+	}
+
+	return services
+}
+
+// Services is an option that preloads service data.
+func Services(s map[string][]*Service) Option {
+	return func(o *Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, servicesKey{}, s)
+	}
+}
+
+// Logger sets the underline logger.
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}

Server/vendor/go-micro.dev/v4/registry/registry.go

@@ -0,0 +1,97 @@
+// Package registry is an interface for service discovery
+package registry
+
+import (
+	"errors"
+)
+
+var (
+	DefaultRegistry = NewRegistry()
+
+	// Not found error when GetService is called.
+	ErrNotFound = errors.New("service not found")
+	// Watcher stopped error when watcher is stopped.
+	ErrWatcherStopped = errors.New("watcher stopped")
+)
+
+// The registry provides an interface for service discovery
+// and an abstraction over varying implementations
+// {consul, etcd, zookeeper, ...}.
+type Registry interface {
+	Init(...Option) error
+	Options() Options
+	Register(*Service, ...RegisterOption) error
+	Deregister(*Service, ...DeregisterOption) error
+	GetService(string, ...GetOption) ([]*Service, error)
+	ListServices(...ListOption) ([]*Service, error)
+	Watch(...WatchOption) (Watcher, error)
+	String() string
+}
+
+type Service struct {
+	Name      string            `json:"name"`
+	Version   string            `json:"version"`
+	Metadata  map[string]string `json:"metadata"`
+	Endpoints []*Endpoint       `json:"endpoints"`
+	Nodes     []*Node           `json:"nodes"`
+}
+
+type Node struct {
+	Metadata map[string]string `json:"metadata"`
+	Id       string            `json:"id"`
+	Address  string            `json:"address"`
+}
+
+type Endpoint struct {
+	Request  *Value            `json:"request"`
+	Response *Value            `json:"response"`
+	Metadata map[string]string `json:"metadata"`
+	Name     string            `json:"name"`
+}
+
+type Value struct {
+	Name   string   `json:"name"`
+	Type   string   `json:"type"`
+	Values []*Value `json:"values"`
+}
+
+type Option func(*Options)
+
+type RegisterOption func(*RegisterOptions)
+
+type WatchOption func(*WatchOptions)
+
+type DeregisterOption func(*DeregisterOptions)
+
+type GetOption func(*GetOptions)
+
+type ListOption func(*ListOptions)
+
+// Register a service node. Additionally supply options such as TTL.
+func Register(s *Service, opts ...RegisterOption) error {
+	return DefaultRegistry.Register(s, opts...)
+}
+
+// Deregister a service node.
+func Deregister(s *Service) error {
+	return DefaultRegistry.Deregister(s)
+}
+
+// Retrieve a service. A slice is returned since we separate Name/Version.
+func GetService(name string) ([]*Service, error) {
+	return DefaultRegistry.GetService(name)
+}
+
+// List the services. Only returns service names.
+func ListServices() ([]*Service, error) {
+	return DefaultRegistry.ListServices()
+}
+
+// Watch returns a watcher which allows you to track updates to the registry.
+func Watch(opts ...WatchOption) (Watcher, error) {
+	return DefaultRegistry.Watch(opts...)
+}
+
+func String() string {
+	return DefaultRegistry.String()
+}

Server/vendor/go-micro.dev/v4/registry/watcher.go

@@ -0,0 +1,56 @@
+package registry
+
+import "time"
+
+// Watcher is an interface that returns updates
+// about services within the registry.
+type Watcher interface {
+	// Next is a blocking call
+	Next() (*Result, error)
+	Stop()
+}
+
+// Result is returned by a call to Next on
+// the watcher. Actions can be create, update, delete.
+type Result struct {
+	Service *Service
+	Action  string
+}
+
+// EventType defines registry event type.
+type EventType int
+
+const (
+	// Create is emitted when a new service is registered.
+	Create EventType = iota
+	// Delete is emitted when an existing service is deregsitered.
+	Delete
+	// Update is emitted when an existing servicec is updated.
+	Update
+)
+
+// String returns human readable event type.
+func (t EventType) String() string {
+	switch t {
+	case Create:
+		return "create"
+	case Delete:
+		return "delete"
+	case Update:
+		return "update"
+	default:
+		return "unknown"
+	}
+}
+
+// Event is registry event.
+type Event struct {
+	// Timestamp is event timestamp
+	Timestamp time.Time
+	// Service is registry service
+	Service *Service
+	// Id is registry id
+	Id string
+	// Type defines type of event
+	Type EventType
+}