def main(args):
rospy.init_node('wechat', anonymous=True)
signal.signal(signal.SIGINT, quit)
signal.signal(signal.SIGTERM, quit)
if cm.get('setting', 'server_mode') == 'True':
serverProcess = threading.Thread(target=run_server)
serverProcess.start()
cmdProcess = threading.Thread(target=cmd_input)
cmdProcess.setDaemon(True)
cmdProcess.start()
while not rospy.is_shutdown():
try:
wechat.start()
except KeyboardInterrupt:
echo(Constant.LOG_MSG_QUIT)
wechat.exit_code = 1
else:
Log.error(traceback.format_exc())
finally:
wechat.stop()
# send a mail to tell the wxbot is failing
subject = 'wxbot stop message'
log_file = open(eval(cm.get('handler_fileHandler', 'args'))[0], 'r')
mail_content = '<pre>' + str(
wechat) + '\n\n-----\nLogs:\n-----\n\n' + ''.join(
log_file.readlines()[-100:]) + '</pre>'
sg.send_mail(subject, mail_content, 'text/html')
log_file.close()
if wechat.exit_code == 0:
echo(Constant.MAIN_RESTART)
else:
# kill process
os.system(Constant.LOG_MSG_KILL_PROCESS % os.getpid())
def send_file(self, user_id, file_path):
"""
@brief send file
@param user_id String
@param file_path String
@return Bool: whether operation succeed
"""
title = file_path.split('/')[-1]
data = {
'appid': Constant.API_WXAPPID,
'title': title,
'totallen': '',
'attachid': '',
'type': self.wx_conf['APPMSGTYPE_ATTACH'],
'fileext': title.split('.')[-1],
}
response = self.webwxuploadmedia(file_path)
if response is not None:
data['totallen'] = response['StartPos']
data['attachid'] = response['MediaId']
else:
Log.error('File upload error')
return self.webwxsendappmsg(user_id, data)
def run(self):
'''
Start process, the subclass must rewrite this function or 'handle' function
when all the father processes quits, then break to quit
'''
if self.log:
self.log = Log(self.name, toFile="plugin")
self.log.info("plugin {0} start, ins:{1}, outs:{2}".format(
self.name, self._ins, self._outs))
else:
self.log = False
while True:
try:
data = self.get()
#print "debug:", "plugin ", self.name, "getting", "ins<<<<<<<<", [str(x) for x in self._ins]
except QueueEmpty:
continue
except IOError:
break
except EOFError:
break
except PluginExit:
self.quit()
#print "debug:", "plugin ", self.name, "quit"
if self.log:
self.log.info("plugin {0} quit".format(self.name))
break
else:
#print "debug:", "plugin ", self.name, "got", data
self.handle(data)
finally:
time.sleep(self.timeout)
def recover(self):
"""
@brief Recover from snapshot data.
@return Bool: whether operation succeed.
"""
cm = ConfigManager()
[self.uuid, self.redirect_uri, self.uin,
self.sid, self.skey, self.pass_ticket,
self.synckey, device_id, self.last_login] = cm.get_wechat_config()
if device_id:
self.device_id = device_id
self.base_request = {
'Uin': int(self.uin),
'Sid': self.sid,
'Skey': self.skey,
'DeviceID': self.device_id,
}
# set cookie
Log.debug('set cookie')
self.cookie = set_cookie(self.cookie_file)
return True
def send_file(self, user_id, file_path):
"""
@brief send file
@param user_id String
@param file_path String
@return Bool: whether operation succeed
"""
title = file_path.split('/')[-1]
data = {
'appid': Constant.API_WXAPPID,
'title': title,
'totallen': '',
'attachid': '',
'type': self.wx_conf['APPMSGTYPE_ATTACH'],
'fileext': title.split('.')[-1],
}
response = self.webwxuploadmedia(file_path)
if response is not None:
data['totallen'] = response['StartPos']
data['attachid'] = response['MediaId']
else:
Log.error('File upload error')
return self.webwxsendappmsg(user_id, data)
def close(self):
"""
@brief close connection to database
"""
self.conn.commit()
Log.debug('DB -> close')
self.conn.close()
def auto_reload(mod):
"""
@brief reload modules
@param mod: the need reload modules
"""
try:
module = sys.modules[mod]
except:
Log.error(traceback.format_exc())
return False
filename = module.__file__
# .pyc 修改时间不会变
# 所以就用 .py 的修改时间
if filename.endswith(".pyc"):
filename = filename.replace(".pyc", ".py")
mod_time = os.path.getmtime(filename)
if not "loadtime" in module.__dict__:
module.loadtime = 0
try:
if mod_time > module.loadtime:
reload(module)
else:
return False
except:
Log.error(traceback.format_exc())
return False
module.loadtime = mod_time
echo('[*] load \'%s\' successful.\n' % mod)
return True
def auto_reload(mod):
"""
@brief reload modules
@param mod: the need reload modules
"""
try:
module = sys.modules[mod]
except:
Log.error(traceback.format_exc())
return False
filename = module.__file__
# .pyc 修改时间不会变
# 所以就用 .py 的修改时间
if filename.endswith(".pyc"):
filename = filename.replace(".pyc", ".py")
mod_time = os.path.getmtime(filename)
if not "loadtime" in module.__dict__:
module.loadtime = 0
try:
if mod_time > module.loadtime:
reload(module)
else:
return False
except:
Log.error(traceback.format_exc())
return False
module.loadtime = mod_time
echo('[*] load \'%s\' successful.\n' % mod)
return True
def upload_method(cron_id, vpn_ip, work_path, exchange, task_type):
try:
run_date = datetime.datetime.now().strftime("%Y%m%d")
# remote check
remote_check_flag = dir_check(vpn_ip, work_path)
local_files = get_local_files(task_type, vpn_ip, work_path)
print local_files
# local check
local_check_flag, size = loacal_files_check(local_files)
if not local_files or not remote_check_flag or not local_check_flag:
cron_trigger(cron_id, -1, size, run_date)
return False
his_cron_id = cron_trigger(cron_id, 0, size, run_date)
if his_cron_id < 0:
return False
file_str = " ".join(local_files)
cmd = "rsync -avz --progress %s %s@%s:%s" % (file_str, "mycapitaltrade", vpn_ip, work_path)
print cmd
tf_out = tempfile.NamedTemporaryFile()
tf_out_r = open(tf_out.name, "r")
proc = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=tf_out)
while proc.poll() is None:
multiple_listen_stdout(cron_id, his_cron_id, size, run_date, tf_out_r)
time.sleep(0.5)
else:
multiple_listen_stdout(cron_id, his_cron_id, size, run_date, tf_out_r)
tf_out_r.close()
tf_out.close()
return True
except:
Log.error("rsync log failed. %s" % traceback.format_exc())
return False
def recover(self):
"""
@brief Recover from snapshot data.
@return Bool: whether operation succeed.
"""
cm = ConfigManager()
[
self.uuid, self.redirect_uri, self.uin, self.sid, self.skey,
self.pass_ticket, self.synckey, device_id, self.last_login
] = cm.get_wechat_config()
if device_id:
self.device_id = device_id
self.base_request = {
'Uin': int(self.uin),
'Sid': self.sid,
'Skey': self.skey,
'DeviceID': self.device_id,
}
# set cookie
Log.debug('set cookie')
self.cookie = set_cookie(self.cookie_file)
return True
def __adjustUrl(self, src_url):
if not self.__feedingUrl:
Log.e("{Spider.__adjustUrl} self.__feedingUrl is None")
return src_url
if src_url == '#':
return self.__feedingUrl
if src_url.startswith('//'):
src_url = "http:" + src_url
return src_url
if src_url.startswith('http://') or src_url.startswith('https://'):
return src_url
if src_url.startswith('javascript:'):
return src_url
elems = src_url.split('/')
feeding = self.__feedingUrl.split('/')
for e in elems:
if e == '.':
elems.remove(e)
while True:
feeding.pop()
if elems[0] != '..':
break;
elems.pop(0)
url = feeding + elems
return '/'.join(url)
def close(self):
"""
@brief close connection to database
"""
Log.debug('DB -> close')
# 关闭数据库连接
self.conn.close()
def __init__(self, width=10, height=10, num_agents=2):
super(RandomRewardGridEnv, self).__init__()
self.map = GridMap(width=10, height=10)
self.agents = list()
for i in range(num_agents):
self.agents.append(Agent(active_map=self.map))
self.map.registerAgent(self.agents[-1])
Log.warning("New env created with %d agents" % (len(self.agents)))
def step(self, action):
Log.debug("=================== New Step ===================")
self.__recorder.record('step')
ret_val = self.__doSequentialStep__(action)
self.__recorder.record('step')
return ret_val
def delete_table(self, table):
"""
@brief Delete a table in database
@param table String
"""
sql = "DROP TABLE if exists %s;" % table
Log.debug('DB -> %s' % sql)
self.execute(sql)
def select_max(self, table, field):
sql = "SELECT MAX(%s) FROM %s" % (field, table)
Log.debug('DB -> %s' % sql)
result = self.execute(sql)
if result:
return result[0]['MAX(%s)' % field]
else:
return 0
def startProcess(self, index):
if self.procStates[index] != STATE_READY:
Log.w(
"processe{%d} is not ready, state {%d}, please call setupProccesse() before"
% (index, self.procStates[index]))
return False
self.processes[index].start()
return True
def delete_table(self, table):
"""
@brief Delete a table in database
@param table String
"""
sql = "DROP TABLE if exists %s;" % table
Log.debug('DB -> %s' % sql)
self.execute(sql)
def doActionAgentCollate(self, action_sequence):
# Given an action space to perform, need to convert it into the
# proper representation that the map can understand. In this case,
# there are PUT and DEL actions.
# Retrieve the current position of the agent within the active map
current_pos = self.active_map.getAgentMapInfo(self)
map_actions = defaultdict(list)
for action in action_sequence:
if (action == Agent.AgentActions.NO_MOVE):
# The agent has decided to make no map-oriented moves
pass
elif (action == Agent.AgentActions.TURN_UP):
# The agent is modifying an internal state and has no map updates
# that it needs to report back to the map
self.orientation = Agent.Orientations.UP
elif (action == Agent.AgentActions.TURN_DOWN):
# The agent is modifying an internal state and has no map updates
# that it needs to report back to the map
self.orientation = Agent.Orientations.DOWN
elif (action == Agent.AgentActions.TURN_LEFT):
# The agent is modifying an internal state and has no map updates
# that it needs to report back to the map
self.orientation = Agent.Orientations.LEFT
elif (action == Agent.AgentActions.TURN_RIGHT):
# The agent is modifying an internal state and has no map updates
# that it needs to report back to the map
self.orientation = Agent.Orientations.RIGHT
elif (action == Agent.AgentActions.FORWARD):
# Add the movement based on the current orientation of the
# agent.
new_x, new_y = current_pos.x, current_pos.y
if (self.orientation == Agent.Orientations.UP):
new_y -= 1
elif (self.orientation == Agent.Orientations.DOWN):
new_y += 1
elif (self.orientation == Agent.Orientations.LEFT):
new_x -= 1
elif (self.orientation == Agent.Orientations.RIGHT):
new_x += 1
else:
raise AssertionError("Invalid Orientation")
# If the new position is valid, move
new_pos = self.active_map.GridPosition(new_x, new_y)
if self.active_map.isValidPosition(new_pos):
map_actions[new_pos].append(
self.active_map.PutMapUpdate(self))
# Delete the agent from the current location
map_actions[current_pos].append(
self.active_map.DelMapUpdate(self))
else:
Log.debug(
"invalid new map position - not generating anything")
else:
raise AssertionError("An invalid action has been specified")
return map_actions
def terminateProcess(self, index):
if self.procStates[index] == STATE_TERMINATE:
Log.w("processe{%d} has been terminated!" % index)
return False
os.kill(self.processes[index].pid, signal.SIGINT)
self.processes[index].join()
self.procStates[index] = STATE_TERMINATE
return True
def create_table(self, table, cols):
"""
@brief Creates a table in database
@param table String
@param cols String, the cols in table
"""
sql = "CREATE TABLE if not exists %s (%s);" % (table, cols)
Log.debug('DB -> %s' % sql)
self.execute(sql)
def create_db(self, db_name):
"""
@brief Creates a database
@param db_name String
"""
if self.conf['database'] not in self.show_database():
sql = 'CREATE DATABASE IF NOT EXISTS %s CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci' % db_name
Log.debug('DB -> %s' % sql)
self.execute(sql)
def insert(self, table, value):
"""
@brief Insert a row in table
@param table String
@param value Tuple
"""
sql = ("INSERT INTO %s VALUES (" + ",".join(['?'] * len(value)) + ");") % table
Log.debug('DB -> %s' % sql)
self.execute(sql, value)
def create_table(self, table, cols):
"""
@brief Creates a table in database
@param table String
@param cols String, the cols in table
"""
sql = "CREATE TABLE if not exists %s (%s);" % (table, cols)
Log.debug('DB -> %s' % sql)
self.execute(sql)
def insert(self, table, value):
"""
@brief Insert a row in table
@param table String
@param value Tuple
"""
sql = ("INSERT INTO %s VALUES (" + ",".join(['?'] * len(value)) + ");") % table
Log.debug('DB -> %s' % sql)
self.execute(sql, value)
def close(self):
"""
@brief close connection to database
"""
Log.debug('DB -> close')
# 关闭数据库连接
self.conn.close()
def create_db(self, db_name):
"""
@brief Creates a database
@param db_name String
"""
if self.conf['database'] not in self.show_database():
sql = 'CREATE DATABASE IF NOT EXISTS %s CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci' % db_name
Log.debug('DB -> %s' % sql)
self.execute(sql)
def insertmany(self, table, values):
"""
@brief Insert many rows in table
@param table String
@param values Array of tuple
"""
col_name = self.table_cols[table][1:]
sql = 'INSERT INTO %s(%s) VALUES (%s)' % (table, ','.join(col_name), ','.join(['%s'] * len(values[0])))
Log.debug('DB -> %s' % sql)
self.execute(sql, values)
def insert(self, table, value):
"""
@brief Insert a row in table
@param table String
@param value Tuple
"""
col_name = self.table_cols[table][1:]
sql = "INSERT INTO %s(%s) VALUES (%s)" % (table, str(','.join(col_name)), array_join(value, ','))
Log.debug('DB -> %s' % sql)
self.execute(sql)
def worker(pid, states):
from time import sleep
try:
states[pid] = STATE_IDLE
sleep(3)
states[pid] = STATE_BUSY
sleep(30)
states[pid] = STATE_TERMINATE
except KeyboardInterrupt:
Log.d("worker end!")
def delete(self, table, field='', condition=''):
"""
@brief execute sql commands, return result if it has
@param table String
@param field String
@param condition String
"""
sql = "DELETE FROM %s WHERE %s=%s" % (table, field, condition)
Log.debug('DB -> %s' % sql)
self.execute(sql)
def registerAgent(self, agent, method='random', **kwargs):
# Registering randomly
if method == 'random':
rand_x, rand_y = random.randint(0, self.width - 1), random.randint(
0, self.height - 1)
pos = GridMap.GridPosition(x=rand_x, y=rand_y)
self._agent_to_pos[agent] = pos
self._pos_to_agent[pos][agent] = agent
Log.debug("Registered new agent %s with position %s" %
(hex(id(agent)), str(pos)))
def delete_table(self, table):
"""
@brief Delete a table in database
@param table String
"""
if table in self.table_cols:
sql = "DROP TABLE IF EXISTS %s" % table
Log.debug('DB -> %s' % sql)
self.execute(sql)
self.table_cols.pop(table)
def delete_table(self, table):
"""
@brief Delete a table in database
@param table String
"""
if table in self.table_cols:
sql = "DROP TABLE IF EXISTS %s" % table
Log.debug('DB -> %s' % sql)
self.execute(sql)
self.table_cols.pop(table)
def delete(self, table, field='', condition=''):
"""
@brief execute sql commands, return result if it has
@param table String
@param field String
@param condition String
"""
sql = "DELETE FROM %s WHERE %s=%s" % (table, field, condition)
Log.debug('DB -> %s' % sql)
self.execute(sql)
def str2qr_terminal(text):
"""
@brief convert string to qrcode matrix and outprint
@param text The string
"""
Log.debug(text)
qr = qrcode.QRCode()
qr.border = 1
qr.add_data(text)
mat = qr.get_matrix()
print_qr(mat)
def insert(self, table, value):
"""
@brief Insert a row in table
@param table String
@param value Tuple
"""
col_name = self.table_cols[table][1:]
sql = "INSERT INTO %s(%s) VALUES (%s)" % (table, str(
','.join(col_name)), array_join(value, ','))
Log.debug('DB -> %s' % sql)
self.execute(sql)
def create_table(self, table, cols):
"""
@brief Creates a table in database
@param table String
@param cols String, the cols in table
"""
if table not in self.table_cols:
sql = 'CREATE TABLE IF NOT EXISTS %s(id int primary key auto_increment, %s) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci' % (table, cols)
Log.debug('DB -> %s' % sql)
self.execute(sql)
self.table_cols[table] = ['id'] + [c.strip().split(' ')[0] for c in cols.split(',')]
def insertmany(self, table, values):
"""
@brief Insert many rows in table
@param table String
@param values Array of tuple
"""
col_name = self.table_cols[table][1:]
sql = 'INSERT INTO %s(%s) VALUES (%s)' % (
table, ','.join(col_name), ','.join(['%s'] * len(values[0])))
Log.debug('DB -> %s' % sql)
self.execute(sql, values)
def load(self):
try:
with open(self.file_path, 'r') as fp:
content = fp.read()
fp.close()
self.blackList = json.loads(content)
return True
except IOError:
Log.w("{BlackSiteList.load} load file (%s) failed!",
self.file_path)
return False
def check_schedule_task(self):
# update group member list at 00:00 am every morning
t = time.localtime()
if t.tm_hour == 0 and t.tm_min <= 1:
# update group member
Log.debug('update group member list everyday')
self.db.delete_table(Constant.TABLE_GROUP_LIST())
self.db.delete_table(Constant.TABLE_GROUP_USER_LIST())
self.db.create_table(Constant.TABLE_GROUP_LIST(), Constant.TABLE_GROUP_LIST_COL)
self.db.create_table(Constant.TABLE_GROUP_USER_LIST(), Constant.TABLE_GROUP_USER_LIST_COL)
self.wechat.fetch_group_contacts()
def get_token(self):
login_data = {
'username': self.username,
'password': self.password,
'public_key': None
}
token = requests.post(url=self.url + '/api/v1/authentication/auth/',
data=login_data).text
Log.debug('token is %s' % token)
self.headers['Authorization'] = 'Bearer %s' % json.loads(
token)['token']
def str2qr_terminal(text):
"""
@brief convert string to qrcode matrix and outprint
@param text The string
"""
Log.debug(text)
qr = qrcode.QRCode()
qr.border = 1
qr.add_data(text)
mat = qr.get_matrix()
print_qr(mat)
def loacal_files_check(files):
if not files:
return False, 0
try:
total_size = 0
for tfile in files:
total_size += os.path.getsize(tfile)
return True, total_size
except os.error:
Log.error("files %s not exist or can't access" % files)
return False, 0
def get_config_strategy(file_content):
ret_list = []
try:
config_obj = xmltodict.parse(file_content)
st_obj = config_obj["MyExchange"]["strategies"]["strategy"]
if not isinstance(st_obj, list):
st_obj = [st_obj]
for st in st_obj:
ret_list.append(st["@model_file"])
except Exception, ex:
Log.error("xml parse error! %s" % ex)
def get_aliyun_hosts(self,
register_prefix='',
default_re='',
extend_re='dev',
project=''):
client = AcsClient(self.accessKeyID, self.accessKeySecret, self.region)
request = DescribeInstancesRequest()
request.set_accept_format('json')
request.set_PageNumber(1)
request.set_PageSize(50)
response = client.do_action_with_exception(request)
data = json.loads(response)
PageNumber = int(data['TotalCount'] / 50 + 2)
list = []
search_shard = extend_mesage(project)
for Number in range(1, PageNumber):
request.set_PageNumber(Number)
request.set_PageSize(50)
response = client.do_action_with_exception(request)
data = json.loads(response)
for host in data['Instances']['Instance']:
dict = {}
id = re.split(r'-', host['SerialNumber'])
id = ''.join(str(i) for i in id)
dict['id'] = id
dict['ip'] = host['NetworkInterfaces']['NetworkInterface'][0][
'PrimaryIpAddress']
if register_prefix:
dict['hostname'] = str(
register_prefix) + host['InstanceName']
else:
dict['hostname'] = host['InstanceName']
dict['is_active'] = 'true'
dict['platform'] = "Linux"
try:
dict['comment'] = search_shard[dict['ip']]
except KeyError:
if 'Tags' in host:
comment = host['Tags']['Tag'][0]['TagValue']
dict['comment'] = "[%s]" % comment
else:
dict['comment'] = "[123]"
# if host['InstanceName'].startswith('G') or host['InstanceName'].startswith('c'):
final_re = '|'.join(
default_re.split('|') + extend_re.split('|')).strip('|')
if re.search(final_re, host['InstanceName']):
dict['group'] = ['dev']
else:
dict['group'] = ['base']
list.append(dict)
Log.debug(list)
return list
def ret_run(str, func, *args):
t = time.time()
r = False
try:
r = func(*args)
return r
except:
if bool(config("setting", "maillisten")):
sendmsg(config("run", "run_name"),
str + ":" + traceback.format_exc())
Log.error(str + ":" + traceback.format_exc())
return False
def select(self, table, field='', condition=''):
"""
@brief select all result from table
@param table String
@param field String
@param condition String
@return result Tuple
"""
sql = "SELECT * FROM %s" % table
if field and condition:
sql += " WHERE %s='%s'" % (field, condition)
Log.debug('DB -> %s' % sql)
return self.execute(sql)
def update(self, table, dic, condition=''):
k_arr = []
v_arr = []
for (k, v) in dic.items():
k_arr.append('%s=?' % k)
v_arr.append(v)
sql = "UPDATE %s SET %s" % (table, ','.join(k_arr))
if condition:
sql += " WHERE %s" % condition
Log.debug('DB -> %s' % sql)
self.execute(sql, tuple(v_arr))
def update(self, table, dic, condition=''):
k_arr = []
v_arr = []
for (k, v) in dic.items():
k_arr.append('%s=?' % k)
v_arr.append(v)
sql = "UPDATE %s SET %s" % (table, ','.join(k_arr))
if condition:
sql += " WHERE %s" % condition
Log.debug('DB -> %s' % sql)
self.execute(sql, tuple(v_arr))
def get_ev_files(vpn_ip, path):
pre_dir = os.path.dirname(path)
my_capital = os.path.join(pre_dir, "my_capital.config")
cli = SSHClient()
try:
ret = cli.cmd(vpn_ip, "cmd.run", ["cat %s" % my_capital])
if ret.get(vpn_ip).get("retcode") == 0:
capital_content = ret.get(vpn_ip).get("return")
sts = get_config_strategy(capital_content)
print "sts: ", sts
return strategy_map_ev(sts)
except Exception, ex:
traceback.print_exc()
Log.error("get ev files error! %s" % ex)
def snapshot(self):
"""
@brief Save basic infos for next login.
@return Bool: whether operation succeed.
"""
try:
conf = {
'uuid': self.uuid,
'redirect_uri': self.redirect_uri,
'uin': self.uin,
'sid': self.sid,
'skey': self.skey,
'pass_ticket': self.pass_ticket,
'synckey': self.synckey,
'device_id': self.device_id,
'last_login': time.time(),
}
cm = ConfigManager()
Log.debug('save wechat config')
cm.set_wechat_config(conf)
# save cookie
Log.debug('save cookie')
if self.cookie:
self.cookie.save(ignore_discard=True)
# save contacts
Log.debug('save contacts')
self.save_contacts()
except Exception, e:
Log.error(traceback.format_exc())
return False
def post(url, params, jsonfmt=True):
"""
@brief http post request
@param url String
@param params Dict, post params
@param jsonfmt Bool, whether is json format
@return http response
"""
Log.debug('POST -> '+url)
Log.debug(params)
if jsonfmt:
request = urllib2.Request(url=url, data=json.dumps(params, ensure_ascii=False).encode('utf8'))
request.add_header(*Constant.HTTP_HEADER_CONTENTTYPE)
else:
request = urllib2.Request(url=url, data=urllib.urlencode(params))
while True:
try:
response = urllib2.urlopen(request, timeout=30)
data = response.read()
response.close()
if jsonfmt:
Log.debug(data)
return json.loads(data, object_hook=_decode_data)
return data
except (KeyboardInterrupt, SystemExit):
raise
except:
Log.error(traceback.format_exc())
time.sleep(1)
def run(str, func, *args):
t = time.time()
echo(str)
r = False
try:
r = func(*args)
except:
Log.error(traceback.format_exc())
if r:
totalTime = int(time.time() - t)
echo(Constant.RUN_RESULT_SUCCESS % totalTime)
else:
echo(Constant.RUN_RESULT_FAIL)
exit()
def recover_contacts(self):
"""
@brief recover contacts.
@return Bool: whether operation succeed.
"""
try:
self.User = pickle_load(self.pickle_file['User'])
self.MemberList = pickle_load(self.pickle_file['MemberList'])
self.GroupList = pickle_load(self.pickle_file['GroupList'])
self.GroupMemeberList = pickle_load(self.pickle_file['GroupMemeberList'])
self.SpecialUsersList = pickle_load(self.pickle_file['SpecialUsersList'])
return True
except Exception, e:
Log.error(traceback.format_exc())
def insertmany(self, table, values):
"""
@brief Insert many rows in table
@param table String
@param values Array of tuple
"""
c = self.conn.cursor()
self.lock.acquire()
n = len(values[0])
sql = ("INSERT INTO %s VALUES (" + ",".join(['?'] * n) + ");") % table
Log.debug('DB -> %s' % sql)
try:
c.executemany(sql, values)
except Exception, e:
Log.error(traceback.format_exc())
def run(self):
'''
Start process, the subclass must rewrite this function or 'handle' function
when all the father processes quits, then break to quit
'''
if self.log:
self.log = Log(self.name, toFile="plugin")
self.log.info("plugin {0} start, ins:{1}, outs:{2}".format(self.name, self._ins, self._outs))
else:
self.log = False
while True:
try:
data = self.get()
#print "debug:", "plugin ", self.name, "getting", "ins<<<<<<<<", [str(x) for x in self._ins]
except QueueEmpty:
continue
except IOError:
break
except EOFError:
break
except PluginExit:
self.quit()
#print "debug:", "plugin ", self.name, "quit"
if self.log:
self.log.info("plugin {0} quit".format(self.name))
break
else:
#print "debug:", "plugin ", self.name, "got", data
self.handle(data)
finally:
time.sleep(self.timeout)
def save_file(filename, data, dirName):
"""
@brief Saves raw data to file.
@param filename String
@param data Binary data
@param dirName String
@return file path
"""
Log.debug('save file: ' + filename)
fn = filename
if not os.path.exists(dirName):
os.makedirs(dirName)
fn = os.path.join(dirName, filename)
with open(fn, 'wb') as f:
f.write(data)
return fn
def set_cookie(cookie_file):
"""
@brief Load cookie from file
@param cookie_file
@param user_agent
@return cookie, LWPCookieJar
"""
cookie = cookielib.LWPCookieJar(cookie_file)
try:
cookie.load(ignore_discard=True)
except:
Log.error(traceback.format_exc())
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie))
opener.addheaders = Constant.HTTP_HEADER_USERAGENT
urllib2.install_opener(opener)
return cookie
def save_json(filename, data, dirName, mode='w+'):
"""
@brief Saves dict to json file.
@param filename String
@param data Dict
@param dirName String
@return file path
"""
Log.debug('save json: ' + filename)
fn = filename
if not os.path.exists(dirName):
os.makedirs(dirName)
fn = os.path.join(dirName, filename)
with open(fn, mode) as f:
f.write(json.dumps(data, indent=4)+'\n')
return fn
