Ejemplo n.º 1
0
    def testSuspendSameClientTwiceBeforeResuming(self):
        def test(suspendMethod):
            s1 = next(
                compose(
                    suspendMethod(clientIdentifier="a-client-id",
                                  prefix='prefix',
                                  sets=[],
                                  continueAfter='9876')))
            s1(CallTrace('reactor'), lambda: None)
            next(
                compose(
                    suspendMethod(clientIdentifier="a-client-id",
                                  prefix='prefix',
                                  sets=[],
                                  continueAfter='9876')))
            try:
                s1.getResult()
                self.fail()
            except ForcedResumeException as e:
                self.assertEqual(
                    "Aborting suspended request because of new request for the same OaiClient with identifier: a-client-id.",
                    str(e))

        test(SuspendRegister().suspendAfterNoResult)
        test(SuspendRegister(batchMode=True).suspendAfterNoResult)
        batchRegister = SuspendRegister(batchMode=True)
        batchRegister.startOaiBatch()
        test(batchRegister.suspendAfterNoResult)
        batchRegister = SuspendRegister(batchMode=True)
        batchRegister._setLastStamp(1000)
        batchRegister.startOaiBatch()
        test(batchRegister.suspendBeforeSelect
             )  #only suspend in batch (not outside)
Ejemplo n.º 2
0
    def testResumeOnlyMatchingSuspendsInBatchMode(self):
        register = SuspendRegister(batchMode=True)
        register._setLastStamp(999)
        register.startOaiBatch()
        resumed = []

        def suspendBeforeSelect(clientIdentifier, prefix, sets, continueAfter):
            suspendObject = compose(register.suspendBeforeSelect(clientIdentifier=clientIdentifier, prefix=prefix, sets=sets, continueAfter=continueAfter)).next()
            suspendObject(CallTrace('reactor'), lambda: resumed.append(clientIdentifier))

        suspendBeforeSelect('id0', prefix='p0', sets=['s0'], continueAfter='1000')
        suspendBeforeSelect('id1', prefix='p0', sets=['s1'], continueAfter='1000')
        suspendBeforeSelect('id2', prefix='p0', sets=['s1'], continueAfter='1000')
        suspendBeforeSelect('id3', prefix='p0', sets=[], continueAfter='1000')
        suspendBeforeSelect('id4', prefix='p1', sets=['s0'], continueAfter='1000')
        suspendBeforeSelect('id5', prefix='p1', sets=[], continueAfter='1000')

        register.signalOaiUpdate(metadataPrefixes=['p0'], sets=set(), stamp=1001)
        self.assertEquals([], resumed)
        register.stopOaiBatch()
        # nobody cared about the update
        self.assertEquals(['id3'], resumed)
        del resumed[:]
        register.startOaiBatch()
        register.signalOaiUpdate(metadataPrefixes=['p0'], sets=set(['s0', 's1']), stamp=1002)
        self.assertEquals([], resumed)
        register.stopOaiBatch()
        self.assertEquals(['id0', 'id1', 'id2'], sorted(resumed))
        del resumed[:]
        register.startOaiBatch()
        register.signalOaiUpdate(metadataPrefixes=['p1'], sets=set('s42'), stamp=1001)
        register.stopOaiBatch()
        self.assertEquals(['id5'], sorted(resumed))
Ejemplo n.º 3
0
    def testResumeOnlyMatchingSuspendsInBatchMode(self):
        register = SuspendRegister(batchMode=True)
        register._setLastStamp(999)
        register.startOaiBatch()
        resumed = []

        def suspendBeforeSelect(clientIdentifier, prefix, sets, continueAfter):
            suspendObject = next(
                compose(
                    register.suspendBeforeSelect(
                        clientIdentifier=clientIdentifier,
                        prefix=prefix,
                        sets=sets,
                        continueAfter=continueAfter)))
            suspendObject(CallTrace('reactor'),
                          lambda: resumed.append(clientIdentifier))

        suspendBeforeSelect('id0',
                            prefix='p0',
                            sets=['s0'],
                            continueAfter='1000')
        suspendBeforeSelect('id1',
                            prefix='p0',
                            sets=['s1'],
                            continueAfter='1000')
        suspendBeforeSelect('id2',
                            prefix='p0',
                            sets=['s1'],
                            continueAfter='1000')
        suspendBeforeSelect('id3', prefix='p0', sets=[], continueAfter='1000')
        suspendBeforeSelect('id4',
                            prefix='p1',
                            sets=['s0'],
                            continueAfter='1000')
        suspendBeforeSelect('id5', prefix='p1', sets=[], continueAfter='1000')

        register.signalOaiUpdate(metadataPrefixes=['p0'],
                                 sets=set(),
                                 stamp=1001)
        self.assertEqual([], resumed)
        register.stopOaiBatch()
        # nobody cared about the update
        self.assertEqual(['id3'], resumed)
        del resumed[:]
        register.startOaiBatch()
        register.signalOaiUpdate(metadataPrefixes=['p0'],
                                 sets=set(['s0', 's1']),
                                 stamp=1002)
        self.assertEqual([], resumed)
        register.stopOaiBatch()
        self.assertEqual(['id0', 'id1', 'id2'], sorted(resumed))
        del resumed[:]
        register.startOaiBatch()
        register.signalOaiUpdate(metadataPrefixes=['p1'],
                                 sets=set('s42'),
                                 stamp=1001)
        register.stopOaiBatch()
        self.assertEqual(['id5'], sorted(resumed))
Ejemplo n.º 4
0
    def testShouldResumeAPreviousSuspendAfterTooManySuspends(self):
        def test(suspendMethod):
            with stderr_replaced() as s:
                s1 = next(
                    compose(
                        suspendMethod(clientIdentifier="a-client-id",
                                      prefix='prefix',
                                      sets=[],
                                      continueAfter='9876')))
                s1(CallTrace('reactor'), lambda: None)
                next(
                    compose(
                        suspendMethod(clientIdentifier="another-client-id",
                                      prefix='prefix',
                                      sets=[],
                                      continueAfter='9876')))
                try:
                    s1.getResult()
                    self.fail()
                except ForcedResumeException:
                    self.assertEqual(
                        "Too many suspended connections in SuspendRegister. One random connection has been resumed.\n",
                        s.getvalue())

        test(
            SuspendRegister(
                maximumSuspendedConnections=1).suspendAfterNoResult)
        test(
            SuspendRegister(
                batchMode=True,
                maximumSuspendedConnections=1).suspendAfterNoResult)
        batchRegister = SuspendRegister(batchMode=True,
                                        maximumSuspendedConnections=1)
        batchRegister.startOaiBatch()
        test(batchRegister.suspendAfterNoResult)
        batchRegister = SuspendRegister(batchMode=True,
                                        maximumSuspendedConnections=1)
        batchRegister._setLastStamp(1000)
        batchRegister.startOaiBatch()
        test(batchRegister.suspendBeforeSelect
             )  #only suspend in batch (not outside)
Ejemplo n.º 5
0
    def testShouldResumeAPreviousSuspendAfterTooManySuspends(self):
        def test(suspendMethod):
            with stderr_replaced() as s:
                s1 = compose(suspendMethod(clientIdentifier="a-client-id", prefix='prefix', sets=[], continueAfter='9876')).next()
                s1(CallTrace('reactor'), lambda: None)
                compose(suspendMethod(clientIdentifier="another-client-id", prefix='prefix', sets=[], continueAfter='9876')).next()
                try:
                    s1.getResult()
                    self.fail()
                except ForcedResumeException:
                    self.assertEquals("Too many suspended connections in SuspendRegister. One random connection has been resumed.\n", s.getvalue())

        test(SuspendRegister(maximumSuspendedConnections=1).suspendAfterNoResult)
        test(SuspendRegister(batchMode=True, maximumSuspendedConnections=1).suspendAfterNoResult)
        batchRegister = SuspendRegister(batchMode=True, maximumSuspendedConnections=1)
        batchRegister.startOaiBatch()
        test(batchRegister.suspendAfterNoResult)
        batchRegister = SuspendRegister(batchMode=True, maximumSuspendedConnections=1)
        batchRegister._setLastStamp(1000)
        batchRegister.startOaiBatch()
        test(batchRegister.suspendBeforeSelect) #only suspend in batch (not outside)