def _get_dest_instance_info(instances, update_module_info):
"""
return instances' infomation include instance id, private ip, keypair name and module name.
"""
dest_instance_info = []
module_to_instance_id = {}
for instance in instances:
instance_name = ec2api.get_instance_tag_name(instance)
if not instance_name:
continue
module_name, module_version = ec2api.get_module_info(instance_name)
if module_name in update_module_info and module_version == update_module_info.get(
module_name):
instance_id = instance.instance_id
instance_ip = instance.private_ip_address
keyname = instance.key_name
dest_instance_info.append(
(instance_id, instance_ip, keyname, module_name))
update_module_info.pop(module_name)
module_to_instance_id.update({module_name: instance_id})
if update_module_info:
error_msg = "some modules' instance not found : %s" % update_module_info.keys(
)
logger.error(error_msg)
return {'ret': False, 'msg': error_msg}
return {
'ret': True,
'dest_instance_info': dest_instance_info,
'module_id_dict': module_to_instance_id
}
def add_volume_tags(ec2res, instance_ids):
"""
Add volume tags with instance information
Args:
ec2res: boto3 ec2 resource
instance_ids (list): instance ids
"""
ret = {'success': [], 'failed': []}
# for each instance
for instance_id in instance_ids:
try:
instance = ec2res.Instance(instance_id)
# get volume tags:
boto3tags = [{
'Key': 'InstanceId',
'Value': instance_id
}, {
'Key': 'Name',
'Value': ec2api.get_instance_tag_name(instance)
}]
for volume in instance.volumes.all():
volume.create_tags(Tags=boto3tags)
ret['success'].append(instance_id)
except Exception as ex:
logger.error('add ebs(%s) tags failed:\n%s' %
(instance_id, traceback.format_exc()))
ret['failed'].append(instance_id)
if ret['failed']:
raise Exception('add ebs tags failed: %s' % ', '.join(ret['failed']))
def __render_instance(instances_detail_dict, instance, can_operate,
bool_check_state, region):
instance_name = ec2api.get_instance_tag_name(instance)
module_name, module_version = ec2api.get_module_info(instance_name)
instance_state = instance.state['Name']
private_ip = instance.private_ip_address
instance_info_dict = {
'instance_name': instance_name,
'public_ip': instance.public_ip_address,
'private_ip': private_ip,
'instance_state': instance_state,
'module_state': 'stopped' if instance_state != 'running' else 'tbd'
}
if bool_check_state:
if instance_state != 'running':
is_running = False
else:
is_running = __check_service_state(module_name, module_version,
region, private_ip)
if is_running:
instance_info_dict.update({'module_state': 'running'})
else:
instance_info_dict.update({'module_state': 'stopped'})
module_info = '%s-%s' % (module_name, module_version)
instance_info = instances_detail_dict.get(module_info)
if instance_info:
instance_info['total_count'] += 1
if instance_state == 'running':
instance_info['running_count'] += 1
instance_info['instances'].append(instance_info_dict)
else:
instances_detail_dict.update({
module_info: {
"module_info": module_info,
"module_name": module_name,
"module_version": module_version,
"total_count": 1,
"running_count": 1 if instance_state == 'running' else 0,
"service_started_count": 0,
"instances": [instance_info_dict],
}
})
if can_operate:
operations = '''<button class="btn btn-primary btn-sm" type="button" onclick="startService('%s')">
<i class="fa fa-play"></i>
</button>
<button class="btn btn-primary btn-sm" type="button" onclick="stopService('%s')">
<i class="fa fa-power-off"></i>
</button>
<button class="btn btn-primary btn-sm" type="button" onclick="restartService('%s')">
<i class="fa fa-repeat"></i>
</button> ''' % (module_info, module_info, module_info)
else:
operations = '''<button class="btn btn-primary btn-sm" type="button"
onclick="alertMessage('没有实例操作权限！', 'normal', 'Message', 'primary')">
<i class="fa fa-ban"></i>
</button>'''
instances_detail_dict[module_info].update({'operations': operations})
if bool_check_state and is_running:
instances_detail_dict[module_info]['service_started_count'] += 1
def scan_all_instances(region):
biz_instances = ec2api.find_biz_instances(region)
instance_info_dict = {}
for instance in biz_instances:
instance_name = ec2api.get_instance_tag_name(instance)
ip = instance.private_ip_address
key_name = instance.key_name
module_name, module_version = ec2api.get_module_info(instance_name)
services = module_name.split('_')
versions = module_version.split('_')
if len(services) != len(versions):
error_msg = 'instance name not correct: %s, service number and version number not equal' % instance_name
logger.error(error_msg)
raise Exception(error_msg)
for name, version in zip(services, versions):
if not instance_info_dict.get(name):
instance_info_dict.update(
{name: {
version: [(ip, key_name)]
}})
elif not instance_info_dict[name].get(version):
instance_info_dict[name].update(
{version: [(ip, key_name)]})
else:
instance_info_dict[name][version].append((ip, key_name))
logger.debug('all business isntances info dict: %s' %
json.dumps(instance_info_dict))
return instance_info_dict
def check(self):
logger.debug('start to check conf.')
result = {}
for instance in self.instances:
self._set_env(instance)
instance_result = {}
instance_name = ec2api.get_instance_tag_name(instance)
module_name, module_version = ec2api.get_module_info(instance_name)
instance_result.update(self.basic_check(module_name))
modules = module_name.split('_')
versions = module_version.split('_')
for name, version in zip(modules, versions):
service_type = BizServiceLayer.objects.get(
service_name=name).service_type
attrname = "check_%s_module" % service_type
try:
common_check_method = getattr(self, attrname)
instance_result.update(
{name: common_check_method(name, version)})
except AttributeError:
logger.warn(
'no common check method for service type: %s not found, try %s special check'
% (service_type, name))
logger.info('search if module: %s has special check')
try:
special_check_method = getattr(self, 'check_%s' % name)
special_check_method(version, instance_result)
logger.info('finished special check for module: %s' % name)
except AttributeError:
logger.info(
'no special check method for %s, check for %s finished'
% (name, name))
result.update({instance.id: instance_result})
return result
def home(request):
current_region = RegionInfo.get_region(request)
regions = RegionInfo.get_regions_infos(['region', 'chinese_name'],
exclude_regions=[current_region])
service_order = BasicServiceStarter.get_service_order(current_region)
service_list = []
for services in service_order.values():
service_list += services
basic_service_instances = ec2api.find_basic_instances(
current_region, service_list)
basic_service_infos = {}
for order in service_order:
basic_service_infos[order] = {}
for instance in basic_service_instances:
instance_state = instance.state['Name']
instance_name = ec2api.get_instance_tag_name(instance)
logger.debug('instance name: %s' % instance_name)
service_name = ec2api.get_module_info(instance_name)[0]
ip = instance.private_ip_address
service_state = True
service_order = BasicServiceDeployInfo.objects.get(
service_name=service_name).order
service_info = basic_service_infos[service_order].get(service_name)
if service_info:
service_info['total_count'] += 1
if instance_state == 'running':
service_info['running_count'] += 1
else:
service_info['service_state'] = False
service_info.get('details').append(
(instance_name, ip, instance_state))
else:
if instance_state == 'running':
running_count = 1
else:
running_count = 0
service_state = False
basic_service_infos[service_order].update({
service_name: {
'total_count': 1,
'running_count': running_count,
'service_state': service_state,
'details': [(instance_name, ip, instance_state)]
}
})
logger.debug('basic service info after one instance: %s ' %
json.dumps(basic_service_infos))
logger.debug('basic service infos: %s' % json.dumps(basic_service_infos))
basic_service_page = SitePage.objects.get(name='basic')
return render(
request, 'basic/basic-service-details.html', {
'basic_service_infos': basic_service_infos,
'current_region': current_region,
'regions': regions,
'basic_service_page': basic_service_page
})
def _get_instances_max_number(prefix, instances):
p = prefix + "-(\d+)"
max_number = -1
for instance in instances:
name = ec2api.get_instance_tag_name(instance)
m = re.match(p, name)
if m is not None:
num = int(m.groups()[0])
if num > max_number:
max_number = num
return max_number
def __init__(self, region):
self.service_name = 'rabbitmq'
BasicService.__init__(self, region)
self.ip_list = []
dest_dict = {}
for instance in self.instances:
self.key_name = instance.key_name
self.ip_list.append(instance.private_ip_address)
instance_name = ec2api.get_instance_tag_name(instance)
dest_dict.update({instance_name: instance})
self.instance_list = dest_dict.items()
# sort all rabbitmq instance by Name tag. make sure the right order when start service.
self.instance_list.sort()
def __init__(self, region):
BasicService.__init__(self, region)
cass_bin_path = '%s/cloud-third/cassandra/apache-cassandra-2.1.5/bin' % HOME_PATH
self.startCmd = '/bin/bash -c "source /etc/profile;nohup %s/cassandra -f > %s/cas_out&"' % (cass_bin_path,
HOME_PATH)
dest_dict = {}
self.name_instance_dict = {}
for instance in self.instances:
self.key_name = instance.key_name
instance_ip = instance.private_ip_address
instance_name = ec2api.get_instance_tag_name(instance)
dest_dict.update({instance_name: instance_ip})
self.name_instance_dict.update({instance_name: instance})
self.instances_list = dest_dict.items()
self.instances_list.sort()
def get_basic_ips(regions, account):
basic_service_infos = {}
for region in regions:
logger.info('scan basic service ips in region: %s, account: %s' % (region, account))
try:
basic_service_instances = BasicServiceDeployInfo.find_all_instances(region, account)
except:
error_msg = 'get all basic service instances failed, region: %s, account: %s, error_msg:\n%s' % (
region,
account,
traceback.format_exc()
)
raise Exception(error_msg)
basic_services_info_in_one_region = {}
for instance in basic_service_instances:
instance_name = ec2api.get_instance_tag_name(instance)
service_name = ec2api.get_module_info(instance_name)[0]
logger.debug('found %s instance: %s' % (service_name, instance_name))
if service_name in basic_services_info_in_one_region:
basic_services_info_in_one_region[service_name].update({
instance_name: instance.private_ip_address
})
else:
basic_services_info_in_one_region.update({
service_name: {
instance_name: instance.private_ip_address
}
})
logger.debug('basic service info in region(%s) and account(%s): %s' % (region,
account,
basic_services_info_in_one_region))
for service_name in basic_services_info_in_one_region:
service_infos = basic_services_info_in_one_region[service_name]
infos_list = service_infos.items()
infos_list.sort()
basic_service_ips = [info[1] for info in infos_list]
if service_name in basic_service_infos:
basic_service_infos[service_name].update({region: basic_service_ips})
else:
basic_service_infos.update({
service_name: {region: basic_service_ips}
})
logger.debug('in account %s, service ip dict: %s' % (account, basic_service_infos))
return basic_service_infos
def scan_instances_and_save_module(region, username):
region_obj = RegionInfo.objects.get(region=region)
user_obj = User.objects.get(username=username)
for layer, modules in biz_modules.items():
order = layer_order_map[layer]
for module in modules:
instances = ec2api.find_instances(region, ['*-%s-*' % module])
max_version = '1.0.0'
count = 0
instance_name = None
module_name = None
module_version = None
for instance in instances:
instance_name = ec2api.get_instance_tag_name(instance)
module_name, module_version = ec2api.get_module_info(
instance_name)
if version_cmp(module_version, max_version) == 1:
count = 0
max_version = module_version
elif version_cmp(module_version, max_version) == 0:
count += 1
elb_names = ELB_MODULES.get(module_name)
if count:
mi = ModuleInfo(module_name=module_name,
current_version=max_version,
instance_count=count + 1,
elb_names=elb_names,
user=user_obj,
order=-1)
mi.save()
mi.regions.add(region_obj)
for service in module.split('_'):
if service in STANDARD_MODULES:
service_type = 'standard'
elif service in TOMCAT_MODULES:
service_type = 'tomcat'
else:
service_type = 'other'
biz_module = BizServiceLayer(module=mi,
service_name=service,
layer_name=layer,
start_order=order,
service_type=service_type)
biz_module.save()
def report(self):
report_ret = ''
output_template = Template(check_result_panel_html)
for instance_id in self.results:
instance_result = self.results[instance_id]
self.output += '<table class="table table-hover">'
current_instance = None
for instance in self.instances:
if instance.id == instance_id:
current_instance = instance
break
if current_instance:
instance_name = ec2api.get_instance_tag_name(current_instance)
self.report_instance(current_instance, instance_result,
instance_name)
output_header = '%s (%s) - %s' % (
instance_name, instance_id,
current_instance.private_ip_address)
else:
output_header = ''
logger.warn("<Warning> Unrecognized instance: %s " %
instance_id)
self.output += "</table>\r\n"
if self.output.find('False') == -1:
pass_or_not = 'success'
else:
pass_or_not = 'danger'
report_ret += output_template.render(pass_or_not=pass_or_not,
instance_id=instance_id,
header=output_header,
result_table=self.output)
self.output = ''
pwd = os.path.split(os.path.realpath(__file__))[0]
fp = open(os.path.join(pwd, "report_body.html"), 'r')
output = fp.read()
fp.close()
report_ret = output.replace("{{replaceContent}}", report_ret)
fp = open(os.path.join(pwd, "report.html"), 'w')
fp.write(report_ret)
fp.close()
return report_ret
def get_instances_for_elb(request):
region = request.GET.get('region')
elbname = request.GET.get('loadbalancerName')
if not region or not elbname:
return HttpResponse('params not correct!', status=400)
instances = LoadBalancerCreater.get_instances_of_elb(region, elbname)
instance_ids = elb_api.get_instances_in_elb(region, elbname)
registered_instances = []
unregistered_instances = []
for instance in instances:
instance_name = ec2api.get_instance_tag_name(instance)
instance_id = instance.instance_id
if instance_id in instance_ids:
registered_instances.append([instance_id, instance_name])
else:
unregistered_instances.append([instance_id, instance_name])
return render(
request, 'elb/choose-elb-instances.html', {
'unregistered_instances': unregistered_instances,
'registered_instances': registered_instances
})
def __to_str(region, instance_id):
ec2conn = AwsAccount.get_awssession(region).resource('ec2')
instance = ec2conn.Instance(instance_id)
instance_name = ec2api.get_instance_tag_name(instance)
return '%s(%s)' % (instance_name, instance_id)
