class AwsInstanceHelper:
#class to fetch data from aws for atlas
def __init__(self, environment=None):
"""Initialize variables."""
self.ah_obj = AtlasHelper()
self.awshelper_obj = AwsHelper()
self.module = 'aws_module'
self.environment_dict = {}
self.env_subnet_dict = {}
self.env_details_dict = {}
self.environment_groups = self.ah_obj.get_atlas_config_data("global_config_data", "environment_groups")
def get_aws_details(self,regionvpcselected):
organizations = self.awshelper_obj.get_organizations()
aws_details_dict={}
environment_list=[]
aws_details = self.awshelper_obj.get_instances_details()
for organization in organizations:
environment_list = self.awshelper_obj.get_environments(organization)
environment_list.append('uncategorized')
environment_list.append('all')
ah_obj = AtlasHelper()
total_count, total_running, total_stopped=0, 0, 0
region_dict = {}
region_env_list=[]
for environment in environment_list:
if environment != 'all':
env_attributes = self.ah_obj.get_nested_attribute_values(aws_details, environment)[1]
for region in regionvpcselected.keys():
if 'regions' in env_attributes.keys() and region in env_attributes['regions'].keys():
region_keys, region_attributes = ah_obj.get_nested_attribute_values(env_attributes['regions'], region)
if 'count' in region_keys and 'running' in region_keys and 'stopped' in region_keys:
region_count =region_attributes['count']
region_running =region_attributes['running']
region_stopped =region_attributes['stopped']
if environment == "uncategorized":
total_count+=region_count
total_running+=region_running
total_stopped+=region_stopped
region_env_list.append([region, "none", environment, region_count, region_running, region_stopped])
else:
vpc_list = regionvpcselected[region]
for vpc in vpc_list:
if 'vpc' in region_attributes.keys():
vpc_attributes = self.ah_obj.get_nested_attribute_values(region_attributes['vpc'], vpc)[1]
vpc_count = vpc_attributes['count']
vpc_running = vpc_attributes['running']
vpc_stopped = vpc_attributes['stopped']
total_count+=vpc_count
total_running+=vpc_running
total_stopped+=vpc_stopped
region_env_list.append([region, vpc, environment, vpc_count, vpc_running, vpc_stopped])
else:
region_env_list.append([region, vpc, environment, total_count, total_running, total_stopped])
temp_list, total_list = [], []
for count in range(0, len(environment_list)):
total_list.append([environment_list[count],0,0,0])
for index in range(0, len(region_env_list)):
for index1 in range(0, len(total_list)):
if region_env_list[index][2] == total_list[index1][0]:
temp_list = [region_env_list[index][3], region_env_list[index][4], region_env_list[index][5]]
total_list[index1][1]+=temp_list[0]
total_list[index1][2]+=temp_list[1]
total_list[index1][3]+=temp_list[2]
aws_details_dict['total_count'] = total_count
aws_details_dict['total_running'] = total_running
aws_details_dict['total_stopped'] = total_stopped
aws_details_dict['environment_list'] = environment_list
aws_details_dict['region_dict'] = region_dict
aws_details_dict['total_list'] = total_list
return aws_details_dict
def calculate_environment_aggregates(self, environment, env_attributes, region_vpc_dict):
"""
Calculate aggregate values for each environment.
"""
total_list = [0,0,0]
for region in region_vpc_dict.keys():
if region in env_attributes['regions'].keys():
region_attributes = env_attributes['regions'][region]
if environment == 'uncategorized':
region_aggs = [region_attributes['count'],region_attributes['running'], region_attributes['stopped']]
total_list = map(add, total_list, region_aggs)
else:
for vpc in region_vpc_dict[region]:
if vpc and vpc in region_attributes['vpc'].keys():
vpc_properties = self.ah_obj.get_nested_attribute_values(env_attributes['regions'][region], vpc)[1]
vpc_aggregates = [vpc_properties['count'], vpc_properties['running'], vpc_properties['stopped']]
total_list = map(add, total_list, vpc_aggregates)
return total_list
def get_environment_aggregates(self, environment, region_vpc_dict):
"""
Get aggregate status values.
"""
aggregate_list = [0,0,0]
organizations = self.awshelper_obj.get_organizations()
org_attributes = self.ah_obj.get_nested_attribute_values(self.awshelper_obj.get_instances_details(), 'organizations')[1]
for organization in organizations:
if self.environment_groups and environment in self.environment_groups[1].keys():
if environment == 'all':
env_group_for_environment = self.awshelper_obj.get_environments(organization)
else:
env_group_for_environment = self.environment_groups[1][environment]
for env in env_group_for_environment:
env_attributes = self.ah_obj.get_nested_attribute_values(org_attributes[organization], env)[1]
env_agg_list = self.calculate_environment_aggregates(env, env_attributes, region_vpc_dict)
aggregate_list = map(add, aggregate_list, env_agg_list)
else:
env_attributes = self.ah_obj.get_nested_attribute_values(org_attributes[organization], environment)[1]
aggregate_list = self.calculate_environment_aggregates(environment, env_attributes, region_vpc_dict)
return aggregate_list
def determine_environment_status(self, environment, env_attributes, region_vpc_dict):
vpc_status_dict = {}
for region in region_vpc_dict.keys():
if region not in env_attributes['regions'].keys():
continue
else:
region_attributes = env_attributes['regions'][region]
vpc_status_dict[region] = {'status': []}
if environment == 'uncategorized':
vpc_status_dict[region]['status'] = [region_attributes['count'], region_attributes['running'], region_attributes['stopped']]
else:
for vpc in region_vpc_dict[region]:
if vpc and vpc in region_attributes['vpc'].keys():
vpc_status_dict[vpc] = {'status': []}
vpc_properties = self.ah_obj.get_nested_attribute_values(env_attributes['regions'][region], vpc)[1]
vpc_status_dict[vpc]['status'] = [vpc_properties['count'], vpc_properties['running'], vpc_properties['stopped']]
return vpc_status_dict
def get_environment_status(self, environment, region_vpc_dict):
"""Get environment status."""
ah_obj = AtlasHelper()
vpc_status_dict = {}
organizations = self.awshelper_obj.get_organizations()
org_attributes = self.ah_obj.get_nested_attribute_values(self.awshelper_obj.get_instances_details(), 'organizations')[1]
for organization in organizations:
if self.environment_groups and environment in self.environment_groups[1].keys():
env_status_dict = {}
if environment == 'all':
env_group_for_env = self.awshelper_obj.get_environments(organization)
else:
env_group_for_env = self.environment_groups[1][environment]
for env in env_group_for_env:
env_attributes = self.ah_obj.get_nested_attribute_values(org_attributes[organization], env)[1]
env_status_dict = self.determine_environment_status(env, env_attributes, region_vpc_dict)
if not vpc_status_dict:
vpc_status_dict.update(env_status_dict)
else:
for vpc in env_status_dict.keys():
vpc_status_dict[vpc]['status'] = map(add,vpc_status_dict[vpc]['status'],env_status_dict[vpc]['status'])
else:
env_attributes = self.ah_obj.get_nested_attribute_values(org_attributes[organization], environment)[1]
vpc_status_dict = self.determine_environment_status(environment, env_attributes, region_vpc_dict)
return vpc_status_dict
def find_env_details(self, environment, env_attributes, region_vpc_dict):
organizations = self.awshelper_obj.get_organizations()
details_dict, env_subnets_dict = {}, {}
environment_subnets = {'vpc':{}}
apps_in_environment, instances_list, application_subnets, env_subnet_list = [], [], [], []
vpc_attribute_dict, aws_info_dict, env_info_dict={}, {}, {}
instances_list,apps_in_environment, env_subnet_list = [], [], []
subnets_with_instances = {} #new addition
instance_keys = self.ah_obj.get_atlas_config_data(self.module, "instance_keys")
for region in region_vpc_dict.keys():
if region not in env_attributes['regions'].keys():
continue
else:
region_attributes = env_attributes['regions'][region]
if environment == 'uncategorized':
vpc_attribute_dict[region] = {"subnets":{"none":{"instance_attributes":{}}}}
for instance, details in region_attributes['uncat_instances'].iteritems():
if details.has_key('instance_attributes') and details['instance_attributes'].has_key('instance_id'):
instance_id = details['instance_attributes']['instance_id']
vpc_attribute_dict[region]["subnets"]["none"]["instance_attributes"][instance_id] = details['instance_attributes']
aws_info_dict[instance_id] = {}
aws_info_dict[instance_id]['aws_information'] = details['aws_information']
aws_info_dict[instance_id]['aws_tags'] = details['aws_tags']
else:
for vpc in region_vpc_dict[region]:
if vpc and vpc in region_attributes['vpc'].keys():
environment_subnets['vpc'][vpc] = {'subnets':[]}
env_subnet_list.extend(self.awshelper_obj.get_subnets_in_environment(region, vpc, environment))
environment_subnets['vpc'][vpc]['subnets'] = env_subnet_list
vpc_attribute_dict[vpc] = {'subnets': {}, 'applications':[]}
vpc_attribute_dict[vpc]['subnets'] = {}
vpc_properties = self.ah_obj.get_nested_attribute_values(env_attributes['regions'][region], vpc)[1]
if 'subnets' in vpc_properties.keys():
for subnet in vpc_properties['subnets'].keys():
instances_details = vpc_properties['subnets'][subnet]['instances']
if instances_details:
#env_subnet_list.append(subnet)
subnets_with_instances[subnet] = []
vpc_attribute_dict[vpc]['subnets'][subnet] = {'instance_attributes': {}}
if subnet not in application_subnets: application_subnets.append(subnet)
for instance, details in instances_details.iteritems():
instance_attributes = details['instance_attributes']
if instance_attributes:
details_key = details['instance_attributes']['instance_id']
vpc_attribute_dict[vpc]['subnets'][subnet]['instance_attributes'][details_key] = instance_attributes
aws_info_dict[details_key] = {}
aws_info_dict[details_key]['aws_information'] = details['aws_information']
aws_info_dict[details_key]['aws_tags'] = details['aws_tags']
instance_application = instance_attributes['application']
if instance_application not in subnets_with_instances[subnet]:
subnets_with_instances[subnet].append(instance_application)
if instance_attributes['application'] not in apps_in_environment:
apps_in_environment.append(instance_attributes['application'])
details_dict['subnets_with_instances'] = subnets_with_instances
details_dict['environment_subnets'] = environment_subnets
details_dict['application_subnets'] = application_subnets
details_dict['vpc_attribute_dict'] = vpc_attribute_dict
details_dict['aws_info_dict'] = aws_info_dict
details_dict['env_subnet_list'] = env_subnet_list
details_dict['apps_in_environment'] = apps_in_environment
return details_dict
def get_environment_details(self, environment, region_vpc_dict):
"""
Get details for a particular environment or environment_group.
"""
organizations = self.awshelper_obj.get_organizations()
org_attributes = self.ah_obj.get_nested_attribute_values(self.awshelper_obj.get_instances_details(), 'organizations')[1]
for organization in organizations:
if self.environment_groups and environment in self.environment_groups[0]:
if environment == 'all':
env_group_for_environment = self.awshelper_obj.get_environments(organization)
else:
env_group_for_environment = self.environment_groups[1][environment]
for env in env_group_for_environment:
env_attributes = self.ah_obj.get_nested_attribute_values(org_attributes[organization], env)[1]
environment_details = self.find_env_details(env, env_attributes, region_vpc_dict)
if not self.env_details_dict:
self.env_details_dict.update(environment_details)
else:
generator_obj = self.ah_obj.merge_dictionaries(self.env_details_dict, environment_details)
self.env_details_dict = {key:value for key, value in generator_obj}
else:
env_attributes = self.ah_obj.get_nested_attribute_values(org_attributes[organization], environment)[1]
self.env_details_dict = self.find_env_details(environment, env_attributes, region_vpc_dict)
return self.env_details_dict
def get_column_data(self, environment):
column_dict = {}
if 'vpc_attribute_dict' in self.env_details_dict:
environment_attributes = self.env_details_dict['vpc_attribute_dict']
for vpc, vpc_attrs_dict in environment_attributes.iteritems():
column_dict[vpc] = {'subnets': {}}
if 'subnets' in vpc_attrs_dict:
for subnet , subnet_attributes in vpc_attrs_dict['subnets'].iteritems():
column_dict[vpc]['subnets'][subnet] = {'instance_attributes':[]}
if 'instance_attributes' in subnet_attributes:
column_dict[vpc]['subnets'][subnet]['instance_attributes'] = subnet_attributes['instance_attributes']
return column_dict
class AwsInstanceHelper:
#class to fetch data from aws for atlas
def __init__(self, environment=None):
"""Initialize variables."""
self.ah_obj = AtlasHelper()
self.awshelper_obj = AwsHelper()
self.module = 'aws_module'
self.environment_dict = {}
self.env_subnet_dict = {}
self.env_details_dict = {}
self.environment_groups = self.ah_obj.get_atlas_config_data(
"global_config_data", "environment_groups")
def get_aws_details(self, regionvpcselected):
organizations = self.awshelper_obj.get_organizations()
aws_details_dict = {}
environment_list = []
aws_details = self.awshelper_obj.get_instances_details()
for organization in organizations:
environment_list = self.awshelper_obj.get_environments(
organization)
environment_list.append('uncategorized')
environment_list.append('all')
ah_obj = AtlasHelper()
total_count, total_running, total_stopped = 0, 0, 0
region_dict = {}
region_env_list = []
for environment in environment_list:
if environment != 'all':
env_attributes = self.ah_obj.get_nested_attribute_values(
aws_details, environment)[1]
for region in regionvpcselected.keys():
if 'regions' in env_attributes.keys(
) and region in env_attributes['regions'].keys():
region_keys, region_attributes = ah_obj.get_nested_attribute_values(
env_attributes['regions'], region)
if 'count' in region_keys and 'running' in region_keys and 'stopped' in region_keys:
region_count = region_attributes['count']
region_running = region_attributes['running']
region_stopped = region_attributes['stopped']
if environment == "uncategorized":
total_count += region_count
total_running += region_running
total_stopped += region_stopped
region_env_list.append([
region, "none", environment,
region_count, region_running,
region_stopped
])
else:
vpc_list = regionvpcselected[region]
for vpc in vpc_list:
if 'vpc' in region_attributes.keys():
vpc_attributes = self.ah_obj.get_nested_attribute_values(
region_attributes['vpc'],
vpc)[1]
vpc_count = vpc_attributes['count']
vpc_running = vpc_attributes[
'running']
vpc_stopped = vpc_attributes[
'stopped']
total_count += vpc_count
total_running += vpc_running
total_stopped += vpc_stopped
region_env_list.append([
region, vpc, environment, vpc_count,
vpc_running, vpc_stopped
])
else:
region_env_list.append([
region, vpc, environment, total_count, total_running,
total_stopped
])
temp_list, total_list = [], []
for count in range(0, len(environment_list)):
total_list.append([environment_list[count], 0, 0, 0])
for index in range(0, len(region_env_list)):
for index1 in range(0, len(total_list)):
if region_env_list[index][2] == total_list[index1][0]:
temp_list = [
region_env_list[index][3], region_env_list[index][4],
region_env_list[index][5]
]
total_list[index1][1] += temp_list[0]
total_list[index1][2] += temp_list[1]
total_list[index1][3] += temp_list[2]
aws_details_dict['total_count'] = total_count
aws_details_dict['total_running'] = total_running
aws_details_dict['total_stopped'] = total_stopped
aws_details_dict['environment_list'] = environment_list
aws_details_dict['region_dict'] = region_dict
aws_details_dict['total_list'] = total_list
return aws_details_dict
def calculate_environment_aggregates(self, environment, env_attributes,
region_vpc_dict):
"""
Calculate aggregate values for each environment.
"""
total_list = [0, 0, 0]
for region in region_vpc_dict.keys():
if region in env_attributes['regions'].keys():
region_attributes = env_attributes['regions'][region]
if environment == 'uncategorized':
region_aggs = [
region_attributes['count'],
region_attributes['running'],
region_attributes['stopped']
]
total_list = map(add, total_list, region_aggs)
else:
for vpc in region_vpc_dict[region]:
if vpc and vpc in region_attributes['vpc'].keys():
vpc_properties = self.ah_obj.get_nested_attribute_values(
env_attributes['regions'][region], vpc)[1]
vpc_aggregates = [
vpc_properties['count'],
vpc_properties['running'],
vpc_properties['stopped']
]
total_list = map(add, total_list, vpc_aggregates)
return total_list
def get_environment_aggregates(self, environment, region_vpc_dict):
"""
Get aggregate status values.
"""
aggregate_list = [0, 0, 0]
organizations = self.awshelper_obj.get_organizations()
org_attributes = self.ah_obj.get_nested_attribute_values(
self.awshelper_obj.get_instances_details(), 'organizations')[1]
for organization in organizations:
if self.environment_groups and environment in self.environment_groups[
1].keys():
if environment == 'all':
env_group_for_environment = self.awshelper_obj.get_environments(
organization)
else:
env_group_for_environment = self.environment_groups[1][
environment]
for env in env_group_for_environment:
env_attributes = self.ah_obj.get_nested_attribute_values(
org_attributes[organization], env)[1]
env_agg_list = self.calculate_environment_aggregates(
env, env_attributes, region_vpc_dict)
aggregate_list = map(add, aggregate_list, env_agg_list)
else:
env_attributes = self.ah_obj.get_nested_attribute_values(
org_attributes[organization], environment)[1]
aggregate_list = self.calculate_environment_aggregates(
environment, env_attributes, region_vpc_dict)
return aggregate_list
def determine_environment_status(self, environment, env_attributes,
region_vpc_dict):
vpc_status_dict = {}
for region in region_vpc_dict.keys():
if region not in env_attributes['regions'].keys():
continue
else:
region_attributes = env_attributes['regions'][region]
vpc_status_dict[region] = {'status': []}
if environment == 'uncategorized':
vpc_status_dict[region]['status'] = [
region_attributes['count'],
region_attributes['running'],
region_attributes['stopped']
]
else:
for vpc in region_vpc_dict[region]:
if vpc and vpc in region_attributes['vpc'].keys():
vpc_status_dict[vpc] = {'status': []}
vpc_properties = self.ah_obj.get_nested_attribute_values(
env_attributes['regions'][region], vpc)[1]
vpc_status_dict[vpc]['status'] = [
vpc_properties['count'],
vpc_properties['running'],
vpc_properties['stopped']
]
return vpc_status_dict
def get_environment_status(self, environment, region_vpc_dict):
"""Get environment status."""
ah_obj = AtlasHelper()
vpc_status_dict = {}
organizations = self.awshelper_obj.get_organizations()
org_attributes = self.ah_obj.get_nested_attribute_values(
self.awshelper_obj.get_instances_details(), 'organizations')[1]
for organization in organizations:
if self.environment_groups and environment in self.environment_groups[
1].keys():
env_status_dict = {}
if environment == 'all':
env_group_for_env = self.awshelper_obj.get_environments(
organization)
else:
env_group_for_env = self.environment_groups[1][environment]
for env in env_group_for_env:
env_attributes = self.ah_obj.get_nested_attribute_values(
org_attributes[organization], env)[1]
env_status_dict = self.determine_environment_status(
env, env_attributes, region_vpc_dict)
if not vpc_status_dict:
vpc_status_dict.update(env_status_dict)
else:
for vpc in env_status_dict.keys():
vpc_status_dict[vpc]['status'] = map(
add, vpc_status_dict[vpc]['status'],
env_status_dict[vpc]['status'])
else:
env_attributes = self.ah_obj.get_nested_attribute_values(
org_attributes[organization], environment)[1]
vpc_status_dict = self.determine_environment_status(
environment, env_attributes, region_vpc_dict)
return vpc_status_dict
def find_env_details(self, environment, env_attributes, region_vpc_dict):
organizations = self.awshelper_obj.get_organizations()
details_dict, env_subnets_dict = {}, {}
environment_subnets = {'vpc': {}}
apps_in_environment, instances_list, application_subnets, env_subnet_list = [], [], [], []
vpc_attribute_dict, aws_info_dict, env_info_dict = {}, {}, {}
instances_list, apps_in_environment, env_subnet_list = [], [], []
subnets_with_instances = {} #new addition
instance_keys = self.ah_obj.get_atlas_config_data(
self.module, "instance_keys")
for region in region_vpc_dict.keys():
if region not in env_attributes['regions'].keys():
continue
else:
region_attributes = env_attributes['regions'][region]
if environment == 'uncategorized':
vpc_attribute_dict[region] = {
"subnets": {
"none": {
"instance_attributes": {}
}
}
}
for instance, details in region_attributes[
'uncat_instances'].iteritems():
if details.has_key('instance_attributes') and details[
'instance_attributes'].has_key('instance_id'):
instance_id = details['instance_attributes'][
'instance_id']
vpc_attribute_dict[region]["subnets"]["none"][
"instance_attributes"][instance_id] = details[
'instance_attributes']
aws_info_dict[instance_id] = {}
aws_info_dict[instance_id][
'aws_information'] = details['aws_information']
aws_info_dict[instance_id]['aws_tags'] = details[
'aws_tags']
else:
for vpc in region_vpc_dict[region]:
if vpc and vpc in region_attributes['vpc'].keys():
environment_subnets['vpc'][vpc] = {'subnets': []}
env_subnet_list.extend(
self.awshelper_obj.get_subnets_in_environment(
region, vpc, environment))
environment_subnets['vpc'][vpc][
'subnets'] = env_subnet_list
vpc_attribute_dict[vpc] = {
'subnets': {},
'applications': []
}
vpc_attribute_dict[vpc]['subnets'] = {}
vpc_properties = self.ah_obj.get_nested_attribute_values(
env_attributes['regions'][region], vpc)[1]
if 'subnets' in vpc_properties.keys():
for subnet in vpc_properties['subnets'].keys():
instances_details = vpc_properties[
'subnets'][subnet]['instances']
if instances_details:
#env_subnet_list.append(subnet)
subnets_with_instances[subnet] = []
vpc_attribute_dict[vpc]['subnets'][
subnet] = {
'instance_attributes': {}
}
if subnet not in application_subnets:
application_subnets.append(subnet)
for instance, details in instances_details.iteritems(
):
instance_attributes = details[
'instance_attributes']
if instance_attributes:
details_key = details[
'instance_attributes'][
'instance_id']
vpc_attribute_dict[vpc][
'subnets'][subnet][
'instance_attributes'][
details_key] = instance_attributes
aws_info_dict[details_key] = {}
aws_info_dict[details_key][
'aws_information'] = details[
'aws_information']
aws_info_dict[details_key][
'aws_tags'] = details[
'aws_tags']
instance_application = instance_attributes[
'application']
if instance_application not in subnets_with_instances[
subnet]:
subnets_with_instances[
subnet].append(
instance_application)
if instance_attributes[
'application'] not in apps_in_environment:
apps_in_environment.append(
instance_attributes[
'application'])
details_dict['subnets_with_instances'] = subnets_with_instances
details_dict['environment_subnets'] = environment_subnets
details_dict['application_subnets'] = application_subnets
details_dict['vpc_attribute_dict'] = vpc_attribute_dict
details_dict['aws_info_dict'] = aws_info_dict
details_dict['env_subnet_list'] = env_subnet_list
details_dict['apps_in_environment'] = apps_in_environment
return details_dict
def get_environment_details(self, environment, region_vpc_dict):
"""
Get details for a particular environment or environment_group.
"""
organizations = self.awshelper_obj.get_organizations()
org_attributes = self.ah_obj.get_nested_attribute_values(
self.awshelper_obj.get_instances_details(), 'organizations')[1]
for organization in organizations:
if self.environment_groups and environment in self.environment_groups[
0]:
if environment == 'all':
env_group_for_environment = self.awshelper_obj.get_environments(
organization)
else:
env_group_for_environment = self.environment_groups[1][
environment]
for env in env_group_for_environment:
env_attributes = self.ah_obj.get_nested_attribute_values(
org_attributes[organization], env)[1]
environment_details = self.find_env_details(
env, env_attributes, region_vpc_dict)
if not self.env_details_dict:
self.env_details_dict.update(environment_details)
else:
generator_obj = self.ah_obj.merge_dictionaries(
self.env_details_dict, environment_details)
self.env_details_dict = {
key: value
for key, value in generator_obj
}
else:
env_attributes = self.ah_obj.get_nested_attribute_values(
org_attributes[organization], environment)[1]
self.env_details_dict = self.find_env_details(
environment, env_attributes, region_vpc_dict)
return self.env_details_dict
def get_column_data(self, environment):
column_dict = {}
if 'vpc_attribute_dict' in self.env_details_dict:
environment_attributes = self.env_details_dict[
'vpc_attribute_dict']
for vpc, vpc_attrs_dict in environment_attributes.iteritems():
column_dict[vpc] = {'subnets': {}}
if 'subnets' in vpc_attrs_dict:
for subnet, subnet_attributes in vpc_attrs_dict[
'subnets'].iteritems():
column_dict[vpc]['subnets'][subnet] = {
'instance_attributes': []
}
if 'instance_attributes' in subnet_attributes:
column_dict[vpc]['subnets'][subnet][
'instance_attributes'] = subnet_attributes[
'instance_attributes']
return column_dict
class AwsActions:
def __init__(self):
self.awshelper_obj = AwsHelper()
self.ah_obj = AtlasHelper()
self.connection_obj = ""
self.module = "aws_module"
self.memcache_var = memcache.Client([
self.ah_obj.get_atlas_config_data("global_config_data",
'memcache_server_location')
],
debug=0)
def get_instance_state(self, connection, instance_id):
instance = connection.get_only_instances(instance_id)
if instance:
return instance[0].__dict__.get('_state')
else:
return "action_failed"
def get_action_status(self,
connection,
instance_id,
action,
parameters=None):
instance_state = self.get_instance_state(connection, instance_id)
if instance_state == "action_failed":
return {
'instance_id': instance_id,
'action_state': "action_failed",
'instance_state': "unknown",
'error_message': "Action Failed!!!"
}
else:
if action == 'start_instance' or action == 'start_instances':
if str(instance_state) == 'running(16)':
return {
'instance_id': instance_id,
'action_state': "action_completed",
'instance_state': "running"
}
else:
return {
'instance_id': instance_id,
'action_state': "action_in_progress",
'instance_state': str(instance_state)
}
elif action == 'stop_instance' or action == 'stop_instances':
if str(instance_state) == 'stopped(80)':
return {
'instance_id': instance_id,
'action_state': "action_completed",
'instance_state': "stopped"
}
else:
return {
'instance_id': instance_id,
'action_state': "action_in_progress",
'instance_state': str(instance_state)
}
elif action == 'terminate_instance' or action == 'terminate_instances':
if str(instance_state) == 'terminated(48)':
return {
'instance_id': instance_id,
'action_state': "action_completed",
'instance_state': "terminated"
}
else:
return {
'instance_id': instance_id,
'action_state': "action_in_progress",
'instance_state': str(instance_state)
}
elif action == 'edit_tags':
tag_dict = self.get_tags(connection, instance_id)
return {
'instance_id': instance_id,
'editable_output': tag_dict,
'action_state': 'action_completed',
'editable': 'true'
}
elif action == 'create_tag':
return {
'instance_id': instance_id,
'editable_output': {},
'action_state': 'action_intiated',
'editable': 'true'
}
elif action == 'delete_tag':
return {
'instance_id': instance_id,
'editable_output': {},
'action_state': 'action_intiated',
'editable': 'true'
}
def start_instance(self, connection, instance_id):
start_list = connection.start_instances([instance_id])
started_instance = re.findall(instance_id, str(start_list[0]))
if cmp(started_instance, [instance_id]) == 0:
return {
'instance_id': instance_id,
'action_state': "action_initiated",
'instance_state': "unknown"
}
else:
return {
'instance_id': instance_id,
'action_state': "action_failed",
'instance_state': "unknown",
'error_message': 'Could not start instance!!!'
}
def stop_instance(self, connection, instance_id):
stop_list = connection.stop_instances([instance_id])
stopped_instance = re.findall(instance_id, str(stop_list[0]))
if cmp(stopped_instance, [instance_id]) == 0:
return {
'instance_id': instance_id,
'action_state': "action_initiated",
'instance_state': "unknown"
}
else:
return {
'instance_id': instance_id,
'action_state': "action_failed",
'instance_state': "unknown",
'error_message': 'Could not stop instance!!!'
}
def terminate_instance(self, connection, instance_id):
terminated_list = connection.terminate_instances([instance_id])
terminated_instance = re.findall(instance_id, str(terminated_list[0]))
if cmp(terminated_instance, [instance_id]) == 0:
return {
'instance_id': instance_id,
'action_state': "action_initiated",
'instance_state': "unknown"
}
else:
return {
'instance_id': instance_id,
'action_state': "action_failed",
'instance_state': "unknown",
'error_message': 'Could not stop instance!!!'
}
def get_tags(self, connection, instance_id):
instance = connection.get_only_instances(instance_id)
tag_dict = instance[0].tags
if tag_dict:
return tag_dict
def create_tag(self, connection, instance_id, tag_name, tag_value):
result = connection.create_tags(instance_id, {tag_name: tag_value})
if result:
tag_dict = self.get_tags(connection, instance_id)
return {
'instance_id': instance_id,
'editable_output': tag_dict,
'action_state': 'action_completed',
'editable': 'true'
}
def delete_tag(self, connection, instance_id, tag_name, tag_value):
result = connection.delete_tags(instance_id, {tag_name: tag_value})
if result:
tag_dict = self.get_tags(connection, instance_id)
return {
'instance_id': instance_id,
'editable_output': tag_dict,
'action_state': 'action_completed',
'editable': 'true'
}
def initiate_actions(self, action, region, instance_id, parameters=None):
try:
connection = self.awshelper_obj.get_aws_connection(region)
if action == 'start_instance' or action == 'start_instances':
return self.start_instance(connection, instance_id)
elif action == 'stop_instance' or action == 'stop_instances':
return self.stop_instance(connection, instance_id)
elif action == 'terminate_instance' or action == 'terminate_instances':
return self.terminate_instance(connection, instance_id)
elif action == 'create_tag':
tag = parameters.keys()[0]
value = parameters[tag]
return self.create_tag(connection, instance_id, tag, value)
elif action == 'delete_tag':
tag = parameters.keys()[0]
value = parameters[tag]
return self.delete_tag(connection, instance_id, tag, value)
elif action == 'edit_tags':
return self.get_tags(connection, instance_id)
except AWSConnectionError:
return {
'instance_id': instance_id,
'action_state': "action_failed",
'instance_state': "unknown",
'error_message': "AWS Connection Error!!!"
}
except EC2ResponseError as exp_object:
return {
'instance_id': instance_id,
'action_state': "action_failed",
'instance_state': "unknown",
'error_message': "Error in response from EC2!!!"
}
except Exception as exp_object:
return {
'instance_id': instance_id,
'action_state': "action_failed",
'instance_state': "unknown",
'error_message': "Action failed!!! An excpetion occurred!!!"
}
def check_action_status(self,
action,
region,
instance_id,
parameters=None):
connection = ""
try:
connection = self.awshelper_obj.get_aws_connection(region)
action_status = self.get_action_status(connection, instance_id,
action, parameters)
console_output = connection.get_console_output(instance_id)
if console_output:
action_status['console_output'] = console_output.output
action_status['other_info'] = {
'instance_id': console_output.instance_id,
'timestamp': console_output.timestamp
}
return action_status
except AWSConnectionError:
return {
'instance_id': instance_id,
'action_state': "action_failed",
'instance_state': "unknown",
'error_message': "AWS Connection Error!!!"
}
except EC2ResponseError:
return {
'instance_id': instance_id,
'action_state': "action_failed",
'instance_state': "unknown",
'error_message': "Error in response from EC2!!!"
}
except Exception as exp_object:
return {
'instance_id': instance_id,
'action_state': "action_failed",
'instance_state': "unknown",
'error_message': "Action failed!!! An excpetion occurred!!!"
}
"""
helpers
"""
def instance_actions(self, instance_json, environment):
status_dict = {}
action_status = ""
parameters = ""
for instance in instance_json['instance_details_dict']['instances']:
instance_details = instance_json['instance_details_dict'][
'instances'][instance]
region, vpc, subnet, instance_id = instance_details[
'region'], instance_details['vpc'], instance_details[
'subnet'], instance_details['instance_id']
status = instance_details['status']
status_dict[instance_id] = {}
if 'parameters' in instance_json.keys():
parameters = instance_json['parameters']
action_status = self.check_action_status(instance_json['action'],
region, instance_id,
parameters)
if 'editable' in action_status.keys(
) and action_status['editable'] == 'true':
if action_status['action_state'] == 'action_completed':
status_dict[instance_id] = action_status
else:
status_dict[instance_id] = self.initiate_actions(
instance_json["action"], region, instance_id,
instance_json['parameters'])
elif action_status['instance_state'] == status:
status_dict[instance_id][
'error_message'] = "Cannot perform action!!!" + " Instance: " + action_status[
'instance_id'] + " already " + action_status[
'instance_state']
elif action_status['action_state'] == "action_failed":
status_dict[instance_id] = action_status
else:
action_status = self.initiate_actions(instance_json["action"],
region, instance_id,
parameters)
status_dict[instance_id] = action_status
status_dict[instance_id]['action'] = instance_json['action']
status_dict[instance_id]['table_id'] = instance_json['table_id']
status_dict[instance_id]['stack_name'] = instance_json['for_stack']
return status_dict
def instance_status(self, instance_json, environment):
status_dict = {}
action_status = ""
#check if action can be performed
instance_details_dict = instance_json['instance_details_dict']
for instance in instance_details_dict['instances']:
instance_details = instance_details_dict['instances'][instance]
region, vpc, subnet,stack, instance_name, instance_id = instance_details['region'], \
instance_details['vpc'],instance_details['subnet'], instance_details['stack'], \
instance_details['instance'], instance_details['instance_id']
status = instance_details['status']
status_dict[instance_id] = {}
environment_information = self.read_instance_details()
org_name = environment_information['organizations'].keys()[1]
action_status = self.check_action_status(instance_json["action"],
region, instance_id,
instance)
status_dict[instance_id] = action_status
if action_status['action_state'] == "action_failed":
status_dict[instance_id] = action_status
if action_status[
'action_state'] == 'action_completed' and action_status[
'instance_state'] != 'terminated':
env_info = ""
if environment != 'uncategorized':
env_info = environment_information['organizations'][
org_name]['environments'][environment]['regions'][
region]['vpc'][vpc]['subnets'][subnet][
'instances'][instance_name][
'instance_attributes']
else:
env_info = environment_information['organizations'][
org_name]['environments'][environment]['regions'][
region]['uncat_instances'][instance_name][
'instance_attributes']
if env_info:
env_info.__setitem__('status',
action_status["instance_state"])
self.write_instance_details(environment_information)
elif action_status[
'action_state'] == 'action_complete' and action_status[
'instance_state'] == 'terminated':
if environment != 'uncategorized':
environment_information.pop(
environment_information['organizations'][org_name]
['environments'][environment]['regions'][region]['vpc']
[vpc]['subnets'][subnet]['instances'][instance_name])
else:
environment_information.pop(
environment_information['organizations'][org_name]
['environments'][environment]['regions'][region]
['uncat_instances'][instance_name])
self.write_instance_details(environment_information)
status_dict[instance_id]['action_type'] = instance_json[
'action_type']
status_dict[instance_id]['action'] = instance_json['action']
status_dict[instance_id]['table_id'] = instance_json['table_id']
status_dict[instance_id]['stack_name'] = instance_json['for_stack']
status_dict[instance_id]['action_type'] = instance_json[
'action_type']
status_dict[instance_id]['action'] = instance_json['action']
return status_dict
def write_instance_details(self, instance_details):
self.memcache_var.set("aws_instances_details_cache", instance_details)
def read_instance_details(self):
instance_details = self.awshelper_obj.get_instances_details()
if instance_details:
return instance_details
