-
Notifications
You must be signed in to change notification settings - Fork 0
/
task_handler_types.go
82 lines (68 loc) · 2.28 KB
/
task_handler_types.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
// Copyright 2014-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License"). You may
// not use this file except in compliance with the License. A copy of the
// License is located at
//
// http://aws.amazon.com/apache2.0/
//
// or in the "license" file accompanying this file. This file is distributed
// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
// express or implied. See the License for the specific language governing
// permissions and limitations under the License.
package eventhandler
import (
"container/list"
"sync"
"github.com/aws/amazon-ecs-agent/agent/api"
"github.com/aws/amazon-ecs-agent/agent/utils"
)
// Maximum number of tasks that may be handled at once by the taskHandler
const CONCURRENT_EVENT_CALLS = 3
// a state change that may have a container and, optionally, a task event to
// send
type sendableEvent struct {
containerSent bool
taskSent bool
api.ContainerStateChange
}
func newSendableEvent(event api.ContainerStateChange) *sendableEvent {
return &sendableEvent{
containerSent: false,
taskSent: false,
ContainerStateChange: event,
}
}
func (event *sendableEvent) taskShouldBeSent() bool {
if event.TaskStatus == api.TaskStatusNone {
return false // container only event
}
if event.taskSent || event.Task.SentStatus >= event.TaskStatus {
return false // redundant event
}
return true
}
func (event *sendableEvent) containerShouldBeSent() bool {
if event.containerSent || event.Container.SentStatus >= event.Status {
return false
}
return true
}
type eventList struct {
sending bool // whether the list is already being handled
sync.Mutex // Locks both the list and sending bool
*list.List // list of *sendableEvents
}
type taskHandler struct {
submitSemaphore utils.Semaphore // Semaphore on the number of tasks that may be handled at once
taskMap map[string]*eventList // arn:*eventList map so events may be serialized per task
sync.RWMutex // Lock for the taskMap
}
func newTaskHandler() taskHandler {
taskMap := make(map[string]*eventList)
submitSemaphore := utils.NewSemaphore(CONCURRENT_EVENT_CALLS)
return taskHandler{
taskMap: taskMap,
submitSemaphore: submitSemaphore,
}
}