modify the framework to work on distributed environment

[pavelpetrovic]

• [x] design data structures
• [x] design algorithms
• [x] impelement
• [x] write new tests for distributed environment

[pavelpetrovic]

Design of data structures modifications:

Every node will be identified by node_id. Nodes with lower id will be connecting to nodes with higher id. module_specifications will only contain node-local information. instance_data will only contain instance data of node-local modules.

• add node_id, number_of_channels to module_info
• add_node_id to channel_data
• add extra GArray around all these structures: module_names, module_types, buffers, subcriptions
• add subscriber_node_id to subscription structure
• add GArray nodes that will map node_id to node_info structure with fields: node_id, IP, name, is_online

Algorithm:

• nodes will be forwarding messages in packets containing both module_id, channel# and data (channel_data).
• each post_data() of a module that is subscribed to by a module in another node will generated forwarding packet to the respective socket.
• receipt of a packet from another node will created as a channel_data and pointer pushed into pipe
• message forwarding thread that will read channel_data from pipe will add it to buffers, and call all our subscribers callbacks, channel_data will remain in buffers in case of borrowed_pointer type and direct_data
• get_data on remote module will return message from buffers immediatelly if any local module is subscribed to that remote module channel, otherwise, it will produce request to another node and after it arrives back it will be returned -> this will happen in the thread of the calling module of get_data function; borrow_data works the same, but leaves the message in the buffers for later reference decrementing.
• add new function get_nodes() that will return the GArray nodes

[pavelpetrovic]

Communication protocol between nodes:

1. login(node_id) (node announces its node_it after connect)
2. new_module_instance(module_info)
3. deleted_module_instance(module_id)
4. subscribe(module_id, channel_number) -> subscription_id
5. unsubscribe(module_id, channel_number, subscription_id)
6. get_data(module_id, channel_number) -> channel_data
7. subscribed data(channel_data)
8. global message(sending_module_id, msg_type, len, data)

[pavelpetrovic]

mato_init() does these new things:

• reads config (with list of node infos)
• creates listening socket where other nodes connect
• creates a thread for reconnecting to other nodes (tries to connect to other nodes, every 10 seconds, when all connected, goes to sleep)
• creates a thread for communication with other nodes (receives messages and new connects from everywhere using select() os call)