def run_parallel_download():
file_length = 10000000
class DownloadListener(ProxyListener):
def forward_request(self, method, path, data, headers):
sleep_time = int(path.replace('/', ''))
time.sleep(sleep_time)
response = Response()
response.status_code = 200
response._content = ('%s' % sleep_time) * file_length
return response
test_port = 12124
tmp_file_pattern = '/tmp/test.%s'
proxy = GenericProxy(port=test_port, update_listener=DownloadListener())
proxy.start()
def do_download(param):
tmp_file = tmp_file_pattern % param
TMP_FILES.append(tmp_file)
download('http://localhost:%s/%s' % (test_port, param), tmp_file)
values = (1, 2, 3)
parallelize(do_download, values)
proxy.stop()
for val in values:
tmp_file = tmp_file_pattern % val
assert len(load_file(tmp_file)) == file_length
def test_api_gateway_http_integration():
test_port = 12123
backend_url = 'http://localhost:%s%s' % (test_port, API_PATH_HTTP_BACKEND)
# create target HTTP backend
def listener(**kwargs):
response = Response()
response.status_code = 200
response._content = json.dumps(
kwargs['data']) if kwargs['data'] else '{}'
return response
proxy = GenericProxy(test_port, update_listener=listener)
proxy.start()
# create API Gateway and connect it to the HTTP backend
result = connect_api_gateway_to_http('test_gateway2',
backend_url,
path=API_PATH_HTTP_BACKEND)
# make test request to gateway
url = INBOUND_GATEWAY_URL_PATTERN.format(api_id=result['id'],
stage_name=TEST_STAGE_NAME,
path=API_PATH_HTTP_BACKEND)
result = requests.get(url)
assert result.status_code == 200
assert to_str(result.content) == '{}'
data = {"data": 123}
result = requests.post(url, data=json.dumps(data))
assert result.status_code == 200
assert json.loads(to_str(result.content)) == data
# clean up
proxy.stop()
def start_proxy(port, backend_url, update_listener=None, quiet=False, params={}, use_ssl=None):
use_ssl = config.USE_SSL if use_ssl is None else use_ssl
proxy_thread = GenericProxy(port=port, forward_url=backend_url,
ssl=use_ssl, update_listener=update_listener, quiet=quiet, params=params)
proxy_thread.start()
TMP_THREADS.append(proxy_thread)
return proxy_thread
def start_server(port, asynchronous=False):
if is_port_open(port):
LOG.debug('API Multiserver appears to be already running.')
return
class ConfigListener(ProxyListener):
def forward_request(self, method, path, data, **kwargs):
response = Response()
response.status_code = 200
response._content = '{}'
try:
if path == API_PATH_SERVERS:
if method == 'POST':
start_api_server_locally(json.loads(to_str(data)))
elif method == 'GET':
response._content = json.dumps(json_safe(API_SERVERS))
except Exception as e:
LOG.error('Unable to process request: %s' % e)
response.status_code = 500
response._content = str(e)
return response
proxy = GenericProxy(port, update_listener=ConfigListener())
proxy.start()
if asynchronous:
return proxy
proxy.join()
def do_start_edge(port, use_ssl, asynchronous=False):
# get port and start Edge
print('Starting edge router (http%s port %s)...' % ('s' if use_ssl else '', port))
# use use=True here because our proxy allows both, HTTP and HTTPS traffic
proxy = GenericProxy(port, ssl=True, update_listener=ProxyListenerEdge())
proxy.start()
if not asynchronous:
proxy.join()
return proxy
def start_proxy(port, backend_url, update_listener, quiet=False, params={}):
proxy_thread = GenericProxy(port=port,
forward_url=backend_url,
ssl=USE_SSL,
update_listener=update_listener,
quiet=quiet,
params=params)
proxy_thread.start()
TMP_THREADS.append(proxy_thread)
return proxy_thread
def start_proxy(port,
backend_port,
update_listener,
quiet=False,
backend_host=DEFAULT_BACKEND_HOST,
params={}):
proxy_thread = GenericProxy(port=port,
forward_host='%s:%s' %
(backend_host, backend_port),
ssl=USE_SSL,
update_listener=update_listener,
quiet=quiet,
params=params)
proxy_thread.start()
TMP_THREADS.append(proxy_thread)
def test_api_gateway_http_integration(self):
test_port = 12123
backend_url = 'http://localhost:%s%s' % (test_port, self.API_PATH_HTTP_BACKEND)
# create target HTTP backend
class TestListener(ProxyListener):
def forward_request(self, **kwargs):
response = Response()
response.status_code = 200
response._content = kwargs.get('data') or '{}'
return response
proxy = GenericProxy(test_port, update_listener=TestListener())
proxy.start()
# create API Gateway and connect it to the HTTP backend
result = self.connect_api_gateway_to_http(
'test_gateway2',
backend_url,
path=self.API_PATH_HTTP_BACKEND
)
url = INBOUND_GATEWAY_URL_PATTERN.format(
api_id=result['id'],
stage_name=self.TEST_STAGE_NAME,
path=self.API_PATH_HTTP_BACKEND
)
# make sure CORS headers are present
origin = 'localhost'
result = requests.options(url, headers={'origin': origin})
self.assertEqual(result.status_code, 200)
self.assertTrue(re.match(result.headers['Access-Control-Allow-Origin'].replace('*', '.*'), origin))
self.assertIn('POST', result.headers['Access-Control-Allow-Methods'])
# make test request to gateway
result = requests.get(url)
self.assertEqual(result.status_code, 200)
self.assertEqual(to_str(result.content), '{}')
data = {'data': 123}
result = requests.post(url, data=json.dumps(data))
self.assertEqual(result.status_code, 200)
self.assertEqual(json.loads(to_str(result.content)), data)
# clean up
proxy.stop()
def do_start_edge(port, use_ssl, asynchronous=False):
try:
# start local DNS server, if present
from localstack_ext.services import dns_server
dns_server.start_servers()
except Exception:
pass
# get port and start Edge
print('Starting edge router (http%s port %s)...' % ('s' if use_ssl else '', port))
# use use=True here because our proxy allows both, HTTP and HTTPS traffic
proxy = GenericProxy(port, ssl=True, update_listener=ProxyListenerEdge())
proxy.start()
if not asynchronous:
proxy.join()
return proxy
def start_http_backend(test_port):
# test listener for target HTTP backend
class TestListener(ProxyListener):
def forward_request(self, **kwargs):
response = Response()
response.status_code = 200
result = {
'data': kwargs.get('data') or '{}',
'headers': dict(kwargs.get('headers'))
}
response._content = json.dumps(json_safe(result))
return response
proxy = GenericProxy(test_port, update_listener=TestListener())
proxy.start()
return proxy
def start_server(port):
class ConfigListener(ProxyListener):
def forward_request(self, method, path, data, **kwargs):
response = Response()
response.status_code = 200
response._content = '{}'
try:
if path == API_PATH_SERVERS:
if method == 'POST':
start_api_server_locally(json.loads(to_str(data)))
elif method == 'GET':
response._content = json.dumps(json_safe(API_SERVERS))
except Exception as e:
LOG.error('Unable to process request: %s' % e)
response.status_code = 500
response._content = str(e)
return response
proxy = GenericProxy(port, update_listener=ConfigListener())
proxy.start()
proxy.join()
def test_api_gateway_http_integration():
test_port = 12123
backend_url = 'http://localhost:%s%s' % (test_port, API_PATH_HTTP_BACKEND)
# create target HTTP backend
class TestListener(ProxyListener):
def forward_request(self, **kwargs):
response = Response()
response.status_code = 200
response._content = kwargs.get('data') or '{}'
return response
proxy = GenericProxy(test_port, update_listener=TestListener())
proxy.start()
# create API Gateway and connect it to the HTTP backend
result = connect_api_gateway_to_http('test_gateway2', backend_url, path=API_PATH_HTTP_BACKEND)
url = INBOUND_GATEWAY_URL_PATTERN.format(api_id=result['id'],
stage_name=TEST_STAGE_NAME, path=API_PATH_HTTP_BACKEND)
# make sure CORS headers are present
origin = 'localhost'
result = requests.options(url, headers={'origin': origin})
assert result.status_code == 200
assert re.match(result.headers['Access-Control-Allow-Origin'].replace('*', '.*'), origin)
assert 'POST' in result.headers['Access-Control-Allow-Methods']
# make test request to gateway
result = requests.get(url)
assert result.status_code == 200
assert to_str(result.content) == '{}'
data = {'data': 123}
result = requests.post(url, data=json.dumps(data))
assert result.status_code == 200
assert json.loads(to_str(result.content)) == data
# clean up
proxy.stop()
def test_api_gateway_http_integration(self):
test_port = 12123
backend_url = 'http://localhost:%s%s' % (test_port,
self.API_PATH_HTTP_BACKEND)
# create target HTTP backend
class TestListener(ProxyListener):
def forward_request(self, **kwargs):
response = Response()
response.status_code = 200
result = {
'data': kwargs.get('data') or '{}',
'headers': dict(kwargs.get('headers'))
}
response._content = json.dumps(json_safe(result))
return response
proxy = GenericProxy(test_port, update_listener=TestListener())
proxy.start()
# create API Gateway and connect it to the HTTP backend
result = self.connect_api_gateway_to_http(
'test_gateway2', backend_url, path=self.API_PATH_HTTP_BACKEND)
url = self.gateway_request_url(api_id=result['id'],
stage_name=self.TEST_STAGE_NAME,
path=self.API_PATH_HTTP_BACKEND)
# make sure CORS headers are present
origin = 'localhost'
result = requests.options(url, headers={'origin': origin})
self.assertEqual(result.status_code, 200)
self.assertTrue(
re.match(
result.headers['Access-Control-Allow-Origin'].replace(
'*', '.*'), origin))
self.assertIn('POST', result.headers['Access-Control-Allow-Methods'])
# make test GET request to gateway
result = requests.get(url)
self.assertEqual(result.status_code, 200)
self.assertEqual(json.loads(to_str(result.content))['data'], '{}')
# make test POST request to gateway
data = json.dumps({'data': 123})
result = requests.post(url, data=data)
self.assertEqual(result.status_code, 200)
self.assertEqual(json.loads(to_str(result.content))['data'], data)
# make test POST request with non-JSON content type
data = 'test=123'
ctype = 'application/x-www-form-urlencoded'
result = requests.post(url, data=data, headers={'content-type': ctype})
self.assertEqual(result.status_code, 200)
content = json.loads(to_str(result.content))
headers = CaseInsensitiveDict(content['headers'])
self.assertEqual(content['data'], data)
self.assertEqual(headers['content-type'], ctype)
# clean up
proxy.stop()
def start_proxy(port, backend_url, update_listener, quiet=False, params={}):
proxy_thread = GenericProxy(port=port, forward_url=backend_url,
ssl=USE_SSL, update_listener=update_listener, quiet=quiet, params=params)
proxy_thread.start()
TMP_THREADS.append(proxy_thread)
return proxy_thread
