cli.stack Namespace Reference

Classes
class	CreateCommand
class	EndMaintCommand
class	GetEnvCommand
class	ListCommand
class	MaintCommand
class	MigrationCommand
class	MonitorCommand
class	RemoveCommand
class	ScaleCommand
class	SetEnvCommand
class	SetStackStateCommand
class	ShowCommand
class	StackCommand
class	StartMaintCommand
class	UpgradeCommand

Functions
def	create_stack_aws_resources (stack, region, ecs_cluster, elb_security_group, elb_internal_security_group, eni_security_group, rds_config, pub_subnet_prefix, priv_subnet_prefix, https_cert_hostname, domain, hostnames, **kwargs)
def	upgrade_cfn_stack (stack, git_sha, passphrase, **kwargs)
def	get_rds_config (region, cluster, rds_config)
def	create_db (stack, db_config)
def	submit_rsql_job (sql, db_config, region, cluster, operator=None)
def	create_cloudformation_stack_params (stack, **kwargs)
def	_deploy_dictionary_ (stack)

Variables
string	RDS_CONFIG_BUCKET = 'homecu.odyssey.rds'
string	RDS_CONFIG_PATH_FMT = '%(region)s/%(ecs_cluster)s/%(rds_config)s.json'

Detailed Description

AWS stack provisioning.

Function Documentation

create_cloudformation_stack_params()

def cli.stack.create_cloudformation_stack_params	(		stack,
		**	kwargs
	)

Create necessary Params dictionary for cloudformation

Definition at line 1045 of file stack.py.

def create_cloudformation_stack_params(stack, **kwargs):
    '''Create necessary Params dictionary for cloudformation'''
    registry = REGISTRIES[stack.region]
    oauth_client = get_client_oauth_data(stack.dns[0])
    return {
        'VpcId': stack.aws['vpc_id'],
        'ECSCluster': stack.cluster,
        'StackName': stack.name,
        'StackVersion': stack.version,
        'StackDomain': stack.dns[0],
        'ContainerRegistry': registry,
        'StackDatabaseHost': stack.db['host'],
        'StackDatabasePort': str(stack.db['port']),
        'StackDatabaseName': stack.db['name'],
        'StackDatabaseUsername': stack.db['user'],
        'StackDatabasePassword': stack.db['password'],
        'Oauth2ClientId': oauth_client[0],
        'Oauth2ClientSecret': oauth_client[1],
        'AppServiceDesiredCount': str(stack.app_service_count),
        'CertificateArn': stack.aws['certificate_arn'],
        'HostedZoneId': stack.aws['hosted_zone_id'],
        'ELBSecurityGroupsIds': ','.join(stack.aws['elb_security_groups']),
        'InternalELBSecurityGroupIds': ','.join(
            stack.aws['elb_internal_security_groups']),
        'ENISecurityGroupIds': ','.join(stack.aws['eni_security_groups']),
        'PrivateSubnetIds': ','.join(stack.aws['private_subnet_ids']),
        'SubnetIds': ','.join(stack.aws['subnet_ids']),
        'IsMigration': kwargs.get('IsMigration', 'False'),
        'Environment': stack.environment,
        'EnvironmentName': stack.environment_name,
    }

create_stack_aws_resources()

def cli.stack.create_stack_aws_resources	(		stack,
			region,
			ecs_cluster,
			elb_security_group,
			elb_internal_security_group,
			eni_security_group,
			rds_config,
			pub_subnet_prefix,
			priv_subnet_prefix,
			https_cert_hostname,
			domain,
			hostnames,
		**	kwargs
	)

Create required AWS resources for given stack

Definition at line 815 of file stack.py.

def create_stack_aws_resources(stack,
                               region,
                               ecs_cluster,
                               elb_security_group,
                               elb_internal_security_group,
                               eni_security_group,
                               rds_config,
                               pub_subnet_prefix,
                               priv_subnet_prefix,
                               https_cert_hostname,
                               domain,
                               hostnames,
                               **kwargs):
    '''Create required AWS resources for given stack'''
    verbose = kwargs.get('verbose', False)
    db_config = get_rds_config(region,
                               ecs_cluster,
                               rds_config)

    def get_vpc_subnets(vpc, prefix):
        def name_tag(tags):
            return [x['Value'] for x in tags
                    if x['Key'] == 'Name'][0]
        return [x for x in vpc.subnets.all()
                if name_tag(x.tags).startswith(prefix)]

    def get_sg(name, region):
        ec2_api = boto3.client('ec2', region_name=region)
        return ec2_api.describe_security_groups(Filters=[{
            'Name': 'group-name',
            'Values': [name]
        }])['SecurityGroups'][0]

    def get_https_cert(name, region):
        acm_api = boto3.client('acm', region_name=region)
        certs = acm_api.list_certificates()['CertificateSummaryList']
        for x in certs:
            if x['DomainName'] == name:
                return x

    def get_hosted_zone_id(domain):
        r53_api = boto3.client('route53')
        response = r53_api.list_hosted_zones_by_name(
            DNSName=domain,
            MaxItems='1'
        )
        if len(response.get('HostedZones', [])) == 0:
            raise SystemExit("Unable to find hosted zone by name")
        return response['HostedZones'][0]['Id']

    elb_sg = get_sg(elb_security_group, region)
    elb_int_sg = get_sg(elb_internal_security_group, region)
    eni_sg = get_sg(eni_security_group, region)
    ec2_res = boto3.resource('ec2', region_name=region)
    vpc = ec2_res.Vpc(elb_sg['VpcId'])
    elb_subnets = get_vpc_subnets(vpc, pub_subnet_prefix)
    if not elb_subnets:
        raise SystemExit("No usable subnets found")
    eni_subnets = get_vpc_subnets(vpc, priv_subnet_prefix)
    if not eni_subnets:
        raise SystemExit("No usable private subnets found")

    cert_name = '%s.%s' % (https_cert_hostname, domain)
    cert = get_https_cert(cert_name, region)

    hosted_zone_id = get_hosted_zone_id(domain)

    if cert is None:
        raise SystemExit("No HTTPS cert found for: %s" % cert_name)

    stack.set("aws", {
        'vpc_id': vpc.vpc_id,
        'certificate_arn': cert['CertificateArn'],
        'elb_security_groups': [elb_sg['GroupId']],
        'elb_internal_security_groups': [elb_int_sg['GroupId']],
        'eni_security_groups': [eni_sg['GroupId']],
        'private_subnet_ids': [x.id for x in eni_subnets],
        'subnet_ids': [x.id for x in elb_subnets],
        'hosted_zone_id': hosted_zone_id,
    })

    if kwargs.get('create_database', True):
        db_creds = create_db(stack, db_config)
        stack.set("db", {
            "host": db_config['host'],
            "port": db_config['port'],
            "name": db_creds['db'],
            "user": db_creds['user'],
            "password": db_creds['password'],
            "rds_config": rds_config,
        })

    stack_cf_params = create_cloudformation_stack_params(stack, **kwargs)

    stack_cf_id = cloudformation.create_cloudformation_stack(
        stack,
        stack_cf_params,
        verbose=verbose
    )
    if stack_cf_id is None:
        raise SystemExit("Unable to create Cloudformation Stack for Stack")

    print("Created Cloudformation Stack: %s" % stack_cf_id)

    stack.deploy = _deploy_dictionary_(stack)

    stack.update_state('active')