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)