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()