def download_targetservers_snapshot(self):
for environment in self.environments:
try:
self.snapshot_data.targetservers[environment] = Targetservers(
self.auth, self.org_name, None
).list_targetservers_in_an_environment(
environment, prefix=self.prefix, format='dict'
)
except HTTPError:
self.snapshot_data.targetservers[environment] = []
data = {
'snapshot': self.snapshot_data.targetservers[environment],
'target_path': self._gen_snapshot_path(
subpaths=['targetservers', environment, 'targetservers.json']
),
'fs_write': self.fs_write,
'indent': 2,
}
write_file(
data['snapshot'],
data['target_path'],
fs_write=data['fs_write'],
indent=data['indent'],
)
return self.snapshot_data.targetservers
def download_developers_snapshot(self):
self.snapshot_data.developers = Developers(self.auth, self.org_name, None).list_developers(
prefix=self.prefix, format='dict'
)
write_file(
self.snapshot_data.developers,
self._gen_download_path(is_snapshot=True, subpaths=['developers', 'developers.json']),
fs_write=self.fs_write,
indent=2,
)
return self.snapshot_data.developers
def download_apiproducts_snapshot(self):
self.snapshot_data.apiproducts = Apiproducts(
self.auth, self.org_name, None
).list_api_products(prefix=self.prefix, format='dict')
write_file(
self.snapshot_data.apiproducts,
self._gen_download_path(is_snapshot=True, subpaths=['apiproducts', 'apiproducts.json']),
fs_write=self.fs_write,
indent=2,
)
return self.snapshot_data.apiproducts
def download_users_for_a_role(self, role_name):
try:
write_file(
Userroles(self.auth, self.org_name, role_name).get_users_for_a_role().json(),
Backups.generate_download_path(
self.org_path, subpaths=['userroles', role_name, 'users.json']
),
fs_write=self.fs_write,
indent=2,
)
except HTTPError as e:
Backups.log_error(e, append_msg=' for User Role ({role_name}) users')
def decrypt_file(symmetric_key, file, verbose, silent):
contents = read_file(file, type='json')
decrypted_count = 0
console.echo('Decrypting... ', end='', flush=True)
contents, decrypted_count = Keyvaluemaps.encrypt_decrypt_keyvaluemap(
contents, symmetric_key, encrypt=False)
if decrypted_count:
write_file(contents, file, indent=2)
console.echo('Done')
return contents
console.echo('None')
return ''
def _download_users_for_a_role(self, role_name):
try:
write_file(
Userroles(self.auth, self.org_name, role_name).get_users_for_a_role().json(),
self._gen_download_path(subpaths=['userroles', role_name, 'users.json']),
fs_write=self.fs_write,
indent=2,
)
except HTTPError as e:
console.echo(
f'Ignoring {type(e).__name__} {e.response.status_code} error for User Role ({role_name}) users'
)
def download_apiproducts(self):
for apiproduct in self.snapshot_data.apiproducts:
try:
write_file(
Apiproducts(self.auth, self.org_name, apiproduct).get_api_product().text,
Backups.generate_download_path(
self.org_path, subpaths=['apiproducts', f'{apiproduct}.json']
),
fs_write=self.fs_write,
)
except HTTPError as e:
Backups.log_error(e, append_msg=' for API Product ({apiproduct})')
self._Backups__progress_callback(desc='API Products')
def download_caches_snapshot(self):
for environment in self.environments:
self.snapshot_data.caches[environment] = Caches(
self.auth, self.org_name, None
).list_caches_in_an_environment(environment, prefix=self.prefix, format='dict')
write_file(
self.snapshot_data.caches[environment],
Backups.generate_download_path(
self.org_path, is_snapshot=True, subpaths=['caches', environment, 'caches.json']
),
fs_write=self.fs_write,
indent=2,
)
def download_developers(self):
for developer in self.snapshot_data.developers:
try:
write_file(
Developers(self.auth, self.org_name, developer).get_developer().text,
Backups.generate_download_path(
self.org_path, subpaths=['developers', f'{developer}.json']
),
fs_write=self.fs_write,
)
except HTTPError as e:
Backups.log_error(e, append_msg=' for Developer ({developer})')
self._Backups__progress_callback(desc='Developers')
def _download_resource_permissions(self, role_name):
try:
data = {
'snapshot': self._get_permissions(role_name),
'target_path': self._gen_download_path(
subpaths=['userroles', role_name, 'resource_permissions.json']
),
'fs_write': self.fs_write,
}
write_file(data['snapshot'], data['target_path'], fs_write=data['fs_write'])
except HTTPError as e:
console.echo(
f'Ignoring {type(e).__name__} {e.response.status_code} error for User Role ({role_name}) resource permissions'
)
def download_apiproducts_snapshot(self):
self.snapshot_data.apiproducts = Apiproducts(
self.auth, self.org_name, None
).list_api_products(prefix=self.prefix, format='dict')
data = {
'snapshot': self.snapshot_data.apiproducts,
'target_path': self._gen_snapshot_path(subpaths=['apiproducts', 'apiproducts.json']),
'fs_write': self.fs_write,
'indent': 2,
}
write_file(
data['snapshot'], data['target_path'], fs_write=data['fs_write'], indent=data['indent']
)
return self.snapshot_data.apiproducts
def download_apis_snapshot(self):
for api in Apis(self.auth, self.org_name, None).list_api_proxies(
prefix=self.prefix, format='dict'
):
self.snapshot_data.apis[api] = (
Apis(self.auth, self.org_name, None).get_api_proxy(api).json()
)
write_file(
self.snapshot_data.apis[api],
self._gen_download_path(is_snapshot=True, subpaths=['apis', f'{api}.json']),
fs_write=self.fs_write,
indent=2,
)
return self.snapshot_data.apis
def download_developers_snapshot(self):
self.snapshot_data.developers = Developers(self.auth, self.org_name, None).list_developers(
prefix=self.prefix, format='dict'
)
data = {
'snapshot': self.snapshot_data.developers,
'target_path': self._gen_snapshot_path(subpaths=['developers', 'developers.json']),
'fs_write': self.fs_write,
'indent': 2,
}
write_file(
data['snapshot'], data['target_path'], fs_write=data['fs_write'], indent=data['indent']
)
return self.snapshot_data.developers
def download_apiproducts(self):
for apiproduct in self.snapshot_data.apiproducts:
try:
write_file(
Apiproducts(self.auth, self.org_name, apiproduct).get_api_product().text,
self._gen_download_path(subpaths=['apiproducts', f'{apiproduct}.json']),
fs_write=self.fs_write,
)
except HTTPError as e:
console.echo(
f'Ignoring {type(e).__name__} {e.response.status_code} error for API Product ({apiproduct})'
)
self._progress_callback(desc='API Products')
return self.snapshot_data.apiproducts
def download_developers(self):
for developer in self.snapshot_data.developers:
try:
write_file(
Developers(self.auth, self.org_name, developer).get_developer().text,
self._gen_download_path(subpaths=['developers', f'{developer}.json']),
fs_write=self.fs_write,
)
except HTTPError as e:
console.echo(
f'Ignoring {type(e).__name__} {e.response.status_code} error for Developer ({developer})'
)
self._progress_callback(desc='Developers')
return self.snapshot_data.developers
def download_userroles_snapshot(self):
self.snapshot_data.userroles = (
Userroles(self.auth, self.org_name, None).list_user_roles().json()
)
if self.prefix:
self.snapshot_data.userroles = [
role for role in self.snapshot_data.userroles if role.startswith(self.prefix)
]
write_file(
self.snapshot_data.userroles,
self._gen_download_path(is_snapshot=True, subpaths=['userroles', 'userroles.json']),
fs_write=self.fs_write,
indent=2,
)
return self.snapshot_data.userroles
def download_caches(self):
for environment in self.environments:
for cache in self.snapshot_data.caches[environment]:
try:
write_file(
Caches(self.auth, self.org_name, cache)
.get_information_about_a_cache(environment)
.text,
Backups.generate_download_path(
self.org_path, subpaths=['caches', environment, f'{cache}.json']
),
fs_write=self.fs_write,
)
except HTTPError as e:
Backups.log_error(e, append_msg=' for Cache ({cache})')
self._Backups__progress_callback(desc='Caches')
def download_apps(self):
for developer, apps in self.snapshot_data.apps.items():
for app in apps:
try:
write_file(
Apps(self.auth, self.org_name, app)
.get_developer_app_details(developer)
.text,
Backups.generate_download_path(
self.org_path, subpaths=['apps', developer, f'{app}.json']
),
fs_write=self.fs_write,
)
except HTTPError as e:
Backups.log_error(e, append_msg=' for Developer App ({app})')
self._Backups__progress_callback(desc='Developer Apps')
def download_keyvaluemaps(self):
for environment in self.environments:
for kvm in self.snapshot_data.keyvaluemaps[environment]:
try:
write_file(
Keyvaluemaps(self.auth, self.org_name, kvm)
.get_keyvaluemap_in_an_environment(environment)
.text,
Backups.generate_download_path(
self.org_path, subpaths=['keyvaluemaps', environment, f'{kvm}.json']
),
fs_write=self.fs_write,
)
except HTTPError as e:
Backups.log_error(e, append_msg=' for KVM ({kvm})')
self._Backups__progress_callback(desc='KeyValueMaps')
def download_targetservers(self):
for environment in self.environments:
for targetserver in self.snapshot_data.targetservers[environment]:
try:
write_file(
Targetservers(self.auth, self.org_name, targetserver)
.get_targetserver(environment)
.text,
Backups.generate_download_path(
self.org_path,
subpaths=['targetservers', environment, f'{targetserver}.json'],
),
fs_write=self.fs_write,
)
except HTTPError as e:
Backups.log_error(e, append_msg=' for TargetServer ({targetserver})')
self._Backups__progress_callback(desc='TargetServers')
def download_apps(self):
for developer, apps in self.snapshot_data.apps.items():
for app in apps:
try:
write_file(
Apps(self.auth, self.org_name, app)
.get_developer_app_details(developer)
.text,
self._gen_download_path(subpaths=['apps', developer, f'{app}.json']),
fs_write=self.fs_write,
)
except HTTPError as e:
console.echo(
f'Ignoring {type(e).__name__} {e.response.status_code} error for Developer App ({app})'
)
self._progress_callback(desc='Developer Apps')
return self.snapshot_data.apps
def download_apps_snapshot(self, expand=False, count=1000, startkey=""):
self.snapshot_data.apps = Apps(self.auth, self.org_name, None).list_apps_for_all_developers(
Developers(self.auth, self.org_name, None).list_developers(
prefix=None, expand=expand, count=count, startkey=startkey, format='dict'
),
prefix=self.prefix,
format='dict',
)
self.snapshot_data.apps = {k: v for k, v in self.snapshot_data.apps.items() if v}
for app, details in self.snapshot_data.apps.items():
write_file(
details,
self._gen_download_path(is_snapshot=True, subpaths=['apps', f'{app}.json']),
fs_write=self.fs_write,
indent=2,
)
return self.snapshot_data.apps
def download_caches(self):
for environment in self.environments:
for cache in self.snapshot_data.caches[environment]:
try:
write_file(
Caches(self.auth, self.org_name, cache)
.get_information_about_a_cache(environment)
.text,
self._gen_download_path(subpaths=['caches', environment, f'{cache}.json']),
fs_write=self.fs_write,
)
except HTTPError as e:
console.echo(
f'Ignoring {type(e).__name__} {e.response.status_code} error for Cache ({cache})'
)
self._progress_callback(desc='Caches')
return self.snapshot_data.caches
def download_caches_snapshot(self):
for environment in self.environments:
try:
self.snapshot_data.caches[environment] = Caches(
self.auth, self.org_name, None
).list_caches_in_an_environment(environment, prefix=self.prefix, format='dict')
except HTTPError:
self.snapshot_data.caches[environment] = []
write_file(
self.snapshot_data.caches[environment],
self._gen_download_path(
is_snapshot=True, subpaths=['caches', environment, 'caches.json']
),
fs_write=self.fs_write,
indent=2,
)
return self.snapshot_data.caches
def download_resource_permissions(self, role_name):
try:
write_file(
json.dumps(
Userroles.sort_permissions(
Permissions(self.auth, self.org_name, role_name).get_permissions(
formatted=True, format='json'
)
),
indent=2,
),
Backups.generate_download_path(
self.org_path, subpaths=['userroles', role_name, 'resource_permissions.json']
),
fs_write=self.fs_write,
)
except HTTPError as e:
Backups.log_error(e, append_msg=' for User Role ({role_name}) resource permissions')
def download_userroles_snapshot(self):
self.snapshot_data.userroles = (
Userroles(self.auth, self.org_name, None).list_user_roles().json()
)
if self.prefix:
self.snapshot_data.userroles = [
role for role in self.snapshot_data.userroles if role.startswith(self.prefix)
]
data = {
'snapshot': self.snapshot_data.userroles,
'target_path': self._gen_snapshot_path(subpaths=['userroles', 'userroles.json']),
'fs_write': self.fs_write,
'indent': 2,
}
write_file(
data['snapshot'], data['target_path'], fs_write=data['fs_write'], indent=data['indent']
)
return self.snapshot_data.userroles
def download_keyvaluemaps(self):
for environment in self.environments:
for kvm in self.snapshot_data.keyvaluemaps[environment]:
try:
write_file(
Keyvaluemaps(self.auth, self.org_name, kvm)
.get_keyvaluemap_in_an_environment(environment)
.text,
self._gen_download_path(
subpaths=['keyvaluemaps', environment, f'{kvm}.json']
),
fs_write=self.fs_write,
)
except HTTPError as e:
console.echo(
f'Ignoring {type(e).__name__} {e.response.status_code} error for KVM ({kvm})'
)
self._progress_callback(desc='KeyValueMaps')
return self.snapshot_data.keyvaluemaps
def download_targetservers(self):
for environment in self.environments:
for targetserver in self.snapshot_data.targetservers[environment]:
try:
write_file(
Targetservers(self.auth, self.org_name, targetserver)
.get_targetserver(environment)
.text,
self._gen_download_path(
subpaths=['targetservers', environment, f'{targetserver}.json']
),
fs_write=self.fs_write,
)
except HTTPError as e:
console.echo(
f'Ignoring {type(e).__name__} {e.response.status_code} error for TargetServer ({targetserver})'
)
self._progress_callback(desc='TargetServers')
return self.snapshot_data.targetservers
def _download_resource_permissions(self, role_name):
try:
write_file(
json.dumps(
Userroles.sort_permissions(
Permissions(self.auth, self.org_name, role_name).get_permissions(
formatted=True, format='json'
)
),
indent=2,
),
self._gen_download_path(
subpaths=['userroles', role_name, 'resource_permissions.json']
),
fs_write=self.fs_write,
)
except HTTPError as e:
console.echo(
f'Ignoring {type(e).__name__} {e.response.status_code} error for User Role ({role_name}) resource permissions'
)
def download_apis_snapshot(self):
for api in Apis(self.auth, self.org_name, None).list_api_proxies(
prefix=self.prefix, format='dict'
):
self.snapshot_data.apis[api] = (
Apis(self.auth, self.org_name, None).get_api_proxy(api).json()
)
data = {
'snapshot': self.snapshot_data.apis[api],
'target_path': self._gen_snapshot_path(subpaths=['apis', f'{api}.json']),
'fs_write': self.fs_write,
'indent': 2,
}
write_file(
data['snapshot'],
data['target_path'],
fs_write=data['fs_write'],
indent=data['indent'],
)
return self.snapshot_data.apis
