1
|
1 |
|
from datetime import datetime |
2
|
|
|
|
3
|
1 |
|
from boto3.session import Session |
4
|
1 |
|
from botocore.exceptions import ClientError, NoCredentialsError |
5
|
1 |
|
from dateutil.tz.tz import tzlocal |
6
|
|
|
|
7
|
|
|
|
8
|
1 |
|
class EcsClient(object): |
9
|
1 |
|
def __init__(self, access_key_id=None, secret_access_key=None, |
10
|
|
|
region=None, profile=None): |
11
|
1 |
|
session = Session(aws_access_key_id=access_key_id, |
12
|
|
|
aws_secret_access_key=secret_access_key, |
13
|
|
|
region_name=region, |
14
|
|
|
profile_name=profile) |
15
|
1 |
|
self.boto = session.client(u'ecs') |
16
|
|
|
|
17
|
1 |
|
def describe_services(self, cluster_name, service_name): |
18
|
1 |
|
return self.boto.describe_services( |
19
|
|
|
cluster=cluster_name, |
20
|
|
|
services=[service_name] |
21
|
|
|
) |
22
|
|
|
|
23
|
1 |
|
def describe_task_definition(self, task_definition_arn): |
24
|
1 |
|
try: |
25
|
1 |
|
return self.boto.describe_task_definition( |
26
|
|
|
taskDefinition=task_definition_arn |
27
|
|
|
) |
28
|
1 |
|
except ClientError: |
29
|
1 |
|
raise UnknownTaskDefinitionError( |
30
|
|
|
u'Unknown task definition arn: %s' % task_definition_arn |
31
|
|
|
) |
32
|
|
|
|
33
|
1 |
|
def list_tasks(self, cluster_name, service_name): |
34
|
1 |
|
return self.boto.list_tasks( |
35
|
|
|
cluster=cluster_name, |
36
|
|
|
serviceName=service_name |
37
|
|
|
) |
38
|
|
|
|
39
|
1 |
|
def describe_tasks(self, cluster_name, task_arns): |
40
|
1 |
|
return self.boto.describe_tasks(cluster=cluster_name, tasks=task_arns) |
41
|
|
|
|
42
|
1 |
|
def register_task_definition(self, family, containers, volumes, role_arn, |
43
|
|
|
additional_properties): |
44
|
1 |
|
return self.boto.register_task_definition( |
45
|
|
|
family=family, |
46
|
|
|
containerDefinitions=containers, |
47
|
|
|
volumes=volumes, |
48
|
|
|
taskRoleArn=role_arn or u'', |
49
|
|
|
**additional_properties |
50
|
|
|
) |
51
|
|
|
|
52
|
1 |
|
def deregister_task_definition(self, task_definition_arn): |
53
|
1 |
|
return self.boto.deregister_task_definition( |
54
|
|
|
taskDefinition=task_definition_arn |
55
|
|
|
) |
56
|
|
|
|
57
|
1 |
|
def update_service(self, cluster, service, desired_count, task_definition): |
58
|
1 |
|
return self.boto.update_service( |
59
|
|
|
cluster=cluster, |
60
|
|
|
service=service, |
61
|
|
|
desiredCount=desired_count, |
62
|
|
|
taskDefinition=task_definition |
63
|
|
|
) |
64
|
|
|
|
65
|
1 |
|
def run_task(self, cluster, task_definition, count, started_by, overrides): |
66
|
1 |
|
return self.boto.run_task( |
67
|
|
|
cluster=cluster, |
68
|
|
|
taskDefinition=task_definition, |
69
|
|
|
count=count, |
70
|
|
|
startedBy=started_by, |
71
|
|
|
overrides=overrides |
72
|
|
|
) |
73
|
|
|
|
74
|
|
|
|
75
|
1 |
|
class EcsService(dict): |
76
|
1 |
|
def __init__(self, cluster, service_definition=None, **kwargs): |
77
|
1 |
|
self._cluster = cluster |
78
|
1 |
|
super(EcsService, self).__init__(service_definition, **kwargs) |
79
|
|
|
|
80
|
1 |
|
def set_desired_count(self, desired_count): |
81
|
1 |
|
self[u'desiredCount'] = desired_count |
82
|
|
|
|
83
|
1 |
|
def set_task_definition(self, task_definition): |
84
|
1 |
|
self[u'taskDefinition'] = task_definition.arn |
85
|
|
|
|
86
|
1 |
|
@property |
87
|
|
|
def cluster(self): |
88
|
1 |
|
return self._cluster |
89
|
|
|
|
90
|
1 |
|
@property |
91
|
|
|
def name(self): |
92
|
1 |
|
return self.get(u'serviceName') |
93
|
|
|
|
94
|
1 |
|
@property |
95
|
|
|
def task_definition(self): |
96
|
1 |
|
return self.get(u'taskDefinition') |
97
|
|
|
|
98
|
1 |
|
@property |
99
|
|
|
def desired_count(self): |
100
|
1 |
|
return self.get(u'desiredCount') |
101
|
|
|
|
102
|
1 |
|
@property |
103
|
|
|
def deployment_created_at(self): |
104
|
1 |
|
for deployment in self.get(u'deployments'): |
105
|
1 |
|
if deployment.get(u'status') == u'PRIMARY': |
106
|
1 |
|
return deployment.get(u'createdAt') |
107
|
1 |
|
return datetime.now() |
108
|
|
|
|
109
|
1 |
|
@property |
110
|
|
|
def deployment_updated_at(self): |
111
|
1 |
|
for deployment in self.get(u'deployments'): |
112
|
1 |
|
if deployment.get(u'status') == u'PRIMARY': |
113
|
1 |
|
return deployment.get(u'updatedAt') |
114
|
1 |
|
return datetime.now() |
115
|
|
|
|
116
|
1 |
|
@property |
117
|
|
|
def errors(self): |
118
|
1 |
|
return self.get_warnings( |
119
|
|
|
since=self.deployment_updated_at |
120
|
|
|
) |
121
|
|
|
|
122
|
1 |
|
@property |
123
|
|
|
def older_errors(self): |
124
|
1 |
|
return self.get_warnings( |
125
|
|
|
since=self.deployment_created_at, |
126
|
|
|
until=self.deployment_updated_at |
127
|
|
|
) |
128
|
|
|
|
129
|
1 |
|
def get_warnings(self, since=None, until=None): |
130
|
1 |
|
since = since or self.deployment_created_at |
131
|
1 |
|
until = until or datetime.now(tz=tzlocal()) |
132
|
1 |
|
errors = {} |
133
|
1 |
|
for event in self.get(u'events'): |
134
|
1 |
|
if u'unable' not in event[u'message']: |
135
|
|
|
continue |
136
|
1 |
|
if since < event[u'createdAt'] < until: |
137
|
1 |
|
errors[event[u'createdAt']] = event[u'message'] |
138
|
1 |
|
return errors |
139
|
|
|
|
140
|
|
|
|
141
|
1 |
|
class EcsTaskDefinition(object): |
142
|
1 |
|
def __init__(self, containerDefinitions, volumes, family, revision, |
143
|
|
|
taskRoleArn, status, taskDefinitionArn, requiresAttributes, |
144
|
|
|
**kwargs): |
145
|
1 |
|
self.containers = containerDefinitions |
146
|
1 |
|
self.volumes = volumes |
147
|
1 |
|
self.family = family |
148
|
1 |
|
self.revision = revision |
149
|
1 |
|
self.role_arn = taskRoleArn |
150
|
1 |
|
self.arn = taskDefinitionArn |
151
|
1 |
|
self.status = status |
152
|
1 |
|
self.requires_attributes = requiresAttributes |
153
|
1 |
|
self.additional_properties = kwargs |
154
|
1 |
|
self._diff = [] |
155
|
|
|
|
156
|
1 |
|
@property |
157
|
|
|
def container_names(self): |
158
|
1 |
|
for container in self.containers: |
159
|
1 |
|
yield container[u'name'] |
160
|
|
|
|
161
|
1 |
|
@property |
162
|
|
|
def family_revision(self): |
163
|
1 |
|
return '%s:%d' % (self.family, self.revision) |
164
|
|
|
|
165
|
1 |
|
@property |
166
|
|
|
def diff(self): |
167
|
1 |
|
return self._diff |
168
|
|
|
|
169
|
1 |
|
def get_overrides(self): |
170
|
1 |
|
override = dict() |
171
|
1 |
|
overrides = [] |
172
|
1 |
|
for diff in self.diff: |
173
|
1 |
|
if override.get('name') != diff.container: |
174
|
1 |
|
override = dict(name=diff.container) |
175
|
1 |
|
overrides.append(override) |
176
|
1 |
|
if diff.field == 'command': |
177
|
1 |
|
override['command'] = self.get_overrides_command(diff.value) |
178
|
1 |
|
elif diff.field == 'environment': |
179
|
1 |
|
override['environment'] = self.get_overrides_env(diff.value) |
180
|
1 |
|
return overrides |
181
|
|
|
|
182
|
1 |
|
@staticmethod |
183
|
|
|
def get_overrides_command(command): |
184
|
1 |
|
return command.split(' ') |
185
|
|
|
|
186
|
1 |
|
@staticmethod |
187
|
|
|
def get_overrides_env(env): |
188
|
1 |
|
return [{"name": e, "value": env[e]} for e in env] |
189
|
|
|
|
190
|
1 |
|
def set_images(self, tag=None, **images): |
191
|
1 |
|
self.validate_container_options(**images) |
192
|
1 |
|
for container in self.containers: |
193
|
1 |
|
if container[u'name'] in images: |
194
|
1 |
|
new_image = images[container[u'name']] |
195
|
1 |
|
diff = EcsTaskDefinitionDiff( |
196
|
|
|
container=container[u'name'], |
197
|
|
|
field=u'image', |
198
|
|
|
value=new_image, |
199
|
|
|
old_value=container[u'image'] |
200
|
|
|
) |
201
|
1 |
|
self._diff.append(diff) |
202
|
1 |
|
container[u'image'] = new_image |
203
|
1 |
|
elif tag: |
204
|
1 |
|
image_definition = container[u'image'].rsplit(u':', 1) |
205
|
1 |
|
new_image = u'%s:%s' % (image_definition[0], tag.strip()) |
206
|
1 |
|
diff = EcsTaskDefinitionDiff( |
207
|
|
|
container=container[u'name'], |
208
|
|
|
field=u'image', |
209
|
|
|
value=new_image, |
210
|
|
|
old_value=container[u'image'] |
211
|
|
|
) |
212
|
1 |
|
self._diff.append(diff) |
213
|
1 |
|
container[u'image'] = new_image |
214
|
|
|
|
215
|
1 |
|
def set_commands(self, **commands): |
216
|
1 |
View Code Duplication |
self.validate_container_options(**commands) |
|
|
|
|
217
|
1 |
|
for container in self.containers: |
218
|
1 |
|
if container[u'name'] in commands: |
219
|
1 |
|
new_command = commands[container[u'name']] |
220
|
1 |
|
diff = EcsTaskDefinitionDiff( |
221
|
|
|
container=container[u'name'], |
222
|
|
|
field=u'command', |
223
|
|
|
value=new_command, |
224
|
|
|
old_value=container.get(u'command') |
225
|
|
|
) |
226
|
1 |
|
self._diff.append(diff) |
227
|
1 |
|
container[u'command'] = [new_command] |
228
|
|
|
|
229
|
1 |
|
def set_environment(self, environment_list): |
230
|
1 |
|
environment = {} |
231
|
|
View Code Duplication |
|
|
|
|
|
232
|
1 |
|
for env in environment_list: |
233
|
1 |
|
environment.setdefault(env[0], {}) |
234
|
1 |
|
environment[env[0]][env[1]] = env[2] |
235
|
|
|
|
236
|
1 |
|
self.validate_container_options(**environment) |
237
|
1 |
|
for container in self.containers: |
238
|
1 |
|
if container[u'name'] in environment: |
239
|
1 |
|
self.apply_container_environment( |
240
|
|
|
container=container, |
241
|
|
|
new_environment=environment[container[u'name']] |
242
|
|
|
) |
243
|
|
|
|
244
|
1 |
|
def apply_container_environment(self, container, new_environment): |
245
|
1 |
|
environment = container.get('environment', {}) |
246
|
1 |
|
old_environment = {env['name']: env['value'] for env in environment} |
247
|
1 |
|
merged = old_environment.copy() |
248
|
1 |
|
merged.update(new_environment) |
249
|
|
|
|
250
|
1 |
|
if old_environment == merged: |
251
|
1 |
|
return |
252
|
|
|
|
253
|
1 |
|
diff = EcsTaskDefinitionDiff( |
254
|
|
|
container=container[u'name'], |
255
|
|
|
field=u'environment', |
256
|
|
|
value=merged, |
257
|
|
|
old_value=old_environment |
258
|
|
|
) |
259
|
1 |
|
self._diff.append(diff) |
260
|
|
|
|
261
|
1 |
|
container[u'environment'] = [ |
262
|
|
|
{"name": e, "value": merged[e]} for e in merged |
263
|
|
|
] |
264
|
|
|
|
265
|
1 |
|
def validate_container_options(self, **container_options): |
266
|
1 |
|
for container_name in container_options: |
267
|
1 |
|
if container_name not in self.container_names: |
268
|
1 |
|
raise UnknownContainerError( |
269
|
|
|
u'Unknown container: %s' % container_name |
270
|
|
|
) |
271
|
|
|
|
272
|
1 |
|
def set_role_arn(self, role_arn): |
273
|
1 |
|
if role_arn: |
274
|
1 |
|
diff = EcsTaskDefinitionDiff( |
275
|
|
|
container=None, |
276
|
|
|
field=u'role_arn', |
277
|
|
|
value=role_arn, |
278
|
|
|
old_value=self.role_arn |
279
|
|
|
) |
280
|
1 |
|
self.role_arn = role_arn |
281
|
1 |
|
self._diff.append(diff) |
282
|
|
|
|
283
|
|
|
|
284
|
1 |
|
class EcsTaskDefinitionDiff(object): |
285
|
1 |
|
def __init__(self, container, field, value, old_value): |
286
|
1 |
|
self.container = container |
287
|
1 |
|
self.field = field |
288
|
1 |
|
self.value = value |
289
|
1 |
|
self.old_value = old_value |
290
|
|
|
|
291
|
1 |
|
def __repr__(self): |
292
|
1 |
|
if self.field == u'environment': |
293
|
1 |
|
return '\n'.join(self._get_environment_diffs( |
294
|
|
|
self.container, |
295
|
|
|
self.value, |
296
|
|
|
self.old_value, |
297
|
|
|
)) |
298
|
1 |
|
elif self.container: |
299
|
1 |
|
return u'Changed %s of container "%s" to: "%s" (was: "%s")' % ( |
300
|
|
|
self.field, |
301
|
|
|
self.container, |
302
|
|
|
self.value, |
303
|
|
|
self.old_value |
304
|
|
|
) |
305
|
|
|
else: |
306
|
1 |
|
return u'Changed %s to: "%s" (was: "%s")' % ( |
307
|
|
|
self.field, |
308
|
|
|
self.value, |
309
|
|
|
self.old_value |
310
|
|
|
) |
311
|
|
|
|
312
|
1 |
|
@staticmethod |
313
|
|
|
def _get_environment_diffs(container, env, old_env): |
314
|
1 |
|
msg = u'Changed environment "%s" of container "%s" to: "%s"' |
315
|
1 |
|
diffs = [] |
316
|
1 |
|
for name, value in env.items(): |
317
|
1 |
|
old_value = old_env.get(name) |
318
|
1 |
|
if value != old_value or not old_value: |
319
|
1 |
|
message = msg % (name, container, value) |
320
|
1 |
|
diffs.append(message) |
321
|
1 |
|
return diffs |
322
|
|
|
|
323
|
|
|
|
324
|
1 |
|
class EcsAction(object): |
325
|
1 |
|
def __init__(self, client, cluster_name, service_name): |
326
|
1 |
|
self._client = client |
327
|
1 |
|
self._cluster_name = cluster_name |
328
|
1 |
|
self._service_name = service_name |
329
|
|
|
|
330
|
1 |
|
try: |
331
|
1 |
|
if service_name: |
332
|
1 |
|
self._service = self.get_service() |
333
|
1 |
|
except IndexError: |
334
|
1 |
|
raise EcsConnectionError( |
335
|
|
|
u'An error occurred when calling the DescribeServices ' |
336
|
|
|
u'operation: Service not found.' |
337
|
|
|
) |
338
|
1 |
|
except ClientError as e: |
339
|
1 |
|
raise EcsConnectionError(str(e)) |
340
|
1 |
|
except NoCredentialsError: |
341
|
1 |
|
raise EcsConnectionError( |
342
|
|
|
u'Unable to locate credentials. Configure credentials ' |
343
|
|
|
u'by running "aws configure".' |
344
|
|
|
) |
345
|
|
|
|
346
|
1 |
|
def get_service(self): |
347
|
1 |
|
services_definition = self._client.describe_services( |
348
|
|
|
cluster_name=self._cluster_name, |
349
|
|
|
service_name=self._service_name |
350
|
|
|
) |
351
|
1 |
|
return EcsService( |
352
|
|
|
cluster=self._cluster_name, |
353
|
|
|
service_definition=services_definition[u'services'][0] |
354
|
|
|
) |
355
|
|
|
|
356
|
1 |
|
def get_current_task_definition(self, service): |
357
|
1 |
|
return self.get_task_definition(service.task_definition) |
358
|
|
|
|
359
|
1 |
|
def get_task_definition(self, task_definition): |
360
|
1 |
|
task_definition_payload = self._client.describe_task_definition( |
361
|
|
|
task_definition_arn=task_definition |
362
|
|
|
) |
363
|
|
|
|
364
|
1 |
|
task_definition = EcsTaskDefinition( |
365
|
|
|
**task_definition_payload[u'taskDefinition'] |
366
|
|
|
) |
367
|
1 |
|
return task_definition |
368
|
|
|
|
369
|
1 |
|
def update_task_definition(self, task_definition): |
370
|
1 |
|
response = self._client.register_task_definition( |
371
|
|
|
family=task_definition.family, |
372
|
|
|
containers=task_definition.containers, |
373
|
|
|
volumes=task_definition.volumes, |
374
|
|
|
role_arn=task_definition.role_arn, |
375
|
|
|
additional_properties=task_definition.additional_properties |
376
|
|
|
) |
377
|
1 |
|
new_task_definition = EcsTaskDefinition(**response[u'taskDefinition']) |
378
|
1 |
|
self._client.deregister_task_definition(task_definition.arn) |
379
|
1 |
|
return new_task_definition |
380
|
|
|
|
381
|
1 |
|
def update_service(self, service): |
382
|
1 |
|
response = self._client.update_service( |
383
|
|
|
cluster=service.cluster, |
384
|
|
|
service=service.name, |
385
|
|
|
desired_count=service.desired_count, |
386
|
|
|
task_definition=service.task_definition |
387
|
|
|
) |
388
|
1 |
|
return EcsService(self._cluster_name, response[u'service']) |
389
|
|
|
|
390
|
1 |
|
def is_deployed(self, service): |
391
|
1 |
|
if len(service[u'deployments']) != 1: |
392
|
1 |
|
return False |
393
|
1 |
|
running_tasks = self._client.list_tasks( |
394
|
|
|
cluster_name=service.cluster, |
395
|
|
|
service_name=service.name |
396
|
|
|
) |
397
|
1 |
|
if not running_tasks[u'taskArns']: |
398
|
1 |
|
return service.desired_count == 0 |
399
|
1 |
|
running_count = self.get_running_tasks_count( |
400
|
|
|
service=service, |
401
|
|
|
task_arns=running_tasks[u'taskArns'] |
402
|
|
|
) |
403
|
1 |
|
return service.desired_count == running_count |
404
|
|
|
|
405
|
1 |
|
def get_running_tasks_count(self, service, task_arns): |
406
|
1 |
|
running_count = 0 |
407
|
1 |
|
tasks_details = self._client.describe_tasks( |
408
|
|
|
cluster_name=self._cluster_name, |
409
|
|
|
task_arns=task_arns |
410
|
|
|
) |
411
|
1 |
|
for task in tasks_details[u'tasks']: |
412
|
1 |
|
arn = task[u'taskDefinitionArn'] |
413
|
1 |
|
status = task[u'lastStatus'] |
414
|
1 |
|
if arn == service.task_definition and status == u'RUNNING': |
415
|
1 |
|
running_count += 1 |
416
|
1 |
|
return running_count |
417
|
|
|
|
418
|
1 |
|
@property |
419
|
|
|
def client(self): |
420
|
1 |
|
return self._client |
421
|
|
|
|
422
|
1 |
|
@property |
423
|
|
|
def service(self): |
424
|
1 |
|
return self._service |
425
|
|
|
|
426
|
1 |
|
@property |
427
|
|
|
def cluster_name(self): |
428
|
1 |
|
return self._cluster_name |
429
|
|
|
|
430
|
1 |
|
@property |
431
|
|
|
def service_name(self): |
432
|
1 |
|
return self._service_name |
433
|
|
|
|
434
|
|
|
|
435
|
1 |
|
class DeployAction(EcsAction): |
436
|
1 |
|
def deploy(self, task_definition): |
437
|
1 |
|
self._service.set_task_definition(task_definition) |
438
|
1 |
|
return self.update_service(self._service) |
439
|
|
|
|
440
|
|
|
|
441
|
1 |
|
class ScaleAction(EcsAction): |
442
|
1 |
|
def scale(self, desired_count): |
443
|
1 |
|
self._service.set_desired_count(desired_count) |
444
|
1 |
|
return self.update_service(self._service) |
445
|
|
|
|
446
|
|
|
|
447
|
1 |
|
class RunAction(EcsAction): |
448
|
1 |
|
def __init__(self, client, cluster_name): |
449
|
1 |
|
super(RunAction, self).__init__(client, cluster_name, None) |
450
|
1 |
|
self._client = client |
451
|
1 |
|
self._cluster_name = cluster_name |
452
|
1 |
|
self.started_tasks = [] |
453
|
|
|
|
454
|
1 |
|
def run(self, task_definition, count, started_by): |
455
|
1 |
|
result = self._client.run_task( |
456
|
|
|
cluster=self._cluster_name, |
457
|
|
|
task_definition=task_definition.family_revision, |
458
|
|
|
count=count, |
459
|
|
|
started_by=started_by, |
460
|
|
|
overrides=dict(containerOverrides=task_definition.get_overrides()) |
461
|
|
|
) |
462
|
1 |
|
self.started_tasks = result['tasks'] |
463
|
1 |
|
return True |
464
|
|
|
|
465
|
|
|
|
466
|
1 |
|
class EcsError(Exception): |
467
|
1 |
|
pass |
468
|
|
|
|
469
|
|
|
|
470
|
1 |
|
class EcsConnectionError(EcsError): |
471
|
1 |
|
pass |
472
|
|
|
|
473
|
|
|
|
474
|
1 |
|
class UnknownContainerError(EcsError): |
475
|
1 |
|
pass |
476
|
|
|
|
477
|
|
|
|
478
|
1 |
|
class TaskPlacementError(EcsError): |
479
|
1 |
|
pass |
480
|
|
|
|
481
|
|
|
|
482
|
1 |
|
class UnknownTaskDefinitionError(EcsError): |
483
|
|
|
pass |
484
|
|
|
|