async def handle_request(self, channel: Channel, body, envelope,
                             properties, futurize=True):
        """
        the 'futurize' param is simply because aioamqp doesnt send another job until
         this method returns (completes), so we ensure the future of
         ourselves and return immediately so we can handle many requests
         at a time.
        """
        if futurize:
            asyncio.ensure_future(
                self.handle_request(channel, body, envelope, properties,
                                    futurize=False))
            return

        self._counter += 1
        headers = properties.headers or {}
        query = headers.pop('x-wasp-query-string', '').lstrip('?')
        correlation_id = properties.correlation_id
        message_id = properties.message_id
        reply_to = properties.reply_to
        route = envelope.routing_key

        method, path = route.split('.', 1)
        try:
            method = Methods(method.upper())
        except ValueError:
            path = route
            method = 'POST'
        path = path.replace('.', '/')
        # need to use `?` to represent `.` in rabbit
        # since its not valid in a path, it should work correctly everywhere
        path = path.replace('?', '.')
        path = urllib.parse.unquote(path)

        request = Request(
            headers=headers,
            path=path,
            correlation_id=correlation_id,
            method=method,
            query_string=query,
            body=body,
        )
        if properties.content_type:
            headers['content-type'] = properties.content_type
            request.content_type = properties.content_type
        if properties.content_encoding:
            headers['content-encoding'] = properties.content_encoding

        logger.debug('received incoming request via rabbitmq: %s', request)
        response = await self._handler(request)
        if response is None:
            # task got cancelled. Dont send a response.
            return
        if reply_to:
            response.headers['Status'] = str(response.status.value)

            payload = response.raw_body or b'null'

            properties = {
                'correlation_id': response.correlation_id,
                'headers': response.headers,
                'content_type': response.content_type,
                'message_id': message_id,
                'expiration': '30000',
            }
            await self._channel_ready.wait()
            await channel.basic_publish(exchange_name='',
                                        payload=payload,
                                        routing_key=reply_to,
                                        properties=properties)

        if self._use_acks:
            await self.channel.basic_client_ack(delivery_tag=envelope.delivery_tag)
        self._counter -= 1