def process(self, *args, **kwargs):
next_interval = self.get_next_interval()
user_total = 0
online_total = 0
with make_db(self.db) as db:
try:
user_total = db.query(models.TrAccount).count()
online_total = db.query(models.TrOnline).count()
except Exception as err:
pass
try:
api_url = 'http://www.taurusxcloud.net/api/v1/ping'
api_token = yield tools.get_sys_token()
params = dict(token=api_token,
app='taurusxee',
ver=__version__,
release=os.environ.get('LICENSE_TYPE', 'taurusxee'),
unum=user_total,
onum=online_total,
dist=pf.linux_distribution())
param_str = urlencode(params)
resp = yield httpclient.fetch(api_url + '?' + param_str,
followRedirect=True)
logger.info('taurusxcloud ping resp code: %s' % resp.code)
except Exception as err:
logger.error(err)
defer.returnValue(next_interval)
def post(self):
self.set_header('Content-Type', 'text/xml;charset=utf-8')
self.set_header('Cache-Control', 'no-cache')
if '/interface/operategw?wsdl' == self.request.uri:
owsurl = '{0}://{1}'.format(self.request.protocol,
self.request.host)
self.finish(optwsdl.wsdlxml(wsurl=owsurl))
return
if '/interface/businessgw?wsdl' == self.request.uri:
bwsurl = '{0}://{1}'.format(self.request.protocol,
self.request.host)
self.finish(bgwsdl.wsdlxml(wsurl=bwsurl))
return
wsbody = self.request.body
logger.info('recv soap message %s' % utils.safeunicode(wsbody),
trace='api')
for _method in self.methods:
try:
if wsbody.find('<wsdd:%s' % _method) >= 0:
getattr(self, _method)(wsbody)
except NULLError:
self.send_wsresp(_method, code=103)
except:
self.send_wsresp(_method,
code=9999,
error=traceback.format_exc())
def acctounting(self):
if not self.account:
return logger.error(u'收到用户:%s 记账结束请求，但用户资料不存在' %
self.request.account_number,
tag='radius_acct_stop_error',
trace='radius',
username=self.request.account_number)
ticket = Storage(**self.request)
_datetime = datetime.datetime.now()
online = self.get_online(ticket.nas_addr, ticket.acct_session_id)
if not online:
session_time = ticket.acct_session_time
stop_time = _datetime.strftime('%Y-%m-%d %H:%M:%S')
start_time = (_datetime - datetime.timedelta(
seconds=int(session_time))).strftime('%Y-%m-%d %H:%M:%S')
ticket.acct_start_time = start_time
ticket.acct_stop_time = stop_time
ticket.start_source = STATUS_TYPE_STOP
ticket.stop_source = STATUS_TYPE_STOP
self.add_ticket(ticket)
else:
self.del_online(ticket.nas_addr, ticket.acct_session_id)
ticket.acct_start_time = online.acct_start_time
ticket.acct_stop_time = _datetime.strftime('%Y-%m-%d %H:%M:%S')
ticket.start_source = online.start_source
ticket.stop_source = STATUS_TYPE_STOP
self.add_ticket(ticket)
self.billing(online)
logger.info(u'用户:%s 记账结束, 清除在线用户数据' % self.account.account_number,
trace='radius',
username=online.account_number)
def event_rossync_set_pppoe_user(self,
name,
password,
profile,
node_id=None,
**kwargs):
if os.environ.get('LICENSE_TYPE',
'') not in ('taurusxee', 'routeros-oem'):
return
with make_db(self.db) as db:
if node_id and db.query(models.TrNode.id).filter_by(
id=node_id, node_type='pppoe').count() == 0:
logger.info('%s not pppoe user' % name)
return
logger.info('set pppoe user: name={0}, {1} {2} {3}'.format(
name, '*******', profile, node_id))
allros = []
if node_id:
allros = self.get_node_ross(node_id)
else:
allros = self.get_all_ros()
print allros
def update_user(resp, rcli, name, password, profile):
ud = rcli.add_pppoe_user(name, password, profile)
ud.addCallback(self.onresp, 'add pppoe user', rcli.apiaddr)
ud.addErrback(self.onerror, 'add pppoe user', rcli.apiaddr)
for rcli in allros:
d = rcli.del_pppoe_user(name)
d.addCallback(update_user, rcli, name, password, profile)
d.addErrback(self.onerror, 'del pppoe user', rcli.apiaddr)
def post(self):
try:
pic_path = os.path.join(os.path.dirname(taurusxradius.__file__),
'static/pics')
try:
if not os.path.exists(pic_path):
os.makedirs(pic_path)
except:
pass
f = self.request.files['Filedata'][0]
filename = os.path.basename(utils.safestr(f['filename']))
savename = 'pic{0}_{1}'.format(tools.gen_num_id(13), filename)
save_path = os.path.join(pic_path, savename)
tf = open(save_path, 'wb')
tf.write(f['body'])
tf.close()
if not safefile.isimg(save_path):
os.remove(save_path)
logger.error('error upload file %s' % save_path)
self.write(u'上传的文件不是图片类型')
return
logger.info('write {0}'.format(save_path))
self.write(u'upload ok')
except Exception as err:
logger.error(err)
self.write(u'上传失败 %s' % utils.safeunicode(err))
def get(self, order_type):
isok = self.alipay.notify_verify(self.get_params())
if not isok:
logger.info(u'收到支付宝订单通知,订单校验无效',
trace='alipay',
**self.get_params())
return self.render_error(code=1, msg=u'订单校验无效')
order_id = self.get_argument('out_trade_no')
order = self.db.query(models.TrCustomerOrder).get(order_id)
if order and order.pay_status == 1:
return self.render('alipay_return.html', order=order)
formdata = self.paycache.get(order_paycaache_key(order_id))
if not formdata:
logger.error(u'收到支付宝订单通知，但是本地查不到订单%s' % order_id, trace='alipay')
return self.render_error(code=1, msg=u'订单不存在')
ret = False
if order_type == 'new':
manager = CustomerAdd(self.db, self.aes)
ret = manager.add(formdata)
if order_type == 'renew':
manager = AccountRenew(self.db, self.aes)
ret = manager.renew(formdata)
if order_type == 'charge':
manager = AccountCharge(self.db, self.aes)
ret = manager.charge(formdata)
if ret:
order = self.db.query(models.TrCustomerOrder).get(order_id)
logger.info(u'收到支付宝订单通知，处理成功',
trace='alipay',
account_number=formdata.account_number,
order_id=order_id)
self.render('alipay_return.html', order=order)
else:
return self.render_error(code=1,
msg=u'订单处理失败 %s' % manager.last_error)
def event_account_delete(self, account_number):
logger.info('account delete event:{}'.format(account_number),
trace='event')
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrAcceptLog.__tablename__,
dict(account_number=account_number)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrAccountAttr.__tablename__,
dict(account_number=account_number)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrBilling.__tablename__,
dict(account_number=account_number)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrOnline.__tablename__,
dict(account_number=account_number)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrAccount.__tablename__,
dict(account_number=account_number)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrCustomerOrder.__tablename__,
dict(account_number=account_number)),
async=True)
dispatch.pub(db_cache.CACHE_DELETE_EVENT,
account_cache_key(account_number),
async=True)
def post(self, order_type):
isok = self.alipay.notify_verify(self.get_params())
if not isok:
self.write('failure')
logger.info(u'收到支付宝订单通知,订单无效', trace='alipay', **self.get_params())
return
order_id = self.get_argument('out_trade_no')
if self.db.query(models.TrCustomerOrder).filter_by(
order_id=order_id, pay_status=1).count() == 1:
self.write('success')
return
formdata = self.paycache.get(order_paycaache_key(order_id))
if not formdata:
logger.error(u'收到支付宝订单通知，但是本地缓存查不到订单%s' % order_id, trace='alipay')
self.write('failure')
return
ret = False
if order_type == 'new':
manager = CustomerAdd(self.db, self.aes)
ret = manager.add(formdata)
if order_type == 'renew':
manager = AccountRenew(self.db, self.aes)
ret = manager.renew(formdata)
if order_type == 'charge':
manager = AccountChange(self.db, self.aes)
ret = manager.charge(formdata)
if ret:
self.write('success')
logger.info(u'收到支付宝订单通知，处理成功',
trace='alipay',
account_number=formdata.account_number,
order_id=formdata.order_id)
else:
logger.error(u'订单处理失败', trace='alipay')
def __init__(self, config, dbengine, **kwargs):
self.config = config
self.que = deque()
self.db_engine = dbengine or get_engine(config, pool_size=30)
self.cache = CacheManager(redis_conf(config),
cache_name='SyncdCache-%s' % os.getpid())
self.metadata = models.get_metadata(self.db_engine)
self.tables = {
_name: _table
for _name, _table in self.metadata.tables.items()
}
self.master_bind = ZmqREPConnection(
ZmqFactory(), ZmqEndpoint('bind', config.ha.master))
self.master_bind.gotMessage = self.dataReceived
self.sync_task = HaSyncTask(config, self.db_engine, self.cache)
self.ops = {
'add': self.do_add,
'update': self.do_update,
'delete': self.do_delete
}
self.process()
logger.info(u'启动HA同步服务: [Master] {} ～ [Slave] {}'.format(
self.config.ha.master, self.config.ha.slave))
if not kwargs.get('standalone'):
self.logtrace = log_trace.LogTrace(redis_conf(config))
if 'elasticsearch' in config:
dispatch.register(eslogapi.EslogApi(config.elasticsearch))
def event_rossync_set_pppoe_profile(self,
name,
pool=None,
rate_limit=None,
bas_id=None,
**kwargs):
if os.environ.get('LICENSE_TYPE',
'') not in ('taurusxee', 'routeros-oem'):
return
logger.info('set pppoe profile: name={0}, {1} {2}'.format(
name, pool, rate_limit))
allros = []
if bas_id:
allros.append(self.get_bas_ros(bas_id))
else:
allros = self.get_all_ros()
def update_profile(resp, rcli):
ud = rcli.add_pppoe_profile(name, pool, rate_limit)
ud.addCallback(self.onresp, 'add pppoe profile', rcli.apiaddr)
ud.addErrback(self.onerror, 'add pppoe profile', rcli.apiaddr)
for rcli in allros:
d = rcli.del_pppoe_profile(name)
d.addCallback(update_profile, rcli)
d.addErrback(self.onerror, 'del pppoe profile', rcli.apiaddr)
def post(self):
form = order_forms.vcard_charge_form()
if not form.validates(source=self.get_params()):
return self.render_json(code=1, msg=form.errors)
account = self.db.query(models.TrAccount).get(
form.d.account_number)
if not account:
return self.render_json(code=1, msg=u'账号不存在')
try:
order_id = utils.gen_order_id()
formdata = Storage(form.d)
formdata['order_id'] = order_id
formdata['product_id'] = account.product_id
formdata['fee_value'] = '0.00'
formdata['accept_source'] = 'ssportal'
formdata['operate_desc'] = u'用户自助充值卡充值'
formdata['vcard_code'] = form.d.vcard_code
formdata['vcard_pwd'] = form.d.vcard_pwd
manager = AccountCharge(self.db, self.aes)
ret = manager.charge(formdata)
if ret:
logger.info(u'充值卡充值成功')
self.render_json(code=0, msg=u'充值卡充值成功')
else:
return self.render_json(code=1,
msg=u'充值卡订单处理失败 %s' %
manager.last_error)
except Exception as err:
logger.exception(err)
return self.render_json(code=1, msg=u'无效的订单')
def __init__(self, config=None, dbengine=None, **kwargs):
self.config = config
self.db_engine = dbengine or get_engine(config, pool_size=20)
self.aes = kwargs.pop('aes', None)
redisconf = redis_conf(config)
self.cache = kwargs.pop(
'cache',
CacheManager(redisconf,
cache_name='RadiusTaskCache-%s' % os.getpid()))
self.db = scoped_session(
sessionmaker(bind=self.db_engine,
autocommit=False,
autoflush=False))
self.load_tasks()
if not kwargs.get('standalone'):
logger.info('start register taskd events')
dispatch.register(log_trace.LogTrace(redis_conf(config)),
check_exists=True)
if 'elasticsearch' in config:
dispatch.register(eslogapi.EslogApi(config.elasticsearch))
event_params = dict(dbengine=self.db_engine,
mcache=self.cache,
aes=self.aes)
event_path = os.path.abspath(os.path.dirname(events.__file__))
dispatch.load_events(event_path,
'taurusxradius.modules.events',
event_params=event_params)
return
def event_rossync_resync_pool(self, bas_id=None, **kwargs):
if os.environ.get('LICENSE_TYPE',
'') not in ('taurusxee', 'routeros-oem'):
return
try:
logger.info('resync pool: bas_id={0}'.format(bas_id))
rcli = self.get_bas_ros(bas_id)
def update_pools(poolresp, name, ranges, next_pool):
if poolresp and '!re' not in poolresp[0]:
d = rcli.add_pool(name, ranges, next_pool)
d.addCallback(self.onresp, 'add pool', rcli.apiaddr)
d.addErrback(self.onerror, 'add pool', rcli.apiaddr)
else:
d2 = rcli.set_pool(name, ranges, next_pool)
d2.addCallback(self.onresp, 'set pool', rcli.apiaddr)
d2.addErrback(self.onerror, 'set pool', rcli.apiaddr)
with make_db(self.db) as db:
for p in self.db.query(models.TrAddrPool).all():
dg = rcli.get_pool(p.pool_name)
dg.addCallback(update_pools, p.pool_name,
'%s-%s' % (p.start_ip, p.end_ip),
p.next_pool)
dg.addErrback(self.onerror, 'get pool', rcli.apiaddr)
except Exception as err:
logger.exception(err)
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 30.0
def event_rossync_resync_pppoe_user(self, bas_id=None, **kwargs):
if os.environ.get('LICENSE_TYPE',
'') not in ('taurusxee', 'routeros-oem'):
return
try:
logger.info('resync pppoe user: bas_id={0}'.format(bas_id))
rcli = self.get_bas_ros(bas_id)
def update_user(resp, name, password, profile):
d = rcli.add_pppoe_user(name, password, profile)
d.addCallback(self.onresp, 'add pppoe user', rcli.apiaddr)
d.addErrback(self.onerror, 'add pppoe user', rcli.apiaddr)
with make_db(self.db) as db:
for node_id, in db.query(models.TrNode.id).filter(
models.TrBasNode.node_id == models.TrNode.id,
models.TrNode.node_type == 'pppoe',
models.TrBasNode.bas_id == bas_id):
for user in self.db.query(models.TrAccount).filter(
models.TrAccount.status < 2,
models.TrAccount.expire_date >=
utils.get_currdate(), models.TrAccount.customer_id
== models.TrCustomer.customer_id,
models.TrCustomer.node_id == node_id):
dg = rcli.del_pppoe_user(user.account_number)
dg.addCallback(update_user, user.account_number,
self.aes.decrypt(user.password),
user.product_id)
dg.addErrback(self.onerror, 'del pppoe user',
rcli.apiaddr)
except Exception as err:
logger.exception(err)
def process(self, *args, **kwargs):
self.logtimes()
next_interval = self.get_next_interval()
billtask_last_day = int(self.get_param_value('billtask_last_day', 3))
if billtask_last_day > 28:
billtask_last_day = 28
_now = datetime.datetime.now()
if _now.day > billtask_last_day:
return next_interval
cmonth = _now.strftime('%Y-%m')
with make_db(self.db) as db:
try:
uquery = db.query(models.TrAccount).filter(
models.TrAccount.product_id == models.TrProduct.id,
models.TrAccount.status == 1,
models.TrProduct.product_policy == APMonth,
models.TrAccount.create_time < cmonth + '-01 00:00:00')
for account in uquery:
alog = db.query(models.TrAcceptLog).filter(
models.TrAcceptLog.accept_type == 'apm_bill',
models.TrAcceptLog.account_number ==
account.account_number, models.TrAcceptLog.accept_time
>= cmonth + '-01 00:00:00')
if alog.count() == 0:
rets = dispatch.pub('apm_user_billing',
account.account_number,
async=True)
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 post(self):
try:
if os.environ.get('DEMO_VER'):
self.write(u'这是一个演示版本，不提供此功能')
return
file_path = os.path.join(os.path.dirname(taurusxradius.__file__),
'static/dnsv')
try:
if not os.path.exists(file_path):
os.makedirs(file_path)
except:
pass
f = self.request.files['Filedata'][0]
filename = os.path.basename(utils.safestr(f['filename']))
save_path = os.path.join(file_path, filename)
tf = open(save_path, 'wb')
filestr = f['body']
tf.write(filestr.strip())
tf.close()
logger.info('write {0}'.format(save_path))
self.write(u'上传完成')
except Exception as err:
logger.error(err)
self.write(u'上传失败 %s' % utils.safeunicode(err))
def sendMailaaa(self, topic, content):
smtp_server = self.get_argument('smtp_server')
smtp_port = self.get_argument('smtp_port')
smtp_tls = self.get_argument('smtp_tls')
smtp_from = self.get_argument('smtp_from')
smtp_user = self.get_argument('smtp_user')
smtp_pwd = self.get_argument('smtp_pwd')
mail_to = self.get_argument('mail_to')
msg = MIMEMultipart()
msg['Subject'] = Header(topic, 'utf-8')
msg['From'] = smtp_from
msg['To'] = mail_to
part = MIMEText(content, 'plain', 'utf-8')
msg.attach(part)
try:
smtpServer = smtplib.SMTP(smtp_server, str(smtp_port))
except Exception as e:
logger.error('SMTP连接邮件服务器失败,可能原因:' + str(e))
return False
try:
smtpServer.login(smtp_user, smtp_pwd)
smtpServer.sendmail(smtp_from, mail_to, msg.as_string())
logger.info('send mail to:' + mail_to)
except smtplib.SMTPException as e:
logger.error('SMTP发送邮件失败,可能原因:' + str(e))
finally:
smtpServer.quit()
return True
def get(self):
product_id = self.get_argument('product_id')
product = self.db.query(models.TrProduct).get(product_id)
if not product:
self.render_error(msg=u'套餐不存在')
return
account_number = self.get_argument('account_number', '')
if account_number and self.db.query(models.TrAccount).get(account_number):
form = order_forms.smsvcode_form(product_id, account_number)
self.render('order_smsvcode_form.html', form=form, msg=u'手机号码已经注册')
return
smsvcode = self.get_argument('vcode', '')
if account_number and not smsvcode:
form = order_forms.smsvcode_form(product_id, account_number)
self.render('order_smsvcode_form.html', form=form, msg=u'验证码不能为空')
return
logger.info('ssportal.sms.vcode = %s ' % self.cache.get('ssportal.sms.vcode.{}'.format(account_number)))
if account_number and smsvcode and self.cache.get('ssportal.sms.vcode.{}'.format(account_number)) != smsvcode:
form = order_forms.smsvcode_form(product_id, account_number)
self.render('order_smsvcode_form.html', form=form, msg=u'验证码不匹配')
return
is_smsvcode = int(self.get_param_value('usrportal_smsvcode_required', 0))
if not account_number and is_smsvcode:
form = order_forms.smsvcode_form(product_id, '')
self.render('order_smsvcode_form.html', form=form)
return
account_number = account_number or self.gen_account_number()
form = order_forms.order_form(product.product_policy)
form.product_id.set_value(product_id)
form.product_name.set_value(product.product_name)
form.months.set_value(product.fee_months)
form.days.set_value(product.fee_days)
form.account_number.set_value(account_number)
self.render('neworder_form.html', form=form)
def do_vcard(self, form, product):
vcard_code = form.d.vcard_code
vcard_pwd = form.d.vcard_pwd
_feevalue, _expire = self.order_calc(form.d.product_id)
order_id = utils.gen_order_id()
formdata = Storage(form.d)
formdata.order_id = order_id
formdata['node_id'] = self.get_param_value('default_user_node_id', 1)
formdata['area_id'] = ''
formdata['fee_value'] = _feevalue
formdata['expire_date'] = _expire
formdata['accept_source'] = 'ssportal'
formdata['giftdays'] = 0
formdata['giftflows'] = 0
formdata['ip_address'] = ''
formdata['status'] = 1
formdata['vcard_code'] = vcard_code
formdata['vcard_pwd'] = vcard_pwd
formdata['customer_desc'] = u'客户自助充值卡开户'
formdata['product_name'] = product.product_name
manager = CustomerAdd(self.db, self.aes)
ret = manager.add(formdata)
if ret:
order = self.db.query(models.TrCustomerOrder).get(order_id)
logger.info(u'充值卡开户成功')
self.render('alipay_return.html', order=order)
else:
return self.render_error(code=1, msg=u'充值卡订单处理失败 %s' % manager.last_error)
def load_plugins(self, load_types = []):
def add_plugin(pobj):
if hasattr(pobj, 'plugin_types') and hasattr(pobj, 'plugin_name') and hasattr(pobj, 'plugin_priority') and hasattr(pobj, 'plugin_func'):
for ptype in load_types:
if ptype == 'radius_auth_req' and ptype in pobj.plugin_types and pobj not in self.auth_req_plugins:
self.auth_req_plugins.append(pobj)
logger.info('load auth_req_plugin -> {} {}'.format(pobj.plugin_priority, pobj.plugin_name))
if ptype == 'radius_accept' and ptype in pobj.plugin_types and pobj not in self.auth_accept_plugins:
self.auth_accept_plugins.append(pobj)
logger.info('load auth_accept_plugin -> {} {}'.format(pobj.plugin_priority, pobj.plugin_name))
if ptype == 'radius_acct_req' and ptype in pobj.plugin_types and pobj not in self.acct_req_plugins:
self.acct_req_plugins.append(pobj)
logger.info('load acct_req_plugin -> {} {}'.format(pobj.plugin_priority, pobj.plugin_name))
default_plugins_dir = os.path.join(os.path.dirname(__file__), 'radius/plugins')
logger.info('start load radius plugins {} from {}'.format(load_types, default_plugins_dir))
modules = (os.path.splitext(m)[0] for m in os.listdir(default_plugins_dir))
for pgname in modules:
try:
pg_prefix = 'taurusxradius.modules.radius.plugins'
add_plugin(importlib.import_module('{0}.{1}'.format(pg_prefix, pgname)))
except Exception as err:
logger.exception(err, trace='radius', tag='radius_plugins_load_error')
self.auth_req_plugins = sorted(self.auth_req_plugins, key=lambda i: i.plugin_priority)
self.acct_req_plugins = sorted(self.acct_req_plugins, key=lambda i: i.plugin_priority)
self.auth_accept_plugins = sorted(self.auth_accept_plugins, key=lambda i: i.plugin_priority)
def acctounting(self):
if self.is_online(self.request.nas_addr, self.request.acct_session_id):
return logger.error(u'用户:%s 已经在线' % self.request.acct_session_id,
tag='radius_acct_start_error')
if not self.account:
dispatch.pub(UNLOCK_ONLINE_EVENT,
self.request.account_number,
self.request.nas_addr,
self.request.acct_session_id,
async=True)
return logger.error(u'用户:%s 不存在' % self.request.account_number,
tag='radius_acct_start_error')
online = Storage(account_number=self.request.account_number,
nas_addr=self.request.nas_addr,
acct_session_id=self.request.acct_session_id,
acct_start_time=datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S'),
framed_ipaddr=self.request.framed_ipaddr,
mac_addr=self.request.mac_addr or '',
nas_port_id=self.request.nas_port_id,
billing_times=0,
input_total=0,
output_total=0,
start_source=STATUS_TYPE_START)
self.add_online(online)
logger.info(u'用户:%s 记账开始, 新增在线用户数据' % online.account_number,
trace='radius',
username=online.account_number)
def __init__(self, taskd, **kwargs):
TaseBasic.__init__(self, taskd, **kwargs)
self.flow_stat = {}
self.statdata = self.cache.get(radius_statcache_key) or statistics.MessageStat(quemax=180)
self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('bind', self.config.mqproxy['task_bind']))
self.puller.onPull = self.update_stat
logger.info('start stat mq %s' % self.puller)
def acctounting(self):
if not self.account:
dispatch.pub(UNLOCK_ONLINE_EVENT,
self.request.account_number,
self.request.nas_addr,
self.request.acct_session_id,
async=True)
return logger.error(u'收到用户:%s 记账更新请求，但用户资料不存在' %
self.request.account_number,
tag='radius_acct_update_error',
trace='radius',
username=self.request.account_number)
ticket = Storage(**self.request)
online = self.get_online(ticket.nas_addr, ticket.acct_session_id)
if not online:
sessiontime = ticket.acct_session_time
updatetime = datetime.datetime.now()
_starttime = updatetime - datetime.timedelta(seconds=sessiontime)
online = Storage(
account_number=self.account.account_number,
nas_addr=ticket.nas_addr,
acct_session_id=ticket.acct_session_id,
acct_start_time=_starttime.strftime('%Y-%m-%d %H:%M:%S'),
framed_ipaddr=ticket.framed_ipaddr or '',
mac_addr=ticket.mac_addr or '',
nas_port_id=ticket.nas_port_id or '',
billing_times=ticket.acct_session_time,
input_total=self.get_input_total(),
output_total=self.get_output_total(),
start_source=STATUS_TYPE_UPDATE)
self.add_online(online)
self.billing(online)
logger.info(u'用户:%s 记账更新, 更新用户在线数据' % self.account.account_number,
trace='radius',
username=online.account_number)
def __init__(self, cache_config, db=2):
self.cache_config = cache_config
self.redis = redis.StrictRedis(host=cache_config.get('host'),
port=cache_config.get('port'),
password=cache_config.get('passwd'),
db=db)
logger.info('LogTrace connected')
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)
username = req.get_user_name()
bypass = int(self.get_param_value('radius_bypass', 1))
if req.code != packet.AccessRequest:
raise PacketError('non-AccessRequest packet on authentication socket')
self.log_trace(host, port, req)
self.do_stat(req.code)
if self.config.system.debug:
logger.debug('[Radiusd] :: Received radius request: %s' % req.format_str())
else:
logger.info('[Radiusd] :: Received radius request: %s' % repr(req))
if bypass == 2:
reply = self.freeReply(req)
self.log_trace(host, port, req, reply)
return reply
if not self.user_exists(username):
errmsg = u'[Radiusd] :: user:%s not exists' % username
reply = self.rejectReply(req, errmsg)
self.log_trace(host, port, req, reply)
return reply
bind_nas_list = self.get_account_bind_nas(username)
if not bind_nas_list or host not in bind_nas_list:
errmsg = u'[Radiusd] :: nas_addr:%s not bind for user:%s node' % (host, username)
reply = self.rejectReply(req, errmsg)
self.log_trace(host, port, req, reply)
return reply
aaa_request = dict(account_number=username, domain=req.get_domain(), macaddr=req.client_mac, nasaddr=req.get_nas_addr(), vlanid1=req.vlanid1, vlanid2=req.vlanid2, bypass=bypass, radreq=req)
auth_resp = RadiusAuth(self.db_engine, self.mcache, self.aes, aaa_request).authorize()
if auth_resp['code'] > 0:
reply = self.rejectReply(req, auth_resp['msg'])
self.log_trace(host, port, req, reply)
return reply
reply = req.CreateReply()
reply.code = packet.AccessAccept
reply.vendor_id = req.vendor_id
reply['Reply-Message'] = 'user:%s auth success' % username
reply_attrs = {}
reply_attrs.update(auth_resp)
reply_attrs.update(req.resp_attrs)
for plugin in self.auth_accept_plugins:
reply = plugin.plugin_func(reply, reply_attrs)
if not req.VerifyReply(reply):
raise PacketError('[Radiusd] :: user:%s auth verify reply error' % username)
self.log_trace(host, port, req, reply)
return reply
except Exception as err:
if not self.reject_debug:
self.do_stat(0)
logger.exception(err, tag='radius_auth_error')
else:
reply = self.rejectReply(req, repr(err))
self.log_trace(host, port, req, reply)
return reply
def get(self):
self.init_wechat()
echostr = self.get_argument('echostr', '')
if self.check_signature():
self.write(echostr)
logger.info('Signature check success.')
else:
logger.error('Signature check failed.')
def __init__(self, config, service = 'auth'):
self.config = config
self.service = service
self.pusher = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('bind', config.mqproxy[self.service + '_message']))
self.puller = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('bind', config.mqproxy[self.service + '_result']))
self.puller.onPull = self.radiusReply
logger.info('%s master message bind @ %s' % (self.service, self.pusher))
logger.info('%s master result bind @ %s' % (self.service, self.puller))
def wxrouter_text(self, msg, gdata = None, wechat = None, **kwargs):
logger.info(u'process wechat text %s' % utils.safeunicode(msg.content))
resp = ''
keychar = msg.content.strip()
if keychar in wechat_funcs:
logger.info('execute func %s' % wechat_funcs[keychar])
resp = yield wxrouter.dispatch(msg, gdata=gdata, wechat=wechat, func=wechat_funcs[keychar], **kwargs)
defer.returnValue(resp)
def post(self, *args, **kwargs):
""" 更新菜单，保存菜单数据为json字符串 """
menudata = self.get_argument('menudata')
menu_json = json.loads(menudata)
try:
menu_object = {'button': []}
for menu in ['menu1', 'menu2', 'menu3']:
menu_buttons = {'name': menu_json['%s_name' % menu]}
menu_type = menu_json.get('%s_type' % menu)
menu_url = menu_json.get('%s_url' % menu)
menu_key = menu_json.get('%s_key' % menu)
if all([menu_type, menu_url]) or all([menu_type, menu_key
]):
menu_buttons['type'] = menu_type
if 'click' in menu_type:
menu_buttons['key'] = menu_key
else:
menu_buttons['url'] = menu_url
menu_object['button'].append(menu_buttons)
continue
menu_buttons['sub_button'] = []
for ms in range(1, 6):
menu_button = {}
_menu_type = menu_json['%s_sub%s_type' % (menu, ms)]
_menu_name = menu_json['%s_sub%s_name' % (menu, ms)]
_menu_key = menu_json['%s_sub%s_key' % (menu, ms)]
_menu_url = menu_json['%s_sub%s_url' % (menu, ms)]
if len(_menu_name) > 1:
menu_button['type'] = _menu_type
menu_button['name'] = _menu_name
if 'click' in _menu_type:
menu_button['key'] = _menu_key
else:
menu_button['url'] = _menu_url
menu_buttons['sub_button'].append(menu_button)
menu_object['button'].append(menu_buttons)
menu_result = json.dumps(menu_object,
ensure_ascii=False,
sort_keys=True,
indent=4,
separators=(',', ': '))
logger.info(menu_result)
self.cache.set(self.MpsMenuCacheKey, menu_result)
_resp = self.wechat.create_menu(menu_object)
if int(_resp.get('errcode')) > 0:
logger.error(u'同步菜单失败，' + _resp.get('errmsg'))
logger.error(menu_result)
return self.render_json(code=0,
msg=u'同步微信菜单失败了［%s］，请检查错误再试试' %
_resp.get('errmsg'))
except:
logger.exception(u'更新菜单失败')
return self.render_json(code=0, msg=u'更新菜单失败')
self.render_json(code=0, msg=u'更新菜单成功')
