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 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): """ 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 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 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])