class MockHTTPServer: def __init__(self, host, port): self.host = host self.port = port self.stop_server = False self.handler = HTTPRequestHandler self.server = ThreadingHTTPServer((self.host, self.port), self.handler) self.server.timeout = 0 #init with default data self.server.data = settings.MOCK_DATA["data"] self.server.tokens = settings.MOCK_DATA["tokens"] def start(self): self.server.allow_reuse_address = True self.th = threading.Thread(target=self.server.serve_forever)#, daemon=True) print("server starting") self.th.start() return self.server def stop(self): self.server.server_close() self.server.shutdown() self.stop_server = True def set_data(self, data): self.handler.data = json.dumps(data).encode()
def start_server(port=8000, launcher=None): from confply import pushd global launcher_path global aliases global configs # this is required to work with safari for some reason. ThreadingHTTPServer.address_family, addr = _get_best_family(None, port) if launcher is not None: launcher_path = os.path.abspath(launcher) with pushd(os.path.dirname(launcher_path)): with open(os.path.basename(launcher_path)) as launcher_file: config = {"aliases": {}, "__file__": launcher_path} exec(launcher_file.read(), config, config) aliases = config["aliases"] for k, v in aliases.items(): for elem in shlex.split(v): if elem.endswith(".py"): configs.add(elem) webServer = ThreadingHTTPServer(addr, ConfplyServer) print("Server started http://%s:%s" % (addr)) try: webServer.serve_forever() except KeyboardInterrupt: pass webServer.server_close() print("Server stopped.")
class AppleWatchStreamer(BaseStreamer): server_port = 8118 def __init__(self, port=8118, path='./Files', parent=None): super(AppleWatchStreamer, self).__init__(path=path, parent=parent) self.server_port = port def run(self): self.add_log.emit( "Démarrage du serveur sur le port " + str(self.server_port), LogTypes.LOGTYPE_INFO) self.request_handler = AppleWatchRequestHandler self.request_handler.streamer = self self.server = ThreadingHTTPServer( (self.get_local_ip_address(), self.server_port), self.request_handler) self.server_running = True self.server.timeout = 5 # 5 seconds timeout should be ok since we are usually on local network self.server.serve_forever() self.server.server_close() # print('Server stopped') # # def get_streamer_infos(self): # return {"Adresse IP": self.get_local_ip_address(), # "Port": str(self.server_port), # "Données": self.server_save_path} @pyqtSlot() def stop_server(self): self.add_log.emit('Arrêt du serveur...', LogTypes.LOGTYPE_INFO) self.server_running = False self.server.shutdown()
class App: def __init__(self, **kwargs): logging.basicConfig( format="[%(asctime)s] %(name)s [%(levelname)s]: %(message)s", level=logging.INFO) self.bind_host = kwargs.get("host", "127.0.0.1") self.bind_port = kwargs.get("port", "6000") self.router = kwargs.get("router", Router) self.routes = kwargs.get("routes", []) self.conffile = kwargs.get("config", None) self._config = {} if ':' in self.bind_host: self.bind_host, self.bind_port = self.bind_host.split(':') if self.conffile: self._config = yaml.load(open(self.conffile), Loader=yaml.FullLoader) if self._config.get("routes", {}): for route in self._config.get("routes", {}): self.router.routes.append(route) self.bind_port = int(self.bind_port) self.server = ThreadingHTTPServer((self.bind_host, self.bind_port), self.router) for route in self.routes: self.router.routes.append(route) @property def config(self): return self._config def run(self): logging.info( f"Starting server on {self.bind_host}:{self.bind_port}, use <Ctrl-C> to stop" ) try: self.server.serve_forever() except KeyboardInterrupt: pass logging.info(f"Stopping server") self.server.server_close() def cli(self): self.parser = argparse.ArgumentParser( description="fastapp application server") self.parser.add_argument( "-b", "--bind", help="Host address to bind to; default 127.0.0.1", default="127.0.0.1") self.parser.add_argument("-p", "--port", help="Port to bind to; default 6000", default="6000") self.args = parser.parse_args()
def web_server(): print("Listing on 172.20.10.7:8080 \n") httpd = ThreadingHTTPServer(("", 8080), PostGetRequestHandler) try: httpd.serve_forever() except KeyboardInterrupt: print("Server is terminated") httpd.server_close()
class BrowserIntegration(QtCore.QObject): listen_port_changed = QtCore.pyqtSignal(int) def __init__(self, parent=None): super().__init__(parent) self.server = None @property def host_address(self): if not self.server: return '' return self.server.server_address[0] @property def port(self): if not self.server: return 0 return self.server.server_address[1] def start(self): if self.server: self.stop() config = get_config() if config.setting["browser_integration_localhost_only"]: host_address = '127.0.0.1' else: host_address = '0.0.0.0' # nosec for port in range(config.setting["browser_integration_port"], 65535): try: self.server = ThreadingHTTPServer((host_address, port), RequestHandler) except OSError: continue log.info("Starting the browser integration (%s:%d)", host_address, port) self.listen_port_changed.emit(port) threading.Thread(target=self.server.serve_forever).start() break else: log.error( "Failed finding an available port for the browser integration." ) self.stop() def stop(self): if self.server: log.info("Stopping the browser integration") self.server.shutdown() self.server.server_close() self.server = None self.listen_port_changed.emit(self.port) else: log.debug("Browser integration inactive, no need to stop")
def go(): webServer = ThreadingHTTPServer((hostName, serverPort), MyServer) print("Server started http://%s:%s" % (hostName, serverPort)) try: webServer.serve_forever() except KeyboardInterrupt: pass webServer.server_close()
def run(): print('starting server...') server_address = ('0.0.0.0', 8081) server = ThreadingHTTPServer(server_address, MysqlHealthCheck) print('running server...') try: server.serve_forever() except KeyboardInterrupt: pass server.server_close()
def serverstart(): webServer = ThreadingHTTPServer((hostName, serverPort), MyServer) logging.info("Server started http://%s:%s" % (hostName, serverPort)) try: logging.info("Connecting to currency exchange...") exchange.load_currencies() except Exception as e: logging.error("Exchange unavailable: %s" % str(e)) exit() try: webServer.serve_forever() except KeyboardInterrupt: pass webServer.server_close()
def start(self): serv = ThreadingHTTPServer((self.HOSTNAME, self.HOSTPORT), ServerHandler) print(time.asctime(), "Server Starts - %s:%s" % (self.HOSTNAME, self.HOSTPORT)) # inject Keymaster dependency serv.RequestHandlerClass.set_serial_driver(serv.RequestHandlerClass, driver=self._serial_driver) try: serv.serve_forever() except KeyboardInterrupt: pass serv.server_close() print(time.asctime(), "Server Stops - %s:%s" % (self.HOSTNAME, self.HOSTPORT))
def start(experiments_arg, port=8081): """ Start the REST API """ global experiments experiments = experiments_arg server_address = ("", port) httpd = ThreadingHTTPServer(server_address, HTTP) print("Starting Experiment Manager HTTP Server..." + str(port)) try: httpd.serve_forever() except KeyboardInterrupt: print("***** Error in Experiment Manager HTTP Server *****") pass httpd.server_close() print( time.asctime(), "Experiment Manager Server Stopped - %s:%s" % (server_address, port), )
def main(): server_address = (CONFIG.get('host'), CONFIG.get('port')) if sys.version_info >= (3, 7): # needs Python 3.7+ # pylint: disable=no-name-in-module from http.server import ThreadingHTTPServer httpd = ThreadingHTTPServer(server_address, Server) # pylint: enable=no-name-in-module else: from http.server import HTTPServer httpd = HTTPServer(server_address, Server) if CONFIG.get('tls') is not None: httpd.socket = ssl.wrap_socket(httpd.socket, keyfile=CONFIG['key'], certfile=CONFIG['cert'], server_side=True) try: print('Server started at %s:%s' % server_address) httpd.serve_forever() except KeyboardInterrupt: print('KeyboardInterrupt, shutting down.') httpd.server_close()
"""This program implements the driver file for our webserver On your web browser navigate to the following URL: http://hostname:8000/ """ import time import os import threading import queue from http.server import ThreadingHTTPServer from server import Server from socket import * from random import shuffle from human_backend import use_data_files HOST_NAME = "SRLAB03.ece.umn.edu" #gethostbyname(gethostname()) PORT_NUMBER = 80 #all we're doing below is launching the server (view server.py for this stuff) and waiting to catch a KeyboardInterrupt. if __name__ == '__main__': use_data_files() httpd = ThreadingHTTPServer((HOST_NAME, PORT_NUMBER), Server) print(time.asctime(), 'Server UP - %s:%s' % (HOST_NAME, PORT_NUMBER)) try: httpd.serve_forever() except KeyboardInterrupt: pass httpd.server_close() print(time.asctime(), 'Server DOWN - %s:%s' % (HOST_NAME, PORT_NUMBER))
return self.do_GET() if __name__ == "__main__": server = ThreadingHTTPServer((hostName, serverPort), RequestHandler) server.daemon_threads = True server.allow_reuse_address = True def signal_handler(signal, frame): print("Exiting due to keyboard interrupt...") try: if (server): server.server_close() finally: sys.exit(0) signal.signal(signal.SIGINT, signal_handler) print(f"Server started http://{hostName}:{serverPort}") print("Press Ctrl-C to exit.") system("title pyZohoAPI Testing Server") system(f"start http://{hostName}:{serverPort}") try: while True: sys.stdout.flush() server.serve_forever() except KeyboardInterrupt: pass server.server_close()
class ImageWindow(QWidget): def __init__(self, config, parent=None): super().__init__(parent) self.config = config self.setWindowTitle('3D Vorschau') vbox = QVBoxLayout() # buttons for global operations, modes save = QPushButton("Speichern") save.clicked.connect(self.saveTriggered) rotleft = QPushButton("Linkes drehen") rotleft.clicked.connect(self.config.leftState().rotate90) rotright = QPushButton("Rechtes drehen") rotright.clicked.connect(self.config.rightState().rotate90) self._linkedBtn = QCheckBox("verbunden", self) self._linkedBtn.setChecked(self.config.linked) self._linkedBtn.stateChanged.connect(self.config.setLinked) self.config.linkedChanged.connect(self.setLinked) self._modeGroup = QButtonGroup(self) self._modeGroup.addButton(QRadioButton("skalieren",self),0) self._modeGroup.addButton(QRadioButton("schieben",self),1) self._modeGroup.addButton(QRadioButton("drehen",self),2) self._modeGroup.addButton(QRadioButton("drehen+skalieren",self),3) self._modeGroup.button(self.config.mode).setChecked(True) self._modeGroup.buttonClicked['int'].connect(self.config.setMode) self.config.modeChanged.connect(self.setMode) tb = QHBoxLayout() tb.addWidget(save) tb.addStretch(1) tb.addWidget(rotleft) tb.addWidget(rotright) tb.addWidget(self._linkedBtn) tb.addWidget(self._modeGroup.button(0)) tb.addWidget(self._modeGroup.button(1)) tb.addWidget(self._modeGroup.button(2)) tb.addWidget(self._modeGroup.button(3)) vbox.addLayout(tb) # the views to the left and right image self.leftImage = ImageView(self.config.leftState(), self.config, False) self.rightImage = ImageView(self.config.rightState(), self.config, True) imgbox = QHBoxLayout() imgbox.setSpacing(0) imgbox.addStretch(1) imgbox.addWidget(self.leftImage) imgbox.addWidget(self.rightImage) imgbox.addStretch(1) vbox.addLayout(imgbox) self.setLayout(vbox) self.leftImage.mousePress.connect(self.mousePressL) self.leftImage.mouseMove.connect(self.mouseMove) self.rightImage.mousePress.connect(self.mousePressR) self.rightImage.mouseMove.connect(self.mouseMove) self.httpd = ThreadingHTTPServer(('', 12345), ImageWebserver) self.httpd.appconfig = self.config self.httpd_thread = threading.Thread(target=self.httpd.serve_forever) self.httpd_thread.daemon = True self.httpd_thread.start() def closeEvent(self, e): self.httpd.shutdown() self.httpd.server_close() def setLinked(self, value): self._linkedBtn.setChecked(value!=0) self._linkedBtn.repaint() def setMode(self, value): self.config.setLinked(value==0) self._modeGroup.button(value).setChecked(True) def computeScale(self, start, end): try: p1 = start - self._mouseCenter p2 = end - self._mouseCenter s = math.sqrt(float(p2.x()*p2.x()+p2.y()*p2.y())/ float(p1.x()*p1.x()+p1.y()*p1.y())) return QTransform().scale(s,s) except ZeroDivisionError: return QTransform() def computeMove(self, start, end): try: m = QPointF(end-start)/self.leftImage.imgRect().width() return QTransform(1,0,0,1,m.x(),m.y()) except ZeroDivisionError: return QTransform() def computeRotate(self, start, end): try: p1 = start - self._mouseCenter p2 = end - self._mouseCenter return QTransform().rotateRadians(math.atan2(p1.x(),p1.y()) - math.atan2(p2.x(),p2.y())) except ZeroDivisionError: return QTransform() def computeRotateScale(self, start, end): try: p1 = start - self._mouseCenter p2 = end - self._mouseCenter s = float(p1.y()*p2.x()-p1.x()*p2.y())/float(p1.x()*p1.x()+p1.y()*p1.y()) c = (p2.y()+p1.x()*s)/p1.y() return QTransform(c,-s,s,c,0,0) except ZeroDivisionError: return QTransform() def mousePressL(self, m): self._mouseCenter = self.leftImage.imgRect().center() self.mousePress(m,0) def mousePressR(self, m): self._mouseCenter = self.rightImage.imgRect().center() self.mousePress(m,1) def mousePress(self, m, side): self._mouseStart = m.pos() self._mouseSide = side self._leftTransform = self.config.leftState().transform self._rightTransform = self.config.rightState().transform def mouseMove(self, m): self._mouseEnd = m.pos() if self.config.mode == 0: transform = self.computeScale(self._mouseStart, self._mouseEnd) elif self.config.mode == 1: transform = self.computeMove(self._mouseStart, self._mouseEnd) elif self.config.mode == 2: transform = self.computeRotate(self._mouseStart, self._mouseEnd) elif self.config.mode == 3: transform = self.computeRotateScale(self._mouseStart, self._mouseEnd) if (self._mouseSide==0 or self.config.linked): self.config.leftState().transform = self._leftTransform * transform if (self._mouseSide==1 or self.config.linked): self.config.rightState().transform = self._rightTransform * transform def saveTriggered(self): dstFile = self.config.proposeFilename() if dstFile == None: return print("saving in "+dstFile) # create an image for the final output img = QImage(self.config.saveSize, QImage.Format_RGB888) qp = QPainter(img) # black background and then the images dst = QRect(0,0,img.width(), img.height()) brush = QBrush(Qt.SolidPattern) brush.setColor(Qt.black) qp.setBrush(brush) qp.drawRect(dst) self.config.paintImage(qp, dst) qp.end() img.save(dstFile)
s += lines_to_html_str( file_to_text("k3/__private__/__private.temp.txt")) s += end_() self.wfile.write(bytes(s, "utf-8")) def do_POST(self): '''Reads post request body''' self.send_response(200) self.send_header("Content-type", "text/html") self.end_headers() content_len = int(self.headers.getheader('content-length', 0)) post_body = self.rfile.read(content_len) self.wfile.write("received post request:<br>{}".format(post_body)) myServer = ThreadingHTTPServer((hostName, hostPort), MyServer) print(time.asctime(), "Server Starts - %s:%s" % (hostName, hostPort)) try: myServer.serve_forever() except KeyboardInterrupt: pass myServer.server_close() print(time.asctime(), "Server Stops - %s:%s" % (hostName, hostPort)) #EOF
class Gui(threading.Thread): def __init__(self, width, height): ''' Creating the GUI :return: :rtype: ''' threading.Thread.__init__(self) self.connected = False self.led_array_listener = [] self.connection_state_listener = [] self.width = width self.height = height # Register listener in the LocalCGIHTTPRequestHandler class LocalCGIHTTPRequestHandler.local_cgi_script[ "connection_status"] = self.add_connection_state_listener LocalCGIHTTPRequestHandler.local_cgi_script[ "led_array"] = self.add_led_array_listener # Create server instance self.https = ThreadingHTTPServer(('', 8000), LocalCGIHTTPRequestHandler) self.led_array = [] self.html_led_array = 'EMPTY' def run(self): self.set_connected(True) self.https.serve_forever() def end(self): self.set_connected(False) self.https.shutdown() self.https.server_close() def set_array_colors(self, led_array): self.led_array = deepcopy(led_array) html = ['<div id="ledArray2">'] for row in self.led_array: html.append('<div class="line">') for r, g, b in row: html.append( f'<div class="led" style="background-color:rgb({r}, {g}, {b});"></div>' ) html.append('</div>') html.append('</div>') self.html_led_array = ''.join(html) self.inform_led_array_listener() def add_connection_state_listener(self, q): self.connection_state_listener.append(q) self.inform_connection_state_listener(q) def add_led_array_listener(self, q): self.led_array_listener.append(q) self.inform_led_array_listener(q) @staticmethod def get_color_in_hex(color): c = '#' for pure in color: c += f'{pure:02X}'[-2:] return c def inform_connection_state_listener(self, q=None): if q: lst = [q] else: lst = self.connection_state_listener for l in lst: l.put("Connected" if self.connected else "NOT Connected") if not self.connected: l.put("#QUIT#") def inform_led_array_listener(self, q=None): if q: lst = [q] else: lst = self.led_array_listener for l in lst: if not self.connected: l.put("#QUIT#") else: l.put(self.html_led_array) def set_connected(self, connected): self.connected = connected self.inform_connection_state_listener() self.inform_led_array_listener()
self.end_headers() self.wfile.write(b"ok") def do_GET(self): self.request_handler() def do_POST(self): self.request_handler() # some sane defaults HOSTNAME = "localhost" if sys.argv[1]: PORT = int(sys.argv[1]) else: PORT = 8081 if __name__ == "__main__": test_server = ThreadingHTTPServer((HOSTNAME, PORT), TestHandler) print(f"Server started: http://{HOSTNAME}:{PORT}") try: test_server.serve_forever() except KeyboardInterrupt: pass test_server.server_close() print("Server stopped.")
config = json.loads(conf.read()) backends = process_config(config) context_dict = { "round_robin": RoundRobinContext, "ip_hash": IPHashContext, "least_connections": LeastConnectionsContext, } chosen_context_class = context_dict[config["context"]] context = chosen_context_class(backends) HandlerClass = partial(LoadBalancerHandler, context) health_check_thread = threading.Thread( target=health_checks, args=(backends,), daemon=True ) health_check_thread.start() load_balancer = ThreadingHTTPServer((HOSTNAME, PORT), HandlerClass) print(f"Server started: http://{HOSTNAME}:{PORT}") try: load_balancer.serve_forever() except KeyboardInterrupt: pass load_balancer.server_close() print("Server stopped.")
if len(ip_list) != 1: print("Select your IP") for i in range(len(ip_list)): print("{}. {}".format(i, ip_list[i])) select_ip = input('>>') while not select_ip.isnumeric() or not (0 <= int(select_ip) < len(ip_list)): print("Incorrect number, Try again") select_ip = input('>>') ip_list = ip_list[int(select_ip)] print() else: ip_list = ip_list[0] hostName = ip_list try: webServer = ThreadingHTTPServer((hostName, serverPort), MyServer) except: print("Couldn't open server. Check IP-address({}) and port number({})".format(hostName, serverPort)) sys.exit(4) print("Server started http://{}:{} <passward:{}>, use <Ctrl-C> to stop".format(hostName, serverPort, password)) try: webServer.serve_forever() except KeyboardInterrupt: pass webServer.server_close() print("Server stopped.")
class HttpService: logger = logging.getLogger(__name__) server_version = 'HttpService/1.0' def __init__(self, host: tuple, root: str, handler: BaseHTTPRequestHandler): '''建立網頁伺服器 Web Server''' self.__evts = { HttpEvents.STARTED: None, HttpEvents.STOPED: None, } self.__evt_exit = threading.Event() self.handler = handler self.handler.webRoot = root self.handler.logger = self.logger self.handler.server_version = self.server_version self.host = host self.__svr = ThreadingHTTPServer(self.host, self.handler) self.__svr.timeout = 0.5 self.__thd = threading.Thread(target=self.__httpWeb_Proc, daemon=True, args=(self.__svr, )) port = property(fget=lambda self: self.__svr.server_port, doc='服務監聽的通訊埠號') started = property(fget=lambda self: self.__thd.isAlive(), doc='是否執行中') # Thread Methods def __httpWeb_Proc(self, svr): '''執行 HTTP Web 等待連線的程序''' while not self.__evt_exit.wait(0.05): try: svr.handle_request() except Exception: pass if self.__evts[HttpEvents.STOPED]: self.__evts[HttpEvents.STOPED]() def __fakeLink(self): '''建立一個假連線(HEAD Request),用以強制 HTTPServer 跳離 handle_request() 阻塞''' if self.__svr is None: return try: url = f'http://{self.__svr.server_name}:{self.__svr.server_port}/fake.link' req = request.Request(url) req.get_method = lambda: 'HEAD' request.urlopen(req) except Exception: pass def start(self): self.__evt_exit.clear() self.__thd.start() while not self.__thd.isAlive(): time.sleep(0.1) if self.__evts[HttpEvents.STARTED]: self.__evts[HttpEvents.STARTED]() def stop(self): self.__evt_exit.set() self.__fakeLink() self.__thd.join() time.sleep(0.1) self.__svr.server_close() def bind(self, evt, callback): '''綁定回呼(callback)函式 傳入參數: `evt` `str` -- 回呼事件代碼;為避免錯誤,建議使用 *WorkerEvents* 列舉值 `callback` `def` -- 回呼(callback)函式 引發錯誤: `KeyError` -- 回呼事件代碼錯誤 `TypeError` -- 型別錯誤,必須為可呼叫執行的函式 ''' if evt not in self.__evts: raise KeyError(f'Event Key(evt):"{evt}" not found!') if callback is not None and not callable(callback): raise TypeError('"callback" not define or not a function!') self.__evts[evt] = callback