def check_custom_rule(self, eid):
"""
check if there is a custom gateway rule
"""
conn = BaseConnection()
sql = """
SELECT
*
FROM
service_domain a,
tenant_info b
WHERE
a.tenant_id = b.tenant_id
AND b.enterprise_id = "{eid}"
AND (
a.certificate_id <> 0
OR ( a.domain_path <> "/" AND a.domain_path <> "" )
OR a.domain_cookie <> ""
OR a.domain_heander <> ""
OR a.the_weight <> 100
OR a.domain_name NOT LIKE concat('%',b.tenant_name,'%')
)
LIMIT 1""".format(eid=eid)
result = conn.query(sql)
return True if len(result) > 0 else False
def get_no_group_services_list(self, team_id, region_name):
dsn = BaseConnection()
query_sql = '''
SELECT
t.service_id,
t.service_alias,
t.service_cname,
t.service_type,
t.create_status,
t.deploy_version,
t.version,
t.update_time,
t.min_memory * t.min_node AS min_memory,
g.group_name
FROM
tenant_service t
LEFT JOIN service_group_relation r ON t.service_id = r.service_id
LEFT JOIN service_group g ON r.group_id = g.ID
WHERE
t.tenant_id = "{team_id}"
AND t.service_region = "{region_name}"
AND r.group_id IS NULL
ORDER BY
t.update_time DESC;
'''.format(team_id=team_id, region_name=region_name)
services = dsn.query(query_sql)
return services
def get_fuzzy_services_list(self, team_id, region_name, query_key, fields, order):
if fields != "update_time" and fields != "ID":
fields = "ID"
if order != "desc" and order != "asc":
order = "desc"
dsn = BaseConnection()
query_sql = '''
SELECT
t.create_status,
t.service_id,
t.service_cname,
t.min_memory * t.min_node AS min_memory,
t.service_alias,
t.service_type,
t.deploy_version,
t.version,
t.update_time,
r.group_id,
g.group_name
FROM
tenant_service t
LEFT JOIN service_group_relation r ON t.service_id = r.service_id
LEFT JOIN service_group g ON r.group_id = g.ID
WHERE
t.tenant_id = "{team_id}"
AND t.service_region = "{region_name}"
AND t.service_cname LIKE "%{query_key}%"
ORDER BY
t.{fields} {order};
'''.format(
team_id=team_id, region_name=region_name, query_key=query_key, fields=fields, order=order)
services = dsn.query(query_sql)
return services
def check_custom_rule(self, eid):
"""
check if there is a custom gateway rule
"""
conn = BaseConnection()
team_name_query = "'%' || b.tenant_name || '%'"
if os.environ.get('DB_TYPE') == 'mysql':
team_name_query = "concat('%',b.tenant_name,'%')"
sql = """
SELECT
*
FROM
service_domain a,
tenant_info b
WHERE
a.tenant_id = b.tenant_id
AND b.enterprise_id = "{eid}"
AND (
a.certificate_id <> 0
OR ( a.domain_path <> "/" AND a.domain_path <> "" )
OR a.domain_cookie <> ""
OR a.domain_heander <> ""
OR a.the_weight <> 100
OR a.domain_name NOT LIKE {team_name}
)
LIMIT 1""".format(eid=eid, team_name=team_name_query)
result = conn.query(sql)
return True if len(result) > 0 else False
def get_team_current_region_service_events(self, region, team, page, page_size):
dsn = BaseConnection()
start = (int(page) - 1) * int(page_size)
end = page_size
query_sql = """
select e.start_time, e.event_id, s.service_alias, s.service_cname
from service_event e
JOIN tenant_service s on e.service_id = s.service_id
WHERE e.tenant_id = "{team_id}"
and s.service_region = "{region_name}"
ORDER BY start_time DESC
LIMIT {start},{end}
""".format(
team_id=team.tenant_id, region_name=region, start=start, end=end)
events = dsn.query(query_sql)
events_ids = []
event_id_service_info_map = dict()
for e in events:
events_ids.append(e.event_id)
event_id_service_info_map[e.event_id] = {"service_alias": e.service_alias, "service_cname": e.service_cname}
events = ServiceEvent.objects.filter(event_id__in=events_ids).order_by("-ID")
try:
self.__sync_region_service_event_status(region, team.tenant_name, events, False)
except Exception as e:
logger.exception("synchorized services events error !", e)
for event in events:
bean = event_id_service_info_map.get(event.event_id, None)
if bean:
event.service_alias = bean["service_alias"]
event.service_cname = bean["service_cname"]
return events
def get_rainbond_app_versions_by_id(self, eid, app_id):
where = 'WHERE (C.enterprise_id="{eid}") AND C.app_id="{app_id}"'.format(
eid=eid, app_id=app_id)
sql = """
SELECT
C.*
FROM (SELECT A.enterprise_id, A.app_id, A.version, MAX(A.update_time) update_time
FROM rainbond_center_app_version A GROUP BY A.enterprise_id, A.app_id, A.version) B
LEFT JOIN rainbond_center_app_version C
ON C.enterprise_id=B.enterprise_id AND C.app_id=B.app_id AND
C.version=B.version AND C.update_time=B.update_time
"""
sql += where
# Sort in reverse order of version number
if os.environ.get('DB_TYPE') == 'mysql':
sql = """
SELECT V.*
FROM ({0}) AS V
ORDER BY
REPLACE(SUBSTRING(SUBSTRING_INDEX(version, '.', 1),
LENGTH(SUBSTRING_INDEX(V.version, '.', 1 - 1)) + 1), '.', '') + 0 desc,
REPLACE(SUBSTRING(SUBSTRING_INDEX(version, '.', 2),
LENGTH(SUBSTRING_INDEX(V.version, '.', 2 - 1)) + 1), '.', '') + 0 desc,
REPLACE(SUBSTRING(SUBSTRING_INDEX(version, '.', 3),
LENGTH(SUBSTRING_INDEX(V.version, '.', 3 - 1)) + 1), '.', '') + 0 desc;
""".format(sql)
else:
sql = """
SELECT V.*
FROM ({0}) AS V
ORDER BY V.update_time
""".format(sql)
conn = BaseConnection()
result = conn.query(sql)
return result
def get_services_list(self, team_id, region_name):
dsn = BaseConnection()
query_sql = '''
SELECT
t.service_id,
t.service_alias,
t.service_cname,
t.service_type,
t.deploy_version,
t.version,
t.update_time,
r.group_id,
g.group_name,
h.tenant_name,
i.region_id
FROM
tenant_service t
LEFT JOIN service_group_relation r ON t.service_id = r.service_id
LEFT JOIN service_group g ON r.group_id = g.ID
LEFT JOIN tenant_info h ON t.tenant_id = h.tenant_id
LEFT JOIN region_info i ON t.service_region = i.region_name
WHERE
t.tenant_id = "{team_id}"
AND t.service_region = "{region_name}"
ORDER BY
t.update_time DESC;
'''.format(team_id=team_id, region_name=region_name)
services = dsn.query(query_sql)
return services
def get_rainbond_app_in_enterprise_by_query(self,
eid,
app_name,
tag_names=None,
page=1,
page_size=10):
sql = self._prepare_get_rainbond_app_by_query_sql(
eid, "enterprise", app_name, None, tag_names, page, page_size)
conn = BaseConnection()
apps = conn.query(sql)
return apps
def get_rainbond_app_in_teams_by_querey(self,
eid,
teams,
app_name,
tag_names=None,
page=1,
page_size=10):
sql = self._prepare_get_rainbond_app_by_query_sql(
eid, "team", app_name, teams, tag_names, page, page_size)
conn = BaseConnection()
apps = conn.query(sql)
return apps
def count_by_tenant_id(self, tenant_id):
sql = """
SELECT
count( * ) as total
FROM
region_info a
LEFT JOIN tenant_region b ON a.region_name = b.region_name
WHERE
b.tenant_id = "{tenant_id}"
""".format(tenant_id=tenant_id)
conn = BaseConnection()
result = conn.query(sql)
return result[0]["total"]
def get_rainbond_app_total_count(self,
eid,
scope,
teams,
app_name,
tag_names,
need_install="false"):
extend_where = ""
join_version = ""
if tag_names:
extend_where += " and tag.name in ({0})".format(",".join(
"'{0}'".format(tag_name) for tag_name in tag_names))
if app_name:
extend_where += " and app.app_name like '%{0}%'".format(app_name)
if need_install == "true":
join_version += " left join rainbond_center_app_version apv on app.app_id = apv.app_id" \
" and app.enterprise_id = apv.enterprise_id"
extend_where += " and apv.`version` <> '' and apv.is_complete"
# if teams is None, create_team scope is ('')
if scope == "team":
team_sql = ""
if teams:
team_sql = " and app.create_team in({0})".format(",".join(
"'{0}'".format(team) for team in teams))
team_sql += " and app.scope='" + scope + "'"
extend_where += team_sql
if scope == "enterprise":
extend_where += " and app.scope='" + scope + "'"
sql = """
select
count(distinct app.app_id) as total
from
rainbond_center_app app
left join (
select
app_id,
tag.name
from
rainbond_center_app_tag_relation rcatr
join rainbond_center_app_tag tag on
rcatr.tag_id = tag.iD) tag on app.app_id = tag.app_id
{join_version}
where
app.enterprise_id = '{eid}'
{extend_where}
""".format(eid=eid,
extend_where=extend_where,
join_version=join_version)
conn = BaseConnection()
count = conn.query(sql)
return count
def get_last_app_versions_by_app_id(self, app_id):
conn = BaseConnection()
sql = """
SELECT B.version, B.version_alias, B.app_version_info as `describe`
FROM (SELECT app_id, version, max(upgrade_time) as upgrade_time
FROM rainbond_center_app_version
WHERE is_complete=1
GROUP BY app_id, version) A
LEFT JOIN rainbond_center_app_version B
ON A.app_id=B.app_id AND A.version=B.version AND A.upgrade_time=B.upgrade_time
WHERE A.app_id = "{app_id}"
""".format(app_id=app_id)
result = conn.query(sql)
return result
def get_rainbond_app_in_enterprise_by_query(self,
eid,
scope,
app_name,
tag_names=None,
page=1,
page_size=10,
need_install="false"):
sql = self._prepare_get_rainbond_app_by_query_sql(
eid, scope, app_name, None, tag_names, page, page_size,
need_install)
conn = BaseConnection()
apps = conn.query(sql)
return apps
def get_enterprise_group_services(self, enterprise_id):
where = 'WHERE group_id IN (SELECT ID FROM service_group WHERE tenant_id IN (SELECT tenant_id FROM ' \
'tenant_info WHERE enterprise_id="{enterprise_id}")) '.format(enterprise_id=enterprise_id)
group_by = "GROUP BY group_id"
sql = """
SELECT
group_id,
CONCAT('[', GROUP_CONCAT(CONCAT('"', service_id, '"')), ']') as service_ids
FROM service_group_relation
"""
sql += where
sql += group_by
conn = BaseConnection()
result = conn.query(sql)
return result
def get_plugins_by_service_ids(self, service_ids):
if not service_ids:
return []
ids = ""
for sid in service_ids:
ids += "\"{0}\",".format(sid)
if len(ids) > 1:
ids = ids[:-1]
dsn = BaseConnection()
query_sql = '''
select t.*,p.build_version from tenant_plugin t,plugin_build_version p,tenant_service_plugin_relation r \
where r.service_id in({service_ids}) and t.plugin_id=r.plugin_id and p.build_version=r.build_version
'''.format(service_ids=ids)
plugins = dsn.query(query_sql)
return plugins
def check_non_default_group_by_eid(self, eid):
conn = BaseConnection()
sql = """
SELECT
group_name
FROM
service_group a,
tenant_info b
WHERE
a.tenant_id = b.tenant_id
AND a.is_default = 0
AND b.enterprise_id = "{eid}"
LIMIT 1;
""".format(eid=eid)
result = conn.query(sql)
return True if len(result) > 0 else False
def check_db_dep_by_eid(self, eid):
"""
check if there is a database installed from the market that is dependent on
"""
conn = BaseConnection()
sql = """
SELECT
a.service_id, a.dep_service_id
FROM
tenant_service_relation a,
tenant_service b,
tenant_info c,
tenant_service d
WHERE
b.tenant_id = c.tenant_id
AND c.enterprise_id = "{eid}"
AND a.service_id = d.service_id
AND a.dep_service_id = b.service_id
AND ( b.image LIKE "%mysql%" OR b.image LIKE "%postgres%" OR b.image LIKE "%mariadb%" )
AND (b.service_source <> "market" OR d.service_source <> "market")
limit 1""".format(eid=eid)
result = conn.query(sql)
if len(result) > 0:
return True
sql2 = """
SELECT
a.dep_service_id
FROM
tenant_service_relation a,
tenant_service b,
tenant_info c,
tenant_service d,
service_source e,
service_source f
WHERE
b.tenant_id = c.tenant_id
AND c.enterprise_id = "{eid}"
AND a.service_id = d.service_id
AND a.dep_service_id = b.service_id
AND ( b.image LIKE "%mysql%" OR b.image LIKE "%postgres%" OR b.image LIKE "%mariadb%" )
AND ( b.service_source = "market" AND d.service_source = "market" )
AND e.service_id = b.service_id
AND f.service_id = d.service_id
AND e.group_key <> f.group_key
LIMIT 1""".format(eid=eid)
result2 = conn.query(sql2)
return True if len(result2) > 0 else False
def check_app_by_eid(self, eid):
"""
check if an app has been shared
"""
conn = BaseConnection()
sql = """
SELECT
a.team_name
FROM
service_share_record a,
tenant_info b
WHERE
a.team_name = b.tenant_name
AND b.enterprise_id = "{eid}"
LIMIT 1""".format(eid=eid)
result = conn.query(sql)
return True if len(result) > 0 else False
def get_rainbond_app_version_by_app_id(self, eid, app_id, version):
where = """
WHERE (BB.enterprise_id="{eid}" OR BB.enterprise_id="public") AND
BB.app_id="{app_id}" AND C.version="{version}";
""".format(eid=eid, app_id=app_id, version=version)
sql = """
SELECT
BB.ID,
BB.app_id,
BB.app_name,
BB.create_user,
BB.create_team,
BB.pic,
BB.dev_status,
BB.describe,
BB.details,
BB.enterprise_id,
BB.create_time,
BB.update_time,
BB.is_ingerit,
BB.is_official,
BB.install_number,
BB.source,
BB.scope,
C.app_template,
C.version,
C.is_complete,
C.version_alias,
C.update_time,
C.create_time
FROM (SELECT A.enterprise_id, A.app_id, A.version, MAX(A.update_time) update_time
FROM rainbond_center_app_version A GROUP BY A.enterprise_id, A.app_id, A.version) B
LEFT JOIN rainbond_center_app_version C
ON C.enterprise_id=B.enterprise_id AND C.app_id=B.app_id AND
C.version=B.version AND C.update_time=B.update_time
RIGHT JOIN (SELECT * FROM rainbond_center_app RCA GROUP BY RCA.enterprise_id, RCA.app_id) BB
ON C.enterprise_id=BB.enterprise_id AND C.app_id=BB.app_id
"""
sql += where
conn = BaseConnection()
result = conn.query(sql)
return result
def check_plugins_by_eid(self, eid):
"""
check if an app has been shared
"""
conn = BaseConnection()
sql = """
SELECT
a.plugin_id
FROM
tenant_service_plugin_relation a,
tenant_service c,
tenant_info b
WHERE
c.tenant_id = b.tenant_id
AND a.service_id = c.service_id
AND c.service_source <> "market"
AND b.enterprise_id = "{eid}"
LIMIT 1""".format(eid=eid)
result = conn.query(sql)
return True if len(result) > 0 else False
def get_service_mnts_filter_volume_type(self,
tenant_id,
service_id,
volume_types=None):
conn = BaseConnection()
query = "mnt.tenant_id = '%s' and mnt.service_id = '%s'" % (tenant_id,
service_id)
if volume_types:
vol_type_sql = " and volume.volume_type in ({})".format(','.join(
["'%s'"] * len(volume_types)))
query += vol_type_sql % tuple(volume_types)
sql = """
select mnt.mnt_name,
mnt.mnt_dir,
mnt.dep_service_id,
mnt.service_id,
mnt.tenant_id,
volume.volume_type,
volume.ID as volume_id
from tenant_service_mnt_relation as mnt
inner join tenant_service_volume as volume
on mnt.dep_service_id = volume.service_id and mnt.mnt_name = volume.volume_name
where {};
""".format(query)
result = conn.query(sql)
dep_mnts = []
for real_dep_mnt in result:
mnt = TenantServiceMountRelation(
tenant_id=real_dep_mnt.get("tenant_id"),
service_id=real_dep_mnt.get("service_id"),
dep_service_id=real_dep_mnt.get("dep_service_id"),
mnt_name=real_dep_mnt.get("mnt_name"),
mnt_dir=real_dep_mnt.get("mnt_dir"))
mnt.volume_type = real_dep_mnt.get("volume_type")
mnt.volume_id = real_dep_mnt.get("volume_id")
dep_mnts.append(mnt)
return dep_mnts
def get_rainbond_app_total_count(self, eid, scope, teams, app_name,
tag_names):
extend_where = ""
if tag_names:
extend_where += " and tag.name in ({0})".format(",".join(
"'{0}'".format(tag_name) for tag_name in tag_names))
if app_name:
extend_where += " and app.app_name like '%{0}%'".format(app_name)
# if teams is None, create_team scope is ('')
if scope == "team":
team_sql = ""
if teams:
team_sql = " and app.create_team in({0})".format(",".join(
"'{0}'".format(team) for team in teams))
team_sql += " and scope='" + scope + "'"
extend_where += team_sql
if scope == "enterprise":
extend_where += " and scope='" + scope + "'"
sql = """
select
count(distinct app.app_id) as total
from
rainbond_center_app app
left join (
select
app_id,
tag.name
from
rainbond_center_app_tag_relation rcatr
join rainbond_center_app_tag tag on
rcatr.tag_id = tag.iD) tag on app.app_id = tag.app_id
where
app.enterprise_id = '{eid}'
{extend_where}
""".format(eid=eid, extend_where=extend_where)
conn = BaseConnection()
count = conn.query(sql)
return count
class PluginService(object):
dsn = BaseConnection()
def get_newest_plugin_version_info(self, region, tenant):
"""
获取所有插件的最新构建信息
:param region :数据中心信息
:param tenant: 租户信息
:return: 插件信息
"""
result = []
query_sql = """SELECT * from plugin_build_version WHERE
id in (
SELECT max(id) from plugin_build_version WHERE
tenant_id="{0}" and region="{1}" GROUP BY plugin_id
) and
plugin_build_version.tenant_id="{2}";""".format(tenant.tenant_id, region, tenant.tenant_id)
data = self.dsn.query(query_sql)
for d in data:
plugin = TenantPlugin.objects.get(plugin_id=d.plugin_id)
record_map = {}
record_map["plugin_alias"] = plugin.plugin_alias
record_map["plugin_name"] = plugin.plugin_name
record_map["category"] = CATEGORY_MAP.get(plugin.category)
record_map["build_version"] = d.build_version
record_map["build_status"] = d.build_status
record_map["plugin_id"] = plugin.plugin_id
record_map["desc"] = plugin.desc
result.append(record_map)
return result
def get_tenant_plugins(self, region, tenant):
"""
获取租户下的所有插件
:param region: 数据中心
:param tenant: 租户信息
:return: 插件信息
"""
plugins = TenantPlugin.objects.filter(region=region, tenant_id=tenant.tenant_id)
return plugins
def get_tenant_plugin_by_plugin_id(self, tenant, plugin_id):
"""
根据租户和插件id查询插件元信息
:param tenant: 租户信息
:param plugin_id: 插件ID列表
:return: 插件信息
"""
tenant_plugins = TenantPlugin.objects.filter(tenant_id=tenant.tenant_id, plugin_id=plugin_id)
if tenant_plugins:
return tenant_plugins[0]
else:
return {}
def get_tenant_plugin_by_origin_key(self, region, tenant, origin_share_id):
"""
根据origin key 获取plugin
@param tenant:
@param origin_key:
@return:
"""
tenant_plugins = TenantPlugin.objects.filter(region=region, tenant_id=tenant.tenant_id, origin_share_id=origin_share_id)
if tenant_plugins:
return tenant_plugins[0]
else:
return {}
def get_tenant_plugin_versions(self, region, tenant, plugin_id):
"""
获取指定租户的指定插件的所有版本信息
:param region: 数据中心
:param tenant: 租户
:param plugin_id: 插件id
:return: 指定插件的所有版本信息
"""
plugin_build_version = PluginBuildVersion.objects.filter(
region=region, tenant_id=tenant.tenant_id, plugin_id=plugin_id).order_by("-ID")
return plugin_build_version
def get_tenant_plugin_newest_versions(self, region_name, tenant, plugin_id):
"""
获取指定租户的指定插件的最新版本信息
:param tenant: 租户
:param plugin_id: 插件id
:return: 指定插件的所有版本信息
"""
plugin_build_version = PluginBuildVersion.objects.filter(
region=region_name, tenant_id=tenant.tenant_id, plugin_id=plugin_id, build_status="build_success").order_by("-ID")
return plugin_build_version
def get_tenant_service_plugin_relation(self, service_id):
"""
获取当前组件关联的插件
@param service_id: 租户id
@return: 获取当前组件关联的插件
"""
return TenantServicePluginRelation.objects.filter(service_id=service_id)
def get_tenant_service_plugin_relation_by_plugin(self, service_id, plugin_id):
"""
获取当前组件关联的插件
@param service_id: 租户id
@return: 获取当前组件关联的插件
"""
return TenantServicePluginRelation.objects.filter(service_id=service_id, plugin_id=plugin_id)
def add_service_plugin_relation(self, service_id, plugin_id, build_version):
"""
添加组件与插件的绑定关系
@param service_id: 组件id
@param plugin_id: 插件id
@param build_version: 插件构建版本
@return:
"""
return TenantServicePluginRelation.objects.create(
service_id=service_id, build_version=build_version, plugin_id=plugin_id)
def del_service_plugin_relation_and_attrs(self, service_id, plugin_id):
# delete service plugin attrs
TenantServicePluginAttr.objects.filter(service_id=service_id, plugin_id=plugin_id).delete()
# delete service plugin relation
TenantServicePluginRelation.objects.filter(service_id=service_id, plugin_id=plugin_id).delete()
return
def del_service_plugin_attrs(self, service_id, plugin_id):
# delete service plugin attrs
TenantServicePluginAttr.objects.filter(service_id=service_id, plugin_id=plugin_id).delete()
return
def update_service_plugin_relation(self, service_id, plugin_id, build_version, switch):
oldRelation = TenantServicePluginRelation.objects.get(service_id=service_id, plugin_id=plugin_id)
oldRelation.build_version = build_version
oldRelation.plugin_status = switch
oldRelation.save()
# delete old service plugin attrs
TenantServicePluginAttr.objects.filter(service_id=service_id, plugin_id=plugin_id).delete()
return
def get_service_meta_type(self, plugin_id, build_version):
return PluginConfigGroup.objects.filter(plugin_id=plugin_id, build_version=build_version)
def getPluginMetaType(self, plugin_id, build_version):
return PluginBuildVersion.objects.get(plugin_id=plugin_id, build_version=build_version)
def get_env_attr_by_service_meta_type(self, plugin_id, build_version, service_meta_type):
return PluginConfigItems.objects.filter(
plugin_id=plugin_id, build_version=build_version, service_meta_type=service_meta_type)
def InsertSqlInDownStreamMeta(self, downStreamList, plugin_id, service_id):
store_list = []
for stream in downStreamList:
for cf in stream.get("config"):
tspa = TenantServicePluginAttr(
service_id=stream.get("service_id"),
service_alias=stream.get("service_alias"),
dest_service_id=stream.get("dest_service_id"),
dest_service_alias=stream.get("dest_service_alias"),
plugin_id=plugin_id,
service_meta_type=stream.get("service_meta_type"),
injection=stream.get("injection"),
container_port=stream.get("port"),
attr_name=cf.get("attr_name"),
attr_value=cf.get("attr_default_value", " "),
attr_type=cf.get("attr_type"),
attr_default_value=cf.get("attr_default_value"),
attr_alt_value=cf.get("attr_alt_value"),
protocol=stream.get("protocol"),
attr_info=cf.get("attr_info"),
is_change=cf.get("is_change"))
store_list.append(tspa)
TenantServicePluginAttr.objects.filter(
service_id=service_id, plugin_id=plugin_id, service_meta_type=ConstKey.DOWNSTREAM_PORT).delete()
TenantServicePluginAttr.objects.bulk_create(store_list)
def UpdateSqlInDownStreamMeta(self, downStreamList, plugin_id, service_id):
store_list = []
for stream in downStreamList:
for cf in stream.get("config"):
tspa = TenantServicePluginAttr(
service_id=stream.get("service_id"),
service_alias=stream.get("service_alias"),
dest_service_id=stream.get("dest_service_id"),
dest_service_alias=stream.get("dest_service_alias"),
plugin_id=plugin_id,
service_meta_type=stream.get("service_meta_type"),
injection=stream.get("injection"),
container_port=stream.get("port"),
attr_name=cf.get("attr_name"),
attr_value=cf.get("attr_value", " "),
attr_type=cf.get("attr_type"),
attr_default_value=cf.get("attr_default_value"),
attr_alt_value=cf.get("attr_alt_value"),
protocol=stream.get("protocol"),
attr_info=cf.get("attr_info"),
is_change=cf.get("is_change"))
store_list.append(tspa)
TenantServicePluginAttr.objects.bulk_create(store_list)
def InsertSqlInUpStreamMeta(self, upStreamList, plugin_id, service_id):
store_list = []
for stream in upStreamList:
for cf in stream.get("config"):
tspa = TenantServicePluginAttr(
service_id=stream.get("service_id"),
service_alias=stream.get("service_alias"),
plugin_id=plugin_id,
service_meta_type=stream.get("service_meta_type"),
injection=stream.get("injection"),
container_port=stream.get("port"),
attr_name=cf.get("attr_name"),
attr_value=cf.get("attr_default_value", " "),
attr_type=cf.get("attr_type"),
attr_default_value=cf.get("attr_default_value"),
attr_alt_value=cf.get("attr_alt_value"),
protocol=stream.get("protocol"),
attr_info=cf.get("attr_info"),
is_change=cf.get("is_change"))
store_list.append(tspa)
TenantServicePluginAttr.objects.filter(
service_id=service_id, plugin_id=plugin_id, service_meta_type=ConstKey.UPSTREAM_PORT).delete()
TenantServicePluginAttr.objects.bulk_create(store_list)
def UpdateSqlInUpStreamMeta(self, upStreamList, plugin_id, service_id):
store_list = []
for stream in upStreamList:
for cf in stream.get("config"):
tspa = TenantServicePluginAttr(
service_id=stream.get("service_id"),
service_alias=stream.get("service_alias"),
plugin_id=plugin_id,
service_meta_type=stream.get("service_meta_type"),
injection=stream.get("injection"),
container_port=stream.get("port"),
attr_name=cf.get("attr_name"),
attr_value=cf.get("attr_value", " "),
attr_type=cf.get("attr_type"),
attr_default_value=cf.get("attr_default_value"),
attr_alt_value=cf.get("attr_alt_value"),
protocol=stream.get("protocol"),
attr_info=cf.get("attr_info"),
is_change=cf.get("is_change"))
store_list.append(tspa)
TenantServicePluginAttr.objects.bulk_create(store_list)
def InsertSqlInENVMeta(self, envList, plugin_id, service_id):
store_list = []
for stream in envList:
for cf in stream.get("config"):
tspa = TenantServicePluginAttr(
service_id=stream.get("service_id"),
service_alias=stream.get("service_alias"),
plugin_id=plugin_id,
service_meta_type=stream.get("service_meta_type"),
container_port=0,
injection=stream.get("injection"),
attr_name=cf.get("attr_name"),
attr_value=cf.get("attr_default_value", " "),
attr_type=cf.get("attr_type"),
attr_default_value=cf.get("attr_default_value"),
attr_alt_value=cf.get("attr_alt_value"),
attr_info=cf.get("attr_info"),
is_change=cf.get("is_change"))
store_list.append(tspa)
TenantServicePluginAttr.objects.filter(
service_id=service_id, plugin_id=plugin_id, service_meta_type=ConstKey.UNDEFINE).delete()
TenantServicePluginAttr.objects.bulk_create(store_list)
def UpdateSqlInENVMeta(self, envList, plugin_id, service_id):
store_list = []
for stream in envList:
for cf in stream.get("config"):
tspa = TenantServicePluginAttr(
service_id=stream.get("service_id"),
service_alias=stream.get("service_alias"),
plugin_id=plugin_id,
service_meta_type=stream.get("service_meta_type"),
container_port=0,
injection=stream.get("injection"),
attr_name=cf.get("attr_name"),
attr_value=cf.get("attr_value", " "),
attr_type=cf.get("attr_type"),
attr_default_value=cf.get("attr_default_value"),
attr_alt_value=cf.get("attr_alt_value"),
attr_info=cf.get("attr_info"),
is_change=cf.get("is_change"))
store_list.append(tspa)
TenantServicePluginAttr.objects.bulk_create(store_list)
def getServicePluginAttrByAttrName(self, service_id, plugin_id, metaType, pubDict, configList):
if metaType == ConstKey.DOWNSTREAM_PORT:
attrList = TenantServicePluginAttr.objects.filter(
service_id=service_id,
plugin_id=plugin_id,
service_meta_type=metaType,
dest_service_alias=pubDict.get("dest_service_alias"),
container_port=int(pubDict.get("port")),
injection=pubDict.get("injection"))
if len(attrList) == 0:
return configList
for config in configList:
for attr in attrList:
if attr.attr_name == config.get("attr_name"):
config["attr_value"] = attr.attr_value
elif metaType == ConstKey.UPSTREAM_PORT:
attrList = TenantServicePluginAttr.objects.filter(
service_id=service_id,
plugin_id=plugin_id,
service_meta_type=metaType,
container_port=int(pubDict.get("port")),
injection=pubDict.get("injection"))
if len(attrList) == 0:
return configList
for config in configList:
for attr in attrList:
if attr.attr_name == config.get("attr_name"):
config["attr_value"] = attr.attr_value
elif metaType == ConstKey.UNDEFINE:
attrList = TenantServicePluginAttr.objects.filter(
service_id=service_id, plugin_id=plugin_id, service_meta_type=metaType, injection=pubDict.get("injection"))
if len(attrList) == 0:
return configList
for config in configList:
for attr in attrList:
if attr.attr_name == config.get("attr_name"):
config["attr_value"] = attr.attr_value
return configList
def getMetaBaseInfo(self, tenant_id, service_id, service_alias, plugin_id, build_version, meta_info, configList, tag):
if meta_info.service_meta_type == ConstKey.DOWNSTREAM_PORT:
relations = TenantServiceRelation.objects.filter(tenant_id=tenant_id, service_id=service_id)
if len(relations) == 0:
logger.error("service {0} has no relation dest_service".format(service_id))
raise HasNoDownStreamService("has no dest_service")
downStreamList = []
for relation in relations:
dest_service_id = relation.dep_service_id
dest_service = TenantServiceInfo.objects.get(tenant_id=tenant_id, service_id=dest_service_id)
dest_service_alias = dest_service.service_alias
dest_service_cname = dest_service.service_cname
ports = TenantServicesPort.objects.filter(tenant_id=tenant_id, service_id=dest_service_id)
if len(ports) == 0:
continue
for port in ports:
destServiceDict = {}
destServiceDict["service_meta_type"] = ConstKey.DOWNSTREAM_PORT
destServiceDict["injection"] = meta_info.injection
destServiceDict["port"] = int(port.container_port)
destServiceDict["protocol"] = port.protocol
destServiceDict["service_alias"] = service_alias
destServiceDict["service_id"] = service_id
destServiceDict["dest_service_alias"] = dest_service_alias
destServiceDict["dest_service_id"] = dest_service_id
destServiceDict["dest_service_cname"] = dest_service_cname
destServiceDict["config"] = copy.deepcopy(
self.getServicePluginAttrByAttrName(service_id, plugin_id, ConstKey.DOWNSTREAM_PORT, destServiceDict,
configList))
downStreamList.append(destServiceDict)
if tag == "post":
self.InsertSqlInDownStreamMeta(downStreamList, plugin_id, service_id)
logger.debug("plugin.relation", "downstreamList is {}".format(downStreamList))
return downStreamList
elif meta_info.service_meta_type == ConstKey.UPSTREAM_PORT:
upStreamList = []
ports = TenantServicesPort.objects.filter(tenant_id=tenant_id, service_id=service_id)
if len(ports) == 0:
return []
for port in ports:
serviceDict = {}
serviceDict["service_meta_type"] = ConstKey.UPSTREAM_PORT
serviceDict["injection"] = meta_info.injection
serviceDict["port"] = int(port.container_port)
serviceDict["protocol"] = port.protocol
serviceDict["service_alias"] = service_alias
serviceDict["service_id"] = service_id
serviceDict["config"] = copy.deepcopy(
self.getServicePluginAttrByAttrName(service_id, plugin_id, ConstKey.UPSTREAM_PORT, serviceDict, configList))
upStreamList.append(serviceDict)
if tag == "post":
self.InsertSqlInUpStreamMeta(upStreamList, plugin_id, service_id)
logger.debug("plugin.relation", "upstreamList is {}".format(upStreamList))
return upStreamList
elif meta_info.service_meta_type == ConstKey.UNDEFINE:
envList = []
DDict = {}
DDict["service_meta_type"] = ConstKey.UNDEFINE
DDict["injection"] = meta_info.injection
DDict["service_alias"] = service_alias
DDict["service_id"] = service_id
DDict["config"] = copy.deepcopy(
self.getServicePluginAttrByAttrName(service_id, plugin_id, ConstKey.UNDEFINE, DDict, configList))
envList.append(DDict)
if tag == "post":
self.InsertSqlInENVMeta(envList, plugin_id, service_id)
logger.debug("plugin.relation", "upstreamList is {}".format(envList))
return envList
else:
logger.error("plugin.relation", "meta info is {}".format(meta_info.service_meta_type))
return []
def metaTypeAttrs(self, tenant_id, service_id, attrList, metaType):
if metaType == ConstKey.DOWNSTREAM_PORT:
relations = TenantServiceRelation.objects.filter(tenant_id=tenant_id, service_id=service_id)
if len(relations) == 0:
logger.error("service {0} has no relation dest_service".format(service_id))
return {}
def get_tenant_plugin_version_by_plugin_id_and_version(self, tenant, plugin_id, build_version=None):
"""
根据插件id和版本信息获取插件版本信息
:param tenant: 租户
:param plugin_id: 插件id
:param build_version: 指定插件的版本
:return: 指定插件的和版本的构建信息
"""
if not build_version:
plugin_build_versions = PluginBuildVersion.objects.filter(
tenant_id=tenant.tenant_id, plugin_id=plugin_id).order_by("-ID")
else:
plugin_build_versions = PluginBuildVersion.objects.filter(
tenant_id=tenant.tenant_id, plugin_id=plugin_id, build_version=build_version).order_by("-ID")
if plugin_build_versions:
return plugin_build_versions[0]
return None
def init_plugin(self,
tenant,
user_id,
region,
desc,
plugin_alias,
category,
build_source,
build_status,
image,
code_repo,
min_memory,
build_cmd="",
image_tag="",
code_version=""):
"""初始化插件信息"""
plugin = self.create_plugin(tenant, user_id, region, desc, plugin_alias, category, build_source, image, code_repo)
build_version = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
min_cpu = self.calculate_cpu(region, min_memory)
plugin_build_version = self.create_plugin_build_version(region, plugin.plugin_id, tenant.tenant_id, user_id, "",
build_version, "unbuild", min_memory, min_cpu, build_cmd,
image_tag, code_version)
return plugin_build_version.plugin_id, plugin_build_version.build_version
def create_plugin(self, tenant, user_id, region, desc, plugin_alias, category, build_source, image, code_repo):
"""创建插件基础信息"""
plugin_id = make_uuid()
category = CATEGORY_REGION_MAP.get(category, category)
tenant_plugin = TenantPlugin.objects.create(
plugin_id=plugin_id,
tenant_id=tenant.tenant_id,
region=region,
create_user=user_id,
desc=desc,
plugin_name="gr" + plugin_id[:6],
plugin_alias=plugin_alias,
category=category,
build_source=build_source,
image=image,
code_repo=code_repo)
return tenant_plugin
def sortList(self, pList):
listp = []
for pdict in pList:
strdict = ""
for (k, v) in pdict.items():
strmm = "{0}^-^{1}".format(str(k), str(v))
if strdict:
strdict = "{0}^_^{1}".format(strdict, strmm)
else:
strdict = strmm
listp.append(strdict)
logger.debug("plugin.relation", "listp is {}".format(listp))
listp = list(set(listp))
# ['port^-^5000^_^name^-^gr1', 'port^-^6000^_^name^-^gr1']
listDict = []
for mm in listp:
listMM = mm.split("^_^")
ppdict = {}
for nn in listMM:
listNN = nn.split("^-^")
ppdict[listNN[0]] = listNN[1]
listDict.append(ppdict)
logger.debug("plugin.relation", "listDict is {}".format(listDict))
return listDict
def createAttrsJsonForRegion(self, service_id, service_alias, plugin_id):
complex_envs = {}
base_services = []
base_ports = []
normal_envs = []
auto_envs = {}
logger.debug("plugin.relation", "service_id: {0}, plugin_id:{1}, service_alias:{2}".format(
service_id, service_alias, plugin_id))
downStream_attrsList = TenantServicePluginAttr.objects.filter(
service_id=service_id, plugin_id=plugin_id, service_meta_type=ConstKey.DOWNSTREAM_PORT)
upstream_attrsList = TenantServicePluginAttr.objects.filter(
service_id=service_id, plugin_id=plugin_id, service_meta_type=ConstKey.UPSTREAM_PORT)
env_attrsList = TenantServicePluginAttr.objects.filter(
service_id=service_id, plugin_id=plugin_id, service_meta_type=ConstKey.UNDEFINE)
# 处理downstram
service_port_items = self.sortList(
downStream_attrsList.values("container_port", "dest_service_alias", "dest_service_id", "service_meta_type",
"protocol"))
logger.debug("plugin.relation", "service port items is {}".format(service_port_items))
if len(service_port_items) > 0:
for service_port in service_port_items:
_base_services = {}
_base_services["service_alias"] = service_alias
_base_services["service_id"] = service_id
_base_services["depend_service_id"] = service_port["dest_service_id"]
_base_services["depend_service_alias"] = service_port["dest_service_alias"]
_base_services["port"] = int(service_port["container_port"])
_base_services["protocol"] = service_port["protocol"]
_options = {}
for attr in downStream_attrsList:
if attr.container_port != int(service_port["container_port"]) or \
attr.dest_service_alias != service_port["dest_service_alias"]:
continue
_options[attr.attr_name] = attr.attr_value
_base_services["options"] = _options
base_services.append(_base_services)
# 处理 upstream
port_items = self.sortList(upstream_attrsList.values("container_port", "service_meta_type", "protocol"))
logger.debug("plugin.relation", "port items is {}".format(port_items))
if len(port_items) > 0:
for port in port_items:
_base_port = {}
_base_port["port"] = int(port["container_port"])
_base_port["protocol"] = port["protocol"]
_base_port["service_alias"] = service_alias
_base_port["service_id"] = service_id
_options = {}
for attr in upstream_attrsList:
if attr.container_port != int(port["container_port"]):
continue
_options[attr.attr_name] = attr.attr_value
_base_port["options"] = _options
base_ports.append(_base_port)
# 处理envs
env_items = self.sortList(env_attrsList.values("service_meta_type", "injection"))
logger.debug("plugin.relation", "env items is {}".format(env_items))
if len(env_items) > 0:
for env in env_items:
for attr in env_attrsList:
if env["injection"] == attr.injection == "auto":
auto_envs[attr.attr_name] = attr.attr_value
elif env["injection"] == attr.injection == "env":
_env = {}
_env["env_name"] = attr.attr_name
_env["env_value"] = attr.attr_value
normal_envs.append(_env)
complex_envs["base_ports"] = base_ports
complex_envs["base_services"] = base_services
complex_envs["base_normal"] = {"option": auto_envs}
logger.debug("plugin.relation", "complex json is {}".format(complex_envs))
return complex_envs, normal_envs
def updateALLTenantServicePluginAttr(self, config, plugin_id, service_id):
downstream_list = []
upstream_list = []
envstream_list = []
for stream in config:
if stream.get("service_meta_type") == ConstKey.DOWNSTREAM_PORT:
downstream_list.append(stream)
elif stream.get("service_meta_type") == ConstKey.UPSTREAM_PORT:
upstream_list.append(stream)
elif stream.get("service_meta_type") == ConstKey.UNDEFINE:
envstream_list.append(stream)
self.UpdateSqlInDownStreamMeta(downstream_list, plugin_id, service_id)
self.UpdateSqlInUpStreamMeta(upstream_list, plugin_id, service_id)
self.UpdateSqlInENVMeta(envstream_list, plugin_id, service_id)
def updateTenantServicePluginAttr(self, request):
logger.debug(
"plugin.relation", "old attr is " + request.get("config_group[service_alias]", "") + ";" +
request.get("config_group[dest_service_alias]", "") + ";" + request.get("plugin_id", None) + ";" + request.get(
"config_group[service_meta_type]", None) + ";" + str(request.get("config_group[port]", 0)) + ";" + request.get(
"config_group[config][attr_name]", None))
oldAttr = TenantServicePluginAttr.objects.get(
service_alias=request.get("config_group[service_alias]", ""),
dest_service_alias=request.get("config_group[dest_service_alias]", ""),
plugin_id=request.get("plugin_id", None),
service_meta_type=request.get("config_group[service_meta_type]", None),
container_port=request.get("config_group[port]", 0),
attr_name=request.get("config_group[config][attr_name]", None))
oldAttr.attr_value = request.get("config_group[config][attr_value]", None)
if not oldAttr.attr_value:
oldAttr.attr_value = request.get("config_group[config][attr_default_value]", None)
oldAttr.save()
def create_plugin_build_version(self,
region,
plugin_id,
tenant_id,
user_id,
update_info,
build_version,
build_status,
min_memory,
min_cpu,
build_cmd="",
image_tag="latest",
code_version="master"):
"""创建插件版本信息"""
plugin_build_version = PluginBuildVersion.objects.create(
plugin_id=plugin_id,
tenant_id=tenant_id,
region=region,
user_id=user_id,
update_info=update_info,
build_version=build_version,
build_status=build_status,
min_memory=min_memory,
min_cpu=min_cpu,
build_cmd=build_cmd,
image_tag=image_tag,
code_version=code_version)
return plugin_build_version
def calculate_cpu(self, region, memory):
"""根据内存和数据中心计算cpu"""
min_cpu = int(memory) * 20 / 128
if region == "ali-hz":
min_cpu = min_cpu * 2
return min_cpu
def check_config(self, *config_group):
if config_group:
temp_list = []
for config in config_group:
injection = config["injection"]
service_meta_type = config["service_meta_type"]
if injection == "env":
if service_meta_type == "port" or service_meta_type == "downstream_port":
return False, u"基于上游端口或下游端口的配置只能使用主动发现"
if service_meta_type in temp_list:
return False, u"配置组配置类型不能重复"
else:
temp_list.append(service_meta_type)
return True, u"检测成功"
def check_group_config(self, service_meta_type, injection, config_groups):
if injection == "env":
if service_meta_type == ConstKey.UPSTREAM_PORT or service_meta_type == ConstKey.DOWNSTREAM_PORT:
return False, u"基于上游端口或下游端口的配置只能使用主动发现"
for config_group in config_groups:
if config_group.service_meta_type == service_meta_type:
return False, u"配置组配置类型不能重复"
return True, u"检测成功"
def create_config_group(self, plugin_id, build_version, config_group):
"""创建配置组信息"""
pbvs = PluginBuildVersion.objects.filter(plugin_id=plugin_id, build_version=build_version)
if not pbvs:
logger.error("plugin id {0} and build version {1} is not found !".format(plugin_id, build_version))
raise Exception("version not found ! ")
plugin_config_meta_list = []
config_items_list = []
if config_group:
for config in config_group:
options = config["options"]
plugin_config_meta = PluginConfigGroup(
plugin_id=plugin_id,
build_version=build_version,
config_name=config["config_name"],
service_meta_type=config["service_meta_type"],
injection=config["injection"])
plugin_config_meta_list.append(plugin_config_meta)
for option in options:
config_item = PluginConfigItems(
plugin_id=plugin_id,
build_version=build_version,
service_meta_type=config["service_meta_type"],
attr_name=option["attr_name"],
attr_alt_value=option["attr_alt_value"],
attr_type=option.get("attr_type", "string"),
attr_default_value=option.get("attr_default_value", None),
is_change=option.get("is_change", False),
attr_info=option.get("attr_info", ""))
config_items_list.append(config_item)
self.bulk_create_plugin_config_group(plugin_config_meta_list)
self.bulk_create_plugin_config_items(config_items_list)
def update_plugin_version_by_unique_key(self, tenant, plugin_id, build_version, **params):
"""更新构建版本信息"""
pbv = self.get_tenant_plugin_version_by_plugin_id_and_version(tenant, plugin_id, build_version)
for k, v in params.items():
setattr(pbv, k, v)
pbv.save(update_fields=params.keys())
return pbv
def bulk_create_plugin_config_group(self, plugin_config_meta_list):
"""批量创建插件配置组信息"""
PluginConfigGroup.objects.bulk_create(plugin_config_meta_list)
def bulk_create_plugin_config_items(self, config_items_list):
"""批量创建插件配置项信息"""
PluginConfigItems.objects.bulk_create(config_items_list)
def get_plugin_config(self, tenant, plugin_id, build_version):
"""获取插件信息"""
build_version_info = self.get_tenant_plugin_version_by_plugin_id_and_version(tenant, plugin_id, build_version)
data = {}
data.update(model_to_dict(build_version_info))
config_group = []
config_groups = self.get_config_group_by_unique_key(plugin_id, build_version)
for conf in config_groups:
config_dict = model_to_dict(conf)
items = self.get_config_items_by_id_metadata_and_version(conf.plugin_id, conf.build_version, conf.service_meta_type)
options = [model_to_dict(item) for item in items]
config_dict["options"] = options
config_group.append(config_dict)
data["config_group"] = config_group
return data
def get_config_group_by_unique_key(self, plugin_id, build_version):
return PluginConfigGroup.objects.filter(plugin_id=plugin_id, build_version=build_version)
def get_config_items_by_id_and_version(self, plugin_id, build_version):
return PluginConfigItems.objects.filter(plugin_id=plugin_id, build_version=build_version)
def get_config_items_by_id_metadata_and_version(self, plugin_id, build_version, service_meta_type):
return PluginConfigItems.objects.filter(
plugin_id=plugin_id, build_version=build_version, service_meta_type=service_meta_type)
def delete_config_group_by_group_id_and_version(self, plugin_id, build_version):
PluginConfigGroup.objects.filter(plugin_id=plugin_id, build_version=build_version).delete()
PluginConfigItems.objects.filter(plugin_id=plugin_id, build_version=build_version).delete()
def roll_back_build(self, plugin_id, build_version):
"""删除原有数据"""
PluginBuildVersion.objects.filter(plugin_id=plugin_id, build_version=build_version).delete()
PluginConfigGroup.objects.filter(plugin_id=plugin_id, build_version=build_version).delete()
PluginConfigItems.objects.filter(plugin_id=plugin_id, build_version=build_version).delete()
def create_region_plugin(self, region, tenant, plugin_id):
"""创建region端插件信息"""
tenant_plugin = self.get_tenant_plugin_by_plugin_id(tenant, plugin_id)
plugin_data = {}
plugin_data["build_model"] = tenant_plugin.build_source
plugin_data["git_url"] = tenant_plugin.code_repo
plugin_data["plugin_id"] = tenant_plugin.plugin_id
plugin_data["plugin_info"] = tenant_plugin.desc
plugin_data["plugin_model"] = CATEGORY_REGION_MAP.get(tenant_plugin.category, tenant_plugin.category)
plugin_data["plugin_name"] = tenant_plugin.plugin_name
plugin_data["tenant_id"] = tenant.tenant_id
res, body = region_api.create_plugin(region, tenant.tenant_name, plugin_data)
return res, body
def build_plugin(self, region, tenant, event_id, plugin_id, build_version, origin=None):
"""构建插件"""
plugin_build_version = self.get_tenant_plugin_version_by_plugin_id_and_version(tenant, plugin_id, build_version)
plugin_base_info = self.get_tenant_plugin_by_plugin_id(tenant, plugin_id)
create_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
plugin_build_version.build_time = create_time
plugin_build_version.save()
build_data = {}
build_data["build_version"] = build_version
build_data["event_id"] = event_id
build_data["info"] = plugin_build_version.update_info
user = Users.objects.get(user_id=plugin_build_version.user_id)
build_data["operator"] = user.nick_name
build_data["plugin_cmd"] = plugin_build_version.build_cmd
build_data["plugin_memory"] = plugin_build_version.min_memory
build_data["plugin_cpu"] = self.calculate_cpu(region, plugin_build_version.min_memory)
build_data["repo_url"] = plugin_build_version.code_version
build_data["tenant_id"] = tenant.tenant_id
build_data["build_image"] = plugin_base_info.image
if origin == "local_market":
plugin_from = "yb"
elif origin == "market":
plugin_from = "ys"
else:
plugin_from = None
# build_data["plugin_from"] = "yb" if plugin_base_info.origin == "source_code" else "ys"
build_data["plugin_from"] = plugin_from
logger.debug("=====> build_data {0}".format(build_data))
body = region_api.build_plugin(region, tenant.tenant_name, plugin_id, build_data)
return body
def copy_config_to_new_version(self, tenant, plugin_id, old_version):
new_version = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
self.__copy_build_version_info(tenant, plugin_id, old_version, new_version)
self.__copy_config_group(plugin_id, old_version, new_version)
self.__copy_config_items(plugin_id, old_version, new_version)
return plugin_id, new_version
def __copy_build_version_info(self, tenant, plugin_id, old_version, new_version):
old_build_version = self.get_tenant_plugin_version_by_plugin_id_and_version(tenant, plugin_id, old_version)
old_dict = model_to_dict(old_build_version)
old_dict["build_status"] = "unbuild"
old_dict["event_id"] = ""
# 剔除主键
old_dict.pop("ID")
pbv = PluginBuildVersion.objects.create(**old_dict)
pbv.build_version = new_version
pbv.save()
return pbv
def __copy_config_group(self, plugin_id, old_version, new_version):
config_groups = self.get_config_group_by_unique_key(plugin_id, old_version)
config_group_copy = []
for config in config_groups:
config_dict = model_to_dict(config)
config_dict["build_version"] = new_version
# 剔除主键
config_dict.pop("ID")
config_group_copy.append(PluginConfigGroup(**config_dict))
self.bulk_create_plugin_config_group(config_group_copy)
def __copy_config_items(self, plugin_id, old_version, new_version):
config_items = self.get_config_items_by_id_and_version(plugin_id, old_version)
config_items_copy = []
for item in config_items:
item_dict = model_to_dict(item)
# 剔除主键
item_dict.pop("ID")
item_dict["build_version"] = new_version
config_items_copy.append(PluginConfigItems(**item_dict))
self.bulk_create_plugin_config_items(config_items_copy)
def get_plugin_event_log(self, region, tenant, event_id, level):
data = {"event_id": event_id, "level": level}
body = region_api.get_plugin_event_log(region, tenant.tenant_name, data)
return body["list"]
def get_plugin_build_status(self, region, tenant, plugin_id, build_version):
pbv = self.get_tenant_plugin_version_by_plugin_id_and_version(tenant, plugin_id, build_version)
if pbv.build_status == "building":
status = self.get_region_plugin_build_status(region, tenant.tenant_name, pbv.plugin_id, pbv.build_version)
pbv.build_status = status
pbv.save()
return pbv
def update_plugin_build_status(self, region, tenant):
logger.debug("start thread to update build status")
pbvs = PluginBuildVersion.objects.filter(region=region, tenant_id=tenant.tenant_id, build_status="building")
for pbv in pbvs:
status = self.get_region_plugin_build_status(region, tenant.tenant_name, pbv.plugin_id, pbv.build_version)
pbv.build_status = status
pbv.save()
def get_region_plugin_build_status(self, region, tenant_name, plugin_id, build_version):
try:
body = region_api.get_build_status(region, tenant_name, plugin_id, build_version)
status = body["bean"]["status"]
rt_status = REGION_BUILD_STATUS_MAP[status]
except region_api.CallApiError as e:
if e.status == 404:
rt_status = "unbuild"
else:
rt_status = "unknown"
return rt_status
def chargeSwtich(self, s):
if type(s) is not bool:
if "false" in s:
s = False
elif "true" in s:
s = True
else:
s = True
return s
def is_plugin_version_can_build(self, plugin_id, plugin_version):
pbvs = PluginBuildVersion.objects.get(plugin_id=plugin_id, plugin_version=plugin_version)
return pbvs.plugin_version_status == "unfixed"
def delete_build_version_by_id_and_version(self, region, tenant, plugin_id, build_version):
region_api.delete_plugin_version(region, tenant.tenant_name, plugin_id, build_version)
PluginBuildVersion.objects.filter(plugin_id=plugin_id, build_version=build_version).delete()
self.delete_config_group_by_group_id_and_version(plugin_id, build_version)
def get_service_plugin_relation_by_plugin_unique_key(self, plugin_id, build_version):
tsprs = TenantServicePluginRelation.objects.filter(plugin_id=plugin_id, build_version=build_version)
if tsprs:
return tsprs
return None
def get_config_group_by_pk(self, pk):
return PluginConfigGroup.objects.get(pk=pk)
def delete_config_group_by_meta_type(self, plugin_id, build_version, service_meta_type):
PluginConfigItems.objects.filter(
plugin_id=plugin_id, build_version=build_version, service_meta_type=service_meta_type).delete()
PluginConfigGroup.objects.filter(
plugin_id=plugin_id, build_version=build_version, service_meta_type=service_meta_type).delete()
def update_config_group_by_pk(self, pk, config_name, service_meta_type, injection):
pcg = PluginConfigGroup.objects.get(pk=pk)
pcg.service_meta_type = service_meta_type
pcg.injection = injection
pcg.config_name = config_name
pcg.save()
def delete_config_items_by_meta_type(self, plugin_id, build_version, service_meta_type):
PluginConfigItems.objects.filter(
plugin_id=plugin_id, build_version=build_version, service_meta_type=service_meta_type).delete()
def create_config_items(self, plugin_id, build_version, service_meta_type, *options):
config_items_list = []
for option in options:
config_item = PluginConfigItems(
plugin_id=plugin_id,
build_version=build_version,
service_meta_type=service_meta_type,
attr_name=option["attr_name"],
attr_alt_value=option["attr_alt_value"],
attr_type=option.get("attr_type", "string"),
attr_default_value=option.get("attr_default_value", None),
is_change=option.get("is_change", False),
attr_info=option.get("attr_info", ""))
config_items_list.append(config_item)
self.bulk_create_plugin_config_items(config_items_list)
def get_rainbond_apps_versions_with_template_by_eid(
self, eid, name=None, tags=None, scope=None, page=1, page_size=10):
page = (page - 1) * page_size
limit = "LIMIT {page}, {page_size}".format(page=page,
page_size=page_size)
where = 'WHERE BB.enterprise_id="{eid}" '.format(eid=eid)
group = """GROUP BY BB.enterprise_id, BB.app_id {}) CC
LEFT JOIN rainbond_center_app_tag_relation D
ON D.app_id=CC.app_id AND D.enterprise_id=CC.enterprise_id
LEFT JOIN rainbond_center_app_tag E
ON D.tag_id=E.ID """.format(limit)
if name:
where += 'AND BB.app_name LIKE"{}%" '.format(name)
if scope:
where += 'AND BB.scope="{}" '.format(scope)
if tags:
group += 'WHERE E.name="{}" '.format(tags[0])
for tag in tags[1:]:
group += 'OR E.name="{}" '.format(tag)
order_by = "GROUP BY CC.enterprise_id, CC.app_id ORDER BY CC.install_number DESC, CC.update_time DESC;"
sql1 = """SET GLOBAL group_concat_max_len = 40960000;"""
sql2 = """SET SESSION group_concat_max_len = 40960000;"""
sql = """
SELECT CC.*,
CONCAT('[',
GROUP_CONCAT(
CONCAT('{"tag_id":"',E.ID,'"'),',',
CONCAT('"name":"',E.name),'"}')
,']') as tags
FROM
(SELECT
BB.ID,
BB.app_id,
BB.app_name,
BB.create_user,
BB.create_team,
BB.pic,
BB.dev_status,
BB.describe,
BB.details,
BB.enterprise_id,
BB.create_time,
BB.update_time,
BB.is_ingerit,
BB.is_official,
BB.install_number,
BB.source,
BB.scope,
CONCAT('[',
GROUP_CONCAT(
CONCAT('"',C.version,'"'))
,']') as versions,
CONCAT('[',
GROUP_CONCAT(
CONCAT('{"version":"',C.version,'"'),',',
CONCAT('"is_complete":',C.is_complete),',',
CONCAT('"version_alias":"',C.version_alias),'",',
CONCAT('"app_template":',C.app_template),'}')
,']') as versions_info
FROM (SELECT A.enterprise_id, A.app_id, A.version, MAX(A.update_time) update_time
FROM rainbond_center_app_version A GROUP BY A.enterprise_id, A.app_id, A.version) B
LEFT JOIN rainbond_center_app_version C
ON C.enterprise_id=B.enterprise_id AND C.app_id=B.app_id AND
C.version=B.version AND C.update_time=B.update_time
RIGHT JOIN (SELECT * FROM rainbond_center_app RCA GROUP BY RCA.enterprise_id, RCA.app_id) BB
ON C.enterprise_id=BB.enterprise_id AND C.app_id=BB.app_id
"""
sql += where
sql += group
sql += order_by
conn = BaseConnection()
conn.query(sql1)
conn.query(sql2)
result = conn.query(sql)
return result
