talm

1
// This Source Code Form is subject to the terms of the Mozilla Public
2
// License, v. 2.0. If a copy of the MPL was not distributed with this
3
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
4

5
package director
6

7
import (
8
	"context"
9
	"sync"
10

11
	"github.com/cosi-project/runtime/pkg/resource"
12
	"github.com/cosi-project/runtime/pkg/state"
13

14
	"github.com/siderolabs/talos/pkg/machinery/resources/network"
15
)
16

17
// LocalAddressProvider provides local address information.
18
type LocalAddressProvider interface {
19
	IsLocalTarget(string) bool
20
}
21

22
// localAddressProvider watches and keeps track of the local node addresses.
23
type localAddressProvider struct {
24
	mu sync.Mutex
25

26
	localAddresses map[string]struct{}
27
	localHostnames map[string]struct{}
28
}
29

30
// NewLocalAddressProvider initializes and returns a new LocalAddressProvider.
31
func NewLocalAddressProvider(st state.State) (LocalAddressProvider, error) {
32
	p := &localAddressProvider{}
33

34
	evCh := make(chan state.Event)
35

36
	if err := st.Watch(context.Background(), resource.NewMetadata(network.NamespaceName, network.NodeAddressType, network.NodeAddressCurrentID, resource.VersionUndefined), evCh); err != nil {
37
		return nil, err
38
	}
39

40
	if err := st.Watch(context.Background(), resource.NewMetadata(network.NamespaceName, network.HostnameStatusType, network.HostnameID, resource.VersionUndefined), evCh); err != nil {
41
		return nil, err
42
	}
43

44
	go p.watch(evCh)
45

46
	return p, nil
47
}
48

49
func (p *localAddressProvider) watch(evCh <-chan state.Event) {
50
	for ev := range evCh {
51
		switch ev.Type {
52
		case state.Created, state.Updated:
53
			// expected
54
		case state.Destroyed, state.Bootstrapped, state.Errored:
55
			// shouldn't happen, ignore
56
			continue
57
		}
58

59
		switch r := ev.Resource.(type) {
60
		case *network.NodeAddress:
61
			p.mu.Lock()
62

63
			p.localAddresses = make(map[string]struct{}, len(r.TypedSpec().Addresses))
64

65
			for _, addr := range r.TypedSpec().Addresses {
66
				p.localAddresses[addr.Addr().String()] = struct{}{}
67
			}
68

69
			p.mu.Unlock()
70
		case *network.HostnameStatus:
71
			p.mu.Lock()
72

73
			p.localHostnames = make(map[string]struct{}, 2)
74

75
			p.localHostnames[r.TypedSpec().Hostname] = struct{}{}
76
			p.localHostnames[r.TypedSpec().FQDN()] = struct{}{}
77

78
			p.mu.Unlock()
79
		}
80
	}
81
}
82

83
// IsLocalTarget returns true if the address (hostname) is local.
84
func (p *localAddressProvider) IsLocalTarget(target string) bool {
85
	p.mu.Lock()
86
	defer p.mu.Unlock()
87

88
	_, ok1 := p.localAddresses[target]
89
	_, ok2 := p.localHostnames[target]
90

91
	return ok1 || ok2
92
}
93