def __init__(self):
zato_options = sys.argv[1]
zato_options = parse_cmd_line_options(zato_options)
self.deployment_key = zato_options['deployment_key']
self.shmem_size = int(zato_options['shmem_size'])
self.host = '127.0.0.1'
self.port = None
self.username = None
self.password = None
self.server_auth = None
self.basic_auth_expected = None
self.server_port = None
self.server_path = None
self.server_address = 'http://127.0.0.1:{}{}'
self.lock = RLock()
self.logger = None
self.parent_pid = getppid()
self.config_ipc = ConnectorConfigIPC()
self.config_ipc.create(self.deployment_key, self.shmem_size, False)
self.connections = {}
self.outconns = {}
self.channels = {}
self.outconn_id_to_def_id = {} # Maps outgoing connection IDs to their underlying definition IDs
self.channel_id_to_def_id = {} # Ditto but for channels
self.outconn_name_to_id = {} # Maps outgoing connection names to their IDs
self.set_config()
def resolve_secret_key(secret_key, _url_prefix=SECRETS.URL_PREFIX):
""" Finds a secret key among command line options or via environment variables.
"""
# We always require a string
secret_key = secret_key or ''
if secret_key and (not isinstance(_url_prefix, bytes)):
_url_prefix = _url_prefix.encode('utf8')
# This is a direct value, to be used as-is
if not secret_key.startswith(_url_prefix):
return secret_key
else:
# We need to look it up somewhere
secret_key = secret_key.replace(_url_prefix, '', 1)
# Command line options
if secret_key.startswith('cli'):
# This will be used by check-config
for idx, elem in enumerate(sys.argv):
if elem == '--secret-key':
secret_key = sys.argv[idx + 1]
break
# This will be used when components are invoked as subprocesses
else:
# To prevent circular imports
from zato.common.util import parse_cmd_line_options
cli_options = parse_cmd_line_options(sys.argv[1])
secret_key = cli_options['secret_key']
# Environment variables
elif secret_key.startswith('env'):
env_key = secret_key.replace('env.', '', 1)
secret_key = os.environ[env_key]
# Unknown scheme, we need to give up
else:
raise ValueError('Unknown secret key type `{}`'.format(secret_key))
# At this point, we have a secret key extracted in one way or another
return secret_key if isinstance(secret_key,
bytes) else secret_key.encode('utf8')
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import os, sys
# ConcurrentLogHandler - updates stlidb's logging config on import so this needs to stay
import cloghandler
cloghandler = cloghandler # For pyflakes
# Zato
from zato.agent.load_balancer.server import LoadBalancerAgent, TLSLoadBalancerAgent
from zato.common.util import get_lb_agent_json_config, parse_cmd_line_options, store_pidfile
if __name__ == '__main__':
repo_dir = sys.argv[1]
component_dir = os.path.join(repo_dir, '..', '..')
lba_config = get_lb_agent_json_config(repo_dir)
# Store agent's pidfile only if we are not running in foreground
options = parse_cmd_line_options(sys.argv[2])
if not options.get('fg', None):
store_pidfile(component_dir, lba_config['pid_file'])
lba_class = TLSLoadBalancerAgent if lba_config.get(
'is_tls_enabled', True) else LoadBalancerAgent
lba = lba_class(repo_dir)
lba.start_load_balancer()
lba.serve_forever()
for key, value in os_environ.items():
os.environ[key] = value
# Run the hook right before the Gunicorn-level server actually starts
startup_callable_tool.invoke(SERVER_STARTUP.PHASE.IMPL_BEFORE_RUN,
kwargs={
'zato_gunicorn_app': zato_gunicorn_app,
})
# Run the app at last
if start_gunicorn_app:
zato_gunicorn_app.run()
else:
return zato_gunicorn_app.zato_wsgi_app
# ################################################################################################################################
if __name__ == '__main__':
server_base_dir = sys.argv[1]
cmd_line_options = sys.argv[2]
if not os.path.isabs(server_base_dir):
server_base_dir = os.path.abspath(
os.path.join(os.getcwd(), server_base_dir))
run(server_base_dir, options=parse_cmd_line_options(cmd_line_options))
# ################################################################################################################################
os.path.join(base_dir, config.profiler.profiler_dir))
server.on_wsgi_request = ProfileMiddleware(
server.on_wsgi_request,
log_filename=os.path.join(profiler_dir,
config.profiler.log_filename),
cachegrind_filename=os.path.join(
profiler_dir, config.profiler.cachegrind_filename),
discard_first_request=config.profiler.discard_first_request,
flush_at_shutdown=config.profiler.flush_at_shutdown,
path=config.profiler.url_path,
unwind=config.profiler.unwind)
# New in 2.0 - set environmet variables for servers to inherit
os_environ = config.get('os_environ', {})
for key, value in os_environ.items():
os.environ[key] = value
# Run the app at last
if start_gunicorn_app:
zato_gunicorn_app.run()
else:
return zato_gunicorn_app.zato_wsgi_app
if __name__ == '__main__':
base_dir = sys.argv[1]
if not os.path.isabs(base_dir):
base_dir = os.path.abspath(os.path.join(os.getcwd(), base_dir))
run(base_dir, options=parse_cmd_line_options(sys.argv[2]))
