def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
data = {}
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
common.connect()
k8s_client = client.BatchV1Api()
try:
## get pods from job
label_selector = "job-name=" + data["name"]
pretty = 'true'
v1 = client.CoreV1Api()
ret = v1.list_pod_for_all_namespaces(watch=False,
label_selector=label_selector)
print("pods found: %s" % len(ret.items))
for i in ret.items:
print("Removing pod %s" % (i.metadata.name))
watch = True
try:
api_response = v1.delete_collection_namespaced_pod(
data["namespace"],
pretty=pretty,
label_selector=label_selector,
watch=watch)
print(common.parseJson(api_response))
except ApiException as e:
print(
"Exception when calling CoreV1Api->delete_collection_namespaced_pod: %s\n"
% e)
body = client.V1DeleteOptions(api_version='v1',
kind="DeleteOptions",
propagation_policy="Background")
api_response = k8s_client.delete_namespaced_job(
name=data["name"],
namespace=data["namespace"],
body=body,
pretty=pretty)
print(common.parseJson(api_response.status))
except ApiException as e:
log.error("Exception when calling delete_namespaced_job: %s\n" % e)
sys.exit(1)
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
common.connect()
data = {}
data["api_version"] = os.environ.get('RD_CONFIG_API_VERSION')
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
force = os.environ.get('RD_CONFIG_FORCE')
try:
k8s_client = client.BatchV1Api()
job = k8s_client.read_namespaced_job(name=data["name"],
namespace=data["namespace"])
if not force and job.status and job.status.active:
log.info('Previous job run still active; not deleting')
return
job.metadata.creation_timestamp = None
job.metadata.uid = None
job.metadata.resource_version = None
job.status = None
job.spec.selector = None
job.spec.template.metadata = None
body = client.V1DeleteOptions(api_version='v1',
kind="DeleteOptions",
propagation_policy="Background")
pretty = 'pretty_example'
api_response = k8s_client.delete_namespaced_job(
name=data["name"],
namespace=data["namespace"],
body=body,
pretty=pretty)
print(common.parseJson(api_response))
api_response = k8s_client.create_namespaced_job(
body=job, namespace=data["namespace"])
print(common.parseJson(api_response.status))
except ApiException:
log.exception("Exception creating job:")
sys.exit(1)
def main():
data = {}
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
common.connect()
try:
api = client.AppsV1Api()
api_response = api.read_namespaced_deployment(data["name"],
data["namespace"])
print(common.parseJson(api_response.status))
replicas = api_response.status.replicas
r_replicas = api_response.status.ready_replicas
u_replicas = api_response.status.unavailable_replicas
if (u_replicas is not None):
log.error("unavailable replicas on the deployment: %s\n",
u_replicas)
sys.exit(1)
if (replicas != r_replicas):
log.error("ready replicas doesn't match with replicas: %s\n",
r_replicas)
sys.exit(1)
except ApiException:
log.exception("Exception deleting deployment:")
sys.exit(1)
def main():
common.connect()
disable_build = os.environ.get('RD_CONFIG_DISABLEBUILD')
if disable_build != "false":
sys.exit(0)
data = {
"yaml": os.environ.get('RD_CONFIG_YAML'),
"namespace": os.environ.get('RD_CONFIG_NAMESPACE'),
"name": os.environ.get('RD_CONFIG_NAME')
}
with client.ApiClient() as k8s_client:
openshift_client = DynamicClient(k8s_client)
try:
dep = yaml.safe_load(data["yaml"])
v1_bc = openshift_client.resources.get(
api_version='build.openshift.io/v1', kind='BuildConfig')
resp = v1_bc.apply(body=dep, namespace=data["namespace"])
print(common.parseJson(resp.metadata))
except ApiException as e:
if e.status == 409:
log.warning("Build config already exists.")
# _trigger_build(data["namespace"], data["name"])
else:
log.error("Exception error creating: %s\n" % e)
sys.exit(1)
def _trigger_build(namespace, name):
headers = {
'Authorization': 'Bearer ' + os.environ.get('RD_CONFIG_TOKEN'),
'Content-Type': 'application/json',
'Accept': 'application/json',
}
data = '''
{
"kind":"BuildRequest","apiVersion":"build.openshift.io/v1",
"metadata":
{
"name":"%s",
"creationTimestamp":null
},
"triggeredBy":[{"message":"Manually triggered"}],
"dockerStrategyOptions":{},
"sourceStrategyOptions":{}
}
''' % name
url = os.environ.get(
'RD_CONFIG_URL'
) + "/apis/build.openshift.io/v1/namespaces/{}/buildconfigs/{}/instantiate".format(
namespace, name)
if url is not None:
try:
response = requests.post(url=url,
json=json.loads(data),
headers=headers,
verify=False)
print(common.parseJson(response.text))
except requests.HTTPError as e:
log.error("Exception while triggering build: %s\n" % e)
sys.exit(1)
def create_deployment(api_instance, deployment, data):
# Create deployement
api_response = api_instance.create_namespaced_deployment(
body=deployment,
namespace=data["namespace"])
print(common.parseJson(api_response.status))
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
data = {}
data["type"] = os.environ.get('RD_CONFIG_TYPE')
data["yaml"] = os.environ.get('RD_CONFIG_YAML')
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
common.connect()
try:
if data["type"] == "ConfigMap":
api_instance = client.CoreV1Api()
dep = yaml.safe_load(data["yaml"])
resp = api_instance.patch_namespaced_config_map(
name=data["name"],
namespace=data["namespace"],
body=dep,
pretty="true")
print(common.parseJson(resp.metadata))
except ApiException as e:
log.error("Exception error creating: %s\n" % e)
sys.exit(1)
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
data = {}
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
common.connect()
api_instance = client.CoreV1Api()
try:
api_response = api_instance.delete_namespaced_service(
name=data["name"],
body=client.V1DeleteOptions(propagation_policy='Foreground',
grace_period_seconds=5),
namespace=data["namespace"],
pretty="true")
print(common.parseJson(api_response))
except ApiException:
log.exception("Exception when calling delete_namespaced_service:")
sys.exit(1)
def wait():
data = {}
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
retries = os.environ.get('RD_CONFIG_RETRIES')
sleep = os.environ.get('RD_CONFIG_SLEEP')
try:
extensions_v1beta1 = client.ExtensionsV1beta1Api()
api_response = extensions_v1beta1.read_namespaced_deployment(
data["name"], data["namespace"], pretty="True")
print common.parseJson(api_response.status)
unavailable_replicas = api_response.status.unavailable_replicas
replicas = api_response.status.replicas
ready_replicas = api_response.status.ready_replicas
retries_count = 0
if (replicas == ready_replicas):
log.info("Deployment is ready")
sys.exit(0)
while (unavailable_replicas is not None):
log.info("wating for deployment")
time.sleep(float(sleep))
retries_count = retries_count + 1
if retries_count > retries:
log.error("number retries exedded")
sys.exit(1)
api_response = extensions_v1beta1.read_namespaced_deployment(
data["name"], data["namespace"], pretty="True")
unavailable_replicas = api_response.status.unavailable_replicas
log.info("unavailable replicas: " + str(unavailable_replicas))
except ApiException as e:
log.error("Exception deleting deployment: %s\n" % e)
sys.exit(1)
def delete_deployment(api_instance, data):
# Delete deployment
api_response = api_instance.delete_namespaced_deployment(
name=data["name"],
namespace=data["namespace"],
body=client.V1DeleteOptions(propagation_policy='Foreground',
grace_period_seconds=5))
print(common.parseJson(api_response.status))
def wait():
data = {}
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
retries = int(os.environ.get('RD_CONFIG_RETRIES'))
sleep = int(os.environ.get('RD_CONFIG_SLEEP'))
try:
appsV1Api = client.AppsV1Api()
api_response = appsV1Api.read_namespaced_deployment(data["name"],
data["namespace"],
pretty="True")
print(common.parseJson(api_response.status))
unavailable_replicas = api_response.status.unavailable_replicas
replicas = api_response.status.replicas
ready_replicas = api_response.status.ready_replicas
if ready_replicas is None:
ready_replicas = 0
else:
ready_replicas = int(ready_replicas)
if replicas is None:
replicas = 0
else:
replicas = int(replicas)
retries_count = 0
if (replicas == ready_replicas):
log.info("Deployment is ready")
sys.exit(0)
while (unavailable_replicas is not None):
log.info("waiting for deployment")
time.sleep(float(sleep))
retries_count = retries_count + 1
if retries_count > retries:
log.error("number of retries exceeded")
sys.exit(1)
api_response = appsV1Api.read_namespaced_deployment(
data["name"], data["namespace"], pretty="True")
unavailable_replicas = api_response.status.unavailable_replicas
log.info("unavailable replicas: " + str(unavailable_replicas))
except ApiException:
log.exception("Exception deleting deployment:")
sys.exit(1)
def main():
# Configs can be set in Configuration class directly or using helper
# utility. If no argument provided, the config will be loaded from
# default location.
common.connect()
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
data = {}
data["api_version"] = os.environ.get('RD_CONFIG_API_VERSION')
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
data["type"] = os.environ.get('RD_CONFIG_TYPE')
data["labels"] = os.environ.get('RD_CONFIG_LABELS')
data["selectors"] = os.environ.get('RD_CONFIG_SELECTORS')
data["ports"] = os.environ.get('RD_CONFIG_PORTS')
# optionals
if os.environ.get('RD_CONFIG_ANNOTATIONS'):
data["annotations"] = os.environ.get('RD_CONFIG_ANNOTATIONS')
if os.environ.get('RD_CONFIG_EXTERNAL_TRAFFIC_POLICY'):
et_policy = os.environ.get('RD_CONFIG_EXTERNAL_TRAFFIC_POLICY')
data["external_traffic_policy"] = et_policy
if os.environ.get('RD_CONFIG_SESSION_AFFINITY'):
data["session_affinity"] = os.environ.get('RD_CONFIG_SESSION_AFFINITY')
if os.environ.get('RD_CONFIG_EXTERNAL_NAME'):
data["external_name"] = os.environ.get('RD_CONFIG_EXTERNAL_NAME')
if os.environ.get('RD_CONFIG_LOAD_BALANCER_IP'):
data["load_balancer_ip"] = os.environ.get('RD_CONFIG_LOAD_BALANCER_IP')
log.debug("Creating service from data:")
log.debug(data)
api_instance = client.CoreV1Api()
service = create_service_object(data)
log.debug("new service: ")
log.debug(service)
try:
resp = api_instance.create_namespaced_service(
namespace=data["namespace"],
body=service
)
print(common.parseJson(resp.status))
except ApiException:
log.exception("Exception when calling create_namespaced_service:")
sys.exit(1)
def main():
common.connect()
data = {"namespace": os.environ.get('RD_CONFIG_NAMESPACE'), "name": os.environ.get('RD_CONFIG_NAME')}
with client.ApiClient() as k8s_client:
openshift_client = DynamicClient(k8s_client)
try:
v1_bc = openshift_client.resources.get(api_version='build.openshift.io/v1', kind='BuildConfig')
resp = v1_bc.delete(name=data["name"], namespace=data["namespace"])
print(common.parseJson(resp.metadata))
except ApiException as e:
log.error("Exception error creating: %s\n" % e)
sys.exit(1)
def update_deployment(api_instance, deployment, data):
# Update the deployment
api_response = api_instance.patch_namespaced_deployment(
name=data["name"], namespace=data["namespace"], body=deployment)
print(common.parseJson(api_response.status))
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
data = {}
data["type"] = os.environ.get('RD_CONFIG_TYPE')
data["yaml"] = os.environ.get('RD_CONFIG_YAML')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
common.connect()
try:
if data["type"] == "Deployment":
dep = yaml.safe_load(data["yaml"])
api_instance = client.AppsV1Api()
resp = api_instance.create_namespaced_deployment(
body=dep, namespace=data["namespace"], pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "ConfigMap":
api_instance = client.CoreV1Api()
dep = yaml.safe_load(data["yaml"])
resp = api_instance.create_namespaced_config_map(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.metadata))
if data["type"] == "StatefulSet":
dep = yaml.safe_load(data["yaml"])
k8s_beta = client.AppsV1Api()
resp = k8s_beta.create_namespaced_stateful_set(
body=dep, namespace=data["namespace"], pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "Service":
api_instance = client.CoreV1Api()
dep = yaml.safe_load(data["yaml"])
resp = api_instance.create_namespaced_service(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "Ingress":
dep = yaml.safe_load(data["yaml"])
k8s_beta = client.ExtensionsV1beta1Api()
resp = k8s_beta.create_namespaced_ingress(
body=dep, namespace=data["namespace"], pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "Job":
api_instance = client.BatchV1Api()
dep = yaml.safe_load(data["yaml"])
resp = api_instance.create_namespaced_job(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "StorageClass":
dep = yaml.safe_load(data["yaml"])
api_instance = client.StorageV1Api()
resp = api_instance.create_storage_class(body=dep, pretty="true")
print(common.parseJson(resp.metadata))
if data["type"] == "PersistentVolumeClaim":
dep = yaml.safe_load(data["yaml"])
api_instance = client.CoreV1Api()
resp = api_instance.create_namespaced_persistent_volume_claim(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "Secret":
dep = yaml.safe_load(data["yaml"])
api_instance = client.CoreV1Api()
resp = api_instance.create_namespaced_secret(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.metadata))
if data["type"] == "PersistentVolume":
dep = yaml.safe_load(data["yaml"])
api_instance = client.CoreV1Api()
resp = api_instance.create_persistent_volume(body=dep,
pretty="true")
print(common.parseJson(resp.status))
except ApiException:
log.exception("Exception error creating:")
sys.exit(1)
def wait():
data = {}
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
retries = int(os.environ.get('RD_CONFIG_RETRIES'))
sleep = int(os.environ.get('RD_CONFIG_SLEEP'))
try:
AppsV1Api = client.AppsV1Api()
api_response = AppsV1Api.read_namespaced_stateful_set(
data["name"], data["namespace"], pretty="True")
print(common.parseJson(api_response.status))
current_replicas = api_response.status.current_replicas
replicas = api_response.spec.replicas
ready_replicas = api_response.status.ready_replicas
if ready_replicas is None:
ready_replicas = 0
else:
ready_replicas = int(ready_replicas)
if replicas is None:
replicas = 0
else:
replicas = int(replicas)
retries_count = 0
if (replicas == ready_replicas):
log.info("Deployment is ready")
sys.exit(0)
while (ready_replicas < replicas):
log.info("waiting for StatefulSet")
time.sleep(float(sleep))
retries_count = retries_count + 1
if retries_count > retries:
log.error("number of retries exceeded")
sys.exit(1)
api_response = AppsV1Api.read_namespaced_stateful_set(
data["name"], data["namespace"], pretty="True")
replicas = api_response.spec.replicas
ready_replicas = api_response.status.ready_replicas
if ready_replicas is None:
ready_replicas = 0
else:
ready_replicas = int(ready_replicas)
if replicas is None:
replicas = 0
else:
replicas = int(replicas)
print(common.parseJson(api_response.status))
log.info("current_replicas" + str(replicas))
except ApiException:
log.exception("Exception deleting StatefulSet:")
sys.exit(1)
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
common.connect()
data = {}
data["api_version"] = os.environ.get('RD_CONFIG_API_VERSION')
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
data["container_name"] = os.environ.get('RD_CONFIG_CONTAINER_NAME')
data["container_image"] = os.environ.get('RD_CONFIG_CONTAINER_IMAGE')
data["image_pull_policy"] = os.environ.get('RD_CONFIG_IMAGE_PULL_POLICY')
if os.environ.get('RD_CONFIG_PARALLELISM'):
data["parallelism"] = os.environ.get('RD_CONFIG_PARALLELISM')
if os.environ.get('RD_CONFIG_LABELS'):
data["labels"] = os.environ.get('RD_CONFIG_LABELS')
if os.environ.get('RD_CONFIG_ANNOTATIONS'):
data["annotations"] = os.environ.get('RD_CONFIG_ANNOTATIONS')
if os.environ.get('RD_CONFIG_SELECTORS'):
data["selectors"] = os.environ.get('RD_CONFIG_SELECTORS')
if os.environ.get('RD_CONFIG_CONTAINER_COMMAND'):
cmd = os.environ.get('RD_CONFIG_CONTAINER_COMMAND')
data["container_command"] = cmd
if os.environ.get('RD_CONFIG_CONTAINER_ARGS'):
data["container_args"] = os.environ.get('RD_CONFIG_CONTAINER_ARGS')
if os.environ.get('RD_CONFIG_RESOURCES_REQUESTS'):
req = os.environ.get('RD_CONFIG_RESOURCES_REQUESTS')
data["resources_requests"] = req
if os.environ.get('RD_CONFIG_VOLUME_MOUNTS'):
data["volume_mounts"] = os.environ.get('RD_CONFIG_VOLUME_MOUNTS')
if os.environ.get('RD_CONFIG_VOLUMES'):
data["volumes"] = os.environ.get('RD_CONFIG_VOLUMES')
if os.environ.get('RD_CONFIG_JOB_RESTART_POLICY'):
rpolicy = os.environ.get('RD_CONFIG_JOB_RESTART_POLICY')
data["job_restart_policy"] = rpolicy
if os.environ.get('RD_CONFIG_COMPLETIONS'):
data["completions"] = os.environ.get('RD_CONFIG_COMPLETIONS')
if os.environ.get('RD_CONFIG_ACTIVE_DEADLINE_SECONDS'):
active_ds = os.environ.get('RD_CONFIG_ACTIVE_DEADLINE_SECONDS')
data["active_deadline_seconds"] = active_ds
if os.environ.get('RD_CONFIG_BACKOFF_LIMIT'):
backoff_limit = os.environ.get('RD_CONFIG_BACKOFF_LIMIT')
data["backoff_limit"] = backoff_limit
if os.environ.get('RD_CONFIG_ENVIRONMENTS'):
data["environments"] = os.environ.get('RD_CONFIG_ENVIRONMENTS')
if os.environ.get('RD_CONFIG_ENVIRONMENTS_SECRETS'):
esecret = os.environ.get('RD_CONFIG_ENVIRONMENTS_SECRETS')
data["environments_secrets"] = esecret
if os.environ.get('RD_CONFIG_IMAGEPULLSECRETS'):
data["image_pull_secrets"] = os.environ.get(
'RD_CONFIG_IMAGEPULLSECRETS')
if os.environ.get('RD_CONFIG_NODE_SELECTORS'):
node_selector = os.environ.get('RD_CONFIG_NODE_SELECTORS')
data["node_selector"] = node_selector
if os.environ.get('RD_CONFIG_TOLERATIONS'):
tolerations = os.environ.get('RD_CONFIG_TOLERATIONS')
data["tolerations"] = tolerations
if os.environ.get('RD_CONFIG_ENV_FROM'):
env_from = os.environ.get('RD_CONFIG_ENV_FROM')
data["env_from"] = env_from
log.debug("Creating job")
log.debug(data)
job = create_job_object(data)
log.debug("new job: ")
log.debug(job)
try:
k8s_client = client.BatchV1Api()
api_response = k8s_client.create_namespaced_job(
body=job, namespace=data["namespace"])
print(common.parseJson(api_response.status))
except ApiException as e:
log.error("Exception creating job: %s\n" % e)
sys.exit(1)
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
data = {}
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["type"] = os.environ.get('RD_CONFIG_TYPE')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
common.connect()
try:
if data["type"] == "Deployment":
k8s_beta = client.ExtensionsV1beta1Api()
resp = k8s_beta.delete_namespaced_deployment(
name=data["name"],
namespace=data["namespace"],
body=client.V1DeleteOptions(propagation_policy='Foreground',
grace_period_seconds=5),
pretty="true")
if data["type"] == "ConfigMap":
k8s_beta = client.CoreV1Api()
resp = k8s_beta.delete_namespaced_config_map(
name=data["name"],
namespace=data["namespace"],
body=client.V1DeleteOptions(propagation_policy='Foreground',
grace_period_seconds=5),
pretty="true")
if data["type"] == "StatefulSet":
k8s_beta = client.AppsV1Api()
resp = k8s_beta.delete_namespaced_stateful_set(
name=data["name"],
namespace=data["namespace"],
body=client.V1DeleteOptions(propagation_policy='Foreground',
grace_period_seconds=5),
pretty="true")
if data["type"] == "Service":
api_instance = client.CoreV1Api()
resp = api_instance.delete_namespaced_service(
namespace=data["namespace"],
name=data["name"],
body=client.V1DeleteOptions(propagation_policy='Foreground',
grace_period_seconds=5),
pretty="true")
if data["type"] == "Ingress":
k8s_beta = client.ExtensionsV1beta1Api()
body = client.V1DeleteOptions()
resp = k8s_beta.delete_namespaced_ingress(
name=data["name"],
namespace=data["namespace"],
body=body,
pretty="true")
if data["type"] == "Job":
api_instance = client.BatchV1Api()
resp = api_instance.delete_namespaced_job(
name=data["name"],
namespace=data["namespace"],
body=client.V1DeleteOptions(api_version='v1',
kind="DeleteOptions",
propagation_policy="Background"),
pretty="true")
if data["type"] == "StorageClass":
api_instance = client.StorageV1Api()
resp = api_instance.delete_storage_class(
name=data["name"],
body=client.V1DeleteOptions(),
pretty="true")
if data["type"] == "PersistentVolumeClaim":
api_instance = client.CoreV1Api()
resp = api_instance.delete_namespaced_persistent_volume_claim(
namespace=data["namespace"],
body=client.V1DeleteOptions(),
name=data["name"],
pretty="true")
if data["type"] == "Secret":
api_instance = client.CoreV1Api()
resp = api_instance.delete_namespaced_secret(
namespace=data["namespace"],
name=data["name"],
body=client.V1DeleteOptions(),
pretty="true")
if data["type"] == "PersistentVolume":
api_instance = client.CoreV1Api()
resp = api_instance.delete_persistent_volume(
name=data["name"],
body=client.V1DeleteOptions(),
pretty="true")
print(common.parseJson(resp))
except ApiException as e:
log.error("Exception error creating: %s\n" % e)
sys.exit(1)
