def __init__(self,
plugins_manager: PluginManager,
session: Session = None):
self.logger = logging.getLogger(__name__ + "." +
self.__class__.__name__)
if session:
self._init_session(session)
else:
self.session = None
self.stream = None
self.plugins_manager = plugins_manager
self._tg = plugins_manager._tg
self._reader_task = None
self._sender_task = None
self._reader_stopped = anyio.create_event()
self._sender_stopped = anyio.create_event()
self._send_q = anyio.create_queue(10)
self._puback_waiters = dict()
self._pubrec_waiters = dict()
self._pubrel_waiters = dict()
self._pubcomp_waiters = dict()
self._disconnecting = False
self._disconnect_waiter = None
self._write_lock = anyio.create_lock()
def __new__(cls, service, id): # pylint: disable=redefined-builtin
family_id, code, chksum = split_id(id)
cls = dev_classes.get(family_id) # pylint: disable=self-cls-assignment
if cls is None:
class cls(Device): # pylint: disable=function-redefined
family = family_id
cls.__name__ = "Device_%02x" % (family_id, )
dev_classes[family_id] = cls
self = object.__new__(cls)
self.id = id.upper()
self.family = family_id
self.code = code
self.chksum = chksum
self.service = service
self.bus = None
self._unseen = 0
self._events = []
self._wait_bus = anyio.create_event()
self._poll = {} # name > poll task scopes
self._intervals = {}
self._task_lock = anyio.create_lock()
return self
async def run(self, evt: anyio.abc.Event=None):
"""
Process my events.
Override+call this e.g. for overall timeouts::
async def run(self):
async with anyio.fail_after(30):
await super().run()
This method creates a runner task that do the actual event processing.
A new runner is started if processing an event takes longer than 0.1 seconds.
Do not replace this method. Do not call it directly.
"""
log.debug("SetupRun %r < %r", self, getattr(self, '_prev', None))
if evt is not None:
await evt.set()
await self.on_start()
if self._ready is not None:
await self._ready.set()
self._proc_lock = anyio.create_lock()
while True:
if self._n_proc == 0:
await self.taskgroup.spawn(self._process, name="Worker " + self.ref_id)
self._proc_check = anyio.create_event()
await anyio.sleep(0.1)
await self._proc_check.wait()
def __init__(self, name, channel, number, prio=0, **kw):
self.name = name
self.channel = channel
self.number = number
self._prio = prio
for k, v in kw.items():
setattr(self, k, v)
self.lock = anyio.create_lock()
async def _get_config_dict_lock(self):
# TODO: make this multithreaded?
if self._config_dict_lock is None:
self._config_dict_lock = anyio.create_lock()
return self._config_dict_lock
async def test_acquire_nowait_wouldblock(self):
async def try_lock():
pytest.raises(WouldBlock, lock.acquire_nowait)
lock = create_lock()
async with lock, create_task_group() as tg:
assert lock.locked()
tg.spawn(try_lock)
def __init__(self, tg, host="localhost", port=7373):
type(self)._conn_id += 1
self._conn_id = type(self)._conn_id
self.tg = tg
self.host = host
self.port = port
self._socket = None
self._seq = 0
self._handlers = {}
self._send_lock = anyio.create_lock()
def __init__(self, sock: anyio.SocketStream):
"""
:param sock: The :class:`anyio.SocketStream` used to connect this redis database.
"""
self._sock = sock
self._parser_lock = anyio.create_lock()
self._parser = hiredis.Reader()
self._pipeline = None
self._closed = False
def __init__(self, bucket: Bucket, response: Response):
self.bucket = bucket
# These values will be set later.
self._date = None
self._remaining = 0
self._reset = None
self.lock = anyio.create_lock()
self.update(response)
def __init__(self, service, host="localhost", port=4304):
self.service = service
self.host = host
self.port = port
self.stream = None
self._msg_proto = None
self.requests = deque()
self._wqueue = anyio.create_queue(100)
self._scan_task = None
self._buses = dict() # path => bus
self._scan_lock = anyio.create_lock()
self._scan_args = {}
def __init__(self, taskgroup, host, port=59995, freq=None, ping_freq=None):
self.task_group = taskgroup
self.host = host
self.port = port
if freq is not None:
self.freq = freq
if ping_freq is not None:
self.ping_freq = freq
self._ports = {}
self._cmds = []
self._send_lock = anyio.create_lock()
async def __new__(cls):
self = super().__new__(cls)
self._handlers = []
self._command_lock = anyio.create_lock()
import sys
self._keepalive = sys._getframe()
async with anyio.create_task_group() as self._group:
proc = await anyio.run_process(["i3", "--get-socketpath"])
path = proc.stdout.decode().strip()
async with await anyio.connect_unix(path) as self._sock:
await self._group.spawn(self._loop)
yield self
await self._group.cancel_scope.cancel()
async def test_lock_cancel(self):
async def task():
nonlocal task_started, got_lock
task_started = True
async with lock:
got_lock = True
task_started = got_lock = False
lock = create_lock()
async with create_task_group() as tg:
async with lock:
await tg.spawn(task)
await tg.cancel_scope.cancel()
assert task_started
assert not got_lock
async def test_lock(self):
async def task():
assert lock.locked()
async with lock:
results.append('2')
results = []
lock = create_lock()
async with create_task_group() as tg:
async with lock:
await tg.spawn(task)
await wait_all_tasks_blocked()
results.append('1')
assert not lock.locked()
assert results == ['1', '2']
def __init__(self, service, host="localhost", port=4304, name=None):
self.service = service
self.host = host
self.port = port
self.name = name or host
self.stream = None
self._msg_proto = None
self.requests = deque()
self._wqueue_w, self._wqueue_r = anyio.create_memory_object_stream(100)
self._read_task = None
self._write_task = None
self._scan_task = None
self._buses = dict() # path => bus
self._scan_lock = anyio.create_lock()
self._scan_args = None
self._backoff = 2
self._current_tg = None
self._current_run = None
async def test_statistics(self):
async def waiter():
async with lock:
pass
lock = create_lock()
async with create_task_group() as tg:
assert not lock.statistics().locked
assert lock.statistics().tasks_waiting == 0
async with lock:
assert lock.statistics().locked
assert lock.statistics().tasks_waiting == 0
for i in range(1, 3):
tg.spawn(waiter)
await wait_all_tasks_blocked()
assert lock.statistics().tasks_waiting == i
assert not lock.statistics().locked
assert lock.statistics().tasks_waiting == 0
def __init__(self, protocol, channel_id):
self.protocol = protocol
self.channel_id = channel_id
self.consumer_queues = {}
self.consumer_callbacks = {}
self.response_future = None
self.close_event = anyio.create_event()
self.cancelled_consumers = set()
self.last_consumer_tag = None
self.publisher_confirms = False
self.delivery_tag_iter = None
# counting iterator, used for mapping delivered messages
# to publisher confirms
self._write_lock = anyio.create_lock()
self._futures = {}
self._ctag_events = {}
def __init__(self,
links,
name,
*,
timeout,
mode="dtmf",
info="-",
src=None,
dst=None,
**kw):
self.name = name
self.mode = importlib.import_module("calltest.mode." + mode).Worker
self.src = links[src] if src is not None else None
self.dst = links[dst] if dst is not None else None
self.info = info
self.timeout = timeout
self.state = attrdict(status="new", ct_wait=0, ct_run=0)
self.state.t_start = time.time()
for k, v in kw.items():
setattr(self, k, v)
self.lock = anyio.create_lock()
async def test_manual_acquire(self):
async def task():
assert lock.locked()
await lock.acquire()
try:
results.append('2')
finally:
lock.release()
results = []
lock = create_lock()
async with create_task_group() as tg:
await lock.acquire()
try:
tg.spawn(task)
await wait_all_tasks_blocked()
results.append('1')
finally:
lock.release()
assert not lock.locked()
assert results == ['1', '2']
def __init__(self):
self._buckets = {}
self.global_lock = anyio.create_lock()
def lock():
return anyio.create_lock()
async def test_lock_release(self):
lock = create_lock()
lock.acquire_nowait()
with pytest.deprecated_call():
await lock.release()
async def test_acquire_nowait(self):
lock = create_lock()
lock.acquire_nowait()
assert lock.locked()
def __init__(self, stream: ByteStream) -> None:
self.stream = stream
self.read_lock = create_lock()
self.write_lock = create_lock()
async def main():
lock = create_lock()
async with create_task_group() as tg:
for num in range(4):
await tg.spawn(use_resource, num, lock)
def __init__(self, stream):
self.stream = stream
self.lock = anyio.create_lock()
def __init__(self, *a, **kw):
self._a = a
self._kw = kw
self._send_lock = anyio.create_lock()
self._receive_lock = anyio.create_lock()
async def _get_index_lock(self) -> Lock:
if self._index_lock is None:
self._index_lock = create_lock()
return self._index_lock
def __init__(self, sock):
self.sock = sock
self.lock = anyio.create_lock()
def __init__(self) -> None:
self._lock = create_lock()
async def _get_init_lock(self):
if self._init_lock is None:
self._init_lock = anyio.create_lock()
return self._init_lock
