def create(self, request, role_guids=None):
"""
Creates a Client
:param request: Raw request
:type request: Request
:param role_guids: The GUIDs of the roles where the client should get access to
:type role_guids: str
"""
if 'role_guids' in request.DATA:
del request.DATA['role_guids']
serializer = FullSerializer(Client, instance=Client(), data=request.DATA)
client = serializer.deserialize()
if client.user is not None:
if client.user_guid == request.client.user_guid or ApiToolbox.is_client_in_roles(request.client, ['manage']):
client.grant_type = 'CLIENT_CREDENTIALS'
client.client_secret = OAuth2Toolbox.create_hash(64)
client.save()
if not role_guids:
roles = [junction.role for junction in client.user.group.roles]
else:
possible_role_guids = [junction.role_guid for junction in client.user.group.roles]
roles = [Role(guid) for guid in role_guids if guid in possible_role_guids]
for role in roles:
roleclient = RoleClient()
roleclient.client = client
roleclient.role = role
roleclient.save()
return client
raise HttpNotAcceptableException(error_description='A client must have a user',
error='invalid_data')
def create(self, request):
"""
Creates a User
:param request: The raw request
:type request: Request
"""
serializer = FullSerializer(User, instance=User(), data=request.DATA, allow_passwords=True)
user = serializer.deserialize()
if UserList.get_user_by_username(user.username) is not None:
raise HttpNotAcceptableException(error='duplicate',
error_description='User with this username already exists')
user.save()
pw_client = Client()
pw_client.ovs_type = 'INTERNAL'
pw_client.grant_type = 'PASSWORD'
pw_client.user = user
pw_client.save()
cc_client = Client()
cc_client.ovs_type = 'INTERNAL'
cc_client.grant_type = 'CLIENT_CREDENTIALS'
cc_client.client_secret = ''.join(random.choice(string.ascii_letters +
string.digits +
'|_=+*#@!/-[]{}<>.?,\'";:~')
for _ in range(128))
cc_client.user = user
cc_client.save()
for junction in user.group.roles:
for client in [cc_client, pw_client]:
roleclient = RoleClient()
roleclient.client = client
roleclient.role = junction.role
roleclient.save()
return user
def create(self, request):
"""
Creates a User
:param request: The raw request
:type request: Request
"""
serializer = FullSerializer(User, instance=User(), data=request.DATA, allow_passwords=True)
user = serializer.deserialize()
if UserList.get_user_by_username(user.username) is not None:
raise HttpNotAcceptableException(error_description='User with this username already exists',
error='duplicate')
user.save()
pw_client = Client()
pw_client.ovs_type = 'INTERNAL'
pw_client.grant_type = 'PASSWORD'
pw_client.user = user
pw_client.save()
cc_client = Client()
cc_client.ovs_type = 'INTERNAL'
cc_client.grant_type = 'CLIENT_CREDENTIALS'
cc_client.client_secret = ''.join(random.choice(string.ascii_letters +
string.digits +
'|_=+*#@!/-[]{}<>.?,\'";:~')
for _ in range(128))
cc_client.user = user
cc_client.save()
for junction in user.group.roles:
for client in [cc_client, pw_client]:
roleclient = RoleClient()
roleclient.client = client
roleclient.role = junction.role
roleclient.save()
return user
def create(self, request, version, abm_cluster=None, nsm_clusters=None):
"""
Creates an AlbaBackend
:param request: Data regarding ALBA backend to create
:type request: request
:param version: version requested by the client
:type version: int
:param abm_cluster: ABM cluster to claim for this new ALBA Backend
:type abm_cluster: str
:param nsm_clusters: NSM clusters to claim for this new ALBA Backend
:type nsm_clusters: list
:return: The newly created ALBA Backend object
:rtype: ovs.dal.hybrids.albabackend.AlbaBackend
"""
if version < 3:
request.DATA['scaling'] = 'LOCAL'
if nsm_clusters is None:
nsm_clusters = []
serializer = FullSerializer(AlbaBackend,
instance=AlbaBackend(),
data=request.DATA,
allow_passwords=True)
alba_backend = serializer.deserialize()
alba_backend.save()
alba_backend.backend.status = 'INSTALLING'
alba_backend.backend.save()
AlbaController.add_cluster.delay(alba_backend.guid, abm_cluster,
nsm_clusters)
return alba_backend
def create(self, request, role_guids=None):
"""
Creates a Client
:param request: Raw request
:type request: Request
:param role_guids: The GUIDs of the roles where the client should get access to
:type role_guids: str
"""
if 'role_guids' in request.DATA:
del request.DATA['role_guids']
serializer = FullSerializer(Client, instance=Client(), data=request.DATA)
client = serializer.deserialize()
if client.user is not None:
if client.user_guid == request.client.user_guid or Toolbox.is_client_in_roles(request.client, ['manage']):
client.grant_type = 'CLIENT_CREDENTIALS'
client.client_secret = OAuth2Toolbox.create_hash(64)
client.save()
if not role_guids:
roles = [junction.role for junction in client.user.group.roles]
else:
possible_role_guids = [junction.role_guid for junction in client.user.group.roles]
roles = [Role(guid) for guid in role_guids if guid in possible_role_guids]
for role in roles:
roleclient = RoleClient()
roleclient.client = client
roleclient.role = role
roleclient.save()
return client
raise HttpNotAcceptableException(error_description='A client must have a user',
error='invalid_data')
def create(self, request, contents=None):
"""
Creates a new Domain
:param request: The raw request:
:type request: Request
:param contents: Requested contents (serializer hint)
:type contents: str
"""
contents = None if contents is None else contents.split(',')
serializer = FullSerializer(Domain, contents=contents, instance=Domain(), data=request.DATA)
domain = serializer.deserialize()
domain.save()
return domain
def create(self, request):
"""
Creates a Backend
:param request: The raw request
:type request: Request
"""
serializer = FullSerializer(Backend, instance=Backend(), data=request.DATA)
backend = serializer.deserialize()
duplicate = BackendList.get_by_name(backend.name)
if duplicate is None:
backend.save()
return backend
raise HttpNotAcceptableException(error_description='Backend with this name already exists',
error='duplicate')
def partial_update(self, storagerouter, request, contents=None):
"""
Update a StorageRouter
:param storagerouter: StorageRouter to update
:type storagerouter: StorageRouter
:param request: The raw Request
:type request: Request
:param contents: Contents to be updated/returned
:type contents: str
"""
contents = None if contents is None else contents.split(',')
serializer = FullSerializer(StorageRouter, contents=contents, instance=storagerouter, data=request.DATA)
storagerouter = serializer.deserialize()
storagerouter.save()
return storagerouter
def partial_update(self, domain, request, contents=None):
"""
Update a Failure Domain
:param domain: The domain to update
:type domain: Domain
:param request: The raw request
:type request: Request
:param contents: Contents to be updated/returned
:type contents: str
"""
contents = None if contents is None else contents.split(',')
serializer = FullSerializer(Domain, contents=contents, instance=domain, data=request.DATA)
domain = serializer.deserialize()
domain.save()
return domain
def partial_update(self, domain, request, contents=None):
"""
Update a Failure Domain
:param domain: The domain to update
:type domain: Domain
:param request: The raw request
:type request: Request
:param contents: Contents to be updated/returned
:type contents: str
"""
contents = None if contents is None else contents.split(',')
serializer = FullSerializer(Domain, contents=contents, instance=domain, data=request.DATA)
domain = serializer.deserialize()
domain.save()
return domain
def create(self, request, contents=None):
"""
Creates a new Domain
:param request: The raw request:
:type request: Request
:param contents: Requested contents (serializer hint)
:type contents: str
"""
contents = None if contents is None else contents.split(',')
serializer = FullSerializer(Domain,
contents=contents,
instance=Domain(),
data=request.DATA)
domain = serializer.deserialize()
domain.save()
return domain
def create(self, request, contents=None):
"""
Creates a new Domain
:param request: The raw request:
:type request: Request
:param contents: Requested contents (serializer hint)
:type contents: str
"""
contents = None if contents is None else contents.split(',')
serializer = FullSerializer(Domain, contents=contents, instance=Domain(), data=request.DATA)
domain = serializer.deserialize()
current_domains = DomainList.get_by_name(domain.name)
if len(current_domains) > 0:
raise HttpNotAcceptableException(error_description='A Domain with the given name already exists',
error='duplicate')
domain.save()
return domain
def create(self, request, version):
"""
Creates an AlbaBackend
:param request: Data regarding ALBA backend to create
:type request: request
:param version: version requested by the client
:type version: int
"""
if version < 3:
request.DATA['scaling'] = 'LOCAL'
serializer = FullSerializer(AlbaBackend, instance=AlbaBackend(), data=request.DATA, allow_passwords=True)
alba_backend = serializer.deserialize()
alba_backend.save()
alba_backend.backend.status = 'INSTALLING'
alba_backend.backend.save()
AlbaController.add_cluster.delay(alba_backend.guid)
return alba_backend
def partial_update(self, contents, user, request):
"""
Update a User
:param request: The raw request
:type request: Request
:param user: The user to update
:type user: User
:param contents: The contents to update/return
:type contents: str
"""
contents = None if contents is None else contents.split(',')
serializer = FullSerializer(User, contents=contents, instance=user, data=request.DATA)
user = serializer.deserialize()
if user.guid == request.client.user_guid:
raise HttpForbiddenException(error_description='A user cannot update itself',
error='impossible_request')
user.save()
return user
def partial_update(self, contents, user, request):
"""
Update a User
:param request: The raw request
:type request: Request
:param user: The user to update
:type user: User
:param contents: The contents to update/return
:type contents: str
"""
contents = None if contents is None else contents.split(',')
serializer = FullSerializer(User, contents=contents, instance=user, data=request.DATA)
user = serializer.deserialize()
if user.guid == request.client.user_guid:
raise HttpForbiddenException(error_description='A user cannot update itself',
error='impossible_request')
user.save()
return user
