obci.control.launcher package

Submodules

obci.control.launcher.eeg_experiment_finder module

class obci.control.launcher.eeg_experiment_finder.EEGExperimentFinder(srv_addrs, ctx, client_push_address, nearby_servers)

Bases: object

find_amplified_experiments()

poll_recv(socket, timeout)

obci.control.launcher.eeg_experiment_finder.find_eeg_experiments_and_push_results(ctx, srv_addrs, rq_message, nearby_servers)

obci.control.launcher.eeg_experiment_finder.find_new_experiments_and_push_results(ctx, rq_message)

obci.control.launcher.launch_file_parser module

class obci.control.launcher.launch_file_parser.LaunchFileParser(obci_base_dir, scenario_base_dir, logger=None)

Bases: obci.control.launcher.launch_file_parser.ScenarioParser

class obci.control.launcher.launch_file_parser.LaunchJSONParser(obci_base_dir, scenario_base_dir, logger=None)

Bases: obci.control.launcher.launch_file_parser.ScenarioParser

parse(p_file, p_config_obj, apply_globals=False)

class obci.control.launcher.launch_file_parser.ScenarioParser

Bases: object

parse(p_file, p_config_obj, apply_globals=False)

obci.control.launcher.launch_file_parser.extend_experiment_config(exp_config, peer_id, peer_path, config_sources=None, launch_deps=None, custom_config_path=None, param_overwrites=None, machine=None, apply_globals=True)

obci.control.launcher.launch_file_parser.parse_peer_default_config(peer_id, peer_program_path, logger=None, apply_globals=False)

obci.control.launcher.launch_file_serializer module

class obci.control.launcher.launch_file_serializer.LaunchFileSerializer

Bases: object

serialize(system_config, dump_dir_path, dump_file)

class obci.control.launcher.launch_file_serializer.LaunchFileSerializerINI

Bases: obci.control.launcher.launch_file_serializer.LaunchFileSerializer

Dump scenario to an INI scenario file and separate peer config files.

class obci.control.launcher.launch_file_serializer.LaunchFileSerializerJSON

Bases: obci.control.launcher.launch_file_serializer.LaunchFileSerializer

Dump entire scenario to one large JSON.

obci.control.launcher.launch_file_serializer.serialize_scenario_json(p_system_config)

obci.control.launcher.launcher_logging module

Module defines a single method get_logger that returns logger with set logging level. Change loggin.INFO lines to change logging level.

obci.control.launcher.launcher_logging.get_logger(p_name, p_level='info')

Return logger with p_name as name. And logging level p_level. p_level should be in (starting with the most talkactive): ‘debug’, ‘info’, ‘warning’, ‘error’, ‘critical’.

obci.control.launcher.launcher_messages module

obci.control.launcher.launcher_tools module

class obci.control.launcher.launcher_tools.ExperimentStatus

Bases: object

as_dict()

del_peer_status(peer_id)

peer_status(peer_id)

peer_status_exists(status_name)

set_status(status_name, details={})

class obci.control.launcher.launcher_tools.PeerStatus(peer_id, status_name='not_ready')

Bases: object

as_dict()

set_status(status_name, details=())

obci.control.launcher.launcher_tools.broker_path()

Used only in obci_process_supervisor.py and supervisor_test.py

obci.control.launcher.launcher_tools.default_config_path(peer_program_path)

obci.control.launcher.launcher_tools.expand_path(program_path, base_dir=None)

obci.control.launcher.launcher_tools.module_path(module)

obci.control.launcher.launcher_tools.obci_root()

obci.control.launcher.launcher_tools.obci_root_relative(path)

obci.control.launcher.launcher_tools.which(file)

obci.control.launcher.local_process module

class obci.control.launcher.local_process.LocalProcess(proc_description, popen_obj, io_handler=None, reg_timeout_desc=None, monitoring_optflags=6, logger=None)

Bases: obci.control.launcher.process.Process

finished()

is_local()

kill()

kill_with_force(timeout_s=0.5)

process_is_running()

returncode_monitor()

tail_stdout(lines=10)

obci.control.launcher.obci_client module

class obci.control.launcher.obci_client.EmptyResponse(details)

Bases: object

class obci.control.launcher.obci_client.OBCIClient(server_addresses, zmq_context=None)

Bases: object

add_peer(strname, peer_id, path, machine, param_overwrites=None, custom_config_path=None, config_sources=None, launch_dependencies=None, apply_globals=True)

configure_peer(exp_strname, peer_id, config_overrides, override_files=None)

default_timeout = 5000

force_kill_experiment(strname)

get_experiment_contact(strname)

get_experiment_details(strname, peer_id=None)

get_tail(strname, peer_id, len_)

init_server_socket(srv_addrs)

join_experiment(strname, peer_id, path)

kill_exp(strname, force=False)

kill_peer(exp_strname, peer_id, remove_config=False)

launch(launch_file=None, sandbox_dir=None, name=None, overwrites=None)

leave_experiment(strname, peer_id)

morph(exp_strname, launch_file, name=None, overwrites=None, leave_on=None)

ping_server(timeout=50)

poll_recv(socket, timeout)

retry_ping(timeout=50)

send_create_experiment(launch_file=None, sandbox_dir=None, name=None, overwrites=None)

send_list_experiments()

send_list_nearby_machines()

send_start_experiment(exp_addrs)

srv_kill()

start_chosen_experiment(exp_strname)

obci.control.launcher.obci_control_peer module

class obci.control.launcher.obci_control_peer.HandlerCollection

Bases: object

copy()

default_handler()

error_handler()

handler(message_type)

handler_for(message_name)

new_from(other)

unsupported_handler()

exception obci.control.launcher.obci_control_peer.MessageHandlingError

Bases: obci.control.launcher.obci_control_peer.OBCIControlPeerError

class obci.control.launcher.obci_control_peer.OBCIControlPeer(source_addresses=None, rep_addresses=None, pub_addresses=None, name='obci_control_peer')

Bases: object

all_sockets()

bad_msg_handler(message, sock)

basic_sockets()

clean_up()

cleanup_before_net_shutdown(kill_message, sock=None)

custom_sockets()

subclass this

default_handler(message, sock)

Ignore message

handle_dead_process(message, sock)

handle_kill(message, sock)

handle_message(message, sock)

handle_ping(message, sock)

handle_register_peer(message, sock)

Subclass this.

handle_socket_read_error(socket, error)

message_tool()

msg_handlers = <obci.control.launcher.obci_control_peer.HandlerCollection object>

net_init()

params_for_registration()

peer_type()

pre_run()

register()

run()

shutdown()

signal_handler()

unsupported_msg_handler(message, sock)

exception obci.control.launcher.obci_control_peer.OBCIControlPeerError

Bases: Exception

class obci.control.launcher.obci_control_peer.RegistrationDescription(uuid, name, rep_addrs, pub_addrs, machine, pid, other=None)

Bases: object

info()

obci.control.launcher.obci_control_peer.basic_arg_parser()

obci.control.launcher.obci_experiment module

class obci.control.launcher.obci_experiment.OBCIExperiment(sandbox_dir, launch_file=None, source_addresses=None, source_pub_addresses=None, rep_addresses=None, pub_addresses=None, name='obci_experiment', current_ip=None, launch=False, overwrites=None)

Bases: obci.control.launcher.obci_control_peer.OBCIControlPeer

args_for_process_sv(machine, local=False)

clean_up()

cleanup_before_net_shutdown(kill_message, sock=None)

custom_sockets()

handle_add_peer(message, sock)

Add new peer to existing scenario. It may run on a different machine than already running peers. add_peer works at runtime and before runtime.

handle_all_peers_launched(message, sock)

handle_dead_process(message, sock)

handle_experiment_finished(message, sock)

handle_get_experiment_info(message, sock)

handle_get_experiment_scenario(message, sock)

handle_get_peer_config(message, sock)

handle_get_peer_info(message, sock)

handle_get_peer_param_values(message, sock)

handle_get_tail(message, sock)

handle_join_experiment(message, sock)

handle_kill_peer(message, sock)

handle_launch_error(message, sock)

handle_launched_process_info(message, sock)

handle_leave_experiment(message, sock)

handle_morph(message, sock)

handle_nearby_machines(message, sock)

handle_obci_launch_failed(message, sock)

handle_obci_peer_dead(message, sock)

handle_obci_peer_params_changed(message, sock)

handle_obci_peer_ready(message, sock)

handle_obci_peer_registered(message, sock)

handle_register_peer(message, sock)

Experiment

handle_save_scenario(message, sock)

handle_set_experiment_scenario(message, sock)

handle_start_experiment(message, sock)

handle_tail(message, sock)

handle_update_peer_config(message, sock)

make_experiment_config(exp_config, launch_file, status)

msg_handlers = <obci.control.launcher.obci_control_peer.HandlerCollection object>

mx_args()

net_init()

params_for_registration()

peer_type()

status_changed(status_name, details, peers=None)

obci.control.launcher.obci_experiment.experiment_arg_parser()

obci.control.launcher.obci_experiment.run_obci_experiment()

obci.control.launcher.obci_process_supervisor module

class obci.control.launcher.obci_process_supervisor.OBCIProcessSupervisor(sandbox_dir, source_addresses=None, source_pub_addresses=None, rep_addresses=None, pub_addresses=None, experiment_uuid='', name='obci_process_supervisor')

Bases: obci.control.launcher.obci_control_peer.OBCIControlPeer

clean_up()

cleanup_before_net_shutdown(kill_message, sock=None)

custom_sockets()

handle_dead_process(message, sock)

handle_experiment_finished(message, sock)

handle_experiment_launch_error(message, sock)

handle_get_tail(message, sock)

handle_kill_peer(message, sock)

handle_manage_peers(message, sock)

handle_morph(message, sock)

handle_nearby_machines(message, sock)

handle_obci_control_message(message, sock)

handle_obci_peer_params_changed(message, sock)

handle_obci_peer_ready(message, sock)

handle_obci_peer_registered(message, sock)

handle_rq_ok(message, sock)

handle_start_broker(message, sock)

handle_start_config_srv(message, sock)

handle_start_peers(message, sock)

handle_stop_all(message, sock)

handle_supervisor_registered(messsage, sock)

launch_process(peer, launch_data, restore_config=[])

msg_handlers = <obci.control.launcher.obci_control_peer.HandlerCollection object>

mx_addr_str(mx_data)

net_init()

params_for_registration()

peer_env(mx_data)

peer_type()

set_mx_data()

obci.control.launcher.obci_process_supervisor.process_supervisor_arg_parser()

obci.control.launcher.obci_process_supervisor.run_obci_process_supervisor()

obci.control.launcher.obci_script module

class obci.control.launcher.obci_script.OBCIArgParser(description='Launch and manage OBCI experiments, their state and configuration', epilog='(c) 2011-2016, Warsaw University', prog='obci')

Bases: object

add_command(name, help, setup_func, parser_parents=None)

defined_commands = {'srv_kill': {'setup_func': <function setup_srv_kill>, 'help': 'Kill OBCIServer', 'parser_parents': [ArgumentParser(prog='setup.py', usage=None, description='OBCI Server : manage OBCI experiments.', formatter_class=<class 'argparse.HelpFormatter'>, conflict_handler='error', add_help=False)]}, 'kill': {'setup_func': <function setup_kill>, 'help': 'Kill an OpenBCI experiment'}, 'info': {'setup_func': <function setup_info>, 'help': 'Get information about controlled OpenBCI experiments and peers'}, 'morph': {'setup_func': <function setup_morph>, 'help': 'Transform chosen running scenario into another.Optionally leave some peers running instead of restarting them'}, 'launch': {'setup_func': <function setup_launch>, 'help': 'Launch an OpenBCI system with configuration specified in a launch file or in a newly created Experiment'}, 'srv': {'setup_func': <function setup_srv>, 'help': 'Start OBCIServer', 'parser_parents': [ArgumentParser(prog='setup.py', usage=None, description='OBCI Server : manage OBCI experiments.', formatter_class=<class 'argparse.HelpFormatter'>, conflict_handler='error', add_help=False)]}}

setup_commands(cmd_defs={})

obci.control.launcher.obci_script.cmd_add(args)

obci.control.launcher.obci_script.cmd_config(args)

obci.control.launcher.obci_script.cmd_info(args)

obci.control.launcher.obci_script.cmd_join(args)

obci.control.launcher.obci_script.cmd_kill(args)

obci.control.launcher.obci_script.cmd_killall(args)

obci.control.launcher.obci_script.cmd_launch(args)

obci.control.launcher.obci_script.cmd_log(args)

obci.control.launcher.obci_script.cmd_morph(args)

obci.control.launcher.obci_script.cmd_new(args)

obci.control.launcher.obci_script.cmd_save(args)

obci.control.launcher.obci_script.cmd_srv(args)

obci.control.launcher.obci_script.cmd_srv_kill(args)

obci.control.launcher.obci_script.cmd_start(args)

obci.control.launcher.obci_script.cmd_tail(args)

obci.control.launcher.obci_script.path_to_file(string)

obci.control.launcher.obci_script.setup_add(parser_add)

obci.control.launcher.obci_script.setup_config(parser_config)

obci.control.launcher.obci_script.setup_info(parser_info)

obci.control.launcher.obci_script.setup_join(parser_join)

obci.control.launcher.obci_script.setup_kill(parser_kill)

obci.control.launcher.obci_script.setup_killall(parser_killall)

obci.control.launcher.obci_script.setup_launch(parser_launch)

obci.control.launcher.obci_script.setup_morph(parser_morph)

obci.control.launcher.obci_script.setup_new(parser_new)

obci.control.launcher.obci_script.setup_save(parser_save)

obci.control.launcher.obci_script.setup_srv(parser_srv)

obci.control.launcher.obci_script.setup_srv_kill(parser_srv_kill)

obci.control.launcher.obci_script.setup_start(parser_start)

obci.control.launcher.obci_script.setup_tail(parser_tail)

obci.control.launcher.obci_script_utils module

obci.control.launcher.obci_script_utils.argv()

obci.control.launcher.obci_script_utils.client_server_prep(cmdargs=None, client_class=<class 'obci.control.launcher.obci_client.OBCIClient'>, server_ip=None, start_srv=True, zmq_ctx=None)

obci.control.launcher.obci_script_utils.connect_client(addresses, client=None, client_class=<class 'obci.control.launcher.obci_client.OBCIClient'>, zmq_ctx=None)

obci.control.launcher.obci_script_utils.launch_obci_server(args=[])

obci.control.launcher.obci_script_utils.server_process_running(expected_dead=False)

Return true if there is an obci_server process running

obci.control.launcher.obci_server module

class obci.control.launcher.obci_server.ExperimentInfo(uuid, name, rep_addrs, pub_addrs, registration_time, origin_machine, pid, status_name=None, details=None, launch_file_path=None, tcp_addrs=None, ip=None)

Bases: object

from_dict(dic)

info()

machine_ip

pid

class obci.control.launcher.obci_server.OBCIServer(rep_addresses=None, pub_addresses=None, name='obci_server')

Bases: obci.control.launcher.obci_control_peer.OBCIControlPeer

clean_up()

cleanup_before_net_shutdown(kill_message, sock=None)

custom_sockets()

exp_matching(strname)

Match strname against all created experiment IDs and names. Return those experiment descriptions which name or uuid starts with strname.

handle_create_experiment(message, sock)

handle_dead_process(message, sock)

handle_experiment_info_change(message, sock)

handle_experiment_status_change(message, sock)

handle_experiment_transformation(message, sock)

handle_find_eeg_experiments(message, sock)

handle_find_new_eeg_amplifiers(message, sock)

handle_get_experiment_contact(message, sock)

handle_kill_experiment(message, sock)

handle_kill_process_supervisor(message, sock)

handle_launch_process(message, sock)

handle_list_experiments(message, sock)

handle_list_nearby_machines(message, sock)

handle_register_experiment(message, sock)

handle_register_peer(message, sock)

Register peer

handle_socket_read_error(socket, error)

handle_start_eeg_signal(message, sock)

msg_handlers = <obci.control.launcher.obci_control_peer.HandlerCollection object>

my_ip()

nearby_server_addrs()

nearby_servers()

net_init()

network_ready()

peer_type()

start_experiment_process(sandbox_dir, launch_file, name=None, overwrites=None)

obci.control.launcher.obci_server.run_obci_server()

obci.control.launcher.obci_server.server_arg_parser(add_help=False)

obci.control.launcher.plain_tcp_handling module

class obci.control.launcher.plain_tcp_handling.OBCIExperimentRequestHandler(request, client_address, server)

Bases: obci.control.launcher.plain_tcp_handling.OBCIPeerRequestHandler

class obci.control.launcher.plain_tcp_handling.OBCIExperimentTCP(server_address, bind_and_activate=True, zmq_ctx=None, zmq_rep_addr=None)

Bases: obci.control.launcher.plain_tcp_handling.OBCIPeerTCP

class obci.control.launcher.plain_tcp_handling.OBCIPeerRequestHandler(request, client_address, server)

Bases: socketserver.StreamRequestHandler

bad_response(rstream, details)

handle()

make_srv_sock()

class obci.control.launcher.plain_tcp_handling.OBCIPeerTCP(server_address, handler_class, bind_and_activate=True, zmq_ctx=None, zmq_rep_addr=None)

Bases: socketserver.TCPServer

allow_reuse_address = True

class obci.control.launcher.plain_tcp_handling.OBCIServerRequestHandler(request, client_address, server)

Bases: obci.control.launcher.plain_tcp_handling.OBCIPeerRequestHandler

handle()

class obci.control.launcher.plain_tcp_handling.OBCIServerTCP(server_address, bind_and_activate=True, zmq_ctx=None, zmq_rep_addr=None)

Bases: obci.control.launcher.plain_tcp_handling.OBCIPeerTCP

obci.control.launcher.plain_tcp_handling.make_netstring(bytes)

obci.control.launcher.plain_tcp_handling.make_unicode_netstring(unicode_str)

obci.control.launcher.plain_tcp_handling.recv_netstring(rstream)

obci.control.launcher.plain_tcp_handling.recv_unicode_netstring(rstream)

obci.control.launcher.plain_tcp_handling.run_tcp_obci_experiment(server_address, zmq_ctx, zmq_rep_addr)

obci.control.launcher.plain_tcp_handling.run_tcp_obci_server(server_address, zmq_ctx, zmq_rep_addr)

obci.control.launcher.process module

class obci.control.launcher.process.Process(proc_description, reg_timeout_desc=None, monitoring_optflags=2, logger=None)

Bases: object

finished()

is_local()

kill()

machine_ip

mark_delete()

marked_delete()

name

new_timer(tim_desc, type_)

path

pid

ping_monitor()

proc_type

process_is_running()

registered(reg_data)

returncode_monitor()

set_registration_timeout_handler(reg_timeout_desc)

start_monitoring()

status()

stop_monitoring()

timeout_handler(custom_method, args, type_)

obci.control.launcher.process_io_handler module

class obci.control.launcher.process_io_handler.ProcessIOHandler(name, stdout=None, stderr=None, stdin=None, out_log=None, err_log=None)

Bases: object

Processes data from descriptors (stdout, stderr) in separate threads. Access to the tail is available through attributes out_tail and err_tail. Communication through stdin, if given, is possible by communicate() method. Data is saved to log files if the handles were given in init.

communicate(input, response_timeout=None)

finished()

is_running()

process_output(lines=None, timeout=None)

Check if there is data from stdout and stderr (if it is monitored). Update tail and save data to logs, if they were given in init. Timeout (s) means blocking queue reads, no timeout - non blocking.

start_output_handler()

stop_output_handler()

tail_stdout(lines)

obci.control.launcher.process_io_handler.start_stdio_handler(popen_obj, stdio_actions, name, stdout_log, stderr_log)

obci.control.launcher.remote_process module

class obci.control.launcher.remote_process.RemoteProcess(proc_description, rq_address, reg_timeout_desc=None, monitoring_optflags=2, logger=None)

Bases: obci.control.launcher.process.Process

is_local()

kill()

registered(reg_data)

returncode_monitor()

obci.control.launcher.server_scanner module

obci.control.launcher.server_scanner.broadcast_server(server_uuid, rep_port, pub_port, bcast_port)

obci.control.launcher.server_scanner.update_nearby_servers(srv_data, bcast_port, ctx=None, update_push_addr=None)

obci.control.launcher.start_eeg_signal module

obci.control.launcher.start_eeg_signal.start_eeg_signal_experiment(ctx, srv_addrs, rq_message)

obci.control.launcher.subprocess_monitor module

class obci.control.launcher.subprocess_monitor.ProcessDescription(proc_type, name, path, args, machine_ip, pid=None)

Bases: object

dict()

class obci.control.launcher.subprocess_monitor.SubprocessMonitor(zmq_ctx, uuid, logger=None, obci_dns=None)

Bases: object

delete(machine, pid)

delete_all()

killall(force=False)

new_local_process(path, args, proc_type='', name='', capture_io=5, stdout_log=None, stderr_log=None, register_timeout_desc=None, monitoring_optflags=6, machine_ip=None, env=None)

new_remote_process(path, args, proc_type, name, machine_ip, conn_addr, capture_io=5, stdout_log=None, stderr_log=None, register_timeout_desc=None, monitoring_optflags=2)

Send a request to conn_addr for a process launch. By default the process will be monitored with ping requests and locally by the remote peer.

not_running_processes()

process(machine_ip, pid)

stop_monitoring()

unknown_status_processes()

class obci.control.launcher.subprocess_monitor.TimeoutDescription(timeout=3, timeout_method=None, timeout_args=[])

Bases: object

default_timeout_method()

timer()

obci.control.launcher.subprocess_monitor.default_timeout_handler()

obci.control.launcher.system_config module

class obci.control.launcher.system_config.OBCIExperimentConfig(launch_file_path=None, uuid=None, origin_machine=None, logger=None)

Bases: object

add_peer(peer_id)

all_param_values(peer_id)

config_ready()

config_sources_graph_ok()

extend_with_peer(peer_id, peer_path, peer_cfg, config_sources=None, launch_deps=None, param_overwrites=None, machine=None)

file_update_peer_config(peer_id, file_path)

info()

launch_data(peer_machine)

launch_deps_graph_ok()

launch_file_path

local_params(peer_id)

param_value(peer_id, param_name)

peer_config(peer_id)

peer_graph(neighbours_method)

peer_machine(peer_id)

peer_machines()

peer_order()

peer_path(peer_id)

peers_info()

set_config_source(peer_id, src_name, src_peer_id)

set_launch_dependency(peer_id, dep_name, dep_peer_id)

set_peer_config(peer_id, peer_config)

set_peer_machine(peer_id, machine_name)

set_peer_path(peer_id, path)

status(status_obj)

update_external_param(peer_id, p_name, src, src_param)

update_local_param(peer_id, p_name, p_value)

update_peer_config(peer_id, config_dict)

update_peer_machine(peer_id, machine_ip)

exception obci.control.launcher.system_config.OBCISystemConfigError

Bases: Exception

exception obci.control.launcher.system_config.OBCISystemConfigWarning

Bases: Warning

class obci.control.launcher.system_config.PeerConfigDescription(peer_id, experiment_id, config=None, path=None, machine=None, logger=None)

Bases: object

info(detailed=False)

launch_data()

list_config_sources()

list_launch_deps()

peer_type()

ready(details=None)

status(peer_status_obj)

obci.control.launcher.twisted_tcp_handling module

class obci.control.launcher.twisted_tcp_handling.OBCIProxy

Bases: twisted.protocols.basic.NetstringReceiver

stringReceived(string)

class obci.control.launcher.twisted_tcp_handling.OBCIProxyFactory(address, zmq_ctx, zmq_rep_addr)

Bases: twisted.internet.protocol.Factory

protocol

alias of OBCIProxy

obci.control.launcher.twisted_tcp_handling.run_twisted_server(address, zmq_ctx, zmq_rep_addr)

obci.control.launcher.view module

class obci.control.launcher.view.OBCIView

Bases: object

format_default(msg)

view(msg, where=None)

Abstract method for printing data in launcher messages.

view_raw(msg, where=None)

class obci.control.launcher.view.OBCIViewText

Bases: obci.control.launcher.view.OBCIView

format_default(msg)

view_raw(msg, where=None)

Module contents