本文整理汇总了Python中redis.StrictRedis.zrevrange方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.zrevrange方法的具体用法?Python StrictRedis.zrevrange怎么用?Python StrictRedis.zrevrange使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.zrevrange方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: __init__
# 需要导入模块: 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
示例2: RedisDB
# 需要导入模块: 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
示例3: copy_values
# 需要导入模块: 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
示例4: process_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
示例5: GistStorage
# 需要导入模块: 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)
示例6: PECorrelator
# 需要导入模块: 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))
示例7: StrictRedis
# 需要导入模块: 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]
示例8: Pyre
# 需要导入模块: 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
示例9: RedisTopTalkerTracker
# 需要导入模块: 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)
示例10: StrictRedis
# 需要导入模块: 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')])
示例11: Leaderboard
# 需要导入模块: 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):
#.........这里部分代码省略.........
示例12: StrictRedis
# 需要导入模块: 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))])
示例13: StrictRedis
# 需要导入模块: 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')])
示例14: StrictRedis
# 需要导入模块: 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)
示例15: RunLogger
# 需要导入模块: 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)