def run_server(): default_ip = get_default_ip() parser = argparse.ArgumentParser(description='Serve a domsocket application.') parser.add_argument('--server_ip','-s', dest='server_ip', default=default_ip, help='the ip address where the zmq domsocket app is listening') parser.add_argument('--zmq_bind_ip','-i', dest='zmq_bind_ip', default='127.0.0.1', help='the ip address where the zmq domsocket app is listening') parser.add_argument('--server_port','-p', dest='web_port', default=8443, help='the port for the web server to listen') parser.add_argument('--zmq_port','-z', dest='zmq_port', default=5555, help='the port for the zmq backend to listen') parser.add_argument('-v', '--verbose', dest='verbose', action='store_true', help='Turn on message debugging (which makes the server seem less responsive') args = parser.parse_args() app_websocket.parsed_args = args config_server_openssl(args.server_ip) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() cherrypy.engine.subscribe('stop', shutdown) server_info = ServerInfo(args) backend = init_backend(args) backend.start() root_factory = RootFactory(server_info) root = root_factory.create_root() root_conf = root_factory.get_conf() try: cherrypy.quickstart(root, '/', config=root_conf) finally: logging.info('finally clause kicked out of cherrypy.quickstart')
def run_cherrypy_server(host="127.0.0.1", port=9000): """ Runs a CherryPy server on Python 2.x. """ import cherrypy from ws4py.server.cherrypyserver import WebSocketPlugin, WebSocketTool from ws4py.websocket import EchoWebSocket cherrypy.config.update({'server.socket_host': host, 'server.socket_port': port, 'engine.autoreload_on': False, 'log.screen': False}) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() class Root(object): @cherrypy.expose def index(self): pass config = { '/': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': EchoWebSocket } } logger = logging.getLogger('autobahn_testsuite') logger.warning("Serving CherryPy server on %s:%s" % (host, port)) cherrypy.quickstart(Root(), '/', config)
def browser_authorize(self): """ Open a browser to the authorization url and spool up a CherryPy server to accept the response """ webbrowser.open(self.authorize_url()) cherrypy.quickstart(self)
def main(): config = { "global": { # Server settings "server.socket_host": "0.0.0.0", "server.socket_port": 8080, # Encoding "tools.encode.on": True, "tools.encode.encoding": "utf-8", "tools.decode.on": True, # URL-adaption "tools.trailing_slash.on": True, }, # "/": { # #... # } } # Add paths for languages to http_root (examples: "/en/aaa/", "/de/aaa/") for lang in LANGUAGE_CODES: setattr(http_root, lang, http_root) # Create, configure and start application app = cherrypy.Application(http_root, config = config) cherrypy.quickstart(app, config = config)
def _serve_forever(self): LOG.debug('Starting plotter') try: cherrypy.quickstart(self, '/', {'/': {}}) except: LOG.error(helper.exc_info()) thread.interrupt_main()
def server(host='127.0.0.1',port='8899',verbose=False,open_browser=True,quiet=False): mode = 'development' if verbose else '' l2s = True if verbose else False config = { 'global': { 'server.environment': mode, 'server.socket_host': host, 'server.socket_port': int(port), 'server.log_to_screen': l2s, 'log.screen': l2s }, '/': { 'tools.staticdir.root': webapp.html_dir }, '/favicon.ico': { 'tools.staticfile.on': True, 'tools.staticfile.filename': webapp.html_dir + '/favicon.ico' }, '/static': { 'tools.staticdir.on': True, 'tools.staticdir.dir': "static" } } url = "http://%s:%s%s" % (host, port, '/') if not quiet: print "Visit this url in your browser to use the app" print url if open_browser: browser_open = threading.Timer(1.0,browser,args=[ url ]) browser_open.start() cherrypy.quickstart(webapp.Root(),config=config)
def main(): configure_logging() config = { '/': {'tools.gzip.on': True}, 'global': {'server.socket_host': "0.0.0.0"} } cherrypy.quickstart(MyAPI(), config=config)
def run(self, args, config): import cherrypy class HelloWorld(object): def index(self): return 'Hello, world!' index.exposed=True cherrypy.quickstart(HelloWorld())
def Main(): """Configure and start the ConstrainedNetworkServer.""" options = ParseArgs() try: traffic_control.CheckRequirements() except traffic_control.TrafficControlError as e: cherrypy.log(e.msg) return cherrypy.config.update({'server.socket_host': '::', 'server.socket_port': options.port}) if options.threads: cherrypy.config.update({'server.thread_pool': options.threads}) if options.socket_timeout: cherrypy.config.update({'server.socket_timeout': options.socket_timeout}) # Setup port allocator here so we can call cleanup on failures/exit. pa = PortAllocator(options.port_range, expiry_time_secs=options.expiry_time) try: cherrypy.quickstart(ConstrainedNetworkServer(options, pa)) finally: # Disable Ctrl-C handler to prevent interruption of cleanup. signal.signal(signal.SIGINT, lambda signal, frame: None) pa.Cleanup(all_ports=True)
def main(): conf = config_server() # Create the root application object root = Root() cherrypy.quickstart(root, "/", config=conf)
def run_cherrypy_server(host="127.0.0.1", port=8008, threads=50, daemonize=False, pidfile=None, autoreload=False): if daemonize: if not pidfile: pidfile = '~/cpwsgi_%d.pid' % port stop_server(pidfile) from django.utils.daemonize import become_daemon become_daemon() fp = open(pidfile, 'w') fp.write("%d\n" % os.getpid()) fp.close() cherrypy.config.update({ 'server.socket_host': host, 'server.socket_port': int(port), 'server.thread_pool': int(threads), 'checker.on': False, }) DjangoAppPlugin(cherrypy.engine).subscribe() if not autoreload: # cherrypyserver automatically reloads if any modules change # Switch-off that functionality here to save cpu cycles # http://docs.cherrypy.org/stable/appendix/faq.html cherrypy.engine.autoreload.unsubscribe() cherrypy.quickstart() if pidfile: stop_server(pidfile)
def start(self): """ """ cherrypy.config.update({ 'server.socket_host': self.host, 'server.socket_port': self.port }) WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool() cherrypy.quickstart(ChatWebApp(), '', config={ '/': { 'tools.response_headers.on': True, 'tools.response_headers.headers': [ ('X-Frame-options', 'deny'), ('X-XSS-Protection', '1; mode=block'), ('X-Content-Type-Options', 'nosniff') ] }, '/ws': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': ChatWebSocketHandler }, })
def startup(config): patch_compat(config) pmxbot.config.update(config) config = pmxbot.config pmxbot.core._load_library_extensions() _init_config() # Cherrypy configuration here app_conf = { cherrypy._cpcompat.tonative('global', encoding='ascii'): { 'server.socket_port': config.port, 'server.socket_host': config.host, #'tools.encode.on': True, 'tools.encode.encoding': 'utf-8', }, cherrypy._cpcompat.tonative('/pmxbot.png', encoding='ascii'): { 'tools.staticfile.on': True, 'tools.staticfile.filename': pkg_resources.resource_filename( 'pmxbot.web', 'templates/pmxbot.png'), }, } cherrypy.quickstart(PmxbotPages(), config.web_base, config=app_conf)
def start(): ''' Start the server loop ''' from . import app root, apiopts, conf = app.get_app(__opts__) if apiopts.get('debug', False): # Start the development server cherrypy.quickstart(root, '/', conf) else: from . import wsgi application = wsgi.get_application(root, apiopts, conf) if not 'ssl_crt' in apiopts or not 'ssl_key' in apiopts: logger.error("Not starting '%s'. Options 'ssl_crt' and 'ssl_key' " "are required in production mode." % __name__) return None # Mount and start the WSGI app using the production CherryPy server verify_certs(apiopts['ssl_crt'], apiopts['ssl_key']) ssl_a = wsgiserver.ssl_builtin.BuiltinSSLAdapter( apiopts['ssl_crt'], apiopts['ssl_key']) wsgi_d = wsgiserver.WSGIPathInfoDispatcher({'/': application}) server = wsgiserver.CherryPyWSGIServer( (apiopts.get('host', '0.0.0.0'), apiopts['port']), wsgi_app=wsgi_d) server.ssl_adapter = ssl_a signal.signal(signal.SIGINT, lambda *args: server.stop()) server.start()
def run_cherrypy_server(host="127.0.0.1", port=8008, threads=50, daemonize=False, pidfile=None): if daemonize: if not pidfile: pidfile = '~/cpwsgi_%d.pid' % port stop_server(pidfile) from django.utils.daemonize import become_daemon become_daemon() fp = open(pidfile, 'w') fp.write("%d\n" % os.getpid()) fp.close() cherrypy.config.update({ 'server.socket_host': host, 'server.socket_port': int(port), 'server.thread_pool': int(threads), 'checker.on': False, }) DjangoAppPlugin(cherrypy.engine).subscribe() cherrypy.quickstart() if pidfile: stop_server(pidfile)
def main(args): # Read settings used by etherpad client rtfn = rLite() # Start etherpad lite client apiKey = rtfn.api_key() baseUrl = rtfn.get("etherpad-url") print "[rlite//Debug]: Starting with api key: %s, elite hosted at: %s" % (apiKey, baseUrl) elite = EtherpadLiteClient(apiKey, baseUrl) # rLite's DB management hooks etherpad lite API calls db = DB(elite) if args.add is not None and args.key is not None: print "Adding competition {0} with key {1}.".format(args.add, args.key) db.create_competition(args.add, args.key, add_elite=False) sys.exit(0) # Start web interface current_dir = os.path.dirname(os.path.abspath(__file__)) config = {"/static": { 'tools.staticdir.on': True, 'tools.staticdir.dir': current_dir + "/static" }} cherrypy.config.update('rtfn.ini') # Web interface uses DB (authentication), and elite (pad lists/info) cherrypy.quickstart(RootController(db, rtfn, elite), "/", config=config)
def wmain(argv): apn = None if len(argv) < 3: try: apn = settings.appname if len(argv) < 2: sys.stderr.write('%s bibletable [appname]\n' % (argv[0], )) return 1 except: sys.stderr.write('%s bibletable [appname]\n\nIf appname is not provided in settings.appname, then pass it in as an arg.' % (argv[0], )) return 2 else: apn = argv[2] orm.ORM.connect(dbname = 'revence', user = '******') # cherrypy.server.socket_host = '0.0.0.0' cherrypy.quickstart(Bible(argv[1], apn), '/', { '/' : { 'tools.sessions.on' : True }, '/static' : { 'tools.staticdir.on' : True, 'tools.staticdir.root': os.path.abspath(os.getcwd()), 'tools.staticdir.dir' : 'static' } }) return 0
def main(uri=schema.default_uri): import cherrypy as cp db = schema.connect(uri) providers = [ transit_routes(db), coordinate_shape(db), coordinate_shapes(db), departure_traces(db), RouteStatisticsProvider(db), route_graph_edges(db), available_date_range(db), ] resources = session_server.ResourceServer(providers) my_static = os.path.join(os.path.dirname(__file__), 'ui') root = session_server.StaticUnderlayServer(my_static) root.resources = resources cpconfig = { 'server.socket_host': config.server_host, 'server.socket_port': config.server_port, 'tools.gzip.on': True, 'tools.gzip.mime_types': ['text/*', 'application/json'] } cp.quickstart(root, config={'global': cpconfig})
def run(self): #Set up the logger logger = logging.getLogger('wiseserver') logger.setLevel(logging.DEBUG) formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') handler = logging.handlers.TimedRotatingFileHandler('wise_daemon.log', 'midnight', backupCount = 15) handler.setLevel(logging.DEBUG) handler.setFormatter(formatter) logger.addHandler(handler) #Fetch the data try: credFile = open('credentials.txt', 'r') usr, passwd = credFile.readline().split(' ') credFile.close() except IOError: sys.exit(0) df = dataFetcher(usr, passwd[0:-1], 'extractor_data.o', logger) if os.path.exists('extractor_data.o'): df.fetchSerialized() else: df.fetchNetData() df.serialize() cherrypy.log.access_log.addHandler(handler) cherrypy.log.error_log.addHandler(handler) cherrypy.log.screen = False cherrypy.config.update({'server.socket_port': 8080, 'server.socket_host': '0.0.0.0', }) conf = {'/favicon.ico':{'tools.staticfile.on': True, 'tools.staticfile.filename': os.path.join(os.getcwd(), 'favicon.ico')}} cherrypy.quickstart(WiseMLServer(df, logger), '/', conf)
def main(): conf = { '/': { 'tools.sessions.on': True, 'tools.staticdir.root': os.path.abspath(os.getcwd()) }, '/generator': { 'request.dispatch': cherrypy.dispatch.MethodDispatcher(), 'tools.response_headers.on': True, 'tools.response_headers.headers': [('Content-Type', 'text/plain')] }, '/static': { 'tools.staticdir.on': True, 'tools.staticdir.dir': './public' } } # When server starts, setup the database cherrypy.engine.subscribe('start', setup_database) # When server shuts down, clean it up by removing tables cherrypy.engine.subscribe('stop', cleanup_database) webapp = StringGenerator() webapp.generator = StringGeneratorWebService() cherrypy.quickstart(webapp, '/', conf) return
def start(cls): ctx = SpellMatcherContext(metadata=metadata, session=session, mapper=mapper) cherrypy.config.update({ 'server.socket_host': ctx.host, 'server.socket_port': ctx.port, 'tools.encode.on': True, 'tools.encode.encoding': 'utf-8', 'tools.decode.on': True, 'tools.trailing_slash.on': True, 'tools.staticdir.root': ctx.static, 'tools.SATransaction.on': True, 'tools.SATransaction.dburi': ctx.db_connection, 'tools.SATransaction.echo': False, 'tools.SATransaction.convert_unicode': True, 'log.screen': True, 'tools.sessions.on': True }) conf = { '/': { 'request.dispatch': cls.__setup_routes(ctx), }, '/media': { 'tools.staticdir.on': True, 'tools.staticdir.dir': 'media/' + ctx.template } } app = cherrypy.tree.mount(None, config=conf) cherrypy.quickstart(app)
def serve(path=None, port=8080): import cherrypy cherrypy.config.update({'server.socket_port': int(port), 'server.thread_pool': 10, 'environment': "production", }) cherrypy.quickstart(Profiler(path))
def start(): ''' Server loop here. Started in a multiprocess. ''' root = API(__opts__) conf = root.get_conf() gconf = conf.get('global', {}) cherrypy.tools.salt_token = cherrypy.Tool('on_start_resource', salt_token_tool, priority=55) cherrypy.tools.salt_auth = cherrypy.Tool('before_request_body', salt_auth_tool, priority=60) cherrypy.tools.hypermedia_out = cherrypy.Tool('before_handler', hypermedia_out) cherrypy.tools.hypermedia_in = cherrypy.Tool('before_request_body', hypermedia_in) if gconf['debug']: cherrypy.quickstart(root, '/', conf) else: root.verify_certs(gconf['ssl_crt'], gconf['ssl_key']) app = cherrypy.tree.mount(root, '/', config=conf) ssl_a = wsgiserver.ssl_builtin.BuiltinSSLAdapter( gconf['ssl_crt'], gconf['ssl_key']) wsgi_d = wsgiserver.WSGIPathInfoDispatcher({'/': app}) server = wsgiserver.CherryPyWSGIServer( ('0.0.0.0', gconf['server.socket_port']), wsgi_app=wsgi_d) server.ssl_adapter = ssl_a signal.signal(signal.SIGINT, lambda *args: server.stop()) server.start()
def start(): def create_rule_if_not_exists(rule): out = sglib.ShellCmd('iptables-save')() if rule in out: return sglib.ShellCmd('iptables %s' % rule)() def prepare_default_rules(): sglib.ShellCmd('iptables --policy INPUT DROP')() name = 'default-chain' try: sglib.ShellCmd('iptables -F %s' % name)() except Exception: sglib.ShellCmd('iptables -N %s' % name)() create_rule_if_not_exists('-I INPUT -p tcp --dport 9988 -j ACCEPT') create_rule_if_not_exists('-I INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT') prepare_default_rules() cherrypy.log.access_file = '/var/log/cs-securitygroup.log' cherrypy.log.error_file = '/var/log/cs-securitygroup.log' cherrypy.server.socket_host = '0.0.0.0' cherrypy.server.socket_port = 9988 cherrypy.quickstart(SGAgent())
def main(): cherrypy.config.update({'server.socket_host': '0.0.0.0',}) cherrypy.config.update({'server.socket_port': int(os.environ.get('PORT', '5000')),}) ROOTDIR = os.path.dirname(os.path.abspath(__file__)) conf = { '/': { 'tools.staticdir.root': ROOTDIR, }, '/js': { 'tools.staticdir.on': True, 'tools.staticdir.dir': 'js' }, '/templates': { 'tools.staticdir.on': True, 'tools.staticdir.dir': 'templates' }, '/favicon.ico': { 'tools.staticfile.on': True, 'tools.staticfile.filename': os.path.join(ROOTDIR, 'static', 'favicon.ico') }, '/static': { 'tools.staticdir.on': True, 'tools.staticdir.dir': 'static' } } tweets = load_tweets(TWEETS_FILE) cherrypy.quickstart(Root(tweets), '/', config=conf)
def start_service(): #Make controller and dispatcher objects dictionaryController = DictionaryController() dispatcher = cherrypy.dispatch.RoutesDispatcher() #GET: dispatcher.connect('dict_get', '/dictionary/:key',controller=dictionaryController, action = 'GET',conditions=dict(method=['GET'])) dispatcher.connect('dict_get_all','/dictionary/',controller=dictionaryController, action = 'GET_ALL',conditions=dict(method=['GET'])) #PUT dispatcher.connect('dict_put','/dictionary/:key',controller=dictionaryController, action = 'PUT',conditions=dict(method=['PUT'])) #POST dispatcher.connect('dict_post','/dictionary/',controller=dictionaryController, action = 'POST',conditions=dict(method=['POST'])) #DELETE dispatcher.connect('dict_del','/dictionary/:key',controller=dictionaryController, action = 'DELETE',conditions=dict(method=['DELETE'])) dispatcher.connect('dict_del_all','/dictionary/',controller=dictionaryController, action = 'DELETE_ALL',conditions=dict(method=['DELETE'])) #Configuration conf = {'global': {'server.socket_host': '127.0.0.1', 'server.socket_port':40041}, '/' : {'request.dispatch':dispatcher}} #Update the configuration and start the server cherrypy.config.update(conf) app = cherrypy.tree.mount(None,config=conf) cherrypy.quickstart(app)
def main(): find_rop_gadgets(libcfile) with open('exploit.mp4', 'wb') as tmp: tmp.write(exploit_mp4()) cherrypy.config.update({'server.socket_host': '0.0.0.0'} ) cherrypy.quickstart(ExploitServer())
def start_experiment(configuration_file, results_root_dir): task_dict, param_dict = load_config(configuration_file, results_root_dir) server = ExperimentServer(task_dict, param_dict, render) cherrypy.config.update({'server.socket_port': PORT, 'server.socket_host': '0.0.0.0'}) cherrypy.quickstart(server)
def main(): #cherrypy.config.update({'error_page.404': error_page_404}) cherrypy.config.update('webapiner.ini') core = Core(current_dir) core.loadConfig("") core.initManagers() rest_service = RESTService(core) cherrypy.tree.mount(rest_service, "/api/", config = {'/':{'request.dispatch':cherrypy.dispatch.MethodDispatcher()}}) conf = { '/static': { 'tools.staticdir.on':True, 'tools.staticdir.dir': current_dir + "/static" }, } Root._cp_config = {'tools.staticdir.on' : True, 'tools.staticdir.dir' : os.path.join(current_dir, "static"), 'tools.staticdir.index' : 'index.html', 'tools.caching.on' :False} with open("webapiner.pid","w") as f: f.write(str(os.getpid())) cherrypy.engine.subscribe("stop", core.getManager("asset").stop) core.getManager("asset").start() #core.getManager("kb").autoload() cherrypy.quickstart(Root(core), config = conf)
def main(): global db root = Root() root.movie = Movies() root.tv = TV() root.about = About() root.media = Media() root.atv = ATV() root.log = Log() conf = { 'global': { 'server.socket_host': '0.0.0.0', 'server.socket_port': PORT, 'tools.staticdir.root': '/Users/dschuetz/Work/AppleTV/rPI', }, '/': { 'request.dispatch': cherrypy.dispatch.MethodDispatcher(), }, '/images': { 'tools.staticdir.on': True, 'tools.staticdir.dir': 'images', } } cherrypy.quickstart(root, '/', conf)
.new-date { border-bottom: 2px solid #666; } #flaky-rate tr :nth-child(1) { width: 70%; } /* make sparkline data not show up before loading */ .inlinesparkline { color: #fff; } /* fix sparkline tooltips */ .jqstooltip { -webkit-box-sizing: content-box; -moz-box-sizing: content-box; box-sizing: content-box; } </style> </head> <body> <script src="//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script> <script src="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js"></script> <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-sparklines/2.1.2/jquery.sparkline.min.js"></script> <div class="container-fluid"> {{ body }} </div> </body> </html> """) return template.render(body=body) if __name__ == "__main__": logging.basicConfig(level=logging.INFO) cherrypy.config.update({'server.socket_host': '0.0.0.0'}) cherrypy.quickstart(TRServer())
import random import string import cherrypy class StringGenerator(object): @cherrypy.expose def index(self): return """<html> <head></head> <body> <form method="get" action="generate"> <input type="text" value="8" name="length" /> <button type="submit">Give it now!</button> </form> </body> </html>""" @cherrypy.expose def generate(self, length=8): return "".join(random.sample(string.hexdigits, int(length))) if __name__ == "__main__": cherrypy.quickstart(StringGenerator())
return 'Invalid input parameter(s)' @cherrypy.expose def SourceUsbNew(self, name=None, width=None, height=None, fps_n=None, fps_d=None): if name and width and height and fps_n and fps_d: try: retval = dms_source_usb_new(name, int(width), int(height), int(fps_n), int(fps_d)) except: retval = sys.exc_info()[0] return retval else: return 'Invalid input parameter(s)' root = Root() hostconf = os.path.join(os.path.dirname(__file__), 'host.conf') if __name__ == '__main__': # CherryPy always starts with app.root when trying to map request URIs # to objects, so we need to mount a request handler root. A request # to '/' will be mapped to Root().index(). cherrypy.quickstart(root, config=hostconf)
#@-others root = Gear() # setup static, images and downloads directories application_conf = { '/static': { 'tools.staticdir.on': True, 'tools.staticdir.dir': _curdir + "/static" }, '/images': { 'tools.staticdir.on': True, 'tools.staticdir.dir': data_dir + "/images" }, '/downloads': { 'tools.staticdir.on': True, 'tools.staticdir.dir': data_dir + "/downloads" } } # if inOpenshift ('OPENSHIFT_REPO_DIR' exists in environment variables) or not inOpenshift if __name__ == '__main__': if 'OPENSHIFT_REPO_DIR' in os.environ.keys(): # operate in OpenShift application = cherrypy.Application(root, config=application_conf) else: # operate in localhost cherrypy.quickstart(root, config=application_conf) #@-leo
import cherrypy class EventCriteria(object): @cherrypy.expose def request(self): return 'hello world' cherrypy.quickstart(EventCriteria(), '/', "/src/server.conf")
#!/usr/bin/python3 import cherrypy config = { 'global' : { #'server.socket_host' : '192.168.0.109', 'server.socket_port' : 8080 } } class Servidor(object): @cherrypy.expose def index(self): return 'Hello World!' @cherrypy.expose def greet(self, name): return 'Hello {}!'.format(name) cherrypy.quickstart(Servidor(),'/',config)
}); </script> </head> <body> <form action='/echo' id='chatform' method='get'> <textarea id='chat' cols='35' rows='10'></textarea> <br /> <label for='message'>%(username)s: </label><input type='text' id='message' /> <input type='submit' value='Send' /> </form> </body> </html> """ % { 'username': "******" % random.randint(0, 100) } @cherrypy.expose def index(self): cherrypy.log("Handler created: %s" % repr(cherrypy.request.ws_handler)) cherrypy.quickstart(Root(), '/', config={ '/': { 'tools.websocket.on': True, 'tools.websocket.handler_cls': EchoWebSocketHandler } })
import base64 class HelloWorld: def index(self): d = self.plot() return ''' <form action="/"> <label for="fname">First name:</label><br> <input type="text" id="fname" name="firstname" value="John"><br> <label for="lname">Last name:</label><br> <input type="text" id="lname" name="lname" value="Doe"><br><br> <input type="submit" value="Submit"> </form> <img src="data:image/png;base64,%s" width="640" height="480" border="0" /> ''' % ( d.decode('utf8')) index.exposed = True print(cherrypy.request.params.get('firstname')) def plot(self): image = BytesIO() x = numpy.linspace(0, 10) y = numpy.sin(x) pyplot.plot(x, y) pyplot.savefig(image, format='png') return base64.encodestring(image.getvalue()) if __name__ == '__main__': cherrypy.quickstart(HelloWorld())
if 'content-length' in cherrypy.request.headers and 'content-type' in cherrypy.request.headers and cherrypy.request.headers[ 'content-type'] == 'application/json': length = int(cherrypy.request.headers['content-length']) json_string = cherrypy.request.body.read(length).decode("utf-8") update = telebot.types.Update.de_json(json_string) bot.process_new_updates([update]) return '' else: raise cherrypy.HTTPError(403) @bot.message_handler(func=lambda message: True, content_types=['text']) def echo_message(message): bot.reply_to(message, message.text) bot.remove_webhook() bot.set_webhook(url=WEBHOOK_URL_BASE + WEBHOOK_URL_PATH, certificate=open(WEBHOOK_SSL_CERT, 'r')) cherrypy.config.update({ 'server.socket_host': WEBHOOK_LISTEN, 'server.socket_port': WEBHOOK_PORT, 'server.ssl_module': 'builtin', 'server.ssl_certificate': WEBHOOK_SSL_CERT, 'server.ssl_private_key': WEBHOOK_SSL_PRIV }) cherrypy.quickstart(WebhookServer(), WEBHOOK_URL_PATH, {'/': {}})
def __init__(self): self.albums = Album() def _cp_dispatch(self, vpath): if len(vpath) == 1: cherrypy.request.params['name'] = vpath.pop() return self if len(vpath) == 3: cherrypy.request.params['artist'] = vpath.pop(0) # /band name/ vpath.pop(0) # /albums/ cherrypy.request.params['title'] = vpath.pop(0) # /album title/ return self.albums return vpath @cherrypy.expose def index(self, name): return 'About %s...' % name pass class Album(object): @cherrypy.expose def index(self, artist, title): return 'About %s by %s...' % (title, artist) if __name__ == '__main__': cherrypy.quickstart(Band())
if 'content-length' in cherrypy.request.headers and \ 'content-type' in cherrypy.request.headers and \ cherrypy.request.headers['content-type'] == 'application/json': length = int(cherrypy.request.headers['content-length']) json_string = cherrypy.request.body.read(length).decode("utf-8") requests.post(BOT_2_ADDRESS, data=json_string) return '' else: raise cherrypy.HTTPError(403) if __name__ == '__main__': bot_1.remove_webhook() bot_1.set_webhook(url='https://122.122.122.122/AAAA', certificate=open(WEBHOOK_SSL_CERT, 'r')) bot_2.remove_webhook() bot_2.set_webhook(url='https://122.122.122.122/ZZZZ', certificate=open(WEBHOOK_SSL_CERT, 'r')) cherrypy.config.update({ 'server.socket_host': WEBHOOK_LISTEN, 'server.socket_port': WEBHOOK_PORT, 'server.ssl_module': 'builtin', 'server.ssl_certificate': WEBHOOK_SSL_CERT, 'server.ssl_private_key': WEBHOOK_SSL_PRIV, 'engine.autoreload.on': False }) cherrypy.quickstart(WebhookServer(), '/', {'/': {}})
def run(self): conf = {'/': {}} cherrypy.quickstart(self.__root, '/', conf)
def __init__(self, queue): self.queue = queue @cherrypy.tools.json_out() def GET(self): return "okay" @cherrypy.tools.json_in() @cherrypy.tools.json_out() def POST(self): print(cherrypy.request.json) if __name__ == "__main__": conf = { '/': { 'request.dispatch': cherrypy.dispatch.MethodDispatcher(), 'tools.response_headers.on': True, 'tools.response_headers.headers': [('Content-Type', 'application/json')] }, 'global': { 'server.socket_host': '0.0.0.0' } } mobileye = MobileyeImageCompressor(JoinableQueue()) cherrypy.quickstart(mobileye, '/', conf)
import cherrypy from cherrypy._cpserver import Server class Hello(object): @cherrypy.expose def index(self): return 'OK' if __name__ == '__main__': port = 8081 for i in range(10): port += 1 server = Server() server.socket_port = port server.subscribe() cherrypy.quickstart(Hello(), '/')
True or False """ with fiona.open(shp) as fc: point = Point(float(lon), float(lat)) # longitude, latitude for feature in fc: if shape(feature['geometry']).contains(point): return True #def capitalizeWords(s): # return re.sub(r'\w+', lambda m:m.group(0).capitalize(), s) static_config = { '/': { 'tools.staticdir.on': True, 'tools.staticdir.dir': PATH, 'tools.staticdir.index': 'index.html', 'log.screen': True, # 'tools.auth_basic.on': True, # 'tools.auth_basic.realm': # 'Please use Chrome or Firefox to access this site.', # 'tools.auth_basic.checkpassword': validate_password }, } cherrypy.config.update({ 'server.socket_host': '0.0.0.0', 'server.socket_port': int(sys.argv[1]), }) cherrypy.quickstart(Root(), config=static_config)
""" Main function. """ import os import sys import cherrypy from archive import Archive def CORS(): """ cors """ cherrypy.response.headers["Access-Control-Allow-Origin"] = "*" if __name__ == '__main__': cherrypy.tools.CORS = cherrypy.Tool('before_handler', CORS) CONF_FILE_REL = sys.argv[1] if len(sys.argv) == 2 and os.path.isfile( sys.argv[1]) else "archive.conf" BASE_DIR = os.path.dirname(os.path.abspath(__file__)) CONF_FILE_ABS = os.path.join(BASE_DIR, CONF_FILE_REL) cherrypy.log.error_log.setLevel('ERROR') cherrypy.config.update(CONF_FILE_ABS) cherrypy.quickstart(Archive.get_instance(), config=CONF_FILE_ABS)
import cherrypy import device_db class DeviceDataWebService(object): @cherrypy.tools.accept(media='application/json') @cherrypy.expose def index(self, brand=None, model=None, os=None, osVersion=None): if not brand: return "" return device_db.new_device_data(brand, model, device_db.OsType[os], osVersion) @cherrypy.expose(['devices']) # @cherrypy.tools.json_out() # not working with Enum for now def devices(self, brand=None, model=None, os=None, osVersion=None, page=None): return device_db.query(brand=brand, model=model, os=device_db.OsType[os] if os else None, osVersion=osVersion, page=page) if __name__ == '__main__': cherrypy.quickstart(DeviceDataWebService())
return json.dumps({"status": "ok"}) @cherrypy.expose def beat(self, beat, ping=-1): if float(ping) > 0: self.starttime = self.starttime - float(ping) / 2 return json.dumps({"currenttime": time.time()}) @cherrypy.expose def start(self): """ with open("bars.json") as bars: sequence = json.loads(bars.read()) bars=sequence["bars"] bpm = sequence["bpm"] self.commands=barToCommands(bars,self.locations,bpm)""" self.starttime = time.time() return json.dumps({"currenttime": time.time()}) if __name__ == '__main__': cherrypy.config.update({ 'server.socket_host': '0.0.0.0', 'server.socket_port': 8080, 'server.ssl_certificate': '/etc/nginx/ssl/nginx.crt', 'server.ssl_private_key': '/etc/nginx/ssl/nginx.key', 'tools.sessions.on': True, 'tools.sessions.timeout': 10 }) cherrypy.quickstart(flashserver())
my_database.exposed = True def exit_application(self): mainframe.engine.exit() exit_contents = """ <section class="col-sm-6 mx-auto text-center text-info"> <label>You have exited the CGPA Application</label> </section> """ return self.display.page_open( ), exit_contents, self.display.page_close() exit_application.exposed = True #Initialization of application on custom server and port if __name__ == '__main__': current_dir = os.path.dirname(os.path.abspath(__file__)) conf = { "global": { "server.socket_host": '127.0.0.1', "server.socket_port": 3000, "server.thread_pool": 10 }, "/": { "tools.staticdir.on": True, "tools.staticdir.dir": current_dir } } mainframe.quickstart(CummulativeGradePointAverage(), "/", config=conf)
# Start rpyc server thread.start_new_thread(RPYC_SERVER.start, ()) logInfo('RPYC Serving on 0.0.0.0:{}'.format(RPYC_PORT)) # CherryPy config CONF = { 'global': { 'server.socket_host': '0.0.0.0', 'server.socket_port': SERVER_PORT, 'server.thread_pool': 90, 'engine.autoreload.on': False, 'log.screen': False, 'tools.sessions.on': True, 'tools.sessions.timeout': 60 * 24 * 365, 'tools.auth_basic.on': True, 'tools.auth_basic.realm': 'Twister Server', 'tools.auth_basic.checkpassword': Project.check_passwd, }, '/static': { 'tools.staticdir.on': True, 'tools.staticdir.dir': TWISTER_PATH + '/server/static', }, } # Start ! cherrypy.engine.signal_handler.handlers['SIGTERM'] = close cherrypy.quickstart(CE, '/', config=CONF) #
</script> <a href="javascript:startPolling();">start</a> | <a href="javascript:stopPolling();">stop</a> <br/> <a href="/">Okay then</a> """ @cherrypy.expose def poll(self): if not self.conn: self.conn = pymongo.Connection(mongostring) while True: try: return "%s" % self.conn.data.thingoes.find({'x': True}).count() except AutoReconnect: continue except: break if __name__ == '__main__': current_dir = os.path.dirname(os.path.abspath(__file__)) print current_dir conf = { '/': { 'tools.staticdir.on': True, 'tools.staticdir.dir': current_dir + '/files' }, } cherrypy.quickstart(Root(), "/", config=conf)
"redirect_uri": callback } req = requests.Request('GET', url, params=payload) p = req.prepare() raise cherrypy.HTTPRedirect(p.url) def authresponse(self, var=None, **params): code = urllib.quote(cherrypy.request.params['code']) callback = cherrypy.url() payload = { "client_id": CLIENT_ID, "client_secret": CLIENT_SECRET, "code": code, "grant_type": "authorization_code", "redirect_uri": callback } url = "https://api.amazon.com/auth/o2/token" r = requests.post(url, data=payload) resp = r.json() return "Success! Here is your refresh token:<br>{}".format( resp['refresh_token']) index.exposed = True authresponse.exposed = True cherrypy.config.update({'server.socket_host': 'localhost'}) cherrypy.config.update({'server.socket_port': WEB_PORT}) print('Open http://localhost:3000 to login in amazon alexa service') cherrypy.quickstart(Start())
st = story.split('.') body = [] for i in st: body.append(pr.get_cont(i, title)) rep = '\n'.join(body) s = s.replace('{{body}}', rep) return s if __name__ == '__main__': conf = { '/': { 'tools.sessions.on': True, 'tools.staticdir.root': os.path.abspath(os.getcwd()), 'engine.autoreload_on': False, }, '/generator': { 'request.dispatch': cherrypy.dispatch.MethodDispatcher(), 'tools.response_headers.on': True, 'tools.response_headers.headers': [('Content-Type', 'text/plain')], }, '/static': { 'tools.staticdir.on': True, 'tools.staticdir.dir': './public' } } webapp = StringGenerator() #webapp.generator = StringGeneratorWebService() cherrypy.quickstart(webapp, '/', conf)
def start(self): self._build() cherrypy.quickstart(self.server)
transform_output = io.StringIO() with redirect_stdout(transform_output): transform_json(boardstate) move_param = transform_output.getvalue() request = cherrypy.serving.request request.json = loads(move_param) move_output = io.StringIO() with redirect_stdout(move_output): result = self.move() output = move_output.getvalue() return ( f'{html_begin}{boardstate}{html_middle}<hr>{result}<br><textarea rows="16" cols="120">{output}</textarea>{html_end}' ) def log(self, message): # output message iwth globals print(f"{self.game_id} [{self.turn}] {message}") if __name__ == "__main__": server = Battlesnake() cherrypy.config.update({"server.socket_host": "0.0.0.0"}) cherrypy.config.update({ "server.socket_port": int(os.environ.get("PORT", "8080")), }) print("Starting Battlesnake Server...") cherrypy.quickstart(server)
import cherrypy from cherrypy import expose class Converter: @expose def index(self): return "Hello World!" @expose def fahr_to_celc(self, degrees): temp = (float(degrees) - 32) * 5 / 9 return "%.01f" % temp @expose def celc_to_fahr(self, degrees): temp = float(degrees) * 9 / 5 + 32 return "%.01f" % temp cherrypy.quickstart(Converter())
def main(): cherrypy.quickstart(TimeService())
def start(): cherrypy.quickstart(ScoutServer(), '/', conf)
import cherrypy import os import searchassistant class HelloWorld(object): # Method test = searchassistant.Test() # Method @cherrypy.expose def index(self): return "Hello world!" conf = { 'global': { 'server.socket_host': '0.0.0.0', 'server.socket_port': int(os.environ.get('PORT', 8084)), }, '/': { 'tools.staticdir.root': os.path.abspath(os.getcwd()) }, '/static': { 'tools.staticdir.on': True, 'tools.staticdir.dir': './static' } } cherrypy.quickstart(HelloWorld(), '/', config=conf)
'user': self.get_user(), 'year': datetime.now().year, } return self.render('formProfissional.html', tparams) @cherrypy.expose def logout(self): self.set_user() raise cherrypy.HTTPRedirect("/") @cherrypy.expose def signup(self): pass @cherrypy.expose def shut(self): cherrypy.engine.exit() if __name__ == '__main__': conf = { '/': { 'tools.sessions.on': True, 'tools.staticdir.root': os.path.abspath(os.getcwd()) }, '/static': { 'tools.staticdir.on': True, 'tools.staticdir.dir': './static' } } cherrypy.quickstart(WebApp(), '/', conf)