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