def create_secret_in_namespace_if_not_exist(self, payload, namespace):
if self.in_cluster:
config.load_incluster_config()
else:
config.load_kube_config(config_file="~/.kube/config")
try:
api_instance = client.CoreV1Api()
api_instance.read_namespaced_secret(payload['metadata']['name'],
namespace)
except ApiException as e:
if e.status == 404:
try:
api_instance = client.CoreV1Api()
meta_data = client.V1ObjectMeta()
meta_data.name = payload['metadata']['name']
body = client.V1Secret(metadata=meta_data,
data=payload['data'])
api_instance.create_namespaced_secret(namespace, body)
except ApiException as create_e:
logger.error(
"Exception when calling CoreV1Api->create_namespaced_secret: %s\n"
% create_e)
sys.exit(1)
else:
logger.error(
"Exception when calling CoreV1Api->read_namespaced_secret: %s\n"
% e)
sys.exit(1)
def __init__(self, config):
k8_config = client.Configuration()
k8_config.host = config.k8_host
k8_config.verify_ssl = False
k8_config.api_key = {"authorization": "Bearer " + config.k8_token}
k8_client = client.ApiClient(k8_config)
self.k8 = client.CoreV1Api(k8_client)
self.config = config
def create_group_if_not_exist(self, name):
if self.in_cluster:
config.load_incluster_config()
else:
config.load_kube_config(config_file="~/.kube/config")
try:
api_instance = client.CoreV1Api()
api_instance.read_namespace(name)
except ApiException as e:
if e.status == 404:
api_instance = client.CoreV1Api()
meta_data = client.V1ObjectMeta()
meta_data.name = name
body = client.V1Namespace(metadata=meta_data)
api_instance.create_namespace(body)
return True
logger.error("Failed to create namespace [{0}]".format(name))
sys.exit(1)
return False
def __init__(self, knative_config):
self.log_level = os.getenv('PYWREN_LOGLEVEL')
self.name = 'knative'
self.knative_config = knative_config
self.endpoint = self.knative_config.get('endpoint')
self.service_hosts = {}
# k8s config can be incluster, in ~/.kube/config or generate kube-config.yaml file and
# set env variable KUBECONFIG=<path-to-kube-confg>
try:
config.load_kube_config()
current_context = config.list_kube_config_contexts()[1].get('context')
self.namespace = current_context.get('namespace', 'default')
self.cluster = current_context.get('cluster')
except Exception:
config.load_incluster_config()
self.namespace = 'default'
self.cluster = 'default'
self.api = client.CustomObjectsApi()
self.v1 = client.CoreV1Api()
self.headers = {'content-type': 'application/json'}
if self.endpoint is None:
try:
ingress = self.v1.read_namespaced_service('istio-ingressgateway', 'istio-system')
http_port = list(filter(lambda port: port.port == 80, ingress.spec.ports))[0].node_port
https_port = list(filter(lambda port: port.port == 443, ingress.spec.ports))[0].node_port
if ingress.status.load_balancer.ingress is not None:
# get loadbalancer ip
ip = ingress.status.load_balancer.ingress[0].ip
else:
# for minikube or a baremetal cluster that has no external load balancer
node = self.v1.list_node()
ip = node.items[0].status.addresses[0].address
self.endpoint = 'http://{}:{}'.format(ip, http_port)
except Exception as e:
log_msg = "Something went wrong getting the istio-ingressgateway endpoint: {}".format(e)
logger.info(log_msg)
self.serice_host_filename = os.path.join(CACHE_DIR, 'knative', self.cluster, 'service_host')
self.service_host_suffix = None
if os.path.exists(self.serice_host_filename):
serice_host_data = load_yaml_config(self.serice_host_filename)
self.service_host_suffix = serice_host_data['service_host_suffix']
logger.debug('Loaded service host suffix: {}'.format(self.service_host_suffix))
log_msg = 'PyWren v{} init for Knative - Endpoint: {}'.format(__version__, self.endpoint)
if not self.log_level:
print(log_msg)
logger.info(log_msg)
def list_all_secrets_from_namespace(self, namespace):
if self.in_cluster:
config.load_incluster_config()
else:
config.load_kube_config(config_file="~/.kube/config")
try:
api_instance = client.CoreV1Api()
api_response = api_instance.list_namespaced_secret(namespace)
return api_response.items
except ApiException as e:
if e.status == 404:
return []
logger.error('Exception when calling CoreV1Api->list_namespaced_secret: %s\n' % e)
sys.exit(1)
def poll_config(self):
configmap = client.CoreV1Api().read_namespaced_config_map(
namespace=self.namespace,
name='vcenter-operator')
password = configmap.data.pop('password')
for key, value in configmap.data.items():
try:
self.global_options[key] = json.loads(value)
except ValueError:
self.global_options[key] = value
if self.password != password:
self.global_options.update(master_password=password)
self.password = password
self.mpw = MasterPassword(self.username, self.password)
self.setup_os_session()
def replace_secret_in_namespace(self, payload, namespace):
if self.in_cluster:
config.load_incluster_config()
else:
config.load_kube_config(config_file="~/.kube/config")
try:
api_instance = client.CoreV1Api()
meta_data = client.V1ObjectMeta()
meta_data.name = payload['metadata']['name']
body = client.V1Secret(metadata=meta_data, data=payload['data'])
# don't use patch, which can't handle empty string: https://github.com/kubernetes/kubernetes/issues/37216
api_instance.replace_namespaced_secret(payload['metadata']['name'],
namespace, body)
except ApiException as e:
logger.error(
"Exception when calling CoreV1Api->patch_namespaced_secret: %s\n"
% e)
sys.exit(1)
def __init__(self, knative_config):
self.log_level = os.getenv('CB_LOG_LEVEL')
self.name = 'knative'
self.knative_config = knative_config
self.endpoint = self.knative_config.get('endpoint')
self.service_hosts = {}
# k8s config can be in ~/.kube/config or generate kube-config.yml file and
# set env variable KUBECONFIG=<path-to-kube-confg>
config.load_kube_config()
self.api = client.CustomObjectsApi()
self.v1 = client.CoreV1Api()
self.headers = {'content-type': 'application/json'}
if self.endpoint is None:
try:
ingress = self.v1.read_namespaced_service('istio-ingressgateway', 'istio-system')
http_port = list(filter(lambda port: port.port == 80, ingress.spec.ports))[0].node_port
https_port = list(filter(lambda port: port.port == 443, ingress.spec.ports))[0].node_port
if ingress.status.load_balancer.ingress is not None:
# get loadbalancer ip
ip = ingress.status.load_balancer.ingress[0].ip
else:
# for minikube or a baremetal cluster that has no external load balancer
node = self.v1.list_node()
ip = node.items[0].status.addresses[0].address
self.endpoint = 'http://{}:{}'.format(ip, http_port)
except Exception as e:
raise Exception("Something went wrong getting the istio-ingressgateway endpoint: {}".format(e))
log_msg = 'PyWren v{} init for Knative Serving - Endpoint: {}'.format(__version__, self.endpoint)
logger.info(log_msg)
if not self.log_level:
print(log_msg)
logger.debug('Knative Serving init for endpoint: {}'.format(self.endpoint))
def __init__(self, knative_config, storage_config):
self.log_active = logger.getEffectiveLevel() != logging.WARNING
self.name = 'knative'
self.knative_config = knative_config
self.istio_endpoint = self.knative_config.get('istio_endpoint')
# k8s config can be incluster, in ~/.kube/config or generate kube-config.yaml file and
# set env variable KUBECONFIG=<path-to-kube-confg>
try:
config.load_kube_config()
current_context = config.list_kube_config_contexts()[1].get(
'context')
self.namespace = current_context.get('namespace', 'default')
self.cluster = current_context.get('cluster')
self.knative_config['namespace'] = self.namespace
self.knative_config['cluster'] = self.cluster
self.is_incluster = False
except Exception:
config.load_incluster_config()
self.namespace = self.knative_config.get('namespace', 'default')
self.cluster = self.knative_config.get('cluster', 'default')
self.is_incluster = True
self.api = client.CustomObjectsApi()
self.v1 = client.CoreV1Api()
if self.istio_endpoint is None:
try:
ingress = self.v1.read_namespaced_service(
'istio-ingressgateway', 'istio-system')
http_port = list(
filter(lambda port: port.port == 80,
ingress.spec.ports))[0].node_port
# https_port = list(filter(lambda port: port.port == 443, ingress.spec.ports))[0].node_port
if ingress.status.load_balancer.ingress is not None:
# get loadbalancer ip
ip = ingress.status.load_balancer.ingress[0].ip
else:
# for minikube or a baremetal cluster that has no external load balancer
node = self.v1.list_node()
ip = node.items[0].status.addresses[0].address
self.istio_endpoint = 'http://{}:{}'.format(ip, http_port)
self.knative_config['istio_endpoint'] = self.istio_endpoint
except Exception:
logger.info("istio-ingressgateway endpoint not found")
if 'service_host_suffix' not in self.knative_config:
self.serice_host_filename = os.path.join(CACHE_DIR, 'knative',
self.cluster,
'service_host')
self.service_host_suffix = None
if os.path.exists(self.serice_host_filename):
serice_host_data = load_yaml_config(self.serice_host_filename)
self.service_host_suffix = serice_host_data[
'service_host_suffix']
self.knative_config[
'service_host_suffix'] = self.service_host_suffix
else:
self.service_host_suffix = self.knative_config[
'service_host_suffix']
logger.debug('Loaded service host suffix: {}'.format(
self.service_host_suffix))
if self.istio_endpoint:
log_msg = 'Lithops v{} init for Knative - Istio Endpoint: {}'.format(
__version__, self.istio_endpoint)
else:
log_msg = 'Lithops v{} init for Knative'.format(__version__)
if not self.log_active:
print(log_msg)
logger.info(log_msg)
def __init__(self, knative_config, storage_config):
self.name = 'knative'
self.knative_config = knative_config
self.istio_endpoint = self.knative_config.get('istio_endpoint')
self.kubecfg_path = self.knative_config.get('kubecfg_path')
# k8s config can be incluster, in ~/.kube/config or generate kube-config.yaml file and
# set env variable KUBECONFIG=<path-to-kube-confg>
try:
config.load_kube_config(config_file=self.kubecfg_path)
contexts = config.list_kube_config_contexts(
config_file=self.kubecfg_path)
current_context = contexts[1].get('context')
self.namespace = current_context.get('namespace', 'default')
self.cluster = current_context.get('cluster')
self.knative_config['namespace'] = self.namespace
self.knative_config['cluster'] = self.cluster
self.is_incluster = False
except Exception:
config.load_incluster_config()
self.namespace = self.knative_config.get('namespace', 'default')
self.cluster = self.knative_config.get('cluster', 'default')
self.is_incluster = True
logger.debug("Set namespace to {}".format(self.namespace))
logger.debug("Set cluster to {}".format(self.cluster))
self.api = client.CustomObjectsApi()
self.v1 = client.CoreV1Api()
if self.istio_endpoint is None:
try:
ingress = self.v1.read_namespaced_service(
'istio-ingressgateway', 'istio-system')
http_port = list(
filter(lambda port: port.port == 80,
ingress.spec.ports))[0].node_port
# https_port = list(filter(lambda port: port.port == 443, ingress.spec.ports))[0].node_port
if ingress.status.load_balancer.ingress is not None:
# get loadbalancer ip
ip = ingress.status.load_balancer.ingress[0].ip
else:
# for minikube or a baremetal cluster that has no external load balancer
node = self.v1.list_node()
ip = node.items[0].status.addresses[0].address
if ip and http_port:
self.istio_endpoint = 'http://{}:{}'.format(ip, http_port)
self.knative_config['istio_endpoint'] = self.istio_endpoint
except Exception:
pass
if 'service_host_suffix' not in self.knative_config:
self.serice_host_filename = os.path.join(CACHE_DIR, 'knative',
self.cluster,
'service_host')
self.service_host_suffix = None
if os.path.exists(self.serice_host_filename):
serice_host_data = load_yaml_config(self.serice_host_filename)
self.service_host_suffix = serice_host_data[
'service_host_suffix']
self.knative_config[
'service_host_suffix'] = self.service_host_suffix
else:
self.service_host_suffix = self.knative_config[
'service_host_suffix']
logger.debug('Loaded service host suffix: {}'.format(
self.service_host_suffix))
msg = COMPUTE_CLI_MSG.format('Knative')
if self.istio_endpoint:
msg += ' - Istio Endpoint: {}'.format(self.istio_endpoint)
elif self.cluster:
msg += ' - Cluster: {}'.format(self.cluster)
logger.info("{}".format(msg))
def __init__(self, knative_config):
self.log_level = os.getenv('PYWREN_LOG_LEVEL')
self.name = 'knative'
self.knative_config = knative_config
self.endpoint = self.knative_config.get('endpoint')
self.serving_host = self.knative_config.get('host')
self.service_name = self.knative_config.get('service_name')
# generate kube-config.yml file and set env variable KUBECONFIG=<path-to-kube-confg>
config.load_kube_config()
self.api = client.CustomObjectsApi()
self.v1 = client.CoreV1Api()
try:
ingress = self.v1.read_namespaced_service('istio-ingressgateway',
'istio-system')
if ingress.status.load_balancer.ingress is not None:
# get loadbalancer ip
self.endpoint = ingress.status.load_balancer.ingress[0].ip
else:
# for minikube or a baremetal cluster that has no external load balancer
node = self.v1.list_node()
node_port = list(
filter(lambda port: port.port == 80,
ingress.spec.ports))[0].node_port
self.endpoint = node.items[0].status.addresses[
0].address + ":" + str(node_port)
except ApiException as e:
print("Exception when calling read_namespaced_service")
print(self.endpoint)
service_name = self._format_action_name(
self.knative_config['service_name'])
#basically for the domain host - but if endpoint still None then read it from the ksvc resource
if self.endpoint is None or self.serving_host is None:
try:
pywren_svc = self.api.get_namespaced_custom_object(
group="serving.knative.dev",
version="v1alpha1",
name=service_name,
namespace="default",
plural="services")
if pywren_svc is not None:
svc_url = pywren_svc['status']['url']
if self.endpoint is None:
self.endpoint = svc_url[7:]
if self.serving_host is None:
self.serving_host = svc_url[7:]
except Exception as e:
if json.loads(e.body)['code'] == 404:
log_msg = 'ksvc resource: {} Not Found'.format(
service_name)
logger.debug(log_msg)
self.headers = {
'content-type': 'application/json',
'Host': self.serving_host
}
log_msg = 'PyWren v{} init for Knative Serving - IP: {} - Service: {}'.format(
__version__, self.endpoint, self.serving_host)
logger.info(log_msg)
if not self.log_level:
print(log_msg)
logger.debug('Knative init for host: {}'.format(self.endpoint))
logger.debug('Knative init for service: {}'.format(self.endpoint))
