Python Store.list_tiddler_revisions方法代码示例

# 需要导入模块: from tiddlyweb.store import Store [as 别名]
# 或者: from tiddlyweb.store.Store import list_tiddler_revisions [as 别名]
class Store(StorageInterface):

    _MC = None

    def __init__(self, store_config=None, environ=None):
        if store_config is None:
            store_config = {}
        if environ is None:
            environ = {}
        self.environ = environ
        self.config = environ.get("tiddlyweb.config")

        self._mc = self._MC

        if self._mc == None:
            try:
                from google.appengine.api import memcache

                self._MC = memcache
            except ImportError:
                import memcache

                try:
                    self._MC = memcache.Client(self.config["memcache_hosts"])
                except KeyError:
                    from tiddlyweb.config import config

                    self.config = config
                    self._MC = memcache.Client(self.config["memcache_hosts"])
            self._mc = self._MC

            self.cached_store = StoreBoss(
                self.config["cached_store"][0], self.config["cached_store"][1], environ=environ
            )
            self.prefix = self.config["server_prefix"]
            self.host = self.config["server_host"]["host"]

    def recipe_delete(self, recipe):
        key = self._recipe_key(recipe)
        self._mc.delete(key)
        self.cached_store.delete(recipe)

    def recipe_get(self, recipe):
        key = self._recipe_key(recipe)
        cached_recipe = self._get(key)
        if cached_recipe:
            recipe = cached_recipe
        else:
            recipe = self.cached_store.get(recipe)
            del recipe.store
            self._mc.set(key, recipe)
        return recipe

    def recipe_put(self, recipe):
        key = self._recipe_key(recipe)
        self.cached_store.put(recipe)
        self._mc.delete(key)

    def bag_delete(self, bag):
        key = self._bag_key(bag)
        if self._mc.delete(key):
            tiddlers_in_bag = bag.list_tiddlers()
            for tiddler in tiddlers_in_bag:
                self._mc.delete_multi(
                    [
                        self._tiddler_revision_key(self._create_tiddler_revision(tiddler, revision_id))
                        for revision_id in self.list_tiddler_revisions(tiddler)
                    ]
                )
            self._mc.delete_multi([self._tiddler_key(tiddler) for tiddler in tiddlers_in_bag])
        self.cached_store.delete(bag)

    def bag_get(self, bag):
        if hasattr(bag, "skinny") and bag.skinny:
            key = self._bag_key(bag)
            cached_bag = self._get(key)
            if cached_bag:
                bag = cached_bag
            else:
                bag = self.cached_store.get(bag)
                del bag.store
                self._mc.set(key, bag)
        else:
            bag = self.cached_store.get(bag)
            del bag.store
        return bag

    def bag_put(self, bag):
        key = self._bag_key(bag)
        self.cached_store.put(bag)
        self._mc.delete(key)

    def tiddler_delete(self, tiddler):
        key = self._tiddler_key(tiddler)

        if self._mc.delete(key):
            self._mc.delete(self._bag_key(Bag(tiddler.bag)))
            self._mc.delete_multi(
                [
                    self._tiddler_revision_key(self._create_tiddler_revision(tiddler, revision_id))
#.........这里部分代码省略.........

# 需要导入模块: from tiddlyweb.store import Store [as 别名]
# 或者: from tiddlyweb.store.Store import list_tiddler_revisions [as 别名]
class Store(StorageInterface):

    def __init__(self, store_config=None, environ=None):
        super(Store, self).__init__(store_config, environ)
        self.config = environ.get('tiddlyweb.config')
        self.binary_store = StoreBoss('text', {'store_root': 'binarystore'},
                environ=environ).storage
        self.core_store = StoreBoss(self.config['binarystore.child'][0],
                self.config['binarystore.child'][1], environ=environ).storage

    def bag_put(self, bag):
        self.core_store.bag_put(bag)

    def bag_get(self, bag):
        return self.core_store.bag_get(bag)

    def bag_delete(self, bag):
        try:
            self.binary_store.bag_delete(bag)
        except NoBagError:
            pass
        return self.core_store.bag_delete(bag)

    def recipe_put(self, recipe):
        self.core_store.recipe_put(recipe)

    def recipe_get(self, recipe):
        return self.core_store.recipe_get(recipe)

    def recipe_delete(self, recipe):
        return self.core_store.recipe_delete(recipe)

    def user_put(self, user):
        self.core_store.user_put(user)

    def user_get(self, user):
        return self.core_store.user_get(user)

    def user_delete(self, user):
        return self.core_store.user_delete(user)

    def tiddler_delete(self, tiddler):
        self.core_store.tiddler_delete(tiddler)
        if binary_tiddler(tiddler):
            self.binary_store.tiddler_delete(tiddler)

    def tiddler_put(self, tiddler):
        if binary_tiddler(tiddler):
            try:
                self.binary_store.tiddler_put(tiddler)
            except NoBagError:
                self.binary_store.bag_put(Bag(tiddler.bag))
                self.binary_store.tiddler_put(tiddler)
            tiddler.text = ''
        self.core_store.tiddler_put(tiddler)

    def tiddler_get(self, tiddler):
        found_tiddler = self.core_store.tiddler_get(tiddler)
        if binary_tiddler(found_tiddler):
            found_tiddler.__class__ = BinaryTiddler
            found_tiddler._text = None
        return found_tiddler

    def list_recipes(self):
        return self.core_store.list_recipes()

    def list_bags(self):
        return self.core_store.list_bags()

    def list_users(self):
        return self.core_store.list_users()

    def list_bag_tiddlers(self, bag):
        return self.core_store.list_bag_tiddlers(bag)

    def list_tiddler_revisions(self, tiddler):
        return self.core_store.list_tiddler_revisions(tiddler)

    def search(self, search_query):
        return self.core_store.search(search_query)

# 需要导入模块: from tiddlyweb.store import Store [as 别名]
# 或者: from tiddlyweb.store.Store import list_tiddler_revisions [as 别名]
class Store(StorageInterface):

	def __init__(self, environ=None):
		logging.debug("initializing SSL Store")
		super(Store, self).__init__(environ)
		config = self.environ["tiddlyweb.config"]
		self.ssl_bags = config["ssl_bags"] # intentionally not providing empty fallback -- XXX: rename?
		real_store = config["server_store"][1]["store_module"] # XXX: rename? -- TODO: use pop method to keep config clean?
		self.real_store = Storage(real_store, self.environ)

	def recipe_delete(self, recipe):
		logging.debug("delete recipe %s" % recipe)
		self.real_store.delete(recipe)

	def recipe_get(self, recipe):
		logging.debug("get recipe %s" % recipe)
		return self.real_store.get(recipe)

	def recipe_put(self, recipe):
		logging.debug("put recipe %s" % recipe)
		self.real_store.put(recipe)

	def bag_delete(self, bag):
		logging.debug("delete bag %s" % bag)
		self._check_security(bag.name)
		self.real_store.delete(bag)

	def bag_get(self, bag):
		logging.debug("get bag %s" % bag)
		self._check_security(bag.name)
		return self.real_store.get(bag)

	def bag_put(self, bag):
		logging.debug("put bag %s" % bag)
		self._check_security(bag.name)
		self.real_store.put(bag)

	def tiddler_delete(self, tiddler):
		logging.debug("delete tiddler %s" % tiddler)
		self.real_store.delete(tiddler)

	def tiddler_get(self, tiddler):
		logging.debug("get tiddler %s" % tiddler)
		return self.real_store.get(tiddler)

	def tiddler_put(self, tiddler):
		logging.debug("put tiddler %s" % tiddler)
		self.real_store.put(tiddler)

	def user_delete(self, user):
		logging.debug("delete user %s" % user)
		self.real_store.delete(user)

	def user_get(self, user):
		logging.debug("get user %s" % user)
		return self.real_store.get(user)

	def user_put(self, user):
		logging.debug("put user %s" % user)
		self.real_store.put(user)

	def list_recipes(self):
		logging.debug("list recipes")
		return self.real_store.list_recipes()

	def list_bags(self):
		logging.debug("list bags")
		return self.real_store.list_bags()

	def list_users(self):
		logging.debug("list users")
		return self.real_store.list_users()

	def list_tiddler_revisions(self, tiddler):
		logging.debug("list revisions %s" % tiddler)
		return self.real_store.list_tiddler_revisions(tiddler)

	def search(self, search_query):
		logging.debug("search %s" % search_query)
		return self.real_store.search(search_query)

	def _check_security(self, bag_name): # TODO: rename? -- TODO: should be decorator!?
		protocol = self.environ.get("wsgi.url_scheme")
		if protocol != "https" and bag_name in self.ssl_bags:
			raise SecureConnectionError("secure connection required")

# 需要导入模块: from tiddlyweb.store import Store [as 别名]
# 或者: from tiddlyweb.store.Store import list_tiddler_revisions [as 别名]

#.........这里部分代码省略.........
    def recipe_delete(self, recipe):
        key = _recipe_key(recipe)
        MC.delete(key)
        self.cached_store.delete(recipe)

    def recipe_get(self, recipe):
        key = _recipe_key(recipe)
        cached_recipe = _get(key)
        if cached_recipe:
            recipe = cached_recipe
        else:
            recipe = self.cached_store.get(recipe)
            MC.set(key, recipe)
        return recipe

    def recipe_put(self, recipe):
        key = _recipe_key(recipe)
        self.cached_store.put(recipe)
        MC.delete(key)

    def bag_delete(self, bag):
        key = _bag_key(bag)
        if MC.delete(key):
            MC.delete_multi([_tiddler_key(tiddler) for tiddler in bag.list_tiddlers()])
        self.cached_store.delete(bag)

    def bag_get(self, bag):
        key = _bag_key(bag)
        cached_bag = _get(key)
        if cached_bag:
            bag = cached_bag
        else:
            bag = self.cached_store.get(bag)
            MC.set(key, bag)
        return bag

    def bag_put(self, bag):
        key = _bag_key(bag)
        self.cached_store.put(bag)
        MC.delete(key)

    def tiddler_delete(self, tiddler):
        key = _tiddler_key(tiddler)
        if MC.delete(key):
            MC.delete(_bag_key(Bag(tiddler.bag)))
        self.cached_store.delete(tiddler)

    def tiddler_get(self, tiddler):
        key = _tiddler_key(tiddler)
        if not tiddler.revision or tiddler.revision == 0:
            cached_tiddler = _get(key)
            if cached_tiddler:
                tiddler = cached_tiddler
            else:
                tiddler = self.cached_store.get(tiddler)
                MC.set(key, tiddler)
        else:
            tiddler = self.cached_store.get(tiddler)
        return tiddler

    def tiddler_put(self, tiddler):
        key = _tiddler_key(tiddler)
        self.cached_store.put(tiddler)
        MC.delete(_bag_key(Bag(tiddler.bag)))
        MC.delete(key)

    def user_delete(self, user):
        key = _user_key(user)
        MC.delete(key)
        self.cached_store.delete(user)

    def user_get(self, user):
        key = _user_key(user)
        cached_user = _get(key)
        if cached_user:
            user = cached_user
        else:
            user = self.cached_store.get(user)
            MC.set(key, user)
        return user

    def user_put(self, user):
        key = _user_key(user)
        self.cached_store.put(user)
        MC.delete(key)

    def list_recipes(self):
        return self.cached_store.list_recipes()

    def list_bags(self):
        return self.cached_store.list_bags()

    def list_users(self):
        return self.cached_store.list_users()

    def list_tiddler_revisions(self, tiddler):
        return self.cached_store.list_tiddler_revisions(tiddler)

    def search(self, search_query):
        return self.cached_store.search(search_query)