456 lines
16 KiB
Python
456 lines
16 KiB
Python
__all__ = [
|
|
'Container',
|
|
'PodArgoSubset',
|
|
]
|
|
|
|
|
|
from collections import OrderedDict
|
|
|
|
from typing import Any, Dict, List, Mapping, Optional, Sequence, Union
|
|
|
|
from ...modelbase import ModelBase
|
|
|
|
|
|
class EnvVar(ModelBase):
|
|
_serialized_names = {
|
|
'value_from': 'valueFrom',
|
|
}
|
|
def __init__(self,
|
|
name: str,
|
|
value: Optional[str] = None,
|
|
#value_from: Optional[EnvVarSource] = None, #TODO: Add if needed
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class ExecAction(ModelBase):
|
|
def __init__(self,
|
|
command: List[str],
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class Handler(ModelBase):
|
|
_serialized_names = {
|
|
'http_get': 'httpGet',
|
|
'tcp_socket': 'tcpSocket',
|
|
}
|
|
def __init__(self,
|
|
exec: Optional[ExecAction] = None,
|
|
#http_get: Optional[HTTPGetAction] = None, #TODO: Add if needed
|
|
#tcp_socket: Optional[TCPSocketAction] = None, #TODO: Add if needed
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class Lifecycle(ModelBase):
|
|
_serialized_names = {
|
|
'post_start': 'postStart',
|
|
'pre_stop': 'preStop',
|
|
}
|
|
def __init__(self,
|
|
post_start: Optional[Handler] = None,
|
|
pre_stop: Optional[Handler] = None,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class VolumeMount(ModelBase):
|
|
_serialized_names = {
|
|
'mount_path': 'mountPath',
|
|
'mount_propagation': 'mountPropagation',
|
|
'read_only': 'readOnly',
|
|
'sub_path': 'subPath',
|
|
}
|
|
def __init__(self,
|
|
name: str,
|
|
mount_path: str,
|
|
mount_propagation: Optional[str] = None,
|
|
read_only: Optional[bool] = None,
|
|
sub_path: Optional[str] = None,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class ResourceRequirements(ModelBase):
|
|
def __init__(self,
|
|
limits: Optional[Dict[str, str]] = None,
|
|
requests: Optional[Dict[str, str]] = None,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class ContainerPort(ModelBase):
|
|
_serialized_names = {
|
|
'container_port': 'containerPort',
|
|
'host_ip': 'hostIP',
|
|
'host_port': 'hostPort',
|
|
}
|
|
def __init__(self,
|
|
container_port: int,
|
|
host_ip: Optional[str] = None,
|
|
host_port: Optional[int] = None,
|
|
name: Optional[str] = None,
|
|
protocol: Optional[str] = None,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class VolumeDevice(ModelBase):
|
|
_serialized_names = {
|
|
'device_path': 'devicePath',
|
|
}
|
|
def __init__(self,
|
|
device_path: str,
|
|
name: str,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class Probe(ModelBase):
|
|
_serialized_names = {
|
|
'failure_threshold': 'failureThreshold',
|
|
'http_get': 'httpGet',
|
|
'initial_delay_seconds': 'initialDelaySeconds',
|
|
'period_seconds': 'periodSeconds',
|
|
'success_threshold': 'successThreshold',
|
|
'tcp_socket': 'tcpSocket',
|
|
'timeout_seconds': 'timeoutSeconds'
|
|
}
|
|
def __init__(self,
|
|
exec: Optional[ExecAction] = None,
|
|
failure_threshold: Optional[int] = None,
|
|
#http_get: Optional[HTTPGetAction] = None, #TODO: Add if needed
|
|
initial_delay_seconds: Optional[int] = None,
|
|
period_seconds: Optional[int] = None,
|
|
success_threshold: Optional[int] = None,
|
|
#tcp_socket: Optional[TCPSocketAction] = None, #TODO: Add if needed
|
|
timeout_seconds: Optional[int] = None,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class SecurityContext(ModelBase):
|
|
_serialized_names = {
|
|
'allow_privilege_escalation': 'allowPrivilegeEscalation',
|
|
'capabilities': 'capabilities',
|
|
'privileged': 'privileged',
|
|
'read_only_root_filesystem': 'readOnlyRootFilesystem',
|
|
'run_as_group': 'runAsGroup',
|
|
'run_as_non_root': 'runAsNonRoot',
|
|
'run_as_user': 'runAsUser',
|
|
'se_linux_options': 'seLinuxOptions'
|
|
}
|
|
def __init__(self,
|
|
allow_privilege_escalation: Optional[bool] = None,
|
|
#capabilities: Optional[Capabilities] = None, #TODO: Add if needed
|
|
privileged: Optional[bool] = None,
|
|
read_only_root_filesystem: Optional[bool] = None,
|
|
run_as_group: Optional[int] = None,
|
|
run_as_non_root: Optional[bool] = None,
|
|
run_as_user: Optional[int] = None,
|
|
#se_linux_options: Optional[SELinuxOptions] = None, #TODO: Add if needed
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class Container(ModelBase):
|
|
_serialized_names = {
|
|
'env_from': 'envFrom',
|
|
'image_pull_policy': 'imagePullPolicy',
|
|
'liveness_probe': 'livenessProbe',
|
|
'readiness_probe': 'readinessProbe',
|
|
'security_context': 'securityContext',
|
|
'stdin_once': 'stdinOnce',
|
|
'termination_message_path': 'terminationMessagePath',
|
|
'termination_message_policy': 'terminationMessagePolicy',
|
|
'volume_devices': 'volumeDevices',
|
|
'volume_mounts': 'volumeMounts',
|
|
'working_dir': 'workingDir',
|
|
}
|
|
|
|
def __init__(self,
|
|
#Better to set at Component level
|
|
image: Optional[str] = None,
|
|
command: Optional[List[str]] = None,
|
|
args: Optional[List[str]] = None,
|
|
env: Optional[List[EnvVar]] = None,
|
|
|
|
working_dir: Optional[str] = None, #Not really needed: container should have proper working dir set up
|
|
|
|
lifecycle: Optional[Lifecycle] = None, #Can be used to specify pre-exit commands to run TODO: Probably support at Component level.
|
|
|
|
#Better to set at Task level
|
|
volume_mounts: Optional[List[VolumeMount]] = None,
|
|
resources: Optional[ResourceRequirements] = None,
|
|
|
|
#Might not be used a lot
|
|
ports: Optional[List[ContainerPort]] = None,
|
|
#env_from: Optional[List[EnvFromSource]] = None, #TODO: Add if needed
|
|
volume_devices: Optional[List[VolumeDevice]] = None,
|
|
|
|
#Probably not needed
|
|
name: Optional[str] = None, #Required by k8s schema, but not Argo.
|
|
image_pull_policy: Optional[str] = None,
|
|
liveness_probe: Optional[Probe] = None,
|
|
readiness_probe: Optional[Probe] = None,
|
|
security_context: Optional[SecurityContext] = None,
|
|
stdin: Optional[bool] = None,
|
|
stdin_once: Optional[bool] = None,
|
|
termination_message_path: Optional[str] = None,
|
|
termination_message_policy: Optional[str] = None,
|
|
tty: Optional[bool] = None,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
#class NodeAffinity(ModelBase):
|
|
# _serialized_names = {
|
|
# 'preferred_during_scheduling_ignored_during_execution': 'preferredDuringSchedulingIgnoredDuringExecution',
|
|
# 'required_during_scheduling_ignored_during_execution': 'requiredDuringSchedulingIgnoredDuringExecution',
|
|
# }
|
|
# def __init__(self,
|
|
# preferred_during_scheduling_ignored_during_execution: Optional[List[PreferredSchedulingTerm]] = None,
|
|
# required_during_scheduling_ignored_during_execution: Optional[NodeSelector] = None,
|
|
# ):
|
|
# super().__init__(locals())
|
|
|
|
|
|
#class Affinity(ModelBase):
|
|
# _serialized_names = {
|
|
# 'node_affinity': 'nodeAffinity',
|
|
# 'pod_affinity': 'podAffinity',
|
|
# 'pod_anti_affinity': 'podAntiAffinity',
|
|
# }
|
|
# def __init__(self,
|
|
# node_affinity: Optional[NodeAffinity] = None,
|
|
# #pod_affinity: Optional[PodAffinity] = None, #TODO: Add if needed
|
|
# #pod_anti_affinity: Optional[PodAntiAffinity] = None, #TODO: Add if needed
|
|
# ):
|
|
# super().__init__(locals())
|
|
|
|
|
|
class Toleration(ModelBase):
|
|
_serialized_names = {
|
|
'toleration_seconds': 'tolerationSeconds',
|
|
}
|
|
def __init__(self,
|
|
effect: Optional[str] = None,
|
|
key: Optional[str] = None,
|
|
operator: Optional[str] = None,
|
|
toleration_seconds: Optional[int] = None,
|
|
value: Optional[str] = None,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class KeyToPath(ModelBase):
|
|
def __init__(self,
|
|
key: str,
|
|
path: str,
|
|
mode: Optional[int] = None,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class SecretVolumeSource(ModelBase):
|
|
_serialized_names = {
|
|
'default_mode': 'defaultMode',
|
|
'secret_name': 'secretName'
|
|
}
|
|
def __init__(self,
|
|
default_mode: Optional[int] = None,
|
|
items: Optional[List[KeyToPath]] = None,
|
|
optional: Optional[bool] = None,
|
|
secret_name: Optional[str] = None,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class NFSVolumeSource(ModelBase):
|
|
_serialized_names = {
|
|
'read_only': 'readOnly',
|
|
}
|
|
def __init__(self,
|
|
path: str,
|
|
server: str,
|
|
read_only: Optional[bool] = None,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class PersistentVolumeClaimVolumeSource(ModelBase):
|
|
_serialized_names = {
|
|
'claim_name': 'claimName',
|
|
'read_only': 'readOnly'
|
|
}
|
|
def __init__(self,
|
|
claim_name: str,
|
|
read_only: Optional[bool] = None,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class Volume(ModelBase):
|
|
_serialized_names = {
|
|
'aws_elastic_block_store': 'awsElasticBlockStore',
|
|
'azure_disk': 'azureDisk',
|
|
'azure_file': 'azureFile',
|
|
'cephfs': 'cephfs',
|
|
'cinder': 'cinder',
|
|
'config_map': 'configMap',
|
|
'downward_api': 'downwardAPI',
|
|
'empty_dir': 'emptyDir',
|
|
'fc': 'fc',
|
|
'flex_volume': 'flexVolume',
|
|
'flocker': 'flocker',
|
|
'gce_persistent_disk': 'gcePersistentDisk',
|
|
'git_repo': 'gitRepo',
|
|
'glusterfs': 'glusterfs',
|
|
'host_path': 'hostPath',
|
|
'iscsi': 'iscsi',
|
|
'name': 'name',
|
|
'nfs': 'nfs',
|
|
'persistent_volume_claim': 'persistentVolumeClaim',
|
|
'photon_persistent_disk': 'photonPersistentDisk',
|
|
'portworx_volume': 'portworxVolume',
|
|
'projected': 'projected',
|
|
'quobyte': 'quobyte',
|
|
'rbd': 'rbd',
|
|
'scale_io': 'scaleIO',
|
|
'secret': 'secret',
|
|
'storageos': 'storageos',
|
|
'vsphere_volume': 'vsphereVolume'
|
|
}
|
|
|
|
def __init__(self,
|
|
name: str,
|
|
secret: Optional[SecretVolumeSource] = None,
|
|
nfs: Optional[NFSVolumeSource] = None,
|
|
persistent_volume_claim: Optional[PersistentVolumeClaimVolumeSource] = None,
|
|
|
|
#No validation for these volume types
|
|
aws_elastic_block_store: Optional[Mapping] = None, #AWSElasticBlockStoreVolumeSource,
|
|
azure_disk: Optional[Mapping] = None, #AzureDiskVolumeSource,
|
|
azure_file: Optional[Mapping] = None, #AzureFileVolumeSource,
|
|
cephfs: Optional[Mapping] = None, #CephFSVolumeSource,
|
|
cinder: Optional[Mapping] = None, #CinderVolumeSource,
|
|
config_map: Optional[Mapping] = None, #ConfigMapVolumeSource,
|
|
downward_api: Optional[Mapping] = None, #DownwardAPIVolumeSource,
|
|
empty_dir: Optional[Mapping] = None, #EmptyDirVolumeSource,
|
|
fc: Optional[Mapping] = None, #FCVolumeSource,
|
|
flex_volume: Optional[Mapping] = None, #FlexVolumeSource,
|
|
flocker: Optional[Mapping] = None, #FlockerVolumeSource,
|
|
gce_persistent_disk: Optional[Mapping] = None, #GCEPersistentDiskVolumeSource,
|
|
git_repo: Optional[Mapping] = None, #GitRepoVolumeSource,
|
|
glusterfs: Optional[Mapping] = None, #GlusterfsVolumeSource,
|
|
host_path: Optional[Mapping] = None, #HostPathVolumeSource,
|
|
iscsi: Optional[Mapping] = None, #ISCSIVolumeSource,
|
|
photon_persistent_disk: Optional[Mapping] = None, #PhotonPersistentDiskVolumeSource,
|
|
portworx_volume: Optional[Mapping] = None, #PortworxVolumeSource,
|
|
projected: Optional[Mapping] = None, #ProjectedVolumeSource,
|
|
quobyte: Optional[Mapping] = None, #QuobyteVolumeSource,
|
|
rbd: Optional[Mapping] = None, #RBDVolumeSource,
|
|
scale_io: Optional[Mapping] = None, #ScaleIOVolumeSource,
|
|
storageos: Optional[Mapping] = None, #StorageOSVolumeSource,
|
|
vsphere_volume: Optional[Mapping] = None, #VsphereVirtualDiskVolumeSource,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class PodSpecArgoSubset(ModelBase):
|
|
_serialized_names = {
|
|
'active_deadline_seconds': 'activeDeadlineSeconds',
|
|
'affinity': 'affinity',
|
|
#'automount_service_account_token': 'automountServiceAccountToken',
|
|
#'containers': 'containers',
|
|
#'dns_config': 'dnsConfig',
|
|
#'dns_policy': 'dnsPolicy',
|
|
#'host_aliases': 'hostAliases',
|
|
#'host_ipc': 'hostIPC',
|
|
#'host_network': 'hostNetwork',
|
|
#'host_pid': 'hostPID',
|
|
#'hostname': 'hostname',
|
|
#'image_pull_secrets': 'imagePullSecrets',
|
|
#'init_containers': 'initContainers',
|
|
#'node_name': 'nodeName',
|
|
'node_selector': 'nodeSelector',
|
|
#'priority': 'priority',
|
|
#'priority_class_name': 'priorityClassName',
|
|
#'readiness_gates': 'readinessGates',
|
|
#'restart_policy': 'restartPolicy',
|
|
#'scheduler_name': 'schedulerName',
|
|
#'security_context': 'securityContext',
|
|
#'service_account': 'serviceAccount',
|
|
#'service_account_name': 'serviceAccountName',
|
|
#'share_process_namespace': 'shareProcessNamespace',
|
|
#'subdomain': 'subdomain',
|
|
#'termination_grace_period_seconds': 'terminationGracePeriodSeconds',
|
|
'tolerations': 'tolerations',
|
|
'volumes': 'volumes',
|
|
}
|
|
def __init__(self,
|
|
active_deadline_seconds: Optional[int] = None,
|
|
affinity: Optional[Mapping] = None, #Affinity, #No validation
|
|
#automount_service_account_token: Optional[bool] = None, #Not supported by Argo
|
|
#containers: Optional[List[Container]] = None, #Not supported by Argo
|
|
#dns_config: Optional[PodDNSConfig] = None, #Not supported by Argo
|
|
#dns_policy: Optional[str] = None, #Not supported by Argo
|
|
#host_aliases: Optional[List[HostAlias]] = None, #Not supported by Argo
|
|
#host_ipc: Optional[bool] = None, #Not supported by Argo
|
|
#host_network: Optional[bool] = None, #Not supported by Argo
|
|
#host_pid: Optional[bool] = None, #Not supported by Argo
|
|
#hostname: Optional[str] = None, #Not supported by Argo
|
|
#image_pull_secrets: Optional[List[LocalObjectReference]] = None, #Not supported by Argo
|
|
#init_containers: Optional[List[Container]] = None, #Not supported by Argo
|
|
#node_name: Optional[str] = None, #Not supported by Argo
|
|
node_selector: Optional[Dict[str, str]] = None,
|
|
#priority: Optional[int] = None, #Not supported by Argo
|
|
#priority_class_name: Optional[str] = None, #Not supported by Argo
|
|
#readiness_gates: Optional[List[PodReadinessGate]] = None, #Not supported by Argo
|
|
#restart_policy: Optional[str] = None, #Not supported by Argo
|
|
#scheduler_name: Optional[str] = None, #Not supported by Argo
|
|
#security_context: Optional[PodSecurityContext] = None, #Not supported by Argo
|
|
#service_account: Optional[str] = None, #Not supported by Argo
|
|
#service_account_name: Optional[str] = None, #Not supported by Argo
|
|
#share_process_namespace: Optional[bool] = None, #Not supported by Argo
|
|
#subdomain: Optional[str] = None, #Not supported by Argo
|
|
#termination_grace_period_seconds: Optional[int] = None, #Not supported by Argo
|
|
tolerations: Optional[List[Toleration]] = None,
|
|
volumes: Optional[List[Volume]] = None, #Argo only supports volumes at the Workflow level
|
|
|
|
#+Argo features:
|
|
#+Metadata: ArgoMetadata? (Argo version)
|
|
#+RetryStrategy: ArgoRetryStrategy ~= k8s.JobSpec.backoffLimit
|
|
#+Parallelism: int
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class ObjectMetaArgoSubset(ModelBase):
|
|
def __init__(self,
|
|
annotations: Optional[Dict[str, str]] = None,
|
|
labels: Optional[Dict[str, str]] = None,
|
|
):
|
|
super().__init__(locals())
|
|
|
|
|
|
class PodArgoSubset(ModelBase):
|
|
_serialized_names = {
|
|
'api_version': 'apiVersion',
|
|
'kind': 'kind',
|
|
'metadata': 'metadata',
|
|
'spec': 'spec',
|
|
'status': 'status',
|
|
}
|
|
def __init__(self,
|
|
#api_version: Optional[str] = None,
|
|
#kind: Optional[str] = None,
|
|
#metadata: Optional[ObjectMeta] = None,
|
|
metadata: Optional[ObjectMetaArgoSubset] = None,
|
|
#spec: Optional[PodSpec] = None,
|
|
spec: Optional[PodSpecArgoSubset] = None,
|
|
#status: Optional[PodStatus] = None,
|
|
):
|
|
super().__init__(locals())
|