def __init__(self, name, loader=None):
"""Initialize, but do not start the WSGI server.
:param name: The name of the WSGI server given to the loader.
:param loader: Loads the WSGI application using the given name.
:returns: None
"""
self.name = name
self.loader = loader or wsgi.Loader(CONF)
self.app = self.loader.load_app(name)
self.host = getattr(CONF, 'listen', "0.0.0.0")
self.port = getattr(CONF, 'port', 0)
self.workers = (getattr(CONF, 'workers', None)
or processutils.get_worker_count())
if self.workers and self.workers < 1:
msg = ("Config option workers has an invalid value %(workers)d "
", the value must be greater than 0." % {
'workers': self.workers
})
raise exception.ConfigInvalid(error_msg=msg)
self.server = wsgi.Server(CONF,
name,
self.app,
host=self.host,
port=self.port)
def __init__(self, name, host, port, workers, use_ssl=False):
"""Initialize, but do not start the WSGI server.
:param name: The name of the WSGI server given to the loader.
:param use_ssl: Wraps the socket in an SSL context if True.
:returns: None
"""
self.name = name
self.app = app.VersionSelectorApplication()
self.workers = workers
if self.workers and self.workers < 1:
raise exception.ConfigInvalid(
_("api_workers value of %d is invalid, "
"must be greater than 0.") % self.workers)
socket_family = None
if IPAddress(host).version == 4:
socket_family = socket.AF_INET
elif IPAddress(host).version == 6:
socket_family = socket.AF_INET6
self.server = wsgi.Server(CONF,
name,
self.app,
host=host,
port=port,
socket_family=socket_family,
use_ssl=use_ssl)
def main():
config.init(app.common_opts, sys.argv[1:])
application = app.setup_app()
host = CONF.bind_host
port = CONF.bind_port
workers = CONF.api_workers
if workers < 1:
LOG.warning("Wrong worker number, worker = %(workers)s", workers)
workers = 1
LOG.info("Admin API on http://%(host)s:%(port)s with %(workers)s", {
'host': host,
'port': port,
'workers': workers
})
service = wsgi.Server(CONF, 'Tricircle Admin_API', application, host, port)
restapp.serve(service, CONF, workers)
LOG.info("Configuration:")
CONF.log_opt_values(LOG, logging.INFO)
restapp.wait()
def main():
api_config.init(sys.argv[1:])
api_config.setup_logging()
application = app.setup_app()
host = CONF.bind_host
port = CONF.bind_port
workers = CONF.api_workers
if workers < 1:
LOG.warning("Wrong worker number, worker = %(workers)s", workers)
workers = 1
LOG.info("Server on http://%(host)s:%(port)s with %(workers)s", {
'host': host,
'port': port,
'workers': workers
})
messaging.setup()
systemd.notify_once()
service = wsgi.Server(CONF, "OrchEngine", application, host, port)
app.serve(service, CONF, workers)
LOG.info("Configuration:")
CONF.log_opt_values(LOG, std_logging.INFO)
app.wait()
def __init__(self, name, loader=None):
"""Initialize, but do not start the WSGI server.
:param name: The name of the WSGI server given to the loader.
:param loader: Loads the WSGI application using the given name.
:returns: None
"""
self.name = name
self.manager = self._get_manager()
self.loader = loader or wsgi.Loader(CONF)
if not rpc.initialized():
rpc.init(CONF)
self.app = self.loader.load_app(name)
self.host = getattr(CONF, '%s_listen' % name, "0.0.0.0")
self.port = getattr(CONF, '%s_listen_port' % name, 0)
self.workers = getattr(CONF, '%s_workers' % name, None)
self.use_ssl = getattr(CONF, '%s_use_ssl' % name, False)
if self.workers is not None and self.workers < 1:
LOG.warning(
"Value of config option %(name)s_workers must be integer "
"greater than 1. Input value ignored.", {'name': name})
# Reset workers to default
self.workers = None
self.server = wsgi.Server(CONF,
name,
self.app,
host=self.host,
port=self.port,
use_ssl=self.use_ssl)
def __init__(self, name, loader=None):
"""Initialize, but do not start the WSGI server.
:param name: The name of the WSGI server given to the loader.
:param loader: Loads the WSGI application using the given name.
:returns: None
"""
self.name = name
self.manager = self._get_manager()
self.loader = loader or wsgi.Loader(CONF)
self.app = self.loader.load_app(name)
self.host = getattr(CONF, '%s_listen' % name, "0.0.0.0")
self.port = getattr(CONF, '%s_listen_port' % name, 0)
self.workers = (getattr(CONF, '%s_workers' % name, None)
or processutils.get_worker_count())
if self.workers and self.workers < 1:
worker_name = '%s_workers' % name
msg = (_("%(worker_name)s value of %(workers)d is invalid, "
"must be greater than 0.") % {
'worker_name': worker_name,
'workers': self.workers
})
raise exception.InvalidInput(msg)
setup_profiler(name, self.host)
self.server = wsgi.Server(CONF,
name,
self.app,
host=self.host,
port=self.port)
def main():
api_config.init(sys.argv[1:])
api_config.setup_logging()
messaging.setup()
dcmanager_messaging.setup()
application = app.load_paste_app()
if CONF.type not in consts.ENDPOINT_TYPES_LIST:
LOG.error("Unsupported endpoint type: (%s)", CONF.type)
sys.exit(1)
CONF.register_opts(proxy_opts, CONF.type)
host, port = utils.get_host_port_options(CONF)
workers = CONF.api_workers
if workers < 1:
LOG.warning("Wrong worker number, worker = %(workers)s", workers)
workers = 1
LOG.info("Server on http://%(host)s:%(port)s with %(workers)s",
{'host': host, 'port': port, 'workers': workers})
systemd.notify_once()
service = wsgi.Server(CONF, CONF.prog, application, host, port)
app.serve(service, CONF, workers)
LOG.info("Configuration:")
CONF.log_opt_values(LOG, std_logging.INFO)
app.wait()
def main():
config.init(sys.argv[1:])
config.setup_logging()
application = app.load_paste_app()
CONF.register_opts(api_opts, 'api')
host = CONF.api.bind_host
port = CONF.api.bind_port
workers = CONF.api.api_workers
if workers < 1:
LOG.warning("Wrong worker number, worker = %(workers)s", workers)
workers = 1
LOG.info("Server on http://%(host)s:%(port)s with %(workers)s", {
'host': host,
'port': port,
'workers': workers
})
systemd.notify_once()
service = wsgi.Server(CONF, CONF.prog, application, host, port)
app.serve(service, CONF, workers)
LOG.debug("Configuration:")
CONF.log_opt_values(LOG, std_logging.DEBUG)
app.wait()
def __init__(self):
self.app = app.app
self.server = wsgi.Server(CONF,
'ironic_inspector',
self.app,
host=CONF.listen_address,
port=CONF.listen_port,
use_ssl=CONF.use_ssl)
def start(self):
"""Start the API service in the background."""
self.service = wsgi.Server(self._conf,
'ironic-python-agent',
app=self,
host=netutils.get_wildcard_address(),
port=self.PORT)
self.service.start()
LOG.info('Started API service on port %s', self.PORT)
def start(self):
"""Start the API service in the background."""
self.service = wsgi.Server(self._conf, 'ironic-python-agent', app=self,
host=self.agent.listen_address.hostname,
port=self.agent.listen_address.port,
use_ssl=self._conf.listen_tls)
self.service.start()
LOG.info('Started API service on port %s',
self.agent.listen_address.port)
def start(self):
self.server = wsgi.Server(CONF,
"m19k",
self._app,
host = self.host,
port = self.port,
use_ssl = self.use_ssl)
launcher = service.ProcessLauncher(CONF)
launcher.launch_service(self.server, workers = self.workers)
LOG.debug("launch service (%s:%s)." % (self.host, self.port))
launcher.wait()
def run_wsgi_app(app):
server = wsgi.Server("Nca")
server.start(app,
cfg.CONF.bind_port,
cfg.CONF.bind_host,
workers=_get_api_workers())
LOG.info("nca service started, listening on %(host)s:%(port)s", {
'host': cfg.CONF.bind_host,
'port': cfg.CONF.bind_port
})
return server
def main():
api_config.init(sys.argv[1:])
api_config.setup_logging()
host = CONF.api.bind_host
port = CONF.api.bind_port
workers = CONF.api.workers
application = app.setup()
service = wsgi.Server(CONF, 'bigbang', application, host, port)
app.serve(service, CONF, workers)
app.wait()
def __init__(self, name):
self.name = name
self.app = app.setup_app()
self.workers = (cfg.CONF.api.api_workers
or processutils.get_worker_count())
self.server = wsgi.Server(cfg.CONF,
name,
self.app,
host=cfg.CONF.api.host,
port=cfg.CONF.api.port,
use_ssl=cfg.CONF.api.enable_ssl_api)
def __init__(self, name):
self.name = name
self.app = app.create_app(app_name='flocx-market')
self.workers = (CONF.api.api_workers
or processutils.get_worker_count())
self.server = wsgi.Server(CONF,
name,
self.app,
host=CONF.api.host_ip,
port=CONF.api.port,
use_ssl=CONF.api.enable_ssl_api)
def __init__(self):
self.app = app.setup_app()
self.workers = processutils.get_worker_count()
self.server = wsgi.Server(
CONF,
"multivimbroker",
self.app,
host="0.0.0.0",
port=mc_cfg.API_SERVER_PORT,
use_ssl=False
)
def __init__(self, name):
self._host = CONF.api_migration_listen
self._port = CONF.api_migration_listen_port
self._workers = (CONF.api_migration_workers or
processutils.get_worker_count())
self._loader = wsgi.Loader(CONF)
self._app = self._loader.load_app(name)
self._server = wsgi.Server(CONF,
name,
self._app,
host=self._host,
port=self._port)
def run(self):
ensure_dir(cfg.CONF.trace_profiler.trace_path)
ensure_dir(cfg.CONF.trace_profiler.sock_path)
sock_path = os.path.join(cfg.CONF.trace_profiler.sock_path,
str(os.getpid()))
socket_mode = 0o666
server = wsgi.Server(cfg.CONF,
"profiler-server",
ProfilerHandler(),
socket_family=socket.AF_UNIX,
socket_mode=socket_mode,
socket_file=sock_path)
server.start()
server.wait()
def __init__(self, service_name, use_ssl=False):
"""Initialize, but do not start the WSGI server.
:param service_name: The service name of the WSGI server.
:param use_ssl: Wraps the socket in an SSL context if True.
"""
self.service_name = service_name
self.app = app.VersionSelectorApplication()
self.workers = (CONF.api.workers or
processutils.get_worker_count())
self.server = wsgi.Server(CONF, self.service_name, self.app,
host=CONF.api.host,
port=CONF.api.port,
use_ssl=use_ssl,
logger_name=self.service_name)
def __init__(self, manager, serializer):
self.manager = manager
self.serializer = serializer
self._method_map = _build_method_map(manager)
if json_rpc.require_authentication():
conf = dict(CONF.keystone_authtoken)
app = auth_token.AuthProtocol(self._application, conf)
else:
app = self._application
self.server = wsgi.Server(CONF,
'ironic-json-rpc',
app,
host=CONF.json_rpc.host_ip,
port=CONF.json_rpc.port,
use_ssl=CONF.json_rpc.use_ssl)
def __init__(self):
self.app = app.setup_app()
self.workers = CONF.api.api_workers
if self.workers is not None and self.workers < 1:
LOG.warning("Value of config option api_workers must be integer "
"greater than 1. Input value ignored.")
self.workers = None
self.workers = self.workers or processutils.get_worker_count()
self.server = wsgi.Server(cfg.CONF,
"qinling_api",
self.app,
host=cfg.CONF.api.host,
port=cfg.CONF.api.port,
use_ssl=cfg.CONF.api.enable_ssl_api)
def start(self, tls_cert_file=None, tls_key_file=None):
"""Start the API service in the background."""
if tls_cert_file and tls_key_file:
self._conf.set_override('cert_file', tls_cert_file, group='ssl')
self._conf.set_override('key_file', tls_key_file, group='ssl')
use_tls = True
else:
use_tls = self._conf.listen_tls
self.service = wsgi.Server(self._conf,
'ironic-python-agent',
app=self,
host=self.agent.listen_address.hostname,
port=self.agent.listen_address.port,
use_ssl=use_tls)
self.service.start()
LOG.info('Started API service on port %s',
self.agent.listen_address.port)
def __init__(self, name):
self._host = CONF.api.api_listen
self._port = CONF.api.api_listen_port
if platform.system() == "Windows":
self._workers = 1
else:
self._workers = ((CONF.api.api_workers
or processutils.get_worker_count()))
self._loader = wsgi.Loader(CONF)
self._app = self._loader.load_app(name)
self._server = wsgi.Server(CONF,
name,
self._app,
host=self._host,
port=self._port)
def __init__(self, name, use_ssl=False):
"""Initialize, but do not start the WSGI server.
:param name: The name of the WSGI server given to the loader.
:param use_ssl: Wraps the socket in an SSL context if True.
:returns: None
"""
self.name = name
self.app = app.setup_app()
self.workers = (processutils.get_worker_count())
if self.workers and self.workers < 1:
raise exception.ConfigInvalid(
_("api_workers value of %d is invalid, "
"must be greater than 0.") % self.workers)
self.server = wsgi.Server(CONF, name, self.app,
host=CONF.api.host,
port=CONF.api.port,
use_ssl=use_ssl)
def _run_wsgi(app_name):
app = config.load_paste_app(app_name)
if not app:
LOG.error(_('No known API applications configured.'))
return
server = wsgi.Server(cfg.CONF,
app_name,
app,
host=cfg.CONF.bind_host,
port=cfg.CONF.bind_port,
use_ssl=sslutils.is_enabled(cfg.CONF))
server.start()
# Dump all option values here after all options are parsed
cfg.CONF.log_opt_values(LOG, std_logging.DEBUG)
LOG.info(_("Hypernet service started, listening on %(host)s:%(port)s"), {
'host': cfg.CONF.bind_host,
'port': cfg.CONF.bind_port
})
return server
def __init__(self, manager, serializer):
self.manager = manager
self.serializer = serializer
self._method_map = _build_method_map(manager)
auth_strategy = json_rpc.auth_strategy()
if auth_strategy == 'keystone':
conf = dict(CONF.keystone_authtoken)
app = auth_token.AuthProtocol(self._application, conf)
elif auth_strategy == 'http_basic':
app = auth_basic.BasicAuthMiddleware(
self._application, cfg.CONF.json_rpc.http_basic_auth_user_file)
else:
app = self._application
self.server = wsgi.Server(CONF,
'ironic-json-rpc',
app,
host=CONF.json_rpc.host_ip,
port=CONF.json_rpc.port,
use_ssl=CONF.json_rpc.use_ssl)
def main():
api_config.init(sys.argv[1:])
api_config.setup_logging()
application = app.setup_app()
host = CONF.api.bind_host
port = CONF.api.bind_port
workers = 1
LOG.info(("Server on http://%(host)s:%(port)s with %(workers)s"), {
'host': host,
'port': port,
'workers': workers
})
service = wsgi.Server(CONF, "plasma", application, host, port)
app.serve(service, CONF, workers)
LOG.info("Configuration:")
app.wait()
def __init__(self, name, worker_count=None):
self._host = CONF.api_migration_listen
self._port = CONF.api_migration_listen_port
# NOTE: oslo_service fork()'s, which won't work on Windows...
if platform.system() == "Windows":
self._workers = 1
elif worker_count is not None:
self._workers = int(worker_count)
else:
self._workers = (CONF.api_migration_workers
or processutils.get_worker_count())
self._loader = wsgi.Loader(CONF)
self._app = self._loader.load_app(name)
self._server = wsgi.Server(CONF,
name,
self._app,
host=self._host,
port=self._port)
def __init__(self, app, name, listen, max_url_len=None):
super(WSGIService, self).__init__(CONF.senlin_api.threads)
self.app = app
self.name = name
self.listen = listen
self.servers = []
for address in self.listen:
host, port = netutils.parse_host_port(address)
server = wsgi.Server(CONF,
name,
app,
host=host,
port=port,
pool_size=CONF.senlin_api.threads,
use_ssl=sslutils.is_enabled(CONF),
max_url_len=max_url_len)
self.servers.append(server)
