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
