def take_snapshot(self):
self.get_snapshots()
console.echo('Generating snapshot files...')
for api in self.apis:
getattr(self, f'download_{api}')()
self.progress_bar.close()
console.echo('Done.')
def wrapper(*args, **kwargs):
try:
result = func(*args, **kwargs)
return result
except Exception as e:
touch(APIGEE_CLI_EXCEPTION_LOG_FILE)
f_handler = logging.FileHandler(APIGEE_CLI_EXCEPTION_LOG_FILE,
'w+')
f_handler.setLevel(logging.INFO)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
f_handler.setFormatter(formatter)
logging.getLogger("").addHandler(f_handler)
logging.error('Exception occurred', exc_info=True)
frm = inspect.trace()[-1]
mod = inspect.getmodule(frm[0])
modname = mod.__name__ if mod else frm[1]
# error_message = {'Exception': {'detail': {'errorcode': f'{modname}.{type(e).__name__}'}, 'exceptionstring': f'{e}'}}
sys.exit(
f'An exception of type {modname}.{type(e).__name__} occurred. Arguments:\n{e}'
)
# sys.exit(json.dumps(error_message, indent=2))
except KeyboardInterrupt as ki:
console.echo()
sys.exit(130)
def _func(ts):
ts_file = str(Path(self._targetservers_dir) / ts)
if not force:
path_exists(os.path.relpath(ts_file))
resp = Targetservers(self._auth, self._org_name,
ts).get_targetserver(environment).text
console.echo(resp, expc_verbosity=1)
with open(ts_file, 'w') as f:
f.write(resp)
def file(username, password, mfa_secret, token, zonename, org, profile, file,
key, **kwargs):
console.echo(
auth_with_prefix(gen_auth(username, password, mfa_secret, token,
zonename),
org,
None,
file=file,
key=key))
def name(username, password, mfa_secret, token, zonename, org, profile, name,
**kwargs):
console.echo(
auth_with_prefix(
gen_auth(username, password, mfa_secret, token, zonename),
org,
name,
file=None,
key='name',
))
def _func(cache):
cache_file = str(Path(self._caches_dir) / cache)
if not force:
path_exists(os.path.relpath(cache_file))
resp = (Caches(
self._auth, self._org_name,
cache).get_information_about_a_cache(environment).text)
console.echo(resp, expc_verbosity=1)
with open(cache_file, 'w') as f:
f.write(resp)
def _func(kvm):
kvm_file = str(Path(self._keyvaluemaps_dir) / kvm)
if not force:
path_exists(os.path.relpath(kvm_file))
resp = (Keyvaluemaps(
self._auth, self._org_name,
kvm).get_keyvaluemap_in_an_environment(environment).text)
console.echo(resp, expc_verbosity=1)
with open(kvm_file, 'w') as f:
f.write(resp)
def _get_access_token_for_token(auth, username, password, oauth_url,
post_headers, session):
if auth.zonename:
oauth_url = APIGEE_ZONENAME_OAUTH_URL.format(zonename=auth.zonename)
post_body = f'username={urllib.parse.quote(username)}&password={urllib.parse.quote(password)}&grant_type=password&response_type=token'
try:
return session.post(f'{oauth_url}',
headers=post_headers,
data=post_body)
except ConnectionError as ce:
console.echo(ce)
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 create_a_consumer_key_and_secret(
self,
developer,
consumer_key=None,
consumer_secret=None,
key_length=32,
secret_length=32,
key_suffix=None,
key_delimiter='-',
products=[],
):
uri = CREATE_A_CONSUMER_KEY_AND_SECRET_PATH.format(
api_url=APIGEE_ADMIN_API_URL,
org=self._org_name,
developer=developer,
name=self._app_name,
)
hdrs = auth.set_header(self._auth,
headers={
'Accept': 'application/json',
'Content-Type': 'application/json'
})
# app = self.get_developer_app_details(developer)
if not consumer_key:
consumer_key = "".join(
random.SystemRandom().choice(string.ascii_letters +
string.digits)
for _ in range(key_length))
if not consumer_secret:
consumer_secret = "".join(
random.SystemRandom().choice(string.ascii_letters +
string.digits)
for _ in range(secret_length))
if key_suffix:
consumer_key += key_delimiter
consumer_key += key_suffix
body = {'consumerKey': consumer_key, 'consumerSecret': consumer_secret}
resp = requests.post(uri, headers=hdrs, json=body)
resp.raise_for_status()
if products:
console.echo(resp.text)
consumer_key = resp.json()['consumerKey']
request_body = json.dumps({
'apiProducts': products,
'attributes': resp.json()['attributes']
})
console.echo(
f'Adding API Products {products} to consumerKey {consumer_key}'
)
return self.add_api_product_to_key(developer, consumer_key,
request_body)
return resp
def _get_access_token_for_sso(auth, username, password, oauth_url,
post_headers, session):
oauth_url = APIGEE_ZONENAME_OAUTH_URL.format(zonename=auth.zonename)
passcode_url = APIGEE_SAML_LOGIN_URL.format(zonename=auth.zonename)
webbrowser.open(passcode_url)
console.echo(
'SSO authorization page has automatically been opened in your default browser.'
)
console.echo(
'Follow the instructions in the browser to complete this authorization request.'
)
console.echo(
f"""\nIf your browser did not automatically open, go to the following URL and sign in:\n\n{passcode_url}\n\nthen copy the Temporary Authentication Code.\n"""
)
try:
passcode = click.prompt(
'Please enter the Temporary Authentication Code')
post_body = f'passcode={passcode}&grant_type=password&response_type=token'
try:
response_post = session.post(f'{oauth_url}',
headers=post_headers,
data=post_body)
response_post.json()['access_token']
return response_post
except KeyError:
sys.exit(
'Temporary Authentication Code is invalid. Please try again.')
except ConnectionError as ce:
console.echo(ce)
except KeyError:
pass
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_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_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 wrapper(*args, **kwargs):
try:
result = func(*args, **kwargs)
return result
except Exception as e:
logging.error('Exception occurred', exc_info=True)
frm = inspect.trace()[-1]
mod = inspect.getmodule(frm[0])
modname = mod.__name__ if mod else frm[1]
sys.exit(
f'An exception of type {modname}.{type(e).__name__} occurred. Arguments:\n{e}'
)
except KeyboardInterrupt:
console.echo()
sys.exit(130)
def set_apiproxy_basepath(self, basepath, file):
default_file = os.path.abspath(file)
tree = et.parse(default_file)
current_basepath = None
try:
current_basepath = tree.find('.//BasePath').text
except AttributeError:
sys.exit(f'No BasePath found in {default_file}')
with open(default_file, 'r+') as f:
body = f.read().replace(current_basepath, basepath)
f.seek(0)
f.write(body)
f.truncate()
console.echo(f'{current_basepath} -> {basepath}')
console.echo(f'M {os.path.relpath(default_file)}')
def undeploy_shared_flow_revisions_in_environment(
self, environment, shared_flow_name, except_revisions=set()
):
resp = self.get_shared_flow_deployments(shared_flow_name)
for deployment in resp.json()['environment']:
if deployment['name'] == environment:
for detail in deployment['revision']:
revision_number = int(detail['name'])
if revision_number not in except_revisions:
console.echo(
f'Undeploying revision {revision_number}... ', end='', flush=True
)
self.undeploy_a_shared_flow(environment, shared_flow_name, revision_number)
console.echo('Done')
return resp
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_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_apis(self):
for api, metadata in self.snapshot_data.apis.items():
for revision in metadata['revision']:
output_file = self._gen_download_path(
subpaths=['apis', api, revision, f'{api}.zip']
)
target_directory = os.path.dirname(output_file)
try:
Apis(self.auth, self.org_name, None).export_api_proxy(
api, revision, fs_write=True, output_file=output_file
)
extract_zip(output_file, target_directory)
os.remove(output_file)
except HTTPError as e:
console.echo(
f'Ignoring {type(e).__name__} {e.response.status_code} error for API Proxy ({api}, revision {revision})'
)
self._progress_callback(desc='APIs')
return self.snapshot_data.apis
def push_data_masks_for_an_api_proxy(self, file):
maskconfig = read_file(file, type='json')
maskconfig_name = maskconfig['name']
try:
self.get_data_mask_details_for_an_api_proxy(maskconfig_name)
console.echo(f'Updating {maskconfig_name} for {self._api_name}')
console.echo(self.create_data_masks_for_an_api_proxy(body).text)
except HTTPError as e:
if e.response.status_code != 404:
raise e
console.echo(f'Creating {maskconfig_name} for {self._api_name}')
console.echo(self.create_data_masks_for_an_api_proxy(body).text)
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_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 push_targetserver(self, environment, file):
targetserver = read_file(file, type='json')
self._targetserver_name = targetserver['name']
try:
self.get_targetserver(environment)
console.echo(f'Updating {self._targetserver_name}')
console.echo(self.update_a_targetserver(environment, body).text)
except HTTPError as e:
if e.response.status_code != 404:
raise e
console.echo(f'Creating {self._targetserver_name}')
console.echo(self.create_a_targetserver(environment, body).text)
def push_apiproducts(self, file):
apiproduct = read_file(file, type='json')
self._apiproduct_name = apiproduct['name']
try:
self.get_api_product()
console.echo(f'Updating {self._apiproduct_name}')
console.echo(self.update_api_product(body).text)
except HTTPError as e:
if e.response.status_code != 404:
raise e
console.echo(f'Creating {self._apiproduct_name}')
console.echo(self.create_api_product(body).text)
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_users_for_a_role(self, role_name):
try:
data = {
'snapshot': self._get_users_for_a_role(role_name),
'target_path': self._gen_download_path(
subpaths=['userroles', role_name, 'users.json']
),
'fs_write': self.fs_write,
'indent': 2,
}
write_file(
data['snapshot'],
data['target_path'],
fs_write=data['fs_write'],
indent=data['indent'],
)
except HTTPError as e:
console.echo(
f'Ignoring {type(e).__name__} {e.response.status_code} error for User Role ({role_name}) users'
)
def deploy_a_shared_flow(
self,
environment,
shared_flow_name,
revision_number,
override=False,
delay=0,
shared_flow_file=None,
):
do_deployments_exist = False
try:
if self.get_shared_flow_revisions(shared_flow_name):
do_deployments_exist = True
except HTTPError as e:
if e.response.status_code != 404:
raise e
if shared_flow_file:
revision_number = int(
self.import_a_shared_flow(shared_flow_file, shared_flow_name).json()['revision']
)
uri = DEPLOY_A_SHARED_FLOW_PATH.format(
api_url=APIGEE_ADMIN_API_URL,
org=self._org_name,
environment=environment,
shared_flow_name=shared_flow_name,
revision_number=revision_number,
)
options_dict = {'override': 'true' if override else 'false', 'delay': f'{delay}'}
params = add_to_dict_if_exists(options_dict)
hdrs = auth.set_header(self._auth, {'Accept': 'application/json'})
console.echo(f'Deploying revision {revision_number}... ', end='', flush=True)
resp = requests.post(uri, headers=hdrs, params=params)
resp.raise_for_status()
console.echo('Done')
if do_deployments_exist:
# console.echo('Attempting undeployment... ')
self.undeploy_shared_flow_revisions_in_environment(
environment, shared_flow_name, except_revisions={revision_number}
)
# console.echo('Done.')
return resp
def delete_undeployed_revisions(self,
api_name,
save_last=0,
dry_run=False):
details = ApisSerializer().filter_deployment_details(
Deployments(self._auth, self._org_name,
api_name).get_api_proxy_deployment_details().json())
undeployed = ApisSerializer().filter_undeployed_revisions(
self.list_api_proxy_revisions(api_name).json(),
ApisSerializer().filter_deployed_revisions(details),
save_last=save_last,
)
console.echo(f'Undeployed revisions to be deleted: {undeployed}')
if dry_run:
return undeployed
def _func(revision):
console.echo(f'Deleting revison {revision}')
self.delete_api_proxy_revision(api_name, revision)
return run_func_on_iterable(undeployed, _func)
def push_cache(self, environment, file):
cache = read_file(file, type='json')
self._cache_name = cache['name']
try:
self.get_information_about_a_cache(environment)
console.echo(f'Updating {self._cache_name}')
console.echo(
self.update_a_cache_in_an_environment(environment, body).text)
except HTTPError as e:
if e.response.status_code != 404:
raise e
console.echo(f'Creating {self._cache_name}')
console.echo(
self.create_a_cache_in_an_environment(environment, body).text)
