forked from coreos/fleet
-
Notifications
You must be signed in to change notification settings - Fork 0
/
event.go
100 lines (78 loc) · 2.8 KB
/
event.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
97
98
99
100
package agent
import (
log "github.com/coreos/fleet/third_party/github.com/golang/glog"
"github.com/coreos/fleet/event"
"github.com/coreos/fleet/job"
"github.com/coreos/fleet/unit"
)
type EventHandler struct {
agent *Agent
}
func NewEventHandler(agent *Agent) *EventHandler {
return &EventHandler{agent}
}
func (eh *EventHandler) HandleEventJobOffered(ev event.Event) {
jo := ev.Payload.(job.JobOffer)
if !jo.OfferedTo(eh.agent.Machine.State().ID) {
log.V(1).Infof("EventJobOffered(%s): not offered to this machine, ignoring", jo.Job.Name)
return
}
log.Infof("EventJobOffered(%s): deciding whether to bid or not", jo.Job.Name)
eh.agent.MaybeBid(jo)
}
func (eh *EventHandler) HandleEventJobScheduled(ev event.Event) {
jobName := ev.Payload.(string)
target := ev.Context.(string)
if target != eh.agent.Machine.State().ID {
log.Infof("EventJobScheduled(%s): Job scheduled to other Machine(%s), informing Agent", jobName, target)
eh.agent.JobScheduledElsewhere(jobName)
} else {
log.Infof("EventJobScheduled(%s): Job scheduled here, informing Agent", jobName)
eh.agent.JobScheduledLocally(jobName)
}
}
func (eh *EventHandler) HandleCommandStartJob(ev event.Event) {
jobName := ev.Payload.(string)
target := ev.Context.(string)
if target != eh.agent.Machine.State().ID {
log.V(1).Infof("CommandStartJob(%s): scheduled elsewhere, ignoring", jobName)
return
}
log.Infof("CommandStartJob(%s): instructing Agent to start Job", jobName)
eh.agent.StartJob(jobName)
}
func (eh *EventHandler) HandleCommandStopJob(ev event.Event) {
jobName := ev.Payload.(string)
target := ev.Context.(string)
if target != eh.agent.Machine.State().ID {
log.V(1).Infof("CommandStopJob(%s): scheduled elsewhere, ignoring", jobName)
return
}
log.Infof("CommandStopJob(%s): instructing Agent to stop Job", jobName)
eh.agent.StopJob(jobName)
}
func (eh *EventHandler) HandleEventJobUnscheduled(ev event.Event) {
eh.unloadJobEvent(ev)
}
func (eh *EventHandler) HandleEventJobDestroyed(ev event.Event) {
eh.unloadJobEvent(ev)
}
// unloadJobEvent handles an event by unloading the job to which it
// refers. The event's payload must be a string representing the
// name of a Job. If the Job is not scheduled locally, it will be
// ignored.
func (eh *EventHandler) unloadJobEvent(ev event.Event) {
jobName := ev.Payload.(string)
log.Infof("%s(%s): Job(%s) unscheduled, deciding what to do", ev.Type, jobName, jobName)
eh.agent.JobUnscheduled(jobName)
}
func (eh *EventHandler) HandleEventUnitStateUpdated(ev event.Event) {
jobName := ev.Context.(string)
state := ev.Payload.(*unit.UnitState)
if state == nil {
log.V(1).Infof("EventUnitStateUpdated(%s): received nil UnitState object, ignoring", jobName)
return
}
log.Infof("EventUnitStateUpdated(%s): reporting state to Registry")
eh.agent.ReportUnitState(jobName, state)
}