Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
]
class RedisError(Exception):
"""Base exception class for aioredis exceptions."""
class ProtocolError(RedisError):
"""Raised when protocol error occurs."""
class ReplyError(RedisError):
"""Raised for redis error replies (-ERR)."""
class PipelineError(ReplyError):
"""Raised if command within pipeline raised error."""
def __init__(self, errors):
super().__init__('{} errors:'.format(self.__class__.__name__), errors)
class MultiExecError(PipelineError):
"""Raised if command within MULTI/EXEC block caused error."""
class WatchVariableError(MultiExecError):
"""Raised if watched variable changed (EXEC returns None)."""
class ChannelClosedError(RedisError):
"""Raised when Pub/Sub channel is unsubscribed and messages queue is empty.
async def unset_lock(self, resource, lock_identifier):
"""
Unlock this instance
:param resource: redis key to set
:param lock_identifier: uniquie id of lock
:raises: LockError if the lock resource acquired with different lock_identifier
"""
try:
with await self.connect() as redis:
await redis.eval(
self.unset_lock_script,
keys=[resource],
args=[lock_identifier]
)
except aioredis.errors.ReplyError as exc: # script fault
self.log.debug('Can not unset lock "%s" on %s',
resource, repr(self))
raise LockError('Can not unset lock') from exc
except (aioredis.errors.RedisError, OSError) as exc:
self.log.error('Can not unset lock "%s" on %s: %s',
resource, repr(self), repr(exc))
raise LockError('Can not set lock') from exc
except asyncio.CancelledError:
self.log.debug('Lock "%s" unset is cancelled on %s',
resource, repr(self))
raise
except Exception as exc:
self.log.exception('Can not unset lock "%s" on %s',
resource, repr(self))
raise
else:
def __init__(self, reader, writer, *, address, encoding=None, loop=None):
if loop is None:
loop = asyncio.get_event_loop()
self._reader = reader
self._writer = writer
self._address = address
self._loop = loop
self._waiters = deque()
self._parser = hiredis.Reader(protocolError=ProtocolError,
replyError=ReplyError)
self._reader_task = async_task(self._read_data(), loop=self._loop)
self._db = 0
self._closing = False
self._closed = False
self._close_waiter = create_future(loop=self._loop)
self._reader_task.add_done_callback(self._close_waiter.set_result)
self._in_transaction = None
self._transaction_error = None # XXX: never used?
self._in_pubsub = 0
self._pubsub_channels = coerced_keys_dict()
self._pubsub_patterns = coerced_keys_dict()
self._encoding = encoding
def __init__(self, protocolError=ProtocolError, replyError=ReplyError,
encoding=None):
if not callable(protocolError):
raise TypeError("Expected a callable")
if not callable(replyError):
raise TypeError("Expected a callable")
self._parser = Parser(protocolError, replyError, encoding)