def keepAlive(self):
global KeepAliveTimeWait
keepAliveTimer = time.time() - random.randint(
0, int(KeepAliveTimeWait / 2))
while self.isOnline():
if time.time() - keepAliveTimer >= keepAliveInterval:
try:
self.keepAliveResponded = False
self.log('Keep alive pinging...')
self.send_keepAlive('ping')
except socket.error as err:
self.log(
'Failed to send keep alive data, error = {}, stopping client now'
.format(err.args))
self.stop()
else:
keepAliveSentTime = time.time()
while self.isOnline(
) and self.keepAliveResponded == False and time.time(
) - keepAliveSentTime <= KeepAliveTimeWait:
utils.sleep()
if not self.isOnline():
break
if self.keepAliveResponded:
self.log('Keep alive responded, ping = {}ms'.format(
round((time.time() - keepAliveSentTime) * 1000,
1)))
else:
self.log('No respond for keep alive, stop the client')
self.stop()
keepAliveTimer = time.time()
utils.sleep()
def start(self, minecraftServer=None):
self.minecraftServer = minecraftServer
if not self.isOnline():
self.log('Trying to start the client, connecting to ' +
utils.addressToString(self.server_addr))
self.sock = socket.socket()
# 发送客户端信息
try:
self.sock.connect(self.server_addr)
self.send_login(self.info.name, self.info.password)
except socket.error:
self.log('Fail to connect to the server')
return
# 获取登录结果
try:
data = self.recieveData()
result = json.loads(data)['result']
except socket.error:
self.log('Fail to receive login result')
return
except ValueError:
self.log('Fail to read login result')
return
self.log(utils.stringAdd('Result: ', result))
if result == 'login success':
super(ChatClient, self).start()
else:
self.log('Client has already been started')
def on_recieve_message(self, data):
messages = utils.messageData_to_strings(data)
for msg in messages:
self.log(msg)
if self.mode == Mode.MCD:
msg = utils.stringAdd('§7', utils.stringAdd(msg, '§r'))
self.minecraftServer.say(msg)
def boardcastMessage(self, senderInfo, messageData):
self.log('Received message "{0}", boardcasting'.format(
utils.messageData_to_string(messageData)))
for msg in utils.messageData_to_strings(messageData):
self.log(msg, ChatLogFile)
for client in self.clients:
if client.info != senderInfo:
client.sendMessage(messageData)
def log(self, msg, fileName=None):
if fileName == None:
fileName = self.logFile
msg = utils.stringAdd('[' + self.logName + '] ', msg)
t = time.strftime('[%Y-%m-%d %H:%M:%S]', time.localtime(
time.time())) + ' '
msg = utils.stringAdd(t, msg)
if fileName != None:
utils.printLog(msg, fileName)
if self.consoleOutput:
print(msg)
def __init__(self, configFile):
config = json.load(open(configFile, 'r'))
super(ChatServer, self).__init__('Server', GeneralLogFile,
config['aes_key'])
self.server_addr = utils.toUTF8(config['hostname']), config['port']
self.log('AESKey = ' + self.AESKey)
self.log('Server address = ' + utils.addressToString(self.server_addr))
self.clients = []
for c in config['clients']:
info = lib.ChatClientInfo(c['name'], c['password'])
self.log('Adding Client: name = {0}, password = {1}'.format(
info.name, info.password))
self.clients.append(ChatClient(info, self, self.AESKey))
def transitCommand(self, senderInfo, commandData):
self.log('Received command "{0}", transiting'.format(
utils.commandData_to_string(commandData)))
target = commandData['sender'] if commandData['result'][
'responded'] else commandData['receiver']
for client in self.clients:
if client.info != senderInfo and client.info.name == target:
client.sendCommand(commandData)
def sendData(self, msg, sock=None):
try:
super(ChatClientBase, self).sendData(msg, sock)
except socket.error as err:
self.log(
'Fail to send data "{}" to server / client, error = {}'.format(
utils.lengthLimit(msg), err.args))
if self.isOnline():
self.stop(False)
async def listeningMessage(self):
self.log('Message listening looping...')
try:
channel_chat = self.get_channel(self.config.channel_chat)
while True:
try:
messageData = self.messages.get(
block=False) # type: MessageData
except queue.Empty:
await asyncio.sleep(0.05)
continue
self.log('Message data with type {} and channel {} get'.format(
messageData.type, messageData.channel))
data = messageData.data
if messageData.type == MessageDataType.CHAT: # chat message
assert isinstance(data, dict)
self.log('Processing chat message from chatbridge: ' +
utils.messageData_to_string(data))
for message in utils.messageData_to_strings(data):
try:
translation = translator.translate(data['message'],
dest='en')
dest = 'en'
if translation.src != dest:
message += ' | [{} -> {}] {}'.format(
translation.src, dest, translation.text)
except:
self.log('Translate fail')
await channel_chat.send(
self.formatMessageToDiscord(message))
elif messageData.type == MessageDataType.EMBED: # embed
assert isinstance(data, discord.Embed)
self.log('Sending embed')
await self.get_channel(messageData.channel).send(embed=data
)
elif messageData.type == MessageDataType.TEXT:
await self.get_channel(messageData.channel).send(
self.formatMessageToDiscord(str(data)))
else:
self.log('Unkown messageData type {}'.format(
messageData.data))
except:
self.log(traceback.format_exc())
await self.close()
def on_recieve_message(self, data):
messages = utils.messageData_to_strings(data)
for msg in messages:
self.log(msg)
if self.mode == Mode.MCD:
self.minecraftServer.execute('tellraw @a {}'.format(
json.dumps({
'text': msg,
'color': 'gray'
})))
def run(self):
self.sock = socket.socket()
try:
self.sock.bind(self.server_addr)
except socket.error:
self.log('Fail to bind ' + str(self.server_addr))
return False
self.sock.listen(5)
self.online = True
self.log('Server Started')
while self.isOnline():
conn, addr = self.sock.accept()
self.log(
'Client {0} connected, receiving initializing data'.format(
utils.addressToString(addr)))
try:
js = json.loads(self.recieveData(conn)) # 接受客户端信息的数据包
self.log('Initializing data =' + str(js))
if js['action'] == 'login':
info = lib.ChatClientInfo(js['name'], js['password'])
flag = False
for client in self.clients:
if client.info == info:
self.send_result('login success', conn)
flag = True
self.log('Starting client "' + client.info.name +
'"')
client.tryStart(conn, addr)
break
if flag == False:
self.send_result('login fail', conn)
else:
self.log('Action not matches, ignore')
except (ValueError, TypeError, KeyError) as err:
self.log('Fail to read received initializing json data: ' +
str(err))
except socket.error:
self.log('Fail to respond the client')
utils.sleep()
return True
def __init__(self, configFile, LogFile, mode):
js = json.load(open(configFile, 'r'))
super(ChatClient,
self).__init__(lib.ChatClientInfo(js['name'], js['password']),
js['aes_key'], LogFile)
self.mode = mode
self.consoleOutput = mode != Mode.MCD
self.server_addr = (js['server_hostname'], js['server_port'])
self.log('Client Info: name = ' + self.info.name + ', password = '******'Mode = ' + mode)
self.log('AESKey = ' + self.AESKey)
self.log('Server address = ' + utils.addressToString(self.server_addr))
def run(self):
self.sock = socket.socket()
try:
self.sock.bind(self.server_addr)
except socket.error:
self.log('Fail to bind ' + str(self.server_addr))
return False
self.sock.listen(5)
self.online = True
self.log('Server Started')
self.start_console_thread()
try:
while self.isOnline():
conn, addr = self.sock.accept()
self.handle_client_connection(conn, addr)
self.log(
'Client {0} connected, receiving initializing data'.format(
utils.addressToString(addr)))
utils.sleep()
except:
if self.isOnline():
raise
return True
async def listeningMessage(self):
channel = self.get_channel(self.config.channel)
try:
while True:
if len(self.messages) == 0:
await asyncio.sleep(0.05)
continue
messageData = self.messages.pop(0)
if type(messageData) == dict: # chat message
self.log('Processing chat message ' +
utils.messageData_to_string(messageData))
for message in utils.messageData_to_strings(messageData):
try:
translation = translator.translate(
messageData['message'], dest='en')
dest = 'en'
if translation.src != dest:
message += ' | [{} -> {}] {}'.format(
translation.src, dest, translation.text)
except:
self.log('Translate fail')
await channel.send(self.formatMessageToDiscord(message)
)
elif type(messageData) == discord.Embed: # embed
self.log('Sending embed')
await channel.send(embed=messageData)
elif type(messageData) == str:
await channel.send(self.formatMessageToDiscord(messageData)
)
else:
self.log('Unkown messageData type {}'.format(
type(messageData)))
except:
s = traceback.format_exc()
print(s)
self.log(s)
await self.close()
def on_recieve_message(self, data):
global cq_bot
if cq_bot is None:
return
try:
messages = utils.messageData_to_strings(data)
for msg in messages:
self.log(msg)
try:
prefix, message = data['message'].split(' ', 1)
except:
pass
else:
log('Triggered command, sending message to qq')
if prefix == '!!qq':
cq_bot.send_message(data['client'], data['player'],
message)
except:
self.log('Error in on_message()')
self.log(traceback.format_exc())
def processData(self, data):
try:
js = json.loads(data)
except ValueError:
self.log('Fail to read received json')
self.log(utils.stringAdd('Received: ', data))
return
action = js['action']
self.log('Client received action "' + action + '"')
if action == 'result':
self.on_recieve_result(js)
elif action == 'login':
self.on_recieve_login(js)
elif action == 'message':
self.on_recieve_message(js)
elif action == 'command':
self.on_recieve_command(js)
elif action == 'stop':
self.on_recieve_stop(js)
elif action == 'keepAlive':
self.on_recieve_keepAlive(js)
def run(self):
self.log('Client address = ' + utils.addressToString(self.addr))
super(ChatClient, self).run()
def sendMessage(self, messageData):
if self.isOnline():
self.log('Sending message "{}" to the client'.format(
utils.lengthLimit(utils.messageData_to_string(messageData))))
self.sendData(json.dumps(messageData))
def __init__(self, name, password):
self.name = utils.toUTF8(name)
self.password = utils.toUTF8(password)
def sendCommand(self, commandData):
if self.isOnline():
self.log('Sending command "{}" to the client'.format(
utils.lengthLimit(utils.commandData_to_string(commandData))))
self.sendData(json.dumps(commandData))
def addChatMessage(self, messageData):
self.log('Adding message "' +
utils.messageData_to_string(messageData) + '" to Discord Bot')
self.messages.append(messageData)
def log(msg):
msg = time.strftime('[%Y-%m-%d %H:%M:%S]', time.localtime(
time.time())) + ' [CQBot] ' + str(msg)
print(msg)
utils.printLog(msg, LogFile)
def log(msg, log_to_file=True):
msg = time.strftime('[%Y-%m-%d %H:%M:%S]', time.localtime(
time.time())) + ' [Discord] ' + msg
print(msg)
if log_to_file:
utils.printLog(msg, LogFile)