class HighLevelResponderTests(unittest.TestCase):
def test_it_hooks_into_socket_sends_and_receives(self):
transmitter = JsonTransmitter(self.connection_socket)
handler = ResponseHandler(MoveGenerator())
responder = Responder(transmitter, handler)
game_info = json.dumps({"board": {1: "o", 3: "o"}, "depth": 20})
self.sock.send(game_info)
responder.respond()
data_received = self.sock.recv(1024)
updated_game = json.loads(data_received)
WIN_MOVE = 2
self.assertEqual(WIN_MOVE, updated_game["ai_move"])
self.assertEqual("o", updated_game["winner_after_ai_move"])
self.assertEqual(None, updated_game["winner_on_board"])
def setUp(self):
PORT = random.randint(2000, 60000)
self.server = ServerSocket("localhost", PORT)
self.server.initialize_and_listen_for_connections()
self.sock = socket.socket()
self.sock.connect(("localhost", PORT))
self.connection_socket = self.server.accept_connection_and_return_socket(
)
def tearDown(self):
self.sock.close()
self.connection_socket.close()
class HighLevelResponderTests(unittest.TestCase):
def test_it_hooks_into_socket_sends_and_receives(self):
transmitter = JsonTransmitter(self.connection_socket)
handler = ResponseHandler(MoveGenerator())
responder = Responder(transmitter,handler)
game_info = json.dumps({ "board": {1:"o",3:"o"},
"depth": 20 })
self.sock.send(game_info)
responder.respond()
data_received = self.sock.recv(1024)
updated_game = json.loads(data_received)
WIN_MOVE = 2
self.assertEqual(WIN_MOVE, updated_game["ai_move"])
self.assertEqual("o" ,updated_game["winner_after_ai_move"])
self.assertEqual(None, updated_game["winner_on_board"])
def setUp(self):
PORT = random.randint(2000,60000)
self.server = ServerSocket("localhost",PORT)
self.server.initialize_and_listen_for_connections()
self.sock = socket.socket()
self.sock.connect(("localhost",PORT))
self.connection_socket = self.server.accept_connection_and_return_socket()
def tearDown(self):
self.sock.close()
self.connection_socket.close()
def setUp(self):
PORT = random.randint(2000, 60000)
self.server = ServerSocket("localhost", PORT)
self.server.initialize_and_listen_for_connections()
self.sock = socket.socket()
self.sock.connect(("localhost", PORT))
self.connection_socket = self.server.accept_connection_and_return_socket(
)
def test_initialize_delegates_to_its_socket(self):
server = ServerSocket("localhost",5000)
server.socket = mock.Mock()
server.socket.bind = mock.MagicMock()
server.socket.listen = mock.MagicMock()
server.initialize_and_listen_for_connections()
server.socket.bind.assert_called_with(("localhost",5000))
self.assertEqual(1,server.socket.listen.call_count)
def __init__(self, segment_size, server_dir, port_max):
''' Create ReceivingQueue object '''
self.threads = {}
# gevent provides a synchronized queue (locking is handled)
self.host_queues = {}
self.socket_mgr = ServerSocket()
self.segment_size = segment_size
self.base_dir = server_dir
self.max_num_ports_per_host = port_max
def __init__(self):
# 初始化套接字
self.server_socket = ServerSocket()
# 保存客户端连接套接字
self.clients = dict()
# 请求处理方法
self.request_handle_functions = dict()
# 注册请求处理方法
self.register(REQUEST_LOGIN,
lambda sf, data: self.request_login_handle(sf, data))
self.register(REQUEST_CHAT,
lambda sf, data: self.request_chat_handle(sf, data))
def __init__(self):
self.server_socket = ServerSocket()
#request id and its corresponding handler function
self.req_handler_functions = {}
self.register(REQUEST_LOGIN, self.request_login_handler)
self.register(REQUEST_CHAT, self.request_chat_handler)
#save info of logged in user
self.clients = {}
#init db
self.db = DB()
def __init__(self):
# 创建服务器套接字
self.server_socket = ServerSocket()
# 创建请求的id和方法关联字典
self.request_handle_function = {}
self.register(REQUEST_LOGIN, self.request_login_handle)
self.register(REQUEST_CHAT, self.request_chat_handle)
self.register(REQUEST_SIGN_UP, self.request_sign_up_handle)
# 创建保存当前用户登录字典
self.clients = {}
# 创建数据库管理对象
self.db = DB()
def setUp(self):
PORT = random.randint(2000,60000)
self.server = ServerSocket("localhost",PORT)
self.server.initialize_and_listen_for_connections()
self.sock = socket.socket()
self.sock.connect(("localhost",PORT))
self.connection_socket = self.server.accept_connection_and_return_socket()
def test_accept_connection_delegates_to_its_socket(self):
server = ServerSocket("localhost",5000)
server.socket = mock.Mock()
server.socket.accept = mock.MagicMock(return_value=("client socket","address"))
self.assertEqual("client socket", server.accept_connection_and_return_socket())
def __init__(self):
self.soc = ServerSocket()
#self.gpio_handler = GPIOHandler()
self.camera = ServerCameraHandler()
class Controller:
"""
Drives the server side of TARS application. Controls the signals through GPIO pins based on the messages received
from the client connection.
"""
def __init__(self):
self.soc = ServerSocket()
#self.gpio_handler = GPIOHandler()
self.camera = ServerCameraHandler()
def parse_message(self, msg):
content = msg.split("|")
result = re.match(DIRECTION_TUPLE_PATTERN, content[1])
direction = list(result.groups())
for i in xrange(0, len(direction)):
direction[i] = int(direction[i])
settings = (tuple(direction), int(content[2]), float(content[3]))
return settings
def run(self):
try:
while True:
msg = self.soc.listen()
if msg == STARTUP:
print "startup"
#self.gpio_handler.startup()
elif msg.startswith(MOTOR_CHANGE):
settings = self.parse_message(msg)
#self.gpio_handler.motor_change(settings)
elif msg == DETECT_OBSTACLE:
#self.soc.reply("@" + str(self.gpio_handler.detect_obstacle()))
if randint(0,2):
self.soc.reply("@False")
else:
self.soc.reply("@True")
elif msg == CLICK_PICTURE:
self.soc.reply(str(self.camera.click_picture()))
elif msg in {STANDBY, SOCKET_ERROR}:
self.soc.standby()
elif msg == SHUTDOWN:
#self.gpio_handler.shutdown()
pass
except KeyboardInterrupt:
self.soc.shutdown()
#self.gpio_handler.shutdown()
sys.exit()
class ReceivingQueue():
''' Class to receiving queue process '''
def __init__(self, segment_size, server_dir, port_max):
''' Create ReceivingQueue object '''
self.threads = {}
# gevent provides a synchronized queue (locking is handled)
self.host_queues = {}
self.socket_mgr = ServerSocket()
self.segment_size = segment_size
self.base_dir = server_dir
self.max_num_ports_per_host = port_max
def add(self, segments, host):
''' A list of segments to the sending queue'''
for sgmt in segments:
self.host_queues[host].put(sgmt)
def can_receive(self, hostname, filename):
''' Determine if the load is not too much to allow receiving from another client
'''
return self.socket_mgr.can_receive(hostname=hostname,
filename=filename)
def init_receive(self, hostname, segment_size, num_segments, filename):
''' Get ports for client and return. Initiate separate thread
which will connect with client and create more threads to
handle the file transfer. Will all close upon completion, no
joining necessary.
'''
max_ports = self.max_num_ports_per_host
# If load is over 50%, only allocate half max num of ports
if self.socket_mgr.check_load():
max_ports = (self.max_num_ports_per_host + 1) / 2
port_list = self.socket_mgr.allocate_ports(hostname,
filename,
maxAllocated=max_ports)
if self.socket_mgr.host_listen(hostname, filename):
gevent.spawn(self.run_receive, hostname, segment_size,
num_segments, filename)
else:
port_list = []
return port_list
def run_receive(self, hostname, segment_size, num_segments, filename):
''' The main thread which will manage the file transfer with a client
Block waiting to accept client connection after listening on ports.
One connected, start reading & applying
'''
logger.debug(
"Starting receive thread. Accept connection from client: %s, for file: %s",
hostname, filename)
# initialize host queue if not already done so
qLock = lock.RLock()
qLock.acquire()
if not self.host_queues.get(hostname):
self.host_queues[hostname] = queue.Queue()
qLock.release()
self.receive(hostname, segment_size, num_segments, filename)
return
def receive(self, hostname, segment_size, num_segments, filename):
''' Iterate continuously Reading segments from client using Socket manager.
Will create another separate thread to apply segments to file system as they
are added to the queue.
One "apply" thread is created per file transaction and terminated once the
segments have all been read (after a timeout and sleep). This wait should be
enough for final segments to be written. However, the queue will not
expected to be empty as other file transfers may be running.
**Though there's one apply thread per file transfer, each apply thread may
write segments from any of the files being currently transfered.
THREAD function
'''
# start thread
fs_apply_thread = gevent.spawn(self.apply, hostname)
i = 0
Stime = time.time()
while i < num_segments:
# Read from client
segments = self.socket_mgr.read(hostname, segment_size, filename)
for seg in segments:
self.host_queues[hostname].put(seg)
i += 1
time.sleep(3)
duration = time.time() - Stime
duration = "{0:.2f}s".format(duration)
server_db.add_record(hostname, filename, duration, segment_size,
self.max_num_ports_per_host)
logger.debug("Finished receiving all segments for host/file: %s/%s",
hostname, filename)
# Kill thread
while self.host_queues[hostname].qsize():
time.sleep(3)
fs_apply_thread.kill()
self.socket_mgr.disconnect(hostname, filename)
logger.debug("Finished applying all segments for host/file: %s/%s",
hostname, filename)
def apply(self, hostname):
''' Iterate continuously looking to segments in queue to write to FS
THREAD function
'''
logger.debug("Starting apply thread")
while True:
if self.host_queues[hostname].qsize():
# Get next segment in queue to Write to FS
new_segment = self.host_queues[hostname].get()
idx = new_segment['index']
fname = new_segment['filename']
logger.debug("Applying next segment, file (%s) - index (%d)",
fname, idx)
# Poll DB for file
file_obj = server_db.get_file(hostname,
new_segment['filename'])
if file_obj:
# File already exists
with open(file_obj[2], 'r+') as existing_file:
existing_file.seek(self.segment_size * idx)
existing_file.write(new_segment['content'])
if server_db.get_segment(hostname, fname, idx):
# Update existing segment at index for file
server_db.update_segment(hostname, fname, idx,
new_segment['sha'])
else:
# Add new segment
server_db.add_segment(hostname, fname, idx,
new_segment['sha'])
else:
# Check directories exist
fullpath = "{}/{}_dir/{}".format(self.base_dir, hostname,
fname)
i = len(self.base_dir)
while i < fullpath.rfind('/'):
if not os.path.exists(
fullpath[:fullpath.find('/', i)]):
os.mkdir(fullpath[:fullpath.find('/', i)])
i = fullpath.find('/', i) + 1
# Will always need to add new segment and file
with open(fullpath, 'w+') as new_file:
new_file.seek(self.segment_size * idx)
new_file.write(new_segment['content'])
server_db.add_file(hostname, fname, fullpath)
server_db.add_segment(hostname, fname, idx,
new_segment['sha'])
else:
time.sleep(3)
class Server(object):
"""服务器"""
def __init__(self):
# 初始化套接字
self.server_socket = ServerSocket()
# 保存客户端连接套接字
self.clients = dict()
# 请求处理方法
self.request_handle_functions = dict()
# 注册请求处理方法
self.register(REQUEST_LOGIN,
lambda sf, data: self.request_login_handle(sf, data))
self.register(REQUEST_CHAT,
lambda sf, data: self.request_chat_handle(sf, data))
def register(self, request_id, handle_function):
"""注册请求处方法"""
self.request_handle_functions[request_id] = handle_function
def startup(self):
"""启动服务器"""
while True:
# 等待客户端连接
sock, addr = self.server_socket.accept()
# 给客户端sock 增加额外功能
client_sock = SocketWrapper(sock)
# 启动线程处理该用户请求
Thread(target=lambda: self.request_handle(client_sock)).start()
def request_handle(self, client_sock):
"""响应处理方法"""
while True:
# 1.读取客户端数据
request_text = client_sock.recv_data()
if not request_text:
print("客户端下线！")
self.remove_offline_user(client_sock)
break
# 2.解析请求数据
request_data = self.parse_request_text(request_text)
# 3.获取响应处理方法
handle_function = self.request_handle_functions[
request_data['request_id']]
# 4.执行响应处理方法
if handle_function:
handle_function(client_sock, request_data)
def remove_offline_user(self, client_sock):
"""移除离线用户连接"""
username = None
for uname, csock in self.clients.items():
if csock['sock'].sock == client_sock.sock:
username = uname
# 删除用户信息
del self.clients[username]
@staticmethod
def parse_request_text(request_text):
"""解析请求信息"""
request_text_list = request_text.split(DELIMITER)
# 保存请求数据
request_data = dict()
request_data['request_id'] = request_text_list[0]
if request_text_list[0] == REQUEST_LOGIN:
request_data['username'] = request_text_list[1]
request_data['password'] = request_text_list[2]
if request_text_list[0] == REQUEST_CHAT:
request_data['username'] = request_text_list[1]
request_data['password'] = request_text_list[2]
return request_data
def request_login_handle(self, client_sock, request_data):
"""处理用户登录"""
# 1.获得登录用户名和密码
username = request_data['username']
password = request_data['password']
# 2.验证用户是否合法
ret, nickname, username = self.check_user_login(username, password)
if ret == '1':
self.clients[username] = {
'sock': client_sock,
'nickname': nickname
}
# 4.组装响应结果
response_text = ResponseProtocol.response_login_result(
ret, nickname, username)
# 发送响应结果
client_sock.send_data(response_text)
def check_user_login(self, username, password):
"""用户名和密码验证"""
# 查询sql
sql = "select * from users where user_name='" + username + "'"
# 创建数据库连接对象
db_conn = DB()
results = db_conn.get_one(sql)
# 未查到数据
if not results:
return "0", "", username
# 用户名和密码不相等
if results['user_password'] != password:
return "0", "", username
return "|", results["user_nickname"], username
def request_chat_handle(self, client_sock, request_data):
"""处理用户聊天"""
# 1.获得当前用户名、发送信息、昵称
username = request_data['username']
messages = request_data['messages']
nickname = self.clients[username]['nickname']
# 创建聊天响应信息
response_text = ResponseProtocol.response_chat(nickname, messages)
# 2.将信息发送到每一个登录客户
for uname, csock in self.clients.items():
# 不发给自己
if uname == username:
continue
# 给其他用户发送信息
csock['sock'].send_data(response_text)
from server_socket import ServerSocket
from json_transmitter import JsonTransmitter
from responder import Responder
from move_generator import MoveGenerator
from response_handler import ResponseHandler
from response_thread import ResponseThread
command_line_parser = OptionParser()
command_line_parser.add_option("-p", "--port",
type="int", dest="port",
help="Port for the server to run on")
command_line_parser.set_defaults(port=5000)
(options, args) = command_line_parser.parse_args()
server = ServerSocket("localhost", options.port)
print "Server starting on port %d..." % options.port
server.initialize_and_listen_for_connections()
while True:
try:
connection_socket = server.accept_connection_and_return_socket()
transmitter = JsonTransmitter(connection_socket)
move_generator = MoveGenerator()
handler = ResponseHandler(move_generator)
responder = Responder(transmitter, handler)
ResponseThread(responder).start()
except KeyboardInterrupt:
print "\nShutting down server..."
break
class Server(object):
def __init__(self):
self.server_socket = ServerSocket()
#request id and its corresponding handler function
self.req_handler_functions = {}
self.register(REQUEST_LOGIN, self.request_login_handler)
self.register(REQUEST_CHAT, self.request_chat_handler)
#save info of logged in user
self.clients = {}
#init db
self.db = DB()
def register(self, req_id, handler):
#for each req type, register handler for it a dictionary
self.req_handler_functions[req_id] = handler
def startup(self):
"""accept connection from client"""
while True:
print('waiting connection from client...')
soc, addr = self.server_socket.accept()
print('Accepted connection from client')
client_soc = SocketWrapper(soc)
Thread(target=lambda: self.request_handler(client_soc)).start()
def request_handler(self, client_soc):
"""handle client requests"""
while True:
#receive and send data
recv_data = client_soc.recv_data()
#receiving nothing means user left
if not recv_data:
self.remove_offline_user(client_soc)
client_soc.close()
break
#get request type and call corresponding handler
handler_function = self.req_handler_functions.get(recv_data['type'])
if handler_function:
handler_function(client_soc, recv_data)
def remove_offline_user(self, client_soc):
print('user left')
for username, info in self.clients.items():
if info['soc'] == client_soc:
print(self.clients)
del self.clients[username]
print(self.clients)
break
def request_login_handler(self, client_soc, req_data):
print('received longin req, processing')
#obtain username and pwd
username = req_data['username']
pwd = req_data['pwd']
#check credentials
result, username = self.check_credential(username, pwd)
#existing user=>save user info
if result == '1':
print('client soc')
print(client_soc)
self.clients[username] = {'soc': client_soc}
#generate response
response_text = ResponseProtocol.response_login(result, username)
#response to user whether login succeeded or not
client_soc.send_data(response_text)
def check_credential(self, username, pwd):
"""
check if the given user existed
result:
0: no such a user
1: user is existing
return (result, username)
"""
print('checking user credentials')
result = self.db.get_user(username, pwd)
if not result:
return '0',''
return '1', result['user_name']
def request_chat_handler(self, client_soc, req_data):
print('received chat req, processing')
#get message content
username = req_data['username']
msg = req_data['msg']
#TODO: publish to pub/sub middleware?
#generate response
response_text = ResponseProtocol.response_chat(username, msg)
#send response to users
for u_name, info in self.clients.items():
if username == u_name:
continue
info['soc'].send_data(response_text)
print(req_data)
from server_socket import ServerSocket
# from server_http import ServerHttp
from ServerCamera import ServerCamera
from ServerSensor import ServerSensor
############################
# 启动后台
# 初始化数据库
ServiceDb().init()
# Socket后台
serverSocket = ServerSocket("192.168.0.10", 8092)
# serverSocket = ServerSocket("127.0.0.1", 8092)
serverSocket.start()
sleep(1)
# ServiceHttp 处理http请求
# serverHttp = ServerHttp(8086)
# serverHttp.start()
# 线程 Opencv监控摄像头 识别图像 调用socket推送消息
serverCamera = ServerCamera(serverSocket)
serverCamera.start()
# 线程 各种传感器监控 轮循监控
# serverSensor = ServerSensor(serverSocket)
# serverSensor.start()
def msg_broadcast(self, addr, msg_bytes):
print(f"[BROADCAST] {addr}: {msg_bytes.decode(ENCODING)}")
for client in self.client_sockets:
if client.addr != addr:
client.send(msg_bytes)
def process_command(self, addr, command):
if command == "::E":
self.remove_client(addr)
else:
client = self.find_client(addr)
if client:
client.send("SERVER: Unknown Command".encode(ENCODING))
print(f"[COMMAND FAILED] unknown command from {addr}")
else:
print(f"[COMMAND FAILED] {addr} not found")
def shutdown(self):
for client in self.client_sockets:
client.close()
self.server_socket.close()
print("[SHUTTING DOWN]")
sys.exit()
if __name__ == '__main__':
addr = (IP, PORT)
server_socket = ServerSocket(addr)
server = Server(server_socket)
server.run()
def test_server_accesses_its_clients_send_method(self):
server = ServerSocket("localhost",5000)
server.client = mock.Mock()
server.client.send = mock.MagicMock()
server.send("Hello World!")
server.client.send.assert_called_with("Hello World!")
class Server(object):
"""服务器核心类"""
def __init__(self):
# 创建服务器套接字
self.server_socket = ServerSocket()
# 创建请求的id和方法关联字典
self.request_handle_function = {}
self.register(REQUEST_LOGIN, self.request_login_handle)
self.register(REQUEST_CHAT, self.request_chat_handle)
self.register(REQUEST_SIGN_UP, self.request_sign_up_handle)
# 创建保存当前用户登录字典
self.clients = {}
# 创建数据库管理对象
self.db = DB()
def register(self, request_id, handle_function):
# 注册消息类型和处理函数到字典
self.request_handle_function[request_id] = handle_function
def startup(self):
"""获取客户端连接，提供服务"""
while True:
# 获取客户端连接
print('正在获取客户端连接')
soc, addr = self.server_socket.accept()
print('获取到客户端连接')
# 使用套接字生成包装对象
client_soc = SocketWrapper(soc)
# 收发消息
t = Thread(target=self.request_handle, args=(client_soc, ))
t.start()
def request_handle(self, client_soc):
"""处理客户端请求"""
while True:
recv_data = client_soc.recv_data()
if not recv_data:
self.remove_office_user(client_soc)
client_soc.close()
break
print(recv_data)
# 解析数据
parse_data = self.parse_request_text(recv_data)
# 分析请求类型，并根据类型调用相应函数
handle_function = self.request_handle_function.get(
parse_data['request_id'])
if handle_function:
handle_function(client_soc, parse_data)
def remove_office_user(self, client_soc):
# 客户端下线处理
print('有客户端下线了')
for username, info in self.clients.items():
if info['sock'] == client_soc:
print(self.clients)
del self.clients[username]
print(self.clients)
break
def parse_request_text(self, text):
""""
解析客户端发送来的数据
登录信息：0001|username|password
聊天信息：0002|username|messages
注册信息：0003|username|password|nickname
"""
print('解析客户端数据：' + text)
request_list = text.split(DELIMITER)
# 按照类型解析数据
request_data = {}
request_data['request_id'] = request_list[0]
if request_data['request_id'] == REQUEST_LOGIN:
# 用户登录信息
request_data['username'] = request_list[1]
request_data['password'] = request_list[2]
elif request_data['request_id'] == REQUEST_CHAT:
# 用户聊天信息
request_data['username'] = request_list[1]
request_data['messages'] = request_list[2]
elif request_data['request_id'] == REQUEST_SIGN_UP:
# 用户注册信息
request_data['username'] = request_list[1]
request_data['password'] = request_list[2]
request_data['nickname'] = request_list[3]
return request_data
def request_chat_handle(self, client_soc, request_data):
# 处理聊天功能
print('收到聊天信息。。。准备处理', request_data)
# 获取消息内容
username = request_data['username']
messages = request_data['messages']
nickname = self.clients[username]['nickname']
# 拼接发送给客户端的消息文本
msg = ResponseProtocol.response_chat(nickname, messages)
# 转发给在线用户
for u_name, info in self.clients.items():
if username == u_name: # 不需要向发送消息的账号转发消息
continue
info['sock'].send_data(msg)
def request_sign_up_handle(self, client_soc, request_data):
# 处理注册功能
print('收到注册请求。。。准备处理')
# 获取密码
username = request_data['username']
password = request_data['password']
nickname = request_data['nickname']
# 检查是否能够注册
ret, username, nickname = self.check_user_sign_up(username, nickname)
# 注册成功将当前用户信息插入数据库
if ret == '1':
user_id = self.db.count_user()
self.db.insert_user("insert into users values(%d,'%s','%s','%s')" %
(user_id + 1, username, password, nickname))
# 拼接返回给客户端的信息
response_text = ResponseProtocol.response_sign_up(
ret, username, nickname)
# 发送信息给客户端
client_soc.send_data(response_text)
def request_login_handle(self, client_soc, request_data):
# 处理登录功能
print('收到登录请求。。。准备处理')
# 获取账号密码
username = request_data['username']
password = request_data['password']
# 检查是否能够登录
ret, nickname, username = self.check_user_login(username, password)
# 登录成功保存当前用户
if ret == '1':
self.clients[username] = {'sock': client_soc, 'nickname': nickname}
# 拼接返回给客户端的消息
response_text = ResponseProtocol.response_login_result(
ret, nickname, username)
# 把消息发送给客户端
client_soc.send_data(response_text)
def check_user_login(self, username, password):
"""检查用户是否登录成功，并返回检查结果(0/失败，1/成功)，昵称，用户名"""
# 从数据库查询用户信息
result = self.db.get_one("select * from users where user_name='%s'" %
username)
# 没有查询结果则说明用户不存在，登录失败
if not result:
return '0', '', username
# 如果密码不匹配，说明密码错误，登陆失败
if password != result['user_password']:
return '0', '', username
# 登录成功
return '1', result['user_nickname'], username
def check_user_sign_up(self, username, nickname):
"""检查用户是否注册成功，并返回检查结果(0/失败，1/成功)，昵称，用户名"""
# 从数据库查询用户信息
username_result = self.db.search_one(
"select * from users where user_name='%s'" % username)
nickname_result = self.db.search_one(
"select * from users where user_nickname='%s'" % nickname)
# 有相同账号则注册失败
if username_result:
return '0', username, ''
# 有相同昵称则注册失败
elif nickname_result:
return '0', '', nickname
# 注册成功
return '1', username, nickname
