@@ -22,23 +22,21 @@ const (
22
22
// WAL for calcium.
23
23
type WAL struct {
24
24
wal.WAL
25
- config types.Config
26
25
calcium * Calcium
27
26
}
28
27
29
- func newCalciumWAL (cal * Calcium ) (* WAL , error ) {
30
- w := & WAL {
31
- WAL : wal .NewHydro (),
32
- config : cal .config ,
33
- calcium : cal ,
28
+ func newWAL (config types.Config , calcium * Calcium ) (* WAL , error ) {
29
+ hydro , err := wal .NewHydro (config .WALFile , config .WALOpenTimeout )
30
+ if err != nil {
31
+ return nil , err
34
32
}
35
33
36
- if err := w .WAL .Open (w .config .WALFile , w .config .WALOpenTimeout ); err != nil {
37
- return nil , err
34
+ w := & WAL {
35
+ WAL : hydro ,
36
+ calcium : calcium ,
38
37
}
39
38
40
39
w .registerHandlers ()
41
-
42
40
return w , nil
43
41
}
44
42
@@ -49,26 +47,92 @@ func (w *WAL) registerHandlers() {
49
47
w .Register (newProcessingCreatedHandler (w .calcium ))
50
48
}
51
49
52
- func (w * WAL ) logCreateLambda (opts * types.CreateWorkloadMessage ) (wal.Commit , error ) {
53
- return w .Log (eventCreateLambda , opts .WorkloadID )
50
+ // CreateLambdaHandler indicates event handler for creating lambda.
51
+ type CreateLambdaHandler struct {
52
+ typ string
53
+ calcium * Calcium
54
+ }
55
+
56
+ func newCreateLambdaHandler (calcium * Calcium ) * CreateLambdaHandler {
57
+ return & CreateLambdaHandler {
58
+ typ : eventCreateLambda ,
59
+ calcium : calcium ,
60
+ }
61
+ }
62
+
63
+ // Event .
64
+ func (h * CreateLambdaHandler ) Typ () string {
65
+ return h .typ
66
+ }
67
+
68
+ // Check .
69
+ func (h * CreateLambdaHandler ) Check (context.Context , interface {}) (bool , error ) {
70
+ return true , nil
71
+ }
72
+
73
+ // Encode .
74
+ func (h * CreateLambdaHandler ) Encode (raw interface {}) ([]byte , error ) {
75
+ workloadID , ok := raw .(string )
76
+ if ! ok {
77
+ return nil , types .NewDetailedErr (types .ErrInvalidType , raw )
78
+ }
79
+ return []byte (workloadID ), nil
80
+ }
81
+
82
+ // Decode .
83
+ func (h * CreateLambdaHandler ) Decode (bs []byte ) (interface {}, error ) {
84
+ return string (bs ), nil
85
+ }
86
+
87
+ // Handle .
88
+ func (h * CreateLambdaHandler ) Handle (ctx context.Context , raw interface {}) error {
89
+ workloadID , ok := raw .(string )
90
+ if ! ok {
91
+ return types .NewDetailedErr (types .ErrInvalidType , raw )
92
+ }
93
+
94
+ logger := log .WithField ("WAL.Handle" , "RunAndWait" ).WithField ("ID" , workloadID )
95
+ go func () {
96
+ workload , err := h .calcium .GetWorkload (ctx , workloadID )
97
+ if err != nil {
98
+ logger .Errorf (ctx , "Get workload failed: %v" , err )
99
+ return
100
+ }
101
+
102
+ r , err := workload .Engine .VirtualizationWait (ctx , workloadID , "" )
103
+ if err != nil {
104
+ logger .Errorf (ctx , "Wait failed: %+v" , err )
105
+ return
106
+ }
107
+ if r .Code != 0 {
108
+ logger .Errorf (ctx , "Run failed: %s" , r .Message )
109
+ }
110
+
111
+ if err := h .calcium .doRemoveWorkloadSync (ctx , []string {workloadID }); err != nil {
112
+ logger .Errorf (ctx , "Remove failed: %+v" , err )
113
+ }
114
+ logger .Infof (ctx , "waited and removed" )
115
+ }()
116
+
117
+ return nil
54
118
}
55
119
56
120
// CreateWorkloadHandler indicates event handler for creating workload.
57
121
type CreateWorkloadHandler struct {
58
- event string
122
+ typ string
59
123
calcium * Calcium
60
124
}
61
125
62
- func newCreateWorkloadHandler (cal * Calcium ) * CreateWorkloadHandler {
126
+ func newCreateWorkloadHandler (calcium * Calcium ) * CreateWorkloadHandler {
63
127
return & CreateWorkloadHandler {
64
- event : eventWorkloadCreated ,
65
- calcium : cal ,
128
+ typ : eventWorkloadCreated ,
129
+ calcium : calcium ,
66
130
}
67
131
}
68
132
69
133
// Event .
70
- func (h * CreateWorkloadHandler ) Event () string {
71
- return h .event
134
+ func (h * CreateWorkloadHandler ) Typ () string {
135
+ return h .typ
72
136
}
73
137
74
138
// Check .
@@ -132,96 +196,22 @@ func (h *CreateWorkloadHandler) Handle(ctx context.Context, raw interface{}) (er
132
196
return nil
133
197
}
134
198
135
- // CreateLambdaHandler indicates event handler for creating lambda.
136
- type CreateLambdaHandler struct {
137
- event string
138
- calcium * Calcium
139
- }
140
-
141
- func newCreateLambdaHandler (cal * Calcium ) * CreateLambdaHandler {
142
- return & CreateLambdaHandler {
143
- event : eventCreateLambda ,
144
- calcium : cal ,
145
- }
146
- }
147
-
148
- // Event .
149
- func (h * CreateLambdaHandler ) Event () string {
150
- return h .event
151
- }
152
-
153
- // Check .
154
- func (h * CreateLambdaHandler ) Check (context.Context , interface {}) (bool , error ) {
155
- return true , nil
156
- }
157
-
158
- // Encode .
159
- func (h * CreateLambdaHandler ) Encode (raw interface {}) ([]byte , error ) {
160
- workloadID , ok := raw .(string )
161
- if ! ok {
162
- return nil , types .NewDetailedErr (types .ErrInvalidType , raw )
163
- }
164
- return []byte (workloadID ), nil
165
- }
166
-
167
- // Decode .
168
- func (h * CreateLambdaHandler ) Decode (bs []byte ) (interface {}, error ) {
169
- return string (bs ), nil
170
- }
171
-
172
- // Handle .
173
- func (h * CreateLambdaHandler ) Handle (ctx context.Context , raw interface {}) error {
174
- workloadID , ok := raw .(string )
175
- if ! ok {
176
- return types .NewDetailedErr (types .ErrInvalidType , raw )
177
- }
178
-
179
- logger := log .WithField ("WAL.Handle" , "RunAndWait" ).WithField ("ID" , workloadID )
180
- go func () {
181
- workload , err := h .calcium .GetWorkload (ctx , workloadID )
182
- if err != nil {
183
- logger .Errorf (ctx , "Get workload failed: %v" , err )
184
- return
185
- }
186
-
187
- r , err := workload .Engine .VirtualizationWait (ctx , workloadID , "" )
188
- if err != nil {
189
- logger .Errorf (ctx , "Wait failed: %+v" , err )
190
- return
191
- }
192
- if r .Code != 0 {
193
- logger .Errorf (ctx , "Run failed: %s" , r .Message )
194
- }
195
-
196
- if err := h .calcium .doRemoveWorkloadSync (ctx , []string {workloadID }); err != nil {
197
- logger .Errorf (ctx , "Remove failed: %+v" , err )
198
- }
199
- logger .Infof (ctx , "waited and removed" )
200
- }()
201
-
202
- return nil
203
- }
204
-
205
- func getReplayContext (ctx context.Context ) (context.Context , context.CancelFunc ) {
206
- return context .WithTimeout (ctx , time .Second * 32 )
207
- }
208
-
209
199
// WorkloadResourceAllocatedHandler .
210
200
type WorkloadResourceAllocatedHandler struct {
211
- event string
201
+ typ string
212
202
calcium * Calcium
213
203
}
214
204
215
- func newWorkloadResourceAllocatedHandler (cal * Calcium ) * WorkloadResourceAllocatedHandler {
205
+ func newWorkloadResourceAllocatedHandler (calcium * Calcium ) * WorkloadResourceAllocatedHandler {
216
206
return & WorkloadResourceAllocatedHandler {
217
- event : eventWorkloadResourceAllocated ,
218
- calcium : cal ,
207
+ typ : eventWorkloadResourceAllocated ,
208
+ calcium : calcium ,
219
209
}
220
210
}
221
211
222
212
// Event .
223
- func (h * WorkloadResourceAllocatedHandler ) Event () string {
224
- return h .event
213
+ func (h * WorkloadResourceAllocatedHandler ) Typ () string {
214
+ return h .typ
225
215
}
226
216
227
217
// Check .
@@ -276,20 +266,20 @@ func (h *WorkloadResourceAllocatedHandler) Handle(ctx context.Context, raw inter
276
266
277
267
// ProcessingCreatedHandler .
278
268
type ProcessingCreatedHandler struct {
279
- event string
269
+ typ string
280
270
calcium * Calcium
281
271
}
282
272
283
- func newProcessingCreatedHandler (cal * Calcium ) * ProcessingCreatedHandler {
273
+ func newProcessingCreatedHandler (calcium * Calcium ) * ProcessingCreatedHandler {
284
274
return & ProcessingCreatedHandler {
285
- event : eventProcessingCreated ,
286
- calcium : cal ,
275
+ typ : eventProcessingCreated ,
276
+ calcium : calcium ,
287
277
}
288
278
}
289
279
290
280
// Event .
291
- func (h * ProcessingCreatedHandler ) Event () string {
292
- return h .event
281
+ func (h * ProcessingCreatedHandler ) Typ () string {
282
+ return h .typ
293
283
}
294
284
295
285
// Check .
@@ -329,3 +319,7 @@ func (h *ProcessingCreatedHandler) Handle(ctx context.Context, raw interface{})
329
319
logger .Infof (ctx , "obsolete processing deleted" )
330
320
return
331
321
}
322
+
323
+ func getReplayContext (ctx context.Context ) (context.Context , context.CancelFunc ) {
324
+ return context .WithTimeout (ctx , time .Second * 32 ) // TODO why 32?
325
+ }
0 commit comments