Specify lan discovery service name (#1788)

diff --git a/p2p/discover/mdns/mdns.go b/p2p/discover/mdns/mdns.go
index c061be9..e96ee5c 100644 (file)
--- a/p2p/discover/mdns/mdns.go
+++ b/p2p/discover/mdns/mdns.go
@@ -2,65 +2,68 @@ package mdns
 
 import (
        "context"
+       "fmt"
 
        "github.com/grandcat/zeroconf"
 )
 
 const (
        instanceName = "bytomd"
-       serviceName  = "lanDiscover"
+       serviceName  = "bytom%sLanDiscover"
        domainName   = "local"
 )
 
 // Protocol decoration ZeroConf,which is a pure Golang library
 // that employs Multicast DNS-SD.
 type Protocol struct {
-       entries chan *zeroconf.ServiceEntry
-       server  *zeroconf.Server
-       quite   chan struct{}
+       entries     chan *zeroconf.ServiceEntry
+       server      *zeroconf.Server
+       serviceName string
+       quite       chan struct{}
 }
 
 // NewProtocol create a specific Protocol.
-func NewProtocol() *Protocol {
+func NewProtocol(chainID string) *Protocol {
        return &Protocol{
-               entries: make(chan *zeroconf.ServiceEntry),
-               quite:   make(chan struct{}),
+               entries:     make(chan *zeroconf.ServiceEntry),
+               serviceName: fmt.Sprintf(serviceName, chainID),
+               quite:       make(chan struct{}),
        }
 }
 
-func (m *Protocol) getLanPeerLoop(event chan LANPeerEvent) {
+func (p *Protocol) getLanPeerLoop(event chan LANPeerEvent) {
        for {
                select {
-               case entry := <-m.entries:
+               case entry := <-p.entries:
                        event <- LANPeerEvent{IP: entry.AddrIPv4, Port: entry.Port}
-               case <-m.quite:
+               case <-p.quite:
                        return
                }
        }
 }
 
-func (m *Protocol) registerService(port int) error {
+func (p *Protocol) registerService(port int) error {
        var err error
-       m.server, err = zeroconf.Register(instanceName, serviceName, domainName, port, nil, nil)
+       p.server, err = zeroconf.Register(instanceName, p.serviceName, domainName, port, nil, nil)
        return err
 }
 
-func (m *Protocol) registerResolver(event chan LANPeerEvent) error {
-       go m.getLanPeerLoop(event)
+func (p *Protocol) registerResolver(event chan LANPeerEvent) error {
+       go p.getLanPeerLoop(event)
        resolver, err := zeroconf.NewResolver(nil)
        if err != nil {
                return err
        }
 
-       return resolver.Browse(context.Background(), serviceName, domainName, m.entries)
+       return resolver.Browse(context.Background(), p.serviceName, domainName, p.entries)
 }
 
-func (m *Protocol) stopResolver() {
-       close(m.quite)
+func (p *Protocol) stopResolver() {
+       close(p.quite)
 }
 
-func (m *Protocol) stopService() {
-       if m.server != nil {
-               m.server.Shutdown()
+func (p *Protocol) stopService() {
+       if p.server != nil {
+               p.server.Shutdown()
        }
 }

diff --git a/p2p/switch.go b/p2p/switch.go
index 6fc9ab3..0cd255f 100644 (file)
--- a/p2p/switch.go
+++ b/p2p/switch.go
@@ -105,7 +105,7 @@ func NewSwitch(config *cfg.Config) (*Switch, error) {
                        return nil, err
                }
                if config.P2P.LANDiscover {
-                       lanDiscv = mdns.NewLANDiscover(mdns.NewProtocol(), int(l.ExternalAddress().Port))
+                       lanDiscv = mdns.NewLANDiscover(mdns.NewProtocol(config.ChainID), int(l.ExternalAddress().Port))
                }
        }