def main(port, brain_wallet, db):
global DEFAULT_BRAIN
global DB
DEFAULT_BRAIN = brain_wallet
DB = db
ip = ''
http.server(DB, port, page1, home)
def start(self, port=DEFAULT_PORT, blocking=True):
if self._httpd:
self.open()
return
if not port: #None or 0
port = random.randint(50080, 59080)
self.port = port
self.init = True
#http.server.SimpleHTTPRequestHandler
#ViewerHandler
#handler = ViewerHandler
handler = HandlerFactory(self.parser)
#http.socketserver.TCPServer
#http.server.HTTPServer
#ThreadedHTTPServer
server = ThreadedHTTPServer
address = ('localhost', port)
self._httpd = server(address, handler)
if blocking:
try:
self._serve()
except KeyboardInterrupt:
pass
#finally: #external
# self.stop()
else:
self._thread = threading.Thread(target=self._serve)
self._thread.daemon = True
self._thread.start()
def run(self):
server = http.server.ThreadingHTTPServer
handler = self.HttpRequestHandler
port = 5151
with server(("", port), handler) as httpd:
httpd.serve_forever()
def send_head(self):
i = io.BytesIO()
if self.path[:19] == "/cgi/chat_server.py":
tmp = server(self.path[9:])
self.send_response(tmp[0])
data = tmp[1]
self.send_header("Pragma", "No-cache")
self.send_header("Cache-Control", "no-cache")
i.write(bytes(data.encode("gb2312"))) # 在中国貌似浏览器都用的gbk编码 这是微软的锅
else:
path = self.translate_path(
self.path if self.path != '/' else "/index.html")
try:
f = open(path, 'rb')
self.send_response(200)
if len(self.path) < 2 or ".html" in self.path:
self.send_header("Content-type", "text/html")
elif ".css" in self.path:
self.send_header("Content-type", "text/css")
data = f.read()
i.write(data)
except OSError:
self.send_error(404, self.path + "File not found.\n")
return None
i.seek(0) # 移动光标至初始
return i
def run(server=Server.HTTPServer, handler=EchoServer):
httpd = server((listen['ip'], listen['port']), handler)
try:
httpd.serve_forever()
except KeyboardInterrupt:
pass
httpd.server_close()
def run(self):
server = BaseHTTPServer.HTTPServer
bind_to = ('127.0.0.1', 8091)
reqhandler = Handler
httpd = server(bind_to, reqhandler)
self.ready.set()
for i in range(self.numtests):
httpd.handle_request()
def start_server(self, func):
myHandler.func = func
address = (self.host, self.port)
self.server = server(address, myHandler)
print('Started httpserver on port %d' % self.port)
self.server.serve_forever()
host, port = self.server.socket.getsockname()[:2]
print(host)
def web_server(port):
server = http.server.HTTPServer
handler = CGIHTTPServer.CGIHTTPRequestHandler #RequestsHandler
server_address = ("", port)
handler.cgi_directories = ["/cgi-bin", ]
httpd = server(server_address, handler)
print(f'Starting web server with CGI support on port: {port}')
httpd.serve_forever()
def web_server(port):
server = http.server.HTTPServer
handler = http.server.CGIHTTPRequestHandler
server_address = ("",port)
handler.cgi_directories = ["/cgi-bin" ]
httpd = server(server_address,handler)
print("Starting web server with CGI support on port: {!s} ...".format(port))
httpd.serve_forever()
def run(self):
global area
area.type = 'VIEW_3D'
server = http.server.HTTPServer
self.httpd = server(self.server_address, myHandler)
global timeInit
timeInit = time.process_time()
bpy.context.scene.frame_set(0)
self.httpd.serve_forever()
def main_monitor(port, vehicle, lock):
print("run_monitor")
server_address = ("", port)
server = http.server.HTTPServer
handler = S
handler.vehicle = vehicle
handler.lock = lock
print("Serveur actif sur le port :", port)
httpd = server(server_address, handler)
httpd.serve_forever()
def start_server():
server, handler = http.server.HTTPServer, SilentServer
httpd = server(("", port), handler)
sa = httpd.socket.getsockname()
print("Serving HTTP on", sa[0], "port", sa[1], "...")
print("Type Ctrl-C to exit.")
try:
httpd.serve_forever()
finally:
httpd.server_close()
def start_server():
server, handler = http.server.HTTPServer, SilentServer
httpd = server(("", port), handler)
sa = httpd.socket.getsockname()
print("Serving HTTP on", sa[0], "port", sa[1], "...")
print("Type Ctrl-C to exit.")
try:
httpd.serve_forever()
finally:
httpd.server_close()
def run(server=http.server.HTTPServer, handler=http.server.BaseHTTPRequestHandler): address = (IP, PORT) httpd = server(address, handler) print(time.asctime(), "Server starts - %s:%s" % address) try: httpd.serve_forever() except KeyboardInterrupt: pass httpd.server_close() print(time.asctime(), "Server stops - %s:%s" % address)
def main_monitor(port, vehicle, sensors_lock, on_off_lock):
server_address = ("", port)
server = http.server.HTTPServer
handler = S
print("Serveur actif sur le port :", port)
httpd = server(server_address, handler)
handler.vehicle = vehicle
handler.sensors_lock = sensors_lock
handler.on_off_lock = on_off_lock
httpd.serve_forever()
def lauchServer(PORT=8888, IP=""):
server_address = (IP, PORT)
server = http.server.HTTPServer
handler = http.server.CGIHTTPRequestHandler
handler.cgi_directories = ["//"]
print("Serveur actif sur le port :", PORT)
httpd = server(server_address, handler)
httpd.serve_forever()
def start_server():
server, handler = http.server.HTTPServer, SilentServer
httpd = server(('', 8000), handler)
sa = httpd.socket.getsockname()
print('Serving HTTP on', sa[0], 'port', sa[1], '...')
print('Type Ctrl-C to exit.')
try:
httpd.serve_forever()
finally:
httpd.server_close()
def run(self):
""" Démarrage du service web """
server_address = ("", Constantes.httpPort)
server = http.server.HTTPServer
handler = http.server.CGIHTTPRequestHandler
handler.cgi_directories = ["/"]
affichage = "Server up on port : " + str(Constantes.httpPort)
print(affichage)
httpd = server(server_address, handler)
httpd.serve_forever()
def run(server=http.server.HTTPServer,
handler=http.server.BaseHTTPRequestHandler):
address = (IP, PORT)
httpd = server(address, handler)
print(time.asctime(), "Server starts - %s:%s" % address)
try:
httpd.serve_forever()
except KeyboardInterrupt:
pass
httpd.server_close()
print(time.asctime(), "Server stops - %s:%s" % address)
def runserver(server, handler, protocol="HTTP/1.0", port=80, bind=""):
server_address = (bind, port)
handler.protocol_version = protocol
httpd = server(server_address, handler)
sa = httpd.socket.getsockname()
sever_message = "Serving HTTP on {host} port {port}"
try:
httpd.serve_forever()
except KeyboardInterrupt:
print('\nKeyboard interrupt recieved')
sys.exit(0)
def main(args):
build_dir = args.build_dir
port = args.port
httpd = server(port)
os.chdir(build_dir)
print("serving from {0} at localhost:".format(build_dir) + str(port))
try:
httpd.serve_forever()
except KeyboardInterrupt:
print("\n...shutting down http server")
httpd.shutdown()
sys.exit()
def main(args):
build_dir = pathlib.Path(args.build_dir).resolve()
port = args.port
httpd = server(port)
os.chdir(build_dir)
print(f"serving from {build_dir} at localhost:{port}")
try:
httpd.serve_forever()
except KeyboardInterrupt:
print("\n...shutting down http server")
httpd.shutdown()
sys.exit()
def server_site(site, port, watching, renderer, render_kwargs):
site_dir = config.sites[site]['path']
msg_file = render_kwargs['msg_file']
output_dirname = render_kwargs['output_dirname']
output_dir = os.path.join(site_dir, output_dirname)
current_dir = os.getcwd()
# start watch thread(optional)
watch_thread = None
if watching:
regex = re.compile(r'(\.md$|{})'.format(output_dirname))
watch_thread = WatchThread(site_dir, output_dir, renderer,
render_kwargs, regex, msg_file)
watch_thread.start()
# start server in main thread, so that KeyboardInterrupt can be captured
try:
server(current_dir, output_dir, port, msg_file)
except KeyboardInterrupt:
# elegant termination watcher thread
if watch_thread is not None:
watch_thread.stop()
watch_thread.join()
message('Server', 'Bye, Bye!', msg_file)
def main():
try:
args = parser().parse_args()
project_path = args.path[0]
except IndexError:
parser.print_help()
sys.exit(1)
print(args)
if args.serve:
server()
elif args.build:
builder()
elif args.new:
vite.create_project(project_path)
else:
parser().print_help()
sys.exit(1)
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
def __init__(self, robot, webport=8000, name=DEFAULT_NAME, auto=True):
"""
Initialisation de la tâche.
Un serveur Web est instancié.
:param robot: Robot propriétaire de de la tâche.
:param webport: Port réseau utilisé par le serveur Web (8000 par défaut)
:param name: Nom de la tâche ("RobotWeb" par défaut).
:param auto: Indicateur si la tâche est automaitquement démarrée.
"""
super().__init__(robot, name=name, auto=auto)
server = http.server.HTTPServer
self._httpd = server(("", webport), self._getHttpHandler())
def runServer(q):
global myQueue
myQueue = q
PORT = 8888
server_address = ("", PORT)
server = http.server.HTTPServer
handler = MyHandler
handler.cgi_directories = ["/"]
print("\t\tServeur actif sur le port :", PORT)
httpd = server(server_address, handler)
httpd.serve_forever()
def __init__(self):
Thread.__init__(self)
global httpd
import http.server
PORT = 8888
server_address = ("", PORT)
server = http.server.HTTPServer
handler = http.server.CGIHTTPRequestHandler
handler.cgi_directories = ["/cgi"]
httpd = server(server_address, handler)
def run(server_class=HTTPServer, handler_class=S, addr="localhost", port=7000, allData=None):
server_address = ("", port)
server = http.server.HTTPServer
handler = S#http.server.CGIHTTPRequestHandler
handler.cgi_directories = ["/index.html"]
handler.allData = allData
print("Serveur actif sur le port :", port)
httpd = server(server_address, handler)
print("Before")
thread1 = threading.Thread(target = httpd.serve_forever)
thread1.start()
def httpServerMain(self):
server = http.server.HTTPServer
# use handler = http.server.SimpleHTTPRequestHandler to get http logs
handler = quietServer
print("Viewer actif sur le port :", self.port)
web_dir = os.path.join(os.path.dirname(__file__), 'res/html_root')
os.chdir(web_dir)
cgitb.enable()
server_address = ("", self.port)
httpd = server(server_address, handler)
httpd.serve_forever()
def run(handler=RequestHandler,port=80,apps=[App],
server=socketserver.ThreadingTCPServer, address_family=socket.AF_INET):
server.address_family=address_family
import Karrigell.check_apps
Karrigell.check_apps.check(apps)
handler.apps = apps
handler.alias = {}
for app in apps :
root_url = app.root_url.lstrip('/')
for host in app.hosts :
handler.alias[(host, root_url)] = app
s=server(('',port),handler)
print("%s %s running on port %s (%s)" %(handler.name,version,port,
{socket.AF_INET : "IPV4", socket.AF_INET6 : "IPV6"}[address_family]))
s.serve_forever()
def web_server(port):
server = http.server.HTTPServer
# Comment out the above line and uncomment the below for Python 2.7.x.
#server = BaseHTTPServer.HTTPServer
handler = http.server.CGIHTTPRequestHandler #RequestsHandler
# Comment out the above line and uncomment the below for Python 2.7.x.
#handler = CGIHTTPServer.CGIHTTPRequestHandler #RequestsHandler
server_address = ("", port)
handler.cgi_directories = [
"/cgi-bin",
]
httpd = server(server_address, handler)
print("Starting web server with CGI support on port: %s ..." % port)
httpd.serve_forever()
def main():
parser = argparse.ArgumentParser(description='HTTP Server for G2D3')
parser.add_argument('--bind', '-b', default='', metavar='ADDRESS',
help='Specify alternate bind address '
'[default: all interfaces]')
parser.add_argument('port', action='store',
default=8000, type=int,
nargs='?',
help='Specify alternate port [default: 8000]')
args = parser.parse_args()
handler = G2D3HTTPRequestHandler
server = http.server.HTTPServer
server_address = (args.bind, args.port)
httpd = server(server_address, handler)
print('G2D3Server serving HTTP on',args.bind,'port',args.port,'...')
httpd.serve_forever()
#python3 -m server.py
import http.server
PORT = 8888
server_address = ("", PORT)
server = http.server.HTTPServer
handler = http.server.CGIHTTPRequestHandler
handler.cgi_directories = ["./"]
print("Serveur actif sur le port :", PORT)
httpd = server(server_address, handler)
httpd.serve_forever()
btn.pack()
screen.geometry("800x900")
out = output(txt2)
sys.stdout = out
#####sys.stderr=out
sys.stdin = ainput(txt2)
screen.bind("<F5>", run)
import glob
with open("_extension.py") as ext:
exec(ext.read())
for x in glob.glob("_*.py"):
with open(x) as ext:
exec(ext.read())
import socket
# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), serverport))
built = "starting"
# become a server socket
serversocket.listen(5)
x = server()
x.start()
editmenu.add_command(label="archive code from other server(running idle)",
command=doclient)
while True:
built = txt.get('1.0', END)
screen.update_idletasks()
screen.update()
PORT = 8002
class HTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
def do_GET(self):
if self.path == "/" or self.path == "/index.html":
self.path = "/build/index.html"
super().do_GET()
def end_headers(self):
self.send_header('Access-Control-Allow-Origin', '*')
self.send_header('Access-Control-Allow-Methods', 'GET, POST')
http.server.SimpleHTTPRequestHandler.end_headers(self)
def server(s_port):
return socketserver.TCPServer(('', s_port), HTTPRequestHandler)
if __name__ == "__main__":
port = PORT
httpd = server(port)
try:
os.chdir('.')
print("\Starting server at 127.0.0.1:" + str(port))
httpd.serve_forever()
except KeyboardInterrupt:
print("\n...shutting down http server")
httpd.shutdown()
sys.exit()
def main(port, brain_wallet, db):
global DB
DB = db
ip = ''
http.server(DB, port, page1, home)
#!/usr/bin/env python3
# above 'she-bang' line makes the script executable from command line
""" A Simple Web Server
Run with ./simpleServer.py
Make sure all cgi scripts are executable
for single script:
chmod +x simpleServer.py
or for a whole directory:
chmod -r +x cgi-bin/
"""
import http.server # import http.server module
import cgitb; cgitb.enable() # import and enable cgitb module for exception handling
PORT = 8000 # specifies the port number to accept connections on
server = http.server.HTTPServer # provides simple web server
handler = http.server.CGIHTTPRequestHandler # provides request handler
server_address = ("", PORT) # specify server directory and port number
handler.cgi_directories = ["/","/cgi-bin","/htbin"] # where CGI scripts will reside in relation to the `server' directory
print("Starting server...") # outputs a message
httpd = server(server_address, handler) # creates the server, passing it the server address and port number, as well as the CGI handler (httpd stands for HTTP Daemon)
print("serving at port", PORT) # outputs a message
httpd.serve_forever() # puts program in infinite loop so that the server can `serve_forever'
import sys
import codecs
sys.stdout = codecs.getwriter("utf-8")(sys.stdout.detach())
host = ''
port = ****
address = (host, port)
server = http.server.HTTPServer
handler = http.server.CGIHTTPRequestHandler
handler.cgi_directories = ["/"]
httpd = server(address, handler)
print (f"Server running on the port {port}")
httpd.serve_forever()
'''
import http.server
import socketserver
host = ''
port = 80
address = ('', port)
handler = http.server.SimpleHTTPRequestHandler
import http
#Create an HTTP server to handle responses */
http.server(request, response)
response.writeHead(200, {"Content-Type": "text/plain"})
response.write("Hello World")
response.end()
respose.listen(8888)
def cgi_server(cgi_directory):
server = http.server.HTTPServer
handler = http.server.CGIHTTPRequestHandler
server_address = ("", 8000)
handler.cgi_directories = [cgi_directory]
return server(server_address, handler)
def main():
if len(sys.argv) > 1:
port = int(sys.argv[1])
server(("", port))
else:
client()
data = []
while True:
line = self.rfile.readline()
line = line.rstrip()
length = int(line, 16)
if length != 0:
data.append(self.rfile.read(length))
self.rfile.read(2) # ignore CRLF
if length == 0:
break
data = b"".join(data)
self.wfile.write(data)
else:
self._404()
def server(ready, host, port):
server_address = (host, port)
httpd = HTTPServer(server_address, Handler)
ready.set()
httpd.serve_forever()
if __name__ == "__main__":
ready = threading.Event()
srv = threading.Thread(target=lambda: server(ready, "", 8090))
srv.daemon = True
srv.start()
ready.wait()
sys.exit(subprocess.call(sys.argv[1:], stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr))
import http.server
server = http.server.HTTPServer
handler = http.server.SimpleHTTPRequestHandler
httpd = server(('', 80), handler)
httpd.serve_forever()
#!/usr/bin/python
import http.server
import cgitb; cgitb.enable() ## This line enables CGI error reporting
server = http.server.HTTPServer
handler = http.server.CGIHTTPRequestHandler
server_address = ("", 8000)
handler.cgi_directories = ["/cgi"]
httpd = server(server_address, handler)
httpd.serve_forever()
