chore: run golines

cmd/cdnsd/main.go

@@ -25,7 +25,12 @@ var cmdlineFlags struct {
 }
 
 func main() {
-	flag.StringVar(&cmdlineFlags.configFile, "config", "", "path to config file to load")
+	flag.StringVar(
+		&cmdlineFlags.configFile,
+		"config",
+		"",
+		"path to config file to load",
+	)
 	flag.Parse()
 
 	// Load config
@@ -54,9 +59,20 @@ func main() {
 
 	// Start debug listener
 	if cfg.Debug.ListenPort > 0 {
-		logger.Infof("starting debug listener on %s:%d", cfg.Debug.ListenAddress, cfg.Debug.ListenPort)
+		logger.Infof(
+			"starting debug listener on %s:%d",
+			cfg.Debug.ListenAddress,
+			cfg.Debug.ListenPort,
+		)
 		go func() {
-			err := http.ListenAndServe(fmt.Sprintf("%s:%d", cfg.Debug.ListenAddress, cfg.Debug.ListenPort), nil)
+			err := http.ListenAndServe(
+				fmt.Sprintf(
+					"%s:%d",
+					cfg.Debug.ListenAddress,
+					cfg.Debug.ListenPort,
+				),
+				nil,
+			)
 			if err != nil {
 				logger.Fatalf("failed to start debug listener: %s", err)
 			}
@@ -69,7 +85,11 @@ func main() {
 	}
 
 	// Start DNS listener
-	logger.Infof("starting DNS listener on %s:%d", cfg.Dns.ListenAddress, cfg.Dns.ListenPort)
+	logger.Infof(
+		"starting DNS listener on %s:%d",
+		cfg.Dns.ListenAddress,
+		cfg.Dns.ListenPort,
+	)
 	if err := dns.Start(); err != nil {
 		logger.Fatalf("failed to start DNS listener: %s", err)
 	}

internal/config/config.go

@@ -37,32 +37,32 @@ type Config struct {
 
 type LoggingConfig struct {
 	Healthchecks bool   `yaml:"healthchecks" envconfig:"LOGGING_HEALTHCHECKS"`
-	Level        string `yaml:"level" envconfig:"LOGGING_LEVEL"`
-	QueryLog     bool   `yaml:"queryLog" envconfig:"LOGGING_QUERY_LOG"`
+	Level        string `yaml:"level"        envconfig:"LOGGING_LEVEL"`
+	QueryLog     bool   `yaml:"queryLog"     envconfig:"LOGGING_QUERY_LOG"`
 }
 
 type DnsConfig struct {
-	ListenAddress    string   `yaml:"address" envconfig:"DNS_LISTEN_ADDRESS"`
-	ListenPort       uint     `yaml:"port" envconfig:"DNS_LISTEN_PORT"`
+	ListenAddress    string   `yaml:"address"          envconfig:"DNS_LISTEN_ADDRESS"`
+	ListenPort       uint     `yaml:"port"             envconfig:"DNS_LISTEN_PORT"`
 	RecursionEnabled bool     `yaml:"recursionEnabled" envconfig:"DNS_RECURSION"`
-	FallbackServers  []string `yaml:"fallbackServers" envconfig:"DNS_FALLBACK_SERVERS"`
+	FallbackServers  []string `yaml:"fallbackServers"  envconfig:"DNS_FALLBACK_SERVERS"`
 }
 
 type DebugConfig struct {
 	ListenAddress string `yaml:"address" envconfig:"DEBUG_ADDRESS"`
-	ListenPort    uint   `yaml:"port" envconfig:"DEBUG_PORT"`
+	ListenPort    uint   `yaml:"port"    envconfig:"DEBUG_PORT"`
 }
 
 type MetricsConfig struct {
 	ListenAddress string `yaml:"address" envconfig:"METRICS_LISTEN_ADDRESS"`
-	ListenPort    uint   `yaml:"port" envconfig:"METRICS_LISTEN_PORT"`
+	ListenPort    uint   `yaml:"port"    envconfig:"METRICS_LISTEN_PORT"`
 }
 
 type IndexerConfig struct {
-	Network       string `yaml:"network" envconfig:"INDEXER_NETWORK"`
-	NetworkMagic  uint32 `yaml:"networkMagic" envconfig:"INDEXER_NETWORK_MAGIC"`
-	Address       string `yaml:"address" envconfig:"INDEXER_TCP_ADDRESS"`
-	SocketPath    string `yaml:"socketPath" envconfig:"INDEXER_SOCKET_PATH"`
+	Network       string `yaml:"network"       envconfig:"INDEXER_NETWORK"`
+	NetworkMagic  uint32 `yaml:"networkMagic"  envconfig:"INDEXER_NETWORK_MAGIC"`
+	Address       string `yaml:"address"       envconfig:"INDEXER_TCP_ADDRESS"`
+	SocketPath    string `yaml:"socketPath"    envconfig:"INDEXER_SOCKET_PATH"`
 	ScriptAddress string `yaml:"scriptAddress" envconfig:"INDEXER_SCRIPT_ADDRESS"`
 	InterceptHash string `yaml:"interceptHash" envconfig:"INDEXER_INTERCEPT_HASH"`
 	InterceptSlot uint64 `yaml:"interceptSlot" envconfig:"INDEXER_INTERCEPT_SLOT"`
@@ -83,7 +83,11 @@ var globalConfig = &Config{
 		ListenAddress: "",
 		ListenPort:    8053,
 		// hdns.io
-		FallbackServers: []string{"103.196.38.38", "103.196.38.39", "103.196.38.40"},
+		FallbackServers: []string{
+			"103.196.38.38",
+			"103.196.38.39",
+			"103.196.38.40",
+		},
 	},
 	Debug: DebugConfig{
 		ListenAddress: "localhost",

internal/dns/dns.go

@@ -15,14 +15,28 @@ import (
 
 func Start() error {
 	cfg := config.GetConfig()
-	listenAddr := fmt.Sprintf("%s:%d", cfg.Dns.ListenAddress, cfg.Dns.ListenPort)
+	listenAddr := fmt.Sprintf(
+		"%s:%d",
+		cfg.Dns.ListenAddress,
+		cfg.Dns.ListenPort,
+	)
 	// Setup handler
 	dns.HandleFunc(".", handleQuery)
 	// UDP listener
-	serverUdp := &dns.Server{Addr: listenAddr, Net: "udp", TsigSecret: nil, ReusePort: true}
+	serverUdp := &dns.Server{
+		Addr:       listenAddr,
+		Net:        "udp",
+		TsigSecret: nil,
+		ReusePort:  true,
+	}
 	go startListener(serverUdp)
 	// TCP listener
-	serverTcp := &dns.Server{Addr: listenAddr, Net: "tcp", TsigSecret: nil, ReusePort: true}
+	serverTcp := &dns.Server{
+		Addr:       listenAddr,
+		Net:        "tcp",
+		TsigSecret: nil,
+		ReusePort:  true,
+	}
 	go startListener(serverTcp)
 	return nil
 }
@@ -48,9 +62,15 @@ func handleQuery(w dns.ResponseWriter, r *dns.Msg) {
 		}
 	}
 
-	nameserverDomain, nameservers, err := findNameserversForDomain(r.Question[0].Name)
+	nameserverDomain, nameservers, err := findNameserversForDomain(
+		r.Question[0].Name,
+	)
 	if err != nil {
-		logger.Errorf("failed to lookup nameservers for %s: %s", r.Question[0].Name, err)
+		logger.Errorf(
+			"failed to lookup nameservers for %s: %s",
+			r.Question[0].Name,
+			err,
+		)
 	}
 	if nameservers != nil {
 		// Assemble response
@@ -158,12 +178,23 @@ func doQuery(msg *dns.Msg, address string, recursive bool) (*dns.Msg, error) {
 	if !strings.Contains(address, ":") {
 		address = address + `:53`
 	}
-	logger.Debugf("querying %s: %s", address, formatMessageQuestionSection(msg.Question))
+	logger.Debugf(
+		"querying %s: %s",
+		address,
+		formatMessageQuestionSection(msg.Question),
+	)
 	resp, err := dns.Exchange(msg, address)
 	if err != nil {
 		return nil, err
 	}
-	logger.Debugf("response: rcode=%s, authoritative=%v, authority=%s, answer=%s, extra=%s", dns.RcodeToString[resp.Rcode], resp.Authoritative, formatMessageAnswerSection(resp.Ns), formatMessageAnswerSection(resp.Answer), formatMessageAnswerSection(resp.Extra))
+	logger.Debugf(
+		"response: rcode=%s, authoritative=%v, authority=%s, answer=%s, extra=%s",
+		dns.RcodeToString[resp.Rcode],
+		resp.Authoritative,
+		formatMessageAnswerSection(resp.Ns),
+		formatMessageAnswerSection(resp.Answer),
+		formatMessageAnswerSection(resp.Extra),
+	)
 	// Immediately return authoritative response
 	if resp.Authoritative {
 		return resp, nil
@@ -195,7 +226,9 @@ func doQuery(msg *dns.Msg, address string, recursive bool) (*dns.Msg, error) {
 	return resp, nil
 }
 
-func findNameserversForDomain(recordName string) (string, map[string][]net.IP, error) {
+func findNameserversForDomain(
+	recordName string,
+) (string, map[string][]net.IP, error) {
 	cfg := config.GetConfig()
 
 	// Split record name into labels and lookup each domain and parent until we get a hit
@@ -223,7 +256,9 @@ func findNameserversForDomain(recordName string) (string, map[string][]net.IP, e
 		// Pick random fallback server
 		fallbackServer := randomFallbackServer()
 		for startLabelIdx := 0; startLabelIdx < len(queryLabels); startLabelIdx++ {
-			lookupDomainName := dns.Fqdn(strings.Join(queryLabels[startLabelIdx:], "."))
+			lookupDomainName := dns.Fqdn(
+				strings.Join(queryLabels[startLabelIdx:], "."),
+			)
 			m := createQuery(lookupDomainName, dns.TypeNS)
 			in, err := doQuery(m, fallbackServer, false)
 			if err != nil {

internal/indexer/indexer.go

@@ -40,15 +40,17 @@ func (i *Indexer) Start() error {
 	i.pipeline = pipeline.New()
 	// Configure pipeline input
 	inputOpts := []input_chainsync.ChainSyncOptionFunc{
-		input_chainsync.WithStatusUpdateFunc(func(status input_chainsync.ChainSyncStatus) {
-			if err := state.GetState().UpdateCursor(status.SlotNumber, status.BlockHash); err != nil {
-				logger.Errorf("failed to update cursor: %s", err)
-			}
-			if !i.tipReached && status.TipReached {
-				i.tipReached = true
-				logger.Infof("caught up to chain tip")
-			}
-		}),
+		input_chainsync.WithStatusUpdateFunc(
+			func(status input_chainsync.ChainSyncStatus) {
+				if err := state.GetState().UpdateCursor(status.SlotNumber, status.BlockHash); err != nil {
+					logger.Errorf("failed to update cursor: %s", err)
+				}
+				if !i.tipReached && status.TipReached {
+					i.tipReached = true
+					logger.Infof("caught up to chain tip")
+				}
+			},
+		),
 		input_chainsync.WithBulkMode(true),
 	}
 	if cfg.Indexer.NetworkMagic > 0 {
@@ -67,7 +69,11 @@ func (i *Indexer) Start() error {
 		return err
 	}
 	if cursorSlotNumber > 0 {
-		logger.Infof("found previous chainsync cursor: %d, %s", cursorSlotNumber, cursorBlockHash)
+		logger.Infof(
+			"found previous chainsync cursor: %d, %s",
+			cursorSlotNumber,
+			cursorBlockHash,
+		)
 		hashBytes, err := hex.DecodeString(cursorBlockHash)
 		if err != nil {
 			return err
@@ -143,22 +149,33 @@ func (i *Indexer) handleEvent(evt event.Event) error {
 		datum := txOutput.Datum()
 		if datum != nil {
 			if _, err := datum.Decode(); err != nil {
-				logger.Warnf("error decoding TX (%s) output datum: %s", eventCtx.TransactionHash, err)
+				logger.Warnf(
+					"error decoding TX (%s) output datum: %s",
+					eventCtx.TransactionHash,
+					err,
+				)
 				return err
 			}
 			datumFields := datum.Value().(cbor.Constructor).Fields()
 			domainName := string(datumFields[0].(cbor.ByteString).Bytes())
 			nameServers := map[string]string{}
 			for _, record := range datumFields[1].([]any) {
 				recordConstructor := record.(cbor.Constructor)
-				nameServer := string(recordConstructor.Fields()[0].(cbor.ByteString).Bytes())
-				ipAddress := string(recordConstructor.Fields()[1].(cbor.ByteString).Bytes())
+				nameServer := string(
+					recordConstructor.Fields()[0].(cbor.ByteString).Bytes(),
+				)
+				ipAddress := string(
+					recordConstructor.Fields()[1].(cbor.ByteString).Bytes(),
+				)
 				nameServers[nameServer] = ipAddress
 			}
 			if err := state.GetState().UpdateDomain(domainName, nameServers); err != nil {
 				return err
 			}
-			logger.Infof("found updated registration for domain: %s", domainName)
+			logger.Infof(
+				"found updated registration for domain: %s",
+				domainName,
+			)
 		}
 	}
 	return nil

internal/logging/logging.go

@@ -20,7 +20,9 @@ func Setup() {
 	// Change timestamp key name
 	loggerConfig.EncoderConfig.TimeKey = "timestamp"
 	// Use a human readable time format
-	loggerConfig.EncoderConfig.EncodeTime = zapcore.TimeEncoderOfLayout(time.RFC3339)
+	loggerConfig.EncoderConfig.EncodeTime = zapcore.TimeEncoderOfLayout(
+		time.RFC3339,
+	)
 
 	// Set level
 	if cfg.Logging.Level != "" {
@@ -50,5 +52,7 @@ func GetDesugaredLogger() *zap.Logger {
 }
 
 func GetAccessLogger() *zap.Logger {
-	return globalLogger.Desugar().With(zap.String("type", "access")).WithOptions(zap.WithCaller(false))
+	return globalLogger.Desugar().
+		With(zap.String("type", "access")).
+		WithOptions(zap.WithCaller(false))
 }

internal/state/state.go

@@ -76,11 +76,18 @@ func (s *State) GetCursor() (uint64, string, error) {
 	return slotNumber, blockHash, err
 }
 
-func (s *State) UpdateDomain(domainName string, nameServers map[string]string) error {
+func (s *State) UpdateDomain(
+	domainName string,
+	nameServers map[string]string,
+) error {
 	err := s.db.Update(func(txn *badger.Txn) error {
 		// TODO: find any existing keys for domain and delete
 		for nameServer, ipAddress := range nameServers {
-			key := fmt.Sprintf("domain_%s_nameserver_%s", domainName, nameServer)
+			key := fmt.Sprintf(
+				"domain_%s_nameserver_%s",
+				domainName,
+				nameServer,
+			)
 			if err := txn.Set([]byte(key), []byte(ipAddress)); err != nil {
 				return err
 			}