def on_connect(self):
self._parser.on_connect(self)
# 若redis服务器设置了密码，那么在使用之前需要先经过AUTH认证
if self.password:
self.send_command('AUTH', self.password)
if nativestr(self.read_response()) != 'OK':
raise AuthenticationError('Invalid Password')
# 选择使用编号为db的数据库
if self.db:
self.send_command('SELECT', self.db)
if nativestr(self.read_response()) != 'OK':
raise ConnectionError('Invalid Database')
def on_connect(self):
self._parser.on_connect(self)
if self.password:
yield self.send_command('AUTH', self.password)
response = yield self.read_response()
if nativestr(response) != 'OK':
raise AuthenticationError('Invalid Password')
if self.db:
yield self.send_command('SELECT', self.db)
response = yield self.read_response()
if nativestr(response) != 'OK':
raise ConnectionError('Invalid Database')
def on_connect(self):
"Initialize the connection, authenticate and select a database"
self._parser.on_connect(self)
# if a password is specified, authenticate
if self.password:
self.send_command('AUTH', self.password)
if nativestr(self.read_response()) != 'OK':
raise AuthenticationError('Invalid Password')
# if a database is specified, switch to it
if self.db:
self.send_command('SELECT', self.db)
if nativestr(self.read_response()) != 'OK':
raise ConnectionError('Invalid Database')
def connect_to(self, address):
self.host, self.port = address
super(SentinelManagedConnection, self).connect()
if self.connection_pool.check_connection:
self.send_command('PING')
if nativestr(self.read_response()) != 'PONG':
raise ConnectionError('PING failed')
def parse_info(response):
"Parse the result of Redis's INFO command into a Python dict"
info = {}
response = nativestr(response)
def get_value(value):
if ',' not in value or '=' not in value:
try:
if '.' in value:
return float(value)
else:
return int(value)
except ValueError:
return value
else:
sub_dict = {}
for item in value.split(','):
k, v = item.rsplit('=', 1)
sub_dict[k] = get_value(v)
return sub_dict
for line in response.splitlines():
if line and not line.startswith('#'):
if line.find(':') != -1:
key, value = line.split(':', 1)
info[key] = get_value(value)
else:
# if the line isn't splittable, append it to the "__raw__" key
info.setdefault('__raw__', []).append(line)
return info
def connect_to(self, address):
self.host, self.port = address
super(SentinelManagedConnection, self).connect()
if self.connection_pool.check_connection:
self.send_command('PING')
if nativestr(self.read_response()) != 'PONG':
raise ConnectionError('PING failed')
def on_connect(self):
"Initialize the connection, authenticate and select a database"
# TODO 初始化链接：鉴权和选择一个DB
self._parser.on_connect(self) # TODO 创建response的解析类对象
# if a password is specified, authenticate
if self.password:
self.send_command('AUTH', self.password)
if nativestr(self.read_response()) != 'OK':
raise AuthenticationError('Invalid Password')
# if a database is specified, switch to it
if self.db:
self.send_command('SELECT', self.db)
if nativestr(self.read_response()) != 'OK':
raise ConnectionError('Invalid Database')
def parse_m_range(response):
res = []
for item in response:
res.append({
nativestr(item[0]): [list_to_dict(item[1]),
parse_range(item[2])]
})
return res
def on_connect(self):
"Initialize the connection, authenticate and select a database"
self._parser.on_connect(self)
# if a password is specified, authenticate
if self.password:
# avoid checking health here -- PING will fail if we try
# to check the health prior to the AUTH
self.send_command('AUTH', self.password, check_health=False)
if nativestr(self.read_response()) != 'OK':
raise AuthenticationError('Invalid Password')
# if a database is specified, switch to it
if self.db:
self.send_command('SELECT', self.db)
if nativestr(self.read_response()) != 'OK':
raise ConnectionError('Invalid Database')
def parseToList(response):
res = []
for item in response:
if item is not None:
res.append(nativestr(item))
else:
res.append(None)
return res
def __repr__(self):
servers = list(
set([
'{}:{}'.format(nativestr(info['host']), info['port'])
for info in self.startup_nodes
]))
servers.sort()
return "{}<{}>".format(type(self).__name__, ','.join(servers))
def __repr__(self):
"""
"""
servers = list({
'{0}:{1}'.format(nativestr(info['host']), info['port'])
for info in self.connection_pool.nodes.startup_nodes
})
servers.sort()
return "{0}<{1}>".format(type(self).__name__, ', '.join(servers))
def parse_m_get(response):
res = []
for item in response:
res.append({
nativestr(item[0]):
[list_to_dict(item[1]), item[2][0],
float(item[2][1])]
})
return res
def read_response(self):
response = self.read()
if not response:
raise ConnectionError("Socket closed on remote end")
byte, response = byte_to_chr(response[0]), response[1:]
if byte not in ('-', '+', ':', '$', '*'):
raise InvalidResponse("Protocol Error")
# server returned an error
if byte == '-':
if nativestr(response).startswith('LOADING '):
# if we're loading the dataset into memory, kill the socket
# so we re-initialize (and re-SELECT) next time.
raise ConnectionError("Redis is loading data into memory")
# if the error starts with ERR, trim that off
if nativestr(response).startswith('ERR '):
response = response[4:]
# *return*, not raise the exception class. if it is meant to be
# raised, it will be at a higher level.
return ResponseError(response)
# single value
elif byte == '+':
pass
# int value
elif byte == ':':
response = long(response)
# bulk response
elif byte == '$':
length = int(response)
if length == -1:
return None
response = self.read(length)
# multi-bulk response
elif byte == '*':
length = int(response)
if length == -1:
return None
response = [self.read_response() for i in xrange(length)]
if isinstance(response, bytes) and self.encoding:
response = response.decode(self.encoding)
return response
def handle_message(self, response, ignore_subscribe_messages=False):
message_type = nativestr(response[0])
if message_type == 'pmessage':
response[1] = rm_namespace(self._namespace, response[1]) # pattern
response[2] = rm_namespace(self._namespace, response[2]) # channel
elif message_type == 'pong':
pass
else:
response[1] = rm_namespace(self._namespace, response[1]) # channel
return super(PubSub, self).handle_message(response, ignore_subscribe_messages)
def on_connect(self):
"Initialize the connection, authenticate and select a database"
self._parser.on_connect(self)
# if a password is specified, authenticate
if self.password:
self.send_command('AUTH', self.password)
if nativestr(self.read_response()) != 'OK':
raise AuthenticationError('Invalid Password')
if self._client_name:
self.send_command('CLIENT', 'SETNAME', self._client_name)
if nativestr(self.read_response()) != 'OK':
raise ConnectionError('Error setting client name')
# if a database is specified, switch to it
if self.db:
self.send_command('SELECT', self.db)
if nativestr(self.read_response()) != 'OK':
raise ConnectionError('Invalid Database')
def add_namespace(ns, key):
if not ns or not key:
return key
if isinstance(key, list):
return [add_namespace(ns, k) for k in key]
elif isinstance(key, dict):
return {add_namespace(ns, k): v for k, v in key.items()}
elif isinstance(key, basestring):
return '{}{}'.format(ns, key)
elif isinstance(key, bytes):
return '{}{}'.format(ns, nativestr(key))
return key
def read_response(self, command=None, index=0):
response = self._buffer.readline()
if not response:
raise ConnectionError(SERVER_CLOSED_CONNECTION_ERROR)
byte, response = byte_to_chr(response[0]), response[1:]
if byte not in ('-', '+', ':', '$', '*'):
raise InvalidResponse("Protocol Error: %s, %s" %
(str(byte), str(response)))
# server returned an error
if byte == '-':
response = nativestr(response)
error = self.parse_error(response)
# if the error is a ConnectionError, raise immediately so the user
# is notified
if isinstance(error, ConnectionError):
raise error
# otherwise, we're dealing with a ResponseError that might belong
# inside a pipeline response. the connection's read_response()
# and/or the pipeline's execute() will raise this error if
# necessary, so just return the exception instance here.
return error
# single value
elif byte == '+':
pass
# int value
elif byte == ':':
response = long(response)
# bulk response
elif byte == '$':
length = int(response)
if length == -1:
return None
# TODO: IF command=HGETALL and it is value (odd indexed), then decode it
if command == 'HGETALL' and index % 2 == 1:
# print('Unpacking through here...')
# start_time = time.time()
# unpacker = msgpack.Unpacker(self._buffer, length)
response = self._buffer.read_and_decode(length)
# print('Time taken: {}'.format(time.time() - start_time))
else:
response = self._buffer.read(length)
# multi-bulk response
elif byte == '*':
length = int(response)
if length == -1:
return None
response = [self.read_response(command, i) for i in xrange(length)]
if isinstance(response, bytes):
response = self.encoder.decode(response)
return response
def on_connect(self):
'''
Initialize the connection, authenticate and select a database and send READONLY if it is
set during object initialization.
'''
super(SSLClusterConnection, self).on_connect()
if self.readonly:
self.send_command('READONLY')
if nativestr(self.read_response()) != 'OK':
raise ConnectionError('READONLY command failed')
def on_connect(self):
'''
Initialize the connection, authenticate and select a database and send READONLY if it is
set during object initialization.
'''
super(ClusterConnection, self).on_connect()
if self.readonly:
self.send_command('READONLY')
if nativestr(self.read_response()) != 'OK':
raise ConnectionError('READONLY command failed')
def read_response(self):
response = yield self._buffer.readline()
if not response:
raise ConnectionError(SERVER_CLOSED_CONNECTION_ERROR)
byte, response = byte_to_chr(response[0]), response[1:]
if byte not in ('-', '+', ':', '$', '*'):
raise InvalidResponse("Protocol Error: %s, %s" %
(str(byte), str(response)))
# server returned an error
if byte == '-':
response = nativestr(response)
error = self.parse_error(response)
# if the error is a ConnectionError, raise immediately so the user
# is notified
if isinstance(error, ConnectionError):
raise error
# otherwise, we're dealing with a ResponseError that might belong
# inside a pipeline response. the connection's read_response()
# and/or the pipeline's execute() will raise this error if
# necessary, so just return the exception instance here.
raise gen.Return(error)
# single value
elif byte == '+':
pass
# int value
elif byte == ':':
response = int(response)
# bulk response
elif byte == '$':
length = int(response)
if length == -1:
raise gen.Return(None)
response = yield self._buffer.read(length)
# multi-bulk response
elif byte == '*':
length = int(response)
if length == -1:
raise gen.Return(None)
response = []
for i in range(length):
res = yield self.read_response()
response.append(res)
if isinstance(response, bytes):
response = self.encoder.decode(response)
raise gen.Return(response)
def read_response(self):
response = yield self._buffer.readline()
if not response:
raise ConnectionError(SERVER_CLOSED_CONNECTION_ERROR)
byte, response = byte_to_chr(response[0]), response[1:]
if byte not in ('-', '+', ':', '$', '*'):
raise InvalidResponse("Protocol Error: %s, %s" %
(str(byte), str(response)))
# server returned an error
if byte == '-':
response = nativestr(response)
error = self.parse_error(response)
# if the error is a ConnectionError, raise immediately so the user
# is notified
if isinstance(error, ConnectionError):
raise error
# otherwise, we're dealing with a ResponseError that might belong
# inside a pipeline response. the connection's read_response()
# and/or the pipeline's execute() will raise this error if
# necessary, so just return the exception instance here.
raise gen.Return(error)
# single value
elif byte == '+':
pass
# int value
elif byte == ':':
response = long(response)
# bulk response
elif byte == '$':
length = int(response)
if length == -1:
raise gen.Return(None)
response = yield self._buffer.read(length)
# multi-bulk response
elif byte == '*':
length = int(response)
if length == -1:
raise gen.Return(None)
response = []
for i in xrange(length):
res = yield self.read_response()
response.append(res)
if isinstance(response, bytes) and self.encoding:
response = response.decode(self.encoding)
raise gen.Return(response)
def handle_message(self, response, ignore_subscribe_messages=False):
'''
Replacement for the default PubSub message handler, use the threadpool for handling
Mostly copied from http://github.com/andymccurdy/redis-py/master/redis/client.py
'''
message_type = nativestr(response[0])
if message_type == 'pmessage':
message = {
'type': message_type,
'pattern': response[1],
'channel': response[2],
'data': response[3],
}
else:
message = {
'type': message_type,
'pattern': None,
'channel': response[1],
'data': response[2],
}
# if this is an unsubscribe message, remove it from memory
if message_type in self.UNSUBSCRIBE_MESSAGE_TYPES:
subscribed_dict = None
if message_type == 'punsubscribe':
subscribed_dict = self.patterns
else:
subscribed_dict = self.channels
try:
del subscribed_dict[message['channel']]
except KeyError:
pass
if message_type in self.PUBLISH_MESSAGE_TYPES:
# if there's a message handler, invoke it
handler = None
if message_type == 'pmessage':
handler = self.patterns.get(message['pattern'], None)
else:
handler = self.channels.get(message['channel'], None)
if handler:
res = self.threadpool.apply_async(handler, [message])
return None
else:
# this is a subscribe/unsubscribe message. ignore if we don't
# want them
if ignore_subscribe_messages or self.ignore_subscribe_messages:
return None
return message
def handle_message(self, response, ignore_subscribe_messages=False):
'''
Replacement for the default PubSub message handler, use the threadpool for handling
Mostly copied from http://github.com/andymccurdy/redis-py/master/redis/client.py
'''
message_type = nativestr(response[0])
if message_type == 'pmessage':
message = {
'type': message_type,
'pattern': response[1],
'channel': response[2],
'data': response[3],
}
else:
message = {
'type': message_type,
'pattern': None,
'channel': response[1],
'data': response[2],
}
# if this is an unsubscribe message, remove it from memory
if message_type in self.UNSUBSCRIBE_MESSAGE_TYPES:
subscribed_dict = None
if message_type == 'punsubscribe':
subscribed_dict = self.patterns
else:
subscribed_dict = self.channels
try:
del subscribed_dict[message['channel']]
except KeyError:
pass
if message_type in self.PUBLISH_MESSAGE_TYPES:
# if there's a message handler, invoke it
handler = None
if message_type == 'pmessage':
handler = self.patterns.get(message['pattern'], None)
else:
handler = self.channels.get(message['channel'], None)
if handler:
res = self.threadpool.apply_async(handler, [message])
return None
else:
# this is a subscribe/unsubscribe message. ignore if we don't
# want them
if ignore_subscribe_messages or self.ignore_subscribe_messages:
return None
return message
def handle_message(self, response, ignore_subscribe_messages=False):
"""
Parses a pub/sub message. If the channel or pattern was subscribed to
with a message handler, the handler is invoked instead of a parsed
message being returned.
"""
message_type = nativestr(response[0])
if message_type == 'pmessage':
message = {
'type': message_type,
'pattern': response[1],
'channel': response[2],
'data': response[3]
}
else:
message = {
'type': message_type,
'pattern': None,
'channel': response[1],
'data': response[2]
}
# if this is an unsubscribe message, remove it from memory
if message_type in self.UNSUBSCRIBE_MESSAGE_TYPES:
subscribed_dict = None
if message_type == 'punsubscribe':
subscribed_dict = self.patterns
else:
subscribed_dict = self.channels
try:
del subscribed_dict[message['channel']]
except KeyError:
pass
if message_type in self.PUBLISH_MESSAGE_TYPES:
# if there's a message handler, invoke it
handler = None
if message_type == 'pmessage':
handler = self.patterns.get(message['pattern'], None)
else:
handler = self.channels.get(message['channel'], None)
if handler:
handler(message)
return None
else:
# this is a subscribe/unsubscribe message. ignore if we don't
# want them
if ignore_subscribe_messages or self.ignore_subscribe_messages:
return None
return message
def on_connect(self):
'''
Initialize the connection, authenticate and select a database and send READONLY if it is
set during object initialization.
'''
super(ClusterConnection, self).on_connect()
if self.readonly:
log.debug("Sending READONLY command to server to configure connection as readonly")
log.debug(str(self))
self.send_command('READONLY')
if nativestr(self.read_response()) != 'OK':
raise ConnectionError('READONLY command failed')
def parse_debug_object(response):
"Parse the results of Redis's DEBUG OBJECT command into a Python dict"
# The 'type' of the object is the first item in the response, but isn't
# prefixed with a name
response = nativestr(response)
response = 'type:' + response
response = dict([kv.split(':') for kv in response.split()])
# parse some expected int values from the string response
# note: this cmd isn't spec'd so these may not appear in all redis versions
int_fields = ('refcount', 'serializedlength', 'lru', 'lru_seconds_idle')
for field in int_fields:
if field in response:
response[field] = int(response[field])
return response
def read_response(self):
response = self._buffer.readline()
if not response:
raise ConnectionError("Socket closed on remote end")
byte, response = byte_to_chr(response[0]), response[1:]
if byte not in ('-', '+', ':', '$', '*'):
raise InvalidResponse("Protocol Error: %s, %s" %
(str(byte), str(response)))
# server returned an error
if byte == '-':
response = nativestr(response)
error = self.parse_error(response)
# if the error is a ConnectionError, raise immediately so the user
# is notified
if isinstance(error, ConnectionError):
raise error
# otherwise, we're dealing with a ResponseError that might belong
# inside a pipeline response. the connection's read_response()
# and/or the pipeline's execute() will raise this error if
# necessary, so just return the exception instance here.
return error
# single value
elif byte == '+':
pass
# int value
elif byte == ':':
response = long(response)
# bulk response
elif byte == '$':
length = int(response)
if length == -1:
return None
response = self._buffer.read(length)
# multi-bulk response
elif byte == '*':
length = int(response)
if length == -1:
return None
response = [self.read_response() for i in xrange(length)]
if isinstance(response, bytes) and self.encoding:
response = response.decode(self.encoding)
return response
def read_response(self):
response = self.read()
if not response:
raise ConnectionError("Socket closed on remote end")
byte, response = byte_to_chr(response[0]), response[1:]
if byte not in ('-', '+', ':', '$', '*'):
message = "Protocol Error: %s, %s" % (str(byte), str(response))
raise InvalidResponse("%s" % message)
# server returned an error
if byte == '-':
response = nativestr(response)
error = self.parse_error(response)
# if the error is a ConnectionError, raise immediately so the user
# is notified
if isinstance(error, ConnectionError):
raise error
# otherwise, we're dealing with a ResponseError that might belong
# inside a pipeline response. the connection's read_response()
# and/or the pipeline's execute() will raise this error if
# necessary, so just return the exception instance here.
return error
# single value
elif byte == '+':
pass
# int value
elif byte == ':':
response = long(response)
# bulk response
elif byte == '$':
length = int(response)
if length == -1:
return None
response = self.read(length)
# multi-bulk response
elif byte == '*':
length = int(response)
if length == -1:
return None
response = [self.read_response() for i in xrange(length)]
if isinstance(response, bytes) and self.encoding:
response = response.decode(self.encoding)
return response
def read_response(self):
response = self.read()
if not response:
raise ConnectionError("Socket closed on remote end")
byte, response = byte_to_chr(response[0]), response[1:]
if byte not in ("-", "+", ":", "$", "*"):
raise InvalidResponse("Protocol Error")
# server returned an error
if byte == "-":
response = nativestr(response)
if response.startswith("LOADING "):
# if we're loading the dataset into memory, kill the socket
# so we re-initialize (and re-SELECT) next time.
raise ConnectionError("Redis is loading data into memory")
# *return*, not raise the exception class. if it is meant to be
# raised, it will be at a higher level.
return self.parse_error(response)
# single value
elif byte == "+":
pass
# int value
elif byte == ":":
response = long(response)
# bulk response
elif byte == "$":
length = int(response)
if length == -1:
return None
response = self.read(length)
# multi-bulk response
elif byte == "*":
length = int(response)
if length == -1:
return None
response = [self.read_response() for i in xrange(length)]
if isinstance(response, bytes) and self.encoding:
response = response.decode(self.encoding)
return response
def read_response(self):
try:
response = yield self._stream.read_until(SYM_CRLF)
except StreamClosedError:
raise socket.error(SERVER_CLOSED_CONNECTION_ERROR)
response = response[:-2]
if not response:
raise ConnectionError(SERVER_CLOSED_CONNECTION_ERROR)
byte, response = byte_to_chr(response[0]), response[1:]
if byte not in ('-', '+', ':', '$', '*'):
raise InvalidResponse("Protocol Error: %s, %s" %
(str(byte), str(response)))
if byte == '-':
response = nativestr(response)
error = self.parse_error(response)
if isinstance(error, ConnectionError):
raise error
raise gen.Return(error)
elif byte == '+':
pass
elif byte == ':':
response = long(response)
elif byte == '$':
length = int(response)
if length == -1:
raise gen.Return(None)
response = yield self._stream.read_bytes(
length + 2) # make sure to read the '\r\n'
response = response[:-2]
elif byte == '*':
length = int(response)
if length == -1:
raise gen.Return(None)
response = []
for i in xrange(length):
part = yield self.read_response()
response.append(part)
if isinstance(response, bytes):
response = self.encoder.decode(response)
raise gen.Return(response)
def __init__(self,
client=None,
encoder=None,
decoder=None,
*args,
**kwargs):
"""
Creates a new ReJSON client.
``encoder`` should be an instance of a ``json.JSONEncoder`` class
``decoder`` should be an instance of a ``json.JSONDecoder`` class
"""
self.setEncoder(encoder)
self.setDecoder(decoder)
if client is None:
self.setClient(StrictRedis(*args, **kwargs))
else:
self.setClient(client)
# Set the module commands' callbacks
MODULE_CALLBACKS = {
'JSON.DEL': long,
'JSON.GET': self._decode,
'JSON.MGET': bulk_of_jsons(self._decode),
'JSON.SET': lambda r: r and nativestr(r) == 'OK',
'JSON.NUMINCRBY': self._decode,
'JSON.NUMMULTBY': self._decode,
'JSON.STRAPPEND': long,
'JSON.STRLEN': long,
'JSON.ARRAPPEND': long,
'JSON.ARRINDEX': long,
'JSON.ARRINSERT': long,
'JSON.ARRLEN': long,
'JSON.ARRPOP': self._decode,
'JSON.ARRTRIM': long,
'JSON.OBJLEN': long,
}
for k, v in six.iteritems(MODULE_CALLBACKS):
self.client.set_response_callback(k, v)
def read_response(self):
response = self.read()
if not response:
raise ConnectionError("Socket closed on remote end")
byte, response = byte_to_chr(response[0]), response[1:]
if byte not in ('-', '+', ':', '$', '*'):
raise InvalidResponse("Protocol Error")
# server returned an error
if byte == '-':
response = nativestr(response)
# *return*, not raise the exception class. if it is meant to be
# raised, it will be at a higher level.
return self.parse_error(response)
# single value
elif byte == '+':
pass
# int value
elif byte == ':':
response = long(response)
# bulk response
elif byte == '$':
length = int(response)
if length == -1:
return None
response = self.read(length)
# multi-bulk response
elif byte == '*':
length = int(response)
if length == -1:
return None
response = [self.read_response() for i in xrange(length)]
if isinstance(response, bytes) and self.encoding:
response = response.decode(self.encoding)
return response
def parse_client_list(response, **options):
clients = []
for c in nativestr(response).splitlines():
clients.append(dict([pair.split('=') for pair in c.split(' ')]))
return clients
def parse_config_get(response, **options):
response = [nativestr(i) if i is not None else None for i in response]
return response and pairs_to_dict(response) or {}
def __repr__(self):
"""
"""
servers = list({'{0}:{1}'.format(nativestr(info['host']), info['port']) for info in self.connection_pool.nodes.startup_nodes})
servers.sort()
return "{0}<{1}>".format(type(self).__name__, ', '.join(servers))
def bool_ok(response):
return nativestr(response) == 'OK'
def _ardb_patch(self, client):
client.response_callbacks["HDEL"] = lambda r: r and nativestr(r) == "OK"
def list_to_dict(aList):
return {nativestr(aList[i][0]):nativestr(aList[i][1])
for i in range(len(aList))}
def parse_cluster_nodes(resp, **options):
"""
@see: http://redis.io/commands/cluster-nodes # string
@see: http://redis.io/commands/cluster-slaves # list of string
"""
resp = nativestr(resp)
current_host = options.get('current_host', '')
def parse_slots(s):
slots, migrations = [], []
for r in s.split(' '):
if '->-' in r:
slot_id, dst_node_id = r[1:-1].split('->-', 1)
migrations.append({
'slot': int(slot_id),
'node_id': dst_node_id,
'state': 'migrating'
})
elif '-<-' in r:
slot_id, src_node_id = r[1:-1].split('-<-', 1)
migrations.append({
'slot': int(slot_id),
'node_id': src_node_id,
'state': 'importing'
})
elif '-' in r:
start, end = r.split('-')
slots.extend(range(int(start), int(end) + 1))
else:
slots.append(int(r))
return slots, migrations
if isinstance(resp, basestring):
resp = resp.splitlines()
nodes = []
for line in resp:
parts = line.split(' ', 8)
self_id, addr, flags, master_id, ping_sent, \
pong_recv, config_epoch, link_state = parts[:8]
host, port = addr.rsplit(':', 1)
node = {
'id': self_id,
'host': host or current_host,
'port': int(port),
'flags': tuple(flags.split(',')),
'master': master_id if master_id != '-' else None,
'ping-sent': int(ping_sent),
'pong-recv': int(pong_recv),
'link-state': link_state,
'slots': [],
'migrations': [],
}
if len(parts) >= 9:
slots, migrations = parse_slots(parts[8])
node['slots'], node['migrations'] = tuple(slots), migrations
nodes.append(node)
return nodes
def __repr__(self):
servers = list(set(['{}:{}'.format(nativestr(info['host']), info['port']) for info in self.connection_pool.nodes.startup_nodes]))
servers.sort()
return "{}<{}>".format(type(self).__name__, ', '.join(servers))
def _ardb_patch(self, client):
client.response_callbacks['HDEL'] = lambda r: r and nativestr(r
) == 'OK'
def bool_ok(response):
return nativestr(response) == 'OK'
def parseToList(response):
res = []
for item in response:
res.append(nativestr(item))
return res
def read_response(self):
'''
Reads one line from the wire, and interprets it.
Example: the acknowledgment to an unsubscribe
from topic myTopic on the wire looks like this:
*3\r\n$11\r\nUNSUBSCRIBE\r\n$7\r\nmyTopic\r\n:1\r\n'
*3 # three items to follow
$11 # string of 11 chars
UNSUBSCRIBE
$7 # string of 7 chars
myTopic
:1 # one topic subscribed to now
Each line will cause a recursive call to this method
(see elif byte == '*' below).
Simpler calls will be individual elements, such
as ':12', which returns the integer 12.
These are the possible prefixes; each item
is followed by a \r\n, which is stripped
by SocketLineReader:
+<str> simple string
:<int> integer
$<n> string of length <n>
*<num> start of array with <num> elements
When the message to parse is the acknowledgment of
a SUBSCRIBE or UNSUBSCRIBE command, this method
will set() event self.unsubscribeAckEvent/self.unsubscribeAckEvent.
:return: response string
:rtype: string
'''
response = self._buffer.readline()
if not response:
raise ConnectionError(SERVER_CLOSED_CONNECTION_ERROR)
byte, response = byte_to_chr(response[0]), response[1:]
if byte not in ('-', '+', ':', '$', '*'):
raise InvalidResponse("Protocol Error: %s, %s" %
(str(byte), str(response)))
# server returned an error
if byte == '-':
response = nativestr(response)
error = self.parse_error(response)
# if the error is a ConnectionError, raise immediately so the user
# is notified
if isinstance(error, ConnectionError):
raise error
# otherwise, we're dealing with a ResponseError that might belong
# inside a pipeline response. the connection's read_response()
# and/or the pipeline's execute() will raise this error if
# necessary, so just return the exception instance here.
return error
# simple-string: response holds result:
elif byte == '+':
pass
# int value
elif byte == ':':
response = long(response)
# bulk response
elif byte == '$':
length = int(response)
if length == -1:
# Null string:
return None
response = self._buffer.read(length)
# multi-bulk response
elif byte == '*':
length = int(response)
if length == -1:
return None
response = [self.read_response() for _ in xrange(length)]
if isinstance(response, bytes) and self.encoding:
response = response.decode(self.encoding)
#***********
#print('Response: %s' % byte + '|' + str(response))
#***********
return response
def read_response(self):
'''
Reads one line from the wire, and interprets it.
Example: the acknowledgment to an unsubscribe
from topic myTopic on the wire looks like this:
*3\r\n$11\r\nUNSUBSCRIBE\r\n$7\r\nmyTopic\r\n:1\r\n'
*3 # three items to follow
$11 # string of 11 chars
UNSUBSCRIBE
$7 # string of 7 chars
myTopic
:1 # one topic subscribed to now
Each line will cause a recursive call to this method
(see elif byte == '*' below).
Simpler calls will be individual elements, such
as ':12', which returns the integer 12.
These are the possible prefixes; each item
is followed by a \r\n, which is stripped
by SocketLineReader:
+<str> simple string
:<int> integer
$<n> string of length <n>
*<num> start of array with <num> elements
When the message to parse is the acknowledgment of
a SUBSCRIBE or UNSUBSCRIBE command, this method
will set() event self.unsubscribeAckEvent/self.unsubscribeAckEvent.
:return: response string
:rtype: string
'''
response = self._buffer.readline()
if not response:
raise ConnectionError(SERVER_CLOSED_CONNECTION_ERROR)
byte, response = byte_to_chr(response[0]), response[1:]
if byte not in ('-', '+', ':', '$', '*'):
raise InvalidResponse("Protocol Error: %s, %s" %
(str(byte), str(response)))
# server returned an error
if byte == '-':
response = nativestr(response)
error = self.parse_error(response)
# if the error is a ConnectionError, raise immediately so the user
# is notified
if isinstance(error, ConnectionError):
raise error
# otherwise, we're dealing with a ResponseError that might belong
# inside a pipeline response. the connection's read_response()
# and/or the pipeline's execute() will raise this error if
# necessary, so just return the exception instance here.
return error
# simple-string: response holds result:
elif byte == '+':
pass
# int value
elif byte == ':':
response = long(response)
# bulk response
elif byte == '$':
length = int(response)
if length == -1:
# Null string:
return None
response = self._buffer.read(length)
# multi-bulk response
elif byte == '*':
length = int(response)
if length == -1:
return None
response = [self.read_response() for _ in xrange(length)]
if isinstance(response, bytes) and self.encoding:
response = response.decode(self.encoding)
#***********
#print('Response: %s' % byte + '|' + str(response))
#***********
return response
def bool_ok(response, *args, **kwargs):
"""
Borrowed from redis._compat becuase that method to not support extra arguments
when used in a cluster environment.
"""
return nativestr(response) == 'OK'
def bool_ok(response, *args, **kwargs):
"""
Borrowed from redis._compat becuase that method to not support extra arguments
when used in a cluster environment.
"""
return nativestr(response) == 'OK'
def fix_server(*args):
return (nativestr(args[0]) or current_host, args[1])
