gevent with cassandra http://rustyrazorblade.com/2016/02/async-python-and-cassandra-with-gevent/

async-python-and-cassandra-with-gevent.py

# remember to patch first
from gevent import monkey
monkey.patch_all()

import gevent

from uuid import uuid4

from cassandra.cqlengine.connection import setup
from cassandra.cqlengine.columns import *
from cassandra.cqlengine.models import Model
from cassandra.cqlengine.management import sync_table, drop_table, create_keyspace_simple, drop_keyspace
from gevent.pool import Pool
from faker import Factory

setup(["127.0.0.1"], "test")
faker = Factory.create()

import time


class Timer:
    name = None

    def __init__(self, name):
        self.name = name

    def __enter__(self):
        self.start = time.time()
        # print "Starting", self.start
        return self

    def __exit__(self, *args):
        self.end = time.time()
        self.interval = self.end - self.start
        print "{}: {}s".format(self.name, self.interval)

class User(Model):
    __keyspace__ = "test"
    __table_name__ = "user"

    user_id = UUID(primary_key=True)
    first_name = Text()
    last_name = Text()

create_keyspace_simple("test", replication_factor=1)
drop_table(User)
sync_table(User)

# create our first user
user = User.create(user_id=uuid4(),
            first_name=faker.first_name(),
            last_name=faker.last_name())
print "user: ", user


future = gevent.spawn(User.create, user_id=uuid4(),
                                   first_name=faker.first_name(),
                                   last_name=faker.last_name())
print "Future: ", future
print "Future result: ", future.get()

# create more users
num = 1000
with Timer("create users sync"):
    for x in range(num):
        # print "Creating user {}".format(x)
        User.create(user_id=uuid4(),
                    first_name=faker.first_name(),
                    last_name=faker.last_name())


# create more users
pool = Pool(100)
with Timer("create users async"):
    def create_user(i):
        User.create(user_id=uuid4(),
                    first_name=faker.first_name(),
                    last_name=faker.last_name())

    pool.map(create_user, range(num))


# with network latency
latency_tests = [.001, .005, .01, .1]

for latency in latency_tests:
    with Timer("create users sync with {} latency".format(latency)):
        for x in range(num):
            # print "Creating user {}".format(x)
            time.sleep(latency)
            User.create(user_id=uuid4(),
                        first_name=faker.first_name(),
                        last_name=faker.last_name())


    # create more users
    pool = Pool(100)
    with Timer("create users async with {} latency".format(latency)):
        def create_user(i):
            time.sleep(latency)
            User.create(user_id=uuid4(),
                        first_name=faker.first_name(),
                        last_name=faker.last_name())

        pool.map(create_user, range(num))