diff --git a/helpers/hdocker.py b/helpers/hdocker.py index ff264da1f..89b625982 100644 --- a/helpers/hdocker.py +++ b/helpers/hdocker.py @@ -1870,7 +1870,7 @@ def run_dockerized_graphviz( ) # Convert files to Docker paths. is_caller_host = not hserver.is_inside_docker() - use_sibling_container_for_callee = True + use_sibling_container_for_callee = False caller_mount_path, callee_mount_path, mount = get_docker_mount_info( is_caller_host, use_sibling_container_for_callee ) diff --git a/helpers/hserver.py b/helpers/hserver.py index 823367a75..68c4281d6 100644 --- a/helpers/hserver.py +++ b/helpers/hserver.py @@ -81,11 +81,11 @@ def get_host_user_name() -> Optional[str]: return os.environ.get("CSFY_HOST_USER_NAME", None) -def get_dev_csfy_host_names() -> List[str]: +def get_dev_csfy_host_names() -> Tuple[str]: """ Return the names of the Causify dev servers. """ - host_names = ("dev1", "dev2", "dev3") + host_names = ["dev1", "dev2", "dev3"] return host_names @@ -278,63 +278,63 @@ def is_dev4() -> bool: return is_dev4_ -def is_host_mac(*, version: Optional[str] = None) -> bool: - """ - Return whether we are running on macOS and, optionally, on a specific - version. - - :param version: check whether we are running on a certain macOS version (e.g., - `Catalina`, `Monterey`) - """ - _LOG.debug("version=%s", version) - host_os_name = os.uname()[0] - _LOG.debug("os.uname()=%s", str(os.uname())) - csfy_host_os_name = os.environ.get("CSFY_HOST_OS_NAME", None) - _LOG.debug( - "host_os_name=%s csfy_host_os_name=%s", host_os_name, csfy_host_os_name - ) - is_mac_ = host_os_name == "Darwin" or csfy_host_os_name == "Darwin" - if version is None: - # The user didn't request a specific version, so we return whether we - # are running on a Mac or not. - _LOG.debug("is_mac_=%s", is_mac_) - return is_mac_ - else: - # The user specified a version: if we are not running on a Mac then we - # return False, since we don't even have to check the macOS version. - if not is_mac_: - _LOG.debug("is_mac_=%s", is_mac_) - return False - # Check the macOS version we are running. - if version == "Catalina": - # Darwin gpmac.local 19.6.0 Darwin Kernel Version 19.6.0: - # root:xnu-6153.141.2~1/RELEASE_X86_64 x86_64 - macos_tag = "19.6" - elif version == "Monterey": - # Darwin alpha.local 21.5.0 Darwin Kernel Version 21.5.0: - # root:xnu-8020.121.3~4/RELEASE_ARM64_T6000 arm64 - macos_tag = "21." - elif version == "Ventura": - macos_tag = "22." - elif version == "Sequoia": - # Darwin gpmac.local 24.4.0 Darwin Kernel Version 24.4.0: - # root:xnu-11417.101.15~1/RELEASE_ARM64_T8112 arm64 - macos_tag = "24." - else: - raise ValueError(f"Invalid version='{version}'") - _LOG.debug("macos_tag=%s", macos_tag) - host_os_version = os.uname()[2] - # 'Darwin Kernel Version 19.6.0: Mon Aug 31 22:12:52 PDT 2020; - # root:xnu-6153.141.2~1/RELEASE_X86_64' - csfy_host_os_version = os.environ.get("CSFY_HOST_VERSION", "") - _LOG.debug( - "host_os_version=%s csfy_host_os_version=%s", - host_os_version, - csfy_host_os_version, - ) - is_mac_ = macos_tag in host_os_version or macos_tag in csfy_host_os_version - _LOG.debug("is_mac_=%s", is_mac_) - return is_mac_ +# def is_host_mac(*, version: Optional[str] = None) -> bool: +# """ +# Return whether we are running on macOS and, optionally, on a specific +# version. + +# :param version: check whether we are running on a certain macOS version (e.g., +# `Catalina`, `Monterey`) +# """ +# _LOG.debug("version=%s", version) +# host_os_name = os.uname()[0] +# _LOG.debug("os.uname()=%s", str(os.uname())) +# csfy_host_os_name = os.environ.get("CSFY_HOST_OS_NAME", None) +# _LOG.debug( +# "host_os_name=%s csfy_host_os_name=%s", host_os_name, csfy_host_os_name +# ) +# is_mac_ = host_os_name == "Darwin" or csfy_host_os_name == "Darwin" +# if version is None: +# # The user didn't request a specific version, so we return whether we +# # are running on a Mac or not. +# _LOG.debug("is_mac_=%s", is_mac_) +# return is_mac_ +# else: +# # The user specified a version: if we are not running on a Mac then we +# # return False, since we don't even have to check the macOS version. +# if not is_mac_: +# _LOG.debug("is_mac_=%s", is_mac_) +# return False +# # Check the macOS version we are running. +# if version == "Catalina": +# # Darwin gpmac.local 19.6.0 Darwin Kernel Version 19.6.0: +# # root:xnu-6153.141.2~1/RELEASE_X86_64 x86_64 +# macos_tag = "19.6" +# elif version == "Monterey": +# # Darwin alpha.local 21.5.0 Darwin Kernel Version 21.5.0: +# # root:xnu-8020.121.3~4/RELEASE_ARM64_T6000 arm64 +# macos_tag = "21." +# elif version == "Ventura": +# macos_tag = "22." +# elif version == "Sequoia": +# # Darwin gpmac.local 24.4.0 Darwin Kernel Version 24.4.0: +# # root:xnu-11417.101.15~1/RELEASE_ARM64_T8112 arm64 +# macos_tag = "24." +# else: +# raise ValueError(f"Invalid version='{version}'") +# _LOG.debug("macos_tag=%s", macos_tag) +# host_os_version = os.uname()[2] +# # 'Darwin Kernel Version 19.6.0: Mon Aug 31 22:12:52 PDT 2020; +# # root:xnu-6153.141.2~1/RELEASE_X86_64' +# csfy_host_os_version = os.environ.get("CSFY_HOST_VERSION", "") +# _LOG.debug( +# "host_os_version=%s csfy_host_os_version=%s", +# host_os_version, +# csfy_host_os_version, +# ) +# is_mac_ = macos_tag in host_os_version or macos_tag in csfy_host_os_version +# _LOG.debug("is_mac_=%s", is_mac_) +# return is_mac_ def is_prod_csfy() -> bool: @@ -510,6 +510,20 @@ def _get_setup_settings() -> List[Tuple[str, bool]]: """ Return a list of tuples with the name and value of the current server setup. + + E.g., + ```bash + is_inside_docker_container_on_csfy_server=True + is_outside_docker_container_on_csfy_server=False + is_inside_docker_container_on_host_mac=False + is_outside_docker_container_on_host_mac=True + is_inside_docker_container_on_external_linux=False + is_outside_docker_container_on_external_linux=True + is_dev4=False + is_ig_prod=False + is_prod_csfy=False + is_inside_ci=False + ``` """ func_names = [ "is_inside_docker_container_on_csfy_server", @@ -631,8 +645,6 @@ def docker_needs_sudo() -> bool: """ if not has_docker(): return False - if not has_dind_support() and not use_docker_sibling_containers(): - return False # Another way to check is to see if your user is in the docker group: # > groups | grep docker rc = os.system("docker run hello-world 2>&1 >/dev/null") @@ -645,6 +657,17 @@ def docker_needs_sudo() -> bool: assert False, "Failed to run docker" +def get_docker_executable() -> str: + """ + Return the docker executable, wrapper with `sudo` if needed. + """ + docker_needs_sudo_ = docker_needs_sudo() + executable = "docker" + if docker_needs_sudo_: + executable = "sudo " + executable + return executable + + @functools.lru_cache() def has_docker_privileged_mode() -> bool: """ @@ -652,18 +675,25 @@ def has_docker_privileged_mode() -> bool: Docker privileged mode gives containers nearly all the same capabilities as the host system's kernel. + Privileged mode allows to: - run Docker-in-Docker - mount filesystems """ - cmd = "docker run --privileged hello-world 2>&1 >/dev/null" + if not has_docker(): + return False + docker_executable = get_docker_executable() + cmd = f"{docker_executable} run --privileged hello-world 2>&1 >/dev/null" rc = os.system(cmd) _print("cmd=%s -> rc=%s" % (cmd, rc)) has_privileged_mode = rc == 0 return has_privileged_mode -def has_sibling_containers_support() -> bool: +def has_docker_sibling_containers_support() -> bool: + """ + Return whether the current container supports running sibling containers. + """ # We need to be inside a container to run sibling containers. if not is_inside_docker(): return False @@ -673,7 +703,7 @@ def has_sibling_containers_support() -> bool: return False -def has_docker_dind_support() -> bool: +def has_docker_children_containers_support() -> bool: """ Return whether the current container supports Docker-in-Docker. """ @@ -684,6 +714,17 @@ def has_docker_dind_support() -> bool: return has_docker_privileged_mode() +def can_run_docker_from_docker() -> bool: + """ + Return whether we can run docker from docker, either as children or sibling + container. + """ + return ( + has_docker_children_containers_support() + or has_docker_sibling_containers_support() + ) + + def get_docker_info() -> str: txt_tmp: List[str] = [] # @@ -704,15 +745,21 @@ def get_docker_info() -> str: txt_tmp.append(f"is_inside_docker={is_inside_docker_}") # if is_inside_docker_: - has_sibling_containers_support_ = has_sibling_containers_support() - has_docker_dind_support_ = has_docker_dind_support() + has_docker_sibling_containers_support_ = ( + has_docker_sibling_containers_support() + ) + has_docker_children_containers_support_ = ( + has_docker_children_containers_support() + ) else: - has_sibling_containers_support_ = "*undef*" - has_docker_dind_support_ = "*undef*" + has_docker_sibling_containers_support_ = "*undef*" + has_docker_children_containers_support_ = "*undef*" + txt_tmp.append( + f"has_docker_sibling_containers_support={has_docker_sibling_containers_support_}" + ) txt_tmp.append( - f"has_sibling_containers_support={has_sibling_containers_support_}" + f"has_docker_children_containers_support={has_docker_children_containers_support_}" ) - txt_tmp.append(f"has_docker_dind_support={has_docker_dind_support_}") # txt = hprint.to_info("Docker info", txt_tmp) return txt @@ -728,56 +775,56 @@ def get_docker_info() -> str: # the system. -# TODO(gp): -> has_docker_privileged_mode -@functools.lru_cache() -def has_dind_support() -> bool: - """ - Return whether the current container supports privileged mode. - - This is needed to use Docker-in-Docker. - """ - _print("is_inside_docker()=%s" % is_inside_docker()) - if not is_inside_docker(): - # Outside Docker there is no privileged mode. - _print("-> ret = False") - return False - # TODO(gp): Not sure this is really needed since we do this check - # after enable_privileged_mode controls if we have dind or not. - if _is_mac_version_with_sibling_containers(): - return False - # TODO(gp): This part is not multi-process friendly. When multiple - # processes try to run this code they interfere. A solution is to run `ip - # link` in the entrypoint and create a `has_docker_privileged_mode` file - # which contains the value. - # We rely on the approach from https://stackoverflow.com/questions/32144575 - # to check if there is support for privileged mode. - # Sometimes there is some state left, so we need to clean it up. - # TODO(Juraj): this is slow and inefficient, but works for now. - cmd = "sudo docker run hello-world" - rc = os.system(cmd) - _print("cmd=%s -> rc=%s" % (cmd, rc)) - has_dind = rc == 0 - # dind is supported on both Mac and GH Actions. - # TODO(Juraj): HelpersTask16. - # if check_repo: - # if hserver.is_inside_ci(): - # # Docker-in-docker is needed for GH actions. For all other builds is optional. - # assert has_dind, ( - # f"Expected privileged mode: has_dind={has_dind}\n" - # + hserver.setup_to_str() - # ) - # else: - # only_warning = True - # _raise_invalid_host(only_warning) - # return False - # else: - # csfy_repo_config = os.environ.get("CSFY_REPO_CONFIG_CHECK", "True") - # print( - # _WARNING - # + ": Skip checking since CSFY_REPO_CONFIG_CHECK=" - # + f"'{csfy_repo_config}'" - # ) - return has_dind +# # TODO(gp): -> has_docker_privileged_mode +# @functools.lru_cache() +# def has_dind_support() -> bool: +# """ +# Return whether the current container supports privileged mode. + +# This is needed to use Docker-in-Docker. +# """ +# _print("is_inside_docker()=%s" % is_inside_docker()) +# if not is_inside_docker(): +# # Outside Docker there is no privileged mode. +# _print("-> ret = False") +# return False +# # TODO(gp): Not sure this is really needed since we do this check +# # after enable_privileged_mode controls if we have dind or not. +# if _is_mac_version_with_sibling_containers(): +# return False +# # TODO(gp): This part is not multi-process friendly. When multiple +# # processes try to run this code they interfere. A solution is to run `ip +# # link` in the entrypoint and create a `has_docker_privileged_mode` file +# # which contains the value. +# # We rely on the approach from https://stackoverflow.com/questions/32144575 +# # to check if there is support for privileged mode. +# # Sometimes there is some state left, so we need to clean it up. +# # TODO(Juraj): this is slow and inefficient, but works for now. +# cmd = "sudo docker run hello-world" +# rc = os.system(cmd) +# _print("cmd=%s -> rc=%s" % (cmd, rc)) +# has_dind = rc == 0 +# # dind is supported on both Mac and GH Actions. +# # TODO(Juraj): HelpersTask16. +# # if check_repo: +# # if hserver.is_inside_ci(): +# # # Docker-in-docker is needed for GH actions. For all other builds is optional. +# # assert has_dind, ( +# # f"Expected privileged mode: has_dind={has_dind}\n" +# # + hserver.setup_to_str() +# # ) +# # else: +# # only_warning = True +# # _raise_invalid_host(only_warning) +# # return False +# # else: +# # csfy_repo_config = os.environ.get("CSFY_REPO_CONFIG_CHECK", "True") +# # print( +# # _WARNING +# # + ": Skip checking since CSFY_REPO_CONFIG_CHECK=" +# # + f"'{csfy_repo_config}'" +# # ) +# return has_dind def _raise_invalid_host(only_warning: bool) -> None: @@ -810,14 +857,16 @@ def enable_privileged_mode() -> bool: ret = True elif is_external_linux(): ret = True - elif is_host_mac(version="Catalina"): - # Docker for macOS Catalina supports dind. - ret = True - elif ( - is_host_mac(version="Monterey") - or is_host_mac(version="Ventura") - or is_host_mac(version="Sequoia") - ): + elif is_host_mac(): + mac_version = get_host_mac_version() + if mac_version == "Catalina": + # Docker for macOS Catalina supports dind. + ret = True + elif mac_version in ("Monterey", "Ventura", "Sequoia"): + # Docker doesn't seem to support dind for these versions of macOS. + ret = False + else: + raise ValueError(f"Invalid version='{version}'") # Docker doesn't seem to support dind for these versions of macOS. ret = False elif is_prod_csfy(): @@ -855,11 +904,8 @@ def has_docker_sudo() -> bool: def _is_mac_version_with_sibling_containers() -> bool: - return ( - is_host_mac(version="Monterey") - or is_host_mac(version="Ventura") - or is_host_mac(version="Sequoia") - ) + mac_version = get_host_mac_version() + return mac_version in ("Monterey", "Ventura", "Sequoia") # TODO(gp): -> use_docker_sibling_container_support @@ -867,9 +913,13 @@ def use_docker_sibling_containers() -> bool: """ Return whether to use Docker sibling containers. - Using sibling containers requires that all Docker containers in the + Using sibling containers requires that all Docker containers are in the same network so that they can communicate with each other. """ + return has_docker_sibling_containers_support() + # if is_dev_csfy(): + # val = True + # else: val = is_dev4() or _is_mac_version_with_sibling_containers() return val diff --git a/helpers/hsql_test.py b/helpers/hsql_test.py index 83ee3e72b..0d28262e3 100644 --- a/helpers/hsql_test.py +++ b/helpers/hsql_test.py @@ -27,12 +27,9 @@ # ############################################################################# -# TODO(Grisha): Why does it require `ck_infra`? -@pytest.mark.requires_ck_infra @pytest.mark.requires_docker_in_docker @pytest.mark.skipif( - not hserver.has_dind_support() - and not hserver.use_docker_sibling_containers(), + not hserver.can_run_docker_from_docker(), reason="Need docker children / sibling support", ) class TestDbHelper(hunitest.TestCase, abc.ABC): diff --git a/helpers/hunit_test_utils.py b/helpers/hunit_test_utils.py index 808472c83..457baf838 100644 --- a/helpers/hunit_test_utils.py +++ b/helpers/hunit_test_utils.py @@ -472,7 +472,9 @@ def execute_only_on_dev_csfy() -> None: def execute_only_on_mac(*, version: Optional[str] = None) -> None: - is_host_mac_ = hserver.is_host_mac(version=version) + is_host_mac_ = hserver.is_host_mac() + if version: + is_host_mac_ = hserver.is_host_mac_version(version) if not is_host_mac_: pytest.skip(f"Only run on Mac with version={version}") diff --git a/helpers/lib_tasks_docker.py b/helpers/lib_tasks_docker.py index bfdaf55d0..5343906f9 100644 --- a/helpers/lib_tasks_docker.py +++ b/helpers/lib_tasks_docker.py @@ -20,6 +20,7 @@ import helpers.hdbg as hdbg import helpers.hdict as hdict import helpers.hdocker as hdocker +import helpers.henv as henv import helpers.hgit as hgit import helpers.hio as hio import helpers.hprint as hprint @@ -363,7 +364,7 @@ def _docker_login_ecr() -> None: cmd = f"eval $(aws ecr get-login --profile {profile} --no-include-email --region {region})" elif major_version == 2: if profile == "ck": - env_var = "CSFY_ECR_BASE_PATH" + env_var = f"CSFY_ECR_BASE_PATH" else: env_var = f"{profile.upper()}_ECR_BASE_PATH" ecr_base_path = hlitauti.get_default_param(env_var) @@ -558,47 +559,55 @@ def _generate_docker_compose_file( # We could do the same also with IMAGE for symmetry. # Keep the env vars in sync with what we print in `henv.get_env_vars()`. # Configure `base_app` service. - base_app_spec = { - "cap_add": ["SYS_ADMIN"], - "environment": [ - f"CSFY_ENABLE_DIND={CSFY_ENABLE_DIND}", - "CSFY_FORCE_TEST_FAIL=$CSFY_FORCE_TEST_FAIL", - f"CSFY_HOST_NAME={csfy_host_name}", - f"CSFY_HOST_OS_NAME={csfy_host_os_name}", - f"CSFY_HOST_OS_VERSION={csfy_host_os_version}", - f"CSFY_HOST_USER_NAME={csfy_host_user_name}", - "CSFY_REPO_CONFIG_CHECK=True", - # Use inferred path for `repo_config.py`. - "CSFY_REPO_CONFIG_PATH=", - "CSFY_AWS_ACCESS_KEY_ID=$CSFY_AWS_ACCESS_KEY_ID", - "CSFY_AWS_DEFAULT_REGION=$CSFY_AWS_DEFAULT_REGION", - "CSFY_AWS_PROFILE=$CSFY_AWS_PROFILE", - "CSFY_AWS_S3_BUCKET=$CSFY_AWS_S3_BUCKET", - "CSFY_AWS_SECRET_ACCESS_KEY=$CSFY_AWS_SECRET_ACCESS_KEY", - "CSFY_AWS_SESSION_TOKEN=$CSFY_AWS_SESSION_TOKEN", - "CSFY_ECR_BASE_PATH=$CSFY_ECR_BASE_PATH", - # The path of the outermost Git root on the host. - f"CSFY_HOST_GIT_ROOT_PATH={git_host_root_path}", - # The path of the outermost Git root in the Docker container. - f"CSFY_GIT_ROOT_PATH={git_root_path}", - # The path of the helpers dir in the Docker container (e.g., - # `/app`, `/app/helpers_root`) - f"CSFY_HELPERS_ROOT_PATH={helper_root_path}", - f"CSFY_USE_HELPERS_AS_NESTED_MODULE={use_helpers_as_nested_module}", - "CSFY_TELEGRAM_TOKEN=$CSFY_TELEGRAM_TOKEN", - # This env var is used by GH Action to signal that we are inside the - # CI. It's set up by default by the GH Action runner. See: - # https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/store-information-in-variables#default-environment-variables - "CSFY_CI=$CSFY_CI", - "OPENAI_API_KEY=$OPENAI_API_KEY", - # TODO(Vlad): consider removing, locally we use our personal tokens - # from files and inside GitHub actions we use the `GH_TOKEN` - # environment variable. + # TODO(gp): Use henv.get_env_vars() to get the env vars. + environment = [ + f"CSFY_ENABLE_DIND={CSFY_ENABLE_DIND}", + f"CSFY_FORCE_TEST_FAIL=$CSFY_FORCE_TEST_FAIL", + f"CSFY_HOST_NAME={csfy_host_name}", + f"CSFY_HOST_OS_NAME={csfy_host_os_name}", + f"CSFY_HOST_OS_VERSION={csfy_host_os_version}", + f"CSFY_HOST_USER_NAME={csfy_host_user_name}", + "CSFY_REPO_CONFIG_CHECK=True", + # Use inferred path for `repo_config.py`. + "CSFY_REPO_CONFIG_PATH=", + "CSFY_AWS_ACCESS_KEY_ID=$CSFY_AWS_ACCESS_KEY_ID", + "CSFY_AWS_DEFAULT_REGION=$CSFY_AWS_DEFAULT_REGION", + "CSFY_AWS_PROFILE=$CSFY_AWS_PROFILE", + "CSFY_AWS_S3_BUCKET=$CSFY_AWS_S3_BUCKET", + "CSFY_AWS_SECRET_ACCESS_KEY=$CSFY_AWS_SECRET_ACCESS_KEY", + "CSFY_AWS_SESSION_TOKEN=$CSFY_AWS_SESSION_TOKEN", + "CSFY_ECR_BASE_PATH=$CSFY_ECR_BASE_PATH", + # The path of the outermost Git root on the host. + f"CSFY_HOST_GIT_ROOT_PATH={git_host_root_path}", + # The path of the outermost Git root in the Docker container. + f"CSFY_GIT_ROOT_PATH={git_root_path}", + # The path of the helpers dir in the Docker container (e.g., + # `/app`, `/app/helpers_root`) + f"CSFY_HELPERS_ROOT_PATH={helper_root_path}", + f"CSFY_USE_HELPERS_AS_NESTED_MODULE={use_helpers_as_nested_module}", + "CSFY_TELEGRAM_TOKEN=$CSFY_TELEGRAM_TOKEN", + # This env var is used by GH Action to signal that we are inside the + # CI. It's set up by default by the GH Action runner. See: + # https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/store-information-in-variables#default-environment-variables + "CSFY_CI=$CSFY_CI", + # TODO(Vlad): consider removing, locally we use our personal tokens + # from files and inside GitHub actions we use the `GH_TOKEN` + # environment variable. + ] + environment.extend( + [ "GH_ACTION_ACCESS_TOKEN=$GH_ACTION_ACCESS_TOKEN", # Inside GitHub Actions we use `GH_TOKEN` environment variable, # see https://cli.github.com/manual/gh_auth_login. "GH_TOKEN=$GH_ACTION_ACCESS_TOKEN", - ], + ] + ) + api_key_env_vars = henv.get_api_key_env_vars() + environment.extend([f"{env_var}=${env_var}" for env_var in api_key_env_vars]) + # + base_app_spec = { + "cap_add": ["SYS_ADMIN"], + "environment": environment, "image": "${IMAGE}", "restart": "no", "volumes": [ diff --git a/helpers/test/test_hserver.py b/helpers/test/test_hserver.py index 2e8f32556..73722b5eb 100644 --- a/helpers/test/test_hserver.py +++ b/helpers/test/test_hserver.py @@ -109,8 +109,8 @@ def setUp(self) -> None: docker_needs_sudo=False has_privileged_mode=True is_inside_docker=True - has_sibling_containers_support=True - has_docker_dind_support=True + has_docker_sibling_containers_support=True + has_docker_children_containers_support=True """ ) self.exp_get_setup_settings = hprint.dedent( @@ -159,8 +159,8 @@ def setUp(self) -> None: docker_needs_sudo=False has_privileged_mode=True is_inside_docker=True - has_sibling_containers_support=True - has_docker_dind_support=True + has_docker_sibling_containers_support=True + has_docker_children_containers_support=True """ ) self.exp_get_setup_settings = hprint.dedent( @@ -209,8 +209,8 @@ def setUp(self) -> None: docker_needs_sudo=False has_privileged_mode=True is_inside_docker=False - has_sibling_containers_support=*undef* - has_docker_dind_support=*undef* + has_docker_sibling_containers_support=*undef* + has_docker_children_containers_support=*undef* """ ) self.exp_get_setup_settings = hprint.dedent( @@ -259,8 +259,8 @@ def setUp(self) -> None: docker_needs_sudo=False has_privileged_mode=True is_inside_docker=True - has_sibling_containers_support=True - has_docker_dind_support=True + has_docker_sibling_containers_support=True + has_docker_children_containers_support=True """ ) self.exp_get_setup_settings = hprint.dedent( @@ -309,8 +309,8 @@ def setUp(self) -> None: docker_needs_sudo=False has_privileged_mode=True is_inside_docker=False - has_sibling_containers_support=*undef* - has_docker_dind_support=*undef* + has_docker_sibling_containers_support=*undef* + has_docker_children_containers_support=*undef* """ ) self.exp_get_setup_settings = hprint.dedent(