def test_test_rewriter(self): @implementer(IPurgePaths) @adapter(FauxContext) class FauxPurgePaths(object): def __init__(self, context): self.context = context def getRelativePaths(self): return ["/foo", "/bar"] def getAbsolutePaths(self): return ["/baz"] provideAdapter(FauxPurgePaths, name="test1") @implementer(IPurgePathRewriter) @adapter(FauxRequest) class DefaultRewriter(object): def __init__(self, request): self.request = request def __call__(self, path): return ["/vhm1" + path, "/vhm2" + path] provideAdapter(DefaultRewriter) self.assertEqual( ["/vhm1/foo", "/vhm2/foo", "/vhm1/bar", "/vhm2/bar", "/baz"], list(utils.getPathsToPurge(self.context, self.request)), )
def test_test_rewriter(self): class FauxPurgePaths(object): implements(IPurgePaths) adapts(FauxContext) def __init__(self, context): self.context = context def getRelativePaths(self): return ['/foo', '/bar'] def getAbsolutePaths(self): return ['/baz'] provideAdapter(FauxPurgePaths, name="test1") class DefaultRewriter(object): implements(IPurgePathRewriter) adapts(FauxRequest) def __init__(self, request): self.request = request def __call__(self, path): return ['/vhm1' + path, '/vhm2' + path] provideAdapter(DefaultRewriter) self.assertEqual( ['/vhm1/foo', '/vhm2/foo', '/vhm1/bar', '/vhm2/bar', '/baz'], list(utils.getPathsToPurge(self.context, self.request)))
def queuePurge(event, force=False): """ so this is a little wonky here... We need to also purge here because plone.cachepurging will only update paths if caching proxies are defined. The deal here is that with cloudflare, we do not want to define caching proxies or we may not be """ request = getRequest() if request is None: return annotations = IAnnotations(request, None) if annotations is None: return registry = queryUtility(IRegistry) if registry is None: return settings = registry.forInterface(ICachePurgingSettings, check=False) if not settings.enabled: return # so we're enabled, BUT we also need to NOT have proxies defined # in order to register here if bool(settings.cachingProxies) and not force: return paths = annotations.setdefault(KEY, set()) paths.update(getPathsToPurge(event.object, request))
def queuePurge(event, force=False): """ so this is a little wonky here... We need to also purge here because plone.cachepurging will only update paths if caching proxies are defined. The deal here is that with cloudflare, we do not want to define caching proxies or we may not be """ request = getRequest() if request is None: return annotations = IAnnotations(request, None) if annotations is None: return registry = queryUtility(IRegistry) if registry is None: return settings = registry.forInterface(ICachePurgingSettings, check=False) if not settings.enabled: return # THIS IS THE OVERRIDE HERE!!! # the original event goes forward IF there are cache proxies defined. # so we check if they are NOT and then only force puring if bool(settings.cachingProxies) and not force: return paths = annotations.setdefault(KEY, set()) paths.update(getPathsToPurge(event.object, request))
def test_test_rewriter(self): class FauxPurgePaths(object): implements(IPurgePaths) adapts(FauxContext) def __init__(self, context): self.context = context def getRelativePaths(self): return ['/foo', '/bar'] def getAbsolutePaths(self): return ['/baz'] provideAdapter(FauxPurgePaths, name="test1") class DefaultRewriter(object): implements(IPurgePathRewriter) adapts(FauxRequest) def __init__(self, request): self.request = request def __call__(self, path): return ['/vhm1' + path, '/vhm2' + path] provideAdapter(DefaultRewriter) self.assertEqual(['/vhm1/foo', '/vhm2/foo', '/vhm1/bar', '/vhm2/bar', '/baz'], list(utils.getPathsToPurge(self.context, self.request)))
def test_multiple_purge_paths(self): @implementer(IPurgePaths) @adapter(FauxContext) class FauxPurgePaths1(object): def __init__(self, context): self.context = context def getRelativePaths(self): return ['/foo', '/bar'] def getAbsolutePaths(self): return ['/baz'] provideAdapter(FauxPurgePaths1, name="test1") @implementer(IPurgePaths) @adapter(FauxContext) class FauxPurgePaths2(object): def __init__(self, context): self.context = context def getRelativePaths(self): return ['/foo/view'] def getAbsolutePaths(self): return ['/quux'] provideAdapter(FauxPurgePaths2, name="test2") @implementer(IPurgePathRewriter) @adapter(FauxRequest) class DefaultRewriter(object): def __init__(self, request): self.request = request def __call__(self, path): return ['/vhm1' + path, '/vhm2' + path] provideAdapter(DefaultRewriter) self.assertEqual( [ '/vhm1/foo', '/vhm2/foo', '/vhm1/bar', '/vhm2/bar', '/baz', '/vhm1/foo/view', '/vhm2/foo/view', '/quux' ], list(utils.getPathsToPurge(self.context, self.request)) )
def purge(self): site_path = '/'.join(api.portal.get().getPhysicalPath()) cf = cloudflare.get() paths = [] urls = [] context = self.context dp = get_default_page(context) if dp: try: context = context[dp] except Exception: pass objs = [context] for ref in get_content_links(context): try: objs.append(ref.to_object) except Exception: pass for obj in objs: paths.extend(getPathsToPurge(obj, self.request)) for path in paths: urls.extend(cf.getUrlsToPurge(path)) urls = list(set(urls)) registry = getUtility(IRegistry) settings = registry.forInterface(ICachePurgingSettings, check=False) purger = queryUtility(IPurger) if purger and settings.cachingProxies: self.proxy_enabled = True for path in paths: for url in getURLsToPurge(path, settings.cachingProxies): purger.purgeAsync(url) success = True if cf.enabled: self.cf_enabled = True resp = CastlePurger.purgeSync(urls, cf) success = resp.json()['success'] notify(CacheInvalidatedEvent(self)) nice_paths = [] for path in paths: if 'VirtualHostRoot' in path: path = path.split('VirtualHostRoot')[-1] else: path = path[len(site_path):] nice_paths.append(path.decode('utf-8')) return nice_paths, success
def queuePurge(event): """Find URLs to purge and queue them for later """ request = getRequest() if request is None: return annotations = IAnnotations(request, None) if annotations is None: return if not isCachePurgingEnabled(): return paths = annotations.setdefault(KEY, set()) paths.update(getPathsToPurge(event.object, request))
def test_rewriter_abort(self): class FauxPurgePaths1(object): implements(IPurgePaths) adapts(FauxContext) def __init__(self, context): self.context = context def getRelativePaths(self): return ['/foo', '/bar'] def getAbsolutePaths(self): return ['/baz'] provideAdapter(FauxPurgePaths1, name="test1") class FauxPurgePaths2(object): implements(IPurgePaths) adapts(FauxContext) def __init__(self, context): self.context = context def getRelativePaths(self): return ['/foo/view'] def getAbsolutePaths(self): return ['/quux'] provideAdapter(FauxPurgePaths2, name="test2") class DefaultRewriter(object): implements(IPurgePathRewriter) adapts(FauxRequest) def __init__(self, request): self.request = request def __call__(self, path): return [] provideAdapter(DefaultRewriter) self.assertEquals(['/baz', '/quux'], list(utils.getPathsToPurge(self.context, self.request)))
def test_no_rewriter(self): class FauxPurgePaths(object): implements(IPurgePaths) adapts(FauxContext) def __init__(self, context): self.context = context def getRelativePaths(self): return ['/foo', '/bar'] def getAbsolutePaths(self): return ['/baz'] provideAdapter(FauxPurgePaths, name="test1") self.assertEqual(['/foo', '/bar', '/baz'], list(utils.getPathsToPurge(self.context, self.request)))
def __call__(self): if not isCachePurgingEnabled(): return "Caching not enabled" registry = getUtility(IRegistry) settings = registry.forInterface(ICachePurgingSettings) purger = getUtility(IPurger) out = StringIO() for path in getPathsToPurge(self.context, self.request): for url in getURLsToPurge(path, settings.cachingProxies): status, xcache, xerror = purger.purgeSync(url) out.write( RESULT_TPL.format( url=url, status=status, xcache=xcache, xerror=xerror ) ) return out.getvalue()
def __call__(self): if not isCachePurgingEnabled(): return 'Caching not enabled' registry = getUtility(IRegistry) settings = registry.forInterface(ICachePurgingSettings) purger = getUtility(IPurger) out = StringIO() for path in getPathsToPurge(self.context, self.request): for url in getURLsToPurge(path, settings.cachingProxies): status, xcache, xerror = purger.purgeSync(url) print >> out, "Purged", url, "Status", status, "X-Cache", xcache, "Error:", xerror return out.getvalue()
def test_empty_relative_paths(self): @implementer(IPurgePaths) class FauxPurgePaths(object): adapts(FauxContext) def __init__(self, context): self.context = context def getRelativePaths(self): return [] def getAbsolutePaths(self): return [] provideAdapter(FauxPurgePaths, name="test1") self.assertEqual([], list(utils.getPathsToPurge(self.context, self.request)))
def test_no_rewriter(self): @implementer(IPurgePaths) @adapter(FauxContext) class FauxPurgePaths(object): def __init__(self, context): self.context = context def getRelativePaths(self): return ['/foo', '/bar'] def getAbsolutePaths(self): return ['/baz'] provideAdapter(FauxPurgePaths, name="test1") self.assertEqual(['/foo', '/bar', '/baz'], list(utils.getPathsToPurge(self.context, self.request)))
def test_empty_relative_paths(self): @implementer(IPurgePaths) @adapter(FauxContext) class FauxPurgePaths(object): def __init__(self, context): self.context = context def getRelativePaths(self): return [] def getAbsolutePaths(self): return [] provideAdapter(FauxPurgePaths, name="test1") self.assertEqual( [], list(utils.getPathsToPurge(self.context, self.request)) )
def __call__(self): if not isCachePurgingEnabled(): return 'Caching not enabled' registry = getUtility(IRegistry) settings = registry.forInterface(ICachePurgingSettings) purger = getUtility(IPurger) out = StringIO() for path in getPathsToPurge(self.context, self.request): for url in getURLsToPurge(path, settings.cachingProxies): status, xcache, xerror = purger.purgeSync(url) print >>out, "Purged", url, "Status", status, "X-Cache", xcache, "Error:", xerror return out.getvalue()
def __call__(self): if not isCachePurgingEnabled(): return "Caching not enabled" registry = getUtility(IRegistry) settings = registry.forInterface(ICachePurgingSettings) purger = getUtility(IPurger) out = StringIO() for path in getPathsToPurge(self.context, self.request): for url in getURLsToPurge(path, settings.cachingProxies): status, xcache, xerror = purger.purgeSync(url) out.write( RESULT_TPL.format(url=url, status=status, xcache=xcache, xerror=xerror)) return out.getvalue()
def test_no_rewriter(self): @implementer(IPurgePaths) @adapter(FauxContext) class FauxPurgePaths(object): def __init__(self, context): self.context = context def getRelativePaths(self): return ["/foo", "/bar"] def getAbsolutePaths(self): return ["/baz"] provideAdapter(FauxPurgePaths, name="test1") self.assertEqual( ["/foo", "/bar", "/baz"], list(utils.getPathsToPurge(self.context, self.request)), )
def syncPurge(obj): request = getRequest() paths = getPathsToPurge(obj, request) registry = queryUtility(IRegistry) if registry is None: return if not isCachePurgingEnabled(registry=registry): return purger = queryUtility(IPurger) if purger is None: return settings = registry.forInterface(ICachePurgingSettings, check=False) purged_urls = [] for path in paths: for url in getURLsToPurge(path, settings.cachingProxies): purger.purgeSync(url) purged_urls.append(url) return purged_urls
def test_no_purge_paths(self): self.assertEqual([], list(utils.getPathsToPurge(self.context, self.request)))
def processPurge(self): urls = self.request.form.get('urls', []) sync = self.request.form.get('synchronous', True) if not urls: self.errors['urls'] = _(u"No URLs or paths entered.") if self.errors: IStatusMessage(self.request).addStatusMessage( _(u"There were errors."), "error") return purger = getUtility(IPurger) serverURL = self.request['SERVER_URL'] def purge(url): if sync: status, xcache, xerror = purger.purgeSync(url) log = url if xcache: log += " (X-Cache header: " + xcache + ")" if xerror: log += " -- " + xerror self.purgeLog.append(log) else: purger.purgeAsync(url) self.purgeLog.append(url) portal_url = getToolByName(self.context, 'portal_url') portal = portal_url.getPortalObject() portalPath = portal.getPhysicalPath() proxies = self.purgingSettings.cachingProxies for inputURL in urls: if not inputURL.startswith(serverURL): # not in the site if '://' in inputURL: # Full URL? purge(inputURL) else: # Path? for newURL in getURLsToPurge(inputURL, proxies): purge(newURL) continue physicalPath = relativePath = None try: physicalPath = self.request.physicalPathFromURL(inputURL) except ValueError: purge(inputURL) continue if not physicalPath: purge(inputURL) continue relativePath = physicalPath[len(portalPath):] if not relativePath: purge(inputURL) continue obj = portal.unrestrictedTraverse(relativePath, None) if obj is None: purge(inputURL) continue for path in getPathsToPurge(obj, self.request): for newURL in getURLsToPurge(path, proxies): purge(newURL)
def test_no_purge_paths(self): self.assertEqual( [], list(utils.getPathsToPurge(self.context, self.request)) )
def processPurge(self): urls = self.request.form.get('urls', []) sync = self.request.form.get('synchronous', True) if not urls: self.errors['urls'] = _(u'No URLs or paths entered.') if self.errors: IStatusMessage(self.request).addStatusMessage( _(u'There were errors.'), 'error') return if six.PY3: urls = [ x.decode('utf8') if isinstance(x, six.binary_type) else x for x in urls ] purger = getUtility(IPurger) serverURL = self.request['SERVER_URL'] def purge(url): if sync: status, xcache, xerror = purger.purgeSync(url) log = url if xcache: log += ' (X-Cache header: ' + xcache + ')' if xerror: log += ' -- ' + xerror if not str(status).startswith('2'): log += ' -- WARNING status ' + str(status) self.purgeLog.append(log) else: purger.purgeAsync(url) self.purgeLog.append(url) portal_url = getToolByName(self.context, 'portal_url') portal = portal_url.getPortalObject() portalPath = portal.getPhysicalPath() proxies = self.purgingSettings.cachingProxies for inputURL in urls: if not inputURL.startswith(serverURL): # not in the site if '://' in inputURL: # Full URL? purge(inputURL) else: # Path? for newURL in getURLsToPurge(inputURL, proxies): purge(newURL) continue physicalPath = relativePath = None try: physicalPath = self.request.physicalPathFromURL(inputURL) except ValueError: purge(inputURL) continue if not physicalPath: purge(inputURL) continue relativePath = physicalPath[len(portalPath):] if not relativePath: purge(inputURL) continue obj = portal.unrestrictedTraverse(relativePath, None) if obj is None: purge(inputURL) continue for path in getPathsToPurge(obj, self.request): for newURL in getURLsToPurge(path, proxies): purge(newURL)
def processPurge(self): urls = self.request.form.get('urls', []) sync = self.request.form.get('synchronous', True) if not urls: self.errors['urls'] = _(u"No URLs or paths entered.") if self.errors: IStatusMessage(self.request).addStatusMessage(_(u"There were errors."), "error") return purger = getUtility(IPurger) serverURL = self.request['SERVER_URL'] def purge(url): if sync: status, xcache, xerror = purger.purgeSync(url) log = url if xcache: log += " (X-Cache header: " + xcache + ")" if xerror: log += " -- " + xerror self.purgeLog.append(log) else: purger.purgeAsync(url) self.purgeLog.append(url) portal_url = getToolByName(self.context, 'portal_url') portal = portal_url.getPortalObject() portalPath = '/'.join(portal.getPhysicalPath()) proxies = self.purgingSettings.cachingProxies for inputURL in urls: if not inputURL.startswith(serverURL): # not in the site if '://' in inputURL: # Full URL? purge(inputURL) else: # Path? for newURL in getURLsToPurge(inputURL, proxies): purge(newURL) continue physicalPath = relativePath = None try: physicalPath = self.request.physicalPathFromURL(inputURL) except ValueError: purge(inputURL) continue if not physicalPath: purge(inputURL) continue relativePath = physicalPath[len(portalPath):] if not relativePath: purge(inputURL) continue obj = portal.unrestrictedTraverse(relativePath, None) if obj is None: purge(inputURL) continue for path in getPathsToPurge(obj, self.request): for newURL in getURLsToPurge(path, proxies): purge(newURL)