def setUp(self):
super().setUp()
self.store = InMemoryStore()
self.test_plan = Plan(id='testplan',
name='testing plan',
description='plan for testing',
metadata=None,
free=True,
bindable=False)
self.test_service = ServiceType(id='test-svc',
name='test_svc',
description='this is a test service',
bindable=False,
tags=['test', 'tester'],
metadata=None,
requires=[],
plan_updateable=False,
plans=[self.test_plan],
dashboard_client=None)
path = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
with open(path + "/manifests/docker-compose.yml", "r") as mani_file:
mani = mani_file.read()
with open(path + '/manifests/test_endpoints.json', 'r') as ep_file:
ep = ep_file.read()
self.test_manifest = Manifest(id='test-mani',
plan_id=self.test_plan.id,
service_id=self.test_service.id,
manifest_type='dummy',
manifest_content=mani,
endpoints=json.loads(ep))
self.test_svc_instance = ServiceInstance(
service_type=self.test_service, context={'id': 'test_svc_inst'})
self.test_last_op = LastOperation(state='test_state',
description='testing')
def model_sql_to_model(model_sql: LastOperationSQL) -> LastOperation:
model = LastOperation()
''' STRING '''
model.state = model_sql.state
model.description = model_sql.description
return model
def sample_model(name='instance1') -> LastOperation:
model = LastOperation()
model.state = name
model.description = name
return model
def create_service_instance(instance_id, service, accept_incomplete=None):
"""
Provisions a service instance
When the broker receives a provision request from a client, it should synchronously take whatever action is
necessary to create a new service resource for the developer. The result of provisioning varies by service
type, although there are a few common actions that work for many services. Supports asynchronous operations.'
:param instance_id: 'The instance_id of a service instance is provided by the client. This ID will be used for
future requests (bind and deprovision), so the broker must use it to correlate the resource it creates.'
:type instance_id: str
:param service: Service information.
:type service: dict | bytes
:param accept_incomplete: Indicates that the client is supporting asynchronous operations
:type accept_incomplete: bool
:rtype: ServiceResponse
"""
ok, message, code = _version_ok()
if not ok:
return message, code
else:
if len(STORE.get_service_instance(instance_id=instance_id)) == 1:
return 'Service instance with id {id} already exists'.format(id=instance_id), 409
if connexion.request.is_json:
service = ServiceRequest.from_dict(connexion.request.get_json())
else:
return "Supplied body content is not or is mal-formed JSON", 400
# look up manifest based on plan id
# based on the manifest type, select the driver
# send the manifest for creation to the target system
# store the ID along with refs to service, plan and manifest
# get the manifest for the service/plan
svc_type = STORE.get_service(service.service_id)[0]
if svc_type is None:
return 'Unrecognised service requested to be instantiated', 404
plans = svc_type.plans
plan = [p for p in plans if p.id == service.plan_id]
if len(plan) <= 0:
return 'Plan {p_id} found.'.format(p_id=service.plan_id), 404
mani = STORE.get_manifest(plan_id=plan[0].id)
if len(mani) <= 0:
return 'no manifest for service {plan} found.'.format(plan=service.plan_id), 404
mani = mani[0]
if accept_incomplete: # given docker-compose runs in detached mode this is not needed - only timing can verify
# XXX put this in a thread to allow for asynch processing?
RM.create(instance_id=instance_id, content=mani.manifest_content,
c_type=mani.manifest_type, parameters=service.parameters)
else:
RM.create(instance_id=instance_id, content=mani.manifest_content,
c_type=mani.manifest_type, parameters=service.parameters)
last_op = LastOperation( # stored within the service instance doc
state='creating',
description='service instance is being created'
)
# store the instance Id with manifest id
srv_inst = ServiceInstance(
service_type=svc_type,
state=last_op,
context={
'id': instance_id,
'manifest_id': mani.id,
}
)
STORE.add_service_instance(srv_inst)
if accept_incomplete:
STORE.add_last_operation(instance_id=instance_id, last_operation=last_op)
return 'created', 200