def test_preemption_behaviour_during_stop(caplog): testing_utils.initialize_environment_core() path = testing_utils.get_test_sm_path( os.path.join("unit_test_state_machines", "preemption_behaviour_during_stop")) state_machine = storage.load_state_machine_from_path(path) rafcon.core.singleton.state_machine_manager.add_state_machine( state_machine) thread = threading.Thread( target=trigger_stop, args=[ state_machine, rafcon.core.singleton.state_machine_execution_engine ]) thread.start() rafcon.core.singleton.state_machine_execution_engine.start( state_machine.state_machine_id) rafcon.core.singleton.state_machine_execution_engine.join() rafcon.core.singleton.state_machine_manager.remove_state_machine( state_machine.state_machine_id) try: assert global_variable_manager.get_variable("s1") == 1 assert global_variable_manager.get_variable("s2") == 1 assert not global_variable_manager.variable_exist("s3") finally: testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_observer_1_exception(self, caplog): gvm.set_variable("wait_observer_1", 0.1) gvm.set_variable("observer_1_exception", True) self.run_state_machine() self.assert_no_errors() assert_all_false(gvm.get_variable("inner_observer_1_finish"), gvm.get_variable("observer_1_finish"), gvm.get_variable("observer_1_finish"), gvm.get_variable("observer_2_finish")) testing_utils.assert_logger_warnings_and_errors(caplog, 0, 1)
def test_inner_observer_1_error(self, caplog): gvm.set_variable("wait_inner_observer_1", 0.1) gvm.set_variable("inner_observer_1_abort", True) self.run_state_machine() assert_gvm("inner_error_handler", False) assert_gvm("error_handler") assert_gvm("error_handler_2") assert_all_false(gvm.get_variable("inner_observer_1_finish"), gvm.get_variable("observer_1_finish"), gvm.get_variable("observer_1_finish"), gvm.get_variable("observer_2_finish")) testing_utils.assert_logger_warnings_and_errors(caplog, 0)
def test_observer_2_finish(self, caplog): gvm.set_variable("wait_observer_2", 0.1) self.run_state_machine() self.assert_no_errors() assert_gvm("observer_2_finish") assert_gvm("inner_exit_handler") assert_gvm("exit_handler") assert_gvm("exit_handler_2") assert_all_false(gvm.get_variable("inner_observer_2_finish"), gvm.get_variable("inner_observer_1_finish"), gvm.get_variable("observer_1_finish")) testing_utils.assert_logger_warnings_and_errors(caplog, 0)
def test_preemptive_wait2_timeout(caplog): with testing_utils.test_multithreading_lock: gvm.set_variable('state_2_wait', 0.5) gvm.set_variable('state_1_wait', 1.) run_state_machine() assert 0.5 < gvm.get_variable('state_2_wait_time') assert gvm.get_variable('state_1_preempted') assert not gvm.get_variable('state_2_preempted') testing_utils.assert_logger_warnings_and_errors(caplog)
def test_preemptive_wait_daemon(caplog): with testing_utils.test_multithreading_lock: gvm.set_variable('state_1_wait', 0.5) gvm.set_variable('state_2_wait', None) run_state_machine() assert 0.5 < gvm.get_variable('state_1_wait_time') # cannot assert this as state 2 may be launched later and will thus have a shorter execution time # assert 0.5 < gvm.get_variable('state_2_wait_time') assert not gvm.get_variable('state_1_preempted') assert gvm.get_variable('state_2_preempted') testing_utils.assert_logger_warnings_and_errors(caplog)
def test_preemptive_wait_timeout(caplog): testing_utils.test_multithreading_lock.acquire() gvm.set_variable('state_1_wait', 0.5) gvm.set_variable('state_2_wait', 1.) run_state_machine() try: assert 0.5 < gvm.get_variable('state_1_wait_time') assert not gvm.get_variable('state_1_preempted') assert gvm.get_variable('state_2_preempted') testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release()
def test_preemption_behaviour_in_preemption_state(caplog): testing_utils.initialize_environment_core() sm = state_machine_execution_engine.execute_state_machine_from_path( path=testing_utils.get_test_sm_path(os.path.join("unit_test_state_machines", "preemption_behaviour_test_sm"))) rafcon.core.singleton.state_machine_manager.remove_state_machine(sm.state_machine_id) from rafcon.core.singleton import global_variable_manager try: assert global_variable_manager.get_variable("s2") == 1.0 assert not global_variable_manager.variable_exist("s3") finally: testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_multi_events(caplog): testing_utils.initialize_environment_core() execution_trigger_thread = threading.Thread(target=trigger_exectuion_engine, args=[global_variable_manager, state_machine_execution_engine]) execution_trigger_thread.start() sm = state_machine_execution_engine.execute_state_machine_from_path( path=testing_utils.get_test_sm_path(os.path.join("unit_test_state_machines", "multi_events_test"))) execution_trigger_thread.join() state_machine_manager.remove_state_machine(sm.state_machine_id) try: assert global_variable_manager.get_variable("sm_status") == 2 finally: testing_utils.shutdown_environment_only_core(caplog=caplog, expected_warnings=0, expected_errors=0)
def server_interaction_worker(queue_dict, execution_engine, state_machine_id): from rafcon.core.singleton import global_variable_manager as gvm from rafcon.core.execution.execution_status import StateMachineExecutionStatus from rafcon.core.singleton import state_machine_manager from monitoring import server from monitoring.monitoring_manager import global_monitoring_manager sm = state_machine_manager.state_machines[state_machine_id] print("current state machine", sm) root_state = sm.root_state sleep_time = 0.99 for key, sv in sm.root_state.scoped_variables.items(): if sv.name == "bottles": sv.default_value = 3 ####################################################### print("\n\n\nserver TEST1 stop - start - wait_for_stop") ####################################################### queue_element = queue_dict[CLIENT_TO_SERVER].get() assert queue_element == "start_test_1" print("received: ", queue_element) # wait before Decimate Bottles execution_engine.run_to_selected_state("GLSUJY/NDIVLD", state_machine_id=state_machine_id) # check when run to is finished; run_to is issued from the server thread while gvm.get_variable("sing_counter") < 1: print("wait for client") time.sleep(sleep_time) print("starting tests\n\n") print("put: started") queue_dict[SERVER_TO_CLIENT].put("started") # step1: stop start test while not execution_engine.finished_or_stopped(): print("wait until state machine finished!") time.sleep(sleep_time) print("put: stop_received") queue_dict[SERVER_TO_CLIENT].put("stop_received") # step2: wait until state machine started while execution_engine.status.execution_mode is not StateMachineExecutionStatus.STARTED: print("execution_engine.status.execution_mode: ", execution_engine.status.execution_mode) # this time has to be very small otherwise the state machine start and finish during one sleep period # each state has a sleep of 0.01s time.sleep(0.01) print("put: started") queue_dict[SERVER_TO_CLIENT].put("restarted") # stop the state machine locally execution_engine.stop() # reset state machine before the next test execution_engine.join() reset_global_variable_manager(gvm) queue_dict[SERVER_TO_CLIENT].put("successfully stopped the state machine") # queue_dict[KILL_SERVER_QUEUE].get() # os._exit(0) # return ####################################################### print("\n\n\nserver TEST2 disconnect -> run sm -> connect -> run sm") ####################################################### print("server: starting test 2") reset_global_variable_manager(gvm) queue_element = queue_dict[CLIENT_TO_SERVER].get() assert queue_element == "start_test_2" print("received: ", queue_element) # step 1 # test disconnect by client run print("disconnect/connect by client test") queue_dict[SERVER_TO_CLIENT].put("disconnect_me_and_run") queue_element = queue_dict[CLIENT_TO_SERVER].get() assert queue_element == "disconnected_and_executed" print("received: ", queue_element) # the client executed a start command, which must not do anything as the client disconnected beforehand assert gvm.get_variable("count_counter") == 0 assert gvm.get_variable("sing_counter") == 0 assert gvm.get_variable("decimate_counter") == 0 # step 2 queue_dict[SERVER_TO_CLIENT].put("reconnect_me_and_run") queue_element = queue_dict[CLIENT_TO_SERVER].get() assert queue_element == "reconnected_and_executed" print("received: ", queue_element) execution_engine.join() print("server sm finished") assert gvm.get_variable("count_counter") == 3 assert gvm.get_variable("sing_counter") == 3 assert gvm.get_variable("decimate_counter") == 3 queue_dict[SERVER_TO_CLIENT].put("succeeded") execution_engine.stop() execution_engine.join() reset_global_variable_manager(gvm) print("server: disconnect/connect by client test successful\n\n") # queue_dict[KILL_SERVER_QUEUE].get() # os._exit(0) # return ####################################################### print("\n\n\nserver TEST3 disable -> run sm -> enable -> run sm ") ####################################################### reset_global_variable_manager(gvm) queue_element = queue_dict[CLIENT_TO_SERVER].get() assert queue_element == "start_test_3" print("server received: ", queue_element) for address in server.network_manager_model.connected_ip_port: global_monitoring_manager.disable(address) # while not server.network_manager_model.get_connected_status(address) == "disabled": # time.sleep(0.01) queue_dict[SERVER_TO_CLIENT].put("you_are_disabled") queue_element = queue_dict[CLIENT_TO_SERVER].get() assert queue_element == "reached end" print("server received: ", queue_element) assert gvm.get_variable("count_counter") == 0 assert gvm.get_variable("sing_counter") == 0 assert gvm.get_variable("decimate_counter") == 0 # TODO: reconnect is not properly implemented # for address in server.network_manager_model.connected_ip_port: # global_monitoring_manager.reconnect(address) queue_element = queue_dict[CLIENT_TO_SERVER].get() assert queue_element == "enabled_again" print("server received: ", queue_element) queue_element = queue_dict[CLIENT_TO_SERVER].get() assert queue_element == "started_execution" print("server received: ", queue_element) if not execution_engine.finished_or_stopped(): execution_engine.join() print("server sm finished") assert gvm.get_variable("count_counter") == 3 assert gvm.get_variable("sing_counter") == 3 assert gvm.get_variable("decimate_counter") == 3 queue_dict[SERVER_TO_CLIENT].put("succeeded") execution_engine.stop() execution_engine.join() reset_global_variable_manager(gvm) print("server: dis- /enabled by server test successful\n\n") # queue_dict[KILL_SERVER_QUEUE].get() # os._exit(0) # return ####################################################### print( "server TEST4 change client ID in config -> apply -> check connected client ID" ) ####################################################### reset_global_variable_manager(gvm) queue_element = queue_dict[CLIENT_TO_SERVER].get() assert queue_element == "start_test_4" print("server received: ", queue_element) queue_dict[SERVER_TO_CLIENT].put("ready_to_change_config") queue_element = queue_dict[CLIENT_TO_SERVER].get() assert queue_element == "on_apply_button_clicked" print("server received: ", queue_element) client_id = [] for address in server.network_manager_model.connected_ip_port: client_id.append( server.network_manager_model.get_connected_id(address)) assert "apply_test_client_id" in client_id queue_dict[SERVER_TO_CLIENT].put("succeeded") print("apply config test successful\n\n") execution_engine.stop() execution_engine.join() queue_dict[KILL_SERVER_QUEUE].get() os._exit(0)
def assert_gvm(key, value=True): assert gvm.get_variable(key) == value
def synchronize_with_clients_threads(queue_dict, execution_engine): from rafcon.core.singleton import global_variable_manager as gvm from rafcon.core.execution.execution_status import StateMachineExecutionStatus from rafcon.core.singleton import state_machine_manager from rafcon.core.execution.execution_engine import ExecutionEngine assert isinstance(execution_engine, ExecutionEngine) active_sm = state_machine_manager.get_active_state_machine() root_state = active_sm.root_state sleep_time = 0.01 # check when run to is finished while gvm.get_variable("sing_counter") < 1: time.sleep(sleep_time) synchronize_with_root_state(root_state, execution_engine, "PXTKIH") # wait for the client to start queue_dict[CLIENT1_TO_SERVER_QUEUE].get() queue_dict[SERVER_TO_CLIENT1_QUEUE].put("start stepping") print "starting tests\n\n" print "server: cp0" # step test while gvm.get_variable("decimate_counter") < 1: time.sleep(sleep_time) # sleep just to prevent busy loop synchronize_with_root_state(root_state, execution_engine, "NDIVLD") queue_dict[SERVER_TO_CLIENT1_QUEUE].put( TestSteps[0]) # step mode also means a step into print "server: cp1" while gvm.get_variable("count_counter") < 1: time.sleep(sleep_time) synchronize_with_root_state(root_state, execution_engine, "SFZGMH") queue_dict[SERVER_TO_CLIENT1_QUEUE].put(TestSteps[1]) # step over print "server: cp2" while gvm.get_variable("sing_counter") < 2: time.sleep(sleep_time) synchronize_with_root_state(root_state, execution_engine, "PXTKIH") queue_dict[SERVER_TO_CLIENT1_QUEUE].put(TestSteps[2]) # step into print "server: cp3" while gvm.get_variable("sing_counter") > 1: time.sleep(sleep_time) # wait until the backward execution of the state is done synchronize_with_root_state(root_state, execution_engine, "PXTKIH") queue_dict[SERVER_TO_CLIENT1_QUEUE].put(TestSteps[3]) # backward step print "server: cp4" while not execution_engine.finished_or_stopped(): time.sleep(sleep_time) execution_engine.join() queue_dict[SERVER_TO_CLIENT1_QUEUE].put( TestSteps[4]) # step out and run until the end reset_global_variable_manager(gvm) print "server: step test successful\n\n" # start and finish execution test while execution_engine.status.execution_mode is not StateMachineExecutionStatus.STARTED: time.sleep(sleep_time) # wait until the state machine executed successfully while not execution_engine.finished_or_stopped(): time.sleep(sleep_time) reset_global_variable_manager(gvm) # as the state machine run to the end this is safe execution_engine.stop() # reset state machine before the next test # do not notify the client before the state machine is really stopped execution_engine.join() print "server: start and wait until finished test successful\n\n" # old_sync_counter = execution_engine.synchronization_counter queue_dict[SERVER_TO_CLIENT1_QUEUE].put(TestSteps[5]) # run until end # run-until test # this is dangerous: the child state is still being executed when setting the "decimate_counter" # global variable and thus the root_state=Hierarchy state is not YET handling the execution mode # while gvm.get_variable("decimate_counter") < 1 and not root_state.handling_execution_mode: # time.sleep(sleep_time) # this also can produce race conditions # while not(execution_engine.synchronization_counter == old_sync_counter + 3): # time.sleep(sleep_time) # this is safe: while gvm.get_variable("decimate_counter") < 1: time.sleep(sleep_time) synchronize_with_root_state(root_state, execution_engine, "NDIVLD") assert gvm.get_variable("count_counter") == 0 queue_dict[SERVER_TO_CLIENT1_QUEUE].put(TestSteps[6]) while not execution_engine.finished_or_stopped(): time.sleep(sleep_time) execution_engine.join() reset_global_variable_manager(gvm) print "server: run until test successful\n\n" queue_dict[SERVER_TO_CLIENT1_QUEUE].put(TestSteps[7]) # start from test while execution_engine.status.execution_mode is not StateMachineExecutionStatus.STARTED: time.sleep(sleep_time) while not execution_engine.finished_or_stopped(): time.sleep(sleep_time) assert gvm.get_variable("sing_counter") == 2 assert gvm.get_variable("decimate_counter") == 3 # as the state machine run to the end this is safe execution_engine.stop() execution_engine.join() print "server: start from test successful\n" queue_dict[SERVER_TO_CLIENT1_QUEUE].put(TestSteps[8]) execution_engine.stop() execution_engine.join() print "server: wait for sync message from client\n" queue_dict[CLIENT1_TO_SERVER_QUEUE].get() print "server: send sync message to client\n" queue_dict[SERVER_TO_CLIENT1_QUEUE].put("sync") print "server: wait for kill command from main queue\n" # set a timeout of 3 seconds queue_dict[KILL_SERVER_QUEUE].get(3) os._exit(0)
def synchronize_with_clients_threads(queue_dict, execution_engine): from rafcon.core.singleton import global_variable_manager as gvm from rafcon.core.execution.execution_status import StateMachineExecutionStatus from rafcon.core.singleton import state_machine_manager active_sm = state_machine_manager.get_active_state_machine() root_state = active_sm.root_state sleep_time = 0.01 # check when run to is finished while gvm.get_variable("sing_counter") < 1: time.sleep(sleep_time) """ TEST1 """ queue_dict[SERVER_TO_CLIENT].put("start") print "starting tests\n\n" # stop start test while not execution_engine.finished_or_stopped(): time.sleep(sleep_time) queue_dict[SERVER_TO_CLIENT].put("stop received") # wait until state machine started while execution_engine.status.execution_mode is not StateMachineExecutionStatus.STARTED: time.sleep(sleep_time) while not execution_engine.finished_or_stopped(): time.sleep(sleep_time) reset_global_variable_manager(gvm) execution_engine.stop() # reset state machine before the next test if execution_engine.status.execution_mode is not StateMachineExecutionStatus.STOPPED: execution_engine.join() queue_dict[SERVER_TO_CLIENT].put( "start received and successfully ran the state machine") print "server: stop start test successful\n\n" """ TEST2 disconnect -> run sm -> connect -> run sm """ from monitoring import server from monitoring.monitoring_manager import global_monitoring_manager # test disconnect by client run print "disconnect/connect by client test" queue_dict[SERVER_TO_CLIENT].put("disconnect_me_and_run") queue_dict[CLIENT_TO_SERVER].get() assert gvm.get_variable("count_counter") == 0 assert gvm.get_variable("sing_counter") == 0 assert gvm.get_variable("decimate_counter") == 0 queue_dict[SERVER_TO_CLIENT].put("reconnect_me_and_run") queue_dict[CLIENT_TO_SERVER].get() if not execution_engine.finished_or_stopped(): execution_engine.join() print "server sm finished" assert gvm.get_variable("count_counter") == 3 assert gvm.get_variable("sing_counter") == 3 assert gvm.get_variable("decimate_counter") == 3 queue_dict[SERVER_TO_CLIENT].put("succeeded") execution_engine.stop() if not execution_engine.finished_or_stopped(): execution_engine.join() reset_global_variable_manager(gvm) print "server: disconnect/connect by client test successful\n\n" """ TEST3 disable -> run sm -> enable -> run sm """ # test dis- enabled by server run print "dis- /enabled test by server" for address in server.network_manager_model.connected_ip_port: global_monitoring_manager.disable(address) # while not server.network_manager_model.get_connected_status(address) == "disabled": # time.sleep(0.01) queue_dict[SERVER_TO_CLIENT].put("you are disabled") queue_dict[CLIENT_TO_SERVER].get() print "sm on client executed and stopped" assert gvm.get_variable("count_counter") == 0 assert gvm.get_variable("sing_counter") == 0 assert gvm.get_variable("decimate_counter") == 0 for address in server.network_manager_model.connected_ip_port: global_monitoring_manager.disable(address) queue_dict[SERVER_TO_CLIENT].put("you are enabled") queue_dict[CLIENT_TO_SERVER].get() if not execution_engine.finished_or_stopped(): execution_engine.join() print "server sm finished" assert gvm.get_variable("count_counter") == 3 assert gvm.get_variable("sing_counter") == 3 assert gvm.get_variable("decimate_counter") == 3 queue_dict[SERVER_TO_CLIENT].put("succeeded") execution_engine.stop() if not execution_engine.finished_or_stopped(): execution_engine.join() reset_global_variable_manager(gvm) print "server: dis- /enabled by server test successful\n\n" """ TEST4 change client ID in config -> apply -> check connected client ID """ print "apply config test" queue_dict[SERVER_TO_CLIENT].put("ready to change config") queue_dict[CLIENT_TO_SERVER].get() client_id = [] for address in server.network_manager_model.connected_ip_port: client_id.append( server.network_manager_model.get_connected_id(address)) assert "apply_test_client_id" in client_id queue_dict[SERVER_TO_CLIENT].put("succeeded") print "apply config test successful\n\n" execution_engine.stop() execution_engine.join() queue_dict[KILL_SERVER_QUEUE].get() os._exit(0)