Python StrictRedis.flushdb方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def test_lshash_redis_extra_val():
    """
    Test external lshash module
    """
    config = {"redis": {"host": 'localhost', "port": 6379, "db": 15}}
    sr = StrictRedis(**config['redis'])
    sr.flushdb()

    lsh = LSHash(6, 8, 1, config)
    for i in xrange(num_elements):
        lsh.index(list(els[i]), el_names[i])
        lsh.index(list(els[i]), el_names[i])  # multiple insertions
    hasht = lsh.hash_tables[0]
    itms = [hasht.get_list(k) for k in hasht.keys()]
    for itm in itms:
        assert itms.count(itm) == 1
        for el in itm:
            assert el[0] in els
            assert el[1] in el_names
    for el in els:
        res = lsh.query(list(el), num_results=1, distance_func='euclidean')[0]
        # vector an name are in the first element of the tuple res[0]
        el_v, el_name = res[0]
        # the distance is in the second element of the tuple
        el_dist = res[1]
        assert el_v in els
        assert el_name in el_names
        assert el_dist == 0
    del lsh
    sr.flushdb()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class RedisDataStore(DataStore):
    """Redis-backed datastore object."""

    def __init__(self, number=0):
        redis_host = os.environ.get('REDIS_PORT_6379_TCP_ADDR')
        redis_port = os.environ.get('REDIS_PORT_6379_TCP_PORT')
        self.redis_conn = StrictRedis(host=redis_host, port=redis_port,
                                      db=number)

    def __setitem__(self, k, v):
        self.redis_conn.set(k, v)

    def __getitem__(self, k):
        return self.redis_conn.get(k)

    def __delitem__(self, k):
        self.redis_conn.delete(k)

    def get(self, k):
        return self.redis_conn.get(k)

    def __contains__(self, k):
        return self.redis_conn.exists(k)

    def todict(self):
        #TODO(tvoran): use paginate
        #TODO(tvoran): do something besides multiple gets
        data = {}
        for key in self.redis_conn.keys():
            data[key] = self.get(key)
        return data

    def clear_all(self):
        self.redis_conn.flushdb()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def test((t, duration, type_)):
    conn = StrictRedis()
    conn.flushdb()
    ret = []

    def run():
        iterations = 0
        signal.setitimer(signal.ITIMER_REAL, int(sys.argv[1]))
        try:
            if type_ == 'redis_lock':
                while True:
                    with Lock(conn, "test-lock", expire=5):
                        iterations += 1
                        time.sleep(duration)
            elif type_ == 'native':
                while True:
                    with conn.lock("test-lock", timeout=5):
                        iterations += 1
                        time.sleep(duration)
        except:
            logging.info("Got %r. Returning ...", sys.exc_value)
        ret.append(iterations)

    sched = scheduler(time.time, time.sleep)
    logging.info("Running in %s seconds ...", t - time.time())
    sched.enterabs(t, 0, run, ())
    sched.run()
    return ret[0]

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def drop_database(db_name, redis_database=0):
    mongo_client = MongoClient()
    db = getattr(mongo_client, db_name)
    db.client.drop_database(db_name)

    redis_client = StrictRedis(db=redis_database)
    redis_client.flushdb()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class IndexCache(object):

    def __init__(self, host, port):
        self.client = StrictRedis(host=host, port=port, db=0)


    def build(self, doc_word_scores):
        """Clears the entire store and adds all the doc_word_scores into a
        hash table in the store.

        :param doc_word_scores: dictionary of dictionaries that looks like:
                    doc_word_scores[word][doc_id] = score of word in that
                                                    document
        """
        self.reset()

        for word, doc_id_score in doc_word_scores.items():
            # Add table name to word
            word_key = DOCUMENT_WORD_SCORE_NAME + word
            self.client.hmset(word_key, doc_id_score)

        self.save_to_disk()

    def reset(self):
        """Deletes all keys in this DB.
        """
        self.client.flushdb()

    def save_to_disk(self):
        """Asyncronous write to disk for persistent storage.
        """
        self.client.bgsave()

    def to_dict(self):
        """Returns the "doc_word_scores" table in Redis in dictionary form.
        """
        doc_word_scores = {}

        for word_key in self.doc_word_scores_iter():
            # Remove the table name from the key
            word = word_key.replace(DOCUMENT_WORD_SCORE_NAME, "")

            # Grab the {doc_ids : scores} dictionary for word
            doc_word_scores[word] = self.client.hgetall(word_key)

        return doc_word_scores

    def doc_word_scores_iter(self):
        """Returns an iterator for the keys of all the words stored in Redis
        """
        return self.client.scan_iter(match=DOCUMENT_WORD_SCORE_NAME + "*")

    def is_empty(self):
        return self.client.dbsize() <= 0

    def doc_scores(self, word):
        """Returns a hash table of document_ids mapping to scores
        """
        word_key = DOCUMENT_WORD_SCORE_NAME + word
        return self.client.hgetall(word_key)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class SutroTestCase(TestCase):
  def setUp(self):
    redis_connection_pool = ConnectionPool(**settings.WS4REDIS_CONNECTION)
    self.redis = StrictRedis(connection_pool=redis_connection_pool)
    self.client = Client()

  def tearDown(self):
    self.redis.flushdb()

  def random_string(self, length=None, str_type=None):
    DEFAULT_LENGTH = 10
    length = length if length else DEFAULT_LENGTH
    if str_type == 'number':
      string_type = string.digits
    else:
      string_type = string.lowercase
    return ''.join(random.choice(string_type) for x in range(length))

  def create_a_user(self, display_name, user_id=None, icon_url=None, user_url=None, rdio_key=None):
    user = User()
    user.display_name = display_name
    user.id = user_id if user_id else uuid.uuid4().hex
    user.icon_url = icon_url if icon_url else 'http://' + self.random_string() + '.jpg'
    user.user_url = user_url if user_url else 'http://' + self.random_string() + '.com/' + self.random_string()
    user.rdio_key = rdio_key if rdio_key else 's' + self.random_string(length=5, str_type='number')
    user.save(self.redis)
    return user

  def create_a_party(self, party_id, name):
    party = Party()
    party.id = party_id
    party.name = name
    party.save(self.redis)
    return party

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def test_lshash_redis():
    """
    Test external lshash module
    """
    config = {"redis": {"host": 'localhost', "port": 6379, "db": 15}}
    sr = StrictRedis(**config['redis'])
    sr.flushdb()

    lsh = LSHash(6, 8, 1, config)
    for i in xrange(num_elements):
        lsh.index(list(els[i]))
        lsh.index(list(els[i]))  # multiple insertions should be prevented by the library
    hasht = lsh.hash_tables[0]
    itms = [hasht.get_list(k) for k in hasht.keys()]
    for itm in itms:
        for el in itm:
            assert itms.count(itm) == 1  # have multiple insertions been prevented?
            assert el in els
    for el in els:
        res = lsh.query(list(el), num_results=1, distance_func='euclidean')[0]
        el_v, el_dist = res
        assert el_v in els
        assert el_dist == 0
    del lsh
    sr.flushdb()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def pytest_runtest_teardown(item):
    from sentry.app import tsdb
    tsdb.flush()

    client = StrictRedis(db=9)
    client.flushdb()

    from celery.task.control import discard_all
    discard_all()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
    def store(self):
        from simplekv.memory.redisstore import RedisStore
        r = StrictRedis()

        try:
            r.get('anything')
        except ConnectionError:
            pytest.skip('Could not connect to redis server')

        r.flushdb()
        yield RedisStore(r)
        r.flushdb()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class RedconTestBase(unittest.TestCase):

    def setUp(self):
        if hasattr(testsettings, 'REDIS_DB_UNIX_SOCKET_PATH'):
            self.redis = StrictRedis(
                db=testsettings.REDIS_DB,
                unix_socket_path=testsettings.REDIS_DB_UNIX_SOCKET_PATH,
            )
        else:
            self.redis = StrictRedis(
                db=testsettings.REDIS_DB,
                host=testsettings.REDIS_DB_HOST,
                port=testsettings.REDIS_DB_PORT,
            )

        self.redis.flushdb()
        self.redcon = Redcon(self.redis)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class RedisManager(NoSqlManager):
    def __init__(self, namespace, url=None, data_dir=None, lock_dir=None, **params):
        self.expiretime = params.pop('expiretime', None)
        NoSqlManager.__init__(self, namespace, url=url, data_dir=data_dir, lock_dir=lock_dir, **params)

    def open_connection(self, host, port, **params):
        self.db_conn = StrictRedis(host=host, port=int(port), **params)

    def __getitem__(self, key):
        return pickle.loads(self.db_conn.hget(self._format_key(key), 'data'))

    def __contains__(self, key):
        return self.db_conn.exists(self._format_key(key))

    def set_value(self, key, value, expiretime=None):
        key = self._format_key(key)

        #
        # beaker.container.Value.set_value calls NamespaceManager.set_value
        # however it (until version 1.6.4) never sets expiretime param.
        #
        # Checking "type(value) is tuple" is a compromise
        # because Manager class can be instantiated outside container.py (See: session.py)
        #
        if (expiretime is None) and (type(value) is tuple):
            expiretime = value[1]

        self.db_conn.hset(key, 'data', pickle.dumps(value))
        self.db_conn.hset(key, 'accessed', datetime.now())
        self.db_conn.hsetnx(key, 'created', datetime.now())

        if expiretime or self.expiretime:
            self.db_conn.expire(key, expiretime or self.expiretime)

    def __delitem__(self, key):
        self.db_conn.delete(self._format_key(key))

    def _format_key(self, key):
        return 'beaker:%s:%s' % (self.namespace, key.replace(' ', '\302\267'))

    def do_remove(self):
        self.db_conn.flushdb()

    def keys(self):
        return self.db_conn.keys('beaker:%s:*' % self.namespace)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class testTaggedCache(unittest.TestCase):
    def setUp(self):
        self.redis = StrictRedis(db=DATABASE)
        self.redis.flushdb()
        self.cache = TaggedCache(self.redis)

    def testEverything(self):
        cache = self.cache

        # Set
        cache.set("User:1", "mitch", tags=["User", "PremiumUser"])
        cache.set("User:2", "foo", tags=["User"])
        cache.set("Post:1", "Hello World!", tags=["Post"])
        cache.set("Post:2", "Hello World, again!", tags=["Post"])
        
        self.assertEquals(cache.get("Post:1"), "Hello World!")
        self.assertEquals(cache.get_keys("Post"), set(["Post:1", "Post:2"]))
        self.assertEquals(cache.get_keys("User"), set(["User:1", "User:2"]))
        self.assertEquals(cache.get_tags("User:1"), set(["User", "PremiumUser"]))
        self.assertEquals(cache.get_tags("User:2"), set(["User"]))

        # Delete all post cache entries
        cache.clear_tag("Post")
        self.assertEquals(cache.get("Post:1"), None, "Post:1 still exists")
        self.assertEquals(cache.get("Post:2"), None, "Post:2 still exists")
        
        # Delete User 2 from cache
        cache.clear("User:2")
        self.assertEquals(cache.get_tags("User:2"), set())

        # Clear everything else
        cache.clear_all()
        cache.gc()

        self.assertEquals(self.redis.get("CacheKeys"), None)
        self.assertEquals(self.redis.get("Tags"), None)
        
        self.assertEquals(len(self.redis.keys("*")), 0, "Some keys were not gc'ed")

    def testExpireTtl(self):
        self.cache.set("ExpireMe", "foo", ttl=1)
        time.sleep(2)
        self.assertEquals(self.cache.get("ExpireMe"), None)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def main():
    json_data = []
    with open("artist.json", 'r') as _file:
        for line in _file.readlines():
            # json stringをdic型に変換
            json_data.append(loads(line))

    path = "./config.ini"
    redis_config = RedisConfig(path)
    host, port, db = redis_config.read_config()

    r = StrictRedis(host=host, port=port, db=db)

    # 接続しているDBを全消し
    r.flushdb()

    # Redisに登録
    for dic in json_data:
        if "area" in dic:
            r.set(str(dic["id"]) + "_" + dic["name"], dic["area"])

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def redis_rules(request):
    """Load up some sample traptor rules into Redis."""
    with open('tests/data/track_rules.json') as f:
        track_rules = [json.loads(line) for line in f]
    with open('tests/data/follow_rules.json') as f:
        follow_rules = [json.loads(line) for line in f]
    with open('tests/data/locations_rules.json') as f:
        locations_rules = [json.loads(line) for line in f]

    conn = StrictRedis(host=HOST_FOR_TESTING, port=6379, db=5)
    conn.flushdb()

    rc = RulesToRedis(conn)
    rc.send_rules(traptor_type='track', rules=track_rules)
    rc.send_rules(traptor_type='follow', rules=follow_rules)
    rc.send_rules(traptor_type='locations', rules=locations_rules)

    def cleanup():
        conn.flushdb()

    request.addfinalizer(cleanup)

    return conn

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class TestCase(AsyncTestCase):
    """
    Subclass API: Base for Wall unit tests. Takes care of setting / cleaning up
    the test environment and provides utilities for testing.

    Attributes:

     * `db`: connection to temporary Redis database (`15`)
     * `app`: Wall application. `TestPost` is available as registered post type.
     * `user`: active user.
    """

    def setUp(self):
        super(TestCase, self).setUp()
        self.db = StrictRedis(db=15)
        self.db.flushdb()
        self.app = WallApp(config={'db': 15})
        self.app.add_post_type(TestPost)
        self.user = self.app.login('Ivanova', 'test')
        self.app.user = self.user

    def get_new_ioloop(self):
        return IOLoop.instance()