def start_server(port):
server = WebsocketServer(port)
ws_log.debug("Server listening on port: %d" % port)
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 __init__(self, conf):
global server
super(WSService, self).__init__()
self.conf = conf
server = WebsocketServer(WSPORT, host='0.0.0.0')
server.set_fn_new_client(newClient)
server.set_fn_client_left(leftClient)
def start_server():
"""Start both the Game Manager and the Web Server"""
# Prepare the web server with above functions
logger.info("Init Web Socket Server")
server = WebsocketServer(PORT, HOST)
server.set_fn_new_client(onconnect)
server.set_fn_client_left(ondisconnect)
server.set_fn_message_received(onmessage)
# Create a game manager
logger.info("Init Game Manager")
global manager
manager = Manager(server)
# Start the web server
logger.info("Starting Server")
server.run_forever()
manager.safe_stop()
# 6. Send Khan user data to the client
#server.send_message(client, login_data)
def runWebsocketServer():
global server
server.run_forever()
def runAuthServer():
global callback_server
callback_server.serve_forever()
#PORT=9001
PORT=8080
SERVERHOST= "0.0.0.0"
server = WebsocketServer(PORT, SERVERHOST)
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
#server.run_forever()
#callback_server.serve_forever()
t1 = threading.Thread(target=runWebsocketServer, args=[])
t2 = threading.Thread(target=runAuthServer, args=[])
t1.start()
t2.start()
for mod in modlist:
mname = GetModuleName(phandle,mod)
if mname.endswith(game["moduleName"]):
memory_address = mod + game["memoryOffset"]
# read address
def readTicker():
ReadProcessMemory(phandle, memory_address, ticker, ticker_s, byref(bytesRead))
def clientJoin(client,server):
global client_num
client_num += 1
if(client_num==1):
initTicker()
def clientLeave(client,server):
global client_num
client_num -= 1
if(client_num==0):
CloseHandle(phandle)
def clientMsg(client,server,message):
readTicker()
server.send_message(client,ticker.value.replace('m','.'))
print "Starting server on " + str(socket.gethostbyname(socket.gethostname()))
server = WebsocketServer(config["serverPort"],"0.0.0.0")
server.set_fn_new_client(clientJoin)
server.set_fn_client_left(clientLeave)
server.set_fn_message_received(clientMsg)
server.run_forever()
def doLogin(message, server):
global unModel
# obj = ast.literal_eval(message) //pour compatibilité avec Android
# print message //aucune idée pourquoi mais il faut mettre cela pour que ça fonctionne avec Android!!?
obj = json.loads(message)
objLogin = obj["object"]
unModel.nom = objLogin["name"]
unModel.prenom = objLogin["firstname"]
#Ack client
dict={}
dict["messageType"]="ackLogin"
objJson = json.dumps(dict)
server.send_message(wsIHM, objJson)
if __name__ == "__main__":
# Fixation du point de lecture de fichier
os.chdir('/')#Obligation de donner le chemin du fichier avec le QPython
# routage des messages receptionnes
switch={
"login":doLogin
}
# Initialisation des models
unModel = UnModel()
# Connexion au client web
server = WebsocketServer(9999)
server.set_fn_new_client(new_client) #définition de la fonction pour l arrivé d un nouveau client
server.set_fn_message_received(rxMessage) #Définition de la fonction pour l arrivé d un nouveau message
server.set_fn_client_left(clientLeft) #définition de la fonction pour la déconnexion d'un client
server.run_forever()
def serve(port, host):
from websocket_server import WebsocketServer
from threading import Thread, Event
import signal
def message_received(client, server, message):
print 'message_received:', message
cmds = message.split('|')
for cmd in cmds:
if cmd.startswith('addr='):
address = cmd[5:]
if server.watched_addresses.has_key(address):
server.watched_addresses[address].append(client)
else:
server.watched_addresses[address] = [client]
if cmd == 'blocks':
server.block_watchers.append(client)
def client_left(client, server):
print 'client_left:', client
addrs = []
for key in server.watched_addresses:
if client in server.watched_addresses[key]:
addrs.append(key)
for addr in addrs:
clients = server.watched_addresses[addr]
clients.remove(client)
if not clients:
del server.watched_addresses[addr]
if client in server.block_watchers:
server.block_watchers.remove(client)
def service_thread(ws_server, evt):
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
from bitrisk.bitcoind_config import read_default_config
import json
import decimal
config = read_default_config()
testnet = ''
if config.has_key('testnet'):
testnet = config['testnet']
rpc_user = config['rpcuser']
rpc_password = config['rpcpassword']
rpc_connection = AuthServiceProxy("http://%s:%s@%s:%s8332"%(rpc_user, rpc_password, host, testnet))
conn = sqlite3.connect(db_filename)
while not evt.wait(5):
txs = get_db_txs(conn)
for tx in txs:
print 'tx:', tx
tx = rpc_connection.gettransaction(tx)
for details in tx['details']:
addr = details['address']
if ws_server.watched_addresses.has_key(addr):
def decimal_default(obj):
if isinstance(obj, decimal.Decimal):
return float(obj)
raise TypeError
msg = json.dumps(tx, default=decimal_default)
for client in ws_server.watched_addresses[addr]:
ws_server.send_message(client, msg)
blocks = get_db_blocks(conn)
for block in blocks:
print 'block:', block
for client in ws_server.block_watchers:
ws_server.send_message(client, block)
server = WebsocketServer(port, host)
server.watched_addresses = {}
server.block_watchers = []
server.set_fn_message_received(message_received)
server.set_fn_client_left(client_left)
evt = Event()
thread = Thread(target=service_thread, args=(server, evt))
thread.start()
server.run_forever() # catches and exits on SIGINT
evt.set() # stop service_thread
thread.join()
# print 'car position did not change'
pos_check = 0
idx0 = string_list[1].find("[")
car_orient_tmp = eval(string_list[1][idx0:])
orient_check = 1
if np.linalg.norm(np.array(car_orient_tmp) - np.array(car_orient)) < 0.05:
# print 'car orientation did not change'
pos_check = 0
if car_pos_tmp == [0, 0] and car_orient_tmp == [1, 0]:
return
car_pos = car_pos_tmp
car_orient = car_orient_tmp
new_car_param = pos_check + orient_check
if new_car_param < 2:
new_car_param = 0
else:
new_car_param = 1
server = WebsocketServer(9090, host='172.27.163.216')
server.set_fn_new_client(new_client)
server.set_fn_message_received(new_message)
server.set_fn_client_left(client_left)
path_pub = rospy.Publisher('web_socket/path', String, queue_size=1)
rospy.Subscriber('lane_driver/path', String, callback_path)
rospy.Subscriber("lane_driver/car", String, callback_car)
rospy.Subscriber("drive_param_fin", drive_param, callback_drive)
update_thread = Update()
server.run_forever()
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)
def serveWS(PORT=8988):
wsServer = WebsocketServer(PORT, host='192.168.1.200')
wsServer.set_fn_new_client(WS_new_client)
wsServer.set_fn_client_left(WS_client_left)
wsServer.set_fn_message_received(WS_onmessage)
wsServer.run_forever()
class Plugin(indigo.PluginBase):
########################################
# Main Plugin methods
########################################
def __init__(self, pluginId, pluginDisplayName, pluginVersion,
pluginPrefs):
indigo.PluginBase.__init__(self, pluginId, pluginDisplayName,
pluginVersion, pluginPrefs)
pfmt = logging.Formatter(
'%(asctime)s.%(msecs)03d\t[%(levelname)8s] %(name)20s.%(funcName)-25s%(msg)s',
datefmt='%Y-%m-%d %H:%M:%S')
self.plugin_file_handler.setFormatter(pfmt)
try:
self.logLevel = int(self.pluginPrefs[u"logLevel"])
except:
self.logLevel = logging.INFO
self.indigo_log_handler.setLevel(self.logLevel)
def validatePrefsConfigUi(self, valuesDict):
errorDict = indigo.Dict()
try:
self.logLevel = int(valuesDict[u"logLevel"])
except:
self.logLevel = logging.INFO
self.indigo_log_handler.setLevel(self.logLevel)
try:
port = int(valuesDict[u"socketPort"])
except:
errorDict[u"socketPort"] = "Non-integer port number"
else:
if port < 1024:
errorDict[u"socketPort"] = "Priviledged port number"
if len(errorDict) > 0:
return (False, valuesDict, errorDict)
return (True, valuesDict)
def closedPrefsConfigUi(self, valuesDict, userCancelled):
if userCancelled:
return
self.logLevel = int(valuesDict[u"logLevel"])
self.indigo_log_handler.setLevel(self.logLevel)
if valuesDict[u"socketPort"] != self.socketPort:
self.socketPort = valuesDict[u"socketPort"]
self.start_websocket(int(self.socketPort))
def startup(self):
self.logger.info(u"Starting StreamDeck")
self.triggers = {}
self.activeConnections = {}
# these are the Streamdeck devices and buttons that have Indigo devices to match
self.activeDecks = {}
self.activeButtons = {}
# these are the known Streamdeck devices and buttons, may not have a matching Indigo device
self.known_devices = indigo.activePlugin.pluginPrefs.get(
u"known_devices", indigo.Dict())
self.known_buttons = indigo.activePlugin.pluginPrefs.get(
u"known_buttons", indigo.Dict())
self.wsServer = None
self.socketPort = self.pluginPrefs.get(u'socketPort', 9001)
self.start_websocket(int(self.socketPort))
def shutdown(self):
self.logger.info(u"Stopping StreamDeck")
indigo.activePlugin.pluginPrefs[u"known_devices"] = self.known_devices
indigo.activePlugin.pluginPrefs[u"known_buttons"] = self.known_buttons
if self.wsServer:
self.wsServer.server_close()
self.wsServer = None
def start_websocket(self, port):
if self.wsServer:
self.logger.debug("Closing existing Websocket Server")
self.wsServer.server_close()
self.wsServer = None
try:
self.wsServer = WebsocketServer(
port, '0.0.0.0') # bind socket to all interfaces
self.wsServer.set_fn_new_client(self.onConnect)
self.wsServer.set_fn_client_left(self.onClose)
self.wsServer.set_fn_message_received(self.onMessage)
self.wsServer.timeout = 1.0
self.logger.debug(
u"Started Websocket Server on port {}".format(port))
except Error as e:
self.logger.warning(
u"Error starting Websocket Server: {}".format(e))
def runConcurrentThread(self):
try:
while True:
if self.wsServer:
self.wsServer.handle_request()
self.sleep(0.1)
else:
self.sleep(1)
except self.StopThread:
pass
####################
def onConnect(self, client, server):
self.logger.debug(u"onConnect client: {}".format(client['id']))
self.activeConnections[client['id']] = client
self.logger.debug(u"onConnect activeConnections: {}".format(
self.activeConnections))
reply = {"event": "connected", "clientID": client['id']}
self.wsServer.send_message(client, json.dumps(reply))
def onClose(self, client, server):
self.logger.debug(u"onClose client: {}".format(client['id']))
del self.activeConnections[client['id']]
def onMessage(self, client, server, received):
try:
message = json.loads(received)
except:
self.logger.warning(
u"onMessage from client {}, invalid JSON:\n{}".format(
client['id'], received))
return
self.logger.threaddebug(
u"onMessage from client: {}, message: {}".format(
client['id'], message))
if not 'message-type' in message:
self.logger.warning(
"onMessage from client {}, no message-type, message: {}".
format(client['id'], message))
return
if message['message-type'] == 'applicationInfo':
self.applicationInfo(message, client)
elif message['message-type'] in ['deviceDidConnect']:
self.deviceDidConnect(message, client)
elif message['message-type'] in ['deviceDidDisconnect']:
self.deviceDidDisconnect(message, client)
elif message['message-type'] in ['willAppear']:
self.buttonWillAppear(message, client)
elif message['message-type'] in ['willDisappear']:
self.buttonWillDisappear(message, client)
elif message['message-type'] in ['keyUp', 'keyDown']:
self.keyPress(message, client)
####################
def applicationInfo(self, message, client):
for dev in message[u'payload'][u'devices']:
self.logger.debug(
u"onMessage applicationInfo Adding/Updating device: {}".format(
dev))
deck = {}
deck[u'id'] = dev[u'id']
deck[u'name'] = dev[u'name']
deck[u'columns'] = dev[u'size'][u'columns']
deck[u'rows'] = dev[u'size'][u'rows']
deck[u'type'] = dev.get(u'type', -1)
deck[u'client'] = client['id']
self.registerDeck(deck)
def deviceDidConnect(self, message, client):
self.logger.debug(
u"onMessage deviceDidConnect Adding/Updating device: {}".format(
message))
deck = {}
deck[u'id'] = message[u'payload'][u'device']
deck[u'name'] = message[u'payload'][u'deviceInfo'][u'name']
deck[u'columns'] = message[u'payload'][u'deviceInfo'][u'size'][
u'columns']
deck[u'rows'] = message[u'payload'][u'deviceInfo'][u'size'][u'rows']
deck[u'type'] = message[u'payload'][u'deviceInfo'].get(u'type', -1)
deck[u'client'] = client['id']
self.registerDeck(deck)
def registerDeck(self, deckDict):
deckKey = safeKey(deckDict[u'id'])
self.known_devices[deckKey] = deckDict
if deckKey in self.activeDecks: # If there's an active Indigo device, update the active state
deckDevice = indigo.devices.get(int(self.activeDecks[deckKey]))
if not deckDevice:
self.logger.warning(
"registerDeck invalid Deck DeviceID: {}".format(deckDict))
else:
states_list = []
states_list.append({'key': 'active', 'value': True})
states_list.append({'key': 'name', 'value': deckDict[u'name']})
states_list.append({
'key': 'columns',
'value': deckDict[u'columns']
})
states_list.append({'key': 'rows', 'value': deckDict[u'rows']})
states_list.append({'key': 'type', 'value': deckDict[u'type']})
states_list.append({
'key': 'clientID',
'value': deckDict['client']
})
deckDevice.updateStatesOnServer(states_list)
def deviceDidDisconnect(self, message, client):
self.logger.debug(u"onMessage deviceDidDisconnect: {}".format(message))
deckKey = safeKey(message[u'payload'][u'device'])
if deckKey in self.activeDecks: # If there's an active Indigo device, update the active state
deckDevice = indigo.devices.get(int(self.activeDecks[deckKey]))
if not deckDevice:
self.logger.warning(
"deviceDidDisconnect invalid Deck DeviceID: {}".format(
message))
else:
deckDevice.updateStateOnServer(key="active", value=False)
def buttonWillAppear(self, message, client):
self.logger.debug(u"onMessage buttonWillAppear: {}".format(message))
buttonKey = safeKey(message[u'payload'][u'context'])
button = {}
button[u'id'] = message[u'payload'][u'context']
button[u'device'] = message[u'payload'][u'device']
button[u'column'] = message[u'payload'][u'payload'][u'coordinates'][
u'column']
button[u'row'] = message[u'payload'][u'payload'][u'coordinates'][
u'row']
button[u'settings'] = message[u'payload'][u'payload'][u'settings']
button[u'name'] = "{}-{}-{}".format(
self.known_devices[button[u'device']][u'name'], button[u'column'],
button[u'row'])
button[u'client'] = client['id']
self.known_buttons[buttonKey] = button
if buttonKey in self.activeButtons: # If there's an active Indigo device, update the visible state
buttonDevice = indigo.devices.get(
int(self.activeButtons[buttonKey]))
if not buttonDevice:
self.logger.warning(
"buttonWillAppear invalid button DeviceID: {}".format(
message))
else:
states_list = []
states_list.append({'key': 'visible', 'value': True})
states_list.append({'key': 'name', 'value': button[u'name']})
states_list.append({
'key': 'column',
'value': button[u'column']
})
states_list.append({'key': 'row', 'value': button[u'row']})
states_list.append({'key': 'clientID', 'value': client['id']})
buttonDevice.updateStatesOnServer(states_list)
def buttonWillDisappear(self, message, client):
self.logger.debug(u"onMessage buttonWillDisappear: {}".format(message))
buttonKey = safeKey(message[u'payload'][u'context'])
if buttonKey in self.activeButtons: # If there's an active Indigo device, update the visible state
buttonDevice = indigo.devices.get(
int(self.activeButtons[buttonKey]))
if not buttonDevice:
self.logger.warning(
"buttonWillDisappear invalid button DeviceID: {}".format(
message))
else:
deckDevice.updateStateOnServer(key="visible", value=False)
def keyPress(self, message, client):
self.logger.debug(u"onMessage keyPress: {}".format(message))
messageType = message['message-type']
if messageType not in ['keyDown', 'keyUp']:
self.logger.warning("keyPress unexpected message-type: {}".format(
message['message-type']))
return
eventID = message[u'payload'][u'payload'][u'settings'][u'eventID']
actionRequest = message[u'payload'][u'payload'][u'settings'][
u'actionRequest']
if actionRequest == u'action-group' and messageType == 'keyDown':
indigo.actionGroup.execute(int(eventID))
elif actionRequest == u'indigo-device-momentary' and messageType == 'keyDown':
indigo.device.turnOn(int(eventID))
elif actionRequest == u'indigo-device-momentary' and messageType == 'keyUp':
indigo.device.turnOff(int(eventID))
elif actionRequest == u'indigo-device-toggle' and messageType == 'keyDown':
indigo.device.toggle(int(eventID))
elif actionRequest == u'indigo-variable':
indigo.variable.updateValue(int(eventID), value=messageType)
########################################
def validateDeviceConfigUi(self, valuesDict, typeId, devId):
errorsDict = indigo.Dict()
if len(errorsDict) > 0:
return (False, valuesDict, errorsDict)
return (True, valuesDict)
########################################
# Called for each enabled Device belonging to plugin
########################################
def deviceStartComm(self, device):
self.logger.info(u"{}: Starting Device".format(device.name))
instanceVers = int(device.pluginProps.get('devVersCount', 0))
if instanceVers == kCurDevVersCount:
self.logger.threaddebug(
u"{}: Device is current version: {}".format(
device.name, instanceVers))
elif instanceVers < kCurDevVersCount:
newProps = device.pluginProps
newProps["devVersCount"] = kCurDevVersCount
device.replacePluginPropsOnServer(newProps)
self.logger.debug(u"{}: Updated device version: {} -> {}".format(
device.name, instanceVers, kCurDevVersCount))
else:
self.logger.warning(u"{}: Invalid device version: {}".format(
device.name, instanceVers))
if device.deviceTypeId == "sdDevice":
self.activeDecks[device.address] = device.id
elif device.deviceTypeId == "sdButton":
self.activeButtons[device.address] = device.id
def deviceStopComm(self, device):
self.logger.info(u"{}: Stopping Device".format(device.name))
if device.deviceTypeId == "sdDevice":
del self.activeDecks[device.id]
elif device.deviceTypeId == "sdButton":
del self.activeButtons[device.id]
########################################
# Plugin Actions object callbacks
########################################
def setButtonIcon(self, pluginAction, deckDevice, callerWaitingForResult):
self.logger.debug(
"setButtonIcon: pluginAction = {}".format(pluginAction))
profile = indigo.activePlugin.substitute(pluginAction.props["profile"])
deckDeviceID = pluginAction.props["device"]
deckDict = self.known_devices[safeKey(deckDeviceID)]
self.logger.debug("setButtonIcon: deckDict = {}".format(deckDict))
socketClient = self.activeConnections[deckDict['client']]
message = {
"event": "setButtonIcon",
"device": deckDeviceID,
"profile": profile
}
self.wsServer.send_message(socketClient, json.dumps(message))
def availableDeckList(self,
filter="",
valuesDict=None,
typeId="",
targetId=0):
retList = []
for key in self.known_devices:
device = self.known_devices[key]
retList.append((device['id'], device['name']))
self.logger.debug("availableDeckList: retList = {}".format(retList))
return retList
def availableButtonList(self,
filter="",
valuesDict=None,
typeId="",
targetId=0):
in_use = []
for dev in indigo.devices.iter(filter="self.sdButton"):
in_use.append(dev.pluginProps[u'context'])
retList = []
for key in self.known_buttons:
button = self.known_buttons[key]
if button['id'] not in in_use:
retList.append((button['id'], button['name']))
self.logger.debug("availableButtonList: retList = {}".format(retList))
return retList
# doesn't do anything, just needed to force other menus to dynamically refresh
def menuChanged(self, valuesDict=None, typeId=None, devId=None):
return valuesDict
def validateActionConfigUi(self, valuesDict, typeId, devId):
errorsDict = indigo.Dict()
try:
pass
except:
pass
if len(errorsDict) > 0:
return (False, valuesDict, errorsDict)
return (True, valuesDict)
########################################
# Menu Command Methods
########################################
def dumpKnownDevices(self):
self.logger.info(u"Known decks:\n{}".format(self.known_devices))
self.logger.info(u"Known buttons:\n{}".format(self.known_buttons))
def dumpActiveDevices(self):
self.logger.info(u"Active decks:\n{}".format(self.activeDecks))
self.logger.info(u"Active buttons:\n{}".format(self.activeButtons))
def purgeKnownDevices(self):
self.known_devices = {}
self.known_buttons = {}
########################################
# Event/Trigger Methods
########################################
def triggerStartProcessing(self, trigger):
self.logger.debug("Adding Trigger %s (%d) - %s" %
(trigger.name, trigger.id, trigger.pluginTypeId))
assert trigger.id not in self.triggers
self.triggers[trigger.id] = trigger
def triggerStopProcessing(self, trigger):
self.logger.debug("Removing Trigger %s (%d)" %
(trigger.name, trigger.id))
assert trigger.id in self.triggers
del self.triggers[trigger.id]
def triggerCheck(self, device):
for triggerId, trigger in sorted(self.triggers.iteritems()):
self.logger.debug("Checking Trigger %s (%s), Type: %s" %
(trigger.name, trigger.id, trigger.pluginTypeId))
time.sleep(0.01) client["handler"].connection.close() del clients[client['id']] print len(clients) # When we recieve thing from WebSocket browser def message_client(client,server,message): json_d = json.loads(message) try: if json_d["action"] == "connect": start_new_thread(start_new_shell,(client,server,json_d["host"],json_d["port"],json_d["username"],json_d["password"],)) elif json_d["action"] == "key": chan = clients[client["id"]]['channel'] chan.send(json_d["key"]) elif json_d["action"] == "keySpecial": chan = clients[client["id"]]['channel'] json_d["key"] = "\x1B" + json_d["key"] chan.send(json_d["key"]) elif json_d["action"] == "keyCode": chan = clients[client["id"]]['channel'] chan.send(chr(json_d["keyCode"])) except: bye_client(client, server) # Listening to our desired port and setting up the connection server = WebsocketServer(13254, host='0.0.0.0') server.set_fn_new_client(new_client) server.set_fn_client_left(bye_client) server.set_fn_message_received(message_client) server.run_forever()
class Template:
# Initialize class variables
# self.time_cycle to run an execution for atleast 1 second
# self.process for the current running process
def __init__(self):
self.thread = None
self.reload = False
# Time variables
self.time_cycle = 80
self.ideal_cycle = 80
self.iteration_counter = 0
self.server = None
self.client = None
self.host = sys.argv[1]
# Initialize the GUI, WEBRTC and Console behind the scenes
self.console = console.Console()
self.exercice = subprocess.Popen(["python", "consumer.py"],
stdout=subprocess.PIPE,
preexec_fn=os.setsid)
self.gui = GUI(self.host, self.console)
# Function for saving
def save_code(self, source_code):
with open('code/academy.py', 'w') as code_file:
code_file.write(source_code)
# Function for loading
def load_code(self):
with open('code/academy.py', 'r') as code_file:
source_code = code_file.read()
return source_code
# Function to parse the code
# A few assumptions:
# 1. The user always passes sequential and iterative codes
# 2. Only a single infinite loop
def parse_code(self, source_code):
# Check for save/load
if (source_code[:5] == "#save"):
source_code = source_code[5:]
self.save_code(source_code)
return "", "", 1
elif (source_code[:5] == "#load"):
source_code = source_code + self.load_code()
self.server.send_message(self.client, source_code)
return "", "", 1
else:
# Get the frequency of operation, convert to time_cycle and strip
try:
# Get the debug level and strip the debug part
debug_level = int(source_code[5])
source_code = source_code[12:]
except:
debug_level = 1
source_code = ""
source_code = self.debug_parse(source_code, debug_level)
sequential_code, iterative_code = self.seperate_seq_iter(
source_code)
return iterative_code, sequential_code, debug_level
# Function to parse code according to the debugging level
def debug_parse(self, source_code, debug_level):
if (debug_level == 1):
# If debug level is 0, then all the GUI operations should not be called
source_code = re.sub(r'GUI\..*', '', source_code)
return source_code
# Function to seperate the iterative and sequential code
def seperate_seq_iter(self, source_code):
if source_code == "":
return "", ""
# Search for an instance of while True
infinite_loop = re.search(r'[^ \t]while\(True\):|[^ \t]while True:',
source_code)
# Seperate the content inside while True and the other
# (Seperating the sequential and iterative part!)
try:
start_index = infinite_loop.start()
iterative_code = source_code[start_index:]
sequential_code = source_code[:start_index]
# Remove while True: syntax from the code
# And remove the the 4 spaces indentation before each command
iterative_code = re.sub(r'[^ ]while\(True\):|[^ ]while True:', '',
iterative_code)
iterative_code = re.sub(r'^[ ]{4}', '', iterative_code, flags=re.M)
except:
sequential_code = source_code
iterative_code = ""
return sequential_code, iterative_code
# The process function
def process_code(self, source_code):
# Reference Environment for the exec() function
reference_environment = {
'console': self.console,
'print': print_function
}
iterative_code, sequential_code, debug_level = self.parse_code(
source_code)
# print("The debug level is " + str(debug_level)
# print(sequential_code)
# print(iterative_code)
try:
# The Python exec function
# Run the sequential part
gui_module = self.generate_modules()
exec(sequential_code, reference_environment)
# Run the iterative part inside template
# and keep the check for flag
while self.reload == False:
start_time = datetime.now()
# Execute the iterative portion
exec(iterative_code, reference_environment)
# Template specifics to run!
finish_time = datetime.now()
dt = finish_time - start_time
ms = (dt.days * 24 * 60 * 60 +
dt.seconds) * 1000 + dt.microseconds / 1000.0
# Keep updating the iteration counter
if (iterative_code == ""):
self.iteration_counter = 0
else:
self.iteration_counter = self.iteration_counter + 1
# The code should be run for atleast the target time step
# If it's less put to sleep
if (ms < self.time_cycle):
time.sleep((self.time_cycle - ms) / 1000.0)
print("Current Thread Joined!")
# To print the errors that the user submitted through the Javascript editor (ACE)
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
self.console.print(str(exc_value))
# Function to generate the modules for use in ACE Editor
def generate_modules(self):
# Define GUI module
gui_module = imp.new_module("GUI")
gui_module.GUI = imp.new_module("GUI")
# Add GUI functions
gui_module.GUI.showImage = self.gui.showImage
gui_module.GUI.getImage = self.gui.getImage
# Adding modules to system
# Protip: The names should be different from
# other modules, otherwise some errors
sys.modules["GUI"] = gui_module
return gui_module
# Function to measure the frequency of iterations
def measure_frequency(self):
previous_time = datetime.now()
# An infinite loop
while self.reload == False:
# Sleep for 2 seconds
time.sleep(2)
# Measure the current time and subtract from the previous time to get real time interval
current_time = datetime.now()
dt = current_time - previous_time
ms = (dt.days * 24 * 60 * 60 +
dt.seconds) * 1000 + dt.microseconds / 1000.0
previous_time = current_time
# Get the time period
try:
# Division by zero
self.ideal_cycle = ms / self.iteration_counter
except:
self.ideal_cycle = 0
# Reset the counter
self.iteration_counter = 0
# Send to client
try:
self.server.send_message(
self.client,
"#freq" + str(round(1000 / self.ideal_cycle, 1)))
except ZeroDivisionError:
self.server.send_message(self.client, "#freq" + str(0))
# Function to maintain thread execution
def execute_thread(self, source_code):
# Keep checking until the thread is alive
# The thread will die when the coming iteration reads the flag
if (self.thread != None):
while self.thread.is_alive() or self.measure_thread.is_alive():
pass
# Turn the flag down, the iteration has successfully stopped!
self.reload = False
# New thread execution
self.measure_thread = threading.Thread(target=self.measure_frequency)
self.thread = threading.Thread(target=self.process_code,
args=[source_code])
self.thread.start()
self.measure_thread.start()
print("New Thread Started!")
# The websocket function
# Gets called when there is an incoming message from the client
def handle(self, client, server, message):
if (message[:5] == "#freq"):
frequency = float(message[5:])
self.time_cycle = 1000.0 / frequency
self.server.send_message(self.client, "#ping")
return
try:
# Once received turn the reload flag up and send it to execute_thread function
code = message
# print(repr(code))
self.reload = True
self.execute_thread(code)
except:
pass
# Function that gets called when the server is connected
def connected(self, client, server):
self.client = client
# Start the GUI update thread
t = ThreadGUI(self.gui)
t.start()
# Initialize the ping message
self.server.send_message(self.client, "#ping")
print(client, 'connected')
# Function that gets called when the connected closes
def handle_close(self, client, server):
os.killpg(os.getpgid(self.exercice.pid), signal.SIGKILL)
print(client, 'closed')
def run_server(self):
self.server = WebsocketServer(port=1905, host=self.host)
self.server.set_fn_new_client(self.connected)
self.server.set_fn_client_left(self.handle_close)
self.server.set_fn_message_received(self.handle)
self.server.run_forever()
class Ui_MainWindow(object):
# Called for every client connecting (after handshake)
def new_client(self, client, server):
self.listWidget_ip.addItem(util.get_time_ymd_hms() +
"New client connected and was given id %d" %
client['id'])
# Called for every client disconnecting
def client_left(self, client, server):
self.listWidget_ip.addItem(util.get_time_ymd_hms() +
"Client(%d) disconnected" % client['id'])
# 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))
server.send_message_to_all("sadsadad")
def set_server(self):
PORT = 8444
self.server = WebsocketServer(PORT)
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)
def setupUi(self, MainWindow):
threading.Thread(target=self.set_server).start()
MainWindow.setObjectName("MainWindow")
MainWindow.resize(882, 728)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.btn_start = QtWidgets.QPushButton(self.centralwidget)
self.btn_start.setGeometry(QtCore.QRect(810, 20, 61, 31))
self.btn_send_test = QtWidgets.QPushButton(self.centralwidget)
self.btn_send_test.setGeometry(QtCore.QRect(610, 20, 61, 31))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(12)
self.btn_start.setFont(font)
self.btn_start.setObjectName("btn_start")
self.btn_send_test.setFont(font)
self.btn_send_test.setObjectName("btn_send_test")
self.listWidget_ip = QtWidgets.QListWidget(self.centralwidget)
self.listWidget_ip.setGeometry(QtCore.QRect(530, 60, 341, 621))
self.listWidget_ip.setObjectName("listWidget_ip")
self.line_gap_price = QtWidgets.QLineEdit(self.centralwidget)
self.line_gap_price.setGeometry(QtCore.QRect(230, 109, 61, 21))
self.line_test = QtWidgets.QLineEdit(self.centralwidget)
self.line_test.setGeometry(QtCore.QRect(230, 20, 61, 21))
self.line_test2 = QtWidgets.QLineEdit(self.centralwidget)
self.line_test2.setGeometry(QtCore.QRect(130, 20, 61, 21))
self.line_gap_price.setObjectName("line_gap_price")
self.line_instant_rise = QtWidgets.QLineEdit(self.centralwidget)
self.line_instant_rise.setGeometry(QtCore.QRect(230, 150, 61, 20))
self.line_instant_rise.setObjectName("line_instant_rise")
self.label = QtWidgets.QLabel(self.centralwidget)
self.label.setGeometry(QtCore.QRect(30, 70, 151, 16))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(11)
self.label.setFont(font)
self.label.setObjectName("label")
self.label_2 = QtWidgets.QLabel(self.centralwidget)
self.label_2.setGeometry(QtCore.QRect(30, 110, 181, 20))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(11)
self.label_2.setFont(font)
self.label_2.setObjectName("label_2")
self.label_3 = QtWidgets.QLabel(self.centralwidget)
self.label_3.setGeometry(QtCore.QRect(30, 150, 181, 20))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(11)
self.label_3.setFont(font)
self.label_3.setObjectName("label_3")
self.label_4 = QtWidgets.QLabel(self.centralwidget)
self.label_4.setGeometry(QtCore.QRect(30, 190, 161, 20))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(11)
self.label_4.setFont(font)
self.label_4.setObjectName("label_4")
self.label_5 = QtWidgets.QLabel(self.centralwidget)
self.label_5.setGeometry(QtCore.QRect(30, 230, 171, 20))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(11)
self.label_5.setFont(font)
self.label_5.setObjectName("label_5")
self.line_instant_fall = QtWidgets.QLineEdit(self.centralwidget)
self.line_instant_fall.setGeometry(QtCore.QRect(230, 190, 61, 20))
self.line_instant_fall.setObjectName("line_instant_fall")
self.line_minute_rise = QtWidgets.QLineEdit(self.centralwidget)
self.line_minute_rise.setGeometry(QtCore.QRect(230, 230, 61, 20))
self.line_minute_rise.setObjectName("line_minute_rise")
self.label_6 = QtWidgets.QLabel(self.centralwidget)
self.label_6.setGeometry(QtCore.QRect(30, 260, 181, 20))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(11)
self.label_6.setFont(font)
self.label_6.setObjectName("label_6")
self.line_minute_fall = QtWidgets.QLineEdit(self.centralwidget)
self.line_minute_fall.setGeometry(QtCore.QRect(230, 260, 61, 21))
self.line_minute_fall.setObjectName("line_minute_fall")
self.btn_end = QtWidgets.QPushButton(self.centralwidget)
self.btn_end.setGeometry(QtCore.QRect(530, 20, 61, 31))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(12)
self.btn_end.setFont(font)
self.btn_end.setObjectName("btn_end")
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 882, 18))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.btn_start.setText(_translate("MainWindow", "开始"))
self.line_gap_price.setText(_translate("MainWindow", "1"))
self.line_instant_rise.setText(_translate("MainWindow", "1"))
self.label.setText(_translate("MainWindow", "涨跌过滤（区间）"))
self.label_2.setText(_translate("MainWindow", "差价（%）"))
self.label_3.setText(_translate("MainWindow", "瞬时增长（%）"))
self.label_4.setText(_translate("MainWindow", "顺势下跌（%）"))
self.label_5.setText(_translate("MainWindow", "分钟增长（%）"))
self.line_instant_fall.setText(_translate("MainWindow", "-1"))
self.line_minute_rise.setText(_translate("MainWindow", "0.75"))
self.label_6.setText(_translate("MainWindow", "分钟下跌（%）"))
self.line_minute_fall.setText(_translate("MainWindow", "-1"))
self.btn_end.setText(_translate("MainWindow", "停止"))
self.btn_send_test.setText(_translate("MainWindow", "测试发送"))
self.btn_send_test.clicked.connect(self.send_test)
self.btn_start.clicked.connect(self.start)
self.btn_end.clicked.connect(self.end)
def check_today_data(self):
while True:
try:
size_str = util.read_one_file(
r"C:\Users\hangqing1\Desktop\bin423\ShareMem.txt",
'gbk')[0]
date_str, size = size_str.split('=')
if date_str != util.get_today_date():
time.sleep(3)
continue
else:
self.listWidget_ip.addItem(util.get_today_time() +
"发现更新数据")
self.start_filter(size)
break
except Exception as e:
print(e)
def start(self):
size_str = util.read_one_file(
r"C:\Users\hangqing1\Desktop\bin423\ShareMem.txt", 'gbk')[0]
date_str, size = size_str.split('=')
self.listWidget_ip.addItem(util.get_today_time() + "等待数据加载")
if date_str != util.get_today_date():
threading.Thread(target=self.check_today_data).start()
else:
self.start_filter(size)
def start_filter(self, size):
threading.Thread(target=self.server.run_forever).start()
filter_conf = FilterConfig()
filter_conf.price_gap_value = float(self.line_gap_price.text().strip())
filter_conf.instant_rise_value = float(
self.line_instant_rise.text().strip())
filter_conf.instant_fall_value = float(
self.line_instant_fall.text().strip())
filter_conf.rise_in_minute_value = float(
self.line_minute_rise.text().strip())
filter_conf.fall_in_minute_value = float(
self.line_minute_fall.text().strip())
self.listWidget_ip.addItem(str(filter_conf.__dict__))
self.new_filter = Filter(self.server, filter_conf)
self.listWidget_ip.addItem("开始")
filter_thread = threading.Thread(target=self.new_filter.run_filter,
args=(int(size), ))
filter_thread.start()
self.listWidget_ip.addItem("过滤器开始启动")
# 开启滚动条最下线程
def send_test(self):
self.server.send_message_to_all("test^test^test^test^test^test^0.5^" +
self.line_test2.text() + "^" +
self.line_test.text())
def end(self):
self.new_filter.filter_flag = False
self.listWidget_ip.addItem("停止监控")
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
cnt = 0
print("imgpath :",imgdict)
for imgpath in imgdict[1]:
with open(imgpath,"rb") as imgf:
imgdict[1][cnt] = base64.b64encode(imgf.read()).decode('utf-8')
cnt+=1
send_data = {"img":[imgdict[1][0],imgdict[1][1]]}
elif jkey == "in_data":
ind = dict_data[jkey]
time = datetime.now()
print(type(time),time)
uuid1 = str(uuid.uuid1())
dir_path = f"/root/Picture/{ind['db']}/{time.year}/{time.month}/{time.day}/{time.hour}/"
tfdir = f"{dir_path}top_{time.minute}-{time.second}_{uuid1}.png"
sfdir = f"{dir_path}slanting_{time.minute}-{time.second}_{uuid1}.png"
os.makedirs(dir_path, exist_ok=True)
with open(tfdir, mode='wb') as ft,open(sfdir, mode='wb') as fs:
ft.write(base64.b64decode(ind["img"][0].encode()))
fs.write(base64.b64decode(ind["img"][1].encode()))
send_data = sql(ind['db'],sqlgen(ind["mac"],time,tfdir,sfdir,ind["jstr"]),True)
server.send_message(client,json.dumps(send_data,default=json_serial))
server = WebsocketServer(8080, host='0.0.0.0')
server.set_fn_new_client(new_client)
server.set_fn_message_received(recv)
server.set_fn_client_left(disconnect)
server.run_forever()
# Receive data from client and put it in the input queue
def communicateWithClient(client, server, msg):
print('recv: ' + msg)
carConnectionSem.acquire()
if (carIsConnected and msg in validInput):
inputSem.acquire()
inputQueue.append(msg)
inputSem.release()
carConnectionSem.release()
# Websocket to talk to client
websocket = WebsocketServer(clientPort)
websocket.set_fn_new_client(onClientConnection)
websocket.set_fn_client_left(onClientDisconnection)
websocket.set_fn_message_received(communicateWithClient)
# Handle car communications
def communicateWithCar():
while (runServer):
# Wait for car to connect
c, addr = carSock.accept()
isConnected = True
global carIsConnected
carConnectionSem.acquire()
carIsConnected = True
carConnectionSem.release()
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
})
print('Client disconnected')
# Receive data from client and put it in the input queue
def communicateWithClient(client, server, msg):
print('recv: ' + msg)
carConnectionSem.acquire()
if (carIsConnected and msg in validInput):
inputSem.acquire()
inputQueue.append(msg)
inputSem.release()
carConnectionSem.release()
# Websocket to talk to client
websocket = WebsocketServer(clientPort)
websocket.set_fn_new_client(onClientConnection)
websocket.set_fn_client_left(onClientDisconnection)
websocket.set_fn_message_received(communicateWithClient)
# Handle car communications
def communicateWithCar():
while(runServer):
# Wait for car to connect
c, addr = carSock.accept()
isConnected = True
global carIsConnected
carConnectionSem.acquire()
carIsConnected = True
carConnectionSem.release()
print('Car connected')
def runwebsocketserver():
_logger = logging.getLogger(__name__)
camera = None
frame = None
def _frame_rate_statistics_generator() -> Generator[float, bool, None]:
"""
统计视频帧率
:return:
"""
count = 0
begin_time = time.time()
break_ = False
while not break_:
if count != 100:
fps = 0.0
else:
end_time = time.time()
fps = count / (end_time - begin_time)
count = 0
begin_time = time.time()
count += 1
break_ = yield fps
def _draw_face_info(image: np.ndarray, face_info: FaceInfo) -> None:
"""
将人脸的信息绘制到屏幕上
:param face_info: 人脸信息
:return: None
"""
# 绘制人脸位置
rect = face_info.rect
color = (255, 0, 0) if face_info.name else (0, 0, 255)
cv.rectangle(image, rect.top_left, rect.bottom_right, color, 2)
# 绘制人的其它信息
x, y = rect.top_middle
put_text(image, "%s" % face_info, bottom_middle=(x, y - 2))
# 绘制人脸 ID
info = "%d" % face_info.arc_face_info.face_id
x, y = rect.top_left
put_text(image, info, left_top=(x + 2, y + 2))
def _show_image(image: np.ndarray) -> int:
global frame
frame = image
#cv.imshow("ArcFace Demo", image)
#cv.waitKey(1)
with open("profile.yml", "r", encoding="utf-8") as file:
profile: Dict[str, str] = yaml.load(file, yaml.Loader)
server_on = profile["server-on"].encode()
if server_on == 0:
return True
return False
@timer(output=_logger.info)
def _run_1_n(image_source: ImageSource, face_process: FaceProcess) -> None:
"""
1:n 的整个处理的逻辑
:image_source: 识别图像的源头
:face_process: 用来对人脸信息进行提取
:return: None
"""
with ArcFace(ArcFace.VIDEO_MODE) as arcface:
cur_face_info = None # 当前的人脸
frame_rate_statistics = _frame_rate_statistics_generator()
while True:
# 获取视频帧
image = image_source.read()
# 检测人脸
faces_pos = arcface.detect_faces(image)
if len(faces_pos) == 0:
# 图片中没有人脸
cur_face_info = None
else:
# 使用曼哈顿距离作为依据找出最靠近中心的人脸
center_y, center_x = image.shape[:2]
center_y, center_x = center_y // 2, center_x // 2
center_face_index = -1
min_center_distance = center_x + center_y + 4
cur_face_index = -1
for i, pos in enumerate(faces_pos):
if cur_face_info is not None and pos.face_id == cur_face_info.arc_face_info.face_id:
cur_face_index = i
break
x, y = pos.rect.center
if x + y < min_center_distance:
center_face_index = i
min_center_distance = x + y
if cur_face_index != -1:
# 上一轮的人脸依然在，更新位置信息
cur_face_info.arc_face_info = faces_pos[cur_face_index]
else:
# 上一轮的人脸不在了，选择当前所有人脸的最大人脸
cur_face_info = FaceInfo(faces_pos[center_face_index])
if cur_face_info is not None:
# 异步更新人脸的信息
if cur_face_info.need_update():
face_process.async_update_face_info(
image, cur_face_info)
# 绘制人脸信息
_draw_face_info(image, cur_face_info)
# 绘制中心点
# put_text(image, "x", bottom_middle=(center_x, center_y))
# 显示到界面上
if _show_image(image):
break
# 统计帧率
fps = next(frame_rate_statistics)
if fps:
_logger.info("FPS: %.2f" % fps)
@timer(output=_logger.info)
def _run_m_n(image_source: ImageSource, face_process: FaceProcess) -> None:
with ArcFace(ArcFace.VIDEO_MODE) as arcface:
faces_info: Dict[int, FaceInfo] = {}
frame_rate_statistics = _frame_rate_statistics_generator()
while True:
# 获取视频帧
image = image_source.read()
# 检测人脸
faces_pos: Dict[int, ArcFaceInfo] = {}
for face_pos in arcface.detect_faces(image):
faces_pos[face_pos.face_id] = face_pos
# 删除过期 id, 添加新的 id
cur_faces_id = faces_pos.keys()
last_faces_id = faces_info.keys()
for face_id in last_faces_id - cur_faces_id:
faces_info[face_id].cancel() # 如果有操作在进行，这将取消操作
faces_info.pop(face_id)
for face_id in cur_faces_id:
if face_id in faces_info:
# 人脸已经存在，只需更新位置就好了
faces_info[face_id].arc_face_info = faces_pos[face_id]
else:
faces_info[face_id] = FaceInfo(faces_pos[face_id])
# 更新人脸的信息
# for face_info in faces_info:
# face_process.async_update_face_info(image, face_info)
opt_face_info = None
for face_info in filter(lambda x: x.need_update(),
faces_info.values()):
if opt_face_info is None or opt_face_info.rect.size < face_info.rect.size:
opt_face_info = face_info
if opt_face_info is not None:
face_process.async_update_face_info(image, opt_face_info)
# 绘制人脸信息
for face_info in faces_info.values():
_draw_face_info(image, face_info)
if _show_image(image):
break
# 统计帧率
fps = next(frame_rate_statistics)
if fps:
_logger.info("FPS: %.2f" % fps)
def new_client(client, server):
print("New client connected and was given id %d" % client['id'])
# 发送给所有的连接
server.send_message_to_all("Hey all, a new client has joined us")
def client_left(client, server):
id = 1
#print("Client(%d) disconnected" % client['id'])
def message_received(client, server, message):
if len(message) > 200:
message = message[:200] + '..'
print("Client(%d) said: %s" % (client['id'], message))
#with open("profile.yml", "r", encoding="utf-8") as file:
# profile: Dict[str, str] = yaml.load(file, yaml.Loader)
# rtsp = profile["camera"][message].encode().decode("gbk", "strict")
#global camera
#camera.set_camera(rtsp)
# 发送给所有的连接
def from_vedio():
thread2 = threading.Thread(target=face_recognition, args=(1, ))
thread2.start()
thread1 = threading.Thread(target=vedio_send, args=(1, ))
thread1.start()
print('webserver start')
def vedio_send(n):
global frame
while True:
with open("profile.yml", "r", encoding="utf-8") as file:
profile: Dict[str, str] = yaml.load(file, yaml.Loader)
server_on = profile["server-on"].encode()
if server_on == 0:
break
if len(server.clients) > 0:
image = cv.imencode('.jpg', frame)[1]
base64_data = base64.b64encode(image)
s = base64_data.decode()
# print('data:image/jpeg;base64,%s'%s)
server.send_message_to_all('data:image/jpeg;base64,%s' % s)
time.sleep(0.01)
def face_recognition(n):
global camera
camera = LocalCamera()
with open("profile.yml", "r", encoding="utf-8") as file:
profile: Dict[str, str] = yaml.load(file, yaml.Loader)
ArcFace.APP_ID = profile["app-id"].encode()
ArcFace.SDK_KEY = profile["sdk-key"].encode()
face_process = FaceProcess()
class AutoCloseOpenCVWindows:
def __enter__(self):
pass
def __exit__(self, exc_type, exc_val, exc_tb):
cv.destroyAllWindows()
"""
加载人脸部分
逻辑->30s刷新一次feature
"""
update_feature = threading.Thread(target=face_process.load_features)
update_feature.start()
with face_process, AutoCloseOpenCVWindows():
run = _run_m_n #_run_1_n if args.single
with camera:
run(camera, face_process)
server = WebsocketServer(port=8124, host='127.0.0.1')
from_vedio()
# 有设备连接上了
server.set_fn_new_client(new_client)
# 断开连接
server.set_fn_client_left(client_left)
# 接收到信息
server.set_fn_message_received(message_received)
# 开始监听
server.run_forever()
class ScriptHandler(object):
to_process = []
def __init__(self):
self.scripts = []
self.API_Key = binascii.b2a_base64(os.urandom(15))[:-1]
self.API_Socket = "ws://127.0.0.1:3337/streamlabs"
self.websocket = None
self.script_folders = [
f for f in os.listdir(script_path)
if os.path.isdir(os.path.join(script_path, f))
]
for script_folder in self.script_folders:
content = os.listdir(os.path.join(script_path, script_folder))
script_name = script_folder + "_StreamlabsSystem"
if script_name + ".py" in content and "UI_Config.json" in content:
try:
specific_scripth_path = os.path.join(
script_path, script_folder)
self.scripts.append(
self.import_by_filename(
os.path.join(specific_scripth_path,
script_name + ".py")))
self.insert_API_Key(specific_scripth_path)
except Exception as e:
print e.message
traceback.print_exc()
else:
print("invalid script folder: " + script_folder)
def insert_API_Key(self, dir_path):
api_file = os.path.join(dir_path, "API_KEY.js")
try:
with codecs.open(api_file, encoding="utf-8-sig", mode="w") as f:
f.write('var API_Key = "{0}";\nvar API_Socket = "{1}";'.format(
self.API_Key, self.API_Socket))
except:
traceback.print_exc()
def start_websocket(self):
self.websocket = WebsocketServer(3337, "127.0.0.1")
self.websocket.set_fn_new_client(Parent.on_client_connect)
self.websocket.set_fn_client_left(Parent.on_client_disconnect)
self.websocket.set_fn_message_received(Parent.on_message)
thread = Thread(target=self.websocket.run_forever)
thread.daemon = True
thread.start()
Parent.websocket = self.websocket
Parent.API_Key = self.API_Key
def init(self):
self.start_websocket()
for script in self.scripts:
script.Parent = Parent
script.Init()
def scripts_loop(self):
self.init()
next_t = 0
live_check = 0
while not stopped.is_set():
if time.time() < live_check:
Parent.stream_online = MixerChat.mixerApi.get_channel_online()
live_check = time.time() + 120
if len(self.to_process) > 0:
data = self.to_process.pop(0)
for script in self.scripts:
try:
script.Execute(data)
except Exception as e:
print 'Error', e.message
traceback.print_exc()
if Parent.stop:
Parent.stop = False
break
if time.time() > next_t:
next_t = time.time() + 0.1
for script in self.scripts:
try:
script.Tick()
except Exception as e:
print 'Error', e.message
traceback.print_exc()
@staticmethod
def import_by_filename(filename):
directory, module_name = os.path.split(filename)
module_name = os.path.splitext(module_name)[0]
path = list(sys.path)
sys.path.insert(0, directory)
try:
module = __import__(module_name)
finally:
sys.path[:] = path # restore
return module
class websocketserver:
cameras = {}
tags = {}
users = {}
calibration = {}
port=8001
# Called for every client connecting (after handshake)
def new_client_connection(self, client, server):
print("New client connected and was given id %d" % client['id'] +" and address " + str(client['address']))
server.send_message(client, "Client connected succesfully")
# Called for every client disconnecting
def client_left(self, client, server):
print("Client(%d) disconnected" % client['id'])
# Remove client from its list
# TODO better delete (remove points etc...)
if(str(client['address']) in self.cameras):
print "Camera disconnected : " + str(client['address'])
del self.cameras[str(client['address'])]
elif(str(client['address']) in self.users):
# Remove Tag assignement because User left
print "User disconnected : " + str(client['address'])
self.users[str(client['address'])].removeTag()
del self.users[str(client['address'])]
elif(str(client['address']) in self.calibration):
print "Calibration disconnected : " + str(client['address'])
del self.calibration[str(client['address'])]
elif(str(client['address']) in self.tags):
print "Tag disconnected : " + str(client['address'])
# Remove Tag assignement to User because Tag left AND kill 3D point
for key in self.users:
if self.users[key].tag == self.tags[str(client['address'])]:
self.users[key].removeTag()
del self.tags[str(client['address'])]
# Called when a client sends a message
def message_received(self, client, server, message):
self.parseMessage(client, message)
def __init__(self, host='127.0.0.1'):
self.server = WebsocketServer(self.port, host)
self.server.set_fn_new_client(self.new_client_connection)
self.server.set_fn_client_left(self.client_left)
self.server.set_fn_message_received(self.message_received)
self.server.run_forever()
def parseMessage(self, client, message):
"""
Check who is the message from to redirect it to User / Tag / Camera / Calibration
or create a new instance of User / Tag / Camera / Calibration
:param client:
:param message:
:return:
"""
if self.cameras.has_key(str(client['address'])):
#print "Message from Camera"
self.cameras[str(client['address'])].push(message)
# Update all cameras counters
#Todo: Change this method for checking all cameras for lost point (auto check inside point2D ?)
for key in self.cameras.keys():
self.cameras[key].update()
elif self.users.has_key(str(client['address'])):
print "Message from User"
elif self.tags.has_key(str(client['address'])):
print "Message from Tag"
elif self.calibration.has_key(str(client['address'])):
self.calibration[str(client['address'])].push(message)
print "Message from Calibration"
# This message is coming from an unknown client
else:
if message.split("-")[0] == "camera":
self.cameras[str(client['address'])] = Camera(client, message.split("-")[1])
# Add Observers linking every user to every camera's update
for key in self.users:
if isinstance(self.users[key], User):
self.cameras[str(client['address'])].new2DPointNotifier.addObserver(self.users[key].position.newPoint2DObserver)
self.cameras[str(client['address'])].point2DdeletedNotifier.addObserver(self.users[key].position.point2DDeletedObserver)
elif message.split("-")[0] == "tag":
self.tags[str(client['address'])] = Tag(self.server, client, message.split("-")[1])
for key in self.users:
if isinstance(self.users[key], User):
# Assign a Tag to User with no Tag
if self.users[key].tag == None:
self.users[key].setTag(self.tags[str(client['address'])])
elif message.split("-")[0] == "user":
user = User(self.server, client, message.split("-")[1])
self.users[str(client['address'])] = user
# Add Observers linking every user to every camera's update
for key in self.cameras:
if isinstance(self.cameras[key], Camera):
self.cameras[key].new2DPointNotifier.addObserver(user.position.newPoint2DObserver)
self.cameras[key].point2DdeletedNotifier.addObserver(user.position.point2DDeletedObserver)
for key in self.tags:
if isinstance(self.tags[key], Tag):
# Assign a Tag to new User
if self.tags[key].isAssigned() == False:
user.setTag(self.tags[key])
elif message == "calibration":
if(len(self.tags)>0):
self.calibration[str(client['address'])] = Calibration(self.server, client, self.cameras, self.tags.values()[0])
else:
self.server.send_message(client, "Please connect a Tag first, and start Calibration again.")
def __init__(self, host='127.0.0.1'):
server = WebsocketServer(self.port, host)
server.set_fn_new_client(self.new_client_connection)
server.set_fn_client_left(self.client_left)
server.set_fn_message_received(self.message_received)
server.run_forever()
def on_client_left(client, server):
print('Client {} Left.'.format(client['id']))
def on_message(client, server, message):
print('Msg from Client {}: {}'.format(client['id'], message))
# magic string for shutdown server :-)
if message.startswith('close-server'):
print('Stopping Server ...')
thread.start_new_thread(kill_server, (ws_server,))
print('Server stopped!')
ws_server.set_fn_new_client(on_new_client)
ws_server.set_fn_client_left(on_client_left)
ws_server.set_fn_message_received(on_message)
thread.start_new_thread(ws_server.run_forever, ())
ws_server.IS_ONLINE = True
while ws_server.IS_ONLINE:
import time
print('Trying to do something ...')
time.sleep(30)
print('Starting get profile ...')
print('Save to ' + tmp_dir)
ws_server.send_message_to_all(tmp_dir)
time.sleep(10)
class websocketserver:
cameras = {}
tags = {}
users = {}
calibration = {}
port=8001
# Called for every client connecting (after handshake)
def new_client_connection(self, client, server):
print("New client connected and was given id %d" % client['id'] +" and address " + str(client['address']))
server.send_message(client, "Client connected succesfully")
# Called for every client disconnecting
def client_left(self, client, server):
print("Client(%d) disconnected" % client['id'])
#TODO : Remove from list
# Called when a client sends a message
def message_received(self, client, server, message):
# print("Client(%d) said: %s" % (client['id'], message))
self.parseMessage(client, message)
def __init__(self, host='127.0.0.1'):
self.server = WebsocketServer(self.port, host)
self.server.set_fn_new_client(self.new_client_connection)
self.server.set_fn_client_left(self.client_left)
self.server.set_fn_message_received(self.message_received)
self.server.run_forever()
def parseMessage(self, client, message):
"""
Check who is the message from to redirect it to User / Tag / Camera / Calibration
or create a new instance of User / Tag / Camera / Calibration
:param client:
:param message:
:return:
"""
if self.cameras.has_key(str(client['address'])):
#print "Message from Camera"
self.cameras[str(client['address'])].push(message)
elif self.users.has_key(str(client['address'])):
print "Message from User"
elif self.tags.has_key(str(client['address'])):
print "Message from Tag"
elif self.calibration.has_key(str(client['address'])):
self.calibration[str(client['address'])].push(message)
print "Message from Calibration"
# This message is coming from an unknown client
else:
if message.split("-")[0] == "camera":
self.cameras[str(client['address'])] = Camera(client, message.split("-")[1])
# Add Observers linking every user to every camera's update
for key in self.users:
if isinstance(self.users[key], User):
self.cameras[str(client['address'])].new2DPointNotifier.addObserver(self.users[key].position.newPoint2DObserver)
self.cameras[str(client['address'])].point2DdeletedNotifier.addObserver(self.users[key].position.point2DDeletedObserver)
elif message.split("-")[0] == "tag":
print "Hello TAG"
# TODO
elif message.split("-")[0] == "user":
user = User(client, self.server, message.split("-")[1])
self.users[str(client['address'])] = user
# Add Observers linking every user to every camera's update
for key in self.cameras:
if isinstance(self.cameras[key], Camera):
self.cameras[key].new2DPointNotifier.addObserver(user.position.newPoint2DObserver)
self.cameras[key].point2DdeletedNotifier.addObserver(user.position.point2DDeletedObserver)
elif message == "calibration":
self.calibration[str(client['address'])] = Calibration(self.cameras, self.server, client)
class MockSocket:
def __init__(self):
self.last_messages = {}
self.connected = False
self.disconnected = False
self.closed = False
self.ws = None
self.should_heartbeat = True
self.fake_workers = []
self.port = None
self.launch_socket()
self.handlers = {}
while self.ws is None:
time.sleep(0.05)
time.sleep(1)
def send(self, packet):
self.ws.send_message_to_all(packet)
def close(self):
if not self.closed:
self.ws.server_close()
self.ws.shutdown()
self.closed = True
def do_nothing(self, *args):
pass
def launch_socket(self):
def on_message(client, server, message):
if self.closed:
raise Exception('Socket is already closed...')
if message == '':
return
packet_dict = json.loads(message)
if packet_dict['content']['id'] == 'WORLD_ALIVE':
self.ws.send_message(client,
json.dumps({'type': 'conn_success'}))
self.connected = True
elif packet_dict['content']['type'] == 'heartbeat':
pong = packet_dict['content'].copy()
pong['type'] = 'pong'
self.ws.send_message(
client,
json.dumps({
'type': data_model.SOCKET_ROUTE_PACKET_STRING,
'content': pong
}),
)
if 'receiver_id' in packet_dict['content']:
receiver_id = packet_dict['content']['receiver_id']
assignment_id = packet_dict['content']['assignment_id']
use_func = self.handlers.get(receiver_id + assignment_id,
self.do_nothing)
use_func(packet_dict['content'])
def on_connect(client, server):
pass
def on_disconnect(client, server):
self.disconnected = True
def run_socket(*args):
port = 3030
while self.port is None:
try:
self.ws = WebsocketServer(port, host='127.0.0.1')
self.port = port
except OSError:
port += 1
self.ws.set_fn_client_left(on_disconnect)
self.ws.set_fn_new_client(on_connect)
self.ws.set_fn_message_received(on_message)
self.ws.run_forever()
self.listen_thread = threading.Thread(target=run_socket,
name='Fake-Socket-Thread')
self.listen_thread.daemon = True
self.listen_thread.start()
class WSServer:
def __init__(self, port=9007):
self.port = port
self.server = WebsocketServer(self.port, host='0.0.0.0')
self.server.set_fn_new_client(self.on_connect)
self.server.set_fn_message_received(self.on_msg)
self.server.set_fn_client_left(self.on_disconnect)
self.msg_lock = Lock()
def ping(self):
self.server.send_message_to_all(json.dumps({'action': 'ping'}))
# pinging every 50 seconds to avoid disconnection
t = Timer(50, self.ping)
t.start()
def on_connect(self, client, server):
#server.send_message_to_all("Hey all, a new client has joined us")
pass
def on_disconnect(self, client, server):
#server.send_message_to_all("Hey all, a new client has joined us")
pass
def on_msg(self, client, server, message):
self.msg_lock.acquire()
try:
args = message.split(' ')
command = args[0]
args = args[1:]
internal = 'internal_ws_' + command
if hasattr(self, internal):
getattr(self, internal)(client, *args)
else:
data = {'action': 'cmd', 'msg': 'not found'}
self.server.send_message(client, json.dumps(data))
except Exception as e:
print("Error: ", e)
connection.close()
self.msg_lock.release()
def run(self):
self.ping()
self.server.run_forever()
def drop_seat(self, hold):
session = hold.session
layout = hold.layout
row, col = hold.seat.split('-')
data = {
'action': 'drop',
'session': session.id,
'layout': layout.id,
'row': row,
'col': col,
}
hold.delete()
confirmed = not session.is_seat_available(layout, row, col)
if confirmed:
data['action'] = 'confirm'
self.server.send_message_to_all(json.dumps(data))
def notify_confirmed(self):
d = timezone.now()
d = d - datetime.timedelta(seconds=80)
holds = TicketSeatHold.objects.filter(date__gt=d, type="R")
for h in holds:
row, col = h.seat.split('-')
data = {
'action': 'confirm',
'session': h.session.id,
'layout': h.layout.id,
'row': row,
'col': col,
}
self.server.send_message_to_all(json.dumps(data))
# Protocol definitions
def internal_ws_autoseats(self, client, session, amount, user):
session = Session.objects.get(id=session)
seats = search_seats(session, int(amount))
data = {
'action': 'autoseat',
'session': session.id,
'seats': seats,
}
for s in seats:
layout = SeatLayout.objects.get(id=s['layout'])
seat = '{}-{}'.format(s['row'], s['col'])
d2 = {
'action': 'hold',
'session': session.id,
'layout': layout.id,
'row': s['row'],
'col': s['col'],
}
sh = TicketSeatHold(client=user,
layout=layout,
seat=seat,
session=session)
sh.save()
self.server.send_message_to_all(json.dumps(d2))
if not seats:
data['error'] = _('Not found contiguous seats, please, select manually using the green button')
self.server.send_message(client, json.dumps(data))
def internal_ws_get_events(self, client):
events = serializers.serialize("json", Event.objects.all())
self.server.send_message(client, events)
def internal_ws_get_spaces(self, client, event):
event = Event.objects.get(slug=event)
spaces = serializers.serialize("json", event.spaces.all())
self.server.send_message(client, spaces)
def internal_ws_get_sessions(self, client, event, space):
event = Event.objects.get(slug=event)
space = event.spaces.get(slug=space)
sessions = serializers.serialize("json", space.sessions.all())
self.server.send_message(client, sessions)
def internal_ws_hold_seat(self, client, session, layout, row, col, user):
session = Session.objects.get(id=session)
layout = SeatLayout.objects.get(id=layout)
data = {
'action': 'hold',
'session': session.id,
'layout': layout.id,
'row': row,
'col': col,
}
if not session.is_seat_holded(layout, row, col):
seat = row + '-' + col
sh = TicketSeatHold(client=user, layout=layout, seat=seat,
session=session)
sh.save()
self.server.send_message_to_all(json.dumps(data))
else:
data['action'] = 'holded'
self.server.send_message(client, json.dumps(data))
def internal_ws_drop_seat(self, client, session, layout, row, col, user):
try:
seat = row + '-' + col
sh = TicketSeatHold.objects.get(client=user,
type='H',
layout=layout,
seat=seat,
session=session)
self.drop_seat(sh)
except:
pass
def internal_ws_add_ac(self, client, control, date, st):
data = {
'action': 'add_ac',
'control': control,
'date': date,
'st': st,
}
log = LogAccessControl(access_control=AccessControl.objects.get(slug=control), status=st)
log.save()
self.server.send_message_to_all(json.dumps(data))
def internal_ws_add_sale(self, client, window, date, payment, amount, price):
data = {
'action': 'add_sale',
'window': window,
'date': date,
'payment': payment,
'amount': amount,
'price': price
}
self.server.send_message_to_all(json.dumps(data))
def internal_ws_add_change(self, client, window, date, payment, amount, price):
data = {
'action': 'add_change',
'window': window,
'date': date,
'payment': payment,
'amount': amount,
'price': price
}
self.server.send_message_to_all(json.dumps(data))
def SocketServerStart():
server = WebsocketServer(SOCKET_PORT, HOST)
server.set_fn_new_client(NewClient)
server.set_fn_client_left(ClientLeft)
server.set_fn_message_received(MessageReceived)
server.run_forever()
#!/usr/bin/env python
from websocket_server import WebsocketServer
import hashlib
import os
def nuevo_cliente(client, server):
print("Cliente (%s) nuevo" % client['address'][0])
def mensaje_recibido(client, server, mensaje):
audio = hashlib.md5(client['address'][0]).hexdigest()
file = open("podcast/"+audio, "ab")
file.write(mensaje)
file.close()
def desconectado(client, server):
audio = hashlib.md5(client['address'][0]).hexdigest()
os.remove("podcast/"+audio)
print("Cliente (%s) desconectado" % client['address'][0])
PORT=9000
server = WebsocketServer(PORT,"192.168.1.2")
server.set_fn_new_client(nuevo_cliente)
server.set_fn_client_left(desconectado)
server.set_fn_message_received(mensaje_recibido)
server.run_forever()
class Template:
# Initialize class variables
# self.time_cycle to run an execution for atleast 1 second
# self.process for the current running process
def __init__(self):
self.thread = None
self.reload = False
# Time variables
self.time_cycle = 80
self.ideal_cycle = 80
self.iteration_counter = 0
self.real_time_factor = 0
self.frequency_message = {'brain': '', 'gui': '', 'rtf': ''}
self.server = None
self.client = None
self.host = sys.argv[1]
# Initialize the GUI, HAL and Console behind the scenes
self.hal = HAL()
self.gui = GUI(self.host, self.hal)
# Function for saving
def save_code(self, source_code):
with open('code/academy.py', 'w') as code_file:
code_file.write(source_code)
# Function for loading
def load_code(self):
with open('code/academy.py', 'r') as code_file:
source_code = code_file.read()
return source_code
# Function to parse the code
# A few assumptions:
# 1. The user always passes sequential and iterative codes
# 2. Only a single infinite loop
def parse_code(self, source_code):
# Check for save/load
if(source_code[:5] == "#save"):
source_code = source_code[5:]
self.save_code(source_code)
return "", ""
elif(source_code[:5] == "#load"):
source_code = source_code + self.load_code()
self.server.send_message(self.client, source_code)
return "", ""
elif(source_code[:5] == "#resu"):
restart_simulation = rospy.ServiceProxy('/gazebo/unpause_physics', Empty)
restart_simulation()
return "", ""
elif(source_code[:5] == "#paus"):
pause_simulation = rospy.ServiceProxy('/gazebo/pause_physics', Empty)
pause_simulation()
return "", ""
elif(source_code[:5] == "#rest"):
reset_simulation = rospy.ServiceProxy('/gazebo/reset_world', Empty)
reset_simulation()
self.gui.reset_gui()
return "", ""
else:
# Get the frequency of operation, convert to time_cycle and strip
try:
# Get the debug level and strip the debug part
debug_level = int(source_code[5])
source_code = source_code[12:]
except:
debug_level = 1
source_code = ""
source_code = self.debug_parse(source_code, debug_level)
sequential_code, iterative_code = self.seperate_seq_iter(source_code)
return iterative_code, sequential_code
# Function to parse code according to the debugging level
def debug_parse(self, source_code, debug_level):
if(debug_level == 1):
# If debug level is 0, then all the GUI operations should not be called
source_code = re.sub(r'GUI\..*', '', source_code)
return source_code
# Function to seperate the iterative and sequential code
def seperate_seq_iter(self, source_code):
if source_code == "":
return "", ""
# Search for an instance of while True
infinite_loop = re.search(r'[^ \t]while\(True\):|[^ \t]while True:', source_code)
# Seperate the content inside while True and the other
# (Seperating the sequential and iterative part!)
try:
start_index = infinite_loop.start()
iterative_code = source_code[start_index:]
sequential_code = source_code[:start_index]
# Remove while True: syntax from the code
# And remove the the 4 spaces indentation before each command
iterative_code = re.sub(r'[^ ]while\(True\):|[^ ]while True:', '', iterative_code)
iterative_code = re.sub(r'^[ ]{4}', '', iterative_code, flags=re.M)
except:
sequential_code = source_code
iterative_code = ""
return sequential_code, iterative_code
# The process function
def process_code(self, source_code):
# Redirect the information to console
start_console()
iterative_code, sequential_code = self.parse_code(source_code)
# Whatever the code is, first step is to just stop!
self.hal.motors.sendV(0)
self.hal.motors.sendW(0)
# print("The debug level is " + str(debug_level)
# print(sequential_code)
# print(iterative_code)
# The Python exec function
# Run the sequential part
gui_module, hal_module = self.generate_modules()
reference_environment = {"GUI": gui_module, "HAL": hal_module}
exec(sequential_code, reference_environment)
# Run the iterative part inside template
# and keep the check for flag
while self.reload == False:
start_time = datetime.now()
# Execute the iterative portion
exec(iterative_code, reference_environment)
# Template specifics to run!
finish_time = datetime.now()
dt = finish_time - start_time
ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0
# Keep updating the iteration counter
if (iterative_code == ""):
self.iteration_counter = 0
else:
self.iteration_counter = self.iteration_counter + 1
# The code should be run for atleast the target time step
# If it's less put to sleep
if (ms < self.time_cycle):
time.sleep((self.time_cycle - ms) / 1000.0)
close_console()
print("Current Thread Joined!")
# Function to generate the modules for use in ACE Editor
def generate_modules(self):
# Define HAL module
hal_module = imp.new_module("HAL")
hal_module.HAL = imp.new_module("HAL")
hal_module.HAL.motors = imp.new_module("motors")
# Add HAL functions
hal_module.HAL.getPose3d = self.hal.pose3d.getPose3d
hal_module.HAL.motors.sendV = self.hal.motors.sendV
hal_module.HAL.motors.sendW = self.hal.motors.sendW
hal_module.HAL.laser = self.hal.laser
hal_module.HAL.getLaserData = self.hal.laser.getLaserData
hal_module.HAL.bumper = self.hal.bumper
# Define GUI module
gui_module = imp.new_module("GUI")
gui_module.GUI = imp.new_module("GUI")
# Add GUI functions
# gui_module.GUI.showImage = self.gui.showImage
# Adding modules to system
# Protip: The names should be different from
# other modules, otherwise some errors
sys.modules["HAL"] = hal_module
sys.modules["GUI"] = gui_module
return gui_module, hal_module
# Function to measure the frequency of iterations
def measure_frequency(self):
previous_time = datetime.now()
# An infinite loop
while self.reload == False:
# Sleep for 2 seconds
time.sleep(2)
# Measure the current time and subtract from the previous time to get real time interval
current_time = datetime.now()
dt = current_time - previous_time
ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0
previous_time = current_time
# Get the time period
try:
# Division by zero
self.ideal_cycle = ms / self.iteration_counter
except:
self.ideal_cycle = 0
# Reset the counter
self.iteration_counter = 0
self.send_frequency_message()
# Function to generate and send frequency messages
def send_frequency_message(self):
# This function generates and sends frequency measures of the brain and gui
brain_frequency = 0; gui_frequency = 0
try:
brain_frequency = round(1000 / self.ideal_cycle, 1)
except ZeroDivisionError:
brain_frequency = 0
try:
gui_frequency = round(1000 / self.thread_gui.ideal_cycle, 1)
except ZeroDivisionError:
gui_frequency = 0
self.frequency_message["brain"] = brain_frequency
self.frequency_message["gui"] = gui_frequency
self.frequency_message["rtf"] = self.real_time_factor
message = "#freq" + json.dumps(self.frequency_message)
self.server.send_message(self.client, message)
# Function to maintain thread execution
def execute_thread(self, source_code):
# Keep checking until the thread is alive
# The thread will die when the coming iteration reads the flag
if(self.thread != None):
while self.thread.is_alive() or self.measure_thread.is_alive():
pass
# Turn the flag down, the iteration has successfully stopped!
self.reload = False
# New thread execution
self.measure_thread = threading.Thread(target=self.measure_frequency)
self.thread = threading.Thread(target=self.process_code, args=[source_code])
self.thread.start()
self.measure_thread.start()
print("New Thread Started!")
# Function to track the real time factor from Gazebo statistics
# https://stackoverflow.com/a/17698359
# (For reference, Python3 solution specified in the same answer)
def track_stats(self):
args = ["gz", "stats", "-p"]
# Prints gz statistics. "-p": Output comma-separated values containing-
# real-time factor (percent), simtime (sec), realtime (sec), paused (T or F)
stats_process = subprocess.Popen(args, stdout=subprocess.PIPE, bufsize=1)
# bufsize=1 enables line-bufferred mode (the input buffer is flushed
# automatically on newlines if you would write to process.stdin )
with stats_process.stdout:
for line in iter(stats_process.stdout.readline, b''):
stats_list = [x.strip() for x in line.split(',')]
self.real_time_factor = stats_list[0]
# Function to read and set frequency from incoming message
def read_frequency_message(self, message):
frequency_message = json.loads(message)
# Set brain frequency
frequency = float(frequency_message["brain"])
self.time_cycle = 1000.0 / frequency
# Set gui frequency
frequency = float(frequency_message["gui"])
self.thread_gui.time_cycle = 1000.0 / frequency
return
# The websocket function
# Gets called when there is an incoming message from the client
def handle(self, client, server, message):
if(message[:5] == "#freq"):
frequency_message = message[5:]
self.read_frequency_message(frequency_message)
time.sleep(1)
self.send_frequency_message()
return
try:
# Once received turn the reload flag up and send it to execute_thread function
code = message
# print(repr(code))
self.reload = True
self.execute_thread(code)
except:
pass
# Function that gets called when the server is connected
def connected(self, client, server):
self.client = client
# Start the GUI update thread
self.thread_gui = ThreadGUI(self.gui)
self.thread_gui.start()
# Start the real time factor tracker thread
self.stats_thread = threading.Thread(target=self.track_stats)
self.stats_thread.start()
# Initialize the ping message
self.send_frequency_message()
print(client, 'connected')
# Function that gets called when the connected closes
def handle_close(self, client, server):
print(client, 'closed')
def run_server(self):
self.server = WebsocketServer(port=1905, host=self.host)
self.server.set_fn_new_client(self.connected)
self.server.set_fn_client_left(self.handle_close)
self.server.set_fn_message_received(self.handle)
self.server.run_forever()
def webServer():
usersfd = open("users.json", "r")
users = json.load(usersfd)
usersfd.close()
def new_client(client, server):
print("New client connected and was given id %d" % client['id'])
def client_left(client, server):
print("Client(%d) disconnected" % client['id'])
def message_received(client, server, message):
#print("received message from client id %d " % client['id'])
#logging.info("received message from client id %d " % client['id'])
msg = json.loads(message)
if msg["action"] == AUTHENTICATE:
print 'msg is AUTHENTICATE'
resp = {"action": AUTHENTICATE, "data": None}
username = msg["data"].get("username") if msg["data"].has_key("username") else None
password = msg["data"].get("password") if msg["data"].has_key("password") else None
if username and password and users.has_key(username) and password == users[username]:
print "AUTHSUCCESS"
resp["data"] = AUTHSUCCESS
else:
print "AUTHFAIL"
resp["data"] = AUTHFAIL
server.send_message(client, json.dumps(resp) )
elif msg["action"] == GETBANNEDIPs:
#print 'msg is GETBANNEDIPs'
#logging.info('msg is GETBANNEDIPs')
resp = {"action": GETBANNEDIPs, "data": []}
username = msg["data"].get("username") if msg["data"].has_key("username") else None
password = msg["data"].get("password") if msg["data"].has_key("password") else None
if username and password and users.has_key(username) and password == users[username]:
for bannedIP in bannedIPs.values():
ip = {}
ip["IP"] = bannedIP.IP
ip["time"] = time.strftime("%b %d %H:%M:%S", time.localtime(bannedIP.time))
ip["timer"] = bannedIP.timer - (time.time() - bannedIP.time)
ip["service"] = bannedIP.service
resp["data"].append(ip)
server.send_message(client, json.dumps(resp))
else:
print "AUTHFAIL"
resp["data"] = AUTHFAIL
server.send_message(client, json.dumps(resp))
elif msg["action"] == GETFAILEDATTEMPTs:
print 'msg is GETFAILEDATTEMPTs'
resp = {"action": GETFAILEDATTEMPTs, "data": []}
username = msg["data"].get("username") if msg["data"].has_key("username") else None
password = msg["data"].get("password") if msg["data"].has_key("password") else None
if username and password and users.has_key(username) and password == users[username]:
for failedAttempt in failedAttempts:
print "in FA"
print "FA=" + str(failedAttempt)
ip = {}
ip["IP"] = failedAttempt[0]
ip["attempts"] = []
ip["service"] = failedAttempt[1]
for attempt in failedAttempts[failedAttempt]:
ip["attempts"].append(time.strftime("%b %d %H:%M:%S", time.localtime(attempt.time)))
resp["data"].append(ip)
server.send_message(client, json.dumps(resp))
else:
print "AUTHFAIL"
resp["data"] = AUTHFAIL
server.send_message(client, json.dumps(resp))
elif msg["action"] == UNBANIPs:
print 'msg is UNBANIPs'
resp = {"action": UNBANIPs, "data": {}}
username = msg["data"].get("username") if msg["data"].has_key("username") else None
password = msg["data"].get("password") if msg["data"].has_key("password") else None
if username and password and users.has_key(username) and password == users[username]:
unbanIP(msg["data"]["IP"], msg["data"]["service"])
resp["data"]["IP"] = msg["data"]["IP"]
resp["data"]["service"] = msg["data"]["service"]
server.send_message(client, json.dumps(resp))
else:
print "AUTHFAIL"
resp["data"] = AUTHFAIL
server.send_message(client, json.dumps(resp))
elif msg["action"] == CHANGECONFIG:
print 'msg is CHANGECONFIG'
#changeconfig(bantimer,nofailedattempts,failinterval)
data = msg["data"]
for service in services.values():
if service.name.lower() == data.get("service").lower():
changeConfig(data.get("bantimer"), data.get("threshold"), data.get("interval"), service)
#server.send_message(client, json.dumps(resp))
global server
PORT=9001
server = WebsocketServer(PORT, host='0.0.0.0')
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 startWebsocketServer(self):
server = WebsocketServer(self.port, host = self.__host)
server.set_fn_client_left(self.__client_left)
server.set_fn_new_client(self.__new_client)
server.set_fn_message_received(self.__msg_received)
server.run_forever()
