| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| # |
| import kopf, logging, json, os |
| import openserverless.kube as kube |
| import openserverless.kustomize as kus |
| import openserverless.config as cfg |
| import openserverless.util as util |
| import openserverless.apihost_util as apihost_util |
| import openserverless.operator_util as operator_util |
| |
| from openserverless.user_config import UserConfig |
| from openserverless.user_metadata import UserMetadata |
| from openserverless.ingress_data import IngressData |
| from openserverless.route_data import RouteData |
| |
| def create(owner=None): |
| logging.info("*** configuring openserverless nginx static provider") |
| runtime = cfg.get('openserverless.kube') |
| |
| data = util.get_storage_static_config_data() |
| data['storage_hostname'] = apihost_util.extract_hostname(data['storage_url']) |
| logging.info(f"configuring storage static provider to check for availability of endpoint {data['storage_hostname']}") |
| |
| tplp = ["nginx-static-cm.yaml","nginx-static-sts.yaml","security-set-attach.yaml","set-attach.yaml"] |
| |
| if(data['affinity'] or data['tolerations']): |
| tplp.append("affinity-tolerance-sts-core-attach.yaml") |
| |
| kust = kus.patchTemplates("nginx-static", tplp, data) |
| spec = kus.kustom_list("nginx-static", kust, templates=[], data=data) |
| |
| if owner: |
| kopf.append_owner_reference(spec['items'], owner) |
| else: |
| cfg.put("state.nginx-static.spec", spec) |
| |
| res = kube.apply(spec) |
| |
| # dynamically detect nginx pod and wait for readiness |
| util.wait_for_pod_ready("{.items[?(@.metadata.labels.app == 'openserverless-static')].metadata.name}") |
| create_nuv_static_ingress(runtime, owner) |
| logging.info("*** configured openserverless nginx static provider") |
| return res |
| |
| def create_nuv_static_ingress(runtime, owner=None): |
| """" |
| Deploys the static ingresses for the openserverless user |
| """ |
| apihost_url = apihost_util.get_apihost(runtime) |
| hostname = apihost_util.extract_hostname(apihost_url) |
| should_create_www = "www" not in hostname and runtime not in ["kind"] |
| bucket_name = util.get_value_from_config_map(path='{.metadata.annotations.s3_bucket_static}') |
| |
| if runtime == 'openshift': |
| res = deploy_content_route_template("openserverless",bucket_name, apihost_url) |
| if should_create_www: |
| res += deploy_content_route_template("www-openserverless",bucket_name,apihost_util.append_prefix_to_url(apihost_url,"www")) |
| return res |
| else: |
| res = deploy_content_ingress_template("openserverless",bucket_name,apihost_url) |
| if should_create_www: |
| res += deploy_content_ingress_template("www-openserverless",bucket_name,apihost_util.append_prefix_to_url(apihost_url,"www")) |
| return res |
| |
| def static_ingress_name(namespace, default="apihost"): |
| return namespace == "openserverless" and f"{default}-static-ingress" or f"{namespace}-static-ingress" |
| |
| def static_route_name(namespace): |
| return f"{namespace}-static-route" |
| |
| def static_secret_name(namespace): |
| return f"{namespace}-crt" |
| |
| def static_middleware_ingress_name(namespace): |
| return f"{namespace}-static-ingress-add-prefix" |
| |
| def deploy_content_route_template(namespace, bucket, url): |
| logging.info(f"**** configuring static openshift route for url {url}") |
| |
| content = RouteData(url) |
| content.with_route_name(static_route_name(namespace)) |
| content.with_needs_rewrite(True) |
| content.with_service_name("openserverless-static-svc") |
| content.with_service_kind("Service") |
| content.with_service_port("8080") |
| content.with_context_path("/") |
| content.with_rewrite_target(f"/{bucket}/") |
| |
| path_to_template_yaml = content.render_template(namespace) |
| |
| res = kube.kubectl("apply", "-f",path_to_template_yaml) |
| os.remove(path_to_template_yaml) |
| return res |
| |
| def deploy_content_ingress_template(namespace, bucket, url): |
| logging.info(f"**** configuring static ingress for url {url}") |
| |
| content = IngressData(url) |
| content.with_ingress_name(static_ingress_name(namespace)) |
| content.with_secret_name(static_secret_name(namespace)) |
| content.with_context_path("/") |
| content.with_context_regexp("(.*)") |
| content.with_prefix_target(f"/{bucket}") |
| content.with_service_name("openserverless-static-svc") |
| content.with_service_port("8080") |
| content.with_middleware_ingress_name(static_middleware_ingress_name(namespace)) |
| |
| res = "" |
| if content.requires_traefik_middleware(): |
| logging.info("*** configuring traefik middleware") |
| path_to_template_yaml = content.render_traefik_middleware_template(namespace) |
| res += kube.kubectl("apply", "-f",path_to_template_yaml) |
| os.remove(path_to_template_yaml) |
| |
| logging.info(f"*** configuring static ingress endpoint for {namespace}") |
| path_to_template_yaml = content.render_template(namespace) |
| res += kube.kubectl("apply", "-f",path_to_template_yaml) |
| os.remove(path_to_template_yaml) |
| |
| return res |
| |
| def create_ow_static_endpoint(ucfg: UserConfig, user_metadata: UserMetadata, owner=None): |
| """ |
| deploy an ingress to access a generic user web bucket |
| """ |
| runtime = cfg.get('openserverless.kube') |
| namespace = ucfg.get("namespace") |
| apihost = ucfg.get("apihost") or "auto" |
| bucket_name = ucfg.get('S3_BUCKET_STATIC') |
| |
| hostname = apihost_util.get_user_static_hostname(runtime, namespace, apihost) |
| logging.debug("using hostname %s to configure access to user web bucket %s", hostname,bucket_name) |
| |
| try: |
| apihost_url = apihost_util.get_user_static_url(runtime, hostname) |
| user_metadata.add_metadata("STATIC_CONTENT_URL",apihost_url) |
| |
| if runtime == 'openshift': |
| return deploy_content_route_template(namespace,bucket_name, apihost_url) |
| else: |
| return deploy_content_ingress_template(namespace,bucket_name, apihost_url) |
| except Exception as e: |
| logging.error(e) |
| return False |
| |
| def delete_ow_static_endpoint(ucfg): |
| """ |
| undeploy an ingress exposing a generic user web bucket |
| """ |
| namespace = ucfg.get("namespace") |
| runtime = cfg.get('openserverless.kube') |
| logging.info(f"*** removing static endpoint for {namespace}") |
| runtime = cfg.get('openserverless.kube') |
| ingress_class = util.get_ingress_class(runtime) |
| |
| try: |
| res = "" |
| if(runtime=='openshift'): |
| route_name = static_route_name(namespace) |
| res = kube.kubectl("delete", "route",route_name) |
| return res |
| |
| if(ingress_class == 'traefik'): |
| middleware_name = static_middleware_ingress_name(namespace) |
| res += kube.kubectl("delete", util.get_traefik_middleware_resource(),middleware_name) |
| |
| ingress_name = static_ingress_name(namespace) |
| res += kube.kubectl("delete", "ingress",ingress_name) |
| return res |
| except Exception as e: |
| logging.warn(e) |
| return False |
| |
| def delete_by_owner(): |
| spec = kus.build("nginx-static") |
| res = kube.delete(spec) |
| logging.info(f"delete openserverless nginx static provider: {res}") |
| return res |
| |
| def delete_by_spec(): |
| spec = cfg.get("state.nginx-static.spec") |
| res = False |
| if spec: |
| res = kube.delete(spec) |
| logging.info(f"delete openserverless nginx static provider: {res}") |
| return res |
| |
| def delete_nuv_ingresses(): |
| logging.info("*** deleting openserverless static ingresses") |
| runtime = cfg.get('openserverless.kube') |
| ingress_class = util.get_ingress_class(runtime) |
| apihost_url = apihost_util.get_apihost(runtime) |
| hostname = apihost_util.extract_hostname(apihost_url) |
| should_delete_www = "www" not in hostname and runtime not in ["kind"] |
| |
| try: |
| res = "" |
| if(runtime=='openshift'): |
| route_name = static_route_name("openserverless") |
| res = kube.kubectl("delete", "route",route_name) |
| |
| if should_delete_www: |
| route_name = static_route_name("www-openserverless") |
| res += kube.kubectl("delete", "route",route_name) |
| return res |
| |
| if(ingress_class == 'traefik'): |
| middleware_name = static_middleware_ingress_name("openserverless") |
| res += kube.kubectl("delete", util.get_traefik_middleware_resource(),middleware_name) |
| |
| if should_delete_www: |
| middleware_name = static_middleware_ingress_name("www-openserverless") |
| res += kube.kubectl("delete", util.get_traefik_middleware_resource(),middleware_name) |
| |
| ingress_name = static_ingress_name("openserverless") |
| res += kube.kubectl("delete", "ingress",ingress_name) |
| |
| if should_delete_www: |
| ingress_name = static_ingress_name("www-openserverless") |
| res += kube.kubectl("delete", "ingress",ingress_name) |
| |
| return res |
| except Exception as e: |
| logging.warn(e) |
| return False |
| |
| |
| def delete(owner=None): |
| delete_nuv_ingresses() |
| if owner: |
| return delete_by_owner() |
| else: |
| return delete_by_spec() |
| |
| def patch(status, action, owner=None): |
| """ |
| Called by the operator patcher to create/delete minio static component |
| """ |
| try: |
| logging.info(f"*** handling request to {action} static") |
| if action == 'create': |
| msg = create(owner) |
| operator_util.patch_operator_status(status,'static','on') |
| else: |
| msg = delete(owner) |
| operator_util.patch_operator_status(status,'static','off') |
| |
| logging.info(msg) |
| logging.info(f"*** hanlded request to {action} static") |
| except Exception as e: |
| logging.error('*** failed to update static: %s' % e) |
| operator_util.patch_operator_status(status,'static','error') |
