def launch(config_file):
""" Launch the Graph Proxy with the specified config_file."""
config.load(config_file)
cache = ProxyLruCache(config.cache_entries)
appdict = apps.init(config.apps)
request_handler_factory = ProxyRequestHandlerFactory(
None, cache, appdict, GRAPH_SERVER)
realtime_handler_factory = RealtimeUpdateHandlerFactory(
cache, None, appdict)
endpoint = "http://" + config.public_hostname + ":" + str(
config.realtime_port) + "/"
proxyserver = wsgiserver.CherryPyWSGIServer(
(config.proxy_interface, config.proxy_port), request_handler_factory)
rtuserver = wsgiserver.CherryPyWSGIServer(
(config.realtime_interface, config.realtime_port),
realtime_handler_factory)
realtime_port_thread = threading.Thread(target=rtuserver.start)
realtime_port_thread.daemon = True
realtime_port_thread.start()
time.sleep(2) # give the server time to come up
realtime_handler_factory.register_apps(endpoint, GRAPH_SERVER)
try:
proxyserver.start()
except KeyboardInterrupt:
proxyserver.stop()
rtuserver.stop()
def runserver(verbose=False):
app = create_app()
if verbose:
storage_logger = logging.getLogger('storage')
storage_logger.setLevel(logging.DEBUG)
storage_handler = logging.StreamHandler()
storage_handler.setLevel(logging.DEBUG)
storage_logger.addHandler(storage_handler)
if app.config['ERROR_LOG_FILE'] is not None:
logging.basicConfig(filename=app.config['ERROR_LOG_FILE'],
loglevel=logging.ERROR)
if app.config['HTTP_PROXIED']:
from revproxy import ReverseProxied
app.wsgi_app = ReverseProxied(app.wsgi_app)
if app.config['HTTP_CHERRYPY']:
from cherrypy import wsgiserver
listen = (app.config['HTTP_LISTEN_HOST'],
app.config['HTTP_LISTEN_PORT'])
server = wsgiserver.CherryPyWSGIServer(listen, app.wsgi_app)
try:
server.start()
except KeyboardInterrupt:
server.stop()
else:
app.run(app.config['HTTP_LISTEN_HOST'])
def run(self, handler):
server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler)
server.ssl_adapter = SecuredSSLServer('cacert.pem', 'privkey.pem')
try:
server.start()
finally:
server.stop()
def run(self, handler):
server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler)
server.ssl_adapter = SecuredSSLServer(ssl_cert, ssl_key)
try:
server.start()
finally:
server.stop()
def main_loop(self):
provider = FabnetProvider(self.nibbler)
config = DEFAULT_CONFIG.copy()
config.update({
"provider_mapping": {"/": provider},
"user_mapping": {},
"verbose": 1,
#"debug_methods": ['OPTIONS', 'PROPFIND', 'GET'],
"enable_loggers": [],
"propsmanager": True, # True: use property_manager.PropertyManager
"locksmanager": True, # True: use lock_manager.LockManager
"acceptdigest": False, # Allow digest authentication, True or False
"defaultdigest": False, # True (default digest) or False (default basic)
"domaincontroller": KSDomainController(self.nibbler.get_security_provider()),
"dir_browser": {'response_trailer': "<a href='http://idepositbox.com'>"\
"iDepositBox/%s</a> ${time}"%VERSION}
})
app = WsgiDAVApp(config)
self.__init_logger()
if config["verbose"] >= 1:
print("Running %s, listening on %s://%s:%s" % (wsgiserver.CherryPyWSGIServer.version, 'http', self.host, self.port))
self.server = wsgiserver.CherryPyWSGIServer((self.host, self.port), app,)
self.server.provider = provider
self.server.start()
def run(self, handler): # pragma: no cover
self.server = wsgiserver.CherryPyWSGIServer((self.host, self.port),
handler)
try:
self.server.start()
finally:
self.server.stop()
def run(self):
wsgi_app = loadapp('config:%s' % self.config['httpd_config'],
relative_to=self.config['httpd_working_directory'],
global_conf={
'cassandra_host':
self.config['cassandra_host'],
'cassandra_port':
self.config['cassandra_port'],
'cassandra_timeout':
self.config['cassandra_timeout'],
'ident':
self.config['ident']
})
server = wsgiserver.CherryPyWSGIServer(
(self.config['httpd_host'], int(self.config['httpd_port'])),
wsgiserver.WSGIPathInfoDispatcher({'/': wsgi_app}))
try:
self.logger.debug(
'Starting httpd server at %s:%s' %
(self.config['httpd_host'], self.config['httpd_port']))
server.start()
except socket.error:
self.logger.error(
'Address already in use: %s:%s' %
(self.config['httpd_host'], self.config['httpd_port']))
server.stop()
except KeyboardInterrupt:
self.logger.error('Httpd server stopped by KeyboardInterrupt')
server.stop()
def start():
#NOTE bots is always on PYTHONPATH!!! - otherwise it will not start.
#***command line arguments**************************
configdir = 'config'
for arg in sys.argv[1:]:
if not arg:
continue
if arg.startswith('-c'):
configdir = arg[2:]
if not configdir:
print 'Configuration directory indicated, but no directory name.'
sys.exit(1)
elif arg in ["?", "/?"] or arg.startswith('-'):
showusage()
else:
showusage()
#***init general: find locating of bots, configfiles, init paths etc.***********************
botsinit.generalinit(configdir)
#***initialise logging. This logging only contains the logging from bots-webserver, not from cherrypy.
botsglobal.logger = logging.getLogger('bots-webserver')
botsglobal.logger.setLevel(logging.DEBUG)
h = TimedRotatingFileHandler(botslib.join(botsglobal.ini.get('directories','logging'),'webserver.log'), backupCount=10)
fileformat = logging.Formatter("%(asctime)s %(levelname)-8s: %(message)s",'%Y%m%d %H:%M:%S')
h.setFormatter(fileformat)
botsglobal.logger.addHandler(h)
#***init cherrypy as webserver*********************************************
#global configuration for cherrypy
cherrypy.config.update({'global': {'log.screen': False, 'server.environment': botsglobal.ini.get('webserver','environment','production')}})
#cherrypy handling of static files
conf = {'/': {'tools.staticdir.on' : True,'tools.staticdir.dir' : 'media' ,'tools.staticdir.root': botsglobal.ini.get('directories','botspath')}}
servestaticfiles = cherrypy.tree.mount(None, '/media', conf) #None: no cherrypy application (as this only serves static files)
#cherrypy handling of django
servedjango = WSGIHandler() #was: servedjango = AdminMediaHandler(WSGIHandler()) but django does not need the AdminMediaHandler in this setup. is much faster.
#cherrypy uses a dispatcher in order to handle the serving of static files and django.
dispatcher = wsgiserver.WSGIPathInfoDispatcher({'/': servedjango, '/media': servestaticfiles})
botswebserver = wsgiserver.CherryPyWSGIServer(bind_addr=('0.0.0.0', botsglobal.ini.getint('webserver','port',8080)), wsgi_app=dispatcher, server_name=botsglobal.ini.get('webserver','name','bots-webserver'))
botsglobal.logger.info(_(u'Bots web-server started.'))
#handle ssl: cherrypy < 3.2 always uses pyOpenssl. cherrypy >= 3.2 uses python buildin ssl (python >= 2.6 has buildin support for ssl).
ssl_certificate = botsglobal.ini.get('webserver','ssl_certificate',None)
ssl_private_key = botsglobal.ini.get('webserver','ssl_private_key',None)
if ssl_certificate and ssl_private_key:
if cherrypy.__version__ >= '3.2.0':
adapter_class = wsgiserver.get_ssl_adapter_class('builtin')
botswebserver.ssl_adapter = adapter_class(ssl_certificate,ssl_private_key)
else:
#but: pyOpenssl should be there!
botswebserver.ssl_certificate = ssl_certificate
botswebserver.ssl_private_key = ssl_private_key
botsglobal.logger.info(_(u'Bots web-server uses ssl (https).'))
else:
botsglobal.logger.info(_(u'Bots web-server uses plain http (no ssl).'))
#***start the cherrypy webserver.
try:
botswebserver.start()
except KeyboardInterrupt:
botswebserver.stop()
def run(self, handler):
try:
# First try to use the new version
from cheroot.ssl.pyopenssl import pyOpenSSLAdapter
from cheroot import wsgi
server = wsgi.Server((self.host, self.port),
handler,
request_queue_size=32)
except:
from cherrypy.wsgiserver.ssl_pyopenssl import pyOpenSSLAdapter
from cherrypy import wsgiserver
server = wsgiserver.CherryPyWSGIServer((self.host, self.port),
handler,
request_queue_size=32)
self.srv = server
# If cert variable is has a valid path, SSL will be used
# You can set it to None to disable SSL
server.ssl_adapter = pyOpenSSLAdapter(Config.REST_SSL_CERTFILE,
Config.REST_SSL_KEYFILE,
Config.REST_SSL_CA_CERTS)
try:
server.start()
finally:
server.stop()
def main(config=None, wiki=None):
"""Start a standalone WSGI server."""
config = config or read_config()
wiki = wiki or Wiki(config)
app = wiki.application
host, port = (config.get('interface',
'0.0.0.0'), int(config.get('port', 8080)))
try:
from cherrypy import wsgiserver
except ImportError:
try:
from cherrypy import _cpwsgiserver as wsgiserver
except ImportError:
import wsgiref.simple_server
server = wsgiref.simple_server.make_server(host, port, app)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
return
name = wiki.site_name
server = wsgiserver.CherryPyWSGIServer((host, port), app, server_name=name)
try:
server.start()
except KeyboardInterrupt:
server.stop()
def main():
server_type = "werkzeug"
if not config.debug_mode:
server_type = "cherrypy"
if config.web_server_type:
server_type = config.web_server_type
assert server_type in ("werkzeug",
"cherrypy"), "Only werkzeug and cherrypy supported"
if server_type == "werkzeug":
assert config.debug_mode, "Refusing to use werkzeug outside of debug mode"
app.run(config.web_host,
config.web_port,
debug=True,
use_reloader=False,
use_debugger=True,
threaded=True)
elif server_type == "cherrypy":
dispatcher = wsgiserver.WSGIPathInfoDispatcher({"/": app})
web_server = wsgiserver.CherryPyWSGIServer(
(config.web_host, config.web_port),
dispatcher,
server_name=config.web_public_host)
web_server.start()
def __init__(self,
session,
audio_buffer,
host='localhost',
try_ports=range(8080, 8090),
allowed_ips=['127.0.0.1'],
allow_ranges=True):
port = self._find_free_port(host, try_ports)
self.__audio_buffer = audio_buffer
sess_ref = weakref.proxy(session)
self.__base_token = create_base_token()
self.__allowed_ips = allowed_ips
self.__cb_stream_ended = DynamicCallback()
self.__root = Root(sess_ref, audio_buffer, self.__base_token,
self.__allowed_ips, self.__cb_stream_ended,
allow_ranges)
app = cherrypy.tree.mount(self.__root, '/')
#Don't log to the screen by default
log = cherrypy.log
log.access_file = ''
log.error_file = ''
log.screen = False
log.access_log.addHandler(NullLogHandler())
log.error_log.addHandler(NullLogHandler())
self.__server = wsgiserver.CherryPyWSGIServer((host, port), app)
threading.Thread.__init__(self)
def get_server(address, port, application):
def _serve(server):
server.start()
server = wsgiserver.CherryPyWSGIServer((address, int(port)), application)
t = threading.Thread(target=_serve, args=(server,))
t.daemon = True
return (t, server)
def start(self):
"""Start the wsgi server."""
from cherrypy import wsgiserver
from cherrypy.wsgiserver.ssl_builtin import BuiltinSSLAdapter
# pylint: disable=too-few-public-methods,super-init-not-called
class ContextSSLAdapter(BuiltinSSLAdapter):
"""SSL Adapter that takes in an SSL context."""
def __init__(self, context):
self.context = context
# pylint: disable=no-member
self.server = wsgiserver.CherryPyWSGIServer(
(self.server_host, self.server_port),
self,
server_name='Home Assistant')
if self.ssl_certificate:
context = ssl.SSLContext(SSL_VERSION)
context.options |= SSL_OPTS
context.set_ciphers(CIPHERS)
context.load_cert_chain(self.ssl_certificate, self.ssl_key)
self.server.ssl_adapter = ContextSSLAdapter(context)
threading.Thread(target=self.server.start,
daemon=True,
name='WSGI-server').start()
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 run(self, handler):
self.srv = wsgiserver.CherryPyWSGIServer((self.host, self.port),
handler,
numthreads=2,
timeout=2,
shutdown_timeout=2)
self.srv.start()
def run_cherrypy_server(app, ip, port=8080):
from cherrypy import wsgiserver
server = wsgiserver.CherryPyWSGIServer(
(ip, port), app, server_name=os.environ['OPENSHIFT_APP_DNS'])
server.start()
def run(self, handler):
server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler)
server.ssl_adapter = pyOpenSSLAdapter(CERT_FILE, PEM_FILE)
try:
server.start()
finally:
server.stop()
def SvcDoRun(self):
key = winreg.OpenKey(rootkey, subkey, 0, winreg.KEY_READ)
port_to_bind = int(winreg.QueryValueEx(key, 'Port')[0])
data_dir = str(winreg.QueryValueEx(key, 'DataDir')[0])
app_config = data_dir + r'\mapproxy.yaml'
log_conf = data_dir + r'\log.ini'
cherrypy.config.update({
'global': {
'log.screen': False,
'tools.log_tracebacks.on': True,
'engine.autoreload.on': False,
'engine.SIGHUP': None,
'engine.SIGTERM': None
}
})
fileConfig(log_conf, {'here': data_dir})
application = make_wsgi_app(app_config)
d = wsgiserver.WSGIPathInfoDispatcher({'/mapproxy': application})
self.server = wsgiserver.CherryPyWSGIServer((server_ip, port_to_bind),
d,
numthreads=10,
server_name=None,
max=-1,
request_queue_size=2048,
timeout=10,
shutdown_timeout=5)
# Infinite loop serving requests
try:
self.server.start()
except Exception as e:
# Log an error event
servicemanager.LogErrorMsg("MapProxy failed to start:\n%s" % e)
def run_server(app, port, numthreads=10):
from cherrypy import wsgiserver
server = wsgiserver.CherryPyWSGIServer(('0.0.0.0', port), app,
numthreads=numthreads)
try:
server.start()
except KeyboardInterrupt:
server.stop()
def setup(self, host, port, app_callback):
self._server = wsgiserver.CherryPyWSGIServer((host, port),
app_callback,
server_name="CP")
sfile = StaticFile('test.flac',
'/mnt/nas/Anastacia/Anastacia/03 Time.flac')
self._tree = {}
self._tree[sfile.name] = sfile
def run(self, handler):
from cherrypy import wsgiserver
server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler)
self.srv = server
try:
server.start()
finally:
server.stop()
def start_server(address, port, module_state):
dispatcher = wsgiserver.WSGIPathInfoDispatcher({'/': app})
server = wsgiserver.CherryPyWSGIServer((address, port), dispatcher)
server_thread = threading.Thread(target=server.start)
server_thread.daemon = True
server_thread.start()
app.module_state = module_state
return server
def run(self, handler):
from cherrypy import wsgiserver
from cherrypy.wsgiserver.ssl_pyopenssl import pyOpenSSLAdapter
server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler)
server.ssl_adapter = pyOpenSSLAdapter('cacert.pem', 'privkey.pem')
try:
server.start()
finally:
server.stop()
def run(self, handler):
from cherrypy import wsgiserver
server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler)
server.ssl_certificate = SSL_CERTIFICATE
server.ssl_private_key = SSL_PRIVATE_KEY
try:
server.start()
finally:
server.stop()
def run(self, handler):
server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler)
#cert = 'server.pem'
#server.ssl_certificate = cert
#server.ssl_private_key = cert
try:
server.start()
finally:
server.stop()
def _start_server(self):
from cherrypy import wsgiserver
apps = {'/': _default_app}
for path, registered_app in _app_register.iteritems():
apps[path] = registered_app
d = wsgiserver.WSGIPathInfoDispatcher(apps)
self.server = wsgiserver.CherryPyWSGIServer((self.bind, self.port), d)
self.server.start()
def run(self, handler):
from cherrypy import wsgiserver
from cherrypy.wsgiserver.ssl_pyopenssl import pyOpenSSLAdapter
server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler)
try:
server.start()
except:
server.stop()
def run(self, handler):
server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler)
server.ssl_adapter = ssl_builtin.BuiltinSSLAdapter("certs/localhost.cert",
"certs/localhost.key")
try:
server.start()
finally:
server.stop()
def run(self):
self.server = cherry.CherryPyWSGIServer(
self.config.bind_addr,
self.config.app,
server_name=self.config.host_name,
numthreads=self.config.get('threads', DEFAULT_THREADS))
try:
self.server.start()
except KeyboardInterrupt:
self.stop()