def main(): print('Initializing HAT') hat.servo_enable(1, False) hat.servo_enable(2, False) hat.light_mode(hat.WS2812) hat.light_type(hat.GRBW) print('Initializing camera') with picamera.PiCamera() as camera: camera.resolution = (WIDTH, HEIGHT) camera.framerate = FRAMERATE camera.vflip = VFLIP # flips image rightside up, as needed camera.hflip = HFLIP # flips image left-right, as needed sleep(1) # camera warm-up time print('Initializing websockets server on port %d' % WS_PORT) WebSocketWSGIHandler.http_version = '1.1' websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) websocket_server.initialize_websockets_manager() websocket_thread = Thread(target=websocket_server.serve_forever) print('Initializing HTTP server on port %d' % HTTP_PORT) http_server = StreamingHttpServer() http_thread = Thread(target=http_server.serve_forever) print('Initializing broadcast thread') output = BroadcastOutput(camera) broadcast_thread = BroadcastThread(output.converter, websocket_server) print('Starting recording') camera.start_recording(output, 'yuv') try: print('Starting websockets thread') websocket_thread.start() print('Starting HTTP server thread') http_thread.start() print('Starting broadcast thread') broadcast_thread.start() while True: camera.wait_recording(1) except KeyboardInterrupt: pass finally: print('Stopping recording') camera.stop_recording() print('Waiting for broadcast thread to finish') broadcast_thread.join() print('Shutting down HTTP server') http_server.shutdown() print('Shutting down websockets server') websocket_server.shutdown() print('Waiting for HTTP server thread to finish') http_thread.join() print('Disabling servos') hat.servo_enable(1, False) hat.servo_enable(2, False) hat.clear() hat.show() print('Waiting for websockets thread to finish') websocket_thread.join()
def run(self): global host, port, rbox, uboxlog logger.info('PyRecordBox is running...') rbox = self self.rbox = RecordBox() _rboxCallback = self.rbox.makeCallback(rboxCallback) if uboxlog: self.rbox.open_logfile() self.rbox.open(_rboxCallback) try: self.server = make_server( host, port, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=PhoneWebSocket)) self.server.initialize_websockets_manager() self.server.serve_forever() except KeyboardInterrupt: self.rbox.close() self.rbox.close_logfile()
def start(self, ctx=None): _logger.debug("Starting Websocket engine...") dispatcher.mount('/ws', WebSocketWSGIApplication(handler_cls=WSConnection)) _logger.debug("Websocket engine started.")
def __init__(self, port=5570, cb_recept=None, log=None): global __ctrlServer__ # check free port for s in __ctrlServer__: if s.port == port: if log: log.error( "Creating WS server error, port %d allready used." % port) raise WsUIServerException( "Creating WS server error, port %d allready used." % port) self.buffer = [] self.clients = set() self.fail_clients = set() self.running = False self.port = port self.cb_recept = cb_recept self.log = log self.server = make_server( '', port, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=WebSocketsHandler)) self.server.initialize_websockets_manager() __ctrlServer__.append(self) servUI = threading.Thread(None, self.run, "th_WSserv_msg_to_ui", (), {}) servUI.start() time.sleep(0.1) if self.log: self.log.info('WebSocket server started on port : %d' % self.port) print "**************** WebSocket server is started on port %d ********************" % self.port
def __init__(self, host, port): self.host = host self.port = port self.ws = WebSocketWSGIApplication(handler_cls=HQCWebSocket) self.clients = [] # TODO: remove clients when they exit self.current_clients = {}
def __init__(self): print('Initializing camera') self.camera = picamera.PiCamera() self.camera.resolution = (WIDTH, HEIGHT) self.camera.framerate = FRAMERATE self.camera.vflip = VFLIP # flips image rightside up, as needed self.camera.hflip = HFLIP # flips image left-right, as needed sleep(1) # camera warm-up time print('Initializing websockets server on port %d' % WS_PORT) WebSocketWSGIHandler.http_version = '1.1' self.websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) self.websocket_server.initialize_websockets_manager() self.websocket_thread = Thread( target=self.websocket_server.serve_forever) print('Initializing HTTP server on port %d' % HTTP_PORT) self.http_server = StreamingHttpServer() self.http_thread = Thread(target=self.http_server.serve_forever) print('Initializing broadcast thread') self.output = BroadcastOutput(self.camera) self.broadcast_thread = BroadcastThread(self.output.converter, self.websocket_server)
def start(self): # Start video server streaming print('Initializing websockets server on port %d' % WS_PORT) self.websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) self.websocket_server.initialize_websockets_manager() self.websocket_thread = Thread( target=self.websocket_server.serve_forever) print('Initializing HTTP server on port %d' % HTTP_PORT) self.http_server = StreamingHttpServer() self.http_thread = Thread(target=self.http_server.serve_forever) print('Initializing broadcast thread') output = BroadcastOutput(self.camera) self.broadcast_thread = BroadcastThread(output.converter, self.websocket_server) print('Starting recording') self.camera.start_recording(output, 'yuv') print('Starting websockets thread') self.websocket_thread.start() print('Starting HTTP server thread') self.http_thread.start() print('Starting broadcast thread') self.broadcast_thread.start() print("Video Stream available...") while True: self.camera.wait_recording(1)
def main(): print('Initializing camera') with picamera.PiCamera() as camera: camera.resolution = (WIDTH, HEIGHT) camera.framerate = FRAMERATE camera.vflip = VFLIP # flips image rightside up, as needed camera.hflip = HFLIP # flips image left-right, as needed sleep(1) # camera warm-up time print('Initializing websockets server on port %d' % WS_PORT) WebSocketWSGIHandler.http_version = '1.1' websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) websocket_server.initialize_websockets_manager() websocket_thread = Thread(target=websocket_server.serve_forever) print('Initializing HTTP server on port %d' % HTTP_PORT) http_server = StreamingHttpServer() http_thread = Thread(target=http_server.serve_forever) print('Initializing broadcast thread') output = BroadcastOutput(camera) broadcast_thread = BroadcastThread(output.converter, websocket_server) print("Initialize video object") # Initialize the face detection with the camera object # that is being used by the live streaming thread. video = Video(camera, cascPath="./cascade.xml") print('Starting recording') camera.start_recording(output, 'yuv') try: print('Starting websockets thread') websocket_thread.start() print('Starting HTTP server thread') http_thread.start() print('Starting broadcast thread') broadcast_thread.start() # Start the video thread. print("Start video") video.start() while True: camera.wait_recording(1) except KeyboardInterrupt: pass finally: print('Stopping recording') camera.stop_recording() print('Waiting for broadcast thread to finish') broadcast_thread.join() print('Shutting down HTTP server') http_server.shutdown() print('Shutting down websockets server') websocket_server.shutdown() print('Waiting for HTTP server thread to finish') http_thread.join() print('Waiting for websockets thread to finish') websocket_thread.join()
def includeme(config): origins = aslist(config.registry.settings.get('origins', '')) config.registry.websocket = WebSocketWSGIApplication(handler_cls=WebSocket) config.registry.websocket_origins = origins config.add_route('ws', 'ws') config.add_view(websocket, route_name='ws') config.add_view(bad_handshake, context=HandshakeError) config.scan(__name__)
def start(ip, port): server = make_server(ip, port, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=MyWebsocket)) server.initialize_websockets_manager() server.serve_forever()
def websocket_view(request): # Provide environment which the WebSocket handler can use... request.environ.update({ "h.ws.streamer_work_queue": streamer.WORK_QUEUE, "h.ws.identity": request.identity, }) app = WebSocketWSGIApplication(handler_cls=websocket.WebSocket) return request.get_response(app)
def start_server(port): global server server = make_server('', port, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=WSServer)) server.initialize_websockets_manager() server.serve_forever()
def __init__(self, host, port): self.host = host self.port = port self.ws = WebSocketWSGIApplication(handler_cls=BroadcastWebSocket) # keep track of connected websocket clients # so that we can brodcasts messages sent by one # to all of them. Aren't we cool? self.clients = []
def main(weight_path, model_config, class_names, draw): print("making net...") net = YoloRunner(weight_path=weight_path, model_config=model_config, class_names=["person"]) print('Initializing camera') with picamera.PiCamera() as camera: camera.resolution = (WIDTH, HEIGHT) camera.framerate = FRAMERATE camera.vflip = VFLIP # flips image rightside up, as needed camera.hflip = HFLIP # flips image left-right, as needed sleep(1) # camera warm-up time print('Initializing websockets server on port %d' % WS_PORT) WebSocketWSGIHandler.http_version = '1.1' websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) websocket_server.initialize_websockets_manager() websocket_thread = Thread(target=websocket_server.serve_forever) print('Initializing HTTP server on port %d' % HTTP_PORT) http_server = StreamingHttpServer() http_thread = Thread(target=http_server.serve_forever) print('Initializing broadcast thread') output = BroadcastOutput(camera, net, draw) broadcast_thread = BroadcastThread(output.converter, websocket_server) print('Starting recording') camera.start_recording(output, 'yuv') error = None try: print('Starting websockets thread') websocket_thread.start() print('Starting HTTP server thread') http_thread.start() print('Starting broadcast thread') broadcast_thread.start() while True: camera.wait_recording(1) except Exception as e: err = e finally: print('Stopping recording') camera.stop_recording() print('Waiting for broadcast thread to finish') broadcast_thread.join() print('Shutting down HTTP server') http_server.shutdown() print('Shutting down websockets server') websocket_server.shutdown() print('Waiting for HTTP server thread to finish') http_thread.join() print('Waiting for websockets thread to finish') websocket_thread.join() if error is not None: raise e
def __init__(self, listen, request_handler, msg_handler_pool_size=1024, indent='indented', pingpong_trigger=0, pingpong_timeout=0, keyfile=None, certfile=None): """ :param listen: string ip:port :param request_handler: instance of januscloud.proxy.core.request:RequestHandler :param msg_handler_pool_size: :param keyfile: :param certfile: """ if msg_handler_pool_size == 0: msg_handler_pool_size = None self._msg_handler_pool = Pool(size=msg_handler_pool_size) self._request_handler = request_handler self._listen = listen if keyfile or certfile: self._server = WSGIServer( self._listen, WebSocketWSGIApplication(protocols=['janus-protocol'], handler_cls=WSServerConn), log=logging.getLogger('websocket server'), keyfile=keyfile, certfile=certfile) else: self._server = WSGIServer( self._listen, WebSocketWSGIApplication(protocols=['janus-protocol'], handler_cls=WSServerConn), log=logging.getLogger('websocket server'), ) self._server.set_environ({ 'app.recv_msg_cbk': self._async_incoming_msg_handler, 'app.closed_cbk': self._request_handler.transport_gone, 'json_indent': indent, 'pingpong_trigger': pingpong_trigger, 'pingpong_timeout': pingpong_timeout })
def main(): led_flash = flash.Flash() led_flash.on() print('Initializing camera') with picamera.PiCamera() as camera: camera.resolution = (WIDTH, HEIGHT) camera.framerate = FRAMERATE sleep(1) # camera warm-up time print('Initializing websockets server on port %d' % WS_PORT) websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) websocket_server.initialize_websockets_manager() websocket_thread = Thread(target=websocket_server.serve_forever) print('Initializing HTTP server on port %d' % HTTP_PORT) output = BroadcastOutput(camera) http_server = StreamingHttpServer(camera, output, led_flash) http_thread = Thread(target=http_server.serve_forever) print('Initializing broadcast thread') broadcast_thread = BroadcastThread(output.converter, websocket_server) print('Starting recording') #camera.start_recording(output, 'yuv') try: print('Starting websockets thread') websocket_thread.start() print('Starting HTTP server thread') http_thread.start() print('Starting broadcast thread') broadcast_thread.start() while True: #camera.wait_recording(1) pass except KeyboardInterrupt: pass finally: print('Turning off flash') led_flash.off() print('Stopping recording') camera.stop_recording() print('Waiting for broadcast thread to finish') broadcast_thread.join() print('Shutting down HTTP server') http_server.shutdown() print('Shutting down websockets server') websocket_server.shutdown() print('Waiting for HTTP server thread to finish') http_thread.join() print('Waiting for websockets thread to finish') websocket_thread.join()
def __init__(self, pi_camera, resolution=(320, 240)): self.camera = pi_camera print( 'Viewer:Initializing websockets server server for img on port %d' % WS_PORT) WebSocketWSGIHandler.http_version = '1.1' self.websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) self.websocket_server.initialize_websockets_manager() self.websocket_thread = Thread( target=self.websocket_server.serve_forever) print( 'Viewer:Initializing websockets server for control data on port %d' % WS_CONTROLLER_PORT) self.controller_websocket_server = make_server( '', WS_CONTROLLER_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication( handler_cls=ControllerStreamingWebSocket)) self.controller_websocket_server.initialize_websockets_manager() self.controller_websocket_thread = Thread( target=self.controller_websocket_server.serve_forever) self.controller_broadcast = ControllerBroadcast( self.controller_websocket_server) self.controller_broadcast_thread = Thread( target=self.controller_broadcast.updata) print('Viewer:Initializing HTTP server on port %d' % HTTP_PORT) self.http_server = StreamingHttpServer() self.http_thread = Thread(target=self.http_server.serve_forever) print('Viewer:Initializing broadcast thread') self.output = BroadcastOutput(self.camera) self.broadcast_thread = BroadcastThread(self.output.converter, self.websocket_server)
def make_ws_server(host="localhost", port=9000): server = make_server( host, port, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=RpcWebSocket)) server.initialize_websockets_manager() return server
def websocket_view(request): # Provide environment which the WebSocket handler can use... request.environ.update({ "h.ws.authenticated_userid": request.authenticated_userid, "h.ws.effective_principals": request.effective_principals, "h.ws.streamer_work_queue": streamer.WORK_QUEUE, }) app = WebSocketWSGIApplication(handler_cls=websocket.WebSocket) return request.get_response(app)
def main(): print('Initializing camera') with picamera.PiCamera() as camera: camera.resolution = (WIDTH, HEIGHT) camera.framerate = FRAMERATE camera.vflip = VFLIP # flips image rightside up, as needed camera.hflip = HFLIP # flips image left-right, as needed sleep(1) # camera warm-up time print('Initializing websockets server on port %d' % WS_PORT) # Start the threaded server server = ThreadedHTTPServer("", CONTROL_SERVER_PORT) WebSocketWSGIHandler.http_version = '1.1' websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) websocket_server.initialize_websockets_manager() websocket_thread = Thread(target=websocket_server.serve_forever) print('Initializing broadcast thread') output = BroadcastOutput(camera, q) broadcast_thread = BroadcastThread(output.converter, websocket_server, q) print('Start recording') camera.start_recording(output, 'yuv') try: print('Starting websockets thread') websocket_thread.start() print('Starting broadcast thread') broadcast_thread.start() print('Starting file recording thread') record_thread.start() print('Starting web server control thread') server.start() while True: camera.wait_recording(1) except KeyboardInterrupt: pass finally: print('Waiting for websockets thread to finish') print('Stopping recording') camera.stop_recording() print('Waiting for broadcast thread to finish') broadcast_thread.join() print('Shutting down websockets server') websocket_server.shutdown() print('Waiting for recording to shutdown') record_thread.kill() print('Stopping web server control thread') server.stop() print('Waiting for websockets server') websocket_thread.join()
def main(): print('Initializing camera') with picamera.PiCamera() as camera: camera.resolution = (WIDTH, HEIGHT) camera.framerate = FRAMERATE sleep(1) # camera warm-up time camera.awb_mode = AWB_MODE camera.brightness = BRIGHTNESS camera.exposure_mode = EXPOSURE_MODE camera.contrast = CONTRAST camera.saturation = SATURATION camera.sharpness = SHARPNESS print('Initializing websockets server on port %d' % WS_PORT) websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) websocket_server.initialize_websockets_manager() websocket_thread = Thread(target=websocket_server.serve_forever) print('Initializing HTTP server on port %d' % HTTP_PORT) http_server = StreamingHttpServer() http_thread = Thread(target=http_server.serve_forever) print('Initializing broadcast thread') output = BroadcastOutput(camera) broadcast_thread = BroadcastThread(output.converter, websocket_server) print('Starting recording') camera.start_recording(output, 'yuv') camera.start_recording('output.h264', splitter_port=2, format='h264') try: print('Starting websockets thread') websocket_thread.start() print('Starting HTTP server thread') http_thread.start() print('Starting broadcast thread') broadcast_thread.start() while True: camera.wait_recording(1) except KeyboardInterrupt: pass finally: print('Stopping recording') camera.stop_recording() print(camera.frame.index) print('Waiting for broadcast thread to finish') broadcast_thread.join() print('Shutting down HTTP server') http_server.shutdown() print('Shutting down websockets server') websocket_server.shutdown() print('Waiting for HTTP server thread to finish') http_thread.join() print('Waiting for websockets thread to finish') websocket_thread.join()
def main(): print('Initializing camera') with picamera.PiCamera() as camera: camera.resolution = (WIDTH, HEIGHT) camera.framerate = FRAMERATE sleep(1) # camera warm-up time print('Initializing websockets server on port %d' % WS_PORT) websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) websocket_server.initialize_websockets_manager() websocket_thread = Thread(target=websocket_server.serve_forever) print('Initializing HTTP server on port %d' % HTTP_PORT) http_server = StreamingHttpServer() http_thread = Thread(target=http_server.serve_forever) print('Initializing broadcast thread') buffer = picamera.PiCameraCircularIO(camera, seconds=2) output = BroadcastOutput(websocket_server) print('Starting recording') camera.start_recording(output, 'h264', intra_period = 25) try: print('Starting websockets thread') websocket_thread.start() print('Starting HTTP server thread') http_thread.start() while True: camera.wait_recording(1) #with buffer.lock: #for frame in buffer.frames : #if frame.frame_type == picamera.PiVideoFrameType.sps_header: #buffer.seek(frame.position) #break #output.write(buffer.read()) except KeyboardInterrupt: pass finally: print('Stopping recording') camera.stop_recording() print('Waiting for broadcast thread to finish') print('Shutting down HTTP server') http_server.shutdown() print('Shutting down websockets server') websocket_server.shutdown() print('Waiting for HTTP server thread to finish') http_thread.join() print('Waiting for websockets thread to finish') websocket_thread.join()
def websocket_view(request): # WebSockets can be opened across origins and send cookies. To prevent # scripts on other sites from using this socket, ensure that the Origin # header (if present) matches the request host URL or is whitelisted. origin = request.headers.get('Origin') allowed = request.registry.settings['origins'] if origin is not None: if origin != request.host_url and origin not in allowed: return httpexceptions.HTTPForbidden() app = WebSocketWSGIApplication(handler_cls=websocket.WebSocket) return request.get_response(app)
def main(): print('Initializing camera') #with picamera.PiCamera() as camera: with picamera.PiCamera(resolution='{}x{}'.format(WIDTH, HEIGHT), framerate=FRAMERATE) as camera: encoder = VideoEncoder(camera) with ImageAnalyser(camera, encoder) as output: # camera.resolution = (WIDTH, HEIGHT) # camera.framerate = FRAMERATE camera.vflip = VFLIP # flips image rightside up, as needed camera.hflip = HFLIP # flips image left-right, as needed sleep(1) # camera warm-up time print('Initializing websockets server on port %d' % WS_PORT) WebSocketWSGIHandler.http_version = '1.1' websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) websocket_server.initialize_websockets_manager() websocket_thread = Thread(target=websocket_server.serve_forever) print('Initializing HTTP server on port %d' % HTTP_PORT) http_server = StreamingHttpServer() http_thread = Thread(target=http_server.serve_forever) print('Initializing broadcast thread') #broadcast_thread = BroadcastThread(output.converter, websocket_server) broadcast_thread = BroadcastThread(encoder.proc, websocket_server) print('Starting recording') camera.start_recording(output, 'bgr') try: print('Starting websockets thread') websocket_thread.start() print('Starting HTTP server thread') http_thread.start() print('Starting broadcast thread') broadcast_thread.start() while True: camera.wait_recording(1) except KeyboardInterrupt: pass finally: print('Stopping recording') camera.stop_recording() print('Waiting for broadcast thread to finish') broadcast_thread.join() print('Shutting down HTTP server') http_server.shutdown() print('Shutting down websockets server') websocket_server.shutdown() print('Waiting for HTTP server thread to finish') http_thread.join() print('Waiting for websockets thread to finish') websocket_thread.join()
def main(): logger.info('Initializing camera') with picamera.PiCamera() as camera: config = get_config() w = config.getint('camera', 'width', fallback=640) h = config.getint('camera', 'height', fallback=480) camera.resolution = (w, h) camera.framerate = config.getint('camera', 'framerate', fallback=24) camera.rotation = config.getint('camera', 'rotation', fallback=0) camera.hflip = config.getboolean('camera', 'hflip', fallback=False) camera.vflip = config.getboolean('camera', 'vflip', fallback=False) camera.led = config.getboolean('camera', 'led', fallback=False) sleep(1) # camera warm-up tim logger.info('Initializing websockets server on port %d' % WS_PORT) websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=HTTP11WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) websocket_server.initialize_websockets_manager() websocket_thread = Thread(target=websocket_server.serve_forever) #logger.info('Initializing HTTP server on port %d' % HTTP_PORT) #http_server = StreamingHttpServer() #http_thread = Thread(target=http_server.serve_forever) logger.debug('Initializing broadcast thread') output = BroadcastOutput(camera) broadcast_thread = BroadcastThread(output.converter, websocket_server) logger.info('Starting recording') camera.start_recording(output, 'yuv') try: logger.debug('Starting websockets thread') websocket_thread.start() #logger.info('Starting HTTP server thread') #http_thread.start() logger.debug('Starting broadcast thread') broadcast_thread.start() while True: camera.wait_recording(1) except KeyboardInterrupt: pass finally: logger.info('Stopping recording') camera.stop_recording() logger.debug('Waiting for broadcast thread to finish') broadcast_thread.join() logger.debug('Shutting down HTTP server') #http_server.shutdown() logger.debug('Shutting down websockets server') websocket_server.shutdown() logger.debug('Waiting for HTTP server thread to finish') #http_thread.join() logger.debug('Waiting for websockets thread to finish') websocket_thread.join()
def start(self): if self.server: return self.server = make_server( self.host, 3000, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=BrowserReloadProtocol)) self.server.initialize_websockets_manager() self.server_thread = Thread(target=self.server.serve_forever) self.server_thread.start()
def start_websockets(self): print('Initializing websocket...') WebSocketWSGIHandler.http_version = '1.1' self.websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) self.websocket_server.initialize_websockets_manager() self.websocket_thread = Thread( target=self.websocket_server.serve_forever)
def run(self): from . import server self.server = make_server( '', 9222, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=server.DebuggerWebSocket)) sys.stderr.write( 'Navigate to chrome://devtools/devtools.html?ws=0.0.0.0:9222\n') self.server.initialize_websockets_manager() self.server.serve_forever()
def main(): print('Setting up GPIO ' + str(GPIO_PIN) + ' IR LED') GPIO.setmode(GPIO.BCM) GPIO.setup(GPIO_PIN, GPIO.OUT) print('Initializing camera') with picamera.PiCamera() as camera: camera.resolution = (WIDTH, HEIGHT) camera.framerate = FRAMERATE camera.led = False sleep(1) # camera warm-up time print('Initializing websockets server on port %d' % WS_PORT) websocket_server = make_server( '', WS_PORT, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket)) websocket_server.initialize_websockets_manager() websocket_thread = Thread(target=websocket_server.serve_forever) print('Initializing HTTP server on port %d' % HTTP_PORT) http_server = StreamingHttpServer(camera) http_thread = Thread(target=http_server.serve_forever) print('Initializing broadcast thread') output = BroadcastOutput(camera) broadcast_thread = BroadcastThread(output.converter, websocket_server) print('Starting recording') camera.start_recording(output, 'yuv') try: print('Starting websockets thread') websocket_thread.start() print('Starting HTTP server thread') http_thread.start() print('Starting broadcast thread') broadcast_thread.start() while True: camera.wait_recording(1) except KeyboardInterrupt: pass finally: print('Stopping recording') camera.stop_recording() print('Waiting for broadcast thread to finish') broadcast_thread.join() print('Shutting down HTTP server') http_server.shutdown() print('Shutting down websockets server') websocket_server.shutdown() print('Waiting for HTTP server thread to finish') http_thread.join() print('Waiting for websockets thread to finish') websocket_thread.join()
def __init__(self, debugger_store, port): class ConcreteDebuggerWebSocket(DebuggerWebSocket): @staticmethod def debugger_store(): return debugger_store self.debug_server = make_server( 'localhost', port, server_class=WSGIServer, handler_class=WebSocketWSGIRequestHandler, app=WebSocketWSGIApplication( handler_cls=ConcreteDebuggerWebSocket)) self.debug_server.initialize_websockets_manager()
def __init__(self, app): self.app = app WebSocketWSGIApplication.__init__(self)
def __call__(self, environ, start_response): if 'ws4py.socket' in environ: WebSocketWSGIApplication.__call__(self, environ, start_response) response = self.app(environ, start_response) return response
def make_websocket(self, sock, protocols, extensions, environ): connection = WebSocketWSGIApplication.make_websocket(self, sock, protocols, extensions, environ) connection.conn_id = sock.fileno() pad_server.new_connection(connection) return connection