Python StrictRedis.zrevrange方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrange [as 别名]
class WordList:
  def __init__(self):
    self.conn = Redis()
    self.CACHE_SIZE = 50
    self.CACHE_KEYS = "words-keys"
    self.CACHE_STORE = "words-store"
    self.WORD_FILE = os.path.join(os.path.expanduser("~"), '.words.txt')

  def _reorganize(self):
    pop_n = self.conn.zcard(self.CACHE_KEYS) - self.CACHE_SIZE
    if pop_n >= 0:
      to_pop = self.conn.zrange(self.CACHE_KEYS, 0, pop_n)
      #print pop_n, to_pop
      self.conn.zremrangebyrank(self.CACHE_KEYS, 0, pop_n)
      for k in to_pop:
        self.conn.hdel(self.CACHE_STORE, k)

  def _add_word(self, key, value):
    result = self.conn.hget(self.CACHE_STORE, key)
    if result:
      self.conn.zincrby(self.CACHE_KEYS, key, 1.0)
    else:
      self._reorganize()
      self.conn.hset(self.CACHE_STORE, key, value)
      self.conn.zadd(self.CACHE_KEYS, 1, key)

  def _get_words(self):
    try:
      words = self.conn.zrevrange(self.CACHE_KEYS, 0, -1, True)
      #hashs = self.conn.hgetall(self.CACHE_STORE)
      #print words
      #print hashs
      return words
    except redis.exceptions.ConnectionError:
      return None

  def dump_console(self):
    if os.path.isfile(self.WORD_FILE):
      with open(self.WORD_FILE, 'r') as f:
        print f.read()

  def write_file(self):
    words = self._get_words()
    if words is None:
      return
    content = '\n'.join(["%d. %s\t %d"%(i, x[0], int(x[1])) for i, x in enumerate(words)])
    with open(self.WORD_FILE, 'w+') as f:
      f.write(content)
      f.write('\n')

  def add_word(self, key):
    try:
      self._add_word(key,key)
      self.write_file()
    except redis.exceptions.ConnectionError:
      return

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

    def __init__(self):
        if not hasattr(RedisDB, 'pool'):
            RedisDB.createPool()
        self.r = StrictRedis(connection_pool = RedisDB.pool)

    @staticmethod  
    def createPool():  
        RedisDB.pool = redis.ConnectionPool(  
        host = '127.0.0.1',  
        port = 6379,  
        db   = 0
        )

    def saveToRedis(self, receiver, to_station_ab, to_station_name, from_station_ab, from_station_name, querydate, purpose_code, noticetime, publishtime):
        '''将需要抓取的信息存入redis'''
        uid = self.r.incr('uid')    
        tickets_info = {'uid':uid, 'receiver':receiver, 'to_station_ab':to_station_ab, 'to_station_name':to_station_name, 'from_station_ab':from_station_ab,'from_station_name':from_station_name, 'querydate':querydate, 'purpose_code':purpose_code, 'noticetime':noticetime, 'publishtime': publishtime}
        self.r.zadd('email_que_set_all', uid, str(tickets_info))
        if noticetime == '9am':
            self.r.zadd('email_que_set_9am', uid, str(tickets_info))
        elif noticetime == '11am':
            self.r.zadd('email_que_set_11am', uid, str(tickets_info))
        elif noticetime == '3pm':
            self.r.zadd('email_que_set_3pm', uid, str(tickets_info))
        elif noticetime == '5pm':
            self.r.zadd('email_que_set_5pm', uid, str(tickets_info))
        self.r.save()

    def getStation(self, set, name):
        return self.r.hget(set, name)

    def zrevrange(self, set, begin, end):
        return self.r.zrevrange(set, begin, end)
    
    def zremrangebyscore(self, queue, uid):
        return self.r.zremrangebyscore(queue, uid, uid)

    def station_validate(self, form, field):  
        ''' 
        表单tostation和tostation验证函数
        '''
        if not self.r.getStation(field.data):
     
            raise ValidationError(u'木有这个站') 

    def saveJSONToSet(self, setName, json):
        if not self.r.exists(setName):
            for i, name in enumerate(json):
                self.r.hset(setName, name, json[name])
                print 'insert'+name
            self.r.save()
        else:
            pass

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrange [as 别名]
def copy_values():
	source = StrictRedis()
	dest = StrictRedis(db=1)
	for key in source.keys():
		try:
			for doc_id, value in source.zrevrange(key, 0, -1, "WITHSCORES"):
				print(dest.zadd(key, value, doc_id))
				source.zrem(key, doc_id)
		except redis.exceptions.ResponseError:
			pass
	print key

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrange [as 别名]
def process_key(k):
    r = StrictRedis(db=INDEX_DB)
    try:
        p = r.pipeline()
        for (doc_id, value) in r.zrevrange(k, 0, -1, "WITHSCORES"):
            if doc_id not in db:
                print("Deleted " + doc_id + " from " + key)
                p.zrem(key, doc_id)            
                continue
            doc = db[doc_id]
            if k.lower() in doc['title'].lower() or k.lower() in doc['description'].lower():
                p.zadd(k, value, doc_id)
        print(p.exceute())
    except redis.exceptions.ResponseError:
        pass

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrange [as 别名]
class GistStorage(object):
    SUPER_KEY = 'live'

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

    def upvote(self, gist_id):
        return self.client.zincrby(self.SUPER_KEY, gist_id, 1)

    def get_rank(self, gist_id):
        return self.client.zrevrank(self.SUPER_KEY, gist_id)

    def get_points(self, gist_id):
        return self.client.zscore(self.SUPER_KEY, gist_id)

    def get_rank_list(self, offset=0, num=-1):
        return self.client.zrevrange(self.SUPER_KEY, offset, num, withscores=True, score_cast_func=float)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrange [as 别名]
class PECorrelator(object):
    def __init__(self):
        self.r = StrictRedis(unix_socket_path=redis_socket, decode_responses=True)

    def get_all_samples(self):
        return self.r.smembers("hashes_sha256")

    def get_all_hashes(self, sha256):
        return [sha256] + list(self.r.hmget(sha256, ["sha1", "md5"]))

    def get_sample_info(self, sha256):
        return self.r.hgetall(sha256)

    def get_timestamps_iso(self, num=-1):
        return [
            (datetime.datetime.fromtimestamp(ts).isoformat(), val)
            for ts, val in self.r.zrevrange("timestamps", 0, num, withscores=True)
        ]

    def get_timestamps(self, num=-1):
        return self.r.zrevrange("timestamps", 0, num, withscores=True)

    def get_samples_timestamp(self, timestamp):
        return self.r.smembers("timestamp:{}".format(timestamp))

    def get_imphashs(self, num=-1):
        return self.r.zrevrange("imphashs", 0, num, withscores=True)

    def get_samples_imphash(self, imphash):
        return self.r.smembers("imphash:{}".format(imphash))

    def get_entrypoints(self, num=-1):
        return self.r.zrevrange("entrypoints", 0, num, withscores=True)

    def get_samples_entrypoint(self, entrypoint):
        return self.r.smembers("entrypoint:{}".format(entrypoint))

    def get_secnumbers(self, num=-1):
        return self.r.zrevrange("secnumbers", 0, num, withscores=True)

    def get_samples_secnumber(self, secnumber):
        return self.r.smembers("secnumber:{}".format(secnumber))

    def get_originalfilenames(self, num=-1):
        return self.r.zrevrange("originalfilenames", 0, num, withscores=True)

    def get_samples_originalfilename(self, originalfilename):
        return self.r.smembers("originalfilename:{}".format(originalfilename))

    def get_sample_secnames(self, sha256):
        return self.r.smembers("{}:secnames".format(sha256))

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrange [as 别名]
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from redis import StrictRedis
import sys
import csv

writer = csv.writer(sys.stdout)

r = StrictRedis(port=6399)

all_hashes = r.smembers('hashes_sha256')

while all_hashes:
    cur_hash = all_hashes.pop()
    zrange = r.zrevrange('matches_{}'.format(cur_hash), 0, -1, True)
    if not zrange:
        continue
    cur_ssdeep = r.hget(cur_hash, 'ssdeep')
    cur_eids = r.smembers('{}:eids'.format(cur_hash)).union(r.smembers('{}:eids'.format(r.hget(cur_hash, 'md5')))).union(r.smembers('{}:eids'.format(r.hget(cur_hash, 'sha1'))))
    uuids = [r.get('eventuuid:{}'.format(eid)) for eid in cur_eids]
    infos = [r.hget('event:{}'.format(uuid), 'info') for uuid in uuids]
    eids_infos = zip(cur_eids, infos)
    cur_list = []
    for h, score in zrange:
        if h in all_hashes:
            all_hashes.remove(h)
        if score > 90:
            eids = r.smembers('{}:eids'.format(h)).union(r.smembers('{}:eids'.format(r.hget(h, 'md5')))).union(r.smembers('{}:eids'.format(r.hget(h, 'sha1'))))
            uuids = [r.get('eventuuid:{}'.format(eid)) for eid in eids]
            infos = [r.hget('event:{}'.format(uuid), 'info')for uuid in uuids]

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

    def __init__(self, *args, **kwargs):
        self.redis = StrictRedis(*args, **kwargs)

    def _map_results(self, keys):
        if not keys:
            return []
        pipe = self.redis.pipeline()
        for key in keys:
            app_dot_model, pk, _ = _KEY.match(key).groups()
            pipe.hgetall(app_dot_model + '#' + pk)
        results = []
        indexes = pipe.execute()
        for i, index in enumerate(indexes):
            for field, value in index.iteritems():
                if not value:
                    continue
                if value[0] == 'A':
                    index[field] = value[2:].split(',')
                elif value[0] == 'M':
                    index[field] = int(value[2:])
                elif value[0] == 'T':
                    index[field] = float(value[2:])
                elif value[0] == 'B':
                    index[field] = bool(value[2:])
                elif value[0] == 'I':
                    index[field] = int(value[2:])
                elif value[0] == 'F':
                    index[field] = float(value[2:])
                elif value[0] == 'S':
                    index[field] = value[2:]
                else:
                    print '\033[93m', 'ERROR', field, value, '\033[0m'
            result = _Result(index)
            result._key = keys[i]
            results.append(result)
        return results

    def get_all(self, model):
        keys = self.redis.keys(model._meta.app_label + '.' + model._meta.module_name + '#*')
        results = self._map_results(keys)
        return results

    def autocomplete(self, query):
        keys = ['a:' + key for key in _unique(_get_words(query, weighted=False))]
        if not keys:
            return []
        pipe = self.redis.pipeline()
        for key in keys:
            pipe.zrevrange(key, 0, -1, withscores=False)
        ikeys = [ikey for sublist in pipe.execute() for ikey in sublist]
        results = [result for result in _unique(self._map_results(ikeys))]
        return results

    def search(self, query, offset=0, count=10):
        keys = ['w:' + key for key in _get_words(query)]
        if not keys:
            return []
        indexed = max(self.redis.get('indexed'), 1)
        pipe = self.redis.pipeline()
        for key in keys:
            pipe.zcard(key)
        counts = pipe.execute()
        ranks = [max(math.log(float(indexed) / count, 2), 0) if count else 0 for count in counts]
        weights = dict((key, rank) for key, count, rank in zip(keys, counts, ranks) if count)
        if not weights:
            return []
        temp_key = 'temp:' + os.urandom(8).encode('hex')
        try:
            self.redis.zunionstore(temp_key, weights)
            keys = self.redis.zrevrange(temp_key, offset, offset+count-1, withscores=False)
        finally:
            self.redis.delete(temp_key)
        results = self._map_results(keys)
        return results

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrange [as 别名]
class RedisTopTalkerTracker(object):
    def __init__(self, size=16384, redis_host='localhost', redis_port=6379,
                 redis_table='top_talkers'):
        self.size = size
        self.redis_table = 'top_talkers'
        self.client = StrictRedis(host=redis_host, port=redis_port)

        self.is_saturated = self.decide_is_saturated()

    def decide_is_saturated(self):
        return self.client.zcard(self.redis_table) >= self.size

    def clear(self):
        self.client.zremrangebyrank(self.redis_table, 0, -1)
        self.is_saturated = self.decide_is_saturated()

    def is_full(self):
        if self.is_saturated:
            return True

        self.is_saturated = self.decide_is_saturated()
        return self.is_saturated

    def get(self, key):
        count = self.client.zscore(self.redis_table, key)
        if count is None:
            return count

        return int(count)

    def contains(self, key):
        count = self.client.zscore(self.redis_table, key)
        return count is not None

    def add(self, key):
        # If it's already in there, increment its count and we're done.
        count = self.client.zscore(self.redis_table, key)
        if count is not None:
            self.client.zincrby(self.redis_table, key, 1)
            return

        # Else if the key is new to us but we're full, pop the lowest key/count
        # pair and insert the new key as count + 1.
        if self.is_full():
            keys_counts = self.client.zrange(
                self.redis_table, 0, 0, withscores=True, score_cast_func=int)
            old_count = keys_counts[0][1]
            self.client.zremrangebyrank(self.redis_table, 0, 0)
            new_count = old_count + 1
            self.client.zadd(self.redis_table, new_count, key)
            return

        # Or if the key is new to us and we have space, just insert it.
        self.client.zadd(self.redis_table, 1, key)

    def top_n_keys(self, n):
        return self.client.zrevrange(
            self.redis_table, 0, n - 1, score_cast_func=int)

    def top_n_keys_counts(self, n):
        keys_counts = self.client.zrevrange(
            self.redis_table, 0, n - 1, withscores=True, score_cast_func=int)
        if self.is_full():
            lowest_keys_counts = self.client.zrange(
                self.redis_table, 0, 0, withscores=True, score_cast_func=int)
            the_min = lowest_keys_counts[0][1] - 1
        else:
            the_min = 0
        return map(lambda (key, count): (key, count - the_min), keys_counts)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrange [as 别名]
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from redis import StrictRedis
from helper import dict_to_md

r = StrictRedis(port=6399)
use_subset = True

names_by_events = {}
events_by_names = {}

for key, score in r.zrevrange('originalfilenames', 0, -1, True):
    if score == 1:
        continue
    hashes = r.smembers('{}:{}'.format('originalfilename', key))
    for h in hashes:
        md5 = r.hget(h, 'md5')
        sha1 = r.hget(h, 'sha1')
        eids = r.smembers('{}:eids'.format(md5)).union(r.smembers('{}:eids'.format(sha1))).union(r.smembers('{}:eids'.format(h)))
        for e in eids:
            uuid = r.get('eventuuid:{}'.format(e))
            if use_subset and uuid not in r.smembers('subset'):
                continue

            if not names_by_events.get(e):
                names_by_events[e] = []
            names_by_events[e].append(key)
            if not events_by_names.get(key):
                events_by_names[key] = []
            events_by_names[key].append([e, r.hget('event:{}'.format(uuid), 'info')])

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrange [as 别名]
class Leaderboard(object):
    """
    Main class for leaderboards.
    """
    _1_DAY_SECONDS = 60 * 60 * 24
    _1_WEEK_SECONDS = _1_DAY_SECONDS * 7
    _1_MONTH_SECONDS = _1_DAY_SECONDS * 31

    # Constants for specifying range(s) to Leaderboard constructor
    # TODO: make expiration configurable and setup a pruner task
    RANGE_DAILY = TimeRange('d', '%Y%m%d', 3 * _1_DAY_SECONDS, _KEY_DELIMITER)
    RANGE_WEEKLY = TimeRange('w', '%Y%W', 2 * _1_WEEK_SECONDS + 2 * _1_DAY_SECONDS, _KEY_DELIMITER)
    RANGE_MONTHLY = TimeRange('m', '%Y%m', 2 * _1_MONTH_SECONDS + 2 * _1_DAY_SECONDS, _KEY_DELIMITER)
    RANGE_ALLTIME = TimeRange('a', 'a', -1, _KEY_DELIMITER)
    RANGES_ALL = [RANGE_DAILY, RANGE_WEEKLY, RANGE_MONTHLY, RANGE_ALLTIME]

    def __init__(self, game, metric, ranges=RANGES_ALL, reverse=True,
                 timed_ties=False, tie_oldest_wins=True,
                 redis=None):
        """
        :param reverse: True for sorting by high to low scores
        :param timed_ties: True to use a given timestamp to resolve tie scores, assumes score values are ints
        :param tie_oldest_wins: True if the earlier time wins
        """
        self.game = game
        self.metric = metric
        self.ranges = ranges
        self.reverse = reverse
        self.timed_ties = timed_ties
        self.tie_oldest_wins = tie_oldest_wins

        if not redis:
            self.r = StrictRedis()
        else:
            self.r = redis

    def _board_key(self, range, slots_ago=0):
        """
        Board keys are of the format:
        /leaders/{game}/{metric}/{range_code}/{range_slot}
        e.g. /combat/highscore/d/20130207
        """
        if slots_ago != 0:
            d = range.date_range(slots_ago)[0]
        else:
            d = datetime.utcnow()
        return _KEY_DELIMITER.join(["leaders", self.game, self.metric,
                                    range.format(d)])

    def _hashlist(self, l):
        """
        hash from a list for creating unique temp zset keys
        """
        h = hashlib.sha1()
        for i in l:
            h.update(i)
        h.update(str(time.time()))
        return h.hexdigest()

    def _range(self, key, start, end):
        if self.reverse:
            return self.r.zrevrange(key, start, end, withscores=True, score_cast_func=float)
        else:
            return self.r.zrange(key, start, end, withscores=True, score_cast_func=float)

    def _add_ranks(self, leaders, offset=0):
        """
        Calculate ranks and update the given leader list to include them.
        Ranks start at 1.
        """
        with_ranks = [Leader(m, s, rank, t) for (m, s, t), rank in zip(leaders, itertools.count(offset + 1))]
        return with_ranks

    def _dt_to_ts(self, ts):
        """
        Ensure we are using a UNIX timestamp
        """
        if isinstance(ts, datetime):
            return (ts - datetime(1970, 1, 1)).total_seconds()
        else:
            return ts

    def _encode_value_with_time(self, value, ts):
        """
        Redis will rank members with identical scores lexigraphically. Often this is not
        what we want for a leaderboard. Using the timed_ties option, we will r the
        timestamp in the decimal part of the float score and thereby use it for tie-breaking.
        tie_oldest_wins controls whether older or newer timestamps get ranked higher.
        """
        if not ts:
            ts = time.time()
        else:
            ts = self._dt_to_ts(ts)
        if self.reverse == self.tie_oldest_wins:
            # invert the timestamp for proper ordering
            ts = 3000000000 - ts
        to_dec = 0.0000000001
        return float(value) + (ts * to_dec)

    def _decode_value_with_time(self, combo):
#.........这里部分代码省略.........

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrange [as 别名]
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from redis import StrictRedis
import csv

pe_indicators = ['timestamps', 'imphashs', 'entrypoints', 'originalfilenames', 'secnumbers']
r = StrictRedis(port=6399)

eid_ignore_list = set(['1813', '2862', '11', '63', '257'])


for i in pe_indicators:
    with open('{}.csv'.format(i), 'w') as f:
        writer = csv.writer(f)
        for key, score in r.zrevrange(i, 0, -1, True):
            if score == 1:
                continue
            hashes = r.smembers('{}:{}'.format(i[:-1], key))
            for h in hashes:
                md5 = r.hget(h, 'md5')
                sha1 = r.hget(h, 'sha1')
                eids = r.smembers('{}:eids'.format(md5)).union(r.smembers('{}:eids'.format(sha1))).union(r.smembers('{}:eids'.format(h)))
                eids = eids.difference(eid_ignore_list)
                if not eids:
                    continue
                writer.writerow([i, key, h, ','.join(sorted(eids, key=int))])

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrange [as 别名]
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from redis import StrictRedis
from helper import dict_to_md

r = StrictRedis(port=6399)
use_subset = True

names_by_events = {}
events_by_imphashes = {}

for key, score in r.zrevrange('imphashs', 0, -1, True):
    if score == 1:
        continue
    hashes = r.smembers('{}:{}'.format('imphash', key))
    for h in hashes:
        md5 = r.hget(h, 'md5')
        sha1 = r.hget(h, 'sha1')
        eids = r.smembers('{}:eids'.format(md5)).union(r.smembers('{}:eids'.format(sha1))).union(r.smembers('{}:eids'.format(h)))
        for e in eids:
            uuid = r.get('eventuuid:{}'.format(e))
            if use_subset and uuid not in r.smembers('subset'):
                continue

            if not names_by_events.get(e):
                names_by_events[e] = []
            names_by_events[e].append(key)
            if not events_by_imphashes.get(key):
                events_by_imphashes[key] = []
            events_by_imphashes[key].append([e, r.hget('event:{}'.format(uuid), 'info')])

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrange [as 别名]
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from redis import StrictRedis
from helper import dict_to_md
import dateutil.parser
import time

r = StrictRedis(port=6399)
use_subset = True

names_by_events = {}
events_by_ts = {}

for key, score in r.zrevrange('timestamps', 0, -1, True):
    if score == 1:
        continue
    timestamp = time.mktime(dateutil.parser.parse(key).timetuple())
    hashes = r.smembers('{}:{}'.format('timestamp', int(timestamp)))
    for h in hashes:
        md5 = r.hget(h, 'md5')
        sha1 = r.hget(h, 'sha1')
        eids = r.smembers('{}:eids'.format(md5)).union(r.smembers('{}:eids'.format(sha1))).union(r.smembers('{}:eids'.format(h)))
        for e in eids:
            uuid = r.get('eventuuid:{}'.format(e))
            if use_subset and uuid not in r.smembers('subset'):
                continue

            if not names_by_events.get(e):
                names_by_events[e] = []
            names_by_events[e].append(key)

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

    def __init__(self, redis_config, max_logs=1000):
        self._redis = StrictRedis(**redis_config)
        self._lock = threading.Lock()
        self._logger = donothing  # All logger calls ignored
        self._job_id = None
        self.max_logs = max_logs

    @contextmanager
    def runlog(self, job_id, run_id=None):
        if not self._lock.acquire(False):
            raise Exception("Can't start %s. %s already started."
                            % (job_id, self._job_id))
        if run_id is None:
            run_id = str(datetime.datetime.now()).replace(' ', '-')
        try:
            hdlr = RunlogHandler(self._redis, job_id, run_id)
            self._logger = logging.getLogger("%s|%s" % (job_id, run_id))
            self._job_id = job_id
            self._logger.addHandler(hdlr)
            timestamp = time.time()
            self._redis.zadd('jobs', timestamp, job_id)
            self._redis.zadd('%s|runs' % job_id, timestamp, run_id)
            self._redis.set('%s|%s|start' % (job_id, run_id), timestamp)
            try:
                try:
                    yield self._logger
                finally:
                    self._redis.set('%s|%s|end' % (job_id, run_id),
                                    time.time())
            except CancelLog:
                self.forget_run(job_id, run_id)
            except Exception as ex:
                self._redis.zadd('exceptions',
                                 timestamp,
                                 "%s|%s" % (job_id, run_id))
                self._logger.exception(ex)
                del logging.Logger.manager.loggerDict[
                    "%s|%s" % (job_id, run_id)]
                raise ex  # Don't swallow errors.
        finally:
            self.forget_old_runs(job_id)
            self._job_id = None
            self._logger = donothing
            self._lock.release()

    def forget_run(self, job_id, run_id):
        self._redis.zrem('%s|runs' % job_id, run_id)
        self._redis.delete('%s|%s|start' % (job_id, run_id))
        self._redis.delete('%s|%s|end' % (job_id, run_id))
        self._redis.delete('%s|%s|log' % (job_id, run_id))

    def forget_old_runs(self, job_id):
        for run_id in self._redis.zrange('%s|runs' % job_id,
                                         self.max_logs,
                                         -1):
            self.forget_run(job_id, run_id)

    def debug(self, *a, **kw):
        self._logger.debug(*a, **kw)

    def info(self, *a, **kw):
        self._logger.info(*a, **kw)

    def warn(self, *a, **kw):
        self._logger.warn(*a, **kw)

    def warning(self, *a, **kw):
        self._logger.warning(*a, **kw)

    def error(self, *a, **kw):
        self._logger.error(*a, **kw)

    def critical(self, *a, **kw):
        self._logger.critical(*a, **kw)

    def exception(self, *a, **kw):
        self._logger.exception(*a, **kw)

    def list_jobs(self):
        return self._redis.zrevrange('jobs', 0, -1)

    def list_runs(self, job_id):
        return self._redis.zrange('%s|runs' % job_id, 0, -1)

    def run_times(self, job_id, run_id):
        return (self._redis.get('%s|%s|start' % (job_id, run_id)),
                self._redis.get('%s|%s|end' % (job_id, run_id)))

    def get_log(self, job_id, run_id):
        return self._redis.lrange('%s|%s|log' % (job_id, run_id), 0, -1)