def process_finished(self, *args, **kwargs):
"""
结果已经返回,处理访问日志
:return:
"""
logger.debug('process_finished')
analytics = self.handler.analytics
analytics.status_code = self.handler.get_status()
now_ts = int(time.time() * 1000)
analytics.elapsed = now_ts - analytics.timestamp
client = self.handler.client
# 如果 client 为空表示未能通过鉴权
if client is not None:
analytics.client_name = client.config.get('name')
analytics.client_id = client.config.get('id')
endpoint = client.request.get('endpoint', {})
analytics.endpoint_name = endpoint.get('name')
analytics.endpoint_id = endpoint.get('id')
analytics.version = endpoint.get('version')
analytics.builtin_endpoint = endpoint.get('builtin_endpoint',
False)
analytics.forward_url = client.request.get('forward_url')
# 将统计数据暂时存储在 redis 中
RedisHelper.add_analytics_log(analytics.get_json())
logger.debug(analytics.get_json())
def process_finished(self, *args, **kwargs):
"""
结果已经返回,处理访问日志
:return:
"""
logger.debug('process_finished')
analytics = self.handler.analytics
analytics.status_code = self.handler.get_status()
now_ts = int(time.time() * 1000)
analytics.elapsed = now_ts - analytics.timestamp
client = self.handler.client
# 如果 client 为空表示未能通过鉴权
if client is not None:
analytics.client_name = client.config.get('name')
analytics.client_id = client.config.get('id')
endpoint = client.request.get('endpoint', {})
analytics.endpoint_name = endpoint.get('name')
analytics.endpoint_id = endpoint.get('id')
analytics.version = endpoint.get('version')
analytics.builtin_endpoint = endpoint.get('builtin_endpoint', False)
analytics.forward_url = client.request.get('forward_url')
# 将统计数据暂时存储在 redis 中
RedisHelper.add_analytics_log(analytics.get_json())
logger.debug(analytics.get_json())
def main():
# 启动 tornado 之前，先测试 redis 是否能正常工作
RedisHelper.ping_redis()
# 重新设置一下日志级别，默认情况下，tornado 是 info
# py2 下 options.logging 不能是 Unicode
options.logging = native_str(settings.LOGGING_LEVEL)
# parse_command_line 的时候将 logging 的根级别设置为 info
options.parse_command_line()
app = Application()
server = httpserver.HTTPServer(app, xheaders=True)
server.listen(options.port, options.host)
logger.info('api gateway server is running on %s:%s' % (options.host, options.port))
ioloop.IOLoop.instance().start()
def post(self, *args, **kwargs):
refresh_token = self.post_data['refresh_token']
token_info = RedisHelper.get_refresh_token_info(refresh_token)
access_token_ex = self.client.config.get('access_token_ex')
refresh_token_ex = self.client.config.get('refresh_token_ex')
if token_info:
RedisHelper.clear_token_info(refresh_token=refresh_token)
token_info = RedisHelper.set_token_info(
token_info, access_token_ex, refresh_token_ex)
if token_info is None:
self.error(msg='Save Access Token Error')
else:
self.success(token_info)
else:
self.fail(msg='Invalid or Expired Refresh Token')
def main():
# 启动 tornado 之前，先测试 redis 是否能正常工作
r = RedisHelper()
r.ping_redis()
# 重新设置一下日志级别，默认情况下，tornado 是 info
# options.logging 不能是 Unicode
options.logging = binary_type(settings.LOGGING_LEVEL)
# parse_command_line 的时候将 logging 的根级别设置为 info
tornado.options.parse_command_line()
http_server = tornado.httpserver.HTTPServer(app, xheaders=True)
http_server.listen(options.port, options.host)
logger.info('api gateway server is running on %s:%s' % (options.host, options.port))
tornado.ioloop.IOLoop.instance().start()
def process_request(self, *args, **kwargs):
logger.debug('process_request')
if 'X-Api-User-Json' in self.handler.request.headers:
del self.handler.request.headers['X-Api-User-Json']
endpoint = self.handler.client.request['endpoint']
require_login = endpoint.get('require_login', False)
if not require_login:
return
access_token = self.handler.get_query_argument('access_token', None)
token_info = RedisHelper.get_access_token_info(access_token)
if token_info is not None:
if token_info['access_key'] != self.handler.client.access_key:
raise AuthRequestException(
'This Access Token is Belongs to Another Client App')
logger.debug('允许访问')
try:
json_str = json.dumps(token_info['user_info'],
ensure_ascii=False)
# 用户信息使用 json 存储，并编码为 base64
self.handler.request.headers[
'X-Api-User-Json'] = base64.b64encode(
json_str.encode('utf8'))
except Exception, e:
logger.error('设置 X-Api-User-Json 失败')
logger.error(e.message)
logger.error(traceback.format_exc())
def process_request(self, *args, **kwargs):
logger.debug('process_request')
if 'X-Api-User-Json' in self.handler.request.headers:
del self.handler.request.headers['X-Api-User-Json']
endpoint = self.handler.client.request['endpoint']
require_login = endpoint.get('require_login', False)
if not require_login:
return
access_token = self.handler.get_query_argument('access_token', None)
token_info = RedisHelper.get_access_token_info(access_token)
if token_info is not None:
if token_info['access_key'] != self.handler.client.access_key:
raise AuthRequestException('This Access Token is Belongs to Another Client App')
logger.debug('允许访问')
try:
json_str = json.dumps(token_info['user_info'], ensure_ascii=False)
# 用户信息使用 json 存储，并编码为 base64
self.handler.request.headers['X-Api-User-Json'] = base64.b64encode(json_str.encode('utf8'))
except Exception, e:
logger.error('设置 X-Api-User-Json 失败')
logger.error(e.message)
logger.error(traceback.format_exc())
def post(self, *args, **kwargs):
refresh_token = self.post_data['refresh_token']
token_info = RedisHelper.get_refresh_token_info(refresh_token)
access_token_ex = self.client.config.get('access_token_ex')
refresh_token_ex = self.client.config.get('refresh_token_ex')
if token_info:
RedisHelper.clear_token_info(refresh_token=refresh_token)
token_info = RedisHelper.set_token_info(token_info,
access_token_ex,
refresh_token_ex)
if token_info is None:
self.error(msg='Save Access Token Error')
else:
self.success(token_info)
else:
self.fail(msg='Invalid or Expired Refresh Token')
def process_request(self, *args, **kwargs):
logger.debug('process_request')
if 'X-Api-User-Json' in self.handler.request.headers:
del self.handler.request.headers['X-Api-User-Json']
endpoint = self.handler.client.request['endpoint']
require_login = endpoint.get('require_login', False)
if not require_login:
return
# 默认从 headers 中获取
access_token = self.handler.request.headers.get('X-Api-Access-Token', None)
# 如果没有获取到,再从 url 中获取
if access_token is None:
access_token = self.handler.get_query_argument('access_token', None)
token_info = RedisHelper.get_access_token_info(access_token)
if token_info is not None:
if token_info['access_key'] != self.handler.client.access_key:
raise LoginAuthException('This Access Token Belongs to Another Client App')
logger.debug('允许访问')
try:
json_str = json.dumps(token_info['user_info'], ensure_ascii=False)
# 用户信息使用 json 存储，并编码为 base64
self.handler.request.headers['X-Api-User-Json'] = base64.b64encode(json_str.encode('utf8'))
except Exception as e:
logger.error('设置 X-Api-User-Json 失败')
logger.error(e)
logger.error(traceback.format_exc())
else:
logger.info('没有获取到用户信息，不允许访问')
# 获取用户信息失败
raise LoginAuthException('Expired or Invalid Access Token')
def main():
# 启动 tornado 之前，先测试 redis 是否能正常工作
r = RedisHelper()
r.ping_redis()
# 重新设置一下日志级别，默认情况下，tornado 是 info
# options.logging 不能是 Unicode
options.logging = binary_type(settings.LOGGING_LEVEL)
# parse_command_line 的时候将 logging 的根级别设置为 info
tornado.options.parse_command_line()
http_server = tornado.httpserver.HTTPServer(app, xheaders=True)
http_server.listen(options.port, options.host)
logger.info('api gateway server is running on %s:%s' %
(options.host, options.port))
tornado.ioloop.IOLoop.instance().start()
class UnionFind():
def __init__(self, conn_type):
self.redis_obj = RedisHelper(conn_type)
def get_redis_ttl(self):
return settings.REDIS_TTL
# now = datetime.now()
# midnight = (now + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
# return (midnight - now).seconds
def find_parent(self, group_id):
group_dict = self.redis_obj.get_value(group_id + "_link")
group_dict = eval(group_dict)
if group_dict.get('parent') != group_id:
group_dict['parent'] = self.find_parent(group_dict.get('parent'))
ttl = self.get_redis_ttl()
self.redis_obj.set_value(group_id + "_link", group_dict, ttl)
return group_dict.get('parent')
def merge(self, g1, g2):
p1 = self.find_parent(g1)
p2 = self.find_parent(g2)
g1_dict = self.redis_obj.get_value(p1 + "_link")
g2_dict = self.redis_obj.get_value(p2 + "_link")
g1_dict, g2_dict = eval(g1_dict), eval(g2_dict)
if g1_dict.get('rank') < g2_dict.get('rank'):
g1_dict['parent'] = p2
elif g2_dict.get('rank') < g1_dict.get('rank'):
g2_dict['parent'] = p1
else:
g2_dict['parent'] = p1
g2_dict['rank'] = g2_dict.get('rank') + 1
ttl = self.get_redis_ttl()
self.redis_obj.set_value(g1 + "_link", g1_dict, ttl)
self.redis_obj.set_value(g2 + "_link", g2_dict, ttl)
def post(self, *args, **kwargs):
logger.debug('AuthLoginHandler')
login_auth_url = self.client.config.get('login_auth_url')
logger.debug(login_auth_url)
if login_auth_url is None:
raise AuthRequestException(
'Missing Login Auth Url in Client Config')
# access_token 多少秒后过期
access_token_ex = self.client.config.get('access_token_ex')
refresh_token_ex = self.client.config.get('refresh_token_ex')
# 设置超时时间
async_http_connect_timeout = ASYNC_HTTP_CONNECT_TIMEOUT
async_http_request_timeout = ASYNC_HTTP_REQUEST_TIMEOUT
headers = {'Content-Type': 'application/json; charset=utf-8'}
try:
response = yield AsyncHTTPClient().fetch(
HTTPRequest(url=login_auth_url,
method=self.request.method,
body=self.request.body,
headers=headers,
connect_timeout=async_http_connect_timeout,
request_timeout=async_http_request_timeout))
except Exception as e:
logger.error(e)
logger.error(traceback.format_exc())
raise AuthRequestException('Fail to Request Login Auth Url')
json_data = json.loads(response.body)
if json_data['code'] == APIStatusCode.SUCCESS:
user_info = json_data['data']
token_info = {
'access_key': self.client.access_key,
'user_info': user_info
}
token_info = RedisHelper.set_token_info(token_info,
access_token_ex,
refresh_token_ex)
if token_info is None:
self.error(msg='Save Access Token Error')
else:
data = {
'access_token': token_info['access_token'],
'refresh_token': token_info['refresh_token'],
# access_token 过期时间
'expires_in': int(time.time()) + access_token_ex,
'user_info': user_info
}
self.success(data)
else:
self.fail(msg=json_data['msg'])
def __init__(self, threadnum, lock, config, queue, shutdown_event):
"""
Transporter class initializer
@param threadnum: Thread number, for debuggable log message. Used to
create a unique tag
@param lock: The thread lock object
@param config: The configuration dictionary
@param queue: Name of the queue. The `queue` is the queue name in
RabbitMQ and queue:`queue` for Redis list
@param shutdown_event: Event object
"""
threading.Thread.__init__(self)
self.threadnum = threadnum
self.lock = lock
self.config = config
self.queue = queue
self.shutdown_event = shutdown_event
self.redis_queue = "queue:%s" % self.queue
self.redis = RedisHelper(config["redis_host"], config["redis_port"])
self.mailer = EmailHelper(config["agent"], config["sender_email"],
config["receiver_email"])
self.tag = "%s-%s#%s" % (config["agent"], self.queue, self.threadnum)
self.exchange = config["rabbit_exchange"]
self.exchange_type = config["rabbit_exchange_type"]
self.routing_key = "%s.%s" % (self.exchange, self.queue)
self.publish_interval = float(config["publish_interval"])
self.message_header = {
"node": socket.gethostname(),
"queue": self.queue,
"tag": self.tag
}
self.amqp_url = ("amqp://%s:%s@%s:%s/%s?connection_attempts=3&"
"heartbeat_interval=600&socket_timeout=300" %
(config["rabbit_user"], config["rabbit_passwd"],
config["rabbit_host"], config["rabbit_port"],
urllib.quote(config["rabbit_vhost"], "")))
self.connection = None
self.channel = None
self.deliveries = []
self.acked = 0
self.nacked = 0
self.message_number = 0
self.publishing = False
self.stopping = False
self.closing = False
self.isRouter = config["router"]
def post(self, *args, **kwargs):
logger.debug('AuthLoginHandler')
login_auth_url = self.client.config.get('login_auth_url')
logger.debug(login_auth_url)
if login_auth_url is None:
raise AuthRequestException('Missing Login Auth Url in Client Config')
# access_token 多少秒后过期
access_token_ex = self.client.config.get('access_token_ex')
refresh_token_ex = self.client.config.get('refresh_token_ex')
# 设置超时时间
async_http_connect_timeout = ASYNC_HTTP_CONNECT_TIMEOUT
async_http_request_timeout = ASYNC_HTTP_REQUEST_TIMEOUT
headers = {'Content-Type': 'application/json; charset=utf-8'}
try:
response = yield AsyncHTTPClient().fetch(
HTTPRequest(url=login_auth_url,
method=self.request.method,
body=self.request.body,
headers=headers,
connect_timeout=async_http_connect_timeout,
request_timeout=async_http_request_timeout))
except Exception as e:
logger.error(e)
logger.error(traceback.format_exc())
raise AuthRequestException('Fail to Request Login Auth Url')
json_data = json_decode(response.body)
if json_data['code'] == APIStatusCode.SUCCESS:
user_info = json_data['data']
token_info = {
'access_key': self.client.access_key,
'user_info': user_info
}
token_info = RedisHelper.set_token_info(
token_info, access_token_ex, refresh_token_ex)
if token_info is None:
self.error(msg='Save Access Token Error')
else:
data = {
'access_token': token_info['access_token'],
'refresh_token': token_info['refresh_token'],
# access_token 过期时间
'expires_in': int(time.time()) + access_token_ex,
'user_info': user_info
}
self.success(data)
else:
self.fail(msg=json_data['msg'])
def get_client_config(self):
config_data = RedisHelper.get_client_config(self.access_key)
if config_data is None:
raise ClientBadConfigException('No Client Config')
else:
# 校验 config 数据是否正确
v = Validator(self.config_schema, allow_unknown=True)
if not v.validate(config_data):
logger.error(v.errors)
raise ClientBadConfigException('Bad Client Config')
logger.debug(config_data)
if not config_data.get('enable', True):
raise AuthRequestException('Disabled Client')
self.secret_key = config_data.get('secret_key')
# 添加内置的 endpoint
for t in settings.BUILTIN_ENDPOINTS:
endpoint = t['config']
k = '%s:%s' % (endpoint['name'], endpoint['version'])
config_data['endpoints'][k] = endpoint
self.config = config_data
def get_client_config(self):
config_data = RedisHelper.get_client_config(self.access_key)
if config_data is None:
raise ClientBadConfigException('No Client Config')
else:
# 校验 config 数据是否正确
v = Validator(self.config_schema, allow_unknown=True)
if not v.validate(config_data):
logger.error(v.errors)
raise ClientBadConfigException('Bad Client Config')
logger.debug(config_data)
if not config_data.get('enable', True):
raise AuthRequestException('Disabled Client')
self.secret_key = config_data.get('secret_key')
# 添加内置的 endpoint
for t in settings.BUILTIN_ENDPOINTS:
endpoint = t['config']
k = '%s:%s' % (endpoint['name'], endpoint['version'])
config_data['endpoints'][k] = endpoint
self.config = config_data
def save_to_redis(self):
r = RedisHelper.get_client()
access_log = json.dumps(self.get_json(save_to_redis=True))
r.rpush(ANALYTICS_LOG_REDIS_LIST_KEY, access_log)
def __init__(self, conn_type):
self.redis_obj = RedisHelper(conn_type)
def post(self, *args, **kwargs):
access_token = self.post_data['access_token']
RedisHelper.clear_token_info(access_token=access_token)
self.success(msg='Logout Success')
def post(self, *args, **kwargs):
access_token = self.post_data['access_token']
RedisHelper.clear_token_info(access_token=access_token)
self.success(msg='Logout Success')