def _build_arbitrary_client(self,
client_name,
client_version,
force_new=False):
"""
:param client_name: name of the service
:param client_version: version of the client to create
:param force_new: whether to create a new client - useful to create arbitrary clients from facades
:return:
"""
if force_new:
client = discovery.build(client_name,
client_version,
cache_discovery=False,
cache=MemoryCache())
http.set_user_agent(
client._http, get_user_agent()) # force set custom user agent
return client
else:
if not self._client:
client = discovery.build(client_name,
client_version,
cache_discovery=False,
cache=MemoryCache())
http.set_user_agent(
client._http,
get_user_agent()) # force set custom user agent
self._client = client
return self._client
async def _get_and_set_activity_logs(self, storage_account,
subscription_id: str):
client = MonitorManagementClient(self.credentials.arm_credentials,
subscription_id)
client._client.config.add_user_agent(get_user_agent())
# Time format used by Azure API:
time_format = "%Y-%m-%dT%H:%M:%S.%f"
# Azure API uses UTC time, we need to use the same to avoid bad requests:
utc_now = datetime.datetime.utcnow()
# Activity logs are only archived for a period of 90 days max (requesting a timespan of more than that ends up
# with a bad request):
timespan = datetime.timedelta(90)
logs_filter = " and ".join([
"eventTimestamp ge {}".format(
(utc_now - timespan).strftime(time_format)),
"eventTimestamp le {}".format(utc_now.strftime(time_format)),
f"resourceId eq {storage_account.id}",
])
try:
activity_logs = await run_concurrently(lambda: list(
client.activity_logs.list(filter=logs_filter,
select=
"eventTimestamp, operationName")))
except Exception as e:
print_exception(f'Failed to retrieve activity logs: {e}')
setattr(storage_account, 'activity_logs', [])
else:
setattr(storage_account, 'activity_logs', activity_logs)
def __init__(self):
# This facade is currently using both libraries as the Cloud Client library doesn't support locations
# Cloud Client
client_info = ClientInfo(user_agent=get_user_agent())
self.cloud_client = kms.KeyManagementServiceClient(client_info=client_info)
# self.cloud_client = kms.KeyManagementServiceClient()
super().__init__('cloudkms', 'v1') # API Client
def get_client(self, subscription_id: str):
client = AuthorizationManagementClient(
self.credentials.get_credentials('arm'),
subscription_id=subscription_id)
client._client.config.add_user_agent(get_user_agent())
return client
def get_alerts_client(self):
client_info = ClientInfo(user_agent=get_user_agent())
client = stackdrivermonitoring.AlertPolicyServiceClient(client_info=client_info)
return client
def get_uptime_client(self):
client_info = ClientInfo(user_agent=get_user_agent())
client = stackdrivermonitoring.UptimeCheckServiceClient(client_info=client_info)
return client
def get_client(self):
client = GraphRbacManagementClient(
self.credentials.get_credentials('aad_graph'),
tenant_id=self.credentials.get_tenant_id())
client._client.config.add_user_agent(get_user_agent())
return client
def get_client(self, subscription_id: str):
client = SecurityCenter(self.credentials.get_credentials('arm'),
subscription_id, '')
client._client.config.add_user_agent(get_user_agent())
return client
def _set_subscriptions(self):
# Create the client
subscription_client = SubscriptionClient(
self.credentials.arm_credentials)
subscription_client._client.config.add_user_agent(get_user_agent())
# Get all the accessible subscriptions
accessible_subscriptions_list = list(
subscription_client.subscriptions.list())
if not accessible_subscriptions_list:
raise AuthenticationException(
'The provided credentials do not have access to any subscriptions'
)
# Final list, start empty
subscriptions_list = []
# No subscription provided, infer
if not (self.subscription_ids or self.all_subscriptions):
try:
# Tries to read the subscription list
print_info('No subscription set, inferring')
s = next(subscription_client.subscriptions.list())
except StopIteration:
print_info('Unable to infer a subscription')
# If the user cannot read subscription list, ask Subscription ID:
if not self.programmatic_execution:
s = input('Subscription ID: ')
else:
print_exception('Unable to infer a Subscription ID')
# raise
finally:
subscriptions_list.append(s)
# All subscriptions
elif self.all_subscriptions:
subscriptions_list = accessible_subscriptions_list
# A specific set of subscriptions
elif self.subscription_ids:
# Only include accessible subscriptions
subscriptions_list = [
s for s in accessible_subscriptions_list
if s.subscription_id in self.subscription_ids
]
# Verbose skip
for s in self.subscription_ids:
if not any(subs.subscription_id == s
for subs in accessible_subscriptions_list):
raise AuthenticationException(
'Subscription {} does not exist or is not accessible '
'with the provided credentials'.format(s))
# Other == error
else:
raise AuthenticationException('Unknown Azure subscription option')
if subscriptions_list and len(subscriptions_list) > 0:
self.subscription_list = subscriptions_list
if len(subscriptions_list) == 1:
print_info('Running against subscription {}'.format(
subscriptions_list[0].subscription_id))
else:
print_info('Running against {} subscriptions'.format(
len(subscriptions_list)))
else:
raise AuthenticationException('No subscriptions to scan')
def get_client(self, project_id: str):
client_info = ClientInfo(user_agent=get_user_agent())
client = stackdriverlogging.Client(project=project_id,
client_info=client_info)
return client
def get_client(self, project_id: str):
client_info = ClientInfo(user_agent=get_user_agent())
client = storage.Client(project=project_id, client_info=client_info)
return client