How it works:
- Multiple contexts can be connected over TCP/IP; the interconnected contexts together form a network.
- Messages are send between channel objects (channels are attached to a context).
- Channels are bound to a slot (a string name); a message send from a channel with slot X is received by all channels with slot X.
- Yoton may be used procedurally, or in an event-driven fashion.
- Yoton supports the pub/sub pattern, in an N to M configuration.
- Yoton supports the req/rep pattern, allowing multiple requesters and repliers to exist in the same network.
- Yoton supports exchanging state information.
- Yoton is optimized to handle large messages by reducing data copying.
- Yoton has a simple event system that makes asynchronous messaging and event-driven programming easy.
- Yoton also has functionality for basic client-server (telnet-like) communication.
A brief overview of the most common classes¶
- Represents a node in the network.
- Has a bind() and connect() method to connect to other nodes.
- Represents a connection to another context.
- Wraps a single BSD-socket, using a persistent connection.
- Has signals that the user can connect to to be notified of timeouts and closing of the connection.
- Channel classes (i.e. yoton.BaseChannel )
- Channels are associated with a context, and send/receive at a particular slot (a string name).
- Messages send at a particular slot can only be received by channels associated with the same slot.
import yoton # Create one context and a pub channel ct1 = yoton.Context(verbose=verbosity) pub = yoton.PubChannel(ct1, 'chat') # Connect ct1.bind('publichost:test') # Send pub.send('hello world')
import yoton # Create another context and a sub channel ct2 = yoton.Context(verbose=verbosity) sub = yoton.SubChannel(ct2, 'chat') # Connect ct2.connect('publichost:test') # Receive print(sub.recv())