def test_check_capsule_template(self):
with self.assertRaisesRegex(
exception.InvalidCapsuleTemplate, "kind fields need to "
"be set as capsule or Capsule"):
params = ({"kind": "test", "spec": {"containers": []}})
utils.check_capsule_template(params)
with self.assertRaisesRegex(exception.InvalidCapsuleTemplate,
"No Spec found"):
params = ({"kind": "capsule"})
utils.check_capsule_template(params)
with self.assertRaisesRegex(exception.InvalidCapsuleTemplate,
"No valid containers field"):
params = ({"kind": "capsule", "spec": {}})
utils.check_capsule_template(params)
params = ({
"kind": "capsule",
"restartPolicy": "Always",
"spec": {
"containers": [{
"image": "test1"
}]
}
})
utils.check_capsule_template(params)
self.assertEqual(params["restart_policy"], "always")
def test_check_capsule_template_unicode(self):
with self.assertRaisesRegex(
exception.InvalidCapsuleTemplate, "kind fields need to "
"be set as capsule or Capsule"):
params = (u'{"kind": "test", "spec": {"containers": []}}')
utils.check_capsule_template(params)
with self.assertRaisesRegex(exception.InvalidCapsuleTemplate,
"No Spec found"):
params = (u'{"kind": "capsule"}')
utils.check_capsule_template(params)
with self.assertRaisesRegex(exception.InvalidCapsuleTemplate,
"No valid containers field"):
params = (u'{"kind": "capsule", "spec": {}}')
utils.check_capsule_template(params)
params = (u'{"kind": "capsule", "spec": {'
u'"containers": [{"image": "test1"}],'
u'"restartPolicy": "Always"}}')
spec_content, tpl_json = utils.check_capsule_template(params)
self.assertEqual(spec_content["restart_policy"], "always")
def post(self, **capsule_dict):
"""Create a new capsule.
:param capsule_dict: a capsule within the request body.
"""
context = pecan.request.context
compute_api = pecan.request.compute_api
policy.enforce(context, "capsule:create", action="capsule:create")
# Abstract the capsule specification
capsules_template = capsule_dict.get('template')
spec_content, template_json = \
utils.check_capsule_template(capsules_template)
containers_spec, init_containers_spec = \
utils.capsule_get_container_spec(spec_content)
volumes_spec = utils.capsule_get_volume_spec(spec_content)
# Create the capsule Object
new_capsule = objects.Capsule(context, **capsule_dict)
new_capsule.project_id = context.project_id
new_capsule.user_id = context.user_id
new_capsule.status = consts.PENDING
new_capsule.create(context)
new_capsule.volumes = []
capsule_need_cpu = 0
capsule_need_memory = 0
container_volume_requests = []
if spec_content.get('restart_policy'):
capsule_restart_policy = spec_content.get('restart_policy')
else:
# NOTE(hongbin): this is deprecated but we need to maintain
# backward-compatibility. Will remove this branch in the future.
capsule_restart_policy = template_json.get('restart_policy',
'always')
container_restart_policy = {
"MaximumRetryCount": "0",
"Name": capsule_restart_policy
}
new_capsule.restart_policy = capsule_restart_policy
metadata_info = template_json.get('metadata', None)
requested_networks_info = template_json.get('nets', [])
requested_networks = \
utils.build_requested_networks(context, requested_networks_info)
if metadata_info:
new_capsule.meta_name = metadata_info.get('name', None)
new_capsule.meta_labels = metadata_info.get('labels', None)
# create the capsule in DB so that it generates a 'id'
new_capsule.save()
extra_spec = {}
az_info = template_json.get('availabilityZone')
if az_info:
extra_spec['availability_zone'] = az_info
# Generate Object for infra container
sandbox_container = objects.Container(context)
sandbox_container.project_id = context.project_id
sandbox_container.user_id = context.user_id
name = self._generate_name_for_capsule_sandbox(new_capsule)
sandbox_container.name = name
sandbox_container.capsule_id = new_capsule.id
sandbox_container.image = CONF.sandbox_image
sandbox_container.image_driver = CONF.sandbox_image_driver
sandbox_container.image_pull_policy = \
CONF.sandbox_image_pull_policy
sandbox_container.status = consts.CREATING
sandbox_container.create(context)
new_capsule.containers_uuids = [sandbox_container.uuid]
new_capsule.init_containers_uuids = []
merged_containers_spec = init_containers_spec + containers_spec
for container_spec in merged_containers_spec:
container_dict = container_spec
container_dict['project_id'] = context.project_id
container_dict['user_id'] = context.user_id
name = self._generate_name_for_capsule_container(new_capsule)
container_dict['name'] = name
if container_dict.get('args') and container_dict.get('command'):
container_dict['command'] = \
container_dict['command'] + container_dict['args']
container_dict.pop('args')
elif container_dict.get('args'):
container_dict['command'] = container_dict['args']
container_dict.pop('args')
# NOTE(kevinz): Don't support port remapping, will find a
# easy way to implement it.
# if container need to open some port, just open it in container,
# user can change the security group and getting access to port.
if container_dict.get('ports'):
container_dict.pop('ports')
if container_dict.get('resources'):
resources_list = container_dict.get('resources')
allocation = resources_list.get('requests')
if allocation.get('cpu'):
capsule_need_cpu += allocation.get('cpu')
container_dict['cpu'] = allocation.get('cpu')
if allocation.get('memory'):
capsule_need_memory += allocation.get('memory')
container_dict['memory'] = str(allocation['memory'])
container_dict.pop('resources')
if container_dict.get('volumeMounts'):
for volume in container_dict['volumeMounts']:
volume['container_name'] = name
container_volume_requests.append(volume)
container_dict['status'] = consts.CREATING
container_dict['interactive'] = True
container_dict['capsule_id'] = new_capsule.id
container_dict['restart_policy'] = container_restart_policy
if container_spec in init_containers_spec:
if capsule_restart_policy == "always":
container_restart_policy = {
"MaximumRetryCount": "10",
"Name": "on-failure"
}
container_dict['restart_policy'] = container_restart_policy
utils.check_for_restart_policy(container_dict)
new_container = objects.Container(context, **container_dict)
new_container.create(context)
new_capsule.containers_uuids.append(new_container.uuid)
if container_spec in init_containers_spec:
new_capsule.init_containers_uuids.append(new_container.uuid)
# Deal with the volume support
requested_volumes = \
self._build_requested_volumes(context,
volumes_spec,
container_volume_requests,
new_capsule)
new_capsule.cpu = capsule_need_cpu
new_capsule.memory = str(capsule_need_memory)
new_capsule.save(context)
compute_api.capsule_create(context, new_capsule, requested_networks,
requested_volumes, extra_spec)
# Set the HTTP Location Header
pecan.response.location = link.build_url('capsules', new_capsule.uuid)
pecan.response.status = 202
return view.format_capsule(pecan.request.host_url, new_capsule,
context)
def post(self, **capsule_dict):
"""Create a new capsule.
:param capsule_dict: a capsule within the request body.
"""
context = pecan.request.context
compute_api = pecan.request.compute_api
policy.enforce(context, "capsule:create",
action="capsule:create")
capsules_spec = capsule_dict['spec']
containers_spec = utils.check_capsule_template(capsules_spec)
new_capsule = objects.Capsule(context, **capsule_dict)
new_capsule.project_id = context.project_id
new_capsule.user_id = context.user_id
new_capsule.create(context)
new_capsule.containers = []
new_capsule.containers_uuids = []
new_capsule.volumes = []
capsule_need_cpu = 0
capsule_need_memory = 0
count = len(containers_spec)
capsule_restart_policy = capsules_spec.get('restart_policy', 'always')
metadata_info = capsules_spec.get('metadata', None)
requested_networks = capsules_spec.get('nets', [])
if metadata_info:
new_capsule.meta_name = metadata_info.get('name', None)
new_capsule.meta_labels = metadata_info.get('labels', None)
# Generate Object for infra container
sandbox_container = objects.Container(context)
sandbox_container.project_id = context.project_id
sandbox_container.user_id = context.user_id
name = self._generate_name_for_capsule_sandbox(new_capsule)
sandbox_container.name = name
sandbox_container.create(context)
new_capsule.containers.append(sandbox_container)
new_capsule.containers_uuids.append(sandbox_container.uuid)
for k in range(count):
container_dict = containers_spec[k]
container_dict['project_id'] = context.project_id
container_dict['user_id'] = context.user_id
name = self._generate_name_for_capsule_container(new_capsule)
container_dict['name'] = name
if container_dict.get('args') and container_dict.get('command'):
container_dict = self._transfer_list_to_str(container_dict,
'command')
container_dict = self._transfer_list_to_str(container_dict,
'args')
container_dict['command'] = \
container_dict['command'] + ' ' + container_dict['args']
container_dict.pop('args')
elif container_dict.get('command'):
container_dict = self._transfer_list_to_str(container_dict,
'command')
elif container_dict.get('args'):
container_dict = self._transfer_list_to_str(container_dict,
'args')
container_dict['command'] = container_dict['args']
container_dict.pop('args')
# NOTE(kevinz): Don't support pod remapping, will find a
# easy way to implement it.
# if container need to open some port, just open it in container,
# user can change the security group and getting access to port.
if container_dict.get('ports'):
container_dict.pop('ports')
if container_dict.get('resources'):
resources_list = container_dict.get('resources')
allocation = resources_list.get('allocation')
if allocation.get('cpu'):
capsule_need_cpu += allocation.get('cpu')
container_dict['cpu'] = allocation.get('cpu')
if allocation.get('memory'):
capsule_need_memory += allocation.get('memory')
container_dict['memory'] = str(allocation['memory']) + 'M'
container_dict.pop('resources')
if capsule_restart_policy:
container_dict['restart_policy'] = \
{"MaximumRetryCount": "0",
"Name": capsule_restart_policy}
utils.check_for_restart_policy(container_dict)
container_dict['status'] = consts.CREATING
container_dict['interactive'] = True
new_container = objects.Container(context, **container_dict)
new_container.create(context)
new_capsule.containers.append(new_container)
new_capsule.containers_uuids.append(new_container.uuid)
new_capsule.cpu = capsule_need_cpu
new_capsule.memory = str(capsule_need_memory) + 'M'
new_capsule.save(context)
compute_api.capsule_create(context, new_capsule, requested_networks)
# Set the HTTP Location Header
pecan.response.location = link.build_url('capsules',
new_capsule.uuid)
pecan.response.status = 202
return view.format_capsule(pecan.request.host_url, new_capsule)
def test_check_capsule_template(self):
with self.assertRaisesRegex(
exception.InvalidCapsuleTemplate, "kind fields need to "
"be set as capsule or Capsule"):
params = ({"kind": "test", "spec": {"containers": []}})
utils.check_capsule_template(params)
with self.assertRaisesRegex(
exception.InvalidCapsuleTemplate, "No Spec found"):
params = ({"kind": "capsule"})
utils.check_capsule_template(params)
with self.assertRaisesRegex(
exception.InvalidCapsuleTemplate,
"No valid containers field"):
params = ({"kind": "capsule", "spec": {}})
utils.check_capsule_template(params)
with self.assertRaisesRegex(
exception.InvalidCapsuleTemplate,
"Capsule need to have one container at least"):
params = ({"kind": "capsule", "spec": {"containers": []}})
utils.check_capsule_template(params)
with self.assertRaisesRegex(
exception.InvalidCapsuleTemplate, "Container "
"image is needed"):
params = ({"kind": "capsule",
"spec": {"containers": [{"labels": {"app": "web"}}]}})
utils.check_capsule_template(params)
with self.assertRaisesRegex(
exception.InvalidCapsuleTemplate, "Container image is needed"):
params = ({"kind": "capsule",
"spec": {"containers": [{"image": "test1"},
{"environment": {"ROOT_PASSWORD": "******"}}]}})
utils.check_capsule_template(params)