def event_toughcloud_mail_account_expire(self, userinfo):
""" toughcloud mail api notify event """
if not userinfo:
return
api_secret = self.get_param_value("toughcloud_license")
service_mail=self.get_param_value("toughcloud_service_mail")
if not service_mail:
return
api_token = yield tools.get_sys_token()
params = dict(
token=api_token.strip(),
mailto=userinfo.email,
tplname=self.MAIL_TPLNAME,
customer=utils.safestr(userinfo.realname),
username=userinfo.account_number,
product=utils.safestr(userinfo.product_name),
expire=userinfo.expire_date,
service_call=self.get_param_value("toughcloud_service_call",''),
service_mail=service_mail,
nonce = str(int(time.time()))
)
params['sign'] = apiutils.make_sign(api_secret.strip(), params.values())
try:
resp = yield httpclient.fetch(self.MAIL_APIURL, postdata=urlencode(params))
logger.info(resp.body)
except Exception as err:
logger.exception(err)
def event_toughcloud_sms_account_open(self, userinfo):
""" toughCloud sms api open notify event """
if not userinfo:
return
if not userinfo.get('phone'):
logger.error('user phone is None exit')
return
api_secret = self.get_param_value("toughcloud_license")
api_token = yield tools.get_sys_token()
params = dict(token=api_token.strip(),
action='sms',
tplname=self.SMS_TPLNAME,
phone=userinfo.get('phone'),
customer=utils.safestr(userinfo.get('realname')),
username=userinfo.get('account_number'),
product=utils.safestr(userinfo.get('product_name')),
password=userinfo.get('password'),
expire=userinfo.get('expire_date'),
nonce=str(int(time.time())))
params['sign'] = apiutils.make_sign(api_secret.strip(),
params.values())
try:
resp = yield httpclient.fetch(self.SMS_APIURL,
postdata=urlencode(params))
logger.info(resp.body)
logger.info('open account send short message success')
except Exception as err:
logger.exception(err)
def process(self, *args, **kwargs):
self.logtimes()
with make_db(self.db) as db:
try:
nodes = db.query(models.TrNode)
for node in nodes:
r = db.query(
func.sum(models.TrOnline.input_total).label("input_total"),
func.sum(models.TrOnline.output_total).label("output_total")
).filter(
models.TrOnline.account_number == models.TrAccount.account_number,
models.TrAccount.customer_id == models.TrCustomer.customer_id,
models.TrCustomer.node_id == node.id
).first()
if r and all([r.input_total,r.output_total]):
stat = models.TrFlowStat()
stat.node_id = node.id
stat.stat_time = int(time.time())
stat.input_total = r.input_total
stat.output_total = r.output_total
db.add(stat)
# clean expire data
_time = int(time.time()) - (86400 * 2)
db.query(models.TrFlowStat).filter(models.TrFlowStat.stat_time < _time).delete()
db.commit()
logger.info("flow stat task done")
except Exception as err:
db.rollback()
logger.exception(err)
return self.get_notify_interval()
def process(self, *args, **kwargs):
self.logtimes()
with make_db(self.db) as db:
try:
nas_list = db.query(models.TrBas)
for nas in nas_list:
if not nas.dns_name:
continue
results, _, _ = yield client.lookupAddress(nas.dns_name)
if not results:
logger.info("domain {0} resolver empty".format(
nas.dns_name))
if results[0].type == dns.A:
ipaddr = ".".join(
str(i) for i in struct.unpack(
"BBBB", results[0].payload.address))
if ipaddr:
nas.ip_addr = ipaddr
db.commit()
logger.info(
"domain {0} resolver {1} success".format(
nas.dns_name, ipaddr))
else:
logger.info("domain {0} no ip address,{1}".format(
nas.dns_name, repr(results)))
except Exception as err:
logger.exception(err)
defer.returnValue(self.get_notify_interval())
def event_toughcloud_mail_account_expire(self, userinfo):
""" toughcloud mail api notify event """
if not userinfo:
return
api_secret = self.get_param_value("toughcloud_license")
service_mail = self.get_param_value("toughcloud_service_mail")
if not service_mail:
return
api_token = yield tools.get_sys_token()
params = dict(token=api_token.strip(),
mailto=userinfo.email,
tplname=self.MAIL_TPLNAME,
customer=utils.safestr(userinfo.realname),
username=userinfo.account_number,
product=utils.safestr(userinfo.product_name),
expire=userinfo.expire_date,
service_call=self.get_param_value(
"toughcloud_service_call", ''),
service_mail=service_mail,
nonce=str(int(time.time())))
params['sign'] = apiutils.make_sign(api_secret.strip(),
params.values())
try:
resp = yield httpclient.fetch(self.MAIL_APIURL,
postdata=urlencode(params))
logger.info(resp.body)
except Exception as err:
logger.exception(err)
def event_toughcloud_mail_account_open(self, userinfo):
""" toughCloud mail api open notify without password event """
if not userinfo:
return
if not userinfo.get('email'):
logger.error('user email is None exit')
return
try:
api_secret = self.get_param_value("toughcloud_license")
service_mail = self.get_param_value("toughcloud_service_mail")
if not service_mail:
return
api_token = yield tools.get_sys_token()
params = dict(token=api_token.strip(),
action='email',
mailto=userinfo.get('email'),
tplname=self.MAIL_TPLNAME,
customer=utils.safestr(userinfo.get('realname')),
username=userinfo.get('account_number'),
product=utils.safestr(userinfo.get('product_name')),
expire=userinfo.get('expire_date'),
service_call=self.get_param_value(
"toughcloud_service_call", ''),
service_mail=service_mail,
nonce=str(int(time.time())))
params['sign'] = apiutils.make_sign(api_secret.strip(),
params.values())
resp = yield httpclient.fetch(self.MAIL_APIURL,
postdata=urlencode(params))
logger.info(resp.body)
logger.info('open account send email without password success')
except Exception as err:
logger.exception(err)
def process(self, *args, **kwargs):
self.logtimes()
with make_db(self.db) as db:
try:
nodes = db.query(models.TrNode)
for node in nodes:
online_count = db.query(models.TrOnline.id).filter(
models.TrOnline.account_number == models.TrAccount.account_number,
models.TrAccount.customer_id == models.TrCustomer.customer_id,
models.TrCustomer.node_id == node.id
).count()
stat = models.TrOnlineStat()
stat.node_id = node.id
stat.stat_time = int(time.time())
stat.total = online_count
db.add(stat)
# clean expire data
_time = int(time.time()) - (86400 * 2)
db.query(models.TrOnlineStat).filter(models.TrOnlineStat.stat_time < _time).delete()
db.commit()
logger.info("online stat task done")
except Exception as err:
db.rollback()
logger.exception(err)
return self.get_notify_interval()
def process(self, *args, **kwargs):
self.logtimes()
next_interval = self.get_notify_interval()
backup_path = self.config.database.backup_path
backup_file = "trdb_cron_backup_%s.json.gz" % utils.gen_backep_id()
try:
self.db_backup.dumpdb(os.path.join(backup_path, backup_file))
logger.info(u"数据备份完成,下次执行还需等待 %s" %
(self.format_time(next_interval)))
except Exception as err:
logger.error(u"数据备份失败,%s, 下次执行还需等待 %s" %
(repr(err), self.format_time(next_interval)))
logger.exception(err)
try:
bak_list = [
bd for bd in os.listdir(backup_path)
if 'trdb_cron_backup' in bd
]
if len(bak_list) > 7:
logger.info("find expire backup file and remove")
_count = 0
for fname in bak_list:
fpath = os.path.join(backup_path, fname)
if (time.time() - os.path.getctime(fpath)) / (3600 *
24) > 14:
os.remove(fpath)
_count += 1
logger.info("remove expire backup file %s" % fpath)
logger.info("remove expire backup file total %s" % _count)
except Exception as err:
logger.exception(err)
return next_interval
def process(self, *args, **kwargs):
self.logtimes()
with make_db(self.db) as db:
try:
onlines = db.query(models.TrOnline)
for online in onlines:
acct_start_time = datetime.datetime.strptime(
online.acct_start_time, '%Y-%m-%d %H:%M:%S')
nowdate = datetime.datetime.now()
dt = nowdate - acct_start_time
online_times = dt.total_seconds()
max_session_time = int(
self.get_param_value('radius_max_session_timeout',
86400))
if online_times > (max_session_time):
logger.info(
"online %s overtime, system auto disconnect this online"
% online.account_number)
dispatch.pub(UNLOCK_ONLINE_EVENT,
online.account_number,
online.nas_addr,
online.acct_session_id,
async=True)
logger.info("在线用户过期清理任务完成，下次执行还需等待一小时", trace="task")
except Exception as err:
db.rollback()
logger.exception(err)
return self.get_notify_interval()
def process(self, *args, **kwargs):
self.logtimes()
next_interval = self.get_notify_interval()
backup_path = self.config.database.backup_path
backup_file = "trdb_cron_backup_%s.json.gz" % utils.gen_backep_id()
try:
self.db_backup.dumpdb(os.path.join(backup_path, backup_file))
logger.info(u"数据备份完成,下次执行还需等待 %s"%(self.format_time(next_interval)),trace="task")
except Exception as err:
logger.info(u"数据备份失败,%s, 下次执行还需等待 %s"%( repr(err), self.format_time(next_interval)),trace="task")
logger.exception(err)
try:
bak_list = [ bd for bd in os.listdir(backup_path) if 'trdb_cron_backup' in bd]
if len(bak_list) > 7:
logger.info("find expire backup file and remove")
_count = 0
for fname in bak_list:
fpath = os.path.join(backup_path, fname)
if (time.time() - os.path.getctime(fpath))/(3600*24) > 14:
os.remove(fpath)
_count += 1
logger.debug("remove expire backup file %s"%fpath)
logger.info("remove expire backup file total %s"%_count,trace="task")
except Exception as err:
logger.exception(err)
return next_interval
def process(self, *args, **kwargs):
self.logtimes()
with make_db(self.db) as db:
try:
onlines = db.query(models.TrOnline)
for online in onlines:
acct_start_time = datetime.datetime.strptime(
online.acct_start_time, '%Y-%m-%d %H:%M:%S')
acct_session_time = online.billing_times
nowdate = datetime.datetime.now()
dt = nowdate - acct_start_time
online_times = dt.total_seconds()
max_interim_intelval = int(
self.get_param_value('radius_acct_interim_intelval',
240))
if (online_times -
acct_session_time) > (max_interim_intelval + 30):
logger.info(
"online %s overtime, system auto clear this online"
% online.account_number)
dispatch.pub(CLEAR_ONLINE_EVENT,
online.account_number,
online.nas_addr,
online.acct_session_id,
async=True)
except Exception as err:
db.rollback()
logger.exception(err)
return self.get_notify_interval()
def event_toughcloud_sms_account_open(self, userinfo):
""" toughCloud sms api open notify event """
if not userinfo:
return
if not userinfo.get('phone'):
logger.error('user phone is None exit')
return
api_secret = self.get_param_value("toughcloud_license")
api_token = yield tools.get_sys_token()
params = dict(
token=api_token.strip(),
action='sms',
tplname=self.SMS_TPLNAME,
phone=userinfo.get('phone'),
customer=utils.safestr(userinfo.get('realname')),
username=userinfo.get('account_number'),
product=utils.safestr(userinfo.get('product_name')),
password=userinfo.get('password'),
expire=userinfo.get('expire_date'),
nonce=str(int(time.time()))
)
params['sign'] = apiutils.make_sign(api_secret.strip(), params.values())
try:
resp = yield httpclient.fetch(self.SMS_APIURL, postdata=urlencode(params))
logger.info(resp.body)
logger.info('open account send short message success')
except Exception as err:
logger.exception(err)
def process(self, *args, **kwargs):
self.logtimes()
with make_db(self.db) as db:
try:
nodes = db.query(models.TrNode)
for node in nodes:
online_count = db.query(models.TrOnline.id).filter(
models.TrOnline.account_number ==
models.TrAccount.account_number,
models.TrAccount.customer_id ==
models.TrCustomer.customer_id,
models.TrCustomer.node_id == node.id).count()
stat = models.TrOnlineStat()
stat.node_id = node.id
stat.stat_time = int(time.time())
stat.total = online_count
db.add(stat)
# clean expire data
_time = int(time.time()) - (86400 * 2)
db.query(models.TrOnlineStat).filter(
models.TrOnlineStat.stat_time < _time).delete()
db.commit()
logger.info("online stat task done")
except Exception as err:
db.rollback()
logger.exception(err)
return self.get_notify_interval()
def get_error_html(self, status_code=500, **kwargs):
try:
if 'exception' in kwargs:
failure = kwargs.get("exception")
logger.exception(failure.getTraceback())
if os.environ.get("XDEBUG"):
from mako import exceptions
return exceptions.html_error_template().render(
traceback=failure.getTracebackObject())
if self.request.headers.get(
'X-Requested-With') == 'XMLHttpRequest':
return self.render_json(code=1,
msg=u"%s:服务器处理失败，请联系管理员" % status_code)
if status_code == 404:
return self.render_string("error.html", msg=u"404:页面不存在")
elif status_code == 403:
return self.render_string("error.html", msg=u"403:非法的请求")
elif status_code == 500:
return self.render_string("error.html",
msg=u"500:服务器处理失败，请联系管理员")
else:
return self.render_string("error.html",
msg=u"%s:服务器处理失败，请联系管理员" %
status_code)
except:
logger.exception(err)
return self.render_string("error.html",
msg=u"%s:服务器处理失败，请联系管理员" % status_code)
def event_toughcloud_mail_account_open(self, userinfo):
""" toughCloud mail api open notify without password event """
if not userinfo:
return
if not userinfo.get('email'):
logger.error('user email is None exit')
return
try:
api_secret = self.get_param_value("toughcloud_license")
service_mail = self.get_param_value("toughcloud_service_mail")
if not service_mail:
return
api_token = yield tools.get_sys_token()
params = dict(
token=api_token.strip(),
action='email',
mailto=userinfo.get('email'),
tplname=self.MAIL_TPLNAME,
customer=utils.safestr(userinfo.get('realname')),
username=userinfo.get('account_number'),
product=utils.safestr(userinfo.get('product_name')),
expire=userinfo.get('expire_date'),
service_call=self.get_param_value("toughcloud_service_call", ''),
service_mail=service_mail,
nonce=str(int(time.time()))
)
params['sign'] = apiutils.make_sign(api_secret.strip(), params.values())
resp = yield httpclient.fetch(self.MAIL_APIURL, postdata=urlencode(params))
logger.info(resp.body)
logger.info('open account send email without password success')
except Exception as err:
logger.exception(err)
def broadcast(self, message):
cls = PressTestMixin
for client in cls.waiters:
try:
client.sendEvent(message)
except Exception as e:
logger.exception(e)
def load_tasks(self):
evs = set(os.path.splitext(it)[0] for it in os.listdir(os.path.dirname(tasks.__file__)))
for ev in evs:
try:
__import__("toughradius.manage.tasks.%s"% ev)
except Exception as err:
logger.exception(err)
continue
def update_stat(self, message):
try:
statmsg = msgpack.unpackb(message[0])
statattrs = statmsg['statattrs']
for statattr in statattrs:
self.statdata.incr(statattr, incr=1)
self.update_flow_stat(statmsg['raddata'])
except Exception as err:
logger.exception(err)
def process(req):
try:
vendorid = str(req.vendor_id)
if vendorid in _parses:
_parses[vendorid](req)
else:
parse_normal(req)
except Exception as err:
logger.exception(err, trace="radius")
return req
def load_tasks(self, prifix, task_path):
evs = set(os.path.splitext(it)[0] for it in os.listdir(task_path))
for ev in evs:
try:
robj = importlib.import_module("%s.%s" % (prifix, ev))
if hasattr(robj, 'taskcls'):
self.start_task(robj.taskcls)
except Exception as err:
logger.exception(err)
continue
def start_task(self, taskcls):
try:
task = taskcls(self)
first_delay = task.first_delay()
if first_delay:
reactor.callLater(first_delay, self.process_task, task)
else:
self.process_task(task)
logger.info('init task %s done' % repr(task))
except Exception as err:
logger.exception(err)
def process(self, *args, **kwargs):
self.logtimes()
try:
self.statdata.run_stat()
if self.cache.get(radius_statcache_key):
self.cache.update(radius_statcache_key,self.statdata)
else:
self.cache.set(radius_statcache_key,self.statdata)
except Exception as err:
logger.exception(err)
return self.get_notify_interval()
def process(self, *args, **kwargs):
self.logtimes()
try:
self.statdata.run_stat()
if self.cache.get(radius_statcache_key):
self.cache.update(radius_statcache_key, self.statdata)
else:
self.cache.set(radius_statcache_key, self.statdata)
except Exception as err:
logger.exception(err)
return self.get_notify_interval()
def process(resp=None, input_rate=0, output_rate=0):
try:
if input_rate == 0 and output_rate == 0:
return std_rate(resp, 0, 0)
_vendor = str(resp.vendor_id)
if _vendor in rate_funcs:
return rate_funcs[_vendor](resp, int(input_rate), int(output_rate))
else:
return std_rate(resp, int(input_rate), int(output_rate))
except Exception as err:
logger.exception(err, trace="radius")
return resp
def processAcct(self, datagram, host, port):
try:
bas = self.find_nas(host)
if not bas:
raise PacketError(
'[Radiusd] :: Dropping packet from unknown host %s' % host)
secret, vendor_id = bas['bas_secret'], bas['vendor_id']
req = self.createAcctPacket(packet=datagram,
dict=self.dict,
secret=six.b(str(secret)),
vendor_id=vendor_id)
self.log_trace(host, port, req)
self.do_stat(req.code, req.get_acct_status_type())
logger.info("[Radiusd] :: Received radius request: %s" %
(repr(req)))
if self.config.system.debug:
logger.debug(req.format_str())
if req.code != packet.AccountingRequest:
raise PacketError(
'non-AccountingRequest packet on authentication socket')
if not req.VerifyAcctRequest():
raise PacketError('VerifyAcctRequest error')
reply = req.CreateReply()
self.log_trace(host, port, req, reply)
self.pusher.push(msgpack.packb([reply.ReplyPacket(), host, port]))
self.do_stat(reply.code)
logger.info("[Radiusd] :: Send radius response: %s" % repr(reply))
if self.config.system.debug:
logger.debug(reply.format_str())
status_type = req.get_acct_status_type()
if status_type in self.acct_class:
ticket = req.get_ticket()
if not ticket.get('nas_addr'):
ticket['nas_addr'] = host
acct_func = self.acct_class[status_type](self.db_engine,
self.mcache, None,
ticket).acctounting
reactor.callLater(0.1, acct_func)
else:
logger.error('status_type <%s> not support' % status_type)
except Exception as err:
self.do_stat(0)
logger.exception(error)
def log_trace(self,host,port,req,reply=None):
if not self.is_trace_on():
return
if not self.user_exists(req.get_user_name()):
return
try:
if reply is None:
msg = message.format_packet_log(req)
logger.info(u"Radius请求来自 Nas(%s:%s) %s"%(host,port,utils.safeunicode(msg)),
trace="radius",username=req.get_user_name())
else:
msg = message.format_packet_log(reply)
logger.info(u"Radius响应至 Nas(%s:%s) %s"%(host,port,utils.safeunicode(msg)),
trace="radius",username=req.get_user_name())
except Exception as err:
logger.exception(err)
def log_trace(self,host,port,req,reply=None):
if not self.is_trace_on():
return
if not self.user_exists(req.get_user_name()):
return
try:
if reply is None:
msg = message.format_packet_log(req)
logger.info(u"Radius请求来自 Nas(%s:%s) %s"%(host,port,utils.safeunicode(msg)),
trace="radius",username=req.get_user_name())
else:
msg = message.format_packet_log(reply)
logger.info(u"Radius响应至 Nas(%s:%s) %s"%(host,port,utils.safeunicode(msg)),
trace="radius",username=req.get_user_name())
except Exception as err:
logger.exception(err)
def event_clear_online(self, account_number,nas_addr, acct_session_id):
try:
with make_db(self.db) as db:
logger.info("event clear expire online [username:{0}] {1} {2}".format(account_number, nas_addr, acct_session_id))
nas = db.query(models.TrBas).filter_by(ip_addr=nas_addr).first()
if nas_addr and not nas:
db.query(models.TrOnline).filter_by(
nas_addr=nas_addr,acct_session_id=acct_session_id).delete()
db.commit()
return
online = db.query(models.TrOnline).filter_by(
nas_addr=nas_addr, acct_session_id=acct_session_id).first()
clear_req = self.get_request(online)
radius_acct_stop.RadiusAcctStop(self.dbengine,self.mcache,self.aes,clear_req).acctounting()
logger.info(u"系统触发用户过期清理成功: [username:%s] OnlineInfo: %s "%(str(account_number), json.dumps(clear_req)),trace="event" )
except Exception as err:
logger.exception(err)
def process(self, *args, **kwargs):
self.logtimes()
next_interval = self.get_notify_interval()
with make_db(self.db) as db:
try:
_days = int(self.get_param_value("system_ticket_expire_days",30))
td = datetime.timedelta(days=_days)
_now = datetime.datetime.now()
edate = (_now - td).strftime("%Y-%m-%d 23:59:59")
db.query(models.TrTicket).filter(models.TrTicket.acct_stop_time < edate).delete()
db.commit()
logger.info(u"上网数据清理完成,下次执行还需等待 %s"%(self.format_time(next_interval)),trace="task")
except:
logger.info(u"上网数据清理失败,%s, 下次执行还需等待 %s"%(
repr(err), self.format_time(next_interval)) ,trace="task")
logger.exception(err)
return next_interval
def processAcct(self, datagram, host, port):
try:
bas = self.find_nas(host)
if not bas:
raise PacketError('[Radiusd] :: Dropping packet from unknown host %s' % host)
secret, vendor_id = bas['bas_secret'], bas['vendor_id']
req = self.createAcctPacket(packet=datagram,
dict=self.dict, secret=six.b(str(secret)),vendor_id=vendor_id)
self.log_trace(host,port,req)
self.do_stat(req.code, req.get_acct_status_type())
logger.info("[Radiusd] :: Received radius request: %s" % (repr(req)))
if self.config.system.debug:
logger.debug(req.format_str())
if req.code != packet.AccountingRequest:
raise PacketError('non-AccountingRequest packet on authentication socket')
if not req.VerifyAcctRequest():
raise PacketError('VerifyAcctRequest error')
reply = req.CreateReply()
self.log_trace(host,port,req,reply)
self.pusher.push(msgpack.packb([reply.ReplyPacket(),host,port]))
self.do_stat(reply.code)
logger.info("[Radiusd] :: Send radius response: %s" % repr(reply))
if self.config.system.debug:
logger.debug(reply.format_str())
status_type = req.get_acct_status_type()
if status_type in self.acct_class:
ticket = req.get_ticket()
if not ticket.get('nas_addr'):
ticket['nas_addr'] = host
acct_func = self.acct_class[status_type](
self.db_engine,self.mcache,None,ticket).acctounting
reactor.callLater(0.1,acct_func)
else:
logger.error('status_type <%s> not support' % status_type)
except Exception as err:
self.do_stat(0)
logger.exception(error)
def process(self, *args, **kwargs):
self.logtimes()
next_interval = self.get_notify_interval()
try:
logger.info("start process expire notify task")
_ndays = self.get_param_value("expire_notify_days")
_now = datetime.datetime.now()
_date = (datetime.datetime.now() +
datetime.timedelta(days=int(_ndays))).strftime("%Y-%m-%d")
with make_db(self.db) as db:
expire_query = db.query(
models.TrCustomer.mobile, models.TrCustomer.realname,
models.TrCustomer.email, models.TrProduct.product_name,
models.TrAccount.account_number,
models.TrAccount.install_address,
models.TrAccount.expire_date,
models.TrAccount.password).filter(
models.TrCustomer.customer_id ==
models.TrAccount.customer_id,
models.TrAccount.product_id == models.TrProduct.id,
models.TrAccount.expire_date <= _date,
models.TrAccount.expire_date >=
_now.strftime("%Y-%m-%d"),
models.TrAccount.status == 1)
for userinfo in expire_query:
self.trigger_notify(userinfo)
logger.info(
u"到期通知任务已执行(%s个已通知)。下次执行还需等待 %s" %
(expire_query.count(), self.format_time(next_interval)),
trace="task")
except Exception as err:
logger.info(u"到期通知任务执行失败，%s。下次执行还需等待 %s" %
(repr(err), self.format_time(next_interval)),
trace="task")
logger.exception(err)
return next_interval
def get_error_html(self, status_code=500, **kwargs):
try:
if 'exception' in kwargs:
failure = kwargs.get("exception")
if isinstance(failure, Failure):
logger.exception(failure.getTraceback())
else:
logger.exception(failure)
if self.request.headers.get(
'X-Requested-With') == 'XMLHttpRequest':
return self.render_json(code=1,
msg=u"%s:服务器处理失败，请联系管理员" % status_code)
if status_code == 404:
return self.render_string("error.html", msg=u"404:页面不存在")
elif status_code == 403:
return self.render_string("error.html", msg=u"403:非法的请求")
elif status_code == 500:
return self.render_string("error.html",
msg=u"500:服务器处理失败，请联系管理员")
else:
return self.render_string("error.html",
msg=u"%s:服务器处理失败，请联系管理员" %
status_code)
except Exception as err:
logger.exception(err)
return self.render_string("error.html",
msg=u"%s:服务器处理失败，请联系管理员" % status_code)
def process(self, *args, **kwargs):
self.logtimes()
next_interval = self.get_notify_interval()
try:
logger.info("start process expire notify task")
_ndays = self.get_param_value("expire_notify_days")
_now = datetime.datetime.now()
_date = (datetime.datetime.now() + datetime.timedelta(
days=int(_ndays))).strftime("%Y-%m-%d")
with make_db(self.db) as db:
expire_query = db.query(
models.TrCustomer.mobile,
models.TrCustomer.realname,
models.TrCustomer.email,
models.TrProduct.product_name,
models.TrAccount.account_number,
models.TrAccount.install_address,
models.TrAccount.expire_date,
models.TrAccount.password
).filter(
models.TrCustomer.customer_id == models.TrAccount.customer_id,
models.TrAccount.product_id == models.TrProduct.id,
models.TrAccount.expire_date <= _date,
models.TrAccount.expire_date >= _now.strftime("%Y-%m-%d"),
models.TrAccount.status == 1
)
for userinfo in expire_query:
self.trigger_notify(userinfo)
logger.info(u"到期通知任务已执行(%s个已通知)。下次执行还需等待 %s"% (
expire_query.count(),self.format_time(next_interval)),trace="task")
except Exception as err:
logger.info(u"到期通知任务执行失败，%s。下次执行还需等待 %s"%(
repr(err),self.format_time(next_interval)),trace="task")
logger.exception(err)
return next_interval
def get_error_html(self, status_code=500, **kwargs):
try:
if 'exception' in kwargs:
failure = kwargs.get("exception")
logger.exception(failure.getTraceback())
if os.environ.get("XDEBUG"):
from mako import exceptions
return exceptions.html_error_template().render(traceback=failure.getTracebackObject())
if self.request.headers.get('X-Requested-With') == 'XMLHttpRequest':
return self.render_json(code=1, msg=u"%s:服务器处理失败，请联系管理员" % status_code)
if status_code == 404:
return self.render_string("error.html", msg=u"404:页面不存在")
elif status_code == 403:
return self.render_string("error.html", msg=u"403:非法的请求")
elif status_code == 500:
return self.render_string("error.html", msg=u"500:服务器处理失败，请联系管理员")
else:
return self.render_string("error.html", msg=u"%s:服务器处理失败，请联系管理员" % status_code)
except:
logger.exception(err)
return self.render_string("error.html", msg=u"%s:服务器处理失败，请联系管理员" % status_code)
def process(self, *args, **kwargs):
self.logtimes()
with make_db(self.db) as db:
try:
onlines = db.query(models.TrOnline)
for online in onlines:
acct_start_time = datetime.datetime.strptime(online.acct_start_time, '%Y-%m-%d %H:%M:%S')
nowdate = datetime.datetime.now()
dt = nowdate - acct_start_time
online_times = dt.total_seconds()
max_session_time = int(self.get_param_value('radius_max_session_timeout',86400))
if online_times > (max_session_time):
logger.info("online %s overtime, system auto disconnect this online"%online.account_number)
dispatch.pub(UNLOCK_ONLINE_EVENT,
online.account_number,
online.nas_addr,
online.acct_session_id,async=True)
logger.info("在线用户过期清理任务完成，下次执行还需等待一小时",trace="task")
except Exception as err:
db.rollback()
logger.exception(err)
return self.get_notify_interval()
def process(self, *args, **kwargs):
self.logtimes()
with make_db(self.db) as db:
try:
nas_list = db.query(models.TrBas)
for nas in nas_list:
if not nas.dns_name:
continue
results, _, _ = yield client.lookupAddress(nas.dns_name)
if not results:
logger.info("domain {0} resolver empty".format(nas.dns_name))
if results[0].type == dns.A:
ipaddr = ".".join(str(i) for i in struct.unpack("BBBB", results[0].payload.address))
if ipaddr:
nas.ip_addr = ipaddr
db.commit()
logger.info("domain {0} resolver {1} success".format(nas.dns_name,ipaddr))
else:
logger.info("domain {0} no ip address,{1}".format(nas.dns_name, repr(results)))
except Exception as err:
logger.exception(err)
defer.returnValue(self.get_notify_interval())
def processAuth(self, datagram, host, port):
try:
bas = self.find_nas(host)
if not bas:
raise PacketError('[Radiusd] :: Dropping packet from unknown host %s' % host)
secret, vendor_id = bas['bas_secret'], bas['vendor_id']
req = self.createAuthPacket(packet=datagram,
dict=self.dict, secret=six.b(str(secret)),vendor_id=vendor_id)
self.log_trace(host,port,req)
self.do_stat(req.code)
logger.info("[Radiusd] :: Received radius request: %s" % (repr(req)))
if self.config.system.debug:
logger.debug(req.format_str())
if req.code != packet.AccessRequest:
raise PacketError('non-AccessRequest packet on authentication socket')
reply = req.CreateReply()
reply.vendor_id = req.vendor_id
aaa_request = dict(
account_number=req.get_user_name(),
domain=req.get_domain(),
macaddr=req.client_mac,
nasaddr=req.get_nas_addr() or host,
vlanid1=req.vlanid1,
vlanid2=req.vlanid2
)
auth_resp = RadiusAuth(self.db_engine,self.mcache,self.aes,aaa_request).authorize()
if auth_resp['code'] > 0:
reply['Reply-Message'] = auth_resp['msg']
reply.code = packet.AccessReject
self.log_trace(host,port,req,reply)
return reply
if 'bypass' in auth_resp and int(auth_resp['bypass']) == 0:
is_pwd_ok = True
else:
is_pwd_ok = req.is_valid_pwd(auth_resp.get('passwd'))
if not is_pwd_ok:
reply['Reply-Message'] = "password not match"
reply.code = packet.AccessReject
self.log_trace(host,port,req,reply)
return reply
else:
if u"input_rate" in auth_resp and u"output_rate" in auth_resp:
reply = rate_process.process(
reply, input_rate=auth_resp['input_rate'], output_rate=auth_resp['output_rate'])
attrs = auth_resp.get("attrs") or {}
for attr_name in attrs:
try:
# todo: May have a type matching problem
reply.AddAttribute(utils.safestr(attr_name), attrs[attr_name])
except Exception as err:
errstr = "RadiusError:current radius cannot support attribute {0},{1}".format(
attr_name,utils.safestr(err.message))
logger.error(RadiusError(err,errstr))
for attr, attr_val in req.resp_attrs.iteritems():
reply[attr] = attr_val
reply['Reply-Message'] = 'success!'
reply.code = packet.AccessAccept
if not req.VerifyReply(reply):
raise PacketError('VerifyReply error')
self.log_trace(host,port,req,reply)
return reply
except Exception as err:
self.do_stat(0)
logger.exception(err)
def processAuth(self, datagram, host, port):
try:
bas = self.find_nas(host)
if not bas:
raise PacketError('[Radiusd] :: Dropping packet from unknown host %s' % host)
secret, vendor_id = bas['bas_secret'], bas['vendor_id']
req = self.createAuthPacket(packet=datagram,
dict=self.dict, secret=six.b(str(secret)),vendor_id=vendor_id)
self.log_trace(host,port,req)
self.do_stat(req.code)
logger.info("[Radiusd] :: Received radius request: %s" % (repr(req)))
if self.config.system.debug:
logger.debug(req.format_str())
if req.code != packet.AccessRequest:
raise PacketError('non-AccessRequest packet on authentication socket')
reply = req.CreateReply()
reply.vendor_id = req.vendor_id
aaa_request = dict(
account_number=req.get_user_name(),
domain=req.get_domain(),
macaddr=req.client_mac,
nasaddr=req.get_nas_addr() or host,
vlanid1=req.vlanid1,
vlanid2=req.vlanid2
)
auth_resp = RadiusAuth(self.db_engine,self.mcache,self.aes,aaa_request).authorize()
if auth_resp['code'] > 0:
reply['Reply-Message'] = auth_resp['msg']
reply.code = packet.AccessReject
self.log_trace(host,port,req,reply)
return reply
if 'bypass' in auth_resp and int(auth_resp['bypass']) == 0:
is_pwd_ok = True
req.is_valid_pwd(auth_resp.get('passwd'))
else:
is_pwd_ok = req.is_valid_pwd(auth_resp.get('passwd'))
if not is_pwd_ok:
reply['Reply-Message'] = "password not match"
reply.code = packet.AccessReject
self.log_trace(host,port,req,reply)
return reply
else:
if u"input_rate" in auth_resp and u"output_rate" in auth_resp:
reply = rate_process.process(
reply, input_rate=auth_resp['input_rate'], output_rate=auth_resp['output_rate'])
attrs = auth_resp.get("attrs") or {}
for attr_name in attrs:
try:
# todo: May have a type matching problem
reply.AddAttribute(utils.safestr(attr_name), attrs[attr_name])
except Exception as err:
errstr = "RadiusError:current radius cannot support attribute {0},{1}".format(
attr_name,utils.safestr(err.message))
logger.error(RadiusError(err,errstr))
for attr, attr_val in req.resp_attrs.iteritems():
reply[attr] = attr_val
reply['Reply-Message'] = 'success!'
reply.code = packet.AccessAccept
if not req.VerifyReply(reply):
raise PacketError('VerifyReply error')
self.log_trace(host,port,req,reply)
return reply
except Exception as err:
self.do_stat(0)
logger.exception(err)
