def __init__(self, name=None, image=None, namespace="default", replicas=0, model=None):
PodBasedModel.__init__(self)
if model is not None:
self.model = model
# if 'status' in self.model:
# self.model.pop('status', None)
if "metadata" in self.model:
self.deployment_metadata = ObjectMeta(model=self.model["metadata"])
if "template" in self.model["spec"]:
self.pod_spec = PodSpec(model=self.model["spec"]["template"]["spec"])
self.pod_metadata = ObjectMeta(model=self.model["spec"]["template"]["metadata"])
else:
if name is None:
raise SyntaxError("Deployment: name: [ {0} ] cannot be None.".format(name))
if not isinstance(name, str):
raise SyntaxError("Deployment: name: [ {0} ] must be a string.".format(name))
self.model = dict(kind="Deployment", apiVersion=API_VERSION)
self.deployment_metadata = ObjectMeta(name=name, namespace=namespace)
self.pod_metadata = ObjectMeta(name=name, namespace=namespace)
self.model["spec"] = {"replicas": replicas, "selector": {"matchLabels": {"name": name}}}
self.model["spec"]["template"] = dict()
if image is not None:
self.pod_spec = PodSpec(name=name, image=image)
else:
self.pod_spec = PodSpec(name=name)
self.pod_spec.set_restart_policy("Always")
self._update_model()
def __init__(self, name=None, image=None, namespace='default', replicas=1, model=None):
PodBasedModel.__init__(self)
if model is not None:
assert isinstance(model, dict)
self.model = model
if 'status' in self.model.keys():
self.model.pop('status', None)
if 'metadata' in self.model.keys():
self.rc_metadata = ObjectMeta(model=self.model['metadata'])
if 'template' in self.model['spec'].keys():
self.pod_spec = PodSpec(model=self.model['spec']['template']['spec'])
self.pod_metadata = ObjectMeta(model=self.model['spec']['template']['metadata'])
else:
if name is None or not isinstance(name, str):
raise SyntaxError('ReplicationController: name should be a string.')
self.model = dict(kind='ReplicationController', apiVersion='v1')
self.rc_metadata = ObjectMeta(name=name, namespace=namespace)
self.model['spec'] = {
"replicas": replicas,
"selector": dict(name=name)
}
self.model['spec']['template'] = dict()
if image is not None:
self.pod_spec = PodSpec(name=name, image=image)
else:
self.pod_spec = PodSpec(name=name)
self.pod_spec.set_restart_policy('Always')
self.pod_metadata = ObjectMeta(name=name, namespace=namespace)
self._update_model()
def _build_with_model(self, model=None):
super(Pod, self).build_with_model(model)
if 'spec' in model:
self.spec = PodSpec(model['spec'])
if 'status' in model:
self.status = PodStatus(model['status'])
def _build_with_model(self, model=None):
if 'kind' in model:
self.kind = model['kind']
if 'apiVersion' in model:
self.api_version = model['apiVersion']
if 'metadata' in model:
self.metadata = ObjectMeta(model['metadata'])
if 'spec' in model:
self.spec = PodSpec(model['spec'])
if 'status' in model:
self.status = PodStatus(model['status'])
def __init__(self, model=None):
super(Pod, self).__init__()
self.kind = 'Pod'
self.api_version = 'v1'
self.spec = PodSpec()
self.status = PodStatus()
if model is not None:
m = filter_model(model)
self._build_with_model(m)
def _build_with_model(self, model=None):
super(Pod, self).build_with_model(model)
if 'spec' in model:
self.spec = PodSpec(model['spec'])
if 'status' in model:
self.status = PodStatus(model['status'])
class Pod(BaseModel):
"""
http://kubernetes.io/docs/api-reference/v1/definitions/#_v1_pod
"""
def __init__(self, model=None):
super(Pod, self).__init__()
self.kind = 'Pod'
self.api_version = 'v1'
self.spec = PodSpec()
self.status = PodStatus()
if model is not None:
m = filter_model(model)
self._build_with_model(m)
def _build_with_model(self, model=None):
super(Pod, self).build_with_model(model)
if 'spec' in model:
self.spec = PodSpec(model['spec'])
if 'status' in model:
self.status = PodStatus(model['status'])
# ------------------------------------------------------------------------------------- spec
@property
def spec(self):
return self._spec
@spec.setter
def spec(self, spec=None):
if not isinstance(spec, PodSpec):
raise SyntaxError('Pod: spec: [ {0} ] is invalid.'.format(spec))
self._spec = spec
# ------------------------------------------------------------------------------------- status
@property
def status(self):
return self._status
@status.setter
def status(self, status=None):
if not isinstance(status, PodStatus):
raise SyntaxError(
'Pod: status: [ {0} ] is invalid.'.format(status))
self._status = status
# ------------------------------------------------------------------------------------- serialize
def serialize(self):
data = super(Pod, self).serialize()
if self.spec is not None:
data['spec'] = self.spec.serialize()
if self.status is not None:
data['status'] = self.status.serialize()
return data
def __init__(self, model=None):
super(PodTemplateSpec, self).__init__()
self._metadata = ObjectMeta()
self._spec = PodSpec()
if model is not None:
self._build_with_model(model)
def __init__(self, name=None, image=None, namespace='default', model=None):
PodBasedModel.__init__(self)
if model is not None:
self.model = model
if 'status' in self.model.keys():
self.pod_status = PodStatus(model=self.model['status'])
self.pod_spec = PodSpec(model=self.model['spec'])
self.pod_metadata = ObjectMeta(model=self.model['metadata'])
else:
if name is None or not isinstance(name, str):
raise SyntaxError('name should be a string.')
self.model = dict(kind='Pod', apiVersion='v1')
if name is not None:
self.pod_metadata = ObjectMeta(name=name, namespace=namespace)
self.pod_spec = PodSpec(name=name, image=image)
self.pod_spec.set_restart_policy('Always')
self._update_model()
class PodTemplateSpec(object):
"""
http://kubernetes.io/docs/api-reference/v1/definitions/#_v1_podtemplatespec
"""
def __init__(self, model=None):
super(PodTemplateSpec, self).__init__()
self._metadata = ObjectMeta()
self._spec = PodSpec()
if model is not None:
self._build_with_model(model)
def _build_with_model(self, model=None):
if 'metadata' in model:
self.metadata = ObjectMeta(model['metadata'])
if 'spec' in model:
self.spec = PodSpec(model['spec'])
# ------------------------------------------------------------------------------------- metadata
@property
def metadata(self):
return self._metadata
@metadata.setter
def metadata(self, metadata=None):
if not isinstance(metadata, ObjectMeta):
raise SyntaxError(
'PodTemplateSpec: metadata: [ {0} ] is invalid'.format(
metadata))
self._metadata = metadata
# ------------------------------------------------------------------------------------- spec
@property
def spec(self):
return self._spec
@spec.setter
def spec(self, spec=None):
if not isinstance(spec, PodSpec):
raise SyntaxError(
'PodTemplateSpec: spec: [ {0} ] is invalid'.format(spec))
self._spec = spec
# ------------------------------------------------------------------------------------- serialize
def serialize(self):
data = {}
if self.metadata is not None:
data['metadata'] = self.metadata.serialize()
if self.spec is not None:
data['spec'] = self.spec.serialize()
return data
def __init__(self, model=None):
super(Pod, self).__init__()
self.kind = 'Pod'
self.api_version = 'v1'
self.spec = PodSpec()
self.status = PodStatus()
if model is not None:
m = filter_model(model)
self._build_with_model(m)
class PodTemplateSpec(object):
"""
http://kubernetes.io/docs/api-reference/v1/definitions/#_v1_podtemplatespec
"""
def __init__(self, model=None):
super(PodTemplateSpec, self).__init__()
self._metadata = ObjectMeta()
self._spec = PodSpec()
if model is not None:
self._build_with_model(model)
def _build_with_model(self, model=None):
if 'metadata' in model:
self.metadata = ObjectMeta(model['metadata'])
if 'spec' in model:
self.spec = PodSpec(model['spec'])
# ------------------------------------------------------------------------------------- metadata
@property
def metadata(self):
return self._metadata
@metadata.setter
def metadata(self, metadata=None):
if not isinstance(metadata, ObjectMeta):
raise SyntaxError('PodTemplateSpec: metadata: [ {0} ] is invalid'.format(metadata))
self._metadata = metadata
# ------------------------------------------------------------------------------------- spec
@property
def spec(self):
return self._spec
@spec.setter
def spec(self, spec=None):
if not isinstance(spec, PodSpec):
raise SyntaxError('PodTemplateSpec: spec: [ {0} ] is invalid'.format(spec))
self._spec = spec
# ------------------------------------------------------------------------------------- serialize
def serialize(self):
data = {}
if self.metadata is not None:
data['metadata'] = self.metadata.serialize()
if self.spec is not None:
data['spec'] = self.spec.serialize()
return data
def __init__(self, name=None, image=None, namespace="default", model=None):
PodBasedModel.__init__(self)
if model is not None:
self.model = model
if "status" in self.model.keys():
self.pod_status = PodStatus(model=self.model["status"])
self.pod_spec = PodSpec(model=self.model["spec"])
self.pod_metadata = ObjectMeta(model=self.model["metadata"])
else:
if name is None or not isinstance(name, str):
raise SyntaxError("name should be a string.")
self.model = dict(kind="Pod", apiVersion="v1")
if name is not None:
self.pod_metadata = ObjectMeta(name=name, namespace=namespace)
self.pod_spec = PodSpec(name=name, image=image)
self.pod_spec.set_restart_policy("Always")
self._update_model()
def __init__(self, name=None, image=None, namespace='default', replicas=1, model=None):
super(ReplicationController, self).__init__()
if model is not None:
self.model = model
if 'status' in self.model:
self.model.pop('status', None)
if 'metadata' in self.model:
self.rc_metadata = ObjectMeta(model=self.model['metadata'])
if 'template' in self.model['spec']:
self.pod_spec = PodSpec(model=self.model['spec']['template']['spec'])
self.pod_metadata = ObjectMeta(model=self.model['spec']['template']['metadata'])
else:
if name is None:
raise SyntaxError('ReplicationController: name: [ {0} ] cannot be None.'.format(name))
if not isinstance(name, str):
raise SyntaxError('ReplicationController: name: [ {0} ] must be a string.'.format(name))
self.model = dict(kind='ReplicationController', apiVersion='v1')
self.rc_metadata = ObjectMeta(name=name, namespace=namespace)
self.pod_metadata = ObjectMeta(name=name, namespace=namespace)
self.model['spec'] = {
"replicas": replicas,
"selector": dict(name=name)
}
self.model['spec']['template'] = dict()
if image is not None:
self.pod_spec = PodSpec(name=name, image=image)
else:
self.pod_spec = PodSpec(name=name)
self.pod_spec.set_restart_policy('Always')
self._update_model()
class PodBasedModel(BaseModel):
def __init__(self):
BaseModel.__init__(self)
self.pod_spec = PodSpec()
self.pod_metadata = ObjectMeta()
self.pod_status = None
def _update_model(self):
self.model['metadata'] = self.pod_metadata.get()
self.model['spec'] = self.pod_spec.get()
if self.pod_status is not None:
self.model['status'] = self.pod_status.get()
return self
# ------------------------------------------------------------------------------------- add
def add_container(self, container):
try:
assert isinstance(container, Container)
self.pod_spec.add_container(container=container)
except:
raise
return self
def add_host_volume(self, name, path):
try:
self.pod_spec.add_host_volume(name=name, path=path)
except:
raise
return self
def add_emptydir_volume(self, name):
try:
self.pod_spec.add_emptydir_volume(name=name)
except:
raise
return self
def add_image_pull_secrets(self, name):
try:
self.pod_spec.add_image_pull_secrets(name=name)
except:
raise
return self
def add_pod_annotation(self, k=None, v=None):
try:
self.pod_metadata.add_annotation(k=k, v=v)
except:
raise
return self
def add_pod_label(self, k=None, v=None):
try:
self.pod_metadata.add_label(k=k, v=v)
except:
raise
return self
# ------------------------------------------------------------------------------------- delete
def del_pod_annotation(self, k):
self.pod_metadata.del_annotation(k=k)
return self
def del_pod_label(self, k):
self.pod_metadata.del_label(k=k)
return self
def del_pod_node_name(self):
self.pod_spec.del_node_name()
return self
# ------------------------------------------------------------------------------------- get
def get_pod_annotation(self, k):
return self.pod_metadata.get_annotation(k=k)
def get_pod_annotations(self):
return self.pod_metadata.get_annotations()
def get_pod_containers(self):
my_list = list()
for c in self.pod_spec.get_containers():
assert isinstance(c, Container)
my_list.append(c.get())
return my_list
def get_pod_label(self, k):
return self.pod_metadata.get_label(k=k)
def get_pod_labels(self):
return self.pod_metadata.get_labels()
def get_pod_name(self):
return self.pod_metadata.get_name()
def get_pod_namespace(self):
return self.pod_metadata.get_namespace()
def get_pod_node_name(self):
return self.pod_spec.get_node_name()
def get_pod_node_selector(self):
return self.pod_spec.get_node_selector()
def get_pod_restart_policy(self):
return self.pod_spec.get_restart_policy()
def get_pod_status(self):
return self.pod_status
def get_service_account(self):
return self.pod_spec.get_service_account()
def get_termination_grace_period(self):
return self.pod_spec.get_termination_grace_period()
# ------------------------------------------------------------------------------------- set
def set_active_deadline(self, seconds):
try:
self.pod_spec.set_active_deadline(seconds)
except:
raise
return self
def set_dns_policy(self, policy):
try:
self.pod_spec.set_dns_policy(policy=policy)
except:
raise
return self
def set_pod_annotations(self, new_dict):
self.pod_metadata.set_annotations(dico=new_dict)
return self
def set_pod_generate_name(self, mode, name):
assert isinstance(mode, bool)
if name is not None:
assert isinstance(name, str)
self.pod_metadata.set_generate_name(mode=mode, name=name)
return self
def set_pod_labels(self, dico):
self.pod_metadata.set_labels(dico=dico)
return self
def set_pod_image(self, name, image):
assert isinstance(name, str)
assert isinstance(image, str)
self.pod_spec.set_image(name=name, image=image)
def set_pod_name(self, name=None):
assert isinstance(name, str)
try:
self.pod_metadata.set_name(name=name)
except:
raise
return self
def set_pod_namespace(self, name=None):
try:
self.pod_metadata.set_namespace(name=name)
except:
raise
return self
def set_pod_node_name(self, name):
self.pod_spec.set_node_name(name=name)
return self
def set_pod_node_selector(self, new_dict):
self.pod_spec.set_node_selector(dico=new_dict)
return self
def set_pod_restart_policy(self, policy):
try:
self.pod_spec.set_restart_policy(policy=policy)
except:
raise
return self
def set_service_account(self, name):
try:
self.pod_spec.set_service_account(name=name)
except:
raise
return self
def set_termination_grace_period(self, seconds=None):
try:
self.pod_spec.set_termination_grace_period(seconds=seconds)
except:
raise
return self
def __init__(self):
BaseModel.__init__(self)
self.pod_spec = PodSpec()
self.pod_metadata = ObjectMeta()
self.pod_status = None
class PodBasedModel(BaseModel):
def __init__(self):
BaseModel.__init__(self)
self.pod_spec = PodSpec()
self.pod_metadata = ObjectMeta()
self.pod_status = None
def _update_model(self):
self.model['metadata'] = self.pod_metadata.get()
self.model['spec'] = self.pod_spec.get()
if self.pod_status is not None:
self.model['status'] = self.pod_status.get()
return self
# ------------------------------------------------------------------------------------- add
def add_container(self, container):
self.pod_spec.add_container(container=container)
self._update_model()
return self
def add_volume(self, volume=None):
self.pod_spec.add_volume(volume)
self._update_model()
return self
def add_image_pull_secrets(self, name):
self.pod_spec.add_image_pull_secrets(name=name)
self._update_model()
return self
def add_pod_annotation(self, k=None, v=None):
self.pod_metadata.add_annotation(k=k, v=v)
self._update_model()
return self
def add_pod_label(self, k=None, v=None):
self.pod_metadata.add_label(k=k, v=v)
self._update_model()
return self
# ------------------------------------------------------------------------------------- delete
def del_pod_annotation(self, k):
self.pod_metadata.del_annotation(k=k)
self._update_model()
return self
def del_pod_label(self, k):
self.pod_metadata.del_label(k=k)
self._update_model()
return self
def del_pod_node_name(self):
self.pod_spec.del_node_name()
self._update_model()
return self
# ------------------------------------------------------------------------------------- get
def get_pod_annotation(self, k):
return self.pod_metadata.get_annotation(k=k)
def get_pod_annotations(self):
return self.pod_metadata.get_annotations()
def get_pod_containers(self):
my_list = list()
for c in self.pod_spec.get_containers():
assert isinstance(c, Container)
my_list.append(c.get())
return my_list
def get_pod_label(self, k):
return self.pod_metadata.get_label(k=k)
def get_pod_labels(self):
return self.pod_metadata.get_labels()
def get_pod_name(self):
return self.pod_metadata.get_name()
def get_pod_namespace(self):
return self.pod_metadata.get_namespace()
def get_pod_node_name(self):
return self.pod_spec.get_node_name()
def get_pod_node_selector(self):
return self.pod_spec.get_node_selector()
def get_pod_restart_policy(self):
return self.pod_spec.get_restart_policy()
def get_pod_status(self):
return self.pod_status
def get_service_account(self):
return self.pod_spec.get_service_account()
def get_termination_grace_period(self):
return self.pod_spec.get_termination_grace_period()
# ------------------------------------------------------------------------------------- set
def set_active_deadline(self, seconds=None):
self.pod_spec.set_active_deadline(seconds)
self._update_model()
return self
def set_dns_policy(self, policy=None):
self.pod_spec.set_dns_policy(policy)
self._update_model()
return self
def set_pod_annotations(self, annotations=None):
self.pod_metadata.set_annotations(annotations)
self._update_model()
return self
def set_pod_generate_name(self, mode=None, name=None):
self.pod_metadata.set_generate_name(mode=mode, name=name)
self._update_model()
return self
def set_pod_labels(self, labels=None):
self.pod_metadata.set_labels(labels)
self._update_model()
return self
def set_pod_image(self, name=None, image=None):
self.pod_spec.set_container_image(name=name, image=image)
self._update_model()
def set_pod_name(self, name=None):
self.pod_metadata.set_name(name=name)
self._update_model()
return self
def set_pod_namespace(self, namespace=None):
self.pod_metadata.set_namespace(namespace)
self._update_model()
return self
def set_pod_node_name(self, name=None):
self.pod_spec.set_node_name(name)
self._update_model()
return self
def set_pod_node_selector(self, selector=None):
self.pod_spec.set_node_selector(selector)
self._update_model()
return self
def set_pod_restart_policy(self, policy=None):
self.pod_spec.set_restart_policy(policy)
self._update_model()
return self
def set_service_account(self, name=None):
self.pod_spec.set_service_account(name)
self._update_model()
return self
def set_termination_grace_period(self, seconds=None):
self.pod_spec.set_termination_grace_period(seconds)
self._update_model()
return self
class Pod(BaseModel):
"""
http://kubernetes.io/docs/api-reference/v1/definitions/#_v1_pod
"""
def __init__(self, model=None):
super(Pod, self).__init__()
self.kind = 'Pod'
self.api_version = 'v1'
self.spec = PodSpec()
self.status = PodStatus()
if model is not None:
m = filter_model(model)
self._build_with_model(m)
def _build_with_model(self, model=None):
super(Pod, self).build_with_model(model)
if 'spec' in model:
self.spec = PodSpec(model['spec'])
if 'status' in model:
self.status = PodStatus(model['status'])
# ------------------------------------------------------------------------------------- spec
@property
def spec(self):
return self._spec
@spec.setter
def spec(self, spec=None):
if not isinstance(spec, PodSpec):
raise SyntaxError(
'Pod: spec: [ {0} ] is invalid.'.format(spec))
self._spec = spec
# ------------------------------------------------------------------------------------- status
@property
def status(self):
return self._status
@status.setter
def status(self, status=None):
if not isinstance(status, PodStatus):
raise SyntaxError(
'Pod: status: [ {0} ] is invalid.'.format(status))
self._status = status
# ------------------------------------------------------------------------------------- serialize
def serialize(self):
data = super(Pod, self).serialize()
if self.spec is not None:
data['spec'] = self.spec.serialize()
if self.status is not None:
data['status'] = self.status.serialize()
return data
class ReplicationController(PodBasedModel):
def __init__(self, name=None, image=None, namespace='default', replicas=1, model=None):
PodBasedModel.__init__(self)
if model is not None:
assert isinstance(model, dict)
self.model = model
if 'status' in self.model.keys():
self.model.pop('status', None)
if 'metadata' in self.model.keys():
self.rc_metadata = ObjectMeta(model=self.model['metadata'])
if 'template' in self.model['spec'].keys():
self.pod_spec = PodSpec(model=self.model['spec']['template']['spec'])
self.pod_metadata = ObjectMeta(model=self.model['spec']['template']['metadata'])
else:
if name is None or not isinstance(name, str):
raise SyntaxError('ReplicationController: name should be a string.')
self.model = dict(kind='ReplicationController', apiVersion='v1')
self.rc_metadata = ObjectMeta(name=name, namespace=namespace)
self.model['spec'] = {
"replicas": replicas,
"selector": dict(name=name)
}
self.model['spec']['template'] = dict()
if image is not None:
self.pod_spec = PodSpec(name=name, image=image)
else:
self.pod_spec = PodSpec(name=name)
self.pod_spec.set_restart_policy('Always')
self.pod_metadata = ObjectMeta(name=name, namespace=namespace)
self._update_model()
def _update_model(self):
self.model['metadata'] = self.rc_metadata.get()
if self.pod_metadata is not None:
if 'template' not in self.model['spec'].keys():
self.model['spec']['template'] = dict()
self.model['spec']['template']['metadata'] = self.pod_metadata.get()
if self.pod_spec is not None:
if 'template' not in self.model['spec'].keys():
self.model['spec']['template'] = dict()
self.model['spec']['template']['spec'] = self.pod_spec.get()
return self
def add_label(self, k, v):
assert isinstance(k, str)
assert isinstance(v, str)
self.rc_metadata.add_label(k=k, v=v)
return self
def add_annotation(self, k, v):
assert isinstance(k, str)
assert isinstance(v, str)
self.rc_metadata.add_annotation(k=k, v=v)
return self
def del_annotation(self, k):
assert isinstance(k, str)
self.rc_metadata.del_annotation(k=k)
return self
def del_label(self, k):
assert isinstance(k, str)
self.rc_metadata.del_label(k=k)
return self
def get_annotation(self, k):
assert isinstance(k, str)
return self.rc_metadata.get_annotation(k=k)
def get_annotations(self):
return self.rc_metadata.get_annotations()
def get_label(self, k):
assert isinstance(k, str)
return self.rc_metadata.get_label(k=k)
def get_labels(self):
return self.rc_metadata.get_labels()
def get_name(self):
return self.rc_metadata.get_name()
def get_namespace(self):
return self.rc_metadata.get_namespace()
def get_replicas(self):
my_replicas = self.model['spec']['replicas']
return my_replicas
def get_selector(self):
return self.model['spec']['selector']
def set_annotations(self, new_dict):
assert isinstance(new_dict, dict)
self.rc_metadata.set_annotations(new_dict=new_dict)
return self
def set_labels(self, new_dict):
assert isinstance(new_dict, dict)
self.rc_metadata.set_labels(new_dict=new_dict)
return self
def set_name(self, name):
assert isinstance(name, str)
self.rc_metadata.set_name(name=name)
return self
def set_namespace(self, name):
assert isinstance(name, str)
self.rc_metadata.set_namespace(name=name)
self.pod_metadata.set_namespace(name=name)
return self
def set_replicas(self, replicas=None):
if replicas is None or not isinstance(replicas, int):
raise SyntaxError('ReplicationController: replicas should be a positive integer value')
self.model['spec']['replicas'] = replicas
return self
def set_selector(self, selector=None):
if selector is None or not isinstance(selector, dict):
raise SyntaxError('ReplicationController: Selector should be a dict of key, value pairs.')
self.model['spec']['selector'] = selector
return self
class Deployment(PodBasedModel):
def __init__(self, name=None, image=None, namespace="default", replicas=0, model=None):
PodBasedModel.__init__(self)
if model is not None:
self.model = model
# if 'status' in self.model:
# self.model.pop('status', None)
if "metadata" in self.model:
self.deployment_metadata = ObjectMeta(model=self.model["metadata"])
if "template" in self.model["spec"]:
self.pod_spec = PodSpec(model=self.model["spec"]["template"]["spec"])
self.pod_metadata = ObjectMeta(model=self.model["spec"]["template"]["metadata"])
else:
if name is None:
raise SyntaxError("Deployment: name: [ {0} ] cannot be None.".format(name))
if not isinstance(name, str):
raise SyntaxError("Deployment: name: [ {0} ] must be a string.".format(name))
self.model = dict(kind="Deployment", apiVersion=API_VERSION)
self.deployment_metadata = ObjectMeta(name=name, namespace=namespace)
self.pod_metadata = ObjectMeta(name=name, namespace=namespace)
self.model["spec"] = {"replicas": replicas, "selector": {"matchLabels": {"name": name}}}
self.model["spec"]["template"] = dict()
if image is not None:
self.pod_spec = PodSpec(name=name, image=image)
else:
self.pod_spec = PodSpec(name=name)
self.pod_spec.set_restart_policy("Always")
self._update_model()
def _update_model(self):
self.model["metadata"] = self.deployment_metadata.get()
if self.pod_metadata is not None:
if "template" not in self.model["spec"]:
self.model["spec"]["template"] = dict()
self.model["spec"]["template"]["metadata"] = self.pod_metadata.get()
if self.pod_spec is not None:
if "template" not in self.model["spec"]:
self.model["spec"]["template"] = dict()
self.model["spec"]["template"]["spec"] = self.pod_spec.get()
return self
# ------------------------------------------------------------------------------------- get
def get_name(self):
return self.deployment_metadata.get_name()
def get_labels(self):
return self.deployment_metadata.get_labels()
def get_namespace(self):
return self.deployment_metadata.get_namespace()
# ------------------------------------------------------------------------------------- set
def set_labels(self, dico=None):
if dico is None:
raise SyntaxError("Deployment: dico: [ {0} ] cannot be None.".format(dico))
if not isinstance(dico, dict):
raise SyntaxError("Deployment: dico: [ {0} ] must be a dict.".format(dico))
self.deployment_metadata.set_labels(labels=dico)
return self
def set_namespace(self, name=None):
if name is None:
raise SyntaxError("Deployment: name: [ {0} ] cannot be None.".format(name))
if not isinstance(name, str):
raise SyntaxError("Deployment: dico: [ {0} ] must be a string.".format(name))
self.deployment_metadata.set_namespace(namespace=name)
self.pod_metadata.set_namespace(namespace=name)
return self
def set_replicas(self, replicas=None):
if replicas is None:
raise SyntaxError("Deployment: replicas: [ {0} ] cannot be None.".format(replicas))
if not isinstance(replicas, int) or replicas < 0:
raise SyntaxError("Deployment: replicas: [ {0} ] must be a positive integer.".format(replicas))
self.model["spec"]["replicas"] = replicas
return self
def set_selector(self, dico=None):
if dico is None:
raise SyntaxError("Deployment: dico: [ {0} ] cannot be None.".format(dico))
if not isinstance(dico, dict):
raise SyntaxError("Deployment: dico: [ {0} ] must be a dict.".format(dico))
self.model["spec"]["selector"] = dico
return self
def _build_with_model(self, model=None):
if 'metadata' in model:
self.metadata = ObjectMeta(model['metadata'])
if 'spec' in model:
self.spec = PodSpec(model['spec'])
def _build_with_model(self, model=None):
if 'metadata' in model:
self.metadata = ObjectMeta(model['metadata'])
if 'spec' in model:
self.spec = PodSpec(model['spec'])
class ReplicationController(PodBasedModel):
def __init__(self, name=None, image=None, namespace='default', replicas=1, model=None):
super(ReplicationController, self).__init__()
if model is not None:
self.model = model
if 'status' in self.model:
self.model.pop('status', None)
if 'metadata' in self.model:
self.rc_metadata = ObjectMeta(model=self.model['metadata'])
if 'template' in self.model['spec']:
self.pod_spec = PodSpec(model=self.model['spec']['template']['spec'])
self.pod_metadata = ObjectMeta(model=self.model['spec']['template']['metadata'])
else:
if name is None:
raise SyntaxError('ReplicationController: name: [ {0} ] cannot be None.'.format(name))
if not isinstance(name, str):
raise SyntaxError('ReplicationController: name: [ {0} ] must be a string.'.format(name))
self.model = dict(kind='ReplicationController', apiVersion='v1')
self.rc_metadata = ObjectMeta(name=name, namespace=namespace)
self.pod_metadata = ObjectMeta(name=name, namespace=namespace)
self.model['spec'] = {
"replicas": replicas,
"selector": dict(name=name)
}
self.model['spec']['template'] = dict()
if image is not None:
self.pod_spec = PodSpec(name=name, image=image)
else:
self.pod_spec = PodSpec(name=name)
self.pod_spec.set_restart_policy('Always')
self._update_model()
def _update_model(self):
self.model['metadata'] = self.rc_metadata.get()
if self.pod_metadata is not None:
if 'template' not in self.model['spec']:
self.model['spec']['template'] = dict()
self.model['spec']['template']['metadata'] = self.pod_metadata.get()
if self.pod_spec is not None:
if 'template' not in self.model['spec']:
self.model['spec']['template'] = dict()
self.model['spec']['template']['spec'] = self.pod_spec.get()
return self
# ------------------------------------------------------------------------------------- add
def add_label(self, k=None, v=None):
if k is None or v is None:
raise SyntaxError('ReplicationController: k: [ {0} ] or v: [ {1} ] cannot be None.'.format(k, v))
if not isinstance(k, str) or not isinstance(v, str):
raise SyntaxError('ReplicationController: k: [ {0} ] or v: [ {1} ] must be a string.'.format(k, v))
self.rc_metadata.add_label(k=k, v=v)
return self
def add_annotation(self, k=None, v=None):
if k is None or v is None:
raise SyntaxError('ReplicationController: k: [ {0} ] or v: [ {1} ] cannot be None.'.format(k, v))
if not isinstance(k, str) or not isinstance(v, str):
raise SyntaxError('ReplicationController: k: [ {0} ] or v: [ {1} ] must be a string.'.format(k, v))
self.rc_metadata.add_annotation(k=k, v=v)
return self
# ------------------------------------------------------------------------------------- del
def del_annotation(self, k=None):
if k is None:
raise SyntaxError('ReplicationController: k: [ {0} ] cannot be None.'.format(k))
if not isinstance(k, str):
raise SyntaxError('ReplicationController: k: [ {0} ] must be a string.'.format(k))
self.rc_metadata.del_annotation(k=k)
return self
def del_label(self, k=None):
if k is None:
raise SyntaxError('ReplicationController: k: [ {0} ] cannot be None.'.format(k))
if not isinstance(k, str):
raise SyntaxError('ReplicationController: k: [ {0} ] must be a string.'.format(k))
self.rc_metadata.del_label(k=k)
return self
# ------------------------------------------------------------------------------------- get
def get_annotation(self, k=None):
if k is None:
raise SyntaxError('ReplicationController: k: [ {0} ] cannot be None.'.format(k))
if not isinstance(k, str):
raise SyntaxError('ReplicationController: k: [ {0} ] must be a string.'.format(k))
return self.rc_metadata.get_annotation(k=k)
def get_annotations(self):
return self.rc_metadata.get_annotations()
def get_label(self, k=None):
if k is None:
raise SyntaxError('ReplicationController: k: [ {0} ] cannot be None.'.format(k))
if not isinstance(k, str):
raise SyntaxError('ReplicationController: k: [ {0} ] must be a string.'.format(k))
return self.rc_metadata.get_label(k=k)
def get_labels(self):
return self.rc_metadata.get_labels()
def get_name(self):
return self.rc_metadata.get_name()
def get_namespace(self):
return self.rc_metadata.get_namespace()
def get_replicas(self):
return self.model['spec']['replicas']
def get_selector(self):
return self.model['spec']['selector']
# ------------------------------------------------------------------------------------- set
def set_annotations(self, dico=None):
if dico is None:
raise SyntaxError('ReplicationController: dico: [ {0} ] cannot be None.'.format(dico))
if not isinstance(dico, dict):
raise SyntaxError('ReplicationController: dico: [ {0} ] must be a dict.'.format(dico))
self.rc_metadata.set_annotations(dico=dico)
return self
def set_labels(self, dico=None):
if dico is None:
raise SyntaxError('ReplicationController: dico: [ {0} ] cannot be None.'.format(dico))
if not isinstance(dico, dict):
raise SyntaxError('ReplicationController: dico: [ {0} ] must be a dict.'.format(dico))
self.rc_metadata.set_labels(labels=dico)
return self
def set_name(self, name=None):
if name is None:
raise SyntaxError('ReplicationController: name: [ {0} ] cannot be None.'.format(name))
if not isinstance(name, str):
raise SyntaxError('ReplicationController: dico: [ {0} ] must be a string.'.format(name))
self.rc_metadata.set_name(name=name)
return self
def set_namespace(self, name=None):
if name is None:
raise SyntaxError('ReplicationController: name: [ {0} ] cannot be None.'.format(name))
if not isinstance(name, str):
raise SyntaxError('ReplicationController: dico: [ {0} ] must be a string.'.format(name))
self.rc_metadata.set_namespace(namespace=name)
self.pod_metadata.set_namespace(namespace=name)
return self
def set_replicas(self, replicas=None):
if replicas is None:
raise SyntaxError('ReplicationController: replicas: [ {0} ] cannot be None.'.format(replicas))
if not isinstance(replicas, int) or replicas < 0:
raise SyntaxError('ReplicationController: replicas: [ {0} ] must be a positive integer.'.format(replicas))
self.model['spec']['replicas'] = replicas
return self
def set_selector(self, dico=None):
if dico is None:
raise SyntaxError('ReplicationController: dico: [ {0} ] cannot be None.'.format(dico))
if not isinstance(dico, dict):
raise SyntaxError('ReplicationController: dico: [ {0} ] must be a dict.'.format(dico))
self.model['spec']['selector'] = dico
return self
