class WebSocket(util.Threadbase):
signals = 'message'
def __init__(self, ip, port):
global emitter
super(WebSocket, self).__init__()
emitter = self
port = int(port)
log.info('starting websocket on %s:%i' % (ip, port))
self.server = SimpleWebSocketServer(ip, port, WebsocketClient)
self.start()
def terminate(self):
log.debug('terminating websocket')
super().terminate()
self.server.close()
@staticmethod
def send_message(client, message_dict):
_json = json.dumps(message_dict)
for _client in clients:
if not client or _client.address[0] == client.address[0]:
_client.sendMessage(_json)
def run(self):
while not self.terminated:
self.server.serveonce()
log.debug('websocket exits')
class Websocket(object):
def send_data(self, data):
for nr, conn in self.server.connections.items():
conn.sendMessage(data)
def run(self):
self.server = SimpleWebSocketServer('', self.port, TestEcho)
while not self.exit_event.is_set():
self.server.serveonce()
def __init__(self, port):
self.port = port
self.exit_event = Event()
self.thread = Thread(target=self.run)
self.thread.start()
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.exit_event.set()
self.thread.join(10)
if self.thread.is_alive():
Utility.console_log('Thread cannot be joined', 'orange')
def loopWebsocketServer(self, ip='', port=8000):
web_socket_server = SimpleWebSocketServer(ip,
port,
WebsocketServer,
game_server=self)
print("Server WebSocket ip is %s, and port is %s" % (ip, port))
while self.running:
web_socket_server.serveonce()
class Backend:
def __init__(self, wsPort=9001, httpPort=80):
self.clients = []
handler = ClientHandler
handler.backend = self
self.wsServer = SimpleWebSocketServer('0.0.0.0', wsPort, handler)
self.httpServer = socketserver.TCPServer(('0.0.0.0', httpPort),
UIHandler)
self.httpServer.socket = ssl.wrap_socket(
self.httpServer.socket,
server_side=True,
certfile='cert.pem',
keyfile='key.pem',
ssl_version=ssl.PROTOCOL_TLSv1_2)
self.zone = 0
self.p = Pipe()
def online(self):
try:
Process(target=self.wsLoop, args=(self.p[1], ),
daemon=True).start()
Process(target=self.httpServer.serve_forever, daemon=True).start()
print("Backend Online")
return True
except Exception as e:
print(e)
return False
def sendFrame(self, frame):
assert type(frame) is np.ndarray
packed = cv2.imencode(".jpeg", frame)[1]
[
client.sendMessage(packed) for client in self.clients
if client.role == "viewer"
]
def wsLoop(self, conn):
Thread(target=self.notifyHelmet, daemon=True).start()
while True:
n = conn.recv()
if isinstance(n, np.ndarray):
self.sendFrame(n)
elif isinstance(n, int):
self.zone = n
self.wsServer.serveonce()
def notifyHelmet(self):
while True:
try:
msg = json.dumps({"range": self.zone})
[
client.sendMessage(msg) for client in self.clients
if client.role == "helmet"
]
time.sleep(0.3)
except:
print("Error notifying helmet")
class VizWebsocketServer(Thread):
def __init__(self, cpstw, port=8000):
Thread.__init__(self)
self.cpstw = cpstw
self._websocketd = None
self._port = port
self.stop_event = threading.Event()
def run(self):
self._websocketd = SimpleWebSocketServer(
'', self._port, get_viz_websocket_handler(self.cpstw))
while not self.stop_event.is_set():
self._websocketd.serveonce()
self._websocketd.close()
def stop(self):
logger.info("Stopping VizWebsocketServer now!")
self.stop_event.set()
def run_server():
global server, server_running
print("Starting Server")
server = SimpleWebSocketServer(
'', 9000, SimpleWebSocket, selectInterval=(1000.0 / 15) / 1000)
server_running = True
analysis_thread = threading.Thread(target=start_camera_analysis, daemon=True)
analysis_thread.start()
try:
while analysis_thread.isAlive():
server.serveonce()
except KeyboardInterrupt:
server_running = False
analysis_thread.join()
class WSBroadcast(Thread):
def __init__(self, name, port):
super().__init__()
self.name = name
self.port = port
self._running = True
self._dispatcher = _Dispatcher(self)
self._server = SimpleWebSocketServer('', self.port, WebSocket)
self._bitrates = {}
def close(self):
self._running = False
self._dispatcher.close()
def run(self):
self._dispatcher.start()
print("Opening WS broadcast '%s' on port %d..." %
(self.name, self.port))
while self._running:
self._server.serveonce()
def message(self, msg):
self._dispatcher.message(msg)
def sync_message(self, msg):
for c in self._server.connections:
"""
Just skip the message if send is in progress
"""
if len(self._server.connections[c].sendq) <= 1:
if c not in self._bitrates:
self._bitrates[c] = RateStream('Websocket: %s (Mbit/s)' %
c)
self._bitrates[c].register(len(msg) * 8. / 1.e6)
self._server.connections[c].sendMessage(msg)
" raised an exception; tweak it and send again."})
print type(e), e
def send(self, msg):
print "> sent", repr(msg)
self.sendMessage(unicode(json.dumps(msg)))
def handleConnected(self):
print self.address, "connected"
def handleClose(self):
print self.address, "closed"
EXIT[0] = True
if __name__ == "__main__":
objective = 'W_{f_{total}}'
aircraft = 'optimald8'
substitutions = get_optimalD8_subs()
fixedBPR = False
pRatOpt = True
mutategparg = True
LASTSOL[0] = None
sol = optimize_aircraft(objective, aircraft, substitutions, fixedBPR, pRatOpt, mutategparg, x0 = LASTSOL[0])
LASTSOL[0] = sol
genfiles(m, sol)
server = SimpleWebSocketServer('', 8000, SPaircraftServer)
while not EXIT[0]:
server.serveonce()
print "Python server has exited."
class EventHandler:
def __init__(self):
self.__version__ = '3.1.3'
logger_format = '%(asctime)s %(message)s'
logging.basicConfig(format=logger_format, level=logging.INFO,
datefmt="%H:%M:%S", filename='./logfile.log', filemode='w')
logging.getLogger().addHandler(SysLogHandler(facility=SysLogHandler.LOG_DAEMON, address='/dev/log'))
self._SIGKILL = False
self.logging = logging
self.config = DB('./config.json')
self.network = Network(self)
self.display = DisplayContent()
self.detector = Detector()
self.ultrasound = Ultrasound(self)
self.temp = Temp()
self.server = SimpleWebSocketServer('', 8069, WebSocketServer, self)
self.cook = Cook(self)
self.energy = Energy(self)
self.history = History(self)
self.audio = Audio(self)
self.users = Users(self)
self.automations = Automations(self)
signal.signal(signal.SIGTERM, self.sig_handler)
signal.signal(signal.SIGINT, self.sig_handler)
self.log("Boot: v" + self.__version__)
def log(self, msg):
self.logging.info(msg)
def err(self, msg):
self.logging.error(msg)
self.logging.error(exc_info()[-1].tb_lineno)
def sig_handler(self, _, _2):
self._SIGKILL = True
self.server.close()
exit()
def poweroff(self):
system('sudo shutdown -h now')
async def startWebsocket(self):
while not self._SIGKILL:
self.server.serveonce()
def dispatchWorker(self, fn, *args):
return asyncio.run(fn(*args))
async def startDetectionLoop(self):
try:
while not self._SIGKILL:
networkStatus = await self.network.get()
if networkStatus == 'connected':
break
self.display.network("Automated Oven" if networkStatus == 'hostapd' else "Connecting")
await asyncio.sleep(0.5)
self.log("Network: Connected")
await self.dispatch([
[self.display.text, "Place The Item"],
[self.cook.init]
])
while not self._SIGKILL:
await self.temp.update()
if not self.cook.isCooking and await self.config.get('autoDetect'):
dist = await self.ultrasound.get()
if dist < await self.config.get('sensitivity')*0.17:
tasks = await self.dispatch([
[self.display.loading],
[self.detector.detect],
])
res = tasks[1].result()
self.log("Detection: " + res)
await self.cook.startFromDB(res)
else:
await asyncio.sleep(await self.config.get('responsiveness')*0.003)
else:
await asyncio.sleep(await self.config.get('responsiveness')*0.01)
except Exception as e:
self.err(e)
async def dispatch(self, arrayOfDispatches):
arrayOfFutures = []
with cf.ThreadPoolExecutor(max_workers=4) as executor:
loop = asyncio.get_running_loop()
for d in arrayOfDispatches:
arrayOfFutures.append(loop.run_in_executor(
executor, self.dispatchWorker, *d))
await asyncio.gather(*arrayOfFutures)
return arrayOfFutures
async def init(self):
await self.dispatch([
[self.display.init, self]
])
await self.dispatch([
[self.display.loading],
[self.detector.init, self],
[self.detector.load_model]
])
def run(self):
server = SimpleWebSocketServer(self.HOST, self.PORT, IDEWSProtocol)
while not self.exit_event.is_set():
server.serveonce()
def thread_function(name):
print 'start listening'
server = SimpleWebSocketServer('', 8000, SimpleEcho, 2)
while _IS_THREAD_RUNNING:
server.serveonce()
print 'stopping network connections'
