GDP

#!/usr/bin/env python

import gdp

import sys

import threading

import time

import pprint

# Assumes that logs are already created, and are named as follows:

lock = None

start = None

def localPrint(s):

    global lock

    global start

    lock.acquire()

    print "%9.6f ## %s] %s" % ((time.time()-start),

                            threading.current_thread().getName(), s)

    sys.stdout.flush()

    lock.release()

def sleep(t):

    # localPrint("Sleeping for %i" % t)

    time.sleep(t)

def appendThread(logname, sleepBefore, numRecords):

    h = gdp.GDP_GCL(gdp.GDP_NAME(logname), gdp.GDP_MODE_AO)

    localPrint(str(h))

    sleep(sleepBefore)

    for i in xrange(numRecords):

        sleep(1)

        data = "\"%s-%s-%d\"" % (logname,

                        threading.current_thread().getName(), i)

        localPrint("Appending %s to %s" % (data, logname))

        h.append({"data": data})

def subscribeThread(logname):

    h = gdp.GDP_GCL(gdp.GDP_NAME(logname), gdp.GDP_MODE_RO)

    localPrint(str(h))

    h.subscribe(0, 0, None)

    while True:

        event = h.get_next_event(None)

        localPrint("Got data: %s on %s" % (event["datum"]["data"], logname))

        # pprint.pprint(event)

def main(logname, numS, delay, numR):

    gdp.gdp_init()

    # gdp.dbg_set("gdp.event=85")

    global start

    start = time.time()

    global lock

    lock = threading.Lock()

    localPrint("logname: %s" % logname)

    # Starting up a single thread for appends

    localPrint("Starting Append Thread")

    t = threading.Thread(target=appendThread,

                        name="AThread", args=(logname, delay, numR))

    t.daemon = False

    t.start()

        # Starting a number of threads for subscriptions

    for i in range(numS):

        localPrint("Starting SThread%d" % (i+1))

        t = threading.Thread(target=subscribeThread,

                            name="SThread"+str(i+1),

                            args=(logname,))

        t.daemon = True

        t.start()

USAGE = """

    * Runs a single threads appending data to `logname`.

    * Also starts `numS` subscriber threads, all subscribed simultaneously

    to the same log.

    * `delay` and numRec` control the execution pattern.

    `delay` is the delay in seconds before starting to append data

    in an append thread, `numRec` is the number of records that are

    appended in each thread (one second delay between consecutive

    appends within a thread)

    Assumes that the log is precreated.

"""

if __name__=="__main__":

    if len(sys.argv)<5:

        print "Uusage: %s logname numS delay numRec" % sys.argv[0]

        print USAGE

        sys.exit(1)

    main(sys.argv[1], int(sys.argv[2]), int(sys.argv[3]), int(sys.argv[4]))