except ChangesetDoesNotExistError:

            return _('Unknown revision %s') % revision

        except EmptyRepositoryError:

            return _('Empty repository')

        except (ImproperArchiveTypeError, KeyError):

            return _('Unknown archive type')

        fd, archive = tempfile.mkstemp()

        t = open(archive, 'wb')

        cs.fill_archive(stream=t, kind=fileformat, subrepos=subrepos)

        t.close()

        def get_chunked_archive(archive):

            stream = open(archive, 'rb')

            while True:

                data = stream.read(16 * 1024)

                if not data:

                    stream.close()

                    os.close(fd)

                    os.remove(archive)

                    break

                yield data

        response.content_disposition = str('attachment; filename=%s-%s%s' \

        response.content_type = str(content_type)

        return get_chunked_archive(archive)

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def diff(self, repo_name, f_path):

        ignore_whitespace = request.GET.get('ignorews') == '1'

        line_context = request.GET.get('context', 3)

        diff1 = request.GET.get('diff1', '')

        diff2 = request.GET.get('diff2', '')

        c.action = request.GET.get('diff')

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        c.big_diff = False

        c.anchor_url = anchor_url

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        c.changes = OrderedDict()

        c.changes[diff2] = []

        #special case if we want a show rev only, it's impl here

        #to reduce JS and callbacks

        inv = cls._get_or_create_key(key, repo_name)

        if inv and inv.cache_active is False:

            return inv

    @classmethod

    def set_invalidate(cls, key=None, repo_name=None):

        """

        Mark this Cache key for invalidation, either by key or whole

        cache sets based on repo_name

        :param key:

        """

        invalidated_keys = []

        if key:

            key, _prefix, _org_key = cls._get_key(key)

            inv_objs = Session().query(cls).filter(cls.cache_key == key).all()

        elif repo_name:

            inv_objs = Session().query(cls).filter(cls.cache_args == repo_name).all()

        try:

            for inv_obj in inv_objs:

                inv_obj.cache_active = False

                log.debug('marking %s key for invalidation based on key=%s,repo_name=%s'

                invalidated_keys.append(inv_obj.cache_key)

                Session().add(inv_obj)

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            Session().rollback()

        return invalidated_keys

    @classmethod

    def set_valid(cls, key):

        """

        Mark this cache key as active and currently cached

        :param key:

        """

        inv_obj = cls.get_by_key(key)

        inv_obj.cache_active = True

        Session().add(inv_obj)

        Session().commit()

    @classmethod

    def get_cache_map(cls):

        class cachemapdict(dict):