def main(self):
log.info("press '^C' to stop server")
freezerDstPath = self.parent.projectPath / ProjectFinder.BUILD_DIR
with local.cwd(freezerDstPath):
sys.argv[1] = self.parent.PORT
log.info("serve frozen flask from %s at http://localhost:%s",
freezerDstPath, self.parent.PORT)
SimpleHTTPServer.test()
def test(HandlerClass=CGIHTTPRequestHandler,
ServerClass=BaseHTTPServer.HTTPServer):
import sys
if sys.argv[1:2] == ['-r']:
db = MyArchive()
db.regenindices()
return
SimpleHTTPServer.test(HandlerClass, ServerClass)
def test(HandlerClass = CGIHTTPRequestHandler,
ServerClass = BaseHTTPServer.HTTPServer):
import sys
if sys.argv[1:2] == ['-r']:
db = MyArchive()
db.regenindices()
return
SimpleHTTPServer.test(HandlerClass, ServerClass)
def main():
pwd = os.getcwd()
try:
os.chdir("./docs")
SimpleHTTPServer.test()
finally:
os.chdir(pwd)
def main():
if len(sys.argv) < 2:
sys.exit("Please supply a directory to serve")
os.chdir(sys.argv[1])
# Remove the directory from argv so the HTTP port can still be
# specified after the directory (read by SimpleHTTPServer.test)
del sys.argv[1]
SimpleHTTPServer.test(ServerClass=ThreadingHTTPServer)
def run():
import sys
if sys.version_info < (3, 0, 0):
# Python2系
import SimpleHTTPServer as server
server.test(HandlerClass=server.SimpleHTTPRequestHandler)
else:
# Python3系
from http.server import HTTPServer, CGIHTTPRequestHandler
host = 'localhost'
port = 8000
httpd = HTTPServer((host, port), CGIHTTPRequestHandler)
print('serving at port', port)
httpd.serve_forever()
def webshare(open_in_browser=False, port=8000):
if open_in_browser:
import webbrowser
def open_in_browser():
webbrowser.open_new_tab('http://localhost:{0}'.format(port))
_delay_background(open_in_browser, 0.5)
# BaseHTTPServer looks at argv[1] for port
sys.argv = [sys.argv[0], port]
import SimpleHTTPServer
try:
SimpleHTTPServer.test()
except KeyboardInterrupt:
print '\nStopping...'
def run_simple_server():
_ = get_dataset('smallfile')
_ = get_dataset('bigfile')
_ = get_dataset_bz2('smallfile')
_ = get_dataset_bz2('bigfile')
os.chdir(DATA_DIR)
if six.PY2:
import SimpleHTTPServer
import RangeHTTPServer
from RangeHTTPServer import RangeRequestHandler
import sys
sys.argv[1] = 8000
SimpleHTTPServer.test(HandlerClass=RangeRequestHandler)
else:
import RangeHTTPServer.__main__
def do_GET(self):
self.actfunc = {
'checkpatch': self.checkpatch,
'listinfo': self.listinfo,
'addpatch': self.addpatch
}
f = SimpleHTTPServer.StringIO()
#self.getcursor()
#f.write('ok<br>')#this is request args::'+self.path+'<br>')
if not self.dbisok(f):
return
self.parseARGS()
if not self.argsdit:
fp = os.getcwd() + self.path
if os.path.isfile(fp):
hf = open(fp)
f.write(hf.read())
hf.close()
else:
f.write("request page is not exist</br>")
self.senddata(f, 200, 'PAGE')
return
if not self.argsdit.get('func'):
f.write('this request have not a function <br>')
self.senddata(f, 201, 'NOTFUNC')
return
if self.actfunc.get(self.argsdit['func']):
self.actfunc[self.argsdit['func']](f)
else:
f.write('this request have a nonexist function <br>')
self.senddata(f, 202, 'NOTEXIST')
# change to the kn_apps dir (as this basic HTTP server only references the
# current directory and below)
os.chdir(appsDir)
# start out using the default mod_pubsub server address
mpsServer = defaultMpsServer
# read the prologue.js file to get the actual server address
try:
prologuePath = os.path.join(appsDir, 'kn_lib', 'prologue.js')
mpsServer = readPubSubServerAddress (prologuePath)
except IOError, (errno, strerror):
sys.stderr.write(
"Warning, problem accessing %s, (%s): %s\n" % (prologuePath, errno, strerror)
)
sys.stderr.flush()
pass
# set the PubSub Server name in the replacement list
for i in range(0,len(replaceStrList)):
replaceStrList[i] = replaceStrList[i] % mpsServer
print "\nUsing mod_pubsub server: %s\n" % mpsServer
SimpleHTTPServer.test(CrossDomainRequestHandler)
if __name__ == "__main__": main(sys.argv)
# End of xdomainserver.py
},
'/js/event-data.gz': {
'Content-Encoding': 'gzip',
'Content-Type': 'text/javascript'
},
'/js/jquery.gz': {
'Content-Encoding': 'gzip',
'Content-Type': 'text/javascript'
},
'/js/d3.gz': {
'Content-Encoding': 'gzip',
'Content-Type': 'text/javascript'
},
'/js/deparam.min.gz': {
'Content-Encoding': 'gzip',
'Content-Type': 'text/javascript'
},
'/js/mapbox.gz': {
'Content-Encoding': 'gzip',
'Content-Type': 'text/javascript'
},
}
if self.path in MONKEYPATCHED_HEADERS:
for header, value in MONKEYPATCHED_HEADERS[self.path].iteritems():
self.send_header(header, value)
if __name__ == '__main__':
SimpleHTTPServer.test(HandlerClass=GZipFriendlyRequestHandler)
except:
self.send_response(200)
self.send_header("Content-type", "text/plain")
self.end_headers()
self.wfile.write("Problem sending image: %s\n" % self.path)
def do_GET(self):
"""Serve a GET request."""
if self.path[:len("/quit")] == "/quit":
self.send_response(200)
self.send_header("Content-type", "text/plain")
self.end_headers()
self.wfile.write("exiting....")
global cam
del cam
sys.exit(0)
if self.path[:len("/cam")] == "/cam":
self.sendImage()
return
if self.path[:len("/push")] == "/push":
self.pushImages()
return
SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
return
if len(sys.argv) == 1:
sys.argv = (sys.argv[0], "8000")
SimpleHTTPServer.test(MyHandler)
#!/usr/bin/env python import SimpleHTTPServer;SimpleHTTPServer.test()
#############
# webserver.py
import BaseHTTPServer, SimpleHTTPServer, CGIHTTPServer
class myRequestHandler(CGIHTTPServer.CGIHTTPRequestHandler):
def is_executable(self, path):
return self.is_python(path)
if __name__ == '__main__':
SimpleHTTPServer.test(myRequestHandler, BaseHTTPServer.HTTPServer)
#############
#!/usr/bin/env python
#encoding: utf8
import rospy, os
import SimpleHTTPServer
def kill():
os.system("kill -KILL " + str(os.getpid())) #強制シャットダウン
os.chdir(os.path.dirname(__file__)) #scriptsディレクトリが見えるように
rospy.init_node("webserver") #rosのノード登録
rospy.on_shutdown(kill) #kill関数の登録
SimpleHTTPServer.test() #サーバ立ち上げ
#!/usr/bin/env python
# coding: utf-8
"""
usage: python httpsserver.py 443
"""
import sys
import ssl
import SocketServer
import BaseHTTPServer
import SimpleHTTPServer
# openssl req -new -x509 -days 365 -nodes -out cert.pem -keyout cert.pem
CERT_FILE = './cert.pem'
class ThreadingSimpleServer(SocketServer.ThreadingMixIn,
BaseHTTPServer.HTTPServer):
def get_request(self):
conn, addr = self.socket.accept()
sconn = ssl.wrap_socket(conn,
server_side=True,
certfile=CERT_FILE,
keyfile=CERT_FILE,
ssl_version=ssl.PROTOCOL_SSLv23)
return (sconn, addr)
if __name__ == '__main__':
SimpleHTTPServer.test(ServerClass=ThreadingSimpleServer)
import SimpleHTTPServer
@contextlib.contextmanager
def working_directory(path):
"""A context manager which changes the working directory to the given
path, and then changes it back to its previous value on exit.
"""
prev_cwd = os.getcwd()
os.chdir(path)
yield
os.chdir(prev_cwd)
class NoCacheHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
def end_headers(self):
self.send_my_headers()
SimpleHTTPServer.SimpleHTTPRequestHandler.end_headers(self)
def send_my_headers(self):
self.send_header("Cache-Control",
"no-cache, no-store, must-revalidate")
self.send_header("Pragma", "no-cache")
self.send_header("Expires", "0")
if __name__ == '__main__':
with working_directory("build"):
SimpleHTTPServer.test(HandlerClass=NoCacheHTTPRequestHandler)
#!/usr/bin/env python
import SimpleHTTPServer
class NoCacheRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
def end_headers(self):
self.send_my_headers()
SimpleHTTPServer.SimpleHTTPRequestHandler.end_headers(self)
def send_my_headers(self):
self.send_header("Cache-Control", "no-cache, no-store, must-revalidate")
self.send_header("Pragma", "no-cache")
self.send_header("Expires", "0")
if __name__ == '__main__':
SimpleHTTPServer.test(HandlerClass=NoCacheRequestHandler)
def httpserver2(port):
import SimpleHTTPServer
sys.argv=['',port]
SimpleHTTPServer.test(SimpleHTTPServer.SimpleHTTPRequestHandler)
import SimpleHTTPServer as server server.test()
def cli(ctx, **kwargs):
'''aspath_graph converts raw ASPATHs to NetJSON Graph
NetJSON is a series of JSON schema for defining networks, NetJSON Graph
being specific to defining how nodes interconnect. "aspath_graph" uses this
to represent BGP autonomous systems as 'nodes' and how they connect from
the perspective of INPUT
INPUT can either be a device or file depending on value of MODE. This
defaults to a file. (txt)
OUTPUT can be '-' to send results to STDOUT.
If not passing '--nopassword', you will be prompted for a password for the
relevant modes.
When using "--asdot" to provide ASDOT notation, the raw ASPLAIN will also
be provided on the node - just under the "raw" attribute. Note that without
using this option, if an ASDOT exists in the INPUT data it will be
represented still as ASPLAIN.
YAML can be formatted as such: (Note that "ignore" must ONLY be ASPLAIN)
\b
---
label_map:
65001: SFO
65002: ORD
65003: NYC
65003.1: NYC-R1
65003.2: NYC-R2
ignore:
- 7224
- 9059
By default, ASDOT will be labeled according to the firsthalf. Eg, if 65001
is configured to be labeled as DFW, 65001.211 will appear as DFW-R21. This
assumes your ToR ASN is your spine ASN + (racknumber*10+1) - to disable
this simply set APG_ASDOT_RAW to true/yes/anything.
Any of the supported options can be passed via ENV by upping the case,
replacing '-' with '_', and prefixing with 'APG'. Eg, 'APG_MODE'
'''
LABEL_MAP, IGNORE_LIST = parse_yaml(kwargs['yaml'])
raw_paths = []
if kwargs['mode'] == 'txt':
# Click can intelligently open standard streams and files
with click.open_file(kwargs['input']) as f:
raw_paths = f.readlines()
elif kwargs['mode'] == 'junos-netconf':
# This must return as a list of stringed paths (think readlines)
raw_paths = netconf_paths(kwargs['input'],
kwargs['user'],
kwargs['nopassword'])
all_nodes = set()
all_pairs = set()
for path_string in raw_paths:
path_calc = link_paths(path_string, ownas=kwargs['ownas'])
all_nodes.update(path_calc['nodes'])
all_pairs.update(path_calc['pairs'])
netjson = generate_netjson(all_nodes, all_pairs,
lmap=LABEL_MAP, ignore=IGNORE_LIST,
asdot=kwargs['asdot'], ownas=kwargs['ownas'])
if kwargs.get('pprint'):
kwargs['output'].write(json.dumps(netjson, indent=2))
else:
kwargs['output'].write(json.dumps(netjson))
if kwargs.get('runserver'):
# This will change directory into the pkg's static directory, create
# netjson.json, and run SimpleHTTPServer
webpath = os.path.abspath(
os.path.dirname(aspath_graph.__file__) + '/static')
os.chdir(webpath)
with open('netjson.json', 'w') as f:
f.write(json.dumps(netjson))
import sys
sys.argv[1] = 8000
SimpleHTTPServer.test()
def main():
args = parse_args()
logger.setLevel(logging.ERROR-args.verbose*10)
cfg = json.load(open(args.config))
if args.profile is None:
profile_name = cfg.get('default_profile',None)
else:
profile_name = args.profile
if profile_name is not None:
try:
profile = cfg.get('profiles',{})[profile_name]
cfg.update(profile)
except KeyError as e:
logger.fatal('No such profile '+ profile_name)
logger.fatal('Available profiles:'+' '.join(cfg.get('profiles',{}).keys()))
exit(1)
if args.sources is None:
args.sources=cfg.get('sources','source')
if args.templates is None:
args.templates=cfg.get('templates','templates')
if args.website is None:
args.website=cfg.get('website','website')
if args.filters is None:
args.filters=cfg.get('filters','filters')
if args.command == 'compile' or args.command == 'list-assets':
jinja_env.config = cfg
jinja_env.filters['json']=json_filter
jinja_env.filters['asset']=asset_filter
jinja_env.filters['DOI']=doi_filter
jinja_env.filters['VIMEO']=vimeo_filter
jinja_env.filters['YOUTUBE']=youtube_filter
jinja_env.filters['split']=split_filter
try:
custom_filters = __import__(args.filters)
for f_name in custom_filters.__all__:
logger.info("Loading filter %s",f_name)
jinja_env.filters[f_name] = getattr(custom_filters,f_name)
except Exception as ex:
logger.error("Could not load custom filters: %s",repr(ex))
jinja_env.tests['equalto']=equalto_test
jinja_env.tests['not equalto']=equalto_test
jinja_env.loader=jinja2.FileSystemLoader([args.templates])
if 'assets' in cfg:
jinja_env.assets = scan_assets(cfg['assets'])
else:
jinja_env.assets = {}
jinja_env.missing_assets={}
default_template_base = strip_extension(cfg.get('default_template','base.tpl'))
tree = build_web_tree(args.sources,base_dir=args.sources,default_template_base=default_template_base)
global_ctx={'type':type}
global_ctx['website']=tree
global_ctx['config']=cfg
process_tree(tree,global_ctx,args.website,dry_run=(args.command =='list-assets'))
if args.command == 'list-assets':
for asset,data in jinja_env.assets.items():
if data['copy']:
print(data['src'],'->',asset, data['hash'])
if len(jinja_env.missing_assets) > 0:
print("MISSING:")
print("\t\n".join(jinja_env.missing_assets.keys()))
else:
if not args.skipassets:
for (asset,data) in jinja_env.assets.items():
if data['copy']:
dest=args.website+'/'+asset
logger.info("Copying '"+data['src']+''" to '"+dest+"'")
cp(data['src'],dest,create_parents=True,filters=data['filters'])
else:
logger.info("Skipping '"+data['src']+"'")
if len(jinja_env.missing_assets) > 0:
logger.error("The following assets were not found:")
logger.error(';'.join(jinja_env.missing_assets.keys()))
elif args.command == 'serve':
import SimpleHTTPServer
sys.argv=['wg.py',str(args.port)]
os.chdir(args.website)
SimpleHTTPServer.test()
elif args.command == 'list-formats':
print("Metadata Formats:", META_FORMATS.keys())
print("Content Formats:", CONTENT_FORMATS.keys())
import BaseHTTPServer, SimpleHTTPServer, CGIHTTPServer
class myRequestHandler(CGIHTTPServer.CGIHTTPRequestHandler):
def is_executable(self, path):
return self.is_python(path)
if __name__ == '__main__':
SimpleHTTPServer.test(myRequestHandler, BaseHTTPServer.HTTPServer)
# change to the kn_apps dir (as this basic HTTP server only references the
# current directory and below)
os.chdir(appsDir)
# start out using the default mod_pubsub server address
mpsServer = defaultMpsServer
# read the prologue.js file to get the actual server address
try:
prologuePath = os.path.join(appsDir, 'kn_lib', 'prologue.js')
mpsServer = readPubSubServerAddress(prologuePath)
except IOError, (errno, strerror):
sys.stderr.write("Warning, problem accessing %s, (%s): %s\n" %
(prologuePath, errno, strerror))
sys.stderr.flush()
pass
# set the PubSub Server name in the replacement list
for i in range(0, len(replaceStrList)):
replaceStrList[i] = replaceStrList[i] % mpsServer
print "\nUsing mod_pubsub server: %s\n" % mpsServer
SimpleHTTPServer.test(CrossDomainRequestHandler)
if __name__ == "__main__":
main(sys.argv)
# End of xdomainserver.py
assert commands.getstatusoutput("python parse.py %s.json" %
suite_name)[0] == 0
zipfb = zipfile.ZipFile("%s.zip" % suite_name, "w")
zipfb.write("%s.json" % suite_name)
zipfb.write("%s.robot" % suite_name)
zipfb.write("variable.py")
zipfb.write("test_api.py")
zipfb.close()
abspath = os.path.realpath(".")
self.send_response(200)
self.send_header("Content-Length", len(abspath))
self.send_header("Connection", "Close")
self.end_headers()
self.wfile.write(abspath)
except:
self.send_error(500)
def do_POST(self):
action = self.distribute_action()
if not action:
self.send_error(404)
return
else:
action()
if __name__ == "__main__":
SimpleHTTPServer.test(
HandlerClass=CustomHTTPRequestHandler,
ServerClass=SimpleHTTPServer.BaseHTTPServer.HTTPServer)
def main():
SimpleHTTPServer.test(CGIHTTPRequestHandler, BaseHTTPServer.HTTPServer)
def test(HandlerClass=SimpleAppServer, ServerClass=BaseHTTPServer.HTTPServer):
SimpleHTTPServer.test(HandlerClass, ServerClass)
import webbrowser as browser
import os
import SimpleHTTPServer as s
browser.open('http://localhost:8000/test')
s.test()
def test(HandlerClass = CGIHTTPRequestHandler,
ServerClass = BaseHTTPServer.HTTPServer):
SimpleHTTPServer.test(HandlerClass, ServerClass)
with open("../suites/%s/%s.json" %(folder_name, suite_name), "w") as fb:
json.dump(request_data["suite_data"], fb, indent=4)
fb.flush()
os.chdir("../suites/%s" %folder_name)
assert commands.getstatusoutput("python parse.py %s.json" %suite_name)[0]==0
zipfb = zipfile.ZipFile("%s.zip" %suite_name, "w")
zipfb.write("%s.json" %suite_name)
zipfb.write("%s.robot" %suite_name)
zipfb.write("variable.py")
zipfb.write("test_api.py")
zipfb.close()
abspath = os.path.realpath(".")
self.send_response(200)
self.send_header("Content-Length", len(abspath))
self.send_header("Connection", "Close")
self.end_headers()
self.wfile.write(abspath)
except:
self.send_error(500)
def do_POST(self):
action = self.distribute_action()
if not action:
self.send_error(404)
return
else:
action()
if __name__=="__main__":
SimpleHTTPServer.test(HandlerClass=CustomHTTPRequestHandler, ServerClass=SimpleHTTPServer.BaseHTTPServer.HTTPServer)
for index in "index.html", "index.htm":
index = os.path.join(path, index)
if os.path.exists(index):
path = index
break
else:
return self.list_directory(path)
ctype = self.guess_type(path)
try:
# Always read in binary mode. Opening files in text mode may cause
# newline translations, making the actual size of the content
# transmitted *less* than the content-length!
f = open(path, "rb")
except IOError:
self.send_error(404, "File not found")
return None
self.send_response(200)
self.send_header("Content-type", ctype)
fs = os.fstat(f.fileno())
self.send_header("Content-Length", str(fs[6]))
self.send_header("Last-Modified", self.date_time_string(fs.st_mtime))
if path.endswith("kif") or path.endswith("kif.txt"):
self.send_header("Pragma", "no-cache")
self.end_headers()
return f
SimpleHTTPServer.test(HookHTTPRequestHandler)
def do_request(connstream, from_addr):
x = object()
SimpleHTTPServer.SimpleHTTPRequestHandler(connstream, from_addr, x)
#!/usr/bin/env python
import BaseHTTPServer
import SimpleHTTPServer
import CGIHTTPServer
if __name__ == '__main__':
SimpleHTTPServer.test(
CGIHTTPServer.CGIHTTPRequestHandler, BaseHTTPServer.HTTPServer)
#!/usr/bin/env python
import SimpleHTTPServer
class RefreshingRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
def end_headers(self):
self.send_header("Refresh", "1")
SimpleHTTPServer.SimpleHTTPRequestHandler.end_headers(self)
if __name__ == '__main__':
SimpleHTTPServer.test(HandlerClass=RefreshingRequestHandler)
"""CGI-savvy HTTP Server.
out_file.seek(0)
return out_file
def send_head(self):
path = self.translate_path(self.path)
if path.endswith(".tsv"):
try:
with open(path, "rb") as orig_file:
encoding = self.file_encoding
tsv_contents = unicode(orig_file.read(), encoding)
rows = [line.split("\t") for line in tsv_contents.splitlines()]
return self._render_table(rows, encoding)
except UnicodeDecodeError:
# default behaviour
pass
return _server.SimpleHTTPRequestHandler.send_head(self)
class LocalHTTPServer(_b_server.HTTPServer):
"""Inheritor of the BaseHTTPServer.HTTPServer that runs strictly on 127.0.0.1"""
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
# serve only on 127.0.0.1, port is taken from the input
server_address = ("127.0.0.1", server_address[1])
_s_server.TCPServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate)
if __name__ == "__main__":
_server.test(HandlerClass=TSVHandler, ServerClass=LocalHTTPServer)
import SimpleHTTPServer
class CORSHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
def end_headers(self):
# Chrome won't load fonts without this header
self.send_header('Access-Control-Allow-Origin', '*')
SimpleHTTPServer.SimpleHTTPRequestHandler.end_headers(self)
if __name__ == '__main__':
SimpleHTTPServer.test(HandlerClass=CORSHandler)
def testName(self):
SimpleHTTPServer.test()
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import sys
if sys.version_info < (3, 0, 0):
# Python2系
import SimpleHTTPServer as server
else:
# Python3系
import http.server as server
server.test(HandlerClass=server.SimpleHTTPRequestHandler)
def do_serve(args):
os.chdir("_site")
import SimpleHTTPServer
sys.argv = [None, args.PORT]
SimpleHTTPServer.test()
#!/usr/bin/env python2
import SimpleHTTPServer
import os
class MyHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
def translate_path(self, path):
if path.startswith("/~zhaoyich/"):
path = path[len("/~zhaoyich/"):]
return SimpleHTTPServer.SimpleHTTPRequestHandler.translate_path(self, path)
if __name__ == "__main__":
SimpleHTTPServer.test(MyHTTPRequestHandler)
def main():
SimpleHTTPServer.test()
def end_headers(self):
self.githubpages_headers()
SimpleHTTPServer.SimpleHTTPRequestHandler.end_headers(self)
"""Agrega headers que usa GHP"""
def githubpages_headers(self):
timestamp = time.time() + 600
year, month, day, hh, mm, ss, wd, y, z = time.gmtime(timestamp)
s = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
self.weekdayname[wd],
day, self.monthname[month], year,
hh, mm, ss)
self.send_header("Cache-Control", "max-age=600")
self.send_header("Expires", s)
"""Asegura el Content-type correcto para el manifest appcache (=GHP)"""
def guess_type(self, path):
mimetype = SimpleHTTPServer.SimpleHTTPRequestHandler.guess_type(
self, path
)
if path.endswith('.appcache'):
mimetype = 'text/cache-manifest'
return mimetype
if __name__ == '__main__':
print "\n* Iniciando servidor local."
print "Puede iniciar este script indicando un numero de puerto si desea.\n"
SimpleHTTPServer.test(HandlerClass=GPlikeRequestHandler)
#! /usr/bin/env python
#-*- coding: utf-8 -*-
import rospy, os
import SimpleHTTPServer
def kill():
os.system("kill -KILL " + str(os.getpid()))
os.chdir(os.path.dirname(__file__))
rospy.init_node("webserver")
rospy.on_shutdown(kill)
SimpleHTTPServer.test()
def main(argv):
SimpleHTTPServer.test(EditRequestHandler, SocketServer.TCPServer)
#!/usr/bin/env python
import SimpleHTTPServer
# https://stackoverflow.com/questions/12193803/invoke-python-simplehttpserver-from-command-line-with-no-cache-option
class MyHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
def end_headers(self):
self.send_my_headers()
SimpleHTTPServer.SimpleHTTPRequestHandler.end_headers(self)
def send_my_headers(self):
self.send_header("Cache-Control",
"no-cache, no-store, must-revalidate")
self.send_header("Pragma", "no-cache")
self.send_header("Expires", "0")
if __name__ == '__main__':
SimpleHTTPServer.test(HandlerClass=MyHTTPRequestHandler)
import mimetypes
import SimpleHTTPServer
import BaseHTTPServer
class LocalHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
"""SimpleHTTPServer subclass which knows about certain necessary MIME types."""
SimpleHTTPServer.SimpleHTTPRequestHandler.extensions_map.update({
'.svg': 'image/svg+xml',
})
if __name__ == '__main__':
SimpleHTTPServer.test(LocalHTTPRequestHandler, BaseHTTPServer.HTTPServer)
import SimpleHTTPServer
import movieutil
class StreamingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
def send_head(self):
path = self.translate_path(self.path)
if movieutil.is_movie(path):
self.send_response(200)
self.send_header("Content-type", 'video/x-matroska')
self.end_headers()
f = movieutil.transcode(path)
else:
f = SimpleHTTPServer.SimpleHTTPRequestHandler.send_head(self)
return f
if __name__ == '__main__':
SimpleHTTPServer.test(StreamingHTTPRequestHandler)
def cli(ctx, **kwargs):
'''aspath_graph converts raw ASPATHs to NetJSON Graph
NetJSON is a series of JSON schema for defining networks, NetJSON Graph
being specific to defining how nodes interconnect. "aspath_graph" uses this
to represent BGP autonomous systems as 'nodes' and how they connect from
the perspective of INPUT
INPUT can either be a device or file depending on value of MODE. This
defaults to a file. (txt)
OUTPUT can be '-' to send results to STDOUT.
If not passing '--nopassword', you will be prompted for a password for the
relevant modes.
When using "--asdot" to provide ASDOT notation, the raw ASPLAIN will also
be provided on the node - just under the "raw" attribute. Note that without
using this option, if an ASDOT exists in the INPUT data it will be
represented still as ASPLAIN.
YAML can be formatted as such: (Note that "ignore" must ONLY be ASPLAIN)
\b
---
label_map:
65001: SFO
65002: ORD
65003: NYC
65003.1: NYC-R1
65003.2: NYC-R2
ignore:
- 7224
- 9059
By default, ASDOT will be labeled according to the firsthalf. Eg, if 65001
is configured to be labeled as DFW, 65001.211 will appear as DFW-R21. This
assumes your ToR ASN is your spine ASN + (racknumber*10+1) - to disable
this simply set APG_ASDOT_RAW to true/yes/anything.
Any of the supported options can be passed via ENV by upping the case,
replacing '-' with '_', and prefixing with 'APG'. Eg, 'APG_MODE'
'''
LABEL_MAP, IGNORE_LIST = parse_yaml(kwargs['yaml'])
raw_paths = []
if kwargs['mode'] == 'txt':
# Click can intelligently open standard streams and files
with click.open_file(kwargs['input']) as f:
raw_paths = f.readlines()
elif kwargs['mode'] == 'junos-netconf':
# This must return as a list of stringed paths (think readlines)
raw_paths = netconf_paths(kwargs['input'], kwargs['user'],
kwargs['nopassword'])
all_nodes = set()
all_pairs = set()
for path_string in raw_paths:
path_calc = link_paths(path_string, ownas=kwargs['ownas'])
all_nodes.update(path_calc['nodes'])
all_pairs.update(path_calc['pairs'])
netjson = generate_netjson(all_nodes,
all_pairs,
lmap=LABEL_MAP,
ignore=IGNORE_LIST,
asdot=kwargs['asdot'],
ownas=kwargs['ownas'])
if kwargs.get('pprint'):
kwargs['output'].write(json.dumps(netjson, indent=2))
else:
kwargs['output'].write(json.dumps(netjson))
if kwargs.get('runserver'):
# This will change directory into the pkg's static directory, create
# netjson.json, and run SimpleHTTPServer
webpath = os.path.abspath(
os.path.dirname(aspath_graph.__file__) + '/static')
os.chdir(webpath)
with open('netjson.json', 'w') as f:
f.write(json.dumps(netjson))
import sys
sys.argv[1] = 8000
SimpleHTTPServer.test()
def loadLog(): SimpleHTTPServer.test(HandlerClass=MyHTTPRequestHandler)
#!/usr/bin/python import sys import SimpleHTTPServer program = sys.argv[0] # Tell Simple HTTP Server to use port 80 # Note: this requires root permission sys.argc = 2 sys.argv = [program, '80'] SimpleHTTPServer.test()
for index in "index.html", "index.htm":
index = os.path.join(path, index)
if os.path.exists(index):
path = index
break
else:
return self.list_directory(path)
ctype = self.guess_type(path)
try:
# Always read in binary mode. Opening files in text mode may cause
# newline translations, making the actual size of the content
# transmitted *less* than the content-length!
f = open(path, 'rb')
except IOError:
self.send_error(404, "File not found")
return None
self.send_response(200)
self.send_header("Content-type", ctype)
fs = os.fstat(f.fileno())
self.send_header("Content-Length", str(fs[6]))
self.send_header("Last-Modified", self.date_time_string(fs.st_mtime))
if (path.endswith("kif") or path.endswith("kif.txt")):
self.send_header("Pragma", "no-cache")
self.end_headers()
return f
SimpleHTTPServer.test(HookHTTPRequestHandler)
def translate_path(self, path):
fs_path = SimpleHTTPRequestHandler.translate_path(self, path)
if self.path.endswith('/'):
for index in "index.html", "index.htm":
index = os.path.join(fs_path, index)
if os.path.exists(index):
fs_path = index
break
if fs_path.endswith('.html'):
content = ssi.InlineIncludes(fs_path)
fs_path = self.create_temp_file(fs_path, content)
return fs_path
def delete_temp_files(self):
for temp_file in self.temp_files:
os.remove(temp_file)
def create_temp_file(self, original_path, content):
_, ext = os.path.splitext(original_path)
fd, path = tempfile.mkstemp(suffix=ext)
os.write(fd, content)
os.close(fd)
self.temp_files.append(path)
return path
if __name__ == '__main__':
SimpleHTTPServer.test(HandlerClass=SSIRequestHandler)
def test(HandlerClass = SimpleAppServer,
ServerClass = BaseHTTPServer.HTTPServer):
SimpleHTTPServer.test(HandlerClass, ServerClass)
import SimpleHTTPServer
import logging
cookieHeader = None
class MyHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
def do_GET(self):
self.cookieHeader = self.headers.get('Cookie')
print self.headers
SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
def end_headers(self):
self.send_my_headers()
SimpleHTTPServer.SimpleHTTPRequestHandler.end_headers(self)
def send_my_headers(self):
self.send_header("Set-Cookie", "_cfuididi=0b59c51aca680614ad7d395510880dd7")
if __name__ == '__main__':
SimpleHTTPServer.test(HandlerClass=MyHTTPRequestHandler)
#!/usr/bin/env python
import subprocess as sub
import BaseHTTPServer
import SimpleHTTPServer as httpd
# override this method to speed up connection
def _bare_address_string(self):
host, port = self.client_address[:2]
return '%s' % host
BaseHTTPServer.BaseHTTPRequestHandler.address_string = _bare_address_string
# get ip address and print
info = sub.Popen('/sbin/ifconfig', stdout=sub.PIPE).communicate()[0]
tokens = []
for line in info.split('\n'):
if 'inet' in line:
if '127.0.0.1' not in line:
tokens = line.split()
print("")
print("' ', tokens[1].replace(':', ': '), '\n ',")
# start server
try:
httpd.test()
except KeyboardInterrupt:
print('\x08\x08Killed')
def test(HandlerClass=CGIHTTPRequestHandler,
ServerClass=BaseHTTPServer.HTTPServer):
SimpleHTTPServer.test(HandlerClass, ServerClass)
def create_server(server):
change_dir()
server = server.BaseHTTPServer.HTTPServer((local_ip(), 80),
server.SimpleHTTPRequestHandler)
print server.server_address
server.serve_forever()
