def build_business_relations(business):
    print business
    response = {}
    instances_to_busi = model_ora.get_all_instances_accord_busi(business)
    business_right_json, business_left_json, center_instance_json = [], [], []
    business_right_set, business_left_set, center_instance_set = [], [], []
    business_to_instance, instance_to_business = {}, {}
    business_left, business_right = model_ora.get_left_business(business), model_ora.get_right_business(
        business)
    business_right_set = list(set([unicode(item[0], 'utf-8') for item in business_right]))
    business_left_set = list(set([unicode(item[0], 'utf-8') for item in business_left]))
    for item in business_left:
        try:
            oop = item[1]
            tmp = {'services_name': item[0], 'services_next': item[1],
                   'services_index': instances_to_busi.index(item[1])}
            business_left_json.append(tmp)
        except:
            pass
    for item in business_right:
        try:
            tmp = {'oop_name': item[1], 'oop_next': unicode(item[0], 'utf-8'),
                   'oop_index': business_right_set.index(unicode(item[0], 'utf-8'))}
            center_instance_json.append(tmp)
        except:
            pass
    for item in business_right_set:
        try:
            tmp = {'services_name': item, 'services_index': business_right_set.index(item)}
            business_right_json.append(tmp)
        except:
            pass
    if len(center_instance_json) == 0:
        for i, item in enumerate(instances_to_busi):
            tmp = {'oop_name': item, 'oop_next': 'null', 'oop_index': i}
            center_instance_json.append(tmp)

    data = {'business_left': business_left_json,
            'business_center': {'services_name': business, 'service_data': center_instance_json},
            'business_right': business_right_json}

    response.update({'data': data, 'result': 'success', 'services_name': business, 'message': 'OK'})
    return response
    "type": "business_relations",
    "get_time": "",
    "services_name": "OPENAV,INST-TOD-IBEAVE",
    "ip_address": "",
}

business = request_data["services_name"]
if business.find(",") != -1:
    bu_in = business.split(",")
    instance = bu_in[1]
    business = bu_in[0]
else:
    instance = None
instances_to_busi = model_ora.get_all_instances_accord_busi(business)
business_right_json, business_left_json, center_instance_json = [], [], []
business_left, business_right = model_ora.get_left_business(business), model_ora.get_right_business(business)
business_right_set = list(set([unicode(item[0], "utf-8") for item in business_right]))
instance_accord_right_set = list(set(item[1] for item in business_right))
instance_diff = list(set(instances_to_busi).difference(set(instance_accord_right_set)))
for item in business_left:
    try:
        tmp = {"services_name": item[0], "services_next": item[1], "services_index": instances_to_busi.index(item[1])}
        business_left_json.append(tmp)
    except:
        pass

for item in business_right:
    try:
        tmp = {
            "oop_name": item[1],
            "oop_next": unicode(item[0], "utf-8"),
Exemplo n.º 3
0
    def POST(self):
        request_data = eval(web.input().keys()[0])['request']
        print request_data
        request_type = utils.s(request_data['type'])
        response = utils.generate_response_header(request_data)
        if request_type == 'get_ip_service':
            pass
        elif request_type == 'business_relations':
            business, ip_insts = Alert.preprocess_request_data(request_data)
            ips = list(set([ip[0] for ip in ip_insts]))
            insts_to_business = list(set([ip[1] for ip in ip_insts]))
            if business.find(',') != -1:
                business = business.split(',')[0]
            right_business, left_business = [], []
            center_business_json, left_business_json, right_business_json = [], [], []
            inst_to_ips_dict = {}
            if len(ips) != 0:
                for item in ip_insts:
                    if item[1] in inst_to_ips_dict:
                        inst_to_ips_dict[item[1]].add(item[0])
                    else:
                        inst_to_ips_dict[item[1]] = set()
                        inst_to_ips_dict[item[1]].add(item[0])

                if len(insts_to_business) > 1:
                    left_business = model_ora.get_left_business_accord_instances_and_ips(insts_to_business, ips)
                    right_business = model_ora.get_right_business_accord_instances_and_ips(insts_to_business, ips)
                else:
                    left_business = model_ora.get_left_business_accord_instance_and_ips(insts_to_business[0], ips)
                    right_business = model_ora.get_right_business_accord_instance_and_ips(insts_to_business[0], ips)
            else:
                insts_to_business = model_ora.get_all_instances_accord_busi(business)
                left_business = model_ora.get_left_business(business)
                right_business = model_ora.get_right_business(business)

            all_businesses = list(
                set(list(set(item[0] for item in right_business)) + list(set(item[0] for item in left_business))))
            alert_businesses, alert_instances = map(lambda x: list(set(x)), model_reporter.get_alert_businesses_insts())
            busi_alert_dict = {}
            inst_alert_dict = {}
            for busi in all_businesses:
                if busi in alert_businesses:
                    busi_alert_dict.update({busi: True})
            for inst in insts_to_business:
                if inst in alert_instances:
                    inst_alert_dict.update({inst: True})

            right_business_set = list(set([unicode(item[0], 'utf-8') for item in right_business]))
            left_business_set = list(set([unicode(item[0], 'utf-8') for item in left_business]))
            for item in left_business:
                try:
                    oop = item[1]
                    tmp = {
                        'services_name': item[0],
                        'services_next': item[1],
                        'services_index': insts_to_business.index(item[1])
                    }
                    if tmp['services_name'] in busi_alert_dict:
                        tmp.update({'alert': True})
                    left_business_json.append(tmp)
                except:
                    pass
            for item in right_business:
                try:
                    tmp = {
                        'oop_name': item[1],
                        'oop_next': unicode(item[0], 'utf-8'),
                        'oop_index': right_business_set.index(unicode(item[0], 'utf-8'))
                    }
                    if tmp['oop_next'] == u'':
                        continue
                    if tmp['oop_name'] in inst_alert_dict:
                        tmp.update({'alert': True})
                    if tmp['oop_name'] in inst_to_ips_dict:
                        tmp.update({'center_ips': list(inst_to_ips_dict[tmp['oop_name']])})
                    center_business_json.append(tmp)
                except:
                    pass

            for item in right_business_set:
                try:
                    tmp = {
                        'services_name': item,
                        'services_index': right_business_set.index(item)
                    }
                    if tmp['services_name'] in busi_alert_dict:
                        tmp.update({'alert': True})
                    right_business_json.append(tmp)
                except:
                    pass
            if len(center_business_json) == 0:
                for i, item in enumerate(insts_to_business):
                    tmp = {
                        'oop_name': item,
                        'oop_next': '',
                        'oop_index': i
                    }
                center_business_json.append(tmp)
            data = {
                'business_left': left_business_json,
                'business_center': {
                    'services_name': business,
                    'service_data': center_business_json
                },
                'business_right': right_business_json}
            response.update({
                'data': data,
                'result': 'success',
                'services_name': business,
                'message': 'OK'
            })
        elif request_type == 'oop_relations':
            instance_name = request_data['oop_name']
            center_ips = request_data['center_ips'] if 'center_ips' in request_data else None
            oop_left, oop_right = [], []
            if center_ips is None:
                oop_left = model_ora.get_left_business_accord_instance(instance_name)
                oop_right = model_ora.get_right_business_accord_instance(instance_name)
            else:
                # 需要测试实现方法
                oop_left = model_ora.get_left_business_accord_instance_and_ips(instance_name, center_ips)
                oop_right = model_ora.get_right_business_accord_instance_and_ips(instance_name, center_ips)
            try:
                oop_left_set = [unicode(item[0], 'utf-8') for item in oop_left]
                oop_right_set = [unicode(item[0], 'utf-8') for item in oop_right]
                oop_left_json, oop_right_json = [], []

                for item in oop_left_set:
                    tmp = dict({
                        'services_name': item,
                        'services_index': oop_left_set.index(item)
                    })
                    oop_left_json.append(tmp)
                for item in oop_right_set:
                    tmp = dict({
                        'services_name': item,
                        'services_index': oop_right_set.index(item)}
                    )
                    oop_right_json.append(tmp)

                if string.lower('-'.join([instance_name.split('-')[0],
                                          instance_name.split('-')[-1]])) == 'inst-db':
                    oop_right_json = []
                response.update({
                    'data': {
                        'oop_left': oop_left_json,
                        'oop_right': oop_right_json
                    },
                    'result': 'success',
                    'message': 'OK'
                })
            except:
                pass
        elif request_type == 'oop_ip_list':
            instance_name = request_data['oop_name']
            business_name = request_data['business_name']
            # 如果center_ips不是空,则需要将不再center_ips中的ips都要剔除
            center_ips = set(request_data['center_ips']) if 'center_ips' in request_data else None
            instance_infos = []
            try:
                instance_infos = model_ora.get_detail_info_of_instance_to_business(instance_name, business_name)
                if center_ips is not None:
                    for item in instance_infos:
                        if item['ip_address'] in center_ips:
                            instance_infos.remove(item)

                response.update({
                    'result': 'success',
                    'data': instance_infos,
                    'message': 'OK'
                })
            except Exception, e:
                response.update({
                    'result': 'fail',
                    'message': e.message
                })
            pass
Exemplo n.º 4
0
    def POST(self):
        print web.data()
        request_data = eval(web.data())['request']
        request_type = utils.s(request_data['type'])
        response = utils.generate_response_header(request_data)
        if request_type == 'business_relations':
            business = request_data['services_name']

            # print business
            if business.find(',') != -1:
                print 'business with instance'
                bu_in = business.split(',')
                instance = bu_in[1]
                business = bu_in[0]
            else:
                instance = None
            instances_to_busi = model_ora.get_all_instances_accord_busi(business)
            business_right_json, business_left_json, center_instance_json = [], [], []
            business_right_set, business_left_set, center_instance_set = [], [], []
            business_to_instance, instance_to_business = {}, {}
            business_left, business_right = model_ora.get_left_business(business), model_ora.get_right_business(
                business)
            business_right_set = list(set([unicode(item[0], 'utf-8') for item in business_right]))
            instance_accord_right_set = list(set(item[1] for item in business_right))
            instance_diff = list(set(instances_to_busi).difference(set(instance_accord_right_set)))
            business_left_set = list(set([unicode(item[0], 'utf-8') for item in business_left]))
            for item in business_left:
                try:
                    oop = item[1]
                    tmp = {
                        'services_name': item[0],
                        'services_next': item[1],
                        'services_index': instances_to_busi.index(item[1])
                    }
                    business_left_json.append(tmp)
                except:
                    pass

            for item in business_right:
                try:
                    tmp = {
                        'oop_name': item[1],
                        'oop_next': unicode(item[0], 'utf-8'),
                        'oop_index': business_right_set.index(unicode(item[0], 'utf-8'))
                    }
                    center_instance_json.append(tmp)
                except:
                    pass

            for item in business_right_set:
                try:
                    tmp = {
                        'services_name': item,
                        'services_index': business_right_set.index(item)
                    }
                    business_right_json.append(tmp)
                except:
                    pass
            if len(instance_diff) != 0:
                for i, item in enumerate(instance_diff):
                    tmp = {
                        'oop_name': item,
                        'oop_next': '',
                        'oop_index': i
                    }
                    center_instance_json.append(tmp)
            if len(center_instance_json) == 0:
                for i, item in enumerate(instances_to_busi):
                    tmp = {
                        'oop_name': item,
                        'oop_next': '',
                        'oop_index': i
                    }
                    center_instance_json.append(tmp)
            data = {
                'business_left': business_left_json,
                'business_center': {
                    'services_name': business,
                    'service_data': center_instance_json
                },
                'business_right': business_right_json}
            if instance is not None:
                data.update({'oop_name': instance})

            response.update({
                'data': data,
                'result': 'success',
                'services_name': business,
                'message': 'OK'
            })

        elif request_type == 'oop_relations':
            instance_name = request_data['oop_name']
            try:
                oop_left = model_ora.get_left_business_accord_instance(instance_name)
                oop_right = model_ora.get_right_business_accord_instance(instance_name)
                oop_left_set = [unicode(item[0], 'utf-8') for item in oop_left]
                oop_right_set = [unicode(item[0], 'utf-8') for item in oop_right]
                oop_left_json, oop_right_json = [], []

                for item in oop_left_set:
                    tmp = dict({
                        'services_name': item,
                        'services_index': oop_left_set.index(item)
                    })
                    oop_left_json.append(tmp)
                for item in oop_right_set:
                    tmp = dict({
                        'services_name': item,
                        'services_index': oop_right_set.index(item)}
                    )
                    oop_right_json.append(tmp)

                if string.lower('-'.join([instance_name.split('-')[0],
                                          instance_name.split('-')[-1]])) == 'inst-db':
                    oop_right_json = []
                response.update({
                    'data': {
                        'oop_left': oop_left_json,
                        'oop_right': oop_right_json
                    },
                    'result': 'success',
                    'message': 'OK'
                })
            except Exception, e:
                print e.message
                response.update({
                    'result': 'fail',
                    'message': e.message
                })