address comments

Author: sgirones

discovery/main.go

@@ -1,9 +1,7 @@
 package discovery
 
 import (
-	"fmt"
-
-	"github.com/miekg/dns"
+	"net"
 )
 
 type Endpoint struct {
@@ -13,50 +11,18 @@ type Endpoint struct {
 
 func DiscoverEndpoints(serviceDNS string) ([]Endpoint, error) {
 	endpoints := []Endpoint{}
-	qType := dns.StringToType["SRV"]
-	serviceDNS = dns.Fqdn(serviceDNS)
-
-	client := &dns.Client{}
-	msg := &dns.Msg{}
-
-	msg.SetQuestion(serviceDNS, qType)
-
-	dnsserver, err := getDNSServer()
-	if err != nil {
-		return endpoints, err
-	}
+	_, remotes, err := net.LookupSRV("", "", serviceDNS)
 
-	response, _, err := client.Exchange(msg, dnsserver)
 	if err != nil {
 		return endpoints, err
 	}
 
-	if msg.Id != response.Id {
-		return nil, fmt.Errorf("DNS ID mismatch, request: %d, response: %d", msg.Id, response.Id)
-	}
-
-	for _, v := range response.Answer {
-		if srv, ok := v.(*dns.SRV); ok {
-			endpoints = append(endpoints, Endpoint{
-				Name: srv.Target,
-				Port: srv.Port,
-			})
-		}
+	for _, n := range remotes {
+		endpoints = append(endpoints, Endpoint{
+			Name: n.Target,
+			Port: n.Port,
+		})
 	}
 
 	return endpoints, nil
 }
-
-func getDNSServer() (string, error) {
-	servers, err := parseResolvConf()
-	return servers[0], err
-}
-
-func parseResolvConf() ([]string, error) {
-	conf, err := dns.ClientConfigFromFile("/etc/resolv.conf")
-	if err != nil {
-		return []string{}, err
-	}
-
-	return conf.Servers, nil
-}

glide.lock

@@ -7,7 +7,7 @@ import:
 - package: github.com/kelseyhightower/envconfig
   version: v1.3.0
 - package: github.com/nats-io/nats
-  version: v1.2.2
+  version: v1.3.0
 - package: github.com/pkg/errors
   version: v0.8.0
 - package: github.com/rybit/nats_logrus_hook
@@ -23,7 +23,6 @@ import:
 - package: gopkg.in/mgo.v2
 - package: github.com/BurntSushi/toml
   version: v0.3.0
-- package: github.com/miekg/dns
 testImport:
 - package: github.com/nats-io/gnatsd
   version: v0.9.6

glide.yaml

@@ -14,10 +14,10 @@ import (
 )
 
 type NatsConfig struct {
-	TLS            *tls.Config `mapstructure:"tls_conf"`
-	ServiceDNSName string      `mapstructure:"service_dnsname"`
-	Servers        []string    `mapstructure:"servers"`
-	LogsSubject    string      `mapstructure:"log_subject"`
+	TLS           *tls.Config `mapstructure:"tls_conf"`
+	DiscoveryName string      `mapstructure:"discovery_name"`
+	Servers       []string    `mapstructure:"servers"`
+	LogsSubject   string      `mapstructure:"log_subject"`
 }
 
 type MetricsConfig struct {
@@ -66,21 +66,14 @@ func ConfigureNatsConnection(config *NatsConfig, log *logrus.Entry) (*nats.Conn,
 
 // ConnectToNats will do a TLS connection to the nats servers specified
 func ConnectToNats(config *NatsConfig, errHandler nats.ErrHandler) (*nats.Conn, error) {
+	var err error
 	serversString := config.ServerString()
 
-	if config.ServiceDNSName != "" {
-		natsUrls := []string{}
-
-		endpoints, err := discovery.DiscoverEndpoints(config.ServiceDNSName)
+	if config.DiscoveryName != "" {
+		serversString, err = buildNatsServersString(config.DiscoveryName)
 		if err != nil {
 			return nil, err
 		}
-
-		for _, endpoint := range endpoints {
-			natsUrls = append(natsUrls, fmt.Sprintf("nats://%s:%d", endpoint.Name, endpoint.Port))
-		}
-
-		serversString = strings.Join(natsUrls, ",")
 	}
 
 	options := []nats.Option{}
@@ -111,3 +104,18 @@ func ErrorHandler(log *logrus.Entry) nats.ErrHandler {
 		}).Error("Error while consuming from " + sub.Subject)
 	}
 }
+
+func buildNatsServersString(serviceName string) (string, error) {
+	natsUrls := []string{}
+
+	endpoints, err := discovery.DiscoverEndpoints(serviceName)
+	if err != nil {
+		return "", err
+	}
+
+	for _, endpoint := range endpoints {
+		natsUrls = append(natsUrls, fmt.Sprintf("nats://%s:%d", endpoint.Name, endpoint.Port))
+	}
+
+	return strings.Join(natsUrls, ","), nil
+}

messaging/nats.go

@@ -41,9 +41,9 @@ func (c *Consumer) Clone(queueName string, delivery *DeliveryDefinition) (*Consu
 }
 
 type RabbitConfig struct {
-	Servers        []string    `mapstructure:"servers"`
-	ServiceDNSName string      `mapstructure:"service_dnsname"`
-	TLS            *tls.Config `mapstructure:"tls_conf"`
+	Servers       []string    `mapstructure:"servers"`
+	DiscoveryName string      `mapstructure:"discovery_name"`
+	TLS           *tls.Config `mapstructure:"tls_conf"`
 
 	ExchangeDefinition ExchangeDefinition  `envconfig:"exchange" mapstructure:"exchange"`
 	QueueDefinition    QueueDefinition     `envconfig:"queue" mapstructure:"queue"`
@@ -206,21 +206,17 @@ func ValidateRabbitConfigStruct(servers []string, exchange ExchangeDefinition, q
 
 // ConnectToRabbit will open a TLS connection to rabbit mq
 func ConnectToRabbit(config *RabbitConfig, log *logrus.Entry) (*Consumer, error) {
-	if err := ValidateRabbitConfig(config); err != nil {
+	var err error
+	if err = ValidateRabbitConfig(config); err != nil {
 		return nil, err
 	}
 
 	servers := config.Servers
-	if config.ServiceDNSName != "" {
-		servers = []string{}
-		endpoints, err := discovery.DiscoverEndpoints(config.ServiceDNSName)
+	if config.DiscoveryName != "" {
+		servers, err = discoverRabbitServers(config.DiscoveryName)
 		if err != nil {
 			return nil, err
 		}
-
-		for _, endpoint := range endpoints {
-			servers = append(servers, fmt.Sprintf("%s:%d", endpoint.Name, endpoint.Port))
-		}
 	}
 
 	conn, err := DialToRabbit(servers, config.TLS, log)
@@ -409,6 +405,21 @@ func Consume(channel *amqp.Channel, deliveryDef *DeliveryDefinition) (<-chan amq
 	)
 }
 
+func discoverRabbitServers(serviceName string) ([]string, error) {
+	rabbitUrls := []string{}
+
+	endpoints, err := discovery.DiscoverEndpoints(serviceName)
+	if err != nil {
+		return rabbitUrls, err
+	}
+
+	for _, endpoint := range endpoints {
+		rabbitUrls = append(rabbitUrls, fmt.Sprintf("%s:%d", endpoint.Name, endpoint.Port))
+	}
+
+	return rabbitUrls, nil
+}
+
 // ----------------------------------------------------------------------------
 // utils
 // ----------------------------------------------------------------------------