import gc

import os

import struct

import sys

import threading

import time

from nose.plugins.skip import SkipTest

from bson.son import SON

from pymongo import MongoClient, MongoReplicaSetClient

from pymongo.errors import AutoReconnect, ConnectionFailure, OperationFailure

from pymongo.pool import NO_REQUEST, NO_SOCKET_YET, SocketInfo

from test import host, port, version

try:

import gevent

has_gevent = True

except ImportError:

has_gevent = False

def my_partial(f, *args, **kwargs):

return _f

def one(s):

"""Get one element of a set"""

return iter(s).next()

def oid_generated_on_client(doc):

"""Is this process's PID in the document's _id?"""

pid_from_doc = struct.unpack(">H", doc['_id'].binary[7:9])[0]

return (os.getpid() % 0xFFFF) == pid_from_doc

def delay(sec):

}''' % sec

def get_command_line(client):

command_line = client.admin.command('getCmdLineOpts')

assert command_line['ok'] == 1, "getCmdLineOpts() failed"

return command_line

def server_started_with_option(client, cmdline_opt, config_opt):

return cmdline_opt in argv

def server_started_with_auth(client):

return '--auth' in argv or '--keyFile' in argv

def server_started_with_nojournal(client):

return server_started_with_option(client, '--nojournal', 'nojournal')

def server_is_master_with_slave(client):

return '--master' in command_line['argv']

def drop_collections(db):

for coll in db.collection_names():

if not coll.startswith('system'):

db.drop_collection(coll)

def remove_all_users(db):

db.system.users.remove({})

def joinall(threads):

assert not t.isAlive(), "Thread %s hung" % t

def is_mongos(client):

res = client.admin.command('ismaster')

return res.get('msg', '') == 'isdbgrid'

def enable_text_search(client):

'setParameter', textSearchEnabled=True)

def assertRaisesExactly(cls, fn, *args, **kwargs):

raise AssertionError("%s not raised" % cls)

def looplet(greenlets):

return

class RendezvousThread(threading.Thread):

self.passed = True

def read_from_which_host(

return None

def assertReadFrom(testcase, rsc, member, *args, **kwargs):

testcase.assertEqual(member, read_from_which_host(rsc, *args, **kwargs))

def assertReadFromAll(testcase, rsc, members, *args, **kwargs):

testcase.assertEqual(members, used)

def get_pool(client):

raise TypeError(str(client))

def pools_from_rs_client(client):

client._MongoReplicaSetClient__rs_state.members]

class TestRequestMixin(object):

self.assertDifferentSock(pool)

NTRIALS = 5

NTHREADS = 10

def run_threads(collection, target, use_greenlets):

assert not t.isAlive()

def lazy_client_trial(reset, target, test, get_client, use_greenlets):

sys.setcheckinterval(interval)

class _TestLazyConnectMixin(object):

c.max_message_size)

class _TestExhaustCursorMixin(object):

self.assertTrue(pool._socket_semaphore.acquire(blocking=False))

class WarningMessage(object):

self.filename, self.lineno, self.line))

class CatchWarnings(object):

self._module.showwarning = self._showwarning

def catch_warnings(record=False, module=None):

"""Helper for use with CatchWarnings."""

return CatchWarnings(record, module)