def check(self, req):
        """Determine if ``req`` is in this instances cache.

        Determine if there are cache hits for the request in this aggregator
        instance.

        Not in the cache

        If req is not in the cache, it returns ``None`` to indicate that the
        caller should send the request.

        Cache Hit; response has errors

        When a cached CheckResponse has errors, it's assumed that ``req`` would
        fail as well, so the cached CheckResponse is returned.  However, the
        first CheckRequest after the flush interval has elapsed should be sent
        to the server to refresh the CheckResponse, though until it's received,
        subsequent CheckRequests should fail with the cached CheckResponse.

        Cache behaviour - response passed

        If the cached CheckResponse has no errors, it's assumed that ``req``
        will succeed as well, so the CheckResponse is returned, with the quota
        info updated to the same as requested.  The requested tokens are
        aggregated until flushed.

        Args:
          req (``ServicecontrolServicesCheckRequest``): to be sent to
            the service control service

        Raises:
           ValueError: if the ``req`` service_name is not the same as
             this instances

        Returns:
           ``CheckResponse``: if an applicable response is cached by this
             instance is available for use or None, if there is no applicable
             response

        """
        if self._cache is None:
            return None  # no cache, send request now
        if not isinstance(req, sc_messages.ServicecontrolServicesCheckRequest):
            raise ValueError(u'Invalid request')
        if req.serviceName != self.service_name:
            _logger.error(u'bad check(): service_name %s does not match ours %s',
                          req.serviceName, self.service_name)
            raise ValueError(u'Service name mismatch')
        check_request = req.checkRequest
        if check_request is None:
            _logger.error(u'bad check(): no check_request in %s', req)
            raise ValueError(u'Expected operation not set')
        op = check_request.operation
        if op is None:
            _logger.error(u'bad check(): no operation in %s', req)
            raise ValueError(u'Expected operation not set')
        if op.importance != sc_messages.Operation.ImportanceValueValuesEnum.LOW:
            return None  # op is important, send request now

        signature = sign(check_request)
        with self._cache as cache:
            _logger.debug(u'checking the cache for %r\n%s', signature, cache)
            item = cache.get(signature)
            if item is None:
                return None  # signal to caller to send req
            else:
                return self._handle_cached_response(req, item)