def main():
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('port',
help='port number to listen on (by default 80)',
default=8080,
type=int,
nargs='?')
parser.add_argument('-4',
help="use IPv4",
action="store_false",
dest='use_ipv6')
parser.add_argument('-6',
help="use IPv6 (default)",
action="store_true",
dest='use_ipv6',
default=True)
args = parser.parse_args()
if args.use_ipv6:
ServerClass = HTTPServerV6
else:
ServerClass = HTTPServerV4
# BaseHTTPServer.test() expects just one positional argument
sys.argv[1:] = [args.port]
BaseHTTPServer.test(RequestHandler, ServerClass)
def start_VyperProxy(server_version=None,version=None):
global __server_version__, __version__
if (misc.isString(server_version)):
__server_version__ = server_version
if (misc.isString(version)):
__version__ = version
BaseHTTPServer.test(VyperProxy, ThreadingHTTPServer, protocol="HTTP/1.1")
def test():
try:
HandlerClass = ProxyHTTPRequestHandler
ServerClass = ThreadingHTTPServer
BaseHTTPServer.test(HandlerClass, ServerClass)
except:
print "sering exit!"
sys._exit(1)
def test(cloudify_manager_ip_address,
first_blueprint_id,
scnd_blueprint_id,
HandlerClass=SimpleHTTPRequestHandler,
ServerClass=BaseHTTPServer.HTTPServer):
# HandlerClass = SimpleHTTPRequestHandler(cloudify_manager_ip_address, first_blueprint_id, scnd_blueprint_id)
BaseHTTPServer.test(HandlerClass, ServerClass)
def test():
try:
HandlerClass = ProxyHTTPRequestHandler
ServerClass = ThreadingHTTPServer
BaseHTTPServer.test(HandlerClass, ServerClass)
except:
print "sering exit!"
sys._exit(1)
def main():
if APP_KEY == '' or APP_SECRET == '':
exit("You need to set your APP_KEY and APP_SECRET!")
if len(sys.argv) == 1:
print "usage: python web_example.py [PORT]"
port = sys.argv[1] if len(sys.argv) > 1 else "8000"
print "Browse to http://localhost:%s to try this app." % port
BaseHTTPServer.test(ExampleHandler, BaseHTTPServer.HTTPServer)
def main():
handler = CGIHTTPServer.CGIHTTPRequestHandler
handler.cgi_directories = ['/cgi-bin']
if sys.argv[1:]:
os.chdir(sys.argv[1])
sys.argv.pop(1)
BaseHTTPServer.test(HandlerClass=handler)
def main():
if APP_KEY == '' or APP_SECRET == '':
exit("You need to set your APP_KEY and APP_SECRET!")
if len(sys.argv) == 1:
print "usage: python web_example.py [PORT]"
port = sys.argv[1] if len(sys.argv) > 1 else "8000"
print "Browse to http://localhost:%s to try this app." % port
BaseHTTPServer.test(ExampleHandler, BaseHTTPServer.HTTPServer)
def test(HandlerClass=LFSHTTPRequestHandler,
ServerClass=BaseHTTPServer.HTTPServer):
orig_dir = os.getcwd()
os.chdir(os.path.join(os.path.dirname(__file__), 'htdocs'))
try:
BaseHTTPServer.test(HandlerClass, ServerClass)
finally:
os.chdir(orig_dir)
def test(HandlerClass=SimpleHTTPRequestHandler,
ServerClass=BaseHTTPServer.HTTPServer):
if sys.argv[1:]:
port = int(sys.argv[1])
else:
port = 8008
sys.argv.append('%s' % port)
url = 'http://%s:%s' % (get_ip_address(), port)
print "Starting simple server: %s" % url
try:
import pyqrcode
qr_url = pyqrcode.create(url)
print qr_url.terminal(quiet_zone=1)
except ImportError:
pass
BaseHTTPServer.test(HandlerClass, ServerClass)
def test(HandlerClass=SimpleHTTPRequestHandler,
ServerClass=BaseHTTPServer.HTTPServer):
"""Run the HTTP request handler class.
This runs an HTTP server on port 8000 (or the first command line
argument).
"""
parse_options()
server_address = ('0.0.0.0', SERVER_PORT)
SimpleHTTPRequestHandler.protocol_version = "HTTP/1.0"
httpd = BaseHTTPServer.HTTPServer(server_address, SimpleHTTPRequestHandler)
sa = httpd.socket.getsockname()
print("Serving HTTP on", sa[0], "port", sa[1], "...")
httpd.serve_forever()
BaseHTTPServer.test(HandlerClass, ServerClass)
def main():
parser = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('port', help='port number to listen on (by default 80)',
default=8080, type=int, nargs='?')
parser.add_argument('-4', help="use IPv4",
action="store_false", dest='use_ipv6')
parser.add_argument('-6', help="use IPv6 (default)",
action="store_true", dest='use_ipv6', default=True)
args = parser.parse_args()
if args.use_ipv6:
ServerClass = HTTPServerV6
else:
ServerClass = HTTPServerV4
# BaseHTTPServer.test() expects just one positional argument
sys.argv[1:] = [ args.port ]
BaseHTTPServer.test(RequestHandler, ServerClass)
def test(HandlerClass = SimpleHTTPRequestHandler,
ServerClass = BaseHTTPServer.HTTPServer):
"""Run the HTTP request handler class.
This runs an HTTP server on port 8000 (or the first command line
argument).
"""
parse_options()
server_address = ('127.0.0.1', SERVER_PORT)
SimpleHTTPRequestHandler.protocol_version = "HTTP/1.0"
httpd = BaseHTTPServer.HTTPServer(server_address, SimpleHTTPRequestHandler)
sa = httpd.socket.getsockname()
print "Serving HTTP on", sa[0], "port", sa[1], "..."
httpd.serve_forever()
BaseHTTPServer.test(HandlerClass, ServerClass)
def test(HandlerClass=SimpleHTTPServer.SimpleHTTPRequestHandler,
ServerClass=CoThreadingHTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
def main(HandlerClass = CaptchaHTTPServer,
ServerClass = BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
environ={"REQUEST_METHOD": "POST"}
)
env = {}
for item in form.list:
env[item.name] = item.value
for request_path, php_file in self.dynamics.items():
if self.path.startswith(request_path):
proc = subprocess.Popen(["php", php_file], env=env, stdout=subprocess.PIPE)
output = proc.communicate()[0]
print "Input: " + env.__str__()
print "Output: " + output
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", output.__len__())
self.end_headers()
self.wfile.write(output)
break
self.do_GET()
class ThreadingSimpleServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
pass
BaseHTTPServer.test(MyHandler, ThreadingSimpleServer)
#!/usr/bin/env python
import SimpleHTTPServer, BaseHTTPServer, os
os.chdir('../games')
try:
print "Server starting. Visit http://localhost:8000/ in your browser."
BaseHTTPServer.test(
SimpleHTTPServer.SimpleHTTPRequestHandler,
BaseHTTPServer.HTTPServer
)
except KeyboardInterrupt:
print
return True
return False
def getRefs(fname):
d = getDump()
out = []
for otherfile in d:
if 'links' in d[otherfile]:
if fname in d[otherfile]['links']:
out.append(otherfile)
return out
def scanDir():
dr = os.listdir(os.getcwd())
dr = [f for f in dr if os.path.isfile(f) and f.endswith('.md')]
s = False
for f in dr:
if scanFile(f):
s = True
if s:
saveDump()
if __name__=="__main__":
BaseHTTPServer.test(DirectoryHandler, BaseHTTPServer.HTTPServer)
def test(HandlerClass=ProxyHTTPRequestHandler, ServerClass=ThreadingHTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
def test(HandlerClass=mydavHandler, ServerClass=BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
import naglfar
import BaseHTTPServer
class HelloWorldHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
if self.path == "/":
self.send_response(200)
self.send_header("Content-type", "text/plain")
self.end_headers()
self.wfile.write("Hello, world")
else:
self.send_error(404)
if __name__ == "__main__":
class ScheduledHTTPServer(naglfar.ScheduledMixIn, BaseHTTPServer.HTTPServer):
pass
BaseHTTPServer.test(HelloWorldHandler, ScheduledHTTPServer)
#!/usr/bin/env python2
import BaseHTTPServer
from SimpleHTTPServer import SimpleHTTPRequestHandler
class CORSRequestHandler(SimpleHTTPRequestHandler):
def end_headers (self):
self.send_header('Access-Control-Allow-Origin', '*')
SimpleHTTPRequestHandler.end_headers(self)
if __name__ == '__main__':
BaseHTTPServer.test(CORSRequestHandler, BaseHTTPServer.HTTPServer)
def main(HandlerClass = HiScoresHandler, ServerClass = BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
def main(HandlerClass=MyHTTPRequestHandler,
ServerClass=BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
import BaseHTTPServer
import SimpleHTTPServer
import os
class MyHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
def do_GET(self):
path = self.translate_path(self.path)
if not os.path.exists(path):
self.path = '404.html'
SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
BaseHTTPServer.test(MyHandler, BaseHTTPServer.HTTPServer)
def main():
request_handler = SimpleHTTPServer.SimpleHTTPRequestHandler
request_handler.server_version = "acsc18{webheader_owngoal}"
BaseHTTPServer.test(HandlerClass=request_handler,
ServerClass=BaseHTTPServer.HTTPServer)
def test(HandlerClass = googleCacheHandler,
ServerClass = BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
#!/usr/bin/env python
import SimpleHTTPServer
import BaseHTTPServer
class CustomHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
def end_headers(self):
self.send_header('Content-Encoding', 'deflate')
SimpleHTTPServer.SimpleHTTPRequestHandler.end_headers(self)
if __name__ == '__main__':
BaseHTTPServer.test(HandlerClass=CustomHTTPRequestHandler,
ServerClass=BaseHTTPServer.HTTPServer,
protocol="HTTP/1.1")
def test(HandlerClass = ProxyHTTPRequestHandler,
ServerClass = ThreadingHTTPServer):
ProxyHTTPRequestHandler.basic_auth_handler.set_users({'jenny':'supersecret'})
ProxyHTTPRequestHandler.basic_auth_handler.set_realm('lugh.localdomain')
BaseHTTPServer.test(HandlerClass, ServerClass)
def test(HandlerClass=TestnetTestServerHandler,
ServerClass=BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
from SimpleHTTPServer import SimpleHTTPRequestHandler
import BaseHTTPServer
class HTTPRequestHandler(SimpleHTTPRequestHandler):
extensions_map = SimpleHTTPRequestHandler.extensions_map.copy()
extensions_map.update({
'.vcf': 'text/plain',
})
if __name__ == '__main__':
BaseHTTPServer.test(HTTPRequestHandler, BaseHTTPServer.HTTPServer)
def main(): BaseHTTPServer.test(MyRequestHandler)
#!/usr/bin/env python import sys import os import BaseHTTPServer from SimpleHTTPServer import SimpleHTTPRequestHandler HandlerClass = SimpleHTTPRequestHandler ServerClass = BaseHTTPServer.HTTPServer os.chdir(os.path.dirname(sys.argv[0]) + "/../static") BaseHTTPServer.test(HandlerClass, ServerClass)
#!/usr/bin/env python
import BaseHTTPServer
class EchoHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
response = '%s %s %s\n%s' % \
(self.command, self.path, self.request_version, self.headers)
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
self.wfile.write(response)
def do_POST(self):
self.do_GET()
self.wfile.write('\n')
length = int(self.headers.getheader('Content-Length'))
self.wfile.write(self.rfile.read(length))
BaseHTTPServer.test(EchoHTTPRequestHandler)
def main():
HANDLER_CLASS = DelayedRequestHandler
SERVER_CLASS = BaseHTTPServer.HTTPServer
BaseHTTPServer.test(HandlerClass=HANDLER_CLASS, ServerClass=SERVER_CLASS)
env = {}
for item in form.list:
env[item.name] = item.value
for request_path, php_file in self.dynamics.items():
if self.path.startswith(request_path):
proc = subprocess.Popen(["php", php_file],
env=env,
stdout=subprocess.PIPE)
output = proc.communicate()[0]
print "Input: " + env.__str__()
print "Output: " + output
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", output.__len__())
self.end_headers()
self.wfile.write(output)
break
self.do_GET()
class ThreadingSimpleServer(SocketServer.ThreadingMixIn,
BaseHTTPServer.HTTPServer):
pass
BaseHTTPServer.test(MyHandler, ThreadingSimpleServer)
else:
self.wfile.write('not authenticated')
def generate_response(self, method, auth=None):
if auth is not None:
userpass = base64.decodestring(auth[6:])
response = {
"rootNull": None,
"data": {
"firstKey":
None,
"lookupArray": [{
"path": self.path,
"auth_header": userpass,
"method": method,
"request": self.post_request_counter
}, {
"path": self.path,
"request": self.post_request_counter
}, {}]
}
}
else:
response = {"serviceName": "sp-api-request-enrichment"}
return json.dumps(response)
if __name__ == '__main__':
print("Starting mock webserver")
BaseHTTPServer.test(AuthHandler, BaseHTTPServer.HTTPServer)
# TODO(njt): implement
def write_file(self, file):
with open(file, 'r') as fp:
data = fp.read()
if data:
self.wfile.write(data)
def do_GET(self):
"""Serve a GET request."""
match = re.match('/tree/[01]*', self.path)
if match:
tree_data = subprocess.check_output(
[self.treecat, self.src_dir,
match.group(1)])
self.write_file(tree_data)
if self.path == '/args':
self.write_file('-m 36 -t 6 -i 36 -s 3000000 -a 5.1')
if self.path == '/words':
self.write_file(self.words_file)
if self.path == '/powers':
self.write_file(self.powers_file)
if self.path == '/moms':
self.write_file(self.moms_file)
if self.path == '/parameterized':
self.write_file(self.parameterized_file)
if __name__ == '__main__':
BaseHTTPServer.test(MomRequestHandler, BaseHTTPServer.HTTPServer)
def test(HandlerClass=ReactTutorialHTTPRequestHandler,
ServerClass=BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
def test(HandlerClass=SimpleHTTPRequestHandler,
ServerClass=BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass, 'HTTP/1.1')
# Source: https://stackoverflow.com/questions/21956683/enable-access-control-on-simple-http-server
# PYTHON 2 ONLY
from SimpleHTTPServer import SimpleHTTPRequestHandler
import BaseHTTPServer
class CORSHandler(SimpleHTTPRequestHandler):
def end_headers(self):
self.send_header('Access-Control-Allow-Origin', '*')
SimpleHTTPRequestHandler.end_headers(self)
if __name__ == '__main__':
BaseHTTPServer.test(CORSHandler, BaseHTTPServer.HTTPServer)
#!/usr/bin/env python
import BaseHTTPServer
class EchoHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
response = '%s %s %s\n%s' % \
(self.command, self.path, self.request_version, self.headers)
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
self.wfile.write(response)
def do_POST(self):
self.do_GET()
self.wfile.write('\n')
length = int(self.headers.getheader('Content-Length'))
self.wfile.write(self.rfile.read(length))
BaseHTTPServer.test(EchoHTTPRequestHandler)
count += 1
(ins, _, exs) = select.select(iw, ow, iw, 3)
if exs: break
if ins:
for i in ins:
if i is soc:
out = self.connection
else:
out = soc
data = i.recv(8192)
if data:
out.send(data)
count = 0
else:
print "..", count,
if count == max_idling: break
do_HEAD = do_GET
do_POST = do_GET
do_PUT = do_GET
do_DELETE= do_GET
class ThreadingHTTPServer (SocketServer.ThreadingMixIn,
BaseHTTPServer.HTTPServer): pass
if __name__ == '__main__':
from sys import argv
if argv[1:] and argv[1] in ('-h', '--help'):
print argv[0], "[port]"
BaseHTTPServer.test(ProxyHandler, ThreadingHTTPServer)
# return list of files
if path == "list/" or path == "list":
return os.path.join(data_dir, "")
# return index file
if path == "":
return os.path.join(website_dir, "tracelogger.html")
# return data files
if os.path.isdir(os.path.join(data_dir, path)) or path.endswith(".json") or path.endswith(".tl"):
return os.path.join(data_dir, path)
# return website UI
return os.path.join(website_dir, path)
if __name__ == '__main__':
# Interpret non-numeric first argument as a data directory.
if len(sys.argv) > 1:
try:
port = int(sys.argv[1])
except:
data_dir = sys.argv.pop(1)
if data_dir is None:
data_dir = os.getcwd()
# If not running from within the website/ directory, assume we are running
# from the data directory. cd to the website dir so we serve non-data files
# from there.
website_dir = os.path.realpath(os.path.dirname(__file__))
os.chdir(website_dir)
BaseHTTPServer.test(TraceLoggerRequestHandler, BaseHTTPServer.HTTPServer)
def test(HandlerClass=RequestHandler, ServerClass=BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
def test(HandlerClass=AuthHandler, ServerClass=BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
class AuthHandler(SimpleHTTPRequestHandler):
def do_HEAD(self):
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
def do_AUTHHEAD(self):
self.send_response(401)
self.send_header('WWW-Authenticate', 'Basic realm=\"Test\"')
self.send_header('Content-type', 'text/html')
self.end_headers()
def do_GET(self):
global key
if self.headers.getheader('Authorization') == None:
self.do_AUTHHEAD()
self.wfile.write('no auth header received')
elif self.headers.getheader('Authorization') == 'Basic ' + key:
SimpleHTTPRequestHandler.do_GET(self)
else:
self.do_AUTHHEAD()
self.wfile.write(self.headers.getheader('Authorization'))
self.wfile.write('not authenticated')
if __name__ == '__main__':
if len(sys.argv) < 3:
print "usage BasicAuthServer.py [port] [username:password]"
sys.exit()
key = base64.b64encode(sys.argv[2])
BaseHTTPServer.test(AuthHandler, BaseHTTPServer.HTTPServer)
if count == max_idling:
break
do_HEAD = do_GET
do_POST = do_GET
do_PUT = do_GET
do_DELETE = do_GET
class ThreadingHTTPServer(SocketServer.ThreadingMixIn,
BaseHTTPServer.HTTPServer):
pass
if __name__ == '__main__':
from sys import argv
if argv[1:] and argv[1] in ('-h', '--help'):
print argv[0], "[port [allowed_client_name ...]]"
else:
if argv[2:]:
allowed = []
for name in argv[2:]:
client = socket.gethostbyname(name)
allowed.append(client)
print "Accept: %s (%s)" % (client, name)
ProxyHandler.allowed_clients = allowed
del argv[2:]
else:
print "Any clients will be served..."
BaseHTTPServer.test(ProxyHandler, ThreadingHTTPServer)
def test(HandlerClass = AuthHandler,
ServerClass = BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
def basicServer(HandlerClass=SimpleHTTPRequestHandler,
ServerClass=BaseHTTPServer.HTTPServer):
url = "http://localhost:8000"
webbrowser.open(url, new=2)
BaseHTTPServer.test(HandlerClass, ServerClass)
def start_server(HandlerClass=SimpleHTTPRequestHandler,
ServerClass=BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
def test(HandlerClass = HandlerWithPost,
ServerClass = BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
return None
try:
with open(path, 'r') as fp:
source = fp.read()
fs = os.fstat(fp.fileno())
except IOError:
return None
output = markdown.markdown(source.decode(_CHARSET),
extensions=_EXTENSIONS)
html = _HTML_TEMPLATE.format(title=os.path.basename(path),
charset=_CHARSET,
body=output.encode(_CHARSET))
self.send_response(200)
self.send_header('Content-Type', 'text/html; charset=' + _CHARSET)
self.send_header('Content-Length', len(html))
self.send_header('Last-Modified', self.date_time_string(fs.st_mtime))
self.end_headers()
return cStringIO.StringIO(html)
def send_head(self):
markdown = self._render_markdown()
if markdown:
return markdown
return SimpleHTTPRequestHandler.send_head(self)
if __name__ == '__main__':
BaseHTTPServer.test(HandlerClass=EzgfmHandler)
def runServer(HandlerClass = BitsHandler, ServerClass = BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
def main():
BaseHTTPServer.test(RequestHandler, BaseHTTPServer.HTTPServer)
#! /usr/bin/env python2
from SimpleHTTPServer import SimpleHTTPRequestHandler
import BaseHTTPServer
class CORSRequestHandler (SimpleHTTPRequestHandler):
def end_headers (self):
self.send_header('Access-Control-Allow-Origin', 'http://localhost:8080')
SimpleHTTPRequestHandler.end_headers(self)
if __name__ == '__main__':
BaseHTTPServer.test(CORSRequestHandler, BaseHTTPServer.HTTPServer)
def runServer(HandlerClass=BitsHandler, ServerClass=BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
def test(HandlerClass = SimpleHTTPRequestHandler,
ServerClass = BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
def test(HandlerClass=MediaRequestHandler, ServerClass=BaseHTTPServer.HTTPServer):
BaseHTTPServer.test(HandlerClass, ServerClass)
