Python StrictRedis.smembers方法代码示例

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

    def __init__(self):
        self.r = StrictRedis(unix_socket_path=redis_socket)

    def search(self, authkey, values=None, hash_values=None, return_eid=False, quiet=False):
        if isinstance(values, list):
            hash_values = [SHA256.new(v.lower()).hexdigest() for v in values]
        elif values:
            hash_values = [SHA256.new(values.lower()).hexdigest()]
        elif not isinstance(hash_values, list):
            hash_values = [hash_values]

        if not hash_values:
            raise Exception('No value to search.')

        org = self.__get_org_by_auth(authkey)
        if not org:
            raise Exception('Invalid authkey')

        if quiet:
            return [(self.r.exists(h) or self.r.exists(org + ':' + h)) for h in hash_values]
        uuid_by_hashes = [self.r.smembers(h).union(self.r.smembers(org + ':' + h)) for h in hash_values]
        if not return_eid:
            to_return = uuid_by_hashes
        else:
            to_return = []
            for h in uuid_by_hashes:
                to_return.append([self.r.hget('uuid_id', uuid) for uuid in h])
        return to_return

    def __get_org_by_auth(self, authkey):
        return self.r.get(authkey)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class Redis(BaseDB):
    def __init__(self, host='localhost', port=6379, db=0):
        super().__init__()
        self.db = StrictRedis(host=host, port=port, db=db)
        self.available = False

    def push_to_available(self, user_id):
        self.db.sadd('available', user_id)  # Add user to awaiting queue
        self.check_available()

    def pop_first_available(self, self_user_id):
        while not self.available:
            threading.Event().wait()  # Prevent busy wait and CPU load

        res = [int(x) for x in self.db.smembers('available')]  # Get all available possible interlocutors
        shuffle(res)  # Randomize queue
        if self_user_id in res:  # User may be listed too
            res.remove(self_user_id)  # If so, remove him
        res = res.pop()  # Get random interlocutor
        self.check_available()
        return res

    def remove(self, user_id):
        self.db.srem('available', user_id)
        self.check_available()

    def check_available(self):
        self.available = True if self.db.scard('available') - 1 > 0 else False  # If there are more than 1 user in queue

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
def test_queue_adopt_producer_step():
    ("Queue#adopt_producer should take a step and know about its id and")

    # Given a dummy manager
    manager = Node()

    # Given a Queue with maximum size of 10
    queue = Queue("test-queue", maxsize=10)
    q1 = Queue("name1")
    q2 = Queue("name2")
    # And a running step (so it gains a thread id)
    step = DummyStep(q1, q2, manager)
    step.start()

    # When that queue adopts the step as a producer
    consumers, producers = queue.adopt_producer(step)

    # And the redis key should contain the step id
    hostname = socket.gethostname()
    pid = os.getpid()
    tid = step.ident
    value = "{hostname}|{pid}|{tid}|tests.functional.test_queue.DummyStep|lineup.framework.Node".format(**locals())

    redis = StrictRedis()
    members = redis.smembers("lineup:test-queue:producers")
    members.should.contain(value)
    queue.deactivate()
    q1.deactivate()
    q2.deactivate()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
def check_redis_host(host, port=6379):
    action("Check Redis on {}".format(host))
    action("...")
    try:
        r = StrictRedis(host, port)
        workers = r.smembers("zmon:metrics")
        ok()
        return r, workers
    except Exception as e:
        error(e)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class Storage(object):
    def __init__(self, host=None, port=None, *args, **kwargs):
        if host is None:
            host = os.environ.get('REDIS_HOST', 'localhost')
        if port is None:
            port = os.environ.get('REDIS_PORT', '6379')

        self.redis = StrictRedis(host, port, *args, **kwargs)

    def get_labels(self):
        return [x.decode('utf-8') for x in self.redis.smembers('labels')]

    def get_images(self, label):
        return self.redis.smembers(label)

    def get_repr_image_for_labels(self, labels):
        if not labels:
            return {}
        keys = [u'repr_img:{}'.format(label) for label in labels]
        return dict(zip(labels, self.redis.mget(*keys)))

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class ProxyCheckSpider(Spider):
    ''' Spider to crawl free proxy servers for intern
    '''
    name = 'proxy_check'
    
    def __init__(self, mode='prod', *args, **kwargs):
        if mode == 'prod':            
            LOCAL_CONFIG_YAML = './hq-proxies.yml'
        elif mode == 'test':
            LOCAL_CONFIG_YAML = './hq-proxies.test.yml'
        with open(LOCAL_CONFIG_YAML, 'r', encoding='utf-8') as f:
            LOCAL_CONFIG = yaml.load(f)
        
        self.redis_db = StrictRedis(
            host=LOCAL_CONFIG['REDIS_HOST'], 
            port=LOCAL_CONFIG['REDIS_PORT'], 
            password=LOCAL_CONFIG['REDIS_PASSWORD'],
            db=LOCAL_CONFIG['REDIS_DB']
        )
        
        self.validator_pool = set([])
        for validator in LOCAL_CONFIG['PROXY_VALIDATORS']:
            self.validator_pool.add((validator['url'], validator['startstring']))
        self.PROXY_COUNT = LOCAL_CONFIG['PROXY_COUNT']
        self.PROXY_SET = LOCAL_CONFIG['PROXY_SET']
        
    def start_requests(self):

        logger.info('测试代理池内代理质量...')
        self.redis_db.set(self.PROXY_COUNT, self.redis_db.scard(self.PROXY_SET))
        for proxy in self.redis_db.smembers(self.PROXY_SET):
            proxy = proxy.decode('utf-8')
            vaurl, vastart = random.choice(list(self.validator_pool))
            yield Request(url=vaurl, meta={'proxy': proxy, 'startstring': vastart}, callback=self.checkin, dont_filter=True)
    
    def checkin(self, response):
        res = response.body_as_unicode()
        if 'startstring' in response.meta and res.startswith(response.meta['startstring']):
            proxy = response.meta['proxy']
            self.redis_db.sadd(self.PROXY_SET, proxy)
            logger.info('可用代理+1  %s' % proxy)
            yield None
        else:
            proxy = response.url if 'proxy' not in response.meta else response.meta['proxy']
            self.redis_db.srem(self.PROXY_SET, proxy)
            logger.info('无效代理  %s' % proxy)
            yield None
    
    def closed(self, reason):
        pcount = self.redis_db.scard(self.PROXY_SET)
        logger.info('代理池测试完成，有效代理数: %s' % pcount)
        self.redis_db.set(self.PROXY_COUNT, pcount)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
def search(request):
    if request.get('value'):
        hash_value = SHA.new(request.get('value')).hexdigest()
    else:
        hash_value = request.get('hash_value')
    if hash_value is None:
        return json.dumps({})
    r = StrictRedis(unix_socket_path=redis_socket)
    known_uuids = r.smembers(hash_value)
    to_return = {'known': (len(known_uuids) != 0)}
    if not request.get('quiet'):
        to_return['uuids'] = known_uuids
    return to_return

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [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 smembers [as 别名]
class Persist(object):
    """ Sequential writer for Carbon server.
    The story is simple, fetch data from redis, write them, wait, loop.
    This code is supervised by Carbon daemon.
    """

    def __init__(self, path="/tmp/"):
        self.redis = Redis()
        self.path = path
        self.dirs = set()
        self.redis.sadd(METRICS, METRIC_POINTS, METRIC_WRITE)

    def metric(self, name, value):
        "Add some metrics : make your own dogfood, just before lunch."
        timestamp = time.time()
        serialized = struct.pack('!ff', timestamp, value)
        pipe = self.redis.pipeline()
        pipe.zadd(name, timestamp, serialized)
        pipe.publish(name, serialized)
        pipe.execute()

    def run(self):
        while True:
            before = time.time()
            self.handle()
            after = time.time()
            self.metric(METRIC_WRITE, (after - before) * 1000)
            time.sleep(PERIOD - int(before) + int(after))

    def handle(self):
        points = 0
        for metric in self.redis.smembers(METRICS):
            values = self.redis.zrange(metric, 0, -1)
            points += len(values)
            f = target_to_path(self.path, metric)
            d = os.path.dirname(f)
            if d not in self.dirs:
                if not os.path.isdir(d):
                    os.makedirs(d)
                self.dirs.add(d)
            if not os.path.exists(f):
                whisper.create(f, [(10, 1000)])  # [FIXME] hardcoded values
            whisper.update_many(f, [struct.unpack('!ff', a) for a in values])
            if len(values):
                self.redis.zrem(metric, *values)
        self.metric(METRIC_POINTS, points)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
def ginfo(request):
    print(str(request.user)+' requested groupinfo')
    rd = StrictRedis()
    pref = settings.MY_PREFIX
    groupinfo = []
    response = {}
    if rd.exists(pref+":groups"):
        # there is atleast 1 group already created
        groupnames = rd.smembers(pref+":groups")
        # groupnames is a set
        for groupname in groupnames:
            groupdict = rd.hgetall(pref+":"+groupname+":hash")
            groupinfo.append(groupdict)
            #print groupdict
        # time to serialize!
        response['group_list'] = groupinfo
    response.update( {"success":True, "group_count":len(groupinfo)})
    #print response
    return JsonResponse(response)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
def search_db(name):
    r = StrictRedis(host='localhost', port=6379, db=1)

    # Redisから取得
    artist_name_list = r.keys("*_" + name)

    if artist_name_list:
        for artist_name in artist_name_list:
            _id = artist_name.split("_")[:1][0]
            _name = "".join(artist_name.split("_")[1:])

            print u"ID:{} アーティスト名:{}".format(_id, _name)

            for tag in r.smembers(artist_name):
                tag_cnt = tag.split("_")[:1][0]
                tag_name = "".join(tag.split("_")[1:])
                print u"タグ:{} 被タグ数:{}".format(tag_name, tag_cnt)

    else:
        print u"データベースに存在しません"

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class MetricsExplorer(Explorer):
    def __init__(self, config: Configuration):
        super().__init__('RedisCassandra')
        redis_host = config.get('redis.host')
        redis_port = config.get('redis.port')
        redis_pass = config.get('redis.password')

        #TODO: change to Sentinel so we can handle multiple hosts
        self.redis_conn = StrictRedis(host=redis_host, port=redis_port, password=redis_pass)
        self.cache = get_cache()

    def get_template(self):
        return 'explorers/metrics.html'

    def get_table_data(self):
        ret = self.cache.get('_tname')

        if ret is not None:
            return ret

        tag_names = self.redis_conn.smembers('_tname')
        tag_names = [t.decode() for t in tag_names]

        pipeline = self.redis_conn.pipeline()  # setup a pipeline

        for tag_name in tag_names:
            # {'tag': name.decode()}
            pipeline.smembers('_t|%s'%tag_name)

        values = pipeline.execute()

        ret = []

        for i in range(len(tag_names)):
            ret.append({'tag': tag_names[i], 'values': [v.decode() for v in values[i]]})

        self.cache.set('_tname', ret)

        return ret

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class Redis(Backend):
    """Default backend for MimicDB. Initiated with identical parameters
    as ``redis.StrictRedis``.

    :param args \*args, \**kwargs: StrictRedis.__init__() parameters

    .. code-block:: python

        from mimicdb.backends.default import Redis

        redis = Redis(host='localhost', port=6379, db=0)
    """
    def __init__(self, *args, **kwargs):
        self._redis = StrictRedis(*args, **kwargs)

    def keys(self, pattern='*'):
        return self._redis.keys(pattern)

    def delete(self, *names):
        return self._redis.delete(*names)

    def sadd(self, name, *values):
        return self._redis.sadd(name, *values)

    def srem(self, name, *values):
        return self._redis.srem(name, *values)

    def sismember(self, name, value):
        return self._redis.sismember(name, value)

    def smembers(self, name):
        return self._redis.smembers(name)

    def hmset(self, name, mapping):
        return self._redis.hmset(name, mapping)

    def hgetall(self, name):
        return self._redis.hgetall(name)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import smembers [as 别名]
class Redis():
    INVITE_EXPIRATION = 300
    
    def __init__(self, host='pulsing.jhk.org', port=6379, password='wsad', db=0, **kwargs):
        super().__init__()
        self.logger = logging.getLogger(__name__)
        self.__client = StrictRedis(host=host, port=port, password=password, db=0, **kwargs)
    
    def storeInvitation(self, to_user_id, from_user_id, invitation_id, invitationType):
        expiration = datetime.utcnow() + timedelta(seconds=Redis.INVITE_EXPIRATION)
        self.__client.setex(invitation_id, '1', Redis.INVITE_EXPIRATION)
        self.__client.sadd('INVITATIONS_'+to_user_id,
                           json.dumps(getInvitation(from_user_id, invitationType, invitation_id, expiration.timestamp() * 1000.0)))

    def removeInvitation(self, user_id, invitation_id):
        s_invitations = self.__client.smembers('INVITATIONS_'+user_id)
        self.logger.debug('removeInvitation fetched - %s ', s_invitations)
        
        invitations = json.loads(s_invitations)
        self.logger.debug('removeInvitation parsed - %s ', invitations)
        
        invitation = [invite for invite in invitations if (invite['invitationId'] == invitation_id)]
        self.__client.delete(invitation_id)
        
        return invitation
        
    @property
    def client(self):
        return self.__client

    def __eq__(self, other):
        return self.__client == other.__client

    def __str__(self):
        return self.__client.__str__()

    def __hash__(self):
        return self.__client.__hash__()

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

    def setUp(self):
        self.redis = StrictRedis(db=9)
        self.predis = Predis(prefix="test", db=9)

    def tearDown(self):
        self.redis.flushdb()

    def test_set(self):
        self.predis.set("foo", "bar")
        assert self.redis.get("test:foo") == "bar"

    def test_get(self):
        self.redis.set("test:foo", "bar")
        assert self.predis.get("foo") == "bar"

    def test_sunionstore(self):
        self.redis.sadd("test:foo", "bar")
        self.redis.sadd("test:boo", "bat")
        self.redis.sadd("test:goo", "bak")
        self.predis.sunionstore("blah", ["foo", "boo"], "goo")
        assert self.redis.smembers("test:blah") == set(["bar", "bat", "bak"])