def purge(event): """Asynchronously send PURGE requests """ request = event.request annotations = IAnnotations(request, None) if annotations is None: return paths = annotations.get(KEY, None) if paths is None: return 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) for path in paths: for url in getURLsToPurge(path, settings.cachingProxies): purger.purgeAsync(url)
def test_relative_path(self): self.assertEqual( ['http://localhost:1234/foo/bar', 'http://localhost:2345/foo/bar'], list( utils.getURLsToPurge( 'foo/bar', ['http://localhost:1234', 'http://localhost:2345/'])))
def test_relative_path(self): self.assertEqual( ["http://localhost:1234/foo/bar", "http://localhost:2345/foo/bar"], list( utils.getURLsToPurge( "foo/bar", ["http://localhost:1234", "http://localhost:2345/"], )), )
def test_relative_path(self): self.assertEqual( ["http://localhost:1234/foo/bar", "http://localhost:2345/foo/bar"], list( utils.getURLsToPurge( "foo/bar", ["http://localhost:1234", "http://localhost:2345/"], ) ), )
def test_relative_path(self): self.assertEqual( ['http://localhost:1234/foo/bar', 'http://localhost:2345/foo/bar'], list( utils.getURLsToPurge( 'foo/bar', ['http://localhost:1234', 'http://localhost:2345/'] ) ) )
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 __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) 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 __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 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 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)
def test_no_proxies(self): self.assertEqual([], list(utils.getURLsToPurge("/foo", [])))
def test_no_proxies(self): self.assertEqual([], list(utils.getURLsToPurge('/foo', [])))
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 = 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)