def send_test_data(udp_client, queue_dict):
protocols = []
# Here just register messages are sent: as register messages are acknowledged per default
# send_message_acknowledged should be successful
protocols.append(Protocol(MessageType.REGISTER, "registering_with_acks"))
protocols.append(Protocol(MessageType.REGISTER, "this_is_a_state_id"))
protocols.append(Protocol(MessageType.REGISTER, "not_the_final_message"))
# protocols.append(Protocol(MessageType.REGISTER, FINAL_MESSAGE))
# register for acknowledges in the first message, all subsequent message should then be acknowledged
protocols.append(
Protocol(MessageType.REGISTER_WITH_ACKNOWLEDGES,
"Registering with acks"))
protocols.append(Protocol(MessageType.STATE_ID, "This is a state_id"))
protocols.append(
Protocol(MessageType.COMMAND,
test_non_acknowledged_messages.FINAL_MESSAGE))
while True:
protocol = protocols.pop(0)
logger.debug("For unit test send datagram: {0}".format(str(protocol)))
# TODO: how does twisted know to which endpoint the message should be sent?
udp_client.send_message_acknowledged(
protocol,
(global_network_config.get_config_value("SERVER_IP"),
global_network_config.get_config_value("SERVER_UDP_PORT")),
blocking=True)
if protocol.message_content == test_non_acknowledged_messages.FINAL_MESSAGE:
break
time.sleep(0.1)
logger.debug("Sender thread finished")
while udp_client.messages_to_be_acknowledged_pending():
from test_non_acknowledged_messages import print_highlight
print_highlight(udp_client._messages_to_be_acknowledged)
for key, protocoll in udp_client._messages_to_be_acknowledged.iteritems(
):
print_highlight(protocoll[0].message_content)
time.sleep(0.2)
if udp_client.number_of_dropped_messages == 0:
queue_dict[test_non_acknowledged_messages.CLIENT_TO_MAIN_QUEUE].put(
SUCCESS_MESSAGE)
else:
queue_dict[test_non_acknowledged_messages.CLIENT_TO_MAIN_QUEUE].put(
FAILURE_MESSAGE)
def on_value_changed(self, widget, path, text):
"""Triggered when a config value is edited.
:param path: The path identifying the edited variable
:param text: New variable value
"""
value = None
# logger.info("changing value")
if self.config_list_store[int(path)][1] == text:
return
key = self.config_list_store[int(path)][0]
data_type = type(global_network_config.get_config_value(key))
try:
if data_type == bool:
if text == "False":
value = False
elif text == "True":
value = True
else:
logger.info("Invalid input: {0}".format(str(text)))
return
else:
value = data_type(text)
self.network_manager_model.set_config_value(key, value)
except RuntimeError as e:
logger.exception(e)
def connect(self):
"""
This function opens a udp port for remote clients
:return:
"""
from twisted.internet import reactor
self.connector = reactor.listenUDP(global_network_config.get_config_value("SERVER_UDP_PORT"), self)
self.initialized = True
logger.info("Initialized")
return True
def check_if_ports_are_open():
import psutil
from acknowledged_udp.config import global_network_config
config_path = os.path.abspath(
path=os.path.dirname(os.path.abspath(__file__)) + "/server")
global_network_config.load(path=config_path)
for connection in psutil.net_connections():
if int(global_network_config.get_config_value(
"SERVER_UDP_PORT")) == connection.laddr[1]:
return False
return True
def set_config_value(self, param, value):
"""
A method to set all config values into the config_list.
:param param: dict with config values to search in network_monitoring_config.YAML
:param value: new value for a config which shall be updated
:return:
"""
if not self.config_list:
for key in self.params:
if global_network_config.get_config_value(key):
self.config_list.append(
(key,
str(global_network_config.get_config_value(key))))
else:
for key in self.config_list:
if param == key[0]:
index = self.config_list.index(key)
self.config_list.remove(key)
global_network_config.set_config_value(param, value)
self.config_list.insert(index, (param, value))
def on_connect_button_clicked(self, *args):
"""
Triggered when connect button clicked
Connects to selected server
:param args:
:return:
"""
path = self.view["connection_tree_view1"].get_cursor()[0]
if path is not None:
for index in path:
address = self.network_manager_model.connected_ip_port[index]
logger.info("Connecting to: {0}".format(address))
if self.network_manager_model.get_connected_status(
address) == "connected":
logger.info("Already connected to server!")
else:
global_monitoring_manager.reconnect(address)
else:
address = ((
global_network_config.get_config_value("SERVER_IP"),
global_network_config.get_config_value("SERVER_UDP_PORT")))
global_monitoring_manager.reconnect(address)
def start_udp_server(name, queue_dict):
info(name)
udp_server = UdpServer()
connector = reactor.listenUDP(
global_network_config.get_config_value("SERVER_UDP_PORT"), udp_server)
udp_server.datagram_received_function = write_back_message
global server_transport
server_transport = udp_server.get_transport()
wait_for_test_finish = threading.Thread(
target=wait_for_test_finished,
args=[queue_dict, udp_server, connector, True])
wait_for_test_finish.start()
# reactor.addSystemEventTrigger('before', 'shutdown', udp_server.some_function)
reactor.run()
wait_for_test_finish.join()
logger.info("Server joined wait_for_test_finish")
def initialize(self, setup_config):
"""
The is an initialization function, which is called when the connection finally is set up.
:param setup_config: the setup configuration for the networking
:return:
"""
if not self.config_flag:
self.config = setup_config
self.config_flag = True
if global_network_config.get_config_value("SERVER", True):
if not self.endpoint:
self.endpoint = MonitoringServer()
self.endpoint_initialized = self.endpoint.connect()
else:
if not self.endpoint:
self.endpoint = MonitoringClient()
self.endpoint_initialized = self.endpoint.connect()
return self.endpoint_initialized
def main_window_setup(main_window_controller):
"""
Launches the model-view-controller of monitoring plugin. Called in controllers/main_window.py
:param main_window_controller:
:return:
"""
from monitoring.views.server_connection import ServerView
from monitoring.views.client_connection import ClientView
from monitoring.controllers.server_controller import ServerController
from monitoring.controllers.client_controller import ClientController
from monitoring.model.network_model import network_manager_model
from rafcon.gui.helpers.label import create_tab_header_label
import constants
icon = {"network": constants.ICON_NET}
monitoring_plugin_eventbox = create_tab_header_label("network", icon)
if global_network_config.get_config_value("SERVER"):
main_window_controller.view.state_machine_server = ServerView()
main_window_controller.view.state_machine_server.show()
main_window_controller.view['lower_notebook'].append_page(
main_window_controller.view.state_machine_server.get_top_widget(),
monitoring_plugin_eventbox)
monitoring_manager_ctrl = ServerController(
network_manager_model,
main_window_controller.view.state_machine_server)
else:
main_window_controller.view.state_machine_client = ClientView()
main_window_controller.view.state_machine_client.show()
main_window_controller.view['lower_notebook'].append_page(
main_window_controller.view.state_machine_client.get_top_widget(),
monitoring_plugin_eventbox)
monitoring_manager_ctrl = ClientController(
network_manager_model,
main_window_controller.view.state_machine_client)
main_window_controller.add_controller('monitoring_manager_ctrl',
monitoring_manager_ctrl)
def networking_enabled():
"""
A method to check if the monitoring capability is globally enabled.
:return:
"""
return global_network_config.get_config_value("ENABLED", False)
"Try to initialize the global monitoring manager and setup the connection to the server!"
)
succeeded = global_monitoring_manager.initialize(
setup_config)
if succeeded:
monitoring_manager_initialized = True
except CannotListenError, e:
logger.exception(
"Cannot start rafcon as a server: Address already in use!")
import threading
init_thread = threading.Thread(target=initialize_monitoring_manager)
init_thread.daemon = True
init_thread.start()
if not global_network_config.get_config_value(
"SERVER") and not 'rafcon.gui' in sys.modules:
logger.error(
"Starting RAFCON with the monitoring plugin in client mode without GUI, does not make sense ..."
)
def main_window_setup(main_window_controller):
"""
Launches the model-view-controller of monitoring plugin. Called in controllers/main_window.py
:param main_window_controller:
:return:
"""
from monitoring.views.server_connection import ServerView
from monitoring.views.client_connection import ClientView
from monitoring.controllers.server_controller import ServerController
from monitoring.controllers.client_controller import ClientController
def monitoring_data_received_function(self, message, address):
"""
This functions receives all messages sent by the remote RAFCON server.
:param message: the received message
:param address: the address (port, ip-address) of the remote server
:return:
"""
logger.info("Received datagram {0} from address: {1}".format(str(message), str(address)))
assert isinstance(message, Protocol)
network_manager_model.add_to_message_list(message.message_content, address, "received")
if message.message_type is MessageType.REGISTER:
ident = message.message_content.split("@")
if 2 < ident:
ident.append(None)
network_manager_model.set_connected_ip_port(address)
network_manager_model.set_connected_id(address, ident[1])
network_manager_model.set_connected_status(address, "connected")
if ident[1]:
protocol = Protocol(MessageType.ID, global_network_config.get_config_value("SERVER_ID"))
self.send_message_non_acknowledged(protocol, address)
network_manager_model.add_to_message_list(protocol, address, "send")
thread = Thread(target=ping_endpoint, args=(address, ))
thread.daemon = True
thread.start()
elif message.message_type is MessageType.COMMAND and network_manager_model.get_connected_status(address) is not "disabled":
received_command = message.message_content.split("@")
execution_mode = StateMachineExecutionStatus(int(received_command[0]))
# currently the monitoring plugin cannot select the target state machine
sm_key, sm = state_machine_manager.state_machines.items()[0]
if execution_mode is StateMachineExecutionStatus.STARTED:
# as there is no dedicated RUN_TO_STATE execution status the message has to be checked for an optional
# start state path
if len(received_command) == 2:
print "start state machine from state " + received_command[1]
state_machine_execution_engine.start(sm.state_machine_id, start_state_path=received_command[1])
else:
state_machine_execution_engine.start(sm.state_machine_id)
elif execution_mode is StateMachineExecutionStatus.STOPPED:
state_machine_execution_engine.stop()
elif execution_mode is StateMachineExecutionStatus.PAUSED:
state_machine_execution_engine.pause()
elif execution_mode is StateMachineExecutionStatus.FORWARD_INTO:
state_machine_execution_engine.step_into()
elif execution_mode is StateMachineExecutionStatus.FORWARD_OVER:
state_machine_execution_engine.step_over()
elif execution_mode is StateMachineExecutionStatus.FORWARD_OUT:
state_machine_execution_engine.step_out()
elif execution_mode is StateMachineExecutionStatus.BACKWARD:
state_machine_execution_engine.backward_step()
elif execution_mode is StateMachineExecutionStatus.RUN_TO_SELECTED_STATE:
state_machine_execution_engine.run_to_selected_state(received_command[1],
state_machine_id=sm.state_machine_id)
elif message.message_type is MessageType.UNREGISTER:
network_manager_model.set_connected_status(address, "disconnected")
network_manager_model.delete_connection(address)
logger.info("Received datagram {0} from address: {1}".format(str(message), str(address)))
