def on_message(self, message):
"""
处理 command 驱动的 web socket 命令
:param message:
:return:
"""
self.info("[%s]Received: " % id(self) + message)
try:
data = json.loads(message)
except:
self.error(traceback.format_exc())
self.send(command="bad-json", content=message)
raise gen.Return()
if data == {}:
# 表示是心跳
raise gen.Return()
try:
data = Schema({
"command": schema_utf8,
Optional("command_id", default=""): schema_utf8_empty,
"content": Or(str, str, list, dict),
}).validate(data)
except SchemaError:
self.send(command="bad-json-schema", content=message)
self.error("bad json: failed when parsing schema.")
raise gen.Return()
command_func = "cmd_" + data["command"].replace("-", "_").lower()
data.pop("command")
yield getattr(self, command_func)(**data)
def run_alert(self, alert):
es_query = alert["query"]["es_query"]
self.log.debug("es_query: %r" % es_query)
# Adjust time
start = alert["last_run"]
if not start:
start = time() - alert["interval"]
try:
for i, f in enumerate(es_query["query"]["bool"]["filter"]):
if f.has_key("range") and f["range"].has_key("@timestamp"):
time_filter = es_query["query"]["bool"]["filter"][i][
"range"]["@timestamp"]
time_filter["gte"] = int(start * 1000)
del time_filter["lte"]
except KeyError:
if es_query.has_key("query") and es_query["query"].has_key("bool") and\
es_query["query"]["bool"].has_key("filter"):
es_query["query"]["bool"]["filter"]["range"] = {
"@timestamp": {
"gte": int(start * 1000)
}
}
else:
raise gen.Return(
{"error": "Query does not support specific times."})
self.log.debug("Running query %s" %
json.dumps(alert["query"]["es_query"]))
req = HTTPRequest("http://" + self.passthrough_node + "/es/_search",
method="POST",
body=json.dumps(alert["query"]["es_query"]))
response = yield self.client.fetch(req, raise_error=False)
self.log.debug("response: %r" % response)
self.log.debug("body: %s" % response.body)
raise gen.Return(response)
def _get_checkpoint_notebooks(self, base):
# Get the model for the current notebook:
cm = self.contents_manager
model = yield gen.maybe_future(
cm.get(base, content=True, type='notebook'))
remote_nb = model['content']
# Get the model for the checkpoint notebook:
checkpoints = yield gen.maybe_future(cm.list_checkpoints(base))
if not checkpoints:
# No checkpoints, indicate unchanged:
self.log.info('No checkpoints for file: %r, %r', base, checkpoints)
raise gen.Return((remote_nb, remote_nb))
self.log.debug('Checkpoints: %r', checkpoints)
checkpoint = checkpoints[0]
if isinstance(cm.checkpoints, GenericCheckpointsMixin):
checkpoint_model = yield gen.maybe_future(
cm.checkpoints.get_notebook_checkpoint(checkpoint, base))
base_nb = checkpoint_model['content']
elif isinstance(cm.checkpoints, FileCheckpoints):
path = yield gen.maybe_future(
cm.checkpoints.checkpoint_path(checkpoint['id'], base))
base_nb = read_notebook(path, on_null='minimal')
else:
raise RuntimeError('Unknown checkpoint handler interface')
raise gen.Return((base_nb, remote_nb))
def tiny_url(long_url):
shorten_service_url = "http://dwz.cn/create.php"
my_link = {"url": long_url}
resp_obj = yield async_requests.session("POST",
shorten_service_url,
callback=None,
data=my_link)
resp = json.loads(resp_obj.body)
if resp['status'] == 0:
raise gen.Return(resp["tinyurl"])
else:
logging.warning('Shorten url=[%s] error, msg=[%s]' %
(long_url, resp["err_msg"]))
raise gen.Return(None)
def async_fetch(self, http_request=None):
"""
请求BL\DAS接口,拿到返回信息
"""
response = yield async_requests.fetch(http_request)
resp = RedirectedHTTPResponse(response)
raise gen.Return(resp)
def async_get_coordinates(city, district, address):
"""
通过百度地图的API接口，将某个地址转换成经纬度坐标
详情见：http://developer.baidu.com/map/webservice-placeapi.htm
中的“5.2 Place检索示例”小节
"""
if not city:
city = '杭州市' if isinstance(address, unicode) else safe_utf8('杭州市')
address = "%s %s %s" % (city, district, address)
url = r"http://api.map.baidu.com/geocoder/v2/"
params = {
"ak": _get_ak(),
"output": "json",
"address": safe_utf8(address),
}
response = yield async_requests.get(url, params=params)
lat = 0.0
lng = 0.0
if response.code == 200:
data = json.loads(response.body)
if data['status'] == 0:
result = data['result']
location = result.get("location")
if result['confidence'] >= 20:
lat = location.get("lat")
lng = location.get("lng")
# "lat" : 30.2592444615,
# "lng" : 120.2193754157,
raise gen.Return((lng, lat))
def get_user_by_id(user_id):
user = {
"user_id" : user_id,
"username" : "matrix",
"email" : "*****@*****.**",
"avatar" : "matrix.png"
}
raise gen.Return(User)
def redirect_delete(self,
url,
params=None,
redirect_header=True,
**kwargs):
response = yield async_requests.delete(url, params=params, **kwargs)
req = RedirectedHTTPResponse(response)
self.write_response(*req.parse_response(redirect_header))
raise gen.Return(req)
def get_response_list(self, request_list):
"""
异步，获取列表中的request请求
:param request_list: [tornado.httpclient.HTTPRequest, ...]
:return:
"""
# http_client = httpclient.AsyncHTTPClient()
response_list = yield [self.asyncHTTPClient.fetch(request) for request in request_list]
raise gen.Return(response_list)
def get_response_dict(self, request_dict):
"""
异步，获取字典中的request请求
:param request_dict: {"key": tornado.httpclient.HTTPRequest, ...}
:return:
"""
# http_client = httpclient.AsyncHTTPClient()
response_dict = yield {key: self.asyncHTTPClient.fetch(value) for key, value in list(request_dict.items())}
raise gen.Return(response_dict)
def get_user_info_from_token(self, simplified=False):
account_info = yield AsyncAccount.get_user_info_from_token(
self.get_token())
if not account_info:
raise gen.Return() # token 错误或者没给 token, 单纯的返回 None, 不报错。
if simplified:
account_info_collected = {
i: account_info[i]
for i in account_info if i in (
# 精简字段: 选出需要的字段
"id",
"name",
"tel")
}
account_info_collected["m_type"] = self.get_app_name()
raise gen.Return(account_info_collected)
else:
account_info["m_type"] = self.get_app_name()
raise gen.Return(account_info)
def process_timeline_data(self, user_id):
q_records = yield User.get_question_records_by_user_id(user_id)
a_records = yield User.get_answer_records_by_user_id(user_id)
c_record = yield User.get_oldest_comment_record_by_user_id(user_id)
print 'q_records: ', q_records
records = self.add_attrs(q_records, 'Question') + self.add_attrs(
a_records, 'Answer') + self.add_attrs(c_record, 'Comment')
sort_recs = self.sort_by_time(records)
print 'sort_recs: ', sort_recs
raise gen.Return(sort_recs)
def calculate_contribution(self, datetimes):
contribution = {}
for each in datetimes:
date_string = each.createAt.strftime("%Y-%m-%d")
date_datetime = time.strptime(date_string, '%Y-%m-%d')
date_timestamp = int(time.mktime(date_datetime))
if date_timestamp not in contribution:
contribution[date_timestamp] = 1
else:
contribution[date_timestamp] += 1
raise gen.Return(contribution)
def get_top_snippets_by_count(self, count):
top_snippets = yield Snippet.get_top_snippets_by_count(count)
for snippet in top_snippets:
snippet.author = yield User.get_user_by_id(snippet.author)
snippet.praises = yield Praise.get_praises_by_sid(snippet.sid)
snippet.comments = yield Comment.get_comments_by_sid(snippet.sid)
snippet.pictures = json.loads(snippet.pictures)
snippet.is_praised = False
for each in snippet.praises:
if each.user_id == self.current_user.user_id:
snippet.is_praised = True
break
raise gen.Return(top_snippets)
def get(self, user_id):
if not user_id.isdigit():
self.finish({
'result': False,
'msg': "参数错误"
})
raise gen.Return(None)
user = yield User.get_user_by_id(user_id)
timeline_recs = yield self.process_timeline_data(user_id)
self.render("user/profile.jade",
profile_user=user,
current_user=self.current_user,
records=timeline_recs)
def get_snippets_by_page(self, page):
snippets = yield Snippet.get_snippets((int(page) - 1) * 10, 10)
for snippet in snippets:
snippet.author = yield User.get_user_by_id(snippet.author)
snippet.praises = yield Praise.get_praises_by_sid(snippet.sid)
snippet.comments = yield Comment.get_comments_by_sid(snippet.sid)
snippet.pictures = json.loads(snippet.pictures)
snippet.is_praised = False
for each in snippet.praises:
if each.user_id == self.current_user.user_id:
snippet.is_praised = True
break
snippets_count = yield Snippet.get_snippet_count()
raise gen.Return((snippets, snippets_count))
def async_get_distance(from_lat, from_lng, to_lat, to_lng, region, origin_region, dest_region, mode='walking',
waypoints=None):
"""
调用百度API获取不同模式下的距离
百度API文档地址: http://developer.baidu.com/map/index.php?title=webapi/direction-api
:param from_lat:
:param from_lng:
:param to_lat:
:param to_lng:
:param region:
:param origin_region:
:param dest_region:
:param mode: 支持 walking(步行) / driving(驾车) / transit(公交)
:param waypoints: 选填 途经点集合，包括一个或多个用竖线字符"|"分隔的地址名称或经纬度。支持驾车、公交方案，最多支持5个途经点。
:return:
"""
url = "http://api.map.baidu.com/direction/v1"
params = {
"mode": mode,
"origin": "%f,%f" % (from_lat, from_lng),
"destination": "%f,%f" % (to_lat, to_lng),
"region": region,
"origin_region": origin_region,
"destination_region": dest_region,
"output": "json",
"ak": _get_ak()
}
if waypoints:
params["waypoints"] = waypoints
response = yield async_requests.get(url, params=params)
distance = 0
if response.code == 200:
response = json.loads(response.body)
if response['status'] == 0:
distance = response['result']['routes'][0]['distance']
# # 如果获取百度不成功的话
# if distance == 0:
# distance = 1.5 * Mercator.distance(from_lng, from_lat, to_lng, to_lat)
raise gen.Return(distance)
def get(self, sid):
snippet = yield Snippet.get_snippet_by_sid(sid)
if snippet == None:
self.finish("404 not found!")
raise gen.Return()
snippet.author = yield User.get_user_by_id(snippet.author)
snippet.praises = yield Praise.get_praises_by_sid(snippet.sid)
snippet.comments = yield Comment.get_comments_by_sid(snippet.sid)
snippet.pictures = json.loads(snippet.pictures)
snippet.is_praised = False
for each in snippet.praises:
if each.user_id == self.current_user.user_id:
snippet.is_praised = True
break
snippet.comments = sorted(snippet.comments, self.cpm_comments)
data = {"current_user": self.current_user, 'snippet': snippet}
self.render('snippet/snippet-comment.jade', **data)
def get_questions_detail(self, tab, page):
if tab == 'hotest':
questions = yield Question.get_hotest_questions(
page * self.item_in_page, self.item_in_page)
elif tab == "zero-answer":
questions = yield Question.get_0answer_questions(
page * self.item_in_page, self.item_in_page)
else:
questions = yield Question.get_newest_questions(
page * self.item_in_page, self.item_in_page)
for question in questions:
question.author = yield User.get_user_by_id(question.author)
question.votes = yield Vote.get_votes_count_by_qid(question.qid)
question.answers = yield Answer.get_answers_by_qid(question.qid)
question.tags = yield Tag.get_tags_by_qid(question.qid)
questions_count = yield Question.get_question_count()
raise gen.Return((questions, questions_count))
def async_geoconv(lng, lat, fro=3):
"""
将其他坐标系转换成百度坐标
:param lng: 经度
:param lat: 纬度
:param from:
1：GPS设备获取的角度坐标，wgs84坐标;
2：GPS获取的米制坐标、sogou地图所用坐标;
3：google地图、soso地图、aliyun地图、mapabc地图和amap地图所用坐标，国测局坐标;
4：3中列表地图坐标对应的米制坐标;
5：百度地图采用的经纬度坐标;
6：百度地图采用的米制坐标;
7：mapbar地图坐标;
8：51地图坐标
:return:
"""
url = "http://api.map.baidu.com/geoconv/v1/?"
params = {
"from": fro,
"to": 5,
"coords": ",".join([str(lng), str(lat)]),
"ak": _get_ak()
}
response = yield async_requests.get(url, params=params)
lng, lat = 0.0, 0.0
if response.code == 200:
data = json.loads(response.body)
if data['status'] == 0:
loc = data['result'][0]
lng = loc['x']
lat = loc['y']
raise gen.Return((lng, lat))
def async_get_reverse_location(lng, lat):
"""
文档:http://lbsyun.baidu.com/index.php?title=webapi/guide/webservice-geocoding
逆地理编码服务
:param lng: 经度
:param lat: 纬度
:return:
{
"adcode": "110105",
"city": "北京市",
"country": "中国",
"direction": "北",
"distance": "68",
"district": "朝阳区",
"province": "北京市",
"street": "花家地街",
"street_number": "19号",
"country_code": 0,
"address": "北京市朝阳区花家地街19号四强写字楼北79米",
"lng": 116.48088102568,
"lat": 39.989410050151
}
"""
url = r"http://api.map.baidu.com/geocoder/v2/"
params = {
"ak": _get_ak(),
"output": "json",
"location": "{lat},{lng}".format(lat=lat, lng=lng),
}
response = yield async_requests.get(url, params=params)
if response.code == 200:
response = json.loads(response.body)
address_component = response['result']['addressComponent']
address_component['address'] = response['result']['formatted_address'] + \
response['result']['sematic_description']
address_component['lng'], address_component['lat'] = response['result']['location']['lng'], \
response['result']['location']['lat']
else:
address_component = {}
raise gen.Return(address_component)
def redirect_put(self, url, json=None, redirect_header=True, **kwargs):
response = yield async_requests.put(url, json=json, **kwargs)
req = RedirectedHTTPResponse(response)
self.write_response(*req.parse_response(redirect_header))
raise gen.Return(req)
def get_key_item_datetimes(self):
user_id = self.get_argument('user_id')
datetimes = yield User.get_heat_datetimes_by_user_id(user_id)
raise gen.Return(datetimes)
def das_requests(self, http_request=None):
response = yield async_requests.fetch(http_request)
req = RedirectedHTTPResponse(response)
raise gen.Return(req)
def get_logical_nvme(self, ip):
func_name = self.get_func_name()
data = yield self.exec_command(ip, func_name)
raise gen.Return(data)
def redirect_request(self, http_request=None, redirect_header=True):
response = yield async_requests.fetch(http_request)
req = RedirectedHTTPResponse(response)
self.write_response(*req.parse_response(redirect_header))
raise gen.Return(req)
def das_get(self, url, params=None, **kwargs):
response = yield async_requests.get(url, params=params, **kwargs)
req = RedirectedHTTPResponse(response)
raise gen.Return(req)
def get_physical_flash(self, ip):
func_name = self.get_func_name()
future = self.exec_command(ip, func_name)
data = yield future
raise gen.Return(data)
def get_physical_disk(self, ip):
func_name = self.get_func_name()
data = yield self.exec_command(ip, func_name)
raise gen.Return(data)
