forked from coreos/fleet
-
Notifications
You must be signed in to change notification settings - Fork 1
/
state.go
96 lines (81 loc) · 2.47 KB
/
state.go
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
96
package agent
import (
"fmt"
"path"
"github.com/coreos/fleet/job"
"github.com/coreos/fleet/log"
"github.com/coreos/fleet/machine"
)
type AgentState struct {
MState *machine.MachineState
Units map[string]*job.Unit
}
func NewAgentState(ms *machine.MachineState) *AgentState {
return &AgentState{
MState: ms,
Units: make(map[string]*job.Unit),
}
}
func (as *AgentState) unitScheduled(name string) bool {
return as.Units[name] != nil
}
// hasConflict determines whether there are any known conflicts with the given Unit
func (as *AgentState) hasConflict(pUnitName string, pConflicts []string) (found bool, conflict string) {
for _, eUnit := range as.Units {
if pUnitName == eUnit.Name {
continue
}
for _, pConflict := range pConflicts {
if globMatches(pConflict, eUnit.Name) {
found = true
conflict = eUnit.Name
return
}
}
for _, eConflict := range eUnit.Conflicts() {
if globMatches(eConflict, pUnitName) {
found = true
conflict = eUnit.Name
return
}
}
}
return
}
func globMatches(pattern, target string) bool {
matched, err := path.Match(pattern, target)
if err != nil {
log.V(1).Infof("Received error while matching pattern '%s': %v", pattern, err)
}
return matched
}
// AbleToRun determines if an Agent can run the provided Job based on
// the Agent's current state. A boolean indicating whether this is the
// case or not is returned. The following criteria is used:
// - Agent must meet the Job's machine target requirement (if any)
// - Agent must have all of the Job's required metadata (if any)
// - Agent must have all required Peers of the Job scheduled locally (if any)
// - Job must not conflict with any other Units scheduled to the agent
func (as *AgentState) AbleToRun(j *job.Job) (bool, string) {
if tgt, ok := j.RequiredTarget(); ok && !as.MState.MatchID(tgt) {
return false, fmt.Sprintf("agent ID %q does not match required %q", as.MState.ID, tgt)
}
metadata := j.RequiredTargetMetadata()
if len(metadata) != 0 {
if !machine.HasMetadata(as.MState, metadata) {
return false, "local Machine metadata insufficient"
}
}
peers := j.Peers()
if len(peers) != 0 {
for _, peer := range peers {
if !as.unitScheduled(peer) {
return false, fmt.Sprintf("required peer Unit(%s) is not scheduled locally", peer)
}
}
}
if cExists, cJobName := as.hasConflict(j.Name, j.Conflicts()); cExists {
return false, fmt.Sprintf("found conflict with locally-scheduled Unit(%s)", cJobName)
}
return true, ""
}