def add(self):
self.myId = getUuid()
self.startTime = get_current_time()
self.finishTime = get_current_time()
obj = {
"ID": self.myId,
"AT_AccountId": self.accountId,
"AT_ApiId": self.apiId,
"AT_Type": self.type,
"AT_Name": self.name,
"AT_State": self.state,
"AT_User": self.user or "",
"AT_Request": transToStr(self.request),
"AT_Reply": transToStr(self.reply),
"AT_StartTime": get_current_time(),
"AT_CreateTime": get_current_time(),
}
if (self.state == API_STATE_FINISHED
or self.state == API_STATE_FAILED):
obj["AT_FinishTime"] = get_current_time()
ret = self.db.insert(TB_APITRACE, obj)
if ret == -1:
WARNING("add api %s error for db operation" % self.myId)
return DB_ERR
return OCT_SUCCESS
def clearSession(db=None):
if (not db):
db = dbmysql.mysqldb()
cond = "WHERE S_ExpireTime < %ld" % get_current_time()
db.delete(TB_SESSION, cond=cond)
def collectMsg():
DEBUG("### Collect msg thread start...")
while True:
for func in funcList:
now = get_current_time()
if (now - func["lastCollect"]) > func["CollectInterval"] * 1000:
func["lastCollect"] = now
tmp = func["func"]()
if lock.acquire():
msg[func["type"]].append(tmp)
if (len(msg[func["type"]]) > 5):
msg[func["type"]] = msg[func["type"]][-5:]
lock.release()
if lock.acquire():
fd = open(MSG_FILE, "w")
fd.write(transToStr(msg, indent=4))
fd.close()
lock.release()
sleep(5)
def OCT_SYSTEM(formatStr, arg=None):
TEMPFILE_NAME = "/tmp/OCTTEMP_FILE_%ld%s" % (get_current_time(), getUuid())
if (arg):
CMD = formatStr % arg
else:
CMD = formatStr
CMD += " > %s" % (TEMPFILE_NAME)
ret = os.system(CMD)
fp = open(TEMPFILE_NAME, 'r')
if (fp == None):
return (ret >> 8 & 0XFF, None)
data = fp.read()
fp.close()
os.remove(TEMPFILE_NAME)
if (len(data) == 0):
return (ret >> 8 & 0XFF, None)
if (data[-1] == '\n'):
data = data[:-1] # to remove last "\n"
if (len(data) == 0):
data = None
return (ret >> 8 & 0XFF, data)
def add(self):
robotObj = {
"ID": getUuid(),
"R_UId": self.uId,
"R_AccountId": self.accountId,
"R_Name": self.name,
"R_CreateTime": get_current_time(),
"R_LastSync": get_current_time(),
}
ret = self.db.insert(TB_ROBOT, robotObj)
if (ret == -1):
WARNING("add robot %s error for db operation" % self.name)
return DB_ERR
DEBUG(robotObj)
return OCT_SUCCESS
def add(self):
userObj = {
"ID": getUuid(),
"Q_Robots": self.robots,
"Q_Message": self.messageCapacity,
"Q_Group": self.group,
"Q_LastSync": get_current_time(),
"Q_CreateTime": get_current_time()
}
ret = self.db.insert(TB_QUOTA, userObj)
if (ret == -1):
WARNING("add user %s error for db operation" % self.myId)
return DB_ERR
DEBUG(userObj)
return OCT_SUCCESS
def add(self):
if not self.myId:
self.myId = getUuid()
dbObj = {
"ID": self.myId,
"A_Name": self.name,
"A_Address": self.address,
"A_CreateTime": get_current_time(),
"A_LastSync": get_current_time(),
}
ret = self.db.insert(TB_AGENT, dbObj)
if (ret == -1):
WARNING("add agent %s error for db operation" % self.name)
return DB_ERR
DEBUG(dbObj)
return OCT_SUCCESS
def updateLogin(self):
userObj = {
"U_LastLogin": get_current_time(),
}
cond = "WHERE ID='%s'" % self.myId
ret = self.db.update(TB_ACCOUNT, userObj, cond=cond)
if (ret == -1):
WARNING("update user %s error for db operation" % self.name)
return DB_ERR
def add(self):
userObj = {
"ID": getUuid(),
"U_Name": self.name,
"U_Password": getEncPass(self.password),
"U_Email": self.email,
"U_PhoneNumber": self.phone,
"U_CreateTime": get_current_time(),
"U_LastSync": get_current_time(),
}
ret = self.db.insert(TB_ACCOUNT, userObj)
if (ret == -1):
WARNING("add user %s error for db operation" % self.name)
return DB_ERR
DEBUG(userObj)
return OCT_SUCCESS
def updateLogin(self):
robotObj = {
"R_LastLogin": get_current_time(),
"R_UId": self.uId,
}
cond = "WHERE ID='%s'" % self.myId
ret = self.db.update(TB_ROBOT, robotObj, cond=cond)
if (ret == -1):
WARNING("update robot %s error for db operation" % self.name)
return DB_ERR
def update(self):
obj = {
"S_ExpireTime": get_current_time() + SESSION_EXPIRE_TIME,
}
cond = "WHERE ID='%s'" % self.myId
ret = self.db.update(TB_SESSION, obj, cond=cond)
if ret == -1:
WARNING("update session %s error for db operation" % self.myId)
return DB_ERR
return 0
def add(self):
self.myId = getUuid()
self.createTime = get_current_time()
self.expireTime = get_current_time() + SESSION_EXPIRE_TIME
obj = {
"ID": self.myId,
"S_UserId": self.userId,
"S_UserName": self.username,
"S_UserType": self.role,
"S_Cookie": transToStr(self.cookie),
"S_CreateTime": self.createTime,
"S_ExpireTime": self.expireTime,
}
ret = self.db.insert(TB_SESSION, obj)
if ret == -1:
WARNING("add session %s error for db operation" % self.myId)
return DB_ERR
return OCT_SUCCESS
def init(self):
cond = "WHERE ID='%s' AND S_ExpireTime > %ld " % (self.myId,
get_current_time())
dbObj = self.db.fetchone(TB_SESSION, cond)
if (not dbObj):
return -1
self.dbObj = dbObj
self.loadFromObj()
return 0
def add(self):
self.myId = getUuid()
obj = {
"ID": self.myId,
"P_Name": self.name,
"P_Type": self.type,
"P_TypeName": PRODUCT_TYPES[self.type],
"P_Description": self.desc,
"P_Info": transToStr(self.infoObj),
"P_CreateTime": get_current_time(),
"P_LastSync": get_current_time()
}
ret = self.db.insert(TB_PRODUCT, obj)
if (ret == -1):
WARNING("add product %s error for db operation" % self.name)
return DB_ERR
DEBUG(obj)
return OCT_SUCCESS
def add(self):
dbObj = {
"M_Type": self.type,
"M_AgentId": self.agentId,
"M_Msg": self.msg,
"M_Time": get_current_time()
}
ret = self.db.insert(TB_MSG, dbObj)
if (ret == -1):
WARNING("add msg error for db operation")
return DB_ERR
return OCT_SUCCESS
def bindUkey(self):
userObj = {
"U_Ukey": self.ukey,
"U_LastSync": get_current_time(),
}
cond = "WHERE ID='%s'" % self.myId
ret = self.db.update(TB_ACCOUNT, userObj, cond=cond)
if (ret == -1):
WARNING("update user %s error for db operation" % self.name)
return DB_ERR
return 0
def updateState(self):
robotObj = {
"R_State": self.state,
"R_LastSync": get_current_time(),
}
cond = "WHERE ID='%s'" % self.myId
ret = self.db.update(TB_ROBOT, robotObj, cond=cond)
if (ret == -1):
WARNING("update robot %s error for db operation" % self.name)
return DB_ERR
return 0
def update(self):
userObj = {
"U_Email": self.email,
"U_PhoneNumber": self.phone,
"U_LastSync": get_current_time(),
}
cond = "WHERE ID='%s'" % self.myId
ret = self.db.update(TB_ACCOUNT, userObj, cond=cond)
if (ret == -1):
WARNING("update user %s error for db operation" % self.name)
return DB_ERR
return 0
def updatePrice(self):
userObj = {
"P_Info": transToStr(self.infoObj),
"P_LastSync": get_current_time(),
"P_Description": self.desc
}
cond = "WHERE ID='%s'" % self.myId
ret = self.db.update(TB_PRODUCT, userObj, cond=cond)
if (ret == -1):
WARNING("update user %s error for db operation" % self.name)
return DB_ERR
return 0
def update(self):
userObj = {
"Q_Robots": self.robots,
"Q_Message": self.messageCapacity,
"Q_Group": self.group,
"Q_LastSync": get_current_time(),
}
cond = "WHERE ID='%s'" % self.myId
ret = self.db.update(TB_QUOTA, userObj, cond=cond)
if (ret == -1):
WARNING("update user %s error for db operation" % self.myId)
return DB_ERR
return 0
def updateReply(self):
obj = {
"AT_Reply": transToStr(self.reply),
"AT_State": API_STATE_FINISHED,
"AT_FinishTime": get_current_time()
}
cond = "WHERE ID='%s'" % self.myId
ret = self.db.update(TB_APITRACE, obj, cond=cond)
if ret == -1:
WARNING("update api request %s error for db operation" %
self.apiId)
return DB_ERR
return 0
def resetPassword(self, newPassword):
if (not newPassword):
ERROR("new password not specified when doing password reset operation")
return NOT_ENOUGH_PARAS
userObj = {
"U_Password": getEncPass(newPassword),
"U_LastSync": get_current_time(),
}
cond = "WHERE ID='%s'" % self.myId
ret = self.db.update(TB_ACCOUNT, userObj, cond=cond)
if (ret == -1):
WARNING("update user %s error for db operation" % self.name)
return DB_ERR
return OCT_SUCCESS
def get_sys_info():
sysinfo = {
"os": platform.system() + " Debian " + get_debian_version(),
"kernel": get_kernel_info(),
"cmdline": get_cmdline(),
"maxOpenFiles": get_max_open_files(),
"maxUserProcesses": get_max_processes(),
"hostname": platform.node()
}
uptime = get_uptime()
if not uptime:
ERROR("got uptime error")
return sysinfo
sysinfo["upTime"] = "%d 天 %d 时 %d 分 %d 秒" % (uptime["day"],
uptime["hour"], uptime["minute"], uptime["second"])
sysinfo["freeRate"] = uptime["freeRate"]
rebootTime = get_current_time() - uptime["seconds"] * 1000
sysinfo["lastRebootTime"] = getStrTime(rebootTime)
return sysinfo
def add(self):
self.myId = getUuid()
obj = {
"ID": self.myId,
"QR_Name": self.name,
"QR_Type": self.type,
"QR_Price": self.price,
"QR_Points": self.points,
"QR_Info": transToStr(self.info),
"QR_Paras": transToStr(self.paras),
"QR_CreateTime": get_current_time(),
"QR_Description": self.desc,
}
ret = self.db.insert(TB_QUERYRESULT, obj)
if (ret == -1):
WARNING("add user %s error for db operation" % self.name)
return DB_ERR
DEBUG(obj)
return OCT_SUCCESS
def get_queryresults(db, paras):
listObj = {
"items": [],
"total": 0,
}
type = paras["type"]
cond = "WHERE 1=1 "
if type:
cond += "AND QR_Type='%s' " % type
date = paras["date"]
if date:
now = get_current_time()
cond += "AND QR_CreateTime >= %ld " % (now -
date * 24 * 60 * 60 * 1000)
keyword = paras["keyword"]
if keyword:
cond += "AND QR_Name LIKE '%%%s%%' " % keyword
ret = db.select(TB_QUERYRESULT, cond=cond)
if ret == -1:
ERROR("get user list error")
return (DB_ERR, None)
for dur in db.cur:
obj = dbmysql.row_to_dict(TB_QUERYRESULT, dur)
item = PricingResult(db, dbObj=obj)
item.loadFromObj()
listObj["items"].append(item.toObj())
listObj["total"] = len(listObj["items"])
return (OCT_SUCCESS, listObj)
def getStrTime(milisecs=None):
if not milisecs:
milisecs = get_current_time()
return time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime(int(milisecs) / 1000))
def sendMsg():
DEBUG("### Send msg thread start...")
if not os.path.exists(CONFIG_FILE_PATH):
ERROR("agent config file not exist")
return
obj = fileToObj(CONFIG_FILE_PATH)
serverIp = obj.get("serverIp")
if not serverIp:
ERROR("can't find server ip in config file")
return
agentId = obj.get("agentId")
if not agentId:
agentId = getUuid()
obj["agentId"] = agentId
fd = open(CONFIG_FILE_PATH, "w")
fd.write(transToStr(obj, indent=4))
fd.close()
while True:
if lock.acquire():
for func in funcList:
msg_type = func["type"]
if len(msg[msg_type]) < 1:
continue
now = get_current_time()
if (now - func["lastSend"]) > func["SendInterval"] * 1000:
func["lastSend"] = now
api = "octlink.quantum.v1.sync.APISyncMsg"
paras = {
"agentId": agentId,
"type": msg_type,
"data": transToStr(msg[msg_type][-1]),
"timeout": 0
}
session_uuid = "00000000000000000000000000000000"
(retCode, retObj) = api_call(serverIp,
"9999",
api,
paras,
session_key=session_uuid,
async=False,
https=False)
if (retCode):
ERROR("connect to server error")
continue
DEBUG("send msg OK!")
lock.release()
sleep(60)
