def _generate_patch(self, previous, new):
keys = set(new.keys())
if not keys.issubset(Namespace.WHITELIST):
raise exceptions.InvalidFields(keys - Namespace.WHITELIST)
patch = super()._generate_patch(previous, new)
# Remove any extranious keys added or deleted by diffing
return list(
filter(lambda p: p['path'].split('/')[1] in Namespace.WHITELIST,
patch))
def create_namespace(self, name, user, permissions=None, **kwargs):
if kwargs:
raise exceptions.InvalidFields(kwargs.keys())
uid = str(uuid.uuid4()).replace('-', '')
if isinstance(permissions or {}, dict):
try:
permissions = {
key: Permissions.from_string(value)
for key, value in (permissions or {}).items()
}
permissions[user] = Permissions.ADMIN
except KeyError as e:
raise exceptions.InvalidPermission(e.args[0])
except AttributeError:
pass # Schema validation will catch issues
try:
self.create(
name, {
'uuid': uid,
'permissions': {
**(permissions or {}), user: Permissions.ADMIN
},
'logger': {
'backend':
settings.NAMESPACE_BACKENDS['logger'],
'settings':
get_backend(settings.NAMESPACE_BACKENDS['logger']).
settings_for(self.uuid, uid, 'logger')
},
'state': {
'backend':
settings.NAMESPACE_BACKENDS['state'],
'settings':
get_backend(
settings.NAMESPACE_BACKENDS['state']).settings_for(
self.uuid, uid, 'state')
},
'storage': {
'backend':
settings.NAMESPACE_BACKENDS['storage'],
'settings':
get_backend(settings.NAMESPACE_BACKENDS['storage']).
settings_for(self.uuid, uid, 'storage')
}
}, user)
except exceptions.KeyExists:
raise exceptions.KeyExists(
code='N409',
title='Namespace already exists',
detail='Namespace "{}" already exists'.format(name))
return self.get_namespace(name)
def update(self, key, patch, user):
if isinstance(patch, dict):
keys = set(patch.keys())
if not keys.issubset(Collection.WHITELIST):
raise exceptions.InvalidFields(keys - Collection.WHITELIST)
previous = self._state.get(key)
patch = jsonpatch.JsonPatch.from_diff(previous.data, {**previous.data, **patch})
patch = list(filter(lambda p: p['path'].split('/')[1] in Namespace.WHITELIST, patch))
for blob in patch:
if not blob['path'].split('/')[1] in Collection.WHITELIST:
raise exceptions.InvalidField(blob['path'])
if blob.get('value') and not isinstance(blob.get('value'), Permissions) and blob['path'].startswith('/permissions'):
try:
blob['value'] = Permissions(reduce(operator.or_, [Permissions[p.strip()] for p in blob['value'].split(',')], Permissions.NONE))
except (AttributeError, KeyError):
raise exceptions.InvalidPermission(blob['value'])
return super().update(key, patch, user)
def create_collection(self,
name,
user,
logger=None,
storage=None,
state=None,
permissions=None,
schema=None,
plugins=None,
**kwargs):
if kwargs:
raise exceptions.InvalidFields(kwargs.keys())
uid = str(uuid.uuid4()).replace('-', '')
state = state or settings.COLLECTION_BACKENDS['state']
logger = logger or settings.COLLECTION_BACKENDS['logger']
storage = storage or settings.COLLECTION_BACKENDS['storage']
if isinstance(permissions or {}, dict):
try:
permissions = {
key: Permissions.from_string(value)
for key, value in (permissions or {}).items()
}
permissions[user] = Permissions.ADMIN
except KeyError as e:
raise exceptions.InvalidPermission(e.args[0])
except AttributeError:
pass # Schema validation will catch issues
collection_dict = {
'uuid': uid,
'plugins': plugins or {},
'schema': schema,
'permissions': permissions,
'logger': {
'backend':
logger,
'settings':
get_backend(logger).settings_for(self.uuid, uid, 'logger')
},
'state': {
'backend':
state,
'settings':
get_backend(state).settings_for(self.uuid, uid, 'state')
},
'storage': {
'backend':
storage,
'settings':
get_backend(storage).settings_for(self.uuid, uid, 'storage')
}
}
# Validate that our inputs can actually be deserialized to a collection
Collection(
Document(
ref=name,
log_ref=None,
data_ref=None,
created_on=0,
created_by='',
modified_on=0,
modified_by='',
data=collection_dict,
))
try:
return Collection(self.create(name, collection_dict, user))
except exceptions.KeyExists:
raise exceptions.KeyExists(
code='C409',
title='Collection already exists',
detail='Collection "{}" already exists in namespace "{}"'.
format(name, self.ref))