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
