def test_publish(self):
page = create(Builder('page').providing(IPreventPublishing))
queue = IQueue(self.portal)
self.assertEquals(0, queue.countJobs())
page.restrictedTraverse('@@publisher.publish')()
self.assertEquals(0, queue.countJobs())
def assert_jobs(self, *expected):
"""Example:
self.assert_jobs(('push', 'page'), ('push', 'textblock'))
"""
got = []
for job in IQueue(self.portal).getJobs():
got.append((job.action, job.getObject(self.portal).getId()))
self.assertEqual(list(expected), list(got))
def __call__(self, event, no_response=False, msg=None):
if IPreventPublishing.providedBy(self.context):
return 'prevented'
if publisher_jobs_are_disabled():
return 'disabled'
self.logger = getLogger()
# is the object blacklisted?
if IPathBlacklist(self.context).is_blacklisted():
self.logger.warning(
'Could not create move job for blacklisted object (%s at %s)' %
(self.context.Title(), '/'.join(
self.context.getPhysicalPath())))
if not no_response:
return self.request.RESPONSE.redirect('./view')
return False
# This View should not be executed at the PloneSiteRoot
if IPloneSiteRoot.providedBy(self.context):
raise Exception('Not allowed on PloneSiteRoot')
# get username
user = self.context.portal_membership.getAuthenticatedMember()
username = user.getUserName()
# create Job
portal = self.context.portal_url.getPortalObject()
queue = IQueue(portal)
additional_data = {
'move_data': {
'newName': event.newName,
'newParent': get_site_relative_path(event.newParent),
'newTitle': event.object.Title().decode('utf-8'),
'oldName': event.oldName,
'oldParent': get_site_relative_path(event.oldParent),
}
}
queue.createJob('move',
self.context,
username,
additional_data=additional_data)
self.logger.debug('Created "%s" Job for "%s" at %s' % (
'move',
self.context.Title(),
'/'.join(self.context.getPhysicalPath()),
))
# status message
if msg is None:
msg = _(u'Object move/rename action has been added to the queue.')
IStatusMessage(self.request).addStatusMessage(msg, type='info')
if not no_response:
return self.request.RESPONSE.redirect('./view')
def __call__(self):
"""
Handles logging purposes and calls execute() method.
"""
# get config and queue
self.config = IConfig(self.context)
portal = self.context.portal_url.getPortalObject()
self.queue = IQueue(portal)
event.notify(BeforeQueueExecutionEvent(portal, self.queue))
# prepare logger
self.logger = getLogger()
self.error_logger = getErrorLogger()
# is it allowed to publish?
if not self.config.publishing_enabled():
self.logger.warning('PUBLISHING IS DISABLED')
return 'PUBLISHING IS DISABLED'
if self.config.locking_enabled():
self.logger.info('LOCKING IS ENABLED')
else:
self.logger.info('LOCKING IS DISABLED')
# lock - check for locking flag
if self.config.locking_enabled(
) and not self.get_lock_object().acquire(0):
self.logger.warning('Already publishing')
return 'Already publishing'
# register our own logging handler for returning logs afterwards
logStream = StringIO()
logHandler = logging.StreamHandler(logStream)
self.logger.addHandler(logHandler)
# be sure to remove the handler!
try:
# execute queue
self.execute()
except Exception:
self.logger.removeHandler(logHandler)
if self.config.locking_enabled():
self.get_lock_object().release()
# re-raise exception
raise
# get logs
self.logger.removeHandler(logHandler)
logStream.seek(0)
log = logStream.read()
del logStream
del logHandler
# unlock
if self.config.locking_enabled():
self.get_lock_object().release()
event.notify(QueueExecutedEvent(portal, log))
return log
def test_delete(self):
page = create(Builder('page'))
queue = IQueue(self.portal)
self.assertEquals(0, queue.countJobs())
with publisher_jobs_disabled():
page.restrictedTraverse('@@publisher.delete')()
self.assertEquals(0, queue.countJobs())
page.restrictedTraverse('@@publisher.delete')()
self.assertEquals(1, queue.countJobs())
def test_blocks_are_published_with_contentpage(self, browser):
page = create(Builder(self.page_builder))
create(Builder(self.textblock_builder).within(page))
browser.login().visit(page)
Workflow().do_transition('publish')
queue = IQueue(self.portal)
self.assertEquals(
2, queue.countJobs(),
'Expected the page and the text block to be in the queue.')
def test_sl_listing_block_publishes_its_children(self, browser):
page = create(Builder(self.page_builder))
listing_block = create(Builder(self.listingblock_builder).within(page))
create(Builder('file').within(listing_block))
browser.login().visit(page)
Workflow().do_transition('publish')
queue = IQueue(self.portal)
self.assertEquals(
3, queue.countJobs(),
'Expected the page, the listing block and the file to be'
' in the queue.')
def __call__(self, no_response=False, msg=None, recursive=True):
if IPreventPublishing.providedBy(self.context):
return 'prevented'
if publisher_jobs_are_disabled():
return 'disabled'
self.logger = getLogger()
# is the object blacklisted?
if IPathBlacklist(self.context).is_blacklisted():
self.logger.warning(
'Could not create push job for blacklisted object (%s at %s)' %
(self.context.Title(), '/'.join(
self.context.getPhysicalPath())))
if not no_response:
return self.request.RESPONSE.redirect('./view')
return False
event.notify(BeforePublishEvent(self.context))
# mle: now its possible to execite this view on plonesiteroot
# This View should not be executed at the PloneSiteRoot
# if IPloneSiteRoot.providedBy(self.context):
# raise Exception('Not allowed on PloneSiteRoot')
# get username
user = self.context.portal_membership.getAuthenticatedMember()
username = user.getUserName()
# create Job
portal = self.context.portal_url.getPortalObject()
queue = IQueue(portal)
queue.createJob('push', self.context, username)
self.logger.debug('Created "%s" Job for "%s" at %s' % (
'push',
self.context.Title(),
'/'.join(self.context.getPhysicalPath()),
))
if recursive and base_hasattr(self.context, 'contentValues'):
# Use contentValues for implicit ftw.trash compatibility.
for obj in filter(belongs_to_parent, self.context.contentValues()):
obj.restrictedTraverse('@@publisher.publish')(no_response=True,
msg=msg)
# status message
if msg is None:
msg = _(u'This object has been added to the queue.')
IStatusMessage(self.request).addStatusMessage(msg, type='info')
if not no_response:
return self.request.RESPONSE.redirect('./view')
def test_no_delete_jobs_for_blocks(self):
"""When a block is deleted, we do not want to instantly delete
the block on the receiver side.
Instead the block is deleted automatically when the page is published
because it is no longer listed in the page state.
"""
page = create(Builder(self.page_builder))
textblock = create(Builder(self.textblock_builder).within(page))
self.assertEquals(0, IQueue(self.portal).countJobs())
page.manage_delObjects([textblock.getId()])
self.assertEquals(
0,
IQueue(self.portal).countJobs(),
'Deleting an ftw.simplelayout block'
' should not publish a delete job.')
self.portal.manage_delObjects([page.getId()])
self.assertEquals(
1,
IQueue(self.portal).countJobs(),
'Deleteing an ftw.simplelayout page'
' should still add a delete job.')
def execute_single_job(self, job):
""" Executes a single job without calling the view
"""
self.logger = getLogger()
self.error_logger = getErrorLogger()
portal = self.context.portal_url.getPortalObject()
self.config = IConfig(portal)
self.queue = IQueue(portal)
# remove job from queue
if job in self.queue.getJobs():
self.queue.removeJob(job)
elif job in self.queue.get_executed_jobs():
self.queue.remove_executed_job(job)
# execute it
self.executeJob(job)
# move json file
job.move_jsonfile_to(self.config.get_executed_folder())
# add to executed list
return self.queue.append_executed_job(job)
def __call__(self, no_response=False, msg=None):
if IPreventPublishing.providedBy(self.context):
return 'prevented'
if publisher_jobs_are_disabled():
return 'disabled'
self.logger = getLogger()
# is the object blacklisted?
if IPathBlacklist(self.context).is_blacklisted():
self.logger.warning('Could not create delete job for blacklisted '
'object (%s at %s)' %
(self.context.Title(), '/'.join(
self.context.getPhysicalPath())))
if not no_response:
return self.request.RESPONSE.redirect('./view')
return False
# This view should not be executed at the PloneSiteRoot
if IPloneSiteRoot.providedBy(self.context):
raise Exception('Not allowed on PloneSiteRoot')
# get username
user = self.context.portal_membership.getAuthenticatedMember()
username = user.getUserName()
# create Job
portal = self.context.portal_url.getPortalObject()
queue = IQueue(portal)
queue.createJob('delete', self.context, username)
self.logger.debug('Created "%s" Job for "%s" at %s' % (
'delete',
self.context.Title(),
'/'.join(self.context.getPhysicalPath()),
))
# status message
if msg is None:
msg = _(u'This object will be deleted at the remote sites.')
add_transaction_aware_status_message(self.request, msg, type='info')
if not no_response:
return self.request.RESPONSE.redirect('./view')
def test_delete_plonesite_is_not_allowed(self, browser):
self.grant('Manager')
self.assertEquals(0, IQueue(self.portal).countJobs())
with browser.expect_http_error(500):
browser.login().open(self.portal, view='@@publisher.delete')
def setUp(self):
super(TestStorage, self).setUp()
self.grant('Manager')
self.folder = create(Builder('folder').titled(u'Foo'))
self.queue = IQueue(self.portal)
def getQueueSize(self):
return IQueue(self.context).countJobs()
def __init__(self, *args, **kwargs):
super(PublisherConfigletView, self).__init__(*args, **kwargs)
self.config = IConfig(self.context)
self.queue = IQueue(self.context)
