14 |
20 |
15 |
19 |
16 | 
17 |
18 |
17 |
21 |
32 |
33 |
34 |
--------------------------------------------------------------------------------
/server/routes_v0.go:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "github.com/eremetic-framework/eremetic/api"
5 | "github.com/eremetic-framework/eremetic/config"
6 | )
7 |
8 | func apiV0Routes(h Handler, conf *config.Config) Routes {
9 | return Routes{
10 | Route{
11 | Name: "AddTask",
12 | Method: "POST",
13 | Pattern: "/task",
14 | Handler: h.AddTask(conf, api.V0),
15 | },
16 | Route{
17 | Name: "Status",
18 | Method: "GET",
19 | Pattern: "/task/{taskId}",
20 | Handler: h.GetTaskInfo(conf, api.V0),
21 | },
22 | Route{
23 | Name: "STDOUT",
24 | Method: "GET",
25 | Pattern: "/task/{taskId}/stdout",
26 | Handler: h.GetFromSandbox("stdout", api.V0),
27 | },
28 | Route{
29 | Name: "STDERR",
30 | Method: "GET",
31 | Pattern: "/task/{taskId}/stderr",
32 | Handler: h.GetFromSandbox("stderr", api.V0),
33 | },
34 | Route{
35 | Name: "Kill",
36 | Method: "POST",
37 | Pattern: "/task/{taskId}/kill",
38 | Handler: h.KillTask(conf, api.V0),
39 | },
40 | Route{
41 | Name: "Delete",
42 | Method: "DELETE",
43 | Pattern: "/task/{taskId}",
44 | Handler: h.DeleteTask(conf, api.V0),
45 | },
46 | Route{
47 | Name: "ListRunningTasks",
48 | Method: "GET",
49 | Pattern: "/task",
50 | Handler: h.ListTasks(api.V0),
51 | },
52 | Route{
53 | Name: "Version",
54 | Method: "GET",
55 | Pattern: "/version",
56 | Handler: h.Version(conf, api.V0),
57 | },
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/server/routes_v1.go:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "github.com/eremetic-framework/eremetic/api"
5 | "github.com/eremetic-framework/eremetic/config"
6 | )
7 |
8 | func apiV1Routes(h Handler, conf *config.Config) Routes {
9 | return Routes{
10 | Route{
11 | Name: "AddTask",
12 | Method: "POST",
13 | Pattern: "/api/v1/task",
14 | Handler: h.AddTask(conf, api.V1),
15 | },
16 | Route{
17 | Name: "Status",
18 | Method: "GET",
19 | Pattern: "/api/v1/task/{taskId}",
20 | Handler: h.GetTaskInfo(conf, api.V1),
21 | },
22 | Route{
23 | Name: "STDOUT",
24 | Method: "GET",
25 | Pattern: "/api/v1/task/{taskId}/stdout",
26 | Handler: h.GetFromSandbox("stdout", api.V1),
27 | },
28 | Route{
29 | Name: "STDERR",
30 | Method: "GET",
31 | Pattern: "/api/v1/task/{taskId}/stderr",
32 | Handler: h.GetFromSandbox("stderr", api.V1),
33 | },
34 | Route{
35 | Name: "Kill",
36 | Method: "POST",
37 | Pattern: "/api/v1/task/{taskId}/kill",
38 | Handler: h.KillTask(conf, api.V1),
39 | },
40 | Route{
41 | Name: "Delete",
42 | Method: "DELETE",
43 | Pattern: "/api/v1/task/{taskId}",
44 | Handler: h.DeleteTask(conf, api.V1),
45 | },
46 | Route{
47 | Name: "ListRunningTasks",
48 | Method: "GET",
49 | Pattern: "/api/v1/task",
50 | Handler: h.ListTasks(api.V1),
51 | },
52 | Route{
53 | Name: "Version",
54 | Method: "GET",
55 | Pattern: "/api/v1/version",
56 | Handler: h.Version(conf, api.V1),
57 | },
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/callback.go:
--------------------------------------------------------------------------------
1 | package eremetic
2 |
3 | import (
4 | "bytes"
5 | "encoding/json"
6 | "net/http"
7 |
8 | "github.com/sirupsen/logrus"
9 | )
10 |
11 | // CallbackData holds information about the status update.
12 | type CallbackData struct {
13 | Time int64 `json:"time"`
14 | Status string `json:"status"`
15 | TaskID string `json:"task_id"`
16 | }
17 |
18 | // NotifyCallback handles posting a JSON back to the URI given with the task.
19 | func NotifyCallback(task *Task) {
20 | if len(task.CallbackURI) == 0 {
21 | return
22 | }
23 |
24 | if len(task.Status) == 0 {
25 | return
26 | }
27 |
28 | status := task.Status[len(task.Status)-1]
29 |
30 | data := CallbackData{
31 | Time: status.Time,
32 | Status: status.Status.String(),
33 | TaskID: task.ID,
34 | }
35 |
36 | body, err := json.Marshal(data)
37 | if err != nil {
38 | logrus.WithError(err).WithFields(logrus.Fields{
39 | "task_id": task.ID,
40 | "callback_uri": task.CallbackURI,
41 | }).Error("Unable to create callback message")
42 |
43 | return
44 | }
45 |
46 | go func() {
47 | _, err = http.Post(task.CallbackURI, "application/json", bytes.NewBuffer(body))
48 | if err != nil {
49 | logrus.WithError(err).WithFields(logrus.Fields{
50 | "task_id": task.ID,
51 | "callback_uri": task.CallbackURI,
52 | }).Error("Unable to POST to Callback URI")
53 |
54 | return
55 | }
56 |
57 | logrus.WithFields(logrus.Fields{
58 | "task_id": task.ID,
59 | "callback_uri": task.CallbackURI,
60 | }).Debug("Sent callback")
61 | }()
62 | }
63 |
--------------------------------------------------------------------------------
/server/static/js/serialize_object.min.js:
--------------------------------------------------------------------------------
1 | /**
2 | * jQuery serializeObject
3 | * @copyright 2014, macek
22 | 
23 |
24 |
31 |
23 |
17 |
26 |
18 |
25 |
19 |
20 |
21 |
20 |
22 |
24 | {{.Version}}
23 |
27 |
134 |
135 |
136 |
137 |
--------------------------------------------------------------------------------
/misc/swagger.yaml:
--------------------------------------------------------------------------------
1 | swagger: '2.0'
2 | info:
3 | title: Eremetic
4 | description: Run one-off tasks on mesos
5 | version: "1.0.0"
6 | schemes:
7 | - https
8 | basePath: /
9 | produces:
10 | - application/json
11 | paths:
12 | /api/v1/task:
13 | get:
14 | summary: List running tasks
15 | description: |
16 | List all running tasks, masking values in MaskedEnvironment.
17 | parameters:
18 | - in: query
19 | name: name
20 | schema:
21 | type: string
22 | required: false
23 | description: The name of the task. There can be several tasks with same name.
24 | - in: query
25 | name: state
26 | schema:
27 | type: string
28 | required: false
29 | description: The state of the task. Valid states are queued, active and terminated.
30 | Can be comma combined composite state e.g. "terminated,queued". The Default value
31 | is "active,queued". Empty string will return all states.
32 | responses:
33 | 200:
34 | description: Task details
35 | schema:
36 | $ref: '#/definitions/Task'
37 | default:
38 | description: Unexpected error
39 | post:
40 | summary: Launch a task
41 | consumes:
42 | - application/json
43 | description: |
44 | The task endpoint lets you launch a task on mesos by submitting a payload describing the task to be run.
45 | parameters:
46 | - name: Task definition
47 | in: body
48 | description: Details of task to launch
49 | required: true
50 | schema:
51 | $ref: '#/definitions/Task'
52 | responses:
53 | 202:
54 | description: Task ID
55 | schema:
56 | type: string
57 | default:
58 | description: Unexpected error
59 | /api/v1/task/{taskId}:
60 | get:
61 | summary: Get status of task
62 | description: |
63 | Check the status of task previously launched.
64 | parameters:
65 | - name: taskId
66 | in: path
67 | description: Task identifier
68 | required: true
69 | type: string
70 | responses:
71 | 200:
72 | description: Task details
73 | schema:
74 | $ref: '#/definitions/Task'
75 | 404:
76 | description: Task not found
77 | default:
78 | description: Unexpected error
79 | definitions:
80 | Volume:
81 | type: object
82 | properties:
83 | container_path:
84 | type: string
85 | description: Path in container to mount at
86 | host_path:
87 | type: string
88 | description: Path on host to mount
89 | URI:
90 | type: object
91 | properties:
92 | uri:
93 | type: string
94 | description: URI to fetch
95 | extract:
96 | type: boolean
97 | description: True if the file should be extracted after being fetched
98 | executable:
99 | type: boolean
100 | description: True if the file should be flagged as executable
101 | cache:
102 | type: boolean
103 | description: True if the file should be cached
104 | Tasks:
105 | type: array
106 | items:
107 | $ref: '#/definitions/Task'
108 | Task:
109 | type: object
110 | required:
111 | - image
112 | - command
113 | - cpu
114 | - mem
115 | properties:
116 | id:
117 | type: string
118 | readOnly: true
119 | description: ID of task
120 | name:
121 | type: string
122 | description: Name of task
123 | image:
124 | type: string
125 | description: Full tag or hash of container to run
126 | command:
127 | type: string
128 | description: Command to run in the docker container
129 | force_pull_image:
130 | type: boolean
131 | description: Docker image will be pulled before each task launch
132 | privileged:
133 | type: boolean
134 | description: Docker will run the container in 'privileged' mode giving it all capabilities
135 | network:
136 | type: string
137 | description: Network mode to pass to the container
138 | dns:
139 | type: string
140 | description: DNS to be used by the container
141 | args:
142 | type: array
143 | items:
144 | type: string
145 | description: arguements to pass to the docker container entrypoint
146 | cpu:
147 | type: number
148 | description: Fractions of a CPU to request
149 | mem:
150 | type: number
151 | description: memory to use (MiB)
152 | volumes:
153 | type: array
154 | items:
155 | $ref: '#/definitions/Volume'
156 | volumes_from:
157 | type: array
158 | items:
159 | type: string
160 | description: container names to get volumes from
161 | fetch:
162 | type: array
163 | items:
164 | $ref: '#/definitions/URI'
165 | env:
166 | type: object
167 | description: Environment variables to set
168 | masked_env:
169 | type: object
170 | description: Environment variables to set but that are masked in any GET request.
171 | labels:
172 | type: object
173 | description: Labels for the task
174 | callback_uri:
175 | type: string
176 | description: URL to post a callback to
177 | framework_id:
178 | type: string
179 | readOnly: true
180 | description: Framework ID used when launching task
181 | agent_id:
182 | type: string
183 | readOnly: true
184 | description: Id of slave where task is running
185 | hostname:
186 | type: string
187 | readOnly: true
188 | description: Name of host where task is launched
189 | retry:
190 | type: number
191 | readOnly: true
192 | description: Number of times a retry have been attempted
193 | status:
194 | type: array
195 | readOnly: true
196 | items:
197 | type: object
198 | properties:
199 | status:
200 | type: string
201 | description: Status identifier
202 | enum:
203 | - TASK_STAGING
204 | - TASK_RUNNING
205 | - TASK_FINISHED
206 | - TASK_FAILED
207 | - TASK_LOST
208 | - TASK_ERROR
209 | time:
210 | type: number
211 | description: Unix timestamp of status change
212 |
--------------------------------------------------------------------------------
/mesos/match_test.go:
--------------------------------------------------------------------------------
1 | package mesos
2 |
3 | import (
4 | "testing"
5 | "time"
6 |
7 | "github.com/mesos/mesos-go/api/v0/mesosproto"
8 | . "github.com/smartystreets/goconvey/convey"
9 |
10 | "github.com/eremetic-framework/eremetic"
11 | )
12 |
13 | func TestMatch(t *testing.T) {
14 | offerA := offer("offer-a", 0.6, 200.0,
15 | unavailability(),
16 | textAttribute("role", "badassmofo"),
17 | textAttribute("node_name", "node1"),
18 | )
19 | offerB := offer("offer-b", 1.8, 512.0,
20 | unavailability(),
21 | textAttribute("node_name", "node2"),
22 | )
23 | offerC := offer("offer-c", 1.8, 512.0,
24 | unavailability(
25 | time.Now().UnixNano(),
26 | time.Unix(0, 0).Add(1*time.Hour).UnixNano(),
27 | ),
28 | textAttribute("node_name", "node3"),
29 | )
30 | offerD := offer("offer-d", 1.8, 512.0,
31 | unavailability(
32 | time.Now().UnixNano(),
33 | ),
34 | textAttribute("node_name", "node4"),
35 | )
36 | offerE := offer("offer-e", 1.8, 512.0,
37 | unavailability(
38 | time.Now().Add(-2*time.Hour).UnixNano(),
39 | time.Unix(0, 0).Add(1*time.Hour).UnixNano(),
40 | ),
41 | textAttribute("node_name", "node3"),
42 | )
43 |
44 | Convey("CPUAvailable", t, func() {
45 | Convey("Above", func() {
46 | m := cpuAvailable(0.4)
47 | err := m.Matches(offerA)
48 | So(err, ShouldBeNil)
49 | })
50 |
51 | Convey("Below", func() {
52 | m := cpuAvailable(0.8)
53 | err := m.Matches(offerA)
54 | So(err, ShouldNotBeNil)
55 | })
56 | })
57 |
58 | Convey("MemoryAvailable", t, func() {
59 | Convey("Above", func() {
60 |
61 | m := memoryAvailable(128.0)
62 | err := m.Matches(offerA)
63 | So(err, ShouldBeNil)
64 | })
65 |
66 | Convey("Below", func() {
67 | m := memoryAvailable(256.0)
68 | err := m.Matches(offerA)
69 | So(err, ShouldNotBeNil)
70 | })
71 | })
72 |
73 | Convey("Maintenance node", t, func() {
74 | Convey("Does not match (Defined maintenance window)", func() {
75 | m := availabilityMatch(time.Now())
76 | err := m.Matches(offerC)
77 | So(err, ShouldNotBeNil)
78 | })
79 |
80 | Convey("Does not match (Undefined maintenance window)", func() {
81 | m := availabilityMatch(time.Now())
82 | err := m.Matches(offerD)
83 | So(err, ShouldNotBeNil)
84 | })
85 |
86 | Convey("Does match (maintenance window in past)", func() {
87 | m := availabilityMatch(time.Now())
88 | err := m.Matches(offerE)
89 | So(err, ShouldBeNil)
90 | })
91 |
92 | Convey("Does match the offer (task match)", func() {
93 | task := eremetic.Task{
94 | TaskCPUs: 0.6,
95 | TaskMem: 128.0,
96 | }
97 | offer, others := matchOffer(task, []*mesosproto.Offer{offerA, offerC, offerD})
98 | So(offer, ShouldEqual, offerA)
99 | So(others, ShouldHaveLength, 2)
100 | })
101 | })
102 |
103 | Convey("AttributeMatch", t, func() {
104 | Convey("Does match", func() {
105 | m := attributeMatch([]eremetic.AgentConstraint{
106 | eremetic.AgentConstraint{
107 | AttributeName: "node_name",
108 | AttributeValue: "node1",
109 | },
110 | })
111 | err := m.Matches(offerA)
112 | So(err, ShouldBeNil)
113 | })
114 | Convey("Does not match", func() {
115 | m := attributeMatch([]eremetic.AgentConstraint{
116 | eremetic.AgentConstraint{
117 | AttributeName: "node_name",
118 | AttributeValue: "node2",
119 | },
120 | })
121 | err := m.Matches(offerA)
122 | So(err, ShouldNotBeNil)
123 | })
124 | })
125 |
126 | Convey("matchOffer", t, func() {
127 | Convey("Tasks without AgentConstraints", func() {
128 | Convey("Match", func() {
129 | task := eremetic.Task{
130 | TaskCPUs: 0.8,
131 | TaskMem: 128.0,
132 | }
133 | offer, others := matchOffer(task, []*mesosproto.Offer{offerA, offerB})
134 |
135 | So(offer, ShouldEqual, offerB)
136 | So(others, ShouldHaveLength, 1)
137 | So(others, ShouldContain, offerA)
138 | })
139 |
140 | Convey("No match CPU", func() {
141 | task := eremetic.Task{
142 | TaskCPUs: 2.0,
143 | TaskMem: 128.0,
144 | }
145 | offer, others := matchOffer(task, []*mesosproto.Offer{offerA, offerB})
146 |
147 | So(offer, ShouldBeNil)
148 | So(others, ShouldHaveLength, 2)
149 | })
150 |
151 | Convey("No match MEM", func() {
152 | task := eremetic.Task{
153 | TaskCPUs: 0.2,
154 | TaskMem: 712.0,
155 | }
156 | offer, others := matchOffer(task, []*mesosproto.Offer{offerA, offerB})
157 |
158 | So(offer, ShouldBeNil)
159 | So(others, ShouldHaveLength, 2)
160 | })
161 | })
162 |
163 | Convey("Tasks with AgentConstraints", func() {
164 | Convey("Match agent with attribute", func() {
165 | // Use task/mem constraints which match both offers.
166 | task := eremetic.Task{
167 | TaskCPUs: 0.5,
168 | TaskMem: 128.0,
169 | AgentConstraints: []eremetic.AgentConstraint{
170 | eremetic.AgentConstraint{
171 | AttributeName: "node_name",
172 | AttributeValue: "node2",
173 | },
174 | },
175 | }
176 | offer, others := matchOffer(task, []*mesosproto.Offer{offerA, offerB})
177 |
178 | So(offer, ShouldEqual, offerB)
179 | So(others, ShouldHaveLength, 1)
180 | So(others, ShouldContain, offerA)
181 | })
182 |
183 | Convey("No matching slave with attribute", func() {
184 | // Use task/mem constraints which match both offers.
185 | task := eremetic.Task{
186 | TaskCPUs: 0.5,
187 | TaskMem: 128.0,
188 | AgentConstraints: []eremetic.AgentConstraint{
189 | eremetic.AgentConstraint{
190 | AttributeName: "node_name",
191 | AttributeValue: "sherah",
192 | },
193 | },
194 | }
195 | offer, others := matchOffer(task, []*mesosproto.Offer{offerA, offerB})
196 |
197 | So(offer, ShouldBeNil)
198 | So(others, ShouldHaveLength, 2)
199 | })
200 |
201 | Convey("Match slave with multiple attributes", func() {
202 | // Build two new offers, both with the same role as offerA.
203 | offerC := offer("offer-c", 0.6, 200.0,
204 | unavailability(),
205 | textAttribute("role", "badassmofo"),
206 | textAttribute("node_name", "node3"),
207 | )
208 | offerD := offer("offer-d", 0.6, 200.0,
209 | unavailability(),
210 | textAttribute("role", "badassmofo"),
211 | )
212 |
213 | task := eremetic.Task{
214 | TaskCPUs: 0.5,
215 | TaskMem: 128.0,
216 | AgentConstraints: []eremetic.AgentConstraint{
217 | eremetic.AgentConstraint{
218 | AttributeName: "role",
219 | AttributeValue: "badassmofo",
220 | },
221 | eremetic.AgentConstraint{
222 | AttributeName: "node_name",
223 | AttributeValue: "node3",
224 | },
225 | },
226 | }
227 | // Specifically add C last, our expected, so that we ensure
228 | // the other mocks do not match first.
229 | offer, others := matchOffer(task, []*mesosproto.Offer{offerA, offerD, offerC})
230 |
231 | So(offer, ShouldEqual, offerC)
232 | So(others, ShouldHaveLength, 2)
233 | So(others, ShouldContain, offerA)
234 | So(others, ShouldContain, offerD)
235 | })
236 | })
237 | })
238 | }
239 |
--------------------------------------------------------------------------------
/api/api_v0.go:
--------------------------------------------------------------------------------
1 | package api
2 |
3 | import (
4 | "github.com/eremetic-framework/eremetic"
5 | )
6 |
7 | // TaskV0 defines the deprecated json-structure for the properties of a scheduled task.
8 | type TaskV0 struct {
9 | TaskCPUs float64 `json:"task_cpus"`
10 | TaskMem float64 `json:"task_mem"`
11 | Command string `json:"command"`
12 | Args []string `json:"args"`
13 | User string `json:"user"`
14 | Environment map[string]string `json:"env"`
15 | MaskedEnvironment map[string]string `json:"masked_env"`
16 | Labels map[string]string `json:"labels"`
17 | Image string `json:"image"`
18 | Volumes []eremetic.Volume `json:"volumes"`
19 | Ports []eremetic.Port `json:"ports"`
20 | Status []eremetic.Status `json:"status"`
21 | ID string `json:"id"`
22 | Name string `json:"name"`
23 | Network string `json:"network"`
24 | DNS string `json:"dns"`
25 | FrameworkID string `json:"framework_id"`
26 | AgentID string `json:"slave_id"`
27 | AgentConstraints []eremetic.AgentConstraint `json:"slave_constraints"`
28 | Hostname string `json:"hostname"`
29 | Retry int `json:"retry"`
30 | CallbackURI string `json:"callback_uri"`
31 | SandboxPath string `json:"sandbox_path"`
32 | AgentIP string `json:"agent_ip"`
33 | AgentPort int32 `json:"agent_port"`
34 | ForcePullImage bool `json:"force_pull_image"`
35 | Privileged bool `json:"privileged"`
36 | FetchURIs []eremetic.URI `json:"fetch"`
37 | }
38 |
39 | // TaskV0FromTask is needed for Go versions < 1.8
40 | // In go 1.8, TaskV0(Task) would work instead
41 | func TaskV0FromTask(task *eremetic.Task) TaskV0 {
42 | return TaskV0{
43 | TaskCPUs: task.TaskCPUs,
44 | TaskMem: task.TaskMem,
45 | Command: task.Command,
46 | Args: task.Args,
47 | User: task.User,
48 | Environment: task.Environment,
49 | MaskedEnvironment: task.MaskedEnvironment,
50 | Labels: task.Labels,
51 | Image: task.Image,
52 | Volumes: task.Volumes,
53 | Ports: task.Ports,
54 | Status: task.Status,
55 | ID: task.ID,
56 | Name: task.Name,
57 | Network: task.Network,
58 | DNS: task.DNS,
59 | FrameworkID: task.FrameworkID,
60 | AgentID: task.AgentID,
61 | AgentConstraints: task.AgentConstraints,
62 | Hostname: task.Hostname,
63 | Retry: task.Retry,
64 | CallbackURI: task.CallbackURI,
65 | SandboxPath: task.SandboxPath,
66 | AgentIP: task.AgentIP,
67 | AgentPort: task.AgentPort,
68 | ForcePullImage: task.ForcePullImage,
69 | Privileged: task.Privileged,
70 | FetchURIs: task.FetchURIs,
71 | }
72 | }
73 |
74 | // TaskFromV0 is needed for Go versions < 1.8
75 | // In go 1.8, Task(TaskV0) would work instead
76 | func TaskFromV0(task *TaskV0) eremetic.Task {
77 | return eremetic.Task{
78 | TaskCPUs: task.TaskCPUs,
79 | TaskMem: task.TaskMem,
80 | Command: task.Command,
81 | Args: task.Args,
82 | User: task.User,
83 | Environment: task.Environment,
84 | MaskedEnvironment: task.MaskedEnvironment,
85 | Labels: task.Labels,
86 | Image: task.Image,
87 | Volumes: task.Volumes,
88 | Ports: task.Ports,
89 | Status: task.Status,
90 | ID: task.ID,
91 | Name: task.Name,
92 | Network: task.Network,
93 | DNS: task.DNS,
94 | FrameworkID: task.FrameworkID,
95 | AgentID: task.AgentID,
96 | AgentConstraints: task.AgentConstraints,
97 | Hostname: task.Hostname,
98 | Retry: task.Retry,
99 | CallbackURI: task.CallbackURI,
100 | SandboxPath: task.SandboxPath,
101 | AgentIP: task.AgentIP,
102 | AgentPort: task.AgentPort,
103 | ForcePullImage: task.ForcePullImage,
104 | Privileged: task.Privileged,
105 | FetchURIs: task.FetchURIs,
106 | }
107 | }
108 |
109 | // RequestV0 represents the old deprecated json-structure of a job request
110 | type RequestV0 struct {
111 | TaskCPUs float64 `json:"task_cpus"`
112 | TaskMem float64 `json:"task_mem"`
113 | DockerImage string `json:"docker_image"`
114 | Command string `json:"command"`
115 | Args []string `json:"args"`
116 | Volumes []eremetic.Volume `json:"volumes"`
117 | Ports []eremetic.Port `json:"ports"`
118 | Name string `json:"name"`
119 | Network string `json:"network"`
120 | DNS string `json:"dns"`
121 | Environment map[string]string `json:"env"`
122 | MaskedEnvironment map[string]string `json:"masked_env"`
123 | Labels map[string]string `json:"labels"`
124 | AgentConstraints []eremetic.AgentConstraint `json:"slave_constraints"`
125 | CallbackURI string `json:"callback_uri"`
126 | URIs []string `json:"uris"`
127 | Fetch []eremetic.URI `json:"fetch"`
128 | ForcePullImage bool `json:"force_pull_image"`
129 | Privileged bool `json:"privileged"`
130 | }
131 |
132 | // RequestFromV0 is needed for Go versions < 1.8
133 | // In go 1.8, Request(RequestV0) would work instead
134 | func RequestFromV0(req RequestV0) eremetic.Request {
135 | return eremetic.Request{
136 | TaskCPUs: req.TaskCPUs,
137 | TaskMem: req.TaskMem,
138 | DockerImage: req.DockerImage,
139 | Command: req.Command,
140 | Args: req.Args,
141 | Volumes: req.Volumes,
142 | Ports: req.Ports,
143 | Name: req.Name,
144 | Network: req.Network,
145 | DNS: req.DNS,
146 | Environment: req.Environment,
147 | MaskedEnvironment: req.MaskedEnvironment,
148 | Labels: req.Labels,
149 | AgentConstraints: req.AgentConstraints,
150 | CallbackURI: req.CallbackURI,
151 | URIs: req.URIs,
152 | Fetch: req.Fetch,
153 | ForcePullImage: req.ForcePullImage,
154 | Privileged: req.Privileged,
155 | }
156 | }
157 |
--------------------------------------------------------------------------------
/api/api_v1.go:
--------------------------------------------------------------------------------
1 | package api
2 |
3 | import (
4 | "github.com/eremetic-framework/eremetic"
5 | )
6 |
7 | // TaskV1 defines the API V1 json-structure for the properties of a scheduled task.
8 | type TaskV1 struct {
9 | TaskCPUs float64 `json:"cpu"`
10 | TaskMem float64 `json:"mem"`
11 | Command string `json:"command"`
12 | Args []string `json:"args"`
13 | User string `json:"user"`
14 | Environment map[string]string `json:"env"`
15 | MaskedEnvironment map[string]string `json:"masked_env"`
16 | Labels map[string]string `json:"labels"`
17 | Image string `json:"image"`
18 | Volumes []eremetic.Volume `json:"volumes"`
19 | VolumesFrom []string `json:"volumes_from"`
20 | Ports []eremetic.Port `json:"ports"`
21 | Status []eremetic.Status `json:"status"`
22 | ID string `json:"id"`
23 | Name string `json:"name"`
24 | Network string `json:"network"`
25 | DNS string `json:"dns"`
26 | FrameworkID string `json:"framework_id"`
27 | AgentID string `json:"agent_id"`
28 | AgentConstraints []eremetic.AgentConstraint `json:"agent_constraints"`
29 | Hostname string `json:"hostname"`
30 | Retry int `json:"retry"`
31 | CallbackURI string `json:"callback_uri"`
32 | SandboxPath string `json:"sandbox_path"`
33 | AgentIP string `json:"agent_ip"`
34 | AgentPort int32 `json:"agent_port"`
35 | ForcePullImage bool `json:"force_pull_image"`
36 | Privileged bool `json:"privileged"`
37 | FetchURIs []eremetic.URI `json:"fetch"`
38 | }
39 |
40 | // TaskV1FromTask is needed for Go versions < 1.8
41 | // In go 1.8, TaskV1(Task) would work instead
42 | func TaskV1FromTask(task *eremetic.Task) TaskV1 {
43 | return TaskV1{
44 | TaskCPUs: task.TaskCPUs,
45 | TaskMem: task.TaskMem,
46 | Command: task.Command,
47 | Args: task.Args,
48 | User: task.User,
49 | Environment: task.Environment,
50 | MaskedEnvironment: task.MaskedEnvironment,
51 | Labels: task.Labels,
52 | Image: task.Image,
53 | Volumes: task.Volumes,
54 | VolumesFrom: task.VolumesFrom,
55 | Ports: task.Ports,
56 | Status: task.Status,
57 | ID: task.ID,
58 | Name: task.Name,
59 | Network: task.Network,
60 | DNS: task.DNS,
61 | FrameworkID: task.FrameworkID,
62 | AgentID: task.AgentID,
63 | AgentConstraints: task.AgentConstraints,
64 | Hostname: task.Hostname,
65 | Retry: task.Retry,
66 | CallbackURI: task.CallbackURI,
67 | SandboxPath: task.SandboxPath,
68 | AgentIP: task.AgentIP,
69 | AgentPort: task.AgentPort,
70 | ForcePullImage: task.ForcePullImage,
71 | Privileged: task.Privileged,
72 | FetchURIs: task.FetchURIs,
73 | }
74 | }
75 |
76 | // TaskFromV1 is needed for Go versions < 1.8
77 | // In go 1.8, Task(TaskV1) would work instead
78 | func TaskFromV1(task *TaskV1) eremetic.Task {
79 | return eremetic.Task{
80 | TaskCPUs: task.TaskCPUs,
81 | TaskMem: task.TaskMem,
82 | Command: task.Command,
83 | Args: task.Args,
84 | User: task.User,
85 | Environment: task.Environment,
86 | MaskedEnvironment: task.MaskedEnvironment,
87 | Labels: task.Labels,
88 | Image: task.Image,
89 | Volumes: task.Volumes,
90 | VolumesFrom: task.VolumesFrom,
91 | Ports: task.Ports,
92 | Status: task.Status,
93 | ID: task.ID,
94 | Name: task.Name,
95 | Network: task.Network,
96 | DNS: task.DNS,
97 | FrameworkID: task.FrameworkID,
98 | AgentID: task.AgentID,
99 | AgentConstraints: task.AgentConstraints,
100 | Hostname: task.Hostname,
101 | Retry: task.Retry,
102 | CallbackURI: task.CallbackURI,
103 | SandboxPath: task.SandboxPath,
104 | AgentIP: task.AgentIP,
105 | AgentPort: task.AgentPort,
106 | ForcePullImage: task.ForcePullImage,
107 | Privileged: task.Privileged,
108 | FetchURIs: task.FetchURIs,
109 | }
110 | }
111 |
112 | // RequestV1 represents the V1 json-structure of a job request
113 | type RequestV1 struct {
114 | TaskCPUs float64 `json:"cpu"`
115 | TaskMem float64 `json:"mem"`
116 | DockerImage string `json:"image"`
117 | Command string `json:"command"`
118 | Args []string `json:"args"`
119 | Volumes []eremetic.Volume `json:"volumes"`
120 | VolumesFrom []string `json:"volumes_from"`
121 | Ports []eremetic.Port `json:"ports"`
122 | Name string `json:"name"`
123 | Network string `json:"network"`
124 | DNS string `json:"dns"`
125 | Environment map[string]string `json:"env"`
126 | MaskedEnvironment map[string]string `json:"masked_env"`
127 | Labels map[string]string `json:"labels"`
128 | AgentConstraints []eremetic.AgentConstraint `json:"agent_constraints"`
129 | CallbackURI string `json:"callback_uri"`
130 | Fetch []eremetic.URI `json:"fetch"`
131 | ForcePullImage bool `json:"force_pull_image"`
132 | Privileged bool `json:"privileged"`
133 | }
134 |
135 | // RequestFromV1 is needed for Go versions < 1.8
136 | // In go 1.8, Request(RequestV1) would work instead
137 | func RequestFromV1(req RequestV1) eremetic.Request {
138 | return eremetic.Request{
139 | TaskCPUs: req.TaskCPUs,
140 | TaskMem: req.TaskMem,
141 | DockerImage: req.DockerImage,
142 | Command: req.Command,
143 | Args: req.Args,
144 | Volumes: req.Volumes,
145 | VolumesFrom: req.VolumesFrom,
146 | Ports: req.Ports,
147 | Name: req.Name,
148 | Network: req.Network,
149 | DNS: req.DNS,
150 | Environment: req.Environment,
151 | MaskedEnvironment: req.MaskedEnvironment,
152 | Labels: req.Labels,
153 | AgentConstraints: req.AgentConstraints,
154 | CallbackURI: req.CallbackURI,
155 | URIs: []string{},
156 | Fetch: req.Fetch,
157 | ForcePullImage: req.ForcePullImage,
158 | Privileged: req.Privileged,
159 | }
160 | }
161 |
--------------------------------------------------------------------------------
/server/templates/task.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
17 |
28 |
18 |
19 |
27 |
20 |
21 |
22 |
23 |
21 |
24 |
26 | {{.Version}}
25 |
29 |
33 |
161 |
162 |
163 |
--------------------------------------------------------------------------------
/mesos/task.go:
--------------------------------------------------------------------------------
1 | package mesos
2 |
3 | import (
4 | "fmt"
5 |
6 | "github.com/gogo/protobuf/proto"
7 |
8 | "github.com/mesos/mesos-go/api/v0/mesosproto"
9 | "github.com/mesos/mesos-go/api/v0/mesosutil"
10 |
11 | "github.com/eremetic-framework/eremetic"
12 | )
13 |
14 | func createTaskInfo(task eremetic.Task, offer *mesosproto.Offer) (eremetic.Task, *mesosproto.TaskInfo) {
15 | task.FrameworkID = *offer.FrameworkId.Value
16 | task.AgentID = *offer.SlaveId.Value
17 | task.Hostname = *offer.Hostname
18 | task.AgentIP = offer.GetUrl().GetAddress().GetIp()
19 | task.AgentPort = offer.GetUrl().GetAddress().GetPort()
20 |
21 | network := buildNetwork(task)
22 | dockerCliParameters := buildDockerCliParameters(task)
23 | portMapping, portResources := buildPorts(task, network, offer)
24 | env := buildEnvironment(task, portMapping)
25 |
26 | taskInfo := &mesosproto.TaskInfo{
27 | TaskId: &mesosproto.TaskID{Value: proto.String(task.ID)},
28 | SlaveId: offer.SlaveId,
29 | Name: proto.String(task.Name),
30 | Command: buildCommandInfo(task, env),
31 | Container: &mesosproto.ContainerInfo{
32 | Type: mesosproto.ContainerInfo_DOCKER.Enum(),
33 | Docker: &mesosproto.ContainerInfo_DockerInfo{
34 | Image: proto.String(task.Image),
35 | ForcePullImage: proto.Bool(task.ForcePullImage),
36 | Privileged: proto.Bool(task.Privileged),
37 | Network: network,
38 | PortMappings: portMapping,
39 | Parameters: dockerCliParameters,
40 | },
41 | Volumes: buildVolumes(task),
42 | },
43 | Labels: buildLabels(task),
44 | Resources: []*mesosproto.Resource{
45 | mesosutil.NewScalarResource("cpus", task.TaskCPUs),
46 | mesosutil.NewScalarResource("mem", task.TaskMem),
47 | mesosutil.NewRangesResource("ports", portResources),
48 | },
49 | }
50 | return task, taskInfo
51 | }
52 |
53 | func buildDockerCliParameters(task eremetic.Task) []*mesosproto.Parameter {
54 | //To be able to move away from docker CLI in future, parameters aren't fully exposed to the API
55 | params := make(map[string]string)
56 | if task.DNS != "" {
57 | params["dns"] = task.DNS
58 | }
59 | var parameters []*mesosproto.Parameter
60 | for k, v := range params {
61 | parameters = append(parameters, &mesosproto.Parameter{
62 | Key: proto.String(k),
63 | Value: proto.String(v),
64 | })
65 | }
66 | if len(task.VolumesFrom) > 0 {
67 | for _, containerName := range task.VolumesFrom {
68 | if containerName == "" {
69 | continue
70 | }
71 | parameters = append(parameters, &mesosproto.Parameter{
72 | Key: proto.String("volumes-from"),
73 | Value: proto.String(containerName),
74 | })
75 | }
76 | }
77 | return parameters
78 | }
79 |
80 | func buildNetwork(task eremetic.Task) *mesosproto.ContainerInfo_DockerInfo_Network {
81 | if task.Network == "" {
82 | return mesosproto.ContainerInfo_DockerInfo_BRIDGE.Enum()
83 | }
84 | return mesosproto.ContainerInfo_DockerInfo_Network(mesosproto.ContainerInfo_DockerInfo_Network_value[task.Network]).Enum()
85 | }
86 |
87 | func buildEnvironment(task eremetic.Task, portMappings []*mesosproto.ContainerInfo_DockerInfo_PortMapping) *mesosproto.Environment {
88 | var environment []*mesosproto.Environment_Variable
89 | for k, v := range task.Environment {
90 | environment = append(environment, &mesosproto.Environment_Variable{
91 | Name: proto.String(k),
92 | Value: proto.String(v),
93 | })
94 | }
95 | for k, v := range task.MaskedEnvironment {
96 | environment = append(environment, &mesosproto.Environment_Variable{
97 | Name: proto.String(k),
98 | Value: proto.String(v),
99 | })
100 | }
101 | for i, m := range portMappings {
102 | environment = append(environment, &mesosproto.Environment_Variable{
103 | Name: proto.String(fmt.Sprintf("PORT%d", i)),
104 | Value: proto.String(fmt.Sprintf("%d", *m.HostPort)),
105 | })
106 | }
107 | if len(portMappings) > 0 {
108 | environment = append(environment, &mesosproto.Environment_Variable{
109 | Name: proto.String("PORT"),
110 | Value: proto.String(fmt.Sprintf("%d", *portMappings[0].HostPort)),
111 | })
112 | }
113 |
114 | environment = append(environment, &mesosproto.Environment_Variable{
115 | Name: proto.String("MESOS_TASK_ID"),
116 | Value: proto.String(task.ID),
117 | })
118 |
119 | return &mesosproto.Environment{
120 | Variables: environment,
121 | }
122 | }
123 |
124 | func buildLabels(task eremetic.Task) *mesosproto.Labels {
125 | var labels *mesosproto.Labels
126 | var labelsSlice []*mesosproto.Label
127 | for k, v := range task.Labels {
128 | labelsSlice = append(labelsSlice, &mesosproto.Label{
129 | Key: proto.String(k),
130 | Value: proto.String(v),
131 | })
132 | }
133 | if len(labelsSlice) > 0 {
134 | labels = &mesosproto.Labels{
135 | Labels: labelsSlice,
136 | }
137 | }
138 | return labels
139 | }
140 |
141 | func buildVolumes(task eremetic.Task) []*mesosproto.Volume {
142 | var volumes []*mesosproto.Volume
143 | for _, v := range task.Volumes {
144 | volumes = append(volumes, &mesosproto.Volume{
145 | Mode: mesosproto.Volume_RW.Enum(),
146 | ContainerPath: proto.String(v.ContainerPath),
147 | HostPath: proto.String(v.HostPath),
148 | })
149 | }
150 |
151 | return volumes
152 | }
153 |
154 | func buildPorts(task eremetic.Task, network *mesosproto.ContainerInfo_DockerInfo_Network, offer *mesosproto.Offer) ([]*mesosproto.ContainerInfo_DockerInfo_PortMapping, []*mesosproto.Value_Range) {
155 | var resources []*mesosproto.Value_Range
156 | var mappings []*mesosproto.ContainerInfo_DockerInfo_PortMapping
157 |
158 | if len(task.Ports) == 0 || *network == mesosproto.ContainerInfo_DockerInfo_HOST {
159 | return mappings, resources
160 | }
161 |
162 | leftToAssign := len(task.Ports)
163 |
164 | for _, rsrc := range offer.Resources {
165 | if *rsrc.Name != "ports" {
166 | continue
167 | }
168 |
169 | for _, rng := range rsrc.Ranges.Range {
170 | if leftToAssign == 0 {
171 | break
172 | }
173 |
174 | start, end := *rng.Begin, *rng.Begin
175 |
176 | for hport := int(*rng.Begin); hport <= int(*rng.End); hport++ {
177 | if leftToAssign == 0 {
178 | break
179 | }
180 |
181 | leftToAssign--
182 |
183 | tport := &task.Ports[leftToAssign]
184 | tport.HostPort = uint32(hport)
185 |
186 | if tport.ContainerPort == 0 {
187 | tport.ContainerPort = tport.HostPort
188 | }
189 |
190 | end = uint64(hport + 1)
191 |
192 | mappings = append(mappings, &mesosproto.ContainerInfo_DockerInfo_PortMapping{
193 | ContainerPort: proto.Uint32(tport.ContainerPort),
194 | HostPort: proto.Uint32(tport.HostPort),
195 | Protocol: proto.String(tport.Protocol),
196 | })
197 | }
198 |
199 | if start != end {
200 | resources = append(resources, mesosutil.NewValueRange(start, end))
201 | }
202 | }
203 | }
204 |
205 | return mappings, resources
206 | }
207 |
208 | func buildURIs(task eremetic.Task) []*mesosproto.CommandInfo_URI {
209 | var uris []*mesosproto.CommandInfo_URI
210 | for _, v := range task.FetchURIs {
211 | uris = append(uris, &mesosproto.CommandInfo_URI{
212 | Value: proto.String(v.URI),
213 | Extract: proto.Bool(v.Extract),
214 | Executable: proto.Bool(v.Executable),
215 | Cache: proto.Bool(v.Cache),
216 | })
217 | }
218 |
219 | return uris
220 | }
221 |
222 | func buildCommandInfo(task eremetic.Task, env *mesosproto.Environment) *mesosproto.CommandInfo {
223 | commandInfo := &mesosproto.CommandInfo{
224 | User: proto.String(task.User),
225 | Environment: env,
226 | Uris: buildURIs(task),
227 | }
228 |
229 | if task.Command != "" {
230 | commandInfo.Shell = proto.Bool(true)
231 | commandInfo.Value = &task.Command
232 | } else {
233 | commandInfo.Shell = proto.Bool(false)
234 | commandInfo.Arguments = task.Args
235 | }
236 |
237 | return commandInfo
238 | }
239 |
--------------------------------------------------------------------------------
/server/helpers.go:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "encoding/base64"
5 | "encoding/json"
6 | "errors"
7 | "fmt"
8 | "html/template"
9 | "io"
10 | "io/ioutil"
11 | "net/http"
12 | "net/url"
13 | "reflect"
14 | "strings"
15 |
16 | "github.com/sirupsen/logrus"
17 |
18 | "github.com/eremetic-framework/eremetic"
19 | "github.com/eremetic-framework/eremetic/api"
20 | "github.com/eremetic-framework/eremetic/config"
21 | "github.com/eremetic-framework/eremetic/server/assets"
22 | "github.com/eremetic-framework/eremetic/version"
23 | )
24 |
25 | // getFile handles the actual fetching of file from the agent.
26 | func getFile(file string, task eremetic.Task) (int, io.ReadCloser) {
27 | if task.SandboxPath == "" {
28 | return http.StatusNoContent, nil
29 | }
30 |
31 | url := fmt.Sprintf(
32 | "http://%s:%d/files/download?path=%s/%s",
33 | task.AgentIP,
34 | task.AgentPort,
35 | task.SandboxPath,
36 | file,
37 | )
38 |
39 | logrus.WithField("url", url).Debug("Fetching file from sandbox")
40 |
41 | response, err := http.Get(url)
42 |
43 | if err != nil {
44 | logrus.WithError(err).Errorf("Unable to fetch %s from agent %s.", file, task.AgentID)
45 | return http.StatusInternalServerError, ioutil.NopCloser(strings.NewReader("Unable to fetch upstream file."))
46 | }
47 |
48 | return http.StatusOK, response.Body
49 | }
50 |
51 | func handleError(err error, w http.ResponseWriter, message string) {
52 | if err == nil {
53 | return
54 | }
55 |
56 | errorMessage := errorDocument{
57 | err.Error(),
58 | message,
59 | }
60 |
61 | if err = writeJSON(422, errorMessage, w); err != nil {
62 | logrus.WithError(err).WithField("message", message).Panic("Unable to respond")
63 | }
64 | }
65 |
66 | func writeJSON(status int, data interface{}, w http.ResponseWriter) error {
67 | w.Header().Set("Content-Type", "application/json; charset=UTF-8")
68 | w.WriteHeader(status)
69 | return json.NewEncoder(w).Encode(data)
70 | }
71 |
72 | func renderHTML(w http.ResponseWriter, r *http.Request, task eremetic.Task, taskID string, conf *config.Config) {
73 | var templateFile string
74 |
75 | data := make(map[string]interface{})
76 | funcMap := template.FuncMap{
77 | "ToLower": strings.ToLower,
78 | "FormatTime": FormatTime,
79 | }
80 |
81 | if reflect.DeepEqual(task, (eremetic.Task{})) {
82 | notFound(w, r, conf)
83 | return
84 | }
85 |
86 | templateFile = "task.html"
87 | data = makeMap(task)
88 | data["Version"] = version.Version
89 | data["URLPrefix"] = conf.URLPrefix
90 |
91 | source, _ := assets.Asset(fmt.Sprintf("templates/%s", templateFile))
92 | tpl, err := template.New(templateFile).Funcs(funcMap).Parse(string(source))
93 |
94 | if err != nil {
95 | http.Error(w, err.Error(), http.StatusInternalServerError)
96 | logrus.WithError(err).WithField("template", templateFile).Error("Unable to load template")
97 | return
98 | }
99 |
100 | err = tpl.Execute(w, data)
101 | if err != nil {
102 | logrus.WithError(err).WithField("template", templateFile).Error("Unable to execute template")
103 | }
104 | }
105 |
106 | func notFound(w http.ResponseWriter, r *http.Request, conf *config.Config) {
107 | w.WriteHeader(http.StatusNotFound)
108 |
109 | data := make(map[string]interface{})
110 | data["URLPrefix"] = conf.URLPrefix
111 |
112 | if strings.Contains(r.Header.Get("Accept"), "text/html") {
113 | src, _ := assets.Asset("templates/error_404.html")
114 | tpl, err := template.New("404").Parse(string(src))
115 | if err != nil {
116 | logrus.WithError(err).WithField("template", "error_404.html").Error("Unable to load template")
117 | }
118 | err = tpl.Execute(w, data)
119 | if err != nil {
120 | logrus.WithError(err).WithField("template", "error_404.html").Error("Unable to execute template")
121 | }
122 | }
123 |
124 | w.Header().Set("Content-Type", "application/json; charset=UTF-8")
125 | json.NewEncoder(w).Encode(nil)
126 | }
127 |
128 | func makeMap(task eremetic.Task) map[string]interface{} {
129 | data := make(map[string]interface{})
130 |
131 | data["TaskID"] = task.ID
132 | data["CommandEnv"] = task.Environment
133 | data["CommandUser"] = task.User
134 | data["Command"] = task.Command
135 | // TODO: Support more than docker?
136 | data["ContainerImage"] = task.Image
137 | data["FrameworkID"] = task.FrameworkID
138 | data["Hostname"] = task.Hostname
139 | data["Name"] = task.Name
140 | data["AgentID"] = task.AgentID
141 | data["AgentConstraints"] = task.AgentConstraints
142 | data["Status"] = task.Status
143 | data["CPU"] = fmt.Sprintf("%.2f", task.TaskCPUs)
144 | data["Memory"] = fmt.Sprintf("%.2f", task.TaskMem)
145 | data["Terminated"] = task.IsTerminated()
146 |
147 | return data
148 | }
149 |
150 | func absURL(r *http.Request, path string, conf *config.Config) string {
151 | scheme := r.Header.Get("X-Forwarded-Proto")
152 | if scheme == "" {
153 | scheme = "http"
154 | }
155 |
156 | if conf.URLPrefix != "" {
157 | path = fmt.Sprintf("%s%s", conf.URLPrefix, path)
158 | logrus.WithField("path", path).Debug("absurl was computed")
159 | }
160 |
161 | url := url.URL{
162 | Scheme: scheme,
163 | Host: r.Host,
164 | Path: path,
165 | }
166 | return url.String()
167 | }
168 |
169 | func parseHTTPCredentials(credentials string) (string, string) {
170 | if credentials == "" {
171 | return "", ""
172 | }
173 |
174 | pair := strings.SplitN(credentials, ":", 2)
175 | if len(pair) != 2 {
176 | logrus.WithField("http_credentials", credentials).Error("using 'username:password' format for http_credentials")
177 | return "", ""
178 | }
179 |
180 | return pair[0], pair[1]
181 | }
182 |
183 | func checkAuth(r *http.Request, user string, password string) error {
184 | s := strings.SplitN(r.Header.Get("Authorization"), " ", 2)
185 | badErr := errors.New("bad authorization")
186 |
187 | if len(s) != 2 || s[0] != "Basic" {
188 | return badErr
189 | }
190 |
191 | b, err := base64.StdEncoding.DecodeString(s[1])
192 | if err != nil {
193 | return err
194 | }
195 |
196 | pair := strings.SplitN(string(b), ":", 2)
197 | if len(pair) != 2 {
198 | return badErr
199 | }
200 | if pair[0] != user || pair[1] != password {
201 | return badErr
202 | }
203 | return nil
204 | }
205 |
206 | func requireAuth(w http.ResponseWriter, r *http.Request) {
207 | if strings.Contains(r.Header.Get("Accept"), "text/html") {
208 | src, _ := assets.Asset("templates/error_401.html")
209 | tpl, err := template.New("401").Parse(string(src))
210 | if err == nil {
211 | w.Header().Set("WWW-Authenticate", `basic realm="Eremetic"`)
212 | w.WriteHeader(http.StatusUnauthorized)
213 | tpl.Execute(w, nil)
214 | return
215 | }
216 | logrus.WithError(err).WithField("template", "error_401.html").Error("Unable to load template")
217 | }
218 |
219 | w.Header().Set("Content-Type", "application/json; charset=UTF-8")
220 | w.WriteHeader(http.StatusUnauthorized)
221 | json.NewEncoder(w).Encode(nil)
222 | }
223 |
224 | func authWrap(fn http.Handler, username, password string) http.HandlerFunc {
225 | return func(w http.ResponseWriter, r *http.Request) {
226 |
227 | err := checkAuth(r, username, password)
228 | if err != nil {
229 | requireAuth(w, r)
230 | return
231 | }
232 |
233 | fn.ServeHTTP(w, r)
234 | }
235 | }
236 |
237 | func getTaskInfoV0(t eremetic.Task, conf *config.Config, id string, w http.ResponseWriter, r *http.Request) {
238 | if strings.Contains(r.Header.Get("Accept"), "text/html") {
239 | renderHTML(w, r, t, id, conf)
240 | } else {
241 | task := api.TaskV0FromTask(&t)
242 | if reflect.DeepEqual(task, (api.TaskV0{})) {
243 | writeJSON(http.StatusNotFound, nil, w)
244 | return
245 | }
246 | writeJSON(http.StatusOK, task, w)
247 | }
248 | }
249 |
250 | func getTaskInfoV1(t eremetic.Task, conf *config.Config, id string, w http.ResponseWriter, r *http.Request) {
251 | task := api.TaskV1FromTask(&t)
252 | if reflect.DeepEqual(task, (api.TaskV1{})) {
253 | writeJSON(http.StatusNotFound, nil, w)
254 | return
255 | }
256 | writeJSON(http.StatusOK, task, w)
257 | }
258 |
259 | func deprecated(w http.ResponseWriter) {
260 | w.Header().Set("Warning", "299 - 'Deprecated API'")
261 | }
262 |
--------------------------------------------------------------------------------
/boltdb/boltdb_test.go:
--------------------------------------------------------------------------------
1 | package boltdb
2 |
3 | import (
4 | "fmt"
5 | "io/ioutil"
6 | "os"
7 | "path/filepath"
8 | "testing"
9 | "time"
10 |
11 | . "github.com/smartystreets/goconvey/convey"
12 |
13 | "github.com/eremetic-framework/eremetic"
14 | )
15 |
16 | func TestBoltDatabase(t *testing.T) {
17 | var (
18 | testDB string
19 | db *TaskDB
20 | )
21 |
22 | setup := func() error {
23 | dir, _ := ioutil.TempDir("", "eremetic")
24 | testDB = fmt.Sprintf("%s/test.db", dir)
25 | adb, err := newCustomTaskDB(defaultConnector{}, testDB)
26 | if err != nil {
27 | return err
28 | }
29 |
30 | db = adb
31 |
32 | return nil
33 | }
34 |
35 | teardown := func() {
36 | os.Remove(testDB)
37 | }
38 |
39 | status := []eremetic.Status{
40 | eremetic.Status{
41 | Status: eremetic.TaskRunning,
42 | Time: time.Now().Unix(),
43 | },
44 | }
45 |
46 | Convey("NewDB", t, func() {
47 | Convey("With an absolute path", func() {
48 | setup()
49 | defer teardown()
50 |
51 | So(db.conn.Path(), ShouldNotBeEmpty)
52 | So(filepath.IsAbs(db.conn.Path()), ShouldBeTrue)
53 | })
54 | })
55 |
56 | Convey("createBoltDriver", t, func() {
57 | Convey("Error", func() {
58 | setup()
59 | defer teardown()
60 | defer db.Close()
61 |
62 | connector := new(mockConnector)
63 | _, err := newCustomTaskDB(connector, "")
64 |
65 | So(err, ShouldNotBeNil)
66 | So(err.Error(), ShouldEqual, "missing boltdb database location")
67 | })
68 | })
69 |
70 | Convey("Close", t, func() {
71 | setup()
72 | defer teardown()
73 | db.Close()
74 |
75 | So(db.conn.Path(), ShouldBeEmpty)
76 | })
77 |
78 | Convey("Clean", t, func() {
79 | setup()
80 | defer teardown()
81 | defer db.Close()
82 |
83 | db.PutTask(&eremetic.Task{ID: "1234"})
84 | task, _ := db.ReadTask("1234")
85 | So(task, ShouldNotEqual, eremetic.Task{})
86 | So(task.ID, ShouldNotBeEmpty)
87 |
88 | db.Clean()
89 |
90 | task, _ = db.ReadTask("1234")
91 | So(task, ShouldBeZeroValue)
92 | })
93 |
94 | Convey("Put and Read Task", t, func() {
95 | setup()
96 | defer teardown()
97 | defer db.Close()
98 |
99 | var maskedEnv = make(map[string]string)
100 | maskedEnv["foo"] = "bar"
101 |
102 | task1 := eremetic.Task{ID: "1234"}
103 | task2 := eremetic.Task{
104 | ID: "12345",
105 | TaskCPUs: 2.5,
106 | TaskMem: 15.3,
107 | Name: "request Name",
108 | Status: status,
109 | FrameworkID: "1234",
110 | Command: "echo date",
111 | User: "root",
112 | Image: "busybox",
113 | MaskedEnvironment: maskedEnv,
114 | }
115 |
116 | db.PutTask(&task1)
117 | db.PutTask(&task2)
118 |
119 | t1, err := db.ReadTask(task1.ID)
120 | So(t1, ShouldResemble, task1)
121 | So(err, ShouldBeNil)
122 | t2, err := db.ReadTask(task2.ID)
123 | So(err, ShouldBeNil)
124 | So(t2.MaskedEnvironment["foo"], ShouldEqual, "*******")
125 | })
126 |
127 | Convey("Read unmasked task", t, func() {
128 | setup()
129 | defer teardown()
130 | defer db.Close()
131 |
132 | var maskedEnv = make(map[string]string)
133 | maskedEnv["foo"] = "bar"
134 |
135 | task := eremetic.Task{
136 | ID: "12345",
137 | TaskCPUs: 2.5,
138 | TaskMem: 15.3,
139 | Name: "request Name",
140 | Status: status,
141 | FrameworkID: "1234",
142 | Command: "echo date",
143 | User: "root",
144 | Image: "busybox",
145 | MaskedEnvironment: maskedEnv,
146 | }
147 | db.PutTask(&task)
148 |
149 | t, err := db.ReadUnmaskedTask(task.ID)
150 | So(t, ShouldResemble, task)
151 | So(err, ShouldBeNil)
152 | So(t.MaskedEnvironment, ShouldContainKey, "foo")
153 | So(t.MaskedEnvironment["foo"], ShouldEqual, "bar")
154 |
155 | })
156 |
157 | Convey("List non-terminal tasks", t, func() {
158 | setup()
159 | defer teardown()
160 | defer db.Close()
161 |
162 | db.Clean()
163 |
164 | // A terminated task
165 | db.PutTask(&eremetic.Task{
166 | ID: "1234",
167 | Status: []eremetic.Status{
168 | eremetic.Status{
169 | Status: eremetic.TaskStaging,
170 | Time: time.Now().Unix(),
171 | },
172 | eremetic.Status{
173 | Status: eremetic.TaskRunning,
174 | Time: time.Now().Unix(),
175 | },
176 | eremetic.Status{
177 | Status: eremetic.TaskFinished,
178 | Time: time.Now().Unix(),
179 | },
180 | },
181 | })
182 |
183 | // A running task
184 | db.PutTask(&eremetic.Task{
185 | ID: "2345",
186 | Status: []eremetic.Status{
187 | eremetic.Status{
188 | Status: eremetic.TaskStaging,
189 | Time: time.Now().Unix(),
190 | },
191 | eremetic.Status{
192 | Status: eremetic.TaskRunning,
193 | Time: time.Now().Unix(),
194 | },
195 | },
196 | })
197 |
198 | tasks, err := db.ListTasks(&eremetic.TaskFilter{
199 | State: eremetic.DefaultTaskFilterState,
200 | })
201 | So(err, ShouldBeNil)
202 | So(tasks, ShouldHaveLength, 1)
203 | task := tasks[0]
204 | So(task.ID, ShouldEqual, "2345")
205 | })
206 |
207 | Convey("ListTasks", t, func() {
208 | setup()
209 | defer teardown()
210 | defer db.Close()
211 |
212 | db.Clean()
213 |
214 | // A terminated task
215 | db.PutTask(&eremetic.Task{
216 | ID: "1234",
217 | Status: []eremetic.Status{
218 | eremetic.Status{
219 | Status: eremetic.TaskStaging,
220 | Time: time.Now().Unix(),
221 | },
222 | eremetic.Status{
223 | Status: eremetic.TaskRunning,
224 | Time: time.Now().Unix(),
225 | },
226 | eremetic.Status{
227 | Status: eremetic.TaskFinished,
228 | Time: time.Now().Unix(),
229 | },
230 | },
231 | })
232 |
233 | // A running task
234 | db.PutTask(&eremetic.Task{
235 | ID: "2345",
236 | Status: []eremetic.Status{
237 | eremetic.Status{
238 | Status: eremetic.TaskStaging,
239 | Time: time.Now().Unix(),
240 | },
241 | eremetic.Status{
242 | Status: eremetic.TaskRunning,
243 | Time: time.Now().Unix(),
244 | },
245 | },
246 | })
247 | Convey("List default non terminated tasks", func() {
248 | tasks, err := db.ListTasks(&eremetic.TaskFilter{
249 | State: eremetic.DefaultTaskFilterState,
250 | })
251 | So(err, ShouldBeNil)
252 | So(tasks, ShouldHaveLength, 1)
253 | task := tasks[0]
254 | So(task.ID, ShouldEqual, "2345")
255 | })
256 |
257 | Convey("List terminated tasks", func() {
258 | tasks, err := db.ListTasks(&eremetic.TaskFilter{
259 | State: eremetic.TerminatedState,
260 | })
261 | So(err, ShouldBeNil)
262 | So(tasks, ShouldHaveLength, 1)
263 | task := tasks[0]
264 | So(task.ID, ShouldEqual, "1234")
265 | })
266 | })
267 |
268 | Convey("DeleteTask", t, func() {
269 | Convey("Success", func() {
270 | setup()
271 | defer teardown()
272 | defer db.Close()
273 | db.Clean()
274 |
275 | var maskedEnv = make(map[string]string)
276 | maskedEnv["foo"] = "bar"
277 |
278 | task1 := eremetic.Task{ID: "1234"}
279 | db.PutTask(&task1)
280 | t1, err := db.ReadUnmaskedTask(task1.ID)
281 | So(t1, ShouldResemble, task1)
282 | So(err, ShouldBeNil)
283 |
284 | err = db.DeleteTask(task1.ID)
285 | So(err, ShouldBeNil)
286 | })
287 | })
288 |
289 | Convey("List non-terminal tasks no running task", t, func() {
290 | setup()
291 | defer teardown()
292 | defer db.Close()
293 |
294 | db.Clean()
295 | db.PutTask(&eremetic.Task{
296 | ID: "1234",
297 | Status: []eremetic.Status{
298 | eremetic.Status{
299 | Status: eremetic.TaskStaging,
300 | Time: time.Now().Unix(),
301 | },
302 | eremetic.Status{
303 | Status: eremetic.TaskRunning,
304 | Time: time.Now().Unix(),
305 | },
306 | eremetic.Status{
307 | Status: eremetic.TaskFinished,
308 | Time: time.Now().Unix(),
309 | },
310 | },
311 | })
312 | tasks, err := db.ListTasks(&eremetic.TaskFilter{
313 | State: eremetic.DefaultTaskFilterState,
314 | })
315 | So(err, ShouldBeNil)
316 | So(tasks, ShouldBeEmpty)
317 | So(tasks, ShouldNotBeNil)
318 | })
319 | }
320 |
--------------------------------------------------------------------------------
/server/server_test.go:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "bytes"
5 | "errors"
6 | "net/http"
7 | "net/http/httptest"
8 | "net/url"
9 | "strconv"
10 | "strings"
11 | "testing"
12 |
13 | . "github.com/smartystreets/goconvey/convey"
14 |
15 | "github.com/eremetic-framework/eremetic"
16 | "github.com/eremetic-framework/eremetic/config"
17 | "github.com/eremetic-framework/eremetic/mock"
18 | )
19 |
20 | func TestServer(t *testing.T) {
21 | Convey("Server", t, func() {
22 | Convey("AddTask", func() {
23 | Convey("Simple", func() {
24 | sched := mock.Scheduler{
25 | ScheduleTaskFn: func(req eremetic.Request) (string, error) {
26 | return "task_id", nil
27 | },
28 | }
29 |
30 | db := mock.TaskDB{}
31 | cfg := config.Config{}
32 |
33 | srv := NewRouter(&sched, &cfg, &db)
34 |
35 | var body bytes.Buffer
36 | body.WriteString(`{}`)
37 |
38 | rec := httptest.NewRecorder()
39 | r, _ := http.NewRequest("POST", "http://example.com/task", &body)
40 |
41 | srv.ServeHTTP(rec, r)
42 |
43 | So(rec.Code, ShouldEqual, http.StatusAccepted)
44 | })
45 | Convey("QueueFull", func() {
46 | sched := mock.Scheduler{
47 | ScheduleTaskFn: func(req eremetic.Request) (string, error) {
48 | return "", eremetic.ErrQueueFull
49 | },
50 | }
51 |
52 | db := mock.TaskDB{}
53 | cfg := config.Config{}
54 |
55 | srv := NewRouter(&sched, &cfg, &db)
56 |
57 | var body bytes.Buffer
58 | body.WriteString(`{}`)
59 |
60 | rec := httptest.NewRecorder()
61 | r, _ := http.NewRequest("POST", "http://example.com/task", &body)
62 |
63 | srv.ServeHTTP(rec, r)
64 |
65 | So(rec.Code, ShouldEqual, http.StatusServiceUnavailable)
66 | })
67 | Convey("UnknownError", func() {
68 | sched := mock.Scheduler{
69 | ScheduleTaskFn: func(req eremetic.Request) (string, error) {
70 | return "", errors.New("unknown error")
71 | },
72 | }
73 |
74 | db := mock.TaskDB{}
75 | cfg := config.Config{}
76 |
77 | srv := NewRouter(&sched, &cfg, &db)
78 |
79 | var body bytes.Buffer
80 | body.WriteString(`{}`)
81 |
82 | rec := httptest.NewRecorder()
83 | r, _ := http.NewRequest("POST", "http://example.com/task", &body)
84 |
85 | srv.ServeHTTP(rec, r)
86 |
87 | So(rec.Code, ShouldEqual, http.StatusInternalServerError)
88 | })
89 | })
90 | Convey("GetFromSandBox", func() {
91 | Convey("Simple", func() {
92 | ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
93 | w.Write([]byte("OK"))
94 | }))
95 | defer ts.Close()
96 |
97 | agentURL, _ := url.Parse(ts.URL)
98 | host := strings.Split(agentURL.Host, ":")
99 | port, _ := strconv.ParseInt(host[1], 10, 64)
100 |
101 | sched := mock.Scheduler{}
102 |
103 | db := mock.TaskDB{
104 | ReadTaskFn: func(id string) (eremetic.Task, error) {
105 | return eremetic.Task{
106 | ID: id,
107 | AgentIP: host[0],
108 | AgentPort: int32(port),
109 | SandboxPath: "/tmp",
110 | }, nil
111 | },
112 | }
113 |
114 | cfg := config.Config{}
115 |
116 | srv := NewRouter(&sched, &cfg, &db)
117 |
118 | rec := httptest.NewRecorder()
119 | r, _ := http.NewRequest("GET", "http://example.com/task/test_id/stdout", nil)
120 |
121 | srv.ServeHTTP(rec, r)
122 |
123 | So(rec.Code, ShouldEqual, http.StatusOK)
124 | So(rec.Body.String(), ShouldEqual, "OK")
125 | })
126 | Convey("MissingSandboxPath", func() {
127 | sched := mock.Scheduler{}
128 |
129 | db := mock.TaskDB{
130 | ReadTaskFn: func(id string) (eremetic.Task, error) {
131 | return eremetic.Task{
132 | ID: id,
133 | }, nil
134 | },
135 | }
136 |
137 | cfg := config.Config{}
138 |
139 | srv := NewRouter(&sched, &cfg, &db)
140 |
141 | rec := httptest.NewRecorder()
142 | r, _ := http.NewRequest("GET", "http://example.com/task/test_id/stdout", nil)
143 |
144 | srv.ServeHTTP(rec, r)
145 |
146 | So(rec.Code, ShouldEqual, http.StatusNoContent)
147 | })
148 | })
149 | Convey("GetTaskInfo", func() {
150 | Convey("Simple", func() {
151 | sched := mock.Scheduler{}
152 |
153 | db := mock.TaskDB{
154 | ReadTaskFn: func(id string) (eremetic.Task, error) {
155 | return eremetic.Task{
156 | ID: id,
157 | }, nil
158 | },
159 | }
160 |
161 | cfg := config.Config{}
162 |
163 | srv := NewRouter(&sched, &cfg, &db)
164 |
165 | rec := httptest.NewRecorder()
166 | r, _ := http.NewRequest("GET", "http://example.com/task/test_id", nil)
167 |
168 | srv.ServeHTTP(rec, r)
169 |
170 | So(rec.Code, ShouldEqual, http.StatusOK)
171 | })
172 | Convey("TaskNotFound", func() {
173 | sched := mock.Scheduler{}
174 |
175 | db := mock.TaskDB{
176 | ReadTaskFn: func(id string) (eremetic.Task, error) {
177 | return eremetic.Task{}, nil
178 | },
179 | }
180 |
181 | cfg := config.Config{}
182 |
183 | srv := NewRouter(&sched, &cfg, &db)
184 |
185 | rec := httptest.NewRecorder()
186 | r, _ := http.NewRequest("GET", "http://example.com/task/unknown_id", nil)
187 |
188 | srv.ServeHTTP(rec, r)
189 |
190 | So(rec.Code, ShouldEqual, http.StatusNotFound)
191 | })
192 | })
193 | Convey("ListRunningTasks", func() {
194 | Convey("Simple", func() {
195 | sched := mock.Scheduler{}
196 |
197 | db := mock.TaskDB{
198 | ListTasksFn: func(filter *eremetic.TaskFilter) ([]*eremetic.Task, error) {
199 | return []*eremetic.Task{}, nil
200 | },
201 | }
202 |
203 | cfg := config.Config{}
204 |
205 | srv := NewRouter(&sched, &cfg, &db)
206 |
207 | rec := httptest.NewRecorder()
208 | r, _ := http.NewRequest("GET", "http://example.com/task", nil)
209 |
210 | srv.ServeHTTP(rec, r)
211 |
212 | So(rec.Code, ShouldEqual, http.StatusOK)
213 | })
214 | })
215 | Convey("Index", func() {
216 | Convey("Simple", func() {
217 | sched := mock.Scheduler{}
218 |
219 | db := mock.TaskDB{
220 | ListNonTerminalTasksFn: func() ([]*eremetic.Task, error) {
221 | return []*eremetic.Task{}, nil
222 | },
223 | }
224 |
225 | cfg := config.Config{}
226 |
227 | srv := NewRouter(&sched, &cfg, &db)
228 |
229 | rec := httptest.NewRecorder()
230 | r, _ := http.NewRequest("GET", "http://example.com/", nil)
231 | r.Header.Set("Accept", "text/html")
232 |
233 | srv.ServeHTTP(rec, r)
234 |
235 | So(rec.Code, ShouldEqual, http.StatusOK)
236 | })
237 | Convey("DoesNotAcceptHTML", func() {
238 | sched := mock.Scheduler{}
239 |
240 | db := mock.TaskDB{
241 | ListNonTerminalTasksFn: func() ([]*eremetic.Task, error) {
242 | return []*eremetic.Task{}, nil
243 | },
244 | }
245 |
246 | cfg := config.Config{}
247 |
248 | srv := NewRouter(&sched, &cfg, &db)
249 |
250 | rec := httptest.NewRecorder()
251 | r, _ := http.NewRequest("GET", "http://example.com/", nil)
252 |
253 | srv.ServeHTTP(rec, r)
254 |
255 | So(rec.Code, ShouldEqual, http.StatusNoContent)
256 | })
257 | })
258 | Convey("Auth", func() {
259 | Convey("IndexUnauthorized", func() {
260 | sched := mock.Scheduler{}
261 |
262 | db := mock.TaskDB{
263 | ListNonTerminalTasksFn: func() ([]*eremetic.Task, error) {
264 | return []*eremetic.Task{}, nil
265 | },
266 | }
267 |
268 | cfg := config.Config{HTTPCredentials: "admin:admin"}
269 |
270 | srv := NewRouter(&sched, &cfg, &db)
271 |
272 | rec := httptest.NewRecorder()
273 | r, _ := http.NewRequest("GET", "http://example.com/", nil)
274 | r.Header.Set("Accept", "text/html")
275 |
276 | srv.ServeHTTP(rec, r)
277 |
278 | So(rec.Code, ShouldEqual, http.StatusUnauthorized)
279 | })
280 |
281 | Convey("IndexOK", func() {
282 | sched := mock.Scheduler{}
283 |
284 | db := mock.TaskDB{
285 | ListNonTerminalTasksFn: func() ([]*eremetic.Task, error) {
286 | return []*eremetic.Task{}, nil
287 | },
288 | }
289 |
290 | cfg := config.Config{HTTPCredentials: "admin:admin"}
291 |
292 | srv := NewRouter(&sched, &cfg, &db)
293 |
294 | rec := httptest.NewRecorder()
295 | r, _ := http.NewRequest("GET", "http://example.com/", nil)
296 | r.Header.Set("Accept", "text/html")
297 | r.SetBasicAuth("admin", "admin")
298 |
299 | srv.ServeHTTP(rec, r)
300 |
301 | So(rec.Code, ShouldEqual, http.StatusOK)
302 | })
303 | })
304 | })
305 | }
306 |
--------------------------------------------------------------------------------
/mock/mesos_scheduler.go:
--------------------------------------------------------------------------------
1 | package mock
2 |
3 | import (
4 | "github.com/mesos/mesos-go/api/v0/mesosproto"
5 | "github.com/mesos/mesos-go/api/v0/scheduler"
6 | )
7 |
8 | // MesosScheduler implements a mocked mesos scheduler iterface for testing
9 | type MesosScheduler struct {
10 | AbortFn func() (mesosproto.Status, error)
11 | AbortFnInvoked bool
12 | AcceptOffersFn func([]*mesosproto.OfferID, []*mesosproto.Offer_Operation, *mesosproto.Filters) (mesosproto.Status, error)
13 | AcceptOffersFnInvoked bool
14 | DeclineOfferFn func(*mesosproto.OfferID, *mesosproto.Filters) (mesosproto.Status, error)
15 | DeclineOfferFnInvoked bool
16 | JoinFn func() (mesosproto.Status, error)
17 | JoinFnInvoked bool
18 | KillTaskFn func(*mesosproto.TaskID) (mesosproto.Status, error)
19 | KillTaskFnInvoked bool
20 | ReconcileTasksFn func([]*mesosproto.TaskStatus) (mesosproto.Status, error)
21 | ReconcileTasksFnInvoked bool
22 | RequestResourcesFn func([]*mesosproto.Request) (mesosproto.Status, error)
23 | RequestResourcesFnInvoked bool
24 | ReviveOffersFn func() (mesosproto.Status, error)
25 | ReviveOffersFnInvoked bool
26 | RunFn func() (mesosproto.Status, error)
27 | RunFnInvoked bool
28 | StartFn func() (mesosproto.Status, error)
29 | StartFnInvoked bool
30 | StopFn func(bool) (mesosproto.Status, error)
31 | StopFnInvoked bool
32 | SendFrameworkMessageFn func(*mesosproto.ExecutorID, *mesosproto.SlaveID, string) (mesosproto.Status, error)
33 | SendFrameworkMessageFnInvoked bool
34 | LaunchTasksFn func([]*mesosproto.OfferID, []*mesosproto.TaskInfo, *mesosproto.Filters) (mesosproto.Status, error)
35 | LaunchTasksFnInvoked bool
36 | RegisteredFn func(scheduler.SchedulerDriver, *mesosproto.FrameworkID, *mesosproto.MasterInfo)
37 | RegisteredFnInvoked bool
38 | ReregisteredFn func(scheduler.SchedulerDriver, *mesosproto.MasterInfo)
39 | ReregisteredFnInvoked bool
40 | DisconnectedFn func(scheduler.SchedulerDriver)
41 | DisconnectedFnInvoked bool
42 | ResourceOffersFn func(scheduler.SchedulerDriver, []*mesosproto.Offer)
43 | ResourceOffersFnInvoked bool
44 | OfferRescindedFn func(scheduler.SchedulerDriver, *mesosproto.OfferID)
45 | OfferRescindedFnInvoked bool
46 | StatusUpdateFn func(scheduler.SchedulerDriver, *mesosproto.TaskStatus)
47 | StatusUpdateFnInvoked bool
48 | FrameworkMessageFn func(scheduler.SchedulerDriver, *mesosproto.ExecutorID, *mesosproto.SlaveID, string)
49 | FrameworkMessageFnInvoked bool
50 | SlaveLostFn func(scheduler.SchedulerDriver, *mesosproto.SlaveID)
51 | SlaveLostFnInvoked bool
52 | ExecutorLostFn func(scheduler.SchedulerDriver, *mesosproto.ExecutorID, *mesosproto.SlaveID, int)
53 | ExecutorLostFnInvoked bool
54 | ErrorFn func(scheduler.SchedulerDriver, string)
55 | ErrorFnInvoked bool
56 | }
57 |
58 | // NewMesosScheduler returns a new mocked mesos scheduler
59 | func NewMesosScheduler() *MesosScheduler {
60 | return &MesosScheduler{}
61 | }
62 |
63 | // Abort mocks the abort functionality
64 | func (m *MesosScheduler) Abort() (stat mesosproto.Status, err error) {
65 | m.AbortFnInvoked = true
66 | return m.AbortFn()
67 | }
68 |
69 | // AcceptOffers mocks the AcceptOffers functionality
70 | func (m *MesosScheduler) AcceptOffers(offerIds []*mesosproto.OfferID, operations []*mesosproto.Offer_Operation, filters *mesosproto.Filters) (mesosproto.Status, error) {
71 | m.AcceptOffersFnInvoked = true
72 | return m.AcceptOffersFn(offerIds, operations, filters)
73 | }
74 |
75 | // DeclineOffer mocks the DeclineOffer functionality
76 | func (m *MesosScheduler) DeclineOffer(offerID *mesosproto.OfferID, filters *mesosproto.Filters) (mesosproto.Status, error) {
77 | m.DeclineOfferFnInvoked = true
78 | return m.DeclineOfferFn(offerID, filters)
79 | }
80 |
81 | // Join mocks the Join functionality
82 | func (m *MesosScheduler) Join() (mesosproto.Status, error) {
83 | m.JoinFnInvoked = true
84 | return m.JoinFn()
85 | }
86 |
87 | // KillTask mocks the KillTask functionality
88 | func (m *MesosScheduler) KillTask(id *mesosproto.TaskID) (mesosproto.Status, error) {
89 | m.KillTaskFnInvoked = true
90 | return m.KillTaskFn(id)
91 | }
92 |
93 | // ReconcileTasks mocks the ReconcileTasks functionality
94 | func (m *MesosScheduler) ReconcileTasks(ts []*mesosproto.TaskStatus) (mesosproto.Status, error) {
95 | m.ReconcileTasksFnInvoked = true
96 | return m.ReconcileTasksFn(ts)
97 | }
98 |
99 | // RequestResources mocks the RequestResources functionality
100 | func (m *MesosScheduler) RequestResources(r []*mesosproto.Request) (mesosproto.Status, error) {
101 | m.RequestResourcesFnInvoked = true
102 | return m.RequestResourcesFn(r)
103 | }
104 |
105 | // ReviveOffers mocks the ReviveOffers functionality
106 | func (m *MesosScheduler) ReviveOffers() (mesosproto.Status, error) {
107 | m.ReviveOffersFnInvoked = true
108 | return m.ReviveOffersFn()
109 | }
110 |
111 | // Run mocks the Run functionality
112 | func (m *MesosScheduler) Run() (mesosproto.Status, error) {
113 | m.RunFnInvoked = true
114 | return m.RunFn()
115 | }
116 |
117 | // Start mocks the Start functionality
118 | func (m *MesosScheduler) Start() (mesosproto.Status, error) {
119 | m.StartFnInvoked = true
120 | return m.StartFn()
121 | }
122 |
123 | // Stop mocks the Stop functionality
124 | func (m *MesosScheduler) Stop(b bool) (mesosproto.Status, error) {
125 | m.StopFnInvoked = true
126 | return m.StopFn(b)
127 | }
128 |
129 | // SendFrameworkMessage mocks the SendFrameworkMessage functionality
130 | func (m *MesosScheduler) SendFrameworkMessage(eID *mesosproto.ExecutorID, sID *mesosproto.SlaveID, s string) (mesosproto.Status, error) {
131 | m.SendFrameworkMessageFnInvoked = true
132 | return m.SendFrameworkMessageFn(eID, sID, s)
133 | }
134 |
135 | // LaunchTasks mocks the LaunchTasks functionality
136 | func (m *MesosScheduler) LaunchTasks(o []*mesosproto.OfferID, t []*mesosproto.TaskInfo, f *mesosproto.Filters) (mesosproto.Status, error) {
137 | m.LaunchTasksFnInvoked = true
138 | return m.LaunchTasksFn(o, t, f)
139 | }
140 |
141 | // Registered mocks the Registered functionality
142 | func (m *MesosScheduler) Registered(s scheduler.SchedulerDriver, f *mesosproto.FrameworkID, minfo *mesosproto.MasterInfo) {
143 | m.RegisteredFnInvoked = true
144 | m.RegisteredFn(s, f, minfo)
145 | }
146 |
147 | // Reregistered mocks the Reregistered functionality
148 | func (m *MesosScheduler) Reregistered(s scheduler.SchedulerDriver, info *mesosproto.MasterInfo) {
149 | m.ReregisteredFnInvoked = true
150 | m.ReregisteredFn(s, info)
151 | }
152 |
153 | // Disconnected mocks the Disconnected functionality
154 | func (m *MesosScheduler) Disconnected(s scheduler.SchedulerDriver) {
155 | m.DisconnectedFnInvoked = true
156 | m.DisconnectedFn(s)
157 | }
158 |
159 | // ResourceOffers mocks the ResourceOffers functionality
160 | func (m *MesosScheduler) ResourceOffers(s scheduler.SchedulerDriver, o []*mesosproto.Offer) {
161 | m.ResourceOffersFnInvoked = true
162 | m.ResourceOffersFn(s, o)
163 | }
164 |
165 | // OfferRescinded mocks the OfferRescinded functionality
166 | func (m *MesosScheduler) OfferRescinded(s scheduler.SchedulerDriver, o *mesosproto.OfferID) {
167 | m.OfferRescindedFnInvoked = true
168 | m.OfferRescindedFn(s, o)
169 | }
170 |
171 | // StatusUpdate mocks the StatusUpdate functionality
172 | func (m *MesosScheduler) StatusUpdate(s scheduler.SchedulerDriver, ts *mesosproto.TaskStatus) {
173 | m.StatusUpdateFnInvoked = true
174 | m.StatusUpdateFn(s, ts)
175 | }
176 |
177 | // FrameworkMessage mocks the FrameworkMessage functionality
178 | func (m *MesosScheduler) FrameworkMessage(sd scheduler.SchedulerDriver, eID *mesosproto.ExecutorID, sID *mesosproto.SlaveID, s string) {
179 | m.FrameworkMessageFnInvoked = true
180 | m.FrameworkMessageFn(sd, eID, sID, s)
181 | }
182 |
183 | // SlaveLost mocks the SlaveLost functionality
184 | func (m *MesosScheduler) SlaveLost(s scheduler.SchedulerDriver, sID *mesosproto.SlaveID) {
185 | m.SlaveLostFnInvoked = true
186 | m.SlaveLostFn(s, sID)
187 | }
188 |
189 | // ExecutorLost mocks the ExecutorLost functionality
190 | func (m *MesosScheduler) ExecutorLost(sd scheduler.SchedulerDriver, eID *mesosproto.ExecutorID, sID *mesosproto.SlaveID, i int) {
191 | m.ExecutorLostFnInvoked = true
192 | m.ExecutorLostFn(sd, eID, sID, i)
193 | }
194 |
195 | // Error mocks the Error functionality
196 | func (m *MesosScheduler) Error(d scheduler.SchedulerDriver, msg string) {
197 | m.ErrorFnInvoked = true
198 | m.ErrorFn(d, msg)
199 | }
200 |
--------------------------------------------------------------------------------
/server/handler.go:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "encoding/json"
5 | "errors"
6 | "fmt"
7 | "html/template"
8 | "io"
9 | "io/ioutil"
10 | "net/http"
11 | "strings"
12 |
13 | "github.com/sirupsen/logrus"
14 | "github.com/elazarl/go-bindata-assetfs"
15 | "github.com/gorilla/mux"
16 | "github.com/gorilla/schema"
17 |
18 | "github.com/eremetic-framework/eremetic"
19 | "github.com/eremetic-framework/eremetic/api"
20 | "github.com/eremetic-framework/eremetic/config"
21 | "github.com/eremetic-framework/eremetic/server/assets"
22 | "github.com/eremetic-framework/eremetic/version"
23 | )
24 |
25 | type errorDocument struct {
26 | Error string `json:"error"`
27 | Message string `json:"message"`
28 | }
29 |
30 | // Handler holds the server context.
31 | type Handler struct {
32 | scheduler eremetic.Scheduler
33 | database eremetic.TaskDB
34 | }
35 |
36 | // NewHandler returns a new instance of Handler.
37 | func NewHandler(scheduler eremetic.Scheduler, database eremetic.TaskDB) Handler {
38 | return Handler{
39 | scheduler: scheduler,
40 | database: database,
41 | }
42 | }
43 |
44 | // AddTask handles adding a task to the queue
45 | func (h Handler) AddTask(conf *config.Config, apiVersion string) http.HandlerFunc {
46 | return func(w http.ResponseWriter, r *http.Request) {
47 | var request eremetic.Request
48 |
49 | body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
50 | if err != nil {
51 | handleError(err, w, "Unable to read payload.")
52 | return
53 | }
54 | format := ""
55 | switch apiVersion {
56 | case api.V0:
57 | deprecated(w)
58 | var req api.RequestV0
59 | err = json.Unmarshal(body, &req)
60 | request = api.RequestFromV0(req)
61 | format = "/task/%s"
62 | if err != nil {
63 | handleError(err, w, "Unable to parse body into a valid request.")
64 | return
65 | }
66 | case api.V1:
67 | var req api.RequestV1
68 | err = json.Unmarshal(body, &req)
69 | request = api.RequestFromV1(req)
70 | format = "/api/v1/task/%s"
71 | if err != nil {
72 | handleError(err, w, "Unable to parse body into a valid request.")
73 | return
74 | }
75 | default:
76 | handleError(errors.New("Invalid API version"), w, "Invalid API version.")
77 | return
78 | }
79 |
80 | taskID, err := h.scheduler.ScheduleTask(request)
81 | location := fmt.Sprintf(format, taskID)
82 |
83 | if err != nil {
84 | logrus.WithError(err).Error("Unable to create task.")
85 | httpStatus := 500
86 | if err == eremetic.ErrQueueFull {
87 | httpStatus = 503
88 | }
89 | errorMessage := errorDocument{
90 | err.Error(),
91 | "Unable to schedule task",
92 | }
93 | writeJSON(httpStatus, errorMessage, w)
94 | return
95 | }
96 |
97 | w.Header().Set("Location", absURL(r, location, conf))
98 | writeJSON(http.StatusAccepted, taskID, w)
99 | }
100 | }
101 |
102 | // GetFromSandbox fetches a file from the sandbox of the agent that ran the task
103 | func (h Handler) GetFromSandbox(file string, apiVersion string) http.HandlerFunc {
104 | return func(w http.ResponseWriter, r *http.Request) {
105 | if apiVersion == api.V0 {
106 | deprecated(w)
107 | }
108 | vars := mux.Vars(r)
109 | taskID := vars["taskId"]
110 | task, _ := h.database.ReadTask(taskID)
111 |
112 | status, data := getFile(file, task)
113 |
114 | if status != http.StatusOK {
115 | writeJSON(status, data, w)
116 | return
117 | }
118 |
119 | defer data.Close()
120 | w.Header().Set("Content-Type", "text/plain; charset=UTF-8")
121 | w.WriteHeader(http.StatusOK)
122 | io.Copy(w, data)
123 | }
124 | }
125 |
126 | // GetTaskInfo returns information about the given task.
127 | func (h Handler) GetTaskInfo(conf *config.Config, apiVersion string) http.HandlerFunc {
128 | return func(w http.ResponseWriter, r *http.Request) {
129 | vars := mux.Vars(r)
130 | id := vars["taskId"]
131 | logrus.WithField("task_id", id).Debug("Fetching task")
132 | task0, _ := h.database.ReadTask(id)
133 | switch apiVersion {
134 | case api.V0:
135 | deprecated(w)
136 | getTaskInfoV0(task0, conf, id, w, r)
137 | case api.V1:
138 | getTaskInfoV1(task0, conf, id, w, r)
139 | }
140 | }
141 | }
142 |
143 | // ListTasks returns information about running tasks in the database.
144 | func (h Handler) ListTasks(apiVersion string) http.HandlerFunc {
145 | return func(w http.ResponseWriter, r *http.Request) {
146 | filter := &eremetic.TaskFilter{
147 | State: eremetic.DefaultTaskFilterState,
148 | }
149 | if err := schema.NewDecoder().Decode(filter, r.URL.Query()); err != nil {
150 | handleError(err, w, "Unable to parse query params")
151 | return
152 | }
153 | logrus.Debug("Fetching all tasks")
154 | tasks, err := h.database.ListTasks(filter)
155 | if err != nil {
156 | handleError(err, w, "Unable to fetch running tasks from the database")
157 | return
158 | }
159 | switch apiVersion {
160 | case api.V0:
161 | deprecated(w)
162 | tasksV0 := []api.TaskV0{}
163 | for _, t := range tasks {
164 | tasksV0 = append(tasksV0, api.TaskV0FromTask(t))
165 | }
166 | writeJSON(200, tasksV0, w)
167 | case api.V1:
168 | tasksV1 := []api.TaskV1{}
169 | for _, t := range tasks {
170 | tasksV1 = append(tasksV1, api.TaskV1FromTask(t))
171 | }
172 | writeJSON(200, tasksV1, w)
173 | }
174 | }
175 | }
176 |
177 | // IndexHandler returns the index template, or no content.
178 | func (h Handler) IndexHandler(conf *config.Config) http.HandlerFunc {
179 | return func(w http.ResponseWriter, r *http.Request) {
180 | if strings.Contains(r.Header.Get("Accept"), "text/html") {
181 | src, _ := assets.Asset("templates/index.html")
182 | tpl, err := template.New("index").Parse(string(src))
183 | data := make(map[string]interface{})
184 | data["Version"] = version.Version
185 | data["URLPrefix"] = conf.URLPrefix
186 | if err == nil {
187 | tpl.Execute(w, data)
188 | return
189 | }
190 | logrus.WithError(err).WithField("template", "index.html").Error("Unable to load template")
191 | }
192 |
193 | w.Header().Set("Content-Type", "application/json; charset=UTF-8")
194 | w.WriteHeader(http.StatusNoContent)
195 | json.NewEncoder(w).Encode(nil)
196 | }
197 | }
198 |
199 | // Version returns the currently running Eremetic version.
200 | func (h Handler) Version(conf *config.Config, apiVersion string) http.HandlerFunc {
201 | return func(w http.ResponseWriter, r *http.Request) {
202 | if apiVersion == api.V0 {
203 | deprecated(w)
204 | }
205 | w.Header().Set("Content-Type", "text/plain; charset=UTF-8")
206 | w.WriteHeader(http.StatusOK)
207 | json.NewEncoder(w).Encode(version.Version)
208 | }
209 | }
210 |
211 | // NotFound is in charge of reporting that a task can not be found.
212 | func (h Handler) NotFound(conf *config.Config) http.HandlerFunc {
213 | return func(w http.ResponseWriter, r *http.Request) {
214 | // Proxy to the notFound helper function
215 | notFound(w, r, conf)
216 | }
217 | }
218 |
219 | // StaticAssets handles the serving of compiled static assets.
220 | func (h Handler) StaticAssets() http.Handler {
221 | return http.StripPrefix(
222 | "/static/", http.FileServer(
223 | &assetfs.AssetFS{Asset: assets.Asset, AssetDir: assets.AssetDir, AssetInfo: assets.AssetInfo, Prefix: "static"}))
224 | }
225 |
226 | // KillTask handles killing a task.
227 | func (h Handler) KillTask(conf *config.Config, apiVersion string) http.HandlerFunc {
228 | return func(w http.ResponseWriter, r *http.Request) {
229 | if apiVersion == api.V0 {
230 | deprecated(w)
231 | }
232 | vars := mux.Vars(r)
233 | id := vars["taskId"]
234 | logrus.WithField("task_id", id).Debug("Killing task")
235 | err := h.scheduler.Kill(id)
236 | respStatus := http.StatusAccepted
237 | var body string
238 | if err != nil {
239 | respStatus = http.StatusInternalServerError
240 | body = err.Error()
241 | }
242 | writeJSON(respStatus, body, w)
243 | }
244 | }
245 |
246 | // DeleteTask takes care of API calls to remove a task
247 | func (h Handler) DeleteTask(conf *config.Config, apiVersion string) http.HandlerFunc {
248 | return func(w http.ResponseWriter, r *http.Request) {
249 | if apiVersion == api.V0 {
250 | deprecated(w)
251 | }
252 | vars := mux.Vars(r)
253 | id := vars["taskId"]
254 | logrus.WithField("task_id", id).Debug("Deleting task")
255 | respStatus := http.StatusAccepted
256 | var body string
257 | task, err := h.database.ReadTask(id)
258 | if err != nil {
259 | respStatus = http.StatusNotFound
260 | writeJSON(respStatus, err.Error(), w)
261 | return
262 | }
263 | if task.IsRunning() {
264 | respStatus = http.StatusConflict
265 | errMsg := fmt.Sprintf("Cannot delete the task [%s]. As it is still running.", id)
266 | logrus.WithField("task_id", id).Debug(errMsg)
267 | writeJSON(respStatus, errMsg, w)
268 | return
269 | }
270 | err = h.database.DeleteTask(id)
271 | if err != nil {
272 | respStatus = http.StatusInternalServerError
273 | body = err.Error()
274 | }
275 | writeJSON(respStatus, body, w)
276 | }
277 | }
278 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # 34 | {{.Name}} 35 |
36 | 37 |
38 |
145 |
146 |
39 |
40 |
41 |
43 |
64 |
40 |
41 | Container
42 |
43 |
44 |
63 |
45 |
46 |
50 |
47 | {{.ContainerImage}}
48 |
49 |
51 |
52 |
56 |
53 | {{.CommandUser}}
54 |
55 |
57 |
58 |
62 |
59 | {{.Command}}
60 |
61 |
65 |
66 |
67 |
76 |
126 |
66 |
67 |
68 | Task Info
69 | {{if not .Terminated}}
70 |
71 |
72 |
73 | {{end}}
74 |
75 |
76 |
77 | {{if .FrameworkID}}
78 |
125 |
79 |
80 |
84 | {{end}}
85 | {{if .Hostname}}
86 |
81 | {{.FrameworkID}}
82 |
83 |
87 |
88 |
92 | {{end}}
93 | {{if .AgentID}}
94 |
89 | {{.Hostname}}
90 |
91 |
95 |
96 |
100 | {{end}}
101 |
97 | {{.AgentID}}
98 |
99 |
102 |
103 |
107 |
104 | {{.CPU}}
105 |
106 |
108 |
109 |
113 | {{if .AgentConstraints}}
114 |
110 | {{.Memory}}
111 |
112 |
115 |
116 |
123 | {{end}}
124 |
117 | Agent constraints:
118 | {{range $index, $constraint := .AgentConstraints}}
119 |
{{$constraint.AttributeName}}={{$constraint.AttributeValue}} 120 | {{end}} 121 |
122 | {{$constraint.AttributeName}}={{$constraint.AttributeValue}} 120 | {{end}} 121 |
127 |
128 |
129 |
131 |
144 |
128 |
129 | Status
130 |
131 |
132 | {{range .Status}}
133 |
143 |
134 |
141 | {{end}}
142 |
135 | {{.Status}}
136 |
137 |
138 | {{.Time | FormatTime}}
139 |
140 |
147 |
153 |
154 | STDOUT
148 | 149 |
150 | no content
151 |
152 |
155 |
160 | STDERR
156 |
157 | no content
158 |
159 | 
2 |
3 | [![Build Status][travis-image]](https://travis-ci.org/eremetic-framework/eremetic)
4 | [![Coverage Status][coveralls-image]](https://coveralls.io/r/eremetic-framework/eremetic?branch=master)
5 | [![Go Report][goreport-image]](https://goreportcard.com/report/github.com/eremetic-framework/eremetic)
6 |
7 | ## Purpose
8 | Eremetic is a Mesos Framework to run one-shot tasks. The vision is to provide a
9 | bridge between Applications that need to run tasks and Mesos. That way a developer
10 | creating an application that needs to schedule tasks (such as cron) wouldn't need
11 | to connect to Mesos directly.
12 |
13 | ## Usage
14 | Send a cURL to the eremetic framework with how much cpu and memory you need, what docker image to run and which command to run with that image.
15 |
16 | ```bash
17 | curl -H "Content-Type: application/json" \
18 | -X POST \
19 | -d '{"mem":22.0, "cpu":1.0, "image": "busybox", "command": "echo $(date)"}' \
20 | http://eremetic_server:8080/api/v1/task
21 | ```
22 |
23 | These basic fields are required but you can also specify volumes, container names to mounts volumes from, ports, environment
24 | variables, and URIs for the mesos fetcher to download. See
25 | [examples.md](examples.md) for more examples on how to use eremetic.
26 |
27 | JSON format:
28 |
29 | ```javascript
30 | {
31 | // Float64, fractions of a CPU to request
32 | "cpu": 1.0,
33 | // Float64, memory to use (MiB)
34 | "mem": 22.0,
35 | // String, full tag or hash of container to run
36 | "image": "busybox",
37 | // Boolean, if set to true, docker image will be pulled before each task launch
38 | "force_pull_image": false,
39 | // Boolean, if set to true, docker will run the container in 'privileged' mode giving it all capabilities
40 | "privileged": false,
41 | // String, command to run in the docker container
42 | "command": "echo $(date)",
43 | // Array of Strings, arguements to pass to the docker container entrypoint
44 | "args": ["+%s"],
45 | // Array of Objects, volumes to mount in the container
46 | "volumes": [
47 | {
48 | "container_path": "/var/run/docker.sock",
49 | "host_path": "/var/run/docker.sock"
50 | }
51 | ],
52 | // Array of Strings, container names to get volumes from
53 | "volumes_from": ["+%s"],
54 | //String, name of the task. If empty, Eremetic assigns a random task name
55 | "name" : "Task Name",
56 | //String, network mode to pass to the container.
57 | "network" : "BRIDGE",
58 | //String, DNS address to be used by the container.
59 | "dns" : "172.0.0.2",
60 | // Array of Objects, ports to forward to the container.
61 | // Assigned host ports are available as environment variables (e.g. PORT0, PORT1 and so on with PORT being an alias for PORT0).
62 | "ports": [
63 | {
64 | "container_port": 80,
65 | "protocol": "tcp"
66 | }
67 | ],
68 | // Object, Environment variables to pass to the container
69 | "env": {
70 | "KEY": "value"
71 | },
72 | // Object, Will be merged to `env` when passed to Mesos, but masked when doing a GET.
73 | // See Clarification of the Masked Env field below for more information
74 | "masked_env": {
75 | "KEY": "value"
76 | },
77 | // Object, labels to be passed to the Mesos task
78 | "labels": {
79 | "KEY": "value"
80 | },
81 | // URIs and attributes of resource to download. You need to explicitly define
82 | // `"extract"` to unarchive files.
83 | "fetch": [
84 | {
85 | "uri" : "http://server.local/another_resource",
86 | "extract": false,
87 | "executable": false,
88 | "cache": false
89 | }
90 | ],
91 | // Constraints for which agent the task can run on (beyond cpu/memory).
92 | // Matching is strict and only attributes are currently supported. If
93 | // multiple constraints exist, they are evaluated using AND (ie: all or none).
94 | "agent_constraints": [
95 | {
96 | "attribute_name": "aws-region",
97 | "attribute_value": "us-west-2"
98 | }
99 | ],
100 | // String, URL to post a callback to. Callback message has format:
101 | // {"time":1451398320,"status":"TASK_FAILED","task_id":"eremetic-task.79feb50d-3d36-47cf-98ff-a52ef2bc0eb5"}
102 | "callback_uri": "http://callback.local"
103 | }
104 | ```
105 |
106 | ### Note
107 | Most of this meta-data will not remain after a full restart of Eremetic.
108 |
109 | ### Clarification of the Masked Env field
110 | The purpose of the field is to provide a way to pass along environment variables that you don't want to have exposed in a subsequent GET call.
111 | It is not intended to provide full security, as someone with access to either the machine running Eremetic or the Mesos Agent that the task is being run on will still be able to view these values.
112 | These values are not encrypted, but simply masked when retrieved back via the API.
113 |
114 | For security purposes, ensure TLS (https) is being used for the Eremetic communication and that access to any machines is properly restricted.
115 |
116 |
117 | ## Configuration
118 | create /etc/eremetic/eremetic.yml with:
119 |
120 | address: 0.0.0.0
121 | port: 8080
122 | master: zk://