"""
pygluu.kubernetes.terminal.sql
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This module contains helpers to interact with user's inputs for jackrabbit terminal prompts.
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
import click
from pygluu.kubernetes.helpers import get_logger, prompt_password
logger = get_logger("gluu-prompt-sql")
class PromptSQL:
"""Prompt is used for prompting users for input used in deploying Gluu.
"""
def __init__(self, settings):
self.settings = settings
def prompt_sql(self):
"""Prompts for SQL server
"""
sql_dialect = {
1: "mysql",
2: "pgsql",
}
if self.settings.get(
https://www.apache.org/licenses/LICENSE-2.0
Generate certificate authority cert, key and chain cert and key signed by CA generated.
"""
import datetime
import OpenSSL.crypto
import OpenSSL.SSL
from pygluu.kubernetes.helpers import get_logger
from cryptography import x509
from cryptography.x509.oid import NameOID, ExtendedKeyUsageOID
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa
logger = get_logger("gluu-cert-manager ")
def setup_crts(ca_common_name,
cert_common_name,
san_list,
ca_cert_file="./ca.crt",
ca_key_file="./ca.key",
cert_file="./chain.pem",
key_file="./pkey.key"):
"""
Generate certificate authority cert, key and chain cert and key signed by CA generated.
:param ca_common_name:
:param cert_common_name:
:param san_list:
"""
pygluu.kubernetes.redis
~~~~~~~~~~~~~~~~~~~~~~~
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
Handles Redis installation for testing.
"""
from pathlib import Path
from pygluu.kubernetes.yamlparser import Parser
from pygluu.kubernetes.helpers import get_logger, exec_cmd, analyze_storage_class
from pygluu.kubernetes.kubeapi import Kubernetes
from pygluu.kubernetes.settings import SettingsHandler
logger = get_logger("gluu-redis ")
class Redis(object):
def __init__(self):
self.settings = SettingsHandler()
self.kubernetes = Kubernetes()
self.timeout = 120
if self.settings.get("DEPLOYMENT_ARCH") == "gke":
user_account, stderr, retcode = exec_cmd(
"gcloud config get-value core/account")
user_account = str(user_account, "utf-8").strip()
user, stderr, retcode = exec_cmd("whoami")
user = str(user, "utf-8").strip()
cluster_role_binding_name = "cluster-admin-{}".format(user)
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
import contextlib
import json
import os
import sys
import shutil
import jsonschema
from dotty_dict import dotty
from pygluu.kubernetes.yamlparser import Parser
from pathlib import Path
from pygluu.kubernetes.helpers import get_logger
logger = get_logger("gluu-values-yaml ")
def unlink_values_yaml():
filename = Path("./helm/gluu/values.yaml")
with contextlib.suppress(FileNotFoundError):
os.unlink(filename)
class ValuesHandler(object):
def __init__(self,
values_file="./helm/gluu/values.yaml",
values_schema_file="./helm/gluu/values.schema.json"):
self.values_file = Path(values_file)
self.values_schema = Path(values_schema_file)
self.errors = list()
~~~~~~~~~~~~~~~~~~~~~~~~~
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
import sys
import time
from kubernetes import client, utils, config
from kubernetes.stream import stream
from pygluu.kubernetes.helpers import get_logger, check_microk8s_kube_config_file, exec_cmd
from pygluu.kubernetes.yamlparser import Parser
logger = get_logger("gluu-kubernetes-api")
def load_kubernetes_config(mute=True):
"""
Loads kubernetes in cluster or from file configuration
:param mute:
"""
config_loaded = False
try:
config.load_incluster_config()
config_loaded = True
except config.config_exception.ConfigException:
if not mute:
logger.warning(
"Unable to load in-cluster configuration; trying to load from Kube config file"
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
Handles Helm Gluu Chart
"""
from pathlib import Path
from pygluu.kubernetes.yamlparser import Parser
from pygluu.kubernetes.helpers import get_logger, exec_cmd
from pygluu.kubernetes.kubeapi import Kubernetes
from pygluu.kubernetes.couchbase import Couchbase
from pygluu.kubernetes.settings import ValuesHandler
import time
import socket
logger = get_logger("gluu-helm ")
class Gluu(object):
def __init__(self):
self.values_file = Path("./helm/gluu/override-values.yaml").resolve()
self.upgrade_values_file = Path(
"./helm/gluu-upgrade/values.yaml").resolve()
self.settings = ValuesHandler()
self.kubernetes = Kubernetes()
self.ldap_backup_release_name = self.settings.get(
"installer-settings.releaseName") + "-ldap-backup"
if "gke" in self.settings.get(
"installer-settings.volumeProvisionStrategy"):
# Clusterrolebinding needs to be created for gke with CB installed
if self.settings.get("config.configmap.cnCacheType") == "REDIS" or \
~~~~~~~~~~~~~~~~~~~~~~~~~~
This module contains helpers to interact with settings saved in a dictionary for terminal and GUI installations.
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
import contextlib
import json
import os
import shutil
import jsonschema
from pathlib import Path
from pygluu.kubernetes.helpers import get_logger, update_settings_json_file
logger = get_logger("gluu-setting ")
def unlink_settings_json():
filename = Path("./settings.json")
with contextlib.suppress(FileNotFoundError):
os.unlink(filename)
class SettingsHandler(object):
def __init__(self):
self.setting_file = Path("./settings.json")
self.setting_schema = Path("./settings_schema.json")
self.errors = tuple()
self.db = self.default_settings
self.load()
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
Handles Postgres operations
"""
from pathlib import Path
from psycopg2 import connect, sql
from pygluu.kubernetes.yamlparser import Parser
from pygluu.kubernetes.helpers import get_logger, analyze_storage_class
from pygluu.kubernetes.kubeapi import Kubernetes
from pygluu.kubernetes.settings import ValuesHandler
import time
import base64
logger = get_logger("gluu-postgres ")
class Postgres(object):
def __init__(self):
self.settings = ValuesHandler()
self.kubernetes = Kubernetes()
self.timeout = 120
@property
def generate_postgres_init_sql(self):
services_using_postgres = []
if self.settings.get("installer-settings.jackrabbit.clusterMode"):
services_using_postgres.append("JACKRABBIT")
if self.settings.get("installer-settings.gluuGateway.install"):
services_using_postgres.append("KONG")
YAML parser.
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
from pathlib import Path
import contextlib
import os
from ruamel.yaml import YAML
from ruamel.yaml.comments import CommentedMap
from collections import OrderedDict, Mapping
from pygluu.kubernetes.helpers import get_logger
logger = get_logger("gluu-yaml-parser ")
class Parser(dict):
def __init__(self,
filename,
check_value=None,
check_value_name=None,
check_key='kind'):
super().__init__()
self.filename = Path(filename)
self.yaml = YAML()
self.yaml.preserve_quotes = True
self.manifests_dict_list = []
self.modify_dict = dict
self.tmp_yaml_file = Path("./tmp.yaml")
"""
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
Installs Gluu
"""
import argparse
import time
import sys
from pygluu.kubernetes.couchbase import Couchbase
from pygluu.kubernetes.terminal.prompt import Prompt
from pygluu.kubernetes.helpers import get_logger, copy_templates
from pygluu.kubernetes.helm import Helm
from pygluu.kubernetes.kustomize import Kustomize
from pygluu.kubernetes.settings import SettingsHandler
logger = get_logger("gluu-create ")
def create_parser():
"""Create parser to handle arguments from CLI.
:return:
"""
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(title="Commands", dest="subparser_name")
subparsers.add_parser("generate-settings", help="Generate settings.json to install "
"Gluu Cloud Native Edition non-interactively")
subparsers.add_parser("install", help="Install Gluu Cloud Native Edition")
subparsers.add_parser("install-no-wait", help="Install Gluu Cloud Native Edition. "
"There will be no wait time between installing services. "
"Pods may look like they are restarting but they will "
"be waiting for hierarchy "
"""
pygluu.kubernetes.terminal.license
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This module contains helpers to interact with user's inputs for terminal license prompt .
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
from pygluu.kubernetes.helpers import get_logger
import click
logger = get_logger("gluu-prompt-license")
class PromptLicense:
def __init__(self, settings, accept_license=False):
self.settings = settings
if accept_license:
self.settings.set("installer-settings", True)
self.prompt_license()
def prompt_license(self):
"""Prompts user to accept Apache 2.0 license
"""
if not self.settings.get("installer-settings.acceptLicense"):
with open("./LICENSE") as f:
print(f.read())
self.settings.set(
"installer-settings.acceptLicense",
"""
pygluu.kubernetes.terminal.istio
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This module contains helpers to interact with user's inputs for istio terminal prompts.
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
import click
from pygluu.kubernetes.helpers import get_logger
from pygluu.kubernetes.terminal.helpers import confirm_yesno
logger = get_logger("gluu-prompt-istio ")
class PromptIstio:
"""Prompt is used for prompting users for input used in deploying Gluu.
"""
def __init__(self, settings):
self.settings = settings
self.enabled_services = self.settings.get("ENABLED_SERVICES_LIST")
def prompt_istio(self):
"""Prompt for Istio
"""
if not self.settings.get("USE_ISTIO_INGRESS") and self.settings.get(
"DEPLOYMENT_ARCH") not in ("microk8s", "minikube"):
self.settings.set(
"USE_ISTIO_INGRESS",
confirm_yesno("[Alpha] Would you like to use "
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
Handles Gluu Gateway and Gluu Gateway UI
"""
from pathlib import Path
from pygluu.kubernetes.yamlparser import Parser
from pygluu.kubernetes.helpers import get_logger, exec_cmd
from pygluu.kubernetes.kubeapi import Kubernetes
from pygluu.kubernetes.settings import SettingsHandler
from ast import literal_eval
import base64
logger = get_logger("gluu-gateway ")
def register_op_client(namespace, client_name, op_host, client_api_url,
release_name):
"""Registers an op client using client_api.
:param namespace:
:param client_name:
:param op_host:
:param client_api_url:
:param release_name:
:return:
"""
kubernetes = Kubernetes()
logger.info("Registering a client : {}".format(client_name))
"""
pygluu.kubernetes.terminal.jackrabbit
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This module contains helpers to interact with user's inputs for jackrabbit terminal prompts.
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
import click
from pygluu.kubernetes.helpers import get_logger, prompt_password
from pygluu.kubernetes.terminal.postgres import PromptPostgres
logger = get_logger("gluu-prompt-jackrabbit")
class PromptJackrabbit:
"""Prompt is used for prompting users for input used in deploying Gluu.
"""
def __init__(self, settings):
self.settings = settings
self.postgres = PromptPostgres(self.settings)
def prompt_jackrabbit(self):
"""Prompts for Jackrabbit content repository
"""
if self.settings.get("global.jackrabbit.enabled") in (None, ''):
logger.info("Jackrabbit must be installed. If the following prompt is answered with N it is assumed "
"the jackrabbit content repository is either installed locally or remotely")
import os
import sys
import traceback
import threading
import time
from pathlib import Path
from queue import Queue
from pygtail import Pygtail
from pygluu.kubernetes.couchbase import Couchbase
from pygluu.kubernetes.gluu import Gluu
from pygluu.kubernetes.helpers import get_logger
from .extensions import gluu_settings
logger = get_logger("gluu-gui ")
class InstallHandler(object):
def __init__(self, target, timeout=120):
self.target = target
self.timeout = timeout
self.queue = Queue()
self.thread = None
self.event = threading.Event()
@staticmethod
def initialize():
# remove setup log offset and set new offset
log_offset = Path("./setup.log.offset")
if log_offset.exists():
os.unlink('./setup.log.offset')
Pygtail("./setup.log", paranoid=True).readlines()
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This module contains helpers to interact with user's inputs for configuration terminal prompts.
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
from pathlib import Path
import re
import json
import click
from pygluu.kubernetes.helpers import get_logger, prompt_password
logger = get_logger("gluu-prompt-config ")
class PromptConfiguration:
"""Prompt is used for prompting users for input used in deploying Gluu.
"""
def __init__(self, settings):
self.settings = settings
self.config_settings = {"hostname": "", "country_code": "", "state": "", "city": "", "admin_pw": "",
"ldap_pw": "", "email": "", "org_name": "", "redis_pw": ""}
def prompt_config(self):
"""Prompts for generation of configuration layer
"""
check_fqdn_provided = False
"""
pygluu.kubernetes.terminal.aws
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This module contains helpers to interact with user's inputs for aws terminal prompts.
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
import click
from pygluu.kubernetes.helpers import get_logger
logger = get_logger("gluu-prompt-aws ")
class PromptAws:
"""Prompt is used for prompting users for input used in deploying Gluu.
"""
def __init__(self, settings):
self.settings = settings
def prompt_aws_lb(self):
"""Prompts for AWS Load balancer information
"""
lb_map = {
1: "clb",
2: "nlb",
3: "alb",
}
"""
pygluu.kubernetes.terminal.common
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This module contains helpers for terminal prompt classes
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
import click
from pygluu.kubernetes.helpers import get_logger
logger = get_logger("gluu-prompt-common")
def gather_ip():
"""Attempts to detect and return ip automatically.
Also set node names, zones, and addresses in a cloud deployment.
:return:
"""
from pygluu.kubernetes.kubeapi import Kubernetes
from pygluu.kubernetes.settings import ValuesHandler
import ipaddress
kubernetes = Kubernetes()
settings = ValuesHandler()
logger.info(
"Determining OS type and attempting to gather external IP address")
ip = ""
"""
from pathlib import Path
import shutil
import tarfile
from pygluu.kubernetes.kubeapi import Kubernetes
from pygluu.kubernetes.yamlparser import Parser
from pygluu.kubernetes.helpers import get_logger, exec_cmd
from pygluu.kubernetes.settings import SettingsHandler
from pygluu.kubernetes.pycert import setup_crts
import sys
import base64
import random
import os
logger = get_logger("gluu-couchbase ")
def extract_couchbase_tar(tar_file):
"""
Extracts couchbase kubernetes tar file
:param tar_file:
"""
extract_folder = Path("./couchbase-source-folder")
logger.info("Extracting {} in {} ".format(tar_file, extract_folder))
tr = tarfile.open(tar_file)
tr.extractall(path=extract_folder)
tr.close()
def set_memory_for_buckets(memory_quota):
"""
pygluu.kubernetes.kubedb
~~~~~~~~~~~~~~~~~~~~~~~~
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
Handles KubeDB
"""
from pathlib import Path
from pygluu.kubernetes.helpers import get_logger, exec_cmd
from pygluu.kubernetes.kubeapi import Kubernetes
from pygluu.kubernetes.settings import SettingsHandler
import time
logger = get_logger("gluu-kubedb ")
class Kubedb(object):
def __init__(self):
self.values_file = Path("./helm/gluu/values.yaml").resolve()
self.upgrade_values_file = Path(
"./helm/gluu-upgrade/values.yaml").resolve()
self.settings = SettingsHandler()
self.kubernetes = Kubernetes()
self.ldap_backup_release_name = self.settings.get(
'CN_HELM_RELEASE_NAME') + "-ldap-backup"
if self.settings.get("DEPLOYMENT_ARCH") == "gke":
# Clusterrolebinding needs to be created for gke with CB or kubeDB installed
if self.settings.get("INSTALL_REDIS") == "Y" or \
self.settings.get("INSTALL_GLUU_GATEWAY") == "Y" or \
"""
pygluu.kubernetes.terminal.testenv
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This module contains helpers to interact with user's inputs for terminal test environment prompts.
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
import click
from pygluu.kubernetes.terminal.helpers import confirm_yesno
from pygluu.kubernetes.helpers import get_logger
logger = get_logger("gluu-prompt-test-env")
class PromptTestEnvironment:
"""Prompt is used for prompting users for input used in deploying Gluu.
"""
def __init__(self, settings):
self.settings = settings
def prompt_test_environment(self):
"""Prompts for test environment.
"""
logger.info("A test environment means that the installer will strip all resource requirements, "
"and hence will use as much as needed only. The pods are subject to eviction. Please use "
" at least 8GB Ram , 4 CPU, and 50 GB disk.")
self.settings.set("TEST_ENVIRONMENT", confirm_yesno("Is this a test environment."))
"""
pygluu.kubernetes.terminal.redis
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This module contains helpers to interact with user's inputs for terminal redis prompts.
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
import click
from pygluu.kubernetes.helpers import get_logger, prompt_password
logger = get_logger("gluu-prompt-redis ")
class PromptRedis:
"""Prompt is used for prompting users for input used in deploying Gluu.
"""
def __init__(self, settings):
self.settings = settings
def prompt_redis(self):
"""Prompts for Redis
"""
if self.settings.get("config.configmap.cnRedisType") in (None, ''):
logger.info("STANDALONE, CLUSTER")
self.settings.set("config.configmap.cnRedisType", click.prompt("Please enter redis type", default="CLUSTER"))
if self.settings.get("installer-settings.redis.install"):
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
from pathlib import Path
import shutil
import base64
import click
from pygluu.kubernetes.helpers import get_logger, prompt_password
from pygluu.kubernetes.terminal.backup import PromptBackup
from pygluu.kubernetes.terminal.architecture import PromptArch
from pygluu.kubernetes.terminal.helpers import confirm_yesno, gather_ip
from pygluu.kubernetes.terminal.namespace import PromptNamespace
logger = get_logger("gluu-prompt-couchbase")
class PromptCouchbase:
"""Prompt is used for prompting users for input used in deploying Gluu.
"""
def __init__(self, settings):
self.settings = settings
self.backup = PromptBackup(self.settings)
self.arch = PromptArch(self.settings)
self.namespace = PromptNamespace(self.settings)
def prompt_couchbase(self):
self.arch.prompt_arch()
self.namespace.prompt_gluu_namespace()
"""
pygluu.kubernetes.terminal.volumes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This module contains helpers to interact with user's inputs for volume terminal prompts.
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
"""
import click
from pygluu.kubernetes.helpers import get_logger
logger = get_logger("gluu-prompt-volumes")
class PromptVolumes:
"""Prompt is used for prompting users for input used in deploying Gluu.
"""
def __init__(self, settings):
self.settings = settings
def prompt_app_volume_type(self):
"""Prompts for volume type
"""
gluu_volume_map = {
1: "microk8sDynamic",
2: "minikubeDynamic",
6: "awsOpenEbsHostPathDynamic",
7: "awsEbsDynamic",
"""
pygluu.kubernetes.mysql
~~~~~~~~~~~~~~~~~~~~~~~
License terms and conditions for Gluu Cloud Native Edition:
https://www.apache.org/licenses/LICENSE-2.0
Handles MySQL operations
"""
from pygluu.kubernetes.helpers import get_logger, exec_cmd
from pygluu.kubernetes.kubeapi import Kubernetes
from pygluu.kubernetes.settings import ValuesHandler
logger = get_logger("gluu-mysql ")
class MySQL(object):
def __init__(self):
self.settings = ValuesHandler()
self.kubernetes = Kubernetes()
self.timeout = 120
def install_mysql(self):
self.uninstall_mysql()
self.kubernetes.create_namespace(
name=self.settings.get("installer-settings.sql.namespace"),
labels={"app": "mysql"})
exec_cmd("helm repo add bitnami https://charts.bitnami.com/bitnami")
exec_cmd("helm repo update")
exec_cmd("helm install {} bitnami/mysql "
"--set auth.rootPassword={} "
