def start_lambda(port=None, asynchronous=False): from localstack.services.awslambda import lambda_api, lambda_utils from localstack.services.infra import start_local_api # print a warning if we're not running in Docker but using Docker based LAMBDA_EXECUTOR if "docker" in lambda_utils.get_executor_mode( ) and not config.is_in_docker and not is_linux(): LOG.warning( ("!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."), lambda_utils.get_executor_mode(), ) if config.is_in_docker and not config.LAMBDA_REMOTE_DOCKER and not config.dirs.functions: LOG.warning( "!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" ) port = port or config.service_port("lambda") return start_local_api("Lambda", port, api="lambda", method=lambda_api.serve, asynchronous=asynchronous)
def start_kinesis(port=None, update_listener=None, asynchronous=None) -> Server: """ Creates a singleton of a Kinesis server and starts it on a new thread. Uses either Kinesis Mock or Kinesalite based on value of config.KINESIS_PROVIDER :param port: port to run server on. Selects an arbitrary available port if None. :param update_listener: an update listener instance for server proxy :param asynchronous: currently unused but required by localstack.services.plugins.Service.start(). TODO: either make use of this param or refactor Service.start() to not pass it. :returns: A running Kinesis server instance :raises: ValueError: Value of config.KINESIS_PROVIDER is not recognized as one of "kinesis-mock" or "kinesalite" """ global _server if not _server: if config.KINESIS_PROVIDER == "kinesis-mock": _server = kinesis_mock_server.create_kinesis_mock_server() elif config.KINESIS_PROVIDER == "kinesalite": _server = kinesalite_server.create_kinesalite_server() else: raise ValueError('Unsupported Kinesis provider "%s"' % config.KINESIS_PROVIDER) _server.start() log_startup_message("Kinesis") port = port or config.service_port("kinesis") start_proxy_for_service( "kinesis", port, backend_port=_server.port, update_listener=update_listener, ) return _server
def start_redshift(port=None, asynchronous=False): port = port or config.service_port("redshift") apply_patches() return start_moto_server("redshift", port, name="Redshift", asynchronous=asynchronous)
def start_route53_resolver(port=None, asynchronous=False, update_listener=None): port = port or config.service_port("route53resolver") return start_moto_server( "route53resolver", port, name="Route53 Resolver", asynchronous=asynchronous, update_listener=update_listener, )
def start_cloudformation(port=None, asynchronous=False): port = port or config.service_port("cloudformation") return start_local_api( "CloudFormation", port, api="cloudformation", method=cloudformation_api.serve, asynchronous=asynchronous, )
def start_route53(port=None, asynchronous=False, update_listener=None): port = port or config.service_port("route53") apply_patches() return start_moto_server( "route53", port, name="Route53", asynchronous=asynchronous, update_listener=update_listener, )
def start_acm(port=None, asynchronous=False, update_listener=None): port = port or config.service_port("acm") apply_patches() return start_moto_server( "acm", port, name="ACM", update_listener=update_listener, asynchronous=asynchronous, )
def start_cloudwatch(port=None, asynchronous=False, update_listener=None): port = port or config.service_port("cloudwatch") apply_patches() return start_moto_server( "cloudwatch", port, name="CloudWatch", update_listener=update_listener, asynchronous=asynchronous, )
def start_cloudwatch_logs(port=None, asynchronous=False, update_listener=None): port = port or config.service_port("logs") patch_logs() return start_moto_server( "logs", port, name="CloudWatch Logs", asynchronous=asynchronous, update_listener=update_listener, )
def start_lambda(port=None, asynchronous=False): from localstack.services.awslambda import lambda_api from localstack.services.infra import start_local_api port = port or config.service_port("lambda") return start_local_api("Lambda", port, api="lambda", method=lambda_api.serve, asynchronous=asynchronous)
def start_rgsa(port=None, asynchronous=False, update_listener=None): port = port or config.service_port("resourcegroupstaggingapi") return start_moto_server( "resourcegroupstaggingapi", port, name="Resource Groups Tagging API", asynchronous=asynchronous, update_listener=update_listener, )
def start_ec2(port=None, asynchronous=False, update_listener=None): patch_ec2() port = port or config.service_port("ec2") return start_moto_server( "ec2", port, name="EC2", asynchronous=asynchronous, update_listener=update_listener, )
def start_sts(port=None, asynchronous=False, update_listener=None): apply_patches() port = port or config.service_port("sts") return start_moto_server( "sts", port, name="STS", asynchronous=asynchronous, update_listener=update_listener, )
def start_sns(port=None, asynchronous=False, update_listener=None): from localstack.services.infra import start_moto_server port = port or config.service_port("sns") return start_moto_server( "sns", port, name="SNS", asynchronous=asynchronous, update_listener=update_listener, )
def start_dynamodbstreams(port=None, asynchronous=False): from localstack.services.dynamodbstreams import dynamodbstreams_api from localstack.services.infra import start_local_api port = port or config.service_port("dynamodbstreams") return start_local_api( "DynamoDB Streams", port, api="dynamodbstreams", method=dynamodbstreams_api.serve, asynchronous=asynchronous, )
def start_kms_moto(port=None, backend_port=None, asynchronous=None, update_listener=None): port = port or config.service_port("kms") return start_moto_server( "kms", port, name="KMS", asynchronous=asynchronous, update_listener=update_listener, )
def publish_lambda_metric(metric, value, kwargs): # publish metric only if CloudWatch service is available if not config.service_port('cloudwatch'): return cw_client = aws_stack.connect_to_service('cloudwatch') cw_client.put_metric_data(Namespace='AWS/Lambda', MetricData=[{ 'MetricName': metric, 'Dimensions': dimension_lambda(kwargs), 'Timestamp': datetime.now(), 'Value': value }] )
def start_events(port=None, asynchronous=None, update_listener=None): port = port or config.service_port("events") apply_patches() start_scheduler() return start_moto_server( key="events", port=port, name="Cloudwatch Events", asynchronous=asynchronous, update_listener=update_listener, )
def publish_lambda_metric(metric, value, kwargs): # publish metric only if CloudWatch service is available if not config.service_port('cloudwatch'): return cw_client = aws_stack.connect_to_service('cloudwatch') cw_client.put_metric_data(Namespace='AWS/Lambda', MetricData=[{ 'MetricName': metric, 'Dimensions': dimension_lambda(kwargs), 'Timestamp': datetime.now(), 'Value': value }] )
def start_swf(port=None, backend_port=None, asynchronous=None, update_listener=None): port = port or config.service_port("swf") return start_moto_server( key="swf", name="SWF", asynchronous=asynchronous, port=port, update_listener=update_listener, )
def start_ses(port=None, backend_port=None, asynchronous=None, update_listener=None): port = port or config.service_port("ses") apply_patches() return start_moto_server( key="ses", name="SES", port=port, backend_port=backend_port, asynchronous=asynchronous, update_listener=update_listener, )
def get_external_port(headers): host = headers.get("Host", "") if not host: forwarded = headers.get("X-Forwarded-For", "").split(",") host = forwarded[-2] if len(forwarded) > 2 else forwarded[-1] if ":" in host: return int(host.split(":")[1]) # If we cannot find the Host header, then fall back to the port of SQS itself (i.e., edge proxy). # (Note that this could be incorrect, e.g., if running in Docker with a host port that # is different from the internal container port, but there is not much else we can do.) return config.service_port("sqs")
def start_apigateway(port=None, backend_port=None, asynchronous=None, update_listener=None): port = port or config.service_port("apigateway") apply_patches() result = start_moto_server( key="apigateway", name="API Gateway", asynchronous=asynchronous, port=port, backend_port=backend_port, update_listener=update_listener, ) return result
def start_sqs_moto(port=None, asynchronous=False, update_listener=None) -> Server: from localstack.services import motoserver port = port or config.service_port("sqs") patch_moto() start_moto_server( "sqs", port, name="SQS", asynchronous=asynchronous, update_listener=update_listener, ) return motoserver.get_moto_server()
def publish_lambda_metric(metric, value, kwargs): # publish metric only if CloudWatch service is available if not config.service_port("cloudwatch"): return cw_client = aws_stack.connect_to_service("cloudwatch") try: cw_client.put_metric_data( Namespace="AWS/Lambda", MetricData=[{ "MetricName": metric, "Dimensions": dimension_lambda(kwargs), "Timestamp": datetime.now(), "Value": value, }], ) except Exception as e: LOG.info('Unable to put metric data for metric "%s" to CloudWatch: %s', metric, e)
def get_api_from_headers(headers, path=None): target = headers.get('x-amz-target', '') host = headers.get('host', '') auth_header = headers.get('authorization', '') ls_target = headers.get(HEADER_LOCALSTACK_TARGET, '') path = path or '/' # initialize result result = '_unknown_', 0 # https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html try: credential_scope = auth_header.split(',')[0].split()[1] _, _, _, service, _ = credential_scope.split('/') result = service, config.service_port(service) except Exception: pass # Fallback rules and route customizations applied below if host.endswith('cloudfront.net'): path = path or '/' result = 'cloudfront', config.PORT_CLOUDFRONT elif target.startswith( 'AWSCognitoIdentityProviderService') or 'cognito-idp.' in host: result = 'cognito-idp', config.PORT_COGNITO_IDP elif target.startswith( 'AWSCognitoIdentityService') or 'cognito-identity.' in host: result = 'cognito-identity', config.PORT_COGNITO_IDENTITY elif result[0] == 's3' or re.match( r'.*s3(\-website)?\.([^\.]+\.)?amazonaws.com', host): host = re.sub(r's3-website\..*\.amazonaws', 's3.amazonaws', host) result = 's3', config.PORT_S3 elif result[0] == 'states' in auth_header or host.startswith('states.'): result = 'stepfunctions', config.PORT_STEPFUNCTIONS elif '.execute-api.' in host: result = 'apigateway', config.PORT_APIGATEWAY elif target.startswith('DynamoDBStreams') or host.startswith( 'streams.dynamodb.'): result = 'dynamodbstreams', config.PORT_DYNAMODBSTREAMS elif ls_target == 'web' or path == '/graph': result = 'web', config.PORT_WEB_UI return result[0], result[1], path, host
def get_stream_info( stream_name, log_file=None, shards=None, env=None, endpoint_url=None, ddb_lease_table_suffix=None, env_vars=None, ): if env_vars is None: env_vars = {} if not ddb_lease_table_suffix: ddb_lease_table_suffix = DEFAULT_DDB_LEASE_TABLE_SUFFIX # construct stream info env = aws_stack.get_environment(env) props_file = os.path.join(tempfile.gettempdir(), "kclipy.%s.properties" % short_uid()) # make sure to convert stream ARN to stream name stream_name = aws_stack.kinesis_stream_name(stream_name) app_name = "%s%s" % (stream_name, ddb_lease_table_suffix) stream_info = { "name": stream_name, "region": aws_stack.get_region(), "shards": shards, "properties_file": props_file, "log_file": log_file, "app_name": app_name, "env_vars": env_vars, } # set local connection if aws_stack.is_local_env(env): stream_info["conn_kwargs"] = { "host": LOCALHOST, "port": config.service_port("kinesis"), "is_secure": bool(config.USE_SSL), } if endpoint_url: if "conn_kwargs" not in stream_info: stream_info["conn_kwargs"] = {} url = urlparse(endpoint_url) stream_info["conn_kwargs"]["host"] = url.hostname stream_info["conn_kwargs"]["port"] = url.port stream_info["conn_kwargs"]["is_secure"] = url.scheme == "https" return stream_info
def start_s3(port=None, backend_port=None, asynchronous=None, update_listener=None): port = port or config.service_port("s3") if not backend_port: if config.FORWARD_EDGE_INMEM: backend_port = multiserver.get_moto_server_port() else: backend_port = get_free_tcp_port() s3_listener.PORT_S3_BACKEND = backend_port apply_patches() return start_moto_server( key="s3", name="S3", asynchronous=asynchronous, port=port, backend_port=backend_port, update_listener=update_listener, )
def start_stepfunctions(port=None, asynchronous=False, update_listener=None): port = port or config.service_port("stepfunctions") backend_port = config.LOCAL_PORT_STEPFUNCTIONS install.install_stepfunctions_local() cmd = get_command(backend_port) log_startup_message("StepFunctions") start_proxy_for_service("stepfunctions", port, backend_port, update_listener) global PROCESS_THREAD # TODO: change ports in stepfunctions.jar, then update here PROCESS_THREAD = do_run( cmd, asynchronous, strip_color=True, env_vars={ "EDGE_PORT": config.EDGE_PORT_HTTP or config.EDGE_PORT, "EDGE_PORT_HTTP": config.EDGE_PORT_HTTP or config.EDGE_PORT, "DATA_DIR": config.DATA_DIR, }, ) return PROCESS_THREAD
def publish_lambda_metric(metric, value, kwargs): # publish metric only if CloudWatch service is available if not config.service_port('cloudwatch'): return cw_client = aws_stack.connect_to_service('cloudwatch') try: cw_client.put_metric_data(Namespace='AWS/Lambda', MetricData=[{ 'MetricName': metric, 'Dimensions': dimension_lambda(kwargs), 'Timestamp': datetime.now(), 'Value': value }]) except Exception as e: LOG.info( 'Unable to put metric data for metric "%s" to CloudWatch: %s' % (metric, e))
def start_kms_local(port=None, backend_port=None, asynchronous=None, update_listener=None): port = port or config.service_port("kms") backend_port = get_free_tcp_port() kms_binary = INSTALL_PATH_KMS_BINARY_PATTERN.replace( "<arch>", f"{platform.system().lower()}-{get_arch()}") log_startup_message("KMS") start_proxy_for_service("kms", port, backend_port, update_listener) env_vars = { "PORT": str(backend_port), "KMS_REGION": config.DEFAULT_REGION, "REGION": config.DEFAULT_REGION, "KMS_ACCOUNT_ID": TEST_AWS_ACCOUNT_ID, "ACCOUNT_ID": TEST_AWS_ACCOUNT_ID, } if config.dirs.data: env_vars["KMS_DATA_PATH"] = config.dirs.data result = do_run(kms_binary, asynchronous, env_vars=env_vars) wait_for_port_open(backend_port) return result