def __init__(self, config=None): logging.basicConfig(level=logging.DEBUG) ComponentManager.__init__(self) load_components(self) self.config = Configuration(self) self.config.load(config) logger.debug("Configuration loaded: %s", repr(self.config._data))
def __init__(self, config=None): logging.basicConfig(level=logging.DEBUG) ComponentManager.__init__(self) load_components(self, 'cydra.config') self.config = Configuration(self) self.config.load(config) logger.debug("Configuration loaded: %s", repr(self.config._data)) load_components(self) # Update last instance to allow instance reusing Cydra._last_instance = self
def __init__(self, config=None): logging.basicConfig(level=logging.DEBUG) ComponentManager.__init__(self) load_components(self, "cydra.config") self.config = Configuration(self) self.config.load(config) logger.debug("Configuration loaded: %s", repr(self.config._data)) load_components(self) # Update last instance to allow instance reusing Cydra._last_instance = self
class Cydra(Component, ComponentManager): """Main point of integration """ datasource = ExtensionPoint(IDataSource) permission = ExtensionPoint(IPermissionProvider) translator = ExtensionPoint(IUserTranslator) subject_cache = ExtensionPoint(ISubjectCache) def __init__(self, config=None): logging.basicConfig(level=logging.DEBUG) ComponentManager.__init__(self) load_components(self) self.config = Configuration(self) self.config.load(config) logger.debug("Configuration loaded: %s", repr(self.config._data)) def get_user(self, userid=None, username=None): """Convenience function for user retrieval""" if userid == '*': return User(self, '*', username='******', full_name='Guest') if userid is None and username is None: raise ValueError("Neither userid nor username given") result = None failed_caches = [] # go to caches for cache in self.subject_cache: if userid is not None: result = cache.get_user(userid) elif username is not None: result = cache.get_user_by_name(username) if result is not None: break else: failed_caches.append(cache) # not found if result is None: if userid is not None: result = self.translator.userid_to_user(userid) elif username is not None: result = self.translator.username_to_user(username) if result is None: return result # update caches for cache in failed_caches: cache.add_users([result]) return result def get_group(self, groupid): """Convenience function for group retrieval""" if groupid is None: raise ValueError("groupid mustn't be None") result = None failed_caches = [] # go to caches for cache in self.subject_cache: result = cache.get_group(groupid) if result is not None: break else: failed_caches.append(cache) # not found if result is None: result = self.translator.groupid_to_group(groupid) if result is None: return result # update caches for cache in failed_caches: cache.add_groups([result]) return result def get_project(self, name): return self.datasource.get_project(name) def get_projects(self, *args, **kwargs): return self.datasource.list_projects(*args, **kwargs) def get_project_names(self, *args, **kwargs): return self.datasource.get_project_names(*args, **kwargs) def get_projects_owned_by(self, *args, **kwargs): return self.datasource.get_projects_owned_by(*args, **kwargs) def get_projects_where_key_exists(self, *args, **kwargs): return self.datasource.get_projects_where_key_exists(*args, **kwargs) def get_projects_user_has_permissions_on(self, user): """Convenience function to retrieve all projects a user has permissions on""" return self.permission.get_projects_user_has_permissions_on(user) def get_permissions(self, user, object): """Convenience function for global permission enumeration""" return self.permission.get_permissions(None, user, object) def get_permission(self, user, object, permission): """Convenience function for permission retrieval""" return self.permission.get_permission(None, user, object, permission) def set_permission(self, user, object, permission, value): """Convenience function for permission retrieval""" return self.permission.set_permission(None, user, object, permission, value) def is_component_enabled(self, cls): component_name = cls.__module__ + '.' + cls.__name__ return self.config.is_component_enabled(component_name)
class Cydra(Component, ComponentManager): """Main point of integration This is the main class that figures as the component manager, is in charge of keeping track of a configuration and contains a set of convenience methods (eg. project retrieval, user lookup)""" datasource = ExtensionPoint(IDataSource) permission = ExtensionPoint(IPermissionProvider) translator = ExtensionPoint(IUserTranslator) user_store = ExtensionPoint(IUserStore) subject_cache = ExtensionPoint(ISubjectCache) project_observers = ExtensionPoint(IProjectObserver) _last_instance = None @classmethod def reuse_last_instance(cls, *args, **kwargs): """Reuse the most recently created :class:`Cydra` instance or create a new one By using this class method, you can reuse a previously created instance instead of creating a new one.""" if cls._last_instance is not None: return cls._last_instance return cls(*args, **kwargs) def __init__(self, config=None): logging.basicConfig(level=logging.DEBUG) ComponentManager.__init__(self) load_components(self, 'cydra.config') self.config = Configuration(self) self.config.load(config) logger.debug("Configuration loaded: %s", repr(self.config._data)) load_components(self) # Update last instance to allow instance reusing Cydra._last_instance = self def get_guest_user(self): return self.get_user(userid='*') def get_user(self, userid=None, username=None): """Convenience function for user retrieval""" if userid == '*': return User(self, '*', username='******', full_name='Guest') if userid is None and username is None: raise ValueError("Neither userid nor username given") result = None failed_caches = [] # go to caches for cache in self.subject_cache: if userid is not None: result = cache.get_user(userid) elif username is not None: result = cache.get_user_by_name(username) if result is not None: break else: failed_caches.append(cache) # not found if result is None: if userid is not None: result = self.translator.userid_to_user(userid) elif username is not None: result = self.translator.username_to_user(username) if result is None: if userid is not None: # since we got a specific userid, we can construct a dummy user object # with the userid and dummy values for everything else. # This is usually a good idea since asking for a specific userid means # the user at least existed at some time. This provides a safe default # for these cases return User(self, userid=userid, full_name="N/A (" + userid + ")") return result # update caches for cache in failed_caches: cache.add_users([result]) return result def create_user(self, **kwargs): userid = self.user_store.create_user(**kwargs) return self.get_user(userid=userid) def get_group(self, groupid): """Convenience function for group retrieval""" if groupid is None: raise ValueError("groupid mustn't be None") result = None failed_caches = [] # go to caches for cache in self.subject_cache: result = cache.get_group(groupid) if result is not None: break else: failed_caches.append(cache) # not found if result is None: result = self.translator.groupid_to_group(groupid) if result is None: return result # update caches for cache in failed_caches: cache.add_groups([result]) return result def get_project(self, name): return self.datasource.get_project(name) def create_project(self, projectname, owner): """Create a project :param projectname: The name of the project :param owner: User object of the owner of this project""" project = self.datasource.create_project(projectname, owner) self.project_observers.post_create_project(project) return project def get_projects(self, *args, **kwargs): return self.datasource.list_projects(*args, **kwargs) def get_project_names(self, *args, **kwargs): return self.datasource.get_project_names(*args, **kwargs) def get_projects_owned_by(self, *args, **kwargs): return self.datasource.get_projects_owned_by(*args, **kwargs) def get_projects_where_key_exists(self, *args, **kwargs): return self.datasource.get_projects_where_key_exists(*args, **kwargs) def get_projects_user_has_permissions_on(self, user): """Convenience function to retrieve all projects a user has permissions on""" return self.permission.get_projects_user_has_permissions_on(user) def get_permissions(self, user, object): """Convenience function for global permission enumeration""" return self.permission.get_permissions(None, user, object) def get_permission(self, user, object, permission): """Convenience function for permission retrieval""" return self.permission.get_permission(None, user, object, permission) def set_permission(self, user, object, permission, value): """Convenience function for permission retrieval""" return self.permission.set_permission(None, user, object, permission, value) def is_component_enabled(self, cls): component_name = cls.__module__ + '.' + cls.__name__ return self.config.is_component_enabled(component_name)
class Cydra(Component, ComponentManager): """Main point of integration This is the main class that figures as the component manager, is in charge of keeping track of a configuration and contains a set of convenience methods (eg. project retrieval, user lookup)""" datasource = ExtensionPoint(IDataSource) permission = ExtensionPoint(IPermissionProvider) translator = ExtensionPoint(IUserTranslator) user_store = ExtensionPoint(IUserStore) subject_cache = ExtensionPoint(ISubjectCache) project_observers = ExtensionPoint(IProjectObserver) _last_instance = None @classmethod def reuse_last_instance(cls, *args, **kwargs): """Reuse the most recently created :class:`Cydra` instance or create a new one By using this class method, you can reuse a previously created instance instead of creating a new one.""" if cls._last_instance is not None: return cls._last_instance return cls(*args, **kwargs) def __init__(self, config=None): logging.basicConfig(level=logging.DEBUG) ComponentManager.__init__(self) load_components(self, "cydra.config") self.config = Configuration(self) self.config.load(config) logger.debug("Configuration loaded: %s", repr(self.config._data)) load_components(self) # Update last instance to allow instance reusing Cydra._last_instance = self def get_guest_user(self): return self.get_user(userid="*") def get_user(self, userid=None, username=None): """Convenience function for user retrieval""" if userid == "*": return User(self, "*", username="******", full_name="Guest") if userid is None and username is None: raise ValueError("Neither userid nor username given") result = None failed_caches = [] # go to caches for cache in self.subject_cache: if userid is not None: result = cache.get_user(userid) elif username is not None: result = cache.get_user_by_name(username) if result is not None: break else: failed_caches.append(cache) # not found if result is None: if userid is not None: result = self.translator.userid_to_user(userid) elif username is not None: result = self.translator.username_to_user(username) if result is None: if userid is not None: # since we got a specific userid, we can construct a dummy user object # with the userid and dummy values for everything else. # This is usually a good idea since asking for a specific userid means # the user at least existed at some time. This provides a safe default # for these cases return User(self, userid=userid, full_name="N/A (" + userid + ")") return result # update caches for cache in failed_caches: cache.add_users([result]) return result def create_user(self, **kwargs): userid = self.user_store.create_user(**kwargs) return self.get_user(userid=userid) def get_group(self, groupid): """Convenience function for group retrieval""" if groupid is None: raise ValueError("groupid mustn't be None") result = None failed_caches = [] # go to caches for cache in self.subject_cache: result = cache.get_group(groupid) if result is not None: break else: failed_caches.append(cache) # not found if result is None: result = self.translator.groupid_to_group(groupid) if result is None: return result # update caches for cache in failed_caches: cache.add_groups([result]) return result def get_project(self, name): return self.datasource.get_project(name) def create_project(self, projectname, owner): """Create a project :param projectname: The name of the project :param owner: User object of the owner of this project""" project = self.datasource.create_project(projectname, owner) self.project_observers.post_create_project(project) return project def get_projects(self, *args, **kwargs): return self.datasource.list_projects(*args, **kwargs) def get_project_names(self, *args, **kwargs): return self.datasource.get_project_names(*args, **kwargs) def get_projects_owned_by(self, *args, **kwargs): return self.datasource.get_projects_owned_by(*args, **kwargs) def get_projects_where_key_exists(self, *args, **kwargs): return self.datasource.get_projects_where_key_exists(*args, **kwargs) def get_projects_user_has_permissions_on(self, user): """Convenience function to retrieve all projects a user has permissions on""" return self.permission.get_projects_user_has_permissions_on(user) def get_permissions(self, user, object): """Convenience function for global permission enumeration""" return self.permission.get_permissions(None, user, object) def get_permission(self, user, object, permission): """Convenience function for permission retrieval""" return self.permission.get_permission(None, user, object, permission) def set_permission(self, user, object, permission, value): """Convenience function for permission retrieval""" return self.permission.set_permission(None, user, object, permission, value) def is_component_enabled(self, cls): component_name = cls.__module__ + "." + cls.__name__ return self.config.is_component_enabled(component_name)
class Cydra(Component, ComponentManager): """Main point of integration This is the main class that figures as the component manager, is in charge of keeping track of a configuration and contains a set of convenience methods (eg. project retrieval, user lookup)""" datasource = ExtensionPoint(IDataSource) permission = ExtensionPoint(IPermissionProvider) translator = ExtensionPoint(IUserTranslator) subject_cache = ExtensionPoint(ISubjectCache) _last_instance = None @classmethod def reuse_last_instance(cls, *args, **kwargs): """Reuse the most recently created :class:`Cydra` instance or create a new one By using this class method, you can reuse a previously created instance instead of creating a new one.""" if cls._last_instance is not None: return cls._last_instance return cls(*args, **kwargs) def __init__(self, config=None): logging.basicConfig(level=logging.DEBUG) ComponentManager.__init__(self) load_components(self, 'cydra.config') self.config = Configuration(self) self.config.load(config) logger.debug("Configuration loaded: %s", repr(self.config._data)) load_components(self) # Update last instance to allow instance reusing Cydra._last_instance = self def get_user(self, userid=None, username=None): """Convenience function for user retrieval""" if userid == '*': return User(self, '*', username='******', full_name='Guest') if userid is None and username is None: raise ValueError("Neither userid nor username given") result = None failed_caches = [] # go to caches for cache in self.subject_cache: if userid is not None: result = cache.get_user(userid) elif username is not None: result = cache.get_user_by_name(username) if result is not None: break else: failed_caches.append(cache) # not found if result is None: if userid is not None: result = self.translator.userid_to_user(userid) elif username is not None: result = self.translator.username_to_user(username) if result is None: return result # update caches for cache in failed_caches: cache.add_users([result]) return result def get_group(self, groupid): """Convenience function for group retrieval""" if groupid is None: raise ValueError("groupid mustn't be None") result = None failed_caches = [] # go to caches for cache in self.subject_cache: result = cache.get_group(groupid) if result is not None: break else: failed_caches.append(cache) # not found if result is None: result = self.translator.groupid_to_group(groupid) if result is None: return result # update caches for cache in failed_caches: cache.add_groups([result]) return result def get_project(self, name): return self.datasource.get_project(name) def get_projects(self, *args, **kwargs): return self.datasource.list_projects(*args, **kwargs) def get_project_names(self, *args, **kwargs): return self.datasource.get_project_names(*args, **kwargs) def get_projects_owned_by(self, *args, **kwargs): return self.datasource.get_projects_owned_by(*args, **kwargs) def get_projects_where_key_exists(self, *args, **kwargs): return self.datasource.get_projects_where_key_exists(*args, **kwargs) def get_projects_user_has_permissions_on(self, user): """Convenience function to retrieve all projects a user has permissions on""" return self.permission.get_projects_user_has_permissions_on(user) def get_permissions(self, user, object): """Convenience function for global permission enumeration""" return self.permission.get_permissions(None, user, object) def get_permission(self, user, object, permission): """Convenience function for permission retrieval""" return self.permission.get_permission(None, user, object, permission) def set_permission(self, user, object, permission, value): """Convenience function for permission retrieval""" return self.permission.set_permission(None, user, object, permission, value) def is_component_enabled(self, cls): component_name = cls.__module__ + '.' + cls.__name__ return self.config.is_component_enabled(component_name)