Example #1
0
 def check_service_source(self, team, team_name, group_id, region_name):
     service_list = share_repo.get_service_list_by_group_id(team=team, group_id=group_id)
     if service_list:
         can_publish_list = [
             service for service in service_list if service.service_source != "market"
         ]
         if not can_publish_list:
             data = {"code": 400, "success": False, "msg_show": "此组中的应用全部来源于云市,无法发布",
                     "list": list(), "bean": dict()}
             return data
         else:
             # 批量查询应用状态
             service_ids = [service.service_id for service in service_list]
             status_list = base_service.status_multi_service(region=region_name, tenant_name=team_name,
                                                             service_ids=service_ids, enterprise_id=team.enterprise_id)
             for status in status_list:
                 if status["status"] != "running":
                     data = {"code": 400, "success": False, "msg_show": "您有应用未在运行状态不能发布。",
                             "list": list(), "bean": dict()}
                     return data
                 else:
                     data = {"code": 200, "success": True, "msg_show": "您的应用都在运行中可以发布。",
                             "list": list(), "bean": dict()}
                     return data
     else:
         data = {"code": 400, "success": False, "msg_show": "当前组内无应用", "list": list(), "bean": dict()}
         return data
Example #2
0
 def query_group_service_plugin_list(self, team, group_id):
     service_list = share_repo.get_service_list_by_group_id(team=team, group_id=group_id)
     if service_list:
         service_ids = [x.service_id for x in service_list]
         plugins = plugin_service.get_plugins_by_service_ids(service_ids)
         # 默认插件分享
         for p in plugins:
             p["is_share"] = True
         return plugins
     else:
         return []
    def query_share_service_info(self, team, group_id):
        service_list = share_repo.get_service_list_by_group_id(
            team=team, group_id=group_id)
        if service_list:
            array_ids = [x.service_id for x in service_list]
            deploy_versions = self.get_team_service_deploy_version(
                service_list[0].service_region, team, array_ids)
            array_keys = []
            for x in service_list:
                if x.service_key == "application" or x.service_key == "0000" or x.service_key == "":
                    array_keys.append(x.service_key)
            # 查询组件端口信息
            service_port_map = self.get_service_ports_by_ids(array_ids)
            # 查询组件依赖
            dep_service_map = self.get_service_dependencys_by_ids(array_ids)
            # 查询组件可变参数和不可变参数
            # service_env_change_map, service_env_nochange_map = self.get_service_env_by_ids(array_ids)
            service_env_map = self.get_service_env_by_ids(array_ids)
            # 查询组件持久化信息
            service_volume_map = self.get_service_volume_by_ids(array_ids)
            # dependent volume
            dep_mnt_map = self.get_dep_mnts_by_ids(team.tenant_id, array_ids)
            # 查询组件伸缩方式信息
            extend_method_map = self.get_service_extend_method_by_keys(
                array_keys)
            # 获取组件的健康检测设置
            probe_map = self.get_service_probes(array_ids)

            all_data_map = dict()

            for service in service_list:
                data = dict()
                data['service_id'] = service.service_id
                data['tenant_id'] = service.tenant_id
                data['service_cname'] = service.service_cname
                data['service_key'] = service.service_key
                if (service.service_key == 'application'
                        or service.service_key == '0000'
                        or service.service_key == 'mysql'):
                    data['service_key'] = make_uuid()
                    service.service_key = data['service_key']
                    service.save()
                #     data['need_share'] = True
                # else:
                #     data['need_share'] = False
                data["service_share_uuid"] = "{0}+{1}".format(
                    data['service_key'], data['service_id'])
                data['need_share'] = True
                data['category'] = service.category
                data['language'] = service.language
                data['extend_method'] = service.extend_method
                data['version'] = service.version
                data['memory'] = service.min_memory - service.min_memory % 32
                data['service_type'] = service.service_type
                data['service_source'] = service.service_source
                data['deploy_version'] = deploy_versions[data[
                    'service_id']] if deploy_versions else service.deploy_version
                data['image'] = service.image
                data['service_alias'] = service.service_alias
                data['service_name'] = service.service_name
                data['service_region'] = service.service_region
                data['creater'] = service.creater
                data["cmd"] = service.cmd
                data['probes'] = [
                    probe.to_dict()
                    for probe in probe_map.get(service.service_id, [])
                ]
                extend_method = extend_method_map.get(service.service_key)
                if extend_method:
                    e_m = dict()
                    e_m['min_node'] = service.min_node
                    e_m['max_node'] = extend_method.max_node
                    e_m['step_node'] = extend_method.step_node
                    e_m['min_memory'] = service.min_memory - service.min_memory % 32
                    e_m['max_memory'] = extend_method.max_memory
                    e_m['step_memory'] = extend_method.step_memory
                    e_m['is_restart'] = extend_method.is_restart
                    data['extend_method_map'] = e_m
                else:
                    data['extend_method_map'] = {
                        "min_node": service.min_node,
                        "max_node": 20,
                        "step_node": 1,
                        "min_memory": service.min_memory,
                        "max_memory": 65536,
                        "step_memory": 128,
                        "is_restart": 0
                    }
                data['port_map_list'] = list()
                if service_port_map.get(service.service_id):
                    for port in service_port_map.get(service.service_id):
                        p = dict()
                        # 写需要返回的port数据
                        p['protocol'] = port.protocol
                        p['tenant_id'] = port.tenant_id
                        p['port_alias'] = port.port_alias
                        p['container_port'] = port.container_port
                        p['is_inner_service'] = port.is_inner_service
                        p['is_outer_service'] = port.is_outer_service
                        data['port_map_list'].append(p)

                data['service_volume_map_list'] = list()
                if service_volume_map.get(service.service_id):
                    for volume in service_volume_map.get(service.service_id):
                        s_v = dict()
                        s_v['file_content'] = ''
                        if volume.volume_type == "config-file":
                            config_file = volume_repo.get_service_config_file(
                                volume.ID)
                            if config_file:
                                s_v['file_content'] = config_file.file_content
                        s_v['category'] = volume.category
                        s_v['volume_type'] = volume.volume_type
                        s_v['volume_path'] = volume.volume_path
                        s_v['volume_name'] = volume.volume_name
                        data['service_volume_map_list'].append(s_v)

                data['service_env_map_list'] = list()
                data['service_connect_info_map_list'] = list()
                if service_env_map.get(service.service_id):
                    for env_change in service_env_map.get(service.service_id):
                        if env_change.container_port == 0:
                            e_c = dict()
                            e_c['name'] = env_change.name
                            e_c['attr_name'] = env_change.attr_name
                            e_c['attr_value'] = env_change.attr_value
                            e_c['is_change'] = env_change.is_change
                            if env_change.scope == "outer":
                                e_c['container_port'] = env_change.container_port
                                data['service_connect_info_map_list'].append(
                                    e_c)
                            else:
                                data['service_env_map_list'].append(e_c)

                data['service_related_plugin_config'] = list()
                # plugins_attr_list = share_repo.get_plugin_config_var_by_service_ids(service_ids=service_ids)
                plugins_relation_list = share_repo.get_plugins_relation_by_service_ids(
                    service_ids=[service.service_id])
                for spr in plugins_relation_list:
                    service_plugin_config_var = service_plugin_config_repo.get_service_plugin_config_var(
                        spr.service_id, spr.plugin_id, spr.build_version)
                    plugin_data = spr.to_dict()
                    plugin_data["attr"] = [
                        var.to_dict() for var in service_plugin_config_var
                    ]
                    data['service_related_plugin_config'].append(plugin_data)

                all_data_map[service.service_id] = data

            all_data = list()
            for service_id in all_data_map:
                service = all_data_map[service_id]
                service['dep_service_map_list'] = list()
                if dep_service_map.get(service['service_id']):
                    for dep in dep_service_map.get(service['service_id']):
                        d = dict()
                        if all_data_map.get(dep.service_id):
                            # 通过service_key和service_id来判断依赖关系
                            d['dep_service_key'] = all_data_map[
                                dep.service_id]["service_share_uuid"]
                            service['dep_service_map_list'].append(d)

                service["mnt_relation_list"] = list()

                if dep_mnt_map.get(service_id):
                    for dep_mnt in dep_mnt_map.get(service_id):
                        if not all_data_map.get(dep_mnt.dep_service_id):
                            continue
                        service["mnt_relation_list"].append({
                            "service_share_uuid":
                            all_data_map[dep_mnt.dep_service_id]
                            ["service_share_uuid"],
                            "mnt_name":
                            dep_mnt.mnt_name,
                            "mnt_dir":
                            dep_mnt.mnt_dir
                        })
                all_data.append(service)
            return all_data
        else:
            return []
    def query_share_service_info(self, team, group_id):
        service_list = share_repo.get_service_list_by_group_id(
            team=team, group_id=group_id)
        if service_list:
            array_ids = [x.service_id for x in service_list]
            array_keys = []
            for x in service_list:
                if x.service_key == "application" or x.service_key == "0000" or x.service_key == "":
                    array_keys.append(x.service_key)
            # 查询服务端口信息
            service_port_map = self.get_service_ports_by_ids(array_ids)
            # 查询服务依赖
            dep_service_map = self.get_service_dependencys_by_ids(array_ids)
            # 查询服务可变参数和不可变参数
            # service_env_change_map, service_env_nochange_map = self.get_service_env_by_ids(array_ids)
            service_env_map = self.get_service_env_by_ids(array_ids)
            # 查询服务持久化信息
            service_volume_map = self.get_service_volume_by_ids(array_ids)
            # 查询服务伸缩方式信息
            extend_method_map = self.get_service_extend_method_by_keys(
                array_keys)
            # 获取应用的健康检测设置
            probe_map = self.get_service_probes(array_ids)

            all_data_map = {}
            for service in service_list:
                data = dict()
                data['service_id'] = service.service_id
                data['tenant_id'] = service.tenant_id
                data['service_cname'] = service.service_cname
                data['service_key'] = service.service_key
                if service.service_source != AppConstants.MARKET:
                    data['service_key'] = make_uuid()
                #     data['need_share'] = True
                # else:
                #     data['need_share'] = False
                data['need_share'] = True
                data['category'] = service.category
                data['language'] = service.language
                data['extend_method'] = service.extend_method
                data['version'] = service.version
                data['memory'] = service.min_memory
                data['service_type'] = service.service_type
                data['service_source'] = service.service_source
                data['deploy_version'] = service.deploy_version
                data['image'] = service.image
                data['service_alias'] = service.service_alias
                data['service_region'] = service.service_region
                data['creater'] = service.creater
                data["cmd"] = service.cmd
                data['probes'] = [
                    probe.to_dict()
                    for probe in probe_map.get(service.service_id, [])
                ]
                extend_method = extend_method_map.get(service.service_key)
                if extend_method:
                    e_m = dict()
                    e_m['min_node'] = extend_method.min_node
                    e_m['max_node'] = extend_method.max_node
                    e_m['step_node'] = extend_method.step_node
                    e_m['min_memory'] = extend_method.min_memory
                    e_m['max_memory'] = extend_method.max_memory
                    e_m['step_memory'] = extend_method.step_memory
                    e_m['is_restart'] = extend_method.is_restart
                    data['extend_method_map'] = e_m
                else:
                    data['extend_method_map'] = {
                        "min_node": 1,
                        "max_node": 20,
                        "step_node": 1,
                        "min_memory": 128,
                        "max_memory": 65536,
                        "step_memory": 128,
                        "is_restart": 0
                    }
                data['port_map_list'] = list()
                if service_port_map.get(service.service_id):
                    for port in service_port_map.get(service.service_id):
                        p = dict()
                        # 写需要返回的port数据
                        p['protocol'] = port.protocol
                        p['tenant_id'] = port.tenant_id
                        p['port_alias'] = port.port_alias
                        p['container_port'] = port.container_port
                        p['is_inner_service'] = port.is_inner_service
                        p['is_outer_service'] = port.is_outer_service
                        data['port_map_list'].append(p)

                data['service_volume_map_list'] = list()
                if service_volume_map.get(service.service_id):
                    for volume in service_volume_map.get(service.service_id):
                        s_v = dict()
                        s_v['category'] = volume.category
                        s_v['volume_type'] = volume.volume_type
                        s_v['volume_path'] = volume.volume_path
                        s_v['volume_name'] = volume.volume_name
                        data['service_volume_map_list'].append(s_v)

                data['service_env_map_list'] = list()
                data['service_connect_info_map_list'] = list()
                if service_env_map.get(service.service_id):
                    for env_change in service_env_map.get(service.service_id):
                        if env_change.container_port == 0:
                            e_c = dict()
                            e_c['name'] = env_change.name
                            e_c['attr_name'] = env_change.attr_name
                            e_c['attr_value'] = env_change.attr_value
                            e_c['is_change'] = env_change.is_change
                            if env_change.scope == "outer":
                                e_c['container_port'] = env_change.container_port
                                data['service_connect_info_map_list'].append(
                                    e_c)
                            else:
                                data['service_env_map_list'].append(e_c)
                service_ids = [x.service_id for x in service_list]
                plugins_attr_list = share_repo.get_plugins_attr_by_service_ids(
                    service_ids=service_ids)
                plugins_relation_list = share_repo.get_plugins_relation_by_service_ids(
                    service_ids=service_ids)
                data['plugin_map_list'] = list()
                for p_relation in plugins_relation_list:
                    plugin_data = dict()
                    if service.service_id == p_relation.service_id:
                        plugin_data['plugin_id'] = p_relation.plugin_id
                        plugin_data['build_version'] = p_relation.build_version
                        plugin_data[
                            'service_meta_type'] = p_relation.service_meta_type
                        plugin_data['plugin_status'] = p_relation.plugin_status
                        plugin_data['create_time'] = p_relation.create_time
                        plugin_data["attr"] = list()
                        for p_attr in plugins_attr_list:
                            if p_relation.service_id == p_attr.service_id:
                                attr_data = {}
                                attr_data[
                                    'dest_service_id'] = p_attr.dest_service_id
                                attr_data[
                                    'dest_service_alias'] = p_attr.dest_service_alias
                                attr_data[
                                    'container_port'] = p_attr.container_port
                                attr_data['attr_name'] = p_attr.attr_name
                                attr_data['attr_value'] = p_attr.attr_value
                                attr_data[
                                    'attr_alt_value'] = p_attr.attr_alt_value
                                attr_data['attr_type'] = p_attr.attr_type
                                attr_data[
                                    'attr_default_value'] = p_attr.attr_default_value
                                attr_data['protocol'] = p_attr.protocol
                                attr_data['attr_info'] = p_attr.attr_info
                                plugin_data["attr"].append(attr_data)
                    data['plugin_map_list'].append(plugin_data)
                all_data_map[service.service_id] = data

            all_data = list()
            for service_id in all_data_map:
                service = all_data_map[service_id]
                service['dep_service_map_list'] = list()
                if dep_service_map.get(service['service_id']):
                    for dep in dep_service_map.get(service['service_id']):
                        d = dict()
                        if all_data_map.get(dep.service_id):
                            d['dep_service_key'] = all_data_map[
                                dep.service_id]['service_key']
                            service['dep_service_map_list'].append(d)
                all_data.append(service)
            return all_data
        else:
            return []