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'更新菜单成功')