GeezerVison

USER=localstack \

PYTHONUNBUFFERED=1

RUN apk del --purge git

RUN pip uninstall -y awscli boto3 botocore localstack_client idna s3transfer

RUN rm -rf /tmp/* /root/.cache /opt/yarn-v1.15.2; mkdir -p /tmp/localstack

RUN ln -s /opt/code/localstack/.venv/bin/aws /usr/bin/aws

ENV PYTHONPATH=/opt/code/localstack/.venv/lib/python3.6/site-packages

ADD localstack/ localstack/

ADD bin/localstack bin/localstack

chown -R localstack:localstack . /tmp/localstack && \

ln -s `pwd` /tmp/localstack_install_dir

RUN apk del --purge git

RUN pip uninstall -y awscli boto3 botocore localstack_client idna s3transfer

RUN rm -rf /tmp/* /root/.cache /opt/yarn-v1.15.2

RUN ln -s /opt/code/localstack/.venv/bin/aws /usr/bin/aws

ENV PYTHONPATH=/opt/code/localstack/.venv/lib/python3.6/site-packages

ADD tests/ tests/

RUN LAMBDA_EXECUTOR=local make test

* v0.10.4: Add checks for open UDP ports; fix S3 chunked encoding uploads; fix LatestStreamLabel; fix CORS headers for SQS/SNS; set Java lambda debug port only when needed; expose default region in a util function; fix MacOS tmp folder; clear tmp supervisord logs at container startup; fix signed header requests for S3; expose Web UI via HTTPS; add Timestamp to SNS messages; fix attributes for SQS queues addressed via URL

* v0.10.3: Allow specifying data types for CF attributes; add API for service status and starting services at runtime; support NextShardIterator in DDB streams; add mock responses for S3 encryption and replication; fix rendering of resources in web UI; custom SQS queue attributes; fix Lambda docker command and imports; fix SQS queue physical ID in CF; allow proxy listener to define custom backend per request; support Lambda event body over stdin; exclude `ingest-geoip` ES module to optimize image size; skip checking MD5 on S3 copy; fix DynamoDB table ARN for CF; fix CF deployment of StepFunction activities; fix uploading of Java Lambda as JAR in ZIP; fix installing libs for plugins; added `LAMBDA_JAVA_OPTS` for Java Lambda debugging; bump Maven dependency versions; refactor Lambda API; fix boolean strings in CF templates; allow overriding AWS account id with `TEST_AWS_ACCOUNT_ID`; fix incorrect region for API GW resources created via CF; fix permissions for cache files in `/tmp`

* v0.10.2: Fix logging issue with async Lambdas; fix kinesis records processing; add basic support for `Ref` in CloudFormation; fix ddb streams uuid generation; upgrade travis CI setup; fix DynamoDB error messages; cache server processes

* v0.10.0: Lazy loading of libraries; fix handling of regions; add API multiserver; improve CPU profiling; fix ES xpack installation; add basic EventBridge support; refactor Lambda API and executor; add MessageAttributes on SNS payloads; tagging for SNS; ability to customize docker command

if is_in_docker and not os.environ.get('LAMBDA_REMOTE_DOCKER', '').strip():

LAMBDA_REMOTE_DOCKER = True

if not is_in_docker and 'docker' in 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.') % LAMBDA_EXECUTOR)

CONFIG_FILE_PATH = os.path.join(expanduser('~'), '.localstack')

import localstack_client.config

VERSION = '0.10.3'

VERSION = '0.10.4'

REGION_LOCAL = 'local'

import cloud.localstack.sample.S3Sample;

import cloud.localstack.sample.SQSLambdaHandler;

import cloud.localstack.sample.SQSLambdaHandlerSSL;

import com.amazonaws.ClientConfiguration;

import com.amazonaws.Protocol;

import com.amazonaws.auth.AWSStaticCredentialsProvider;

import com.amazonaws.auth.BasicAWSCredentials;

import com.amazonaws.client.builder.AwsClientBuilder;

import com.amazonaws.services.kinesis.AmazonKinesis;

import com.amazonaws.services.kinesis.model.ListStreamsResult;

import com.amazonaws.services.kinesis.model.PutRecordRequest;

import com.amazonaws.services.s3.model.Bucket;

import com.amazonaws.services.s3.model.ObjectListing;

import com.amazonaws.services.sqs.AmazonSQS;

import com.amazonaws.services.sqs.AmazonSQSAsync;

import com.amazonaws.services.sqs.AmazonSQSAsyncClientBuilder;

import com.amazonaws.services.sqs.model.CreateQueueRequest;

import com.amazonaws.services.sqs.model.CreateQueueResult;

import com.amazonaws.services.sqs.model.DeleteQueueRequest;

import com.amazonaws.services.sqs.model.SendMessageRequest;

import com.amazonaws.services.sqs.model.SendMessageResult;

import org.assertj.core.api.Assertions;

import org.junit.Assert;

import org.junit.jupiter.api.extension.ExtendWith;

import org.junit.runner.RunWith;

import java.io.File;

import java.io.FileOutputStream;

import java.nio.ByteBuffer;

import java.nio.file.Files;

import java.util.Arrays;

import java.util.List;

import java.util.UUID;

import java.util.*;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

Assertions.assertThat(message).isEqualTo(SQSLambdaHandler.DID_YOU_GET_THE_MESSAGE);

}

@org.junit.Test

@org.junit.jupiter.api.Test

public void testSQSQueueAttributes() {

// Based on https://github.com/localstack/localstack/issues/1551

AwsClientBuilder.EndpointConfiguration endpoint = TestUtils.getEndpointConfigurationSQS();

ClientConfiguration cc = new ClientConfiguration();

cc.setProtocol(Protocol.HTTP);

AmazonSQSAsync sqsAsync = AmazonSQSAsyncClientBuilder.standard()

.withCredentials(new AWSStaticCredentialsProvider(new BasicAWSCredentials("foo", "foo")))

.withEndpointConfiguration(endpoint)

.withClientConfiguration(cc)

.build();

CreateQueueResult result1 = sqsAsync.createQueue("1551-test");

CreateQueueResult result2 = sqsAsync.createQueue("1551-test-dlq");

final String queueArn = "QueueArn";

GetQueueAttributesResult dlqQueueAttributes = sqsAsync.getQueueAttributes(result2.getQueueUrl(),

Collections.singletonList(queueArn));

dlqQueueAttributes.getAttributes().get(queueArn);

// set queue attributes

final Map<String, String> attributes = new HashMap<>();

attributes.put("VisibilityTimeout", "60");

attributes.put("MessageRetentionPeriod", "345600");

attributes.put("RedrivePolicy", "{\"foo\":1}");

final String queueUrl = result1.getQueueUrl();

sqsAsync.setQueueAttributes(queueUrl, attributes);

// get and assert queue attributes

Map<String, String> result = sqsAsync.getQueueAttributes(queueUrl, Arrays.asList("All")).getAttributes();

Assert.assertEquals(result.get("MessageRetentionPeriod"), "345600");

Assert.assertEquals(result.get("VisibilityTimeout"), "60");

Assert.assertEquals(result.get("RedrivePolicy"), "{\"foo\":1}");

}

@org.junit.Test

@org.junit.jupiter.api.Test

public void testLocalS3API() throws Exception {

if 'Access-Control-Allow-Headers' not in headers:

requested_headers = self.headers.get('Access-Control-Request-Headers', '')

requested_headers = re.split(r'[,\s]+', requested_headers) + CORS_ALLOWED_HEADERS

self.send_header('Access-Control-Allow-Headers', ','.join(requested_headers))

self.send_header('Access-Control-Allow-Headers', ','.join([h for h in requested_headers if h]))

if 'Access-Control-Expose-Headers' not in headers:

self.send_header('Access-Control-Expose-Headers', ','.join(CORS_EXPOSE_HEADERS))

DEFAULT_PORT_APIGATEWAY_BACKEND, DEFAULT_PORT_SNS_BACKEND,

DEFAULT_PORT_IAM_BACKEND, DEFAULT_PORT_EC2_BACKEND, DEFAULT_SERVICE_PORTS)

from localstack.utils import common, persistence

from localstack.utils.common import (TMP_THREADS, run, get_free_tcp_port,

from localstack.utils.common import (TMP_THREADS, run, get_free_tcp_port, is_linux,

FuncThread, ShellCommandThread, get_service_protocol, in_docker, is_port_open)

from localstack.utils.server import multiserver

from localstack.utils.bootstrap import (

def start_infra(asynchronous=False, apis=None):

try:

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)

# 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})

{'d': is_in_docker and 1 or 0, 'c': in_ci() and 1 or 0})

# set up logging

setup_logging()

if new_response:

return new_response

elif action == 'SetQueueAttributes':

self._set_queue_attributes(req_data)

self._set_queue_attributes(path, req_data, headers)

if 'QueueName' in req_data:

encoded_data = urlencode(req_data, doseq=True) if method == 'POST' else ''

# Allow CORS preflight requests to succeed.

return 200

if method == 'POST' and path == '/':

region_name = extract_region_from_auth_header(headers)

req_data = urlparse.parse_qs(to_str(data))

action = req_data.get('Action', [None])[0]

content_str = content_str_original = to_str(response.content)

self._fire_event(req_data, response)

# patch the response and add missing attributes

if action == 'GetQueueAttributes':

content_str = self._add_queue_attributes(req_data, content_str)

# patch the response and return the correct endpoint URLs / ARNs

if action in ('CreateQueue', 'GetQueueUrl', 'ListQueues', 'GetQueueAttributes'):

if config.USE_SSL and '<QueueUrl>http://' in content_str:

# return https://... if we're supposed to use SSL

content_str = re.sub(r'<QueueUrl>\s*http://', r'<QueueUrl>https://', content_str)

# expose external hostname:port

external_port = SQS_PORT_EXTERNAL or get_external_port(headers, request_handler)

content_str = re.sub(r'<QueueUrl>\s*([a-z]+)://[^<]*:([0-9]+)/([^<]*)\s*</QueueUrl>',

r'<QueueUrl>\1://%s:%s/\3</QueueUrl>' % (HOSTNAME_EXTERNAL, external_port), content_str)

# fix queue ARN

content_str = re.sub(r'<([a-zA-Z0-9]+)>\s*arn:aws:sqs:elasticmq:([^<]+)</([a-zA-Z0-9]+)>',

r'<\1>arn:aws:sqs:%s:\2</\3>' % (region_name), content_str)

if content_str_original != content_str:

# if changes have been made, return patched response

new_response = Response()

new_response.status_code = response.status_code

new_response.headers = response.headers

new_response._content = content_str

new_response.headers['content-length'] = len(new_response._content)

return new_response

# Since the following 2 API calls are not implemented in ElasticMQ, we're mocking them

# and letting them to return an empty response

if action == 'TagQueue':

new_response = Response()

new_response.status_code = 200

new_response._content = ("""

""").strip().format(uuid.uuid4())

return new_response

elif action == 'ListQueueTags':

new_response = Response()

new_response.status_code = 200

new_response._content = ("""

""").strip().format(XMLNS_SQS, uuid.uuid4())

return new_response

if method != 'POST':

return

region_name = extract_region_from_auth_header(headers)

req_data = urlparse.parse_qs(to_str(data))

action = req_data.get('Action', [None])[0]

content_str = content_str_original = to_str(response.content)

self._fire_event(req_data, response)

# patch the response and add missing attributes

if action == 'GetQueueAttributes':

content_str = self._add_queue_attributes(path, req_data, content_str, headers)

# patch the response and return the correct endpoint URLs / ARNs

if action in ('CreateQueue', 'GetQueueUrl', 'ListQueues', 'GetQueueAttributes'):

if config.USE_SSL and '<QueueUrl>http://' in content_str:

# return https://... if we're supposed to use SSL

content_str = re.sub(r'<QueueUrl>\s*http://', r'<QueueUrl>https://', content_str)

# expose external hostname:port

external_port = SQS_PORT_EXTERNAL or get_external_port(headers, request_handler)

content_str = re.sub(r'<QueueUrl>\s*([a-z]+)://[^<]*:([0-9]+)/([^<]*)\s*</QueueUrl>',

r'<QueueUrl>\1://%s:%s/\3</QueueUrl>' % (HOSTNAME_EXTERNAL, external_port), content_str)

# fix queue ARN

content_str = re.sub(r'<([a-zA-Z0-9]+)>\s*arn:aws:sqs:elasticmq:([^<]+)</([a-zA-Z0-9]+)>',

r'<\1>arn:aws:sqs:%s:\2</\3>' % (region_name), content_str)

if content_str_original != content_str:

# if changes have been made, return patched response

new_response = Response()

new_response.status_code = response.status_code

new_response.headers = response.headers

new_response._content = content_str

new_response.headers['content-length'] = len(new_response._content)

return new_response

# Since the following 2 API calls are not implemented in ElasticMQ, we're mocking them

# and letting them to return an empty response

if action == 'TagQueue':

new_response = Response()

new_response.status_code = 200

new_response._content = ("""

""").strip().format(uuid.uuid4())

return new_response

elif action == 'ListQueueTags':

new_response = Response()

new_response.status_code = 200

new_response._content = ("""

""").strip().format(XMLNS_SQS, uuid.uuid4())

return new_response

# Format of the message Name attribute is MessageAttribute.<int id>.<field>

# Format of the Value attributes is MessageAttribute.<int id>.Value.DataType

return result

def _send_message(self, path, data, req_data, headers):

queue_url = req_data.get('QueueUrl', [path.partition('?')[0]])[0]

queue_url = self._queue_url(path, req_data, headers)

queue_name = queue_url[queue_url.rindex('/') + 1:]

message_body = req_data.get('MessageBody', [None])[0]

message_attributes = self.format_message_attributes(req_data)

new_response.status_code = 200

return new_response

def _set_queue_attributes(self, req_data):

queue_url = req_data['QueueUrl'][0]

def _set_queue_attributes(self, path, req_data, headers):

queue_url = self._queue_url(path, req_data, headers)

attrs = self._format_attributes(req_data)

# select only the attributes in UNSUPPORTED_ATTRIBUTE_NAMES

attrs = dict([(k, v) for k, v in attrs.items() if k in UNSUPPORTED_ATTRIBUTE_NAMES])

QUEUE_ATTRIBUTES[queue_url] = QUEUE_ATTRIBUTES.get(queue_url) or {}

QUEUE_ATTRIBUTES[queue_url].update(attrs)

def _add_queue_attributes(self, req_data, content_str):

def _add_queue_attributes(self, path, req_data, content_str, headers):

flags = re.MULTILINE | re.DOTALL

queue_url = req_data['QueueUrl'][0]

queue_url = self._queue_url(path, req_data, headers)

regex = r'(.*<GetQueueAttributesResult>)(.*)(</GetQueueAttributesResult>.*)'

attrs = re.sub(regex, r'\2', content_str, flags=flags)

for key, value in QUEUE_ATTRIBUTES.get(queue_url, {}).items():

if event_type and queue_url:

event_publisher.fire_event(event_type, payload={'u': event_publisher.get_hash(queue_url)})

def _queue_url(self, path, req_data, headers):

queue_url = req_data.get('QueueUrl')

if queue_url:

return queue_url[0]

url = config.TEST_SQS_URL

if headers.get('Host'):

url = 'http%s://%s' % ('s' if config.USE_SSL else '', headers['Host'])

queue_url = '%s%s' % (url, path.partition('?')[0])

return queue_url

def get_external_port(headers, request_handler):