Python StrictRedis.get方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
def app(environ, start_response):
	ret = {}
	qs = dict(parse_qsl(environ["QUERY_STRING"]))
	red = StrictRedis(host="localhost", port=6379, db=0)
	root_key = red.get("root")
	if root_key is None: #Load trucks into redis if there is no tree already in it
		inp_file = "Mobile_Food_Facility_Permit.csv"
		load_trucks(inp_file, red)
		root_key = red.get("root")
	try:
		lat = float(qs["latitude"])
		lon = float(qs["longitude"])
		rad = float(qs["radius"])
	except KeyError: #Return error if required fields aren't present
		start_response("400 Bad Request", [("Content-type", "text/plain")])
		ret["error"] = "latitude, longitude, and radius query parameters are required"
		return [dumps(ret)]
	ret["latitude"] = lat
	ret["longitude"] = lon
	ret["radius"] = rad
	food = qs.get("food", "").upper()
	if food:
		ret["food"] = food
		ret["trucks"] = [str(t)
				for t in get_trucks(lat, lon, rad, red, root_key) if food in t.food]
	else:
		trucks = []
		foods = set()
		for t in get_trucks(lat, lon, rad, red, root_key):
			trucks.append(str(t))
			foods |= set(t.food)
		ret["trucks"] = trucks
		ret["foods"] = list(foods)
	start_response("200 OK", [("Content-type", "text/plain")])
	return [dumps(ret)]

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
class RedisDataStore(DataStore):
    """Redis-backed datastore object."""

    def __init__(self, number=0):
        redis_host = os.environ.get('REDIS_PORT_6379_TCP_ADDR')
        redis_port = os.environ.get('REDIS_PORT_6379_TCP_PORT')
        self.redis_conn = StrictRedis(host=redis_host, port=redis_port,
                                      db=number)

    def __setitem__(self, k, v):
        self.redis_conn.set(k, v)

    def __getitem__(self, k):
        return self.redis_conn.get(k)

    def __delitem__(self, k):
        self.redis_conn.delete(k)

    def get(self, k):
        return self.redis_conn.get(k)

    def __contains__(self, k):
        return self.redis_conn.exists(k)

    def todict(self):
        #TODO(tvoran): use paginate
        #TODO(tvoran): do something besides multiple gets
        data = {}
        for key in self.redis_conn.keys():
            data[key] = self.get(key)
        return data

    def clear_all(self):
        self.redis_conn.flushdb()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
class Redis:
    """
    To store and query local/remote Redis server.
    """

    def __init__(self, host='localhost',
                       port=6379,
                       db=0,
                       password=None):
        self.r = StrictRedis(host, port, db, password)

    def __del__(self):
        del(self.r)

    def update(self, track):
        self.r.set(track.key, track.stats())

    def lookup(self, keyword):
        # TODO: add option for caseless search
        return self.r.keys('*' + keyword + '*')

    def retrieve(self, key):
        if isinstance(key, list):
            return self.get_all(key)
        return Track.from_redis(key, self.r.get(key))

    def get_all(self, keys):
        tracks = []
        for key in keys:
            tracks.append(Track.from_redis(key, self.r.get(key)))
        return tracks

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
def test_token(redis_server):
    conn = StrictRedis(unix_socket_path=UDS_PATH)
    lock = Lock(conn, "foobar-tok")
    tok = lock.id
    assert conn.get(lock._name) is None
    lock.acquire(blocking=False)
    assert conn.get(lock._name) == tok

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
class RedisRequestLogger(RequestLoggerBase):
    """A faster alternative to the default logger, but requiring more configuration"""
    
    def __init__(self):
        from redis import StrictRedis
        
        super(RedisRequestLogger, self).__init__()
        self.db = StrictRedis(
            host = getattr(settings, 'API_REDIS_HOST', 'localhost'),
            port = getattr(settings, 'API_REDIS_PORT', 6379),
            db = getattr(settings, 'API_REDIS_DB', 0),
            password = getattr(settings, 'API_REDIS_PASSWORD', '')
        )
    
    def get_key(self, app):
        return 'bambu-api-requests-%s' % app.key
    
    def log_request(self, app):
        """Saves the number of requests within the given timeframe to the Redis database"""
        
        timestamp = self.get_timestamp()
        key = self.get_key(app)
        values = self.db.get(key)
        
        if values:
            try:
                values = pickle.loads(values)
            except:
                values = {}
        else:
            values = {}
        
        if values.has_key(timestamp):
            values = {
                timestamp: values[timestamp] + 1
            }
        else:
            values = {
                timestamp: 1
            }
        
        self.db.set(key, pickle.dumps(values))
    
    def get_request_count(self, app, timestamp):
        """Returns the number of requests by the specified app, within the specified timeframe"""
        
        values = self.db.get(
            self.get_key(app)
        )
        
        if values:
            try:
                values = pickle.loads(values)
            except:
                values = {}
        else:
            values = {}
        
        return values.get(timestamp) or 0

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
class BearerAuth(BasicAuth):
    """ Overrides Eve's built-in basic authorization scheme and uses Redis to
    validate bearer token
    """
    def __init__(self):
        super(BearerAuth, self).__init__()
        self.redis = StrictRedis()

    def check_auth(self, token, allowed_roles, resource, method):
        """ Check if API request is authorized.

        Examines token in header and checks Redis cache to see if token is
        valid. If so, request is allowed.

        :param token: OAuth 2.0 access token submitted.
        :param allowed_roles: Allowed user roles.
        :param resource: Resource being requested.
        :param method: HTTP method being executed (POST, GET, etc.)
        """
        if not token:
            return False

        user_id = self.redis.get(token)
        if not user_id:
            return False

        # now switching to the user-reserved mongo instance.

        mongo_prefix = 'MONGO%s' % user_id

        # TODO remove defaulting to localhost so exception is raised
        # if db host is not available. Right now, unless redis hodls a
        # key for the user, all dbs are hosted on localhost.
        host = self.redis.get(user_id) or 'localhost'
        if not host:
            raise ConfigException('Cannot locate host for user database %s' %
                                  user_id)

        uri = 'mongodb://%s/%s' % (host, user_id)

        current_app.config['%s_URI' % mongo_prefix] = uri

        self.set_mongo_prefix(mongo_prefix)

        return True

    def authorized(self, allowed_roles, resource, method):
        """ Validates the the current request is allowed to pass through.

        :param allowed_roles: allowed roles for the current request, can be a
                              string or a list of roles.
        :param resource: resource being requested.
        """
        try:
            token = request.headers.get('Authorization').split(' ')[1]
        except:
            token = None
        return self.check_auth(token, allowed_roles, resource, method)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
    def get(cls, name):
        db = StrictRedis()

        value = None
        while True:
            ver = db.get(name+'::v')
            value = cls._get(db, name)
            if ver == db.get(name+'::v'):
                break

        return value

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
	def check_health_status(self):
		'''
			Verify that all necessary systems are available and running correctly.
		'''
		
		status = {'result': 'error', 'message': 'failure'}

		self.log.info("check_health_status(): starting health check")

		# Check Redis. Fail right-away if Redis is down - verifies infrastructure
		
		try:
			cache = StrictRedis(db=config.health_cache_redis_db)
			cache.set('test', 'test')
			rv = cache.get('test')
			if rv <> 'test':
				return {'result': 'error', 'message': 'redis is not responding correctly'}
		except Exception as ex:
			self.log.critical("check_health_status() redis is not responding: " + str(ex))
			return {'result': 'error', 'message': 'redis is not responding'}
			
		# Check if down for maintenance
		
		cache = StrictRedis(db=config.health_cache_redis_db)
		is_maintenance = cache.get('is_maintenance')
		if is_maintenance == 'true':
			return {'result': 'error', 'message': 'system is down for maintenance'}

		# Do a web request for all buildings - verifies data quality
		
		try:
			cache = StrictRedis(db=config.tokens_cache_redis_db)
			token = config.test_token
			token_hash = auth.calc_hash(token)
			cache.set(token_hash, '[email protected]')
			r = requests.get('http://localhost:8888/org/v1/buildings', auth=(token, ''))
			buildings = r.json()
			
			if len(buildings) < 65 or len(buildings) > 90:
				self.log.critical("check_health_status(): building data failure")
				return {'result': 'error', 'message': 'building data failure'}
			
			#cache.delete(token_hash)
		except Exception as ex:
			self.log.critical("check_health_status(): building data failure: " + str(ex))
			return {'result': 'error', 'message': 'building data failure: ' + str(ex)}
		
		# Check db -- if down set flag to not expire data. Do not fail if db is down
		

		status = {'result': 'success', 'message': "success"}
		
		return status

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
class RedisRequestLogger(RequestLoggerBase):
	def __init__(self):
		from redis import StrictRedis
		
		super(RedisRequestLogger, self).__init__()
		self.db = StrictRedis(
			host = getattr(settings, 'API_REDIS_HOST', 'localhost'),
			port = getattr(settings, 'API_REDIS_PORT', 6379),
			db = getattr(settings, 'API_REDIS_DB', 0),
			password = getattr(settings, 'API_REDIS_PASSWORD', '')
		)
	
	def get_key(self, app):
		return 'bambu-api-requests-%s' % app.key
	
	def log_request(self, app):
		timestamp = self.get_timestamp()
		key = self.get_key(app)
		values = self.db.get(key)
		
		if values:
			try:
				values = pickle.loads(values)
			except:
				values = {}
		else:
			values = {}
		
		if values.has_key(timestamp):
			values = {
				timestamp: values[timestamp] + 1
			}
		else:
			values = {
				timestamp: 1
			}
		
		self.db.set(key, pickle.dumps(values))
	
	def get_request_count(self, app, timestamp):
		values = self.db.get(
			self.get_key(app)
		)
		
		if values:
			try:
				values = pickle.loads(values)
			except:
				values = {}
		else:
			values = {}
		
		return values.get(timestamp) or 0

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
    def store(self):
        from simplekv.memory.redisstore import RedisStore
        r = StrictRedis()

        try:
            r.get('anything')
        except ConnectionError:
            pytest.skip('Could not connect to redis server')

        r.flushdb()
        yield RedisStore(r)
        r.flushdb()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
class TaskCache(ITaskCache):
    """
    `self.user_store': {'user_id': <list of task_ids>}
    `self.task_store`: {'task_id`: <AsyncResult>}
    `self.progress_store`: {`task_id`: `progress_value(int)`}
    """
    def __init__(self, user_kwargs, task_kwargs ,progress_kwargs):
        self.user_store = StrictRedis(**user_kwargs)
        self.task_store = StrictRedis(**task_kwargs)
        self.progress_store = LingvodocRedisClient(**progress_kwargs)

    def get(self, user, remove_finished=False):
        result = dict()
        tasks = self.user_store.get(user.id)
        if tasks is None:
            return {}
        tasks = pickle.loads(tasks)
        remained_tasks = list()
        for t in tasks:
            val = self.task_store.get(t)
            if val is None:
                continue
            async_result = pickle.loads(val)
            progress = self.progress_store.get(t)
            # Redis client returns byte array. We need to decode it
            if progress is not None:
                progress = int(progress.decode())
            result[t] = {'finished': async_result.ready(),
                         'progress': progress}
            if remove_finished:
                if async_result.ready():
                    self.task_store.delete(t)
                else:
                    remained_tasks.append(t)
        if remove_finished:
            self.user_store.set(user.id, pickle.dumps(remained_tasks))
        return result


    # TODO: add try/catch handlers.
    # we should remove the task from caches (and queue?) if exception is raised
    def set(self, user, task_key, async_task):
        self.task_store.set(task_key, pickle.dumps(async_task))
        cached = self.user_store.get(user.id)
        if cached is None:
            tmp_tasks = [task_key]
        else:
            tmp_tasks = pickle.loads(cached)
            tmp_tasks.append(task_key)
        self.user_store.set(user.id, pickle.dumps(tmp_tasks))

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
class DbRedis(Db):
    def __init__(self):
        super().__init__()
        self.redis = StrictRedis(**dbSettings)

    def generateKey(self):
        return self.redis.incr("id")

    def store(self, key, objSerial):
        self.redis.setex(key, TTL, objSerial)

    def retrieve(self, key):
        return self.redis.get(key)

    def lenList(self, name):
        return self.redis.llen(name)

    def listAppend(self, name, val):
        self.redis.lpush(name, val)

    def listPopLeft(self, name):
        return self.redis.lpop(name)

    def retrieveList(self, name):
        return self.redis.lrange(name, 0, -1)

    def removeFromList(self, name, item):
        self.redis.lrem(name, item, 0)

    def keyExists(self, key):
        return self.redis.exists(key)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
def polite_get(url, ttl=TTL, db=0, port=6379):

    """
    Don't hammer the remote servers.

    1. They don't update that often anyway.
    2. We don't want to get throttled or banned.
    3. It's polite.

    Accepts kwargs for ttl, db, and port; otherwise
    uses Redis defaults and a one-hour ttl.
    """

    db = StrictRedis(db=db, port=port)

    key = "url_cache::{0}".format(url)
    result = db.get(key)

    if result is None:

        page = requests.get(url)
        result = page.text
        db.setex(key, ttl, result.encode('utf-8'))

    else:
        result = result.decode('utf-8')

    return result

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
    def __admin_handler(self, endpoint: bytes):
        """
        Handle Admin Request

        :param bytes endpoint: Endpoint (in bytes!)
        :return: jsonified answer data
        """
        json_data = request.get_json()
        if json_data is None:
            raise BadRequest()
        if 'admin_token' not in json_data:
            raise BadRequest()
        admin_token = json_data['admin_token']
        if not isinstance(admin_token, str):
            raise BadRequest()
        if not RULE_TOKEN.match(admin_token):
            raise BadRequest()
        redis = StrictRedis(connection_pool=self.api_pool)
        ep_key = 'ADMIN_TOKEN:{:s}'.format(admin_token)
        should_endpoint = redis.get(ep_key)
        if should_endpoint is None:
            raise BadRequest()
        redis.delete(ep_key)
        if should_endpoint != endpoint:
            raise BadRequest()
        if 'data' not in json_data:
            raise BadRequest()
        data = json_data['data']
        if not isinstance(data, dict):
            raise BadRequest()
        return jsonify(self.queue_dispatcher({
            '_': 'admin:{:s}'.format(endpoint.decode('utf-8')),
            'data': data,
        }))

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
class CacheHelper(object):
    """A thin wrapper on top of Redis."""
    def __init__(self, host="localhost", port=6379, db=0):
        self.host = host
        self.port = port
        self.db = db

    def __enter__(self):
        self.r = StrictRedis(host=self.host, port=self.port, db=self.db)
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        try:
            if any((exc_type, exc_value, traceback,)):
                raise
        finally:
            pass

    def get(self, key):
        return self.r.get(key) if key in self.r.keys() else None

    def set(self, key, json):
        self.r.set(key, json)

    def keys(self):
        return self.r.keys()

    def reset(self):
        for key in self.keys():
            self.r.delete(key)