forked from coreos/fleet
-
Notifications
You must be signed in to change notification settings - Fork 1
/
engine.go
127 lines (96 loc) · 3.15 KB
/
engine.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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package engine
import (
"errors"
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/machine"
"github.com/coreos/fleet/registry"
)
type Engine struct {
registry *registry.Registry
events *event.EventBus
machine *machine.Machine
stop chan bool
}
func New(reg *registry.Registry, events *event.EventBus, mach *machine.Machine) *Engine {
return &Engine{reg, events, mach, nil}
}
func (self *Engine) Run() {
self.stop = make(chan bool)
handler := NewEventHandler(self)
self.events.AddListener("engine", self.machine, handler)
// Block until we receive a stop signal
<-self.stop
self.events.RemoveListener("engine", self.machine)
}
func (self *Engine) Stop() {
log.V(1).Info("Stopping Engine")
close(self.stop)
}
func (self *Engine) GetJobsScheduledToMachine(machBootId string) []job.Job {
var jobs []job.Job
for _, j := range self.registry.GetAllJobs() {
tgt := self.registry.GetJobTarget(j.Name)
if tgt == nil || tgt.BootId != machBootId {
continue
}
jobs = append(jobs, j)
}
return jobs
}
func (self *Engine) UnscheduleJob(jobName string) {
self.registry.UnscheduleJob(jobName)
log.Infof("Unscheduled Job(%s)", jobName)
}
func (self *Engine) OfferJob(j job.Job) error {
log.V(2).Infof("Attempting to lock Job(%s)", j.Name)
mutex := self.lockJob(j.Name)
if mutex == nil {
log.V(1).Infof("Could not lock Job(%s)", j.Name)
return errors.New("Could not lock Job")
}
defer mutex.Unlock()
log.V(1).Infof("Claimed Job", j.Name)
offer := job.NewOfferFromJob(j)
log.V(2).Infof("Publishing JobOffer(%s)", offer.Job.Name)
self.registry.CreateJobOffer(offer)
log.Infof("Published JobOffer(%s)", offer.Job.Name)
return nil
}
func (self *Engine) ResolveJobOffer(jobName string, machBootId string) error {
log.V(2).Infof("Attempting to lock JobOffer(%s)", jobName)
mutex := self.lockJobOffer(jobName)
if mutex == nil {
log.V(2).Infof("Could not lock JobOffer(%s)", jobName)
return errors.New("Could not lock JobOffer")
}
defer mutex.Unlock()
log.V(2).Infof("Claimed JobOffer(%s)", jobName)
log.V(2).Infof("Resolving JobOffer(%s), scheduling to Machine(%s)", jobName, machBootId)
err := self.registry.ResolveJobOffer(jobName)
if err != nil {
log.Errorf("Failed resolving JobOffer(%s): %v", jobName, err)
return err
}
err = self.registry.ScheduleJob(jobName, machBootId)
if err != nil {
log.Errorf("Failed scheduling Job(%s): %v", jobName, err)
return err
}
log.Infof("Scheduled Job(%s) to Machine(%s)", jobName, machBootId)
return nil
}
func (self *Engine) RemoveJobState(jobName string) {
self.registry.RemoveJobState(jobName)
}
func (self *Engine) lockJobOffer(jobName string) *registry.TimedResourceMutex {
return self.registry.LockJobOffer(jobName, self.machine.State().BootId)
}
func (self *Engine) lockJob(jobName string) *registry.TimedResourceMutex {
return self.registry.LockJob(jobName, self.machine.State().BootId)
}
// Pass-through to Registry.LockMachine
func (self *Engine) LockMachine(machBootId string) *registry.TimedResourceMutex {
return self.registry.LockMachine(machBootId, self.machine.State().BootId)
}