# coding: utf-8 """Client for abase""" from __future__ import absolute_import, division, print_function, unicode_literals import datetime import functools import time import bytedredis from redis.client import Pipeline as RedisPipeline from redis.exceptions import ( ConnectionError, TimeoutError, ) SIMPLE_ABASE_COMMANDS = [ "decr", "decrby", "expire", "expireat", "get", "incr", "incrby", "lpush", "lpop", "lindex", "llen", "lrange", "persist", "pexpire", "psetex", "psetex", 'rpush', "pttl", "set", "setex", "setnx", "ttl", "hset", "hget", "hdel", ] class Client(object): def __init__(self, psm, table, from_url=True, **kwargs): """Create abase client. :param psm: abase service name :type psm: str :param table: abase table name :type tabale: str :param socket_timeout: set the underlying socket's timeout :type socket_timeout: float :param socket_connect_timeout: set the connect timeout for underlying socket :type socket_connect_timeout: float :param decode_responses: set True to return strings, False(default) to bytes :type decode_responses: bool """ available_params = ["socket_timeout", "socket_connect_timeout", "decode_responses", "password"] redis_kwargs = {} for k in available_params: if k in kwargs: redis_kwargs[k] = kwargs[k] self._psm = psm self._table = table if from_url: self._redis_client = bytedredis.Client.from_url("redis://?redis_psm=" + psm, **redis_kwargs) else: self._redis_client = bytedredis.Client(redis_psm=psm, **redis_kwargs) def _compose_abase_key(self, key): return "[%s]%s" % (self._table, key) @functools.wraps(bytedredis.Client.exists) def exists(self, *keys): return self._redis_client.exists(*(self._compose_abase_key(key) for key in keys)) @functools.wraps(bytedredis.Client.delete) def delete(self, *keys): return self._redis_client.delete(*(self._compose_abase_key(key) for key in keys)) @functools.wraps(bytedredis.Client.mget) def mget(self, keys, *args): return self._redis_client.mget((self._compose_abase_key(key) for key in keys), *args) @functools.wraps(bytedredis.Client.mset) def mset(self, mapping): mapping = {self._compose_abase_key(k): v for k, v in mapping.items()} return self._redis_client.mset(mapping) @functools.wraps(bytedredis.Client.eval) def eval(self, script, numkeys, *keys_and_args): keys = keys_and_args[:numkeys] args = keys_and_args[numkeys:] keys = [self._compose_abase_key(key) for key in keys] keys.extend(args) return self._redis_client.eval(script, numkeys, *keys) @functools.wraps(bytedredis.Client.evalsha) def evalsha(self, script, numkeys, *keys_and_args): keys = keys_and_args[:numkeys] args = keys_and_args[numkeys:] keys = [self._compose_abase_key(key) for key in keys] keys.extend(args) return self._redis_client.evalsha(script, numkeys, *keys) def scanrow(self, row, limit, offset=0, target=None): row = self._compose_abase_key(row) args = [row, limit, offset] if target: args.append(target) return self._redis_client.execute_command("SCANROW", *args) def xget(self, key): return self._redis_client.execute_command("XGET", self._compose_abase_key(key)) def xset(self, key, value, generation, ex=None, px=None): if ex is not None and px is not None: raise ValueError("ex and px must not be specified both") args = [self._compose_abase_key(key), value, generation] if ex is not None: args.append("EX") if isinstance(ex, datetime.timedelta): ex = int(ex.total_seconds()) args.append(ex) if px is not None: args.append("PX") if isinstance(px, datetime.timedelta): px = int(px.total_seconds() * 1000) args.append(px) return self._redis_client.execute_command("XSET", *args) def append(self, key, value, ttl=None): args = [self._compose_abase_key(key), value] if ttl is not None: args.append(ttl) return self._redis_client.execute_command("APPEND", *args) def prepend(self, key, value, ttl=None): args = [self._compose_abase_key(key), value] if ttl is not None: args.append(ttl) return self._redis_client.execute_command("PREPEND", *args) def pipeline(self): return AbasePipeline(self._table, self._redis_client.connection_pool, self._redis_client.response_callbacks, self._redis_client._metrics_client) class AbasePipeline(RedisPipeline): SUPPORTED_COMMANDS = set([ "GET", "SET", "DEL", "SETEX", "SETNX", "INCR", "INCRBY", "DECR", "DECRBY", "TTL", "PTTL", "PSETEX", "EXPIRE", "EXPIREAT", "PEXPIRE", "PERSIST", "LPUSH", "RPUSH", "LRANGE", "Hgetall", "Hset", "Hdrop", "Hsetexpires" ]) def __init__(self, table, conn_pool, response_callbacks, metrics_client, *args, **kwargs): transaction = False shard_hint = None super(AbasePipeline, self).__init__(conn_pool, response_callbacks, transaction, shard_hint) self._table = table self._metrics_client = metrics_client def _get_connection(self): if self.connection: return self.connection self.connection = self.connection_pool.get_connection("MULTI", self.shard_hint) return self.connection def execute_command(self, *args, **kwargs): cmd = args[0] if cmd not in AbasePipeline.SUPPORTED_COMMANDS: raise ValueError("{cmd} is not supported, supported cmds are [{cmds}]".format( cmd=cmd, cmds=", ".join(list(AbasePipeline.SUPPORTED_COMMANDS)) )) args = self._transfer_to_abase_cmd(cmd, args[1:]) return super(AbasePipeline, self).execute_command(*args, **kwargs) def execute(self, raise_on_error=True): cmd_name = "PIPELINE" ok = True start = time.time() conn = self._get_connection() try: return self._execute(conn, raise_on_error) except Exception: ok = False raise finally: cost = int((time.time() - start) * 1000 * 1000) rip = "%s_%s" % (conn.host, conn.port) self._metrics_client.emit(ok, latency=cost, method=cmd_name, rip=rip) def _execute(self, conn, raise_on_error): try: return self._execute_pipeline(conn, self.command_stack, raise_on_error) except (ConnectionError, TimeoutError) as e: conn.disconnect() # if retry_on_timeout is not set, or the error is not # a TimeoutError, raise it if not (conn.retry_on_timeout and isinstance(e, TimeoutError)): raise # retry a TimeoutError when retry_on_timeout is set return self._execute_pipeline(conn, self.command_stack, raise_on_error) finally: self.reset() def _transfer_to_abase_cmd(self, cmd, redis_args): abase_args = [cmd] for idx, arg in enumerate(redis_args): if idx == 0 or cmd == 'DEL': abase_args.append(self._compose_abase_key(arg)) else: abase_args.append(arg) return abase_args def _compose_abase_key(self, key): return "[%s]%s" % (self._table, key) def compose_simple_abase_command(command): redis_command = getattr(bytedredis.Client, command) @functools.wraps(redis_command) def abase_command(self, *args, **kwargs): args = list(args) redis_command = getattr(self._redis_client, command) key = self._compose_abase_key(args.pop(0)) return redis_command(key, *args, **kwargs) return abase_command for command in SIMPLE_ABASE_COMMANDS: if hasattr(bytedredis.Client, command): setattr(Client, command, compose_simple_abase_command(command))