def __init__(self, cache_config,cache_name="cache",stattimes=300,poolsize=10):
self.cache_name = cache_name
self.stattimes = stattimes
self.cache_config = cache_config
# try:
# import cyclone.redis
# self.redis = cyclone.redis.lazyConnectionPool(
# host=cache_config.get('host'),
# port=cache_config.get("port"),
# password=cache_config.get('passwd'),
# dbid=cache_config.get('db',0),
# poolsize=poolsize)
# except Exception as err:
# logger.exception(err)
import redis
self.redis = redis.StrictRedis(
host=cache_config.get('host'),
port=cache_config.get("port"),
password=cache_config.get('passwd'),
db=cache_config.get('db',0))
self.get_total = 0
self.set_total = 0
self.hit_total = 0
self.miss_total = 0
self.update_total = 0
self.delete_total = 0
# self.print_hit_stat(first_delay=10)
logger.info('redis client connected')
def __init__(self,
cache_config,
cache_name="cache",
stattimes=300,
poolsize=10):
self.cache_name = cache_name
self.stattimes = stattimes
self.cache_config = cache_config
# try:
# import cyclone.redis
# self.redis = cyclone.redis.lazyConnectionPool(
# host=cache_config.get('host'),
# port=cache_config.get("port"),
# password=cache_config.get('passwd'),
# dbid=cache_config.get('db',0),
# poolsize=poolsize)
# except Exception as err:
# logger.exception(err)
import redis
self.redis = redis.StrictRedis(host=cache_config.get('host'),
port=cache_config.get("port"),
password=cache_config.get('passwd'),
db=cache_config.get('db', 0))
self.get_total = 0
self.set_total = 0
self.hit_total = 0
self.miss_total = 0
self.update_total = 0
self.delete_total = 0
# self.print_hit_stat(first_delay=10)
logger.info('redis client connected')
def post(self):
uname = self.get_argument("username")
upass = self.get_argument("password")
next_url = self.get_argument("next")
print next_url
if not uname:
return self.render_json(code=1, msg=u"请填写用户名")
if not upass:
return self.render_json(code=1, msg=u"请填写密码")
enpasswd = tools.saltmd5(upass.encode())
opr = self.db.query(models.SysOperator).filter_by(
operator_name=uname, operator_pass=enpasswd).first()
if not opr:
return self.render_json(code=1, msg=u"用户名密码不符")
if opr.operator_status == 1:
return self.render_json(code=1, msg=u"该操作员账号已被停用")
self.set_session_user(uname, self.request.remote_ip, opr.operator_type,
utils.get_currtime())
logger.info(u'操作员(%s)登陆' % (uname))
self.db.commit()
self.render_json(code=0, msg="ok", next=next_url)
def handler_wapper(cls):
if not menuname:
self.add_handler(cls, url_pattern)
selfobj.free_routes.append(url_pattern)
logger.info("add free route [%s:%s]" % (url_pattern, repr(cls)))
else:
selfobj.add_route(cls, url_pattern, menuname, category,
order=order, is_menu=is_menu, is_open=is_open,oem=oem)
logger.info("add managed route [%s:%s]" % (url_pattern, repr(cls)))
return cls
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 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 initapp(r):
app = web.Application(gdata)
if gdata.config.web.get("ssl"):
logger.info("load ssl key %s"%gdata.config.web.privatekey)
logger.info("load ssl crt %s"%gdata.config.web.certificate)
from twisted.internet import ssl
sslContext = ssl.DefaultOpenSSLContextFactory(gdata.config.web.privatekey, gdata.config.web.certificate)
reactor.listenSSL(
gdata.port or int(gdata.config.web.port),
app,
contextFactory=sslContext,
interface=gdata.config.web.host
)
else:
reactor.listenTCP(gdata.port or int(gdata.config.web.port), app, interface=gdata.config.web.host)
def post(self):
form = password_forms.password_update_form()
if not form.validates(source=self.get_params()):
self.render("base_form.html", form=form)
return
if form.d.tr_user_pass != form.d.tr_user_pass_chk:
self.render("base_form.html", form=form, msg=u'确认密码不一致')
return
opr = self.db.query(models.SysOperator).filter_by(
operator_name=form.d.tr_user).first()
opr.operator_pass = tools.saltmd5(form.d.tr_user_pass)
logger.info(u'修改%s密码 ' % (self.current_user.username))
self.db.commit()
self.redirect("/admin")
def initapp(r):
app = web.Application(gdata)
if gdata.config.web.get("ssl"):
logger.info("load ssl key %s" % gdata.config.web.privatekey)
logger.info("load ssl crt %s" % gdata.config.web.certificate)
from twisted.internet import ssl
sslContext = ssl.DefaultOpenSSLContextFactory(
gdata.config.web.privatekey, gdata.config.web.certificate)
reactor.listenSSL(gdata.port or int(gdata.config.web.port),
app,
contextFactory=sslContext,
interface=gdata.config.web.host)
else:
reactor.listenTCP(gdata.port or int(gdata.config.web.port),
app,
interface=gdata.config.web.host)
def handler_wapper(cls):
if not menuname:
self.add_handler(cls, url_pattern)
selfobj.free_routes.append(url_pattern)
logger.info("add free route [%s:%s]" %
(url_pattern, repr(cls)))
else:
selfobj.add_route(cls,
url_pattern,
menuname,
category,
order=order,
is_menu=is_menu,
is_open=is_open,
oem=oem)
logger.info("add managed route [%s:%s]" %
(url_pattern, repr(cls)))
return cls
def print_hit_stat(self, first_delay=0):
if first_delay > 0:
reactor.callLater(first_delay, self.print_hit_stat)
return
logstr = """
----------------------- cache stat ----------------------
# cache name : {0}
# visit cache total : {1}
# add cache total : {2}
# hit cache total : {3}
# miss cache total : {4}
# update cache total : {5}
# delete cache total : {6}
# current db cache total : {7}
---------------------------------------------------------
""".format(self.cache_name, self.get_total, self.set_total, self.hit_total,
self.miss_total, self.update_total, self.delete_total, self.count())
logger.info(logstr)
reactor.callLater(self.stattimes, self.print_hit_stat)
def post(self):
active = self.get_argument("active", "syscfg")
for param_name in self.get_params():
if param_name in ("active", "submit"):
continue
param = self.db.query(
models.SysParam).filter_by(param_name=param_name).first()
if not param:
param = models.SysParam()
param.param_name = param_name
param.param_value = self.get_argument(param_name)
self.db.add(param)
else:
param.param_value = self.get_argument(param_name)
dispatch.pub(redis_cache.CACHE_SET_EVENT, param.param_name,
param.param_value, 600)
logger.info(u'操作员(%s)修改参数' % (self.current_user.username))
self.db.commit()
self.redirect("/admin/param?active=%s" % active)
def print_hit_stat(self, first_delay=0):
if first_delay > 0:
reactor.callLater(first_delay, self.print_hit_stat)
return
logstr = """
----------------------- cache stat ----------------------
# cache name : {0}
# visit cache total : {1}
# add cache total : {2}
# hit cache total : {3}
# miss cache total : {4}
# update cache total : {5}
# delete cache total : {6}
# current db cache total : {7}
---------------------------------------------------------
""".format(self.cache_name, self.get_total,self.set_total,self.hit_total,self.miss_total,
self.update_total,self.delete_total,self.count())
logger.info(logstr)
reactor.callLater(self.stattimes, self.print_hit_stat)
class RadiusdAuthorize(protocol.DatagramProtocol):
def __init__(self, config, dbengine=None,statcache=None):
self.config = config
self.dbengine = dbengine
self.statcache = statcache
self.radloader = RadiusLoader(config,dbengine)
def processPacket(self, coareq, (host,port)):
session_id = coareq.get_acct_sessionid()
session = RadiusSession.sessions.pop(session_id,None)
if session:
session.stop()
reply = coareq.CreateReply()
logger.info("[RADIUSAuthorize] :: Send Authorize radius response: %s" % (repr(reply)))
if self.config.radius.debug:
logger.debug(message.format_packet_str(reply))
self.transport.write(reply.ReplyPacket(), (host, port))
def __init__(self, gdata):
self.gdata = gdata
self.config = gdata.config
self.que = deque()
self.cache = gdata.cache
self.db_engine = gdata.db_engine
self.metadata = models.get_metadata(self.db_engine)
self.ops = {
'radstart':self.start_session,
'radstop':self.stop_session
}
self.radstart = ZmqPullConnection(ZmqFactory(), ZmqEndpoint('connect', self.config.mqproxy.radstart_connect))
self.radstop = ZmqSubConnection(ZmqFactory(), ZmqEndpoint('connect',self.config.mqproxy.radstop_connect))
self.radresp = ZmqPushConnection(ZmqFactory(), ZmqEndpoint('connect', self.config.mqproxy.radresp_connect))
self.radstop.subscribe('radstop')
self.radstop.gotMessage = self.subdataReceived
self.radstart.onPull = self.dataReceived
self.process_poll()
logger.info("Start radstart %s" % self.radstart)
logger.info("Start radstop %s" % self.radstop)
logger.info("Start radresp %s" % self.radresp)
def event_cache_delete(self, key):
logger.info("event: delete cache %s " % key)
self.delete(key)
def add_oplog(self, message):
msg = u"operate_log: %s %s %s %s" % (
self.current_user.username, self.current_user.ipaddr,
utils.get_currtime(), utils.safeunicode(message))
logger.info(msg, trace="oplog")
def event_cache_set(self, key, value, expire=3600):
logger.info("event: set cache %s " % key)
self.set(key, value, expire)
session_id = coareq.get_acct_sessionid()
session = RadiusSession.sessions.pop(session_id,None)
if session:
session.stop()
reply = coareq.CreateReply()
logger.info("[RADIUSAuthorize] :: Send Authorize radius response: %s" % (repr(reply)))
if self.config.radius.debug:
logger.debug(message.format_packet_str(reply))
self.transport.write(reply.ReplyPacket(), (host, port))
def datagramReceived(self, datagram, (host, port)):
try:
radius = self.radloader.getRadius(host)
if not radius:
logger.info('[RADIUSAuthorize] :: Dropping Authorize packet from unknown host ' + host)
return
coa_req = message.CoAMessage(packet=datagram, dict=radius.dict, secret=six.b(radius.secret))
logger.info("[RADIUSAuthorize] :: Received Authorize radius request: %s" % message.format_packet_log(coa_req))
if self.config.radius.debug:
logger.debug(message.format_packet_str(coa_req))
self.processPacket(coa_req, (host, port))
except packet.PacketError as err:
errstr = 'RadiusError:Dropping invalid packet from {0} {1},{2}'.format(
host, port, utils.safeunicode(err))
logger.error(errstr)
def init(gdata):
appname = os.path.basename(gdata.app_dir)
utils.update_tz(gdata.config.system.tz)
syslog = logger.Logger(gdata.config, appname)
dispatch.register(syslog)
log.startLoggingWithObserver(syslog.emit, setStdout=0)
gdata.db_engine = get_engine(gdata.config)
gdata.db = scoped_session(
sessionmaker(bind=gdata.db_engine, autocommit=False, autoflush=False))
# web 应用初始化
gdata.settings = dict(
cookie_secret="12oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
login_url="/admin/login",
template_path=os.path.join(os.path.dirname(__file__), "views"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
xsrf_cookies=True,
xheaders=True,
conf=gdata.config)
# 模板初始化
gdata.tp_lookup = TemplateLookup(
directories=[gdata.settings['template_path']],
default_filters=['decode.utf8'],
input_encoding='utf-8',
output_encoding='utf-8',
encoding_errors='ignore',
module_directory="/tmp/toughcloud")
gdata.redisconf = redis_conf(gdata.config)
gdata.session_manager = session.SessionManager(
gdata.redisconf, gdata.settings["cookie_secret"], 7200)
gdata.cache = CacheManager(gdata.redisconf,
cache_name='Cache-%s' % os.getpid())
gdata.aes = utils.AESCipher(key=gdata.config.system.secret)
# 数据库备份器初始化
gdata.db_backup = DBBackup(models.get_metadata(gdata.db_engine),
excludes=[])
#cache event init
dispatch.register(gdata.cache)
# app handles init
handler_dir = os.path.join(gdata.app_dir, 'handlers')
load_handlers(handler_path=handler_dir,
pkg_prefix="%s.handlers" % appname,
excludes=[])
gdata.all_handlers = permit.all_handlers
# app event init
event_dir = os.path.abspath(os.path.join(gdata.app_dir, 'events'))
load_events(event_dir, "%s.events" % appname)
# init zmq
gdata.radque = deque([], 8192)
gdata.radstart = ZmqPushConnection(
ZmqFactory(), ZmqEndpoint('bind', gdata.config.mqproxy.radstart_bind))
gdata.radstop = ZmqPubConnection(
ZmqFactory(), ZmqEndpoint('bind', gdata.config.mqproxy.radstop_bind))
gdata.radresp = ZmqPullConnection(
ZmqFactory(), ZmqEndpoint('bind', gdata.config.mqproxy.radresp_bind))
gdata.radresp.onPull = lambda m: gdata.radque.appendleft(
msgpack.unpackb(m[0]))
gdata.statcache = StatCounter(gdata)
gdata.statcache.init()
gdata.statcache.poll_calc()
logger.info(gdata.radstart)
logger.info(gdata.radstop)
logger.info(gdata.radresp)
def event_cache_update(self, key, value, expire=3600):
logger.info("event: update cache %s " % key)
self.update(key, value, expire)
def event_cache_delete(self, key):
logger.info("event: delete cache %s " % key)
self.delete(key)
def event_cache_update(self, key, value, expire=3600):
logger.info("event: update cache %s " % key)
self.update(key, value, expire)
def event_cache_set(self, key, value, expire=3600):
logger.info("event: set cache %s " % key)
self.set(key, value, expire)
