def deprovision(instance_id):
try:
plan_id = request.args["plan_id"]
service_id = request.args["service_id"]
accepts_incomplete = 'true' == request.args.get("accepts_incomplete", 'false')
deprovision_details = DeprovisionDetails(service_id=service_id, plan_id=plan_id)
deprovision_details.originating_identity = request.originating_identity
deprovision_details.authorization_username = extract_authorization_username(request)
if not _check_plan_id(service_broker, deprovision_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 = service_broker.deprovision(instance_id, deprovision_details, accepts_incomplete)
except errors.ErrInstanceDoesNotExist as e:
logger.exception(e)
return to_json_response(EmptyResponse()), HTTPStatus.GONE
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.is_async:
return to_json_response(DeprovisionResponse(result.operation)), HTTPStatus.ACCEPTED
else:
return to_json_response(EmptyResponse()), HTTPStatus.OK
def unbind(instance_id, binding_id):
try:
accepts_incomplete = 'true' == request.args.get("accepts_incomplete", 'false')
plan_id = request.args["plan_id"]
service_id = request.args["service_id"]
unbind_details = UnbindDetails(service_id=service_id, plan_id=plan_id)
unbind_details.originating_identity = request.originating_identity
unbind_details.authorization_username = extract_authorization_username(request)
if not _check_plan_id(service_broker, unbind_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 = service_broker.unbind(instance_id, binding_id, unbind_details, accepts_incomplete)
except errors.ErrBindingDoesNotExist as e:
logger.exception(e)
return to_json_response(EmptyResponse()), HTTPStatus.GONE
if result.is_async:
return to_json_response(UnbindResponse(result.operation)), HTTPStatus.ACCEPTED
else:
return to_json_response(EmptyResponse()), HTTPStatus.OK
def update(instance_id):
try:
accepts_incomplete = 'true' == request.args.get(
"accepts_incomplete", 'false')
update_details = UpdateDetails(**json.loads(request.data))
update_details.originating_identity = request.originating_identity
update_details.authorization_username = request.authorization.username
broker = get_broker_by_id(update_details.service_id)
if not broker.check_plan_id(update_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 = broker.update(instance_id, update_details,
accepts_incomplete)
add_service_id_to_async_response(result, broker.service_id())
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.is_async:
return to_json_response(UpdateResponse(
result.operation)), HTTPStatus.ACCEPTED
else:
return to_json_response(EmptyResponse()), HTTPStatus.OK
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 get_binding(instance_id, binding_id):
try:
result = service_broker.get_binding(instance_id, binding_id)
response = GetBindingResponse(
credentials=result.credentials,
syslog_drain_url=result.syslog_drain_url,
route_service_url=result.route_service_url,
volume_mounts=result.volume_mounts,
parameters=result.parameters,
)
return to_json_response(response), HTTPStatus.OK
except errors.ErrBindingDoesNotExist:
return to_json_response(EmptyResponse()), HTTPStatus.NOT_FOUND
def unbind(instance_id, binding_id):
try:
plan_id = request.args["plan_id"]
service_id = request.args["service_id"]
unbind_details = UnbindDetails(plan_id, service_id)
unbind_details.originating_identity = request.originating_identity
unbind_details.authorization_username = request.authorization.username
broker = get_broker_by_id(unbind_details.service_id)
if not broker.check_plan_id(unbind_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:
broker.unbind(instance_id, binding_id, unbind_details)
except errors.ErrBindingDoesNotExist as e:
logger.exception(e)
return to_json_response(EmptyResponse()), HTTPStatus.GONE
return to_json_response(EmptyResponse()), HTTPStatus.OK
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 get_instance(instance_id):
try:
result = service_broker.get_instance(instance_id)
response = GetInstanceResponse(
service_id=result.service_id,
plan_id=result.plan_id,
dashboard_url=result.dashboard_url,
parameters=result.parameters,
)
return to_json_response(response), HTTPStatus.OK
except errors.ErrInstanceDoesNotExist:
return to_json_response(EmptyResponse()), HTTPStatus.NOT_FOUND
except errors.ErrConcurrentInstanceAccess:
error_response = ErrorResponse(error='ConcurrencyError',
description='The Service Broker does not support concurrent requests that mutate the same resource.')
return to_json_response(error_response), HTTPStatus.UNPROCESSABLE_ENTITY
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.')
