def check_pm(m): if m.chat.type == 'supergroup': redis.sadd(m.content_type, m.message_id) if redis.sismember('groups', m.chat.id): if not redis.get('expire' + str(m.chat.id)): bot.reply_to(m, '🔴 اعتبار گروه به پایان رسیده است 🔴') redis.srem('groups', m.chat.id) bot.leave_chat(m.chat.id) else: check(m) if m.chat.type == 'private': if m.reply_to_message.forward_from: if is_sudo(m.from_user.id): id = m.reply_to_message.forward_from.id if m.text == 'مسدود': redis.set('ban' + str(id), True) bot.reply_to( m, 'این کاربر دیگر قادر به استفاده از پیوی ربات نیست ❌') elif m.text: bot.send_message(id, m.text) bot.reply_to(m, 'رفت براش') elif m.sticker: bot.send_sticker(id, m.sticker.file_id) bot.reply_to(m, 'رفت براش') elif m.photo: bot.send_photo(id, m.photo[-1].file_id) bot.reply_to(m, 'رفت براش')
def redis_del(self, proxy): if type(proxy) is not str: proxy = str(proxy) try: redis.srem('proxy', proxy) except: pass
def remove_worker(self, client_id): """ Remove the id """ app.logger.debug("Removing client: {}".format(client_id)) redis.srem(XROOTD_CLIENT, client_id) redis.expire(client_id, 30) del self.clients[client_id]
def remove_server(self, server_id): """ Remove the id """ app.logger.debug("Removing server: {}".format(server_id)) redis.srem(XROOTD_SERVER, server_id) redis.expire(server_id, 30) del self.servers[server_id]
def listen_domain(self, storage_handler, domain, listen_myself = False): try: self._domain_handlers[domain].add(storage_handler) except KeyError: self._domain_handlers[domain] = set([storage_handler]) redis = self._get_redis(domain) redis.sadd('#' + domain, self._data_to_string((self._myself.serialize(), listen_myself))) if not listen_myself: redis.srem('#' + domain, self._data_to_string((self._myself.serialize(), True)))
def toall(m): if str(m.from_user.id) == is_sudo: text = m.text.replace('/toall','') rd = redis.smembers('startmebot') for id in rd: try: bot.send_message(id, "{}".format(text), parse_mode="Markdown") except: redis.srem('startmebot',id)
def clac(m): if m.from_user.id == 317409865 : text = m.text.replace("/bc ","") rd = redis.smembers('alls') for id in rd: try: bot.send_message(id, "{}".format(text), parse_mode="Markdown") except: redis.srem('alls', id)
def clearSet(tableName): set = redis.smembers(tableName) print('==>list type:{},list:{}'.format(type(list), list)) print(len(set)) for ele in set: redis.srem(tableName, ele)
def fwdall(m): if m.from_user.id == 317409865 : if m.reply_to_message: mid = m.reply_to_message.message_id ids = redis.smembers('alls') for id in ids : try: bot.forward_message(id,m.chat.id,mid) except: redis.srem('alls',id)
def check_pm(m): if m.chat.type == 'supergroup': redis.sadd(m.content_type, m.message_id) if redis.sismember('groups', m.chat.id): if not redis.get('expire' + str(m.chat.id)): bot.reply_to(m, '🔴 اعتبار گروه به پایان رسیده است 🔴') redis.srem('groups', m.chat.id) bot.leave_chat(m.chat.id) else: check(m)
def listen_key(self, storage_handler, key, domain = 'default', listen_myself = False): name = self._make_name(key, domain) try: self._key_handlers[name].add(storage_handler) except KeyError: self._key_handlers[name] = set([storage_handler]) redis = self._get_redis(name) redis.sadd('@' + name, self._data_to_string((self._myself.serialize(), listen_myself))) if not listen_myself: redis.srem('@' + name, self._data_to_string((self._myself.serialize(), True)))
def remove_member(number, sourceId): if redis.scard(number) == 1: redis.srem(number, sourceId) redis.delete(number + '_member') else: redis.srem(number, sourceId) redis.hset(sourceId, 'current', '-') redis.hset(sourceId, 'voted', 'N') redis.hdel(sourceId, 'status')
def get_file(self, fid, stop_event, driver=None, restart=False): """Transfers a file from a Driver to another. """ redis = self.plug.redis metadata = Metadata.get_by_id(self.plug, fid) filename = metadata.filename transfer_key = 'drivers:{}:transfers:{}'.format(self.plug.name, fid) if driver: redis.sadd('drivers:{}:transfers'.format(self.plug.name), fid) redis.hmset(transfer_key, {'from': driver, 'offset': 0}) offset = 0 self.logger.info("Starting to get '{}' from {}", filename, driver) else: transfer = redis.hgetall(transfer_key) driver = transfer['from'] offset = int(transfer['offset']) self.logger.info("Restarting transfer of '{}' from {}", filename, driver) dealer = self.context.socket(zmq.DEALER) port = redis.get('drivers:{}:router'.format(driver)) dealer.connect('tcp://localhost:{}'.format(port)) end = metadata.size chunk_size = self.plug.options.get('chunk_size', 1 * 1024 * 1024) if not restart: self._call('start_upload', metadata) while offset < end: if stop_event.is_set(): # another transaction for the same file has # probably started self.logger.info("Aborting transfer of '{}' from {}", filename, driver) return dealer.send_multipart((filename, str(offset), str(chunk_size))) chunk = dealer.recv() self.logger.debug("Received chunk of size {} from {} for '{}'", len(chunk), driver, filename) self._call('upload_chunk', filename, offset, chunk) offset = redis.hincrby(transfer_key, 'offset', len(chunk)) self._call('end_upload', metadata) redis.delete(transfer_key) redis.srem('drivers:{}:transfers'.format(self.plug.name), fid) self.logger.info("Transfer of '{}' from {} successful", filename, driver)
def flush_dead_mappers(redis, mappers_key, ping_key): mappers = redis.smembers(mappers_key) for mapper in mappers: last_ping = redis.get(ping_key % mapper) if last_ping: now = datetime.now() last_ping = datetime.strptime(last_ping, DATETIME_FORMAT) if ((now - last_ping).seconds > TIMEOUT): logging.warning('MAPPER %s found to be inactive after %d seconds of not pinging back' % (mapper, TIMEOUT)) redis.srem(mappers_key, mapper) redis.delete(ping_key % mapper)
def flush_dead_mappers(redis, mappers_key, ping_key): mappers = redis.smembers(mappers_key) for mapper in mappers: last_ping = redis.get(ping_key % mapper) if last_ping: now = datetime.now() last_ping = datetime.strptime(last_ping, DATETIME_FORMAT) if ((now - last_ping).seconds > TIMEOUT): logging.warning( 'MAPPER %s found to be inactive after %d seconds of not pinging back' % (mapper, TIMEOUT)) redis.srem(mappers_key, mapper) redis.delete(ping_key % mapper)
def m(m): try: if (m.from_user.id) == admin: if m.text == "/stats": ms = redis.scard('mbrs_bot') bot.send_message(m.chat.id, '👥Members : <code>{}</code>'.format(ms),parse_mode='HTML') if re.match("^(/ban) (.*)", m.text): mn = re.match("^(/ban) (.*)", m.text) redis.sadd("bans", mn.group(2)) bot.send_message(m.chat.id, "🤖کاربر {} از ربات مسدود شد.".format(mn.group(2))) bot.send_message(mn.group(2), "🔰شما در این ربات مسدود شدید.") if re.match("^(/unban) (.*)", m.text): mn = re.match("^(/unban) (.*)", m.text) redis.srem('bans',mn.group(2)) bot.send_message(m.chat.id, "🤖کاربر {} ازاد شد.".format(mn.group(2))) bot.send_message(mn.group(2), "🔰شما از مسدودیت در این ربات ازاد شدید.") except Exception as e: print e
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 do_clearContainBrocast(): """ 重启时清除维护广播 """ system_contain_bro = redis.lrange(HALL_BRO_CONTAIN_ALL_LIST%(0),0,-1) fish_system_bro = redis.lrange(FISH_BRO_CONTAIN_ALL_LIST%(0),0,-1) agent_contain_bro = redis.lrange(HALL_BRO_CONTAIN_ALL_LIST%(2),0,-1) play_set = redis.smembers(HALL_BRO_PLAY_SET) if not system_contain_bro: system_contain_bro = [] if not agent_contain_bro: agent_contain_bro = [] system_contain_bro,agent_contain_bro,fish_system_bro = list(system_contain_bro),list(agent_contain_bro),list(fish_system_bro) system_contain_bro.extend(agent_contain_bro) system_contain_bro.extend(fish_system_bro) for bro in system_contain_bro: if bro in play_set: redis.srem(HALL_BRO_PLAY_SET,bro) print '[try do_clearContainBrocast] broadId[%s] is remove..'%(bro)
def article_switch_vote(redis, user, from_article, to_article): cutoff = datetime.datetime.now() - datetime.timedelta( seconds=ONE_WEEK_IN_SECONDS) to_ = (not datetime.datetime.fromtimestamp( redis.zscore('time:', to_article)) < cutoff) from_ = (not datetime.datetime.fromtimestamp( redis.zscore('time:', from_article)) < cutoff) #if both articles are within the cutoff if to_ and from_: vrem = 'voted:' + from_article.split(':')[-1] vadd = 'voted:' + to_article.split(':')[-1] #verify user voting status on articles if redis.sismember(vrem, user) and not redis.sismember(vadd, user): #remove vote from from_article redis.srem(vrem, user) redis.zincrby(name='score:', value=from_article, amount=-1 * VOTE_SCORE) redis.hincrby(name=from_article, key='votes', amount=-1) #add vote to to_article redis.sadd(vadd, user) redis.zincrby(name='score:', value=to_article, amount=VOTE_SCORE) redis.hincrby(name=to_article, key='votes', amount=1)
def update_ip(): try: redis = RedisConnect("192.168.200.116", 6379, 4, "mypasshahayou") count = redis.getScard("ipPool") if not count: Ips = getIp(10000) for i in Ips: print "------Is insert ip :%s---------" % i redis.setSadd("ipPool", i) if redis.getScard("ipPool") >= 1000: break else: ipList = redis.getSrandmember("ipPool", 80) for i in ipList: test = "curl --connect-timeout 3 -o /dev/null -s -w %{http_code} -x " + i + " http://www.hc360.com/" print test output = os.popen(test) num = output.read() print num, "----" if int(num) != 200: print "xxxxxxxxxxIs delete ip :%sxxxxxxxxxxx" % i redis.srem("ipPool", i) Ipss = getIp(10000) m = 0 while m < len(Ipss): print redis.getScard("ipPool") print "------Is update ip :%s---------" % Ipss[m] redis.setSadd("ipPool", Ipss[m]) m += 1 print "--------------------------Update Ip Success----------------------------" print "---------------------------Wait for the update, the next update will be in 60 seconds after the----------------------------------------------" except Exception, e: redis = RedisConnect("192.168.200.116", 6379, 4, "mypasshahayou") count = redis.getScard("ipPool") print e
def reset_subscriptions (chat_id): users = redis.srem("optimusprice.subscriptions.users", str(chat_id)) redis.delete("optimusprice.subscriptions." + str(chat_id)) fsm_reset(chat_id)
def delete_slug(slug): redis.srem('slugs_set', slug)
def remove_key(cls, api_key, redis): redis.srem(_key('a'), api_key)
def get_file(self, fid, stop_event, driver=None, restart=False): """Transfers a file from a Driver to another. """ redis = self.plug.redis metadata = Metadata.get_by_id(self.plug, fid) filename = metadata.filename transfer_key = 'drivers:{}:transfers:{}'.format(self.plug.name, fid) if driver: redis.sadd( 'drivers:{}:transfers'.format(self.plug.name), fid ) redis.hmset(transfer_key, {'from': driver, 'offset': 0}) offset = 0 self.logger.info("Starting to get '{}' from {}", filename, driver) else: transfer = redis.hgetall(transfer_key) driver = transfer['from'] offset = int(transfer['offset']) self.logger.info( "Restarting transfer of '{}' from {}", filename, driver ) dealer = self.context.socket(zmq.DEALER) port = redis.get('drivers:{}:router'.format(driver)) dealer.connect('tcp://localhost:{}'.format(port)) end = metadata.size chunk_size = self.plug.options.get('chunk_size', 1 * 1024 * 1024) if not restart: self._call('start_upload', metadata) while offset < end: if stop_event.is_set(): # another transaction for the same file has # probably started self.logger.info( "Aborting transfer of '{}' from {}", filename, driver ) return dealer.send_multipart((filename, str(offset), str(chunk_size))) chunk = dealer.recv() self.logger.debug( "Received chunk of size {} from {} for '{}'", len(chunk), driver, filename ) self._call('upload_chunk', filename, offset, chunk) offset = redis.hincrby(transfer_key, 'offset', len(chunk)) self._call('end_upload', metadata) redis.delete(transfer_key) redis.srem( 'drivers:{}:transfers'.format(self.plug.name), fid ) self.logger.info( "Transfer of '{}' from {} successful", filename, driver )
def srem(self, key, value): redis = self._get_redis(key) return redis.srem(key, value)
# del object # del <sha1sum>:data # del <sha1sum>:tags # go through tags and delete image from each tag set # add.py filename.jpg tag1 tag2 tag3 # TODO: delete by filename (find hash from redis) if len(sys.argv) < 2: print("usage: del.py <hash>") sys.exit(0) sha = sys.argv[1] # TODO: Option(?) to delete file from source # Delete object data redis.delete("%s:data" % sha) # Delete object tags redis.delete("%s:tags" % sha) # Tags tags = redis.keys("tag:*") # Remove object from all tags for tag in tags: redis.srem(tag, sha) redis.close()
print '[%s][try Brocast] borads[%s] is boradding....'%(datetime.strftime(nowDate,"%Y-%m-%d %H:%M:%S"),borad) broad_table = HALL_BRO_TABLE%(borad) boradInfo = redis.hgetall(broad_table) start_date = datetime.strptime(boradInfo['start_date'],'%Y-%m-%d %H:%M') end_date = None if boradInfo['end_date']: end_date = datetime.strptime(boradInfo['end_date'],'%Y-%m-%d %H:%M') if start_date > nowDate:#未到开始时间 continue if end_date and end_date<=nowDate: #播放时间已结束 if borad not in out_set: redis.hset(broad_table,'status',2) redis.srem(HALL_BRO_PLAY_SET,borad) redis.sadd(HALL_BRO_OUT_SET,borad) print '[%s] broadId[%s] is endding.'%(datetime.strftime(nowDate,"%Y-%m-%d %H:%M:%S"),borad) continue if start_date <= nowDate: if borad not in play_set: redis.hset(broad_table,'status',1) redis.sadd(HALL_BRO_PLAY_SET,borad) print '[%s] broadId[%s] is ready broading.'%(datetime.strftime(nowDate,"%Y-%m-%d %H:%M:%S"),borad) continue elapseTime = time.time() - nowTime sleepTime = max(SLEEP_SECS - elapseTime,0) time.sleep(sleepTime)
redis = redis.StrictRedis.from_url(redis_url, decode_responses=True) except Exception as e: print('Failed while connecting to redis at 127.0.0.1:16739: {}'.format(e)) exit(1) if sys.argv[1] == 'unregister_pipeline': if len(sys.argv) < 3: print( 'Invalid arguments - expect pipeline:xxx after unregister_pipeline' ) exit(1) pipeline_id = sys.argv[2] redis.delete(pipeline_id) redis.srem('pipelines', pipeline_id) redis.publish(pipeline_channel, pipeline_id) print('Unregistered pipeline with ID {}'.format(pipeline_id)) exit(0) elif sys.argv[1] == 'get_settings': if len(sys.argv) < 3: print('Invalid arguments') exit(1) job_id = sys.argv[2] data = redis.hgetall(job_id) print('Data for job ident {}:'.format(job_id)) print('{}'.format( json.dumps(data, sort_keys=True, indent=4, separators=(',', ': '))))
def delete(proxy_ids): for id in proxy_ids: redis.delete(Proxy._get_redis_key(id)) redis.srem(Proxy._get_set_key(), id) redis.zrem(Proxy._get_sorted_set_key(), id)
redis=RedisConnect("192.168.200.116",6379,4,"mypasshahayou") >>>>>>> 7235bd3b1c4452496ce81c35a74b003805fe6394 count=redis.getScard("ipPool") while True: if not count: Ips=getIp(10000) for i in Ips: print "------Is insert ip :%s---------"%i redis.setSadd("ipPool",i) if redis.getScard("ipPool")>=1000: break else: ipList=redis.getSrandmember("ipPool",500) for i in ipList: print "xxxxxxxxxxIs delete ip :%sxxxxxxxxxxx"%i redis.srem("ipPool",i) Ipss=getIp(10000) m=0 while redis.getScard("ipPool") <1000: print redis.getScard("ipPool") print "------Is update ip :%s---------"%Ipss[m] redis.setSadd("ipPool",Ipss[m]) m+=1 print "--------------------------Update Ip Success----------------------------" print "---------------------------Wait for the update, the next update will be in 60 seconds after the----------------------------------------------" time.sleep(60) except Exception,e: <<<<<<< HEAD <<<<<<< HEAD redis=RedisConnect("192.168.1.100",6379,0,"")
def _sremove(self, key, value, domain): name = self._make_name(key, domain) redis = self._get_redis(name) ret = redis.srem(name, self._data_to_string(value)) self._notify(key, value, domain, self.SREMOVE) return ret