def _copy_schema(self, session, src_database, src_schema, dst_database,
dst_schema, auths, **kwargs):
src_record = model_query(session,
RecordDatabase,
filter=RecordDatabase.record_id == int(
src_database.reflection_id)).one()
dst_record = model_query(session,
RecordDatabase,
filter=RecordDatabase.record_id == int(
dst_database.reflection_id)).one()
src_info = dict(user=src_database.user,
passwd=src_database.passwd,
host=src_record.host,
port=src_record.port)
dst_info = dict(user=dst_database.user,
passwd=dst_database.passwd,
host=dst_record.host,
port=dst_record.port)
schema_info = utils.copydb(
src=src_info,
dst=dst_info,
auths=auths,
tables_need_copy=kwargs.get('tables_need_copy'),
exec_sqls=kwargs.get('exec_sqls'))
try:
yield schema_info[1], schema_info[2]
except Exception:
engine = create_engine(connformater % dst_info,
thread_checkin=False,
poolclass=NullPool)
utils.drop_schema(engine, auths)
raise
def esure(self, req, oid, body=None):
"""
这个接口由客户端调用
"""
oid = int(oid)
now = int(time.time() * 1000)
otime = uuidutils.Gprimarykey.timeformat(oid)
if (now - otime) > weiXinApi.overtime * 2 or otime > now:
raise InvalidArgument('Order id error or overtime')
session = endpoint_session(readonly=True) # 注意主从不同步的可能
query = model_query(session,
RechargeLog,
filter=RechargeLog.oid == oid)
recharge = query.one_or_none()
if recharge:
return resultutils.results(result='esure orde success',
data=[
dict(oid=oid,
coins=recharge.gift +
recharge.coin,
money=recharge.money)
])
session = endpoint_session()
query = model_query(session, Order, filter=Order.oid == oid)
order = query.one()
serial, extdata = weiXinApi.esure_order(order)
self.record(session, order, serial, extdata)
return resultutils.results(result='esure orde success',
data=[
dict(oid=oid,
coins=order.gift + order.coin,
money=order.money)
])
def ready_relation(self, database_id, **kwargs):
slave_id = kwargs.pop('slave')
force = kwargs.pop('force')
session = endpoint_session()
query = model_query(session,
GopSalveRelation,
filter=and_(
GopSalveRelation.master_id == database_id,
GopSalveRelation.slave_id == slave_id))
with session.begin(subtransactions=True):
relation = query.one_or_none()
if not relation:
raise InvalidArgument(
'Can not find relation of master %d slave %d' %
(database_id, slave_id))
if relation.ready:
return None
if force:
relation.ready = True
return None
query = model_query(session,
GopDatabase,
filter=GopDatabase.database_id.in_(
[database_id, slave_id]))
query = query.options(
joinedload(GopDatabase.schemas, innerjoin=False))
for database in query:
if database.database_id == database_id:
master = database
elif database.database_id == slave_id:
slave = database
return self._ready_relation(session, master, slave, relation,
**kwargs)
def quote_version(self, req, group_id, objtype, entity, body=None):
"""区服包引用指定资源版本"""
body = body or {}
if objtype != common.GAMESERVER:
raise InvalidArgument('Version quote just for %s' % common.GAMESERVER)
package_id = int(body.get('package_id'))
rversion = body.get('rversion')
group_id = int(group_id)
entity = int(entity)
session = endpoint_session()
query = model_query(session, Group, filter=Group.group_id == group_id)
query = query.options(joinedload(Group.packages, innerjoin=False))
group = query.one()
resource_id = None
for package in group.packages:
if package.package_id == package_id:
resource_id = package.resource_id
if not resource_id:
raise InvalidArgument('Entity can not find package or package resource is None')
query = model_query(session, AppEntity, filter=AppEntity.entity == entity)
query = query.options(joinedload(AppEntity.areas, innerjoin=False))
with session.begin():
_entity = query.one()
if _entity.objtype != objtype:
raise InvalidArgument('Objtype not match')
if _entity.group_id != group_id:
raise InvalidArgument('Group id not match')
if not model_count_with_key(session, PackageArea.package_id,
filter=and_(PackageArea.package_id == package_id,
PackageArea.area_id.in_([area.area_id
for area in _entity.areas])
)):
raise InvalidArgument('Entity area not in package areas')
versions = jsonutils.loads_as_bytes(_entity.versions) if _entity.versions else {}
str_key = str(package_id)
if str_key in versions:
quote = versions.get(str_key)
if quote.get('version') != rversion:
body = {'version': rversion}
quote.update(body)
cdnquote_controller.update(req, quote.get('quote_id'), body=body)
else:
qresult = cdnresource_controller.vquote(req, resource_id,
body={'version': rversion,
'desc': '%s.%d' % (common.NAME, entity)})
quote = qresult['data'][0]
quote = dict(version=rversion, quote_id=quote.get('quote_id'))
versions.setdefault(str_key, quote)
_entity.versions = jsonutils.dumps(versions)
session.flush()
return resultutils.results(result='set entity version quote success',
data=[dict(resource_id=resource_id,
version=rversion, quote_id=quote.get('quote_id'))])
def show(self, req, md5, body=None):
session = get_session(readonly=True)
query = model_query(session, DownFile, filter=DownFile.md5 == md5)
downfile = query.one_or_none()
if not downfile:
return resultutils.results(resultcode=manager_common.RESULT_ERROR,
result='Get file fail, no found')
file_info = {
'downloader': downfile.downloader,
'address': downfile.address,
'ext': downfile.ext,
'size': downfile.size,
'uploadtime': str(downfile.uploadtime),
'md5': downfile.md5,
'status': downfile.status,
}
if downfile.adapter_args:
file_info.setdefault(
'adapter_args',
jsonutils.dumps_as_bytes(downfile.adapter_args))
if downfile.desc:
file_info.setdefault('desc', downfile.desc)
resultcode = manager_common.RESULT_SUCCESS
if downfile.status != manager_common.DOWNFILE_FILEOK:
resultcode = manager_common.RESULT_ERROR
return resultutils.results(result='Get file success',
resultcode=resultcode,
data=[
file_info,
])
def entitys(self, req, body=None):
"""批量查询entitys信息接口,内部接口agent启动的时调用,一般由agent端调用"""
entitys = body.get('entitys')
if not entitys:
return resultutils.results(result='not any app entitys found')
entitys = argutils.map_to_int(entitys)
session = endpoint_session(readonly=True)
query = model_query(session,
AppEntity,
filter=AppEntity.entity.in_(entitys))
query = query.options(joinedload(AppEntity.areas, innerjoin=False))
return resultutils.results(result='get app entitys success',
data=[
dict(entity=_entity.entity,
group_id=_entity.group_id,
status=_entity.status,
opentime=_entity.opentime,
areas=[
dict(area_id=area.area_id,
show_id=area.show_id,
areaname=area.areaname)
for area in _entity.areas
],
objtype=_entity.objtype)
for _entity in query
])
def show(self, req, agent_id, body=None):
body = body or {}
show_ports = body.get('ports', False)
show_entitys = body.get('entitys', False)
session = get_session(readonly=True)
joins = joinedload(Agent.endpoints, innerjoin=False)
if show_entitys:
joins = joins.joinedload(AgentEndpoint.entitys, innerjoin=False)
if show_ports:
joins = joins.joinedload(AgentEntity.ports, innerjoin=False)
query = model_query(session, Agent).options(joins)
agent = query.filter_by(agent_id=agent_id).one()
result = resultutils.results(total=1, pagenum=0, result='Show agent success')
endpoints = {}
for endpoint in agent.endpoints:
endpoints[endpoint.endpoint] = []
if show_entitys:
for entity in endpoint.entitys:
_entity = {'entity': entity.entity, 'ports': []}
endpoints[endpoint.endpoint].append(_entity)
if show_ports:
for port in entity.ports:
_entity['ports'].append(port['port'])
result_data = dict(agent_id=agent.agent_id, host=agent.host,
agent_type=agent.agent_type,
status=agent.status,
cpu=agent.cpu,
memory=agent.memory,
disk=agent.disk,
ports_range=jsonutils.safe_loads_as_bytes(agent.ports_range) or [],
endpoints=endpoints,
metadata=BaseContorller.agent_metadata(agent_id),
)
result['data'].append(result_data)
return result
def show(self, req, endpoint, entity, body=None):
body = body or {}
show_ports = body.get('ports', False)
endpoint = validateutils.validate_endpoint(endpoint)
entity = int(entity)
session = get_session(readonly=True)
query = model_query(session,
AgentEntity,
filter=and_(AgentEntity.endpoint == endpoint,
AgentEntity.entity == entity))
if show_ports:
query = query.options(
joinedload(AgentEntity.ports, innerjoin=False))
_entity = query.one_or_none()
if not _entity:
raise InvalidArgument('no entity found for %s' % endpoint)
# return resultutils.results(result='no entity found', resultcode=manager_common.RESULT_ERROR)
return resultutils.results(
result='show entity success',
data=[
dict(endpoint=_entity.endpoint,
agent_id=_entity.agent_id,
metadata=BaseContorller.agent_metadata(_entity.agent_id),
entity=_entity.entity,
ports=sorted([x.port for x in _entity.ports])
if show_ports else [])
])
def save_logbook(self, book):
try:
with self.session.begin():
query = dbapi.model_query(self.session,
LogBook).filter_by(uuid=book.uuid)
logbook = query.one_or_none()
if logbook:
e_lb = self._converter.convert_book(logbook)
self._converter.populate_book(self.session, e_lb)
e_lb.merge(book)
logbook.update(e_lb.to_dict())
for fd in book:
e_fd = e_lb.find(fd.uuid)
if e_fd is None:
e_lb.add(fd)
self._insert_flow_details(fd, e_lb.uuid)
else:
self._update_flow_details(fd, e_fd)
return e_lb
else:
self.session.add(LogBook(**book.to_dict()))
self.session.flush()
for fd in book:
self._insert_flow_details(fd, book.uuid)
return book
except sa_exc.DBAPIError:
exc.raise_with_cause(exc.StorageFailure,
"Failed saving logbook '%s'" % book.uuid)
def orders(self, req, uid, body=None):
"""用户订单查询"""
uid = int(uid)
session = endpoint_session(readonly=True)
query = model_query(session, Order, filter=Order.uid == uid)
query = query.order_by(Order.oid.desc())
return resultutils.results(
result='show order of user success',
data=[
dict(
oid=order.oid,
sandbox=order.sandbox,
uid=order.uid,
coins=order.coins,
gifts=order.gifts,
coin=order.coin,
gift=order.gift,
money=order.money,
platform=order.platform,
serial=order.serial,
time=order.time,
cid=order.cid,
chapter=order.chapter,
ext=jsonutils.loads_as_bytes(order.ext)
if order.ext else None,
) for order in query
])
def show(self, req, uid, body=None):
"""列出用户信息"""
uid = int(uid)
session = endpoint_session(readonly=True)
query = model_query(session, User, filter=User.uid == uid)
joins = joinedload(User.books, innerjoin=False)
query = query.options(joins)
user = query.one()
return resultutils.results(result='show user success',
data=[
dict(
name=user.name,
uid=user.uid,
offer=user.offer,
coins=user.coins,
gifts=user.gifts,
status=user.status,
regtime=user.regtime,
books=[
dict(cid=comic.cid,
name=comic.name,
author=comic.author,
time=comic.time)
for comic in user.books
],
owns=[
dict(cid=own.cid,
chapter=own.chapter)
for own in user.owns
],
)
])
def _show_database(self, session, database, **kwargs):
"""show database info"""
_record = model_query(session,
RecordDatabase,
filter=RecordDatabase.record_id == int(
database.reflection_id)).one()
yield _record.host, _record.port
def _select_database(self, session, query, dbtype, **kwargs):
zone = kwargs.get('zone', 'all')
query = query.filter_by(impl='record')
affinitys = {}
rquery = model_query(session,
RecordDatabase,
filter=RecordDatabase.zone == zone)
includes = set()
for r in rquery:
r.add(r.record_id)
if not includes:
raise InvalidArgument('No record database found with zone %s' %
zone)
for _database in query:
if int(_database.reflection_id) not in includes:
continue
try:
affinitys[_database.affinity].append(_database)
except KeyError:
affinitys[_database.affinity] = [_database]
if not affinitys:
raise InvalidArgument('No record database found')
result = []
for affinity in affinitys:
result.append(
dict(affinity=affinity,
databases=[
_database.database_id
for _database in sorted(affinitys[affinity],
key=lambda x: len(x.schemas))
]))
return result
def _create_schema(self, session, database, schema, auths, options,
**kwargs):
"""create new schema intance on database_id"""
try:
_record = model_query(session,
RecordDatabase,
filter=RecordDatabase.record_id == int(
database.reflection_id)).one()
host = _record.host
port = _record.port
if database.passwd:
connection = connformater % dict(user=database.user,
passwd=database.passwd,
host=host,
port=port,
schema=schema)
engine = create_engine(connection,
thread_checkin=False,
poolclass=NullPool)
utils.create_schema(
engine,
auths=auths,
character_set=options.get('character_set'),
collation_type=options.get('collation_type'),
connection_timeout=3)
yield host, port
except Exception:
raise
def rpc_changesource(self, ctxt, agent_id, fds, conns, free, process, cputime, iowait, left, metadata):
"""agent status of performance change"""
if agent_id not in self.agents_loads:
session = get_session(readonly=True)
query = model_query(session, Agent, filter=Agent.agent_id == agent_id)
agent = query.one_or_none()
if not agent:
return
if agent_id not in self.agents_loads:
self.agents_loads[agent_id] = dict(cpu=agent.cpu,
memory=agent.memory,
disk=agent.disk)
new_status = {'free': free, 'process': process,
'cputime': cputime, 'iowait': iowait,
'left': left, 'fds': fds, 'conns': conns,
'time': int(time.time())}
# 元数据为None时不更新元数据
if metadata is not None:
new_status['metadata'] = metadata
else:
# 当前agent没有元数据,尝试获取元数据
if not self.agents_loads[agent_id].get('metadata'):
# cache_store = get_redis()
# metadata = cache_store.get(targetutils.host_online_key(agent_id))
# new_status['metadata'] = metadata if not metadata else jsonutils.loads_as_bytes(metadata)
global_data = get_global()
metadatas = global_data.agents_metadata([agent_id, ])
new_status['metadata'] = metadatas.get(agent_id)
self.agents_loads[agent_id].update(new_status)
def show(self, req, oid, body=None):
"""完成订单详情"""
body = body or {}
oid = int(oid)
session = endpoint_session(readonly=True)
query = model_query(session,
RechargeLog,
filter=RechargeLog.oid == oid)
relog = query.one()
return resultutils.results(
result='show recharge log success',
data=[
dict(
oid=relog.oid,
sandbox=relog.sandbox,
uid=relog.uid,
coins=relog.coins,
gifts=relog.gifts,
coin=relog.coin,
gift=relog.gift,
money=relog.money,
platform=relog.platform,
serial=relog.serial,
time=relog.time,
cid=relog.cid,
chapter=relog.chapter,
ext=jsonutils.loads_as_bytes(relog.ext)
if relog.ext else None,
)
])
def recharges(self, req, uid, body=None):
"""用户订单列表"""
body = body or {}
uid = int(uid)
session = endpoint_session(readonly=True)
query = model_query(session,
RechargeLog,
filter=RechargeLog.uid == uid)
query = query.order_by(RechargeLog.oid.desc())
return resultutils.results(
result='show user recharge log success',
data=[
dict(
oid=relog.oid,
sandbox=relog.sandbox,
uid=relog.uid,
coins=relog.coins,
gifts=relog.gifts,
coin=relog.coin,
gift=relog.gift,
money=relog.money,
platform=relog.platform,
serial=relog.serial,
time=relog.time,
cid=relog.cid,
chapter=relog.chapter,
ext=jsonutils.loads_as_bytes(relog.ext)
if relog.ext else None,
) for relog in query
])
def quote(self, req, quote_id, body=None):
"""show schema quote info"""
body = body or {}
session = endpoint_session(readonly=True)
query = model_query(session,
SchemaQuote,
filter=SchemaQuote.quote_id == quote_id)
schema_quote = query.one()
data = dict(
quote_id=quote_id,
schema_id=schema_quote.schema_id,
qdatabase_id=schema_quote.qdatabase_id,
entity=schema_quote.entity,
endpoint=schema_quote.endpoint,
)
if body.get('schema', False):
schema = schema_quote.schema
data.setdefault(
'schema',
dict(schema=schema.schema,
character_set=schema.character_set,
collation_type=schema.collation_type))
if body.get('database', False):
database = schema_quote.database
data.setdefault(
'database',
dict(impl=database.impl,
reflection_id=database.reflection_id,
slave=database.slave,
dbtype=database.dbtype,
dbversion=database.dbversion))
return resultutils.results(result='get quote success', data=[
data,
])
def status_database(self, database_id, **kwargs):
session = endpoint_session(readonly=True)
query = model_query(session,
GopDatabase,
filter=GopDatabase.database_id == database_id)
_database = query.one()
return self._status_database(_database, **kwargs)
def task():
session = get_session()
query = model_query(session,
ScheduleJob,
filter=ScheduleJob.job_id == job_id)
job = query.one_or_none()
if job is None:
LOG.warring(
'Scheduler job %d has been deleted or run by this scheduler'
)
raise loopingcall.LoopingCallDone
if job.times is not None:
if job.times == 0:
query.delete()
raise loopingcall.LoopingCallDone
# call taskflow run job
factory.start_taskflow(job)
if job.times is not None:
job.times -= 1
session.flush()
session.close()
if job.times is not None:
if job.times == 0:
query.delete()
raise loopingcall.LoopingCallDone
def _address(database_ids):
IMPLMAP = {}
NOT_CACHED = []
for database_id in database_ids:
if database_id in MANAGERCACHE:
try:
IMPLMAP[MANAGERCACHE[database_id]].append(database_id)
except KeyError:
IMPLMAP[MANAGERCACHE[database_id]] = [
database_id,
]
else:
NOT_CACHED.append(database_id)
if NOT_CACHED:
session = endpoint_session(readonly=True)
query = model_query(session,
(GopDatabase.database_id, GopDatabase.impl),
filter=GopDatabase.database_id.in_(NOT_CACHED))
for r in query:
dbmanager = utils.impl_cls('wsgi', r[1])
try:
IMPLMAP[dbmanager].append(r[0])
except KeyError:
IMPLMAP[dbmanager] = [
r[0],
]
session.close()
maps = dict()
for dbmanager in IMPLMAP:
maps.update(dbmanager.address(IMPLMAP[dbmanager]))
return maps
def clean(self, req, agent_id):
session = get_session()
query = model_query(session, Agent,
filter=and_(Agent.agent_id == agent_id,
Agent.status <= manager_common.DELETED))
entity_query = model_query(session, AgentEntity.entity, filter=Agent.agent_id == agent_id)
with session.begin():
entitys = entity_query.all()
if entitys:
for entity in entitys:
LOG.error('Clean agent fail, entity %s:%d still on %s' %
(entity.endpoint, entity.entity, agent_id))
raise EndpointNotEmpty('Clean agent %s fail, still has %d entitys' % (agent_id, len(entitys)))
count = query.delete()
LOG.info('Clean deleted agent %d, agent_id %s' % (count, agent_id))
return resultutils.results(result='Clean deleted agent success')
def show(self, req, oid, body=None):
"""订单详情"""
body = body or {}
oid = int(oid)
session = endpoint_session(readonly=True)
query = model_query(session, Order, filter=Order.oid == oid)
order = query.one()
return resultutils.results(
result='show order success',
data=[
dict(
oid=order.oid,
sandbox=order.sandbox,
uid=order.uid,
coins=order.coins,
gifts=order.gifts,
coin=order.coin,
gift=order.gift,
money=order.money,
platform=order.platform,
serial=order.serial,
time=order.time,
cid=order.cid,
chapter=order.chapter,
ext=jsonutils.loads_as_bytes(order.ext)
if order.ext else None,
)
])
def migrate(self, req, group_id, objtype, entity, body=None):
"""Entity变更agent"""
body = body or {}
entity = int(entity)
group_id = int(group_id)
jsonutils.schema_validate(body, self.MIGRATE)
new = body.pop('new')
new = int(new)
body.update({'databases': True, 'chiefs': True})
session = endpoint_session(autocommit=False)
query = model_query(session, AppEntity, filter=AppEntity.entity == entity)
query = query.options(joinedload(AppEntity.areas, innerjoin=False))
_entity = query.one()
if _entity.objtype != objtype:
raise InvalidArgument('Entity is not %s' % objtype)
if not self._check_file(_entity.agent_id, objtype, body.get(common.APPFILE)):
return resultutils.results(result='migrate entity %d not run, check appfile fail')
LOG.debug('Check appfile success, migrate start')
areas = [dict(area_id=area.area_id, areaname=area.areaname, show_id=area.show_id)
for area in _entity.areas]
with entity_controller.migrate_with_out_data(common.NAME, entity, new,
dict(token=uuidutils.generate_uuid()),
drop_ports=True):
_entity.agent_id = new
session.commit()
LOG.info('Migrate finish, now call post create entity and reset entity on new agent')
entity_controller.post_create_entity(
entity, common.NAME, objtype=objtype,
status=_entity.status, opentime=_entity.opentime, group_id=group_id,
areas=areas, migrate=True)
LOG.info('Notify create entity in new agent success')
return self.reset(req, group_id, objtype, entity, body)
def order(session,
client,
serial,
uid,
oid,
money,
cid,
chapter,
ext=None,
order_time=None):
query = model_query(session, User, filter=User.uid == uid)
coin, gift = client.translate(money)
with session.begin():
user = query.one()
order = Order(oid=oid,
uid=uid,
sandbox=client.sandbox,
currency=client.currency,
platform=client.name,
money=money,
serial=serial,
time=order_time or int(time.time()),
cid=cid,
chapter=chapter,
coins=user.coins,
gifts=user.gifts,
coin=coin,
gift=gift,
ext=jsonutils.dumps(ext) if ext else None)
session.add(order)
return coin + gift
def opentime(self, req, group_id, objtype, entity, body=None):
"""修改开服时间接口"""
body = body or {}
group_id = int(group_id)
entity = int(entity)
if objtype != common.GAMESERVER:
raise InvalidArgument('Api just for %s' % common.GAMESERVER)
opentime = int(body.pop('opentime'))
if opentime < 0 or opentime >= int(time.time()) + 86400 * 15:
raise InvalidArgument('opentime value error')
session = endpoint_session()
with session.begin():
query = model_query(session, AppEntity, filter=AppEntity.entity == entity)
_entity = query.one()
if _entity.objtype != objtype:
raise InvalidArgument('Entity is not %s' % objtype)
if _entity.group_id != group_id:
raise InvalidArgument('Entity group %d not match %d' % (_entity.group_id, group_id))
metadata, ports = self._entityinfo(req=req, entity=entity)
target = targetutils.target_agent_by_string(metadata.get('agent_type'),
metadata.get('host'))
target.namespace = common.NAME
rpc = get_client()
finishtime, timeout = rpcfinishtime()
# with session.begin():
rpc_ret = rpc.call(target, ctxt={'finishtime': finishtime},
msg={'method': 'opentime_entity',
'args': dict(entity=entity, opentime=opentime)},
timeout=timeout)
query.update({'opentime': opentime})
if not rpc_ret:
raise RpcResultError('change entity opentime result is None')
if rpc_ret.get('resultcode') != manager_common.RESULT_SUCCESS:
raise RpcResultError('change entity opentime fail %s' % rpc_ret.get('result'))
return resultutils.results(result='change entity %d opentime success' % entity)
def unquote_version(self, req, group_id, objtype, entity, body=None):
"""区服包引用指定资源引用删除"""
body = body or {}
if objtype != common.GAMESERVER:
raise InvalidArgument('Version unquote just for %s' % common.GAMESERVER)
package_id = int(body.get('package_id'))
group_id = int(group_id)
entity = int(entity)
session = endpoint_session()
query = model_query(session, AppEntity, filter=AppEntity.entity == entity)
quote = None
with session.begin():
_entity = query.one()
if _entity.objtype != objtype:
raise InvalidArgument('Objtype not match')
if _entity.group_id != group_id:
raise InvalidArgument('Group id not match')
versions = jsonutils.loads_as_bytes(_entity.versions) if _entity.versions else {}
str_key = str(package_id)
if str_key in versions:
quote = versions.pop(str_key)
cdnquote_controller.delete(req, quote.get('quote_id'))
_entity.versions = jsonutils.dumps(versions) if versions else None
session.flush()
return resultutils.results(result='%s entity version unquote success' % objtype,
data=[dict(version=quote.get('version') if quote else None,
quote_id=quote.get('quote_id') if quote else None)])
def delete(self, req, agent_id, endpoint):
endpoints = validateutils.validate_endpoints(endpoint)
if not endpoints:
raise InvalidArgument('Endpoints is None for add endpoints')
endpoints = validateutils.validate_endpoints(endpoints)
session = get_session()
glock = get_global().lock('agents')
with glock([
agent_id,
]):
with session.begin():
if model_count_with_key(
session,
AgentEntity.entity,
filter=and_(AgentEntity.agent_id == agent_id,
AgentEntity.endpoint.in_(endpoints))):
return resultutils.results(
resultcode=manager_common.RESULT_ERROR,
result=
'delete endpoints fail, entitys still in endpoint')
query = model_query(session,
AgentEndpoint,
filter=and_(
AgentEndpoint.agent_id == agent_id,
AgentEndpoint.endpoint.in_(endpoints)))
delete_count = query.delete(synchronize_session=False)
need_to_delete = len(endpoints)
if delete_count != len(endpoints):
LOG.warning('Delete %d endpoints, but expect count is %d' %
(delete_count, need_to_delete))
session.close()
return resultutils.results(result='delete endpoints success')
def show(self, req, group_id, objtype, entity, body=None):
body = body or {}
group_id = int(group_id)
entity = int(entity)
session = endpoint_session(readonly=True)
_format = body.get('format') or 'list'
query = model_query(session,
AppEntity,
filter=AppEntity.entity == entity)
query = query.options(joinedload(AppEntity.databases, innerjoin=False))
_entity = query.one()
if _entity.objtype != objtype:
raise InvalidArgument('Entity is not %s' % objtype)
if _entity.group_id != group_id:
raise InvalidArgument('Entity group %d not match %d' %
(_entity.group_id, group_id))
metadata, ports = self._entityinfo(req, entity)
if _format == 'list':
databases = []
else:
databases = {}
for database in _entity.databases:
dbinfo = dict(quote_id=database.quote_id,
database_id=database.database_id,
host=database.host,
port=database.port,
ro_user=database.ro_user,
ro_passwd=database.ro_passwd,
subtype=database.subtype,
schema='%s_%s_%s_%d' %
(common.NAME, objtype, database.subtype, entity))
if _format == 'list':
databases.append(dbinfo)
else:
databases[database.subtype] = dbinfo
return resultutils.results(
result='show %s areas success' % objtype,
data=[
dict(entity=_entity.entity,
agent_id=_entity.agent_id,
objtype=objtype,
group_id=_entity.group_id,
opentime=_entity.opentime,
platform=_entity.platform,
status=_entity.status,
versions=jsonutils.loads_as_bytes(_entity.versions)
if _entity.versions else None,
areas=[
dict(
area_id=area.area_id,
gid=0,
show_id=area.show_id,
areaname=area.areaname.encode('utf-8'),
) for area in _entity.areas
],
databases=databases,
metadata=metadata,
ports=ports)
])
def index(self, req, agent_id):
session = get_session(readonly=True)
query = model_query(session,
AgentEndpoint,
filter=AgentEndpoint.agent_id == agent_id)
data = [endpoint for endpoint in query.options(entityjoin)]
return resultutils.results(result='list endpoint on success',
data=data)
