Exemple #1
0
def set_page_url_cache(page_lookup, lang, site_id, url):
    from django.core.cache import cache
    cache.set(_page_url_key(page_lookup, lang, site_id),
              url,
              get_cms_setting('CACHE_DURATIONS')['content'],
              version=_get_cache_version())
    _set_cache_version(_get_cache_version())
Exemple #2
0
def set_placeholder_page_cache(page_lookup, lang, site_id, placeholder_name, content):
    from django.core.cache import cache

    cache.set(_placeholder_page_cache_key(page_lookup, lang, site_id, placeholder_name),
              content,
              get_cms_setting('CACHE_DURATIONS')['content'], version=_get_cache_version())
    _set_cache_version(_get_cache_version())
Exemple #3
0
def set_placeholder_page_cache(page_lookup, lang, site_id, placeholder_name, content):
    from django.core.cache import cache

    cache.set(
        _placeholder_page_cache_key(page_lookup, lang, site_id, placeholder_name),
        content,
        get_cms_setting("CACHE_DURATIONS")["content"],
        version=_get_cache_version(),
    )
    _set_cache_version(_get_cache_version())
def set_placeholder_cache(placeholder, lang, content):
    """
    Caches the rendering of a placeholder
    """
    from django.core.cache import cache
    cache.set(_placeholder_cache_key(placeholder, lang),
              content,
              get_cms_setting('CACHE_DURATIONS')['content'],
              version=_get_cache_version())
    _set_cache_version(_get_cache_version())
Exemple #5
0
def set_placeholder_cache(placeholder, lang, content):
    """
    Caches the rendering of a placeholder
    """
    from django.core.cache import cache

    cache.set(
        _placeholder_cache_key(placeholder, lang),
        content,
        get_cms_setting("CACHE_DURATIONS")["content"],
        version=_get_cache_version(),
    )
    _set_cache_version(_get_cache_version())
Exemple #6
0
def get_placeholder_cache(placeholder, lang):
    """
    Retrieves the cached content of a placeholder
    """
    from django.core.cache import cache

    return cache.get(_placeholder_cache_key(placeholder, lang), version=_get_cache_version())
Exemple #7
0
 def save(self, *args, **kwargs):
     super(Redirection, self).save(*args, **kwargs)
     invalidate_cms_page_cache()
     cache.set('redir:%s:%s:%s' % (self.site_id, self.source, self.enabled),
               self,
               get_cms_setting('CACHE_DURATIONS')['menus'],
               version=_get_cache_version())
Exemple #8
0
def set_blog_page_cache(response):
    from django.core.cache import cache

    if not get_cms_setting('PAGE_CACHE'):
        return response
    request = response._request
    save_cache = True
    for placeholder in getattr(request, 'placeholders', []):
        if not placeholder.cache_placeholder:
            save_cache = False
            break
    if hasattr(request, 'toolbar'):
        if request.toolbar.edit_mode or request.toolbar.show_toolbar:
            save_cache = False
    if request.user.is_authenticated():
        save_cache = False
    if not save_cache:
        add_never_cache_headers(response)
        return response
    else:
        version = _get_cache_version()
        ttl = get_cms_setting('CACHE_DURATIONS')['content']

        cache.set(
            _blog_page_cache_key(request),
            (response.content, response._headers),
            ttl,
            version=version
        )
        # See note in invalidate_cms_page_cache()
        _set_cache_version(version)
Exemple #9
0
def set_page_cache(response):
    from django.core.cache import cache

    if not get_cms_setting('PAGE_CACHE'):
        return response
    request = response._request
    save_cache = True
    for placeholder in getattr(request, 'placeholders', []):
        if not placeholder.cache_placeholder:
            save_cache = False
            break
    if hasattr(request, 'toolbar'):
        if request.toolbar.edit_mode or request.toolbar.show_toolbar:
            save_cache = False
    if request.user.is_authenticated():
        save_cache = False
    if not save_cache:
        add_never_cache_headers(response)
        return response
    else:
        version = _get_cache_version()
        ttl = get_cms_setting('CACHE_DURATIONS')['content']

        cache.set(
            _page_cache_key(request),
            (response.content, response._headers),
            ttl,
            version=version
        )
        # See note in invalidate_cms_page_cache()
        _set_cache_version(version)
Exemple #10
0
def set_page_cache(response):
    from django.core.cache import cache

    request = response._request
    toolbar = get_toolbar_from_request(request)
    is_authenticated = request.user.is_authenticated()

    if is_authenticated or toolbar._cache_disabled or not get_cms_setting(
            "PAGE_CACHE"):
        add_never_cache_headers(response)
        return response

    # This *must* be TZ-aware
    timestamp = now()

    placeholders = toolbar.content_renderer.get_rendered_placeholders()
    # Checks if there's a plugin using the legacy "cache = False"
    placeholder_ttl_list = []
    vary_cache_on_set = set()
    for ph in placeholders:
        # get_cache_expiration() always returns:
        #     EXPIRE_NOW <= int <= MAX_EXPIRATION_IN_SECONDS
        ttl = ph.get_cache_expiration(request, timestamp)
        vary_cache_on = ph.get_vary_cache_on(request)

        placeholder_ttl_list.append(ttl)
        if ttl and vary_cache_on:
            # We're only interested in vary headers if they come from
            # a cache-able placeholder.
            vary_cache_on_set |= set(vary_cache_on)

    if EXPIRE_NOW not in placeholder_ttl_list:
        if placeholder_ttl_list:
            min_placeholder_ttl = min(x for x in placeholder_ttl_list)
        else:
            # Should only happen when there are no placeholders at all
            min_placeholder_ttl = MAX_EXPIRATION_TTL
        ttl = min(
            get_cms_setting('CACHE_DURATIONS')['content'], min_placeholder_ttl)

        if ttl > 0:
            # Adds expiration, etc. to headers
            patch_response_headers(response, cache_timeout=ttl)
            patch_vary_headers(response, sorted(vary_cache_on_set))

            version = _get_cache_version()
            # We also store the absolute expiration timestamp to avoid
            # recomputing it on cache-reads.
            expires_datetime = timestamp + timedelta(seconds=ttl)
            cache.set(_page_cache_key(request), (
                response.content,
                response._headers,
                expires_datetime,
            ),
                      ttl,
                      version=version)
            # See note in invalidate_cms_page_cache()
            _set_cache_version(version)
    return response
Exemple #11
0
def get_placeholder_cache(placeholder, lang):
    """
    Retrieves the cached content of a placeholder
    """
    from django.core.cache import cache

    return cache.get(_placeholder_cache_key(placeholder, lang),
                     version=_get_cache_version())
    def cache_key(self, template_name, template_dirs, skip=None):
        key = super(Loader, self).cache_key(template_name, template_dirs, skip)
        if template_name.startswith(settings.PAGE_TEMP_MEMCACHED):
            new_key = key + '-' + str(_get_cache_version())
            if key in self.cached_templates:
                old_key = self.cached_templates[key]
                if old_key != new_key:
                    del self.get_template_cache[old_key]

            self.cached_templates[key] = new_key
            key = new_key
        return key
def get_cms_templates_list():
    from django.conf import settings
    import copy
    templates = copy.deepcopy(settings.BASE_CMS_TEMPLATES)

    # Fetch the templates list from the cache first
    from django.contrib.sites.models import Site
    from django.core.cache import cache
    from cms.cache import _get_cache_version
    from cms.utils import get_cms_setting

    site_id = Site.objects.get_current().pk
    version = _get_cache_version()
    custom_templates = cache.get('templ:%s' % (site_id), version=version)

    if custom_templates is None:
        custom_templates = dict()
        try:
            from .models import PageTemplate
            from django.contrib.sites.models import Site

            for template in PageTemplate.objects.only(
                    'id', 'name', 'site_id').filter(site_id=site_id,
                                                    enabled=True):
                custom_templates[
                    template.get_template_html_name()] = template.name.title()
        except:
            from .constants import TEMPLATE_DIR
            import os, warnings

            warnings.warn(
                'Getting templates by looking in the template directory')

            for template in os.listdir(TEMPLATE_DIR):
                template_name = get_name_from_filename(template)
                if template_name:
                    custom_templates[template] = template_name.title()

        cache.set('templ:%s' % (site_id),
                  custom_templates,
                  get_cms_setting('CACHE_DURATIONS')['menus'],
                  version=version)

    if not isinstance(custom_templates, long):
        templates.update(custom_templates)
    return templates
Exemple #14
0
def get_page_url_cache(page_lookup, lang, site_id):
    from django.core.cache import cache
    return cache.get(_page_url_key(page_lookup, lang, site_id),
                     version=_get_cache_version())
Exemple #15
0
def set_xframe_cache(page, xframe_options):
    from django.core.cache import cache
    cache.set('cms:xframe_options:%s' % page.pk,
              xframe_options,
              version=_get_cache_version())
    _set_cache_version(_get_cache_version())
Exemple #16
0
def get_placeholder_page_cache(page_lookup, lang, site_id, placeholder_name):
    from django.core.cache import cache

    return cache.get(_placeholder_page_cache_key(page_lookup, lang, site_id,
                                                 placeholder_name),
                     version=_get_cache_version())
Exemple #17
0
def clear_placeholder_cache(placeholder, lang):
    from django.core.cache import cache

    cache.delete(_placeholder_cache_key(placeholder, lang),
                 version=_get_cache_version())
Exemple #18
0
def set_page_cache(response):
    from django.core.cache import cache

    request = response._request
    toolbar = get_toolbar_from_request(request)
    is_authenticated = request.user.is_authenticated()

    if is_authenticated or toolbar._cache_disabled or not get_cms_setting("PAGE_CACHE"):
        add_never_cache_headers(response)
        return response

    # This *must* be TZ-aware
    timestamp = now()

    placeholders = toolbar.content_renderer.get_rendered_placeholders()
    # Checks if there's a plugin using the legacy "cache = False"
    placeholder_ttl_list = []
    vary_cache_on_set = set()
    for ph in placeholders:
        # get_cache_expiration() always returns:
        #     EXPIRE_NOW <= int <= MAX_EXPIRATION_IN_SECONDS
        ttl = ph.get_cache_expiration(request, timestamp)
        vary_cache_on = ph.get_vary_cache_on(request)

        placeholder_ttl_list.append(ttl)
        if ttl and vary_cache_on:
            # We're only interested in vary headers if they come from
            # a cache-able placeholder.
            vary_cache_on_set |= set(vary_cache_on)

    if EXPIRE_NOW not in placeholder_ttl_list:
        if placeholder_ttl_list:
            min_placeholder_ttl = min(x for x in placeholder_ttl_list)
        else:
            # Should only happen when there are no placeholders at all
            min_placeholder_ttl = MAX_EXPIRATION_TTL
        ttl = min(
            get_cms_setting('CACHE_DURATIONS')['content'],
            min_placeholder_ttl
        )

        if ttl > 0:
            # Adds expiration, etc. to headers
            patch_response_headers(response, cache_timeout=ttl)
            patch_vary_headers(response, sorted(vary_cache_on_set))

            version = _get_cache_version()
            # We also store the absolute expiration timestamp to avoid
            # recomputing it on cache-reads.
            expires_datetime = timestamp + timedelta(seconds=ttl)
            cache.set(
                _page_cache_key(request),
                (
                    response.content,
                    response._headers,
                    expires_datetime,
                ),
                ttl,
                version=version
            )
            # See note in invalidate_cms_page_cache()
            _set_cache_version(version)
    return response
Exemple #19
0
def get_blog_page_cache(request):
    from django.core.cache import cache

    return cache.get(_blog_page_cache_key(request),
                     version=_get_cache_version())
Exemple #20
0
def clear_placeholder_cache(placeholder, lang):
    from django.core.cache import cache

    cache.delete(_placeholder_cache_key(placeholder, lang), version=_get_cache_version())
Exemple #21
0
def set_xframe_cache(page, xframe_options):
    from django.core.cache import cache
    cache.set('cms:xframe_options:%s' % page.pk,
              xframe_options,
              version=_get_cache_version())
    _set_cache_version(_get_cache_version())
Exemple #22
0
def get_page_url_cache(page_lookup, lang, site_id):
    from django.core.cache import cache
    return cache.get(_page_url_key(page_lookup, lang, site_id),
                     version=_get_cache_version())
Exemple #23
0
def get_page_cache(request):
    from django.core.cache import cache
    return cache.get(_page_cache_key(request), version=_get_cache_version())
Exemple #24
0
def get_placeholder_page_cache(page_lookup, lang, site_id, placeholder_name):
    from django.core.cache import cache

    return cache.get(
        _placeholder_page_cache_key(page_lookup, lang, site_id, placeholder_name), version=_get_cache_version()
    )
Exemple #25
0
    def test_cache_page(self):
        # Ensure that we're testing in an environment WITHOUT the MW cache...
        exclude = [
            'django.middleware.cache.UpdateCacheMiddleware',
            'django.middleware.cache.FetchFromCacheMiddleware'
        ]
        overrides = dict()
        if getattr(settings, 'MIDDLEWARE', None):
            overrides['MIDDLEWARE'] = [mw for mw in settings.MIDDLEWARE if mw not in exclude]
        else:
            overrides['MIDDLEWARE_CLASSES'] = [mw for mw in settings.MIDDLEWARE_CLASSES if mw not in exclude]
        with self.settings(**overrides):

            # Silly to do these tests if this setting isn't True
            page_cache_setting = get_cms_setting('PAGE_CACHE')
            self.assertTrue(page_cache_setting)

            # Create a test page
            page1 = create_page('test page 1', 'nav_playground.html', 'en', published=True)

            # Add some content
            placeholder = page1.placeholders.filter(slot="body")[0]
            add_plugin(placeholder, "TextPlugin", 'en', body="English")
            add_plugin(placeholder, "TextPlugin", 'de', body="Deutsch")

            # Create a request object
            request = self.get_request(page1.get_path(), 'en')

            # Ensure that user is NOT authenticated
            self.assertFalse(request.user.is_authenticated())

            # Test that the page is initially uncached
            with self.assertNumQueries(FuzzyInt(1, 24)):
                response = self.client.get('/en/')
            self.assertEqual(response.status_code, 200)

            #
            # Test that subsequent requests of the same page are cached by
            # asserting that they require fewer queries.
            #
            with self.assertNumQueries(0):
                response = self.client.get('/en/')
            self.assertEqual(response.status_code, 200)

            #
            # Test that the cache is invalidated on unpublishing the page
            #
            old_version = _get_cache_version()
            page1.unpublish('en')
            self.assertGreater(_get_cache_version(), old_version)

            #
            # Test that this means the page is actually not cached.
            #
            page1.publish('en')
            with self.assertNumQueries(FuzzyInt(1, 24)):
                response = self.client.get('/en/')
            self.assertEqual(response.status_code, 200)

            #
            # Test that the above behavior is different when CMS_PAGE_CACHE is
            # set to False (disabled)
            #
            with self.settings(CMS_PAGE_CACHE=False):

                # Test that the page is initially un-cached
                with self.assertNumQueries(FuzzyInt(1, 20)):
                    response = self.client.get('/en/')
                self.assertEqual(response.status_code, 200)

                #
                # Test that subsequent requests of the same page are still requires DB
                # access.
                #
                with self.assertNumQueries(FuzzyInt(1, 20)):
                    response = self.client.get('/en/')
                self.assertEqual(response.status_code, 200)
Exemple #26
0
def set_page_url_cache(page_lookup, lang, site_id, url):
    from django.core.cache import cache
    cache.set(_page_url_key(page_lookup, lang, site_id),
              url,
              get_cms_setting('CACHE_DURATIONS')['content'], version=_get_cache_version())
    _set_cache_version(_get_cache_version())