def test_returns_500_with_json_body_if_service_exception_was_raised(self):
self.broker.deprovision.side_effect = errors.ServiceException("Boooom!")
response = self.client.delete(
"/v2/service_instances/abc?plan_id=a&service_id=service-guid-here",
headers={
'Authorization': self.auth_header,
'X-Broker-Api-Version': '2.13',
})
self.assertEqual(response.status_code, http.HTTPStatus.INTERNAL_SERVER_ERROR)
self.assertEqual(response.json["description"], "Boooom!")
def provision(instance_id):
try:
accepts_incomplete = 'true' == request.args.get(
"accepts_incomplete", 'false')
if not request.is_json:
er = ErrorResponse(
description=
'Improper Content-Type header. Expecting "application/json"'
)
return to_json_response(er), HTTPStatus.BAD_REQUEST
provision_details = ProvisionDetails(**json.loads(request.data))
provision_details.originating_identity = request.originating_identity
provision_details.authorization_username = request.authorization.username
broker = get_broker_by_id(provision_details.service_id)
if not broker.check_plan_id(provision_details.plan_id):
raise TypeError('plan_id not found in this service.')
except (TypeError, KeyError) as e:
logger.exception(e)
return to_json_response(
ErrorResponse(description=str(e))), HTTPStatus.BAD_REQUEST
try:
result = broker.provision(instance_id, provision_details,
accepts_incomplete)
add_service_id_to_async_response(result, broker.service_id())
except errors.ErrInstanceAlreadyExists as e:
logger.exception(e)
return to_json_response(EmptyResponse()), HTTPStatus.CONFLICT
except errors.ErrAsyncRequired as e:
logger.exception(e)
return to_json_response(
ErrorResponse(
error="AsyncRequired",
description=
"This service plan requires client support for asynchronous service operations."
)), HTTPStatus.UNPROCESSABLE_ENTITY
if result.state == ProvisionState.IS_ASYNC:
return to_json_response(
ProvisioningResponse(result.dashboard_url,
result.operation)), HTTPStatus.ACCEPTED
elif result.state == ProvisionState.IDENTICAL_ALREADY_EXISTS:
return to_json_response(
ProvisioningResponse(result.dashboard_url,
result.operation)), HTTPStatus.OK
elif result.state == ProvisionState.SUCCESSFUL_CREATED:
return to_json_response(
ProvisioningResponse(result.dashboard_url,
result.operation)), HTTPStatus.CREATED
else:
raise errors.ServiceException(
'IllegalState, ProvisioningState unknown.')
def provision(instance_id):
try:
accepts_incomplete = 'true' == request.args.get(
"accepts_incomplete", 'false')
provision_details = ProvisionDetails(**json.loads(request.data))
provision_details.originating_identity = request.originating_identity
provision_details.authorization_username = extract_authorization_username(
request)
if not _check_plan_id(service_broker, provision_details.plan_id):
raise TypeError('plan_id not found in this service.')
except (TypeError, KeyError, JSONDecodeError) as e:
logger.exception(e)
return to_json_response(
ErrorResponse(description=str(e))), HTTPStatus.BAD_REQUEST
try:
result = service_broker.provision(instance_id, provision_details,
accepts_incomplete)
except errors.ErrInstanceAlreadyExists as e:
logger.exception(e)
return to_json_response(EmptyResponse()), HTTPStatus.CONFLICT
except errors.ErrInvalidParameters as e:
return to_json_response(ErrorResponse(
'InvalidParameters', str(e))), HTTPStatus.BAD_REQUEST
except errors.ErrAsyncRequired as e:
logger.exception(e)
return to_json_response(
ErrorResponse(
error="AsyncRequired",
description=
"This service plan requires client support for asynchronous service operations."
)), HTTPStatus.UNPROCESSABLE_ENTITY
if result.state == ProvisionState.IS_ASYNC:
return to_json_response(
ProvisioningResponse(result.dashboard_url,
result.operation)), HTTPStatus.ACCEPTED
elif result.state == ProvisionState.IDENTICAL_ALREADY_EXISTS:
return to_json_response(
ProvisioningResponse(result.dashboard_url,
result.operation)), HTTPStatus.OK
elif result.state == ProvisionState.SUCCESSFUL_CREATED:
return to_json_response(
ProvisioningResponse(result.dashboard_url,
result.operation)), HTTPStatus.CREATED
else:
raise errors.ServiceException(
'IllegalState, ProvisioningState unknown.')
def bind(instance_id, binding_id):
try:
accepts_incomplete = 'true' == request.args.get(
"accepts_incomplete", 'false')
binding_details = BindDetails(**json.loads(request.data))
binding_details.originating_identity = request.originating_identity
binding_details.authorization_username = extract_authorization_username(
request)
if not _check_plan_id(service_broker, binding_details.plan_id):
raise TypeError('plan_id not found in this service.')
except (TypeError, KeyError, JSONDecodeError) as e:
logger.exception(e)
return to_json_response(
ErrorResponse(description=str(e))), HTTPStatus.BAD_REQUEST
try:
result = service_broker.bind(instance_id, binding_id,
binding_details, accepts_incomplete)
except errors.ErrBindingAlreadyExists as e:
logger.exception(e)
return to_json_response(EmptyResponse()), HTTPStatus.CONFLICT
except errors.ErrAppGuidNotProvided as e:
logger.exception(e)
return to_json_response(
ErrorResponse(
error="RequiresApp",
description=
"This service supports generation of credentials through binding an application only."
)), HTTPStatus.UNPROCESSABLE_ENTITY
response = BindResponse(credentials=result.credentials,
syslog_drain_url=result.syslog_drain_url,
route_service_url=result.route_service_url,
volume_mounts=result.volume_mounts)
if result.state == BindState.SUCCESSFUL_BOUND:
return to_json_response(response), HTTPStatus.CREATED
elif result.state == BindState.IDENTICAL_ALREADY_EXISTS:
return to_json_response(response), HTTPStatus.OK
elif result.state == BindState.IS_ASYNC:
return to_json_response(
BindResponse(operation=result.operation)), HTTPStatus.ACCEPTED
else:
raise errors.ServiceException('IllegalState, BindState unknown.')
def provision(self, instance_id: str, details: ProvisionDetails,
async_allowed: bool, **kwargs) -> ProvisionedServiceSpec:
if not async_allowed:
raise errors.ErrAsyncRequired()
if instance_id in self.service_instances.keys():
raise errors.ErrInstanceAlreadyExists()
self.service_instances[instance_id] = {
'provision_details': details,
'state': self.CREATING
}
try:
project_name = details.parameters.get('project_name')
github_id = details.parameters.get('github_id')
github_pass = details.parameters.get('github_pass')
email_id = details.parameters.get('email')
repo_details = jenkins_utils.provision_job(project_name, github_id,
github_pass, email_id)
# jenkins_utils.provision_job(githib_url)
except Exception as e:
print(e)
raise errors.ServiceException(e)
# repo_details = {
# 'html_url' : repo.html_url,
# 'clone_url': repo.clone_url,
# 'hooks_url': repo.hooks_url,
# 'hook_id' : hook.id
# }
self.service_instances[instance_id] = {
'provision_details': details,
'state': self.CREATED,
'project_name': project_name,
'repo_html_url': repo_details.get('html_url'),
'repo_clone_url': repo_details.get('clone_url'),
'repo_hooks_url': repo_details.get('hooks_url'),
'repo_hook_id': repo_details.get('hook_id')
}
return ProvisionedServiceSpec(state=ProvisionState.IS_ASYNC,
operation='provision')
