<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def report(self, req):
 """Adds a report request to the cache. Returns ``None`` if it could not be aggregated, and callers need to send the request to the server, otherwise it returns ``CACHED_OK``. Args: req (:class:`sc_messages.ReportRequest`):
 the request to be aggregated Result: ``None`` if the request as not cached, otherwise ``CACHED_OK`` """

        if self._cache is None:
            return None  # no cache, send request now
        if not isinstance(req, sc_messages.ServicecontrolServicesReportRequest):
            raise ValueError(u'Invalid request')
        if req.serviceName != self.service_name:
            _logger.error(u'bad report(): service_name %s does not match ours %s',
                          req.serviceName, self.service_name)
            raise ValueError(u'Service name mismatch')
        report_req = req.reportRequest
        if report_req is None:
            _logger.error(u'bad report(): no report_request in %s', req)
            raise ValueError(u'Expected report_request not set')
        if _has_high_important_operation(report_req) or self._cache is None:
            return None
        ops_by_signature = _key_by_signature(report_req.operations,
                                             _sign_operation)

        # Concurrency:
        #
        # This holds a lock on the cache while updating it.  No i/o operations
        # are performed, so any waiting threads see minimal delays
        with self._cache as cache:
            for key, op in ops_by_signature.items():
                agg = cache.get(key)
                if agg is None:
                    cache[key] = operation.Aggregator(op, self._kinds)
                else:
                    agg.add(op)

        return self.CACHED_OK