def set_name(instance_id, instance_name, dry_run=False):
resource = crds_manager.get(APP_NAME_CRD_SINGULAR,
name=instance_name,
required=False)
if resource:
resource['spec']['latest-instance-id'] = instance_id
if not resource['spec']['instance-ids'].get(instance_id):
resource['spec']['instance-ids'][instance_id] = {
'added': datetime.datetime.now()
}
else:
resource = crds_manager.get_resource(
APP_NAME_CRD_SINGULAR,
instance_name,
spec={
'name': instance_name,
'latest-instance-id': instance_id,
'instance-ids': {
instance_id: {
'added': datetime.datetime.now()
}
}
})
if dry_run:
logs.print_yaml_dump(resource)
else:
kubectl.apply(resource)
def _create_down_time_approval_code(instance_id, old_db_prefix, new_db_prefix,
db_name, datastore_name):
jenkins_user_token = ckan_manager.get_jenkins_token(
'ckan-cloud-operator-jenkins-creds')
backups_console_log = jenkins_driver.curl(
*jenkins_user_token,
'https://cc-p-jenkins.ckan.io/job/check%20individual%20DB%20backups/lastBuild/console',
raw=True)
backups_console_log = backups_console_log.split(
'Finished: SUCCESS')[0].split('Updated property [compute/zone].')[1]
backups = yaml.safe_load(backups_console_log)
backups = {
k: v
for k, v in backups.items()
if (k == db_name or k == datastore_name or k == f'{db_name}-total-size'
or k == f'{datastore_name}-total-size')
}
logs.info('last instance backups')
logs.print_yaml_dump(backups)
return scripts_helpers.create_file_based_approval_code({
'instance-id':
instance_id,
'old-db-prefix':
old_db_prefix,
'new-db-prefix':
new_db_prefix,
'db-name':
db_name,
'datastore-name':
datastore_name
})
def get(instance_id_or_name, attr, with_spec):
"""Get detailed information about an instance, optionally returning only a single get attribute
Example: ckan-cloud-operator apps get <INSTANCE_ID_OR_NAME> deployment
"""
if attr == 'spec':
with_spec = True
logs.print_yaml_dump(manager.get(instance_id_or_name, attr, with_spec=with_spec), exit_success=True)
def _list():
for server in get_cluster()['servers']:
logs.print_yaml_dump([{
'specs': f'datacenter={server["datacenter"]},cpu={server["cpu"]},ram={server["ram"]},disk={", ".join(server["disk"])}',
'name': server['name'],
'private_ip': server['private_ip'],
'public_ip': server['public_ip'],
'rke-node-role': ', '.join(server['rke-node']['role'])
}])
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 wait_instance_ready(instance_id_or_name):
logs.info(f'Waiting for instance ready status ({instance_id_or_name})')
time.sleep(3)
while True:
data = get(instance_id_or_name)
if data.get('ready'):
break
else:
logs.print_yaml_dump({
k: v
for k, v in data.items()
if (k not in ['ready'] and type(v) == dict
and not v.get('ready')) or k == 'namespace'
})
time.sleep(2)
def set_storage(instance_id, instance_name, dry_run=False):
from ckan_cloud_operator.providers.storage.manager import get_provider, get_provider_id
resource = crds_manager.get(INSTANCE_NAME_CRD_SINGULAR, name=instance_name, required=False)
storage_provider = get_provider(default=None, provider_id=get_provider_id())
bucket = storage_provider.create_bucket(instance_id, exists_ok=True, dry_run=dry_run)
resource['spec']['ckanStorageBucket'] = {
storage_provider.PROVIDER_ID: bucket
}
if dry_run:
logs.print_yaml_dump(resource)
else:
kubectl.apply(resource)
def create_server(server, server_password):
logs.info(f'creating server (server_name={server["name"]})')
logs.print_yaml_dump(server)
cmd = ['cloudcli', 'server', 'create', '--wait']
for arg in [
'billingcycle', 'cpu', 'dailybackup', 'datacenter', 'disk',
'image', 'managed', 'monthlypackage', 'name', 'network',
'password', 'poweronaftercreate', 'quantity', 'ram'
]:
if arg == 'quantity':
val = '1'
elif arg == 'password':
val = server_password
else:
val = server[arg]
if arg == 'disk' or arg == 'network':
for subval in val:
cmd += [f'--{arg}', subval]
else:
cmd += [f'--{arg}', val]
subprocess.check_call(cmd)
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 db_migration_import_urls(old_site_id, raw):
urls = db_migration_manager.get_db_import_urls(old_site_id)
if raw:
print(' '.join(urls))
else:
logs.print_yaml_dump(list(urls))
def admin_credentials(instance_id):
logs.print_yaml_dump(manager.ckan_admin_credentials(instance_id))
def collection_status(collection_name):
logs.print_yaml_dump(manager.get_collection_status(collection_name))
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)
import os
from ckan_cloud_operator import logs
from ckan_cloud_operator.providers.apps import manager as apps_manager
instance_id_or_name = os.environ.get('INSTANCE_ID_OR_NAME')
attr = os.environ.get('ATTR')
with_spec = os.environ.get('WITH_SPEC')
with_spec = with_spec == 'yes'
logs.print_yaml_dump(
apps_manager.get(instance_id_or_name=instance_id_or_name, attr=attr, with_spec=with_spec),
exit_success=True
)
def operation_status(operation_id):
logs.print_yaml_dump(manager.get_operation_status(operation_id))
def cloudflare_rate_limits(root_domain):
logs.print_yaml_dump(
routers_manager.get_cloudflare_rate_limits(root_domain))
def create_ckan_admin_user(instance_id_or_name, name, email, password,
dry_run):
logs.print_yaml_dump(
manager.create_ckan_admin_user(instance_id_or_name, name, email,
password, dry_run))
logs.exit_great_success()
def print_management_machine_secrets(key):
if key:
print(manager.get_management_machine_secrets(key))
else:
logs.print_yaml_dump(manager.get_management_machine_secrets(),
exit_success=True)
def curl(jenkins_user, jenkins_token, jenkins_url, post_json_data):
logs.print_yaml_dump(
driver.curl(jenkins_user, jenkins_token, jenkins_url, post_json_data))
logs.exit_great_success(quiet=True)
