Python StrictRedis.ltrim方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import ltrim [as 别名]
def update_status(msg, **redis_kwargs):
    """ Updated Redis with a message, prefix it with the current timestamp.
    
        Keyword args are passed directly to redis.StrictRedis().
    """
    pid = getpid()
    red = StrictRedis(**redis_kwargs)
    key = 'pid-%d-statuses' % pid
    msg = '%.6f %s' % (time(), msg)
    
    red.lpush(key, msg)
    red.expire(key, 60 * 60)
    red.ltrim(key, 0, _keep)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import ltrim [as 别名]
class RedisDatabaseManager(object):
  redisHandler = None

  # initialization, establish connection to redis server
  #
  # @param host string host of the redis server
  # @param port int port of the redis server
  # @param db int database you want to use in redis server
  def __init__(self, host, port, db):
    self.redisHandler = StrictRedis(host=host, port=port, db=db)

    # create deadLinks, unvisistedLinks, visitedLinks in redis
    self.redisHandler.ltrim('deadLinks', -1, 0)
    self.redisHandler.ltrim('unvisitedLinks', -1, 0)
    self.redisHandler.ltrim('visitedLinks', -1, 0)

  # createDeadLinks
  # create a record in deadLinks list
  #
  # @param url string
  # @return boolean
  def createDeadLinks(self, url):
    pass

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import ltrim [as 别名]
class KeyValueStore(object):
    def __init__(self):
        self.data = StrictRedis(host = settings.redis.server.host, port = settings.redis.server.port)
        log.debug("Connected to REDIS(%s, %s)" % (settings.redis.server.host, settings.redis.server.port))

    def _get_value(self, key):
        return self.data.get(key)

    def _set_value(self, key, value, seconds=None):
        self.data.set(key, value)
        if seconds is not None:
            self.data.expire(key, seconds)

    def _delete_key(self, key):
        self.data.delete(key)

    def _search_keys(self, pattern):
        return self.data.keys(pattern)

    def _get_model(self, model_pf, model_id):
        value = self._get_value(model_pf+model_id)
        if value is None:
            return None
        return Struct(loads(self._get_value(model_pf+model_id)))

    def _set_model(self, model_pf, model_id, model_value, seconds=None):
        self._set_value(model_pf+model_id, dumps(model_value, default=datetime_serializer), seconds)

    def _list_model(self, model_pf):
        return [Struct(loads(self._get_value(key))) for key in self._search_keys(model_pf+'*')]

    def _get_list_models(self, list_pf, list_id):
        return [Struct(loads(value)) for value in self.data.lrange(list_pf+list_id, 0, -1)]

    def _get_list_scalars(self, list_pf, list_id):
        return [value for value in self.data.lrange(list_pf+list_id, 0, -1)]

    def _pop_list_scalars(self, list_pf, list_id):
        scalars = []
        scalar = True

        while scalar:
            scalar=self.data.lpop(list_pf+list_id)
            if scalar:
                scalars += [scalar]

        return scalars

    def _push_list(self, list_pf, list_id, model_value, trim_count):
        if not isinstance(model_value, unicode):
            model_value = dumps(model_value)

        self.data.lpush(list_pf+list_id, model_value)
        self.data.ltrim(list_pf+list_id, 0, MAX_STAT_ITEMS-1)

    # Devices

    def get_device(self, mac_address):
        return self._get_model(DEVICE_PF, mac_address.replace(":","").upper())

    def set_device(self, mac_address, device):
        self._set_model(DEVICE_PF, mac_address.replace(":","").upper(), device)

    def delete_device(self, mac_address):
        self._delete_key(DEVICE_PF+mac_address.replace(":","").upper())
        self._delete_key(ASSETLIST_PF+mac_address.replace(":","").upper())

    def list_devices(self):
        return self._list_model(DEVICE_PF)

    # Assets

    def get_asset(self, guid):
        return self._get_model(ASSET_PF, guid)

    def set_asset(self, guid, asset):
        self._set_model(ASSET_PF, guid, asset)

    def delete_asset(self, guid):
        self._delete_key(ASSET_PF+guid)

    def list_assets(self):
        return self._list_model(ASSET_PF)

    # Playlists

    def get_playlist(self, name):
        return self._get_model(PLAYLIST_PF, name)

    def set_playlist(self, name, playlist):
        self._set_model(PLAYLIST_PF, name, playlist)

    def delete_playlist(self, name):
        self._delete_key(PLAYLIST_PF+name)

    def list_playlists(self):
        return self._list_model(PLAYLIST_PF)

    # Stats

#.........这里部分代码省略.........

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import ltrim [as 别名]

#.........这里部分代码省略.........
            f.write(snapshot)
            f.close()
            shutil.move(f.name, self.snapshot_path)
            os._exit(os.EX_OK)

    def _import_subclasses(self, module_name, parent_class):
        module = importlib.import_module(module_name)
        return {
            cls.__name__: cls
            for name, cls in inspect.getmembers(module)
            if inspect.isclass(cls) and issubclass(cls, parent_class)
        }

    def load_modules(self):
        sys.path.append(self.world_path)

        self.components = self._import_subclasses(self.config['world']['components'], Component)
        self.modes = self._import_subclasses(self.config['world']['modes'], Mode)

        log.debug('Loaded %s component(s) and %s mode(s).' % (
            len(self.components), len(self.modes)
        ))

    def start(self):
        try:
            self.redis.ping()
        except ConnectionError as e:
            fatal("Redis error: %s" % e.message)

        self.running = True
        log.info('Listening.')

        # Clear any existing tick events
        self.redis.ltrim(self.tick_key, 0, 0)
        try:
            while self.running:
                self.process_one_event()
        except Exception as e:
            log.critical(traceback.format_exc())
        except BaseException as e:
            pass
        finally:
            self.save_snapshot()

    def stop(self):
        self.running = False

    def start_ticker(self):
        log.info('Ticking every %ss.' % self.tick_interval)
        tock = False
        while True:
            log.debug('Tock.' if tock else 'Tick.')
            # TODO: timestamp here instead of True, for debugging?
            self.redis.rpush(self.tick_key, True)
            sleep(self.tick_interval)
            tock = not tock

    def send_message(self, entity_id, message):
        self.redis.publish(self.messages_key(entity_id), message)

    def listen(self, entity_id):
        subscription = self.subscribe(entity_id)
        for message in subscription.listen():
            yield message['data']

    # TODO: Leaky abstraction :\

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import ltrim [as 别名]
class RedisTimeline(object):
    _redis = None

    def __init__(self, **kwargs):
        """
        Creates Redis object with key ``timelines:<id>``.
        """

        name = kwargs.pop('name')
        prefix = kwargs.pop('prefix', "timelines")
        sep = kwargs.pop('sep', ":")
        
        self.name = "%s%s%s" % (prefix, sep, name)

        # Default to uncapped length
        self.max_length = kwargs.pop("max_length", 0)

        if self._redis is None:
            url = kwargs.get('url', None)

            if url is not None:
                self._redis = StrictRedis().from_url(url)
            else:
                self._redis = StrictRedis(**kwargs)

    def push(self, value):
        """
        Adds the value to the front of the list and trim if the 
        max length != 0. Returns the value.
        """

        self._redis.lpush(self.name, value)

        if self.max_length > 0:
            self._redis.ltrim(self.name, 0, self.max_length-1)

        return value

    def range(self, count=0, **kwargs):
        """
        Returns a range values from the front of the list to the limit.
        """

        if count is 0:
            # No count, check for offset/limit
            offset = kwargs.get('offset', 0)
            limit = kwargs.get('limit', -1)
        else:
            # If there's a count, default to offset 0
            offset = 0
            limit = count

        if limit is 1: 
            # Get range of length 1 using LRANGE <timeline> <limit> <limit>
            limit = offset
        elif limit > 0:
            limit = offset+limit - 1

        return self._redis.lrange(self.name, offset, limit)

    def count(self):
        """
        Uses Redis LLEN to get the length of the timeline.
        """
        return self._redis.llen(self.name)

    @property
    def length(self):
        """
        Access the length (count) as a property.
        """
        return self.count()