def runNginxServer(self): from django.core.servers.fastcgi import runfastcgi from django.core.management import setup_environ from mysite import settings os.chdir("%s/../../python-support/nginx"%self.p) fname="conf/site.conf" f=file(fname, "w+") confStr=nginxConf%{"PORT":self.port, "FCGI_PORT":self.fcgiPort} f.write(confStr) f.close() if os.name=='posix': os.system("""./nginx -s stop""") os.system("""./nginx""") else: #'nt', windows os.system("""nginx.exe -s stop""") os.system("""start nginx.exe""") os.chdir(self.p) address=("0.0.0.0",self.fcgiPort) wserver = wsgiserver.CherryPyWSGIServer( (address[0], int(address[1])), django.core.handlers.wsgi.WSGIHandler(), server_name='www.bio-Device.com', numthreads = self.numthreads, request_queue_size=self.queue_size, ) try: wserver.start() except KeyboardInterrupt: wserver.stop() #print "startup fcgi module ..." """if os.name=='posix':
def run(self): import wsgiserver self.server = wsgiserver.CherryPyWSGIServer( self.config.bind_addr, self.config.app, server_name=self.config.host_name, numthreads=self.config.params.get('threads', DEFAULT_THREADS)) try: self.server.start() except KeyboardInterrupt: self.stop()
def __init__( self, ip='127.0.0.1', port=8000, password='', pid_filename='httpserver.pid', log_filename='httpserver.log', profiler_filename=None, ssl_certificate=None, ssl_private_key=None, numthreads=10, server_name=None, request_queue_size=5, timeout=10, shutdown_timeout=5, path=web2py_path, ): """ starts the web server. """ save_password(password, port) self.pid_filename = pid_filename if not server_name: server_name = socket.gethostname() logging.info('starting web server...') from contrib.wsgihooks import ExecuteOnCompletion2, callback self.server = wsgiserver.CherryPyWSGIServer( # self.server = sneaky.Sneaky( (ip, port), appfactory(ExecuteOnCompletion2(wsgibase, callback), log_filename, profiler_filename, web2py_path=path), numthreads=int(numthreads), server_name=server_name, request_queue_size=int(request_queue_size), timeout=int(timeout), shutdown_timeout=int(shutdown_timeout), ) if not ssl_certificate or not ssl_private_key: logging.info('SSL is off') elif not wsgiserver.SSL: logging.warning('OpenSSL libraries unavailable. SSL is OFF') elif not os.path.exists(ssl_certificate): logging.warning('unable to open SSL certificate. SSL is OFF') elif not os.path.exists(ssl_private_key): logging.warning('unable to open SSL private key. SSL is OFF') else: self.server.ssl_certificate = ssl_certificate self.server.ssl_private_key = ssl_private_key logging.info('SSL is ON')
def runWSGIServer(self): # print "runWSGIServer" address=tuple(self.address.split(":")) wserver = wsgiserver.CherryPyWSGIServer( (address[0], int(address[1])), django.core.handlers.wsgi.WSGIHandler(), server_name='www.bio-Device.com', numthreads = self.numthreads, request_queue_size=self.queue_size, ) try: wserver.start() except KeyboardInterrupt: wserver.stop()
def WSGIServer(server_address, wsgi_app): """Creates CherryPy WSGI server listening at `server_address` to serve `wsgi_app`. This function can be overwritten to customize the webserver or use a different webserver. """ import wsgiserver # Default values of wsgiserver.ssl_adapters uses cheerypy.wsgiserver # prefix. Overwriting it make it work with web.wsgiserver. wsgiserver.ssl_adapters = { 'builtin': 'web.wsgiserver.ssl_builtin.BuiltinSSLAdapter', 'pyopenssl': 'web.wsgiserver.ssl_pyopenssl.pyOpenSSLAdapter', } return wsgiserver.CherryPyWSGIServer(server_address, wsgi_app, server_name="localhost")
def start(): #print "[amiweb]startServer_start_: before server set<br>" server = wsgiserver.CherryPyWSGIServer(('', port), wsgi_app, numthreads=numthreads, request_queue_size=15, timeout=10) try: #print "[amiweb]startServer_start_:Server started on port %s<br>" % port server.start() #print "[amiweb]startServer_start_:after server.start w/ CherryPyBusiness<br>" except KeyboardInterrupt: #print "[amiweb]startServer_start_:Server stopped<br>" server.stop()
def WSGIServer(server_address, wsgi_app): """Creates CherryPy WSGI server listening at `server_address` to serve `wsgi_app`. This function can be overwritten to customize the webserver or use a different webserver. """ import wsgiserver # Default values of wsgiserver.ssl_adapters uses cherrypy.wsgiserver # prefix. Overwriting it make it work with web.wsgiserver. wsgiserver.ssl_adapters = { 'builtin': 'web.wsgiserver.ssl_builtin.BuiltinSSLAdapter', 'pyopenssl': 'web.wsgiserver.ssl_pyopenssl.pyOpenSSLAdapter', } server = wsgiserver.CherryPyWSGIServer(server_address, wsgi_app, server_name="localhost") def create_ssl_adapter(cert, key): # wsgiserver tries to import submodules as cherrypy.wsgiserver.foo. # That doesn't work as not it is web.wsgiserver. # Patching sys.modules temporarily to make it work. import types cherrypy = types.ModuleType('cherrypy') cherrypy.wsgiserver = wsgiserver sys.modules['cherrypy'] = cherrypy sys.modules['cherrypy.wsgiserver'] = wsgiserver from wsgiserver.ssl_pyopenssl import pyOpenSSLAdapter adapter = pyOpenSSLAdapter(cert, key) # Added 2014-11-28 by [email protected]. # The default setting is insecure. Therefore we get the SSL-Context # and set our own OpenSSL options according to the default that we # have specified above or according to the settings in the program that # make use of web.py. adapter.context = adapter.get_context() adapter.context.set_options(web.config.ssl_parameters.ssl_options) adapter.context.set_cipher_list(web.config.ssl_parameters.ssl_cipher_list) # We are done with our work. Cleanup the patches. del sys.modules['cherrypy'] del sys.modules['cherrypy.wsgiserver'] return adapter # SSL backward compatibility if (server.ssl_adapter is None and getattr(server, 'ssl_certificate', None) and getattr(server, 'ssl_private_key', None)): server.ssl_adapter = create_ssl_adapter(server.ssl_certificate, server.ssl_private_key) server.nodelay = not sys.platform.startswith('java') # TCP_NODELAY isn't supported on the JVM return server
def WSGIServer(server_address, wsgi_app): """Creates CherryPy WSGI server listening at `server_address` to serve `wsgi_app`. This function can be overwritten to customize the webserver or use a different webserver. """ import wsgiserver # Default values of wsgiserver.ssl_adapters uses cherrypy.wsgiserver # prefix. Overwriting it make it work with web.wsgiserver. wsgiserver.ssl_adapters = { 'builtin': 'web.wsgiserver.ssl_builtin.BuiltinSSLAdapter', 'pyopenssl': 'web.wsgiserver.ssl_pyopenssl.pyOpenSSLAdapter', } # *************************************************************************************** # # wsgi_app = wsgifunc(*middleware) in application.py line 268 # from here you can see that: # wsgiserver -> WSGI entry function(wsgi_app) -> your app server = wsgiserver.CherryPyWSGIServer(server_address, wsgi_app, server_name="localhost") # *************************************************************************************** def create_ssl_adapter(cert, key): # wsgiserver tries to import submodules as cherrypy.wsgiserver.foo. # That doesn't work as not it is web.wsgiserver. # Patching sys.modules temporarily to make it work. import types cherrypy = types.ModuleType('cherrypy') cherrypy.wsgiserver = wsgiserver sys.modules['cherrypy'] = cherrypy sys.modules['cherrypy.wsgiserver'] = wsgiserver from wsgiserver.ssl_pyopenssl import pyOpenSSLAdapter adapter = pyOpenSSLAdapter(cert, key) # We are done with our work. Cleanup the patches. del sys.modules['cherrypy'] del sys.modules['cherrypy.wsgiserver'] return adapter # SSL backward compatibility if (server.ssl_adapter is None and getattr(server, 'ssl_certificate', None) and getattr(server, 'ssl_private_key', None)): server.ssl_adapter = create_ssl_adapter(server.ssl_certificate, server.ssl_private_key) server.nodelay = not sys.platform.startswith( 'java') # TCP_NODELAY isn't supported on the JVM return server
def WSGIServerOfNumthreads(server_address, wsgi_app, numthreads, max, request_queue_size): """Can set threadspool numthreads """ import wsgiserver # Default values of wsgiserver.ssl_adapters uses cherrypy.wsgiserver # prefix. Overwriting it make it work with web.wsgiserver. wsgiserver.ssl_adapters = { 'builtin': 'web.wsgiserver.ssl_builtin.BuiltinSSLAdapter', 'pyopenssl': 'web.wsgiserver.ssl_pyopenssl.pyOpenSSLAdapter', } server = wsgiserver.CherryPyWSGIServer( server_address, wsgi_app, numthreads=numthreads, server_name="localhost", max=max, request_queue_size=request_queue_size) def create_ssl_adapter(cert, key): # wsgiserver tries to import submodules as cherrypy.wsgiserver.foo. # That doesn't work as not it is web.wsgiserver. # Patching sys.modules temporarily to make it work. import types cherrypy = types.ModuleType('cherrypy') cherrypy.wsgiserver = wsgiserver sys.modules['cherrypy'] = cherrypy sys.modules['cherrypy.wsgiserver'] = wsgiserver from wsgiserver.ssl_pyopenssl import pyOpenSSLAdapter adapter = pyOpenSSLAdapter(cert, key) # We are done with our work. Cleanup the patches. del sys.modules['cherrypy'] del sys.modules['cherrypy.wsgiserver'] return adapter # SSL backward compatibility if (server.ssl_adapter is None and getattr(server, 'ssl_certificate', None) and getattr(server, 'ssl_private_key', None)): server.ssl_adapter = create_ssl_adapter(server.ssl_certificate, server.ssl_private_key) server.nodelay = not sys.platform.startswith( 'java') # TCP_NODELAY isn't supported on the JVM return server
def set_up_server(remote_base_path): # choosing free port s = socket.socket() s.bind(('',0)) ip, port = s.getsockname() s.close() del s print("Chosen URL is http://%s:%s/" % (ip, port)) # setting up the server. server = wsgiserver.CherryPyWSGIServer( (ip, port), ges.assemble_ges_app(remote_base_path) ) ip = 'localhost' # the IP the socket yields is '0.0.0.0' which is not useful for testing. return ip, port, server
def run(config): app.load_config(config) logger.info("Server running on port %s." % config.port) if config.allow_remote_conn: # import socket # socket.gethostname(), host = ('0.0.0.0', config.port) else: host = ('127.0.0.1', config.port) global server server = wsgiserver.CherryPyWSGIServer(host, app.handler, numthreads=50) server_thread = threading.Thread(target=server.start) server_thread.daemon = True server_thread.start()
def WSGIServer(server_address, wsgi_app): """Creates CherryPy WSGI server listening at `server_address` to serve `wsgi_app`. This function can be overwritten to customize the webserver or use a different webserver. """ import wsgiserver # Default values of wsgiserver.ssl_adapters uses cheerypy.wsgiserver # prefix. Overwriting it make it work with web.wsgiserver. wsgiserver.ssl_adapters = { 'builtin': 'web.wsgiserver.ssl_builtin.BuiltinSSLAdapter', 'pyopenssl': 'web.wsgiserver.ssl_pyopenssl.pyOpenSSLAdapter', } server = wsgiserver.CherryPyWSGIServer(server_address, wsgi_app, server_name="localhost") server.nodelay = not sys.platform.startswith( 'java') # TCP_NODELAY isn't supported on the JVM return server
def ServerFunc(): logging.info('pywfotd server startup') RegisterPathsByDict() SortRegisteredPathsBySize() if not REGISTERED_PATHS: logging.error('no path handlers registered') sys.exit(3) logging.info('registered paths: %r' % [pathx[0] for pathx in REGISTERED_PATHS]) bind_host = '0.0.0.0' # Bind on all interfaces. bind_port = 8080 if len(sys.argv) == 2: try: port = int(sys.argv[1]) except ValueError: pass if len(sys.argv) == 3: bind_host = sys.argv[1] try: port = int(sys.argv[2]) except ValueError: pass import wsgiserver server = wsgiserver.CherryPyWSGIServer((bind_host, bind_port), WsgiApp) def Tick(): listen_host, listen_port = server.socket.getsockname() logging.info('pywfotd listening on http://%s:%s/', listen_host, listen_port) logging.info('press Ctrl-<C> to abort the server') del server.tick server.tick() server.tick = Tick try: server.start() finally: # for KeyboardInterrupt and SystemExit server.stop()
def run_server(): sys.path.append('..') os.environ['DJANGO_SETTINGS_MODULE'] = 'dscada.settings' from dscada import settings print settings app = AdminMediaHandler(django.core.handlers.wsgi.WSGIHandler()) #logged_app = TransLogger(app) server = wsgiserver.CherryPyWSGIServer( ('127.0.0.1', 8080), app, server_name='luz.lifeway.org', numthreads=20, ) try: server.start() webbrowser.open('http://127.0.0.1:8080') except KeyboardInterrupt: server.stop()
def run(self, handler): # pragma: no cover import wsgiserver self.options['bind_addr'] = (self.host, self.port) self.options['wsgi_app'] = handler certfile = self.options.get('certfile') if certfile: del self.options['certfile'] keyfile = self.options.get('keyfile') if keyfile: del self.options['keyfile'] server = wsgiserver.CherryPyWSGIServer(**self.options) if certfile: server.ssl_certificate = certfile if keyfile: server.ssl_private_key = keyfile try: server.start() finally: server.stop()
def SvcDoRun(self): # first, let's make sure the folder with our code is visible. try: code_folder_path = os.path.split(__file__)[0] except: raise Exception( "G.E.S: Cannot determine what folder the code is located in") if code_folder_path not in sys.path: sys.path.append(code_folder_path) if not os.path.isfile( os.path.join(code_folder_path, 'static', 'favicon.ico')): raise Exception( 'G.E.S.: Cannot find static content in directory "%s".' % code_folder_path) # now that we are reasonably sure our code is visible, let's import import ges import wsgiserver app = ges.assemble_ges_app(content_path=self._content_path, uri_marker=self._uri_marker, static_content_path=os.path.join( code_folder_path, 'static')) self._server_instance = wsgiserver.CherryPyWSGIServer( (self._server_ip, self._server_port), app) try: self._server_instance.start() except KeyboardInterrupt: # i know this will never happen. That's the point. # all other exceptions will bubble up, somewhere... i hope... pass finally: self._server_instance.stop()
#!/usr/bin/env python import wsgiserver #This can be from cherrypy import wsgiserver if you're not running it standalone. import os import django.core.handlers.wsgi from django.conf import settings from phyloconf import ITIS_PORT, IP if __name__ == "__main__": os.environ['DJANGO_SETTINGS_MODULE'] = 'itis.settings' print "===",settings.TAXONOMY_ENGINE,"===" server = wsgiserver.CherryPyWSGIServer( (IP, ITIS_PORT), django.core.handlers.wsgi.WSGIHandler(), #server_name='django.example', numthreads = 20, ) print "Server launched. See Phyloexplorer in action at :\n http://%s:%s/phyloexplorer" % (IP, ITIS_PORT) try: server.start() except KeyboardInterrupt: server.stop()
def initialize(): """Init function for this module""" with INIT_LOCK: global __INITIALIZED__, app, FULL_PATH, RUNDIR, ARGS, DAEMON, PIDFILE, VERBOSE, LOG_FILE, LOG_DIR, logger, PORT, SERVER, DATABASE, AUTH, \ UPDATER, CURRENT_COMMIT, LATEST_COMMIT, COMMITS_BEHIND, COMMITS_COMPARE_URL, USE_GIT, WEBROOT, HOST, KIOSK, DATA_DIR, SCRIPT_DIR, \ THREADS, FIRST_RUN if __INITIALIZED__: return False # Set up logger if not LOG_FILE: LOG_FILE = os.path.join(DATA_DIR, 'logs', 'maraschino.log') FILENAME = os.path.basename(LOG_FILE) LOG_DIR = LOG_FILE[:-len(FILENAME)] if not os.path.exists(LOG_DIR): try: os.makedirs(LOG_DIR) except OSError: if VERBOSE: print 'Unable to create the log directory.' logger = maraschinoLogger(LOG_FILE, VERBOSE) #set up script dir if not SCRIPT_DIR: SCRIPT_DIR = os.path.join(DATA_DIR, 'scripts') if not os.path.exists(SCRIPT_DIR): os.makedirs(SCRIPT_DIR) # check if database exists or create it from database import init_db if KIOSK: logger.log('Running in KIOSK Mode, settings disabled.', 'INFO') try: logger.log('Opening database at: %s' % (DATABASE), 'INFO') open(DATABASE) except IOError: logger.log('Opening database failed', 'WARNING') #Check if a version file exists. If not assume latest revision. version_file = os.path.join(DATA_DIR, 'Version.txt') if not os.path.exists(version_file): FIRST_RUN = 1 try: logger.log('Checking if PATH exists: %s' % (DATABASE), 'WARNING') dbpath = os.path.dirname(DATABASE) if not os.path.exists(dbpath): try: logger.log('It does not exist, creating it...', 'WARNING') os.makedirs(dbpath) except: logger.log('Could not create %s.' % (DATABASE), 'CRITICAL') print 'Could not create %s.' % (DATABASE) quit() except: logger.log('Could not create %s.' % (DATABASE), 'CRITICAL') quit() logger.log('Database successfully initialised', 'INFO') init_db() # Web server settings from tools import get_setting_value if get_setting_value('maraschino_port'): port_arg = False for arg in ARGS: if arg == '--port' or arg == '-p': port_arg = True if not port_arg: PORT = int(get_setting_value('maraschino_port')) # Set up AUTH username = get_setting_value('maraschino_username') password = get_setting_value('maraschino_password') if username and password != None: AUTH = {'username': username, 'password': password} # Set up web server if '--webroot' not in str(ARGS): WEBROOT = get_setting_value('maraschino_webroot') if WEBROOT is None or DEVELOPMENT: WEBROOT = '' if WEBROOT: if WEBROOT[0] != '/': WEBROOT = '/' + WEBROOT d = wsgiserver.WSGIPathInfoDispatcher({WEBROOT: app}) else: d = wsgiserver.WSGIPathInfoDispatcher({'/': app}) SERVER = wsgiserver.CherryPyWSGIServer((HOST, PORT), d) __INITIALIZED__ = True return True
import time import wsgiserver from app.wsgiapp import Main, Redirecter from app.collector import collect_mactraffic from threading import Thread webapp = Main(debug=False) redirecter = Redirecter(debug=False) bind_address = "0.0.0.0" redirecter_port = 80 app_port = 5000 webapp = wsgiserver.CherryPyWSGIServer((bind_address, app_port), webapp) redirecter = wsgiserver.CherryPyWSGIServer((bind_address, redirecter_port), redirecter) for target in (webapp, redirecter): t = Thread(target=target.start) t.daemon = True t.start() collect_mactraffic() try: while True: # Do nothing (10000 seconds) time.sleep(10000) except KeyboardInterrupt:
''' Created on 30-Oct-2013 @author: suryan ''' import wsgiserver #This can be from cherrypy import wsgiserver if you're not running it standalone. import os import django.core.handlers.wsgi if __name__ == "__main__": os.environ['DJANGO_SETTINGS_MODULE'] = 'wikise.settings' server = wsgiserver.CherryPyWSGIServer( ('0.0.0.0', 8000), django.core.handlers.wsgi.WSGIHandler(), server_name='www.django.example', numthreads=20, ) try: server.start() except KeyboardInterrupt: server.stop()
def assisted_start(options): _help = r''' ges.py - Git Enablement Server v1.1 Note only the folder that contains folders and object that you normally see in .git folder is considered a "repo folder." This means that either a "bare" folder name or a working folder's ".git" folder will be a "repo" folder discussed in the examples below. This server automatically creates "bare" repo folders on push. Note, the folder does NOT have to have ".git" in the name to be a "repo" folder. You can name bare repo folders whatever you like. If the signature (right files and folders are found inside) matches a typical git repo, it's a "repo." Options: --content_path (Defaults to random temp folder) Serving contents of folder path passed in. Accepts relative paths, including things like "./../" and resolves them agains current path. (If you set this to actual .git folder, you don't need to specify the folder's name on URI as the git repo will be served at the root level of the URI.) If not specified, a random, temp folder is created in the OS-specific temporary storage path. This folder will be NOT be deleted after server exits unless the switch "--remove_temp" is used. --remove_temp (Defaults to False) When --content_path is not specified, this server will create a folder in a temporary file storage location that is OS-specific and will NOT remove it after the server shuts down. This switch, if included on command line, enables automatic removal of the created folder and all of its contents. --uri_marker (Defaults to '') Acts as a "virtual folder" - separator between decorative URI portion and the actual (relative to path_prefix) path that will be appended to path_prefix and used for pulling an actual file. the URI does not have to start with contents of repo_uri_marker. It can be preceeded by any number of "virtual" folders. For --repo_uri_marker 'my' all of these will take you to the same repo: http://localhost/my/HEAD http://localhost/admysf/mylar/zxmy/my/HEAD If you are using reverse proxy server, pick the virtual, decorative URI prefix / path of your choice. This hanlder will cut and rebase the URI. Default of '' means that no cutting marker is used, and whole URI after FQDN is used to find file relative to path_prefix. --port (Defaults to 8888) --demo (Defaults to False) You do not have to provide any arguments for this option. It's a switch. If "--demo" is part of the command-line options, a sample tree of folders with some repos will be extracted into the folder specified as content_path. If --content_path was not specified (we use temp folder) and "--demo" switch is present, we assume --remove_temp is on. Examples: ges.py (no arguments) A random temp folder is created on the file system and now behaves as the root of the served git repos folder tree. ges.py --demo This server is shipped with a small demo tree of Git repositories. This command deploys that tree into a temp folder and deletes that temp folder after the server is shut down. ges.py --content_path "~/somepath/repofolder" --uri_marker "myrepo" Will serve chosen repo folder as http://localhost/myrepo/ or http://localhost:8888/does/not/matter/what/you/type/here/myrepo/ This "repo uri marker" is useful for making a repo server appear as part of a server applications structure while serving from behind a reverse proxy. cd c:\myproject_workingfolder\.git ges.py --port 80 --content_path '.' This project's repo will be one and only served directly over http://localhost/ ''' # options = dict([ # ['content_path',None], # ['static_content_path', None], # ['uri_marker',''], # ['port', None], # ['devel', False], # ['demo',False], # ['remove_temp',False] # ]) # let's decide what port to serve on. port = options['port'] if not port: import socket # let's see if we can reuse our preferred default of 8888 s = socket.socket() try: s.bind(('', 8888)) ip, port = s.getsockname() except: pass s.close() del s if not port: # looks like our default of 8888 is already occupied. # taking next available port. s = socket.socket() s.bind(('', 0)) ip, port = s.getsockname() s.close() del s options['port'] = port # next we determine if the static server contents folder is visible to us. if not options['static_content_path'] or not os.path.isfile( os.path.join(options['static_content_path'], 'static', 'favicon.ico')): if sys.path[0] and os.path.isfile( os.path.join(sys.path[0], 'static', 'favicon.ico')): options['static_content_path'] = os.path.join( sys.path[0], 'static') else: raise Exception( 'G.E.S.: Specified static content directory - "%s" - does not contain expected files. Please, provide correct "static_content_path" variable value.' % options['static_content_path']) # now we pick a random temp folder for Git folders tree if none were specified. if options['content_path']: CONTENT_PATH_IS_TEMP = False else: import tempfile import shutil CONTENT_PATH_IS_TEMP = True options['content_path'] = tempfile.mkdtemp() if options['demo']: import zipfile demo_repos_zip = os.path.join(sys.path[0], 'test', 'sample_tree_of_repos_v2.zip') try: zipfile.ZipFile(demo_repos_zip).extractall(options['content_path']) except: pass if 'help' in options: print _help else: app = assemble_ges_app(**options) import wsgiserver httpd = wsgiserver.CherryPyWSGIServer( ('0.0.0.0', int(options['port'])), app) if options['uri_marker']: _s = '"/%s/".' % options['uri_marker'] example_URI = '''http://localhost:%s/whatever/you/want/here/%s/myrepo.git (Note: "whatever/you/want/here" cannot include the "/%s/" segment)''' % ( options['port'], options['uri_marker'], options['uri_marker']) else: _s = 'not chosen.' example_URI = 'http://localhost:%s/' % (options['port']) print ''' =========================================================================== Run this command with "--help" option to see available command-line options Chosen repo folders' base file system path: %s Starting GES server on port %s URI segment indicating start of git repo foler name is %s Application URI: %s Use Keyboard Interrupt key combination (usually CTRL+C) to stop the server =========================================================================== ''' % (os.path.abspath( options['content_path']), options['port'], _s, example_URI) # running with CherryPy's WSGI Server try: httpd.start() except KeyboardInterrupt: pass finally: httpd.stop() if (CONTENT_PATH_IS_TEMP and options['remove_temp']) or (CONTENT_PATH_IS_TEMP and options['demo']): shutil.rmtree(options['content_path'], True)
except: indexpath = os.path.join(TESTSCENE_DIR, "index.html") f = open(indexpath, 'r') payload = f.read() f.close() status = '200 OK' mimetype = mimetypes.guess_type(fullpath) print "guessed mimetype:", mimetype[0] if (not mimetype[0]): mimetype = ["application/xhtml+xml"] print "set mimetype:", mimetype[0] response_headers = [('Content-type', mimetype[0])] start_response(status, response_headers) return payload print "Starting x3dom development testserver" # Init the mimetypes module mimetypes.init() server = wsgiserver.CherryPyWSGIServer(('0.0.0.0', 8070), testScenes, server_name='www.x3dom.org') if __name__ == '__main__': try: server.start() except KeyboardInterrupt: server.stop()
try: frozen = sys.frozen except AttributeError: frozen = False # Define path based on frozen state if frozen: path_base = os.environ['_MEIPASS2'] rundir = os.path.dirname(sys.executable) else: path_base = rundir # Include paths sys.path.insert(0, path_base) sys.path.insert(0, os.path.join(path_base, 'lib')) import wsgiserver from Maraschino import app from settings import * d = wsgiserver.WSGIPathInfoDispatcher({'/': app}) server = wsgiserver.CherryPyWSGIServer(('0.0.0.0', CHERRYPY_PORT), d) if __name__ == '__main__': try: server.start() except KeyboardInterrupt: server.stop()
default=8000, help="port to listen to [default: %default]") parser.add_option("--num-threads", metavar="N", type='int', default=20, help="number of listening threads [default: %default]") opt, args = parser.parse_args() if args: parser.error("no argument expected, only params") return opt if __name__ == "__main__": opt = parse_options() os.environ['DJANGO_SETTINGS_MODULE'] = 'gammon.settings' server = wsgiserver.CherryPyWSGIServer( (opt.host, opt.port), django.core.handlers.wsgi.WSGIHandler(), server_name='reports.example.com', numthreads=opt.num_threads, ) logger.info("listening on %s:%s", opt.host, opt.port) try: server.start() except KeyboardInterrupt: server.stop()