def test_get_base_store_container_with_mount_store(self):
claim_store = V1ConnectionType(
name="test_claim",
kind=V1ConnectionKind.VOLUME_CLAIM,
schema=V1ClaimConnection(mount_path="/tmp",
volume_claim="test",
read_only=True),
)
container = get_base_store_container(
container=k8s_schemas.V1Container(name="init"),
container_name="init",
polyaxon_init=V1PolyaxonInitContainer(image_tag=""),
store=claim_store,
env=None,
env_from=None,
volume_mounts=None,
args=None,
)
assert container.name == "init"
assert container.image == "polyaxon/polyaxon-init"
assert container.image_pull_policy is None
assert container.command == ["/bin/sh", "-c"]
assert container.args is None
assert container.env == get_connection_env_var(connection=claim_store,
secret=None)
assert container.env_from == []
assert container.resources is not None
assert container.volume_mounts == [
get_mount_from_store(store=claim_store)
]
def test_get_base_store_container_with_store_without_secret(self):
bucket_store_without_secret = V1ConnectionType(
name="test_gcs",
kind=V1ConnectionKind.GCS,
schema=V1BucketConnection(bucket="gs//:foo"),
)
container = get_base_store_container(
container=k8s_schemas.V1Container(name="test"),
container_name="init",
polyaxon_init=V1PolyaxonInitContainer(image_tag=""),
store=bucket_store_without_secret,
env=None,
env_from=None,
volume_mounts=None,
args=None,
)
assert container.name == "init"
assert container.image == "polyaxon/polyaxon-init"
assert container.image_pull_policy is None
assert container.command == ["/bin/sh", "-c"]
assert container.args is None
assert container.env == get_connection_env_var(
connection=bucket_store_without_secret, secret=None)
assert container.env_from == []
assert container.resources is not None
assert container.volume_mounts == []
def test_get_env_vars_with_all(self):
connection = V1ConnectionType(
name="test_s3",
kind=V1ConnectionKind.S3,
schema=V1BucketConnection(bucket="s3//:foo"),
secret=self.resource6.schema,
)
env_vars = get_env_vars(
contexts=PluginsContextsSpec.from_config(
V1Plugins(collect_logs=False,
collect_artifacts=True,
collect_resources=True)),
log_level="info",
kv_env_vars=[["key1", "val1"], ["key2", "val2"]],
artifacts_store_name="test",
connections=[connection],
secrets=[
self.resource1,
self.resource2,
self.resource3,
self.resource4,
self.resource6,
],
config_maps=[
self.resource1,
self.resource2,
self.resource3,
self.resource4,
],
)
expected = [
get_env_var(name=POLYAXON_KEYS_LOG_LEVEL, value="info"),
get_env_var(name=POLYAXON_KEYS_COLLECT_ARTIFACTS, value=True),
get_env_var(name=POLYAXON_KEYS_COLLECT_RESOURCES, value=True),
get_env_var(name=POLYAXON_KEYS_ARTIFACTS_STORE_NAME, value="test"),
]
expected += get_connection_env_var(connection=connection,
secret=self.resource6)
expected += get_kv_env_vars([["key1", "val1"], ["key2", "val2"]])
expected += get_env_vars_from_k8s_resources(
secrets=[
self.resource1,
self.resource2,
self.resource3,
self.resource4,
self.resource6,
],
config_maps=[
self.resource1,
self.resource2,
self.resource3,
self.resource4,
],
)
assert env_vars == expected
def test_get_sidecar_container_with_managed_mount_outputs_and_blob_logs_store(self):
env_vars = [
get_env_var(name="key1", value="value1"),
get_env_var(name="key2", value="value2"),
]
resource1 = V1K8sResourceType(
name="test1", schema=V1K8sResourceSchema(name="ref1"), is_requested=False
)
blob_managed_store = V1ConnectionType(
name="test_gcs",
kind=V1ConnectionKind.GCS,
schema=V1BucketConnection(bucket="gs//:foo"),
secret=resource1.schema,
)
# logs and outputs
sidecar = get_sidecar_container(
container_id=MAIN_JOB_CONTAINER,
env=env_vars,
polyaxon_sidecar=V1PolyaxonSidecarContainer(
image="sidecar/sidecar",
image_tag="",
image_pull_policy="IfNotPresent",
sleep_interval=213,
sync_interval=212,
),
artifacts_store=blob_managed_store,
contexts=PluginsContextsSpec.from_config(None, default_auth=True),
run_path="test",
)
assert sidecar.name == SIDECAR_CONTAINER
assert sidecar.image == "sidecar/sidecar"
assert sidecar.image_pull_policy == "IfNotPresent"
assert sidecar.command == ["polyaxon", "sidecar"]
assert sidecar.args == get_sidecar_args(
container_id=MAIN_JOB_CONTAINER,
sleep_interval=213,
sync_interval=212,
monitor_logs=False,
)
assert (
sidecar.env
== get_sidecar_env_vars(
env_vars=env_vars,
container_id=MAIN_JOB_CONTAINER,
artifacts_store_name=blob_managed_store.name,
)
+ get_connection_env_var(connection=blob_managed_store, secret=resource1)
)
assert sidecar.env_from == [get_env_from_secret(secret=resource1)]
assert sidecar.resources == get_sidecar_resources()
assert sidecar.volume_mounts == [
get_auth_context_mount(read_only=True),
get_artifacts_context_mount(read_only=False),
]
def get_custom_init_container(
connection: V1ConnectionType,
contexts: PluginsContextsSpec,
container: Optional[k8s_schemas.V1Container],
env: List[k8s_schemas.V1EnvVar] = None,
mount_path: str = None,
) -> k8s_schemas.V1Container:
if not connection:
raise PolypodException(
"A connection is required to create a repo context.")
volume_name = (get_volume_name(mount_path)
if mount_path else constants.CONTEXT_VOLUME_ARTIFACTS)
mount_path = mount_path or CONTEXT_MOUNT_ARTIFACTS
volume_mounts = [
get_connections_context_mount(name=volume_name, mount_path=mount_path)
]
if contexts and contexts.auth:
volume_mounts.append(get_auth_context_mount(read_only=True))
env = to_list(env, check_none=True)
env_from = []
secret = connection.get_secret()
if secret:
volume_mounts += to_list(get_mount_from_resource(resource=secret),
check_none=True)
env += to_list(get_items_from_secret(secret=secret), check_none=True)
env_from = to_list(get_env_from_secret(secret=secret), check_none=True)
env += to_list(get_connection_env_var(connection=connection,
secret=secret),
check_none=True)
config_map = connection.get_config_map()
if config_map:
volume_mounts += to_list(get_mount_from_resource(resource=config_map),
check_none=True)
env += to_list(get_items_from_config_map(config_map=config_map),
check_none=True)
env_from = to_list(get_env_from_config_map(config_map=config_map),
check_none=True)
container_name = container.name or generate_container_name(
INIT_CUSTOM_CONTAINER_PREFIX, connection.name)
return patch_container(
container=container,
name=container_name,
env=env,
env_from=env_from,
volume_mounts=volume_mounts,
)
def get_env_vars(
contexts: PluginsContextsSpec,
log_level: str,
kv_env_vars: List[List],
artifacts_store_name: str,
connections: Iterable[V1ConnectionType],
secrets: Iterable[V1K8sResourceType],
config_maps: Iterable[V1K8sResourceType],
) -> List[k8s_schemas.V1EnvVar]:
env_vars = []
connections = connections or []
if log_level:
env_vars.append(get_env_var(name=POLYAXON_KEYS_LOG_LEVEL, value=log_level))
if contexts and contexts.collect_artifacts:
env_vars.append(get_env_var(name=POLYAXON_KEYS_COLLECT_ARTIFACTS, value=True))
if contexts and contexts.collect_resources:
env_vars.append(get_env_var(name=POLYAXON_KEYS_COLLECT_RESOURCES, value=True))
if artifacts_store_name:
env_vars.append(
get_env_var(
name=POLYAXON_KEYS_ARTIFACTS_STORE_NAME, value=artifacts_store_name
)
)
# Add connection env vars information
for connection in connections:
try:
secret = connection.get_secret()
env_vars += to_list(
get_connection_env_var(connection=connection, secret=secret),
check_none=True,
)
except PolyaxonSchemaError as e:
raise PolypodException("Error resolving secrets: %s" % e) from e
env_vars += get_kv_env_vars(kv_env_vars)
env_vars += get_env_vars_from_k8s_resources(
secrets=secrets, config_maps=config_maps
)
return env_vars
def test_get_store_container_mount_stores(self):
# Managed store
store = V1ConnectionType(
name="test_claim",
kind=V1ConnectionKind.VOLUME_CLAIM,
schema=V1ClaimConnection(mount_path="/tmp",
volume_claim="test",
read_only=True),
)
container = get_store_container(
polyaxon_init=V1PolyaxonInitContainer(
image="foo/foo",
image_tag="foo",
image_pull_policy="IfNotPresent"),
connection=store,
artifacts=None,
)
mount_path = CONTEXT_MOUNT_ARTIFACTS_FORMAT.format(store.name)
assert container.name == generate_container_name(
INIT_ARTIFACTS_CONTAINER_PREFIX, store.name)
assert container.image == "foo/foo:foo"
assert container.image_pull_policy == "IfNotPresent"
assert container.command == ["/bin/sh", "-c"]
assert container.args == [
get_volume_args(store=store, mount_path=mount_path, artifacts=None)
]
assert container.env == get_connection_env_var(connection=store,
secret=None)
assert container.env_from == []
assert container.resources is not None
assert container.volume_mounts == [
get_connections_context_mount(
name=constants.CONTEXT_VOLUME_ARTIFACTS,
mount_path=CONTEXT_MOUNT_ARTIFACTS_FORMAT.format(store.name),
),
get_mount_from_store(store=store),
]
def get_sidecar_container(
container_id: str,
polyaxon_sidecar: V1PolyaxonSidecarContainer,
env: List[k8s_schemas.V1EnvVar],
artifacts_store: V1ConnectionType,
contexts: PluginsContextsSpec,
run_path: Optional[str],
) -> Optional[k8s_schemas.V1Container]:
if artifacts_store and not contexts:
raise PolypodException(
"Logs/artifacts store was passed and contexts was not passed.")
has_artifacts = artifacts_store and contexts.collect_artifacts
has_logs = artifacts_store and contexts.collect_logs
if not has_logs and not has_artifacts:
# No sidecar
return None
if (has_artifacts or has_logs) and not run_path:
raise PolypodException(
"Logs store / outputs store must have a run_path.")
env = get_sidecar_env_vars(
env_vars=env,
container_id=container_id,
artifacts_store_name=artifacts_store.name,
)
volume_mounts = get_mounts(
use_auth_context=contexts.auth,
use_artifacts_context=has_artifacts,
use_docker_context=False,
use_shm_context=False,
)
sidecar_args = get_sidecar_args(
container_id=container_id,
sleep_interval=polyaxon_sidecar.sleep_interval,
sync_interval=polyaxon_sidecar.sync_interval,
)
env_from = []
secret = None
if artifacts_store.is_bucket:
secret = artifacts_store.get_secret()
volume_mounts += to_list(get_mount_from_resource(resource=secret),
check_none=True)
env += to_list(get_items_from_secret(secret=secret), check_none=True)
env_from += to_list(get_env_from_secret(secret=secret),
check_none=True)
config_map = artifacts_store.get_config_map()
volume_mounts += to_list(get_mount_from_resource(resource=config_map),
check_none=True)
env += to_list(get_items_from_config_map(config_map=config_map),
check_none=True)
env_from += to_list(get_env_from_config_map(config_map=config_map),
check_none=True)
else:
volume_mounts += to_list(get_mount_from_store(store=artifacts_store),
check_none=True)
env += to_list(
get_connection_env_var(connection=artifacts_store, secret=secret),
check_none=True,
)
return k8s_schemas.V1Container(
name=SIDECAR_CONTAINER,
image=polyaxon_sidecar.get_image(),
image_pull_policy=polyaxon_sidecar.image_pull_policy,
command=["/bin/bash", "-c"],
args=[sidecar_args],
env=env,
env_from=env_from,
resources=polyaxon_sidecar.get_resources(),
volume_mounts=volume_mounts,
)
def test_get_sidecar_container_with_managed_mount_outputs_logs_store(self):
env_vars = [
get_env_var(name="key1", value="value1"),
get_env_var(name="key2", value="value2"),
]
mount_managed_store = V1ConnectionType(
name="test_path",
kind=V1ConnectionKind.HOST_PATH,
schema=V1HostPathConnection(mount_path="/tmp", host_path="/tmp"),
secret=None,
)
# logs and outputs
sidecar = get_sidecar_container(
container_id=MAIN_JOB_CONTAINER,
env=env_vars,
polyaxon_sidecar=V1PolyaxonSidecarContainer(
image="sidecar/sidecar",
image_tag="",
image_pull_policy="IfNotPresent",
sleep_interval=213,
sync_interval=212,
),
artifacts_store=mount_managed_store,
contexts=PluginsContextsSpec.from_config(None, default_auth=True),
run_path="test",
)
assert sidecar.name == SIDECAR_CONTAINER
assert sidecar.image == "sidecar/sidecar"
assert sidecar.image_pull_policy == "IfNotPresent"
assert sidecar.command == ["polyaxon", "sidecar"]
assert sidecar.args == get_sidecar_args(
container_id=MAIN_JOB_CONTAINER,
sleep_interval=213,
sync_interval=212,
monitor_logs=False,
)
assert sidecar.env == get_sidecar_env_vars(
env_vars=env_vars,
container_id=MAIN_JOB_CONTAINER,
artifacts_store_name=mount_managed_store.name,
) + get_connection_env_var(connection=mount_managed_store, secret=None)
assert sidecar.env_from == []
assert sidecar.resources == get_sidecar_resources()
assert sidecar.volume_mounts == [
get_auth_context_mount(read_only=True),
get_artifacts_context_mount(read_only=False),
get_mount_from_store(store=mount_managed_store),
]
# logs and no outputs
sidecar = get_sidecar_container(
container_id=MAIN_JOB_CONTAINER,
env=env_vars,
polyaxon_sidecar=V1PolyaxonSidecarContainer(
image="sidecar/sidecar",
image_tag="",
image_pull_policy="IfNotPresent",
sleep_interval=213,
sync_interval=212,
),
artifacts_store=mount_managed_store,
contexts=PluginsContextsSpec.from_config(
V1Plugins(collect_artifacts=False, auth=True)),
run_path="test",
)
assert sidecar.name == SIDECAR_CONTAINER
assert sidecar.image == "sidecar/sidecar"
assert sidecar.image_pull_policy == "IfNotPresent"
assert sidecar.command == ["polyaxon", "sidecar"]
assert sidecar.args == get_sidecar_args(
container_id=MAIN_JOB_CONTAINER,
sleep_interval=213,
sync_interval=212,
monitor_logs=False,
)
assert sidecar.env == get_sidecar_env_vars(
env_vars=env_vars,
container_id=MAIN_JOB_CONTAINER,
artifacts_store_name=mount_managed_store.name,
) + get_connection_env_var(connection=mount_managed_store, secret=None)
assert sidecar.env_from == []
assert sidecar.resources == get_sidecar_resources()
assert sidecar.volume_mounts == [
get_auth_context_mount(read_only=True),
get_mount_from_store(store=mount_managed_store),
]
# outputs and no logs
sidecar = get_sidecar_container(
container_id=MAIN_JOB_CONTAINER,
env=env_vars,
polyaxon_sidecar=V1PolyaxonSidecarContainer(
image="sidecar/sidecar",
image_tag="",
image_pull_policy="IfNotPresent",
sleep_interval=213,
sync_interval=212,
),
artifacts_store=mount_managed_store,
contexts=PluginsContextsSpec.from_config(
V1Plugins(collect_logs=False, auth=True)),
run_path="test",
)
assert sidecar.name == SIDECAR_CONTAINER
assert sidecar.image == "sidecar/sidecar"
assert sidecar.image_pull_policy == "IfNotPresent"
assert sidecar.command == ["polyaxon", "sidecar"]
assert sidecar.args == get_sidecar_args(
container_id=MAIN_JOB_CONTAINER,
sleep_interval=213,
sync_interval=212,
monitor_logs=False,
)
assert sidecar.env == get_sidecar_env_vars(
env_vars=env_vars,
container_id=MAIN_JOB_CONTAINER,
artifacts_store_name=mount_managed_store.name,
) + get_connection_env_var(connection=mount_managed_store, secret=None)
assert sidecar.env_from == []
assert sidecar.resources == get_sidecar_resources()
assert sidecar.volume_mounts == [
get_auth_context_mount(read_only=True),
get_artifacts_context_mount(read_only=False),
get_mount_from_store(store=mount_managed_store),
]
def get_base_store_container(
container: Optional[k8s_schemas.V1Container],
container_name: str,
polyaxon_init: V1PolyaxonInitContainer,
store: V1ConnectionType,
env: List[k8s_schemas.V1EnvVar],
env_from: List[k8s_schemas.V1EnvFromSource],
volume_mounts: List[k8s_schemas.V1VolumeMount],
args: List[str],
) -> Optional[k8s_schemas.V1Container]:
env = env or []
env_from = env_from or []
volume_mounts = volume_mounts or []
# Artifact store needs to allow init the contexts as well, so the store is not required
if not store:
raise PolypodException("Init store container requires a store")
secret = None
if store.is_bucket:
secret = store.get_secret()
volume_mounts = volume_mounts + to_list(
get_mount_from_resource(resource=secret), check_none=True
)
env = env + to_list(get_items_from_secret(secret=secret), check_none=True)
env_from = env_from + to_list(
get_env_from_secret(secret=secret), check_none=True
)
env += to_list(
get_connection_env_var(connection=store, secret=secret), check_none=True
)
config_map = store.get_config_map()
volume_mounts = volume_mounts + to_list(
get_mount_from_resource(resource=config_map), check_none=True
)
env = env + to_list(
get_items_from_config_map(config_map=config_map), check_none=True
)
env_from = env_from + to_list(
get_env_from_config_map(config_map=config_map), check_none=True
)
else:
volume_mounts = volume_mounts + to_list(
get_mount_from_store(store=store), check_none=True
)
env += to_list(
get_connection_env_var(connection=store, secret=secret), check_none=True
)
return patch_container(
container=container,
name=container_name,
image=polyaxon_init.get_image(),
image_pull_policy=polyaxon_init.image_pull_policy,
command=["/bin/sh", "-c"],
args=args,
env=env,
env_from=env_from,
resources=polyaxon_init.get_resources(),
volume_mounts=volume_mounts,
)
def get_git_init_container(
polyaxon_init: V1PolyaxonInitContainer,
connection: V1ConnectionType,
contexts: PluginsContextsSpec,
container: Optional[k8s_schemas.V1Container] = None,
env: List[k8s_schemas.V1EnvVar] = None,
mount_path: str = None,
track: bool = False,
) -> k8s_schemas.V1Container:
if not connection:
raise PolypodException(
"A connection is required to create a repo context.")
if not container:
container = k8s_schemas.V1Container(name=generate_container_name(
INIT_GIT_CONTAINER_PREFIX, connection.name), )
volume_name = (get_volume_name(mount_path)
if mount_path else constants.CONTEXT_VOLUME_ARTIFACTS)
mount_path = mount_path or CONTEXT_MOUNT_ARTIFACTS
volume_mounts = [
get_connections_context_mount(name=volume_name, mount_path=mount_path)
]
if contexts and contexts.auth:
volume_mounts.append(get_auth_context_mount(read_only=True))
env = to_list(env, check_none=True)
env_from = []
secret = connection.get_secret()
if secret:
volume_mounts += to_list(get_mount_from_resource(resource=secret),
check_none=True)
env += to_list(get_items_from_secret(secret=secret), check_none=True)
env_from = to_list(get_env_from_secret(secret=secret), check_none=True)
env += to_list(get_connection_env_var(connection=connection,
secret=secret),
check_none=True)
config_map = connection.get_config_map()
if config_map:
volume_mounts += to_list(get_mount_from_resource(resource=config_map),
check_none=True)
env += to_list(get_items_from_config_map(config_map=config_map),
check_none=True)
env_from = to_list(get_env_from_config_map(config_map=config_map),
check_none=True)
args = get_repo_context_args(
name=connection.name,
url=connection.schema.url,
revision=connection.schema.revision,
mount_path=mount_path,
connection=connection.name if track else None,
)
return patch_container(
container=container,
name=generate_container_name(INIT_GIT_CONTAINER_PREFIX,
connection.name),
image=polyaxon_init.get_image(),
image_pull_policy=polyaxon_init.image_pull_policy,
command=["polyaxon", "initializer", "git"],
args=args,
env=env,
env_from=env_from,
volume_mounts=volume_mounts,
resources=polyaxon_init.get_resources(),
)
def test_get_base_store_container_with_store_with_secret(self):
non_mount_resource1 = V1K8sResourceType(
name="resource",
schema=V1K8sResourceSchema(name="ref", items=["item1", "item2"]),
is_requested=False,
)
bucket_store_with_secret = V1ConnectionType(
name="test_gcs",
kind=V1ConnectionKind.GCS,
schema=V1BucketConnection(bucket="gs//:foo"),
secret=non_mount_resource1.schema,
)
container = get_base_store_container(
container=k8s_schemas.V1Container(name="init"),
container_name="init",
polyaxon_init=V1PolyaxonInitContainer(image_tag=""),
store=bucket_store_with_secret,
env=None,
env_from=None,
volume_mounts=None,
args=None,
)
assert container.name == "init"
assert container.image == "polyaxon/polyaxon-init"
assert container.image_pull_policy is None
assert container.command == ["/bin/sh", "-c"]
assert container.args is None
env = get_items_from_secret(
secret=non_mount_resource1) + get_connection_env_var(
connection=bucket_store_with_secret,
secret=non_mount_resource1)
assert container.env == env
assert container.env_from == []
assert container.resources is not None
assert container.volume_mounts == []
mount_resource1 = V1K8sResourceType(
name="resource",
schema=V1K8sResourceSchema(name="resource",
items=["item1", "item2"],
mount_path="/tmp1"),
is_requested=False,
)
bucket_store_with_secret.secret = mount_resource1.schema
container = get_base_store_container(
container=k8s_schemas.V1Container(name="init"),
container_name="init",
polyaxon_init=V1PolyaxonInitContainer(image_tag=""),
store=bucket_store_with_secret,
env=None,
env_from=None,
volume_mounts=None,
args=None,
)
assert container.name == "init"
assert container.image == "polyaxon/polyaxon-init"
assert container.image_pull_policy is None
assert container.command == ["/bin/sh", "-c"]
assert container.args is None
assert container.env == get_connection_env_var(
connection=bucket_store_with_secret, secret=mount_resource1)
assert container.env_from == []
assert container.resources is not None
assert container.volume_mounts == [
get_mount_from_resource(resource=mount_resource1)
]
def test_get_git_init_container(self):
connection = V1ConnectionType(
name="user/foo",
kind=V1ConnectionKind.GIT,
schema=V1GitConnection(url="foo.com"),
)
container = get_git_init_container(
polyaxon_init=V1PolyaxonInitContainer(image="foo", image_tag=""),
connection=connection,
contexts=PluginsContextsSpec.from_config(V1Plugins(auth=True)),
)
assert container.name == INIT_GIT_CONTAINER.format(connection.name)
assert container.image == "foo"
assert container.image_pull_policy is None
assert container.command == ["polyaxon", "initializer", "git"]
assert container.env == get_connection_env_var(connection=connection,
secret=None)
assert container.resources == get_init_resources()
assert container.volume_mounts == [
get_connections_context_mount(
name=constants.CONTEXT_VOLUME_ARTIFACTS,
mount_path=CONTEXT_MOUNT_ARTIFACTS,
),
get_auth_context_mount(read_only=True),
]
container = get_git_init_container(
polyaxon_init=V1PolyaxonInitContainer(
image="init/init",
image_tag="",
image_pull_policy="IfNotPresent"),
connection=connection,
contexts=PluginsContextsSpec.from_config(V1Plugins(auth=True)),
)
assert container.name == INIT_GIT_CONTAINER.format(connection.name)
assert container.image == "init/init"
assert container.image_pull_policy == "IfNotPresent"
assert container.command == ["polyaxon", "initializer", "git"]
assert container.args == [
"--repo_path={}/{}".format(CONTEXT_MOUNT_ARTIFACTS,
connection.name),
"--url={}".format(connection.schema.url),
]
assert container.resources == get_init_resources()
assert container.volume_mounts == [
get_connections_context_mount(
name=constants.CONTEXT_VOLUME_ARTIFACTS,
mount_path=CONTEXT_MOUNT_ARTIFACTS,
),
get_auth_context_mount(read_only=True),
]
connection = V1ConnectionType(
name="user/foo",
kind=V1ConnectionKind.GIT,
schema=V1GitConnection(
url="foo.com",
revision="00b9d2ea01c40f58d6b4051319f9375675a43c02"),
)
container = get_git_init_container(
polyaxon_init=V1PolyaxonInitContainer(
image="init/init",
image_tag="",
image_pull_policy="IfNotPresent"),
connection=connection,
mount_path="/somepath",
contexts=PluginsContextsSpec.from_config(V1Plugins(auth=True)),
)
assert container.name == INIT_GIT_CONTAINER.format(connection.name)
assert container.image == "init/init"
assert container.image_pull_policy == "IfNotPresent"
assert container.command == ["polyaxon", "initializer", "git"]
assert container.args == [
"--repo_path=/somepath/{}".format(connection.name),
"--url={}".format(connection.schema.url),
"--revision=00b9d2ea01c40f58d6b4051319f9375675a43c02",
]
assert container.resources == get_init_resources()
assert container.volume_mounts == [
get_connections_context_mount(name=get_volume_name("/somepath"),
mount_path="/somepath"),
get_auth_context_mount(read_only=True),
]
def test_get_sidecar_container_with_managed_bucket_outputs_logs_store_and_mount_secret(
self,
):
env_vars = [
get_env_var(name="key1", value="value1"),
get_env_var(name="key2", value="value2"),
]
resource1 = V1K8sResourceType(
name="test1",
schema=V1K8sResourceSchema(
name="test1", items=["item1", "item2"], mount_path="/path"
),
is_requested=False,
)
bucket_managed_store = V1ConnectionType(
name="test_gcs",
kind=V1ConnectionKind.GCS,
schema=V1BucketConnection(bucket="gs//:foo"),
secret=resource1.schema,
)
# Both logs and outputs
sidecar = get_sidecar_container(
env=env_vars,
polyaxon_sidecar=V1PolyaxonSidecarContainer(
image="sidecar/sidecar",
image_tag="",
image_pull_policy="IfNotPresent",
sleep_interval=213,
sync_interval=212,
),
artifacts_store=bucket_managed_store,
contexts=PluginsContextsSpec.from_config(None),
run_path="test",
)
assert sidecar.name == SIDECAR_CONTAINER
assert sidecar.image == "sidecar/sidecar"
assert sidecar.image_pull_policy == "IfNotPresent"
assert sidecar.command == ["/bin/bash", "-c"]
assert sidecar.args == [
get_sidecar_args(
container_id=MAIN_JOB_CONTAINER, sleep_interval=213, sync_interval=212
)
]
assert sidecar.env == get_sidecar_env_vars(
env_vars=env_vars,
job_container_name=MAIN_JOB_CONTAINER,
artifacts_store_name=bucket_managed_store.name,
) + get_items_from_secret(secret=resource1) + get_connection_env_var(
connection=bucket_managed_store, secret=resource1
)
assert sidecar.env_from == []
assert sidecar.resources == get_sidecar_resources()
assert sidecar.volume_mounts == [
get_auth_context_mount(read_only=True),
get_artifacts_context_mount(read_only=False),
get_mount_from_resource(resource=resource1),
]
# logs and no outputs
sidecar = get_sidecar_container(
env=env_vars,
polyaxon_sidecar=V1PolyaxonSidecarContainer(
image="sidecar/sidecar",
image_tag="",
image_pull_policy="IfNotPresent",
sleep_interval=213,
sync_interval=212,
),
artifacts_store=bucket_managed_store,
contexts=PluginsContextsSpec.from_config(
V1Plugins(collect_artifacts=False)
),
run_path="test",
)
assert sidecar.name == SIDECAR_CONTAINER
assert sidecar.image == "sidecar/sidecar"
assert sidecar.image_pull_policy == "IfNotPresent"
assert sidecar.command == ["/bin/bash", "-c"]
assert sidecar.args == [
get_sidecar_args(
container_id=MAIN_JOB_CONTAINER, sleep_interval=213, sync_interval=212
)
]
assert sidecar.env == get_sidecar_env_vars(
env_vars=env_vars,
job_container_name=MAIN_JOB_CONTAINER,
artifacts_store_name=bucket_managed_store.name,
) + get_items_from_secret(secret=resource1) + get_connection_env_var(
connection=bucket_managed_store, secret=resource1
)
assert sidecar.env_from == []
assert sidecar.resources == get_sidecar_resources()
assert sidecar.volume_mounts == [
get_auth_context_mount(read_only=True),
get_mount_from_resource(resource=resource1),
]
# outputs and no logs
sidecar = get_sidecar_container(
env=env_vars,
polyaxon_sidecar=V1PolyaxonSidecarContainer(
image="sidecar/sidecar",
image_tag="",
image_pull_policy="IfNotPresent",
sleep_interval=213,
sync_interval=212,
),
artifacts_store=bucket_managed_store,
contexts=PluginsContextsSpec.from_config(V1Plugins(collect_logs=False)),
run_path="test",
)
assert sidecar.name == SIDECAR_CONTAINER
assert sidecar.image == "sidecar/sidecar"
assert sidecar.image_pull_policy == "IfNotPresent"
assert sidecar.command == ["/bin/bash", "-c"]
assert sidecar.args == [
get_sidecar_args(
container_id=MAIN_JOB_CONTAINER, sleep_interval=213, sync_interval=212
)
]
assert sidecar.env == get_sidecar_env_vars(
env_vars=env_vars,
job_container_name=MAIN_JOB_CONTAINER,
artifacts_store_name=bucket_managed_store.name,
) + get_items_from_secret(secret=resource1) + get_connection_env_var(
connection=bucket_managed_store, secret=resource1
)
assert sidecar.env_from == []
assert sidecar.resources == get_sidecar_resources()
assert sidecar.volume_mounts == [
get_auth_context_mount(read_only=True),
get_artifacts_context_mount(read_only=False),
get_mount_from_resource(resource=resource1),
]
