def main(): """ Serve the LocalstackGateway with the default configuration directly through hypercorn. This is mostly for development purposes and documentation on how to serve the Gateway. """ from .serving.hypercorn import serve use_ssl = True port = 4566 # serve the LocalStackAwsGateway in a dev app from localstack.utils.bootstrap import setup_logging setup_logging() if use_ssl: from localstack.services.generic_proxy import ( GenericProxy, install_predefined_cert_if_available, ) install_predefined_cert_if_available() _, cert_file_name, key_file_name = GenericProxy.create_ssl_cert( serial_number=port) ssl_creds = (cert_file_name, key_file_name) else: ssl_creds = None gw = LocalstackAwsGateway(SERVICE_PLUGINS) serve(gw, use_reloader=True, port=port, ssl_creds=ssl_creds)
def start_infra(asynchronous=False, apis=None): try: # load plugins load_plugins() event_publisher.fire_event(event_publisher.EVENT_START_INFRA, {'d': in_docker() and 1 or 0, 'c': in_ci() and 1 or 0}) # set up logging setup_logging() # prepare APIs apis = canonicalize_api_names(apis) # set environment os.environ['AWS_REGION'] = config.DEFAULT_REGION os.environ['ENV'] = ENV_DEV # register signal handlers if not os.environ.get(ENV_INTERNAL_TEST_RUN): register_signal_handlers() # make sure AWS credentials are configured, otherwise boto3 bails on us check_aws_credentials() # install libs if not present install.install_components(apis) # Some services take a bit to come up sleep_time = 5 # start services thread = None if 'elasticsearch' in apis or 'es' in apis: sleep_time = max(sleep_time, 10) # loop through plugins and start each service for name, plugin in SERVICE_PLUGINS.items(): if name in apis: t1 = plugin.start(asynchronous=True) thread = thread or t1 time.sleep(sleep_time) # ensure that all infra components are up and running check_infra(apis=apis) # restore persisted data restore_persisted_data(apis=apis) print('Ready.') sys.stdout.flush() if not asynchronous and thread: # this is a bit of an ugly hack, but we need to make sure that we # stay in the execution context of the main thread, otherwise our # signal handlers don't work while True: time.sleep(1) return thread except KeyboardInterrupt: print('Shutdown') except Exception as e: print('Error starting infrastructure: %s %s' % (e, traceback.format_exc())) sys.stdout.flush() raise e finally: if not asynchronous: stop_infra()
def do_start_infra(asynchronous, apis, is_in_docker): # import to avoid cyclic dependency from localstack.services.edge import BOOTSTRAP_LOCK event_publisher.fire_event(event_publisher.EVENT_START_INFRA, {'d': is_in_docker and 1 or 0, 'c': in_ci() and 1 or 0}) # set up logging setup_logging() # prepare APIs apis = canonicalize_api_names(apis) @log_duration() def prepare_environment(): # set environment os.environ['AWS_REGION'] = config.DEFAULT_REGION os.environ['ENV'] = ENV_DEV # register signal handlers if not is_local_test_mode(): register_signal_handlers() # make sure AWS credentials are configured, otherwise boto3 bails on us check_aws_credentials() @log_duration() def prepare_installation(): # install libs if not present install.install_components(apis) @log_duration() def start_api_services(): # Some services take a bit to come up sleep_time = 5 # start services thread = None # loop through plugins and start each service for name, plugin in SERVICE_PLUGINS.items(): if plugin.is_enabled(api_names=apis): record_service_health(name, 'starting') t1 = plugin.start(asynchronous=True) thread = thread or t1 time.sleep(sleep_time) # ensure that all infra components are up and running check_infra(apis=apis) # restore persisted data persistence.restore_persisted_data(apis=apis) return thread prepare_environment() prepare_installation() with BOOTSTRAP_LOCK: thread = start_api_services() print(READY_MARKER_OUTPUT) sys.stdout.flush() return thread
def main(): setup_logging() # make sure all API names and ports are mapped properly canonicalize_api_names() # start API sys.exit(start_up())
def _setup_cli_debug(): from localstack import config from localstack.utils.bootstrap import setup_logging config.DEBUG = True os.environ["DEBUG"] = "1" setup_logging()
def start_infra(asynchronous=False, apis=None): try: os.environ[LOCALSTACK_INFRA_PROCESS] = "1" is_in_docker = in_docker() # print a warning if we're not running in Docker but using Docker based LAMBDA_EXECUTOR if not is_in_docker and "docker" in config.LAMBDA_EXECUTOR and not is_linux(): print( ( "!WARNING! - Running outside of Docker with $LAMBDA_EXECUTOR=%s can lead to " "problems on your OS. The environment variable $LOCALSTACK_HOSTNAME may not " "be properly set in your Lambdas." ) % config.LAMBDA_EXECUTOR ) if is_in_docker and not config.LAMBDA_REMOTE_DOCKER and not config.dirs.functions: print( "!WARNING! - Looks like you have configured $LAMBDA_REMOTE_DOCKER=0 - " "please make sure to configure $HOST_TMP_FOLDER to point to your host's $TMPDIR" ) print_runtime_information(is_in_docker) # apply patches patch_urllib3_connection_pool(maxsize=128) patch_instance_tracker_meta() # set up logging setup_logging() # run hooks, to allow them to apply patches and changes hooks.on_infra_start.run() # with changes that hooks have made, now start the infrastructure thread = do_start_infra(asynchronous, apis, is_in_docker) if not asynchronous and thread: # We're making sure that we stay in the execution context of the # main thread, otherwise our signal handlers don't work SHUTDOWN_INFRA.wait() return thread except KeyboardInterrupt: print("Shutdown") except Exception as e: print("Error starting infrastructure: %s %s" % (e, traceback.format_exc())) sys.stdout.flush() raise e finally: if not asynchronous: stop_infra()
def main(): setup_logging() # patch moto implementation apply_patches() # add memory profiling endpoint inject_stats_endpoint() # make sure all API names and ports are mapped properly canonicalize_api_names() # start API sys.exit(moto_main())
def do_start_infra(asynchronous, apis, is_in_docker): event_publisher.fire_event(event_publisher.EVENT_START_INFRA, { 'd': is_in_docker and 1 or 0, 'c': in_ci() and 1 or 0 }) # set up logging setup_logging() # prepare APIs apis = canonicalize_api_names(apis) # set environment os.environ['AWS_REGION'] = config.DEFAULT_REGION os.environ['ENV'] = ENV_DEV # register signal handlers if not is_local_test_mode(): register_signal_handlers() # make sure AWS credentials are configured, otherwise boto3 bails on us check_aws_credentials() # install libs if not present install.install_components(apis) # Some services take a bit to come up sleep_time = 5 # start services thread = None # loop through plugins and start each service for name, plugin in SERVICE_PLUGINS.items(): if plugin.is_enabled(api_names=apis): record_service_health(name, 'starting') t1 = plugin.start(asynchronous=True) thread = thread or t1 time.sleep(sleep_time) # ensure that all infra components are up and running check_infra(apis=apis) # restore persisted data persistence.restore_persisted_data(apis=apis) print('Ready.') sys.stdout.flush() if not asynchronous and thread: # this is a bit of an ugly hack, but we need to make sure that we # stay in the execution context of the main thread, otherwise our # signal handlers don't work sleep_forever() return thread
def cli(): """ The LocalStack Package Manager (lpm) CLI is a set of commands to install third-party packages used by localstack service providers. Here are some handy commands: List all packages python -m localstack.cli.lpm list Install DynamoDB Local: python -m localstack.cli.install dynamodb-local Install all community packages, four in parallel: python -m localstack.cli.lpm list | grep "/community" | cut -d'/' -f1 | xargs python -m localstack.cli.lpm install --parallel 4 """ setup_logging()
def start_infra(asynchronous=False, apis=None): events.infra_starting.set() try: os.environ[LOCALSTACK_INFRA_PROCESS] = "1" is_in_docker = in_docker() print_runtime_information(is_in_docker) # apply patches patch_urllib3_connection_pool(maxsize=128) patch_instance_tracker_meta() # set up logging setup_logging() # run hooks, to allow them to apply patches and changes hooks.on_infra_start.run() # with changes that hooks have made, now start the infrastructure thread = do_start_infra(asynchronous, apis, is_in_docker) if not asynchronous and thread: # We're making sure that we stay in the execution context of the # main thread, otherwise our signal handlers don't work SHUTDOWN_INFRA.wait() return thread except KeyboardInterrupt: print("Shutdown") except Exception as e: print("Error starting infrastructure: %s %s" % (e, traceback.format_exc())) sys.stdout.flush() raise e finally: if not asynchronous: stop_infra()
def main(): setup_logging() port = int(sys.argv[1]) if len(sys.argv) > 0 else MULTI_SERVER_PORT start_server(port)
def main(): LOG.info("LocalStack version: %s" % constants.VERSION) # set basic CLI commands config.CLI_COMMANDS["infra"] = { "description": "Commands to manage the infrastructure", "function": cmd_infra, } config.CLI_COMMANDS["start"] = { "description": "Shorthand to start the infrastructure", "function": cmd_infra, } config.CLI_COMMANDS["ssh"] = { "description": "Shorthand to obtain a shell in the running container", "function": cmd_ssh, } config.CLI_COMMANDS["status"] = { "description": "Obtain status details about the installation", "function": cmd_status, } config.CLI_COMMANDS["config"] = { "description": "Validate docker configurations", "function": cmd_config, } # load CLI plugins bootstrap.load_plugins(scope=bootstrap.PLUGIN_SCOPE_COMMANDS) # create final usage string additional_params = [] additional_commands = "" for cmd in sorted(config.CLI_COMMANDS.keys()): cmd_details = config.CLI_COMMANDS[cmd] additional_commands += "\n %s%s%s" % ( cmd, (20 - len(cmd)) * " ", cmd_details["description"], ) for param in cmd_details.get("parameters", []): additional_params.append(param) additional_params = "\n".join(additional_params) doc_string = __doc__ % (additional_commands, additional_params) args = docopt(doc_string, options_first=True) if args["--version"]: print(constants.VERSION) sys.exit(0) if args["--debug"]: config.DEBUG = True os.environ["DEBUG"] = "1" # set up logging (after DEBUG has been configured) setup_logging() # invoke subcommand argv = [args["<command>"]] + args["<args>"] subcommand = config.CLI_COMMANDS.get(args["<command>"]) if subcommand: try: subcommand["function"](argv, args) except Exception as e: if os.environ.get("DEBUG") in ["1", "true"]: print(traceback.format_exc()) print("ERROR: %s" % e) sys.exit(1) else: print('ERROR: Invalid command "%s"' % args["<command>"]) sys.exit(1)
def main(): setup_logging() port = int(sys.argv[1]) if len(sys.argv) > 1 else get_multi_server_port() start_server(port)
def do_start_infra(asynchronous, apis, is_in_docker): event_publisher.fire_event( event_publisher.EVENT_START_INFRA, { "d": is_in_docker and 1 or 0, "c": in_ci() and 1 or 0 }, ) # set up logging setup_logging() if config.DEVELOP: install.install_debugpy_and_dependencies() import debugpy LOG.info("Starting debug server at: %s:%s" % (constants.BIND_HOST, config.DEVELOP_PORT)) debugpy.listen((constants.BIND_HOST, config.DEVELOP_PORT)) if config.WAIT_FOR_DEBUGGER: debugpy.wait_for_client() # prepare APIs apis = canonicalize_api_names(apis) analytics.log.event("infra_start", apis=apis) @log_duration() def prepare_environment(): # set environment os.environ["AWS_REGION"] = config.DEFAULT_REGION os.environ["ENV"] = ENV_DEV # register signal handlers if not is_local_test_mode(): register_signal_handlers() # make sure AWS credentials are configured, otherwise boto3 bails on us check_aws_credentials() patch_moto_request_handling() @log_duration() def prepare_installation(): # install libs if not present install.install_components(apis) @log_duration() def preload_services(): """ Preload services if EAGER_SERVICE_LOADING is true. """ # TODO: lazy loading should become the default beginning 0.13.0 if not config.EAGER_SERVICE_LOADING: # listing the available service plugins will cause resolution of the entry points SERVICE_PLUGINS.list_available() return apis = list() for api in SERVICE_PLUGINS.list_available(): try: SERVICE_PLUGINS.require(api) apis.append(api) except ServiceDisabled as e: LOG.debug("%s", e) except Exception: LOG.exception("could not load service plugin %s", api) if persistence.is_persistence_enabled(): if not config.is_env_true(constants.ENV_PRO_ACTIVATED): LOG.warning( "Persistence mechanism for community services (based on API calls record&replay) will be " "deprecated in 0.13.0 ") persistence.restore_persisted_data(apis) @log_duration() def start_runtime_components(): from localstack.services.edge import start_edge from localstack.services.internal import LocalstackResourceHandler, get_internal_apis # serve internal APIs through the generic proxy ProxyListener.DEFAULT_LISTENERS.append( LocalstackResourceHandler(get_internal_apis())) # TODO: we want a composable LocalStack runtime (edge proxy, service manager, dns, ...) t = start_thread(start_edge, quiet=False) # TODO: properly encapsulate starting/stopping of edge server in a class if not poll_condition( lambda: is_port_open(config.get_edge_port_http()), timeout=5, interval=0.1): raise TimeoutError( f"gave up waiting for edge server on {config.EDGE_BIND_HOST}:{config.EDGE_PORT}" ) return t prepare_environment() prepare_installation() thread = start_runtime_components() preload_services() if config.DATA_DIR: persistence.save_startup_info() print(READY_MARKER_OUTPUT) sys.stdout.flush() INFRA_READY.set() analytics.log.event("infra_ready") return thread
def do_start_infra(asynchronous, apis, is_in_docker): # import to avoid cyclic dependency from localstack.services.edge import BOOTSTRAP_LOCK event_publisher.fire_event( event_publisher.EVENT_START_INFRA, { "d": is_in_docker and 1 or 0, "c": in_ci() and 1 or 0 }, ) # set up logging setup_logging() if config.DEVELOP: install.install_debugpy_and_dependencies() import debugpy LOG.info("Starting debug server at: %s:%s" % (constants.BIND_HOST, config.DEVELOP_PORT)) debugpy.listen((constants.BIND_HOST, config.DEVELOP_PORT)) if config.WAIT_FOR_DEBUGGER: debugpy.wait_for_client() # prepare APIs apis = canonicalize_api_names(apis) analytics.log.event("infra_start", apis=apis) @log_duration() def prepare_environment(): # set environment os.environ["AWS_REGION"] = config.DEFAULT_REGION os.environ["ENV"] = ENV_DEV # register signal handlers if not is_local_test_mode(): register_signal_handlers() # make sure AWS credentials are configured, otherwise boto3 bails on us check_aws_credentials() @log_duration() def prepare_installation(): # install libs if not present install.install_components(apis) @log_duration() def start_api_services(): # Some services take a bit to come up sleep_time = 5 # start services thread = None # loop through plugins and start each service for name, plugin in SERVICE_PLUGINS.items(): if plugin.is_enabled(api_names=apis): record_service_health(name, "starting") t1 = plugin.start(asynchronous=True) thread = thread or t1 time.sleep(sleep_time) # ensure that all infra components are up and running check_infra(apis=apis) # restore persisted data record_service_health( "features:persistence", "initializing" if config.DATA_DIR else "disabled") persistence.restore_persisted_data(apis=apis) if config.DATA_DIR: record_service_health("features:persistence", "initialized") return thread prepare_environment() prepare_installation() with BOOTSTRAP_LOCK: thread = start_api_services() if config.DATA_DIR: persistence.save_startup_info() print(READY_MARKER_OUTPUT) sys.stdout.flush() INFRA_READY.set() analytics.log.event("infra_ready") return thread
def main(): LOG.info('LocalStack version: %s' % constants.VERSION) # set basic CLI commands config.CLI_COMMANDS['infra'] = { 'description': 'Commands to manage the infrastructure', 'function': cmd_infra } config.CLI_COMMANDS['start'] = { 'description': 'Shorthand to start the infrastructure', 'function': cmd_infra } config.CLI_COMMANDS['web'] = { 'description': 'Commands to manage the Web dashboard (deprecated)', 'function': cmd_web } config.CLI_COMMANDS['ssh'] = { 'description': 'Shorthand to obtain a shell in the running container', 'function': cmd_ssh } config.CLI_COMMANDS['status'] = { 'description': 'Obtain status details about the installation', 'function': cmd_status } config.CLI_COMMANDS['config'] = { 'description': 'Validate docker configurations', 'function': cmd_config } # load CLI plugins bootstrap.load_plugins(scope=bootstrap.PLUGIN_SCOPE_COMMANDS) # create final usage string additional_params = [] additional_commands = '' for cmd in sorted(config.CLI_COMMANDS.keys()): cmd_details = config.CLI_COMMANDS[cmd] additional_commands += '\n %s%s%s' % (cmd, (20 - len(cmd)) * ' ', cmd_details['description']) for param in cmd_details.get('parameters', []): additional_params.append(param) additional_params = '\n'.join(additional_params) doc_string = __doc__ % (additional_commands, additional_params) args = docopt(doc_string, options_first=True) if args['--version']: print(constants.VERSION) sys.exit(0) if args['--debug']: config.DEBUG = True os.environ['DEBUG'] = '1' # set up logging (after DEBUG has been configured) setup_logging() # invoke subcommand argv = [args['<command>']] + args['<args>'] subcommand = config.CLI_COMMANDS.get(args['<command>']) if subcommand: try: subcommand['function'](argv, args) except Exception as e: if os.environ.get('DEBUG') in ['1', 'true']: print(traceback.format_exc()) print('ERROR: %s' % e) sys.exit(1) else: print('ERROR: Invalid command "%s"' % args['<command>']) sys.exit(1)
def start_infra(asynchronous=False, apis=None): try: os.environ[LOCALSTACK_INFRA_PROCESS] = '1' is_in_docker = in_docker() # print a warning if we're not running in Docker but using Docker based LAMBDA_EXECUTOR if not is_in_docker and 'docker' in config.LAMBDA_EXECUTOR and not is_linux( ): print(( '!WARNING! - Running outside of Docker with $LAMBDA_EXECUTOR=%s can lead to ' 'problems on your OS. The environment variable $LOCALSTACK_HOSTNAME may not ' 'be properly set in your Lambdas.') % config.LAMBDA_EXECUTOR) if is_in_docker and config.LAMBDA_REMOTE_DOCKER and not os.environ.get( 'HOST_TMP_FOLDER'): print( '!WARNING! - Looks like you have configured $LAMBDA_REMOTE_DOCKER=1 - ' "please make sure to configure $HOST_TMP_FOLDER to point to your host's $TMPDIR" ) # apply patches patch_urllib3_connection_pool(maxsize=128) # load plugins load_plugins() event_publisher.fire_event(event_publisher.EVENT_START_INFRA, { 'd': is_in_docker and 1 or 0, 'c': in_ci() and 1 or 0 }) # set up logging setup_logging() # prepare APIs apis = canonicalize_api_names(apis) # set environment os.environ['AWS_REGION'] = config.DEFAULT_REGION os.environ['ENV'] = ENV_DEV # register signal handlers if not os.environ.get(ENV_INTERNAL_TEST_RUN): register_signal_handlers() # make sure AWS credentials are configured, otherwise boto3 bails on us check_aws_credentials() # install libs if not present install.install_components(apis) # Some services take a bit to come up sleep_time = 5 # start services thread = None # loop through plugins and start each service for name, plugin in SERVICE_PLUGINS.items(): if plugin.is_enabled(api_names=apis): record_service_health(name, 'starting') t1 = plugin.start(asynchronous=True) thread = thread or t1 time.sleep(sleep_time) # ensure that all infra components are up and running check_infra(apis=apis) # restore persisted data persistence.restore_persisted_data(apis=apis) print('Ready.') sys.stdout.flush() if not asynchronous and thread: # this is a bit of an ugly hack, but we need to make sure that we # stay in the execution context of the main thread, otherwise our # signal handlers don't work while True: time.sleep(1) return thread except KeyboardInterrupt: print('Shutdown') except Exception as e: print('Error starting infrastructure: %s %s' % (e, traceback.format_exc())) sys.stdout.flush() raise e finally: if not asynchronous: stop_infra()
def main(): setup_logging() # patch moto implementation apply_patches() # start API sys.exit(moto_main())