troup package

Submodules

troup.apps module

class troup.apps.App(name=None, description=None, command=None, params=None, needs=None)

Bases: object

troup.client module

class troup.client.CallbackWrapper(callback, valid_for, promise=None, created_on=None)

Bases: object

check_expired()

execute_callback(result)

class troup.client.ChannelClient(nodes_specs=None, reply_timeout=5000, check_interval=5000)

Bases: object

build_channel(for_node)

create_channel(node_name, reference)

get_channel(for_node)

send_message(message, to_node=None, on_reply=None)

send_message_to_node(message, node, on_reply)

shutdown()

class troup.client.CommandAPI(channel_client)

Bases: object

command(name, data)

monitor(command_ref)

send(command, to_node=None, on_reply=None)

shutdown()

task(type, data, ttl=None, track_out=False, buffer=None)

troup.client.client_to_local_node()

troup.debug module

exception troup.debug.ExitCliException

Bases: Exception

troup.debug.debug_cli()

troup.debug.print_help(cmd)

troup.debug.print_threads(cmd)

troup.debug.quit_cli(cmd)

troup.debug.run_debug_cli()

troup.distributed module

exception troup.distributed.DistributedException(message, data=None)

Bases: Exception

class troup.distributed.Promise

Bases: object

complete(result=None, error=None)

is_done

result

troup.infrastructure module

class troup.infrastructure.AsyncIOWebSocketServer(host='', port=1700, web_socket_class=<class 'troup.infrastructure.IncomingChannelWSAdapter'>)

Bases: object

get_server_endpoint()

notify_event(event, channel)

on_channel_closed(channel)

on_channel_open(channel)

on_event(callback)

start()

stop()

class troup.infrastructure.Bus

Bases: object

class troup.infrastructure.Channel(name, to_url)

Bases: object

CLOSED = 'CLOSED'

CLOSING = 'CLOSING'

CONNECTING = 'CONNECTING'

CREATED = 'CREATED'

ERROR = 'ERROR'

OPEN = 'OPEN'

close()

connect()

data_received(data)

disconnect()

on(event_name, callback)

open()

register_listener(callback)

send(data)

trigger(event, *data)

exception troup.infrastructure.ChannelClosedError

Bases: troup.infrastructure.ChannelError

exception troup.infrastructure.ChannelError

Bases: Exception

class troup.infrastructure.ChannelManager(aio_server)

Bases: troup.observer.Observable

channel(name=None, to_url=None)

close_channel(name=None, endpoint=None)

listen(name=None, to_url=None, listener=None)

on_data(callback, from_channel=None)

open_channel_to(name, url)

send(name=None, to_url=None, data=None)

class troup.infrastructure.IncomingChannelWSAdapter(protocol)

Bases: ws4py.async_websocket.WebSocket

closed(code, reason=None)

local_address

Local endpoint address as a tuple

opened()

peer_address

Peer endpoint address as a tuple

received_message(message)

class troup.infrastructure.IncommingChannel(name, to_url, adapter=None)

Bases: troup.infrastructure.Channel

disconnect()

notify_close()

send(data)

class troup.infrastructure.ListenerWrapper(delegate)

Bases: object

on_data(data)

class troup.infrastructure.MessageBus

Bases: object

on(topic, handler, message_filter=None)

publish(topic, *events)

remove(topic, handler)

class troup.infrastructure.MessageHandler(handler, message_filter)

Bases: object

class troup.infrastructure.OutgoingChannelOverWS(name, to_url, early_messages='queue', queue_max_size=1000)

Bases: troup.infrastructure.Channel

connect()

disconnect()

on_closed(code, reason=None)

on_opened()

send(data)

class troup.infrastructure.OutgoingChannelWSAdapter(url, handlers)

Bases: ws4py.client.threadedclient.WebSocketClient

closed(code, reason=None)

opened()

received_message(m)

class troup.infrastructure.ServerAwareWebSocketProtocol(handler_class, server)

Bases: ws4py.server.tulipserver.WebSocketProtocol

class troup.infrastructure.Subscribe(topic, filter=None, bus=None)

Bases: object

troup.main module

troup.main.configure_node_parser()

troup.main.run_node()

troup.messaging module

class troup.messaging.DictEncoder(skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: json.encoder.JSONEncoder

default(o)

class troup.messaging.Message

Bases: object

class troup.messaging.MessageBuilder

Bases: object

build()

data(message_data)

header(name, value)

id(message_id)

value(key, value)

troup.messaging.deserialize(smsg, as_type=None, strict=False)

troup.messaging.deserialize_dict(dval, as_type, strict=None)

troup.messaging.message(id=None, data=None)

troup.messaging.serialize(msg, indent=None)

troup.metadata module

troup.node module

class troup.node.Node(node_id, config, store=None, channel_manager=None, aio_server=None, stats_tracker=None, sync_manager=None, tasks_runner=None)

Bases: object

Basic interface for interaction with the system and the basic unit of the system.

A Node tracks system stats, interacts with other nodes and ultimatly manages the execution of tasks and commands.

The system is comprised of multiple nodes coordinating between themselves. Usually there is one node per machine.

• node_id is the node identifier. This should be uniqe on the system.
• config is the configuration dict() for the node.
• store is the troup.store.Store instance used by this node.

command_handler(command, handler)

get_apps()

get_available_apps()

get_node_info()

get_stats()

query(q)

run_app(app_name)

start()

stop()

class troup.node.NodeInfo(name=None, stats=None, apps=None, endpoint=None, hostname=None, data=None)

Bases: object

class troup.node.RandomBuffer(nodes_dict)

Bases: object

next(n)

class troup.node.SyncManager(node, channel_manager, event_processor, sync_interval=60000, sync_percent=0.3)

Bases: object

get_node_info(node)

get_sync_message()

register_node(node)

start()

stop()

sync_one_node(node, this_node_info)

sync_random_nodes()

unregister_node(node)

troup.node.check_local_node_lock()

troup.node.local_node_lock_file(node_info=None)

troup.node.node_info_from_dict(node_dict)

troup.node.read_local_node_lock()

troup.observer module

class troup.observer.Observable

Bases: object

on(event, handler)

remove_listener(event, listener)

trigger(event, *args)

troup.process module

class troup.process.LocalProcess(id, name, args=None, cwd=None)

Bases: troup.process.Process

close_streams()

execute()

get_returncode()

kill()

wait()

class troup.process.LockFile(path, content=None, create=False, read_only=False)

Bases: object

content

exists()

unlock()

class troup.process.Process(id, name, args=None)

Bases: object

execute()

get_returncode()

send_signal(signal)

class troup.process.ProcessInfoFile(path, pid=None, create=False, with_info=None, read_only=False)

Bases: troup.process.LockFile

get_info(name)

set_info(name, info)

class troup.process.RemoteProcess(id, name, args=None)

Bases: troup.process.Process

class troup.process.SSHRemoteProcess(id, name, args=None, cwd=None, forward_video=False, forward_audio=False, compress_stream=False, target_host=None, target_port='22', ssh_user='')

Bases: troup.process.LocalProcess

get_ssh_args()

troup.process.open_process_lock_file(path, read_only=False)

troup.process.this_process_info_file(path, info=None, create=False)

troup.setup module

troup.setup.main()

Entry point for the application script

troup.store module

class troup.store.DictEncoder(skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: json.encoder.JSONEncoder

default(o)

class troup.store.InMemorySyncedStore(root_path, apps_file=None, settings_file=None)

Bases: troup.store.Store

APPS_FILE = 'apps.json'

SETTINGS_FILE = 'settings.json'

add_app(app)

find_app(app_name)

get_setting(setting_name)

get_settings()

load_from_file()

remove_app(app_name)

search_apps(query)

set_setting(name, value)

store_settings(settings)

sync()

update_app(app)

class troup.store.Store

Bases: object

add_app(app)

find_app(app_name)

get_setting(setting_name)

get_settings()

remove_app(app_name)

search_apps(query)

set_setting(name, value)

store_settings(settings)

update_app(app)

troup.system module

class troup.system.CpuinfoParser

Bases: object

ENTRY_REGEX = '(?P<label>[\\w\\d-]+)\\s?:\\s?(?P<value>.+)'

parse(cpu_info_file)

class troup.system.StatsTracker(period=1000)

Bases: object

get_stats()

refresh_values()

stop_tracking()

class troup.system.SystemStats

Bases: object

Statistics values for the underlying system.

Holds the values for a single measurement of the system performance.

Attributes:

cpu (dict): Holds the CPU values in a dictionary. The following values

are retrieved: * “usage” (number): CPU usage. It is a number 0.0 - 1.0. * “per_cpu” (Array[number]): CPU usage per CPU. Reports the usage of each

CPU separately in an Array.

• “processors” (int): Number of processors present on the system.
• “bogomips” (number): Bogus MIPS as reported by the Linux kernel (if available)

memory (dict): Holds the values for the system memory:

• “total” (int): total memory present in the system in Bytes.
• “user” (int): Used memory (in Bytes).
• “free” (int): Free memory (in Bytes).

system (dict): System load and general system info:

• “load” (Array[number]): System load as reported by the system. Usually this

  is an array of three values - the system load for the last 5, 10 and 15 minutes.

• “name” (str): Node name or the name of the machine.

• “platform” (str): The underlying OS platform. May be “linux”, “bsd” etc.

disk (dict): Information about the disk and I/O of the system:

• “ioload” (number): Normalized Input/Output load of the system - a number

  between 0.0 and 1.0. This is the average value for the disk usage in a previous time interval.

troup.system.get_bogomips()

troup.tasks module

class troup.tasks.CodeTask(task_id, code, exec_type, ttl=None, data=None)

Bases: troup.tasks.Task

exec(task_globals, task_locals)

run(context)

class troup.tasks.FunctionBytecodeTask(task_id, bytecode, fn_args, fn_kwargs, data, ttl=None)

Bases: troup.tasks.CodeTask

exec(fn_locals, fn_globals)

class troup.tasks.LocalProcessTask(process_type, process_data, task_id=None, ttl=None, consume_process_out=False, buffer_size=100000)

Bases: troup.tasks.Task

PROCESS_BUILDERS = {'SSHProcess': <function LocalProcessTask.__SSHProcessBuilder at 0x7f4de8202488>, 'LocalProcess': <function LocalProcessTask.__LocalProcessBuilder at 0x7f4de8202400>}

run(context=None)

stop(reason=None)

exception troup.tasks.ProcessTaskException

Bases: troup.tasks.TaskException

class troup.tasks.Task(task_id=None, ttl=None)

Bases: object

run(context=None)

stop(reason=None)

exception troup.tasks.TaskException

Bases: Exception

class troup.tasks.TaskRun(task, future=None, run_id=None)

Bases: object

CREATED = 'CREATED'

DONE = 'DONE'

ERROR = 'ERROR'

RUNNING = 'RUNNING'

STOPPING = 'STOPPING'

do_start()

do_stop(reason=None)

start()

stop(reason=None)

exception troup.tasks.TaskRunException

Bases: troup.tasks.TaskException

class troup.tasks.TasksRunner(max_workers=3)

Bases: object

clear(task_id)

run(task)

shutdown()

stats

stop(task_id, wait=False, timeout=None)

troup.tasks.build_task(msg)

troup.tasks.task_for_app(app, remote=False, node=None, ttl=0, consume_output=False, buffer_size=1048576)

troup.testtools module

troup.threading module

class troup.threading.AtomicIncrement(initial_value=0)

Bases: troup.threading.AtomicOperation

atomic_op()

inc()

value

class troup.threading.AtomicOperation

Bases: object

atomic_op()

op()

class troup.threading.IntervalTimer(interval, offset=0, target=None, name=None)

Bases: object

cancel()

run()

start()

Module contents