cloudformation.py

#!/usr/bin/env python
'''Hosting Cloudformation Library'''

import json
import logging
import os
import sys
import time
import boto3

STACK_TEMPLATE_DIR = '/cloudformation'
STACK_TEMPLATE = os.path.join(STACK_TEMPLATE_DIR, 'odyssey.cf.json')
LOG = logging.getLogger(__name__)


def __get_boto_client__(region):
    return boto3.client('cloudformation', region_name=region)


def __get_stack_name__(cluster, region, name, uuid):
    return '-'.join((cluster, region, 'odyssey', name, uuid))


def __get_changeset_name__(stack_name, git_sha):
    return '-'.join((stack_name, git_sha))


def __read_template_body_as_json__():
    with open(STACK_TEMPLATE, 'r') as fh:
        return json.loads(fh.read())


def __aws_tags_translation__(tags):
    return list({'Key': k, 'Value': v} for k, v in tags.items())


def __aws_params_translation__(params):
    return list({'ParameterKey': k,
                 'ParameterValue': v} for k, v in params.items())


def __update_template_tasks_environments__(template, env):
    tasks = [
        'AppECSTask',
        'CUManageECSTask',
        'SchedECSTask',
        'SSLRedirectECSTask',
    ]
    for task in tasks:
        task_def = template['Resources'][task]['Properties']
        cdefs = task_def['ContainerDefinitions']
        for cdef in cdefs:
            cenv = dict((x['Name'], x['Value']) for x in cdef['Environment'])
            cenv.update(env)
            cdef['Environment'] = [{
                'Name': key,
                'Value': value
            } for key, value in cenv.items()]
    return template


def __validate_template__(client, template_body):
    return client.validate_template(
        TemplateBody=template_body
    )


def describe_stack(stack, **kwargs):
    assert stack
    stack_name = __get_stack_name__(stack.cluster,
                                    stack.region,
                                    stack.name,
                                    stack.uuid)
    client = __get_boto_client__(stack.region)
    stack = client.describe_stacks(
        StackName=stack_name)
    return stack['Stacks'][-1]


def describe_changeset(stack, git_sha, **kwargs):
    assert stack
    stack_name = __get_stack_name__(stack.cluster,
                                    stack.region,
                                    stack.name,
                                    stack.uuid)
    changeset_name = __get_changeset_name__(stack_name, git_sha)
    client = __get_boto_client__(stack.region)
    changeset = client.describe_change_set(
        ChangeSetName=changeset_name,
        StackName=stack_name
    )
    return changeset


def watch_stack_progress(stack, **kwargs):
    while True:
        try:
            cfn_stack = describe_stack(stack, **kwargs)
            if cfn_stack['StackStatus'].endswith('_IN_PROGRESS'):
                time.sleep(10)
                print('.', file=sys.stderr, end='')
                continue
            else:
                print('', file=sys.stderr)
                return cfn_stack
        except Exception as ex:
            if kwargs.get('verbose', False):
                print(ex)
            return None


def watch_changeset_progress(stack, git_sha, **kwargs):
    while True:
        changeset = describe_changeset(stack, git_sha, **kwargs)
        if changeset['Status'] in ['CREATE_PENDING', 'CREATE_IN_PROGRESS']:
            print('.', file=sys.stderr, end='')
            time.sleep(10)
            continue
        else:
            print('', file=sys.stderr)
            return changeset


def list_stack_events(stack, **kwargs):
    assert stack
    stack_name = __get_stack_name__(stack.cluster,
                                    stack.region,
                                    stack.name,
                                    stack.uuid)
    client = __get_boto_client__(stack.region)
    events = client.describe_stack_events(
        StackName=stack_name)
    return events['StackEvents']


def create_cloudformation_stack(stack,
                                params,
                                tags=None,
                                **kwargs):
    '''Create AWS Cloudformation Stack'''
    if tags is None:
        tags = {}
    stack_name = __get_stack_name__(stack.cluster,
                                    stack.region,
                                    stack.name,
                                    stack.uuid)
    stack_template = __update_template_tasks_environments__(
        __read_template_body_as_json__(),
        stack.env
    )
    template_body = json.dumps(stack_template, indent=4)

    client = __get_boto_client__(stack.region)

    if kwargs.get('verbose', False):
        print(__validate_template__(client, template_body), file=sys.stderr)

    response = client.create_stack(
        StackName=stack_name,
        Parameters=__aws_params_translation__(params),
        TemplateBody=template_body,
        Capabilities=['CAPABILITY_NAMED_IAM'],
        Tags=__aws_tags_translation__(tags))
    return response.get('StackId')


def create_cloudformation_changeset(stack,
                                    params,
                                    git_sha,
                                    tags=None,
                                    **kwargs):
    '''Create AWS Cloudformation Changeset'''
    if tags is None:
        tags = {}
    client = __get_boto_client__(stack.region)
    stack_name = __get_stack_name__(stack.cluster,
                                    stack.region,
                                    stack.name,
                                    stack.uuid)
    changeset_name = __get_changeset_name__(stack_name, git_sha)
    stack_template = __update_template_tasks_environments__(
        __read_template_body_as_json__(),
        stack.env
    )
    template_body = json.dumps(stack_template, indent=2)

    if kwargs.get('verbose', False):
        print(__validate_template__(client, template_body), file=sys.stderr)

    try:
        response = client.create_change_set(
            StackName=stack_name,
            ChangeSetName=changeset_name,
            TemplateBody=template_body,
            Parameters=__aws_params_translation__(params),
            Capabilities=['CAPABILITY_NAMED_IAM'],
            Tags=__aws_tags_translation__(tags))
    except Exception as ex:
        print(ex, file=sys.stderr)
        return False

    if kwargs.get('verbose', False):
        print(response, file=sys.stderr)

    if response['ResponseMetadata']['HTTPStatusCode'] != 200:
        return False
    else:
        return True


def execute_changeset(stack, git_sha, **kwargs):
    assert stack
    assert git_sha
    wait_until_complete = kwargs.get('wait_until_complete', False)
    stack_name = __get_stack_name__(stack.cluster,
                                    stack.region,
                                    stack.name,
                                    stack.uuid)
    changeset_name = __get_changeset_name__(stack_name, git_sha)
    client = __get_boto_client__(stack.region)
    client.execute_change_set(
        StackName=stack_name,
        ChangeSetName=changeset_name)
    if wait_until_complete:
        cfn_stack = watch_stack_progress(stack, **kwargs)
        if cfn_stack['StackStatus'] == 'UPDATE_COMPLETE':
            return True
        else:
            LOG.error(cfn_stack['StackStatusReason'])
            return False
    return True


def deploy_changeset(stack, git_sha, params, **kwargs):
    if kwargs.get('verbose', False):
        print('Creating Changeset...', file=sys.stderr)
    create_changeset = create_cloudformation_changeset(
        stack,
        params,
        git_sha,
        **kwargs)
    changeset = watch_changeset_progress(stack, git_sha, **kwargs)

    if not (create_changeset or changeset['STATUS'] == 'CREATE_COMPLETE'):
        raise SystemExit("Changeset creation failed")

    if kwargs.get('verbose', False):
        print('Executing Changeset...', file=sys.stderr)
    return execute_changeset(stack, git_sha, **kwargs)


def delete_stack(stack, **kwargs):
    '''Delete stack'''
    assert stack
    stack_name = __get_stack_name__(stack.cluster,
                                    stack.region,
                                    stack.name,
                                    stack.uuid)
    client = boto3.client('cloudformation', region_name=stack.region)
    client.delete_stack(StackName=stack_name)
    if kwargs.get('wait_until_complete', False):
        watch_stack_progress(stack, **kwargs)