Overview¶
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.
Messaging patterns:
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.
Some features:
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¶
- yoton.Context
Represents a node in the network.
Has a bind() and connect() method to connect to other nodes.
- yoton.Connection
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.
Example¶
One end
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')
Other end
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())