def check_validate_code(func):
if callable(func):
@functools.wraps(func)
def check_validate_code_wrapper(*args, **kwargs):
_validate_code_string = flask.session.pop('_validate_code_string', None)
flask.session.pop('_validate_code_img', None)
validate_code = flask.request.values.get('validate_code', None)
if flask.request.method == "POST" or validate_code:
if not validate_code or not _validate_code_string or validate_code != _validate_code_string:
flask.session['WRONG_VALIDATE_CODE'] = True
else:
flask.session.pop('WRONG_VALIDATE_CODE', None)
else:
flask.session.pop('WRONG_VALIDATE_CODE', None)
need_remove_alert_cookie = not flask.session.get("NO_REMOVE_ALERT_COOKIE", False)
response = flask.make_response(func(*args, **kwargs))
if is_validate_code_wrong():
response.set_cookie('WRONG_VALIDATE_CODE', 'True')
elif need_remove_alert_cookie:
response.delete_cookie('WRONG_VALIDATE_CODE')
return response
return check_validate_code_wrapper
else:
_validate_code_string = flask.session.pop('_validate_code_string', None)
flask.session.pop('_validate_code_img', None)
validate_code = func
logger.info(_validate_code_string)
logger.info(validate_code)
if not validate_code or not _validate_code_string or validate_code != _validate_code_string:
return False
return True
def getSubForumList(self, id, parentId=-9999):
url = RutrackerConfig.forumUrl.format(id)
contentPage = self.__getPage(url)
bs = BeautifulSoup(contentPage,"html.parser")
divPageContent = bs.find(id="main_content_wrap")
if divPageContent == None:
logger.info("下载页面出错:%s", bs.find(name="div", attrs={"class":"msg-main"}).text)
return
naviList = []
name = divPageContent.find(name="h1", attrs={"class":"maintitle"}).text
currentNav = NaviItem(forumId=id, name=name)
if parentId != -9999:
currentNav.parentForumId = parentId
currentNav.url = url
currentNav.parentUrl=RutrackerConfig.forumUrl.format(parentId),
else:
tableNav = divPageContent.find(name="table", attrs={"class":"w100"})
tdNav = tableNav.td
forumNavList=self.__parseNavList(tableNav)
cNav=forumNavList[len(forumNavList) - 1]
currentNav.parentForumId=cNav.parentForumId
naviList.append(forumNavList[len(forumNavList) - 2])
naviList.append(currentNav)
h4ForumList=divPageContent.findAll(name="h4", attrs={"class":"forumlink"})
for h4Forum in h4ForumList:
aLink = h4Forum.a
link = aLink["href"]
cid = link[len("viewforum.php?f="):]
name = aLink.text
parentForumId=id
parentForumUrl=url
nav=NaviItem(forumId=cid, name=name, url=RutrackerConfig.url.format(link), parentForumId=parentForumId, parentUrl=parentForumUrl)
naviList.append(nav)
return naviList
def restart(self):
logger.info("Restart %s" % (self.name))
if not utils.check_hostname(self.ip):
print("Bad device")
return False
else:
print("Good device")
return True
def signal_handler(signum, frame):
global test_list
if (signum == signal.SIGINT):
logger.info('Application terminated by user')
end_test()
if (signum == signal.SIGTERM):
logger.info('Application terminated by kill command')
end_test()
def api_login():
data = {"status": "error"}
if flask.request.is_json:
json = flask.request.get_json()
username = json.get('username', None)
password = json.get('password', None)
validate_code = json.get('validate_code', None)
if not validate_code:
data["reason"] = "no_validate_code"
return flask.jsonify(data)
if not check_validate_code(validate_code):
data["reason"] = "error_validate_code"
return flask.jsonify(data)
if username == '':
username = "******"
if username:
user_info = self.check_user_password(username, password)
if user_info:
uid = str(uuid.uuid1())
signed_uid = itsdangerous.Signer(user_info.password, salt='LoginChecker:uid').sign(
uid.encode(errors='ignore')).decode(
errors='ignore')
self.signed_uid = signed_uid
self.username = username
self.uid = uid
self.is_admin = user_info.is_admin
self.user_id = user_info.id
self.role = user_info.role
if use_mongoengine:
user_login_data = UserLoginData(uid=uid, user=user_info, username=username,
timestamp=int(time.time() * 1e3),
datetime=datetime.now(),
utc_datetime=datetime.utcnow())
user_login_data.save()
logger.info("<username=%s,uid=%s> save login with mongodb" % (username, uid))
elif use_peewee:
with db.execution_context():
UserLoginData.create(uid=uid, user=user_info, username=username,
timestamp=int(time.time() * 1e3),
datetime=datetime.now(),
utc_datetime=datetime.utcnow())
logger.info("<username=%s,uid=%s> save login with peewee" % (username, uid))
data["status"] = "ok"
data["username"] = self.username
data["is_admin"] = self.is_admin
data["role"] = self.role
data["uid"] = self.signed_uid
data["_csrf_token"] = get_csrf_token()
resp = flask.make_response(flask.jsonify(data))
self.save_login_info_to_cookie(resp)
return resp
data["reason"] = "error_user"
else:
data["reason"] = "no_json"
return flask.jsonify(data)
def append(self, test_name, **parameters):
logger.info("Append name \"%s\" " % (test_name))
if parameters == {}:
obj = tests[test_name]()
else:
obj = tests[test_name](**parameters)
if obj is not None:
logger.debug("Appended name \"%s\" " % (test_name))
self.__data[test_name + str(self.__id)] = obj
self.__id = self.__id + 1
def __parseForum(self, page, forum, loadPage=True):
bs = BeautifulSoup(page,"html.parser")
divPageContent = bs.find(id="main_content_wrap")
if divPageContent == None:
logger.info("下载页面出错:%s", bs.find(name="div", attrs={"class":"msg-main"}).text)
forum.error = True
return
if loadPage:
self.__parseNavgateInfo(divPageContent, forum)
tableTor=divPageContent.find(name="table", attrs={"class":"vf-tor"})
if tableTor == None:
return
forumItemList=[]
for trForumItem in tableTor.children:
if not isinstance(trForumItem, Tag) or trForumItem.name != "tr" or not trForumItem.has_attr("id") or trForumItem["id"] == "" or not trForumItem.has_attr("data-topic_id"):
continue
topicId=trForumItem["data-topic_id"]
id=trForumItem["id"]
imgTopicIcon=trForumItem.img
topicIcon=imgTopicIcon["src"]
divColumTitle=trForumItem.find(name="td", attrs={"class":"vf-col-t-title"})
divTorTopic=divColumTitle.div
spanApprovedLabel=divTorTopic.span
if spanApprovedLabel != None:
approvedLabel=spanApprovedLabel.text
else :
logger.info("no approvedLabel info for %s", topicId)
continue
spanAuthLabel=divTorTopic.find(name="span", attrs={"class":"ttp-label ttp-auth"})
authLabel=""
if spanAuthLabel != None:
authLabel=spanAuthLabel.text
torTopicTitle=divTorTopic.find(name="a", attrs={"id": "tt-"+topicId}).text
divtopicAuthor=divColumTitle.find(name="a", attrs={"class":"topicAuthor"})
if divtopicAuthor != None:
topicAuthor = divtopicAuthor.text
else:
topicAuthor=divColumTitle.find(name="div", attrs={"class":"topicAuthor"}).text
torrentInfo=self.__parseTorrentInfo(trForumItem)
topicReplies=self.__parseTopicReplies(trForumItem)
tdLastPost=trForumItem.find(name="td", attrs={"class":"vf-col-last-post"})
lastPostInfo=self.__parseLastReplyInfo(tdLastPost)
forumItem=RutrackerForumItem(topicId=topicId, topicIcon=topicIcon, approvedLabel=approvedLabel, authLabel=authLabel, rutrackerForumId=forum.forumId,
torTopicTitle=torTopicTitle, topicAuthor=topicAuthor, torrentInfo=torrentInfo, topicReplies=topicReplies,
lastPostInfo=lastPostInfo)
forumItemList.append(forumItem)
forum.forumItemList=forumItemList
def get(self, request, format=None):
# 2019-04-17 00:00:00
try:
data = request.GET
# 查询条件
datetime_start = datetime.strptime(data.get('datetime_start'),
'%Y-%m-%d %H:%M:%S')
datetime_end = datetime.strptime(data.get('datetime_end'),
'%Y-%m-%d %H:%M:%S')
db_name = data.get('db_type')
collection_name = data.get('db_instance')
accountName = data.get('account_name', '.*')
sql_text = '.*{}.*'.format(
data.get('cmd')) if data.get('cmd') else '.*'
# 分页
page = int(data.get('page', 1))
size = int(data.get('size', 10))
skip_count = (page - 1) * size
collection = mongodb_client[db_name][collection_name]
cursor = collection.find({
'ExecuteTime': {
'$gte': datetime_start,
'$lte': datetime_end
},
'AccountName': {
'$regex': accountName
},
'SQLText': {
'$regex': sql_text
}
}).sort('ExecuteTime', DESCENDING)
# 分页后的数据
documents = list(cursor.skip(skip_count).limit(size))
# 转换MongoDBObjectId
for i in range(len(documents)):
documents[i]['_id'] = str(documents[i]['_id'])
data = {'count': cursor.count(), 'results': documents}
return Response(data)
except (ValueError, TypeError) as e:
logger.info(e)
return Response({'detail': str(e)},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error(e)
return Response({'detail': str(e)},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def delete_timeout_data(self, ttl=7):
if isinstance(ttl, int):
ttl = timedelta(days=ttl)
old_datetime = datetime.utcnow() - ttl
if use_mongoengine:
result = UserLoginData.objects(utc_datetime__lt=old_datetime).delete()
logger.info("delete %d timeout data" % result)
elif use_peewee:
with db.execution_context():
query = UserLoginData.delete().where(UserLoginData.utc_datetime < old_datetime) # type:peewee.Query
result = query.execute()
logger.info("delete %d timeout data" % result)
def test_code():
global tests
# Enable debug message
# Default info
if verbose:
logging.getLogger().setLevel(logging.DEBUG)
fmt = logging.Formatter(utils.FORMAT_DBG)
utils.hndlr.setFormatter(fmt)
fmt = logging.Formatter("%(asctime)-15s " + utils.FORMAT_DBG)
utils.filehndlr.setFormatter(fmt)
else:
logging.getLogger().setLevel(logging.INFO)
fmt = logging.Formatter(utils.FORMAT_INFO)
utils.hndlr.setFormatter(fmt)
fmt = logging.Formatter("%(asctime)-15s " + utils.FORMAT_INFO)
utils.filehndlr.setFormatter(fmt)
# Posix handler
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
#---------------------------------------------------------------
#-------------------- PRINT AVAILIBLE TESTS --------------------
#---------------------------------------------------------------
if list_tests:
print("Availible tests:")
for key in sorted(checks.tests_list.keys()):
if hasattr(checks.tests_list[key], 'test_desc'):
print("*** %-30s *** Description: %s" %
(key, checks.tests_list[key].test_desc))
else:
print("*** %-30s ***" % (key))
return
#---------------------------------------------------------------
#-------------------------- ADD TESTs --------------------------
#---------------------------------------------------------------
logger.info('Loading User tests')
tvss_user_conf.user_conf()
#---------------------------------------------------------------
#-------------------------- RUN TESTs --------------------------
#---------------------------------------------------------------
logger.info('Start test TVSS')
tests.run()
# Application loop
while True:
time.sleep(0.1)
def is_login(self):
if self.username is None:
username = flask.request.cookies.get('MEMBER_LOGIN', None)
signed_uid = flask.request.cookies.get('UID', None)
if username and signed_uid and (use_mongoengine or use_peewee):
user_info = self.get_user_info(username)
if user_info:
try:
uid = itsdangerous.Signer(user_info.password, salt='LoginChecker:uid').unsign(
signed_uid).decode(
errors='ignore')
except itsdangerous.BadData:
return False
if use_mongoengine:
user_login_data = UserLoginData.objects(uid=uid, user=user_info.id, username=username).first()
if user_login_data:
self.is_admin = user_info.is_admin
self.username = username
self.uid = uid
self.signed_uid = signed_uid
self.user_id = user_info.id
self.role = user_info.role
user_login_data.timestamp = int(time.time() * 1e3)
user_login_data.datetime = datetime.now()
user_login_data.utc_datetime = datetime.utcnow()
user_login_data.save()
logger.info("<username=%s,uid=%s> pass login with mongodb" % (username, uid))
return True
return False
elif use_peewee:
with db.execution_context():
user_login_data = UserLoginData.get(UserLoginData.uid == uid,
UserLoginData.user == user_info.id,
UserLoginData.username == username)
if user_login_data:
self.is_admin = user_info.is_admin
self.username = username
self.uid = uid
self.signed_uid = signed_uid
self.user_id = user_info.id
self.role = user_info.role
user_login_data.timestamp = int(time.time() * 1e3)
user_login_data.datetime = datetime.now()
user_login_data.utc_datetime = datetime.utcnow()
user_login_data.save()
logger.info("<username=%s,uid=%s> pass login with peewee" % (username, uid))
return True
return False
return False
return False
return True
def getForumAllPage(self, id, start=1):
firstForumInfo = self.getForumInfoByPage(id=id)
if hasattr(firstForumInfo, "error") and firstForumInfo.error != None:
return
totalPage= firstForumInfo.totalPage
logger.info("下载第1页, 共%d",totalPage )
self.saveForumInfo(firstForumInfo, saveForumNavi=True)
for i in range(start, totalPage - 1):
time.sleep(random.uniform(0.1, 1))
logger.info("下载第{0}页".format(i + 1))
forumInfo= self.getForumInfoByPage(id, i)
self.saveForumInfo(forumInfo, saveForumNavi=False)
def tests_from_topo(config_root, topo_fname):
topology_file = config_root + '/' + topo_fname
logger.info("Load topology file %s" % topology_file)
if not os.path.exists(topology_file):
logger.warning("Can't open tvss_topology.cfg")
return
# Open topology file
fd_topo = open(topology_file, 'r')
__topology = json.load(fd_topo)
logger.info("Load devices from topology")
for sw_obj in __topology['devices']:
# Check sw
if not sw_obj.get('errors'):
if switches.get(sw_obj['id']) is not None:
sw = sw_moxa.sw_moxa(mac=sw_obj['id'],
ip=sw_obj['ip_address'],
name=sw_obj['location'],
user="******",
password="******",
snmp_rw_pass="******",
ports=switches.get(sw_obj['id']))
if sw is not None:
# tvss_test.tests.append("SW MOXA test restart", target=sw)
# tvss_test.tests.append("SW MOXA complex test", target=sw)
tvss_test.tests.append("SW MOXA complex thread test",
target=sw,
min_sleep=120,
max_sleep=180)
for vc_obj in sw_obj['vc']:
if vc_obj['name'] != "VC99":
# Check vc
vc = vc_axis.vc_axis(mac=vc_obj['id'],
ip=vc_obj['ip_address'],
name=vc_obj['name'],
user="******",
password="******",
snmp_rw_pass="******")
if vc is not None:
# tvss_test.tests.append("VC AXIS test restart", target=vc)
# tvss_test.tests.append("VC AXIS test RTSP", target=vc)
# tvss_test.tests.append("VC AXIS test UDP", target=vc)
tvss_test.tests.append(
"VC AXIS complex thread test",
target=vc,
min_sleep=120,
max_sleep=180)
# Close topology file
fd_topo.close()
def start(self):
try:
retcode = call("service %s %s" % (self.service_name, "start"),
shell=True)
if retcode < 0:
logger.error("%s: Unable start the service" %
(self.service_name))
elif retcode == 0:
logger.info("%s: Service is started succesfully" %
(self.service_name))
self.__state = Service_State.run
else:
logger.warning("Service already started")
except OSError as e:
logger.error("Execution failed: %s", e)
def check_user_password(self, username, password):
user_info = self.get_user_info(username)
if not user_info:
if username == "admin":
self.add_user("admin", "admin", True)
logger.info('Create default admin user with <username:admin,password:admin>')
return self.check_user_password(username, password)
return False
if self.ignore_check_user:
return user_info
db_password = user_info.password
if self.check_password_hash(db_password, password):
return user_info
else:
return False
def state(self):
try:
logger.debug("%s: Check service state", self.service_name)
FNULL = open(os.devnull, 'w')
retcode = call("pgrep %s" % (self.service_name),
stdout=FNULL,
stderr=subprocess.STDOUT,
shell=True)
if retcode == 0:
logger.info("%s: Service runnig" % (self.service_name))
return Service_State.run
else:
logger.info("%s: Service stopped" % (self.service_name))
return Service_State.stop
except OSError as e:
logger.error("Execution failed: %s", e)
def remove_login(self, response):
username = self.username
uid = self.uid
del self.is_login
response.delete_cookie('MEMBER_LOGIN')
response.delete_cookie('UID')
response.delete_cookie('IS_ADMIN')
if username and uid:
if use_mongoengine:
UserLoginData.objects(uid=uid, username=username).delete()
logger.info("<username=%s,uid=%s> remove login with mongodb" % (username, uid))
elif use_peewee:
with db.execution_context():
query = UserLoginData.delete().where(UserLoginData.uid == uid,
UserLoginData.username == username) # type:peewee.Query
query.execute()
logger.info("<username=%s,uid=%s> remove login with peewee" % (username, uid))
return response
def add_user(self, username, password, is_admin=False):
password = self.generate_password_hash(password)
if use_mongoengine:
try:
user = User(username=username, password=password, is_admin=is_admin)
user.save()
logger.info("create new user <username=%s,user_id=%s> into mongodb" % (username, user.id))
return user
except mongoengine.NotUniqueError:
raise UserWasExist
elif use_peewee:
try:
with db.execution_context():
user = User.create(id=str(uuid.uuid4()), username=username, password=password, is_admin=is_admin)
logger.info("create new user <username=%s,user_id=%s> into mysql" % (username, user.id))
return user
except peewee.PeeweeException:
raise UserWasExist
def get_token(self, prefix='token'):
"""
登录获取token
"""
data = json.dumps({ "userName": self.username, "password": self.password})
headers = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
token_url = '{}{}'.format(self.url, prefix)
try:
req = requests.post(token_url, headers=headers,
data=data, verify=False, timeout=self.timeout)
if req.status_code == 200:
logger.info('获取OA token: {}'.format(req.json()))
return req.json().get('id')
except Exception as e:
logger.error(e)
return ''
def state_str(self):
if self.__state == Service_State.unknown:
logger.info("%s: Service state unknown" % (self.service_name))
elif self.__state == Service_State.run:
logger.info("%s: Service running" % (self.service_name))
elif self.__state == Service_State.stop:
logger.info("%s: Service stopped" % (self.service_name))
def getAllSubForumInfo(self, saveColume=False):
url="https://rutracker.org/forum/index.php"
contentPage = self.__getPage(url)
bs = BeautifulSoup(contentPage,"html.parser")
divPageContent = bs.find(id="categories-wrap")
if divPageContent == None:
logger.info("下载页面出错:%s", bs.find(name="div", attrs={"class":"msg-main"}).text)
return
divCategoryList=divPageContent.findAll(name="div", attrs={"class":"category"})
cateGoryList=[]
naviList=[]
for divCategory in divCategoryList:
aTitle=divCategory.h3.a
categoryTitle=aTitle.text
categoryLink =aTitle["href"]
categoryUrl=RutrackerConfig.url.format(categoryLink)
categoryId = divCategory["id"][len("c-"):]
catagoryNav=NaviItem(forumId=categoryId, name=categoryTitle,
url=categoryUrl,
parentForumId=-2, parentUrl=url)
cateGoryList.append(catagoryNav)
h4ForumList=divCategory.findAll(name="h4", attrs={"class":"forumlink"})
for h4Forum in h4ForumList:
aLink = h4Forum.a
link = aLink["href"]
cid = link[len("viewforum.php?f="):]
name = aLink.text
parentForumId=categoryId
parentForumUrl=categoryUrl
nav=NaviItem(forumId=cid, name=name, url=RutrackerConfig.url.format(link), parentForumId=parentForumId, parentUrl=parentForumUrl)
naviList.append(nav)
if saveColume:
self.saveSubForumInfo(cateGoryList)
self.saveSubForumInfo(naviList)
return naviList
def post(self, request, *args, **kwargs):
username = request.data.get('username')
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
user = serializer.object.get('user') or request.user
token = serializer.object.get('token')
response_data = jwt_response_payload_handler(token, user, request)
response = Response(response_data)
if api_settings.JWT_AUTH_COOKIE:
expiration = (datetime.utcnow() +
api_settings.JWT_EXPIRATION_DELTA)
response.set_cookie(api_settings.JWT_AUTH_COOKIE,
token,
expires=expiration,
httponly=True)
set_last_login(username)
write_login_log(request, username=username, status=True, type='JWT')
return response
else:
logger.info(serializer.errors)
write_login_log(request, username=username, status=False, type='JWT')
return Response({'detail': '用户名或密码错误'}, status=status.HTTP_400_BAD_REQUEST)
def sendNewPassw(email, newpassw):
html_content = '用户名：' + email + ', 新密码：' + newpassw
sendEmail('密码重置', html_content, email)
logger.info((email + ":" + html_content).encode("utf-8"))
def generate_validate_code_to_db(string=None):
if string:
if use_mongoengine:
query_set = ValidateCode.objects(string=string)
if query_set.count():
return query_set.first().base64_img
elif use_peewee:
with db.execution_context():
query_set = ValidateCode.select().where(ValidateCode.string == string)
if query_set.count():
return query_set.first().base64_img
start_time = time.time()
img_bytes, strs = create_validate_code(string)
end_time = time.time()
logger.info("create_validate_code <%s> use time: %f s" % (strs, (end_time - start_time)))
encode_img = base64_encode(img_bytes, return_type=str)
size = len(encode_img)
logger.info("encode_img length = %d" % size)
start_time = time.time()
if use_mongoengine:
ValidateCode(string=string, base64_img=encode_img).save()
elif use_peewee:
with db.execution_context():
ValidateCode.create(string=string, base64_img=encode_img)
end_time = time.time()
logger.info("insert <%s> to mongodb use time: %f s" % (strs, (end_time - start_time)))
return encode_img
if use_peewee:
with db.execution_context():
# Only create the tables if they do not exist.
db.create_tables([ValidateCode], safe=True)
time1 = time.time()
total_size = 0
for num in range(10000):
string = "%04d" % num
if use_mongoengine:
if ValidateCode.objects(string=string).count():
logger.info("validate_code <%s> was already in mongodb, skip it" % string)
continue
elif use_peewee:
with db.execution_context():
if ValidateCode.select().where(ValidateCode.string == string).count():
logger.info("validate_code <%s> was already in mongodb, skip it" % string)
continue
# 把strs发给前端,或者在后台使用session保存
start_time = time.time()
img_bytes, strs = create_validate_code(string)
end_time = time.time()
logger.info("create_validate_code <%s> use time: %f s" % (strs, (end_time - start_time)))
encode_img = base64_encode(img_bytes, return_type=str)
size = len(encode_img)
total_size += size
logger.info("encode_img length = %d" % size)
logger.info("total_size = %d" % total_size)
start_time = time.time()
if use_mongoengine:
ValidateCode(string=string, base64_img=encode_img).save()
elif use_peewee:
with db.execution_context():
ValidateCode.create(string=string, base64_img=encode_img)
end_time = time.time()
logger.info("insert <%s> to mongodb use time: %f s" % (strs, (end_time - start_time)))
time2 = time.time()
logger.info("total use time: %f s" % (time2 - time1))
logger.info("total_size = %d" % total_size)
def missionPlannerServer():
global inputs, outputs, MISSION_PLANNER_S, deviceConnectionToIPMap, messageForMPQueue, logger
logger.info("Mission Planner Server start at port: " + str(MP_PORT))
# TCP 入口主程序，负责接收网络连接，然后分发到子线程处理
while True:
# global MP_PORT
try:
readables, writables, exceptional = select.select(
inputs, outputs, [], .5)
except:
if not (readables or writables or exceptional):
break
else:
# 循环处理 可读 列表
for s in readables:
if s is server:
# 接收网络请求
connection, addr = s.accept()
connection.setblocking(0)
logger.info("MP connection from: " + addr[0] + ":" +
str(addr[1]))
inputs.append(connection)
# 接受客户端连接请求
deviceConnectionToIPMap[connection] = addr
d = getOrBuildMPClient(addr[0], addr[1], connection)
messageForMPQueue[d] = Queue.Queue(QUEUE_SIZE)
# 如果是客户端上传数据进来
else:
host, port = deviceConnectionToIPMap[s]
if deviceConnectionToIPMap.has_key(s):
try:
data = s.recv(BUF_SIZE)
except socket.error, e:
if 10035 == e.errno:
continue
# 如果对方强制关闭
else:
closeConnect(host, port, s)
except:
continue
else:
# 如果读数据成功，则处理由客户端上传数据
if data:
hexData = binascii.b2a_hex(data)
logger.debug("data from MP " + host + ":" +
str(port) + " " + hexData)
# 获取连接设备
d = getOrBuildMPClient(addr[0], addr[1], s)
d.counter += 1
# 第一次连接，第一个上行数据包为两个字节时
# 第一个字节，为指令，00则认为是关注哪个FC (此版忽略)
# 第二个字节，为数据，当第一个字节为00时，则代码关注哪个设备
if 5 > d.counter and len(data) == 2:
d.code = hexData[2:4]
else:
devicesServer.sendMessageToDevice(
d.code, data)
# 处理客户端上传的数据
# if s not in outputs:
# outputs.append(s)
# 如果为客户端关闭请求
else:
closeConnect(host, port, s)
pass
def deviceServer():
global messageForDeviceQueue, outputs, logger
logger.info("Device Server start at port: " + str(PORT))
# TCP 入口主程序，负责接收网络连接，然后分发到子线程处理
while True:
try:
#global PORT
readables, writables, exceptional = select.select(
inputs, outputs, [], .5)
except:
if not (readables or writables or exceptional):
break
else:
# 循环处理 可读 列表
for s in readables:
if s is server:
# 接收网络请求
connection, addr = s.accept()
connection.setblocking(0)
logger.info("Device connection from: " + addr[0] + ":" +
str(addr[1]))
inputs.append(connection)
deviceConnToHostMap[connection] = addr
messageForDeviceQueue[(addr[0],
addr[1])] = Queue.Queue(QUEUE_SIZE)
getOrBuildDevice(addr[0], addr[1], connection)
# 如果是客户端其它数据进来
else:
host, port = deviceConnToHostMap[s]
try:
data = s.recv(BUF_SIZE)
except socket.error, e:
if 10035 == e.errno:
continue
# 如果对方强制关闭
else:
logger.info("closing FC:" + host)
closeConnection(host, port, s)
except:
continue
else:
# 0000000000000000000000000000000000000000000000000000000000000000
host, port = deviceConnToHostMap[s]
# 如果读数据成功，则处理由客户端上传数据
if data:
d = getOrBuildDevice(host, port, s)
d.counter += 1
hexData = binascii.b2a_hex(data)
# 如果上传数据大于，则取第四个字节做为设备编号
if "-1" == d.code and len(
data) > 4 and "fe" == hexData[0:2]:
d.code = hexData[6:8]
logger.debug("get the FC code:" + d.code +
" msg:" + hexData)
# 处理设备上传的数据
# service.logServerService.receiveData(data, d)
# 信息透传到 MissionPlanner
missionPlannerServer.sendMessageToMPClient(data, d)
logger.debug("data from FC " + host + " " +
hexData)
# if s not in outputs:
# outputs.append(s)
# 如果为客户端关闭请求
else:
closeConnection(host, port, s)
def up_iff(self, id_iff):
logger.info("Enable at %s/%s port %s" % (self.name, self.ip, id_iff))
def sendActiveEmail(username):
encoded = jwt.encode({'username': username}, 'secret', algorithm='HS256')
html_content = sys_template['regist_email_content'] + encoded.decode(
"utf-8")
sendEmail('邮箱验证', html_content, username)
logger.info(username + ":" + html_content)
def handler(self):
logger.info("Run test \"%s\"" % (self.__name))
def enable_rtsp(self):
logger.info("Enable RTSP at %s" % (self.name))
if not utils.check_hostname(self.ip):
return False
else:
return True
