def main(): app = create_app() log_fmt = logging.Formatter("[%(asctime)s] %(module)s " "%(levelname)s %(message)s") suggestion_log_path = os.path.join(app.instance_path, 'database.log') suggestion_handler = logging.FileHandler(suggestion_log_path) suggestion_handler.setFormatter(log_fmt) database.log.addHandler(suggestion_handler) import sys if len(sys.argv) > 1: cmd = sys.argv[1] else: cmd = 'runserver' if cmd == 'runserver': app.run(debug=True) elif cmd == 'shell': from code import interact with app.test_request_context(): interact(local={'app': app}) elif cmd == 'fastcgi': from flup.server.fcgi import WSGIServer error_log_path = os.path.join(app.instance_path, 'error.log') error_handler = logging.FileHandler(error_log_path) error_handler.setFormatter(log_fmt) error_handler.setLevel(logging.ERROR) logging.getLogger().addHandler(error_handler) sock_path = os.path.join(app.instance_path, 'fcgi.sock') server = WSGIServer(app, bindAddress=sock_path, umask=0) server.run()
def _runFlup(app, config, mode): """Run WsgiDAV using flup.server.fcgi, if Flup is installed.""" try: # http://trac.saddi.com/flup/wiki/FlupServers if mode == "flup-fcgi" or "runfcgi": from flup.server.fcgi import WSGIServer, __version__ as flupver elif mode == "flup-fcgi_fork": from flup.server.fcgi_fork import WSGIServer, __version__ as flupver else: raise ValueError if config["verbose"] >= 2: print "Running WsgiDAV/%s %s/%s..." % (__version__, WSGIServer.__module__, flupver) server = WSGIServer(app, bindAddress=(config["host"], config["port"]), # bindAddress=("127.0.0.1", 8001), # debug=True, ) server.run() except ImportError, e: if config["verbose"] >= 1: print "Could not import flup.server.fcgi", e return False
class FlupFCGIServer(object): """Adapter for a flup.server.fcgi.WSGIServer.""" def __init__(self, *args, **kwargs): from flup.server.fcgi import WSGIServer self.fcgiserver = WSGIServer(*args, **kwargs) # TODO: report this bug upstream to flup. # If we don't set _oldSIGs on Windows, we get: # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 108, in run # self._restoreSignalHandlers() # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 156, in _restoreSignalHandlers # for signum,handler in self._oldSIGs: # AttributeError: 'WSGIServer' object has no attribute '_oldSIGs' self.fcgiserver._oldSIGs = [] self.ready = False def start(self): """Start the FCGI server.""" self.ready = True self.fcgiserver.run() def stop(self): """Stop the HTTP server.""" self.ready = False # Forcibly stop the fcgi server main event loop. self.fcgiserver._keepGoing = False # Force all worker threads to die off. self.fcgiserver._threadPool.maxSpare = 0
class FlupSCGIServer(object): """Adapter for a flup.server.scgi.WSGIServer.""" def __init__(self, *args, **kwargs): self.args = args self.kwargs = kwargs self.ready = False def start(self): """Start the SCGI server.""" # We have to instantiate the server class here because its __init__ # starts a threadpool. If we do it too early, daemonize won't work. from flup.server.scgi import WSGIServer self.scgiserver = WSGIServer(*self.args, **self.kwargs) # TODO: report this bug upstream to flup. # If we don't set _oldSIGs on Windows, we get: # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 108, in run # self._restoreSignalHandlers() # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 156, in _restoreSignalHandlers # for signum,handler in self._oldSIGs: # AttributeError: 'WSGIServer' object has no attribute '_oldSIGs' self.scgiserver._installSignalHandlers = lambda: None self.scgiserver._oldSIGs = [] self.ready = True self.scgiserver.run() def stop(self): """Stop the HTTP server.""" self.ready = False # Forcibly stop the scgi server main event loop. self.scgiserver._keepGoing = False # Force all worker threads to die off. self.scgiserver._threadPool.maxSpare = 0
def main(): app = create_app() log_fmt = logging.Formatter("[%(asctime)s] %(module)s " "%(levelname)s %(message)s") suggestion_log_path = os.path.join(app.instance_path, "database.log") suggestion_handler = logging.FileHandler(suggestion_log_path) suggestion_handler.setFormatter(log_fmt) database.log.addHandler(suggestion_handler) import sys if len(sys.argv) > 1: cmd = sys.argv[1] else: cmd = "runserver" if cmd == "runserver": app.run(debug=True) elif cmd == "shell": from code import interact with app.test_request_context(): interact(local={"app": app}) elif cmd == "fastcgi": from flup.server.fcgi import WSGIServer error_log_path = os.path.join(app.instance_path, "error.log") error_handler = logging.FileHandler(error_log_path) error_handler.setFormatter(log_fmt) error_handler.setLevel(logging.ERROR) logging.getLogger().addHandler(error_handler) sock_path = os.path.join(app.instance_path, "fcgi.sock") server = WSGIServer(app, bindAddress=sock_path, umask=0) server.run() elif cmd == "update_identities": import sync with app.test_request_context(): sync.update_identities() elif cmd == "new_people": with app.test_request_context(): database.add_people(line.strip() for line in sys.stdin) database.db.session.commit()
class FlupFCGIServer(object): """Adapter for a flup.server.fcgi.WSGIServer.""" def __init__(self, *args, **kwargs): if kwargs.get('bindAddress', None) is None: import socket if not hasattr(socket.socket, 'fromfd'): raise ValueError( 'Dynamic FCGI server not available on this platform. ' 'You must use a static or external one by providing a ' 'legal bindAddress.') self.args = args self.kwargs = kwargs self.ready = False def start(self): """Start the FCGI server.""" # We have to instantiate the server class here because its __init__ # starts a threadpool. If we do it too early, daemonize won't work. from flup.server.fcgi import WSGIServer self.fcgiserver = WSGIServer(*self.args, **self.kwargs) # TODO: report this bug upstream to flup. # If we don't set _oldSIGs on Windows, we get: # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 108, in run # self._restoreSignalHandlers() # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 156, in _restoreSignalHandlers # for signum,handler in self._oldSIGs: # AttributeError: 'WSGIServer' object has no attribute '_oldSIGs' self.fcgiserver._installSignalHandlers = lambda: None self.fcgiserver._oldSIGs = [] self.ready = True self.fcgiserver.run() def stop(self): """Stop the HTTP server.""" # Forcibly stop the fcgi server main event loop. self.fcgiserver._keepGoing = False # Force all worker threads to die off. self.fcgiserver._threadPool.maxSpare = self.fcgiserver._threadPool._idleCount self.ready = False
def __init__(self, *args, **kwargs): from flup.server.fcgi import WSGIServer self.fcgiserver = WSGIServer(*args, **kwargs) # TODO: report this bug upstream to flup. # If we don't set _oldSIGs on Windows, we get: # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 108, in run # self._restoreSignalHandlers() # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 156, in _restoreSignalHandlers # for signum,handler in self._oldSIGs: # AttributeError: 'WSGIServer' object has no attribute '_oldSIGs' self.fcgiserver._oldSIGs = [] self.ready = False
def start(self): """Start the SCGI server.""" # We have to instantiate the server class here because its __init__ # starts a threadpool. If we do it too early, daemonize won't work. from flup.server.scgi import WSGIServer self.scgiserver = WSGIServer(*self.args, **self.kwargs) # TODO: report this bug upstream to flup. # If we don't set _oldSIGs on Windows, we get: # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 108, in run # self._restoreSignalHandlers() # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 156, in _restoreSignalHandlers # for signum,handler in self._oldSIGs: # AttributeError: 'WSGIServer' object has no attribute '_oldSIGs' self.scgiserver._installSignalHandlers = lambda: None self.scgiserver._oldSIGs = [] self.ready = True self.scgiserver.run()
print I_N_P_U_T""" % code from os import urandom random_filename = '/tmp/' + urandom(10).encode('hex') f = open(random_filename, 'w') f.write(python_code) f.close() f = open('log/code', 'a') f.write(request.remote_addr + "\n" + code + "\r\n-------------\r\n") f.close() result = subprocess.Popen('python %s' % (random_filename), shell=True, stdout=subprocess.PIPE).communicate()[0] os.remove(random_filename) HTML += "\n\t\t\t\t-----------------------------------\n\t\t\t\t<strong style='color:White;'>%s</strong>\n</pre>" % result return HTML if __name__ == "__main__": if (sys.argv[1] == 'test'): app.run(host='0.0.0.0', port=4000, debug=True) else: PORT = 40002 print '------------------------' print 'Running on port', int(PORT) WSGIServer(app, multithreaded=True, bindAddress=('0.0.0.0', int(PORT))).run()
def run(self, handler): from flup.server.fcgi import WSGIServer WSGIServer(handler, bindAddress=(self.host, self.port)).run()
# published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. import logging from flup.server.fcgi import WSGIServer from talkatv import app # Explicitly set app.debug to false, otherwise flask will swallow any exceptions # that are raised from the app. app.debug = False if __name__ == '__main__': # Set up logging, even though app.debug is off we'll probably want the logs. handler = logging.StreamHandler() handler.setFormatter(logging.Formatter(app.debug_log_format)) app.logger.addHandler(handler) app.logger.setLevel(logging.DEBUG) app.logger.info('Starting WSGI server on {0}'.format( app.config['WSGI_BIND_ADDR'])) WSGIServer(app, bindAddress=app.config['WSGI_BIND_ADDR']).run()
session = web.session.Session(app, web.session.DiskStore('sessions')) web.config._session = session def notfound(): return web.notfound(render.notfound()) app.notfound = notfound app.add_processor(web.loadhook(auth_admin)) app.add_processor(web.unloadhook(baseutils.assert_closed)) if __name__ == '__main__': if len(sys.argv) == 1: app.run() elif sys.argv[1] == 'deploy': # if "deploy" in sys.argv: from flup.server.fcgi import WSGIServer func = app.wsgifunc() server_address = '/tmp/nowater_novel.sock' WSGIServer( func, bindAddress=server_address, maxSpare=16, minSpare=16, # maxRequests=128, # maxChildren=32 ).run() else: application = app.wsgifunc()
#!/usr/bin/python def myapp(environ, start_response): start_response('200 OK', [('Content-Type', 'text/plain')]) return ['PONG'] from flup.server.fcgi import WSGIServer WSGIServer(myapp).run()
logger.info("%s replies with %s results" % (VEP.getRESTserver(), len(rows))) # check if assembly is correct in each variation. # SUPPORTED_ASSEMBLIES[assembly] is a dictionary where keys are SNPchimp # assemblies, and values are HARD CODED ensembl assemblies logger.debug("Checking if assembly is supported...") try: VEP.CheckAssembly(SUPPORTED_ASSEMBLIES[assembly]) except EnsEMBL.VEP.VePException as e: message = "Assembly '%s' is not supported by EnsEMBL: %s" % (assembly, e) logger.critical(message) return mytemplate.render(header=[], rows=[], message=message) # now transforming ensembl names in link logger.debug("Add html link to table...") rows = linkifyTable(rows, header, animal) logger.debug("completed!") # Script finish here logger.info("CGI script finished") # print data with mako templayes return mytemplate.render(header=header, rows=rows) if __name__ == '__main__': WSGIServer(myapp, bindAddress=('0.0.0.0', 8000), umask=0).run()
#!/usr/bin/env python from webapp import create_app app = create_app('config.cfg') from flup.server.fcgi import WSGIServer WSGIServer(app, bindAddress='/tmp/webapp.sock').run()
default='0.0.0.0', help='accesible address') parser.add_argument('-p', '--port', default=5125, type=int, help='port') parser.add_argument('-d', '--debug', action='store_true', help='debug mode') return parser.parse_args(argv[1:]) if __name__ == "__main__": args = parse_arg(sys.argv) controler = Controler(os.path.abspath('../model')) # emotions = np.array(controler.list_model()['LJ40K_svm']) emotions = np.array(controler.list_model()['YAHOO_svm']) logger = Logger() if args.debug: args.port += 1 app.run(args.address, args.port, debug=False, threaded=True, use_reloader=False) else: print "* Running on http://{}:{}/".format(args.address, args.port) WSGIServer(app, multithreaded=True, bindAddress=(args.address, args.port)).run()
def _mainloopPeriodic(self): WSGIServer._mainloopPeriodic(self) if getmtime(__file__) != START_TIME: self._keepGoing = False
def handle(self, app): _error_log(os.path.join(app.instance_path, 'error.log')) from flup.server.fcgi import WSGIServer sock_path = os.path.join(app.instance_path, 'fcgi.sock') server = WSGIServer(app, bindAddress=sock_path, umask=0) server.run()
def run( app=None, components=(), method=STANDALONE, name="retro", root = ".", resetlog=False, address="", port=None, prefix='', asynchronous=False, sessions=False, withReactor=None, processStack=lambda x:x, runCondition=lambda:True, onError=None ): """Runs this web application with the given method (easiest one is STANDALONE), with the given root (directory from where the web app-related resource will be resolved). This function is the 'main' for your web application, so this is basically the last call you should have in your web application main.""" if app == None: app = Application(prefix=prefix,components=components) else: for _ in components: app.register(_) # We set up the configuration if necessary config = app.config() if not config: config = Configuration(CONFIG) # Adjusts the working directory to basepath root = os.path.abspath(root) if os.path.isfile(root): root = os.path.dirname(root) # We set the application root to the given root, and do a chdir os.chdir(root) config.setdefault("root", root) config.setdefault("name", name) config.setdefault("logfile", name + ".log") if resetlog: os.path.unlink(config.logfile()) # We set the configuration app.config(config) # And start the application app.start() # NOTE: Maybe we should always print it #print app.config() # We start the WSGI stack stack = app._dispatcher stack = processStack(stack) # == FCGI (Flup-provided) # if method == FCGI: if not has(FLUP): raise ImportError("Flup is required to run FCGI") fcgi_address = address or config.get("address") fcgi_port = port or config.get("port") if fcgi_port and fcgi_address: server = FLUP_FCGIServer(stack, bindAddress=(fcgi_address, fcgi_port)) elif fcgi_address: server = FLUP_FCGIServer(stack, bindAddress=fcgi_address) else: server = FLUP_FCGIServer(stack) server.run() # # == SCGI (Flup-provided) # elif method == SCGI: if not has(FLUP): raise ImportError("Flup is required to run SCGI") fcgi_address = address or config.get("address") fcgi_port = port or config.get("port") if fcgi_port and fcgi_address: server = FLUP_SCGIServer(stack, bindAddress=(fcgi_address, fcgi_port)) elif fcgi_address: server = FLUP_SCGIServer(stack, bindAddress=fcgi_address) else: server = FLUP_SCGIServer(stack) server.run() # # == CGI # elif method == CGI: environ = {} ; environ.update(os.environ) # From <http://www.python.org/dev/peps/pep-0333/#the-server-gateway-side> environ['wsgi.input'] = sys.stdin environ['wsgi.errors'] = sys.stderr environ['wsgi.version'] = (1,0) environ['wsgi.multithread'] = False environ['wsgi.multiprocess'] = True environ['wsgi.run_once'] = True if environ.get('HTTPS','off') in ('on','1'): environ['wsgi.url_scheme'] = 'https' else: environ['wsgi.url_scheme'] = 'http' # FIXME: Don't know if it's the proper solution req_uri = environ["REQUEST_URI"] script_name = environ["SCRIPT_NAME"] if req_uri.startswith(script_name): environ["PATH_INFO"] = req_uri[len(script_name):] else: environ["PATH_INFO"] = "/" if sessions: environ["com.saddi.service.session"] = sessions def start_response( status, headers, executionInfo=None ): for key, value in headers: print ("%s: %s" % (key, value)) print () # FIXME: This is broken res = "".join(tuple(self.dispatcher(environ, start_response))) print (res) if sessions: sessions.close() # # == GEVENT, BJOERN, ROCKET & WSGI # elif method in (GEVENT, BJOERN, ROCKET, WSGI): host = config.get("host") port = config.get("port") try: import reporter as logging except: import logging def application(environ, startResponse): # Gevent needs a wrapper if "retro.app" not in environ: environ["retro.app"] = stack.app() return environ["retro.app"](environ, startResponse) def logged_application(environ, startResponse): logging.info("{0} {1}".format(environ["REQUEST_METHOD"], environ["PATH_INFO"])) if "retro.app" not in environ: environ["retro.app"] = stack.app() return environ["retro.app"](environ, startResponse) if method == "GEVENT": try: from gevent import wsgi except ImportError: raise ImportError("gevent is required to run `gevent` method") # NOTE: This starts using gevent's WSGI server (faster!) wsgi.WSGIServer((host,port), application, spawn=None).serve_forever() elif method == BJOERN: try: import bjoern except ImportError: raise ImportError("bjoern is required to run `bjoern` method") bjoern.run(logged_application, host, port) elif method == ROCKET: try: import rocket except ImportError: raise ImportError("rocket is required to run `rocket` method") rocket.Rocket((host, int(port)), "wsgi", {"wsgi_app":application}).start() elif method == WSGI: # When using standalone WSGI, we make sure to wrap RendezVous objects # that might be returned by the handlers, and make sure we wait for # them -- we could use a callback version instead for specific web # servers. def retro_rendezvous_wrapper( environ, start_response, request=None): results = stack(environ, start_response, request) for result in results: if isinstance(result, RendezVous): result.wait() continue yield result retro_rendezvous_wrapper.stack = stack return retro_rendezvous_wrapper # == STANDALONE (WSGIREF) # # elif method == STANDALONE_WSGIREF: # server_address = ( # address or app.config("address") or DEFAULT_ADDRESS, # port or app.config("port") or DEFAULT_PORT # ) # server = WSGIServer(server_address, WSGIRequestHandler) # server.set_app(stack) # socket = server.socket.getsockname() # print "WSGIREF server listening on %s:%s" % ( socket[0], socket[1]) # try: # while runCondition: server.handle_request() # except KeyboardInterrupt: # print "done" # # == STANDALONE (Retro WSGI server) # elif method in (STANDALONE, AIO): try: import reporter as logging except: import logging server_address = ( address or app.config("address") or DEFAULT_ADDRESS, int(port or app.config("port") or DEFAULT_PORT) ) stack.fromRetro = True stack.app = lambda: app if method == STANDALONE and not asynchronous: import retro.wsgi try: server = retro.wsgi.WSGIServer(server_address, stack) retro.wsgi.onError(onError) socket = server.socket.getsockname() print ("Retro embedded server listening on %s:%s" % ( socket[0], socket[1])) except Exception as e: logging.error("Retro: Cannot bind to {0}:{1}, error: {2}".format(server_address[0], server_address[1], e)) return -1 # TODO: Support runCondition try: while runCondition(): server.handle_request() except KeyboardInterrupt: print ("done") else: import retro.aio import asyncio retro.aio.run(app, server_address[0], server_address[1]) # TODO: Support runCondition else: raise Exception("Unknown retro setup method:" + method)
def __init__(self): WSGIServer.__init__(self, self.application, debug=False)
def handle(self, app, sock): _production_logging(app) from flup.server.fcgi import WSGIServer server = WSGIServer(app, bindAddress=sock, umask=0, maxThreads=5) server.run()
#!/usr/bin/env python import os from flup.server.fcgi import WSGIServer import server wsgi = WSGIServer(server.app, bindAddress="/var/www/run/starroamer.sock", umask=0002) print("running as process %s" % os.getpid()) while wsgi.run(): reload(server) wsgi.application = server.app print("application reloaded")
if message: headers[0] = ('Content-Type', 'image/png') try: font = ImageFont.truetype(_FONT_PATH, _FONT_SIZE) size = [i.__add__(_OFFSET[0]) for i in font.getsize(message)] image = Image.new("RGB", size, _BG_COLOR) draw = ImageDraw.Draw(image) draw.text(_OFFSET, message, font=font, fill=_FONT_COLOR) output = StringIO() image.save(output, _FORMAT) message = output.getvalue() output.close() except: error = open(_ERROR_IMAGE) message = error.read() error.close() else: message = "Usage: http://%s?addr=base64-string" % environ['HTTP_HOST'] start_response('200 OK', headers) return [message] if __name__ == '__main__': WSGIServer(MageHandler, **wsgi_opts).run()
# testLang = u"en"; # testItems = { # u"Luis Hernández": 1, # u"Mexikói labdarúgó-válogatott": 1, # u"Labdarúgó": 1, # u"CA Boca Juniors": 1, # u"CF Monterrey": 1 # } # testLang = u"hu"; # testItems = { # u"باشگاه فوتبال بوکا جونیورز": 1, # u"فوتبال": 1, # u"زبان اسپانیایی": 1, # u"آرژانتین": 1}; # testLang = u"fa"; # logging.basicConfig(level=logging.DEBUG) # recommender = LinkRecommender(lang=testLang, nrecs=2500, verbose=True); # recommender.connect(); # recs = recommender.get_recs(item_map=testItems, \ # param_map=dict({u'nrecs': 2500,u'lang': testLang})); # recommender.close(); # print "Received %d recommendations." % (len(recs),); # Also, comment out these if you run from command line wsgi = WSGIServer(app); wsgi.run();
#!/usr/bin/python """ FastCGI server using flup. Reloads on SIGHUP. """ import site, os site.addsitedir(os.path.dirname(__file__)) import restrack.server from flup.server.fcgi import WSGIServer import os, sys, logging, site lh = logging.StreamHandler(sys.stderr) lh.setFormatter(logging.Formatter(restrack.server.FORMAT)) logging.root.addHandler(lh) logging.root.setLevel(logging.DEBUG) f = open('/tmp/restracker.pid', 'w') f.write(str(os.getpid())) f.close() try: ws = WSGIServer(restrack.server.restracker_app, bindAddress='/tmp/restracker.sock') rerun = ws.run() finally: os.unlink('/tmp/restracker.pid') if rerun: os.spawnv(__file__, sys.argv)
from flup.server.fcgi import WSGIServer from weeklypedia.labs import wsgi_app wsgi_server = WSGIServer(wsgi_app) if __name__ == "__main__": wsgi_server.run()
def fastcgi(wsgi_application, spawn=False, address=('127.0.0.1', 9000), use=os.environ.get("WSGI_FCGI_LIB")): "Creates an FastCGI server for wsgi_application." if spawn: valid_libs = VALID_FCGI_SPAWN address = None else: valid_libs = VALID_FCGI_SERVER if use is None: use_libs = valid_libs else: if use.lower() not in valid_libs: raise ValueError("Invalid FastCGI library. " "Valid for the selected mode are: {}".format( ", ".join(valid_libs))) use_libs = [use.lower()] for lib in use_libs: try: if lib == "gevent-fastcgi": from gevent_fastcgi.server import FastCGIServer from gevent_fastcgi.wsgi import WSGIRequestHandler request_handler = WSGIRequestHandler(wsgi_application) server = FastCGIServer(address, request_handler, num_workers=cpu_count()) sys.stderr.write("FCGI library: gevent-fastcgi\n") server.serve_forever() break elif lib in ("flup", "flup6"): from flup.server.fcgi import WSGIServer server = WSGIServer(wsgi_application, bindAddress=address) sys.stderr.write("FCGI library: flup/flup6\n") server.run() break elif lib == "flipflop": from flipflop import WSGIServer server = WSGIServer(wsgi_application) sys.stderr.write("FCGI library: flipflop\n") server.run() break except (ImportError, SyntaxError): continue except KeyboardInterrupt: sys.stderr.write("\nAborted.\n") break else: if len(use_libs) == 1: sys.stderr.write( "The selected FastCGI library could not be used.\n") else: sys.stderr.write("No usable FastCGI library found.\n") return 1 return 0
answer = dns.resolver.query(domain + ".lan", "a") for record in answer: if record.address == ip: break else: return update = dns.update.Update("lan") update.delete(domain, "a") dns.query.tcp(update, "127.0.0.1") def domain_manager(env, responde): if not env["QUERY_STRING"]: return info_page(env, responde) params = urlparse.parse_qs(env["QUERY_STRING"]) if "action" in params and "domain" in params: domain = validate_domain(params["domain"][0].decode("utf-8")) if domain: if "add" in params["action"]: domain_add(domain, env["REMOTE_ADDR"]) elif "delete" in params["action"]: domain_delete(domain, env["REMOTE_ADDR"]) responde("303 Did it. Now go back", [("Location", env.get("HTTP_REFERER", env["SCRIPT_NAME"]))]) return [] if __name__ == "__main__": from flup.server.fcgi import WSGIServer WSGIServer(domain_manager).run()
# http://www.gnu.org/licenses/gpl.html # # Contributors: # Proxima Centauri srl <*****@*****.**> - initial API and implementation #------------------------------------------------------------------------------- #!/usr/bin/python # -*- coding: utf-8 -*- from bottle import route, run, request, abort, static_file, template, default_app import bottle from gui import * from gzipper import Gzipper # set up the application path # first the static file path # the second the api path setup('/static/gui', "/api", "/gui/", "/rrd/graph/") app = Gzipper(app, content_types=set([ 'text/plain', 'text/html', 'text/css', 'application/json', 'application/x-javascript', 'text/xml', 'application/javascript', 'application/xml', 'application/xml+rss', 'text/javascript', 'image/svg', 'image/svg+xml' ])) if __name__ == '__main__': from flup.server.fcgi import WSGIServer WSGIServer(app, multithreaded=False).run()
def runfcgi(socket): from flup.server.fcgi import WSGIServer app = create_app() WSGIServer(app, debug=app.debug, bindAddress=socket, umask=0).run()
from flup.server.fcgi import WSGIServer from pygal import Line from pp_log import posix_logger from pp_db import mysql_db, redis_db #======================================= logger = posix_logger('pygal.log') mysql = mysql_db() redis = redis_db() if mysql != None: logger.info('mysql connect init ok') if redis != None: logger.info('redis connect init ok') #======================================= def application(env, start_response): global logger, mysql, redis req = env['REQUEST_URI'].split('/', 2)[2].strip().strip('?') logger.debug(req) data = redis.get(req) if data == None: data = (req + ':Data no found !!!').encode() start_response('200 OK', [('Content-Type', 'text/html')]) return [data] WSGIServer(application, bindAddress=('127.0.0.1', 9090)).run()
#!/usr/bin/env python from bak.fkmv import create_app app = create_app('config.cfg') from flup.server.fcgi import WSGIServer WSGIServer(app, bindAddress='/tmp/pypress-master.sock').run()
sock.bind(('', 9999)) sock.listen(1) while True: print 'Waiting for input stream' sd, addr = sock.accept() print 'Connected input stream from', addr data = True while data: readable = select([sd], [], [], 0.1)[0] for s in readable: data = s.recv(1024) if not data: break q = Queue() for q in app.queues: q.put(data) print 'Lost input stream from', addr if __name__ == '__main__': app = LiveHTTPStreamer() server = WSGIServer(app, bindAddress=('', 9998)) t1 = Thread(target=input_loop, args=[app]) t1.setDaemon(True) t1.start() server.run()
return '401 Authentication Required' if prj.owner == user: return '200 Ok' pm = q_get(ProjectMember, project=prj, user=user) if pm is not None: return '200 Ok' return '401 Authentication Required' if __name__ == '__main__': from flup.server.fcgi import WSGIServer from flup.server.fcgi_base import FCGI_RESPONDER, FCGI_AUTHORIZER addr = sys.argv[1] if addr.find(':') != -1: addr = addr.split(':') addr[1] = int(addr[1]) addr = tuple(addr) if len(sys.argv) >= 3 and sys.argv[2] == '-d': do_daemon(sys.argv[3]) print 'serve in', sys.argv[1], '...' WSGIServer(authapp, bindAddress=addr, roles=[FCGI_RESPONDER, FCGI_AUTHORIZER]).run()
def server(num): WSGIServer(receiver.r_app, bindAddress=(config.get('server', 'host'), 8000 + num)).run()
from flup.server.fcgi import WSGIServer from main import app if __name__ == '__main__': #help (WSGIServer) WSGIServer(app, multithreaded=1, multiprocess=0, debug=1, bindAddress=('127.0.0.1', 8080)).run()
def runServer(self, services=[]): """Starts up the server. It (will) support different config options via the config plugin.""" self.add_routes() #debug = self.general_section.get("debug") host = self.general_section.get("host") use_reloader = ast.literal_eval( self.general_section.get("use_reloader")) app_port = int(self.general_section.get("port")) cFCGI = ast.literal_eval(self.fcgi_section.get("enabled")) fcgi_port = int(self.fcgi_section.get("port")) must_have_client_cert = ast.literal_eval( self.certificates_flask_section.get("force_client_certificate")) if cFCGI: logger.info("registering fcgi server at %s:%i", host, fcgi_port) from flup.server.fcgi import WSGIServer WSGIServer(self._app, bindAddress=(host, fcgi_port)).run() else: logger.info("registering app server at %s:%i", host, app_port) # this workaround makes sure that the client cert can be acquired later (even when running the development server) # copied all this stuff from the actual flask implementation, so we can intervene and adjust the ssl context # self._app.run(host=host, port=app_port, ssl_context='adhoc', debug=debug, request_handler=ClientCertHTTPRequestHandler) # the code from flask's `run...` # see https://github.com/mitsuhiko/flask/blob/master/flask/app.py #options = {} try: # now the code from werkzeug's `run_simple(host, app_port, self._app, **options)` # see https://github.com/mitsuhiko/werkzeug/blob/master/werkzeug/serving.py #from werkzeug.debug import DebuggedApplication import socket #application = DebuggedApplication(self._app, True) # Set up an SSL context context = SSL.Context(SSL.SSLv23_METHOD) certs_path = os.path.normpath( os.path.join(os.path.dirname(__file__), "../../..", "cert")) context_crt = os.path.join(certs_path, "server.crt") context_key = os.path.join(certs_path, "server.key") try: context.use_certificate_file(context_crt) context.use_privatekey_file(context_key) except Exception as e: logger.critical( "error starting flask server. Cert or key is missing under %s", certs_path) sys.exit(e) def inner(): #server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, 'adhoc') server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, ssl_context=context) #server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, ssl_context=(context_crt, context_key)) # The following line is the reason why I copied all that code! if must_have_client_cert: # FIXME: what works with web app does not work with cli. Check this out server.ssl_context.set_verify( SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT, lambda a, b, c, d, e: True) # before enter in the loop, start the supplementary services for s in services: s.start() # That's it server.serve_forever() address_family = serving.select_ip_version(host, app_port) test_socket = socket.socket(address_family, socket.SOCK_STREAM) test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) test_socket.bind((host, app_port)) test_socket.close() # Disable reloader only by explicit config setting if use_reloader == False: serving.run_simple(host, app_port, self._app, use_reloader=False) else: serving.run_with_reloader(inner, None, 1) finally: self._app._got_first_request = False
if "lft" in i: spd = int(i["lft"][0]) if spd < -1020: G.setup(pinDlyLft1, G.OUT) G.setup(pinDlyLft2, G.OUT) s.set_servo(pinLft, abs(spd)) else: G.cleanup(pinDlyLft1) G.cleanup(pinDlyLft2) s.set_servo(pinLft, abs(spd)) if "rgt" in i: spd = int(i["rgt"][0]) if spd < -1020: G.setup(pinDlyRgt1, G.OUT) G.setup(pinDlyRgt2, G.OUT) s.set_servo(pinRgt, abs(spd)) else: G.cleanup(pinDlyRgt1) G.cleanup(pinDlyRgt2) s.set_servo(pinRgt, abs(spd)) if "led" in i: if i["led"][0] == "on": G.setup(pinLED, G.OUT) else: G.cleanup(pinLED) WSGIServer(app).run() G.cleanup()
tmpLog.error(errStr) # return internal server error start_response('500 INTERNAL SERVER ERROR', [('Content-Type', 'text/plain')]) return [str(e)] if panda_config.entryVerbose: tmpLog.debug("done") regTime = datetime.datetime.utcnow() - regStart tmpLog.info( "exec_time=%s.%03d sec, return len=%s B" % (regTime.seconds, regTime.microseconds / 1000, len(str(exeRes)))) # return if exeRes == taskbuffer.ErrorCode.EC_NotFound: start_response('404 Not Found', [('Content-Type', 'text/plain')]) return ['not found'] elif isinstance(exeRes, taskbuffer.ErrorCode.EC_Redirect): start_response('302 Redirect', [('Location', exeRes.url)]) return ['redirect'] else: if retType == 'json': start_response('200 OK', [('Content-Type', 'application/json')]) else: start_response('200 OK', [('Content-Type', 'text/plain')]) return [exeRes] # start server if panda_config.useFastCGI: from flup.server.fcgi import WSGIServer WSGIServer(application, multithreaded=False).run()
def flup_adapter(host, port): # Experimental (Untested). from flup.server.fcgi import WSGIServer WSGIServer(handle_request, bindAddress=(host, port)).run()
def run(): WSGIServer(dispatch_request, **params).run()
def handle(self, app): _production_logging(app) from flup.server.fcgi import WSGIServer sock_path = os.path.join(app.instance_path, 'fcgi.sock') server = WSGIServer(app, bindAddress=sock_path, umask=0) server.run()
def run_fcgi(): app = bottle.default_app() from flup.server.fcgi import WSGIServer WSGIServer(app).run()
def run_fcgi(app, args): from flup.server.fcgi import WSGIServer sock_path = args.fastcgi_socket wsgi_server = WSGIServer(app, bindAddress=sock_path, umask=0) wsgi_server.run()
#!/usr/bin/env python3 # -*- coding: UTF-8 -*- import cgi import psycopg2 import sys, os from flup.server.fcgi import WSGIServer def app(environ, start_response): form = cgi.FieldStorage(fp=environ['wsgi.input'], environ=environ) start_response('200 OK', [('Content-Type', 'text/html')]) con = psycopg2.connect(database="docker", user="******", password='******', host="db", port="5432") cur = con.cursor() for item in form: cur.execute('INSERT INTO postdata (key, value) VALUES (%s, %s)', (item, form.getvalue(item))) con.commit() yield 'OK' bindAddress = ('0.0.0.0', int(8888)) WSGIServer(app, bindAddress=bindAddress).run()
def wsgi(): """Run WSGI server for use with an external FCGI server""" read_env() WSGIServer(app).run()
self.send_response (int (statusCode), statusMsg) for header, value in headers: self.send_header (header, value) self.end_headers() self.wsgiSentHeaders = 1 # Send the data self.wfile.write (data) class WSGIServer (SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer): def __init__(self, func): BaseHTTPServer.HTTPServer.__init__(self, ("0.0.0.0", int(port)), WSGIHandler) self.app = func self.serverShuttingDown = 0 print "Launching server: http://0.0.0.0:"+str(port)+"/" WSGIServer(func).serve_forever() def runfcgi(func): from flup.server.fcgi import WSGIServer class MyServer(WSGIServer): def error(self, req): w = req.stdout.write internalerror() w('Status: '+context.status+'\r\n') for (h, v) in context.headers: w(h+': '+v+'\r\n') w('\r\n'+context.output) return MyServer(func, multiplexed=True).run()
def get_info(lat, lon): return json.dumps({ 'inches': howmuchsnow.how_much_snow_gps((lat, lon), conn), 'coords': howmuchsnow.make_coordinates(lat, lon) }) def application(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) parameters = parse_qs(environ.get('QUERY_STRING', '')) if 'faq' in parameters: yield pages.faq elif 'geo' in parameters: lat = float(parameters['lat'][0]) lon = float(parameters['lon'][0]) # inches = howmuchsnow.how_much_snow_gps((lat, lon), conn) # yield inches yield get_info(lat, lon) elif 'ip' in parameters: ip_addr = environ['REMOTE_ADDR'] lat, lon = ipv4_to_gps(ip_addr) # inches = howmuchsnow.how_much_snow_ipv4(ip_addr, conn) # yield inches yield get_info(lat, lon) else: yield pages.homepage if __name__ == '__main__': WSGIServer(application).run()
from flup.server.fcgi import WSGIServer from weeklypedia.labs import wsgi_app wsgi_server = WSGIServer(wsgi_app) if __name__ == '__main__': wsgi_server.run()
# And start the application app.start() # NOTE: Maybe we should always print it #print app.config() # We start the WSGI stack stack = app._dispatcher stack = processStack(stack) # == FCGI (Flup-provided) # if method == FCGI: if not has(FLUP): raise ImportError("Flup is required to run FCGI") fcgi_address = address or config.get("address") fcgi_port = port or config.get("port") if fcgi_port and fcgi_address: server = FLUP_FCGIServer(stack, bindAddress=(fcgi_address, fcgi_port)) elif fcgi_address: server = FLUP_FCGIServer(stack, bindAddress=fcgi_address) else: server = FLUP_FCGIServer(stack) server.run() # # == SCGI (Flup-provided) # elif method == SCGI: if not has(FLUP): raise ImportError("Flup is required to run SCGI") fcgi_address = address or config.get("address") fcgi_port = port or config.get("port") if fcgi_port and fcgi_address: server = FLUP_SCGIServer(stack,
# And start the application app.start() # NOTE: Maybe we should always print it #print app.config() # We start the WSGI stack stack = app._dispatcher stack = processStack(stack) # == FCGI (Flup-provided) # if method == FCGI: if not has(FLUP): raise ImportError("Flup is required to run FCGI") fcgi_address = address or config.get("address") fcgi_port = port or config.get("port") if fcgi_port and fcgi_address: server = FLUP_FCGIServer(stack, bindAddress=(fcgi_address, fcgi_port)) elif fcgi_address: server = FLUP_FCGIServer(stack, bindAddress=fcgi_address) else: server = FLUP_FCGIServer(stack) server.run() # # == SCGI (Flup-provided) # elif method == SCGI: if not has(FLUP): raise ImportError("Flup is required to run SCGI") fcgi_address = address or config.get("address") fcgi_port = port or config.get("port") if fcgi_port and fcgi_address: server = FLUP_SCGIServer(stack, bindAddress=(fcgi_address, fcgi_port))
def handle(self, app): from flup.server.fcgi import WSGIServer sock_path = os.path.join(app.instance_path, 'fcgi.sock') server = WSGIServer(app, bindAddress=sock_path, umask=0, maxThreads=5) server.run()