async def me(access_token: str = Cookie(None)):
if not access_token:
raise HTTPException(401, "Authentication required")
headers = {"Authorization": f"Bearer {access_token}"}
res = await client.post(url=openid_conf.userinfo_endpoint, headers=headers)
if res.is_error:
expected_errors = {
401: "Authentication required",
403: "Forbidden",
}
if res.status_code in expected_errors:
logger.debug("Got error from user info endpoint",
code=res.status_code,
err=res.text)
raise HTTPException(res.status_code,
expected_errors[res.status_code])
else:
logger.error("Failed to call user info endpoint",
code=res.status_code,
err=res.text)
raise HTTPException(502, "Error with authentication APIs")
result = UserInfoResponse(**res.json())
return MeResponse(id=result.sub, name=result.name)
def handle(self):
param = self.queue.get()
player = param
try:
assert isinstance(manager.gg, GameInit)
if player.coins > 0:
time.sleep(0.1)
self.queue.put(player)
else:
if player.area:
table = player.area
try:
assert table.game.players_cards_on_table.get(
player.id).get('bet') > 0
time.sleep(0.1)
self.queue.put(player)
except AssertionError:
self.bring_to_black_room(player)
else:
# 既没有参加赌局也没有生命，视为被关进小黑屋
self.bring_to_black_room(player)
except AssertionError as e:
logger.error('LimitedGuessSettleHandler fail: {}'.format(e))
return False
def post(self):
data = parser.parse_args()
user_id = get_jwt_identity()['userid']
logger.info(f'{get_jwt_identity()}=={data}')
try:
all_results = HostModel.query.filter_by(project_id=data.project_id,
delete_sign=0).all()
host_list = []
for i in all_results:
host_data = {
'host_name': i.host_name,
'host_addr': i.host_addr,
'host_desc': i.host_desc,
'host_id': i.host_id
}
host_list.append(host_data)
send_data = {
'code': 0,
'message': "SUCCESS",
'host_list': host_list
}
logger.info(f'{send_data}')
return send_data
except Exception as e:
logger.error(f'{e}')
send_data = {'messaeg': 'Something went wrong', 'code': 1}
return send_data, 500
def post(self):
data = parser.parse_args()
user = UserModel.find_by_username(data['username'])
logger.info(f"{user.id}====={data}")
if not user:
send_data = {
'message': f'User {data["username"]} don\'t exist1',
'code': 1
}
logger.error(f"{send_data}")
return send_data
if UserModel.verify_hash(data['password'], user.password):
access_token = create_access_token(identity={
'username': data["username"],
'userid': user.id
})
refresh_token = create_refresh_token(identity={
'username': data["username"],
'userid': user.id
})
send_data = {
'msg': f'logged in as {data["username"]}',
'code': 0,
'access_token': access_token,
'refresh_token': refresh_token
}
logger.info(f'{send_data}')
return send_data
else:
send_data = {
'message': f'User {data["username"]} don\'t exist2',
'code': 1
}
logger.info(f'{send_data}')
return send_data
def request_error(e):
logger.error(e)
error_messages_list = []
for k, v in e.messages.items():
for k in v:
error_messages_list.append(k)
if len(error_messages_list) != 0:
VALIDATE_ERROR.message = error_messages_list
return ErrorResponse(VALIDATE_ERROR).make()
def get_all_instances(self):
try:
instances = self._boto_client.describe_db_instances()
if instances and 'DBInstances' in instances:
return instances['DBInstances']
except Exception as ex:
logger.error(ex)
return []
def fuction():
try:
ProjectModel.query.filter_by(
project_id=data.project_id).update({'delete_sign': 1})
send_data = {'message': 'SUCCESS', 'code': 0}
logger.info(f'{send_data}')
return send_data
except Exception as e:
logger.error({f'e'})
send_data = {'message': 'Something went wrong', 'code': 1}
return send_data, 500
def function():
try:
todeletehost.update({'delete_sign': 1})
send_data = {'message': 'SUCCESS', 'code': 0}
logger.info(f'{send_data}')
return send_data
except Exception as e:
logger.error(f'{e}')
print('=============================', e)
send_data = {'messaeg': 'Something went wrong', 'code': 1}
return send_data, 500
def password(self):
if self.ctx.password:
try:
return self._crypto.decrypt(self.ctx.password)
except ValueError as e:
logger.error(u"Couldn't decrypt password. {}".format(
e.message))
except TypeError as e:
logger.error(u"Couldn't decode base64 password. {}".format(
e.message))
return None
def handle(self):
param = self.queue.get()
table_id, = param
try:
assert isinstance(manager.gg, GameInit)
assert table_id in manager.gg.table_dc.keys()
table = manager.gg.table_dc[table_id]
table.init_gambling()
return True
except AssertionError as e:
logger.error('InitGameHandler fail: {}'.format(e))
return False
def get(self, **kwargs):
try:
review_obj = self.model.get(hash_key=str(kwargs['product_id']))
except self.model.DoesNotExist as ex:
logger.error(str(ex))
response = {
'msg':
'resource with product id {} does not exist'.format(
kwargs['product_id'])
}
return response, 404
return self.serializer().dump(review_obj), 200
def post(self, args):
data = dict(product_id=str(args['product_id']),
user_id=str(args['user_id']),
review_text=str(args['review_text']))
review_obj = self.model.dict2model(data)
try:
review_obj.save()
except Exception as ex:
logger.error(ex)
raise
return self.serializer().dump(data), 201
def password(self):
password = self.hostData.password
if not password:
password = self.groupsData.default_password
if password:
try:
return self._crypto.decrypt(password)
except ValueError as e:
logger.error("Couldn't decrypt password. {}".format(e.message))
except TypeError as e:
logger.error("Couldn't decode base64 password. {}".format(
e.message))
return None
def handle(self):
param = self.queue.get()
host, password = param
if isinstance(manager.gg, GameInit):
return True
else:
if (host, password) in Config.users:
manager.turn_on()
return True
else:
logger.error('not administrator')
return False
def load_feature_names(feat_names_readpath):
"""
Loads the set of feature names from a csv; one feature name per line
:param feat_names_readpath: (str)
Read path for feature names
:return: (set)
set of features
"""
try:
with open(feat_names_readpath, "r") as rfile:
return [feat_name.replace("\n", '') for feat_name in rfile]
except FileNotFoundError:
logger.error("Feature-names file not found.")
return []
def before_request():
logger.debug("request ip: %s, path: %s, args: %s, body: %s",
request.remote_addr, request.path, request.args,
request.data.decode('utf-8'))
if request.method == 'OPTIONS':
return SuccessResponse()()
login_urls = set(
[url.decode('utf-8') for url in redis.smembers(login_url_key)])
try:
if request.endpoint.split('.')[-1] in login_urls:
return check_request_token()
except AttributeError as err:
logger.error(err)
return ErrorResponse(ENDPOINT_NOT_EXIST).make()
def decorator(*args, **kwargs):
try:
if len(
AuthModel.query.filter_by(user_id=user_id,
project_id=project_id).all()) != 0:
return function(*args, **kwargs)
else:
logger.info(f'{false_json}')
return false_json
except Exception as e:
logger.error(f'{e}')
print(e)
return error_json, 500
def compare(cls, point1, point2):
if point1 in cls.points and point2 in cls.points:
pass
else:
logger.error('p1: {} p2: {}'.format(point1, point2))
raise Exception
if point1 == point2:
return 0
else:
if 'R' in (point1, point2):
return 'R' if 'S' in (point1, point2) else 'P'
else:
return 'S'
def function():
try:
toupdatahost.update(
dict(host_name=data.host_name,
host_addr=data.host_addr,
host_desc=data.host_desc,
user_id=user_id))
send_data = {'message': 'SUCCESS', 'code': 0}
logger.info(f'{send_data}')
return send_data
except Exception as e:
logger.error(f'{e}')
send_data = {'messaeg': 'Something went wrong', 'code': 1}
return send_data, 500
def function():
try:
new_host = HostModel(host_name=data.host_name,
host_addr=data.host_addr,
host_desc=data.host_desc,
user_id=user_id,
project_id=data.project_id)
new_host.save_to_db()
send_data = {'message': 'SUCCESS', 'code': 0}
logger.info(f'{send_data}')
return send_data
except Exception as e:
logger.error(f'{e}')
send_data = {'messaeg': 'Something went wrong', 'code': 1}
return send_data, 500
def global_game_init():
"""
init global game
:return:
"""
try:
info = request.data
dc = json.loads(info)
user, pwd = dc.get('user'), dc.get('password')
init_global_game_queue.put((user, pwd))
return run()
except AssertionError as e:
msg = 'TRY ME {}'.format(e)
logger.error(msg)
return error(msg)
def post(self):
data = parser.parse_args()
user_id = get_jwt_identity()['userid']
logger.info(f'{get_jwt_identity()}=={data}')
try:
# 多表联合查询ProjectModel与UserModel表，获取username及项目信息，通过创建时间倒序
all_results = db.session.query(
ProjectModel.project_name, ProjectModel.project_desc,
ProjectModel.project_v, ProjectModel.create_time,
ProjectModel.project_id, ProjectModel.updata_time,
ProjectModel.project_state, UserModel.username).filter(
and_(
ProjectModel.project_name.like("%" +
data.project_name + "%")
if data.project_name is not None else user_id != '',
ProjectModel.delete_sign == 0)).filter(
ProjectModel.user_id == UserModel.id).order_by(
ProjectModel.create_time.desc()).all()
project_list = []
for i in all_results:
if i.project_state == 0:
project_state = '进行中'
elif i.project_state == 1:
project_state = '项目暂停'
else:
project_state = '项目结束'
project_data = {
'project_name': i.project_name,
'project_id': i.project_id,
'project_v': i.project_v,
'project_desc': i.project_desc,
'user_name': i.username,
'create_time': str(i.create_time),
'updata_time': str(i.updata_time),
'project_state': project_state,
}
project_list.append(project_data)
send_data = {
'code': 0,
'message': "SUCCESS",
'project': project_list
}
logger.info(f'{send_data}')
return send_data
except Exception as e:
logger.error(f'{e}')
send_data = {'messaeg': 'Something went wrong', 'code': 1}
return send_data, 500
def handle(self):
param = self.queue.get()
p_id, coin_num = param
logger.info('<<<<< p_id: {} coin_num: {}'.format(p_id, coin_num))
try:
assert isinstance(manager.gg, GameInit)
assert p_id in manager.gg.player_info.keys()
assert type(coin_num) is int and coin_num >= 1
player = manager.gg.player_info[p_id]
table = player.area
table.game.bet(player, coin_num)
return True
except AssertionError as e:
logger.error('LimitedGuessBetHandler fail: {}'.format(e))
return False
def handle(self):
param = self.queue.get()
p_id, = param
logger.info('<<<<< p_id: {}'.format(p_id))
try:
assert isinstance(manager.gg, GameInit)
assert p_id in manager.gg.player_info.keys()
player = manager.gg.player_info[p_id]
table = player.area
table.game.ready(player)
return True
except AssertionError as e:
logger.error('LimitedGuessReadyHandler fail: {}'.format(e))
return False
def connectHost(self, hostId, frameless=False, screenIndex=None):
hostId = unicode(hostId) # sometimes hostId comes as QString
tabPage = self.tabWidget.createTab(hostId)
tabPage.reconnectionNeeded.connect(self.connectHost)
if frameless:
self.tabWidget.detachFrameless(tabPage, screenIndex)
try:
execCmd, opts = self.getCmd(tabPage, hostId)
except LookupError:
logger.error(u"Host {} not found.".format(hostId))
return
ProcessManager.start(hostId, tabPage, execCmd, opts)
return tabPage
def upgrade():
cryptoKey = Config().getPrivateKey()
connection = op.get_bind()
with connection.begin() as trans:
for host in connection.execute(hostsHelper.select().where(
hostsHelper.c.password.isnot(None))):
try:
passwordToUpdate = cryptoKey.encrypt(host.password)
connection.execute(hostsHelper.update().where(
hostsHelper.c.id == host.id).values(
password=passwordToUpdate))
except Exception as e:
logger.error(u"Error when trying to update host '{}'.".format(
host.name))
raise e
def connectHost(self, hostId, frameless=False, screenIndex=None):
hostId = unicode(hostId) # sometimes hostId comes as QString
tabPage = self.tabWidget.createTab(hostId)
tabPage.reconnectionNeeded.connect(self.connectHost)
if frameless:
self.tabWidget.detachFrameless(tabPage, screenIndex)
try:
execCmd, opts = self.getCmd(tabPage, hostId)
except LookupError:
logger.error(u"Host {} not found.".format(hostId))
return
ProcessManager.start(hostId, tabPage, execCmd, opts)
return tabPage
def upgrade():
cryptoKey = Config().getPrivateKey()
connection = op.get_bind()
with connection.begin() as trans:
for host in connection.execute(hostsHelper.select().where(hostsHelper.c.password.isnot(None))):
try:
passwordToUpdate = cryptoKey.encrypt(host.password)
connection.execute(
hostsHelper.update().where(
hostsHelper.c.id == host.id
).values(password=passwordToUpdate)
)
except Exception as e:
logger.error(u"Error when trying to update host '{}'.".format(host.name))
raise e
def handle(self):
param = self.queue.get()
p_id, card_points = param
logger.info('<<<<< p_id: {} card_points: {}'.format(p_id, card_points))
try:
assert isinstance(manager.gg, GameInit)
assert p_id in manager.gg.player_info.keys()
assert type(card_points) is list and len(card_points) == 1
player = manager.gg.player_info[p_id]
table = player.area
table.game.put(player, card_points[0])
return True
except AssertionError as e:
logger.error('LimitedGuessPutHandler fail: {}'.format(e))
return False
def getUrl(url):
logger.debug("Parsing source url for " + url)
if (url[-4:] in (".avi", ".mkv", ".mp4", ".mp3")) or (".googlevideo.com/"
in url):
logger.debug("Direct video URL, no need to use youtube-dl.")
return url
ydl = youtube_dl.YoutubeDL({
"logger": logger,
"noplaylist": True,
"ignoreerrors": True,
}) # Ignore errors in case of error in long playlists
with ydl: # Downloading youtub-dl infos. We just want to extract the info
result = ydl.extract_info(url, download=False)
if result is None:
logger.error(
"Result is none, returning none. Cancelling following function.")
return None
if "entries" in result: # Can be a playlist or a list of videos
video = result["entries"][0]
else:
video = result # Just a video
if "youtu" in url:
logger.debug(
"""CASTING: Youtube link detected. Extracting url in maximal quality."""
)
for fid in ("22", "18", "36", "17"):
for i in video["formats"]:
if i["format_id"] == fid:
logger.debug("CASTING: Playing highest video quality " +
i["format_note"] + "(" + fid + ").")
return i["url"]
elif "vimeo" in url:
logger.debug("Vimeo link detected, extracting url in maximal quality.")
return video["url"]
else:
logger.debug(
"""Video not from Youtube or Vimeo. Extracting url in maximal quality."""
)
return video["url"]
def acquire(self):
""" Acquire the lock, if possible. If the lock is in use, it check again
every `wait` seconds. It does this until it either gets the lock or
exceeds `timeout` number of seconds, in which case it throws
an exception.
"""
start_time = time.time()
while True:
try:
os.makedirs(self.lockpath,0777)
break
except OSError, e:
logger.warn(e)
if e.errno != errno.EEXIST:
logger.error(e)
raise
if (time.time() - start_time) >= self.timeout:
logger.error(e)
raise LockException("Timeout occured.")
time.sleep(self.delay)
def handle(self):
# add_player_queue 元素 (table_id, data)
# data: (player_id, )
param = self.queue.get()
table_id, data = param
player_id, = data
try:
logger.info(manager.gg)
logger.info(manager.gg.table_dc)
assert isinstance(manager.gg, GameInit)
assert table_id in manager.gg.table_dc.keys()
assert player_id in manager.gg.player_info.keys()
table = manager.gg.table_dc[table_id]
player = manager.gg.player_info[player_id]
if player not in table.players:
table.add_player(player)
return True
except AssertionError as e:
logger.error('AddPlayerHandler fail: {}'.format(e))
return False
def function():
try:
ProjectModel.query.filter_by(
project_id=data.project_id).update({
'project_name':
data.project_name,
'project_v':
data.project_v,
'project_desc':
data.project_desc,
'project_state':
data.project_state
})
send_data = {'message': 'SUCCESS', 'code': 0}
logger.info(f'{send_data}')
return send_data
except Exception as e:
logger.error(f"{e}")
send_data = {'message': 'FALSE', 'code': 1}
return send_data, 500
def findHostItemByName(self, name):
result = self.ui.hostsList.findItems(name, Qt.MatchExactly)
resultLen = len(result)
if resultLen != 1: # should be only one host
logger.error("Host not found. Got %d results" % resultLen)
return result[0]
