def on_get(self, request):
from localstack.utils import diagnose
return {
"version": {
"image-version": call_safe(diagnose.get_docker_image_details),
"localstack-version":
call_safe(diagnose.get_localstack_version),
"host": {
"kernel": call_safe(diagnose.get_host_kernel_version),
},
},
"services":
call_safe(diagnose.get_service_stats),
"config":
call_safe(diagnose.get_localstack_config),
"docker-inspect":
call_safe(diagnose.inspect_main_container),
"docker-dependent-image-hashes":
call_safe(diagnose.get_important_image_hashes),
"file-tree":
call_safe(diagnose.get_file_tree),
"important-endpoints":
call_safe(diagnose.resolve_endpoints),
"logs":
call_safe(diagnose.get_localstack_logs),
}
def get_machine_id() -> str:
cache_path = os.path.join(config.dirs.cache, "machine.json")
doc = FileMappedDocument(cache_path)
if "machine_id" not in doc:
# generate a machine id
doc["machine_id"] = _generate_machine_id()
# try to cache the machine ID
call_safe(doc.save)
return doc["machine_id"]
def __init__(
self,
name,
start=_default,
check=_default,
listener=None,
active=False,
stop=None,
lifecycle_hook: ServiceLifecycleHook = None,
):
self.plugin_name = name
self.start_function = start
self.listener = listener
self.check_function = check if check is not _default else local_api_checker(
name)
self.default_active = active
self.stop_function = stop
self.lifecycle_hook = lifecycle_hook or ServiceLifecycleHook()
call_safe(self.lifecycle_hook.on_after_init)
def start(self, asynchronous):
call_safe(self.lifecycle_hook.on_before_start)
if not self.start_function:
return
if self.start_function is _default:
# fallback start method that simply adds the listener function to the list of proxy listeners if it exists
if not self.listener:
return
from localstack.services.infra import add_service_proxy_listener
add_service_proxy_listener(self.plugin_name, self.listener)
return
kwargs = {"asynchronous": asynchronous}
if self.listener:
kwargs["update_listener"] = self.listener
return self.start_function(**kwargs)
def wait_container_is_ready(timeout: Optional[float] = None):
"""Blocks until the localstack main container is running and the ready marker has been printed."""
container_name = config.MAIN_CONTAINER_NAME
started = time.time()
def is_container_running():
return DOCKER_CLIENT.is_container_running(container_name)
if not poll_condition(is_container_running, timeout=timeout):
return False
stream = DOCKER_CLIENT.stream_container_logs(container_name)
# create a timer that will terminate the log stream after the remaining timeout
timer = None
if timeout:
waited = time.time() - started
remaining = timeout - waited
# check the rare case that the timeout has already been reached
if remaining <= 0:
stream.close()
return False
timer = threading.Timer(remaining, stream.close)
timer.start()
try:
for line in stream:
line = line.decode("utf-8").strip()
if line == constants.READY_MARKER_OUTPUT:
return True
# EOF was reached or the stream was closed
return False
finally:
call_safe(stream.close)
if timer:
# make sure the timer is stopped (does nothing if it has already run)
timer.cancel()
def _pre_delete(resource_id, resources, resource_type, func, stack_name):
"""detach managed policies from role before deleting"""
iam_client = aws_stack.connect_to_service("iam")
resource = resources[resource_id]
props = resource["Properties"]
role_name = props["RoleName"]
try:
# TODO: this should probably only remove the policies that are specified in the stack (verify with AWS)
# detach managed policies
for policy in iam_client.list_attached_role_policies(
RoleName=role_name).get("AttachedPolicies", []):
call_safe(
iam_client.detach_role_policy,
kwargs={
"RoleName": role_name,
"PolicyArn": policy["PolicyArn"]
},
)
# delete inline policies
for inline_policy_name in iam_client.list_role_policies(
RoleName=role_name).get("PolicyNames", []):
call_safe(
iam_client.delete_role_policy,
kwargs={
"RoleName": role_name,
"PolicyName": inline_policy_name
},
)
# TODO: potentially remove this when stack resource deletion order is fixed (check AWS behavior first)
# cleanup instance profile
rs = iam_client.list_instance_profiles_for_role(RoleName=role_name)
for instance_profile in rs["InstanceProfiles"]:
ip_name = instance_profile["InstanceProfileName"]
call_safe(
iam_client.remove_role_from_instance_profile,
kwargs={
"InstanceProfileName": ip_name,
"RoleName": role_name
},
)
except Exception as e:
if "NoSuchEntity" not in str(e):
raise
def stop(self):
call_safe(self.lifecycle_hook.on_before_stop)
if not self.stop_function:
return
return self.stop_function()
