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
