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 ( # 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)
def start_api_server_locally(request):
if localstack_config.FORWARD_EDGE_INMEM:
if "__started__" in API_SERVERS:
return
API_SERVERS["__started__"] = True
api = request.get("api")
port = request.get("port")
if api in API_SERVERS:
return API_SERVERS[api]
result = API_SERVERS[api] = {}
def thread_func(params):
if localstack_config.FORWARD_EDGE_INMEM:
return moto_server.main(
["-p", str(port), "-H", constants.BIND_HOST])
return moto_server.main(
[api, "-p", str(port), "-H", constants.BIND_HOST])
thread = FuncThread(thread_func)
thread.start()
TMP_THREADS.append(thread)
result["port"] = port
result["thread"] = thread
return result
def publish_event(event_type, payload=None):
global SENDER_THREAD
if not SENDER_THREAD:
SENDER_THREAD = FuncThread(poll_and_send_messages, {})
SENDER_THREAD.start()
event = AnalyticsEvent(event_type=event_type, payload=payload)
EVENT_QUEUE.put_nowait(event)
def start_local_api(name, port, method, asynchronous=False):
print('Starting mock %s service (%s port %s)...' % (name, get_service_protocol(), port))
if asynchronous:
thread = FuncThread(method, port, quiet=True)
thread.start()
TMP_THREADS.append(thread)
return thread
else:
method(port)
def start_local_api(name, port, method, asynchronous=False):
print('Starting mock %s service in %s ports %s (recommended) and %s (deprecated)...' % (
name, get_service_protocol(), config.EDGE_PORT, port))
if asynchronous:
thread = FuncThread(method, port, quiet=True)
thread.start()
TMP_THREADS.append(thread)
return thread
else:
method(port)
class JobScheduler(object):
_instance = None
def __init__(self):
self.jobs = []
self.thread = None
def add_job(self, job_func, schedule, enabled=True):
job = Job(job_func, schedule, enabled=enabled)
self.jobs.append(job)
return job.job_id
def disable_job(self, job_id):
for job in self.jobs:
if job.job_id == job_id:
job.is_enabled = False
break
def cancel_job(self, job_id):
i = 0
while i < len(self.jobs):
if self.jobs[i].job_id == job_id:
del self.jobs[i]
else:
i += 1
def loop(self, *args):
while True:
try:
for job in list(self.jobs):
job.run()
except Exception:
pass
# This is a simple heuristic to cause the loop to run apprx every minute
# TODO: we should keep track of jobs execution times, to avoid duplicate executions
time.sleep(59.9)
def start_loop(self):
self.thread = FuncThread(self.loop)
self.thread.start()
@classmethod
def instance(cls):
if not cls._instance:
cls._instance = JobScheduler()
return cls._instance
@classmethod
def start(cls):
instance = cls.instance()
if not instance.thread:
instance.start_loop()
return instance
def publish_event(event_type, payload=None):
global SENDER_THREAD
if not SENDER_THREAD:
SENDER_THREAD = FuncThread(poll_and_send_messages, {})
SENDER_THREAD.start()
if payload is None:
payload = {}
if isinstance(payload, dict) and is_travis():
payload['travis'] = True
event = AnalyticsEvent(event_type=event_type, payload=payload)
EVENT_QUEUE.put_nowait(event)
def start_cloudformation(port=None, asynchronous=False, update_listener=None):
port = port or config.PORT_CLOUDFORMATION
backend_port = DEFAULT_PORT_CLOUDFORMATION_BACKEND
print('Starting mock CloudFormation (%s port %s)...' % (get_service_protocol(), port))
start_proxy_for_service('cloudformation', port, backend_port, update_listener)
if RUN_SERVER_IN_PROCESS:
cmd = 'python "%s" cloudformation -p %s -H 0.0.0.0' % (__file__, backend_port)
env_vars = {'PYTHONPATH': ':'.join(sys.path)}
return do_run(cmd, asynchronous, env_vars=env_vars)
else:
argv = ['cloudformation', '-p', str(backend_port), '-H', '0.0.0.0']
thread = FuncThread(start_up, argv)
thread.start()
return thread
def retrieve_loop(self, params):
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.bind(self.events_file)
sock.listen(1)
if self.ready_mutex:
self.ready_mutex.release()
while self.running:
try:
conn, client_addr = sock.accept()
thread = FuncThread(self.handle_connection, conn)
thread.start()
except Exception as e:
LOGGER.error('Error dispatching client request: %s %s' % (e, traceback.format_exc()))
sock.close()
def fire_event(event_type, payload=None):
global SENDER_THREAD
if not SENDER_THREAD:
SENDER_THREAD = FuncThread(poll_and_send_messages, {})
SENDER_THREAD.start()
if payload is None:
payload = {}
if isinstance(payload, dict):
if is_travis():
payload['travis'] = True
if os.environ.get(ENV_INTERNAL_TEST_RUN):
payload['int'] = True
event = AnalyticsEvent(event_type=event_type, payload=payload)
EVENT_QUEUE.put_nowait(event)
def fire_event(event_type, payload=None):
global SENDER_THREAD
if not SENDER_THREAD:
SENDER_THREAD = FuncThread(poll_and_send_messages, {})
SENDER_THREAD.start()
if payload is None:
payload = {}
if isinstance(payload, dict):
if is_travis():
payload['travis'] = True
if os.environ.get(ENV_INTERNAL_TEST_RUN):
payload['int'] = True
event = AnalyticsEvent(event_type=event_type, payload=payload)
EVENT_QUEUE.put_nowait(event)
def start_api_server_locally(request):
api = request.get('api')
port = request.get('port')
if api in API_SERVERS:
return API_SERVERS[api]
result = API_SERVERS[api] = {}
def thread_func(params):
return moto_main([api, '-p', str(port), '-H', constants.BIND_HOST])
thread = FuncThread(thread_func)
thread.start()
TMP_THREADS.append(thread)
result['port'] = port
result['thread'] = thread
return result
def fire_event(event_type, payload=None):
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
if payload is None:
payload = {}
if isinstance(payload, dict):
if is_travis():
payload['travis'] = True
if os.environ.get(ENV_INTERNAL_TEST_RUN):
payload['int'] = True
event = AnalyticsEvent(event_type=event_type,
payload=payload,
api_key=api_key)
EVENT_QUEUE.put_nowait(event)
def start_api_server_locally(request):
if localstack_config.FORWARD_EDGE_INMEM:
if '__started__' in API_SERVERS:
return
API_SERVERS['__started__'] = True
api = request.get('api')
port = request.get('port')
if api in API_SERVERS:
return API_SERVERS[api]
result = API_SERVERS[api] = {}
def thread_func(params):
if localstack_config.FORWARD_EDGE_INMEM:
return moto_server.main(['-p', str(port), '-H', constants.BIND_HOST])
return moto_server.main([api, '-p', str(port), '-H', constants.BIND_HOST])
thread = FuncThread(thread_func)
thread.start()
TMP_THREADS.append(thread)
result['port'] = port
result['thread'] = thread
return result
backend_port or port, constants.BIND_HOST)
if not name:
name = key
print('Starting mock %s (%s port %s)...' % (name, get_service_protocol(), port))
if backend_port:
start_proxy_for_service(key, port, backend_port, update_listener)
elif USE_SSL:
cmd += ' --ssl'
return do_run(cmd, async)
def start_local_api(name, port, method, async=False):
print('Starting mock %s service (%s port %s)...' % (name, get_service_protocol(), port))
if async:
thread = FuncThread(method, port, quiet=True)
thread.start()
TMP_THREADS.append(thread)
return thread
else:
method(port)
def stop_infra():
global INFRA_STOPPED
if INFRA_STOPPED:
return
event_publisher.fire_event(event_publisher.EVENT_STOP_INFRA)
generic_proxy.QUIET = True
common.cleanup(files=True, quiet=True)
cmd = 'VALIDATE_LAMBDA_S3=0 %s %s -p %s -H %s' % (moto_server_cmd, key, backend_port or port, constants.BIND_HOST)
if not name:
name = key
print('Starting mock %s (%s port %s)...' % (name, get_service_protocol(), port))
if backend_port:
start_proxy_for_service(key, port, backend_port, update_listener)
elif USE_SSL:
cmd += ' --ssl'
return do_run(cmd, async)
def start_local_api(name, port, method, async=False):
print('Starting mock %s service (%s port %s)...' % (name, get_service_protocol(), port))
if async:
thread = FuncThread(method, port, quiet=True)
thread.start()
TMP_THREADS.append(thread)
return thread
else:
method(port)
def stop_infra():
global INFRA_STOPPED
if INFRA_STOPPED:
return
event_publisher.fire_event(event_publisher.EVENT_STOP_INFRA)
generic_proxy.QUIET = True
common.cleanup(files=True, quiet=True)
