def put(self, namespace, name, ignore_exception=False, **kwargs):
url = self.api("/namespaces/{}/middlewares/{}", namespace, name)
if kwargs.get("resource_version") is None:
response = self.get(namespace, name)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response,
"get middleware {}".format(name))
resource_version = response.json()["metadata"]["resourceVersion"]
kwargs["resource_version"] = resource_version
data = self.manifest(name, **kwargs)
response = self.http_put(url, json=data)
if not ignore_exception and self.unhealthy(response.status_code):
raise KubeHTTPException(response,
"put middleware {}".format(namespace))
return response
def create(self, ingress, namespace, hostname, ingress_class):
url = "/apis/extensions/v1beta1/namespaces/%s/ingresses" % namespace
data = {
"kind": "Ingress",
"apiVersion": "extensions/v1beta1",
"metadata": {
"name": ingress,
"annotations": {
"kubernetes.io/ingress.class": ingress_class
}
},
"spec": {
"rules": [{
"host": ingress + "." + hostname,
"http": {
"paths": [{
"path": "/",
"backend": {
"serviceName": ingress,
"servicePort": 80
}
}]
}
}]
}
}
response = self.http_post(url, json=data)
if not response.status_code == 201:
raise KubeHTTPException(response,
"create Ingress {}".format(namespace))
return response
def delete(self, namespace, ingress):
url = "/apis/extensions/v1beta1/namespaces/%s/ingresses/%s" % (namespace, ingress)
response = self.http_delete(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response, 'delete Ingress "{}"', namespace)
return response
def create(self, namespace_name, name, **kwargs):
"""
Create resource quota for namespace
"""
url = self.api("/namespaces/{}/resourcequotas".format(namespace_name))
manifest = {
"kind": "ResourceQuota",
"apiVersion": "v1",
"metadata": {
"namespace": namespace_name,
"name": name,
'labels': {
'app': namespace_name,
'heritage': 'deis'
},
},
'spec': {}
}
data = dict_merge(manifest, kwargs.get('data', {}))
response = self.http_post(url, json=data)
if not response.status_code == 201:
raise KubeHTTPException(
response, "create quota {} for namespace {}".format(
name, namespace_name))
return response
def delete(self, namespace, name):
# get timeout info from pod
pod = self.pod.get(namespace, name).json()
# 30 seconds is the kubernetes default
timeout = pod['spec'].get('terminationGracePeriodSeconds', 30)
# delete pod
url = self.api("/namespaces/{}/pods/{}", namespace, name)
response = self.http_delete(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response,
'delete Pod "{}" in Namespace "{}"', name,
namespace)
# Verify the pod has been deleted
# Only wait as long as the grace period is - k8s will eventually GC
for _ in range(timeout):
try:
pod = self.pod.get(namespace, name).json()
# hide pod if it is passed the graceful termination period
if self.deleted(pod):
return
except KubeHTTPException as e:
if e.response.status_code == 404:
break
time.sleep(1)
return response
def create(self, namespace, name, message, **kwargs):
url = self.api('/namespaces/{}/events'.format(namespace))
data = {
'kind': 'Event',
'apiVersion': 'v1',
'count': kwargs.get('count', 1),
'metadata': {
'creationTimestamp': datetime.now().strftime(DATETIME_FORMAT),
'namespace': namespace,
'name': name,
'resourceVersion': kwargs.get('resourceVersion', ''),
'uid': str(uuid.uuid4()),
},
'message': message,
'type': kwargs.get('type', 'Normal'),
'firstTimestamp': datetime.now().strftime(DATETIME_FORMAT),
'lastTimestamp': datetime.now().strftime(DATETIME_FORMAT),
'reason': kwargs.get('reason', ''),
'source': {
'component': kwargs.get('component', ''),
},
'involvedObject': kwargs.get('involvedObject', {})
}
response = self.http_post(url, json=data)
if not response.status_code == 201:
raise KubeHTTPException(
response,
'create Event for namespace {}'.format(namespace)) # noqa
return response
def update(self, namespace, name, data):
url = self.api("/namespaces/{}/replicationcontrollers/{}", namespace, name)
response = self.http_put(url, json=data)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response, 'scale ReplicationController "{}"', name)
return response
def create(self, ingress, namespace, hostname):
# Ingress API will be deprecated in 1.20 to use networking.k8s.io/v1beta1
# https://kubernetes.io/blog/2019/07/18/api-deprecations-in-1-16/
url = "/apis/extensions/v1beta1/namespaces/%s/ingresses" % namespace
data = {
"kind": "Ingress",
"apiVersion": "extensions/v1beta1",
"metadata": {
"name": ingress
},
"spec": {
"rules": [{
"host": ingress + "." + hostname,
"http": {
"paths": [{
"path": "/",
"backend": {
"serviceName": ingress,
"servicePort": 80
}
}]
}
}]
}
}
response = self.http_post(url, json=data)
if not response.status_code == 201:
raise KubeHTTPException(response,
"create Ingress {}".format(namespace))
return response
def delete(self, namespace, ingress):
url = self.api("/namespaces/{}/ingresses/{}", namespace, ingress)
response = self.http_delete(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response, 'delete Ingress "{}"', namespace)
return response
def events(self, namespace, **kwargs):
url = self.api("/namespaces/{}/events", namespace)
response = self.http_get(url, params=self.query_params(**kwargs))
if self.unhealthy(response.status_code):
raise KubeHTTPException(response, "get Events in Namespace {}",
namespace)
return response
def delete(self, namespace, name, ignore_exception=True):
url = self.api("/namespaces/{}/middlewares/{}", namespace, name)
response = self.http_delete(url)
if not ignore_exception and self.unhealthy(response.status_code):
raise KubeHTTPException(response, 'delete middlewares "{}"',
namespace)
return response
def create(self, namespace, ignore_exception=False, **kwargs):
url = self.api("/namespaces/{}/middlewares", namespace)
data = self.manifest(**kwargs)
response = self.http_post(url, json=data)
if not ignore_exception and self.unhealthy(response.status_code):
raise KubeHTTPException(response,
"create middleware {}".format(namespace))
return response
def version(self):
"""Get Kubernetes version as a float"""
response = self.http_get('/version')
if self.unhealthy(response.status_code):
raise KubeHTTPException(response, 'fetching Kubernetes version')
data = response.json()
return float('{}.{}'.format(data['major'], data['minor']))
def delete_binding(self, namespace, name):
"""
Delete servicebindings
"""
url = self.api('/namespaces/{}/servicebindings/{}', namespace, name)
response = self.http_delete(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response, 'delete servicebindings ' + name)
return response
def delete(self, namespace, name):
url = self.api("/namespaces/{}/deployments/{}", namespace, name)
response = self.http_delete(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(
response, 'delete Deployment "{}" in Namespace "{}"', name,
namespace)
return response
def update(self, namespace, name, data):
url = self.api("/namespaces/{}/services/{}", namespace, name)
response = self.http_put(url, json=data)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response,
'update Service "{}" in Namespace "{}"',
namespace, name)
return response
def put(self, namespace, name, hosts, version):
url = self.api('/namespaces/{}/certificates/{}', namespace, name)
data = self.manifest(self.api_version, namespace, name, hosts, version)
response = self.http_put(url, json=data)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response,
"put certificate {}".format(namespace))
return response
def delete(self, namespace, name):
"""
Delete certificate
"""
url = self.api('/namespaces/{}/certificates/{}', namespace, name)
response = self.http_delete(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response, 'delete certificate ' + name)
return response
def logs(self, namespace, name):
url = self.api("/namespaces/{}/pods/{}/log", namespace, name)
response = self.http_get(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response,
'get logs for Pod "{}" in Namespace "{}"',
name, namespace)
return response
def delete(self, namespace, name):
url = self.api("/namespaces/{}/horizontalpodautoscalers/{}", namespace, name)
response = self.http_delete(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(
response,
'delete HorizontalPodAutoscaler "{}" in Namespace "{}"', name, namespace
)
return response
def delete(self, namespace, name):
url = self.api("/namespaces/{}/replicationcontrollers/{}", namespace, name)
response = self.http_delete(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(
response,
'delete ReplicationController "{}" in Namespace "{}"', name, namespace
)
return response
def update(self, namespace, name, data, secret_type='Opaque', labels={}):
manifest = self.manifest(namespace, name, data, secret_type, labels)
url = self.api("/namespaces/{}/secrets/{}", namespace, name)
response = self.http_put(url, json=manifest)
if self.unhealthy(response.status_code):
raise KubeHTTPException(
response, 'failed to update Secret "{}" in Namespace "{}"',
name, namespace)
return response
def get_serviceplans(self, namespace=None):
if namespace is None:
url = self.api('/clusterserviceplans')
message = 'get clusterserviceplans'
else:
url = self.api('/namespaces/{}/serviceplans', namespace)
message = 'get serviceplans ' + namespace
response = self.http_get(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response, message)
return response
def create(self, namespace, name, **kwargs):
"""
Create persistentvolumeclaim
"""
url = self.api('/namespaces/{}/persistentvolumeclaims', namespace)
data = self.manifest(namespace, name, **kwargs)
response = self.http_post(url, json=data)
if not response.status_code == 201:
raise KubeHTTPException(
response, "create persistentvolumeclaim {}".format(namespace))
return response
def create(self, namespace, name, hosts):
url = self.api('/namespaces/{}/certificates', namespace)
data = self.manifest(self.api_version, namespace, name, hosts)
response = self.http_post(url, json=data)
if not response.status_code == 201:
raise KubeHTTPException(response,
"create certificate {}".format(namespace))
return response
def delete(self, namespace, name):
"""
Delete persistentvolumeclaim
"""
url = self.api('/namespaces/{}/persistentvolumeclaims/{}', namespace,
name)
response = self.http_delete(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response,
'delete persistentvolumeclaim ' + name)
return response
def create_instance(self, namespace, name, **kwargs):
"""
Create serviceinstances
"""
url = self.api('/namespaces/{}/serviceinstances', namespace)
data = self.service_instance_manifest(namespace, name, **kwargs)
response = self.http_post(url, json=data)
if not response.status_code == 201:
raise KubeHTTPException(
response, "create serviceinstances {}".format(namespace))
return response
def version(self):
"""Get Kubernetes version"""
response = self.http_get('/version')
if self.unhealthy(response.status_code):
raise KubeHTTPException(response, 'fetching Kubernetes version')
data = response.json()
parsed_version = parse(
re.sub(r'[^0-9\.]', '',
str('{}.{}'.format(data['major'], data['minor']))))
return Version('{}'.format(parsed_version))
def get(self, namespace_name, name):
"""
Fetch a single quota
"""
url = '/namespaces/{}/resourcequotas/{}'.format(namespace_name, name)
message = 'get quota {} for namespace {}'.format(name, namespace_name)
url = self.api(url)
response = self.http_get(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response, message)
return response
def get(self, namespace_name, name):
"""
Fetch a single LimitRanges
"""
url = '/namespaces/{}/limitranges/{}'.format(namespace_name, name)
message = 'get LimitRanges {} for namespace {}'.format(
name, namespace_name)
url = self.api(url)
response = self.http_get(url)
if self.unhealthy(response.status_code):
raise KubeHTTPException(response, message)
return response
