CalvinBackup/ctrld
1
0
Fork 0
mirror of https://github.com/Control-D-Inc/ctrld.git synced 2026-05-15 00:50:25 +02:00
Code Issues Packages Projects Releases Wiki Activity

all: eliminate usage of global ProxyLogger

Browse Source 
So setting up logging for ctrld binary and ctrld packages could be done
more easily, decouple the required setup for interactive vs daemon
running.

This is the first step toward replacing rs/zerolog libary with a
different logging library.
This commit is contained in:
Cuong Manh Le
2025-04-03 21:17:02 +07:00
committed by Cuong Manh Le
parent 5641aab5bd
commit fc527dbdfb
39 changed files with 425 additions and 420 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/clientinfo/client_info.go
+31 -23
View File
@@ -79,6 +79,7 @@ type Table struct {
initOnce sync.Once
stopOnce sync.Once
refreshInterval int
logger *ctrld.Logger
dhcp *dhcp
merlin *merlinDiscover
@@ -98,11 +99,14 @@ type Table struct {
ptrNameservers []string
}
func NewTable(cfg *ctrld.Config, selfIP, cdUID string, ns []string) *Table {
func NewTable(cfg *ctrld.Config, selfIP, cdUID string, ns []string, logger *ctrld.Logger) *Table {
refreshInterval := cfg.Service.DiscoverRefreshInterval
if refreshInterval <= 0 {
refreshInterval = 2 * 60 // 2 minutes
}
if logger == nil {
logger = ctrld.NopLogger
}
return &Table{
svcCfg: cfg.Service,
quitCh: make(chan struct{}),
@@ -111,6 +115,7 @@ func NewTable(cfg *ctrld.Config, selfIP, cdUID string, ns []string) *Table {
cdUID: cdUID,
ptrNameservers: ns,
refreshInterval: refreshInterval,
logger: logger,
}
}
@@ -179,7 +184,7 @@ func (t *Table) SetSelfIP(ip string) {
// initSelfDiscover initializes necessary client metadata for self query.
func (t *Table) initSelfDiscover() {
t.dhcp = &dhcp{selfIP: t.selfIP}
t.dhcp = &dhcp{selfIP: t.selfIP, logger: t.logger}
t.dhcp.addSelf()
t.ipResolvers = append(t.ipResolvers, t.dhcp)
t.macResolvers = append(t.macResolvers, t.dhcp)
@@ -189,14 +194,14 @@ func (t *Table) initSelfDiscover() {
func (t *Table) init() {
// Custom client ID presents, use it as the only source.
if _, clientID := controld.ParseRawUID(t.cdUID); clientID != "" {
ctrld.ProxyLogger.Load().Debug().Msg("start self discovery with custom client id")
t.logger.Debug().Msg("start self discovery with custom client id")
t.initSelfDiscover()
return
}
// If we are running on platforms that should only do self discover, use it as the only source, too.
if ctrld.SelfDiscover() {
ctrld.ProxyLogger.Load().Debug().Msg("start self discovery on desktop platforms")
t.logger.Debug().Msg("start self discovery on desktop platforms")
t.initSelfDiscover()
return
}
@@ -208,7 +213,7 @@ func (t *Table) init() {
// - Merlin
// - Ubios
if t.discoverDHCP() || t.discoverARP() {
t.merlin = &merlinDiscover{}
t.merlin = &merlinDiscover{logger: t.logger}
t.ubios = &ubiosDiscover{}
discovers := map[string]interface {
refresher
@@ -219,7 +224,7 @@ func (t *Table) init() {
}
for platform, discover := range discovers {
if err := discover.refresh(); err != nil {
ctrld.ProxyLogger.Load().Warn().Err(err).Msgf("failed to init %s discover", platform)
t.logger.Warn().Err(err).Msgf("failed to init %s discover", platform)
}
t.hostnameResolvers = append(t.hostnameResolvers, discover)
t.refreshers = append(t.refreshers, discover)
@@ -227,10 +232,10 @@ func (t *Table) init() {
}
// Hosts file mapping.
if t.discoverHosts() {
t.hf = &hostsFile{}
ctrld.ProxyLogger.Load().Debug().Msg("start hosts file discovery")
t.hf = &hostsFile{logger: t.logger}
t.logger.Debug().Msg("start hosts file discovery")
if err := t.hf.init(); err != nil {
ctrld.ProxyLogger.Load().Error().Err(err).Msg("could not init hosts file discover")
t.logger.Error().Err(err).Msg("could not init hosts file discover")
} else {
t.hostnameResolvers = append(t.hostnameResolvers, t.hf)
t.refreshers = append(t.refreshers, t.hf)
@@ -239,10 +244,10 @@ func (t *Table) init() {
}
// DHCP lease files.
if t.discoverDHCP() {
t.dhcp = &dhcp{selfIP: t.selfIP}
ctrld.ProxyLogger.Load().Debug().Msg("start dhcp discovery")
t.dhcp = &dhcp{selfIP: t.selfIP, logger: t.logger}
t.logger.Debug().Msg("start dhcp discovery")
if err := t.dhcp.init(); err != nil {
ctrld.ProxyLogger.Load().Error().Err(err).Msg("could not init DHCP discover")
t.logger.Error().Err(err).Msg("could not init DHCP discover")
} else {
t.ipResolvers = append(t.ipResolvers, t.dhcp)
t.macResolvers = append(t.macResolvers, t.dhcp)
@@ -253,8 +258,8 @@ func (t *Table) init() {
// ARP/NDP table.
if t.discoverARP() {
t.arp = &arpDiscover{}
t.ndp = &ndpDiscover{}
ctrld.ProxyLogger.Load().Debug().Msg("start arp discovery")
t.ndp = &ndpDiscover{logger: t.logger}
t.logger.Debug().Msg("start arp discovery")
discovers := map[string]interface {
refresher
IpResolver
@@ -266,7 +271,7 @@ func (t *Table) init() {
for protocol, discover := range discovers {
if err := discover.refresh(); err != nil {
ctrld.ProxyLogger.Load().Error().Err(err).Msgf("could not init %s discover", protocol)
t.logger.Error().Err(err).Msgf("could not init %s discover", protocol)
} else {
t.ipResolvers = append(t.ipResolvers, discover)
t.macResolvers = append(t.macResolvers, discover)
@@ -283,7 +288,10 @@ func (t *Table) init() {
}
// PTR lookup.
if t.discoverPTR() {
t.ptr = &ptrDiscover{resolver: ctrld.NewPrivateResolver()}
t.ptr = &ptrDiscover{
resolver: ctrld.NewPrivateResolver(context.Background()),
logger: t.logger,
}
if len(t.ptrNameservers) > 0 {
nss := make([]string, 0, len(t.ptrNameservers))
for _, ns := range t.ptrNameservers {
@@ -295,18 +303,18 @@ func (t *Table) init() {
if _, portErr := strconv.Atoi(port); portErr == nil && port != "0" && net.ParseIP(host) != nil {
nss = append(nss, net.JoinHostPort(host, port))
} else {
ctrld.ProxyLogger.Load().Warn().Msgf("ignoring invalid nameserver for ptr discover: %q", ns)
t.logger.Warn().Msgf("ignoring invalid nameserver for ptr discover: %q", ns)
}
}
if len(nss) > 0 {
t.ptr.resolver = ctrld.NewResolverWithNameserver(nss)
ctrld.ProxyLogger.Load().Debug().Msgf("using nameservers %v for ptr discovery", nss)
t.logger.Debug().Msgf("using nameservers %v for ptr discovery", nss)
}
}
ctrld.ProxyLogger.Load().Debug().Msg("start ptr discovery")
t.logger.Debug().Msg("start ptr discovery")
if err := t.ptr.refresh(); err != nil {
ctrld.ProxyLogger.Load().Error().Err(err).Msg("could not init PTR discover")
t.logger.Error().Err(err).Msg("could not init PTR discover")
} else {
t.hostnameResolvers = append(t.hostnameResolvers, t.ptr)
t.refreshers = append(t.refreshers, t.ptr)
@@ -314,10 +322,10 @@ func (t *Table) init() {
}
// mdns.
if t.discoverMDNS() {
t.mdns = &mdns{}
ctrld.ProxyLogger.Load().Debug().Msg("start mdns discovery")
t.mdns = &mdns{logger: t.logger}
t.logger.Debug().Msg("start mdns discovery")
if err := t.mdns.init(t.quitCh); err != nil {
ctrld.ProxyLogger.Load().Error().Err(err).Msg("could not init mDNS discover")
t.logger.Error().Err(err).Msg("could not init mDNS discover")
} else {
t.hostnameResolvers = append(t.hostnameResolvers, t.mdns)
}
internal/clientinfo/client_info_test.go
+5 -2
View File
@@ -2,6 +2,8 @@ package clientinfo
import (
"testing"
"github.com/Control-D-Inc/ctrld"
)
func Test_normalizeIP(t *testing.T) {
@@ -28,8 +30,9 @@ func Test_normalizeIP(t *testing.T) {
func TestTable_LookupRFC1918IPv4(t *testing.T) {
table := &Table{
dhcp: &dhcp{},
arp: &arpDiscover{},
dhcp: &dhcp{},
arp: &arpDiscover{},
logger: ctrld.NopLogger,
}
table.ipResolvers = append(table.ipResolvers, table.dhcp)
internal/clientinfo/dhcp.go
+10 -10
View File
@@ -13,9 +13,8 @@ import (
"strings"
"sync"
"tailscale.com/net/netmon"
"github.com/fsnotify/fsnotify"
"tailscale.com/net/netmon"
"tailscale.com/util/lineread"
"github.com/Control-D-Inc/ctrld"
@@ -30,6 +29,7 @@ type dhcp struct {
watcher *fsnotify.Watcher
selfIP string
logger *ctrld.Logger
}
func (d *dhcp) init() error {
@@ -52,7 +52,7 @@ func (d *dhcp) watchChanges() {
}
if dir := router.LeaseFilesDir(); dir != "" {
if err := d.watcher.Add(dir); err != nil {
ctrld.ProxyLogger.Load().Err(err).Str("dir", dir).Msg("could not watch lease dir")
d.logger.Err(err).Str("dir", dir).Msg("could not watch lease dir")
}
}
for {
@@ -64,7 +64,7 @@ func (d *dhcp) watchChanges() {
if event.Has(fsnotify.Create) {
if format, ok := clientInfoFiles[event.Name]; ok {
if err := d.addLeaseFile(event.Name, format); err != nil {
ctrld.ProxyLogger.Load().Err(err).Str("file", event.Name).Msg("could not add lease file")
d.logger.Err(err).Str("file", event.Name).Msg("could not add lease file")
}
}
continue
@@ -72,14 +72,14 @@ func (d *dhcp) watchChanges() {
if event.Has(fsnotify.Write) || event.Has(fsnotify.Rename) || event.Has(fsnotify.Chmod) || event.Has(fsnotify.Remove) {
format := clientInfoFiles[event.Name]
if err := d.readLeaseFile(event.Name, format); err != nil && !os.IsNotExist(err) {
ctrld.ProxyLogger.Load().Err(err).Str("file", event.Name).Msg("leases file changed but failed to update client info")
d.logger.Err(err).Str("file", event.Name).Msg("leases file changed but failed to update client info")
}
}
case err, ok := <-d.watcher.Errors:
if !ok {
return
}
ctrld.ProxyLogger.Load().Err(err).Msg("could not watch client info file")
d.logger.Err(err).Msg("could not watch client info file")
}
}
@@ -222,7 +222,7 @@ func (d *dhcp) dnsmasqReadClientInfoReader(reader io.Reader) error {
}
ip := normalizeIP(string(fields[2]))
if net.ParseIP(ip) == nil {
ctrld.ProxyLogger.Load().Warn().Msgf("invalid ip address entry: %q", ip)
d.logger.Warn().Msgf("invalid ip address entry: %q", ip)
ip = ""
}
@@ -275,7 +275,7 @@ func (d *dhcp) iscDHCPReadClientInfoReader(reader io.Reader) error {
case "lease":
ip = normalizeIP(strings.ToLower(fields[1]))
if net.ParseIP(ip) == nil {
ctrld.ProxyLogger.Load().Warn().Msgf("invalid ip address entry: %q", ip)
d.logger.Warn().Msgf("invalid ip address entry: %q", ip)
ip = ""
}
case "hardware":
@@ -328,7 +328,7 @@ func (d *dhcp) keaDhcp4ReadClientInfoReader(r io.Reader) error {
}
ip := normalizeIP(record[0])
if net.ParseIP(ip) == nil {
ctrld.ProxyLogger.Load().Warn().Msgf("invalid ip address entry: %q", ip)
d.logger.Warn().Msgf("invalid ip address entry: %q", ip)
ip = ""
}
@@ -350,7 +350,7 @@ func (d *dhcp) keaDhcp4ReadClientInfoReader(r io.Reader) error {
func (d *dhcp) addSelf() {
hostname, err := os.Hostname()
if err != nil {
ctrld.ProxyLogger.Load().Err(err).Msg("could not get hostname")
d.logger.Err(err).Msg("could not get hostname")
return
}
hostname = normalizeHostname(hostname)
internal/clientinfo/hostsfile.go
+4 -3
View File
@@ -27,6 +27,7 @@ type hostsFile struct {
watcher *fsnotify.Watcher
mu sync.Mutex
m map[string][]string
logger *ctrld.Logger
}
// init performs initialization works, which is necessary before hostsFile can be fully operated.
@@ -55,7 +56,7 @@ func (hf *hostsFile) refresh() error {
// override hosts file with host_entries.conf content if present.
hem, err := parseHostEntriesConf(hostEntriesConfPath)
if err != nil && !os.IsNotExist(err) {
ctrld.ProxyLogger.Load().Debug().Err(err).Msg("could not read host_entries.conf file")
hf.logger.Debug().Err(err).Msg("could not read host_entries.conf file")
}
for k, v := range hem {
hf.m[k] = v
@@ -77,14 +78,14 @@ func (hf *hostsFile) watchChanges() {
}
if event.Has(fsnotify.Write) || event.Has(fsnotify.Rename) || event.Has(fsnotify.Chmod) || event.Has(fsnotify.Remove) {
if err := hf.refresh(); err != nil && !os.IsNotExist(err) {
ctrld.ProxyLogger.Load().Err(err).Msg("hosts file changed but failed to update client info")
hf.logger.Err(err).Msg("hosts file changed but failed to update client info")
}
}
case err, ok := <-hf.watcher.Errors:
if !ok {
return
}
ctrld.ProxyLogger.Load().Err(err).Msg("could not watch client info file")
hf.logger.Err(err).Msg("could not watch client info file")
}
}
internal/clientinfo/mdns.go
+12 -11
View File
@@ -34,7 +34,8 @@ var (
)
type mdns struct {
name sync.Map // ip => hostname
name sync.Map // ip => hostname
logger *ctrld.Logger
}
func (m *mdns) LookupHostnameByIP(ip string) string {
@@ -93,9 +94,9 @@ func (m *mdns) init(quitCh chan struct{}) error {
}
// Check if IPv6 is available once and use the result for the rest of the function.
ctrld.ProxyLogger.Load().Debug().Msgf("checking for IPv6 availability in mdns init")
m.logger.Debug().Msgf("checking for IPv6 availability in mdns init")
ipv6 := ctrldnet.IPv6Available(context.Background())
ctrld.ProxyLogger.Load().Debug().Msgf("IPv6 is %v in mdns init", ipv6)
m.logger.Debug().Msgf("IPv6 is %v in mdns init", ipv6)
v4ConnList := make([]*net.UDPConn, 0, len(ifaces))
v6ConnList := make([]*net.UDPConn, 0, len(ifaces))
@@ -129,11 +130,11 @@ func (m *mdns) probeLoop(conns []*net.UDPConn, remoteAddr net.Addr, quitCh chan
for {
err := m.probe(conns, remoteAddr)
if shouldStopProbing(err) {
ctrld.ProxyLogger.Load().Warn().Msgf("stop probing %q: %v", remoteAddr, err)
m.logger.Warn().Msgf("stop probing %q: %v", remoteAddr, err)
break
}
if err != nil {
ctrld.ProxyLogger.Load().Warn().Err(err).Msg("error while probing mdns")
m.logger.Warn().Err(err).Msg("error while probing mdns")
bo.BackOff(context.Background(), errors.New("mdns probe backoff"))
continue
}
@@ -161,7 +162,7 @@ func (m *mdns) readLoop(conn *net.UDPConn) {
if errors.Is(err, net.ErrClosed) {
return
}
ctrld.ProxyLogger.Load().Debug().Err(err).Msg("mdns readLoop error")
m.logger.Debug().Err(err).Msg("mdns readLoop error")
return
}
@@ -184,11 +185,11 @@ func (m *mdns) readLoop(conn *net.UDPConn) {
if ip != "" && name != "" {
name = normalizeHostname(name)
if val, loaded := m.name.LoadOrStore(ip, name); !loaded {
ctrld.ProxyLogger.Load().Debug().Msgf("found hostname: %q, ip: %q via mdns", name, ip)
m.logger.Debug().Msgf("found hostname: %q, ip: %q via mdns", name, ip)
} else {
old := val.(string)
if old != name {
ctrld.ProxyLogger.Load().Debug().Msgf("update hostname: %q, ip: %q, old: %q via mdns", name, ip, old)
m.logger.Debug().Msgf("update hostname: %q, ip: %q, old: %q via mdns", name, ip, old)
m.name.Store(ip, name)
}
}
@@ -227,7 +228,7 @@ func (m *mdns) probe(conns []*net.UDPConn, remoteAddr net.Addr) error {
// getDataFromAvahiDaemonCache reads entries from avahi-daemon cache to update mdns data.
func (m *mdns) getDataFromAvahiDaemonCache() {
if _, err := exec.LookPath("avahi-browse"); err != nil {
ctrld.ProxyLogger.Load().Debug().Err(err).Msg("could not find avahi-browse binary, skipping.")
m.logger.Debug().Err(err).Msg("could not find avahi-browse binary, skipping.")
return
}
// Run avahi-browse to discover services from cache:
@@ -237,7 +238,7 @@ func (m *mdns) getDataFromAvahiDaemonCache() {
// - "-c" -> read from cache.
out, err := exec.Command("avahi-browse", "-a", "-r", "-p", "-c").Output()
if err != nil {
ctrld.ProxyLogger.Load().Debug().Err(err).Msg("could not browse services from avahi cache")
m.logger.Debug().Err(err).Msg("could not browse services from avahi cache")
return
}
m.storeDataFromAvahiBrowseOutput(bytes.NewReader(out))
@@ -257,7 +258,7 @@ func (m *mdns) storeDataFromAvahiBrowseOutput(r io.Reader) {
name := normalizeHostname(fields[6])
// Only using cache value if we don't have existed one.
if _, loaded := m.name.LoadOrStore(ip, name); !loaded {
ctrld.ProxyLogger.Load().Debug().Msgf("found hostname: %q, ip: %q via avahi cache", name, ip)
m.logger.Debug().Msgf("found hostname: %q, ip: %q via avahi cache", name, ip)
}
}
}
internal/clientinfo/mdns_test.go
+3 -1
View File
@@ -3,6 +3,8 @@ package clientinfo
import (
"strings"
"testing"
"github.com/Control-D-Inc/ctrld"
)
func Test_mdns_storeDataFromAvahiBrowseOutput(t *testing.T) {
@@ -11,7 +13,7 @@ func Test_mdns_storeDataFromAvahiBrowseOutput(t *testing.T) {
=;wlp0s20f3;IPv6;Foo\032\0402\041;_companion-link._tcp;local;Foo-2.local;192.168.1.123;64842;"rpBA=00:00:00:00:00:01" "rpHI=e6ae2cbbca0e" "rpAD=36566f4d850f" "rpVr=510.71.1" "rpHA=0ddc20fdddc8" "rpFl=0x30000" "rpHN=1d4a03afdefa" "rpMac=0"
=;wlp0s20f3;IPv4;Foo\032\0402\041;_companion-link._tcp;local;Foo-2.local;192.168.1.123;64842;"rpBA=00:00:00:00:00:01" "rpHI=e6ae2cbbca0e" "rpAD=36566f4d850f" "rpVr=510.71.1" "rpHA=0ddc20fdddc8" "rpFl=0x30000" "rpHN=1d4a03afdefa" "rpMac=0"
`
m := &mdns{}
m := &mdns{logger: ctrld.NopLogger}
m.storeDataFromAvahiBrowseOutput(strings.NewReader(content))
ip := "192.168.1.123"
val, loaded := m.name.LoadOrStore(ip, "")
internal/clientinfo/merlin.go
+2 -1
View File
@@ -15,6 +15,7 @@ const merlinNvramCustomClientListKey = "custom_clientlist"
type merlinDiscover struct {
hostname sync.Map // mac => hostname
logger *ctrld.Logger
}
func (m *merlinDiscover) refresh() error {
@@ -25,7 +26,7 @@ func (m *merlinDiscover) refresh() error {
if err != nil {
return err
}
ctrld.ProxyLogger.Load().Debug().Msg("reading Merlin custom client list")
m.logger.Debug().Msg("reading Merlin custom client list")
m.parseMerlinCustomClientList(out)
return nil
}
internal/clientinfo/ndp.go
+7 -6
View File
@@ -20,8 +20,9 @@ import (
// ndpDiscover provides client discovery functionality using NDP protocol.
type ndpDiscover struct {
mac sync.Map // ip => mac
ip sync.Map // mac => ip
mac sync.Map // ip => mac
ip sync.Map // mac => ip
logger *ctrld.Logger
}
// refresh re-scans the NDP table.
@@ -97,7 +98,7 @@ func (nd *ndpDiscover) saveInfo(ip, mac string) {
func (nd *ndpDiscover) listen(ctx context.Context) {
ifis, err := allInterfacesWithV6LinkLocal()
if err != nil {
ctrld.ProxyLogger.Load().Debug().Err(err).Msg("failed to find valid ipv6 interfaces")
nd.logger.Debug().Err(err).Msg("failed to find valid ipv6 interfaces")
return
}
for _, ifi := range ifis {
@@ -110,11 +111,11 @@ func (nd *ndpDiscover) listen(ctx context.Context) {
func (nd *ndpDiscover) listenOnInterface(ctx context.Context, ifi *net.Interface) {
c, ip, err := ndp.Listen(ifi, ndp.Unspecified)
if err != nil {
ctrld.ProxyLogger.Load().Debug().Err(err).Msg("ndp listen failed")
nd.logger.Debug().Err(err).Msg("ndp listen failed")
return
}
defer c.Close()
ctrld.ProxyLogger.Load().Debug().Msgf("listening ndp on: %s", ip.String())
nd.logger.Debug().Msgf("listening ndp on: %s", ip.String())
for {
select {
case <-ctx.Done():
@@ -128,7 +129,7 @@ func (nd *ndpDiscover) listenOnInterface(ctx context.Context, ifi *net.Interface
if errors.As(readErr, &opErr) && (opErr.Timeout() || opErr.Temporary()) {
continue
}
ctrld.ProxyLogger.Load().Debug().Err(readErr).Msg("ndp read loop error")
nd.logger.Debug().Err(readErr).Msg("ndp read loop error")
return
}
internal/clientinfo/ndp_linux.go
+4 -6
View File
@@ -5,15 +5,13 @@ import (
"github.com/vishvananda/netlink"
"golang.org/x/sys/unix"
"github.com/Control-D-Inc/ctrld"
)
// scan populates NDP table using information from system mappings.
func (nd *ndpDiscover) scan() {
neighs, err := netlink.NeighList(0, netlink.FAMILY_V6)
if err != nil {
ctrld.ProxyLogger.Load().Warn().Err(err).Msg("could not get neigh list")
nd.logger.Warn().Err(err).Msg("could not get neigh list")
return
}
@@ -34,7 +32,7 @@ func (nd *ndpDiscover) subscribe(ctx context.Context) {
done := make(chan struct{})
defer close(done)
if err := netlink.NeighSubscribe(ch, done); err != nil {
ctrld.ProxyLogger.Load().Err(err).Msg("could not perform neighbor subscribing")
nd.logger.Err(err).Msg("could not perform neighbor subscribing")
return
}
for {
@@ -47,7 +45,7 @@ func (nd *ndpDiscover) subscribe(ctx context.Context) {
}
ip := normalizeIP(nu.IP.String())
if nu.Type == unix.RTM_DELNEIGH {
ctrld.ProxyLogger.Load().Debug().Msgf("removing NDP neighbor: %s", ip)
nd.logger.Debug().Msgf("removing NDP neighbor: %s", ip)
nd.mac.Delete(ip)
continue
}
@@ -56,7 +54,7 @@ func (nd *ndpDiscover) subscribe(ctx context.Context) {
case netlink.NUD_REACHABLE:
nd.saveInfo(ip, mac)
case netlink.NUD_FAILED:
ctrld.ProxyLogger.Load().Debug().Msgf("removing NDP neighbor with failed state: %s", ip)
nd.logger.Debug().Msgf("removing NDP neighbor with failed state: %s", ip)
nd.mac.Delete(ip)
}
}
internal/clientinfo/ndp_others.go
+2 -4
View File
@@ -7,8 +7,6 @@ import (
"context"
"os/exec"
"runtime"
"github.com/Control-D-Inc/ctrld"
)
// scan populates NDP table using information from system mappings.
@@ -17,14 +15,14 @@ func (nd *ndpDiscover) scan() {
case "windows":
data, err := exec.Command("netsh", "interface", "ipv6", "show", "neighbors").Output()
if err != nil {
ctrld.ProxyLogger.Load().Warn().Err(err).Msg("could not query ndp table")
nd.logger.Warn().Err(err).Msg("could not query ndp table")
return
}
nd.scanWindows(bytes.NewReader(data))
default:
data, err := exec.Command("ndp", "-an").Output()
if err != nil {
ctrld.ProxyLogger.Load().Warn().Err(err).Msg("could not query ndp table")
nd.logger.Warn().Err(err).Msg("could not query ndp table")
return
}
nd.scanUnix(bytes.NewReader(data))
internal/clientinfo/ptr_lookup.go
+3 -2
View File
@@ -17,6 +17,7 @@ type ptrDiscover struct {
hostname sync.Map // ip => hostname
resolver ctrld.Resolver
serverDown atomic.Bool
logger *ctrld.Logger
}
func (p *ptrDiscover) refresh() error {
@@ -73,14 +74,14 @@ func (p *ptrDiscover) lookupHostname(ip string) string {
msg := new(dns.Msg)
addr, err := dns.ReverseAddr(ip)
if err != nil {
ctrld.ProxyLogger.Load().Info().Str("discovery", "ptr").Err(err).Msg("invalid ip address")
p.logger.Info().Str("discovery", "ptr").Err(err).Msg("invalid ip address")
return ""
}
msg.SetQuestion(addr, dns.TypePTR)
ans, err := p.resolver.Resolve(ctx, msg)
if err != nil {
if p.serverDown.CompareAndSwap(false, true) {
ctrld.ProxyLogger.Load().Info().Str("discovery", "ptr").Err(err).Msg("could not perform PTR lookup")
p.logger.Info().Str("discovery", "ptr").Err(err).Msg("could not perform PTR lookup")
go p.checkServer()
}
return ""
internal/controld/config.go
+21 -18
View File
@@ -88,18 +88,18 @@ type LogsRequest struct {
}
// FetchResolverConfig fetch Control D config for given uid.
func FetchResolverConfig(rawUID, version string, cdDev bool) (*ResolverConfig, error) {
func FetchResolverConfig(ctx context.Context, rawUID, version string, cdDev bool) (*ResolverConfig, error) {
uid, clientID := ParseRawUID(rawUID)
req := utilityRequest{UID: uid}
if clientID != "" {
req.ClientID = clientID
}
body, _ := json.Marshal(req)
return postUtilityAPI(version, cdDev, false, bytes.NewReader(body))
return postUtilityAPI(ctx, version, cdDev, false, bytes.NewReader(body))
}
// FetchResolverUID fetch resolver uid from provision token.
func FetchResolverUID(req *UtilityOrgRequest, version string, cdDev bool) (*ResolverConfig, error) {
func FetchResolverUID(ctx context.Context, req *UtilityOrgRequest, version string, cdDev bool) (*ResolverConfig, error) {
if req == nil {
return nil, errors.New("invalid request")
}
@@ -108,21 +108,21 @@ func FetchResolverUID(req *UtilityOrgRequest, version string, cdDev bool) (*Reso
hostname, _ = os.Hostname()
}
body, _ := json.Marshal(UtilityOrgRequest{ProvToken: req.ProvToken, Hostname: hostname})
return postUtilityAPI(version, cdDev, false, bytes.NewReader(body))
return postUtilityAPI(ctx, version, cdDev, false, bytes.NewReader(body))
}
// UpdateCustomLastFailed calls API to mark custom config is bad.
func UpdateCustomLastFailed(rawUID, version string, cdDev, lastUpdatedFailed bool) (*ResolverConfig, error) {
func UpdateCustomLastFailed(ctx context.Context, rawUID, version string, cdDev, lastUpdatedFailed bool) (*ResolverConfig, error) {
uid, clientID := ParseRawUID(rawUID)
req := utilityRequest{UID: uid}
if clientID != "" {
req.ClientID = clientID
}
body, _ := json.Marshal(req)
return postUtilityAPI(version, cdDev, true, bytes.NewReader(body))
return postUtilityAPI(ctx, version, cdDev, true, bytes.NewReader(body))
}
func postUtilityAPI(version string, cdDev, lastUpdatedFailed bool, body io.Reader) (*ResolverConfig, error) {
func postUtilityAPI(ctx context.Context, version string, cdDev, lastUpdatedFailed bool, body io.Reader) (*ResolverConfig, error) {
apiUrl := resolverDataURLCom
if cdDev {
apiUrl = resolverDataURLDev
@@ -139,12 +139,12 @@ func postUtilityAPI(version string, cdDev, lastUpdatedFailed bool, body io.Reade
}
req.URL.RawQuery = q.Encode()
req.Header.Add("Content-Type", "application/json")
transport := apiTransport(cdDev)
transport := apiTransport(ctx, cdDev)
client := &http.Client{
Timeout: defaultTimeout,
Transport: transport,
}
resp, err := doWithFallback(client, req, apiServerIP(cdDev))
resp, err := doWithFallback(ctx, client, req, apiServerIP(cdDev))
if err != nil {
return nil, fmt.Errorf("postUtilityAPI client.Do: %w", err)
}
@@ -166,7 +166,7 @@ func postUtilityAPI(version string, cdDev, lastUpdatedFailed bool, body io.Reade
}
// SendLogs sends runtime log to ControlD API.
func SendLogs(lr *LogsRequest, cdDev bool) error {
func SendLogs(ctx context.Context, lr *LogsRequest, cdDev bool) error {
defer lr.Data.Close()
apiUrl := logURLCom
if cdDev {
@@ -180,12 +180,12 @@ func SendLogs(lr *LogsRequest, cdDev bool) error {
q.Set("uid", lr.UID)
req.URL.RawQuery = q.Encode()
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
transport := apiTransport(cdDev)
transport := apiTransport(ctx, cdDev)
client := &http.Client{
Timeout: sendLogTimeout,
Transport: transport,
}
resp, err := doWithFallback(client, req, apiServerIP(cdDev))
resp, err := doWithFallback(ctx, client, req, apiServerIP(cdDev))
if err != nil {
return fmt.Errorf("SendLogs client.Do: %w", err)
}
@@ -213,7 +213,7 @@ func ParseRawUID(rawUID string) (string, string) {
}
// apiTransport returns an HTTP transport for connecting to ControlD API endpoint.
func apiTransport(cdDev bool) *http.Transport {
func apiTransport(loggerCtx context.Context, cdDev bool) *http.Transport {
transport := http.DefaultTransport.(*http.Transport).Clone()
transport.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
apiDomain := apiDomainCom
@@ -227,9 +227,10 @@ func apiTransport(cdDev bool) *http.Transport {
apiIPs = []string{apiDomainDevIPv4}
}
ips := ctrld.LookupIP(apiDomain)
ips := ctrld.LookupIP(loggerCtx, apiDomain)
if len(ips) == 0 {
ctrld.ProxyLogger.Load().Warn().Msgf("No IPs found for %s, use direct IPs: %v", apiDomain, apiIPs)
logger := ctrld.LoggerFromCtx(loggerCtx)
logger.Warn().Msgf("No IPs found for %s, use direct IPs: %v", apiDomain, apiIPs)
ips = apiIPs
}
@@ -245,7 +246,8 @@ func apiTransport(cdDev bool) *http.Transport {
dial := func(ctx context.Context, network string, addrs []string) (net.Conn, error) {
d := &ctrldnet.ParallelDialer{}
return d.DialContext(ctx, network, addrs, ctrld.ProxyLogger.Load())
logger := ctrld.LoggerFromCtx(loggerCtx)
return d.DialContext(ctx, network, addrs, logger.Logger)
}
_, port, _ := net.SplitHostPort(addr)
@@ -283,10 +285,11 @@ func addrsFromPort(ips []string, port string) []string {
return addrs
}
func doWithFallback(client *http.Client, req *http.Request, apiIp string) (*http.Response, error) {
func doWithFallback(ctx context.Context, client *http.Client, req *http.Request, apiIp string) (*http.Response, error) {
resp, err := client.Do(req)
if err != nil {
ctrld.ProxyLogger.Load().Warn().Err(err).Msgf("failed to send request, fallback to direct IP: %s", apiIp)
logger := ctrld.LoggerFromCtx(ctx)
logger.Warn().Err(err).Msgf("failed to send request, fallback to direct IP: %s", apiIp)
ipReq := req.Clone(req.Context())
ipReq.Host = apiIp
ipReq.URL.Host = apiIp