def getUserDataInfo(username):
blogList = Blog.objects.filter(auther=User.objects.get(
username=username)).filter(draft=False)
followkey = generateKey(username, RedisKey['FOLLOWKEY'])
fanskey = generateKey(username, RedisKey['FANSKEY'])
followcount = 0
fanscount = 0
blogCount = 0
commentCount = 0
pool = ConnectionPool(host='localhost', port='6379', db=0)
redis = StrictRedis(connection_pool=pool)
if redis.exists(followkey):
followcount = redis.scard(followkey)
if redis.exists(fanskey):
fanscount = redis.scard(fanskey)
for blog in blogList:
blogCount = blogCount + 1
commentCount = commentCount + blog.commentcount
messagekey = generateKey(username, RedisKey['UNREADMSGKEY'])
if redis.exists(messagekey):
msgcount = redis.llen(messagekey)
else:
msgcount = 0
pool.disconnect()
userdataInfo = {
'followcount': followcount,
'fanscount': fanscount,
'blogcount': blogCount,
'commentcount': commentCount,
'msgcount': msgcount
}
return userdataInfo
def __init__(self, name='huey', blocking=True, read_timeout=1,
connection_pool=None, url=None, client_name=None,
**connection_params):
if Redis is None:
raise ConfigurationError('"redis" python module not found, cannot '
'use Redis storage backend. Run "pip '
'install redis" to install.')
# Drop common empty values from the connection_params.
for p in ('host', 'port', 'db'):
if p in connection_params and connection_params[p] is None:
del connection_params[p]
if sum(1 for p in (url, connection_pool, connection_params) if p) > 1:
raise ConfigurationError(
'The connection configuration is over-determined. '
'Please specify only one of the following: '
'"url", "connection_pool", or "connection_params"')
if url:
connection_pool = ConnectionPool.from_url(
url, decode_components=True)
elif connection_pool is None:
connection_pool = ConnectionPool(**connection_params)
self.pool = connection_pool
self.conn = self.redis_client(connection_pool=connection_pool)
self.connection_params = connection_params
super(RedisStorage, self).__init__(name, blocking, read_timeout, **connection_params)
def __init__(self):
conf = cper.read_yaml_file('redis')
host = conf['host']
port = conf['port']
db = conf['db']
max_conn = conf['max_conn']
self.redis_pool = ConnectionPool(host=host, port=port, max_connections=max_conn, db=db)
class DBAdaptor(object):
def __init__(self):
conf = cper.read_yaml_file('redis')
host = conf['host']
port = conf['port']
db = conf['db']
max_conn = conf['max_conn']
self.redis_pool = ConnectionPool(host=host, port=port, max_connections=max_conn, db=db)
def create_conn(self, db_type='influxdb'):
if db_type == 'redis':
return RedisDB(self.redis_pool)
elif db_type == 'influxdb':
return InfluxDB()
elif db_type == 'mysql':
return MysqlDB()
else:
print('Error! Please specify the type of database.')
return None
def saveall(self, data):
pass
def createtab(self):
pass
def get_data(self):
print('factory')
def __del__(self):
self.redis_pool.disconnect()
def clearRedis(keys):
pool = ConnectionPool(host='localhost', port='6379', db=0)
redis = StrictRedis(connection_pool=pool)
for key in keys:
if redis.exists(key):
redis.delete(key)
pool.disconnect()
def follow(request, followusername):
try:
currentUser = request.user
except Users.DoesNotExist:
return HttpResponseRedirect(reverse('users:pleaselogin'))
except KeyError:
return HttpResponseRedirect(reverse('users:pleaselogin'))
currentUsername = currentUser.username
if currentUser:
followkey = generateKey(currentUsername, RedisKey['FOLLOWKEY'])
fanskey = generateKey(followusername, RedisKey['FANSKEY'])
pool = ConnectionPool(host='localhost', port='6379', db=0)
redis = StrictRedis(connection_pool=pool)
if redis.exists(followkey):
if redis.sismember(followkey, followusername):
return HttpResponseRedirect(
reverse('blogs:content',
kwargs={'blogId': request.session['currblogId']}))
else:
redis.sadd(followkey, followusername)
redis.sadd(fanskey, currentUsername)
else:
redis.sadd(followkey, followusername)
redis.sadd(fanskey, currentUsername)
pool.disconnect()
return HttpResponseRedirect(
reverse('blogs:content',
kwargs={'blogId': request.session['currblogId']}))
def __init__(self):
if REDISPASSWORD:
self.pool = ConnectionPool(host=REDISHOST,
port=REDISPORT,
password=REDISPASSWORD)
else:
self.pool = ConnectionPool(host=REDISHOST,
port=REDISPORT)
def __init__(self, connection_pool=None, url=None, **connection_params):
if url:
connection_pool = ConnectionPool.from_url(url,
decode_components=True)
elif connection_pool is None:
connection_pool = ConnectionPool(**connection_params)
self.pool = connection_pool
self.conn = self.redis_client(connection_pool=connection_pool)
def configure_extensions(app):
# flask-MongoEngine
db.init_app(app)
db.register_connection(**app.config.get('ORDER_DB_CONFIG'))
db.register_connection(**app.config.get('INVENTORY_DB_CONFIG'))
db.register_connection(**app.config.get('CART_DB_CONFIG'))
db.register_connection(**app.config.get('CONTENT_DB_CONFIG'))
db.register_connection(**app.config.get('LOG_DB_CONFIG'))
mongo_inventory.init_app(app, config_prefix='MONGO_INVENTORY')
redis.connection_pool = ConnectionPool(**app.config.get('REDIS_CONFIG'))
session_redis.connection_pool = ConnectionPool(
**app.config.get('SESSION_REDIS'))
# server side session
app.session_interface = RedisSessionInterface(session_redis)
# flask-mail
mail.init_app(app)
mail.app = app
# flask-cache
cache.init_app(app)
# flask-bcrypt
bcrypt.init_app(app)
# flask-babel
babel.init_app(app)
# flask-assets
assets.init_app(app)
# flask_debugtoolbar
toolbar.init_app(app)
# flask-login (not configured will raise 401 error)
login_manager.login_view = 'frontend.login'
# login_manager.refresh_view = 'frontend.reauth'
@login_manager.user_loader
def load_user(id):
import application.models as Models
return Models.User.objects(id=id, is_deleted=False).first()
login_manager.init_app(app)
login_manager.login_message = _('Please log in to access this page.')
login_manager.needs_refresh_message = _(
'Please reauthenticate to access this page.')
# flask-principal (must be configed after flask-login!!!)
principal.init_app(app)
@identity_loaded.connect_via(app)
def on_identity_loaded(sender, identity):
principal_on_identity_loaded(sender, identity)
def redis_init():
settings = get_project_settings()
if settings["REDIS_PARAMS"]:
pool = ConnectionPool(host=settings["REDIS_HOST"], port=settings["REDIS_PORT"],
password=settings["REDIS_PARAMS"]['password'])
else:
pool = ConnectionPool(host=settings["REDIS_HOST"], port=settings["REDIS_PORT"])
conn = Redis(connection_pool=pool)
return conn
def get_redis_queue(self):
redis_config = self.get_config("redis")
try:
pool = ConnectionPool(host=redis_config["host"])
pool.make_connection().connect()
queue = Queue("high", connection=Redis(connection_pool=pool))
return queue
except RedisError as e:
self.logger.exception(e)
raise DarterException("Not possible connection on Redis")
class PoolRedisDispatcher(AbstractRedisDispatcher):
redis_pool = None
def __init__(self, *pool_args, **pool_kwargs):
self.redis_pool = ConnectionPool(*pool_args, **pool_kwargs)
AbstractRedisDispatcher.__init__(self)
def get_redis(self):
return Redis(connection_pool=self.redis_pool)
def close(self):
self.redis_pool.disconnect()
def __init__(self,
host: str,
port: int = 6379,
db: int = 0,
password: str = None,
patterns: Iterable[str] = ('.*', )):
if password is None:
self.redis_pool = ConnectionPool(host=host, port=port, db=db)
else:
self.redis_pool = ConnectionPool(host=host,
port=port,
db=db,
password=password)
self.patterns = patterns
def __init__(self, redis_host, redis_port, redis_password, db=0):
if isinstance(redis_host, list) and len(redis_host) == 1:
redis_host = redis_host[0]
if isinstance(redis_host, str):
conn_pool = ConnectionPool(host=redis_host,
port=redis_port,
db=db,
password=redis_password)
self.redis_eng = StrictRedis(
connection_pool=conn_pool,
max_connections=10,
)
elif isinstance(redis_host, list):
if isinstance(redis_port, int):
startup_nodes = [{
"host": host,
"port": redis_port
} for host in redis_host]
elif isinstance(redis_port, list):
startup_nodes = [{
"host": host,
"port": port
} for host, port in zip(redis_host, redis_port)]
self.redis_eng = StrictRedisCluster(startup_nodes=startup_nodes,
password=redis_password)
def __init__(self):
if not RedisConnect.pool:
RedisConnect.pool = ConnectionPool(host=DevConfig.REDIS_URI,
port=DevConfig.REDIS_PORT,
db=0,
decode_responses=True)
self.r_connect = StrictRedis(connection_pool=RedisConnect.pool)
def setUpClass(cls):
pool = ConnectionPool()
cls.r = Redis(connection_pool=pool)
cls.r.flushdb()
cls.rr = RedisResource(connection_pool=pool,
schema=_schema,
id_schema=_schema.properties["id"])
def __init__(self, manager):
self.manager = manager
self._logger = logging.getLogger("redis_backend.backend")
settings = manager.settings
port = settings.get('REDIS_PORT')
host = settings.get('REDIS_HOST')
self._min_hosts = settings.get('BC_MIN_HOSTS')
self._max_requests_per_host = settings.get('BC_MAX_REQUESTS_PER_HOST')
self.queue_partitions = settings.get('SPIDER_FEED_PARTITIONS')
self._logger.info("RedisBackend started with {} partitions".format(
self.queue_partitions))
self.pool = ConnectionPool(host=host, port=port, db=0)
self._metadata = None
self._queue = None
self._states = None
def __init__(self):
self.pool = ConnectionPool(
host=REDIS_HOST,
port=REDIS_PORT,
password=REDIS_PASSWD
)
self.redisTemplate = StrictRedis(connection_pool=self.pool)
def __init__(self, *args, **kwargs):
self.rooms = kwargs.pop('rooms', [])
self.nickname = kwargs.pop('nickname', 'Dropbot')
self.cmd_prefix = kwargs.pop('cmd_prefix', '!')
self.kos_url = kwargs.pop('kos_url', 'http://kos.cva-eve.org/api/')
self.hidden_commands = ['cmd_prefix']
self.last_killdate = datetime.utcnow()
self.kill_corps = [int(x) for x in kwargs.pop('kill_corps', [])]
self.kills_disabled = kwargs.pop('kills_disabled', '0') == '1'
self.kills_muted = False
self.office_api_key_keyid = kwargs.pop('office_api_keyid', None)
self.office_api_key_vcode = kwargs.pop('office_api_vcode', None)
self.redis_pool = ConnectionPool.from_url(
kwargs.pop('redis_url', 'redis://localhost:6379/0'))
self.redis = Redis(connection_pool=self.redis_pool)
self.map = Map.from_json(pkgutil.get_data('dropbot', 'data/map.json'))
jid = kwargs.pop('jid', None)
password = kwargs.pop('password', None)
super(DropBot, self).__init__(jid, password)
self.register_plugin('xep_0030') # Service Discovery
self.register_plugin('xep_0045') # Multi-User Chat
self.register_plugin('xep_0199') # XMPP Ping
# Basic bot auto config
self.auto_subscribe = False
self.auto_authorize = True
# Handlers
self.add_event_handler('session_start', self.handle_session_start)
self.add_event_handler('message', self.handle_message)
def open_connection(self, host, port, **params):
pool_key = self._format_pool_key(host, port)
if pool_key not in self.connection_pools:
self.connection_pools[pool_key] = ConnectionPool(
host=host, port=port, db=self.db, password=self.dbpass)
self.db_conn = StrictRedis(
connection_pool=self.connection_pools[pool_key], **params)
def __init__(self, host, db, pwd):
self.pool = ConnectionPool(host=host,
port=6379,
db=db,
password=pwd,
decode_responses=True)
self.rdb = Redis(connection_pool=self.pool)
def get_redis_pool(config):
url = config.get('session.url', '172.23.16.12:6379')
host, port = url.split(':')
redispool = ConnectionPool(host=host, port=int(port))
return redispool
def make(self, dependency_resources):
host = '127.0.0.1'
# Use a broken port to simulate Redis being unavailable.
port = 9999
db = 1 # Use DB number 1 instead of 0 for testing purposes.
connectionPool = ConnectionPool(host=host, port=port, db=db)
setCacheConnectionPool(connectionPool)
def clean(self, client):
host = '127.0.0.1'
# Use a broken port to simulate Redis being unavailable.
port = 9999
db = 1 # Use DB number 1 instead of 0 for testing purposes.
connectionPool = ConnectionPool(host=host, port=port, db=db)
setCacheConnectionPool(connectionPool)
def __init__(self) -> None:
self.logger = logging.getLogger(f'{self.__class__.__name__}')
self.logger.setLevel(get_config('generic', 'loglevel'))
self.redis_pool: ConnectionPool = ConnectionPool(
connection_class=UnixDomainSocketConnection,
path=get_socket_path('indexing'),
decode_responses=True)
def redis_client(self):
pool = ConnectionPool(host=RedisConfigs.HOST.value,
port=RedisConfigs.PORT.value,
db=RedisConfigs.DB.value,
password=RedisConfigs.PASSWORD.value,
decode_responses=True)
return Redis(connection_pool=pool)
def get_redis_client():
"""
获取一个redis连接
:return:
"""
server_url = settings.REDIS_SERVER_URL
return StrictRedis(connection_pool=ConnectionPool.from_url(server_url))
def __init__(self, debug=False):
settings = {
"cookie_secret":
"61oEdfTzKXdQAGaYddkL5fgEdf123mGeJJFfusYh7EQnp2fXdTP1o/Vo=",
'login_url': '/login.html',
'xsrf_cookies': False,
'max_age_days': 0.1,
'debug': debug,
}
handles = [
#(r'/ansible/status', CheckHandler),
# (r'/ansible/task', TaskHandler),
]
self.async_session_pool = ClientPool(max_size=100,
client_timeout=30,
host=options.redis_host,
port=options.redis_port,
db=options.redis_session_db,
autoconnect=True)
self.yum_source_pool = ClientPool(max_size=100,
client_timeout=30,
host=options.redis_host,
port=options.redis_port,
db=options.redis_yum_source_db,
autoconnect=True)
self.sync_session_pool = ConnectionPool(max_connections=10,
host=options.redis_host,
port=options.redis_port,
db=options.redis_session_db)
super(App, self).__init__(handles, **settings)
def __init__(self, index_name, host='localhost', port=6379):
self.host = host
self.port = port
self.index_name = index_name
self.redis = Redis(
connection_pool = ConnectionPool(host=host, port=port))
def list():
#列表方法l开头，少数r开头
pool = ConnectionPool(host='localhost', port=6379, password="", db=1)
redis = StrictRedis(connection_pool=pool)
redis.rpush('lst', 1, 2, 3, 4, 5) #右边加列表值
redis.lpush('lst', 0) #左边加列列表值
def connect_to_redis():
u'''
(Lazily) connect to Redis.
The connection is set up but not actually established. The latter
happens automatically once the connection is used.
:returns: A lazy Redis connection.
:rtype: ``redis.Redis``
.. seealso:: :py:func:`is_redis_available`
'''
global _connection_pool
if _connection_pool is None:
url = config.get(REDIS_URL_SETTING_NAME, REDIS_URL_DEFAULT_VALUE)
log.debug(u'Using Redis at {}'.format(url))
_connection_pool = ConnectionPool.from_url(url)
return Redis(connection_pool=_connection_pool)
def create_redis(registry: Registry, connection_url=None, redis_client=StrictRedis, max_connections=16, **redis_options) -> StrictRedis:
"""Sets up Redis connection pool once at the start of a process.
Connection pool life cycle is the same as Pyramid registry which is the life cycle of a process (all threads).
:param max_connections: Default per-process connection pool limit
"""
# if no url passed, try to get it from pyramid settings
url = registry.settings.get('redis.sessions.url') if connection_url is None else connection_url
# otherwise create a new connection
if url is not None:
# remove defaults to avoid duplicating settings in the `url`
redis_options.pop('password', None)
redis_options.pop('host', None)
redis_options.pop('port', None)
redis_options.pop('db', None)
# the StrictRedis.from_url option no longer takes a socket
# argument. instead, sockets should be encoded in the URL if
# used. example:
# unix://[:password]@/path/to/socket.sock?db=0
redis_options.pop('unix_socket_path', None)
# connection pools are also no longer a valid option for
# loading via URL
redis_options.pop('connection_pool', None)
process_name = os.getpid()
thread_name = threading.current_thread().name
logger.info("Creating a new Redis connection pool. Process %s, thread %s, max_connections %d", process_name, thread_name, max_connections)
connection_pool = ConnectionPool.from_url(url, max_connections=max_connections, **redis_options)
redis = StrictRedis(connection_pool=connection_pool)
else:
raise RuntimeError("Redis connection options missing. Please configure redis.sessions.url")
return redis
def __init__(self, *args, **kwargs):
self.rooms = kwargs.pop('rooms', [])
self.nickname = kwargs.pop('nickname', 'Dropbot')
self.cmd_prefix = kwargs.pop('cmd_prefix', '!')
self.kos_url = kwargs.pop('kos_url', 'http://kos.cva-eve.org/api/')
self.hidden_commands = ['cmd_prefix']
self.last_killdate = datetime.utcnow()
self.kill_corps = [int(x) for x in kwargs.pop('kill_corps', [])]
self.kills_disabled = kwargs.pop('kills_disabled', '0') == '1'
self.kills_muted = False
self.office_api_key_keyid = kwargs.pop('office_api_keyid', None)
self.office_api_key_vcode = kwargs.pop('office_api_vcode', None)
self.market_systems = kwargs.pop('market_systems', ['Jita', 'Amarr', 'Rens', 'Dodixie', 'Hek'])
if 'redis_url' in kwargs:
self.redis_pool = ConnectionPool.from_url(kwargs.pop('redis_url', 'redis://localhost:6379/0'))
self.redis = Redis(connection_pool=self.redis_pool)
else:
logging.warning('No DROPBOT_REDIS_URL defined, EVE API calls will not be cached!')
self.redis = None
self.map = Map.from_json(pkgutil.get_data('dropbot', 'data/map.json'))
jid = kwargs.pop('jid', None)
password = kwargs.pop('password', None)
super(DropBot, self).__init__(jid, password)
self.register_plugin('xep_0030') # Service Discovery
self.register_plugin('xep_0045') # Multi-User Chat
self.register_plugin('xep_0199') # XMPP Ping
# Basic bot auto config
self.auto_subscribe = False
self.auto_authorize = True
# Handlers
self.add_event_handler('session_start', self.handle_session_start)
self.add_event_handler('message', self.handle_message)
def __init__(self, name='huey', blocking=True, read_timeout=1,
connection_pool=None, url=None, client_name=None,
**connection_params):
if Redis is None:
raise ConfigurationError('"redis" python module not found, cannot '
'use Redis storage backend. Run "pip '
'install redis" to install.')
if sum(1 for p in (url, connection_pool, connection_params) if p) > 1:
raise ConfigurationError(
'The connection configuration is over-determined. '
'Please specify only one of the the following: '
'"url", "connection_pool", or "connection_params"')
if url:
connection_pool = ConnectionPool.from_url(
url, decode_components=True)
elif connection_pool is None:
connection_pool = ConnectionPool(**connection_params)
self.pool = connection_pool
self.conn = self.redis_client(connection_pool=connection_pool)
self.connection_params = connection_params
self._pop = self.conn.register_script(SCHEDULE_POP_LUA)
self.name = self.clean_name(name)
self.queue_key = 'huey.redis.%s' % self.name
self.schedule_key = 'huey.schedule.%s' % self.name
self.result_key = 'huey.results.%s' % self.name
self.error_key = 'huey.errors.%s' % self.name
if client_name is not None:
self.conn.client_setname(client_name)
self.blocking = blocking
self.read_timeout = read_timeout
_signal_encoder = import_string(settings.WEBSOCKET_SIGNAL_ENCODER)
_topic_serializer = import_string(settings.WEBSOCKET_TOPIC_SERIALIZER)
__values = {
"host": settings.WEBSOCKET_REDIS_HOST,
"port": ":%s" % settings.WEBSOCKET_REDIS_PORT
if settings.WEBSOCKET_REDIS_PORT
else "",
"db": settings.WEBSOCKET_REDIS_DB,
"password": "******" % settings.WEBSOCKET_REDIS_PASSWORD
if settings.WEBSOCKET_REDIS_PASSWORD
else "",
}
redis_connection_pool = ConnectionPool.from_url(
"redis://%(password)s%(host)s%(port)s/%(db)s" % __values
)
def get_websocket_redis_connection():
"""Return a valid Redis connection, using a connection pool."""
return StrictRedis(connection_pool=redis_connection_pool)
def set_websocket_topics(request, *topics):
"""Use it in a Django view for setting websocket topics. Any signal sent to one of these topics will be received
by the client.
:param request: :class:`django.http.request.HttpRequest`
:param topics: list of topics that will be subscribed by the websocket (can be any Python object).
"""
# CONNECT TO redis METHOD 1)
redis = StrictRedis(host='localhost', port=6397, db=0)
# CONNECT TO redis METHOD 2)
pool = ConnectionPool(host='localhost', port=6397, db=0)
redis = StrictRedis(ConnectionPool)
# CONNECT TO redis METHOD 3) : via URL
# redis = StrictRedis.from_url(url='redis://*****:*****@localhost:6379/1')
redis = StrictRedis(connection_pool=pool)
# ------------------------------------------------------
# OP demo
# 1) simple set key-value and query
import redis
r = redis.Redis(host='127.0.0.1', port=6379)
r.set('key1', 'abc')
print (r.get('key1'))
def from_url(cls, url, db=None, **kwargs):
namespace = kwargs.pop('namespace')
connection_pool = ConnectionPool.from_url(url, db=db, **kwargs)
return cls(connection_pool=connection_pool, namespace=namespace)
