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):
if 'apiVersion' in model:
self.api_version = model['apiVersion']
if 'kind' in model:
self.kind = model['kind']
if 'metadata' in model:
self.metadata = ObjectMeta(model['metadata'])
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 'provisioner' in model:
self.provisioner = model['provisioner']
if 'parameters' in model:
self.parameters = model['parameters']
def __init__(self, name=None, namespace='default', model=None):
BaseModel.__init__(self)
if model is not None:
assert isinstance(model, dict)
if 'status' in self.model.keys():
self.model.pop('status', None)
self.model = model
self.secret_metadata = ObjectMeta(model=self.model['metadata'])
else:
if name is None or not isinstance(name, str):
raise SyntaxError('name must be a string.')
self.model = dict(kind='Secret', apiVersion='v1')
self.secret_metadata = ObjectMeta(name=name, namespace=namespace)
self._update_model()
def build_with_model(self, model=None):
if 'apiVersion' in model:
self.api_version = model['apiVersion']
if 'kind' in model:
self.kind = model['kind']
if 'metadata' in model:
self.metadata = ObjectMeta(model['metadata'])
def __init__(self, model=None):
super(CronJobTemplate, self).__init__()
self._metadata = ObjectMeta()
self._spec = JobSpec()
if model is not None:
self._build_with_model(model)
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):
super(BaseModel, self).__init__()
self._api_version = None
self._kind = None
self._metadata = ObjectMeta()
self._spec = None
self._status = None
def __init__(self, name=None, namespace='default', port_name=None, port=0,
target_port=None, selector=None, session_affinity='None', model=None):
BaseModel.__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)
self.svc_metadata = ObjectMeta(model=self.model['metadata'], del_server_attr=False)
else:
self.model = dict(kind='Service', apiVersion='v1')
self.svc_metadata = ObjectMeta(name=name, namespace=namespace)
self.model['spec'] = dict(ports=[], selector=dict(), sessionAffinity=session_affinity, type='ClusterIP')
if port_name is not None and port > 0 and target_port is not None:
self.add_port(port=port, target_port=target_port, name=port_name)
if selector is not None:
self.add_selector(selector=selector)
self._update_model()
def _build_with_model(self, model=None):
super(HorizontalPodAutoscaler, self).build_with_model(model)
if 'metadata' in model:
self.metadata = ObjectMeta(model['metadata'])
if 'spec' in model:
self.spec = HorizontalPodAutoscalerSpec(model['spec'])
if 'status' in model:
self.status = HorizontalPodAutoscalerStatus(model['status'])
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(StorageClass, self).__init__()
self._kind = 'StorageClass'
self._api_version = 'storage.k8s.io/v1beta1'
self._metadata = ObjectMeta()
self._provisioner = None
self._parameters = None
if model is not None:
self._build_with_model(model)
def __init__(self, model=None):
super(BaseModel, self).__init__()
self._api_version = None
self._kind = None
self._metadata = ObjectMeta()
self._spec = None
self._status = None
if model is not None:
self.build_with_model(model)
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 = NodeSpec(model['spec'])
if 'status' in model:
self.status = NodeStatus(model['status'])
def __init__(self, model=None):
super(HorizontalPodAutoscaler, self).__init__()
self.kind = 'HorizontalPodAutoscaler'
self.api_version = 'autoscaling/v1'
self.metadata = ObjectMeta()
self.spec = HorizontalPodAutoscalerSpec()
self.status = HorizontalPodAutoscalerStatus()
if model is not None:
self._build_with_model(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, name=None, namespace='default', model=None):
BaseModel.__init__(self)
if name is None:
raise SyntaxError('Secret: name: [ {0} ] cannot be None.'.format(name))
if not isinstance(name, str):
raise SyntaxError('Secret: name: [ {0} ] must be a string.'.format(name))
if model is not None and not isinstance(model, dict):
raise SyntaxError('Secret: model: [ {0} ] must be a dict.'.format(model))
if model is not None:
if 'status' in self.model:
self.model.pop('status', None)
self.model = model
self.secret_metadata = ObjectMeta(model=self.model['metadata'])
else:
self.model = dict(kind='Secret', apiVersion='v1')
self.secret_metadata = ObjectMeta(name=name, namespace=namespace)
self._update_model()
class CronJobTemplate(object):
def __init__(self, model=None):
super(CronJobTemplate, self).__init__()
self._metadata = ObjectMeta()
self._spec = JobSpec()
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 = JobSpec(model['spec'])
# ------------------------------------------------------------------------------------- metadata
@property
def metadata(self):
return self._metadata
@metadata.setter
def metadata(self, meta=None):
if not isinstance(meta, ObjectMeta):
raise SyntaxError(
'CronJobTemplate: metadata: [ {} ] is invalid.'.format(meta))
self._metadata = meta
# ------------------------------------------------------------------------------------- spec
@property
def spec(self):
return self._spec
@spec.setter
def spec(self, spec=None):
if not isinstance(spec, JobSpec):
raise SyntaxError(
'CronJobTemplate: spec: [ {} ] 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', 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 _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 'data' in model:
d = {}
for k, v in model['data'].items():
d[k] = base64.b64decode(v)
self.data = d
if 'stringData' in model:
self.string_data = model['stringData']
if 'type' in model:
self.type = model['type']
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 'conditions' in model:
if not isinstance(model['conditions'], list):
raise SyntaxError(
'ComponentStatus: _build_with_model: conditions : [ {0} ] is invalid.'
.format(model['conditions']))
l = list()
for c in model['conditions']:
l.append(ComponentCondition(c))
self.conditions = l
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
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
class Secret(BaseModel):
def __init__(self, name=None, namespace='default', model=None):
BaseModel.__init__(self)
if model is not None:
assert isinstance(model, dict)
if 'status' in self.model.keys():
self.model.pop('status', None)
self.model = model
self.secret_metadata = ObjectMeta(model=self.model['metadata'])
else:
if name is None or not isinstance(name, str):
raise SyntaxError('name must be a string.')
self.model = dict(kind='Secret', apiVersion='v1')
self.secret_metadata = ObjectMeta(name=name, namespace=namespace)
self._update_model()
def _update_model(self):
self.model['metadata'] = self.secret_metadata.get()
return self
def add_label(self, k=None, v=None):
assert isinstance(k, str)
assert isinstance(v, str)
self.secret_metadata.add_label(k=k, v=v)
return self
def add_annotation(self, k=None, v=None):
assert isinstance(k, str)
assert isinstance(v, str)
self.secret_metadata.add_annotation(k=k, v=v)
return self
def get_annotation(self, k):
assert isinstance(k, str)
return self.secret_metadata.get_annotation(k=k)
def get_annotations(self):
return self.secret_metadata.get_annotations()
def get_label(self, k):
assert isinstance(k, str)
return self.secret_metadata.get_label(k=k)
def get_labels(self):
return self.secret_metadata.get_annotations()
def set_annotations(self, new_dict):
assert isinstance(new_dict, dict)
self.secret_metadata.set_annotations(new_dict=new_dict)
return self
def set_data(self, data_key=None, data_value=None):
if data_key is None or data_value is None:
raise SyntaxError('Secret: data_key should be a string and data_value a content')
else:
if 'data' not in self.model.keys():
self.model['data'] = dict()
self.model['data'][data_key] = base64.b64encode(data_value)
return self
def set_dockercfg_secret(self, data=None):
if data is None or not isinstance(data, str):
raise SyntaxError('Secret: data must be a string')
self.set_type(secret_type='kubernetes.io/dockercfg')
self.set_data(data_key='.dockercfg', data_value=data)
return self
def set_dockercfg_json_secret(self, data=None):
if data is None or not isinstance(data, str):
raise SyntaxError('Secret: data must be a string')
self.set_type(secret_type='kubernetes.io/dockerconfigjson')
self.set_data(data_key='.dockerconfigjson', data_value=data)
return self
def set_labels(self, new_dict):
assert isinstance(new_dict, dict)
self.secret_metadata.set_labels(new_dict=new_dict)
return self
def set_service_account_token(self, account_name=None, account_uid=None, token=None,
kubecfg_data=None, cacert=None):
if account_name is None or account_uid is None or token is None \
or not isinstance(account_name, str) or not isinstance(account_uid, str) \
or not isinstance(token, str):
raise SyntaxError('Secret: account_name, account_uid and token must be strings.')
self.set_type(secret_type='kubernetes.io/service-account-token')
self.secret_metadata.add_annotation(k='kubernetes.io/service-account.name', v=account_name)
self.secret_metadata.add_annotation(k='kubernetes.io/service-account.uid', v=account_uid)
self.set_data(data_key='token', data_value=token)
if kubecfg_data is not None:
self.set_data(data_key='kubernetes.kubeconfig', data_value=kubecfg_data)
if cacert is not None:
self.set_data(data_key='ca.crt', data_value=cacert)
return self
def set_type(self, secret_type=None):
if secret_type is None or not isinstance(secret_type, str):
raise SyntaxError('Secret: secret_type must be a string')
self.model['type'] = secret_type
return self
class BaseModel(object):
def __init__(self, model=None):
super(BaseModel, self).__init__()
self._api_version = None
self._kind = None
self._metadata = ObjectMeta()
self._spec = None
self._status = None
if model is not None:
self.build_with_model(model)
def build_with_model(self, model=None):
if 'apiVersion' in model:
self.api_version = model['apiVersion']
if 'kind' in model:
self.kind = model['kind']
if 'metadata' in model:
self.metadata = ObjectMeta(model['metadata'])
def __eq__(self, other):
# see https://github.com/kubernetes/kubernetes/blob/master/docs/design/identifiers.md
if isinstance(other, self.__class__):
return self.metadata.namespace == other.metadata.namespace \
and self.metadata.name == other.metadata.name
return NotImplemented
# ------------------------------------------------------------------------------------- apiVersion
@property
def api_version(self):
return self._api_version
@api_version.setter
def api_version(self, v=None):
if not is_valid_string(v):
raise SyntaxError(
'BaseModel: api_version: [ {} ] is invalid.'.format(v))
self._api_version = v
# ------------------------------------------------------------------------------------- kind
@property
def kind(self):
return self._kind
@kind.setter
def kind(self, k=None):
if not is_valid_string(k):
raise SyntaxError('BaseModel: kind: [ {} ] is invalid.'.format(k))
self._kind = k
# ------------------------------------------------------------------------------------- metadata
@property
def metadata(self):
return self._metadata
@metadata.setter
def metadata(self, meta=None):
if not isinstance(meta, ObjectMeta):
raise SyntaxError(
'BaseModel: metadata: [ {} ] is invalid.'.format(meta))
self._metadata = meta
# ------------------------------------------------------------------------------------- spec
@property
def spec(self):
return self._spec
@spec.setter
def spec(self, s=None):
self._spec = s
# ------------------------------------------------------------------------------------- status
@property
def status(self):
return self._status
@status.setter
def status(self, s=None):
self._status = s
# ------------------------------------------------------------------------------------- name
@property
def name(self):
return self.metadata.name
@name.setter
def name(self, name=None):
if not is_valid_string(name):
raise SyntaxError(
'BaseModel: name: [ {} ] is invalid.'.format(name))
self.metadata.name = name
self.metadata.labels.update({'name': name})
# ------------------------------------------------------------------------------------- serialize
def serialize(self):
data = {}
if self.api_version is not None:
data['apiVersion'] = self.api_version
if self.kind is not None:
data['kind'] = self.kind
if self.metadata is not None:
data['metadata'] = self.metadata.serialize()
return data
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 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 Service(BaseModel):
def __init__(self, name=None, namespace='default', port_name=None, port=0,
target_port=None, selector=None, session_affinity='None', model=None):
BaseModel.__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)
self.svc_metadata = ObjectMeta(model=self.model['metadata'], del_server_attr=False)
else:
self.model = dict(kind='Service', apiVersion='v1')
self.svc_metadata = ObjectMeta(name=name, namespace=namespace)
self.model['spec'] = dict(ports=[], selector=dict(), sessionAffinity=session_affinity, type='ClusterIP')
if port_name is not None and port > 0 and target_port is not None:
self.add_port(port=port, target_port=target_port, name=port_name)
if selector is not None:
self.add_selector(selector=selector)
self._update_model()
def _update_model(self):
self.model['metadata'] = self.svc_metadata.get()
return self
def add_label(self, k, v):
assert isinstance(k, str)
assert isinstance(v, str)
self.svc_metadata.add_label(k=k, v=v)
return self
def add_annotation(self, k, v):
assert isinstance(k, str)
assert isinstance(v, str)
self.svc_metadata.add_annotation(k=k, v=v)
return self
def add_port(self, port, name=None, target_port=None, protocol=None, node_port=None):
my_port = dict()
if port is not None and isinstance(port, int):
my_port['port'] = port
else:
raise SyntaxError('port should be an integer.')
if name is not None:
if isinstance(name, str):
my_port['name'] = name
else:
raise SyntaxError('name should be a string.')
if protocol is not None:
if protocol in ['TCP', 'UDP']:
my_port['protocol'] = protocol
else:
raise SyntaxError('protocol should be TCP or UDP')
if target_port is not None:
if isinstance(target_port, int):
my_port['targetPort'] = target_port
elif isinstance(target_port, str):
my_port['targetPort'] = target_port
else:
raise SyntaxError('target_port should either be a string or an integer')
if node_port is not None:
if isinstance(node_port, int):
my_port['nodePort'] = node_port
else:
raise SyntaxError('node_port should be an integer.')
self.model['spec']['ports'].append(my_port)
return self
def add_selector(self, selector=None):
if (selector is None) or (not isinstance(selector, dict)):
raise SyntaxError('Service: selector should be a dict of string, string.')
if 'selector' not in self.model['spec'].keys():
self.model['spec']['selector'] = dict()
self.model['spec']['selector'].update(selector)
return self
def del_annotation(self, k):
assert isinstance(k, str)
self.svc_metadata.del_annotation(k=k)
return self
def del_label(self, k):
assert isinstance(k, str)
self.svc_metadata.del_label(k=k)
return self
def del_meta_creation_timestamp(self):
self.svc_metadata.del_creation_timestamp()
return self
def del_meta_generation(self):
self.svc_metadata.del_generation()
return self
def del_meta_resource_version(self):
self.svc_metadata.del_resource_version()
return self
def del_meta_self_link(self):
self.svc_metadata.del_self_link()
return self
def del_meta_uid(self):
self.svc_metadata.del_uid()
return self
def del_server_generated_meta_attr(self):
return self.svc_metadata.del_server_generated_meta_attr()
def get_annotation(self, k):
assert isinstance(k, str)
return self.svc_metadata.get_annotation(k=k)
def get_annotations(self):
return self.svc_metadata.get_annotations()
def get_cluster_ip(self):
return self.model['spec']['clusterIP']
def get_label(self, k):
assert isinstance(k, str)
return self.svc_metadata.get_label(k=k)
def get_labels(self):
return self.svc_metadata.get_annotations()
def get_name(self):
return self.svc_metadata.get_name()
def get_namespace(self):
return self.svc_metadata.get_namespace()
def get_meta_creation_timestamp(self):
return self.svc_metadata.get_creation_timestamp()
def get_meta_generation(self):
return self.svc_metadata.get_generation()
def get_meta_resource_version(self):
return self.svc_metadata.get_resource_version()
def get_meta_self_link(self):
return self.svc_metadata.get_self_link()
def get_meta_uid(self):
return self.svc_metadata.get_uid()
def set_annotations(self, new_dict):
assert isinstance(new_dict, dict)
self.svc_metadata.set_annotations(new_dict=new_dict)
return self
def set_cluster_ip(self, ip=None):
if ip is not None:
self.model['spec']['clusterIP'] = ip
return self
def set_external_ip(self, ips=None):
if ips is None or not isinstance(ips, list):
raise SyntaxError('Service: ips should be a list of IP addresses')
self.model['spec']['externalIPs'] = ips
return self
def set_labels(self, new_dict):
assert isinstance(new_dict, dict)
self.svc_metadata.set_labels(new_dict=new_dict)
return self
def set_load_balancer_ip(self, ip=None):
if ip is None:
raise SyntaxError('Service: ip should be an ip address.')
self.model['spec']['loadBalancerIP'] = ip
return self
def set_meta_creation_timestamp(self, ts):
return self.svc_metadata.set_creation_timestamp(ts=ts)
def set_meta_generation(self, gen):
return self.svc_metadata.set_generation(gen=gen)
def set_meta_resource_version(self, ver):
return self.svc_metadata.set_resource_version(ver=ver)
def set_meta_self_link(self, link):
return self.svc_metadata.set_self_link(link=link)
def set_meta_uid(self, uid):
return self.svc_metadata.set_uid(uid=uid)
def set_name(self, name):
assert isinstance(name, str)
self.svc_metadata.set_name(name=name)
return self
def set_namespace(self, name):
assert isinstance(name, str)
self.svc_metadata.set_namespace(name=name)
return self
def set_session_affinity(self, affinity_type=None):
if affinity_type is None or affinity_type not in ['None', 'ClientIP']:
raise SyntaxError('Service: affinity_type should be either: None or ClientIP')
self.model['spec']['sessionAffinity'] = affinity_type
return self
def set_service_type(self, service_type=None):
if service_type is None or service_type not in ['ClusterIP', 'NodePort', 'LoadBalancer']:
raise SyntaxError('Service: service_type should be one of: ClusterIP, NodePort, LoadBalancer')
self.model['spec']['type'] = service_type
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
class BaseModel(object):
def __init__(self, model=None):
super(BaseModel, self).__init__()
self._api_version = None
self._kind = None
self._metadata = ObjectMeta()
self._spec = None
self._status = None
if model is not None:
self.build_with_model(model)
def build_with_model(self, model=None):
if 'apiVersion' in model:
self.api_version = model['apiVersion']
if 'kind' in model:
self.kind = model['kind']
if 'metadata' in model:
self.metadata = ObjectMeta(model['metadata'])
def __eq__(self, other):
# see https://github.com/kubernetes/kubernetes/blob/master/docs/design/identifiers.md
if isinstance(other, self.__class__):
return self.metadata.namespace == other.metadata.namespace \
and self.metadata.name == other.metadata.name
return NotImplemented
# ------------------------------------------------------------------------------------- apiVersion
@property
def api_version(self):
return self._api_version
@api_version.setter
def api_version(self, v=None):
if not is_valid_string(v):
raise SyntaxError('BaseModel: api_version: [ {} ] is invalid.'.format(v))
self._api_version = v
# ------------------------------------------------------------------------------------- kind
@property
def kind(self):
return self._kind
@kind.setter
def kind(self, k=None):
if not is_valid_string(k):
raise SyntaxError('BaseModel: kind: [ {} ] is invalid.'.format(k))
self._kind = k
# ------------------------------------------------------------------------------------- metadata
@property
def metadata(self):
return self._metadata
@metadata.setter
def metadata(self, meta=None):
if not isinstance(meta, ObjectMeta):
raise SyntaxError('BaseModel: metadata: [ {} ] is invalid.'.format(meta))
self._metadata = meta
# ------------------------------------------------------------------------------------- spec
@property
def spec(self):
return self._spec
@spec.setter
def spec(self, s=None):
self._spec = s
# ------------------------------------------------------------------------------------- status
@property
def status(self):
return self._status
@status.setter
def status(self, s=None):
self._status = s
# ------------------------------------------------------------------------------------- name
@property
def name(self):
return self.metadata.name
@name.setter
def name(self, name=None):
if not is_valid_string(name):
raise SyntaxError('BaseModel: name: [ {} ] is invalid.'.format(name))
self.metadata.name = name
self.metadata.labels.update({'name': name})
# ------------------------------------------------------------------------------------- serialize
def serialize(self):
data = {}
if self.api_version is not None:
data['apiVersion'] = self.api_version
if self.kind is not None:
data['kind'] = self.kind
if self.metadata is not None:
data['metadata'] = self.metadata.serialize()
return data
class StorageClass(BaseModel):
"""
https://github.com/kubernetes/kubernetes/tree/master/examples/persistent-volume-provisioning/
https://kubernetes.io/docs/user-guide/persistent-volumes/#storageclasses
"""
def __init__(self, model=None):
super(StorageClass, self).__init__()
self._kind = 'StorageClass'
self._api_version = 'storage.k8s.io/v1beta1'
self._metadata = ObjectMeta()
self._provisioner = None
self._parameters = None
if model is not None:
self._build_with_model(model)
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 'provisioner' in model:
self.provisioner = model['provisioner']
if 'parameters' in model:
self.parameters = model['parameters']
# ------------------------------------------------------------------------------------- kind
@property
def kind(self):
return self._kind
@kind.setter
def kind(self, k=None):
if not is_valid_string(k):
raise SyntaxError(
'StorageClass: kind: [ {} ] is invalid.'.format(k))
self._kind = k
# ------------------------------------------------------------------------------------- apiVersion
@property
def api_version(self):
return self._api_version
@api_version.setter
def api_version(self, v=None):
if not is_valid_string(v):
raise SyntaxError(
'StorageClass: api_version: [ {} ] is invalid.'.format(v))
self._api_version = v
# ------------------------------------------------------------------------------------- metadata
@property
def metadata(self):
return self._metadata
@metadata.setter
def metadata(self, meta=None):
if not isinstance(meta, ObjectMeta):
raise SyntaxError(
'StorageClass: metadata: [ {} ] is invalid.'.format(meta))
self._metadata = meta
# ------------------------------------------------------------------------------------- provisioner
@property
def provisioner(self):
return self._provisioner
@provisioner.setter
def provisioner(self, p=None):
if not is_valid_string(p):
raise SyntaxError(
'StorageClass: provisioner: [ {} ] is invalid.'.format(p))
self._provisioner = p
# ------------------------------------------------------------------------------------- parameters
@property
def parameters(self):
return self._parameters
@parameters.setter
def parameters(self, p=None):
if not is_valid_dict(p):
raise SyntaxError(
'StorageClass: parameters: [ {} ] is invalid.'.format(p))
self._parameters = p
# ------------------------------------------------------------------------------------- serialize
def serialize(self):
data = {}
if self.kind is not None:
data['kind'] = self.kind
if self.api_version is not None:
data['apiVersion'] = self.api_version
if self.metadata is not None:
data['metadata'] = self.metadata.serialize()
if self.provisioner is not None:
data['provisioner'] = self.provisioner
if self.parameters is not None:
data['parameters'] = self.parameters
return data
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 Secret(BaseModel):
def __init__(self, name=None, namespace='default', model=None):
BaseModel.__init__(self)
if name is None:
raise SyntaxError('Secret: name: [ {0} ] cannot be None.'.format(name))
if not isinstance(name, str):
raise SyntaxError('Secret: name: [ {0} ] must be a string.'.format(name))
if model is not None and not isinstance(model, dict):
raise SyntaxError('Secret: model: [ {0} ] must be a dict.'.format(model))
if model is not None:
if 'status' in self.model:
self.model.pop('status', None)
self.model = model
self.secret_metadata = ObjectMeta(model=self.model['metadata'])
else:
self.model = dict(kind='Secret', apiVersion='v1')
self.secret_metadata = ObjectMeta(name=name, namespace=namespace)
self._update_model()
def _update_model(self):
self.model['metadata'] = self.secret_metadata.get()
return self
# ------------------------------------------------------------------------------------- add
def add_annotation(self, k=None, v=None):
self.secret_metadata.add_annotation(k=k, v=v)
return self
def add_label(self, k=None, v=None):
self.secret_metadata.add_label(k=k, v=v)
return self
# ------------------------------------------------------------------------------------- get
def get_annotation(self, k):
assert isinstance(k, str)
return self.secret_metadata.get_annotation(k=k)
def get_annotations(self):
return self.secret_metadata.get_annotations()
def get_label(self, k):
assert isinstance(k, str)
return self.secret_metadata.get_label(k=k)
def get_labels(self):
return self.secret_metadata.get_annotations()
# ------------------------------------------------------------------------------------- set
def set_annotations(self, new_dict):
assert isinstance(new_dict, dict)
self.secret_metadata.set_annotations(dico=new_dict)
return self
def set_data(self, k=None, v=None):
if k is None or v is None:
raise SyntaxError('Secret: k: [ {0} ] or v: [ {1} ] cannot be None.'.format(k, v))
if not isinstance(k, str) or not isinstance(v, str):
raise SyntaxError('Secret: k: [ {0} ] or v: [ {1} ]must be a string.'.format(k, v))
if 'data' not in self.model:
self.model['data'] = dict()
self.model['data'][k] = base64.b64encode(v)
return self
def set_dockercfg_secret(self, data=None):
if data is None:
raise SyntaxError('Secret: data: [ {0} ] cannot be None.'.format(data))
if not isinstance(data, str):
raise SyntaxError('Secret: data: [ {0} ] must be a string'.format(data))
self.set_type(secret_type='kubernetes.io/dockercfg')
self.set_data(k='.dockercfg', v=data)
return self
def set_dockercfg_json_secret(self, data=None):
if data is None:
raise SyntaxError('Secret: data: [ {0} ] cannot be None.'.format(data))
if not isinstance(data, str):
raise SyntaxError('Secret: data: [ {0} ] must be a string'.format(data))
self.set_type(secret_type='kubernetes.io/dockerconfigjson')
self.set_data(k='.dockerconfigjson', v=data)
return self
def set_labels(self, new_dict):
assert isinstance(new_dict, dict)
self.secret_metadata.set_labels(dico=new_dict)
return self
def set_service_account_token(self, account_name=None, account_uid=None,
token=None, kubecfg_data=None, cacert=None):
if account_name is None or account_uid is None or token is None:
raise SyntaxError('Secret: account_name: [ {0} ], account_uid: [ {1} ] or token: [ {2} ] '
'cannot be None'.format(account_name, account_uid, token))
if not isinstance(account_name, str) or not isinstance(account_uid, str) or not isinstance(token, str):
raise SyntaxError('Secret: account_name: [ {0} ], account_uid: [ {1} ] or token: [ {2} ] '
'must be strings'.format(account_name, account_uid, token))
self.set_type(secret_type='kubernetes.io/service-account-token')
self.secret_metadata.add_annotation(k='kubernetes.io/service-account.name', v=account_name)
self.secret_metadata.add_annotation(k='kubernetes.io/service-account.uid', v=account_uid)
self.set_data(k='token', v=token)
if kubecfg_data is not None and isinstance(kubecfg_data, str):
self.set_data(k='kubernetes.kubeconfig', v=kubecfg_data)
if cacert is not None and isinstance(cacert, str):
self.set_data(k='ca.crt', v=cacert)
return self
def set_type(self, secret_type=None):
if secret_type is None:
raise SyntaxError('Secret: secret_type: [ {0} ] cannot be None.'.format(secret_type))
if not isinstance(secret_type, str):
raise SyntaxError('Secret: secret_type: [ {0} ] must be a string'.format(secret_type))
self.model['type'] = secret_type
return self
def __init__(self):
BaseModel.__init__(self)
self.pod_spec = PodSpec()
self.pod_metadata = ObjectMeta()
self.pod_status = None
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 Service(BaseModel):
def __init__(self, name=None, namespace='default', port_name=None, port=0,
target_port=None, selector=None, session_affinity='None', model=None):
BaseModel.__init__(self)
if model is not None:
assert isinstance(model, dict)
self.model = model
if 'status' in self.model:
self.model.pop('status', None)
self.svc_metadata = ObjectMeta(model=self.model['metadata'], del_server_attr=False)
else:
self.model = dict(kind='Service', apiVersion='v1')
self.svc_metadata = ObjectMeta(name=name, namespace=namespace)
self.model['spec'] = dict(ports=[], selector=dict(), sessionAffinity=session_affinity, type='ClusterIP')
if port_name is not None and port > 0 and target_port is not None:
self.add_port(port=port, target_port=target_port, name=port_name)
if selector is not None:
self.add_selector(selector=selector)
self._update_model()
def _update_model(self):
self.model['metadata'] = self.svc_metadata.get()
return self
# ------------------------------------------------------------------------------------- add
def add_label(self, k, v):
self.svc_metadata.add_label(k=k, v=v)
return self
def add_annotation(self, k, v):
self.svc_metadata.add_annotation(k=k, v=v)
return self
def add_port(self, port=None, name=None, target_port=None, protocol=None, node_port=None):
if port is not None:
if not isinstance(port, int) or not 0 < port < 65536:
raise SyntaxError('Service: port: [ {0} ] must be a positive integer.'.format(port))
if name is not None:
if not isinstance(name, str):
raise SyntaxError('Service: name: [ {0} ] must be a string.'.format(name))
if target_port is not None:
if (not isinstance(target_port, str) and not isinstance(target_port, int)) or not 0 < target_port < 65536:
raise SyntaxError('Service: target_port: [ {0} ] must be either a string or a positive integer.'.format(target_port))
if protocol is not None:
if protocol not in ['TCP', 'UDP']:
raise SyntaxError('Service: port: [ {0} ] must be in: [ \'TCP\', \'UDP\' ]'.format(protocol))
if node_port is not None:
if not isinstance(node_port, int) or not 0 < node_port < 65536:
raise SyntaxError('Service: node_port: [ {0} ] should be a positive integer.'.format(node_port))
my_port = dict()
if port:
my_port['port'] = port
if name:
my_port['name'] = name
if protocol:
my_port['protocol'] = protocol
if target_port:
my_port['targetPort'] = target_port
if node_port:
my_port['nodePort'] = node_port
if len(my_port) > 0:
self.model['spec']['ports'].append(my_port)
return self
def add_selector(self, selector=None):
if selector is None:
raise SyntaxError('Service: selector: [ {0} ] cannot be None.'.format(selector))
if not isinstance(selector, dict):
raise SyntaxError('Service: selector: [ {0} ] must be a dict.')
for k, v in selector.iteritems():
if not isinstance(k, str) or not isinstance(v, str):
raise SyntaxError("Service: selector: [ {0} ] must be a dict of str to str.".format(selector))
if 'selector' not in self.model['spec']:
self.model['spec']['selector'] = dict()
self.model['spec']['selector'].update(selector)
return self
# ------------------------------------------------------------------------------------- del
def del_annotation(self, k):
self.svc_metadata.del_annotation(k=k)
return self
def del_label(self, k):
self.svc_metadata.del_label(k=k)
return self
def del_meta_creation_timestamp(self):
self.svc_metadata.del_creation_timestamp()
return self
def del_meta_generation(self):
self.svc_metadata.del_generation()
return self
def del_meta_resource_version(self):
self.svc_metadata.del_resource_version()
return self
def del_meta_self_link(self):
self.svc_metadata.del_self_link()
return self
def del_meta_uid(self):
self.svc_metadata.del_uid()
return self
def del_server_generated_meta_attr(self):
self.svc_metadata.del_server_generated_meta_attr()
return self
# ------------------------------------------------------------------------------------- get
def get_annotation(self, k=None):
return self.svc_metadata.get_annotation(k=k)
def get_annotations(self):
return self.svc_metadata.get_annotations()
def get_cluster_ip(self):
if 'clusterIP' in self.model['spec']:
return self.model['spec']['clusterIP']
return None
def get_external_ips(self):
if 'externalIPs' in self.model['spec']:
return self.model['spec']['externalIPs']
return None
def get_label(self, k=None):
return self.svc_metadata.get_label(k=k)
def get_labels(self):
return self.svc_metadata.get_labels()
def get_name(self):
return self.svc_metadata.get_name()
def get_namespace(self):
return self.svc_metadata.get_namespace()
def get_meta_creation_timestamp(self):
return self.svc_metadata.get_creation_timestamp()
def get_meta_generation(self):
return self.svc_metadata.get_generation()
def get_meta_resource_version(self):
return self.svc_metadata.get_resource_version()
def get_meta_self_link(self):
return self.svc_metadata.get_self_link()
def get_meta_uid(self):
return self.svc_metadata.get_uid()
# ------------------------------------------------------------------------------------- set
def set_annotations(self, dico):
self.svc_metadata.set_annotations(dico=dico)
return self
def set_cluster_ip(self, ip=None):
if ip is None:
raise SyntaxError('Service: clusterIP: [ {0} ] cannot be None.'.format(ip))
if not isinstance(ip, str):
raise SyntaxError('Service: clusterIP: [ {0} ] must be a string.'.format(ip))
try:
socket.inet_aton(ip)
except socket.error:
raise SyntaxError('Service: clusterIP: [ {0} ] is not a valid IP address.'.format(ip))
self.model['spec']['clusterIP'] = ip
return self
def set_external_ips(self, ips=None):
if ips is None:
raise SyntaxError('Service: ips: [ {0} ] cannot be None.'.format(ips))
if not isinstance(ips, list):
raise SyntaxError('Service: ips: [ {0} ] must be a list of IP addresses.'.format(ips.__class__.__name__))
for ip in ips:
if not isinstance(ip, str):
raise SyntaxError('Service: ips: [ {0} ] contains an element which isn\'t a string.'.format(ips))
try:
socket.inet_aton(ip)
except socket.error:
raise SyntaxError('Service: ips: [ {0} ] contains an invalid IP address.'.format(ips))
self.model['spec']['externalIPs'] = ips
return self
def set_labels(self, dico):
self.svc_metadata.set_labels(dico=dico)
return self
def set_load_balancer_ip(self, ip=None):
if ip is None:
raise SyntaxError('Service: loadBalancerIP: [ {0} ] cannot be None.'.format(ip))
if not isinstance(ip, str):
raise SyntaxError('Service: loadBalancerIP: [ {0} ] must be a string.'.format(ip))
try:
socket.inet_aton(ip)
except socket.error:
raise SyntaxError('Service: loadBalancerIP: [ {0} ] is not a valid IP address.'.format(ip))
self.model['spec']['loadBalancerIP'] = ip
return self
def set_meta_creation_timestamp(self, ts=None):
return self.svc_metadata.set_creation_timestamp(ts=ts)
def set_meta_generation(self, gen=None):
return self.svc_metadata.set_generation(gen=gen)
def set_meta_resource_version(self, ver):
return self.svc_metadata.set_resource_version(ver=ver)
def set_meta_self_link(self, link):
return self.svc_metadata.set_self_link(link=link)
def set_meta_uid(self, uid):
return self.svc_metadata.set_uid(uid=uid)
def set_name(self, name):
assert isinstance(name, str)
self.svc_metadata.set_name(name=name)
return self
def set_namespace(self, name):
self.svc_metadata.set_namespace(name=name)
return self
def set_session_affinity(self, affinity_type=None):
if affinity_type is None:
raise SyntaxError('Service: affinity_type: [ {0} ] cannot be None.'.format(affinity_type))
if affinity_type not in ['None', 'ClientIP']:
raise SyntaxError('Service: affinity_type: [ {0} ] must be in: [ \'None\', \'ClientIP\' ]')
self.model['spec']['sessionAffinity'] = affinity_type
return self
def set_service_type(self, service_type=None):
if service_type is None:
raise SyntaxError('Service: service_type: [ {0} ] cannot be None.'.format(service_type))
if service_type not in ['ClusterIP', 'NodePort', 'LoadBalancer']:
raise SyntaxError('Service: service_type: [ {0} ] must be in: [ \'ClusterIP\', \'NodePort\', \'LoadBalancer\' ]')
self.model['spec']['type'] = service_type
return self
