def sendEmail(self,emailAdd,content,content_type = 0):
msgRoot = MIMEMultipart('related')
msgRoot['From'] = self.localVariable["__MAIL__"]
msgRoot['To'] = "".join(emailAdd)
subject = '验证码'
msgRoot['Subject'] = Header(subject, 'utf-8')
mail_msg = "<p>欢迎注册，您的验证码为： {code}</p>".format(code=content)
msgRoot.attach(MIMEText(mail_msg, 'html', 'utf-8'))
mailserver = "smtp.qq.com" # 账号 qq 邮箱
port = 465
try:
smtpObj = smtplib.SMTP_SSL(mailserver, port)
# smtpObj = smtplib.SMTP(mailserver, port)
sender = self.localVariable["__MAIL__"]
passwd = self.localVariable["__MAIL_PASSWORD__"]
smtpObj.login(sender, passwd)
# smtpObj.set_debuglevel(1)
# smtpObj.docmd("EHLO server")
# smtpObj.docmd("AUTH LOGIN")
smtpObj.sendmail(sender, emailAdd, msgRoot.as_string())
self.write(json.dumps({"code": content}))
weblog.info("邮件发送成功。", self._request_summary())
except smtplib.SMTPException as e:
weblog.info("Error: 无法发送邮件", self._request_summary(), e)
def get(self):
weblog.info("%s.", self._request_summary())
# return self.render('bug/bugtrackadd.html')
return self.render('bug/bugtrackadd.html',
message="",
users=get_user_list(self),
projects=get_project_list(self))
def get(self):
weblog.info("%s.", self._request_summary())
task = dict()
task['progress'] = 45
self.render("project/task.html", message="", projects=get_project_list(self),
users=get_user_list(self), task=task)
pass
def post(self, id):
weblog.info("%s.", self._request_summary())
username = self.get_argument("username", None)
passowrd = self.get_argument("passowrd", None)
useremail = self.get_argument("useremail", None)
userrole = self.get_argument("userrole")
msg = []
if username is None or username == "":
msg.append(msg_define.USERNAME_IS_EMPTY)
if passowrd is None or check_passord(passowrd) is None:
msg.append(msg_define.USERPASSWORD_INVALID)
if useremail is None or useremail == "":
msg.append(msg_define.USEREMAIL_IS_EMPTY)
elif check_email(useremail) is None:
msg.append(msg_define.USEREMAIL_INVALID)
if msg:
return self.render('admin/useredit.html', message=msg)
else:
try:
old_user = get_user_by_id(self, id)
old_user.username = username
old_user.password = passowrd
old_user.email = useremail
old_user.userrole = userrole
self.mysqldb().commit()
return self.redirect('/user/list')
except:
weblog.exception("Edit user error!")
self.mysqldb().rollback()
return self.render('admin/useredit.html', message=msg)
def post(self, id):
weblog.info("%s.", self._request_summary())
Projectname = self.get_argument("Projectname", None)
passowrd = self.get_argument("passowrd", None)
Projectemail = self.get_argument("Projectemail", None)
Projectrole = self.get_argument("Projectrole")
msg = []
if Projectname is None or Projectname == "":
msg.append(msg_define.ProjectNAME_IS_EMPTY)
if passowrd is None or check_passord(passowrd) is None:
msg.append(msg_define.ProjectPASSWORD_INVALID)
if Projectemail is None or Projectemail == "":
msg.append(msg_define.ProjectEMAIL_IS_EMPTY)
elif check_email(Projectemail) is None:
msg.append(msg_define.ProjectEMAIL_INVALID)
if msg:
return self.render('admin/Projectedit.html', message=msg)
else:
try:
old_Project = get_project_by_id(self, id)
old_Project.Projectname = Projectname
old_Project.password = passowrd
old_Project.email = Projectemail
old_Project.Projectrole = Projectrole
self.mysqldb().commit()
return self.redirect('/Project/list')
except:
weblog.exception("Edit Project error!")
self.mysqldb().rollback()
return self.render('admin/Projectedit.html', message=msg)
async def __save_secret(self, secret):
key = 'vps-' + self.__remote_ip()
redis = await aioredis.create_redis(self.redis_addr,
timeout=REDIS_TIMEOUT)
access_log.info('adding: ({}, {})'.format(key, secret))
await redis.set(key, secret, expire=30) # register secret
redis.close()
def get(self, *args, **kwargs):
weblog.info("%s. get extrabase.html", self._request_summary())
topic_id = self.get_argument("topic_id", "0")
topic = get_topic(self, topic_id)
self.render("extra/topic.html",
topic=topic,
user=get_user_nickname(self)) # templates/
def get(self, *args, **kwargs):
weblog.info("%s. get extrabase.html", self._request_summary())
current_page = int(self.get_argument("current_page", "1"))
topics, total_page = yield self.get_data(current_page)
self.render("extrabase.html",
topics=topics,
user=get_user_nickname(self)) # templates/
def post(self):
weblog.info("%s.", self._request_summary())
cur_login_name = self.get_secure_cookie('user_account')
# 用户是否存在
cur_user_id = self.mysqldb().query(
TblAccount.id, TblAccount.userstate).filter(
TblAccount.username == cur_login_name).first()
project_name = self.get_argument("project_name", None)
top_project_id = self.get_argument("top_project_id", 0)
project_describe = self.get_argument("project_describe", None)
peers = self.get_arguments("peer")
msg = ''
try:
new_project = TblProject()
new_project.project_name = project_name
new_project.progress = 0
new_project.describe = project_describe
new_project.status = msg_define.USER_NORMAL
new_project.top_project_id = top_project_id
new_project.created_by = cur_user_id.id
self.mysqldb().add(new_project)
self.mysqldb().commit()
# 添加项目关联人员
self.relation_project_user(project_name, peers)
# return self.render('project/projectlist.html', projects=get_project_list(self),
# project_map=get_project_map(self))
return self.redirect('/project/list')
except:
weblog.exception("Add new Project error!")
self.mysqldb().rollback()
return self.render('project/projectadd.html',
message="",
users=get_user_list(self),
projects=get_project_list(self))
def get(self):
weblog.info("%s.", self._request_summary())
projects = get_project_list(self)
project_map = get_project_map(self)
return self.render('project/projectlist.html',
projects=projects,
project_map=project_map)
def post(self, code):
email = self.get_argument('email')
if not is_valid_email(email):
error = 'Please enter a valid email address'
self.render(template('auth/resend_verification.html'), error=error)
yield send_verification_email(email)
access_log.info('Sent email verification to %s' % email)
self.render(template('auth/verification_sent.html'), error='')
def log_request(self, handler):
super(DebuggingApplication, self).log_request(handler)
size = self.connection_pool._queue.qsize()
access_log.info(
"Stats for Server on port '{}': Active Server connections: {}, DB Connections in pool: {}, DB Pool size: {}"
.format(tornado.options.options.port,
len(self._server._connections), size,
self.connection_pool._con_count))
def get(self):
weblog.info("%s , TableTestHandler.", self._request_summary())
data = {"name": "GET", "value": "v12", "type": 1}
datas = []
datas.append(data)
datas.append(data)
# self.render('tabletest.html',data=datas)
self.render('project/multiselect.html')
def request(self):
handle = getattr(requests, self.dispatch())
try:
result = handle("%s:%s%s" % (self.host, self.port, self.url), params=self.params, data=self.data)
result = json.loads(result.text)
except Exception, e:
log.info("request the url: {} failed for this reason {}".format(self.url, e))
return False, None
def get(self, bid):
weblog.info("%s.", self._request_summary())
# return self.render('bug/bugtracklist.html', bugtracks=get_bugtrack_list(self, belongid, compid))
return self.render('bug/bugtrackedit.html',
message="",
users=get_user_list(self),
projects=get_project_list(self),
bug=get_bugtrack_by_id(self, bid))
def get(self, *args, **kwargs):
weblog.info("%s.", self._request_summary())
data = yield self.get_data()
# print(data)
self.render("extra/setting.html",
user=get_user_nickname(self),
data=data)
pass
async def __load_secret(self):
key = 'vps-' + self.__remote_ip()
redis = await aioredis.create_redis(self.redis_addr,
timeout=REDIS_TIMEOUT)
secret = await redis.get(key)
redis.close()
access_log.info('retrieving: ({}, {})'.format(key, secret))
return secret
def update_client(self, connection, msg, authorization, client):
client.update_configuration(clean_session=msg.clean_session,
keep_alive=msg.keep_alive)
client.update_connection(connection)
client.update_authorization(authorization)
access_log.info("[uid: %s] Reconfigured client upon "
"reconnection." % client.uid)
def open(self):
key = self.get_query_argument('key', '')
if key != app_key:
access_log.warn('Access denied on %s.' % self.request.remote_ip)
self.write_message("Access denied")
self.close()
else:
self.write_message("Access granted")
access_log.info('Access allowed on %s.' % self.request.remote_ip)
def prepare(self):
#根据cookies生成用户信息
access_log.info('>>>>>>>>>>>>>>>>>>>>>>>')
username = self.get_cookie('username','')
uinfo = db.con.user.find_one({'username':username})
# print username
self.uinfo = uinfo
if username:
pass
def delete(self, uid):
weblog.info("uid={}".format(uid))
try:
self.mysqldb().query(TblAccount).filter(TblAccount.id == uid).delete()
self.mysqldb().commit()
return self.write(json_dumps({"error_code": 0, "msg": u"删除成功"}))
except Exception as e:
weblog.error("{}".format(e))
return self.write(json_dumps({"error_code": 1, "msg": u"删除失败。{}".format(e)}))
def get(self):
print(datetime.now(), "start")
# self.render("testclick.html")
weblog.info("%s.", self._request_summary())
weblog.info("get home")
result = yield self.doing()
print(result)
# self.render("admin/homepage.html")
self.write(self.render_template('admin/homepage.html'))
def prepare(self):
self._start_time = time.time()
arguments = self.request.arguments
if self.current_user is None:
user = "******"
else:
user = self.current_user["email"]
access_log.info("uri: %s, method: %s, user: %s, arguments: %s, ip: %s" % (
self.request.uri, self.request.method, user,
arguments, self.request.remote_ip))
def post(self, *args, **kwargs):
weblog.info("%s. post add a topic", self._request_summary())
title = self.get_argument("title", None)
content = self.get_argument("content", None)
category = int(self.get_argument("category", "0"))
if title is None or content is None:
return self.write(json_dumps({"msg": u"标题或内容不能为空"}))
yield self.add_topic(title, content, category)
def get(self):
current_page = int(self.get_argument("current_page", FIRST_PAGE))
# users = get_user_list(self)
users, total_page = get_user_pagination(self, current_page)
weblog.info("{2}. user list total page:{0},current page:{1}".format(
total_page, current_page, self._request_summary()))
return self.render('admin/usermanage.html',
users=users,
current_page=current_page,
total_page=total_page)
def get(self):
belongid = self.get_argument("belongid", None)
compid = self.get_argument("compid", None)
blevel = self.get_argument("blevel", None)
weblog.info("%s.", self._request_summary())
return self.render('bug/bugtracklist.html',
bugtracks=get_bugtrack_list(self, belongid, compid,
blevel),
users=get_user_list(self),
projects=get_project_list(self))
def put(self):
weblog.info("%s. put edit a topic", self._request_summary())
title = self.get_argument("title", None)
content = self.get_argument("content", None)
category = int(self.get_argument("category", "0"))
topic_id = self.get_argument("topic_id", "0")
if title is None or content is None:
return self.write(json_dumps({"msg": u"标题或内容不能为空"}))
yield self.edit_topic(title, content, category, topic_id)
def get(self, cid):
weblog.info("%s.", self._request_summary())
comp_mt = self.mysqldb().query(TblComponentMaintenance).filter_by(comp_id=cid).first()
comp_mt.comp_status = -1
try:
self.mysqldb().commit()
except Exception as e:
weblog.error("delete component maintenance id={} error. {}".format(cid, e))
self.mysqldb().rollback()
return self.render('bug/compmtlist.html', bugs=get_compmt_list(self),
users=get_user_list(self), projects=get_project_list(self))
def get(self, pjid):
weblog.info("%s. pjid=%d", self._request_summary(), pjid)
project = self.mysqldb().query(TblProject).filter_by(
project_id=pjid).first() # u"必须查询对象"
# print(project)
try:
project.status = 1
self.mysqldb().commit()
except Exception as e:
weblog.error("delete project id={} fail:{}.".format(pjid, e))
self.mysqldb().rollback()
return self.redirect('/project/list')
def open(self):
# returns the value of the argument with the given name from the request
# query string (the url)
# it's the key that will be compared with the one saved
key = self.get_query_argument('key', '')
if key != app_key:
access_log.warn('Access denied on %s.' % self.request.remote_ip)
self.write_message("Access denied")
self.close()
else:
self.write_message("Access granted")
access_log.info('Access allowed on %s.' % self.request.remote_ip)
def get(self, bid):
weblog.info("%s.", self._request_summary())
bug_track = self.mysqldb().query(TblBugTrack).filter_by(
comp_id=bid).first()
bug_track.bug_project_id = -1
try:
self.mysqldb().commit()
except Exception as e:
weblog.error("delete bug track id={} error. {}".format(bid, e))
self.mysqldb().rollback()
return self.render('bug/bugtracklist.html',
bugtracks=get_bugtrack_list(self))
def post(self):
destr = self.get_argument("destr", "")
bstr = destr.encode('utf-8')
# print(bstr)
error_code = 0
weblog.info("destr:{}".format(bstr))
try:
result = self_decode(bstr)
except Exception as e:
weblog.error("{}".format(e))
result = u"解密失败"
error_code = 1
return self.write(json_dumps({"decode": result, "error_code": error_code}))
def get(self, *args, **kwargs):
"""
get_user_nickname and self.current_user
:param args:
:param kwargs:
:return:
"""
weblog.info("%s. get topicadmin.html", self._request_summary())
current_page = int(self.get_argument("current_page", "1"))
topics, total_page = yield self.get_data(current_page)
self.render("extra/topicadmin.html",
topics=topics,
user=get_user_nickname(self)) # templates/
def _make_proxy_request(self, request_data):
timeout = float(request_data.get("timeout", DEFAULT_TIMEOUT))
validate_cert = bool(request_data.get("validate_cert") or True)
max_redirects = request_data.get("max_http_redirects") or 0
follow_redirects = max_redirects > 0 # 0 means do not follow redirects
url = request_data.get("url")
params = request_data.get("data")
post_type = request_data.get("post_type")
if params and post_type is None:
url = "%s?%s" % (url, urlencode(params))
logger.info("[%s]agent request url: %s", self.id, url)
proxy_request = HTTPRequest(
url, validate_cert=validate_cert,
headers=self._get_proxy_request_headers(request_data),
method=request_data.get("method", "GET"),
allow_nonstandard_methods=True,
connect_timeout=timeout,
request_timeout=timeout,
streaming_callback=self._streaming_callback,
header_callback=self._header_callback,
follow_redirects=follow_redirects,
max_redirects=max_redirects,
prepare_curl_callback=self.prepare_curl_callback,
)
role_name = request_data.get("role")
if role_name:
InterfaceRoleManager.set_curl_interface_role(
proxy_request, role_name,
)
keystone_auth_info = request_data.get("keystone")
if keystone_auth_info:
logger.warning(
"[%s]agent request required keystone token",
)
auth_headers = yield self._get_keystone_auth_headers(
keystone_auth_info, validate_cert=validate_cert,
)
if not auth_headers:
raise gen.Return()
proxy_request.headers.update(auth_headers)
body = self._get_request_body(request_data)
if body:
proxy_request.body = body
raise gen.Return(proxy_request)
def post(self):
weblog.info("%s.", self._request_summary())
bug_component = int(self.get_argument("bug_component", '-1'))
component_belong = int(self.get_argument("component_belong", '-1'))
bug_level = int(self.get_argument("bug_level", '-1'))
bug_component = None if bug_component < 0 else bug_component
component_belong = None if component_belong < 0 else component_belong
bug_level = None if bug_level < 0 else bug_level
bugtracks = get_bugtrack_list(self, component_belong, bug_component,
bug_level)
weblog.info("%s. %d %d %d", self._request_summary(), bug_component,
component_belong, bug_level)
return self.write(json.dumps(bugtracks))
def get(self, code):
try:
email = check_signature(code, 86400) # 24 hours
except:
error = 'Signature %s did not authenticate.' % code
access_log.error(error)
self.render(template('auth/signature_invalid.html'), error='')
email = str(email)[2:-1]
yield activate_user(self.db, email)
access_log.info('%s email verified, \
user account activated and logged in.' % email)
self.set_current_user(email)
self.redirect('/')
def prepare(self):
try:
user_agent = self.request.headers['User-Agent']
except KeyError:
user_agent = '-'
access_log.info('request log -> %s|%s|%s|%s' % (
self.request.remote_ip,
self.request.method,
self.request.uri,
user_agent)
)
if not self.settings['admin'] and self.request.method == 'GET' and self.request.uri != '/welcome':
self.redirect('/welcome')
def create_client(self, connection, msg, authorization):
client_persistence = self.persistence.get_for_client(msg.client_uid)
client = MQTTClient(
server=self,
connection=connection,
authorization=authorization,
uid=msg.client_uid,
clean_session=msg.clean_session,
keep_alive=msg.keep_alive,
persistence=client_persistence,
)
# verbosity... testing
type = "plain-client"
if client.is_broker():
type = "broker"
access_log.info("[uid: %s] new session created (client type: %s)" % (client.uid, type))
return client
def remove_client(self, client):
"""
Removes a client from the know clients list. It's safe to call this
method without checking if the client is already known.
:param MQTTClient client: A :class:`broker.client.MQTTClient` instance;
.. caution::
It won't force client disconnection during the process, which can
result in a lingering client in the Tornado loop.
"""
assert isinstance(client, MQTTClient)
self.persistence.remove_client_data(client.uid)
if client.uid in self.clients:
del self.clients[client.uid]
access_log.info("[uid: %s] session cleaned" % client.uid)
def post(self):
email = self.get_argument('email')
password = self.get_argument('password')
if not is_valid_email(email):
error = 'Please enter a valid email address'
self.render(template('auth/register.html'), error=error)
yield send_verification_email(email)
rdb = yield add_user(self.db, email, password)
if rdb.get('first_error') is None:
access_log.info('%s registered and \
verification email sent.' % email)
self.render(template('auth/verify_email.html'))
else:
access_log.error(rdb.get('first_error'))
error = 'An error occurred adding user to the database.'
self.render(template('auth/register.html'), error=error)
def load_app(port, root):
settings = {
"socket_io_port": port,
"static_path": path.join(root, "client"),
"template_path": path.join(root, "client"),
"debug" : True,
"xsrf_cookies": False,
}
routers = load_routers()
application = tornado.web.Application(
routers,
**settings
)
access_log.info("Starting server")
application.listen(port)
tornado.ioloop.IOLoop.instance().start()
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_type == toro.Timeout:
access_log.debug("[uid: %s] connection timeout" % self.client_uid)
elif exc_type == StreamClosedError:
access_log.warning("[uid: %s] stream closed unexpectedly" % self.client_uid)
elif exc_type == ConnectError:
self.stream.close()
access_log.info("[uid: %s] connection refused: %s" % (self.client_uid, exc_val.message))
elif exc_type == Exception:
access_log.exception("[uid: %s] error handling stream" % self.client_uid, exc_info=True)
if exc_val is not None:
if self.client is not None:
self.client.disconnect()
return True # suppress the raised exception
def post(self):
old_pass = self.get_argument('old_password')
new_pass = self.get_argument('new_password')
new_pass_verify = self.get_argument('new_password1')
email = self.get_current_user()
if new_pass != new_pass_verify:
error = 'New passwords must match'
self.render(template('auth/change_password.html'), error=error)
auth = yield verify_user(self.db, email, old_pass)
if auth:
change_password(self.db, email, new_pass)
yield send_password_changed_email(email)
self.redirect('/')
else:
access_log.info('Change password requested by %s, \
but wrong old password' % email)
error = 'Wrong password, try again?'
self.render(template('auth/change_password.html'), error=error)
def _fetch_proxy_request(self, proxy_request):
self.in_request_headers = False
try:
response = yield self.http_client.fetch(proxy_request)
except HTTPError as err:
self.set_status(err.code, err.message)
raise gen.Return()
except Exception as err:
self.set_status(503, str(err))
raise gen.Return()
if response.error:
self.set_status(response.code, str(response.error))
else:
self.set_status(response.code, response.reason)
logger.info(
"[%s]agent response status: %s, reason: %s",
self.id, response.code, response.reason,
)
def _get_keystone_auth_headers(self, auth_info, validate_cert=True):
try:
response = yield self.http_client.fetch(
auth_info.get("auth_url"), method="POST",
headers={"Content-Type": "application/json"},
validate_cert=validate_cert,
body=json.dumps({
"auth": {
"passwordCredentials": {
"username": auth_info.get("user_name"),
"password": auth_info.get("password"),
},
"tenantName": auth_info.get("tenant_name"),
}
})
)
except Exception as err:
logger.info(err)
self.set_status(503, "keystone auth error")
raise gen.Return()
if response.error or response.code != 200:
logger.info("keystone auth error")
self.set_status(407, "keystone auth error")
raise gen.Return()
auth_info = json.loads(response.body.decode("utf-8"))
try:
raise gen.Return({
"X-AUTH-TOKEN": auth_info["access"]["token"]["id"],
})
except KeyError:
logger.info("keystone auth failed")
self.set_status(407, "keystone auth failed")
raise gen.Return()
def prepare(self):
try:
user_agent = self.request.headers['User-Agent']
except KeyError:
user_agent = '-'
access_log.info('request log -> %s|%s|%s|%s' % (
self.request.remote_ip,
self.request.method,
self.request.uri,
user_agent)
)
session_id = self.get_cookie('s')
if not session_id:
session_id = str(uuid.uuid4())
# Set session
self.set_cookie(name="s", value=session_id)
self.current_user = self.get_current_user()
if not self.current_user:
self.session.record_visitor(session_id, 'Anonymous', self.request.remote_ip, user_agent)
session_check = self.session.check_visitor(session_id)
if session_check['requests'] > 5:
self.set_status(403)
self.finish('Access Denied')
return
# if the site is just created without a admin user
if not self.settings['admin']:
if self.request.uri.startswith('/api'):
self.set_status(403)
self.finish('login first')
elif self.request.uri != '/welcome':
self.redirect('/welcome')
def forward_subscription(self, topic, granted_qos, sender_uid):
"""
:param topic_qos: A list of topic-qos-pairs to forward.
:param sender_uid: sender's ID, don't send subscription back there!
:return: FIXME (not specified yet)
"""
"""
if not (topic, granted_qos) in self.hacked_topic_list:
access_log.info("[.....] forwarding subscription from: \"%s\"" % sender_uid)
# TODO rebuild package with subscription intents; think about qos
msg = Subscribe()
# recipients = [c for c in self.clients if c.receive_subscriptions and not c.uid == sender_uid]
recipients = filter(lambda client: client.receive_subscriptions and not client.uid == sender_uid,
self.clients.values())
for client in recipients:
client.send_packet(msg)
# TODO send it to "uplink" message broker if it did not come from there
if sender_uid: # XXX uplink is not a client, assume sender_uid would be None
pass
# Uplink.send_packet(msg)
"""
access_log.info('[.....] forwarding subscription from: "%s"' % sender_uid)
# TODO rebuild package with subscription intents; think about qos
msg = Subscribe()
# recipients = [c for c in self.clients if c.receive_subscriptions and not c.uid == sender_uid]
recipients = filter(
lambda client: client.receive_subscriptions and not client.uid == sender_uid, self.clients.values()
)
for client in recipients:
client.send_packet(msg)
# TODO send it to "uplink" message broker if it did not come from there
if sender_uid: # XXX uplink is not a client, assume sender_uid would be None
pass
def post(self):
email = self.get_argument("email")
password = self.get_argument("password")
auth = yield verify_user(self.db, email, password)
if auth:
activated = yield is_activated(self.db, email)
if activated:
access_log.info('%s logged in.' % email)
self.set_current_user(email)
self.redirect(self.get_argument("next", u"/"))
else:
access_log.info('%s attempted login, \
but email not verified, \
re-sending verification email.' % email)
yield send_verification_email(email)
self.render(template("auth/verify_email.html"))
else:
access_log.info('%s failed login.' % email)
self.render(template("auth/login.html"),
error="Login incorrect",
user=self.get_current_user())
def on_finish(self):
cost_time = time.time() - self._start_time
access_log.info("cost time: %0.3f" % (cost_time, ))
def setup_loggers ():
"""
set up tornado loggers with custom format
logger has 5 severity levels :
D - DEBUG (lowest)
I - INFO
W - WARNING
E - ERROR
C - CRITICAL (highest)
"""
# config logger output in console
# logging.basicConfig( level = logging.DEBUG,
# format = "%(name)s - %(funcName)s - %(levelname)s : %(message)s" )
# Create a Formatter for formatting the log messages
# log_formatter = logging.Formatter('%(name)s -- %(funcName)s - %(levelname)s - %(message)s')
openscraper_log_format = '%(color)s::: %(levelname)s %(name)s %(asctime)s ::: %(module)s:%(lineno)d -in- %(funcName)s() :::%(end_color)s \
%(message)s'
# datefmt='%y%m%d %H:%M:%S'
# style='%'
# color=True
# colors={40: 1, 10: 4, 20: 2, 30: 3}
"""
default tornado format for logging :
fmt='%(color)s[%(levelname)1.1s %(asctime)s %(module)s:%(lineno)d]%(end_color)s %(message)s'
datefmt='%y%m%d %H:%M:%S'
style='%'
color=True
colors={40: 1, 10: 4, 20: 2, 30: 3}
))
"""
# log_formatter = logging.Formatter( fmt=openscraper_log_format )
tornado_log_formatter = LogFormatter(fmt=openscraper_log_format, color=True)
enable_pretty_logging()
### Logger as self var
# create the Logger
# dictConfig(logging_config)
# self.log = logging.getLogger(__name__)
# self.logger = logging.getLogger()
# self.access_log = logging.getLogger("tornado.access")
# self.app_log = logging.getLogger("tornado.application")
# self.gen_log = logging.getLogger("tornado.general")
### Get root logger
root_logger = logging.getLogger()
# print root_logger.__dict__
### Format root_logger stream
# parent_logger = app_log.parent
# print parent_logger.__dict__
# root_stream_handler = parent_logger.handlers
# root_stream_handler[0].setFormatter(tornado_log_formatter)
root_logger.handlers[0].setFormatter(tornado_log_formatter)
# streamHandler = logging.StreamHandler() # stream=sys.stdout
# streamHandler.setFormatter(tornado_log_formatter)
# self.gen_log.addHandler(streamHandler)
# self.app_log.addHandler(streamHandler)
# self.access_log.addHandler(streamHandler)
# self.log.setLevel(logging.DEBUG)
# Create the Handlers for logging data to log files
gen_log_handler = logging.FileHandler('logs/openscraper_general.log')
gen_log_handler.setLevel(logging.WARNING)
access_log_handler = logging.FileHandler('logs/openscraper_access.log')
access_log_handler.setLevel(logging.WARNING)
app_log_handler = logging.FileHandler('logs/openscraper_app.log')
app_log_handler.setLevel(logging.WARNING)
# Add the Formatter to the Handler
gen_log_handler.setFormatter(tornado_log_formatter)
access_log_handler.setFormatter(tornado_log_formatter)
app_log_handler.setFormatter(tornado_log_formatter)
# Add the Handler to the Logger
gen_log.addHandler(gen_log_handler)
access_log.addHandler(access_log_handler)
app_log.addHandler(app_log_handler)
# test loggers
print()
app_log.info('>>> this is app_log ')
gen_log.info('>>> this is gen_log ')
access_log.info('>>> this is access_log ')
print()
def log_request(self, handler):
request_time = 1000.0 * handler.request.request_time()
access_log.info("%d %s %.2fms", handler.get_status(),
handler._request_summary(), request_time)
def recreate_sessions(self, uids):
access_log.info("recreating %s sessions" % len(uids))
for uid in uids:
if uid not in self.clients:
self.add_client(self.recreate_client(str(uid)))
def get(self):
user = self.get_current_user()
access_log.info('%s logged out.' % user)
self.clear_cookie("user")
self.redirect(self.get_argument("next", "/"))
allows_methods = ["get", "post"]
def __init__(self, url, host="", method="get", params=None, data=None):
self.host = host or DEFAULT_HOST
self.port = host or DEFAULT_PORT
self.url = url
self.method = method
self.params = params
self.data = data
# enable log
enable_pretty_logging()
def dispatch(self):
method = self.method.lower()
if method not in self.allows_methods:
raise TypeError("Method must be get or post")
return method
def request(self):
handle = getattr(requests, self.dispatch())
try:
result = handle("%s:%s%s" % (self.host, self.port, self.url), params=self.params, data=self.data)
result = json.loads(result.text)
except Exception, e:
log.info("request the url: {} failed for this reason {}".format(self.url, e))
return False, None
else:
log.info(json.dumps(result, indent=4, ensure_ascii=False))
return True, result
def prepare(self):
"""Log access."""
request_time = 1000.0 * self.request.request_time()
access_log.info(
"%d %s %.2fms", self.get_status(),
self._request_summary(), request_time)
def on_close(self):
access_log.info('Client %s disconnected.' % self.request.remote_ip)
def update_client(self, connection, msg, authorization, client):
client.update_configuration(clean_session=msg.clean_session, keep_alive=msg.keep_alive)
client.update_connection(connection)
client.update_authorization(authorization)
access_log.info("[uid: %s] Reconfigured client upon " "reconnection." % client.uid)
class AuthLoginHandler(BaseHandler, tornado.auth.GoogleMixin):
@tornado.web.asynchronous
@tornado.gen.coroutine
def get(self):
if self.get_argument("openid.mode", None):
user = yield self.get_authenticated_user()
# Save the user with e.g. set_secure_cookie()
self.set_secure_cookie("dmonitoring_user",
tornado.escape.json_encode(user),
expires_days=7)
self.redirect(self.get_argument("next", "/"))
else:
yield self.authenticate_redirect()
class AuthLogoutHandler(BaseHandler):
def get(self):
self.clear_cookie("dmonitoring_user")
self.redirect(self.get_argument("next", "/"))
if __name__ == "__main__":
set_options()
access_log.info("Server is starting on port %s" % options.port)
app = Application()
app.listen(options.port, xheaders=True)
tornado.ioloop.IOLoop.instance().start()
"handlers": ["file"],
"level": "DEBUG"
}
}
})
if options.interface_roles:
InterfaceRoleManager.setup_roles(dict(
i.split(":", 1)
for i in options.interface_roles.split(",")
))
application = web.Application([
(r"/?", IndexHandler),
(r"/request/?", ProxyHandler),
], debug=options.debug)
if options.curl_httpclient:
AsyncHTTPClient.configure(
"tornado.curl_httpclient.CurlAsyncHTTPClient"
)
http_server = httpserver.HTTPServer(application)
http_server.listen(options.port)
instance = ioloop.IOLoop.instance()
try:
logger.info("server listen on %s", options.port)
instance.start()
except KeyboardInterrupt:
logger.info("bye")