How to use the gevent.queue function in gevent

class Broker:

        def subscribe(self, subscriber):
            for idx, _ in enumerate(LIFECYCLE_EVENTS):
                subscriber.put(event(idx))
            subscriber.put(StopIteration)

        def unsubscribe(self, queue):
            queue.put(StopIteration)

    app = vadvisor.app.rest.app
    broker = Broker()
    app.eventBroker = broker
    app.eventStore = InMemoryStore()

    q = queue.Queue()
    broker.subscribe(q)
    for element in q:
        app.eventStore.put(element)

    return app

patcher = patch('steam.core.crypto.symmetric_decrypt')
        self.addCleanup(patcher.stop)
        self.s_dec = patcher.start()
        self.s_dec.side_effect = lambda c, k: c
        patcher = patch('steam.core.crypto.symmetric_decrypt_HMAC')
        self.addCleanup(patcher.stop)
        self.s_dec_hmac = patcher.start()
        self.s_dec_hmac.side_effect = lambda c, k, mac: c

        # mock out TCPConnection
        patcher = patch('steam.core.cm.TCPConnection', autospec=True)
        self.addCleanup(patcher.stop)
        self.conn = patcher.start().return_value

        self.conn_in = gevent.queue.Queue()
        self.conn.__iter__.return_value = self.conn_in

        # mock out CMServerList
        patcher = patch('steam.core.cm.CMServerList', autospec=True)
        self.addCleanup(patcher.stop)
        self.server_list = patcher.start().return_value
        self.server_list.__iter__.return_value = [(127001, 20000+i) for i in range(10)]
        self.server_list.bootstrap_from_webapi.return_value = False
        self.server_list.bootstrap_from_dns.return_value = False

def destroy(self):
        if self._ref and self._ref():
            ref = self._ref()  # grab the ref before we stop, otherwise ref() returns a dead ref
            self.stopped = True
            ref._cell = None
            self._ref = None
        else:
            self.stopped = True
            ref = self.ref
        while True:
            try:
                sender, m = self.queue.get_nowait()
            except gevent.queue.Empty:
                break
            if m == ('_watched', ANY):
                self._watched(m[1])
            elif m == ('__error', ANY, ANY):
                _, exc, tb = m
                self.report((exc, tb))
            elif not (m == ('terminated', ANY) or m == ('_unwatched', ANY) or m == ('_node_down', ANY) or m == '_stop' or m == '_kill' or m == '__done' or m == '__undone'):
                Events.log(DeadLetter(ref, m, sender))
        self.parent_actor.send(('_child_terminated', ref))
        for watcher in (self.watchers or []):
            watcher << ('terminated', ref)
        self.actor = self.inbox = self.queue = self.parent_actor = None

sock.send("\r\n")

    slave = HaystackSlave()
    slave.last_fileno = last_fileno
    slaves.append(slave)

    try:
        while True:
            while slave.last_fileno < haystack.haystack_last_fileno:
                if not post_file(sock, slave.last_fileno+1):
                    return False
                slave.last_fileno += 1
            try:
                slave.waiting = True
                slave.channel.get(timeout=5)
            except queue.Empty:
                if not heartbeat(sock):
                    return False
            finally:
                slave.waiting = False
    finally:
        slaves.remove(slave)

)  # Event when we are trying to send a file.
        self._data_channel_recv = gevent.event.Event()  # Event for receiving a file.
        self.cli_ip, self.cli_port = (
            None,
            None,
        )  # IP and port received from client in active/passive mode.
        self._data_sock = None
        self._data_listener_sock = None
        # socket for accepting cli_ip and cli_port in passive mode.

        self._rnfr = None  # For RNFR and RNTO
        self.metrics = FTPMetrics()  # track session related metrics.

        # Input and output queues.
        self._command_channel_input_q = gevent.queue.Queue()
        self._command_channel_output_q = gevent.queue.Queue()
        self._data_channel_output_q = gevent.queue.Queue()
        self._data_channel_input_q = gevent.queue.Queue()
        self.ftp_greenlets = None  # Keep track of all greenlets
        socketserver.BaseRequestHandler.__init__(
            self, request=request, client_address=client_address, server=server
        )

...     message.finish()

    Or give it to a pool::

        >>> gevent.pool.Pool().map(queue, my_handler)

    :param maxsize: maximum number of messages that can be queued. If less than
        or equal to zero or None, the queue size is infinite.
    """

    def __call__(self, consumer, message):
        message.enable_async()
        self.put(message)


class ChannelHandler(gevent.queue.Channel):
    """Iterator like api for gnsq.

    Like :class:`QueueHandler` with a ``maxsize`` of ``1``.
    """

    def __call__(self, consumer, message):
        message.enable_async()
        self.put(message)

def __init__(self, host, port):
        self._ibuffer = ''
        self._obuffer = ''
        self.iqueue = queue.Queue()
        self.oqueue = queue.Queue()
        self.host = host
        self.port = port
        self._socket = self._create_socket()
        self.jobs = None

# Simple Python script for searching & downloading samples from VirusTotal.

import gevent.monkey
import gevent.queue
gevent.monkey.patch_all()

import click
import os.path
import requests
import time

VT_SEARCH = "https://www.virustotal.com/vtapi/v2/file/search"
VT_DOWNLOAD = "https://www.virustotal.com/vtapi/v2/file/download"

apikey = open(os.path.expanduser("~/.vtdl"), "rb").read().strip()
queue = gevent.queue.Queue()

@click.group()
def vtdl():
    pass

@vtdl.command()
@click.argument("query")
@click.option("-c", "--count", default=100)
def search(query, count):
    data = {
        "apikey": apikey,
        "query": query,
    }

    r = requests.post(VT_SEARCH, data=data)

if brace_count > 0:
                    brace_count -= 1
                    if sub.find('{next_sub}') >= 0:
                        for _ in self.next_subs:
                            self.queue.put((0, sub.replace('{next_sub}', _)))
                    if sub.find('{alphnum}') >= 0:
                        for _ in 'abcdefghijklmnopqrstuvwxyz0123456789':
                            self.queue.put((brace_count, sub.replace('{alphnum}', _, 1)))
                    elif sub.find('{alpha}') >= 0:
                        for _ in 'abcdefghijklmnopqrstuvwxyz':
                            self.queue.put((brace_count, sub.replace('{alpha}', _, 1)))
                    elif sub.find('{num}') >= 0:
                        for _ in '0123456789':
                            self.queue.put((brace_count, sub.replace('{num}', _, 1)))
                    continue
            except gevent.queue.Empty as e:
                break

            try:

                if sub in self.found_subs:
                    continue

                self.scan_count_local += 1
                cur_domain = sub + '.' + self.domain
                answers = self.resolvers[j].query(cur_domain)

                if answers:
                    self.found_subs.add(sub)
                    ips = ', '.join(sorted([answer.address for answer in answers]))
                    if ips in ['1.1.1.1', '127.0.0.1', '0.0.0.0', '0.0.0.1']:
                        continue

def __init__(self, socket):
        self._socket = socket
        self._recv_queue = gevent.queue.Channel()
        self._recv_task = gevent.spawn(self._recver)