[CalendarServer-changes] [12030] CalendarServer/trunk

source_changes at macosforge.org source_changes at macosforge.org
Wed Mar 12 11:19:35 PDT 2014


Revision: 12030
          http://trac.calendarserver.org//changeset/12030
Author:   cdaboo at apple.com
Date:     2013-12-03 19:47:41 -0800 (Tue, 03 Dec 2013)
Log Message:
-----------
Return a 503 response when a DB lock times out.

Modified Paths:
--------------
    CalendarServer/trunk/twext/enterprise/locking.py
    CalendarServer/trunk/twext/enterprise/test/test_locking.py
    CalendarServer/trunk/twistedcaldav/storebridge.py
    CalendarServer/trunk/twistedcaldav/test/test_wrapping.py

Modified: CalendarServer/trunk/twext/enterprise/locking.py
===================================================================
--- CalendarServer/trunk/twext/enterprise/locking.py	2013-12-04 03:43:03 UTC (rev 12029)
+++ CalendarServer/trunk/twext/enterprise/locking.py	2013-12-04 03:47:41 UTC (rev 12030)
@@ -35,6 +35,13 @@
 
 
 
+class LockTimeout(Exception):
+    """
+    The lock you were trying to lock was already locked causing a timeout.
+    """
+
+
+
 def makeLockSchema(inSchema):
     """
     Create a self-contained schema just for L{Locker} use, in C{inSchema}.
@@ -57,7 +64,6 @@
 
 
 
-
 class NamedLock(Record, fromTable(LockSchema.NAMED_LOCK)):
     """
     An L{AcquiredLock} lock against a shared data store that the current
@@ -79,7 +85,9 @@
         def autoRelease(self):
             txn.preCommit(lambda: self.release(True))
             return self
-        return cls.create(txn, lockName=name).addCallback(autoRelease)
+        def lockFailed(f):
+            raise LockTimeout(name)
+        return cls.create(txn, lockName=name).addCallback(autoRelease).addErrback(lockFailed)
 
 
     def release(self, ignoreAlreadyUnlocked=False):
@@ -98,6 +106,3 @@
             unlocked.
         """
         return self.delete()
-
-
-

Modified: CalendarServer/trunk/twext/enterprise/test/test_locking.py
===================================================================
--- CalendarServer/trunk/twext/enterprise/test/test_locking.py	2013-12-04 03:43:03 UTC (rev 12029)
+++ CalendarServer/trunk/twext/enterprise/test/test_locking.py	2013-12-04 03:47:41 UTC (rev 12030)
@@ -22,7 +22,7 @@
 from twisted.trial.unittest import TestCase
 
 from twext.enterprise.fixtures import buildConnectionPool
-from twext.enterprise.locking import NamedLock
+from twext.enterprise.locking import NamedLock, LockTimeout
 from twext.enterprise.dal.syntax import Select
 from twext.enterprise.locking import LockSchema
 
@@ -76,3 +76,17 @@
         txn2 = self.pool.connection()
         rows = yield Select(From=LockSchema.NAMED_LOCK).on(txn2)
         self.assertEquals(rows, [])
+
+
+    @inlineCallbacks
+    def test_timeout(self):
+        """
+        Trying to acquire second lock times out.
+        """
+        txn1 = self.pool.connection()
+        yield NamedLock.acquire(txn1, u"a test lock")
+
+        txn2 = self.pool.connection()
+        yield self.assertFailure(NamedLock.acquire(txn2, u"a test lock"), LockTimeout)
+        yield txn2.abort()
+        self.flushLoggedErrors()

Modified: CalendarServer/trunk/twistedcaldav/storebridge.py
===================================================================
--- CalendarServer/trunk/twistedcaldav/storebridge.py	2013-12-04 03:43:03 UTC (rev 12029)
+++ CalendarServer/trunk/twistedcaldav/storebridge.py	2013-12-04 03:47:41 UTC (rev 12030)
@@ -17,7 +17,9 @@
 
 from pycalendar.datetime import DateTime
 
+from twext.enterprise.locking import LockTimeout
 from twext.python.log import Logger
+from twext.web2 import responsecode, http_headers, http
 from twext.web2.dav.http import ErrorResponse, ResponseQueue, MultiStatusResponse
 from twext.web2.dav.noneprops import NonePropertyStore
 from twext.web2.dav.resource import TwistedACLInheritable, AccessDeniedError, \
@@ -26,6 +28,7 @@
 from twext.web2.filter.location import addLocation
 from twext.web2.http import HTTPError, StatusResponse, Response
 from twext.web2.http_headers import ETag, MimeType, MimeDisposition
+from twext.web2.iweb import IResponse
 from twext.web2.responsecode import \
     FORBIDDEN, NO_CONTENT, NOT_FOUND, CREATED, CONFLICT, PRECONDITION_FAILED, \
     BAD_REQUEST, OK, INSUFFICIENT_STORAGE_SPACE, SERVICE_UNAVAILABLE
@@ -41,14 +44,20 @@
     MaxInstances, NoUIDConflict
 from twistedcaldav.carddavxml import carddav_namespace, NoUIDConflict as NovCardUIDConflict
 from twistedcaldav.config import config
+from twistedcaldav.customxml import calendarserver_namespace
 from twistedcaldav.directory.wiki import WikiDirectoryService, getWikiAccess
 from twistedcaldav.ical import Component as VCalendar, Property as VProperty, \
     InvalidICalendarDataError, iCalendarProductID, Component
+from twistedcaldav.instance import InvalidOverriddenInstanceError, \
+    TooManyInstancesError
 from twistedcaldav.memcachelock import MemcacheLockTimeoutError
 from twistedcaldav.notifications import NotificationCollectionResource, NotificationResource
 from twistedcaldav.resource import CalDAVResource, GlobalAddressBookResource, \
     DefaultAlarmPropertyMixin
 from twistedcaldav.scheduling_store.caldav.resource import ScheduleInboxResource
+from twistedcaldav.sharing import invitationBindStatusToXMLMap, \
+    invitationBindModeToXMLMap
+from twistedcaldav.util import bestAcceptType
 from twistedcaldav.vcard import Component as VCard, InvalidVCardDataError
 
 from txdav.base.propertystore.base import PropertyName
@@ -74,19 +83,10 @@
 from txdav.xml.base import dav_namespace, WebDAVUnknownElement, encodeXMLName
 
 from urlparse import urlsplit, urljoin
+import collections
 import hashlib
 import time
 import uuid
-from twext.web2 import responsecode, http_headers, http
-from twext.web2.iweb import IResponse
-from twistedcaldav.customxml import calendarserver_namespace
-from twistedcaldav.instance import InvalidOverriddenInstanceError, \
-    TooManyInstancesError
-from twistedcaldav.util import bestAcceptType
-import collections
-from twistedcaldav.sharing import invitationBindStatusToXMLMap, \
-    invitationBindModeToXMLMap
-
 """
 Wrappers to translate between the APIs in L{txdav.caldav.icalendarstore} and
 L{txdav.carddav.iaddressbookstore} and those in L{twistedcaldav}.
@@ -2291,11 +2291,53 @@
         returnValue(response)
 
     # The following are used to map store exceptions into HTTP error responses
-    StoreExceptionsStatusErrors = set()
     StoreExceptionsErrors = {}
-    StoreMoveExceptionsStatusErrors = set()
     StoreMoveExceptionsErrors = {}
+    StoreRemoveExceptionsErrors = {}
 
+    @classmethod
+    def _storeExceptionStatus(cls, err, arg):
+        """
+        Raise a status error.
+
+        @param err: the actual exception that caused the error
+        @type err: L{Exception}
+        @param arg: description of error or C{None}
+        @type arg: C{str} or C{None}
+        """
+        raise HTTPError(StatusResponse(responsecode.FORBIDDEN, arg if arg is not None else str(err)))
+
+
+    @classmethod
+    def _storeExceptionError(cls, err, arg):
+        """
+        Raise a DAV:error error with the supplied error element.
+
+        @param err: the actual exception that caused the error
+        @type err: L{Exception}
+        @param arg: the error element
+        @type arg: C{tuple}
+        """
+        raise HTTPError(ErrorResponse(
+            responsecode.FORBIDDEN,
+            arg,
+            str(err),
+        ))
+
+
+    @classmethod
+    def _storeExceptionUnavailable(cls, err, arg):
+        """
+        Raise a service unavailable error.
+
+        @param err: the actual exception that caused the error
+        @type err: L{Exception}
+        @param arg: description of error or C{None}
+        @type arg: C{str} or C{None}
+        """
+        raise HTTPError(StatusResponse(responsecode.SERVICE_UNAVAILABLE, arg if arg is not None else str(err)))
+
+
     @requiresPermissions(fromParent=[davxml.Unbind()])
     def http_DELETE(self, request):
         """
@@ -2387,15 +2429,9 @@
             # Grab the current exception state here so we can use it in a re-raise - we need this because
             # an inlineCallback might be called and that raises an exception when it returns, wiping out the
             # original exception "context".
-            if type(err) in self.StoreMoveExceptionsStatusErrors:
-                raise HTTPError(StatusResponse(responsecode.FORBIDDEN, str(err)))
-
-            elif type(err) in self.StoreMoveExceptionsErrors:
-                raise HTTPError(ErrorResponse(
-                    responsecode.FORBIDDEN,
-                    self.StoreMoveExceptionsErrors[type(err)],
-                    str(err),
-                ))
+            if type(err) in self.StoreMoveExceptionsErrors:
+                error, arg = self.StoreMoveExceptionsErrors[type(err)]
+                error(err, arg)
             else:
                 # Return the original failure (exception) state
                 raise
@@ -2438,15 +2474,9 @@
 
         # Map store exception to HTTP errors
         except Exception as err:
-            if type(err) in self.StoreExceptionsStatusErrors:
-                raise HTTPError(StatusResponse(responsecode.FORBIDDEN, str(err)))
-
-            elif type(err) in self.StoreExceptionsErrors:
-                raise HTTPError(ErrorResponse(
-                    responsecode.FORBIDDEN,
-                    self.StoreExceptionsErrors[type(err)],
-                    str(err),
-                ))
+            if type(err) in self.StoreExceptionsErrors:
+                error, arg = self.StoreExceptionsErrors[type(err)]
+                error(err, arg)
             else:
                 raise
 
@@ -2491,6 +2521,14 @@
         except NoSuchObjectResourceError:
             raise HTTPError(NOT_FOUND)
 
+        # Map store exception to HTTP errors
+        except Exception as err:
+            if type(err) in self.StoreExceptionsErrors:
+                error, arg = self.StoreExceptionsErrors[type(err)]
+                error(err, arg)
+            else:
+                raise
+
         # Re-initialize to get stuff setup again now we have no object
         self._initializeWithObject(None, self._newStoreParent)
 
@@ -2624,51 +2662,51 @@
         else:
             return False
 
-    StoreExceptionsStatusErrors = set((
-        ObjectResourceNameNotAllowedError,
-        ObjectResourceNameAlreadyExistsError,
-    ))
-
     StoreExceptionsErrors = {
-        TooManyObjectResourcesError: customxml.MaxResources(),
-        ObjectResourceTooBigError: (caldav_namespace, "max-resource-size"),
-        InvalidObjectResourceError: (caldav_namespace, "valid-calendar-data"),
-        InvalidComponentForStoreError: (caldav_namespace, "valid-calendar-object-resource"),
-        InvalidComponentTypeError: (caldav_namespace, "supported-component"),
-        TooManyAttendeesError: MaxAttendeesPerInstance.fromString(str(config.MaxAttendeesPerInstance)),
-        InvalidCalendarAccessError: (calendarserver_namespace, "valid-access-restriction"),
-        ValidOrganizerError: (calendarserver_namespace, "valid-organizer"),
-        UIDExistsError: NoUIDConflict(),
-        UIDExistsElsewhereError: (caldav_namespace, "unique-scheduling-object-resource"),
-        InvalidUIDError: NoUIDConflict(),
-        InvalidPerUserDataMerge: (caldav_namespace, "valid-calendar-data"),
-        AttendeeAllowedError: (caldav_namespace, "attendee-allowed"),
-        InvalidOverriddenInstanceError: (caldav_namespace, "valid-calendar-data"),
-        TooManyInstancesError: MaxInstances.fromString(str(config.MaxAllowedInstances)),
-        AttachmentStoreValidManagedID: (caldav_namespace, "valid-managed-id"),
-        ShareeAllowedError: (calendarserver_namespace, "sharee-privilege-needed",),
-        DuplicatePrivateCommentsError: (calendarserver_namespace, "no-duplicate-private-comments",),
+        ObjectResourceNameNotAllowedError: (_CommonObjectResource._storeExceptionStatus, None,),
+        ObjectResourceNameAlreadyExistsError: (_CommonObjectResource._storeExceptionStatus, None,),
+        TooManyObjectResourcesError: (_CommonObjectResource._storeExceptionError, customxml.MaxResources(),),
+        ObjectResourceTooBigError: (_CommonObjectResource._storeExceptionError, (caldav_namespace, "max-resource-size"),),
+        InvalidObjectResourceError: (_CommonObjectResource._storeExceptionError, (caldav_namespace, "valid-calendar-data"),),
+        InvalidComponentForStoreError: (_CommonObjectResource._storeExceptionError, (caldav_namespace, "valid-calendar-object-resource"),),
+        InvalidComponentTypeError: (_CommonObjectResource._storeExceptionError, (caldav_namespace, "supported-component"),),
+        TooManyAttendeesError: (_CommonObjectResource._storeExceptionError, MaxAttendeesPerInstance.fromString(str(config.MaxAttendeesPerInstance)),),
+        InvalidCalendarAccessError: (_CommonObjectResource._storeExceptionError, (calendarserver_namespace, "valid-access-restriction"),),
+        ValidOrganizerError: (_CommonObjectResource._storeExceptionError, (calendarserver_namespace, "valid-organizer"),),
+        UIDExistsError: (_CommonObjectResource._storeExceptionError, NoUIDConflict(),),
+        UIDExistsElsewhereError: (_CommonObjectResource._storeExceptionError, (caldav_namespace, "unique-scheduling-object-resource"),),
+        InvalidUIDError: (_CommonObjectResource._storeExceptionError, NoUIDConflict(),),
+        InvalidPerUserDataMerge: (_CommonObjectResource._storeExceptionError, (caldav_namespace, "valid-calendar-data"),),
+        AttendeeAllowedError: (_CommonObjectResource._storeExceptionError, (caldav_namespace, "attendee-allowed"),),
+        InvalidOverriddenInstanceError: (_CommonObjectResource._storeExceptionError, (caldav_namespace, "valid-calendar-data"),),
+        TooManyInstancesError: (_CommonObjectResource._storeExceptionError, MaxInstances.fromString(str(config.MaxAllowedInstances)),),
+        AttachmentStoreValidManagedID: (_CommonObjectResource._storeExceptionError, (caldav_namespace, "valid-managed-id"),),
+        ShareeAllowedError: (_CommonObjectResource._storeExceptionError, (calendarserver_namespace, "sharee-privilege-needed",),),
+        DuplicatePrivateCommentsError: (_CommonObjectResource._storeExceptionError, (calendarserver_namespace, "no-duplicate-private-comments",),),
+        LockTimeout: (_CommonObjectResource._storeExceptionUnavailable, "Lock timed out.",),
     }
 
-    StoreMoveExceptionsStatusErrors = set((
-        ObjectResourceNameNotAllowedError,
-        ObjectResourceNameAlreadyExistsError,
-    ))
-
     StoreMoveExceptionsErrors = {
-        TooManyObjectResourcesError: customxml.MaxResources(),
-        InvalidResourceMove: (calendarserver_namespace, "valid-move"),
-        InvalidComponentTypeError: (caldav_namespace, "supported-component"),
+        ObjectResourceNameNotAllowedError: (_CommonObjectResource._storeExceptionStatus, None,),
+        ObjectResourceNameAlreadyExistsError: (_CommonObjectResource._storeExceptionStatus, None,),
+        TooManyObjectResourcesError: (_CommonObjectResource._storeExceptionError, customxml.MaxResources(),),
+        InvalidResourceMove: (_CommonObjectResource._storeExceptionError, (calendarserver_namespace, "valid-move"),),
+        InvalidComponentTypeError: (_CommonObjectResource._storeExceptionError, (caldav_namespace, "supported-component"),),
+        LockTimeout: (_CommonObjectResource._storeExceptionUnavailable, "Lock timed out.",),
     }
 
+    StoreRemoveExceptionsErrors = {
+        LockTimeout: (_CommonObjectResource._storeExceptionUnavailable, "Lock timed out.",),
+    }
+
     StoreAttachmentValidErrors = set((
         AttachmentStoreFailed,
         InvalidAttachmentOperation,
     ))
 
     StoreAttachmentExceptionsErrors = {
-        AttachmentStoreValidManagedID: (caldav_namespace, "valid-managed-id-parameter",),
-        AttachmentRemoveFailed: (caldav_namespace, "valid-attachment-remove",),
+        AttachmentStoreValidManagedID: (_CommonObjectResource._storeExceptionError, (caldav_namespace, "valid-managed-id-parameter",),),
+        AttachmentRemoveFailed: (_CommonObjectResource._storeExceptionError, (caldav_namespace, "valid-attachment-remove",),),
     }
 
 
@@ -2982,28 +3020,15 @@
         except Exception as err:
 
             if type(err) in self.StoreAttachmentValidErrors:
-                raise HTTPError(ErrorResponse(
-                    responsecode.FORBIDDEN,
-                    (caldav_namespace, valid_preconditions[action],),
-                    str(err),
-                ))
+                self._storeExceptionError(err, (caldav_namespace, valid_preconditions[action],))
 
             elif type(err) in self.StoreAttachmentExceptionsErrors:
-                raise HTTPError(ErrorResponse(
-                    responsecode.FORBIDDEN,
-                    self.StoreAttachmentExceptionsErrors[type(err)],
-                    str(err),
-                ))
+                error, arg = self.StoreAttachmentExceptionsErrors[type(err)]
+                error(err, arg)
 
-            elif type(err) in self.StoreExceptionsStatusErrors:
-                raise HTTPError(StatusResponse(responsecode.FORBIDDEN, str(err)))
-
             elif type(err) in self.StoreExceptionsErrors:
-                raise HTTPError(ErrorResponse(
-                    responsecode.FORBIDDEN,
-                    self.StoreExceptionsErrors[type(err)],
-                    str(err),
-                ))
+                error, arg = self.StoreExceptionsErrors[type(err)]
+                error(err, arg)
 
             else:
                 raise
@@ -3301,32 +3326,32 @@
 
     vCard = _CommonObjectResource.component
 
-    StoreExceptionsStatusErrors = set((
-        ObjectResourceNameNotAllowedError,
-        ObjectResourceNameAlreadyExistsError,
-    ))
-
     StoreExceptionsErrors = {
-        TooManyObjectResourcesError: customxml.MaxResources(),
-        ObjectResourceTooBigError: (carddav_namespace, "max-resource-size"),
-        InvalidObjectResourceError: (carddav_namespace, "valid-address-data"),
-        InvalidComponentForStoreError: (carddav_namespace, "valid-addressbook-object-resource"),
-        UIDExistsError: NovCardUIDConflict(),
-        InvalidUIDError: NovCardUIDConflict(),
-        InvalidPerUserDataMerge: (carddav_namespace, "valid-address-data"),
+        ObjectResourceNameNotAllowedError: (_CommonObjectResource._storeExceptionStatus, None,),
+        ObjectResourceNameAlreadyExistsError: (_CommonObjectResource._storeExceptionStatus, None,),
+        TooManyObjectResourcesError: (_CommonObjectResource._storeExceptionError, customxml.MaxResources(),),
+        ObjectResourceTooBigError: (_CommonObjectResource._storeExceptionError, (carddav_namespace, "max-resource-size"),),
+        InvalidObjectResourceError: (_CommonObjectResource._storeExceptionError, (carddav_namespace, "valid-address-data"),),
+        InvalidComponentForStoreError: (_CommonObjectResource._storeExceptionError, (carddav_namespace, "valid-addressbook-object-resource"),),
+        UIDExistsError: (_CommonObjectResource._storeExceptionError, NovCardUIDConflict(),),
+        InvalidUIDError: (_CommonObjectResource._storeExceptionError, NovCardUIDConflict(),),
+        InvalidPerUserDataMerge: (_CommonObjectResource._storeExceptionError, (carddav_namespace, "valid-address-data"),),
+        LockTimeout: (_CommonObjectResource._storeExceptionUnavailable, "Lock timed out.",),
     }
 
-    StoreMoveExceptionsStatusErrors = set((
-        ObjectResourceNameNotAllowedError,
-        ObjectResourceNameAlreadyExistsError,
-    ))
-
     StoreMoveExceptionsErrors = {
-        TooManyObjectResourcesError: customxml.MaxResources(),
-        InvalidResourceMove: (calendarserver_namespace, "valid-move"),
+        ObjectResourceNameNotAllowedError: (_CommonObjectResource._storeExceptionStatus, None,),
+        ObjectResourceNameAlreadyExistsError: (_CommonObjectResource._storeExceptionStatus, None,),
+        TooManyObjectResourcesError: (_CommonObjectResource._storeExceptionError, customxml.MaxResources(),),
+        InvalidResourceMove: (_CommonObjectResource._storeExceptionError, (calendarserver_namespace, "valid-move"),),
+        LockTimeout: (_CommonObjectResource._storeExceptionUnavailable, "Lock timed out.",),
     }
 
+    StoreRemoveExceptionsErrors = {
+        LockTimeout: (_CommonObjectResource._storeExceptionUnavailable, "Lock timed out.",),
+    }
 
+
     def resourceType(self):
         if self.isShared():
             return customxml.ResourceType.sharedownergroup

Modified: CalendarServer/trunk/twistedcaldav/test/test_wrapping.py
===================================================================
--- CalendarServer/trunk/twistedcaldav/test/test_wrapping.py	2013-12-04 03:43:03 UTC (rev 12029)
+++ CalendarServer/trunk/twistedcaldav/test/test_wrapping.py	2013-12-04 03:47:41 UTC (rev 12030)
@@ -19,41 +19,37 @@
 """
 
 
+from twext.enterprise.ienterprise import AlreadyFinishedError
+from twext.enterprise.locking import NamedLock
+from twext.web2 import responsecode
+from twext.web2.http import HTTPError
+from twext.web2.http_headers import Headers, MimeType
+from twext.web2.responsecode import INSUFFICIENT_STORAGE_SPACE
 from twext.web2.responsecode import UNAUTHORIZED
-from twext.web2.http_headers import Headers
-from twext.enterprise.ienterprise import AlreadyFinishedError
+from twext.web2.stream import MemoryStream
 
-from txdav.xml import element as davxml
-from twistedcaldav.config import config
-
 from twisted.internet.defer import inlineCallbacks, returnValue
+from twisted.internet.defer import maybeDeferred
 
+from twistedcaldav.config import config
+from twistedcaldav.directory.test.test_xmlfile import XMLFileBase
 from twistedcaldav.ical import Component as VComponent
-from twistedcaldav.vcard import Component as VCComponent
-
 from twistedcaldav.storebridge import DropboxCollection, \
     CalendarCollectionResource
-
 from twistedcaldav.test.util import StoreTestCase, SimpleStoreRequest
+from twistedcaldav.vcard import Component as VCComponent
 
-from txdav.idav import IDataStore
+from txdav.caldav.datastore.file import Calendar
 from txdav.caldav.datastore.test.test_file import test_event_text
-
+from txdav.caldav.icalendarstore import ICalendarHome
 from txdav.carddav.datastore.test.test_file import vcard4_text
-
+from txdav.carddav.iaddressbookstore import IAddressBookHome
 from txdav.common.datastore.test.util import assertProvides
-
-
-from twext.web2.http import HTTPError
-from twext.web2.responsecode import INSUFFICIENT_STORAGE_SPACE
-from twext.web2.stream import MemoryStream
 from txdav.common.datastore.test.util import deriveQuota
-from twistedcaldav.directory.test.test_xmlfile import XMLFileBase
-from txdav.caldav.icalendarstore import ICalendarHome
-from txdav.carddav.iaddressbookstore import IAddressBookHome
+from txdav.idav import IDataStore
+from txdav.xml import element as davxml
 
-from twisted.internet.defer import maybeDeferred
-from txdav.caldav.datastore.file import Calendar
+import hashlib
 
 def _todo(f, why):
     f.todo = why
@@ -560,3 +556,90 @@
         self.requestUnderTest = None
         yield self.assertCalendarEmpty(wsanchez)
         yield self.assertCalendarEmpty(cdaboo)
+
+
+
+class TimeoutTests(StoreTestCase):
+    """
+    Tests for L{twistedcaldav.storebridge} lock timeouts.
+    """
+
+    @inlineCallbacks
+    def test_timeoutOnPUT(self):
+        """
+        PUT gets a 503 on a lock timeout.
+        """
+
+        # Create a fake lock
+        txn = self.transactionUnderTest()
+        yield NamedLock.acquire(txn, "ImplicitUIDLock:%s" % (hashlib.md5("uid1").hexdigest(),))
+
+        # PUT fails
+        request = SimpleStoreRequest(
+            self,
+            "PUT",
+            "/calendars/users/wsanchez/calendar/1.ics",
+            headers=Headers({"content-type": MimeType.fromString("text/calendar")}),
+            authid="wsanchez"
+        )
+        request.stream = MemoryStream("""BEGIN:VCALENDAR
+CALSCALE:GREGORIAN
+PRODID:-//Apple Computer\, Inc//iCal 2.0//EN
+VERSION:2.0
+BEGIN:VEVENT
+UID:uid1
+DTSTART;VALUE=DATE:20020101
+DTEND;VALUE=DATE:20020102
+DTSTAMP:20020101T121212Z
+SUMMARY:New Year's Day
+END:VEVENT
+END:VCALENDAR
+""".replace("\n", "\r\n"))
+        response = yield self.send(request)
+        self.assertEqual(response.code, responsecode.SERVICE_UNAVAILABLE)
+
+
+    @inlineCallbacks
+    def test_timeoutOnDELETE(self):
+        """
+        DELETE gets a 503 on a lock timeout.
+        """
+
+        # PUT works
+        request = SimpleStoreRequest(
+            self,
+            "PUT",
+            "/calendars/users/wsanchez/calendar/1.ics",
+            headers=Headers({"content-type": MimeType.fromString("text/calendar")}),
+            authid="wsanchez"
+        )
+        request.stream = MemoryStream("""BEGIN:VCALENDAR
+CALSCALE:GREGORIAN
+PRODID:-//Apple Computer\, Inc//iCal 2.0//EN
+VERSION:2.0
+BEGIN:VEVENT
+UID:uid1
+DTSTART;VALUE=DATE:20020101
+DTEND;VALUE=DATE:20020102
+DTSTAMP:20020101T121212Z
+ORGANIZER:mailto:wsanchez at example.com
+ATTENDEE:mailto:wsanchez at example.com
+SUMMARY:New Year's Day
+END:VEVENT
+END:VCALENDAR
+""".replace("\n", "\r\n"))
+        response = yield self.send(request)
+        self.assertEqual(response.code, responsecode.CREATED)
+
+        # Create a fake lock
+        txn = self.transactionUnderTest()
+        yield NamedLock.acquire(txn, "ImplicitUIDLock:%s" % (hashlib.md5("uid1").hexdigest(),))
+
+        request = SimpleStoreRequest(
+            self,
+            "DELETE",
+            "/calendars/users/wsanchez/calendar/1.ics",
+            authid="wsanchez"
+        )
+        response = yield self.send(request)
+        self.assertEqual(response.code, responsecode.SERVICE_UNAVAILABLE)
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.macosforge.org/pipermail/calendarserver-changes/attachments/20140312/d432526e/attachment.html>


More information about the calendarserver-changes mailing list