def main():
contexts, active_context = config.list_kube_config_contexts()
if not contexts:
print("Cannot find any context in kube-config file.")
return
contexts = [context['name'] for context in contexts]
active_index = contexts.index(active_context['name'])
cluster1, first_index = pick(contexts, title="Pick the first context",
default_index=active_index)
cluster2, _ = pick(contexts, title="Pick the second context",
default_index=first_index)
client1 = client.CoreV1Api(
api_client=config.new_client_from_config(context=cluster1))
client2 = client.CoreV1Api(
api_client=config.new_client_from_config(context=cluster2))
print("\nList of pods on %s:" % cluster1)
for i in client1.list_pod_for_all_namespaces().items:
print("%s\t%s\t%s" %
(i.status.pod_ip, i.metadata.namespace, i.metadata.name))
print("\n\nList of pods on %s:" % cluster2)
for i in client2.list_pod_for_all_namespaces().items:
print("%s\t%s\t%s" %
(i.status.pod_ip, i.metadata.namespace, i.metadata.name))
def main():
contexts, active_context = config.list_kube_config_contexts()
if not contexts:
print("Cannot find any context in kube-config file.")
return
contexts = [context['name'] for context in contexts]
active_index = contexts.index(active_context['name'])
cluster1, first_index = pick(contexts,
title="Pick the first context",
default_index=active_index)
cluster2, _ = pick(contexts,
title="Pick the second context",
default_index=first_index)
client1 = client.CoreV1Api(api_client=config.new_client_from_config(
context=cluster1))
client2 = client.CoreV1Api(api_client=config.new_client_from_config(
context=cluster2))
print("\nList of pods on %s:" % cluster1)
for i in client1.list_pod_for_all_namespaces().items:
print("%s\t%s\t%s" %
(i.status.pod_ip, i.metadata.namespace, i.metadata.name))
print("\n\nList of pods on %s:" % cluster2)
for i in client2.list_pod_for_all_namespaces().items:
print("%s\t%s\t%s" %
(i.status.pod_ip, i.metadata.namespace, i.metadata.name))
def load_kube_credentials_gcloud(credentials: Dict[str, str]) -> ApiClient:
# Try to pull credentials from gcloud, but first checking if there
# is a context, using their auto generated naming scheme, to avoid
# calling `gcloud` every time, if we've already authed before.
from subprocess import check_call, DEVNULL
cluster = credentials["cluster"]
project = credentials["project"]
zone = credentials["zone"]
context = f"gke_{project}_{zone}_{cluster}"
try:
return new_client_from_config(context=context)
except (ConfigException, FileNotFoundError):
pass
check_call(
[
"gcloud",
"container",
"clusters",
"get-credentials",
cluster,
"--zone",
zone,
"--project",
project,
],
stdout=DEVNULL,
stderr=DEVNULL,
)
return new_client_from_config(context=context)
def pick_cluster(self, cluster_name: str = None):
"""
Pick the cluster you will scale the workload
"""
try:
# Load the context in kube-config file
contexts, active_context = config.list_kube_config_contexts(config_file=self.kube_config)
config.load_incluster_config()
self.logger.debug(f"contexts: {contexts}, active_context: {active_context}")
if not contexts:
self.logger.error("Cannot locate any context in kube-config file")
return
contexts = [context['name'] for context in contexts]
self.logger.debug(f"context list: {contexts}")
if cluster_name is None:
cluster_name = active_context['name']
target_cluster_index = next((i for i, j in enumerate(contexts) if cluster_name in j), None)
if target_cluster_index is None:
self.logger.error(f"Cannot find {cluster_name} in {contexts}")
return
picked_cluster = contexts[target_cluster_index]
self.logger.debug(f"Picked cluster: {picked_cluster}")
return {
'core_v1': client.CoreV1Api(
api_client=config.new_client_from_config(config_file=self.kube_config, context=picked_cluster)
),
'apps_v1': client.AppsV1Api(
api_client=config.new_client_from_config(config_file=self.kube_config, context=picked_cluster)
),
}
except Exception as e:
self.logger.error(f"Can't pick a cluster: {e}")
raise e
def main():
source_pods = []
contexts, active_context = config.list_kube_config_contexts()
if not contexts:
print("Cannot find any context in kube-config file.")
return
contexts = [context['name'] for context in contexts]
active_index = contexts.index(active_context['name'])
cluster1, first_index = pick(contexts, title="Pick the source Cluster Context for the POD to be backed up",
default_index=active_index)
client1 = client.CoreV1Api(
api_client=config.new_client_from_config(context=cluster1))
# TK - Added to setup
source_pods = [i.metadata.name for i in client1.list_pod_for_all_namespaces().items]
print("\nList of source_pods on %s:" % source_pods)
selected_pod = pick(source_pods, title="Pick the POD to be backed up")
for i in client1.list_pod_for_all_namespaces().items:
if selected_pod[0] == i.metadata.name: # Return the Kubernetes API POD object
print("Found the POD Object for Selected POD")
source_pod_object = i
print(type(source_pod_object))
print ('This is the POD you selected {0}'.format(source_pod_object.metadata.name))
labels = source_pod_object.metadata.
# Original Code for listing pods
print("\nList of pods on %s:" % cluster1)
for i in client1.list_pod_for_all_namespaces().items:
print("%s\t%s\t%s" % (i.status.pod_ip, i.metadata.namespace, i.metadata.name))
cluster2, _ = pick(contexts, title="Pick the target Cluster Context for the POD to be restored to",
default_index=first_index)
client2 = client.CoreV1Api(
api_client=config.new_client_from_config(context=cluster2))
'''
def delete_pipeline(self, uuid=None, name=None, namespace="moon",
active_context=None,
active_context_name=None):
"""Delete a pipeline
:param uuid:
:param name:
:param namespace:
:param active_context:
:param active_context_name:
:return:
"""
name_to_delete = None
if uuid and uuid in self.get_pods():
name_to_delete = self.get_pods()[uuid][0]['name']
elif name:
for pod_key, pod_list in self.get_pods().items():
for pod_value in pod_list:
if pod_value.get("name") == name:
name_to_delete = pod_value.get("name")
break
if not name_to_delete:
raise exceptions.PipelineUnknown
logger.info("Will delete deployment and service named {}".format(name_to_delete))
contexts, _active_context = self.get_contexts()
if active_context_name:
for _context in contexts:
if _context["name"] == active_context_name:
active_context = _context
break
if active_context:
active_context = _active_context
_config = config.new_client_from_config(
context=active_context['name'])
logger.debug("_config={}".format(_config))
api_client = client.CoreV1Api(_config)
ext_client = client.ExtensionsV1beta1Api(_config)
self.delete_deployment(name=name_to_delete, namespace=namespace,
ext_client=ext_client)
self.delete_service(name=name_to_delete, api_client=api_client)
return
logger.debug("contexts={}".format(contexts))
for _ctx in contexts:
_config = config.new_client_from_config(context=_ctx['name'])
logger.debug("_config={}".format(_config))
api_client = client.CoreV1Api(_config)
ext_client = client.ExtensionsV1beta1Api(_config)
self.delete_deployment(name=name_to_delete, namespace=namespace,
ext_client=ext_client)
self.delete_service(name=name_to_delete, api_client=api_client)
def main():
parser = argparse.ArgumentParser(
description="ROSA Post install configuration for PerfScale CI")
parser.add_argument(
'--incluster',
default="false",
type=str,
help='Is this running from a pod within the cluster [true|false]')
parser.add_argument(
'--kubeconfig',
help='Optional kubeconfig location. Incluster cannot be true')
args = parser.parse_args()
if args.incluster.lower() == "true":
config.load_incluster_config()
k8s_config = client.Configuration()
k8s_client = client.api_client.ApiClient(configuration=k8s_config)
elif args.kubeconfig:
k8s_client = config.new_client_from_config(args.kubeconfig)
else:
k8s_client = config.new_client_from_config()
dyn_client = DynamicClient(k8s_client)
nodes = dyn_client.resources.get(api_version='v1', kind='Node')
if args.kubeconfig:
cmd = [
"oc get infrastructures.config.openshift.io cluster -o jsonpath={.status.infrastructureName} --kubeconfig "
+ args.kubeconfig
]
else:
cmd = [
"oc get infrastructures.config.openshift.io cluster -o jsonpath={.status.infrastructureName}"
]
process = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
stdout, stderr = process.communicate()
clustername = stdout.decode("utf-8")
# Remove worker label from infa nodes
_remove_worker_label(nodes)
# Add a workload label to one of the workers
_label_workload_machine(nodes)
# AWS configuration
_aws_config(nodes, clustername)
def __init__(self,
pod_name,
env_pod,
command,
image_namespace=None,
image_tag=None,
env=None,
env_container_id=0):
self.pod_name = pod_name if pod_name else "digdag-mds-job"
self.env_pod = env_pod if env_pod else "digdag-mds-job"
self.command = command if command else ["flask", "test-cli-command"]
self.env_container_id = env_container_id
# If env, creating container from scratch, pull from tools build suffix
if (env):
self.env = env
self.image = f"docker-registry.default.svc:5000/{image_namespace}/{self.env_pod}:build{self.suffix}"
# Else creating based on existing image and pod, requires tag
else:
self.env = None
self.image = f"docker-registry.default.svc:5000/{self.namespace}/{self.env_pod}:{self.image_tag}"
self.job_pod_name = self.pod_name + self.suffix
self.env_pod_name = self.env_pod + self.suffix
self.job_pod_label = f"name={self.job_pod_name}"
self.env_pod_label = f"name={self.env_pod_name}"
k8s_client = config.new_client_from_config(self.kube_config)
dyn_client = DynamicClient(k8s_client)
self.v1_pod = dyn_client.resources.get(api_version="v1", kind="Pod")
def getpvs(context):
try:
replystr = ""
cluster = context
api = client.CoreV1Api(api_client=config.new_client_from_config(
context=cluster))
pvs = api.list_persistent_volume()
replystr += ("---- PVs ---\n")
replystr += ("%-16s\t%-10s\t%-30s\t%-10s\t%-6s\n" %
("NAME", "STATUS", "CLAIM", "STORAGECLASS", "SIZE"))
for pv in pvs.items:
pvandpvc = ""
try:
if pv.spec.claim_ref.namespace is not None:
pvandpvc = pv.spec.claim_ref.namespace + "/" + pv.spec.claim_ref.name
except Exception as e:
pvandpvc = "Unassigned"
replystr += (
"%-16s\t%-10s\t%-30s\t%-10s\t%-6s\n" %
(pv.metadata.name, pv.status.phase, pvandpvc,
pv.spec.storage_class_name, pv.spec.capacity['storage']))
pvandpvc = ""
return replystr
except Exception as e:
print("error: ", e)
return '"message": {"error": "something borked in getpvs"}'
def patch_aws_node(Context: str, **kwargs):
while True:
response = choice("Do you want to patch the aws-node Daemonset(Yes/No)? This will trigger a rolling restart of the networking plugin: ")
if response == 'yes':
break
if response == 'no':
exit(1)
else:
print('Please enter "Yes" or "No".')
print('Patching aws-node daemonset')
if 'Clientset' in kwargs:
api_client = kwargs['Clientset']
AppsV1 = client.AppsV1Api(api_client)
else:
AppsV1 = client.AppsV1Api(api_client=config.new_client_from_config(context=Context))
patch = {
"spec": {
"template": {
"metadata": {
"annotations": {
"irsa": "enabled"
}
}
}
}
}
try:
AppsV1.patch_namespaced_daemon_set_with_http_info(name='aws-node', namespace='kube-system', body=patch)
except ApiException:
print('An error occurred while patching the aws-node Daemonset')
exit(1)
def testRunInKubernetes(self):
self._build_docker_images()
temp_spill_dir = tempfile.mkdtemp(prefix='test-mars-k8s-')
api_client = k8s_config.new_client_from_config()
kube_api = k8s_client.CoreV1Api(api_client)
cluster_client = None
try:
extra_vol_config = HostPathVolumeConfig('mars-src-path',
'/mnt/mars', MARS_ROOT)
cluster_client = new_cluster(
api_client,
image=self._docker_image,
worker_spill_paths=[temp_spill_dir],
extra_volumes=[extra_vol_config],
pre_stop_command=['rm', '/tmp/stopping.tmp'],
timeout=600,
log_when_fail=True)
self.assertIsNotNone(cluster_client.endpoint)
pod_items = kube_api.list_namespaced_pod(
cluster_client.namespace).to_dict()
log_processes = []
for item in pod_items['items']:
log_processes.append(
subprocess.Popen([
'kubectl', 'logs', '-f', '-n',
cluster_client.namespace, item['metadata']['name']
]))
a = mt.ones((100, 100), chunk_size=30) * 2 * 1 + 1
b = mt.ones((100, 100), chunk_size=30) * 2 * 1 + 1
c = (a * b * 2 + 1).sum()
r = cluster_client.session.run(c, timeout=600)
expected = (np.ones(a.shape) * 2 * 1 + 1)**2 * 2 + 1
assert_array_equal(r, expected.sum())
# turn off service processes with grace to get coverage data
procs = []
for item in pod_items['items']:
p = subprocess.Popen([
'kubectl', 'exec', '-n', cluster_client.namespace,
item['metadata']['name'], '/srv/graceful_stop.sh'
])
procs.append(p)
for p in procs:
p.wait()
[p.terminate() for p in log_processes]
finally:
shutil.rmtree(temp_spill_dir)
if cluster_client:
try:
cluster_client.stop(wait=True, timeout=20)
except TimeoutError:
pass
self._remove_docker_image(False)
def main():
conn = None
device_opt = [
"port", "namespace", "kubeconfig", "separator", "no_password"
]
define_new_opts()
options = check_input(device_opt, process_input(device_opt))
docs = {}
docs["shortdesc"] = "Fence agent for KubeVirt"
docs["longdesc"] = "fence_kubevirt is an I/O Fencing agent for KubeVirt."
docs["vendorurl"] = "https://kubevirt.io/"
show_docs(options, docs)
run_delay(options)
validate_options(['--namespace'], options)
try:
from kubernetes import config
from openshift.dynamic import DynamicClient
kubeconfig = options.get('--kubeconfig')
k8s_client = config.new_client_from_config(config_file=kubeconfig)
conn = DynamicClient(k8s_client)
except ImportError:
logging.error(
"Couldn\'t import kubernetes.config or "
"openshift.dynamic.DynamicClient - not found or not accessible")
# Operate the fencing device
result = fence_action(conn, options, set_power_status, get_power_status,
get_nodes_list)
sys.exit(result)
def create_connection(url):
"""
:Method to create connection with client
:param url:URL of each region
:return:dyn_client
"""
try:
if url is not None:
path = cae_lib.get_kube_config_path(url)
print("INFO: Kube Config's Path", path)
# looping for retrying connection attempts in case of server busy or hit 429 error due to too many requests
for i in range(0, 10):
try:
k8s_client = config.new_client_from_config(path)
dyn_client = DynamicClient(k8s_client)
except Exception as e:
exception_str = str(e)
if '429' in exception_str:
print(
"LOG: RETRYING upon receiving \"HTTP error 429 (Too Many Requests)\"",
str(exception_str))
time.sleep(5)
continue
break
except Exception as e:
print("ERROR: Fail to create connection handle: %s" % str(e))
return None
return dyn_client
def build_chamberlain_client(self):
"""
Build configmaps for chamberlain client.
"""
self.define_all_client_objects()
kube_client = k_config.new_client_from_config()
os_client = DynamicClient(kube_client)
if self.with_dv:
try:
config_map = os_client.resources.get(api_version='v1',
kind="ConfigMap")
api_response = config_map.create(
namespace=self.config['namespace'],
body=self.dv_config_map_body)
print("Created Dataverse ConfigMap: \n{} \n".format(
api_response))
except DynamicApiError as e:
print("Error creating Dataverse ConfigMap: \n{} \n".format(e))
if self.with_swift:
try:
config_map = os_client.resources.get(api_version='v1',
kind="ConfigMap")
api_response = config_map.create(
namespace=self.config['namespace'],
body=self.swift_config_map_body)
print("Created Swift ConfigMap: \n{} \n".format(api_response))
except DynamicApiError as e:
print("Error creating Swift ConfigMap: \n{} \n".format(e))
def api_client(cluster_name: str, api_class: str) -> k8s.client.apis:
"""
Creates and returns a python k8s api client of the specified class and pointing to the specified cluster.
Usage: Use this function whenever you want a python k8s api client.
Python k8s api documentation: https://github.com/kubernetes-client/python/blob/master/kubernetes/README.md
:param (str) cluster_name
:param (str) api_class, e.g. "CoreV1Api"
:return: (k8s.client.apis object) python k8s api client object
"""
# retrieve name of context that points to the given cluster
target_context = k8s_config.context_for_cluster(cluster_name)
if target_context == None:
print("No valid context could be found for cluster with name",
cluster_name + ".")
print(
"As of most recent update, you have access to the following clusters:",
k8s_config.all_cluster_names())
return
new_client = config.new_client_from_config(context=target_context)
# check if given api_class is a valid k8s api class
try:
api_client = eval("client." + api_class + "(api_client = new_client)")
except AttributeError as e:
print("No known API class could be found with name", api_class + ".")
print(
"API classes can be found here: https://github.com/kubernetes-client/python/blob/master/kubernetes/README.md"
)
return
return api_client
def get_api_clients(self, resource_config):
"""Get API Clients.
:param cloudshell.cp.kubernetes.resource_config.
KubernetesResourceConfig resource_config:
"""
if not os.path.isfile(resource_config.config_file_path):
raise ValueError(
"Config File Path is invalid. Cannot open file '{}'.".format(
resource_config.config_file_path))
# todo - alexaz - Need to add support for urls so that we can
# download a config file from a central location and
# todo - also have the config file password protected.
if resource_config.aws_access_key_id and resource_config.aws_secret_access_key:
self._logger.debug(
"EKS config for, key-ID {}, secret-key {}".format(
resource_config.aws_access_key_id,
resource_config.aws_secret_access_key,
))
api_client = self._new_client_from_eks_config(
resource_config.config_file_path,
resource_config.aws_access_key_id,
resource_config.aws_secret_access_key,
)
else:
api_client = new_client_from_config(
config_file=resource_config.config_file_path)
core_api = CoreV1Api(api_client=api_client)
apps_api = AppsV1Api(api_client=api_client)
return KubernetesClients(api_client, core_api, apps_api)
def explore_kubernetes_system() -> DiscoveredSystemInfo:
"""
Fetch information from the current Kubernetes context.
"""
logger.info("Discovering Kubernetes system")
if not has_local_config_file():
logger.warn("Could not locate the default kubeconfig file")
return
api = config.new_client_from_config()
v1core = client.CoreV1Api(api)
v1ext = client.ExtensionsV1beta1Api(api)
ret = v1core.list_namespace(_preload_content=False)
namespaces = ret.read()
info = {}
for ns in json.loads(namespaces)["items"]:
ret = v1core.list_namespaced_pod(namespace=ns["metadata"]["name"],
_preload_content=False)
info["pods"] = json.loads(ret.read())
ret = v1ext.list_namespaced_deployment(
namespace=ns["metadata"]["name"], _preload_content=False)
info["deployments"] = json.loads(ret.read())
return info
def cpvc(context, namespace, pvcname, pvname):
try:
cluster = context
api = client.CoreV1Api(api_client=config.new_client_from_config(
context=cluster))
ns = namespace
nm = pvcname
vn = pvname
my_resource = {
"apiVersion": "v1",
"kind": "PersistentVolumeClaim",
"metadata": {
"name": nm,
"namespace": ns
},
"spec": {
"volumeName": vn,
"accessModes": ["ReadWriteMany"],
"resources": {
"requests": {
"storage": "1Gi"
}
}
}
}
pvcs = api.create_namespaced_persistent_volume_claim(namespace=ns,
body=my_resource)
output = str(pvcs) + "\n"
return output
except Exception as e:
return ("Exception: ", str(e))
def __init__(
self,
conf: str,
namespace: str,
meta: t.Dict,
spec_path: str,
override: str = None,
) -> None:
"""Manages deployment.
Args:
conf (str): Path to Kubernetes config.
namespace (str): Kubernetes namespace.
meta (t.Dict): Spec variables.
spec_path (str): Location of chart to deploy.
override (str): Override specific resource file, defaults to
`resource.override.yaml` where one has `resource.yaml`.
"""
self.client: k8s.ApiClient = config.new_client_from_config(conf)
# Disable threadding pool inside swagger client
# because it causes problems with other multithreading workers
# as we don't use any async calls we are safe to do so.
self.client.pool.close()
self.client.pool.join()
self.meta = meta
self.namespace = namespace
self.override = override if override else "override"
self.spec_path = spec_path
def apiclient(self):
homedir = os.path.expanduser("˜")
if os.path.exists(
'/var/run/secrets/kubernetes.io/serviceaccount/token'):
with open('/var/run/secrets/kubernetes.io/serviceaccount/token'
) as tokenfile:
token = tokenfile.read()
aConfiguration = client.Configuration()
aConfiguration.host = "https://kubernetes.default.svc"
if os.path.exists(
'/var/run/secrets/kubernetes.io/serviceaccount/ca.crt'):
aConfiguration.verify_ssl = True
aConfiguration.ssl_ca_cert = '/var/run/secrets/kubernetes.io/serviceaccount/ca.crt'
else:
aConfiguration.verify_ssl = False
aConfiguration.api_key = {"authorization": "Bearer " + token}
logging.info('Initiating kubeapi session with auth token...')
apiclient = client.ApiClient(aConfiguration)
return apiclient
elif os.path.exists(homedir + '/.kube/config'):
config.verify_ssl = False
k8sclient = config.new_client_from_config()
logging.info('Found kubeconfig file on ' + homedir +
'/.kube/config')
return k8sclient
else:
raise Exception(
'Unauthorized: No kubeconfig file or bearer token found so cannot instantiate client instance'
)
def create_wrappers(self, slave_name=None):
contexts, active_context = self.get_contexts()
logger.debug("contexts: {}".format(contexts))
logger.debug("active_context: {}".format(active_context))
conf = configuration.get_configuration("components/wrapper")
hostname = conf["components/wrapper"].get(
"hostname", "wrapper")
port = conf["components/wrapper"].get("port", 80)
container = conf["components/wrapper"].get(
"container",
"wukongsun/moon_wrapper:v4.3")
for _ctx in contexts:
if slave_name and slave_name != _ctx['name']:
continue
_config = config.new_client_from_config(context=_ctx['name'])
logger.debug("_config={}".format(_config))
api_client = client.CoreV1Api(_config)
ext_client = client.ExtensionsV1beta1Api(_config)
data = [{
"name": hostname + "-" + get_random_name(),
"container": container,
"port": port,
"namespace": "moon",
"slave_name": _ctx['name']
}, ]
self.load_deployment_and_service(data, api_client, ext_client, expose=True)
def checkMe(self):
ret = Service.FAIL
extra = None
try:
k8s = client.CoreV1Api(api_client=config.new_client_from_config(
context=self.context))
list_nodes = k8s.list_node(watch=False)
unknowns = 0
nodes = 0
for item in list_nodes.items:
if 'Unknown' in [x.status for x in item.status.conditions]:
unknowns = unknowns + 1
nodes = nodes + 1
if nodes > 0 and (100 -
(unknowns * 100 / nodes)) >= self.availability:
ret = Service.OK
else:
# FAIL so inform about the number of nodes availables or not
extra = {"ready": nodes - unknowns, "unknown": unknowns}
except Exception as e:
extra = {"exception": str(e)}
return super().checkMe(ret, extra)
def _start_kube_cluster(**kwargs):
image_name = _build_docker_images()
temp_spill_dir = tempfile.mkdtemp(prefix='test-mars-k8s-')
api_client = k8s_config.new_client_from_config()
kube_api = k8s_client.CoreV1Api(api_client)
cluster_client = None
try:
extra_vol_config = HostPathVolumeConfig('mars-src-path', '/mnt/mars',
MARS_ROOT)
cluster_client = new_cluster(
api_client,
image=image_name,
worker_spill_paths=[temp_spill_dir],
extra_volumes=[extra_vol_config],
pre_stop_command=['rm', '/tmp/stopping.tmp'],
timeout=600,
log_when_fail=True,
**kwargs)
assert cluster_client.endpoint is not None
pod_items = kube_api.list_namespaced_pod(
cluster_client.namespace).to_dict()
log_processes = []
for item in pod_items['items']:
log_processes.append(
subprocess.Popen([
'kubectl', 'logs', '-f', '-n', cluster_client.namespace,
item['metadata']['name']
]))
yield
# turn off service processes with grace to get coverage data
procs = []
pod_items = kube_api.list_namespaced_pod(
cluster_client.namespace).to_dict()
for item in pod_items['items']:
p = subprocess.Popen([
'kubectl', 'exec', '-n', cluster_client.namespace,
item['metadata']['name'], '--', '/srv/graceful_stop.sh'
])
procs.append(p)
for p in procs:
p.wait()
[p.terminate() for p in log_processes]
finally:
shutil.rmtree(temp_spill_dir)
if cluster_client:
try:
cluster_client.stop(wait=True, timeout=20)
except TimeoutError:
pass
_collect_coverage()
_remove_docker_image(image_name, False)
def k8s_client(self):
"""
Return k8s_client instance for specific openshift cluster based on kube_config_file attribute
:return: Instance of K8s_client
"""
if self.kube_config_file and self.kube_config_file not in OcpBase.k8s_clients:
OcpBase.k8s_clients[self.kube_config_file] = config.new_client_from_config(str(self.kube_config_file))
return OcpBase.k8s_clients.get(self.kube_config_file)
def __init__(self, config_file='/etc/kubernetes/admin.conf', logger=None):
self.api_client = config.new_client_from_config(config_file)
self.api_client.config.assert_hostname = False
self.v1_h = client.CoreV1Api(self.api_client)
self.v1_h.read_namespace('default')
self.v1_beta_h = client.ExtensionsV1beta1Api(self.api_client)
self.logger = logger or contrail_logging.getLogger(__name__)
def __init__(self, spec, name_generator=None, atomic_inst=None):
super(KubernetesService, self).__init__(None,
name_generator=name_generator,
atomic_inst=atomic_inst)
self._spec = spec
apiclient = config.new_client_from_config(spec.get("config_file"))
self.api = core_v1_api.CoreV1Api(api_client=apiclient)
self.events = []
def client_from_config(config_file, context):
# TODO(fabianvf): probably want to break this branch out or refactor method names
try:
return config.new_client_from_config(config_file, context)
except (IOError, config.ConfigException):
if not config_file:
return ApiClient(configuration=Configuration())
else:
raise
def __init__(self, config_file='/etc/kubernetes/admin.conf', logger=None):
self.api_client = config.new_client_from_config(config_file)
self.api_client.configuration.assert_hostname = False
self.v1_h = client.CoreV1Api(self.api_client)
self.v1_h.read_namespace('default')
self.v1_beta_h = client.ExtensionsV1beta1Api(self.api_client)
self.apps_v1_beta1_h = client.AppsV1beta1Api(self.api_client)
self.logger = logger or contrail_logging.getLogger(__name__)
def get_pods_for_context(context, name):
try:
kube = client.CoreV1Api(config.new_client_from_config(context=context))
pod_dicts = [pod.to_dict()
for pod in kube.list_pod_for_all_namespaces(watch=False,
field_selector='metadata.namespace!=kube-system').items]
except (kubernetes.client.rest.ApiException, kubernetes.config.config_exception.ConfigException):
return []
return [pod for pod in pod_dicts if re.match(name, pod['metadata']['name'])]
def _load_user_config(self, user):
if user not in self.user_configs:
raise Exception("{} not found in configs".format(user))
self.user = user
if user not in self.api_cache:
c = config.new_client_from_config(self.user_configs[self.user])
self.api_cache[user] = (client.CoreV1Api(c),
client.ExtensionsV1beta1Api(c))
self.apiV1, self.apiV1beta1 = self.api_cache[user]
def dpv(cluster, pvname):
try:
api = client.CoreV1Api(api_client=config.new_client_from_config(context=cluster))
pvn = pvname
dpvs = api.delete_persistent_volume(name=pvn)
output = str(dpvs) + "\n"
return output
except Exception as e:
return("Exception e: ", str(e))
def get_ocp_secrets(namespace, in_cluster):
if in_cluster:
config.load_incluster_config()
k8s_client = client.ApiClient()
else:
k8s_client = config.new_client_from_config()
_client = DynamicClient(k8s_client)
v1_secrets = _client.resources.get(api_version='v1', kind='Secret')
return v1_secrets.get(namespace=namespace).items
def __init__(self, config_file='/etc/kubernetes/admin.conf', logger=None):
super(Client, self).__init__(config_file, logger)
#Creating Dynamic API client
k8s_client = config.new_client_from_config(config_file)
dyn_client = DynamicClient(k8s_client)
self.pod_h = dyn_client.resources.get(api_version='v1', kind='Pod')
self.namespace_h = dyn_client.resources.get(api_version='v1', kind='Namespace')
self.network_policy_h = dyn_client.resources.get(api_version='v1', kind='NetworkPolicy')
self.deployment_h = dyn_client.resources.get(api_version='v1', kind='Deployment')
self.service_h = dyn_client.resources.get(api_version='v1', kind='Service')
def _load_kube_config(in_cluster, cluster_context):
from kubernetes import config, client
if in_cluster:
config.load_incluster_config()
return client.CoreV1Api()
else:
if cluster_context is None:
config.load_kube_config()
return client.CoreV1Api()
else:
return client.CoreV1Api(
api_client=config.new_client_from_config(context=cluster_context))
def get_fernet_key(composer_env):
print("Retrieving fernet key for Composer Environment {}.".format(
composer_env.get('name', '')))
gke_cluster_resource = composer_env.get("config", {}).get("gkeCluster")
project_zone_cluster = re.match(
"projects/([^/]*)/zones/([^/]*)/clusters/([^/]*)", gke_cluster_resource
).groups()
tmp_dir_name = None
try:
print("Getting cluster credentials {} to retrieve fernet key.".format(
gke_cluster_resource))
tmp_dir_name = tempfile.mkdtemp()
kubeconfig_file = tmp_dir_name + "/config"
os.environ["KUBECONFIG"] = kubeconfig_file
if subprocess.call(
[
"gcloud",
"container",
"clusters",
"get-credentials",
project_zone_cluster[2],
"--zone",
project_zone_cluster[1],
"--project",
project_zone_cluster[0]
]
):
print("Failed to retrieve cluster credentials: {}.".format(
gke_cluster_resource))
sys.exit(1)
kubernetes_client = client.CoreV1Api(
api_client=config.new_client_from_config(
config_file=kubeconfig_file))
airflow_configmap = kubernetes_client.read_namespaced_config_map(
"airflow-configmap", "default")
config_str = airflow_configmap.data['airflow.cfg']
with contextlib.closing(six.StringIO(config_str)) as config_buffer:
config_parser = configparser.ConfigParser()
config_parser.readfp(config_buffer)
return config_parser.get("core", "fernet_key")
except Exception as exc:
print("Failed to get fernet key for cluster: {}.".format(str(exc)))
sys.exit(1)
finally:
if tmp_dir_name:
shutil.rmtree(tmp_dir_name)
