def fire_event(event_type, payload=None):
if config.DISABLE_EVENTS:
return
global SENDER_THREAD
if not SENDER_THREAD:
SENDER_THREAD = FuncThread(poll_and_send_messages, {})
SENDER_THREAD.start()
api_key = read_api_key_safe()
if not api_key:
# only store events if API key has been specified
return
from localstack.utils.analytics import log
from localstack.utils.testutil import ( # leave here to avoid circular dependency
is_local_test_mode,
)
if payload is None:
payload = {}
if isinstance(payload, dict):
if is_travis():
payload["travis"] = True
if is_local_test_mode():
payload["int"] = True
# event = AnalyticsEvent(event_type=event_type, payload=payload, api_key=api_key)
# EVENT_QUEUE.put_nowait(event) FIXME: remove old logging code entirely before next release
log.event("legacy", {"event": event_type, "payload": payload})
def prepare_environment():
# set environment
os.environ['AWS_REGION'] = config.DEFAULT_REGION
os.environ['ENV'] = ENV_DEV
# register signal handlers
if not is_local_test_mode():
register_signal_handlers()
# make sure AWS credentials are configured, otherwise boto3 bails on us
check_aws_credentials()
def do_start_infra(asynchronous, apis, is_in_docker):
event_publisher.fire_event(event_publisher.EVENT_START_INFRA, {
'd': is_in_docker and 1 or 0,
'c': in_ci() and 1 or 0
})
# set up logging
setup_logging()
# prepare APIs
apis = canonicalize_api_names(apis)
# set environment
os.environ['AWS_REGION'] = config.DEFAULT_REGION
os.environ['ENV'] = ENV_DEV
# register signal handlers
if not is_local_test_mode():
register_signal_handlers()
# make sure AWS credentials are configured, otherwise boto3 bails on us
check_aws_credentials()
# install libs if not present
install.install_components(apis)
# Some services take a bit to come up
sleep_time = 5
# start services
thread = None
# loop through plugins and start each service
for name, plugin in SERVICE_PLUGINS.items():
if plugin.is_enabled(api_names=apis):
record_service_health(name, 'starting')
t1 = plugin.start(asynchronous=True)
thread = thread or t1
time.sleep(sleep_time)
# ensure that all infra components are up and running
check_infra(apis=apis)
# restore persisted data
persistence.restore_persisted_data(apis=apis)
print('Ready.')
sys.stdout.flush()
if not asynchronous and thread:
# this is a bit of an ugly hack, but we need to make sure that we
# stay in the execution context of the main thread, otherwise our
# signal handlers don't work
sleep_forever()
return thread
def fire_event(event_type, payload=None):
# TODO: replace fire_event calls with analytics.log.event
if config.DISABLE_EVENTS:
return
from localstack.utils.analytics import log
from localstack.utils.testutil import ( # leave here to avoid circular dependency
is_local_test_mode, )
if payload is None:
payload = {}
if isinstance(payload, dict):
if is_travis():
payload["travis"] = True
if is_local_test_mode():
payload["int"] = True
log.event("legacy", {"event": event_type, "payload": payload})
def fire_event(event_type, payload=None):
if config.DISABLE_EVENTS:
return
global SENDER_THREAD
if not SENDER_THREAD:
SENDER_THREAD = FuncThread(poll_and_send_messages, {})
SENDER_THREAD.start()
api_key = read_api_key_safe()
if not api_key:
# only store events if API key has been specified
return
from localstack.utils.testutil import is_local_test_mode # leave here to avoid circular dependency
if payload is None:
payload = {}
if isinstance(payload, dict):
if is_travis():
payload['travis'] = True
if is_local_test_mode():
payload['int'] = True
event = AnalyticsEvent(event_type=event_type,
payload=payload,
api_key=api_key)
EVENT_QUEUE.put_nowait(event)
def forward(self, method):
data = self.data_bytes
path = self.path
forward_headers = CaseInsensitiveDict(self.headers)
# force close connection
connection_header = forward_headers.get('Connection') or ''
if connection_header.lower() not in ['keep-alive', '']:
self.close_connection = 1
client_address = self.client_address[0]
server_address = ':'.join(map(str, self.server.server_address))
try:
# run the actual response forwarding
response = modify_and_forward(
method=method,
path=path,
data_bytes=data,
headers=forward_headers,
forward_base_url=self.proxy.forward_base_url,
listeners=self._listeners(),
request_handler=self,
client_address=client_address,
server_address=server_address)
# copy headers and return response
self.send_response(response.status_code)
# set content for chunked encoding
is_chunked = uses_chunked_encoding(response)
if is_chunked:
response._content = create_chunked_data(response._content)
# send headers
content_length_sent = False
for header_key, header_value in iteritems(response.headers):
# filter out certain headers that we don't want to transmit
if header_key.lower() not in ('transfer-encoding', 'date',
'server'):
self.send_header(header_key, header_value)
content_length_sent = content_length_sent or header_key.lower(
) == 'content-length'
# fix content-type header if needed
if not content_length_sent and not is_chunked:
self.send_header(
'Content-Length',
'%s' % len(response.content) if response.content else 0)
if isinstance(response, LambdaResponse):
self.send_multi_value_headers(response.multi_value_headers)
self.end_headers()
if response.content and len(response.content):
self.wfile.write(to_bytes(response.content))
except Exception as e:
trace = str(traceback.format_exc())
conn_errors = ('ConnectionRefusedError', 'NewConnectionError',
'Connection aborted', 'Unexpected EOF',
'Connection reset by peer',
'cannot read from timed out object')
conn_error = any(e in trace for e in conn_errors)
error_msg = 'Error forwarding request: %s %s' % (e, trace)
if 'Broken pipe' in trace:
LOG.warn(
'Connection prematurely closed by client (broken pipe).')
elif not self.proxy.quiet or not conn_error:
LOG.error(error_msg)
if is_local_test_mode():
# During a test run, we also want to print error messages, because
# log messages are delayed until the entire test run is over, and
# hence we are missing messages if the test hangs for some reason.
print('ERROR: %s' % error_msg)
self.send_response(502) # bad gateway
self.end_headers()
# force close connection
self.close_connection = 1
finally:
try:
self.wfile.flush()
except Exception as e:
LOG.warning('Unable to flush write file: %s' % e)
