Provided by: pyzo_4.15.0-1_all 
NAME
pyzo - Pyzo Documentation
API docs in progress.
IEP is organized in several subpackages, some of which can be used completely independent
from the rest. Although IEP the IDE requires Qt and Python 3, some of its subpackages can
safely be imported without these dependencies…
Contents:
CODEEDITOR - THE CORE EDITING COMPONENT
This subpackage is independent of any other components of IEP and only has Qt (PySide2 or
PyQt5) as a dependency. It works on Python 3 and may also still work on Python2.
Content and API will come here.
YOTON - INTER PROCESS COMMUNICATION
Yoton is a Python package that provides a simple interface to communicate between two or
more processes.
Yoton is independent of any other component of IEP and has no dependencies except Python
itself. It runs on any Python version from 2.4.
Yoton is …
• lightweight
• written in pure Python
• without dependencies (except Python)
• available on Python version >= 2.4, including Python 3
• cross-platform
• pretty fast
----
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())
Examples
Abstract example
This example shows four connected contexts. In principal, all contexts are the same (a
context is neither a client nor a server). Yet, different contexts can play different
roles in the network, by using different channels:
• The upper left context publishes a stream of messages.
• The upper right context employs a reply-channel, thereby taking on a server role.
• The bottom left context takes on a client-like role by subscribing to the
"stream" channel and by having a request-channel on "data".
• The bottom right context has no channels and thus only serves as a means of
connecting the different contexts.
[image]
Simple client server
Two contexts. One takes a server role by having a publish-channel and a reply-channel. The
other takes on a client role by deploying the corresponding subscribe-channel and
request-channel. [image]
Multiple request/reply
This network contains only two types of context: requesters and repliers. Yoton performs a
simple load balancing scheme: when the user posts a request, the req-channel first asks
all repliers whether they can want to handle it. Eventually all repliers will answer that
they do, but the actual request is only send to the first to respond. Requesters that are
handling a previous request are unable to respond quickly so that the request will be
handled by a "free" replier automatically. If all requesters are busy, the first to "come
back" will handle the request. [image]
Chat
This network consists of context which all take the same role; they all send chat messages
and receive chat messages of the other nodes. One big chat room! [image]
IDE / kernel
This network illustrates a simplified version of what yoton was initially designed for:
client-kernel communication. IEP uses yoton for its kernel-client communications, see here
which channels IEP uses for that.
The network consists of one kernel and two clients which are connected via a broker. Both
clients can control the kernel via an stdin stream and receive output on stdout. The
kernel also has a reply-channel so that the IDE's can obtain introspection information
(think auto-completion). The broker also publishes some status messages. The bottom kernel
is apparently only interested in kernel control. [image]
Context
class yoton.Context(verbose=0, queue_params=None)
Inherits from object
A context represents a node in the network. It can connect to multiple other
contexts (using a yoton.Connection. These other contexts can be in another process
on the same machine, or on another machine connected via a network or the internet.
This class represents a context that can be used by channel instances to
communicate to other channels in the network. (Thus the name.)
The context is the entity that queue routes the packages produced by the channels
to the other context in the network, where the packages are distributed to the
right channels. A context queues packages while it is not connected to any other
context.
If messages are send on a channel registered at this context while the context is
not connected, the messages are stored by the context and will be send to the first
connecting context.
Example 1
# Create context and bind to a port on localhost
context = yoton.Context()
context.bind('localhost:11111')
# Create a channel and send a message
pub = yoton.PubChannel(context, 'test')
pub.send('Hello world!')
Example 2
# Create context and connect to the port on localhost
context = yoton.Context()
context.connect('localhost:11111')
# Create a channel and receive a message
sub = yoton.SubChannel(context, 'test')
print(sub.recv() # Will print 'Hello world!'
Queue params
The queue_params parameter allows one to specify the package queues used in the
system. It is recommended to use the same parameters for every context in the
network. The value of queue_params should be a 2-element tuple specifying queue
size and discard mode. The latter can be ‘old’ (default) or ‘new’, meaning that if
the queue is full, either the oldest or newest messages are discarted.
PROPERTIES
connection_count
Get the number of connected contexts. Can be used as a boolean to check if
the context is connected to any other context.
connections
Get a list of the Connection instances currently active for this context.
In addition to normal list indexing, the connections objects can be queried
from this list using their name.
connections_all
Get a list of all Connection instances currently associated with this
context, including pending connections (connections waiting for another end
to connect). In addition to normal list indexing, the connections objects
can be queried from this list using their name.
id The 8-byte UID of this context.
METHODS
bind(address, max_tries=1, name='')
Setup a connection with another Context, by being the host. This method
starts a thread that waits for incoming connections. Error messages are
printed when an attempted connect fails. the thread keeps trying until a
successful connection is made, or until the connection is closed.
Returns a Connection instance that represents the connection to the other
context. These connection objects can also be obtained via the
Context.connections property.
Parameters
address
str Should be of the shape hostname:port. The port should be an
integer number between 1024 and 2**16. If port does not represent a
number, a valid port number is created using a hash function.
max_tries
int The number of ports to try; starting from the given port,
subsequent ports are tried until a free port is available. The final
port can be obtained using the ‘port’ property of the returned
Connection instance.
name string The name for the created Connection instance. It can be used
as a key in the connections property.
Notes on hostname
The hostname can be:
• The IP address, or the string hostname of this computer.
• ‘localhost’: the connections is only visible from this computer.
Also some low level networking layers are bypassed, which results
in a faster connection. The other context should also connect to
‘localhost’.
• ‘publichost’: the connection is visible by other computers on the
same network. Optionally an integer index can be appended if the
machine has multiple IP addresses (see socket.gethostbyname_ex).
close()
Close the context in a nice way, by closing all connections and all
channels.
Closing a connection means disconnecting two contexts. Closing a channel
means disasociating a channel from its context. Unlike connections and
channels, a Context instance can be reused after closing (although this
might not always the best strategy).
close_channels()
Close all channels associated with this context. This does not close the
connections. See also close().
connect(self, address, timeout=1.0, name='')
Setup a connection with another context, by connection to a hosting context.
An error is raised when the connection could not be made.
Returns a Connection instance that represents the connection to the other
context. These connection objects can also be obtained via the
Context.connections property.
Parameters
address
str Should be of the shape hostname:port. The port should be an
integer number between 1024 and 2**16. If port does not represent a
number, a valid port number is created using a hash function.
max_tries
int The number of ports to try; starting from the given port,
subsequent ports are tried until a free port is available. The final
port can be obtained using the ‘port’ property of the returned
Connection instance.
name string The name for the created Connection instance. It can be used
as a key in the connections property.
Notes on hostname
The hostname can be:
• The IP address, or the string hostname of this computer.
• ‘localhost’: the connection is only visible from this computer.
Also some low level networking layers are bypassed, which results
in a faster connection. The other context should also host as
‘localhost’.
• ‘publichost’: the connection is visible by other computers on the
same network. Optionally an integer index can be appended if the
machine has multiple IP addresses (see socket.gethostbyname_ex).
flush(timeout=5.0)
Wait until all pending messages are send. This will flush all messages
posted from the calling thread. However, it is not guaranteed that no new
messages are posted from another thread.
Raises an error when the flushing times out.
Connection
The connection classes represent the connection between two context. There is one base
class (yoton.Connection) and currently there is one implementation: the
yoton.TcpConnection. In the future other connections might be added that use other methods
than TCP/IP.
class yoton.Connection(context, name='')
Inherits from object
Abstract base class for a connection between two Context objects. This base class
defines the full interface; subclasses only need to implement a few private
methods.
The connection classes are intended as a simple interface for the user, for example
to query port number, and be notified of timeouts and closing of the connection.
All connection instances are intended for one-time use. To make a new connection,
instantiate a new Connection object. After instantiation, either _bind() or
_connect() should be called.
PROPERTIES
closed Signal emitted when the connection closes. The first argument is the
ContextConnection instance, the second argument is the reason for the
disconnection (as a string).
hostname1
Get the hostname corresponding to this end of the connection.
hostname2
Get the hostname for the other end of this connection. Is empty string if
not connected.
id1 The id of the context on this side of the connection.
id2 The id of the context on the other side of the connection.
is_alive
Get whether this connection instance is alive (i.e. either waiting or
connected, and not in the process of closing).
is_connected
Get whether this connection instance is connected.
is_waiting
Get whether this connection instance is waiting for a connection. This is
the state after using bind() and before another context connects to it.
name Set/get the name that this connection is known by. This name can be used to
obtain the instance using the Context.connections property. The name can be
used in networks in which each context has a particular role, to easier
distinguish between the different connections. Other than that, the name has
no function.
pid1 The pid of the context on this side of the connection. (hint: os.getpid())
pid2 The pid of the context on the other side of the connection.
port1 Get the port number corresponding to this end of the connection. When
binding, use this port to connect the other context.
port2 Get the port number for the other end of the connection. Is zero when not
connected.
timedout
This signal is emitted when no data has been received for over ‘timeout’
seconds. This can mean that the connection is unstable, or that the other
end is running extension code.
Handlers are called with two arguments: the ContextConnection instance, and
a boolean. The latter is True when the connection times out, and False when
data is received again.
timeout
Set/get the amount of seconds that no data is received from the other side
after which the timedout signal is emitted.
METHODS
close(reason=None)
Close the connection, disconnecting the two contexts and stopping all
trafic. If the connection was waiting for a connection, it stops waiting.
Optionally, a reason for closing can be specified. A closed connection
cannot be reused.
close_on_problem(reason=None)
Disconnect the connection, stopping all trafic. If it was waiting for a
connection, we stop waiting.
Optionally, a reason for stopping can be specified. This is highly
recommended in case the connection is closed due to a problem.
In contrast to the normal close() method, this method does not try to notify
the other end of the closing.
flush(timeout=3.0)
Wait until all pending packages are send. An error is raised when the
timeout passes while doing so.
class yoton.TcpConnection(context, name='')
Inherits from Connection
The TcpConnection class implements a connection between two contexts that are in
differenr processes or on different machines connected via the internet.
This class handles the low-level communication for the context. A
ContextConnection instance wraps a single BSD socket for its communication, and
uses TCP/IP as the underlying communication protocol. A persisten connection is
used (the BSD sockets stay connected). This allows to better distinguish between
connection problems and timeouts caused by the other side being busy.
Channels
The channel classes represent the mechanism for the user to send messages into the network
and receive messages from it. A channel needs a context to function; the context
represents a node in the network.
Slots
To be able to route messages to the right channel, channels are associated with a slot (a
string name). This slot consists of a user-defined base name and an extension to tell the
message type and messaging pattern. Messages send from a channel with slot X, are only
received by channels with the same slot X. Slots are case insensitive.
Messaging patterns
Yoton supports three base messaging patterns. For each messaging pattern there are
specific channel classes. All channels derive from yoton.BaseChannel.
publish/subscribe The yoton.PubChannel class is used for sending messages into the
network, and the yoton.SubChannel class is used to receiving these messages. Multiple
PubChannels and SubChannels can exist in the same network at the same slot; the
SubChannels simply collect the messages send by all PubChannels.
request/reply The yoton.ReqChannel class is used to do requests, and the yoton.RepChannel
class is used to reply to requests. If multiple ReqChannels are present at the same slot,
simple load balancing is performed.
state The yoton.StateChannel class is used to communicate state to other state channels.
Each yoton.StateChannel can set and get the state.
Message types
Messages are of a specific type (text, binary, …), the default being Unicode text. The
third (optional) argument to a Channel’s initializer is a MessageType object that
specifies how messages should be converted to bytes and the other way around.
This way, the channels classes themself can be agnostic about the message type, while the
user can implement its own MessageType class to send whatever messages he/she likes.
class yoton.BaseChannel(context, slot_base, message_type=yoton.TEXT)
Inherits from object
Abstract class for all channels.
Parameters
context
yoton.Context instance The context that this channel uses to send messages
in a network.
slot_base
string The base slot name. The channel appends an extension to indicate
message type and messaging pattern to create the final slot name. The final
slot is used to connect channels at different contexts in a network
message_type
yoton.MessageType instance (default is yoton.TEXT) Object to convert
messages to bytes and bytes to messages. Users can create their own
message_type class to enable communicating any type of message they want.
Details
Messages send via a channel are delivered asynchronically to the corresponding
channels.
All channels are associated with a context and can be used to send messages to
other channels in the network. Each channel is also associated with a slot, which
is a string that represents a kind of address. A message send by a channel at slot
X can only be received by a channel with slot X.
Note that the channel appends an extension to the user-supplied slot name, that
represents the message type and messaging pattern of the channel. In this way, it
is prevented that for example a PubChannel can communicate with a RepChannel.
PROPERTIES
closed Get whether the channel is closed.
pending
Get the number of pending incoming messages.
received
Signal that is emitted when new data is received. Multiple arrived messages
may result in a single call to this method. There is no guarantee that
recv() has not been called in the mean time. The signal is emitted with the
channel instance as argument.
slot_incoming
Get the incoming slot name.
slot_outgoing
Get the outgoing slot name.
METHODS
close()
Close the channel, i.e. unregisters this channel at the context. A closed
channel cannot be reused.
Future attempt to send() messages will result in an IOError being raised.
Messages currently in the channel’s queue can still be recv()’ed, but no new
messages will be delivered at this channel.
class yoton.PubChannel(context, slot_base, message_type=yoton.TEXT)
Inherits from BaseChannel
The publish part of the publish/subscribe messaging pattern. Sent messages are
received by all yoton.SubChannel instances with the same slot.
There are no limitations for this channel if events are not processed.
Parameters
context
yoton.Context instance The context that this channel uses to send messages
in a network.
slot_base
string The base slot name. The channel appends an extension to indicate
message type and messaging pattern to create the final slot name. The final
slot is used to connect channels at different contexts in a network
message_type
yoton.MessageType instance (default is yoton.TEXT) Object to convert
messages to bytes and bytes to messages. Users can create their own
message_type class to let channels any type of message they want.
METHODS
send(message)
Send a message over the channel. What is send as one message will also be
received as one message.
The message is queued and delivered to all corresponding SubChannels (i.e.
with the same slot) in the network.
class yoton.SubChannel(context, slot_base, message_type=yoton.TEXT)
Inherits from BaseChannel
The subscribe part of the publish/subscribe messaging pattern. Received messages
were sent by a yoton.PubChannel instance at the same slot.
This channel can be used as an iterator, which yields all pending messages. The
function yoton.select_sub_channel can be used to synchronize multiple SubChannel
instances.
If no events being processed this channel works as normal, except that the received
signal will not be emitted, and sync mode will not work.
Parameters
context
yoton.Context instance The context that this channel uses to send messages
in a network.
slot_base
string The base slot name. The channel appends an extension to indicate
message type and messaging pattern to create the final slot name. The final
slot is used to connect channels at different contexts in a network
message_type
yoton.MessageType instance (default is yoton.TEXT) Object to convert
messages to bytes and bytes to messages. Users can create their own
message_type class to let channels any type of message they want.
METHODS
next() Return the next message, or raises StopIteration if non available.
recv(block=True)
Receive a message from the channel. What was send as one message is also
received as one message.
If block is False, returns empty message if no data is available. If block
is True, waits forever until data is available. If block is an int or
float, waits that many seconds. If the channel is closed, returns empty
message.
recv_all()
Receive a list of all pending messages. The list can be empty.
recv_selected()
Receive a list of messages. Use only after calling yoton.select_sub_channel
with this channel as one of the arguments.
The returned messages are all received before the first pending message in
the other SUB-channels given to select_sub_channel.
The combination of this method and the function select_sub_channel enables
users to combine multiple SUB-channels in a way that preserves the original
order of the messages.
set_sync_mode(value)
Set or unset the SubChannel in sync mode. When in sync mode, all channels
that send messages to this channel are blocked if the queue for this
SubChannel reaches a certain size.
This feature can be used to limit the rate of senders if the consumer (i.e.
the one that calls recv()) cannot keep up with processing the data.
This feature requires the yoton event loop to run at the side of the
SubChannel (not necessary for the yoton.PubChannel side).
yoton.select_sub_channel(channel1, channel2, ...)
Returns the channel that has the oldest pending message of all given
yoton.SubCannel instances. Returns None if there are no pending messages.
This function can be used to read from SubCannels instances in the order that the
messages were send.
After calling this function, use channel.recv_selected() to obtain all messages
that are older than any pending messages in the other given channels.
class yoton.ReqChannel(context, slot_base)
Inherits from BaseChannel
The request part of the request/reply messaging pattern. A ReqChannel instance
sends request and receive the corresponding replies. The requests are replied by a
yoton.RepChannel instance.
This class adopts req/rep in a remote procedure call (RPC) scheme. The handling of
the result is done using a yoton.Future object, which follows the approach
specified in PEP 3148. Note that for the use of callbacks, the yoton event loop
must run.
Basic load balancing is performed by first asking all potential repliers whether
they can handle a request. The actual request is then send to the first replier to
respond.
Parameters
context
yoton.Context instance The context that this channel uses to send messages
in a network.
slot_base
string The base slot name. The channel appends an extension to indicate
message type and messaging pattern to create the final slot name. The final
slot is used to connect channels at different contexts in a network
Usage
One performs a call on a virtual method of this object. The actual method is
executed by the yoton.RepChannel instance. The method can be called with normal and
keyword arguments, which can be (a combination of): None, bool, int, float, string,
list, tuple, dict.
Example
# Fast, but process is idling when waiting for the response.
reply = req.add(3,4).result(2.0) # Wait two seconds
# Asynchronous processing, but no waiting.
def reply_handler(future):
... # Handle reply
future = req.add(3,4)
future.add_done_callback(reply_handler)
class yoton.RepChannel(context, slot_base)
Inherits from BaseChannel
The reply part of the request/reply messaging pattern. A RepChannel instance
receives request and sends the corresponding replies. The requests are send from a
yoton.ReqChannel instance.
This class adopts req/rep in a remote procedure call (RPC) scheme.
To use a RepChannel, subclass this class and implement the methods that need to be
available. The reply should be (a combination of) None, bool, int, float, string,
list, tuple, dict.
This channel needs to be set to event or thread mode to function (in the first case
yoton events need to be processed too). To stop handling events again, use
set_mode(‘off’).
Parameters
context
yoton.Context instance The context that this channel uses to send messages
in a network.
slot_base
string The base slot name. The channel appends an extension to indicate
message type and messaging pattern to create the final slot name. The final
slot is used to connect channels at different contexts in a network
METHODS
echo(arg1, sleep=0.0)
Default procedure that can be used for testing. It returns a tuple
(first_arg, context_id)
set_mode(mode)
Set the replier to its operating mode, or turn it off.
Modes:
• 0 or ‘off’: do not process requests
• 1 or ‘event’: use the yoton event loop to process requests
• 2 or ‘thread’: process requests in a separate thread
class yoton.Future(req_channel, req, request_id)
Inherits from object
The Future object represents the future result of a request done at a
yoton.ReqChannel.
It enables:
• checking whether the request is done.
• getting the result or the exception raised during handling the request.
• canceling the request (if it is not yet running)
• registering callbacks to handle the result when it is available
METHODS
add_done_callback(fn)
Attaches the callable fn to the future. fn will be called, with the future
as its only argument, when the future is cancelled or finishes running.
Added callables are called in the order that they were added. If the
callable raises a Exception subclass, it will be logged and ignored. If the
callable raises a BaseException subclass, the behavior is undefined.
If the future has already completed or been cancelled, fn will be called
immediately.
cancel()
Attempt to cancel the call. If the call is currently being executed and
cannot be cancelled then the method will return False, otherwise the call
will be cancelled and the method will return True.
cancelled()
Return True if the call was successfully cancelled.
done() Return True if the call was successfully cancelled or finished running.
exception(timeout)
Return the exception raised by the call. If the call hasn’t yet completed
then this method will wait up to timeout seconds. If the call hasn’t
completed in timeout seconds, then a TimeoutError will be raised. timeout
can be an int or float. If timeout is not specified or None, there is no
limit to the wait time.
If the future is cancelled before completing then CancelledError will be
raised.
If the call completed without raising, None is returned.
result(timeout=None)
Return the value returned by the call. If the call hasn’t yet completed then
this method will wait up to timeout seconds. If the call hasn’t completed in
timeout seconds, then a TimeoutError will be raised. timeout can be an int
or float. If timeout is not specified or None, there is no limit to the wait
time.
If the future is cancelled before completing then CancelledError will be
raised.
If the call raised, this method will raise the same exception.
result_or_cancel(timeout=1.0)
Return the value returned by the call. If the call hasn’t yet completed then
this method will wait up to timeout seconds. If the call hasn’t completed in
timeout seconds, then the call is cancelled and the method will return None.
running()
Return True if the call is currently being executed and cannot be cancelled.
set_auto_cancel_timeout(timeout)
Set the timeout after which the call is automatically cancelled if it is not
done yet. By default, this value is 10 seconds.
If timeout is None, there is no limit to the wait time.
set_exception(exception)
Sets the result of the work associated with the Future to the Exception
exception. This method should only be used by Executor implementations and
unit tests.
set_result(result)
Sets the result of the work associated with the Future to result. This
method should only be used by Executor implementations and unit tests.
set_running_or_notify_cancel()
This method should only be called by Executor implementations before
executing the work associated with the Future and by unit tests.
If the method returns False then the Future was cancelled, i.e.
Future.cancel() was called and returned True.
If the method returns True then the Future was not cancelled and has been
put in the running state, i.e. calls to Future.running() will return True.
This method can only be called once and cannot be called after
Future.set_result() or Future.set_exception() have been called.
class yoton.StateChannel(context, slot_base, message_type=yoton.TEXT)
Inherits from BaseChannel
Channel class for the state messaging pattern. A state is synchronized over all
state channels of the same slot. Each channel can send (i.e. set) the state and
recv (i.e. get) the current state. Note however, that if two StateChannel
instances set the state around the same time, due to the network delay, it is
undefined which one sets the state the last.
The context will automatically call this channel’s send_last() method when a new
context enters the network.
The recv() call is always non-blocking and always returns the last received
message: i.e. the current state.
There are no limitations for this channel if events are not processed, except that
the received signal is not emitted.
Parameters
context
yoton.Context instance The context that this channel uses to send messages
in a network.
slot_base
string The base slot name. The channel appends an extension to indicate
message type and messaging pattern to create the final slot name. The final
slot is used to connect channels at different contexts in a network
message_type
yoton.MessageType instance (default is yoton.TEXT) Object to convert
messages to bytes and bytes to messages. Users can create their own
message_type class to let channels any type of message they want.
METHODS
recv(block=False)
Get the state of the channel. Always non-blocking. Returns the most up to
date state.
send(message)
Set the state of this channel.
The state-message is queued and send over the socket by the IO-thread.
Zero-length messages are ignored.
send_last()
Resend the last message.
Event system
Module yoton.events
Yoton comes with a simple event system to enable event-driven applications.
All channels are capable of running without the event system, but some channels have
limitations. See the documentation of the channels for more information. Note that signals
only work if events are processed.
class yoton.Signal
Inherits from object
The purpose of a signal is to provide an interface to bind/unbind to events and to
fire them.
One can bind() or unbind() a callable to the signal. When emitted, an event is
created for each bound handler. Therefore, the event loop must run for signals to
work.
Some signals call the handlers using additional arguments to specify specific
information.
PROPERTIES
type The type (__class__) of this event.
METHODS
bind(func)
Add an eventhandler to this event.
The callback/handler (func) must be a callable. It is called with one
argument: the event instance, which can contain additional information about
the event.
emit(*args, **kwargs)
Emit the signal, calling all bound callbacks with
*
args and
**
kwargs. An event is queues for each callback registered to this signal.
Therefore it is safe to call this method from another thread.
emit_now(*args, **kwargs)
Emit the signal now. All handlers are called from the calling thread.
Beware, this should only be done from the same thread that runs the event
loop.
unbind(func=None)
Unsubscribe a handler, If func is None, remove all handlers.
class yoton.Timer(interval=1.0, oneshot=True)
Inherits from Signal
Timer class. You can bind callbacks to the timer. The timer is fired when it runs
out of time.
Parameters
interval
number The interval of the timer in seconds.
oneshot
bool Whether the timer should do a single shot, or run continuously.
PROPERTIES
interval
Set/get the timer’s interval in seconds.
oneshot
Set/get whether this is a oneshot timer. If not is runs continuously.
running
Get whether the timer is running.
METHODS
start(interval=None, oneshot=None)
Start the timer. If interval or oneshot are not given, their current values
are used.
stop() Stop the timer from running.
yoton.call_later(func, timeout=0.0, *args, **kwargs)
Call the given function after the specified timeout.
Parameters
func callable The function to call.
timeout
number The time to wait in seconds. If zero, the event is put on the event
queue. If negative, the event will be put at the front of the event queue,
so that it’s processed asap.
args arguments The arguments to call func with.
kwargs: keyword arguments.
The keyword arguments to call func with.
yoton.process_events(block=False)
Process all yoton events currently in the queue. This function should be called
periodically in order to keep the yoton event system running.
block can be False (no blocking), True (block), or a float blocking for maximally
‘block’ seconds.
yoton.start_event_loop()
Enter an event loop that keeps calling yoton.process_events(). The event loop can
be stopped using stop_event_loop().
yoton.stop_event_loop()
Stops the event loop if it is running.
yoton.embed_event_loop(callback)
Embed the yoton event loop in another event loop. The given callback is called
whenever a new yoton event is created. The callback should create an event in the
other event-loop, which should lead to a call to the process_events() method. The
given callback should be thread safe.
Use None as an argument to disable the embedding.
clientserver – Request-reply pattern using a client-server model
yoton.clientserver.py
Yoton comes with a small framework to setup a request-reply pattern using a client-server
model (over a non-persistent connection), similar to telnet. This allows one process to
easily ask small pieces of information from another process.
To create a server, create a class that inherits from yoton.RequestServer and implement
its handle_request() method.
A client process can simply use the yoton.do_request function. Example:
yoton.do_request('www.google.com:80', 'GET http/1.1\r\n')
The client server model is implemented using one function and one class: yoton.do_request
and yoton.RequestServer.
Details
The server implements a request/reply pattern by listening at a socket. Similar to
telnet, each request is handled using a connection and the socket is closed after the
response is send.
The request server can setup to run in the main thread, or can be started using its own
thread. In the latter case, one can easily create multiple servers in a single process,
that listen on different ports.
Implementation
The client server model is implemented using one function and one class: yoton.do_request
and yoton.RequestServer.
yoton.do_request(address, request, timeout=-1)
Do a request at the server at the specified address. The server can be a
yoton.RequestServer, or any other server listening on a socket and following a
REQ/REP pattern, such as html or telnet. For example: html =
do_request('www.google.com:80', 'GET http/1.1\r\n')
Parameters
address
str Should be of the shape hostname:port.
request
string The request to make.
timeout
float If larger than 0, will wait that many seconds for the respons, and
return None if timed out.
Notes on hostname
The hostname can be:
• The IP address, or the string hostname of this computer.
• ‘localhost’: the connections is only visible from this computer. Also
some low level networking layers are bypassed, which results in a faster
connection. The other context should also connect to ‘localhost’.
• ‘publichost’: the connection is visible by other computers on the same
network.
class yoton.RequestServer(address, async=False, verbose=0)
Inherits from Thread
Setup a simple server that handles requests similar to a telnet server, or
asyncore. Starting the server using run() will run the server in the calling
thread. Starting the server using start() will run the server in a separate thread.
To create a server, subclass this class and re-implement the handle_request method.
It accepts a request and should return a reply. This server assumes utf-8 encoded
messages.
Parameters
address
str Should be of the shape hostname:port.
async bool If True, handles each incoming connection in a separate thread. This
might be advantageous if a the handle_request() method takes a long time to
execute.
verbose
bool If True, print a message each time a connection is accepted.
Notes on hostname
The hostname can be:
• The IP address, or the string hostname of this computer.
• ‘localhost’: the connections is only visible from this computer. Also
some low level networking layers are bypassed, which results in a faster
connection. The other context should also connect to ‘localhost’.
• ‘publichost’: the connection is visible by other computers on the same
network.
Internals (if you want to know more)
In yoton, the yoton.Context is the object that represents the a node in the network. The
context only handles packages. It gets packages from all its associated channels and from
the other nodes in the network. It routes packages to the other nodes, and deposits
packages in channel instances if the package slot matches the channel slot.
The yoton.Connection represents a one-to-one connection between two contexts. It handles
the low level messaging. It breaks packages into pieces and tries to send them as
efficiently as possible. It also receives bytes from the other end, and reconstructs it
into packages, which are then given to the context to handle (i.e. route). For the
yoton.TcpConnection this is all done by dedicated io threads.
Packages
Packages are simply a bunch of bytes (the encoded message), wrapped in a header. Packages
are directed at a certain slot. They also have a source id, source sequence number, and
optionally a destination id and destination sequence number (so that packages can be
replies to other packages). When a package is received, it also gets assigned a receiving
sequence number (in order to synchronize channels).
Levels of communication
Two yoton.Connection instances also communicate directly with each-other. They do this
during the handshaking procedure, obviously, but also during operation they send
each-other heart beat messages to detect time-outs. When the connection is closed in a
nice way, thet also send a close message to the other end. A package addressed directly at
the Connection has no body (consists only of a header).
Two contexts can also communicate. They do this to notify each-other of new formed
connections, closing of contexts, etc. A package directed at a context uses a special
slot.
Channel instances can also communicate. Well, that’s what yoton is all about… A sending
channels packs a message in a package and gives it to the contect. All other contexts will
receive the package and deposit it in the channel’s queue if the slots match. On
recv’ing, the message is extracted/decoded from the package.
Persistent connection
Two yoton.TcpConnection instances are connected using a single BSD-socket (TCP/IP). The
socket operates in persistent mode; once the connection is established, the socket remains
open until the connection is closed indefinetely.
Would we adopt a req/rep approach (setting up the connection for each request), failure
could mean either that the kernel is running extension code, or that the connection is
broken. It’s not possible to differentiate between the two.
On initialization of the connection, TcpConnection’s perform a small handshake procedue to
establish that both are a yoton.TcpConnection objects, and to exchange the context id’s.
There is one thread dedicated to receive data from the socket, and subsequently have the
context route the packages. Another dedicated thread gets data from a queue (of the
Connection) and sends the packages over the sockets. The sockets and queues are blocking,
but on a timeout (the receiving thread uses a select() call for this). This makes it easy
to periodically send heartbeat packages if necessary, and their absence can be detected.
In a previous design, there was a single io thread per context that did all the work. It
would run through a generator function owned by the connections to send/receive data. This
required all queueing and io to be non-blocking. After changing the design the code got
much smaller, cleaner and easier to read, and is probably more robust. We could also get
rid of several classes to buffer data, because with blocking threads the data can simply
be buffered at the queues and sockets.
Message framing
To differentiate between messages, there are two common approaches. One can add a small
header to each message that indicates how long the message is. Or one can delimit the
messages with a specific character.
In earlier designs, yoton used the second approach and was limited to sending text which
was encoded using utf-8. This meant the bytes 0xff and 0xfe could be used for delimiting.
The first approach is more complex and requires more per-message processing. However,
because the message size is know, messages can be received with much less copying of data.
This significantly improved the performance for larger messages (with the delimiting
approach we would get memory errors when Yoton tried to encode/decode the message to/from
utf-8).
The current design is such that as little data has to be copied (particularly for larger
messages).
Heart beat signals
If there is no data to send for a while, small heart beat messages are produced, so that
connection problems can be easily detected. For TCP one needs to send data in order to
detect connection problem (because no ACK’s will be received). However, the TCP timeout is
in the order of minutes and is different between OS’s. Therefore we check when the last
time was that data was received, enabling us to detect connection problems in the order of
a few seconds.
Note that when two Context’s are connected using ‘localhost’, there is no way for the
connection to be lost, as several network layers are bypassed. In such a situation, we can
therefore be sure that the reason for the timeout lies not in the connection, but is
caused for example by the process running extension code.
When the process runs extension code
With respect to client-kernel comminication: the kernel will not be able to send any data
(neither heart beat signals) if its running extension code. In such a case, the client can
still send messages; this data is transported by TCP and ends up in the network buffer
until the kernel returns from extension code and starts receiving messages again.
For this reason, in a client-kernel configuration, the kernel should always be connected
to another process via ‘localhost’, and should use a proxi/broker to connect with clients
on another box.
In that case, the client can detect that the kernel is running extension code because the
kernel stopped sending data (incl heartbeat messages).
Congestion prevention
In any communication system, there is a risk of congestion: one end sends data faster than
the other end can process it. This data can be buffered, but as the buffer fills, it
consumes more memory.
Yoton uses two approaches to solve this problem. The first (and most common) solution is
that all queues have a maximum size. When this size is reached and a new messages is
added, messages will be discarted. The user can choose whether the oldest or the newest
message should be discarted.
The second approach is only possible for the PUB/SUB channels. If the yoton.SubChannel is
put in sync-mode (using the set_sync_mode method), the yoton.SubChannel will send a
message to the corresponding PubChannels if its queue reaches a certain size. This size is
relatively small (e.g. 10-100). When a yoton.PubChannel receives the message, its send
method will block (for at most 1 second). The SubChannel sends a second message when the
queue is below a certain level again. Note that it takes a while for these control
messages to be received by the PubChannel. Therefore the actual queue size can easily grow
larger than the threshold. In this situation, the first approach (discarting messages is
still used as a failsave, but messages are very unlikely to be discarted since the
threshold is much much smaller than the maximum queue size.
An important aspect for the second approach is that the queue that buffers packages before
they are send over the socket remains small. If this is not the case, the PubChannel is
able to spam the queue with gigantic amounts of messages before the SubChannel even
receives the first message. To keep this queue small, much like the queue of the
SubChannel, it has a certain threshold. If this threshold is reached, subsequent pushes on
the queue will block for maximally 1 second. The threshold is in the same order of
magnitude as the queue for the SubChannel.
References
• http://www.unixguide.net/network/socketfaq/2.9.shtml
• http://nitoprograms.blogspot.com/2009/04/message-framing.html
• http://nitoprograms.blogspot.com/2009/05/detection-of-halfopen-dropped.html
Experiments with sockets
I performed a series on tests on bot Windows and Linux. Testing sockets on localhost and
publichost (what you get with gethostname()), for killing one of the processes, and
removing the connection (unplugging the cable).
I wanted to answer the following questions:
• When and how can we detect that the other process dropped (killed or terminated)?
• When and how can we detect connection problems?
• Can we still send data if the other end stops receiving data? And if not, can we
still detect a connection drop?
On Windows, same box
• If hosting on network level, and killing the network device, the disconnection is
immediately detected (socket.error is raised when calling send() or recv()).
• Killing either process will immediately result in an error being raised.
• This is true for hosting local or public.
• -> Therefore, when hosting on localhost (the connection cannot be lost) we do not
need a heartbeat.
On Linux, same box
• I cannot kill the connection, only the process. When I do, the other side will be
able to receive, but receives EOF (empty bytes), which looks like a nice exit. Note
that this behavior is different than on Windows.
• When the other side does not receive, I can still send huge amounts of data.
• This applies when hosting as localhost or as gethostname.
On Linux & Windows, different boxes
• When I kill the connection (remove network cable), it takes a while for either end to
see that the connection is dead. I can even put the cable back in and go on
communicating. This is a feature of TCP to be robust against network problems. See
http://www.unixguide.net/network/socketfaq/2.8.shtml
• When I keep the connection, but kill the process on either end, this is detected
immediately (in the same way as described above, depending on the OS); there’s still
low-level communication between the two boxes, and the port is detected to be
unavailable.
• On Linux I can keep sending huge amounts of data even if the other end does not
receive. On Windows I can’t. In both cases they can detect the other process
dropping.
Conclusions
• On local machine (broker-kernel), we use localhost so that we will not have network
problems. We can detect if a process drops, which is essential.
• Between boxes, we use a heartbeat signal to be able to determine whether the
connection is still there. If we set that timeout low enough (<30 sec or so) we can
even distinguish a network problem from a process crash. This should not be
necessary, however, because we can assume (I guess) that the broker and client close
nicely.
• Index
• Module Index
• Search Page
AUTHOR
Pyzo contributors
COPYRIGHT
2024, Pyzo contributors