Python utils.assertReadFrom函数代码示例

    def test_passive_and_hidden(self):
        self.c = MongoReplicaSetClient(
            self.seed, replicaSet=self.name, use_greenlets=use_greenlets)

        passives = ha_tools.get_passives()
        passives = partition_nodes(passives)
        self.assertEqual(self.c.secondaries, set(passives))

        for mode in SECONDARY, SECONDARY_PREFERRED:
            utils.assertReadFromAll(self, self.c, passives, mode)

        ha_tools.kill_members(ha_tools.get_passives(), 2)
        sleep(2 * MONITOR_INTERVAL)
        utils.assertReadFrom(self, self.c, self.c.primary, SECONDARY_PREFERRED)

    def test_passive_and_hidden(self):
        self.c = MongoClient(
            self.seed,
            replicaSet=self.name,
            serverSelectionTimeoutMS=self.server_selection_timeout)

        passives = ha_tools.get_passives()
        passives = partition_nodes(passives)
        self.assertEqual(self.c.secondaries, set(passives))

        for mode in SECONDARY, SECONDARY_PREFERRED:
            utils.assertReadFromAll(self, self.c, passives, mode)

        ha_tools.kill_members(ha_tools.get_passives(), 2)
        time.sleep(2 * self.heartbeat_frequency)
        utils.assertReadFrom(self, self.c, self.c.primary, SECONDARY_PREFERRED)

    def test_request_during_failover(self):
        primary = _partition_node(ha_tools.get_primary())
        secondary = _partition_node(ha_tools.get_random_secondary())

        self.assertTrue(self.c.auto_start_request)
        self.assertTrue(self.c.in_request())

        rs_state = self.c._MongoReplicaSetClient__rs_state
        primary_pool = rs_state.get(primary).pool
        secondary_pool = rs_state.get(secondary).pool

        # Trigger start_request on primary pool
        utils.assertReadFrom(self, self.c, primary, PRIMARY)
        self.assertTrue(primary_pool.in_request())

        # Fail over
        ha_tools.kill_primary()
        sleep(5)

        patience_seconds = 60
        for _ in range(patience_seconds):
            try:
                if ha_tools.ha_tools_debug:
                    print 'Waiting for failover'
                if ha_tools.get_primary():
                    # We have a new primary
                    break
            except ConnectionFailure:
                pass

            sleep(1)
        else:
            self.fail("Problem with test: No new primary after %s seconds"
                % patience_seconds)

        try:
            # Trigger start_request on secondary_pool, which is becoming new
            # primary
            self.c.test.test.find_one()
        except AutoReconnect:
            # We've noticed the failover now
            pass

        # The old secondary is now primary
        utils.assertReadFrom(self, self.c, secondary, PRIMARY)
        self.assertTrue(self.c.in_request())
        self.assertTrue(secondary_pool.in_request())

    def test_monitor_removes_recovering_member(self):
        self.c = MongoReplicaSetClient(
            self.seed, replicaSet=self.name, use_greenlets=use_greenlets)

        secondaries = ha_tools.get_secondaries()

        for mode in SECONDARY, SECONDARY_PREFERRED:
            partitioned_secondaries = partition_nodes(secondaries)
            utils.assertReadFromAll(self, self.c, partitioned_secondaries, mode)

        secondary, recovering_secondary = secondaries
        ha_tools.set_maintenance(recovering_secondary, True)
        sleep(2 * MONITOR_INTERVAL)

        for mode in SECONDARY, SECONDARY_PREFERRED:
            # Don't read from recovering member
            utils.assertReadFrom(self, self.c, _partition_node(secondary), mode)

    def test_recovering(self):
        self.c = ReplicaSetConnection(
            self.seed, replicaSet=self.name, use_greenlets=use_greenlets,
            auto_start_request=False)

        secondaries = ha_tools.get_secondaries()

        for mode in SECONDARY, SECONDARY_PREFERRED:
            partitioned_secondaries = [_partition_node(s) for s in secondaries]
            utils.assertReadFromAll(self, self.c, partitioned_secondaries, mode)

        secondary, recovering_secondary = secondaries
        ha_tools.set_maintenance(recovering_secondary, True)
        sleep(2 * MONITOR_INTERVAL)

        for mode in SECONDARY, SECONDARY_PREFERRED:
            # Don't read from recovering member
            utils.assertReadFrom(self, self.c, _partition_node(secondary), mode)

    def test_monitor_removes_recovering_member(self):
        self.c = MongoClient(
            self.seed,
            replicaSet=self.name,
            serverSelectionTimeoutMS=self.server_selection_timeout)

        secondaries = ha_tools.get_secondaries()

        for mode in SECONDARY, SECONDARY_PREFERRED:
            partitioned_secondaries = partition_nodes(secondaries)
            utils.assertReadFromAll(self, self.c, partitioned_secondaries, mode)

        secondary, recovering_secondary = secondaries
        ha_tools.set_maintenance(recovering_secondary, True)
        time.sleep(2 * self.heartbeat_frequency)

        for mode in SECONDARY, SECONDARY_PREFERRED:
            # Don't read from recovering member
            utils.assertReadFrom(self, self.c, partition_node(secondary), mode)

    def test_pinned_member(self):
        latency = 1000 * 1000
        conn = self._get_connection(
            auto_start_request=False, secondary_acceptable_latency_ms=latency)

        host = read_from_which_host(conn, ReadPreference.SECONDARY)
        self.assertTrue(host in conn.secondaries)

        # No pinning since we're not in a request
        assertReadFromAll(
            self, conn, conn.secondaries,
            ReadPreference.SECONDARY, None, latency)

        assertReadFromAll(
            self, conn, list(conn.secondaries) + [conn.primary],
            ReadPreference.NEAREST, None, latency)

        conn.start_request()
        host = read_from_which_host(conn, ReadPreference.SECONDARY)
        self.assertTrue(host in conn.secondaries)
        assertReadFrom(self, conn, host, ReadPreference.SECONDARY)

        # Changing any part of read preference (mode, tag_sets, latency)
        # unpins the current host and pins to a new one
        primary = conn.primary
        assertReadFrom(self, conn, primary, ReadPreference.PRIMARY_PREFERRED)

        host = read_from_which_host(conn, ReadPreference.NEAREST)
        assertReadFrom(self, conn, host, ReadPreference.NEAREST)

        assertReadFrom(self, conn, primary, ReadPreference.PRIMARY_PREFERRED)

        host = read_from_which_host(conn, ReadPreference.SECONDARY_PREFERRED)
        self.assertTrue(host in conn.secondaries)
        assertReadFrom(self, conn, host, ReadPreference.SECONDARY_PREFERRED)

        # Unpin
        conn.end_request()
        assertReadFromAll(
            self, conn, list(conn.secondaries) + [conn.primary],
            ReadPreference.NEAREST, None, latency)

    def test_pinned_member(self):
        raise SkipTest("skipping due to Tokutek/mongo#77")
        latency = 1000 * 1000
        client = self._get_client(secondary_acceptable_latency_ms=latency)

        host = read_from_which_host(client, ReadPreference.SECONDARY)
        self.assertTrue(host in client.secondaries)

        # No pinning since we're not in a request
        assertReadFromAll(
            self, client, client.secondaries,
            ReadPreference.SECONDARY, None, latency)

        assertReadFromAll(
            self, client, list(client.secondaries) + [client.primary],
            ReadPreference.NEAREST, None, latency)

        client.start_request()
        host = read_from_which_host(client, ReadPreference.SECONDARY)
        self.assertTrue(host in client.secondaries)
        assertReadFrom(self, client, host, ReadPreference.SECONDARY)

        # Changing any part of read preference (mode, tag_sets, latency)
        # unpins the current host and pins to a new one
        primary = client.primary
        assertReadFrom(self, client, primary, ReadPreference.PRIMARY_PREFERRED)

        host = read_from_which_host(client, ReadPreference.NEAREST)
        assertReadFrom(self, client, host, ReadPreference.NEAREST)

        assertReadFrom(self, client, primary, ReadPreference.PRIMARY_PREFERRED)

        host = read_from_which_host(client, ReadPreference.SECONDARY_PREFERRED)
        self.assertTrue(host in client.secondaries)
        assertReadFrom(self, client, host, ReadPreference.SECONDARY_PREFERRED)

        # Unpin
        client.end_request()
        assertReadFromAll(
            self, client, list(client.secondaries) + [client.primary],
            ReadPreference.NEAREST, None, latency)

    def test_pinned_member(self):
        conn = self._get_connection(
            auto_start_request=False, secondary_acceptable_latency_ms=1000*1000)

        host = read_from_which_host(conn, ReadPreference.SECONDARY)
        self.assertTrue(host in conn.secondaries)

        # No pinning since we're not in a request
        assertReadFromAll(
            self, conn, conn.secondaries, ReadPreference.SECONDARY)

        assertReadFromAll(
            self, conn, list(conn.secondaries) + [conn.primary],
            ReadPreference.NEAREST)

        conn.start_request()
        host = read_from_which_host(conn, ReadPreference.SECONDARY)
        self.assertTrue(host in conn.secondaries)
        assertReadFrom(self, conn, host, ReadPreference.SECONDARY)

        # Repin
        primary = read_from_which_host(conn, ReadPreference.PRIMARY)
        self.assertEqual(conn.primary, primary)
        assertReadFrom(self, conn, primary, ReadPreference.NEAREST)

        # Repin again
        host = read_from_which_host(conn, ReadPreference.SECONDARY)
        self.assertTrue(host in conn.secondaries)
        assertReadFrom(self, conn, host, ReadPreference.SECONDARY)

        # Unpin
        conn.end_request()
        assertReadFromAll(
            self, conn, list(conn.secondaries) + [conn.primary],
            ReadPreference.NEAREST)

 def assertReadFrom(member, *args, **kwargs):
     utils.assertReadFrom(self, c, member, *args, **kwargs)

    def test_pinned_member(self):
        latency = 1000 * 1000
        conn = self._get_connection(
            auto_start_request=False, secondary_acceptable_latency_ms=latency)

        host = read_from_which_host(conn, ReadPreference.SECONDARY)
        self.assertTrue(host in conn.secondaries)

        # No pinning since we're not in a request
        assertReadFromAll(
            self, conn, conn.secondaries,
            ReadPreference.SECONDARY, None, latency)

        assertReadFromAll(
            self, conn, list(conn.secondaries) + [conn.primary],
            ReadPreference.NEAREST, None, latency)

        conn.start_request()
        host = read_from_which_host(conn, ReadPreference.SECONDARY)
        self.assertTrue(host in conn.secondaries)
        assertReadFrom(self, conn, host, ReadPreference.SECONDARY)

        # Oddly, we expect PRIMARY_PREFERRED to keep reading from secondary,
        # since the secondary is pinned and "matches" the preference.
        assertReadFrom(self, conn, host, ReadPreference.PRIMARY_PREFERRED)

        # Repin
        primary = read_from_which_host(conn, ReadPreference.PRIMARY)
        self.assertEqual(conn.primary, primary)
        assertReadFrom(self, conn, primary, ReadPreference.NEAREST)
        assertReadFrom(self, conn, primary, ReadPreference.PRIMARY_PREFERRED)

        # Since the we're pinned to primary we still use it
        assertReadFrom(self, conn, primary, ReadPreference.SECONDARY_PREFERRED)

        # Repin again
        host = read_from_which_host(conn, ReadPreference.SECONDARY)
        self.assertTrue(host in conn.secondaries)
        assertReadFrom(self, conn, host, ReadPreference.SECONDARY)

        # Unpin
        conn.end_request()
        assertReadFromAll(
            self, conn, list(conn.secondaries) + [conn.primary],
            ReadPreference.NEAREST, None, latency)