def taint(self, key=None, value=None, effect=None):
if not (key and value and effect):
raise SyntaxError(
"K8sNode: taint: you must specify a key, a value and an effect."
)
if not is_valid_string(key) or not is_valid_string(value):
raise SyntaxError(
"K8sNode: taint: key: [ {} ] or value: [ {} ] is invalid.".
format(key, value))
if effect not in Taint.VALID_TAINT_EFFECTS:
raise SyntaxError("K8sNode: taint: effect must be in {}".format(
Taint.VALID_TAINT_EFFECTS))
t = Taint()
t.key = key
t.value = value
t.effect = effect
exists = False
for existing_taint in self.taints:
if existing_taint.key == key and existing_taint.value == value and existing_taint.effect == effect:
exists = True
if not exists:
self.taints.append(t)
self.update()
return self
def set_container_image(self, name=None, image=None):
if not is_valid_string(name):
raise SyntaxError('PodSpec: name: [ {0} ] is invalid.')
if not is_valid_string(image):
raise SyntaxError('PodSpec: image: [ {0} ] is invalid.')
for c in self.containers:
if c.name == name:
c.image(image=image)
break
return self
def get_by_name(config=None, name=None, name_label='name'):
if config is not None and not isinstance(config, K8sConfig):
raise SyntaxError(
'ReplicationController.get_by_name(): config: [ {0} ] is invalid.'
.format(config))
if not is_valid_string(name):
raise SyntaxError(
'K8sReplicationController.get_by_name() name: [ {0} ] is invalid.'
.format(name))
rc_list = []
data = {'labelSelector': '{0}={1}'.format(name_label, name)}
rcs = K8sReplicationController(config=config,
name=name).get_with_params(data=data)
for rc in rcs:
try:
model = ReplicationController(rc)
obj = K8sReplicationController(
config=config,
name=model.metadata.name).from_model(m=model)
rc_list.append(obj)
except NotFoundException:
pass
return rc_list
def add_port(self,
name=None,
port=None,
target_port=None,
protocol=None,
node_port=None):
if not is_valid_string(name):
raise SyntaxError(
'Service.add_port() name: [ {} ] is invalid.'.format(name))
if port is None or not (isinstance(port, str)
or isinstance(port, int)):
raise SyntaxError(
'Service.add_port() port: [ {} ] is invalid.'.format(name))
ports = []
port_found = False
# exists previously
for p in self.spec.ports:
if int(p.port) == int(port) and p.protocol == protocol:
p.name = name
p.target_port = target_port
p.protocol = str(protocol).upper()
p.node_port = node_port
port_found = True
ports.append(p)
# doesn't exist yet
if not port_found:
p = ServicePort()
p.name = name
p.port = port
p.target_port = target_port
p.protocol = protocol
p.node_port = node_port
ports.append(p)
self.spec.ports = ports
def untaint(self, key=None, value=None):
if key and value:
if not is_valid_string(key) or not is_valid_string(value):
raise SyntaxError(
"K8sNode: taint: key: [ {} ] or value: [ {} ] is invalid.".
format(key, value))
remaining_taints = []
for t in self.taints:
if key and value:
if t.key != key and t.value != value:
remaining_taints.append(t)
self.taints = remaining_taints
self.update()
return self
def service_account_name(self, san=None):
if not is_valid_string(san):
raise SyntaxError(
"PodSpec: service_account_name: [ {0} ] is invalid.".format(
san))
self._service_account_name = san
self._service_account = san
def get_by_name(cls, config=None, name=None, name_label='name'):
if not is_valid_string(name):
raise SyntaxError(
'K8sPod.get_by_name(): name: [ {0} ] is invalid.'.format(name))
return cls.get_by_labels(config=config, labels={
name_label: name,
})
def sub_path(self, path=None):
if path is None:
path = "" # default; volume's root
if not is_valid_string(path):
raise SyntaxError(
"VolumeMount: sub_path: [ {0} ] is invalid.".format(path))
self._sub_path = path
def operator(self, o=None):
if not is_valid_string(
o) or o not in NodeSelectorRequirement.VALID_OPERATORS:
raise SyntaxError(
'NodeSelectorRequirement: operator: [ {} ] is invalid.'.format(
o))
self._operator = o
def path(self, path=None):
if not is_valid_string(path):
raise SyntaxError("KeyToPath: path: [ {0} ] is invalid.".format(path))
if re.match("/", path):
raise SyntaxError("KeyToPath: path: [ {0} ] is invalid. It may not be an absolute path".format(path))
if re.search("\.\.", path):
raise SyntaxError('KeyToPath: path: [ {0} ] is invalid. It may not contain the string ".."'.format(path))
self._path = path
def data(self):
d = {}
for k, v in self._data.items():
d[k] = base64.b64decode(v)
if isinstance(d[k], bytes):
d[k] = d[k].decode()
elif is_valid_string(d[k]):
d[k] = d[k].decode()
return d
def mode(self, mode=None):
if is_valid_string(mode):
try:
mode = int(mode)
except ValueError:
raise SyntaxError("KeyToPath: mode: [ {0} ] is invalid.".format(mode))
if not isinstance(mode, int):
raise SyntaxError("KeyToPath: mode: [ {0} ] is invalid.".format(mode))
self._mode = mode
def target_port(self, port=None):
msg = "ServicePort: target_port: [ {} ] is invalid.".format(port)
try:
p = int(port)
except ValueError:
if not is_valid_string(port):
raise SyntaxError(msg)
p = port
except TypeError:
raise SyntaxError(msg)
self._target_port = p
def set_service_account_token(self,
account_name=None,
account_uid=None,
token=None,
kubecfg_data=None,
cacert=None):
for x in [account_name, account_uid, token]:
if not is_valid_string(x):
raise SyntaxError(
"Secret.set_service_account() account_name: [ {} ] is invalid."
.format(x))
if not is_valid_string(account_uid):
raise SyntaxError(
"Secret.set_service_account() account_uid: [ {} ] is invalid.".
format(account_uid))
if not is_valid_string(token):
raise SyntaxError(
"Secret.set_service_account() token: [ {} ] is invalid.".
format(token))
anns = {
self.K8s_ANNOTATION_SERVICE_ACCOUNT_NAME: account_name,
self.K8s_ANNOTATION_SERVICE_ACCOUNT_UID: account_uid
}
self.type = self.K8s_TYPE_SERVICE_ACCOUNT
self.metadata.annotations = anns
self.data = {"token": token}
if is_valid_string(kubecfg_data):
d = self.data
d.update({"kubernetes_py.kubeconfig": kubecfg_data})
self.data = d
if is_valid_string(cacert):
d = self.data
d.update({"ca.crt": cacert})
self.data = d
return self
def default_mode(self, mode=None):
if is_valid_string(mode):
try:
mode = int(mode)
except ValueError:
raise SyntaxError(
'ConfigMapVolumeSource: defaultMode: [ {0} ] is invalid.'.
format(mode))
if not isinstance(mode, int):
raise SyntaxError(
'ConfigMapVolumeSource: defaultMode: [ {0} ] is invalid.'.
format(mode))
self._default_mode = mode
def serialize(self):
data = super(Secret, self).serialize()
if self.data is not None:
d = {}
for k, v in self.data.items():
if is_valid_string(v):
v = bytearray(source=v, encoding="UTF-8")
d[k] = base64.b64encode(v)
if isinstance(d[k], bytes):
d[k] = d[k].decode()
data["data"] = d
if self.string_data is not None:
data["stringData"] = self.string_data
if self.type is not None:
data["type"] = self.type
return data
def get_by_pod_ip(config=None, ip=None, labels=None):
if config is None:
config = K8sConfig()
if not is_valid_string(ip):
raise SyntaxError(
'K8sPod.get_by_pod_ip(): ip: [ {0} ] is invalid.'.format(ip))
found = None
pods = K8sPod(config=config, name='throwaway').list(labels=labels)
for pod in pods:
try:
assert isinstance(pod, K8sPod)
if pod.pod_ip == ip:
found = pod
break
except NotFoundException:
pass
return found
def data(self, data=None):
msg = "Secret: data: [ {0} ] is invalid.".format(data)
if isinstance(data, string_types):
try:
data = json.loads(data)
except ValueError:
raise SyntaxError(msg)
if not is_valid_dict(data):
raise SyntaxError(msg)
for k, v in data.items():
if not is_valid_string(k):
raise SyntaxError(msg)
if not isinstance(v, bytes):
try:
v = bytearray(v, "UTF-8")
except:
raise SyntaxError(
"Could not convert [ {0} ] to bytes.".format(v))
self._data[k] = base64.b64encode(v)
def name(self, name=None):
if not is_valid_string(name):
raise SyntaxError(
"DeploymentRollback: name: [ {} ] is invalid.".format(name))
self._name = name
def api_version(self, v=None):
if not is_valid_string(v):
raise SyntaxError(
"DeploymentRollback: api_version: [ {} ] is invalid.".format(
v))
self._api_version = v
def kind(self, kind=None):
if not is_valid_string(kind):
raise SyntaxError(
"DeploymentRollback: kind: [ {} ] is invalid.".format(kind))
self._kind = kind
def key(self, k=None):
if not is_valid_string(k):
raise SyntaxError(
'SecretKeySelector: key: [ {} ] is invalid.'.format(k))
self._key = k
def name(self, n=None):
if not is_valid_string(n):
raise SyntaxError(
'SecretKeySelector: name: [ {} ] is invalid.'.format(n))
self._name = n
def kind(self, k=None):
if not is_valid_string(k):
raise SyntaxError("BaseModel: kind: [ {} ] is invalid.".format(k))
self._kind = k
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
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})
def message(self, msg=None):
if not is_valid_string(msg):
raise SyntaxError(
"ContainerStateTerminated: message: [ {0} ] is invalid.".
format(msg))
self._message = msg
def reason(self, msg=None):
if not is_valid_string(msg):
raise SyntaxError(
"ContainerStateTerminated: reason: [ {0} ] is invalid.".format(
msg))
self._reason = msg
def container_id(self, cid=None):
if not is_valid_string(cid):
raise SyntaxError(
"ContainerStateTerminated: container_id: [ {0} ] is invalid.".
format(cid))
self._container_id = cid
def finished_at(self, time=None):
if not is_valid_string(time):
raise SyntaxError(
"ContainerStateTerminated: finished_at: [ {0} ] is invalid.".
format(time))
self._finished_at = time
