def start(port_number):
'''Start server running at port_number. If configuration file value
FIRST_PAGE is an actual file then the server will automatically serve that
page, otherwise, the server will sleep for a second and then serve the
page assumed to be a CGI script.'''
from http.server import HTTPServer, CGIHTTPRequestHandler
import cgitb
import subprocess
import webbrowser
create_read_me_file(port_number)
###########################################################################
# Browse to FIRST_PAGE. Unscalable past 1 due to likely port # collision.
###########################################################################
if os.path.isfile(FIRST_PAGE):
webbrowser.open('file://' + os.path.realpath(FIRST_PAGE))
else:
# Delayed browse of page served by this script
webcommand = 'sleep 1 && python -m webbrowser "http://localhost:'
webcommand += str(port_number) + '/' + FIRST_PAGE + '"'
proc = subprocess.Popen(webcommand, shell=True)
print('Delayed browse command pid =', str(proc.pid))
cgi_handler = CGIHTTPRequestHandler
cgi_handler.cgi_directories = ['/']
cgitb.enable()
# TODO: detect/prevent reuse of port_number in case of 2 dirsites...
httpd = HTTPServer(("", port_number), cgi_handler)
print("Serving at port", port_number)
httpd.serve_forever()
def __init__(self, RequestHandlerClass=ProxyRequestHandler, **kwargs):
# Save off proxy specific options
self.target_host = kwargs.pop('target_host', None)
self.target_port = kwargs.pop('target_port', None)
self.wrap_cmd = kwargs.pop('wrap_cmd', None)
self.wrap_mode = kwargs.pop('wrap_mode', None)
self.unix_target = kwargs.pop('unix_target', None)
self.ssl_target = kwargs.pop('ssl_target', None)
self.target_cfg = kwargs.pop('target_cfg', None)
self.daemon = False
self.target_cfg = None
# Server configuration
listen_host = kwargs.pop('listen_host', '')
listen_port = kwargs.pop('listen_port', None)
web = kwargs.pop('web', '')
# Configuration affecting base request handler
self.only_upgrade = not web
self.verbose = kwargs.pop('verbose', False)
record = kwargs.pop('record', '')
if record:
self.record = os.path.abspath(record)
self.run_once = kwargs.pop('run_once', False)
self.handler_id = 0
for arg in kwargs.keys():
print("warning: option %s ignored when using --libserver" % arg)
if web:
os.chdir(web)
HTTPServer.__init__(self, (listen_host, listen_port),
RequestHandlerClass)
class HTTPWalletNotifyHandlerBase:
def __init__(self, transaction_updater, ip, port):
self.transaction_updater = transaction_updater
self.running = True
self.ip = ip
self.port = port
self.ready = False
server_address = (self.ip, self.port)
try:
self.httpd = HTTPServer(server_address, WalletNotifyRequestHandler)
self.httpd.transaction_updater = transaction_updater
except OSError as e:
raise RuntimeError("Could not start cryptoassets HTTP walletnotify notifiaction server at {}:{}".format(self.ip, self.port)) from e
def run(self):
self.running = True
self.ready = True
self.httpd.serve_forever()
self.running = False
def stop(self):
if self.httpd:
logger.info("Shutting down HTTP walletnofify server %s", self)
self.httpd.shutdown()
self.httpd = None
def main(wait):
try:
server = HTTPServer(('', 8080), RequestHandler)
print('Test server running...')
server.serve_forever()
except KeyboardInterrupt:
server.socket.close()
def start_listening(bot=None, loop=None, name="", port=8000, certfile=None, webhookReceiver=BaseHTTPRequestHandler, friendlyName="UNKNOWN"):
if loop:
asyncio.set_event_loop(loop)
if bot:
webhookReceiver._bot = bot
try:
httpd = HTTPServer((name, port), webhookReceiver)
httpd.socket = ssl.wrap_socket(
httpd.socket,
certfile=certfile,
server_side=True)
sa = httpd.socket.getsockname()
message = "sink: {} : {}:{}...".format(friendlyName, sa[0], sa[1])
print(message)
httpd.serve_forever()
except OSError as e:
message = "SINK: {} : {}:{} : {}".format(friendlyName, name, port, e)
print(message)
logging.error(message)
logging.exception(e)
try:
httpd.socket.close()
except Exception as e:
pass
except KeyboardInterrupt:
httpd.socket.close()
class PasswordProtectedSiteTestCase(unittest.TestCase):
def setUp(self):
self.server = HTTPServer((support.HOST, 0), RobotHandler)
self.t = threading.Thread(
name='HTTPServer serving',
target=self.server.serve_forever,
# Short poll interval to make the test finish quickly.
# Time between requests is short enough that we won't wake
# up spuriously too many times.
kwargs={'poll_interval':0.01})
self.t.daemon = True # In case this function raises.
self.t.start()
def tearDown(self):
self.server.shutdown()
self.t.join()
self.server.server_close()
@support.reap_threads
def testPasswordProtectedSite(self):
addr = self.server.server_address
url = 'http://' + support.HOST + ':' + str(addr[1])
robots_url = url + "/robots.txt"
parser = urllib.robotparser.RobotFileParser()
parser.set_url(url)
parser.read()
self.assertFalse(parser.can_fetch("*", robots_url))
def main():
certfile = write_cert()
httpd = HTTPServer(('127.0.0.1', PORT), LearningHTTPRequestHandler)
httpd.socket = ssl.wrap_socket(httpd.socket, certfile=certfile, server_side=True)
print('Ready for Python code on port %d...' % PORT)
print('Press Ctrl + C to exit...')
httpd.serve_forever()
def __init__(self, server_address, request_handler_class, logger=None):
"""
Proxy constructor
:param server_address: The server address
:param request_handler_class: The request handler class
:param logger: An optional logger, in case of ignored error
"""
# Determine the address family
addr_info = socket.getaddrinfo(server_address[0], server_address[1],
0, 0, socket.SOL_TCP)
# Change the address family before the socket is created
# Get the family of the first possibility
self.address_family = addr_info[0][0]
# Set up the server, socket, ... but do not bind immediately
HTTPServer.__init__(self, server_address, request_handler_class, False)
if self.address_family == socket.AF_INET6:
# Explicitly ask to be accessible both by IPv4 and IPv6
try:
pelix.ipv6utils.set_double_stack(self.socket)
except AttributeError as ex:
if logger is not None:
logger.exception("System misses IPv6 constant: %s", ex)
except socket.error as ex:
if logger is not None:
logger.exception("Error setting up IPv6 double stack: %s",
ex)
# Bind & accept
self.server_bind()
self.server_activate()
def serve_presentation(args):
# XXX Bit of a hack, clean this up, I check for this twice, also in the template.
if args.template and args.template not in ('simple', 'default'):
args.template = os.path.abspath(args.template)
if args.targetdir:
# Generate the presentation
generate(args)
else:
# Server mode. Start a server that serves a temporary directory.
with TemporaryDirectory() as targetdir:
args.targetdir = targetdir
args.presentation = os.path.abspath(args.presentation)
# Set up watchdog to regenerate presentation if saved.
event = threading.Event()
event.set()
thread = threading.Thread(target=generate_and_observe, args=(args, event))
try:
# Serve presentation
if ':' in args.port:
bind, port = args.port.split(':')
else:
bind, port = '0.0.0.0', args.port
port = int(port)
# First create the server. This checks that we can connect to
# the port we want to.
os.chdir(targetdir)
server = HTTPServer((bind, port), SimpleHTTPRequestHandler)
print("Serving HTTP on", bind, "port", port, "...")
try:
# Now generate the presentation
thread.start()
try:
# All is good, start the server
server.serve_forever()
except KeyboardInterrupt:
print("\nKeyboard interrupt received, exiting.")
finally:
# Server exited
server.server_close()
finally:
# Stop the generation thread
event.clear()
# Wait for it to end
thread.join()
except PermissionError:
print("Can't bind to port %s:%s: No permission" % (bind, port))
except OSError as e:
if e.errno == 98:
print("Can't bind to port %s:%s: port already in use" % (bind, port))
else:
raise
def start(port=3636):
global __isstart
if __isstart:
return
httpd = HTTPServer(("127.0.0.1", port), MyRequestHandler)
httpd.serve_forever() # 设置一直监听并接收请求
__isstart = True
def run():
address = ("", 8080)
httpd = HTTPServer(address, RequestHandler)
try:
httpd.serve_forever()
except KeyboardInterrupt:
httpd.server_close()
def main():
port = arguments.port or 5454
ip = arguments.ip or '127.0.0.1'
print('======================= Ferrymang =======================')
print('Ferrymang is now listening on ' + ip + ':' + str(port) + '...')
httpd = HTTPServer((ip, port), RequestHandler)
httpd.serve_forever()
def http_setup():
global httpd
bind_address = ('localhost', 10451)
httpd = HTTPServer(bind_address, Handler)
httpd.timeout = 0
def __init__(self): if hasattr(config, 'disconnected') and config.disconnected: self._handlers = [] else: self._handlers = self._setup_handlers() from server.http_handler import Handler HTTPServer.__init__(self, (config.server_host, config.server_port), Handler, False)
def __init__(self, server_address, RequestHandlerClass, websocket_address, multiple_instance, enable_file_cache, update_interval, *userdata):
HTTPServer.__init__(self, server_address, RequestHandlerClass)
self.websocket_address = websocket_address
self.multiple_instance = multiple_instance
self.enable_file_cache = enable_file_cache
self.update_interval = update_interval
self.userdata = userdata
def start_listening(bot=None, loop=None, name="", port=8000, certfile=None, webhookReceiver=BaseHTTPRequestHandler, friendlyName="UNKNOWN"):
if loop:
asyncio.set_event_loop(loop)
if bot:
webhookReceiver._bot = bot
try:
httpd = HTTPServer((name, port), webhookReceiver)
httpd.socket = ssl.wrap_socket(
httpd.socket,
certfile=certfile,
server_side=True)
sa = httpd.socket.getsockname()
print(_("listener: {} : sink on {}, port {}...").format(friendlyName, sa[0], sa[1]))
httpd.serve_forever()
except IOError:
# do not run sink without https!
print(_("listener: {} : pem file possibly missing or broken (== '{}')").format(friendlyName, certfile))
httpd.socket.close()
except OSError as e:
# Could not connect to HTTPServer!
print(_("listener: {} : requested access could not be assigned. Is something else using that port? (== '{}:{}')").format(friendlyName, name, port))
except KeyboardInterrupt:
httpd.socket.close()
def rest_server():
server_address = ('', _REST_PORT)
httpd = HTTPServer(server_address, RESTHandler)
while True:
rlist = select.select([httpd.fileno()], [], [], _POLL_TMO)[0]
if httpd.fileno() in rlist:
httpd.handle_request()
def do_multiple(self, address, n_clients, n_requests):
Config()
handler = make_handler()
server = HTTPServer(address, handler)
try:
Thread(target=lambda: server.serve_forever(0.001)).start()
lock = Lock()
counter = [n_requests]
clients = [Client(address, lock, counter, index) for index in range(n_clients)]
start = time()
for client in clients: client.start()
while True:
sleep(0.1)
with lock:
if not counter[0]: break
duration = time() - start
handler.dump()
expected = 60 * n_requests / (120.0 * 0.9)
# check duration within 20% of expected
assert expected * 0.8 < duration < expected * 1.2, (duration, expected)
count = clients[0].count
# check requests distributed fairly across clients
for client in clients: assert count * 0.9 < client.count < count * 1.1, (client.count, count)
finally:
server.shutdown()
def run(port):
"""Run the server indefinitely."""
print('Server starting on port {}.'.format(port))
server_address = ('127.0.0.1', port)
httpd = HTTPServer(server_address, CustomHandler)
print('Server running on port {}.'.format(port))
httpd.serve_forever()
class TestHTTPRequestHandler(unittest.TestCase):
def setUp(self):
self._port = random.randint(8000, 9000)
def handler(*args, **kwargs):
return http_request_handler.HTTPRequestHandler(
_FakeMainHandler(), logging.getLogger(), *args, **kwargs)
self._server = HTTPServer(('localhost', self._port), handler)
self._thr = threading.Thread(target=self._server.serve_forever)
self._thr.start()
time.sleep(1)
def runTest(self):
d = {'key1': 'va中文1', 'key2': 'value2', 'key3': ['meow', 'wang']}
r = requests.post('http://localhost:%d' % self._port,
data=json.dumps(d),
headers={'content-type': 'application/json'})
self.assertEqual(r.status_code, 200)
d2 = json.loads(r.text)
self.assertEqual(d['key1'], d2['key1'])
self.assertEqual(d['key2'], d2['key2'])
self.assertEqual(d['key3'][0], d2['key3'][0])
self.assertEqual(d['key3'][1], d2['key3'][1])
def tearDown(self):
self._server.shutdown()
self._thr.join()
self._server.server_close()
def main():
address = 'localhost'
port = 1234
ipv6 = "n"
# set this to logging.DEBUG to see each request
#
logging.basicConfig(format='%(asctime)s %(name)s %(levelname)s + %(message)s', level=logging.INFO)
logging.debug('Parsing args...')
parser = argparse.ArgumentParser()
parser.add_argument("--address", help="default: " + address)
parser.add_argument("--port", help="default: " + str(port))
parser.add_argument("--is_ipv6", help="mandatory if parameter for --address is an IPv6 hostname, default: " + ipv6)
args = parser.parse_args()
if args.address:
address = str(args.address).replace('[','').replace(']','')
if args.port:
port = int(args.port)
if args.is_ipv6:
ipv6 = str(args.is_ipv6)
else:
if re.match (":", address):
ipv6 = "y"
if ipv6 == "y":
server = HTTPServerV6((address, port), MyHandler)
else:
server = HTTPServer((address, port), MyHandler)
logging.info('Starting ...')
server.serve_forever()
def server_close(self):
# Again, we want this to run in a thread, so we need to override
# close to clear the "active" flag, so that serve_forever() will
# terminate.
with self.active_lock:
HTTPServer.server_close(self)
self.active = False
def run():
# Server settings
# Choose port 8080, for port 80, which is normally used for a http server, you need root access
server_address = (config['ip'], config['port'])
httpd = HTTPServer(server_address, HTTPServer_RequestHandler)
print('Starting http server on {0}:{1}'.format(config['ip'],config['port']))
httpd.serve_forever()
def main(argv):
import getopt
import imp
def usage():
print('usage: %s [-h host] [-p port] [-n name] module.class' % argv[0])
return 100
try:
(opts, args) = getopt.getopt(argv[1:], 'h:p:n:')
except getopt.GetoptError:
return usage()
host = ''
port = 8080
name = 'WebApp'
for (k, v) in opts:
if k == '-h':
host = v
elif k == '-p':
port = int(v)
elif k == '-n':
name = v
if not args:
return usage()
path = args.pop(0)
module = imp.load_source('app', path)
WebAppHandler.APP_CLASS = getattr(module, name)
print('Listening %s:%d...' % (host, port))
httpd = HTTPServer((host, port), WebAppHandler)
httpd.serve_forever()
def main():
httpd = HTTPServer(("localhost", PORT), MyTCPHandler)
print("serving at port ", PORT)
try:
httpd.serve_forever()
except KeyboardInterrupt:
print("Goodbye!")
class HttpListener(object):
def __init__(self, host, port):
self._server_address = (host, port)
self.httpd = HTTPServer(self._server_address, RequestHandler)
def run(self):
self.httpd.serve_forever()
def __init__(
self,
server_address,
RequestHandlerClass,
websocket_address,
auth,
multiple_instance,
enable_file_cache,
update_interval,
websocket_timeout_timer_ms,
host_name,
pending_messages_queue_length,
title,
*userdata
):
HTTPServer.__init__(self, server_address, RequestHandlerClass)
self.websocket_address = websocket_address
self.auth = auth
self.multiple_instance = multiple_instance
self.enable_file_cache = enable_file_cache
self.update_interval = update_interval
self.websocket_timeout_timer_ms = websocket_timeout_timer_ms
self.host_name = host_name
self.pending_messages_queue_length = pending_messages_queue_length
self.title = title
self.userdata = userdata
def main(ip_addr, port, endpoint_class = server.SimpleHttpNotifyEndpoint, msg_type=u"XML", prefix=u"https://"):
#init logger
global logger
endpoint_class.access_log_file = "access_log.%s" % port
endpoint_class.msg_type = msg_type
log_file = "endpoint_log.%s" % port
logger = logging.getLogger()
file_handler = logging.handlers.RotatingFileHandler(log_file, maxBytes=100*1024*1024)
formatter = logging.Formatter('[%(asctime)s] [%(name)s] [%(levelname)s] [%(filename)s:%(lineno)d] [%(thread)d] %(message)s', '%Y-%m-%d %H:%M:%S')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.setLevel(logging.INFO)
tmpcertfile = "x509_public_certificate_checkhttp.pem"
tmpkeyfile = "rsa_private_key_checkhttp.pem"
open(tmpcertfile, 'w').write(CERTIFICATE)
open(tmpkeyfile, 'w').write(RSA_PRIVATE_KEY)
#start endpoint
addr_info = "Start Endpoint! Address: %s%s:%s" % (prefix, ip_addr, port)
print(addr_info)
try:
logger.info(addr_info)
httpd = HTTPServer((ip_addr, port), endpoint_class)
httpd.socket = ssl.wrap_socket(httpd.socket, keyfile=tmpkeyfile, certfile=tmpcertfile, server_side=True)
httpd.serve_forever()
#httpd = server.ThreadedHTTPServer(('', port), endpoint_class)
except KeyboardInterrupt:
print("Shutting down the simple notify endpoint!")
httpd.socket.close()
def __init__(self, server_address, services=[], RequestHandlerClass=SOAPRequestHandler):
'''server_address --
RequestHandlerClass --
'''
HTTPServer.__init__(self, server_address, RequestHandlerClass)
self._nodes = self.NodeTree()
list(map(lambda s: self.setNode(s), services))
def run():
print("starting server...")
server_address = ("127.0.0.1", 8081)
httpd = HTTPServer(server_address, TestHTTPServerRequestHandler)
print("running server...")
httpd.serve_forever()
self.send_error(500, 'Trigger command failed')
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument("-p",
"--port",
type=int,
default=18812,
help="Set port number, default is 18812")
parser.add_argument("-P",
"--http-port",
type=int,
default=8080,
dest='http_port',
help="Set http port number, default is 8080")
args = parser.parse_args()
if args.http_port < 1024 and os.geteuid() != 0:
sys.stderr.write('Port {} (< 1024) requires root privileges.\n'.format(
args.http_port))
sys.exit(-2)
msg_client = Client("http-server", port=args.port)
server = HTTPServer(("0.0.0.0", args.http_port), RequestHandler)
print("Run http server on port", args.http_port)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
sys.exit(0)
def main():
httpd = HTTPServer(('0.0.0.0', 443), DeepLabRequestHandler)
httpd.socket = ssl.wrap_socket(httpd.socket, certfile=CERTIFICATE_PATH, keyfile=KEY_PATH, server_side=True)
print("Serving DeepLab server...")
httpd.serve_forever()
logger.addHandler(handler)
def _set_response(self):
self.send_response(200)
self.end_headers()
self.logger.info('200 OK')
def _set_bad_response(self):
self.send_response(400)
self.end_headers()
self.logger.info('400 Bad Request')
def do_GET(self):
self._set_response()
def do_POST(self):
if self.header_name in self.headers:
self.logger.info('Headers: ' + str(self.headers))
if (re.match(self.regexp, self.headers[self.header_name]))\
and (self.MIN_LENGTH <= len(self.headers[self.header_name]) <= self.MAX_LENGTH):
self._set_response()
else:
self._set_bad_response()
else:
self._set_bad_response()
serv = HTTPServer(('localhost', 80), HttpProcessor)
serv.serve_forever()
data_len = ec2_socket.recv(4)
data_len = struct.unpack("<I",data_len)[0]
print("[+] Receiving Data size %s [+]" % data_len)
while len(data) < data_len:
data += ec2_socket.recv(data_len - len(data))
return data
def get_payload(arch,pipename):
send_data("arch={}".format(arch))
send_data("pipename={}".format(pipename))
send_data("block=500")
send_data("go")
payload = recv_data()
return base64.b64encode(payload)
def init_connection(host,port):
ec2_socket.connect((host,port))
print("[+] Connection to External C2 successful [+]")
try:
server = HTTPServer(('', port), get_handler)
print('[+] Started HTTP server on port %d [+]' % port)
server.serve_forever()
except KeyboardInterrupt:
print('^C received, shutting down the web server')
server.socket.close()
def run(self):
print("Starting HTTP server on port 5001...")
server_address = ('', 5001)
httpd = HTTPServer(server_address, MyHTTPHandler)
httpd.serve_forever()
first_number = '123456788'
second_number = '123456799'
class Handler(BaseHTTPRequestHandler):
def _set_headers(self,
length: str,
header: (str, str) = ("Content-type", "text/xml")):
self.send_response(200)
self.protocol_version = 'HTTP/1.1'
self.send_header(header[0], header[1])
self.send_header('Content-Length', length)
self.end_headers()
def do_GET(self):
data = find_me_or_follow_me(first_number,
second_number).encode('utf-8')
length = len(data)
self._set_headers(length=str(length))
self.wfile.write(data)
port = 8080
handler = Handler
httpd = HTTPServer(("", port), handler)
httpd.serve_forever()
def run(port):
print('Server starting on port {}.'.format(port))
server_address = ('127.0.0.1', port)
httpd = HTTPServer(server_address, CustomHandler)
print('Server running on port {}.'.format(port))
httpd.serve_forever()
from http.server import HTTPServer, BaseHTTPRequestHandler
count = 0
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
def do_GET(self):
global count
count += 1
self.send_response(200)
self.end_headers()
self.wfile.write(bytes(str(count), 'utf-8'))
server_address = ('localhost', 80)
httpd = HTTPServer(server_address, SimpleHTTPRequestHandler)
httpd.serve_forever()
# 2. Read the correct amount of request data.
# 3. Extract the "message" field from the request data.
#
# When you're done, run this server and test it from your browser using the
# Messageboard.html form. Then run the test.py script to check it.
from http.server import HTTPServer, BaseHTTPRequestHandler
from urllib.parse import parse_qs
class MessageHandler(BaseHTTPRequestHandler):
def do_POST(self):
# 1. How long was the message? (Use the Content-Length header.)
length = int(self.headers.get('Content-length', 0))
# 2. Read the correct amount of data from the request.
data = self.rfile.read(length).decode()
# 3. Extract the "message" field from the request data.
message = parse_qs(data)['message'][0]
# Send the "message" field back as the response.
self.send_response(200)
self.send_header('Content-type', 'text/plain; charset=utf-8')
self.end_headers()
self.wfile.write(message.encode())
if __name__ == '__main__':
server_address = ('', 8000)
httpd = HTTPServer(server_address, MessageHandler)
httpd.serve_forever()
base = __NOW_HANDLER_FILENAME.handler if (
'handler' in __now_variables) else __NOW_HANDLER_FILENAME.Handler
if not issubclass(base, BaseHTTPRequestHandler):
print('Handler must inherit from BaseHTTPRequestHandler')
print(
'See the docs https://zeit.co/docs/v2/deployments/official-builders/python-now-python'
)
exit(1)
print('using HTTP Handler')
from http.server import HTTPServer
from urllib.parse import unquote
import requests
import _thread
server = HTTPServer(('', 0), base)
port = server.server_address[1]
def now_handler(event, context):
_thread.start_new_thread(server.handle_request, ())
payload = json.loads(event['body'])
path = unquote(payload['path'])
headers = payload['headers']
method = payload['method']
encoding = payload.get('encoding')
body = payload.get('body')
if ((body is not None and len(body) > 0)
and (encoding is not None and encoding == 'base64')):
body = base64.b64decode(body)
try:
print('Discovering... delay=%ums' % u.discoverdelay)
ndevices = u.discover()
print(ndevices, 'device(s) detected')
# select an igd
u.selectigd()
# display information about the IGD and the internet connection
print('local ip address :', u.lanaddr)
externalipaddress = u.externalipaddress()
print('external ip address :', externalipaddress)
print(u.statusinfo(), u.connectiontype())
#instanciate a HTTPd object. The port is assigned by the system.
httpd = HTTPServer((u.lanaddr, 0), handler_class)
eport = httpd.server_port
# find a free port for the redirection
r = u.getspecificportmapping(eport, 'TCP')
while r != None and eport < 65536:
eport = eport + 1
r = u.getspecificportmapping(eport, 'TCP')
print('trying to redirect %s port %u TCP => %s port %u TCP' %
(externalipaddress, eport, u.lanaddr, httpd.server_port))
b = u.addportmapping(eport, 'TCP', u.lanaddr, httpd.server_port,
'UPnP IGD Tester port %u' % eport, '')
if b:
print('Success. Now waiting for some HTTP request on http://%s:%u' %
def __init__(self, port=0):
super().__init__()
self.path = ""
server_address = ('localhost', port)
self.httpd = HTTPServer(server_address, AuthenticationHandler) # partial(AuthenticationHandler, self))
self.port = self.httpd.server_port
class balenaPurpleHTTP(BaseHTTPRequestHandler):
def _set_headers(self):
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
def do_GET(self):
self._set_headers()
API_ROOT = 'https://www.purpleair.com/json'
id = 22079
response = requests.get(f'{API_ROOT}?show={id}')
print(response)
self.wfile.write(json.dumps(response[0]['results']).encode('UTF-8'))
#measurements = balenasense.sample()
#self.wfile.write(json.dumps(measurements[0]['fields']).encode('UTF-8'))
def do_HEAD(self):
self._set_headers()
# Start the server to answer requests for readings
balenapurpleair = balenaPurpleAir()
while True:
server_address = ('', 80)
httpd = HTTPServer(server_address, balenaPurpleHTTP)
print('Purple HTTP server running')
httpd.serve_forever()
def main():
host = ''
port = 8088
HTTPServer((host, port), HandleRequests).serve_forever()
def do_GET(self):
super().do_GET()
# self.parse_request()
# print('path:{}'.format(self.path)) # path:/index.html
# print('command:{}'.format(self.command)) # command:GET
# if self.path == '/login.html':
# super().do_GET()
# # list of headers
# # for header in self.headers:
# # print('header: {}'.format(header))
# if "Cookie" in self.headers:
# key, pdict = parse_header(self.headers['Cookie'])
# sid = 'none'
# if 'sid' in pdict:
# sid = pdict['sid']
# if isSession(sid):
# super().do_GET()
# return
# self.send_header("Location", 'login.html')
# self.end_headers()
# print('end')
Handler = httpServer
if __name__ == '__main__':
httpd = HTTPServer(("", PORT), Handler)
print("serving at port", PORT)
httpd.serve_forever()
#!/usr/bin/env python3 # by Honghe # Ported to Python 3 by Telmo "Trooper" ([email protected]) # # Original code from: # http://www.piware.de/2011/01/creating-an-https-server-in-python/ # https://gist.github.com/dergachev/7028596 # # To generate a certificate use: # openssl req -newkey rsa:4096 -nodes -keyout key.pem -x509 -days 365 -out cert.pem from http.server import HTTPServer, SimpleHTTPRequestHandler import ssl port = 4443 httpd = HTTPServer(('0.0.0.0', port), SimpleHTTPRequestHandler) httpd.socket = ssl.wrap_socket(httpd.socket, keyfile='key.pem', certfile="cert.pem", server_side=True) print("Server running on https://0.0.0.0:" + str(port)) httpd.serve_forever()
hostName = "0.0.0.0"
serverPort = 8080
class MyServer(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write(
bytes("<html><head><title>https://pythonbasics.org</title></head>",
"utf-8"))
self.wfile.write(bytes("<p>Request: %s</p>" % self.path, "utf-8"))
self.wfile.write(bytes("<body>", "utf-8"))
self.wfile.write(
bytes("<p>This is an example web server.</p>", "utf-8"))
self.wfile.write(bytes("</body></html>", "utf-8"))
if __name__ == "__main__":
webServer = HTTPServer((hostName, serverPort), MyServer)
print("Server started http://%s:%s" % (hostName, serverPort))
try:
webServer.serve_forever()
except KeyboardInterrupt:
pass
webServer.server_close()
print("Server stopped.")
from http.server import BaseHTTPRequestHandler, HTTPServer
class MyServer(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header('Content-type', 'application/octet-stream')
self.send_header('Content-Disposition',
'attachment; filename="firmware.zip"')
self.end_headers()
with open('firmware.zip', 'rb') as file:
self.wfile.write(file.read())
myServer = HTTPServer(('localhost', 80), MyServer)
myServer.serve_forever()
myServer.server_close()
class MyHandler(BaseHTTPRequestHandler):
def do_GET(self):
url_dict = urlparse(self.path) # parse URL string into dictionary
get_dict = parse_qs(
url_dict.query) # select query string from URL dictionary
self.send_response(200)
self.send_header('Content-Type', 'text/html;charset=utf-8')
self.send_header('X-XSS-Protection',
'0') # disables XSS protection in the browser
self.end_headers()
result = ''
if 'lookup' in get_dict:
lookup = get_dict['lookup'][0]
result = f'<h3>Search Results for {escape(lookup)}</h3>'
for user in users:
if user.lower().find(lookup.lower()) >= 0:
result += f'{user}<br>'
output = main_doc.format(result=result)
self.wfile.write(bytes(output, 'UTF-8'))
if __name__ == '__main__':
server = HTTPServer(('', 8081), MyHandler)
print("Starting web server on http://localhost:8081/")
server.serve_forever()
def run_path_planner(hostname, port, command_queue, room_config):
server = HTTPServer((hostname, port), PathPlanner)
server.commandQueue = command_queue
server.scene = scene_parser.parse(room_config)
server.serve_forever()
class HTTPHandler(BaseHTTPRequestHandler):
def do_HEAD(s):
s.send_response(200)
def do_GET(s):
global fake_bq_called
global fake_bq_header_found
fake_bq_called = True
fake_bq_header_found = any(
k for k in s.headers
if k == "X-KAGGLE-PROXY-DATA" and s.headers[k] == "test-key")
s.send_response(200)
httpd = HTTPServer((HOSTNAME, PORT), HTTPHandler)
threading.Thread(target=httpd.serve_forever).start()
client = bigquery.Client()
try:
for ds in client.list_datasets():
pass
except:
pass
httpd.shutdown()
assert fake_bq_called, "Fake server did not recieve a request from the BQ client."
assert fake_bq_header_found, "X-KAGGLE-PROXY-DATA header was missing from the BQ request."
print("bigquery proxy ok")
import shap
print("shap ok")
def main():
parser = argparse.ArgumentParser(description=(
'Poppy services launcher. Use it to quickly instantiate a ' +
'poppy creature with Snap!, an http server, or a remote robot.'),
epilog="""
Examples:
* poppy-services --snap poppy-torso
* poppy-services --snap --vrep poppy-humanoid""",
formatter_class=RawTextHelpFormatter)
parser.add_argument('creature',
type=str,
help='poppy creature name',
action='store',
nargs='?',
choices=installed_poppy_creatures.keys())
parser.add_argument('--dummy',
help='use a simulated dummy robot',
action='store_true')
parser.add_argument('--vrep',
help='use a V-REP simulated Poppy Creature',
action='store_true')
parser.add_argument(
'--poppy-simu',
help=
'start a simulated dummy robot and the HTTP API to connect to the viewer on simu.poppy-project.org',
action='store_true')
parser.add_argument('--snap',
help='start a Snap! robot server',
action='store_true')
parser.add_argument('--snap-port',
help='port used by the Snap! server',
default=6969,
type=int)
parser.add_argument('-nb',
'--no-browser',
help='avoid automatic start of Snap! in web browser',
action='store_true')
parser.add_argument('--http',
help='start a http robot server',
action='store_true')
parser.add_argument('--http-port',
help='port of HttpRobotServer, used for poppy-simu',
default=8080,
type=int)
parser.add_argument('--remote',
help='start a remote robot server',
action='store_true')
parser.add_argument('--ws',
help='start the websocket server',
action='store_true')
parser.add_argument('--ws-port',
help='port of Websocket Server',
default=9009,
type=int)
parser.add_argument('--disable-camera',
help='Start the robot without the camera.',
action='store_true')
parser.add_argument(
'-v',
'--verbose',
help=
'start services with verbose mode. There is 3 debug levels, add as "v" as debug level you want',
action='count')
parser.add_argument('-f',
'--log-file',
help='Log filename',
action='store')
nb_creatures = len(installed_poppy_creatures.keys())
if nb_creatures == 0:
print('No installed poppy creature were found!')
print('You should first install the python package '
'corresponding to your robot or check your python environment.')
sys.exit(1)
args = parser.parse_args()
# If no creature are specified and only one is installed
# We use it as default.
if args.creature is None:
if nb_creatures > 1:
parser.print_help()
sys.exit(1)
args.creature = installed_poppy_creatures.keys()[0]
print('No creature specified, use {}'.format(args.creature))
if args.log_file:
fh = logging.FileHandler(args.log_file)
fh.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
logging.getLogger('').addHandler(fh)
if args.verbose:
args.snap_quiet = False
args.http_quiet = False
args.ws_quiet = False
if args.verbose == 1:
lvl = logging.WARNING
elif args.verbose == 2:
lvl = logging.INFO
elif args.verbose > 2:
lvl = logging.DEBUG
if args.log_file is not None:
ch = logging.FileHandler(args.log_file)
else:
ch = logging.StreamHandler()
ch.setLevel(lvl)
formatter = logging.Formatter(
'%(name)-12s: %(levelname)-8s %(message)s')
ch.setFormatter(formatter)
logging.getLogger('').addHandler(ch)
if not any([
args.snap, args.http, args.remote, args.poppy_simu, args.ws,
args.dummy
]):
print('No service specified! See --help for details.')
sys.exit(1)
static_server_started = False
if args.snap and not args.no_browser:
snap_static_port = 8888
snap_static_server = HTTPServer(("0.0.0.0", snap_static_port),
SimpleHTTPRequestHandler)
os.chdir(os.path.join(os.path.dirname(__file__), "..", "snap"))
snap_static_server_process = Process(
target=snap_static_server.serve_forever, args=())
static_server_started = True
snap_static_server_process.start()
snap_url = 'http://127.0.0.1:{}/snap.html'.format(snap_static_port)
block_url = 'http://{}:{}/snap-blocks.xml'.format(
find_local_ip(), args.snap_port)
url = '{}#open:{}'.format(snap_url, block_url)
with closing(start_poppy_with_services(args)):
msg = ''
if args.dummy or args.poppy_simu:
msg += 'Simulated robot created! He is running on: ip={}'.format(
find_local_ip())
else:
msg += 'Robot instantiated! He is running on: ip={},'.format(
find_local_ip())
if args.disable_camera: msg += ' without camera access.'
else: msg += ' with camera access.'
if args.vrep: msg += ' With V-REP link.'
if args.snap or args.ws or args.http or args.poppy_simu:
msg += '\nServer started on:'
if args.http or args.poppy_simu:
msg += ' http_port={},'.format(args.http_port)
if args.snap: msg += ' Snap_port={},'.format(args.snap_port)
if args.ws: msg += ' ws_port={},'.format(args.ws_port)
msg = msg[0:-1] + '.'
print(msg)
sys.stdout.flush()
if static_server_started:
for browser_name in [
'chromium-browser', 'chromium', 'google-chrome', 'chrome',
'safari', 'midori', None
]:
try:
browser = webbrowser.get(browser_name)
browser.open(url, new=0, autoraise=True)
break
except Exception:
pass
# Just run4ever (until Ctrl-c...)
try:
while (True):
time.sleep(1000)
except KeyboardInterrupt:
print("Bye bye!")
if static_server_started:
snap_static_server_process.terminate()
snap_static_server_process.join()
self.wfile.write(b'\n')
def do_gettopics(self):
"""
return list of all topics in JSON format
"""
print('api access - gettopics!')
self.send_response(200)
self.send_header('Content-type', 'application/json')
self.end_headers()
l = scrape_list_of_topics()
j = json.dumps(l)
self.wfile.write(j.encode('utf8'))
if __name__ == "__main__":
setup_logging()
logging.info("%s %s starting up at %s." %
(PROG, VERSION, datetime.datetime.now(
datetime.timezone.utc).isoformat()))
httpd = HTTPServer(('', 8001), myHandler)
httpd.serve_forever()
# EXAMPLE:
topics = ['sys/burner_hours_run', 'non_existant_topic']
# todo: support wildcards like sys/temperatures/#
d = retrieve_data_for(topics, '2019-01-24T20000', '2019-01-29T000000')
for line in d:
print(line)
def start_server_cmd(directory, port=8000):
LOGGER.info("starting server at port=%s" % port)
server = HTTPServer(("", port), Handler)
server.formresponse = None
server.serve_forever()
""", 'application/javascript')
def do_GET(self):
code, content = self.dispatch(self.path)
self.send_response(code)
self.send_header('content-type', content.mime)
self.end_headers()
self.wfile.write(bytes(content.content, 'utf8'))
def dispatch(self, path) -> (HTTPStatus, Content):
if path == '/':
return HTTPStatus.OK, self.page_tpl.substitute(
content=self.content.substitute(path=path).content)
if path.startswith('/_/'):
return HTTPStatus.OK, self.page_tpl.substitute(content=path)
elif path == '/style.css':
return HTTPStatus.OK, self.style
elif path == '/script.js':
return HTTPStatus.OK, self.script
return HTTPStatus.NOT_FOUND, self.page_tpl.substitute(
content=self.not_found.substitute(path=path).content)
if __name__ == '__main__':
addr = ('localhost', 8888)
server = HTTPServer(addr, MyLittleJoomla)
print('Started at http://{}:{}'.format(addr[0], addr[1]))
server.serve_forever()
def __init__(self, inst):
global instances
instances = inst
serv = HTTPServer(('', 8080), MyRequestHandler)
serv.serve_forever()
def main():
print('webdir "%s", port %s' % (webdir, port))
os.chdir(webdir)
threading.Thread(target=launcher).start()
HTTPServer(('', port), CGIHTTPRequestHandler).serve_forever()
return
ret = None
try:
# parse the conversation id
id = self.path[len(uri):]
# perform the query
ret = chat.query(id)
except:
err = {"error": "%s" % sys.exc_info()[0], "trace": traceback.format_exc()}
ret = json.dumps(err)
# send back the history
self.wfile.write(bytes(ret, 'utf-8'))
# start the server by the above settings
chat_server = HTTPServer(('', port), WebServer)
print(chat.now(), "Server %d starts\n" % port)
try:
chat_server.serve_forever()
except KeyboardInterrupt:
pass
# cleaning up
chat_server.server_close()
print(chat.now(), "Server %d closed\n" % port)
chat = None
chat_server = None
def start_server(port):
http_server = HTTPServer((ipAddress, int(port)), ServerHTTP)
http_server.serve_forever()
cmd3 = _cmd3.split(' ')
print(cmd3)
ffmpeg1 = subprocess.Popen(cmd1, stdout=subprocess.PIPE, bufsize=10000)
flags = fcntl.fcntl(ffmpeg1.stdout, fcntl.F_GETFL)
fcntl.fcntl(ffmpeg1.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)
ffmpeg2 = subprocess.Popen(cmd2, stdin=ffmpeg1.stdout, stdout=subprocess.PIPE, bufsize=10000)
flags = fcntl.fcntl(ffmpeg2.stdout, fcntl.F_GETFL)
fcntl.fcntl(ffmpeg2.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)
ffmpeg3 = subprocess.Popen(cmd3, stdin=ffmpeg2.stdout, stdout=subprocess.PIPE)
flags = fcntl.fcntl(ffmpeg3.stdout, fcntl.F_GETFL)
fcntl.fcntl(ffmpeg3.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)
options = {
'hlsBase':'test',
'hlsListSize':5,
'hlsListInit':True,
'bufferListSize':5
}
_mp4frag = mp4frag(ffmpeg3.stdout, options)
_mp4frag.start()
host = ('0.0.0.0', 8888)
server = HTTPServer(host, Resquest)
print("Starting server, listen at: %s:%s" % host)
server.serve_forever()
_mp4frag.stop()
