def main():
""" main """
my_logfile = 'logs/awsbuild.log'
my_region = 'us-east-1'
#my_vpc = 'vpc-xxx'
my_tag = 'momo-us-east-1'
# setup logging
log_formatter = logging.Formatter("%(asctime)s %(filename)s %(name)s %(levelname)s %(message)s")
root_logger = logging.getLogger()
file_handler = logging.FileHandler(my_logfile)
file_handler.setFormatter(log_formatter)
root_logger.addHandler(file_handler)
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)
root_logger.addHandler(console_handler)
config = AwsConfig(cfgdir='configs',\
cfgfile='ec2.yaml')
conn = AwsConnector(credentials=config.settings['aws_cfg']['credentials'], region=my_region)
aws_conn = conn.get_all_conn()
if not aws_conn:
print('error AwsConnector\n')
sys.exit(-1)
vpc_conn = AwsVPC(aws_conn=aws_conn, tag=my_tag)
if not vpc_conn:
print('error AwsVPC\n')
sys.exit(-1)
vpc_id = vpc_conn.get_vpc_id()
vpc_conn.set_vpc_resource(vpc_id=vpc_id)
dc_ipv6 = config.settings['dc_cfg'][my_region]['dc_ipv6']
networkv6, cidrv6 = vpc_conn.get_vpc_cidr(ip_type='v6', split_cidr=True)
net_config = set_network_config(dc_cfg=config.settings['dc_cfg'][my_region])
if not net_config:
print('error set_network_config\n')
sys.exit(-1)
# set the network topoloy first (subnet size)
net_config.update(config.settings['dc_cfg'][my_region])
# add the config from the configuration file and the VPC ipv6 settings
net_config.update(set_network_config(dc_cfg=net_config, \
dc_cidr_v6=cidrv6, dc_network_v6=networkv6))
sec_conn = AwsSecGroup(aws_conn=aws_conn, cfgs=config.get_settings(), \
dc_cfg=net_config, vpc_id=vpc_id, ipv6=dc_ipv6 \
)
if not sec_conn:
print('error\n')
sys.exit(-1)
print('sec -> {}\n'.format(sec_conn.destroy()))
def _create_vpc(self):
""" create the VPC and update the network configuration with the ipv6 detail """
# for create we only need to know the CIDR block first
vpc_cidr = get_cidr(dc_cfg=self.net_config)
self.vpc_conn = AwsVPC(aws_conn=self.aws_conn,
tag=self.tag,
cidr=vpc_cidr)
if not self.vpc_conn:
print('error AwsVPC\n')
sys.exit(-1)
# there should be no ID yet
if self.vpc_conn.get_vpc_id() is not None:
print('There is already a VPC with the given tag: {}, aborted.'.
format(self.tag))
sys.exit(-1)
print('\t--< Start creating the VPC: {} >--'.format(strftime("%c")))
if self.vpc_conn.create() is None:
print('error creating the VPC\n')
sys.exit(-1)
# get the vpc id and ipv6 details and update the net_config dict
self.vpc_id = self.vpc_conn.get_vpc_id()
networkv6, cidrv6 = self.vpc_conn.get_vpc_cidr(ip_type='v6',
split_cidr=True)
self.net_config.update(set_network_config(dc_cfg=self.net_config, \
dc_cidr_v6=cidrv6, dc_network_v6=networkv6))
# get the main route table
self.vpc_route_table = self.vpc_conn.get_main_route_table()
if self.vpc_route_table is None:
print('error getting main route of the VPC\n')
sys.exit(-1)
def main():
""" main """
my_logfile = 'logs/awsbuild.log'
my_region = 'us-east-1'
my_vpc = 'vpc-xxx'
my_tag = 'momo-us-east-1'
# setup logging
log_formatter = logging.Formatter("%(asctime)s %(filename)s %(name)s %(levelname)s %(message)s")
root_logger = logging.getLogger()
file_handler = logging.FileHandler(my_logfile)
file_handler.setFormatter(log_formatter)
root_logger.addHandler(file_handler)
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)
root_logger.addHandler(console_handler)
config = AwsConfig(cfgdir='configs',\
cfgfile='auto_scaling_group.yaml',\
cfgkey='autoscale_group')
conn = AwsConnector(credentials=config.settings['aws_cfg']['credentials'], region=my_region)
aws_conn = conn.get_all_conn()
if not aws_conn:
print('error AwsConnector\n')
sys.exit(-1)
autoscale_conn = aws_conn['autoscaling']
if not autoscale_conn:
print('error AwsConnector for autoscaling\n')
sys.exit(-1)
vpc_conn = AwsVPC(aws_conn=aws_conn, tag=my_tag)
if not vpc_conn:
print('error AwsVPC\n')
sys.exit(-1)
#vpc_id = vpc_conn.get_vpc_id()
vpc_conn.set_vpc_resource(vpc_id=my_vpc)
net_config = set_network_config(dc_cfg=config.settings['dc_cfg'][my_region])
if not net_config:
print('error set_network_config\n')
sys.exit(-1)
groups_data = config.settings['autoscale_group']
for autoscale_group in groups_data:
temp_tag_dict = {}
tags_list = []
group_data = groups_data[autoscale_group]
# create tag list
for tag in group_data['Tags']:
# set the working dictonary and overwrite or skip as needd
temp_tag_dict = {'Key': tag, 'Value': group_data['Tags'][tag], 'PropagateAtLaunch': True}
# we leave hostid empty if set to none
if tag == 'hostid' and group_data['Tags'][tag] == 'none':
temp_tag_dict = {'Key': tag, 'Value': '', 'PropagateAtLaunch': True}
tags_list.append(temp_tag_dict)
try:
autoscale_conn.create_auto_scaling_group(
AutoScalingGroupName=autoscale_group,
LaunchTemplate={
'LaunchTemplateName': group_data['LaunchTemplate']['LaunchTemplateName'],
'Version': group_data['LaunchTemplate']['Version']
},
MinSize=int(group_data['MinSize']),
MaxSize=int(group_data['MaxSize']),
DesiredCapacity=int(group_data['DesiredCapacity']),
DefaultCooldown=int(group_data['DefaultCooldown']),
AvailabilityZones=group_data['AvailabilityZones'],
HealthCheckGracePeriod=group_data['HealthCheckGracePeriod'],
VPCZoneIdentifier=','.join(group_data['VPCZoneIdentifier']),
TerminationPolicies=[group_data['TerminationPolicies']],
Tags=tags_list
)
print('Autoscale Group {} created'.format(autoscale_group))
except Exception as err:
critical('Unable to create launch group {}, error {}'.format(autoscale_group, err))
sys.exit(0)
def main():
""" main """
my_logfile = 'logs/awsbuild.log'
my_region = 'us-east-1'
my_vpc = 'vpc-xxx'
my_tag = 'momo-us-east-1'
# setup logging
log_formatter = logging.Formatter(
"%(asctime)s %(filename)s %(name)s %(levelname)s %(message)s")
root_logger = logging.getLogger()
file_handler = logging.FileHandler(my_logfile)
file_handler.setFormatter(log_formatter)
root_logger.addHandler(file_handler)
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)
root_logger.addHandler(console_handler)
config = AwsConfig(cfgdir='configs',\
cfgfile='launch_configuration.yaml',\
cfgkey='autoscale')
conn = AwsConnector(credentials=config.settings['aws_cfg']['credentials'],
region=my_region)
aws_conn = conn.get_all_conn()
if not aws_conn:
print('error AwsConnector\n')
sys.exit(-1)
autoscale_conn = aws_conn['autoscaling']
if not autoscale_conn:
print('error AwsConnector for autoscaling\n')
sys.exit(-1)
vpc_conn = AwsVPC(aws_conn=aws_conn, tag=my_tag)
if not vpc_conn:
print('error AwsVPC\n')
sys.exit(-1)
#vpc_id = vpc_conn.get_vpc_id()
vpc_conn.set_vpc_resource(vpc_id=my_vpc)
net_config = set_network_config(
dc_cfg=config.settings['dc_cfg'][my_region])
if not net_config:
print('error set_network_config\n')
sys.exit(-1)
sec_conn = AwsSecGroup(aws_conn=aws_conn, cfgs=config.get_settings(), \
dc_cfg=net_config, vpc_id=my_vpc, ipv6=False\
)
if not sec_conn:
print('error\n')
sec_name_dict = sec_conn.get(vpc_id=my_vpc)
autoscale_data = config.settings['autoscale']
for template in autoscale_data:
temp_tag_dict = {}
tags_list = []
sgs_list = []
template_data = autoscale_data[template]
# create tag list
for tag in template_data['tags']:
# set the working dictonary and overwrite or skip as needd
temp_tag_dict = {'Key': tag, 'Value': template_data['tags'][tag]}
# we leave hostid empty if set to none
if tag == 'hostid' and template_data['tags'][tag] == 'none':
temp_tag_dict = {'Key': tag, 'Value': ''}
# we do not add role if set to none
if tag == 'role' and template_data['tags'][tag] == 'none':
continue
tags_list.append(temp_tag_dict)
# create security group list
for sec_group in template_data['SecurityGroups']:
sec_id = sec_name_dict[sec_group]
sgs_list.append(sec_id)
try:
result = autoscale_conn.create_launch_configuration(
LaunchConfigurationName=template,
ImageId=template_data['ImageId'],
KeyName=template_data['KeyName'],
InstanceType=template_data['InstanceType'],
SecurityGroups=sgs_list,
InstanceMonitoring={
'Enabled': template_data['InstanceMonitoring']
},
PlacementTenancy=template_data['PlacementTenancy'],
BlockDeviceMappings=[{
'DeviceName':
template_data['BlockDeviceMappings']['DeviceName'],
'Ebs': {
'VolumeSize':
template_data['BlockDeviceMappings']['VolumeSize'],
'DeleteOnTermination':
template_data['BlockDeviceMappings']
['DeleteOnTermination']
}
}],
AssociatePublicIpAddress=template_data[
'AssociatePublicIpAddress'],
UserData=''.join(template_data['UserData']))
#autoscale_conn.create_or_update_tags(Tags=tags_list)
print('{}'.format(result))
except Exception as err:
critical('Unable to create launch template {}, error {}'.format(
template, err))
sys.exit(0)
def main():
""" main """
my_logfile = 'logs/awsbuild.log'
my_region = 'us-east-1'
my_vpc = 'vpc-xxx'
my_tag = 'momo-us-east-1'
# setup logging
log_formatter = logging.Formatter("%(asctime)s %(filename)s %(name)s %(levelname)s %(message)s")
root_logger = logging.getLogger()
file_handler = logging.FileHandler(my_logfile)
file_handler.setFormatter(log_formatter)
root_logger.addHandler(file_handler)
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)
root_logger.addHandler(console_handler)
config = AwsConfig(cfgdir='configs',\
cfgfile='launch_template.yaml',\
cfgkey='launch_template')
conn = AwsConnector(credentials=config.settings['aws_cfg']['credentials'], region=my_region)
aws_conn = conn.get_all_conn()
if not aws_conn:
print('error AwsConnector\n')
sys.exit(-1)
ec2_conn = aws_conn['ec2_client']
if not ec2_conn:
print('error AwsConnector for ec2_client\n')
sys.exit(-1)
vpc_conn = AwsVPC(aws_conn=aws_conn, tag=my_tag)
if not vpc_conn:
print('error AwsVPC\n')
sys.exit(-1)
#vpc_id = vpc_conn.get_vpc_id()
vpc_conn.set_vpc_resource(vpc_id=my_vpc)
net_config = set_network_config(dc_cfg=config.settings['dc_cfg'][my_region])
if not net_config:
print('error set_network_config\n')
sys.exit(-1)
sec_conn = AwsSecGroup(aws_conn=aws_conn, cfgs=config.get_settings(), \
dc_cfg=net_config, vpc_id=my_vpc, ipv6=False\
)
if not sec_conn:
print('error\n')
sec_name_dict = sec_conn.get(vpc_id=my_vpc)
templates_data = config.settings['launch_template']
for template in templates_data:
temp_tag_dict = {}
tags_list = []
sgs_list = []
template_data = templates_data[template]
# create tag list
for tag in template_data['TagSpecifications']:
# set the working dictonary and overwrite or skip as needd
temp_tag_dict = {'Key': tag, 'Value': template_data['TagSpecifications'][tag]}
# we leave hostid empty if set to none
if tag == 'hostid' and template_data['TagSpecifications'][tag] == 'none':
temp_tag_dict = {'Key': tag, 'Value': ''}
# we do not add role if set to none
if tag == 'role' and template_data['TagSpecifications'][tag] == 'none':
continue
tags_list.append(temp_tag_dict)
# create security group list
for sec_group in template_data['SecurityGroupIds']:
sec_id = sec_name_dict[sec_group]
sgs_list.append(sec_id)
try:
result = ec2_conn.create_launch_template(
LaunchTemplateName=template,
VersionDescription=template_data['VersionDescription'],
LaunchTemplateData={
'IamInstanceProfile': {
'Arn': template_data['IamInstanceProfile']
},
'BlockDeviceMappings': [{
'DeviceName': template_data['BlockDeviceMappings']['DeviceName'],
'Ebs': {
'DeleteOnTermination': template_data['BlockDeviceMappings']['Ebs']['DeleteOnTermination'],
'VolumeSize': int(template_data['BlockDeviceMappings']['Ebs']['VolumeSize'])
}
}],
'ImageId': template_data['ImageId'],
'InstanceType': template_data['InstanceType'],
'KeyName': template_data['KeyName'],
'Monitoring': {
'Enabled': template_data['Monitoring'],
},
'Placement': {
'Tenancy': template_data['Placement']['Tenancy']
},
'InstanceInitiatedShutdownBehavior': template_data['InstanceInitiatedShutdownBehavior'],
'UserData': ''.join(template_data['UserData']),
'TagSpecifications': [
{
'ResourceType': 'instance',
'Tags': tags_list
},
{
'ResourceType': 'volume',
'Tags': tags_list
}
],
'SecurityGroupIds': sgs_list
}
)
print('Launch template {} created, result {}.'.format(template, result))
except Exception as err:
critical('Unable to create launch template {}, error {}'.format(template, err))
sys.exit(0)
def main():
""" the main method """
# Working variable
#sec_info = {}
# Install interrupt handler
install_int_handler()
# Process giving arguments
parser = argparse.ArgumentParser(
usage=__usage_txt__, description=__description__,
formatter_class=argparse.RawDescriptionHelpFormatter,
conflict_handler='resolve'
)
parser.add_argument('-version', action='version', version=__info__)
parser.add_argument(
'-config', action='store', dest='cfgfile', help=bao_const.CFG_FILES_HELP, default=bao_const.EC2_CFG_FILE
)
parser.add_argument(
'-cfgdir', action='store', dest='cfgdir', help=bao_const.CFG_DIR_HELP, default=bao_const.CFG_DIR
)
parser.add_argument(
'-action', action='store', dest='action', help=bao_const.ACTION_HELP, choices=bao_const.ACTION_CHOICE,
required=True
)
parser.add_argument(
'-region', action='store', dest='region', help=bao_const.REGION_HELP, default=None
)
parser.add_argument(
'-tag', action='store', dest='tag', help=bao_const.TAG_HELP, default=None
)
parser.add_argument(
'-log', action='store', dest='logfile', help=bao_const.LOG_FILES_HELP, default=bao_const.LOG_FILE
)
# get the given argument
given_args = parser.parse_args()
# set shortname for the option
cfgfile = given_args.cfgfile
cfgdir = given_args.cfgdir
action = given_args.action
region = given_args.region
tag = given_args.tag
if given_args.logfile:
logfile = given_args.logfile
# setup logging
log_formatter = logging.Formatter("%(asctime)s %(filename)s %(name)s %(levelname)s %(message)s")
root_logger = logging.getLogger()
file_handler = logging.FileHandler(logfile)
file_handler.setFormatter(log_formatter)
root_logger.addHandler(file_handler)
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)
root_logger.addHandler(console_handler)
if action == 'explain':
os.system('clear')
print('{}'.format(bao_const.CONFIG_EXPLAINED))
return 0
# Need to handle args here since we have odd combination that is not available the parser
if action == 'regions':
region = bao_const.REGION
tag = 'region'
else:
if region is None or tag is None:
print('action {} requires region, given {} and tag, given {}'.format(action, region, tag))
return 1
print('--< AwsConfig >--')
config = AwsConfig(cfgdir=cfgdir, cfgfile=cfgfile)
print('--< netConfig >--')
if region not in config.settings['dc_cfg']:
critical('Error regions {} has no configuration.'.format(region))
return 1
net_config = set_network_config(dc_cfg=config.settings['dc_cfg'][region])
if not net_config:
return 1
print('--< AwsConnectionManager >--')
conn = AwsConnector(credentials=config.settings['aws_cfg']['credentials'], region=region)
aws_conn = conn.get_all_conn()
if not aws_conn:
return 1
print('--< AwsZones >--')
zones = AwsZones(aws_conn=aws_conn)
if not zones:
return 1
net_config['dc_zones_names'] = zones.get_zones_name()
net_config['dc_zones_id'] = zones.get_zones_id()
net_config['dc_zones'] = zones.get_zones_cnt()
net_config.update(config.settings['dc_cfg'][region])
print('--< validConfig >--')
if validconfig(aws_confg=config.settings['aws_cfg'], net_config=net_config) is False:
return 1
# set keys values early
key_name = config.settings['aws_cfg']['key']['keyname']
key_value = config.settings['aws_cfg']['key']['pubkey']
print('--< AwsRegion >--')
current_regions = show_aws_regions(aws_conn=aws_conn, show=action)
if region not in current_regions:
print('Given region {} in invalid.'.format(region))
print('Valid regions: {}'.format(' - '.join(current_regions)))
return 0
time_started = strftime("%c")
#--------------------------------------------------------------------------------------#
# add EC2 key
if action == 'key':
print('--< AwsKey >--')
key = AwsKey(aws_conn=aws_conn, key_name=key_name, key_value=key_value)
if not key:
return 1
if key.replace() is None:
return 1
#--------------------------------------------------------------------------------------#
# Building a new VPC
if action == 'create':
print('--< create >--')
create_conn = BaoCreate(aws_conn=aws_conn, net_config=net_config, tag=tag, region=region)
create_conn.create()
#--------------------------------------------------------------------------------------#
# Destroy a VPC
if action == 'destroy':
print('--< destroy >--')
print('todo: destroy_vpc(aws_conn=aws_conn, net_config=net_config, tag=tag, region=region)')
#--------------------------------------------------------------------------------------#
# Start all instances in a VPC
if action == 'start':
print('--< start >--')
print('todo: start_instances(aws_conn=aws_conn, net_config=net_config, tag=tag, region=region)')
#--------------------------------------------------------------------------------------#
# Stop all instances in a VPC
if action == 'stop':
print('--< stop >--')
print('todo: stop_instances(aws_conn=aws_conn, net_config=net_config, tag=tag, region=region)')
#--------------------------------------------------------------------------------------#
# Show status all instances in a VPC
if action == 'status':
print('--< status >--')
print('todo: status_instances(aws_conn=aws_conn, net_config=net_config, tag=tag, region=region)')
#--------------------------------------------------------------------------------------#
# Terminate all instances in a VPC
if action == 'terminate':
print('--< terminate >--')
print('todo: terminate_instances(aws_conn=aws_conn, net_config=net_config, tag=tag, region=region)')
#--------------------------------------------------------------------------------------#
# Add instance in a VPC
if action == 'add':
print('--< add >--')
print('todo: add_instances(aws_conn=aws_conn, net_config=net_config, tag=tag, region=region)')
#--------------------------------------------------------------------------------------#
print('Process started: {}'.format(time_started))
print('Process completed: {}'.format(strftime("%c")))
return 0
def main():
""" main """
my_logfile = 'logs/awsbuild.log'
my_region = 'us-east-1'
my_vpc = 'vpc-xxx'
my_tag = 'momo-us-east-1'
# setup logging
log_formatter = logging.Formatter(
"%(asctime)s %(filename)s %(name)s %(levelname)s %(message)s")
root_logger = logging.getLogger()
file_handler = logging.FileHandler(my_logfile)
file_handler.setFormatter(log_formatter)
root_logger.addHandler(file_handler)
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)
root_logger.addHandler(console_handler)
config = AwsConfig(cfgdir='configs',\
cfgfile='lb.yaml',\
cfgkey='elbs')
conn = AwsConnector(credentials=config.settings['aws_cfg']['credentials'],
region=my_region)
aws_conn = conn.get_all_conn()
if not aws_conn:
print('error AwsConnector\n')
sys.exit(-1)
elbv2_conn = aws_conn['elbv2_client']
if not elbv2_conn:
print('error AwsConnector for elbv2_client\n')
sys.exit(-1)
vpc_conn = AwsVPC(aws_conn=aws_conn, tag=my_tag)
if not vpc_conn:
print('error AwsVPC\n')
sys.exit(-1)
#vpc_id = vpc_conn.get_vpc_id()
vpc_conn.set_vpc_resource(vpc_id=my_vpc)
net_config = set_network_config(
dc_cfg=config.settings['dc_cfg'][my_region])
if not net_config:
print('error set_network_config\n')
sys.exit(-1)
sec_conn = AwsSecGroup(aws_conn=aws_conn, cfgs=config.get_settings(), \
dc_cfg=net_config, vpc_id=my_vpc, ipv6=False\
)
if not sec_conn:
print('error\n')
sec_name_dict = sec_conn.get(vpc_id=my_vpc)
target_grp_conn = AwsTargetGroup(aws_conn=aws_conn,
vpc_id=my_vpc,
tag=my_tag)
if not target_grp_conn:
print('error AwsTargetGroup\n')
sys.exit(-1)
target_grp_dict = target_grp_conn.get_target_groups(named_key=True)
elbs_data = config.settings['elbs']
lbs_info = {}
for elb_data in elbs_data:
# reset by each pass
elb_sec_groups_list = []
elb_tag_list = []
temp_tag_dict = {}
#
elb_config = elbs_data[elb_data]
elb_name = elb_data
elb_scheme = elb_config['scheme']
elb_type = elb_config['type']
elb_ipaddresstype = elb_config['ipaddresstype']
elb_tag_list.append({'Key': 'Name', 'Value': elb_name})
for tag_set in elb_config['tag']:
for tag_detail in tag_set:
temp_tag_dict = {
'Key': tag_detail,
'Value': tag_set[tag_detail]
}
elb_tag_list.append(temp_tag_dict)
if elb_type == 'application':
for elb_sec_group in elb_config['securitygroups']:
elb_sec_group_name = elb_sec_group
elb_sec_groups_list.append(sec_name_dict[elb_sec_group_name])
if elb_scheme == 'internal':
subnets_list = [
'subnet-02faead28c21ed12a', 'subnet-08a48156d3d611758',
'subnet-0f8bc11728fcc4cc7'
]
else:
subnets_list = [
'subnet-05f204849ad05086b', 'subnet-0a5676dd39d5923a4',
'subnet-017e90e9060f41fd0'
]
# for charter all internal
elb_scheme = 'internal'
try:
if elb_type == 'application':
new_elb_info = elbv2_conn.create_load_balancer(
Name=elb_name,
Subnets=subnets_list,
Scheme=elb_scheme,
Tags=elb_tag_list,
Type=elb_type,
SecurityGroups=elb_sec_groups_list,
IpAddressType=elb_ipaddresstype)
else:
new_elb_info = elbv2_conn.create_load_balancer(
Name=elb_name,
Subnets=subnets_list,
Scheme=elb_scheme,
Tags=elb_tag_list,
Type=elb_type,
IpAddressType=elb_ipaddresstype)
except Exception as err:
critical('Unable to create elb {}, error {}'.format(elb_name, err))
sys.exit(0)
# get the ARN of the new created LB
for new_elb_info in new_elb_info['LoadBalancers']:
lbs_info[new_elb_info['LoadBalancerName']] =\
new_elb_info['LoadBalancerArn']
lb_arn = new_elb_info['LoadBalancerArn']
# create the listner then add to the LB, for now only support forward and fixed-response
for listner_port in elb_config['listner']:
default_type = elb_config['listner'][listner_port][
'defaultactions']['Type']
if default_type == 'forward':
default_value = elb_config['listner'][listner_port][
'defaultactions']['TargetGroupArn']
default_arn = target_grp_dict[default_value]
if default_type == 'fixed-response':
default_value = elb_config['listner'][listner_port][
'defaultactions']['StatusCode']
try:
if default_type == 'forward':
new_listener = elbv2_conn.create_listener(
LoadBalancerArn=lb_arn,
Protocol=elb_config['listner'][listner_port]
['protocol'],
Port=listner_port,
DefaultActions=[{
'Type': default_type,
'TargetGroupArn': default_arn
}])
if default_type == 'fixed-response':
new_listener = elbv2_conn.create_listener(
LoadBalancerArn=lb_arn,
Protocol=elb_config['listner'][listner_port]
['protocol'],
Port=listner_port,
DefaultActions=[{
'Type': default_type,
'FixedResponseConfig': {
'StatusCode': default_value
}
}])
except Exception as err:
critical('Unable to create elb\'s listner {}, error {}'.format(
elb_name, err))
sys.exit(0)
# get the new listner arn
for new_listener_detail in new_listener['Listeners']:
new_listeners_arn = new_listener_detail['ListenerArn']
if elb_config['listner'][listner_port]['rules']:
listner_rules = elb_config['listner'][listner_port]['rules']
for rule_detail in listner_rules:
rule_priority = int(rule_detail)
rule_conditions = listner_rules[rule_detail]['Conditions']
rule_action = listner_rules[rule_detail]['Actions']
if 'TargetGroupArn' in rule_action:
target_grp_name = rule_action['TargetGroupArn']
target_grp_arn = target_grp_dict[target_grp_name]
rule_action['TargetGroupArn'] = target_grp_arn
try:
elbv2_conn.create_rule(ListenerArn=new_listeners_arn,
Conditions=[rule_conditions],
Priority=rule_priority,
Actions=[rule_action])
except Exception as err:
critical(
'Unable to create elb\'s listner {}, error {}'.format(
elb_name, err))
sys.exit(0)
