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()
