def put(self, item, block=True, timeout=None):
"""Put item into the queue"""
if self.maxsize > 0:
if not block:
if self.qsize() >= self.maxsize:
raise Full('Redis queue is full')
elif timeout is None:
while self.qsize() >= self.maxsize:
_sleep(0.1)
elif timeout < 0:
raise ValueError("'timeout' must be a positive number")
else:
endtime = _time() + timeout
while self.qsize() >= self.maxsize:
remaining = endtime - _time()
if remaining <= 0.0:
raise Full('Redis queue is full')
_sleep(0.1)
if type(item) is not list:
item = [
item,
]
elif len(item) < 1:
return False
pipe = self.__db.pipeline()
for i in item:
i = self.__serialize(i)
pipe.lpush(self.key, i)
pipe.execute()
def test_put_full(self, fake_queue):
fake_queue().put.side_effect = SideEffect([Full(), Full(), None])
# test
item = Mock()
queue = RequestQueue(Mock())
queue.put(item)
# validation
self.assertEqual(fake_queue().put.call_count, 3)
def test_put_full(self, fake_queue):
canceled = Mock()
canceled.is_set.return_value = False
fake_queue().put.side_effect = SideEffect([Full(), Full(), None])
# test
item = Mock()
queue = RequestQueue(canceled, Mock())
queue.put(item)
# validation
self.assertEqual(fake_queue().put.call_count, 3)
def put(self, item, block=True, timeout=None):
"""put an item into the queue
.. note::
if the queue was created with a `maxsize` and it is currently
:meth:`full`, this method will block the calling coroutine until
another coroutine :meth:`get`\ s an item.
:param item: the object to put into the queue, can be any type
:param block:
whether to block if the queue is already :meth:`full` (default
``True``)
:type block: bool
:param timeout:
the maximum time in seconds to block waiting. with the default of
``None``, it can wait indefinitely. this is unused if `block` is
``False``.
:type timeout: int, float or None
:raises:
:class:`Full` if the queue is :meth:`full` and `block` is
``False``, or if `timeout` expires.
"""
if self.full():
if not block:
raise Full()
current = compat.getcurrent()
waketime = None if timeout is None else time.time() + timeout
if timeout is not None:
scheduler.schedule_at(waketime, current)
self._waiters.append((current, waketime))
scheduler.state.mainloop.switch()
if timeout is not None:
if not scheduler._remove_timer(waketime, current):
self._waiters.remove((current, waketime))
raise Full()
if self._waiters and not self.full():
scheduler.schedule(self._waiters.popleft()[0])
if not self._open_tasks:
self._jobs_done.clear()
self._open_tasks += 1
self._put(item)
def put(self, data):
room = len(data) > self.memory_size - self.qusize
if room:
raise Full("Not enough room in queue")
indexes = (self.qutail + np.arange(len(data))) % self.memory_size
self.memory[indexes] = data
self.qusize += len(data)
self.qutail += len(data)
def put(self, data):
self.queue_mutex.acquire()
room = len(data) > self.memory_size - self.qusize
self.queue_mutex.release()
if room:
raise Full("Not enough room in queue")
self.queue_mutex.acquire()
indexes = (self.qutail + np.arange(len(data))) % self.memory_size
self.memory[indexes] = data
self.qusize += len(data)
self.queue_mutex.release()
self.qutail += len(data)
def _do_get(self):
while True:
try:
with self._lock:
if self._available:
t, connection = self._available.pop(0)
self.logger.debug('pop connection (%s available, %s in use)', len(self._available), len(self._inuse))
else:
if self.max_connections is not None and len(self._inuse) >= self.max_connections:
self._is_not_full.clear()
raise Full('max connections of %s reached' % self.max_connections)
connection = self._create_connection()
self.logger.info('new connection (%s available, %s in use)', len(self._available), len(self._inuse) + 1)
self._inuse.append(connection)
except Full:
if self.is_full_event == 'wait':
self.logger.warning('pool full. waiting for available slot (%s available, %s in use)', len(self._available), len(self._inuse))
self._is_not_full.wait()
else:
raise
else:
return connection
def put(self, item):
"""Put an item into the queue."""
if self.full():
raise Full()
self._append(item)
def reject_handler(queue, item):
raise Full()