def create_namespace(self, name, user, permissions=None): uid = str(uuid.uuid4()).replace('-', '') 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 __init__(self, name=None): self.uuid = self.name = name or 'jam' storage_backend = get_backend( settings.NAMESPACEMANAGER_BACKENDS['storage']) logger_backend = get_backend( settings.NAMESPACEMANAGER_BACKENDS['logger']) state_backend = get_backend( settings.NAMESPACEMANAGER_BACKENDS['state']) super().__init__(jam.Storage( storage_backend(**storage_backend.settings_for( 'manager', self.uuid, 'storage'))), jam.Logger( logger_backend(**logger_backend.settings_for( 'manager', self.uuid, 'logger'))), jam.State( state_backend(**state_backend.settings_for( 'manager', self.uuid, 'state'))), schema={ 'type': 'jsonschema', 'schema': Namespace.SCHEMA }, permissions={ 'system-system-*': Permissions.CREATE, 'system-system-system': Permissions.ADMIN, })
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): uid = str(uuid.uuid4()).replace("-", "") 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 __init__(self, name=None): self.uuid = self.name = name or "jam" storage_backend = get_backend(settings.NAMESPACEMANAGER_BACKENDS["storage"]) logger_backend = get_backend(settings.NAMESPACEMANAGER_BACKENDS["logger"]) state_backend = get_backend(settings.NAMESPACEMANAGER_BACKENDS["state"]) super().__init__( jam.Storage(storage_backend(**storage_backend.settings_for("manager", self.uuid, "storage"))), jam.Logger(logger_backend(**logger_backend.settings_for("manager", self.uuid, "logger"))), jam.State(state_backend(**state_backend.settings_for("manager", self.uuid, "state"))), )
def __init__(self, name=None): self.uuid = self.name = name or 'jam' storage_backend = get_backend(settings.NAMESPACEMANAGER_BACKENDS['storage']) logger_backend = get_backend(settings.NAMESPACEMANAGER_BACKENDS['logger']) state_backend = get_backend(settings.NAMESPACEMANAGER_BACKENDS['state']) super().__init__( jam.Storage(storage_backend(**storage_backend.settings_for('manager', self.uuid, 'storage'))), jam.Logger(logger_backend(**logger_backend.settings_for('manager', self.uuid, 'logger'))), jam.State(state_backend(**state_backend.settings_for('manager', self.uuid, 'state'))), schema={'type': 'jsonschema', 'schema': Namespace.SCHEMA} )
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_collection(self, name, user, logger=None, storage=None, state=None, permissions=None, schema=None): 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): permissions = {**(permissions or {}), user: Permissions.ADMIN} collection_dict = { 'uuid': uid, '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 = Collection.from_dict(collection_dict) try: 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.name) ) return collection
def prerequisite_check(self): super().prerequisite_check() if not isinstance(self.collection._state._backend.raw_backend(), get_backend('elasticsearch')): raise exceptions.BadRequest( detail='This collection does not support searching')
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 prerequisite_check(self): super().prerequisite_check() if not isinstance(self.collection._state._backend.raw_backend(), get_backend('elasticsearch')): raise exceptions.BadRequest(detail='This collection does not support searching')