def doWork(self):
try:
home = (yield self.transaction.calendarHomeWithResourceID(self.homeResourceID))
resource = (yield home.objectResourceWithID(self.resourceID))
attendeeAddress = yield calendarUserFromCalendarUserUID(home.uid(), self.transaction)
attendee = attendeeAddress.record.canonicalCalendarUserAddress()
calendar = (yield resource.componentForUser())
organizer = calendar.validOrganizerForScheduling()
# Deserialize "" as None
changedRids = map(lambda x: DateTime.parseText(x) if x else None, self.changedRids.split(",")) if self.changedRids else None
log.debug("ScheduleReplyWork - running for ID: {id}, UID: {uid}, attendee: {att}", id=self.workID, uid=calendar.resourceUID(), att=attendee)
# We need to get the UID lock for implicit processing.
yield NamedLock.acquire(self.transaction, "ImplicitUIDLock:%s" % (hashlib.md5(calendar.resourceUID()).hexdigest(),))
itipmsg = iTipGenerator.generateAttendeeReply(calendar, attendee, changedRids=changedRids)
# Send scheduling message and process response
response = (yield self.sendToOrganizer(home, "REPLY", itipmsg, attendee, organizer))
responses, all_delivered = self.extractSchedulingResponse((response,))
if not all_delivered:
changed = yield self.handleSchedulingResponse(responses, calendar, False)
if changed:
yield resource._setComponentInternal(calendar, internal_state=ComponentUpdateState.ATTENDEE_ITIP_UPDATE)
self._dequeued()
except Exception, e:
# FIXME: calendar may not be set here!
log.debug("ScheduleReplyWork - exception ID: {id}, UID: '{uid}', {err}", id=self.workID, uid=calendar.resourceUID(), err=str(e))
raise
def doWork(self):
try:
home = (yield self.transaction.calendarHomeWithResourceID(self.homeResourceID))
resource = (yield home.objectResourceWithID(self.resourceID))
organizerAddress = yield calendarUserFromCalendarUserUID(home.uid(), self.transaction)
organizer = organizerAddress.record.canonicalCalendarUserAddress()
calendar_old = Component.fromString(self.icalendarTextOld) if self.icalendarTextOld else None
calendar_new = Component.fromString(self.icalendarTextNew) if self.icalendarTextNew else None
log.debug("ScheduleOrganizerWork - running for ID: {id}, UID: {uid}, organizer: {org}", id=self.workID, uid=self.icalendarUID, org=organizer)
# We need to get the UID lock for implicit processing.
yield NamedLock.acquire(self.transaction, "ImplicitUIDLock:%s" % (hashlib.md5(self.icalendarUID).hexdigest(),))
from txdav.caldav.datastore.scheduling.implicit import ImplicitScheduler
scheduler = ImplicitScheduler()
yield scheduler.queuedOrganizerProcessing(
self.transaction,
scheduleActionFromSQL[self.scheduleAction],
home,
resource,
self.icalendarUID,
calendar_old,
calendar_new,
self.smartMerge
)
self._dequeued()
except Exception, e:
log.debug("ScheduleOrganizerWork - exception ID: {id}, UID: '{uid}', {err}", id=self.workID, uid=self.icalendarUID, err=str(e))
log.debug(traceback.format_exc())
raise
def doWork(self):
try:
home = (yield self.transaction.calendarHomeWithResourceID(self.homeResourceID))
resource = (yield home.objectResourceWithID(self.resourceID))
organizerAddress = yield calendarUserFromCalendarUserUID(home.uid(), self.transaction)
organizer = organizerAddress.record.canonicalCalendarUserAddress()
calendar_old = Component.fromString(self.icalendarTextOld) if self.icalendarTextOld else None
calendar_new = Component.fromString(self.icalendarTextNew) if self.icalendarTextNew else None
log.debug("ScheduleOrganizerWork - running for ID: {id}, UID: {uid}, organizer: {org}", id=self.workID, uid=self.icalendarUid, org=organizer)
# We need to get the UID lock for implicit processing.
yield NamedLock.acquire(self.transaction, "ImplicitUIDLock:%s" % (hashlib.md5(self.icalendarUid).hexdigest(),))
from txdav.caldav.datastore.scheduling.implicit import ImplicitScheduler
scheduler = ImplicitScheduler()
yield scheduler.queuedOrganizerProcessing(
self.transaction,
scheduleActionFromSQL[self.scheduleAction],
home,
resource,
self.icalendarUid,
calendar_old,
calendar_new,
self.smartMerge
)
self._dequeued()
except Exception, e:
log.debug("ScheduleOrganizerWork - exception ID: {id}, UID: '{uid}', {err}", id=self.workID, uid=self.icalendarUid, err=str(e))
log.debug(traceback.format_exc())
raise
def doWork(self):
try:
home = (yield self.transaction.calendarHomeWithResourceID(self.homeResourceID))
resource = (yield home.objectResourceWithID(self.resourceID))
itipmsg = Component.fromString(self.itipMsg)
organizerAddress = yield calendarUserFromCalendarUserUID(home.uid(), self.transaction)
organizer = organizerAddress.record.canonicalCalendarUserAddress()
log.debug(
"ScheduleOrganizerSendWork - running for ID: {id}, UID: {uid}, organizer: {org}, attendee: {att}",
id=self.workID,
uid=self.icalendarUID,
org=organizer,
att=self.attendee
)
# We need to get the UID lock for implicit processing.
yield NamedLock.acquire(self.transaction, "ImplicitUIDLock:%s" % (hashlib.md5(self.icalendarUID).hexdigest(),))
from txdav.caldav.datastore.scheduling.implicit import ImplicitScheduler
scheduler = ImplicitScheduler()
yield scheduler.queuedOrganizerSending(
self.transaction,
scheduleActionFromSQL[self.scheduleAction],
home,
resource,
self.icalendarUID,
organizer,
self.attendee,
itipmsg,
self.noRefresh
)
# Handle responses - update the actual resource in the store. Note that for a create the resource did not previously
# exist and is stored as None for the work item, but the scheduler will attempt to find the new resources and use
# that. We need to grab the scheduler's resource for further processing.
resource = scheduler.resource
if resource is not None:
responses, all_delivered = self.extractSchedulingResponse(scheduler.queuedResponses)
if not all_delivered:
# Check for all connection failed
yield self.checkTemporaryFailure(responses)
# Update calendar data to reflect error status
calendar = (yield resource.componentForUser())
changed = self.handleSchedulingResponse(responses, calendar, True)
if changed:
yield resource._setComponentInternal(calendar, internal_state=ComponentUpdateState.ORGANIZER_ITIP_UPDATE)
self._dequeued()
except Exception, e:
log.debug("ScheduleOrganizerSendWork - exception ID: {id}, UID: '{uid}', {err}", id=self.workID, uid=self.icalendarUID, err=str(e))
log.debug(traceback.format_exc())
raise
def doWork(self):
try:
home = (yield self.transaction.calendarHomeWithResourceID(self.homeResourceID))
resource = (yield home.objectResourceWithID(self.resourceID))
itipmsg = Component.fromString(self.itipMsg)
organizerAddress = yield calendarUserFromCalendarUserUID(home.uid(), self.transaction)
organizer = organizerAddress.record.canonicalCalendarUserAddress()
log.debug(
"ScheduleOrganizerSendWork - running for ID: {id}, UID: {uid}, organizer: {org}, attendee: {att}",
id=self.workID,
uid=self.icalendarUID,
org=organizer,
att=self.attendee
)
# We need to get the UID lock for implicit processing.
yield NamedLock.acquire(self.transaction, "ImplicitUIDLock:%s" % (hashlib.md5(self.icalendarUID).hexdigest(),))
from txdav.caldav.datastore.scheduling.implicit import ImplicitScheduler
scheduler = ImplicitScheduler()
yield scheduler.queuedOrganizerSending(
self.transaction,
scheduleActionFromSQL[self.scheduleAction],
home,
resource,
self.icalendarUID,
organizer,
self.attendee,
itipmsg,
self.noRefresh
)
# Handle responses - update the actual resource in the store. Note that for a create the resource did not previously
# exist and is stored as None for the work item, but the scheduler will attempt to find the new resources and use
# that. We need to grab the scheduler's resource for further processing.
resource = scheduler.resource
if resource is not None:
responses, all_delivered = self.extractSchedulingResponse(scheduler.queuedResponses)
if not all_delivered:
# Check for all connection failed
yield self.checkTemporaryFailure(responses)
# Update calendar data to reflect error status
calendar = (yield resource.componentForUser())
changed = self.handleSchedulingResponse(responses, calendar, True)
if changed:
yield resource._setComponentInternal(calendar, internal_state=ComponentUpdateState.ORGANIZER_ITIP_UPDATE)
self._dequeued()
except Exception, e:
log.debug("ScheduleOrganizerSendWork - exception ID: {id}, UID: '{uid}', {err}", id=self.workID, uid=self.icalendarUID, err=str(e))
log.debug(traceback.format_exc())
raise
def doWork(self):
try:
home = (yield self.transaction.calendarHomeWithResourceID(
self.homeResourceID))
resource = (yield home.objectResourceWithID(self.resourceID))
itipmsg = Component.fromString(self.itipMsg)
attendeeAddress = yield calendarUserFromCalendarUserUID(
home.uid(), self.transaction)
attendee = attendeeAddress.record.canonicalCalendarUserAddress()
organizer = itipmsg.validOrganizerForScheduling()
log.debug(
"ScheduleReplyWork - running for ID: {id}, UID: {uid}, attendee: {att}",
id=self.workID,
uid=itipmsg.resourceUID(),
att=attendee)
# We need to get the UID lock for implicit processing.
yield NamedLock.acquire(
self.transaction, "ImplicitUIDLock:%s" %
(hashlib.md5(itipmsg.resourceUID()).hexdigest(), ))
# Send scheduling message and process response
response = (yield self.sendToOrganizer(home, itipmsg, attendee,
organizer))
if resource is not None:
responses, all_delivered = self.extractSchedulingResponse(
(response, ))
if not all_delivered:
# Check for all connection failed
yield self.checkTemporaryFailure(responses)
# Update calendar data to reflect error status
calendar = (yield resource.componentForUser())
changed = yield self.handleSchedulingResponse(
responses, calendar, False)
if changed:
yield resource._setComponentInternal(
calendar,
internal_state=ComponentUpdateState.
ATTENDEE_ITIP_UPDATE)
self._dequeued()
except Exception, e:
# FIXME: calendar may not be set here!
log.debug(
"ScheduleReplyWork - exception ID: {id}, UID: '{uid}', {err}",
id=self.workID,
uid=itipmsg.resourceUID(),
err=str(e))
raise
def doWork(self):
try:
home = (yield self.transaction.calendarHomeWithResourceID(
self.homeResourceID))
resource = (yield home.objectResourceWithID(self.resourceID))
attendeeAddress = yield calendarUserFromCalendarUserUID(
home.uid(), self.transaction)
attendee = attendeeAddress.record.canonicalCalendarUserAddress()
calendar = (yield resource.componentForUser())
organizer = calendar.validOrganizerForScheduling()
# Deserialize "" as None
changedRids = map(
lambda x: DateTime.parseText(x) if x else None,
self.changedRids.split(",")) if self.changedRids else None
log.debug(
"ScheduleReplyWork - running for ID: {id}, UID: {uid}, attendee: {att}",
id=self.workID,
uid=calendar.resourceUID(),
att=attendee)
# We need to get the UID lock for implicit processing.
yield NamedLock.acquire(
self.transaction, "ImplicitUIDLock:%s" %
(hashlib.md5(calendar.resourceUID()).hexdigest(), ))
itipmsg = iTipGenerator.generateAttendeeReply(
calendar, attendee, changedRids=changedRids)
# Send scheduling message and process response
response = (yield self.sendToOrganizer(home, "REPLY", itipmsg,
attendee, organizer))
responses, all_delivered = self.extractSchedulingResponse(
(response, ))
if not all_delivered:
changed = yield self.handleSchedulingResponse(
responses, calendar, False)
if changed:
yield resource._setComponentInternal(
calendar,
internal_state=ComponentUpdateState.
ATTENDEE_ITIP_UPDATE)
self._dequeued()
except Exception, e:
# FIXME: calendar may not be set here!
log.debug(
"ScheduleReplyWork - exception ID: {id}, UID: '{uid}', {err}",
id=self.workID,
uid=calendar.resourceUID(),
err=str(e))
raise
def doWork(self):
try:
home = (yield self.transaction.calendarHomeWithResourceID(
self.homeResourceID))
attendeeAddress = yield calendarUserFromCalendarUserUID(
home.uid(), self.transaction)
attendee = attendeeAddress.record.canonicalCalendarUserAddress()
calendar = Component.fromString(self.icalendarText)
organizer = calendar.validOrganizerForScheduling()
log.debug(
"ScheduleReplyCancelWork - running for ID: {id}, UID: {uid}, attendee: {att}",
id=self.workID,
uid=calendar.resourceUID(),
att=attendee)
# We need to get the UID lock for implicit processing.
yield NamedLock.acquire(
self.transaction, "ImplicitUIDLock:%s" %
(hashlib.md5(calendar.resourceUID()).hexdigest(), ))
itipmsg = iTipGenerator.generateAttendeeReply(calendar,
attendee,
force_decline=True)
# Send scheduling message - no need to process response as original resource is gone
yield self.sendToOrganizer(home, "CANCEL", itipmsg, attendee,
organizer)
self._dequeued()
except Exception, e:
log.debug(
"ScheduleReplyCancelWork - exception ID: {id}, UID: '{uid}', {err}",
id=self.workID,
uid=calendar.resourceUID(),
err=str(e))
raise
def doWork(self):
try:
home = (yield self.transaction.calendarHomeWithResourceID(self.homeResourceID))
resource = (yield home.objectResourceWithID(self.resourceID))
itipmsg = Component.fromString(self.itipMsg)
attendeeAddress = yield calendarUserFromCalendarUserUID(home.uid(), self.transaction)
attendee = attendeeAddress.record.canonicalCalendarUserAddress()
organizer = itipmsg.validOrganizerForScheduling()
log.debug("ScheduleReplyWork - running for ID: {id}, UID: {uid}, attendee: {att}", id=self.workID, uid=itipmsg.resourceUID(), att=attendee)
# We need to get the UID lock for implicit processing.
yield NamedLock.acquire(self.transaction, "ImplicitUIDLock:%s" % (hashlib.md5(itipmsg.resourceUID()).hexdigest(),))
# Send scheduling message and process response
response = (yield self.sendToOrganizer(home, itipmsg, attendee, organizer))
if resource is not None:
responses, all_delivered = self.extractSchedulingResponse((response,))
if not all_delivered:
# Check for all connection failed
yield self.checkTemporaryFailure(responses)
# Update calendar data to reflect error status
calendar = (yield resource.componentForUser())
changed = yield self.handleSchedulingResponse(responses, calendar, False)
if changed:
yield resource._setComponentInternal(calendar, internal_state=ComponentUpdateState.ATTENDEE_ITIP_UPDATE)
self._dequeued()
except Exception, e:
# FIXME: calendar may not be set here!
log.debug("ScheduleReplyWork - exception ID: {id}, UID: '{uid}', {err}", id=self.workID, uid=itipmsg.resourceUID(), err=str(e))
raise
def doWork(self):
try:
home = (yield self.transaction.calendarHomeWithResourceID(self.homeResourceID))
attendeeAddress = yield calendarUserFromCalendarUserUID(home.uid(), self.transaction)
attendee = attendeeAddress.record.canonicalCalendarUserAddress()
calendar = Component.fromString(self.icalendarText)
organizer = calendar.validOrganizerForScheduling()
log.debug("ScheduleReplyCancelWork - running for ID: {id}, UID: {uid}, attendee: {att}", id=self.workID, uid=calendar.resourceUID(), att=attendee)
# We need to get the UID lock for implicit processing.
yield NamedLock.acquire(self.transaction, "ImplicitUIDLock:%s" % (hashlib.md5(calendar.resourceUID()).hexdigest(),))
itipmsg = iTipGenerator.generateAttendeeReply(calendar, attendee, force_decline=True)
# Send scheduling message - no need to process response as original resource is gone
yield self.sendToOrganizer(home, "CANCEL", itipmsg, attendee, organizer)
self._dequeued()
except Exception, e:
log.debug("ScheduleReplyCancelWork - exception ID: {id}, UID: '{uid}', {err}", id=self.workID, uid=calendar.resourceUID(), err=str(e))
raise
