1
0
mirror of https://github.com/go-micro/go-micro.git synced 2024-12-18 08:26:38 +02:00
go-micro/registry/mdns_registry.go

619 lines
11 KiB
Go
Raw Normal View History

2019-01-15 18:50:37 +02:00
// Package mdns is a multicast dns registry
package registry
import (
2020-04-10 18:19:26 +02:00
"bytes"
"compress/zlib"
2019-02-01 15:41:11 +02:00
"context"
2020-04-10 18:19:26 +02:00
"encoding/hex"
"encoding/json"
2019-07-08 09:01:42 +02:00
"fmt"
"io"
2019-01-15 18:50:37 +02:00
"net"
2019-07-08 09:01:42 +02:00
"strconv"
2019-01-15 18:50:37 +02:00
"strings"
"sync"
"time"
"github.com/google/uuid"
2024-06-04 22:40:43 +02:00
log "go-micro.dev/v5/logger"
"go-micro.dev/v5/util/mdns"
2019-01-15 18:50:37 +02:00
)
2019-09-09 14:11:25 +02:00
var (
2022-09-30 16:27:07 +02:00
// use a .micro domain rather than .local.
2019-09-09 14:11:25 +02:00
mdnsDomain = "micro"
)
2019-01-15 18:50:37 +02:00
type mdnsTxt struct {
2023-04-26 02:16:34 +02:00
Metadata map[string]string
2019-01-15 18:50:37 +02:00
Service string
Version string
Endpoints []*Endpoint
}
type mdnsEntry struct {
node *mdns.Server
2023-04-26 02:16:34 +02:00
id string
2019-01-15 18:50:37 +02:00
}
type mdnsRegistry struct {
2023-04-26 02:16:34 +02:00
opts *Options
2019-01-15 18:50:37 +02:00
services map[string][]*mdnsEntry
// watchers
watchers map[string]*mdnsWatcher
// listener
listener chan *mdns.ServiceEntry
2023-04-26 02:16:34 +02:00
// the mdns domain
domain string
mtx sync.RWMutex
sync.Mutex
2019-01-15 18:50:37 +02:00
}
2020-04-12 12:01:09 +02:00
type mdnsWatcher struct {
wo WatchOptions
ch chan *mdns.ServiceEntry
exit chan struct{}
// the registry
registry *mdnsRegistry
2023-04-26 02:16:34 +02:00
id string
// the mdns domain
domain string
2020-04-12 12:01:09 +02:00
}
2020-04-10 18:19:26 +02:00
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)
2020-04-10 18:19:26 +02:00
if err != nil {
return nil, err
}
var txt *mdnsTxt
if err := json.Unmarshal(rbuf, &txt); err != nil {
return nil, err
}
return txt, nil
}
2019-01-15 18:50:37 +02:00
func newRegistry(opts ...Option) Registry {
mergedOpts := append([]Option{Timeout(time.Millisecond * 100)}, opts...)
options := NewOptions(mergedOpts...)
2019-09-09 14:11:25 +02:00
// set the domain
domain := mdnsDomain
d, ok := options.Context.Value("mdns.domain").(string)
if ok {
domain = d
}
2019-01-15 18:50:37 +02:00
return &mdnsRegistry{
opts: options,
2019-09-09 14:11:25 +02:00
domain: domain,
2019-01-15 18:50:37 +02:00
services: make(map[string][]*mdnsEntry),
watchers: make(map[string]*mdnsWatcher),
2019-01-15 18:50:37 +02:00
}
}
func (m *mdnsRegistry) Init(opts ...Option) error {
for _, o := range opts {
o(m.opts)
2019-01-15 18:50:37 +02:00
}
return nil
}
func (m *mdnsRegistry) Options() Options {
return *m.opts
2019-01-15 18:50:37 +02:00
}
func (m *mdnsRegistry) Register(service *Service, opts ...RegisterOption) error {
m.Lock()
defer m.Unlock()
logger := m.opts.Logger
2019-01-15 18:50:37 +02:00
entries, ok := m.services[service.Name]
// first entry, create wildcard used for list queries
if !ok {
s, err := mdns.NewMDNSService(
service.Name,
"_services",
2019-09-09 14:11:25 +02:00
m.domain+".",
2019-01-15 18:50:37 +02:00
"",
9999,
[]net.IP{net.ParseIP("0.0.0.0")},
nil,
)
if err != nil {
return err
}
2019-12-05 18:10:49 +02:00
srv, err := mdns.NewServer(&mdns.Config{Zone: &mdns.DNSSDService{MDNSService: s}})
2019-01-15 18:50:37 +02:00
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 {
2019-01-15 18:50:37 +02:00
continue
// doesn't exist
} else {
e = &mdnsEntry{}
2019-01-15 18:50:37 +02:00
}
txt, err := encode(&mdnsTxt{
Service: service.Name,
Version: service.Version,
Endpoints: service.Endpoints,
Metadata: node.Metadata,
})
if err != nil {
gerr = err
continue
}
2019-07-08 09:01:42 +02:00
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)
2019-01-15 18:50:37 +02:00
// we got here, new node
s, err := mdns.NewMDNSService(
node.Id,
service.Name,
2019-09-09 14:11:25 +02:00
m.domain+".",
2019-01-15 18:50:37 +02:00
"",
2019-07-08 09:01:42 +02:00
port,
[]net.IP{net.ParseIP(host)},
2019-01-15 18:50:37 +02:00
txt,
)
if err != nil {
gerr = err
continue
}
srv, err := mdns.NewServer(&mdns.Config{Zone: s, LocalhostChecking: true})
2019-01-15 18:50:37 +02:00
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
}
2020-04-14 13:32:59 +02:00
func (m *mdnsRegistry) Deregister(service *Service, opts ...DeregisterOption) error {
2019-01-15 18:50:37 +02:00
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
}
2020-04-14 13:32:59 +02:00
func (m *mdnsRegistry) GetService(service string, opts ...GetOption) ([]*Service, error) {
logger := m.opts.Logger
2019-01-15 18:50:37 +02:00
serviceMap := make(map[string]*Service)
2019-02-01 15:41:11 +02:00
entries := make(chan *mdns.ServiceEntry, 10)
done := make(chan bool)
p := mdns.DefaultParams(service)
// set context with timeout
2019-12-03 09:25:58 +02:00
var cancel context.CancelFunc
p.Context, cancel = context.WithTimeout(context.Background(), m.opts.Timeout)
defer cancel()
2019-02-01 15:41:11 +02:00
// set entries channel
p.Entries = entries
2019-09-09 14:11:25 +02:00
// set the domain
p.Domain = m.domain
2019-01-15 18:50:37 +02:00
go func() {
for {
select {
2019-02-01 15:41:11 +02:00
case e := <-entries:
2019-01-15 18:50:37 +02:00
// list record so skip
if p.Service == "_services" {
continue
}
2019-09-09 14:11:25 +02:00
if p.Domain != m.domain {
continue
}
2019-01-15 18:50:37 +02:00
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
}
2019-01-15 18:50:37 +02:00
s.Nodes = append(s.Nodes, &Node{
Id: strings.TrimSuffix(e.Name, "."+p.Service+"."+p.Domain+"."),
Address: addr,
2019-01-15 18:50:37 +02:00
Metadata: txt.Metadata,
})
serviceMap[txt.Version] = s
2019-02-01 15:41:11 +02:00
case <-p.Context.Done():
close(done)
2019-01-15 18:50:37 +02:00
return
}
}
}()
2019-02-01 15:41:11 +02:00
// execute the query
2019-01-15 18:50:37 +02:00
if err := mdns.Query(p); err != nil {
return nil, err
}
2019-02-01 15:41:11 +02:00
// wait for completion
<-done
2019-01-15 18:50:37 +02:00
// create list and return
2019-11-11 02:03:51 +02:00
services := make([]*Service, 0, len(serviceMap))
2019-01-15 18:50:37 +02:00
for _, service := range serviceMap {
services = append(services, service)
}
return services, nil
}
2020-04-14 13:32:59 +02:00
func (m *mdnsRegistry) ListServices(opts ...ListOption) ([]*Service, error) {
2019-02-01 15:41:11 +02:00
serviceMap := make(map[string]bool)
entries := make(chan *mdns.ServiceEntry, 10)
done := make(chan bool)
2019-01-15 18:50:37 +02:00
2019-02-01 15:41:11 +02:00
p := mdns.DefaultParams("_services")
// set context with timeout
2019-12-03 09:25:58 +02:00
var cancel context.CancelFunc
p.Context, cancel = context.WithTimeout(context.Background(), m.opts.Timeout)
defer cancel()
2019-02-01 15:41:11 +02:00
// set entries channel
p.Entries = entries
2019-09-09 14:11:25 +02:00
// set domain
p.Domain = m.domain
2019-01-15 18:50:37 +02:00
var services []*Service
go func() {
for {
select {
2019-02-01 15:41:11 +02:00
case e := <-entries:
2019-01-15 18:50:37 +02:00
if e.TTL == 0 {
continue
}
2019-09-09 14:11:25 +02:00
if !strings.HasSuffix(e.Name, p.Domain+".") {
continue
}
2019-01-15 18:50:37 +02:00
name := strings.TrimSuffix(e.Name, "."+p.Service+"."+p.Domain+".")
if !serviceMap[name] {
serviceMap[name] = true
services = append(services, &Service{Name: name})
}
2019-02-01 15:41:11 +02:00
case <-p.Context.Done():
close(done)
2019-01-15 18:50:37 +02:00
return
}
}
}()
2019-02-01 15:41:11 +02:00
// execute query
2019-01-15 18:50:37 +02:00
if err := mdns.Query(p); err != nil {
return nil, err
}
2019-02-01 15:41:11 +02:00
// wait till done
<-done
2019-01-15 18:50:37 +02:00
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
2019-01-15 18:50:37 +02:00
}
// start the listener
2019-01-15 18:50:37 +02:00
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()
2019-01-15 18:50:37 +02:00
}
}()
return md, nil
}
func (m *mdnsRegistry) String() string {
return "mdns"
}
2020-04-12 12:01:09 +02:00
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()
}
2020-04-12 12:01:09 +02:00
service.Nodes = append(service.Nodes, &Node{
Id: strings.TrimSuffix(e.Name, suffix),
Address: addr,
2020-04-12 12:01:09 +02:00
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()
}
}
2022-09-30 16:27:07 +02:00
// NewRegistry returns a new default registry which is mdns.
2019-01-15 18:50:37 +02:00
func NewRegistry(opts ...Option) Registry {
return newRegistry(opts...)
}