def test_get_sidecar_container_with_non_managed_mount_outputs_logs_store(
self):
env_vars = [
get_env_var(name="key1", value="value1"),
get_env_var(name="key2", value="value2"),
]
mount_non_managed_store = V1ConnectionType(
name="test_claim",
kind=V1ConnectionKind.VOLUME_CLAIM,
schema=V1ClaimConnection(volume_claim="test",
mount_path="/tmp",
read_only=True),
)
sidecar = get_sidecar_container(
container_id=MAIN_JOB_CONTAINER,
env=env_vars,
polyaxon_sidecar=V1PolyaxonSidecarContainer(
image="sidecar/sidecar",
image_pull_policy="IfNotPresent",
sleep_interval=213,
sync_interval=-1,
),
artifacts_store=mount_non_managed_store,
contexts=PluginsContextsSpec.from_config(
V1Plugins(collect_logs=False,
collect_artifacts=False,
auth=True)),
run_path=None,
)
assert sidecar is None
def test_get_sidecar_container_with_non_managed_bucket_artifacts_logs_store(
self):
env_vars = [
get_env_var(name="key1", value="value1"),
get_env_var(name="key2", value="value2"),
]
bucket_non_managed_store = V1ConnectionType(
name="test_s3",
kind=V1ConnectionKind.S3,
schema=V1BucketConnection(bucket="s3//:foo"),
)
sidecar = get_sidecar_container(
container_id=MAIN_JOB_CONTAINER,
env=env_vars,
polyaxon_sidecar=V1PolyaxonSidecarContainer(
image="sidecar/sidecar",
image_pull_policy="IfNotPresent",
sleep_interval=213,
sync_interval=-1,
),
artifacts_store=bucket_non_managed_store,
contexts=PluginsContextsSpec.from_config(
V1Plugins(collect_logs=False,
collect_artifacts=False,
auth=True)),
run_path=None,
)
assert sidecar is None
def test_get_env_vars_with_artifacts_store(self):
assert (get_env_vars(
contexts=None,
log_level=None,
kv_env_vars=None,
connections=None,
secrets=None,
config_maps=None,
) == [])
assert get_env_vars(
contexts=PluginsContextsSpec.from_config(
V1Plugins(collect_logs=False,
collect_artifacts=True,
collect_resources=True)),
log_level=None,
kv_env_vars=None,
connections=None,
secrets=None,
config_maps=None,
) == [
get_env_var(name=POLYAXON_KEYS_COLLECT_ARTIFACTS, value=True),
get_env_var(name=POLYAXON_KEYS_COLLECT_RESOURCES, value=True),
]
assert (get_env_vars(
contexts=PluginsContextsSpec.from_config(
V1Plugins(
collect_logs=False,
collect_artifacts=False,
collect_resources=False,
)),
log_level=None,
kv_env_vars=None,
connections=None,
secrets=None,
config_maps=None,
) == [])
assert (get_env_vars(
contexts=None,
log_level=None,
kv_env_vars=None,
connections=None,
secrets=None,
config_maps=None,
) == [])
assert get_env_vars(
contexts=PluginsContextsSpec.from_config(
V1Plugins(collect_logs=False,
collect_artifacts=True,
collect_resources=False)),
log_level=None,
kv_env_vars=None,
connections=None,
secrets=None,
config_maps=None,
) == [get_env_var(name=POLYAXON_KEYS_COLLECT_ARTIFACTS, value=True)]
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_sidecar_env_vars(
env_vars: List[k8s_schemas.V1EnvVar],
container_id: str,
artifacts_store_name: str,
) -> List[k8s_schemas.V1EnvVar]:
env_vars = to_list(env_vars, check_none=True)[:]
env_vars.append(get_env_var(name=POLYAXON_KEYS_CONTAINER_ID, value=container_id))
env_vars.append(
get_env_var(name=POLYAXON_KEYS_ARTIFACTS_STORE_NAME, value=artifacts_store_name)
)
return env_vars
def test_get_env_vars(self):
# String value
env_var = get_env_var(name="foo", value="bar")
assert env_var.name == "foo"
assert env_var.value == "bar"
# Int value
env_var = get_env_var(name="foo", value=1)
assert env_var.name == "foo"
assert env_var.value == "1"
# Dict value
env_var = get_env_var(name="foo", value={"moo": "bar"})
assert env_var.name == "foo"
assert env_var.value == '{"moo": "bar"}'
def test_get_sidecar_env_vars(self):
sidecar_env_vars = get_sidecar_env_vars(
env_vars=None, container_id="foo", artifacts_store_name="name"
)
assert sidecar_env_vars == [
get_env_var(name=POLYAXON_KEYS_CONTAINER_ID, value="foo"),
get_env_var(name=POLYAXON_KEYS_ARTIFACTS_STORE_NAME, value="name"),
]
# Initial env vars
env_vars = [
get_env_var(name="key1", value="value1"),
get_env_var(name="key2", value="value2"),
]
sidecar_env_vars = get_sidecar_env_vars(
env_vars=env_vars, container_id="foo", artifacts_store_name="name"
)
assert sidecar_env_vars == env_vars + [
get_env_var(name=POLYAXON_KEYS_CONTAINER_ID, value="foo"),
get_env_var(name=POLYAXON_KEYS_ARTIFACTS_STORE_NAME, value="name"),
]
# Outputs Path
sidecar_env_vars = get_sidecar_env_vars(
env_vars=None, container_id="foo", artifacts_store_name="name"
)
assert sidecar_env_vars == [
get_env_var(name=POLYAXON_KEYS_CONTAINER_ID, value="foo"),
get_env_var(name=POLYAXON_KEYS_ARTIFACTS_STORE_NAME, value="name"),
]
def get_init_service_env_vars(
self,
external_host: bool = False
) -> Optional[List[k8s_schemas.V1EnvVar]]:
if settings.CLIENT_CONFIG.no_api:
return [get_env_var(name=POLYAXON_KEYS_NO_API, value=True)]
return None
def test_get_base_container(self):
store = V1ConnectionType(
name="test_claim",
kind=V1ConnectionKind.VOLUME_CLAIM,
schema=V1ClaimConnection(mount_path="/tmp",
volume_claim="test",
read_only=True),
)
env = [get_env_var(name="key", value="value")]
env_from = [k8s_schemas.V1EnvFromSource(secret_ref={"name": "ref"})]
mounts = [k8s_schemas.V1VolumeMount(name="test", mount_path="/test")]
container = get_base_store_container(
container=k8s_schemas.V1Container(name="init"),
container_name="init",
polyaxon_init=V1PolyaxonInitContainer(
image="foo/foo",
image_tag="",
image_pull_policy="IfNotPresent"),
store=store,
env=env,
env_from=env_from,
volume_mounts=mounts,
args=["test"],
)
assert container.name == "init"
assert container.image == "foo/foo"
assert container.image_pull_policy == "IfNotPresent"
assert container.command == ["/bin/sh", "-c"]
assert container.args == ["test"]
assert container.env == env
assert container.env_from == env_from
assert container.resources is not None
assert container.volume_mounts == mounts + [
get_mount_from_store(store=store)
]
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_main_container_simple_params(self):
initial_mounts = [
k8s_schemas.V1VolumeMount(name="test",
mount_path="/mount_test",
read_only=True)
]
resources = k8s_schemas.V1ResourceRequirements(
requests={
"cpu": "1",
"memory": "256Mi"
},
limits={
"cpu": "1",
"memory": "256Mi"
},
)
container = get_main_container(
container_id="new-name",
main_container=k8s_schemas.V1Container(
name="main",
image="job_docker_image",
image_pull_policy="IfNotPresent",
command=["cmd", "-p", "-c"],
args=["arg1", "arg2"],
resources=resources,
),
contexts=None,
volume_mounts=initial_mounts,
log_level="info",
artifacts_store=None,
init=None,
connection_by_names=None,
connections=None,
secrets=None,
config_maps=None,
kv_env_vars=None,
env=None,
ports=23,
run_path=None,
)
assert container.name == "new-name"
assert container.image == "job_docker_image"
assert container.image_pull_policy == "IfNotPresent"
assert container.command == ["cmd", "-p", "-c"]
assert container.args == ["arg1", "arg2"]
assert container.ports == [
k8s_schemas.V1ContainerPort(container_port=23)
]
assert container.env == [
get_env_var(name=POLYAXON_KEYS_LOG_LEVEL, value="info")
]
assert container.env_from == []
assert container.resources == resources
assert container.volume_mounts == initial_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 test_get_sidecar_container_auth_context(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", items=["item1", "item2"]),
is_requested=False,
)
bucket_managed_store = V1ConnectionType(
name="test_gcs",
kind=V1ConnectionKind.GCS,
schema=V1BucketConnection(bucket="gs//:foo"),
secret=resource1.schema,
)
# Default auth is included
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=bucket_managed_store,
contexts=PluginsContextsSpec.from_config(V1Plugins(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.volume_mounts == [
get_auth_context_mount(read_only=True),
get_artifacts_context_mount(read_only=False),
]
# Nno auth
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=bucket_managed_store,
contexts=PluginsContextsSpec.from_config(V1Plugins(auth=False)),
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.volume_mounts == [
get_artifacts_context_mount(read_only=False)
]
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.")
container_name = generate_container_name(INIT_GIT_CONTAINER_PREFIX, connection.name)
if not container:
container = k8s_schemas.V1Container(name=container_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
)
# Add special handling to auto-inject ssh mount path
if connection.kind == V1ConnectionKind.SSH and secret.schema.mount_path:
env += [get_env_var(POLYAXON_KEYS_SSH_PATH, secret.schema.mount_path)]
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,
# Handle the case of custom connection
url=getattr(connection.schema, "url", None),
revision=getattr(connection.schema, "revision", None),
flags=getattr(connection.schema, "flags", None),
mount_path=mount_path,
connection=connection.name if track else None,
)
return patch_container(
container=container,
name=container_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_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),
]
def get_polyaxon_sidecar_service_env_vars(
self, ) -> Optional[List[k8s_schemas.V1EnvVar]]:
if settings.CLIENT_CONFIG.no_api:
return [get_env_var(name=POLYAXON_KEYS_NO_API, value=True)]
return None
