class OperatorInstaller:
def __init__(self, cluster_spec, options):
self.options = options
self.cluster_spec = cluster_spec
self.operator_version = self.options.operator_version
if "-" in self.operator_version:
self.operator_release = self.operator_version.split("-")[0]
self.operator_tag = 'registry.gitlab.com/cb-vanilla/operator:{}'\
.format(self.operator_version)
self.admission_controller_release = self.operator_version.split("-")[0]
self.admission_controller_tag = \
'registry.gitlab.com/cb-vanilla/admission-controller:{}' \
.format(self.operator_version)
else:
self.operator_release = self.operator_version
self.operator_tag = 'couchbase/operator:{}'\
.format(self.operator_version)
self.admission_controller_release = self.operator_version
self.admission_controller_tag = 'couchbase/admission-controller:{}' \
.format(self.operator_version)
self.couchbase_version = self.options.couchbase_version
if "-" in self.couchbase_version:
self.couchbase_release = self.couchbase_version.split("-")[0]
self.couchbase_tag = 'registry.gitlab.com/cb-vanilla/server:{}'\
.format(self.couchbase_version)
else:
self.couchbase_release = self.couchbase_version
self.couchbase_tag = 'couchbase/server:{}'\
.format(self.couchbase_version)
self.operator_backup_version = self.options.operator_backup_version
if self.operator_backup_version:
if "-" in self.operator_backup_version:
self.operator_backup_release = self.operator_backup_version.split("-")[0]
self.operator_backup_tag = 'registry.gitlab.com/cb-vanilla/operator-backup:{}'\
.format(self.operator_backup_version)
else:
self.operator_backup_release = self.operator_backup_version
self.operator_backup_tag = 'couchbase/operator-backup/{}'\
.format(self.operator_backup_version)
else:
self.operator_backup_tag = 'registry.gitlab.com/cb-vanilla/operator-backup:latest'
self.node_count = len(self.cluster_spec.infrastructure_clusters['couchbase1'].split())
self.remote = RemoteHelper(cluster_spec)
self.docker_config_path = os.path.expanduser("~") + "/.docker/config.json"
self.operator_base_path = "cloud/operator/{}/{}"\
.format(self.operator_release.split(".")[0],
self.operator_release.split(".")[1])
self.certificate_authority_path = "{}/ca.crt"\
.format(self.operator_base_path)
self.crd_path = "{}/crd.yaml"\
.format(self.operator_base_path)
self.config_path = "{}/config.yaml"\
.format(self.operator_base_path)
self.config_template_path = "{}/config_template.yaml"\
.format(self.operator_base_path)
self.auth_path = "{}/auth_secret.yaml"\
.format(self.operator_base_path)
self.cb_cluster_path = "{}/couchbase-cluster.yaml"\
.format(self.operator_base_path)
self.template_cb_cluster_path = "{}/couchbase-cluster_template.yaml"\
.format(self.operator_base_path)
self.worker_base_path = "cloud/worker"
self.worker_path = "{}/worker.yaml"\
.format(self.worker_base_path)
self.rmq_base_path = "cloud/broker/rabbitmq/0.48"
self.rmq_operator_path = "{}/cluster-operator.yaml"\
.format(self.rmq_base_path)
self.rmq_cluster_path = "{}/rabbitmq.yaml"\
.format(self.rmq_base_path)
def install(self):
self.install_operator()
self.install_celery_broker()
def install_operator(self):
logger.info("installing operator")
self.create_secrets()
self.create_crd()
self.create_config()
self.wait_for_operator_and_admission()
self.create_auth()
self.create_cluster()
self.wait_for_cluster()
def install_celery_broker(self):
logger.info("installing celery broker")
self.create_rabbitmq_operator()
self.wait_for_rabbitmq_operator()
self.create_rabbitmq_cluster()
self.wait_for_rabbitmq_cluster()
self.creating_rabbitmq_config()
def uninstall(self):
self.uninstall_operator()
self.uninstall_celery_broker()
self.uninstall_workers()
self.delete_artifacts()
def uninstall_operator(self):
logger.info("uninstalling operator")
self.delete_operator_files()
self.delete_operator_secrets()
self.wait_for_operator_deletion()
def uninstall_celery_broker(self):
logger.info("uninstalling celery broker")
self.delete_rabbitmq_files()
self.wait_for_rabbitmq_deletion()
def uninstall_workers(self):
logger.info("uninstall workers")
self.delete_worker_files()
self.wait_for_worker_deletion()
def create_secrets(self):
logger.info("creating secrets")
self.remote.create_docker_secret(
self.docker_config_path)
self.remote.create_operator_tls_secret(
self.certificate_authority_path)
def create_crd(self):
logger.info("creating CRD")
self.remote.create_from_file(self.crd_path)
def create_config(self):
logger.info("creating config")
self.remote.create_operator_config(
self.config_template_path,
self.config_path,
self.operator_tag,
self.admission_controller_tag)
def create_auth(self):
logger.info("creating auth")
self.remote.create_from_file(self.auth_path)
def create_cluster(self):
logger.info("creating couchbase cluster")
self.remote.create_couchbase_cluster(
self.template_cb_cluster_path,
self.cb_cluster_path,
self.couchbase_tag,
self.operator_backup_tag,
self.node_count)
def wait_for_operator_and_admission(self):
logger.info("waiting for operator and admission controller")
self.remote.wait_for_admission_controller_ready()
self.remote.wait_for_operator_ready()
def wait_for_cluster(self):
logger.info("waiting for cluster")
self.remote.wait_for_couchbase_pods_ready(self.node_count)
def create_rabbitmq_operator(self):
logger.info("creating rabbitmq operator")
self.remote.create_from_file(self.rmq_operator_path)
def wait_for_rabbitmq_operator(self):
logger.info("waiting for rabbitmq operator")
self.remote.wait_for_rabbitmq_operator_ready()
def create_rabbitmq_cluster(self):
logger.info("creating rabbitmq cluster")
self.remote.create_from_file(self.rmq_cluster_path)
def wait_for_rabbitmq_cluster(self):
logger.info("waiting for rabbitmq cluster")
self.remote.wait_for_rabbitmq_broker_ready()
def creating_rabbitmq_config(self):
logger.info("creating rabbitmq config")
self.remote.upload_rabbitmq_config()
def delete_operator_files(self):
logger.info("deleting operator files")
files = [self.cb_cluster_path, self.auth_path,
self.config_path, self.crd_path]
self.remote.delete_from_files(files)
def delete_operator_secrets(self):
logger.info("deleting operator secrets")
secrets = ['regcred', 'couchbase-operator-tls',
'couchbase-server-tls', 'user-password-secret']
self.remote.delete_secrets(secrets)
def wait_for_operator_deletion(self):
logger.info("waiting for operator deletion")
self.remote.wait_for_operator_deletion()
def delete_rabbitmq_files(self):
logger.info("deleting rabbit mq files")
self.remote.delete_from_files(
[self.rmq_cluster_path,
self.rmq_operator_path])
def wait_for_rabbitmq_deletion(self):
logger.info("waiting for rabbitmq deletion")
self.remote.wait_for_rabbitmq_deletion()
def delete_worker_files(self):
logger.info("deleting worker files")
self.remote.delete_from_file(self.worker_path)
def wait_for_worker_deletion(self):
logger.info("waiting for worker deletion")
self.remote.wait_for_workers_deletion()
def delete_artifacts(self):
logger.info("deleting any artifact pods, pvcs, and backups")
self.remote.delete_all_backups()
self.remote.delete_all_pods()
self.remote.delete_all_pvc()
