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 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)
