def list(self, request, *args, **kwargs):
"""Obtain the list of sources."""
response = super().list(request=request, args=args, kwargs=kwargs)
_, tenant = self._get_account_and_tenant(request)
for source in response.data["data"]:
if source.get("authentication", {}).get("credentials",
{}).get("client_secret"):
del source["authentication"]["credentials"]["client_secret"]
try:
manager = ProviderManager(source["uuid"])
except ProviderManagerError:
source["provider_linked"] = False
source["infrastructure"] = "Unknown"
source["cost_models"] = []
else:
source["provider_linked"] = True
source["infrastructure"] = manager.get_infrastructure_name()
connection.set_tenant(tenant)
source["cost_models"] = [{
"name": model.name,
"uuid": model.uuid
} for model in manager.get_cost_models(tenant)]
connection.set_schema_to_public()
connection.set_schema_to_public()
return response
def test_provider_statistics_negative_case(self):
"""Test that the provider statistics method returns None for tenant misalignment."""
# Create Provider
provider_authentication = ProviderAuthentication.objects.create(provider_resource_name='cluster_id_1001')
provider = Provider.objects.create(name='ocpprovidername',
type='AWS',
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,)
data_generator = OCPReportDataGenerator(self.tenant, provider)
data_generator.add_data_to_tenant(**{'provider_uuid': provider.uuid})
provider_uuid = provider.uuid
manager = ProviderManager(provider_uuid)
stats = manager.provider_statistics(self.tenant)
self.assertIn(str(data_generator.dh.this_month_start.date()), stats.keys())
self.assertIn(str(data_generator.dh.last_month_start.date()), stats.keys())
for key, value in stats.items():
key_date_obj = parser.parse(key)
value_data = value.pop()
self.assertIsNotNone(value_data.get('assembly_id'))
self.assertIsNotNone(value_data.get('files_processed'))
self.assertEqual(value_data.get('billing_period_start'), key_date_obj.date())
self.assertGreater(parser.parse(value_data.get('last_process_start_date')), key_date_obj)
self.assertGreater(parser.parse(value_data.get('last_process_complete_date')), key_date_obj)
self.assertIsNone(value_data.get('summary_data_creation_datetime'))
self.assertIsNone(value_data.get('summary_data_updated_datetime'))
self.assertIsNone(value_data.get('derived_cost_datetime'))
def test_provider_manager_error(self):
"""Raise ProviderManagerError."""
with self.assertRaises(ProviderManagerError):
ProviderManager(uuid="4216c8c7-8809-4381-9a24-bd965140efe2")
with self.assertRaises(ProviderManagerError):
ProviderManager(uuid="abc")
def test_delete_report_data(self, mock_delete):
"""Test that the masu API call returns a response."""
logging.disable(logging.NOTSET)
response = MockResponse(200, '{"Response": "OK"}')
mock_delete.return_value = response
expected_message = f'INFO:api.provider.provider_manager:Response: {response.json()}'
provider_authentication = ProviderAuthentication.objects.create(
provider_resource_name='arn:aws:iam::2:role/mg'
)
provider_billing = ProviderBillingSource.objects.create(
bucket='my_s3_bucket'
)
provider = Provider.objects.create(name='awsprovidername',
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,
billing_source=provider_billing)
provider_uuid = provider.uuid
manager = ProviderManager(provider_uuid)
with self.assertLogs('api.provider.provider_manager', level='INFO') as logger:
manager._delete_report_data()
self.assertIn(expected_message, logger.output)
def test_remove_aws(self):
"""Remove aws provider."""
# Create Provider
provider_authentication = ProviderAuthentication.objects.create(provider_resource_name='arn:aws:iam::2:role/mg')
provider_billing = ProviderBillingSource.objects.create(bucket='my_s3_bucket')
provider = Provider.objects.create(name='awsprovidername',
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,
billing_source=provider_billing)
provider_uuid = provider.uuid
new_user_dict = self._create_user_data()
request_context = self._create_request_context(self.customer_data,
new_user_dict, False)
user_serializer = UserSerializer(data=new_user_dict, context=request_context)
other_user = None
if user_serializer.is_valid(raise_exception=True):
other_user = user_serializer.save()
with tenant_context(self.tenant):
manager = ProviderManager(provider_uuid)
manager.remove(self._create_delete_request(other_user))
provider_query = Provider.objects.all().filter(uuid=provider_uuid)
auth_count = ProviderAuthentication.objects.count()
billing_count = ProviderBillingSource.objects.count()
self.assertFalse(provider_query)
self.assertEqual(auth_count, 0)
self.assertEqual(billing_count, 0)
def test_is_removable_by_user(self):
"""Can current user remove provider."""
# Create Customer
customer = None
serializer = CustomerSerializer(data=self.customer_data[0])
if serializer.is_valid(raise_exception=True):
customer = serializer.save()
# Create Provider
provider = Provider.objects.create(name='providername', created_by=customer.owner, customer=customer)
provider_uuid = provider.uuid
# Create another user for negative tests
# Add another user
group = Group.objects.get(name=customer.name)
new_user_dict = self.gen_user_data()
user_serializer = UserSerializer(data=new_user_dict)
new_user = None
if user_serializer.is_valid(raise_exception=True):
new_user = user_serializer.save()
group.user_set.add(new_user)
manager = ProviderManager(provider_uuid)
self.assertTrue(manager.is_removable_by_user(customer.owner))
self.assertFalse(manager.is_removable_by_user(new_user))
superuser = User.objects.filter(is_superuser=True).first()
self.assertFalse(manager.is_removable_by_user(superuser))
def test_ocp_on_azure_infrastructure_type(self):
"""Test that the provider infrastructure returns Azure when running on Azure."""
credentials = {"cluster_id": "cluster_id_1002"}
provider_authentication = ProviderAuthentication.objects.create(
credentials=credentials)
azure_provider = Provider.objects.filter(type="Azure-local").first()
infrastructure = ProviderInfrastructureMap.objects.create(
infrastructure_type=Provider.PROVIDER_AZURE,
infrastructure_provider=azure_provider)
with patch("masu.celery.tasks.check_report_updates"):
provider = Provider.objects.create(
name="ocpprovidername",
type=Provider.PROVIDER_OCP,
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,
infrastructure=infrastructure,
)
provider_uuid = provider.uuid
manager = ProviderManager(provider_uuid)
infrastructure_info = manager.get_infrastructure_info()
self.assertEqual(infrastructure_info.get("type", ""),
Provider.PROVIDER_AZURE)
self.assertEqual(infrastructure_info.get("uuid", ""),
azure_provider.uuid)
def test_update_ocp_added_via_sources(self):
"""Raise error on update to ocp provider added via sources."""
# Create Provider
credentials = {"cluster_id": "cluster_id_1001"}
provider_authentication = ProviderAuthentication.objects.create(
credentials=credentials)
with patch("masu.celery.tasks.check_report_updates"):
provider = Provider.objects.create(
name="ocpprovidername",
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,
)
provider_uuid = provider.uuid
sources = Sources.objects.create(source_id=1,
auth_header="testheader",
offset=1,
koku_uuid=provider_uuid)
sources.save()
put_request = self._create_put_request(self.user)
with tenant_context(self.tenant):
manager = ProviderManager(provider_uuid)
with self.assertRaises(ProviderManagerError):
manager.update(put_request)
def test_provider_statistics(self):
"""Test that the provider statistics method returns report stats."""
provider = Provider.objects.filter(data_updated_timestamp__isnull=False).first()
self.assertIsNotNone(provider)
provider_uuid = provider.uuid
manager = ProviderManager(provider_uuid)
stats = manager.provider_statistics(self.tenant)
self.assertIn(str(self.dh.this_month_start.date()), stats.keys())
self.assertIn(str(self.dh.last_month_start.date()), stats.keys())
for key, value in stats.items():
if key == "data_updated_date":
value_data = value
self.assertIsInstance(parser.parse(value_data), date)
continue
key_date_obj = parser.parse(key)
value_data = value.pop()
self.assertIsNotNone(value_data.get("assembly_id"))
self.assertIsNotNone(value_data.get("files_processed"))
self.assertEqual(value_data.get("billing_period_start"), key_date_obj.date())
self.assertGreater(parser.parse(value_data.get("last_process_start_date")), key_date_obj)
self.assertGreater(parser.parse(value_data.get("last_process_complete_date")), key_date_obj)
self.assertGreater(parser.parse(value_data.get("last_manifest_complete_date")), key_date_obj)
def test_provider_statistics_ocp_on_cloud(self):
"""Test that the provider statistics method returns report stats."""
provider_uuid = ProviderInfrastructureMap.objects.first(
).infrastructure_provider_id
provider = Provider.objects.filter(uuid=provider_uuid).first()
self.assertIsNotNone(provider)
provider_uuid = provider.uuid
manager = ProviderManager(provider_uuid)
stats = manager.provider_statistics(self.tenant)
self.assertIn(str(self.dh.this_month_start.date()), stats.keys())
self.assertIn(str(self.dh.last_month_start.date()), stats.keys())
for key, value in stats.items():
if key == "data_updated_date":
value_data = value
self.assertIsInstance(parser.parse(value_data), date)
continue
elif key == "ocp_on_cloud_data_updated_date":
self.assertIsInstance(parser.parse(value_data), date)
continue
ocp_on_cloud = value.get("ocp_on_cloud")
for record in ocp_on_cloud:
self.assertIsNotNone(record.get("ocp_source_uuid"))
self.assertIsNotNone(
record.get("ocp_on_cloud_updated_datetime"))
def test_remove_not_removeable(self, _):
"""Test error raised if user without capability tries to remove a provider."""
# Create Provider
credentials = {"role_arn": "arn:aws:iam::2:role/mg"}
provider_authentication = ProviderAuthentication.objects.create(credentials=credentials)
data_source = {"bucket": "my_s3_bucket"}
provider_billing = ProviderBillingSource.objects.create(data_source=data_source)
with patch("masu.celery.tasks.check_report_updates"):
provider = Provider.objects.create(
name="awsprovidername",
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,
billing_source=provider_billing,
)
provider_uuid = provider.uuid
new_user_dict = self._create_user_data()
request_context = self._create_request_context(self.customer_data, new_user_dict, False, create_user=False)
user_serializer = UserSerializer(data=new_user_dict, context=request_context)
other_user = None
if user_serializer.is_valid(raise_exception=True):
other_user = user_serializer.save()
with tenant_context(self.tenant):
manager = ProviderManager(provider_uuid)
with self.assertRaises(ProviderManagerError):
manager.remove(self._create_delete_request(other_user))
def test_remove_ocp_added_via_sources(self, mock_delete_report):
"""Remove ocp provider added via sources."""
# Create Provider
provider_authentication = ProviderAuthentication.objects.create(
provider_resource_name='cluster_id_1001')
provider = Provider.objects.create(
name='ocpprovidername',
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,
)
provider_uuid = provider.uuid
sources = Sources.objects.create(source_id=1,
auth_header='testheader',
offset=1,
koku_uuid=provider_uuid)
sources.save()
delete_request = self._create_delete_request(
self.user, {'Sources-Client': 'True'})
with tenant_context(self.tenant):
manager = ProviderManager(provider_uuid)
manager.remove(delete_request)
provider_query = Provider.objects.all().filter(uuid=provider_uuid)
self.assertFalse(provider_query)
def test_ocp_infrastructure_type_error(self):
"""Test that the provider infrastructure returns Unknown when running stand alone."""
provider_authentication = ProviderAuthentication.objects.create(
provider_resource_name='cluster_id_1001')
provider = Provider.objects.create(
name='ocpprovidername',
type=Provider.PROVIDER_OCP,
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,
)
data_generator = OCPAWSReportDataGenerator(self.tenant,
provider,
current_month_only=True)
data_generator.create_ocp_provider('cool-cluster-id', 'awesome-alias')
provider_uuid = data_generator.provider_uuid
manager = ProviderManager(provider_uuid)
with patch.object(ProviderAccessor,
'infrastructure_type',
side_effect=ProviderAccessorError('mock_error')):
infrastructure_name = manager.get_infrastructure_name(self.tenant)
self.assertEqual(infrastructure_name, 'Unknown-Error')
data_generator.remove_data_from_tenant()
def test_ocp_infrastructure_type(self):
"""Test that the provider infrastructure returns Unknown when running stand alone."""
provider_authentication = ProviderAuthentication.objects.create(
provider_resource_name='cluster_id_1001')
provider = Provider.objects.create(
name='ocpprovidername',
type=Provider.PROVIDER_OCP,
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,
)
ocp_aws_data_generator = OCPAWSReportDataGenerator(
self.tenant, provider, current_month_only=True)
data_generator = OCPReportDataGenerator(self.tenant,
provider,
current_month_only=True)
data_generator.add_data_to_tenant()
ocp_aws_data_generator.create_ocp_provider(
data_generator.cluster_id, data_generator.cluster_alias)
provider_uuid = ocp_aws_data_generator.provider_uuid
manager = ProviderManager(provider_uuid)
infrastructure_name = manager.get_infrastructure_name(self.tenant)
self.assertEqual(infrastructure_name, 'Unknown')
data_generator.remove_data_from_tenant()
ocp_aws_data_generator.remove_data_from_tenant()
def test_remove(self):
"""Remove provider."""
# Create Customer
customer = None
serializer = CustomerSerializer(data=self.customer_data[0])
if serializer.is_valid(raise_exception=True):
customer = serializer.save()
# Create Provider
provider = Provider.objects.create(name='providername', created_by=customer.owner, customer=customer)
provider_uuid = provider.uuid
# Create another user for negative tests
# Add another user
group = Group.objects.get(name=customer.name)
new_user_dict = self.gen_user_data()
user_serializer = UserSerializer(data=new_user_dict)
other_user = None
if user_serializer.is_valid(raise_exception=True):
other_user = user_serializer.save()
group.user_set.add(other_user)
manager = ProviderManager(provider_uuid)
with self.assertRaises(ProviderManagerError):
self.assertFalse(manager.remove(other_user))
manager.remove(customer.owner)
provider_query = Provider.objects.all().filter(uuid=provider_uuid)
self.assertFalse(provider_query)
def test_remove_ocp_added_via_sources(self):
"""Remove ocp provider added via sources."""
# Create Provider
credentials = {"cluster_id": "cluster_id_1001"}
provider_authentication = ProviderAuthentication.objects.create(
credentials=credentials)
with patch("masu.celery.tasks.check_report_updates"):
provider = Provider.objects.create(
name="ocpprovidername",
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,
)
provider_uuid = provider.uuid
sources = Sources.objects.create(source_id=1,
auth_header="testheader",
offset=1,
koku_uuid=provider_uuid)
sources.save()
delete_request = self._create_delete_request(
self.user, {"Sources-Client": "True"})
with tenant_context(self.tenant):
manager = ProviderManager(provider_uuid)
manager.remove(delete_request, from_sources=True)
provider_query = Provider.objects.all().filter(uuid=provider_uuid)
self.assertFalse(provider_query)
def test_get_providers_queryset_for_customer(self):
"""Verify all providers returned by a customer."""
# Create Customer
customer = None
serializer = CustomerSerializer(data=self.customer_data[0])
if serializer.is_valid(raise_exception=True):
customer = serializer.save()
# Verify no providers are returned
self.assertFalse(ProviderManager.get_providers_queryset_for_customer(customer).exists())
# Create Providers
provider_1 = Provider.objects.create(name='provider1', created_by=customer.owner, customer=customer)
provider_2 = Provider.objects.create(name='provider2', created_by=customer.owner, customer=customer)
providers = ProviderManager.get_providers_queryset_for_customer(customer)
# Verify providers are returned
provider_1_found = False
provider_2_found = False
for provider in providers:
if provider.uuid == provider_1.uuid:
provider_1_found = True
elif provider.uuid == provider_2.uuid:
provider_2_found = True
self.assertTrue(provider_1_found)
self.assertTrue(provider_2_found)
self.assertEqual((len(providers)), 2)
def test_get_providers_queryset_for_customer(self):
"""Verify all providers returned by a customer."""
# Verify no providers are returned
self.assertFalse(ProviderManager.get_providers_queryset_for_customer(self.customer).exists())
# Create Providers
provider_1 = Provider.objects.create(name='provider1',
created_by=self.user,
customer=self.customer)
provider_2 = Provider.objects.create(name='provider2',
created_by=self.user,
customer=self.customer)
providers = ProviderManager.get_providers_queryset_for_customer(self.customer)
# Verify providers are returned
provider_1_found = False
provider_2_found = False
for provider in providers:
if provider.uuid == provider_1.uuid:
provider_1_found = True
elif provider.uuid == provider_2.uuid:
provider_2_found = True
self.assertTrue(provider_1_found)
self.assertTrue(provider_2_found)
self.assertEqual((len(providers)), 2)
def retrieve(self, request, *args, **kwargs):
"""Get a source."""
response = super().retrieve(request=request, args=args, kwargs=kwargs)
_, tenant = self._get_account_and_tenant(request)
if response.data.get("authentication",
{}).get("credentials", {}).get("client_secret"):
del response.data["authentication"]["credentials"]["client_secret"]
try:
manager = ProviderManager(response.data["uuid"])
except ProviderManagerError:
response.data["provider_linked"] = False
response.data["active"] = False
response.data["infrastructure"] = "Unknown"
response.data["cost_models"] = []
else:
response.data["provider_linked"] = True
response.data["active"] = manager.get_active_status()
response.data["infrastructure"] = manager.get_infrastructure_name()
connection.set_tenant(tenant)
response.data["cost_models"] = [{
"name": model.name,
"uuid": model.uuid
} for model in manager.get_cost_models(tenant)]
connection.set_schema_to_public()
return response
def test_remove_aws_auth_billing_remain(self):
"""Remove aws provider."""
# Create Provider
credentials = {"role_arn": "arn:aws:iam::2:role/mg"}
provider_authentication = ProviderAuthentication.objects.create(
credentials=credentials)
expected_auth_count = ProviderAuthentication.objects.count()
credentials = {"role_arn": "arn:aws:iam::3:role/mg"}
provider_authentication2 = ProviderAuthentication.objects.create(
credentials=credentials)
data_source = {"bucket": "my_s3_bucket"}
provider_billing = ProviderBillingSource.objects.create(
data_source=data_source)
expected_billing_count = ProviderBillingSource.objects.count()
with patch("masu.celery.tasks.check_report_updates"):
provider = Provider.objects.create(
name="awsprovidername",
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,
billing_source=provider_billing,
)
provider2 = Provider.objects.create(
name="awsprovidername2",
created_by=self.user,
customer=self.customer,
authentication=provider_authentication2,
billing_source=provider_billing,
)
provider_uuid = provider2.uuid
self.assertNotEqual(provider.uuid, provider2.uuid)
new_user_dict = self._create_user_data()
request_context = self._create_request_context(self.customer_data,
new_user_dict,
False,
create_user=False)
user_serializer = UserSerializer(data=new_user_dict,
context=request_context)
other_user = None
if user_serializer.is_valid(raise_exception=True):
other_user = user_serializer.save()
with tenant_context(self.tenant):
manager = ProviderManager(provider_uuid)
manager.remove(self._create_delete_request(other_user))
auth_count = ProviderAuthentication.objects.count()
billing_count = ProviderBillingSource.objects.count()
provider_query = Provider.objects.all().filter(uuid=provider_uuid)
self.assertFalse(provider_query)
self.assertEqual(auth_count, expected_auth_count)
self.assertEqual(billing_count, expected_billing_count)
def stats(self, request, pk=None):
"""Get source stats."""
source = self.get_object()
stats = {}
try:
manager = ProviderManager(source.source_uuid)
except ProviderManagerError:
stats["provider_linked"] = False
else:
stats["provider_linked"] = True
stats.update(manager.provider_statistics(request.tenant))
return Response(stats)
def test_get_name(self):
"""Can the provider name be returned."""
# Create Provider
provider_name = "sample_provider"
provider = Provider.objects.create(name=provider_name, created_by=self.user, customer=self.customer)
# Get Provider UUID
provider_uuid = provider.uuid
# Get Provider Manager
manager = ProviderManager(provider_uuid)
self.assertEqual(manager.get_name(), provider_name)
def test_ocp_infrastructure_type_error(self):
"""Test that the provider infrastructure returns Unknown when running stand alone."""
data_generator = OCPAWSReportDataGenerator(self.tenant, current_month_only=True)
data_generator.create_ocp_provider('cool-cluster-id', 'awesome-alias')
provider_uuid = data_generator.provider_uuid
manager = ProviderManager(provider_uuid)
with patch.object(ProviderAccessor, 'infrastructure_type', side_effect=ProviderAccessorError('mock_error')):
infrastructure_name = manager.get_infrastructure_name(self.tenant)
self.assertEqual(infrastructure_name, 'Unknown-Error')
data_generator.remove_data_from_tenant()
def destroy_provider(self, provider_uuid):
"""Call to destroy provider."""
connection.set_schema_to_public()
_, customer, user = self._create_context()
tenant = Tenant.objects.get(schema_name=customer.schema_name)
connection.set_tenant(tenant)
try:
manager = ProviderManager(provider_uuid)
except ProviderManagerError:
LOG.info("Provider does not exist, skipping Provider delete.")
else:
manager.remove(user=user, from_sources=True)
connection.set_schema_to_public()
def test_get_name(self):
"""Can the provider name be returned."""
# Create Provider
provider_name = "sample_provider"
with patch("masu.celery.tasks.check_report_updates"):
provider = Provider.objects.create(name=provider_name, created_by=self.user, customer=self.customer)
# Get Provider UUID
provider_uuid = provider.uuid
# Get Provider Manager
manager = ProviderManager(provider_uuid)
self.assertEqual(manager.get_name(), provider_name)
def test_remove_all_aws_providers(self):
"""Remove all AWS providers."""
provider_query = Provider.objects.all().filter(type="AWS-local")
customer = None
for provider in provider_query:
customer = provider.customer
with tenant_context(provider.customer):
manager = ProviderManager(provider.uuid)
manager.remove(self._create_delete_request(self.user, {"Sources-Client": "False"}))
for view in AWS_MATERIALIZED_VIEWS:
with tenant_context(customer):
self.assertFalse(view.objects.count())
def test_ocp_on_aws_infrastructure_type(self):
"""Test that the provider infrastructure returns AWS when running on AWS."""
data_generator = OCPAWSReportDataGenerator(self.tenant, current_month_only=True)
data_generator.add_data_to_tenant()
data_generator.add_aws_data_to_tenant()
data_generator.create_ocp_provider(data_generator.cluster_id, data_generator.cluster_alias)
provider_uuid = data_generator.provider_uuid
manager = ProviderManager(provider_uuid)
infrastructure_name = manager.get_infrastructure_name(self.tenant)
self.assertEqual(infrastructure_name, 'AWS')
data_generator.remove_data_from_tenant()
def destroy(self, request, *args, **kwargs):
"""Delete a customer.
@api {delete} /api/v1/customers/:uuid/ Delete a customer
@apiName DeleteCustomers
@apiGroup Customer
@apiVersion 1.0.0
@apiDescription Delete a customer.
@apiHeader {String} token Service Admin authorization token.
@apiHeaderExample {json} Header-Example:
{
"Authorization": "Token 45138a913da44ab89532bab0352ef84b"
}
@apiParam {String} uuid Customer unique ID.
@apiSuccessExample {json} Success-Response:
HTTP/1.1 204 NO CONTENT
"""
user_savepoint = transaction.savepoint()
customer_manager = None
try:
customer_manager = CustomerManager(kwargs['uuid'])
except (CustomerManagerDoesNotExist, CustomerManagerValidationError):
LOG.error('Unable to find provider for uuid {}.'.format(kwargs['uuid']))
raise NotFound
providers = ProviderManager.get_providers_queryset_for_customer(customer_manager.get_model())
try:
customer_manager.remove_users(request.user)
customer_manager.remove_tenant(request.user)
except DatabaseError:
transaction.savepoint_rollback(user_savepoint)
LOG.error('Failed to remove assets for customer {}.'.format(customer_manager.get_name()))
raise UserDeleteException
try:
for provider in providers:
provider_manager = ProviderManager(provider.uuid)
provider_manager.remove(request.user, customer_remove_context=True)
except (DatabaseError, ProviderManagerError):
transaction.savepoint_rollback(user_savepoint)
LOG.error('{} failed to remove provider {}.'.format(request.user.username, provider_manager.get_name()))
raise ProviderDeleteException
http_response = super().destroy(request=request, args=args, kwargs=kwargs)
if http_response.status_code is not 204:
transaction.savepoint_rollback(user_savepoint)
return http_response
def destroy_provider(self, provider_uuid, retry_count=None):
"""Call to destroy provider."""
connection.set_schema_to_public()
_, customer, user = self._create_context()
tenant = self._tenant_for_schema(customer.schema_name)
connection.set_tenant(tenant)
try:
manager = ProviderManager(provider_uuid)
except ProviderManagerError:
LOG.info("Provider does not exist, skipping Provider delete.")
else:
manager.remove(user=user, from_sources=True, retry_count=retry_count)
invalidate_view_cache_for_tenant_and_cache_key(customer.schema_name, SOURCES_CACHE_PREFIX)
connection.set_schema_to_public()
def test_update_ocp_not_added_via_sources(self):
"""Return None on update to ocp provider not added via sources."""
# Create Provider
provider_authentication = ProviderAuthentication.objects.create(provider_resource_name='cluster_id_1001')
provider = Provider.objects.create(name='ocpprovidername',
created_by=self.user,
customer=self.customer,
authentication=provider_authentication,)
provider_uuid = provider.uuid
put_request = self._create_put_request(self.user)
with tenant_context(self.tenant):
manager = ProviderManager(provider_uuid)
self.assertIsNone(manager.update(put_request))
