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(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()