File size: 2,091 Bytes
b110593
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
//                           _       _
// __      _____  __ ___   ___  __ _| |_ ___
// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
//
//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
//
//  CONTACT: [email protected]
//

package cluster

import (
	"fmt"
	"sort"
	"strings"
	"sync"
	"time"
)

type IdealClusterState struct {
	memberNames  []string
	currentState MemberLister
	lock         sync.Mutex
}

func NewIdealClusterState(s MemberLister) *IdealClusterState {
	ics := &IdealClusterState{currentState: s}
	go ics.startPolling()
	return ics
}

// Validate returns an error if the actual state does not match the assumed
// ideal state, e.g. because a node has died, or left unexpectedly.
func (ics *IdealClusterState) Validate() error {
	ics.lock.Lock()
	defer ics.lock.Unlock()

	actual := map[string]struct{}{}
	for _, name := range ics.currentState.AllNames() {
		actual[name] = struct{}{}
	}

	var missing []string
	for _, name := range ics.memberNames {
		if _, ok := actual[name]; !ok {
			missing = append(missing, name)
		}
	}

	if len(missing) > 0 {
		return fmt.Errorf("node(s) %s unhealthy or unavailable",
			strings.Join(missing, ", "))
	}

	return nil
}

func (ics *IdealClusterState) Members() []string {
	ics.lock.Lock()
	defer ics.lock.Unlock()

	return ics.memberNames
}

func (ics *IdealClusterState) startPolling() {
	t := time.NewTicker(1 * time.Second)
	for {
		<-t.C
		current := ics.currentState.AllNames()
		ics.extendList(current)
	}
}

func (ics *IdealClusterState) extendList(current []string) {
	ics.lock.Lock()
	defer ics.lock.Unlock()

	var unknown []string
	known := map[string]struct{}{}
	for _, name := range ics.memberNames {
		known[name] = struct{}{}
	}

	for _, name := range current {
		if _, ok := known[name]; !ok {
			unknown = append(unknown, name)
		}
	}

	ics.memberNames = append(ics.memberNames, unknown...)
	sort.Strings(ics.memberNames)
}