def _validate_patch(self, patch):
for blob in patch:
if not blob['path'].split('/')[1] in Namespace.WHITELIST:
raise exceptions.InvalidField(blob['path'])
if blob.get('value') and blob['path'].startswith('/permissions'):
blob['value'] = Permissions.from_string(blob['value'])
return patch
def _validate_patch(self, patch):
for blob in patch:
if not blob['path'].split('/')[1] in Namespace.WHITELIST:
raise exceptions.InvalidField(blob['path'])
if blob.get('value') and blob['path'].startswith('/permissions'):
blob['value'] = Permissions.from_string(blob['value'])
return patch
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)
)
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 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 collection_permissions(self):
return Permissions.from_string(self._raw.get('collection', ''))
def document_permissions(self):
return Permissions.from_string(self._raw.get('document', ''))
def collection_permissions(self):
return Permissions.from_string(self._raw.get('collection', ''))
def document_permissions(self):
return Permissions.from_string(self._raw.get('document', ''))
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))
