syncproto Package

syncproto Package

base Module

class sts.syncproto.base.SyncIODelegate(io_master, socket)

Bases: object

__init__(io_master, socket)

close()

get_on_message_received()

on_message_received

send(msg)

set_on_message_received(f)

wait_for_message(timeout=None)

class sts.syncproto.base.SyncMessage

Bases: sts.syncproto.base.SyncMessage

value object that models a message in the STS sync protocol

class sts.syncproto.base.SyncProtocolListener(handlers, io_delegate, collect_stats=True, delay_threshold_ms=3.0)

Bases: object

Speaker delegates to this class to wait on messages

__init__(handlers, io_delegate, collect_stats=True, delay_threshold_ms=3.0)

on_message_received(msg_hash)

wait_for_xaction(message, timeout=None)

class sts.syncproto.base.SyncProtocolSpeaker(handlers, io_delegate, collect_stats=True)

Bases: object

speaks the sts sync protocol

__init__(handlers, io_delegate, collect_stats=True)

ack_sync_notification(messageClass, xid)

async_notification(messageClass, fingerPrint, value)

message_with_xid(message)

send(message)

Send a message you don’t expect a response from

sync_notification(messageClass, fingerPrint, value)

sync_request(messageClass, name, timeout=None)

Send a message you expect a response from. Note: Blocks this thread until a response is received!

class sts.syncproto.base.SyncTime

Bases: sts.syncproto.base.SyncTime

ValueObject that models the microsecond timestamps used in STS Sync Messages

as_float()

static now()

sts.syncproto.base.unpatched_time()

pox_syncer Module

class sts.syncproto.pox_syncer.POXIOMaster

Bases: sts.util.io_master.IOMaster, pox.lib.recoco.recoco.Task

horrible clutch of a hack that is both a regular select loop and a POX task yielding select (so it can be run by the recoco scheduler)

__init__()

run()

class sts.syncproto.pox_syncer.POXNomSnapshotter

Bases: object

__init__()

get_snapshot()

class sts.syncproto.pox_syncer.POXSyncConnection(io_master, sync_uri)

Bases: object

__init__(io_master, sync_uri)

async_notification(messageClass, fingerPrint, value)

listen()

request(messageClass, name)

sync_notification(messageClass, fingerPrint, value)

wait_for_connect()

class sts.syncproto.pox_syncer.POXSyncMaster(io_master, blocking=True)

Bases: object

__init__(io_master, blocking=True)

get_time()

Hack alert: python logging use time.time(). That means that log statements in the determinism protocols are going to invoke get_time again. Solve by returning the real time if we (get_time) are in the stacktrace

handle_UpEvent(_)

patch_functions()

start(sync_uri)

state_change(msg, *args)

Notify sts that we’re about to make a state change (log msg)

class sts.syncproto.pox_syncer.POXSyncProtocolSpeaker(io_delegate=None)

Bases: sts.syncproto.base.SyncProtocolSpeaker

__init__(io_delegate=None)

sts.syncproto.pox_syncer.launch(blocking=False)

sts_syncer Module

class sts.syncproto.sts_syncer.STSSyncCallback

Bases: object

override with your favorite functionality

get_deterministic_value(controller, name)

state_change(type, controller, time, fingerprint, name, value)

class sts.syncproto.sts_syncer.STSSyncConnection(controller, state_master, sync_uri)

Bases: object

A connection to a controller with the sts sync protocol

__init__(controller, state_master, sync_uri)

ack_sync_notification(messageClass, xid)

close()

connect(io_master)

disconnect()

get_nom_snapshot()

on_disconnect(func)

send_deterministic_value(xid, value)

send_link_notification(link_attrs)

class sts.syncproto.sts_syncer.STSSyncConnectionManager(io_master, state_master)

Bases: object

the connection manager for the STS sync protocols. TODO: finish

__init__(io_master, state_master)

connect(controller, sync_uri)

remove_connection(connection)

class sts.syncproto.sts_syncer.STSSyncProtocolSpeaker(controller, state_master, io_delegate)

Bases: sts.syncproto.base.SyncProtocolSpeaker

__init__(controller, state_master, io_delegate)