def initialize_environment_core(core_config=None, libraries=None, delete=False): from rafcon.core.config import global_config import rafcon.core.singleton if rafcon.core.singleton.state_machine_manager.state_machines: raise EnvironmentError("The environment has to have an empty StateMachineManager but here the following " "state machines are still existing: \n{0}" "".format(rafcon.core.singleton.state_machine_manager.state_machines)) test_multithreading_lock.acquire() # preserve LIBRARY_PATHS if handed with dict -> can be already be the dict of the global_config object if libraries is None and core_config is not None and 'LIBRARY_PATHS' in core_config: libraries = copy.deepcopy(core_config['LIBRARY_PATHS']) # initialize global core config if isinstance(core_config, tuple) and exists(join(core_config[1], core_config[0])): global_config.load(core_config[0], core_config[1]) if global_config.get_config_value('LIBRARY_PATHS') is not None: libraries = copy.deepcopy(global_config.get_config_value('LIBRARY_PATHS')) else: global_config.load(path=RAFCON_TEMP_PATH_CONFIGS) if isinstance(core_config, dict): for key, value in core_config.items(): global_config.set_config_value(key, value) rewind_and_set_libraries(libraries=libraries)
def run_turtle_demo(): import rafcon.core import rafcon.core.start signal.signal(signal.SIGINT, rafcon.core.start.signal_handler) global_config.load() global_gui_config.load() # set the test_libraries path temporarily to the correct value library_paths = rafcon.core.config.global_config.get_config_value( "LIBRARY_PATHS") if os.path.exists( str(os.path.sep).join( [rafcon.__path__[0], '..', '..', '..', 'share', 'libraries'])): # rm-pkg os.environ['RAFCON_LIB_PATH'] = os.path.join(rafcon.__path__[0], '..', '..', '..', 'share', 'libraries') library_paths["ros_libraries"] = os.path.join(rafcon.__path__[0], '..', '..', '..', 'share', 'examples', 'libraries', 'ros_libraries') library_paths["turtle_libraries"] = os.path.join( rafcon.__path__[0], '..', '..', '..', 'share', 'examples', 'libraries', 'turtle_libraries') example_path = os.path.join(rafcon.__path__[0], os.pardir, '..', '..', 'share', 'examples', "tutorials") else: # git repo os.environ['RAFCON_LIB_PATH'] = os.path.join( dirname(abspath(__file__)), '..', '..', '..', 'libraries') library_paths["ros_libraries"] = os.path.join( dirname(abspath(__file__)), '..', '..', 'libraries', 'ros_libraries') library_paths["turtle_libraries"] = os.path.join( dirname(abspath(__file__)), '..', '..', 'libraries', 'turtle_libraries') example_path = os.path.join(dirname(abspath(__file__)), '..', '..', "tutorials") rafcon.core.singleton.library_manager.initialize() rafcon.core.singleton.state_machine_manager.delete_all_state_machines() base_path = os.path.dirname(os.path.abspath(__file__)) basic_turtle_demo_state = create_turtle_statemachine( base_path, example_path) state_machine = StateMachine(basic_turtle_demo_state) # # load the state machine # [state_machine, version, creation_time] = storage.load_statemachine_from_path( # "../../share/examples/tutorials/basic_turtle_demo_sm") rafcon.core.singleton.library_manager.initialize() main_window_view = MainWindowView() rafcon.core.singleton.state_machine_manager.add_state_machine( state_machine) sm_manager_model = rafcon.gui.singleton.state_machine_manager_model main_window_controller = MainWindowController(sm_manager_model, main_window_view) gtk.main() logger.debug("Gtk main loop exited!")
def setup_configuration(config_path): """Loads the core configuration from the specified path and uses its content for further setup :param config_path: Path to the core config file """ if config_path is not None: config_path, config_file = filesystem.separate_folder_path_and_file_name(config_path) global_config.load(config_file=config_file, path=config_path) else: global_config.load(path=config_path) # Initialize libraries core_singletons.library_manager.initialize()
def start_server(interacting_function, queue_dict): import sys import os import rafcon from rafcon.utils import log from rafcon.utils import plugins from rafcon.core.config import global_config import rafcon.core.singleton as core_singletons from rafcon.core.storage import storage as global_storage # needed for yaml parsing from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.preemptive_concurrency_state import PreemptiveConcurrencyState from rafcon.core.states.barrier_concurrency_state import BarrierConcurrencyState from rafcon.core.start import signal_handler, register_signal_handlers register_signal_handlers(signal_handler) logger = log.get_logger("start-no-gui") logger.info("initialize RAFCON ... ") plugins.load_plugins() plugins.run_pre_inits() global_config.load(path=os.path.dirname(os.path.abspath(__file__))) # Initialize libraries core_singletons.library_manager.initialize() from tests import utils as testing_utils state_machine = global_storage.load_state_machine_from_path( testing_utils.get_test_sm_path(os.path.join("unit_test_state_machines", "99_bottles_of_beer_monitoring"))) sm_id = rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine) sm_thread = threading.Thread(target=check_for_sm_finished, args=[state_machine, ]) sm_thread.start() setup_config = dict() setup_config["net_config_path"] = os.path.abspath(path=os.path.join(os.path.dirname(os.path.abspath(__file__)), "server")) plugins.run_post_inits(setup_config) if "twisted" in sys.modules: print("################# twisted found #######################") interacting_thread = threading.Thread(target=interacting_function, args=[queue_dict, sm_id]) interacting_thread.start() from twisted.internet import reactor reactor.run() else: logger.error("Server: Twisted is not in sys.modules or twisted is not working! Exiting program ... !") import os os._exit(0) state_machine.root_state.join() rafcon.core.singleton.state_machine_execution_engine.stop() logger.info("State machine execution finished!")
def start_client(interacting_function, queue_dict): from rafcon.gui.config import global_gui_config import os from rafcon.gui.controllers.main_window import MainWindowController from rafcon.gui.views.main_window import MainWindowView import rafcon.gui.singleton as gui_singletons from rafcon.gui.runtime_config import global_runtime_config from rafcon.gui.start import signal_handler import rafcon from rafcon.utils import log from rafcon.utils import plugins from rafcon.core.config import global_config from rafcon.core.storage import storage as global_storage from rafcon.core.state_machine import StateMachine from rafcon.core.states.hierarchy_state import HierarchyState import rafcon.core.singleton as core_singletons from rafcon.core.start import setup_environment # load all plugins specified in the RAFCON_PLUGIN_PATH plugins.load_plugins() import testing_utils # check if twisted is imported if "twisted" in sys.modules.keys(): from twisted.internet import gtk2reactor # needed for glib.idle_add, and signals gtk2reactor.install() from twisted.internet import reactor else: print "Twisted not imported! Thus the gkt2reatcor is not installed!" exit() plugins.run_pre_inits() setup_logger() logger = log.get_logger("start") logger.info("RAFCON launcher") setup_environment() signal.signal(signal.SIGINT, signal_handler) global_config.load(path=os.path.dirname(os.path.abspath(__file__))) global_gui_config.load(path=os.path.dirname(os.path.abspath(__file__))) global_runtime_config.load(path=os.path.dirname(os.path.abspath(__file__))) setup_config = dict() setup_config["net_config_path"] = os.path.abspath(path=os.path.join( os.path.dirname(os.path.abspath(__file__)), "client")) # Initialize library core_singletons.library_manager.initialize() # Create the GUI main_window_view = MainWindowView() state_machine = global_storage.load_state_machine_from_path( testing_utils.get_test_sm_path( os.path.join("unit_test_state_machines", "99_bottles_of_beer_monitoring"))) sm_id = rafcon.core.singleton.state_machine_manager.add_state_machine( state_machine) rafcon.core.singleton.state_machine_manager.active_state_machine_id = sm_id sm_manager_model = gui_singletons.state_machine_manager_model main_window_controller = MainWindowController(sm_manager_model, main_window_view) plugins.run_post_inits(setup_config) import threading # this is not recognized by pycharm as the module is loaded in plugins.load_plugins() from monitoring.monitoring_manager import global_monitoring_manager interacting_thread = threading.Thread( target=interacting_function, args=[main_window_controller, global_monitoring_manager, queue_dict]) testing_utils.wait_for_gui() interacting_thread.start() # check if twisted is imported if "twisted" in sys.modules.keys(): reactor.run() else: logger.error( "Client: Twisted is not in sys.modules or twisted is not working! Exiting program ... !" ) os._exit(0) logger.info("Joined root state") # If there is a running state-machine, wait for it to be finished before exiting sm = core_singletons.state_machine_manager.get_active_state_machine() if sm: sm.root_state.join() logger.info("Exiting ...") # this is a ugly process shutdown method but works if gtk or twisted process are still blocking os._exit(0)
def convert(config_path, source_path, target_path=None, gui_config_path=None): logger.info("RAFCON launcher") rafcon.gui.start.setup_l10n(logger) from rafcon.gui.controllers.main_window import MainWindowController from rafcon.gui.views.main_window import MainWindowView setup_environment() gui_config_path = gui_config_path or get_default_config_path() setup_config = {} setup_config["config_path"] = config_path setup_config["gui_config_path"] = gui_config_path setup_config["source_path"] = [source_path] if not target_path: setup_config["target_path"] = [source_path] else: setup_config["target_path"] = [target_path] global_config.load(path=setup_config['config_path']) global_gui_config.load(path=setup_config['gui_config_path']) global_runtime_config.load(path=setup_config['gui_config_path']) # Initialize library core_singletons.library_manager.initialize() # Create the GUI main_window_view = MainWindowView() if setup_config['source_path']: if len(setup_config['source_path']) > 1: logger.error("Only one state machine is supported yet") exit(-1) for path in setup_config['source_path']: try: state_machine = gui_helper_state_machine.open_state_machine( path) except Exception as e: logger.error("Could not load state machine {0}: {1}".format( path, e)) else: logger.error( "You need to specify exactly one state machine to be converted!") sm_manager_model = gui_singletons.state_machine_manager_model main_window_controller = MainWindowController(sm_manager_model, main_window_view) if not os.getenv("RAFCON_START_MINIMIZED", False): main_window = main_window_view.get_top_widget() size = global_runtime_config.get_config_value("WINDOW_SIZE", None) position = global_runtime_config.get_config_value("WINDOW_POS", None) if size: main_window.resize(size[0], size[1]) if position: position = (max(0, position[0]), max(0, position[1])) screen_width = Gdk.Screen.width() screen_height = Gdk.Screen.height() if position[0] < screen_width and position[1] < screen_height: main_window.move(position[0], position[1]) wait_for_gui() thread = threading.Thread(target=trigger_gui_signals, args=[ sm_manager_model, main_window_controller, setup_config, state_machine ]) thread.start() Gtk.main() logger.debug("Gtk main loop exited!") logger.debug("Conversion done")