def server():
s = WebsocketServer(0, loglevel=logging.DEBUG)
server_thread = Thread(target=s.run_forever)
server_thread.daemon = True
server_thread.start()
yield s
s.server_close()
def server():
""" Returns the response of a server after"""
s = WebsocketServer(0, loglevel=logging.DEBUG)
server_thread = Thread(target=s.run_forever)
server_thread.daemon = True
server_thread.start()
yield s
s.server_close()
def server():
""" Returns the response of a server after"""
s = WebsocketServer(0, loglevel=logging.DEBUG)
server_thread = Thread(target=s.run_forever)
server_thread.daemon = True
server_thread.start()
yield s
s.server_close()
class WebsocketConnection(Thread):
def __init__(self, port, message_received_callback):
Thread.__init__(self)
self.port = port
self.num_clients_connected = 0
self.message_received_callback = message_received_callback
def run(self):
print "starting web socket..."
self.websocket_server = WebsocketServer(self.port, "")
self.websocket_server.set_fn_new_client(self._new_web_client)
self.websocket_server.set_fn_client_left(self._web_client_left)
self.websocket_server.set_fn_message_received(self._web_message_received)
try:
self.websocket_server.run_forever()
except:
print "Exception"
def stop(self):
# @TODO: okay, this is not super clean but seems to work for now with an exception popping up...
print "Stopping web server..."
self.websocket_server.server_close()
def is_client_connected(self):
return self.num_clients_connected > 0
def send(self, message):
self.websocket_server.send_message_to_all(message)
def _new_web_client(self, client, server):
print "New client connected via web"
self.num_clients_connected += 1
def _web_client_left(self, client, server):
print "Web client disconnected"
self.num_clients_connected -= 1
def _web_message_received(self, client, server, message):
print "Message received from web client: " + message
self.message_received_callback("web", message)
class WSServer:
def __init__(self):
self.serv = None
self.clients = []
self.previous_messages = []
def start(self):
port = 4001
self.serv = WebsocketServer(port, "0.0.0.0")
self.serv.set_fn_new_client(self.client_joined)
self.serv.set_fn_message_received(self.message_received)
self.serv.set_fn_client_left(self.client_left)
thr = Thread(target=lambda: self.serv.run_forever())
thr.start()
def stop(self):
self.serv.shutdown()
self.serv.server_close()
def send_ws_message(self, msg):
if not self.is_enabled():
return
self.previous_messages.append(msg)
self.serv.send_message_to_all(msg)
def is_enabled(self):
return self.serv is not None
def client_joined(self, client, server):
if len(self.previous_messages) == 0:
return
server.send_message(client, "payload-start")
for prev_msg in self.previous_messages:
server.send_message(client, prev_msg)
server.send_message(client, "payload-end")
def message_received(self, client, server):
pass
def client_left(self, client, server):
pass
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
def startServer(server):
print("HMI signals listener was started\r")
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
server.run_forever()
def keyBoardEvent():
global server
char = ' '
while char != 'q':
char = getch()
server = WebsocketServer(8081)
serverThread = Thread(target=startServer, args=(server, ))
keyBoardThread = Thread(target=keyBoardEvent)
keyBoardThread.start()
serverThread.start()
keyBoardThread.join()
print("Closing server...")
server.shutdown()
server.server_close()
class WebsocketServerModule(ModuleProcess):
def __init__(self, baseConfig, pInBoundQueue, pOutBoundQueue,
loggingQueue):
# super(WebsocketServerModule, self).__init__()
ModuleProcess.__init__(self, baseConfig, pInBoundQueue, pOutBoundQueue,
loggingQueue)
self.alive = False
self.config = baseConfig
self.inQueue = pInBoundQueue # inQueue are messages from the main process to websocket clients
self.outQueue = pOutBoundQueue # outQueue are messages from clients to main process
self.websocketServer = None
self.loggingQueue = loggingQueue
self.threadProcessQueue = None
# Configs
self.moduleConfig = configLoader.load(self.loggingQueue, __name__)
# Constants
self._port = self.moduleConfig['WebsocketPort']
self._host = self.moduleConfig['WebsocketHost']
# logging setup
self.logger = ThreadsafeLogger(loggingQueue, __name__)
def run(self):
if not self.check_ss_version():
#cant run with wrong version so we return early
return False
""" Main thread entry point.
Sets up websocket server and event callbacks.
Starts thread to monitor inbound message queue.
"""
self.logger.info("Starting websocket server")
self.alive = True
self.listen()
self.websocketServer = WebsocketServer(self._port, host=self._host)
self.websocketServer.set_fn_new_client(self.new_websocket_client)
self.websocketServer.set_fn_message_received(
self.websocket_message_received)
self.websocketServer.run_forever()
def check_ss_version(self):
#check for min version met
self.logger.info('Module version %s' % (__version__))
if LooseVersion(self.config['ss_version']) < LooseVersion(
self.moduleConfig['MinSimpleSensorVersion']):
self.logger.error(
'This module requires a min SimpleSensor %s version. This instance is running version %s'
% (self.moduleConfig['MinSimpleSensorVersion'],
self.config['ss_version']))
return False
return True
def new_websocket_client(self, client, server):
""" Client joined callback - called whenever a new client joins. """
self.logger.debug("Client joined")
def websocket_message_received(self, client, server, message):
""" Message received callback - called whenever a new message is received. """
self.logger.debug('Message received: %s' % message)
message = json.loads(message)
self.logger.info("message jsond: %s" % message)
_msg = Message(topic=message['topic'], sender_id=message['sender_id'])
if 'sender_type' in message:
_msg.sender_type = message['sender_type']
if 'recipients' in message:
_msg.recipients = message['recipients']
if 'extended_data' in message:
_msg.extended_data = message['extended_data']
self.put_message(_msg)
def listen(self):
self.threadProcessQueue = Thread(target=self.process_queue)
self.threadProcessQueue.setDaemon(True)
self.threadProcessQueue.start()
def shutdown(self):
""" Handle shutdown message.
Close and shutdown websocket server.
Join queue processing thread.
"""
self.logger.info("Shutting down websocket server")
try:
self.logger.info("Closing websocket")
self.websocketServer.server_close()
except Exception as e:
self.logger.error("Websocket close error : %s " % e)
try:
self.logger.info("Shutdown websocket")
self.websocketServer.shutdown()
except Exception as e:
self.logger.error("Websocket shutdown error : %s " % e)
self.alive = False
self.threadProcessQueue.join()
time.sleep(1)
self.exit = True
def handle_message(self, message):
""" Send message to listening clients. """
self.websocketServer.send_message_to_all(json.dumps(message.__dict__))
def process_queue(self):
""" Monitor queue of messages from main process to this thread. """
while self.alive:
if (self.inQueue.empty() == False):
try:
message = self.inQueue.get(block=False, timeout=1)
if message is not None:
if message.topic.upper() == "SHUTDOWN":
self.logger.debug("SHUTDOWN handled")
self.shutdown()
else:
self.handle_message(message)
except Exception as e:
self.logger.error("Websocket unable to read queue : %s " %
e)
else:
time.sleep(.25)
def on_exit(self, client, server: WebsocketServer):
server.server_close()
class WebSocket:
def __init__(self):
self.server = None
self.S = None
# Called for every client connecting (after handshake)
def new_client(self, client, server):
#print("New client connected and was given id %d" % client['id'])
str = self.S.getUpdateInfo()
server.send_message(client, str)
# Called for every client disconnecting
def client_left(self, client, server):
#print("Client(%d) disconnected" % client['id'])
pass
def start(self):
port = 3344
self.S = S()
self.server = WebsocketServer(port,
host='0.0.0.0',
loglevel=logging.CRITICAL)
self.server.set_fn_new_client(self.new_client)
self.server.set_fn_client_left(self.client_left)
server_thread = threading.Thread(target=self.server.run_forever)
server_thread.start()
def stop(self):
self.server.server_close()
def reset(self):
self.S.players = [""] * 4
self.S.callsRecord = [""] * 4
self.S.callsRaw = [""] * 4
self.S.threeModeUsers = [""] * 4
self.S.playsRecord = [""] * 4
self.S.playsRaw = [""] * 4
self.S.boutsWinRecord = []
self.S.flowerCountRecord = [0] * 4
self.S.playsPokerHand = [[] for i in range(4)]
self.S.threeModeIndex = [-1] * 4
self.S.trump = 'Waiting'
self.S.trumpRaw = -1
self.S.attackIndex = [-1] * 2
self.S.attackWinNumber = 7
self.S.attackTeam = ''
self.S.attackScore = 0
self.S.defenseTeam = ''
self.S.defenseScore = 0
self.S.threeMode = False
def setPlayers(self, str):
self.S.players = str.split(',')
self.server.send_message_to_all(self.S.getUpdateInfo())
def setThreeModePlayers(self, str):
self.S.threeModeUsers = str.split(',')
def setThreeModeIndex(self, list):
self.S.threeModeIndex = list
def setPlayersPoker(self, index, cards):
cardArray = cards.split(',')
for card in cardArray:
self.S.playsPokerHand[index].append(int(card))
self.server.send_message_to_all(self.S.getUpdateInfo())
def updateContent(self, str):
connectState = str[0:1]
info = str[1:]
# print connectState,info
if connectState == "S":
splitArray = info.split(',')
trump = int(splitArray[1])
lastUser = int(splitArray[3])
self.S.trump = ("%d%s") % (trump / 7 + 1, Trumps[trump % 7])
self.S.trumpRaw = trump
self.S.attackWinNumber = (trump / 7 + 7)
if self.S.threeMode:
self.S.attackIndex[0] = 0
self.S.attackIndex[1] = 2
else:
self.S.attackIndex[0] = (lastUser + 1) % 4
self.S.attackIndex[1] = (lastUser + 3) % 4
attackTeam = ''
defenseTeam = ''
for i in range(0, 4):
player = self.S.players[i]
if self.S.threeMode:
player = self.S.threeModeUsers[i]
if i in self.S.attackIndex:
attackTeam = attackTeam + player + ' , '
else:
defenseTeam = defenseTeam + player + ' , '
self.S.attackTeam = attackTeam[0:len(attackTeam) - 3]
self.S.defenseTeam = defenseTeam[0:len(defenseTeam) - 3]
elif connectState == "T":
self.S.threeMode = True
elif connectState == "C":
splitArray = info.split(',')
lastUser = int(splitArray[0])
trump = int(splitArray[2])
updateRecord = self.S.callsRecord[lastUser]
updateRaw = self.S.callsRaw[lastUser]
if trump != -1:
tempStr = ("%d%s,") % ((trump / 7) + 1, Trumps[trump % 7])
else:
tempStr = "Pass,"
self.S.callsRecord[lastUser] = updateRecord + tempStr
self.S.callsRaw[lastUser] = updateRaw + ("%d^") % trump
elif connectState == "P":
splitArray = info.split(',')
nextUser = int(splitArray[2])
lastUser = (nextUser + 4 - 1) % 4
poker = int(splitArray[0])
playState = Type.PlayState(int(splitArray[1]))
if poker != 0:
removeIndex = lastUser
updateRecord = self.S.playsRecord[lastUser]
updateRaw = self.S.playsRaw[lastUser]
tempStr = showPokerStr(poker)
self.S.playsRecord[lastUser] = updateRecord + tempStr
self.S.playsRaw[lastUser] = updateRaw + ("%d^") % poker
flower = int((poker - 1) / 13)
self.S.flowerCountRecord[flower] += 1
if self.S.threeMode:
removeIndex = self.S.threeModeIndex[lastUser]
self.S.playsPokerHand[removeIndex].remove(poker)
else:
if nextUser in self.S.attackIndex:
self.S.attackScore += 1
else:
self.S.defenseScore += 1
self.S.boutsWinRecord.append(nextUser)
if poker != 0:
flower = int((poker - 1) / 13)
self.S.flowerCountRecord[flower] += 1
for index in range(4):
tempStr = self.S.playsRecord[index]
tempStr = tempStr[:-1]
if index == nextUser:
tempStr += "✓,"
else:
tempStr += "✗,"
self.S.playsRecord[index] = tempStr
if playState == Type.PlayState.GameOver:
self.recordCSV()
self.saveShowRecord()
self.server.send_message_to_all(self.S.getUpdateInfo())
def recordCSV(self):
#{time},{trump},{threeMode},{name},{call},{play},{threeName}
file = open('record.csv', "a+")
timeStr = time.strftime("%Y-%m-%d %H:%M", time.localtime())
trumpStr = self.S.trump
nameStr = ""
for player in self.S.players:
nameStr += player + "|"
nameStr = nameStr[:-1]
callStr = ""
for callRaw in self.S.callsRaw:
callStr += callRaw[0:-1] + "|"
callStr = callStr[:-1]
playStr = ""
for playRaw in self.S.playsRaw:
playStr += playRaw[0:-1] + "|"
playStr = playStr[:-1]
threeStr = ""
if self.S.threeModeUsers[0] != "":
for player in self.S.threeModeUsers:
threeStr += player + "|"
threeStr = threeStr[:-1]
file.write("%s,%s,%s,%s,%s,%s\n" %
(timeStr, trumpStr, nameStr, callStr, playStr, threeStr))
file.close()
def saveShowRecord(self):
#{time},{trump},{name},{call},{threeName},{play}
file = open('/var/www/html/data/showRecord.csv', "a+")
local = pytz.timezone("Etc/GMT+8")
naive = datetime.datetime.now()
local_dt = local.localize(naive, is_dst=None)
utc_dt = local_dt.astimezone(pytz.utc)
timeStr = utc_dt.strftime('%Y-%m-%d %H:%M')
winFlag = "✓"
if (self.S.attackScore < self.S.attackWinNumber):
winFlag = "✗"
trumpStr = ("%s %s %d:%d") % (self.S.trump, winFlag,
self.S.attackScore, self.S.defenseScore)
nameStr = ""
for player in self.S.players:
nameStr += player + "|"
nameStr = nameStr[:-1]
callStr = ""
subCalls = [[], [], [], []]
for index in range(4):
subCalls[index] = self.S.callsRecord[index].split(',')
count = 0
index = 0
length = 0
while 1:
subCall = subCalls[index]
str = ""
if length < len(subCall) and subCall[length] != "":
str = subCall[length]
elif (subCalls[index] != ""):
count += 1
subCalls[index] = ""
if count == 4:
break
callStr += str + " - "
if index + 1 == 4:
index = 0
length += 1
callStr = callStr[:-2]
callStr += "|"
else:
index += 1
callStr = callStr[:-1]
threeStr = ""
if self.S.threeModeUsers[0] != "":
for player in self.S.threeModeUsers:
threeStr += player + "|"
threeStr = threeStr[:-1]
playStr = ""
subPlays = [[], [], [], []]
for index in range(4):
subPlays[index] = self.S.playsRecord[index].split(',')
for i in range(13):
for j in range(4):
subPlay = subPlays[j]
str = subPlay[i]
playStr += str + " | "
playStr = playStr[:-2]
playStr += ","
playStr = playStr[:-1]
file.write("%s,%s,%s,%s,%s,%s\n" %
(timeStr, trumpStr, nameStr, callStr, threeStr, playStr))
file.close()
class WebSocket:
def __init__(self):
self.server = None
self.rooms = None
self.clientSelectedRoom = dict()
self.debugMode = False
# Called for every client connecting (after handshake)
def new_client(self,client, server):
print("New client connected and was given id %d" % client['id'])
self.clientSelectedRoom[client['id']]=-1
if self.rooms == None or len(self.rooms) == 0:
server.send_message(client,"0")
else:
messageStr = self.getRoomInfo(self.rooms)
server.send_message(client,"R:"+messageStr)
# Called for every client disconnecting
def client_left(self,client, server):
# print("Client(%d) disconnected" % client['id'])
self.clientSelectedRoom.pop(client['id'])
print("Client disconnected")
pass
# Called when a client sends a message
def message_received(self,client, server, message):
if len(message) > 200:
message = message[:200]+'..'
print("Client(%d) said: %s" % (client['id'], message))
if message == "debug":
self.debugMode = True
elif message == "normal":
self.debugMode = False
else:
roomIndex=int(message)
self.clientSelectedRoom[client['id']]=roomIndex
if roomIndex < len(self.rooms):
room = self.rooms[roomIndex]
messageStr = self.getUpdateInfo(self.rooms[roomIndex])
server.send_message(client,messageStr)
def start(self):
port=3344
self.server = WebsocketServer(port,host='0.0.0.0')
self.server.set_fn_new_client(self.new_client)
self.server.set_fn_client_left(self.client_left)
self.server.set_fn_message_received(self.message_received)
server_thread = threading.Thread(target=self.server.run_forever)
server_thread.daemon = True
server_thread.start()
def stop(self):
self.server.server_close()
def findClientFromId(self,clientId):
for client in self.server.clients:
if client['id'] == clientId:
return client
return None
def updateRooms(self,Rooms,removeIndex):
self.rooms=Rooms
messageStr = ""
if len(self.rooms) != 0:
messageStr = self.getRoomInfo(self.rooms)
self.server.send_message_to_all("R:"+messageStr)
if removeIndex != -1:
for key in self.clientSelectedRoom:
if self.clientSelectedRoom[key] > removeIndex:
self.clientSelectedRoom[key]-=1
elif self.clientSelectedRoom[key] == removeIndex:
self.clientSelectedRoom[key]=-1
def updateContent(self,Rooms,roomIndex):
self.rooms=Rooms
for clientId,selectedIndex in self.clientSelectedRoom.iteritems():
client = self.findClientFromId(clientId)
if client == None:
continue
if selectedIndex == roomIndex:
messageStr = self.getUpdateInfo(Rooms[roomIndex])
self.server.send_message(client,messageStr)
def getRoomInfo(self,rooms):
content = ""
for room in rooms:
names = ""
for index in range(4):
name = room.users[index].name
names += name
if index != 3:
names += "、"
content += names + "|"
content = content[:-1]
return content
def getUpdateInfo(self,room):
# trump^{info}^{Name}^{call}^{three}^{play}^{card}
info = ""
if room.attackTeam!="":
info = room.attackTeam + "|" + ("%d / %d")%(room.attackScore,room.attackWinNumber) + "|" + room.defenseTeam + "|" + ("%d / %d")%(room.defenseScore,14-room.attackWinNumber)
name = ""
for user in room.users:
name += user.name + "|"
name = name[:-1]
call = ""
subCalls = [[],[],[],[]]
for index in range(4):
subCalls[index] = room.callsRaw[index].split('^')
count=0;index=0;length=0
while 1:
subCall = subCalls[index]
str = ""
if length < len(subCall) and subCall[length]!="":
str = subCall[length]
elif(subCalls[index]!=""):
count+=1
subCalls[index]=""
if count == 4:
break
call += str + ","
if index+1 == 4:
index = 0
length += 1
call = call[:-1]
call += "|"
else:
index += 1
call = call[:-1]
three = ""
for player in room.threeModeUsers:
three += player + "|"
three = three[:-1]
play = ""
subPlays = [[],[],[],[]]
for index in range(4):
subPlays[index] = room.playsRaw[index].split('^')
count=0;index=0;length=0
while 1:
subPlay = subPlays[index]
str = ""
if length < len(subPlay):
str = subPlay[length]
if count == 13:
break
play += str + ","
if index+1 == 4:
index = 0
length += 1
count += 1
play = play[:-1]
play += "|"
else:
index += 1
play = play[:-1]
winBount = room.boutsWinRecord[:-1]
flower = ""
for index in range(4):
flower += ("%d|")%room.flowerCountRecord[index]
flower = flower[:-1]
card = ""
if room.users[0].name!="":
for index in range(4):
str = ""
for poker in room.playsPokerHand[index]:
str += ("%d,")%poker
card += str[:-1] + "|"
card = card[:-1]
return ("%d")%room.getTrump() + "^" + info + "^" + name + "^" + call + "^" + three + "^" + play + "^" + winBount + "^"+ flower + "^" +card
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
def startServer(server):
print("HMI signals listener was started\r")
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
server.run_forever()
def keyBoardEvent():
global server
char = ' '
while char != 'q':
char = getch()
server = WebsocketServer(8081)
serverThread = Thread(target = startServer, args = (server, ))
keyBoardThread = Thread(target = keyBoardEvent)
keyBoardThread.start()
serverThread.start()
keyBoardThread.join()
print("Closing server...")
server.shutdown()
server.server_close()
class CloudLink:
def __init__(self):
self.wss = None
self.users = {}
self.userlist = []
self.handlers = []
self.gdata = ""
self.mode = 0 # 1=Host, 2=Client, 3=Plugin
def host(self, port):
if serverModeSupport:
self.mode = 1
self.wss = WebsocketServer(
int(port)
) # Instanciate WebsocketServer alongside CloudLink module
# Define callbacks to functions
self.wss.set_fn_new_client(self.newConnection)
self.wss.set_fn_message_received(self.gotPacket)
self.wss.set_fn_client_left(self.closedConnection)
# Run the server
print("Now running in host mode on port {0}...".format(port))
try:
self.wss.serve_forever()
except KeyboardInterrupt:
if not len(self.users) == 0:
print("Shutdown in progress, please wait...")
# Tell all users to disconnect, and wait until all are disconnected
self.wss.send_message_to_all(json.dumps({"cmd": "ds"}))
while not len(self.users) == 0:
pass
print("All users disconnected, now exiting...")
else:
print("Now exiting...")
self.wss.server_close()
else:
print(
"Error! Couldn't initialize mode 1: Support for Server mode has been disabled since you don't have the required websocket_server.py!"
)
sys.exit()
def client(self):
if clientOrPluginModeSupport:
self.mode = 2
print("Oops. This is a WIP feature. Sorry...")
sys.exit()
else:
print(
"Error! Couldn't initialize mode 2: Support for Client mode has been disabled since you don't have the required library websocket-client!"
)
sys.exit()
def plugin(self):
if clientOrPluginModeSupport:
self.mode = 3
print("Oops. This is a WIP feature. Sorry...")
sys.exit()
else:
print(
"Error! Couldn't initialize mode 3: Support for Plugin mode has been disabled since you don't have the required library websocket-client!"
)
sys.exit()
def newConnection(self, client, server):
if self.mode == 1:
print("New connection: {0}".format(client['id']))
self.users[str(client)] = {"name": "", "id": str(client['id'])}
self.relayUserList(server, True, client)
self.sendPacket(server, True, {
"cmd": "gmsg",
"id": client,
"val": str(self.gdata)
})
def sendPacket(self, server, type, data): # False:Public, True:Private
if self.mode == 1:
if "id" in data:
id = data["id"]
del data["id"]
if type == False:
server.send_message_to_all(json.dumps(data))
elif type == True:
server.send_message(id, json.dumps(data))
def relayUserList(self, server, type, id):
if self.mode == 1:
y = ""
for x in range(len(self.userlist)):
y = str(y + self.userlist[x] + ";")
self.sendPacket(server, type, {
"cmd": "ulist",
"id": id,
"val": str(y)
})
def closedConnection(self, client, server):
if self.mode == 1:
if str(client) in self.users:
if self.users[str(client)]['name'] in self.userlist:
print("Connection closed: {0} ({1})".format(
self.users[str(client)]['name'], client['id']))
else:
print("Connection closed: {0}".format(client['id']))
if self.users[str(client)]['name'] in self.userlist:
del self.userlist[self.userlist.index(
self.users[str(client)]['name'])]
if client in self.handlers:
del self.handlers[self.handlers.index(client)]
del self.users[str(client)]
if not len(self.users) == 0:
self.relayUserList(server, False, client)
def gotPacket(self, client, server, message):
if self.mode == 1:
err = False
try:
packet = json.loads(message)
except Exception as e:
err = True
finally:
if not err:
if "cmd" in packet: # Check if the cmd parameter is specified
cmd = packet['cmd']
if "val" in packet:
val = packet["val"]
else:
val = ""
if "id" in packet:
try:
id = self.handlers[self.userlist.index(
str(packet['id']))]
except Exception as e:
id = ""
else:
id = ""
if "name" in packet:
name = str(packet['name'])
else:
name = ""
if cmd == "clear": # Clears comms
self.sendPacket(server, False, {
"cmd": "gmsg",
"val": ""
})
self.sendPacket(server, False, {
"cmd": "pmsg",
"val": ""
})
if cmd == "setid": # Set username on server link
if "val" in packet:
if not client in self.handlers:
self.userlist.append(val)
self.handlers.append(client)
else:
if self.users[str(
client)]['name'] in self.userlist:
self.userlist[self.userlist.index(
self.users[str(
client)]['name'])] = val
self.users[str(client)]['name'] = val
print("User {0} declared username: {1}".format(
client['id'],
self.users[str(client)]['name']))
self.relayUserList(server, False, client)
if cmd == "gmsg": # Set global stream data values
self.gdata = str(val)
self.sendPacket(server, False, {
"cmd": "gmsg",
"val": self.gdata
})
if cmd == "pmsg": # Set private stream data values
if not id == "":
self.sendPacket(server, True, {
"cmd": "pmsg",
"id": id,
"val": val
})
if cmd == "gvar": # Set global variable data values
self.sendPacket(server, False, {
"cmd": "gvar",
"name": name,
"val": val
})
if cmd == "pvar": # Set private variable data values
if not id == "":
self.sendPacket(
server, True, {
"cmd": "pvar",
"name": name,
"id": id,
"val": val
})
class ServerWs(threading.Thread):
def __init__(self, bartender):
threading.Thread.__init__(self)
self.bartender = bartender
self.bartender.log("ServerWs", "Initialisation...")
self.server = None
def run(self):
self.bartender.log(
"ServerWs",
f"Démarrage du serveur websocket sur l'adresse {self.bartender.config['ws']['ip']}:{self.bartender.config['ws']['port']}..."
)
try:
self.server = WebsocketServer(
self.bartender.config["ws"]["port"],
host=self.bartender.config["ws"]["ip"],
loglevel=logging.NOTSET)
self.server.set_fn_new_client(self.new_client)
self.server.set_fn_message_received(self.message_received)
self.server.set_fn_client_left(self.client_left)
self.bartender.log("ServerWs", "Serveur démarré")
self.server.run_forever()
except Exception as e:
self.bartender.log(
"ServerWs", "Erreur lors du démarrage du serveur : " + str(e))
def close(self):
self.bartender.log("ServerWs", "Arrêt du serveur websocket...")
try:
self.server.server_close()
self.server = None
self.bartender.log("ServerWs", "Arrêté")
except Exception as e:
self.bartender.log("ServerWs",
"Erreur lors de l'arrêt du serveur : " + str(e))
def send_message(self, client, msg):
self.bartender.log("ServerWs", f"Envoie (id:{client['id']}) : {msg}")
self.server.send_message(client, msg)
def send_message_to_all(self, msg):
# self.bartender.log("ServerWs", f"Envoie (all) : {msg}")
for client in self.server.clients:
if (client != self.bartender.ethylotest):
self.server.send_message(client, msg)
def message_received(self, client, server, msg):
self.bartender.log("ServerWs", f"Reçu (id:{client['id']}) : {msg}")
self.bartender.message_received(client, server, msg)
def new_client(self, client, server):
self.bartender.log("ServerWs",
f"Nouvelle connexion (id:{client['id']})")
self.bartender.newClient(client, server)
def client_left(self, client, server):
self.bartender.log("ServerWs", f"Déconnexion (id:{client['id']})")
self.bartender.clientLeft(client, server)
def getOtherClients(self, client):
clients = []
for other in self.server.clients:
if (other != client):
clients.append(other)
return clients
def kickClient(self, client):
client['handler'].send_text("", opcode=0x8)
class RTC_Spider2020_Info(OpenRTM_aist.DataFlowComponentBase):
##
# @brief constructor
# @param manager Maneger Object
#
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
self._d_GCCapacityRatio_In = OpenRTM_aist.instantiateDataType(
RTC.TimedDouble)
"""
ゲームコントローラのバッテリ残容量比
- Unit: [%]
"""
self._GCCapacityRatio_InIn = OpenRTM_aist.InPort(
"GCCapacityRatio_In", self._d_GCCapacityRatio_In)
self._d_MainCapacityRatio_In = OpenRTM_aist.instantiateDataType(
RTC.TimedDouble)
"""
メインバッテリのバッテリ残容量比
- Unit: [%]
"""
self._MainCapacityRatio_InIn = OpenRTM_aist.InPort(
"MainCapacityRatio_In", self._d_MainCapacityRatio_In)
self._d_Mode_In = OpenRTM_aist.instantiateDataType(RTC.TimedLongSeq)
"""
動作指令の状態
- Number: 6
- Semantics: [0]: 操作モード
[1]: 走行操作 速度レベル
[2]: 走行操作 最大速度フラグ
[3]: 走行モード フリッパーの選択状態
[4]: 走行モード フリッパーの動作状態
[5]: 走行モード 台車の位置姿勢のクリア
"""
self._Mode_InIn = OpenRTM_aist.InPort("Mode_In", self._d_Mode_In)
self._d_Pose3D_In = OpenRTM_aist.instantiateDataType(RTC.TimedPose3D)
"""
３次元の位置・姿勢
- Unit: 位置:[m], 姿勢:[rad]
"""
self._Pose3D_InIn = OpenRTM_aist.InPort("Pose3D_In", self._d_Pose3D_In)
self._d_Velocity2D_In = OpenRTM_aist.instantiateDataType(
RTC.TimedVelocity2D)
"""
メインクローラの速度
- Unit: [m/s]
"""
self._Velocity2D_InIn = OpenRTM_aist.InPort("Velocity2D_In",
self._d_Velocity2D_In)
self._d_FlipperAngle_In = OpenRTM_aist.instantiateDataType(
RTC.TimedDoubleSeq)
"""
フリッパーの角度
- Number: 4
- Semantics: [0]: 右前方フリッパー
[1]: 左前方フリッパー
[2]: 右後方フリッパー
[3]: 左後方フリッパー
- Unit: [rad]
"""
self._FlipperAngle_InIn = OpenRTM_aist.InPort("FlipperAngle_In",
self._d_FlipperAngle_In)
self._d_MotorLoad_In = OpenRTM_aist.instantiateDataType(
RTC.TimedDoubleSeq)
"""
モータの負荷
- Number: 6
- Semantics: [0]: 右メインモータ
[1]: 左メインモータ
[2]: 右前方サブモータ
[3]: 左前方サブモータ
[4]: 右後方サブモータ
[5]: 左後方サブモータ
- Unit: [A]
"""
self._MotorLoad_InIn = OpenRTM_aist.InPort("MotorLoad_In",
self._d_MotorLoad_In)
self._d_Arm1Pose3D_In = OpenRTM_aist.instantiateDataType(
RTC.TimedPose3D)
"""
アーム1の３次元の位置・姿勢
(ロボット座標系)
- Unit: 位置:[m], 姿勢:[rad]
"""
self._Arm1Pose3D_InIn = OpenRTM_aist.InPort("Arm1Pose3D_In",
self._d_Arm1Pose3D_In)
self._d_Arm1Angular_In = OpenRTM_aist.instantiateDataType(
RTC.TimedDoubleSeq)
"""
アーム1の腕の角度
- Semantics: [0]: 1軸目
[1]: 2軸目
[2]: 3軸目
[3]: 4軸目
[4]: 5軸目
[5]: 6軸目
- Unit: [rad]
"""
self._Arm1Angular_InIn = OpenRTM_aist.InPort("Arm1Angular_In",
self._d_Arm1Angular_In)
self._d_Arm1Finger_In = OpenRTM_aist.instantiateDataType(
RTC.TimedLongSeq)
"""
アーム1の指の開閉具合
- Semantics: [0]: 親指
[1]: 差指
[2]: 中指
- Unit: [u] (独自単位)
"""
self._Arm1Finger_InIn = OpenRTM_aist.InPort("Arm1Finger_In",
self._d_Arm1Finger_In)
self._d_Arm1Current_In = OpenRTM_aist.instantiateDataType(
RTC.TimedDoubleSeq)
"""
アーム1のモータ負荷
- Semantics: [0]: 1軸目
[1]: 2軸目
[2]: 3軸目
[3]: 4軸目
[4]: 5軸目
[5]: 6軸目
[6]: 親指
[7]: 差指
[8]: 中指
- Unit: [A]
"""
self._Arm1Current_InIn = OpenRTM_aist.InPort("Arm1Current_In",
self._d_Arm1Current_In)
# initialize of configuration-data.
# <rtc-template block="init_conf_param">
"""
WebSocket 待受ポート番号
- Name: WEBSOCKET_PORT
- DefaultValue: 8080
"""
self._WEBSOCKET_PORT = [8080]
"""
WebSocket 待受アドレス
- Name: WEBSOCKET_HOST
- DefaultValue: 0.0.0.0
"""
self._WEBSOCKET_HOST = ['0.0.0.0']
# </rtc-template>
##
#
# The initialize action (on CREATED->ALIVE transition)
# formaer rtc_init_entry()
#
# @return RTC::ReturnCode_t
#
#
def onInitialize(self):
# Bind variables and configuration variable
self.bindParameter("WEBSOCKET_PORT", self._WEBSOCKET_PORT, "8080")
self.bindParameter("WEBSOCKET_HOST", self._WEBSOCKET_HOST, "0.0.0.0")
# Set InPort buffers
self.addInPort("GCCapacityRatio_In", self._GCCapacityRatio_InIn)
self.addInPort("MainCapacityRatio_In", self._MainCapacityRatio_InIn)
self.addInPort("Mode_In", self._Mode_InIn)
self.addInPort("Pose3D_In", self._Pose3D_InIn)
self.addInPort("Velocity2D_In", self._Velocity2D_InIn)
self.addInPort("FlipperAngle_In", self._FlipperAngle_InIn)
self.addInPort("MotorLoad_In", self._MotorLoad_InIn)
self.addInPort("Arm1Pose3D_In", self._Arm1Pose3D_InIn)
self.addInPort("Arm1Angular_In", self._Arm1Angular_InIn)
self.addInPort("Arm1Finger_In", self._Arm1Finger_InIn)
self.addInPort("Arm1Current_In", self._Arm1Current_InIn)
# Set OutPort buffers
# Set service provider to Ports
# Set service consumers to Ports
# Set CORBA Service Ports
return RTC.RTC_OK
##
#
# The finalize action (on ALIVE->END transition)
# formaer rtc_exiting_entry()
#
# @return RTC::ReturnCode_t
#
def onFinalize(self):
return RTC.RTC_OK
###
##
## The startup action when ExecutionContext startup
## former rtc_starting_entry()
##
## @param ec_id target ExecutionContext Id
##
## @return RTC::ReturnCode_t
##
##
#def onStartup(self, ec_id):
#
# return RTC.RTC_OK
###
##
## The shutdown action when ExecutionContext stop
## former rtc_stopping_entry()
##
## @param ec_id target ExecutionContext Id
##
## @return RTC::ReturnCode_t
##
##
#def onShutdown(self, ec_id):
#
# return RTC.RTC_OK
##
#
# The activated action (Active state entry action)
# former rtc_active_entry()
#
# @param ec_id target ExecutionContext Id
#
# @return RTC::ReturnCode_t
#
#
def onActivated(self, ec_id):
# ビューアーの設定ファイルを生成
config = {
"WEBSOCKET_PORT": self._WEBSOCKET_PORT[0],
}
with open(VIEWER_CONFIG_FILE, mode="w") as f:
json.dump(config,
f,
ensure_ascii=False,
indent=2,
separators=(",", ": "))
#def ws_on_message(client, server, message):
# server.send_message_to_all(message)
# return
# WebSocket サーバーを起動
self.ws_server = WebsocketServer(self._WEBSOCKET_PORT[0],
host=self._WEBSOCKET_HOST[0])
#self.ws_server.set_fn_message_received(ws_on_message)
self.ws_thread = threading.Thread(target=self.ws_server.run_forever)
self.ws_thread.start()
return RTC.RTC_OK
##
#
# The deactivated action (Active state exit action)
# former rtc_active_exit()
#
# @param ec_id target ExecutionContext Id
#
# @return RTC::ReturnCode_t
#
#
def onDeactivated(self, ec_id):
# WebSocket サーバーを終了
self.ws_server.shutdown()
self.ws_server.server_close()
return RTC.RTC_OK
##
#
# The execution action that is invoked periodically
# former rtc_active_do()
#
# @param ec_id target ExecutionContext Id
#
# @return RTC::ReturnCode_t
#
#
def onExecute(self, ec_id):
# 入力ポートに入ってきたデータを WebSocket クライアントに転送する
for port in self._inports:
port_name = port._name
port_type = port._value.__class__.__name__
if port.isNew():
port_in = port.read()
time = port_in.tm.sec + port_in.tm.nsec * (10**-9)
if port_type in [
"TimedDouble", "TimedLongSeq", "TimedDoubleSeq"
]:
data = port_in.data
elif port_type == "TimedPose3D":
position = port_in.data.position
orientation = port_in.data.orientation
data = {
"position": {
"x": position.x,
"y": position.y,
"z": position.z
},
"orientation": {
"r": orientation.r,
"p": orientation.p,
"y": orientation.y
},
}
elif port_type == "TimedVelocity2D":
velocity = port_in.data
data = {
"vx": velocity.vx,
"vy": velocity.vy,
"va": velocity.va
}
js_data = json.dumps({port_name: {"tm": time, "data": data}})
self.ws_server.send_message_to_all(js_data)
#print(js_data)
return RTC.RTC_OK
class SocConn(Communicator):
def __init__(self):
super().__init__()
DEFAULT_SOC_PORT = 8765
self.host = ''
self.port = DEFAULT_SOC_PORT
self.bus = WebsocketServer(host=self.host, port=self.port)
self.recv_q = Queue()
self.send_q = Queue()
self.close_event = False
def open(self):
Thread(target=self.__open, daemon=True).start()
Thread(target=self.__send_handler, daemon=True).start()
return self.host, self.port
def close(self):
self.bus.server_close()
def recv(self):
if self.recv_q.empty():
return None
modi_message = self.recv_q.get()
return modi_message
def send(self, modi_message):
self.send_q.put(modi_message)
#
# Helper Methods
#
def __open(self):
def new_client(client, server):
server.send_message_to_all(
f'Hey all, a new client:{client} has joined us'
)
def client_left(client, server):
server.send_message_to_all(
f'Hey all, a client:{client} has left us'
)
# Set callback functions
self.bus.set_fn_new_client(new_client)
self.bus.set_fn_message_received(self.__recv_handler)
self.bus.set_fn_client_left(client_left)
# Run the server forever
self.bus.run_forever()
def __recv_handler(self, client, server, message):
self.recv_q.put(message)
def __send_handler(self):
while not self.close_event:
if self.send_q.empty():
time.sleep(0.001)
continue
try:
message = self.send_q.get()
self.bus.send_message_to_all(message)
except Exception:
self.close_event = True
