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_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 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_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 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 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_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_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_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
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
