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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
// Copyright 2014 Canonical Ltd.
// Copyright 2014 Cloudbase Solutions SRL
// Licensed under the AGPLv3, see LICENCE file for details.
package state
import (
"fmt"
"github.com/juju/errors"
"gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
"gopkg.in/mgo.v2/txn"
)
var _ RebootFlagSetter = (*Machine)(nil)
var _ RebootActionGetter = (*Machine)(nil)
// RebootAction defines the action a machine should
// take when a hook needs to reboot
type RebootAction string
const (
// ShouldDoNothing instructs a machine agent that no action
// is required on its part
ShouldDoNothing RebootAction = "noop"
// ShouldReboot instructs a machine to reboot
// this happens when a hook running on a machine, requests
// a reboot
ShouldReboot RebootAction = "reboot"
// ShouldShutdown instructs a machine to shut down. This usually
// happens when running inside a container, and a hook on the parent
// machine requests a reboot
ShouldShutdown RebootAction = "shutdown"
)
// rebootDoc will hold the reboot flag for a machine.
type rebootDoc struct {
DocID string `bson:"_id"`
Id string `bson:"machineid"`
ModelUUID string `bson:"model-uuid"`
}
func (m *Machine) setFlag() error {
if m.Life() == Dead {
return mgo.ErrNotFound
}
ops := []txn.Op{
assertModelActiveOp(m.st.ModelUUID()),
{
C: machinesC,
Id: m.doc.DocID,
Assert: notDeadDoc,
}, {
C: rebootC,
Id: m.doc.DocID,
Insert: &rebootDoc{Id: m.Id()},
},
}
err := m.st.runTransaction(ops)
if err == txn.ErrAborted {
if err := checkModelActive(m.st); err != nil {
return errors.Trace(err)
}
return mgo.ErrNotFound
} else if err != nil {
return errors.Errorf("failed to set reboot flag: %v", err)
}
return nil
}
func removeRebootDocOp(st *State, machineId string) txn.Op {
op := txn.Op{
C: rebootC,
Id: st.docID(machineId),
Remove: true,
}
return op
}
func (m *Machine) clearFlag() error {
reboot, closer := m.st.getCollection(rebootC)
defer closer()
docID := m.doc.DocID
count, err := reboot.FindId(docID).Count()
if count == 0 {
return nil
}
ops := []txn.Op{removeRebootDocOp(m.st, m.Id())}
err = m.st.runTransaction(ops)
if err != nil {
return errors.Errorf("failed to clear reboot flag: %v", err)
}
return nil
}
// SetRebootFlag sets the reboot flag of a machine to a boolean value. It will also
// do a lazy create of a reboot document if needed; i.e. If a document
// does not exist yet for this machine, it will create it.
func (m *Machine) SetRebootFlag(flag bool) error {
if flag {
return m.setFlag()
}
return m.clearFlag()
}
// GetRebootFlag returns the reboot flag for this machine.
func (m *Machine) GetRebootFlag() (bool, error) {
rebootCol, closer := m.st.getCollection(rebootC)
defer closer()
count, err := rebootCol.FindId(m.doc.DocID).Count()
if err != nil {
return false, fmt.Errorf("failed to get reboot flag: %v", err)
}
if count == 0 {
return false, nil
}
return true, nil
}
func (m *Machine) machinesToCareAboutRebootsFor() []string {
var possibleIds []string
for currentId := m.Id(); currentId != ""; {
possibleIds = append(possibleIds, currentId)
currentId = ParentId(currentId)
}
return possibleIds
}
// ShouldRebootOrShutdown check if the current node should reboot or shutdown
// If we are a container, and our parent needs to reboot, this should return:
// ShouldShutdown
func (m *Machine) ShouldRebootOrShutdown() (RebootAction, error) {
rebootCol, closer := m.st.getCollection(rebootC)
defer closer()
machines := m.machinesToCareAboutRebootsFor()
docs := []rebootDoc{}
sel := bson.D{{"machineid", bson.D{{"$in", machines}}}}
if err := rebootCol.Find(sel).All(&docs); err != nil {
return ShouldDoNothing, errors.Trace(err)
}
iNeedReboot := false
for _, val := range docs {
if val.Id != m.doc.Id {
return ShouldShutdown, nil
}
iNeedReboot = true
}
if iNeedReboot {
return ShouldReboot, nil
}
return ShouldDoNothing, nil
}
type RebootFlagSetter interface {
SetRebootFlag(flag bool) error
}
type RebootActionGetter interface {
ShouldRebootOrShutdown() (RebootAction, error)
}
|