def createhotel(): if not request.json or not 'displayname' in request.json or not 'id' in request.json: abort(400) hotel = { 'id': request.json['id'], 'displayname': request.json['displayname'], 'acname': request.json['acname'], 'image': request.json.get('image', ''), 'latitude': request.json.get('latitude', 0), 'longitude': request.json.get('longitude', 0), 'thirdpartyrating': request.json.get('thirdpartyrating', 0) } hotelname = hotel['acname'] for l in range(1, len(hotelname)): hotelfragment = hotelname[0:l] redis.zadd('hotelfragments', 0, hotelfragment) hotelwithid = hotelname + '%H-' + str(hotel['id']) + '%' redis.zadd('hotelfragments', 0, hotelwithid) hotelkey = 'H-' + str(hotel['id']) redis.execute_command('geoadd', 'hotels', '%f' % hotel['longitude'], '%f' % hotel['latitude'], hotelkey) redis.delete(hotelkey) redis.rpush(hotelkey, hotel['id']) redis.rpush(hotelkey, hotel['displayname']) redis.rpush(hotelkey, hotel['acname']) redis.rpush(hotelkey, hotel['image']) redis.rpush(hotelkey, hotel['latitude']) redis.rpush(hotelkey, hotel['longitude']) redis.rpush(hotelkey, hotel['thirdpartyrating']) return jsonify({ 'hotel': hotel }), 201
def createlocation(): if not request.json or not 'displayname' in request.json or not 'id' in request.json: abort(400) location = { 'id': request.json['id'], 'displayname': request.json['displayname'], 'acname': request.json['acname'], 'icon': request.json.get('icon', ''), 'latitude': request.json.get('latitude', 0), 'longitude': request.json.get('longitude', 0) } locationname = location['acname'] for l in range(1, len(locationname)): locationfragment = locationname[0:l] redis.zadd('locationfragments', 0, locationfragment) locationwithid = locationname + '%L-' + str(location['id']) + '%' redis.zadd('locationfragments', 0, locationwithid) locationkey = 'L-' + str(location['id']) redis.delete(locationkey) redis.rpush(locationkey, location['id']) redis.rpush(locationkey, location['displayname']) redis.rpush(locationkey, location['acname']) redis.rpush(locationkey, location['icon']) redis.rpush(locationkey, location['latitude']) redis.rpush(locationkey, location['longitude']) return jsonify({'location': location}), 201
def delay(self, msg): msg.id = str(uuid.uuid4()) value = json.dumps(msg.id) retry_ts = time.time() + 5 # zset: key score1 value1 score2 value2 # score: 到期处理时间 value: 请求的ID redis.zadd("delay-queue", retry_ts, value)
def send_message(redis, chat_id, sender, message): """ 发送消息 :param redis: :param chat_id: :param sender: :param message: :return: """ key_chat_group = CHAT_GRUOP.format(chat_id=chat_id) key_chat_message_ids = CHAT_MESSAGE_GEN_IDS.format(chat_id=chat_id) key_chat_message = CHAT_MESSAGE.format(chat_id=chat_id) identifier = acquire_lock(redis, key_chat_group) if not identifier: raise Exception("Couldn't get the lock") try: # 筹备待发送的消息。 message_id = redis.incr(key_chat_message_ids) ts = time.time() paked = json.dumps({ 'id': message_id, 'ts': ts, 'sender': sender, 'message': message, }) # 将消息推送至群组 redis.zadd(key_chat_message, {paked: message_id}) except: pass finally: release_lock(redis, key_chat_group, identifier) return chat_id
def handler(event, context): for record in event['Records']: if record['eventName'] == "REMOVE": continue print(record) playerName = record['dynamodb']['NewImage']['PlayerName']['S'] if 'OldImage' in record['dynamodb'].keys(): oldScore = int(record['dynamodb']['OldImage']['Score']['N']) oldWin = int(record['dynamodb']['OldImage']['Win']['N']) oldLose = int(record['dynamodb']['OldImage']['Lose']['N']) olddata = { "PlayerName": str(playerName), "Win": int(oldWin), "Lose": int(oldLose) } old_json = json.dumps(olddata) redis.zrem('Rating', old_json) newScore = int(record['dynamodb']['NewImage']['Score']['N']) newWin = int(record['dynamodb']['NewImage']['Win']['N']) newLose = int(record['dynamodb']['NewImage']['Lose']['N']) newdata = { "PlayerName": str(playerName), "Win": int(newWin), "Lose": int(newLose) } new_json = json.dumps(newdata) redis.zadd('Rating', new_json, newScore) return "OK"
def run(self): dbJson = list() redis = open_connection_redis(self.schema_conv_output_option.host, self.schema_conv_output_option.username, self.schema_conv_output_option.password, self.schema_conv_output_option.dbname) mongoConnection = open_connection_mongodb(self.schema_conv_init_option) # TODO: Map nhe lai cai nay thanh check schema roi loop tren kia. for dataAndSchema in mongoConnection.list_collection_names(): data = dataAndSchema["data"] if dataAndSchema["schema"]["collection"] == "string": for item in data: redis.set(item["key"], item["value"]) elif dataAndSchema["schema"]["collection"] == "list": for item in data: redis.rpush(item["key"], *item["value"]) elif dataAndSchema["schema"]["collection"] == "set": for item in data: redis.sadd(item["key"], *item["value"]) elif dataAndSchema["schema"]["collection"] == "hash": for item in data: redis.hset(item["key"], mapping=item["value"]) elif dataAndSchema["schema"]["collection"] == "sortedSet": for item in data: redis.zadd(item["key"], item["value"]) else: for item in data: # TODO: bitmap hyperlog redis.set( dataAndSchema["schema"]["collection"] + "_" + item["key"], item["value"])
def handler(event, context): for record in event['Records']: if record['eventName'] == "REMOVE": continue print(record) playerName = record['dynamodb']['NewImage']['PlayerName']['S'] if 'OldImage' in record['dynamodb'].keys(): oldScore = int(record['dynamodb']['OldImage']['Score']['N']) oldWin = int(record['dynamodb']['OldImage']['Win']['N']) oldLose = int(record['dynamodb']['OldImage']['Lose']['N']) olddata = { "PlayerName" : str(playerName), "Win" : int(oldWin), "Lose" : int(oldLose)} old_json = json.dumps(olddata) redis.zrem('Rating', old_json) newScore = int(record['dynamodb']['NewImage']['Score']['N']) newWin = int(record['dynamodb']['NewImage']['Win']['N']) newLose = int(record['dynamodb']['NewImage']['Lose']['N']) newdata = { "PlayerName" : str(playerName), "Win" : int(newWin), "Lose" : int(newLose)} new_json = json.dumps(newdata) redis.zadd('Rating', new_json, newScore) return "OK"
def save(proxies): for proxy in proxies: redis.set(Proxy._get_redis_key(str(proxy)), json.dumps(proxy._proxy_info)) redis.sadd(Proxy._get_set_key(), str(proxy)) redis.zadd(Proxy._get_sorted_set_key(), {str(proxy): int(datetime.now().timestamp())})
def store_message(self, mailfrom, target, rcpttos, data): msg = email.message_from_string(data) headers = { "From": msg.get("From"), "To": msg.get("To"), "Subject": msg.get("Subject"), "Date": time.ctime(time.time()), } text_parts = [] html_parts = [] for part in msg.walk(): if part.get_content_type() == "text/plain": text_parts.append(part.get_payload()) elif part.get_content_type() == "text/html": html_parts.append(self.clean_html(part.get_payload())) simple_msg = {"headers": headers, "text_parts": text_parts, "html_parts": html_parts} simple_msg_json = json.dumps(simple_msg) timestamp = time.time() msgid = redis.get("msgid_counter") if msgid: msgid = redis.incr("msgid_counter") else: redis.set("msgid_counter", 1) msgid = 1 msgkey = "message:" + str(msgid) redis.set(msgkey, simple_msg_json) # storing the msg once redis.zadd("messages:" + target, msgkey, timestamp) # all messages to me redis.zadd("messages_from:" + target + ":" + mailfrom, msgkey, timestamp) # all messages from you to me
def execute_later(redis, queue, name, args, delay=0): identifier = str(uuid.uuid4()) item = json.dumps([identifier, queue, name, args]) if delay > 0: redis.zadd('delayed:queue:', {item: time.time() + delay}) else: redis.rpush('queue:' + queue, item) return identifier
def set_score_participant(hash_position: str) -> None: """ Cria o score do participante com um valor inicial de 0. Parameters: hash_position: número do usuário. """ redis.zadd(SCORES, {SCORE + hash_position: 0})
def update_elo(self, p_a, p_b, score_a, score_b): Ra = redis.zscore('elo', p_a) or START_ELO Rb = redis.zscore('elo', p_b) or START_ELO Ea = 1.0 / (1 + 10.0**((Rb - Ra) / 400.0)) Eb = 1.0 / (1 + 10.0**((Ra - Rb) / 400.0)) Ra_new = Ra + 10 * (score_a - Ea) Rb_new = Rb + 10 * (score_b - Eb) redis.zadd('elo', {p_a: Ra_new}) redis.zadd('elo', {p_b: Rb_new}) return Ra_new, Rb_new, Ra_new - Ra
def load_initial_sites(redis): fname = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data/other_sites.json") f = open(fname, 'r') parsed_json = json.load(f) sites = parsed_json['sites'] scores = [int(time()) for i in range(len(sites))] zipped = zip(scores, sites) zset_args = [item for sublist in zipped for item in sublist] redis.zadd(redis_keys.URLS_TO_PROCESS_SET, *zset_args)
def zadd_test(self, num=1000, pipe=False) : key = 'zadd-test-0' value = 'f382460a7c7c3597ef34b139ecda7e59' redis = self.get_redis() if pipe == False: for i in range(0, num): redis.zadd(key, i, value + str(i)) else : pipe = redis.pipeline() for i in range(0, num): pipe.zadd(key, i, value + str(i)) pipe.execute()
def load_initial_sites(redis): fname = os.path.join( os.path.dirname(os.path.abspath(__file__)), "data/other_sites.json") f = open(fname, 'r') parsed_json = json.load(f) sites = parsed_json['sites'] scores = [int(time()) for i in range(len(sites))] zipped = zip(scores, sites) zset_args = [item for sublist in zipped for item in sublist] redis.zadd(redis_keys.URLS_TO_PROCESS_SET, *zset_args)
def join(self, player): if player.table == self: return # Already part of this table. if player.table is not None: player.table.leave(player) # Player has to leave old table msg = Message('JOINED') # Tell all the other players msg.player_name = player.name # that a new player has joined. self.send(msg) player.table = self # Register the new player with self.players.append(player) # this table. # Get a list of all the other players on this table others = redis.zrange(self.players_key, 0, -1) # Check if the player exists (race condition I guess) score = redis.zscore(self.players_key, player.name) if score is None: # Add new player to the player list redis.zadd(self.players_key, player.name, 0) # Add player to the turn list if he/she wasn't already there redis.zadd(self.turns_key, player.name, time.time()) # Prepare joined messages for all existing players msgs = [] for other in others: if other == player.name: continue msg = Message('JOINED') msg.player_name = other msgs.append(msg) # Prepare passed message to set correct turn current = self._get_artist() msg = Message('PASSED', player_name=current) if player.name == current: msg.word = redis.get(self.word_key) end_time = time.time() + 120 if not redis.setnx(self.end_key, end_time): # Clock's already started! end_time = redis.get(self.end_key) else: end_time = redis.get(self.end_key) assert(end_time is not None) msg.end_time = end_time msgs.append(msg) # Send all the prepared messages gevent.joinall([gevent.spawn(player.send, x) for x in msgs])
def join(self, player): if player.table == self: return # Already part of this table. if player.table is not None: player.table.leave(player) # Player has to leave old table msg = Message('JOINED') # Tell all the other players msg.player_name = player.name # that a new player has joined. self.send(msg) player.table = self # Register the new player with self.players.append(player) # this table. # Get a list of all the other players on this table others = redis.zrange(self.players_key, 0, -1) # Check if the player exists (race condition I guess) score = redis.zscore(self.players_key, player.name) if score is None: # Add new player to the player list redis.zadd(self.players_key, player.name, 0) # Add player to the turn list if he/she wasn't already there redis.zadd(self.turns_key, player.name, time.time()) # Prepare joined messages for all existing players msgs = [] for other in others: if other == player.name: continue msg = Message('JOINED') msg.player_name = other msgs.append(msg) # Prepare passed message to set correct turn current = self._get_artist() msg = Message('PASSED', player_name=current) if player.name == current: msg.word = redis.get(self.word_key) end_time = time.time() + 120 if not redis.setnx(self.end_key, end_time): # Clock's already started! end_time = redis.get(self.end_key) else: end_time = redis.get(self.end_key) assert (end_time is not None) msg.end_time = end_time msgs.append(msg) # Send all the prepared messages gevent.joinall([gevent.spawn(player.send, x) for x in msgs])
def __init__(self, stream, address): self._stream = stream self._address = address self._message = [] self._stream.set_close_callback(self.on_close) self.uuid = str(uuid.uuid4()) #self.uuid= str(451377) obj = ConnectionObj() obj.stream = self._stream obj.time = int(time.time()) obj.uuid = self.uuid Connection.clients[self.uuid] = obj redis.zadd('hs:user:session' + ":" + server_id, self.uuid, int(time.time())) ''' all_uuids= [] for id, client in Connection.clients.items(): all_uuids.append({"uuid":id}) for id, client in Connection.clients.items(): if id== self.uuid: encoded_data = {"uuid":self.uuid, "service": "main", "method": "signUpSucceeded", "params":{"all_user": all_uuids}} else: continue encoded_data = {"uuid":self.uuid, "service": "main", "method": "joinNewPlayer", "params":{"user": {'uuid':self.uuid}}} print encoded_data reqt= request(encoded_data) res= reqt.dump() client.stream.write_to_fd(res) ''' encoded_data = { "uuid": self.uuid, "service": "main", "method": "signUpSucceeded", "params": {} } reqt = request(encoded_data) res = reqt.dump() self._stream.write_to_fd(res) self.read_message() print "A new user has entered.", address, self.uuid
def company_event_changes(): rethink_conn = yield r.connect(**rethink_conn.conn()) feed = yield r.table('company_events').changes().run(rethink_conn) while (yield feed.fetch_next()): change = yield feed.next() # get domain of company qry = {"domain":change["new_val"]["domain"]} users = r.table("user_contacts").filter(qry).run(conn) max_number_of_elements = 100 val = change["new_val"] for user in users: key = "user:#{id}".format(user) #redis.zadd(key, score, new_content.id) redis.zadd(key, val["timestamp"], val["id"]) redis.zremrangebyrank(key, max_number_of_elements, -1)
def inital(): """ inital project data to redis :return: """ for path in get_files(settings.PROJECT_DIR, ".md"): # 文件创建时间 # 有序结合保存所有文档,查看所有文章时,可以按照时间顺序查看 create_time = os.path.getctime(path) redis.zadd('admin.blog.list', create_time, utils.encrypt(path)) # 把文件的上级目录当作标签 #有序set存放该标签下的文章,相当于文章按标签分类,用有序集合的原因是可以按时间顺序显示 tag_name = os.path.basename(os.path.dirname(path)) redis.zadd('blog.tag.%s' % tag_name, create_time, utils.encrypt(path)) #set集合存放所有标签 redis.sadd('blog.tag', tag_name)
def article_switch_vote(redis, user, from_article, to_article): # HOMEWORK 2 Part I from_article_id = from_article.split(':')[-1] to_article_id = to_article.split(':')[-1] redis.srem('voted:' + from_article_id, user) redis.sadd('voted:' + to_article_id, user) # or redis.smove('voted:' + from_article_id, 'voted:' + to_article_id, user) from_article_score = redis.zscore('score:', 'article:' + from_article_id) changed_from_article_score = from_article_score - 432 to_article_score = redis.zscore('score:', 'article:' + to_article_id) changed_to_article_score = to_article_score + 432 redis.zrem('score:', 'article:' + from_article_id) redis.zadd('score:', changed_from_article_score, 'article:' + from_article_id) redis.zrem('score:', 'article:' + to_article_id) redis.zadd('score:', changed_to_article_score, 'article:' + to_article_id)
def publish_article(redis, user, title, link): user_id = user.split(':')[-1] article_id = str(int(redis.zrange("nArticles", 0, 0)[0]) + 1) redis.hset("article:" + article_id, "title", title) redis.hset("article:" + article_id, "upvotes", 1) redis.hset("article:" + article_id, "user", user_id) redis.hset("article:" + article_id, "link", link) redis.hset("article:" + article_id, "time", time.time()) redis.hset("article:" + article_id, "comments", 0) redis.hincrby(name=user, key="submissions", amount=1) redis.hincrby(name=user, key="karma", amount=1) redis.sadd("uSubmissions:" + user_id, article_id) redis.zadd("tArticles", 1, article_id) redis.zadd("nArticles", time.time(), article_id) return article_id
def sorted_sets_redis(): import redis redis = redis.Redis(host='127.0.0.1', port=6379, db=0, charset="utf-8", decode_responses=True) print("-------------") print("SORTED_SETS") print("-------------") #zadd(name,mapping) zrangebyscore(name, min, max) redis.zadd("country.user", {392832938: 0, 34340923233: 1}) print(redis.zrangebyscore("country.user", 0, 1)) #delete all keys for key in redis.scan_iter("prefix:*"): redis.delete(key) #clean data redis.flushdb
def add_domains(): try: assert request.data, "there is no data" json = request.get_json() assert isinstance(json, dict), "Data is not a dict" assert "links" in json, "Trere is no field 'links' in data" assert isinstance(json["links"], list), "'links' is not a list" assert json["links"] != [], "'links' list is empty" assert list_isinstance(json["links"], str), ("'links' contain non-string values") domains = [check_valid_domain(link) for link in json["links"]] except Exception as e: return {"status": str(e)}, 400 try: assert is_db_connected, "no connection to redis db" timestamp = int(datetime.now(tz=timezone.utc).timestamp()) domains = dict(zip(domains, [timestamp] * len(domains))) redis.zadd("visited_links", domains) except Exception as e: return {"status": str(e)}, 500 return {"status": "ok"}
def _pass_turn(self, player_name, guesser=None, score=None): # Get the next player next_player = redis.zrange(self.turns_key, 1, 1) # Are we playing with ourself? if next_player: next_player = next_player[0] else: next_player = player_name # Set the new word word = redis.set(self.word_key, get_next_word().text) # Clear the skip key redis.delete(self.skip_key) # Tell everyone who's turn it is msg = Message('PASSED', player_name=next_player) msg.end_time = time.time() + 120 redis.set(self.end_key, msg.end_time) if score is not None: msg.guesser = guesser msg.score = score self.send(msg) # Ten points to win the game if score >= 10: # Send the won message self.send(Message('WON', player_name=guesser)) # Clear all scores players = redis.zrange(self.players_key, 0, -1) scores = dict((x, 0) for x in players) redis.zadd(self.players_key, **scores) # Move the old player to the end of the turn list redis.zadd(self.turns_key, player_name, time.time())
def fetch_pending_message(redis, recipient): """ 获取消息 :param redis: :param recipient: :return: """ key_user_seen = CHAT_USER_SEEN.format(user=recipient) # 获取最后接收到的消息ID seen = redis.zrange(key_user_seen, 0, -1, withscores=True) p = redis.pipeline() for chat_id, seen_id in seen: key_chat_message = CHAT_MESSAGE.format(chat_id=chat_id) p.zrangebyscore(key_chat_message, seen_id + 1, 'inf') chat_info = zip(seen, p.execute()) for i, ((chat_id, seen_id), messages) in enumerate(chat_info): if not messages: continue key_chat_group = CHAT_GRUOP.format(chat_id=chat_id) messages[:] = map(json.loads, messages) # 使用最新收到的消息来更新群组有序集合。 seen_id = messages[-1]['id'] redis.zadd(key_chat_group, {recipient: seen_id}) # 找出那些所有人都已经阅读过的消息 min_id = redis.zrange(key_chat_group, 0, 0, withscores=True) # 更新已读消息有序集合 p.zadd(key_user_seen, {chat_id: seen_id}) if min_id: key_chat_message = CHAT_MESSAGE.format(chat_id=chat_id) # 清除那些已经被所有人阅读过的消息 p.zremrangebyscore(key_chat_message, 0, min_id[0][1]) chat_info[i] = (chat_id, messages) p.execute() return chat_info
def post(self): redis = datastore.get_datastore() # get a dict from the response activity = request.get_json(force=True) position = int(redis.get('activityindex')) redis.incr('activityindex', 1) activity['id'] = str(position) akey = "activity:" + str(activity['id']) redis.hset('activitieshash', akey, pickle.dumps(activity)) redis.zadd('sortet-activities:all', position, akey) if (activity['state'] == "FINISHED"): redis.zadd('sortet-activities:finished', position, akey) else: redis.zadd('sortet-activities:notfinished', position, akey) return activity, 201
print(arguments.set, "set to", arguments.value, "for", arguments.expire, "seconds") else: redis.set(arguments.set, arguments.value) print(str(arguments.set), ":", str(arguments.value)) else: print("value not given for the key :", arguments.set) # for adding to a orered set --------------------------------------------- if arguments.zadd: if arguments.key: if arguments.score: if arguments.member: # redis.zadd("key",{"value":score}) syntax of zadd for newer update of redis----------------- redis.zadd(arguments.key, {arguments.member: arguments.score}) print("zadd", arguments.key, arguments.score, arguments.member) else: print("provide member for zadd") else: print("provide score for zadd") else: print("provide the key for zadd") if arguments.zrange: if arguments.key: data = redis.zrange(arguments.key, 0, -1) print(data[:]) else: print("provide the key for zrange")
def addSynonymsToRedis(word, syns): for syn in syns: redis.zadd(word, syn[1], syn[0])
def index_add(id, score): redis.zadd('index', id, score)
def delay(msg): msg.id = str(uuid.uuid4()) value = json.dumps(msg) retry_ts = time.time() + 5 redis.zadd("delay-queue", msg_id, value)
#https://developer.redis.com/develop/python/ import redis redis = redis.Redis(host='localhost', port='6379') redis.set('mykey', 'Hello from Python!') value = redis.get('mykey') print(value) redis.zadd('vehicles', {'car': 0}) redis.zadd('vehicles', {'bike': 0}) vehicles = redis.zrange('vehicles', 0, -1) print(vehicles)
redis.sadd(albums_key, album_key) for tune in tunes: album, title, artist = tune.id3gw.get_album(), tune.id3gw.get_title(), tune.id3gw.get_artist() if not album or not title or not artist: continue # @todo log {{path}}... tune_key = RdsTune.get_key(album, title, artist) tune_id3_key = RdsTune.get_id3_key(tune_key) tune_audio_key = RdsTune.get_audio_key(tune_key) for key, value in tune.get_id3().iteritems(): redis.hset(tune_id3_key, key, value) redis.zadd(album_tunes_key, tune_key, tune.id3gw.get_trackn()) redis.sadd(tunes_key, tune_key) # track and add all tunes for image in images: if image.get_type() is image.get_undefined_type(): continue i = { "type": image.get_type(), "dimx": image.get_dimx(), "dimy": image.get_dimx(), "filenameid": image.get_filename_id((album_id3["artist"], album_id3["album"]), image.get_type()), } image_key = RdsImage.get_key(artist, album, image.get_type())
def refresh_fair_semaphore(redis, semname, identifier): semname = "semaphore:" + semname if redis.zadd(semname, {identifier: time.time()}): release_fair_semaphore(redis, semname, identifier) return False return True
import redis redis = redis.Redis() redis.flushall() FEM = "female_names_set" with open("female-names.txt", "r") as f: for line in f: redis.zadd(FEM, {line.rstrip(): 0}) print("Finished loading the names") print(redis.zrange(FEM, 4500, 4510)) print("Searching that start with susann") for tup in redis.zscan_iter(FEM, "susann*"): print(tup[0], end=',') print() while True: name = input("Search for ('Enter' for quit): ") if name == "": break for tup in redis.zscan_iter(FEM, name + "*"): print(tup[0]) ## b) redis.flushall() with open("nomes-registados-2018.csv", "r") as f: for line in f: name, gender, num = line.rstrip().split(",") redis.zadd(FEM, {name: num})
redis.sadd("aComments:2", "1", "2") #USER COMMENTS redis.sadd("uComments:1", "21") redis.sadd("uComments:2", "11") redis.sadd("uComments:3", "12", "22") #USER SUBMISSIONS redis.sadd("uSubmissions:1", "1") redis.sadd("uSubmissions:2", "2") #TOP ARTICLES redis.zadd("tArticles", 1234, "1") redis.zadd("tArticles", 4321, "2") #NEW ARTICLES redis.zadd("nArticles", time.time() - 333333, "1") redis.zadd("nArticles", time.time() - 4444444, "2") #COUNTER redis.hset("counter", "user", 3) redis.hset("counter", "comments", 4) redis.hset("counter", "articles", 2) #create new user new_user(redis, 'niki') #user publishes article
def delay(msg): # uuid.uuid4() - Generate a random UUID msg.id = str(uuid.uuid4()) # 保证value值唯一 value = json.dumps(msg) retry_ts = time.time() + 5 # 5秒重试 redis.zadd("delay-queue", retry_ts, value)