def GET(self, release_id, role_name):
""":http:
* 200 (OK)
* 404 (no such object found)
"""
release = self.get_object_or_404(objects.Release, release_id)
return RoleSerializer.serialize(release, role_name)
def GET(self, release_id):
release = self.get_object_or_404(objects.Release, release_id)
role_names = six.iterkeys(release.roles_metadata)
return [
RoleSerializer.serialize_from_release(release, name)
for name in role_names
]
def GET(self, release_id):
""":http:
* 200 (OK)
"""
release = self.get_object_or_404(objects.Release, release_id)
role_names = six.iterkeys(release.roles_metadata)
return [RoleSerializer.serialize(release, name) for name in role_names]
def GET(self, release_id, role_name):
""":http:
* 200 (OK)
* 404 (no such object found)
"""
release = self.get_object_or_404(objects.Release, release_id)
return RoleSerializer.serialize_from_release(release, role_name)
def GET(self, release_id):
""":http:
* 200 (OK)
"""
release = self.get_object_or_404(objects.Release, release_id)
role_names = six.iterkeys(release.roles_metadata)
return [RoleSerializer.serialize(release, name) for name in role_names]
def PUT(self, release_id, role_name):
""":http:
* 200 (OK)
* 404 (no such object found)
"""
data = self.checked_data()
release = self.get_object_or_404(objects.Release, release_id)
objects.Release.update_role(release, data)
return RoleSerializer.serialize(release, role_name)
def GET(self, cluster_id, role_name):
""":returns: JSON-ed metadata for the role
:http:
* 200 (OK)
* 404 (no such object found)
"""
cluster = self.get_object_or_404(objects.Cluster, cluster_id)
self._check_role(cluster, role_name)
return RoleSerializer.serialize_from_cluster(cluster, role_name)
def PUT(self, release_id, role_name):
""":http:
* 200 (OK)
* 404 (no such object found)
"""
data = self.checked_data()
release = self.get_object_or_404(objects.Release, release_id)
objects.Release.update_role(release, data)
return RoleSerializer.serialize(release, role_name)
def GET(self, cluster_id, role_name):
""":returns: JSON-ed metadata for the role
:http:
* 200 (OK)
* 404 (no such object found)
"""
cluster = self.get_object_or_404(objects.Cluster, cluster_id)
self._check_role(cluster, role_name)
return RoleSerializer.serialize(cluster.release, role_name)
def GET(self, release_id, role_name):
"""Retrieve role
:http:
* 200 (OK)
* 404 (no such object found)
"""
release = self.get_object_or_404(objects.Release, release_id)
self._check_role(release, role_name)
return RoleSerializer.serialize_from_release(release, role_name)
def PUT(self, release_id, role_name):
""":http:
* 200 (OK)
* 404 (no such object found)
"""
release = self.get_object_or_404(objects.Release, release_id)
data = self.checked_data(self.validator.validate_update,
instance=release)
objects.Release.update_role(release, data)
return RoleSerializer.serialize_from_release(release, role_name)
def GET(self, cluster_id):
""":returns: collection of JSON-ed cluster roles metadata
:http:
* 200 (OK)
* 404 (no such object found)
"""
cluster = self.get_object_or_404(objects.Cluster, cluster_id)
roles_names = six.iterkeys(objects.Cluster.get_roles(cluster))
return [RoleSerializer.serialize(cluster.release, name) for name in
roles_names]
def PUT(self, release_id, role_name):
""":http:
* 200 (OK)
* 404 (no such object found)
"""
release = self.get_object_or_404(objects.Release, release_id)
data = self.checked_data(
self.validator.validate_update, instance=release)
objects.Release.update_role(release, data)
return RoleSerializer.serialize_from_release(release, role_name)
def GET(self, obj_type, obj_id, role_name):
"""Retrieve role
:http:
* 200 (OK)
* 404 (no such object found)
"""
obj_cls, obj = self._get_object_or_404(obj_type, obj_id)
self._check_role(obj_cls, obj, role_name)
return RoleSerializer.serialize_from_obj(obj_cls, obj, role_name)
def GET(self, cluster_id):
""":returns: collection of JSON-ed cluster roles metadata
:http:
* 200 (OK)
* 404 (no such object found)
"""
cluster = self.get_object_or_404(objects.Cluster, cluster_id)
roles_names = six.iterkeys(objects.Cluster.get_roles(cluster))
return [
RoleSerializer.serialize_from_cluster(cluster, name)
for name in roles_names
]
def PUT(self, obj_type, obj_id, role_name):
"""Update role
:http:
* 200 (OK)
* 404 (no such object found)
"""
obj_cls, obj = self._get_object_or_404(obj_type, obj_id)
self._check_role(obj_cls, obj, role_name)
data = self.checked_data(
self.validator.validate_update, instance_cls=obj_cls, instance=obj)
obj_cls.update_role(obj, data)
return RoleSerializer.serialize_from_obj(obj_cls, obj, role_name)
def POST(self, release_id):
"""Create role for release
:http:
* 201 (object successfully created)
* 400 (invalid object data specified)
* 409 (object with such parameters already exists)
"""
release = self.get_object_or_404(objects.Release, release_id)
try:
data = self.checked_data(
self.validator.validate_create, instance=release)
except errors.AlreadyExists as exc:
raise self.http(409, exc.message)
role_name = data['name']
objects.Release.update_role(release, data)
raise self.http(
201, RoleSerializer.serialize_from_release(release, role_name))
def POST(self, release_id):
""":http:
* 201 (object successfully created)
* 400 (invalid object data specified)
* 409 (object with such parameters already exists)
"""
data = self.checked_data()
role_name = data['name']
release = self.get_object_or_404(objects.Release, release_id)
if role_name in release.roles_metadata:
raise self.http(
409, 'Role with name {name} already '
'exists for release {release}'.format(name=role_name,
release=release_id))
objects.Release.update_role(release, data)
raise self.http(201, RoleSerializer.serialize(release, role_name))
def POST(self, release_id):
"""Create role for release
:http:
* 201 (object successfully created)
* 400 (invalid object data specified)
* 409 (object with such parameters already exists)
"""
release = self.get_object_or_404(objects.Release, release_id)
try:
data = self.checked_data(self.validator.validate_create,
instance=release)
except errors.AlreadyExists as exc:
raise self.http(409, exc.message)
role_name = data['name']
objects.Release.update_role(release, data)
raise self.http(
201, RoleSerializer.serialize_from_release(release, role_name))
def POST(self, release_id):
""":http:
* 201 (object successfully created)
* 400 (invalid object data specified)
* 409 (object with such parameters already exists)
"""
data = self.checked_data()
role_name = data['name']
release = self.get_object_or_404(objects.Release, release_id)
if role_name in release.roles_metadata:
raise self.http(
409,
'Role with name {name} already '
'exists for release {release}'.format(
name=role_name, release=release_id))
objects.Release.update_role(release, data)
raise self.http(201, RoleSerializer.serialize(release, role_name))
def POST(self, obj_type, obj_id):
"""Create role for release or cluster
:http:
* 201 (object successfully created)
* 400 (invalid object data specified)
* 409 (object with such parameters already exists)
"""
obj_cls, obj = self._get_object_or_404(obj_type, obj_id)
try:
data = self.checked_data(
self.validator.validate_create,
instance_cls=obj_cls,
instance=obj)
except errors.AlreadyExists as exc:
raise self.http(409, exc.message)
role_name = data['name']
obj_cls.update_role(obj, data)
raise self.http(
201, RoleSerializer.serialize_from_obj(obj_cls, obj, role_name))
def GET(self, release_id):
release = self.get_object_or_404(objects.Release, release_id)
role_names = six.iterkeys(release.roles_metadata)
return [RoleSerializer.serialize_from_release(release, name)
for name in role_names]
def GET(self, obj_type, obj_id):
obj_cls, obj = self._get_object_or_404(obj_type, obj_id)
role_names = six.iterkeys(obj_cls.get_roles(obj))
return [RoleSerializer.serialize_from_obj(obj_cls, obj, name)
for name in role_names]
