def delete_routes(datapusher_name, deis_instance_id, root_domain,
sub_domain):
routers_manager.delete_routes(datapusher_name=datapusher_name,
deis_instance_id=deis_instance_id,
root_domain=root_domain,
sub_domain=sub_domain)
logs.exit_great_success()
def initialize(interactive, cluster_provider, operator_image, skip_to):
"""Initialize the currently connected cluster"""
manager.initialize(interactive=interactive,
default_cluster_provider=cluster_provider,
skip_to=skip_to,
operator_image=operator_image)
logs.exit_great_success()
def create_base_db(db_name, db_password, admin_connection_string):
with _get_admin_connection(admin_connection_string) as admin_conn:
db_name = db_name or _generate_password(8)
db_password = db_password or _generate_password(12)
logs.info(f'creating base db: {db_name} / {db_password}')
driver.create_base_db(admin_conn, db_name, db_password)
logs.exit_great_success()
def update(instance_id_or_name, override_spec_json, persist_overrides,
wait_ready, skip_deployment, skip_route, force, override_spec_file,
ckan_cloud_docker_latest_tag):
"""Update an instance to the latest resource spec, optionally applying the given json override to the resource spec
Examples:
ckan-cloud-operator ckan instance update <INSTANCE_ID_OR_NAME> '{"siteUrl": "http://localhost:5000"}' --wait-ready
ckan-cloud-operator ckan instance update <INSTANCE_ID_OR_NAME> '{"replicas": 3}' --persist-overrides
"""
override_spec = json.loads(
override_spec_json) if override_spec_json else None
if override_spec:
assert not override_spec_file, "Can't specify both OVERRIDE_SPEC_JSON and override_spec_file"
elif override_spec_file:
with open(override_spec_file) as f:
override_spec = yaml.safe_load(f)
if ckan_cloud_docker_latest_tag:
assert override_spec.get(
"ckanImage"
), "ckanImage attribute is required in spec for --ckan-cloud-docker-latest-tag arg"
if override_spec["ckanImage"].endswith(":latest"):
override_spec["ckanImage"] = override_spec["ckanImage"].replace(
":latest", ":%s" % ckan_cloud_docker_latest_tag)
logs.info("Replacing ckanImage to latest tag: %s" %
override_spec["ckanImage"])
manager.update(instance_id_or_name,
override_spec=override_spec,
persist_overrides=persist_overrides,
wait_ready=wait_ready,
skip_deployment=skip_deployment,
skip_route=skip_route,
force=force)
logs.exit_great_success()
def initialize(interactive, provider_id, storage_suffix, disk_name, dry_run):
manager.initialize(interactive=interactive,
provider_id=provider_id,
storage_suffix=storage_suffix,
use_existing_disk_name=disk_name,
dry_run=dry_run)
logs.exit_great_success()
def create_instance(instance_id, instance_type, values_file, exists_ok,
dry_run):
manager.create_instance(instance_id,
instance_type,
values_filename=values_file,
exists_ok=exists_ok,
dry_run=dry_run)
logs.exit_great_success()
def create(values_file, instance_id, instance_name, exists_ok, dry_run, update_, wait_ready,
skip_deployment, skip_route, force, deployment_provider):
if not deployment_provider:
deployment_provider = 'helm'
manager.create(deployment_provider=deployment_provider, instance_id=instance_id, instance_name=instance_name,
values_filename=values_file, exists_ok=exists_ok, dry_run=dry_run, update_=update_,
wait_ready=wait_ready, skip_deployment=skip_deployment, skip_route=skip_route, force=force)
logs.exit_great_success()
def delete(instance_id_or_name, no_dry_run):
generator = manager.delete_instances(instance_ids_or_names=instance_id_or_name, dry_run=not no_dry_run)
while True:
try:
logs.info('Deleting instance', **next(generator))
except StopIteration:
break
logs.info(**next(generator))
logs.exit_great_success(quiet=True)
def list_instances(full, quick, name, credentials):
instances = list(
manager.list_instances(full=full,
quick=quick,
name=name,
withCredentials=credentials))
print('---')
logs.print_yaml_dump(instances)
logs.exit_great_success(quiet=True)
def list_instances(full, quick, name, credentials):
'''
List existing CKAN instaces
'''
instances = list(
manager.list_instances(full=full, quick=quick,
name=name, withCredentials=credentials)
)
logs.print_yaml_dump(instances)
logs.exit_great_success(quiet=True)
def migrate_deis_instance(old_site_id, new_instance_id, router_name,
skip_gitlab, force, rerun, recreate_dbs, recreate,
recreate_instance, skip_routes, skip_solr,
skip_deployment, no_db_proxy):
"""Run a full end-to-end migration of an instasnce"""
manager.migrate_deis_instance(old_site_id, new_instance_id, router_name,
skip_gitlab, force, rerun, recreate_dbs,
recreate, recreate_instance, skip_routes,
skip_solr, skip_deployment, no_db_proxy)
logs.exit_great_success()
def create(instance_type, values_file, instance_id, instance_name, exists_ok, dry_run, update_, wait_ready,
skip_deployment, skip_route, force, skip_solr):
'''
Create CKAN instance
'''
manager.create(instance_id=instance_id, instance_type=instance_type, instance_name=instance_name,
values_filename=values_file, exists_ok=exists_ok, dry_run=dry_run, update_=update_,
wait_ready=wait_ready, skip_deployment=skip_deployment, skip_route=skip_route, force=force, skip_solr=skip_solr)
logs.exit_great_success()
def update(instance_id_or_name, override_spec_json, persist_overrides, wait_ready, skip_deployment, skip_route, force):
"""Update an instance to the latest resource spec, optionally applying the given json override to the resource spec
Examples:
ckan-cloud-operator apps update <INSTANCE_ID_OR_NAME> '{"siteUrl": "http://localhost:5000"}' --wait-ready
ckan-cloud-operator apps update <INSTANCE_ID_OR_NAME> '{"replicas": 3}' --persist-overrides
"""
override_spec = json.loads(override_spec_json) if override_spec_json else None
manager.update(instance_id_or_name, override_spec=override_spec, persist_overrides=persist_overrides,
wait_ready=wait_ready, skip_deployment=skip_deployment, skip_route=skip_route,
force=force)
logs.exit_great_success()
def proxy_update(verify_instance_id, set_pool_mode, reload):
manager.update(wait_updated=reload, set_pool_mode=set_pool_mode)
if verify_instance_id:
from ckan_cloud_operator.providers.db import manager as db_manager
logs.info(f'{verify_instance_id}: Checking DB..')
db_manager.check_connection_string(
db_manager.get_deis_instsance_external_connection_string(
verify_instance_id))
logs.info(f'{verify_instance_id}: Checking DataStore..')
db_manager.check_connection_string(
db_manager.get_deis_instsance_external_connection_string(
verify_instance_id, is_datastore=True))
logs.info(f'{verify_instance_id}: Checking DataStore ReadOnly..')
db_manager.check_connection_string(
db_manager.get_deis_instsance_external_connection_string(
verify_instance_id, is_datastore_readonly=True))
logs.exit_great_success()
def update(user):
assert user['spec']['role'] == 'admin', 'only admin role is supported'
username = user['spec']['name']
password = _generate_password(12)
config = _config_get(is_secret=True)
api_endpoint, access_key, secret = [
config['api-endpoint'], config['access-key'], config['secret-key']
]
print('---- # Creating Rancher user')
res = rancher_driver.create_user(api_endpoint, access_key, secret,
username, password)
user_id = res['id']
assert len(res['principalIds']) == 1, 'invalid principalIds'
user_principal_id = res['principalIds'][0]
print(yaml.dump(res, default_flow_style=False))
cluster_id, _ = _config_get('default-context', is_secret=True).split(':')
print('---- # Creating admin role bindings')
logs.print_yaml_dump(
rancher_driver.create_cluster_role_template_binding(
api_endpoint, access_key, secret, cluster_id, user_principal_id))
print('---')
logs.print_yaml_dump(
rancher_driver.create_global_role_binding(api_endpoint, access_key,
secret, user_id))
print('---- # Creating user token')
res = rancher_driver.login(api_endpoint, username, password)
user_login_token = res['token']
logs.print_yaml_dump(res)
print('---')
res = rancher_driver.create_user_token(api_endpoint, user_login_token,
'ckan-cloud-operator')
token = res['token']
logs.print_yaml_dump(res)
_config_set(f'{username}-token', token, is_secret=True)
print(
'\n\nckan-cloud-operator uses the token to login, if you require human access, keep the username/password, it will not be displayed again\n\n'
)
print('username:'******'password:'******'\n\n')
logs.exit_great_success()
def print_event_exit_on_complete(event, details_msg, soft_exit=False):
if not details_msg: details_msg = ''
msg = event.pop('msg')
step = event.pop('step')
logs.info(f'{step}: {msg}')
if len(event) > 0:
logs.info(f'event metadata: {event}')
event_completed_successfully = get_event_migration_complete_status(event)
if event_completed_successfully:
logs.info(f'Migration completed successfully ({details_msg})')
if soft_exit:
return True
else:
logs.exit_great_success()
elif event_completed_successfully is False:
logs.error(f'Migration failed ({details_msg})')
if soft_exit:
return False
else:
logs.exit_catastrophic_failure()
else:
return None
def initialize(interactive):
manager.initialize(interactive=interactive)
logs.exit_great_success()
def migrate_delete(migration_name, delete_dbs):
for name in migration_name:
db_migration_manager.delete(name, delete_dbs)
logs.exit_great_success()
def post_create_checks(instance_id):
manager.post_create_checks(instance_id)
logs.exit_great_success()
def initialize():
manager.initialize()
logs.exit_great_success()
def put_configs(configs_dir):
manager.zk_put_configs(configs_dir)
logs.exit_great_success()
def initialize(interactive, db_prefix):
"""Enable Azure SQL as the main DB provider"""
manager.initialize(interactive=interactive, db_prefix=db_prefix)
logs.exit_great_success()
def create_management_server(interactive, values):
manager.create_management_server(interactive, values)
logs.exit_great_success()
def get_kubeconfig(user_name):
"""Get kubeconfig file for a user"""
print(
yaml.dump(manager.get_kubeconfig(user_name), default_flow_style=False))
logs.exit_great_success(quiet=True)
def set_name(instance_id, instance_name):
logs.info(f'{instance_name} --> {instance_id}')
manager.set_name(instance_id, instance_name)
logs.exit_great_success()
def delete_name(instance_name):
manager.delete_name(instance_name=instance_name)
logs.exit_great_success()
def create(user_name, role):
"""Create a user with the given role"""
manager.create(user_name, role)
manager.update(user_name)
logs.exit_great_success()
def list_instances(full, quick, name):
for instance in manager.list_instances(full=full, quick=quick, name=name):
logs.print_yaml_dump([instance])
logs.exit_great_success(quiet=True)
def initialize_docker_registry():
manager.initialize_docker_registry()
logs.exit_great_success()
def initialize(interactive, dry_run):
manager.initialize(interactive=interactive, dry_run=dry_run)
logs.exit_great_success()
