Merge lp:projetrpgorleans into lp:~jordan-smagghe/projetrpgorleans/branche-jordan

[magnamaitre]

[Sami Hernandez (oceansbleus)]

ok

review: Approve

[magnamaitre (jordan-smagghe)]

review: Approve

=== added directory 'build'
=== added directory 'build/lib.linux-i686-2.7'
=== added directory 'build/lib.linux-i686-2.7/pynetez'
=== added file 'build/lib.linux-i686-2.7/pynetez/ADict.py'
--- build/lib.linux-i686-2.7/pynetez/ADict.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/ADict.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,54 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+class ADict(object):
+
+    __slots__ = ('_table_',)
+
+    def __init__(self):
+        ADict._table_.__set__(self, {})
+
+    def __getattr__(self, name):
+        return self[name]
+
+    def __setattr__(self, name, value):
+        self[name] = value
+
+    def __delattr__(self, name):
+        del self[name]
+
+    def __getitem__(self, name):
+        return self._table_[name]
+
+    def __setitem__(self, name, value):
+        self._table_[name] = value
+
+    def __delitem__(self, name):
+        del self._table_[name]
+
+    def values(self):
+        return self._table_.values()
+
+    def keys(self):
+        return self._table_.keys()
+
+    def items(self):
+        return self._table_.items()
+
+    def __contains__(self, key):
+        return key in self._table_

=== added file 'build/lib.linux-i686-2.7/pynetez/ActiveObject.py'
--- build/lib.linux-i686-2.7/pynetez/ActiveObject.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/ActiveObject.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,45 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from ActiveObjectBase import ActiveObjectBase
+from Queue import Queue
+
+class ActiveObject(ActiveObjectBase):
+    """reacts to messages received on its queue."""
+
+    def __init__(self, *args, **kargs):
+        self._queue = Queue(-1)
+        super(ActiveObject, self).__init__(*args, **kargs)
+
+    def recv(self, msg):
+        if not self.closed:
+            self._queue.put(msg)
+
+    def do(self):
+        while not self.closed:
+            msg = self._queue.get()
+            # None causes the active object to close
+            if msg is None:
+                return self.close()
+            self.react(msg)
+
+    def react(self, msg):
+        raise NotImplementedError()
+
+    def close(self):
+        super(ActiveObject, self).close()

=== added file 'build/lib.linux-i686-2.7/pynetez/ActiveObjectBase.py'
--- build/lib.linux-i686-2.7/pynetez/ActiveObjectBase.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/ActiveObjectBase.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,46 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from Activity  import Activity
+from Signal    import Signal
+from threading import RLock
+
+class ActiveObjectBase(Activity):
+    """almost an ActiveObject, but without the queue."""
+
+    def __init__(self, *args, **kargs):
+        self.eof = Signal()
+        self._rlock = RLock()
+        self._closed = False
+        super(ActiveObjectBase, self).__init__(*args, **kargs)
+
+    @property
+    def closed(self):
+        return self._closed
+
+    def close(self):
+        sig = False
+        with self._rlock:
+            if not self._closed:
+                sig = True
+                self._closed = True
+        if sig:
+            self.eof()
+
+    def __del__(self):
+        self.close()

=== added file 'build/lib.linux-i686-2.7/pynetez/Activity.py'
--- build/lib.linux-i686-2.7/pynetez/Activity.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/Activity.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,61 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from Signal import Signal
+from threading import Thread
+
+class Activity(object):
+    """abstraction for doing things on a thread."""
+
+    def __init__(self, *args, **kw):
+        self._thread = None
+        self.begin = Signal()
+        self.end = Signal()
+        self.begin.connect(self.on_begin)
+        self.end.connect(self.on_end)
+
+    def on_begin(self):
+        pass
+
+    def on_end(self):
+        pass
+
+    daemon = True
+
+    def start(self, *args, **kw):
+        """create and start a thread for doing things."""
+        self._thread = Thread(target=self._do, args=args, kwargs=kw)
+        self._thread.daemon = self.daemon
+        self._thread.start()
+
+    def _do(self, *args, **kargs):
+        self.begin()
+        try:
+            self.do(*args, **kargs)
+        finally:
+            self.end()
+
+    def do(self, *args, **kargs):
+        """method for doing things
+
+        it is invoked with whatever arguments were passed to start().
+        """
+        raise NotImplementedError()
+
+    def join(self):
+        self._thread.join()

=== added file 'build/lib.linux-i686-2.7/pynetez/Agent.py'
--- build/lib.linux-i686-2.7/pynetez/Agent.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/Agent.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,51 @@
+#==============================================================================
+# Copyright (C) 2012 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+#==============================================================================
+# For the moment, an agent is an ActiveObject associated with a Protocol and
+# with methods for reacting to messages.  Methods implementing reactions for
+# messages are also called do_XXX (where XXX is the message name).
+#==============================================================================
+
+from ActiveObject import ActiveObject
+from ADict import ADict
+
+class Agent(ActiveObject):
+
+    def __init__(self, proto, *args, **kargs):
+        super(Agent, self).__init__(*args, **kargs)
+        self._proto = proto
+        self._recv = qfun = self.recv
+        self.recv = vtable = ADict()
+        def mkmsg(mt, qfun):
+            def msg(*args):
+                qfun(mt(*args))
+            return msg
+        for mt in proto.msgtypes:
+            vtable[mt.name] = mkmsg(mt, qfun)
+
+    def react(self, msg):
+        doname = "do_%s" % msg.name
+        try:
+            dofun = getattr(self, doname)
+        except AttributeError:
+            raise NotImplementedError(doname)
+        dofun(*msg.args)
+
+    def finish(self):
+        self._recv(None)

=== added file 'build/lib.linux-i686-2.7/pynetez/Client.py'
--- build/lib.linux-i686-2.7/pynetez/Client.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/Client.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,45 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from Socket  import Socket
+
+class Client(object):
+
+    def __init__(self, protocol, sessiontype):
+        self.session = sessiontype(protocol)
+
+    def run(self, host, port, wait=True):
+        socket = Socket()
+        socket.socket()
+        socket.connect((host, port))
+        self.session.pluginto(socket)
+        self.send = self.session.send
+        self.recv = self.session.recv
+        self.finish = self.session.finish
+        self.wait = self.session.wait
+        self.session.start()
+        if wait:
+            self.session.wait()
+
+    def run_argv(self, wait=True):
+        from optparse import OptionParser
+        parser = OptionParser("usage: %prog [options]")
+        parser.add_option("--host","-H",dest="host",default="localhost")
+        parser.add_option("--port","-p",dest="port",type=int,default=9999)
+        options, args = parser.parse_args()
+        self.run(options.host, options.port, wait=wait)

=== added file 'build/lib.linux-i686-2.7/pynetez/IBuffer.py'
--- build/lib.linux-i686-2.7/pynetez/IBuffer.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/IBuffer.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,64 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+class IBuffer(object):
+    """abstraction for buffered input."""
+
+    def __init__(self, refill):
+        self._data = ""         # buffered data
+        self._offset = 0        # how much of it we have already used
+        self._refill = refill   # how to get more data
+        self._eof = False
+
+    @property
+    def size(self):
+        """how many bytes are still available in the buffer."""
+        return len(self._data) - self._offset
+
+    def _read(self, n):
+        if self._eof:
+            raise IOError("EOF")
+        m = self.size
+        if m <= 0:
+            return None
+        elif m >= n:
+            off = self._offset
+            nxt = off + n
+            self._offset = nxt
+            return self._data[off:nxt]
+        else:
+            data = self._data[self._offset:]
+            self._data = ""
+            self._offset = 0
+            return data
+
+    def read(self, n):
+        """read and return exactly n bytes from the stream."""
+        daten = []
+        while n:
+            data = self._read(n)
+            if not data:
+                self._offset = 0
+                self._data = self._refill()
+                if not self._data:
+                    self._eof = True
+                    raise IOError("EOF")
+            else:
+                daten.append(data)
+                n -= len(data)
+        return "".join(daten)

=== added file 'build/lib.linux-i686-2.7/pynetez/Protocol.py'
--- build/lib.linux-i686-2.7/pynetez/Protocol.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/Protocol.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,180 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+#===============================================================================
+# possible types of message fields.  each type knows how to un/marshal itself
+#===============================================================================
+
+class FieldType(object): pass
+
+class _uint8(FieldType):
+    def marshal(self, sock, i):
+        sock.put_uint8(i)
+    def unmarshal(self, sock):
+        return sock.get_uint8()
+uint8 = _uint8()
+
+class _uint16(FieldType):
+    def marshal(self, sock, i):
+        sock.put_int16(i)
+    def unmarshal(self, sock):
+        return sock.get_uint16()
+uint16 = _uint16()
+
+class _uint32(FieldType):
+    def marshal(self, sock, i):
+        sock.put_int32(i)
+    def unmarshal(self, sock):
+        return sock.get_uint32()
+uint32 = _uint32()
+
+class _int8(FieldType):
+    def marshal(self, sock, i):
+        sock.put_int8(i)
+    def unmarshal(self, sock):
+        return sock.get_int8()
+int8 = _int8()
+
+class _int16(FieldType):
+    def marshal(self, sock, i):
+        sock.put_int16(i)
+    def unmarshal(self, sock):
+        return sock.get_int16()
+int16 = _int16()
+
+class _int32(FieldType):
+    def marshal(self, sock, i):
+        sock.put_int32(i)
+    def unmarshal(self, sock):
+        return sock.get_int32()
+int32 = _int32()
+
+class listof(FieldType):
+    def __init__(self, typ):
+        self.elemtype = typ
+    def __cmp__(self, other):
+        return isinstance(other, listof) and \
+            self.elemtype == other.elemtype
+    def marshal(self, sock, l):
+        sock.put_uint32(len(l))
+        for x in l:
+            self.elemtype.marshal(sock, x)
+    def unmarshal(self, sock):
+        n = sock.get_uint32()
+        l = []
+        while n:
+            l.append(self.elemtype.unmarshal(sock))
+            n -= 1
+        return tuple(l)
+
+class _binary(FieldType):
+    def marshal(self, sock, b):
+        sock.put_bytes(b)
+    def unmarshal(self, sock):
+        return sock.get_bytes()
+binary = _binary()
+string = binary
+
+#===============================================================================
+# M1 = MessageType("send",0,dict(portsrc=int16,portdst=int16,data=binary))
+# m1 = M1(portsrc=2345,portdst=80,data="hello world")
+# m1.marshal(socket)
+# m2 = M1.unmarshal(socket)
+#===============================================================================
+
+class Message(object):
+
+    def __init__(self, msgtype, args):
+        self.type = msgtype
+        self.args = args
+
+    def marshal(self, sock):
+        self.type.marshal(sock, self.args)
+
+    @property
+    def name(self):
+        return self.type.name
+
+    def __getitem__(self, i):
+        return self.args[i]
+
+class MessageType(object):
+
+    def __init__(self, name, code, args):
+        self.name = name
+        self.code = code
+        if not isinstance(args, tuple):
+            args = tuple(args)
+        self.args = args
+
+    def __call__(self, *args):
+        return Message(self, args)
+
+    def marshal(self, sock, args):
+        sock.put_uint8(self.code)
+        for t,v in zip(self.args, args):
+            t.marshal(sock, v)
+
+    def unmarshal(self, sock):
+        return Message(self, tuple(t.unmarshal(sock) for t in self.args))
+
+    def writer(self, sock):
+        def msgwriter(*args):
+            self(*args).marshal(sock)
+        return msgwriter
+
+#===============================================================================
+# proto = Protocol()
+# proto.defmsgtype("send", int16, int16, binary)
+# proto.defmsgtype("ping", int32)
+# m1 = proto.message.send(2345, 80, "hello world")
+# m2 = proto.message.ping(23)
+# m1.marshal(sock)
+# m2.marshal(sock)
+# m3 = proto.unmarshal(sock)
+#===============================================================================
+
+from ADict import ADict
+
+class Protocol(object):
+
+    def __init__(self):
+        self._code = 0
+        self.message = ADict()
+
+    def defmsgtype(self, name, *args):
+        if name in self.message:
+            raise Exception("message type '%s' is already defined" % name)
+        code = self._code
+        self._code += 1
+        self.message[code] = MessageType(name, code, args)
+
+    define = defmsgtype
+
+    @property
+    def msgtypes(self):
+        return self.message.values()
+
+    def unmarshal(self, sock):
+        return self.message[sock.get_uint8()].unmarshal(sock)
+
+    def writer(self, sock):
+        protowriter = ADict()
+        for mt in self.msgtypes:
+            protowriter[mt.name] = mt.writer(sock)
+        return protowriter

=== added file 'build/lib.linux-i686-2.7/pynetez/Reader.py'
--- build/lib.linux-i686-2.7/pynetez/Reader.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/Reader.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,42 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from ActiveObjectBase import ActiveObjectBase
+from Signal import Signal
+
+class Reader(ActiveObjectBase):
+    """emits a signal for every message read on a socket."""
+
+    def __init__(self, socket):
+        super(Reader, self).__init__()
+        self.socket = socket
+        self.send = Signal()
+
+    def do(self):
+        while not self.closed:
+            try:
+                msg = self.read()
+            except IOError:
+                self.close()
+                return
+            self.send(msg)
+
+    # you need to reimplement this method
+    # to deserialize a message from the socket
+    def read(self):
+        raise NotImplementedError()

=== added file 'build/lib.linux-i686-2.7/pynetez/Server.py'
--- build/lib.linux-i686-2.7/pynetez/Server.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/Server.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,43 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from Socket import Socket
+
+class Server(object):
+
+    def __init__(self, protocol, sessiontype):
+        self._protocol = protocol
+        self._sessiontype = sessiontype
+
+    def run(self, port):
+        self._socket = Socket()
+        self._socket.socket()
+        self._socket.bind(("", port))
+        self._socket.listen(10)
+        while True:
+            sock = self._socket.accept()
+            session = self._sessiontype(self._protocol)
+            session.pluginto(sock)
+            session.start()
+
+    def run_argv(self):
+        from optparse import OptionParser
+        parser = OptionParser(usage="usage: %prog [options]")
+        parser.add_option("--port","-p",type=int,dest="port",default=9999)
+        options, args = parser.parse_args()
+        self.run(options.port)

=== added file 'build/lib.linux-i686-2.7/pynetez/Session.py'
--- build/lib.linux-i686-2.7/pynetez/Session.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/Session.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,222 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from Reader import Reader
+from Writer import Writer
+from Signal import Signal
+from socket import SHUT_RD, SHUT_WR, SHUT_RDWR
+from threading import Lock
+from Queue  import Queue
+from ActiveObjectBase import ActiveObjectBase
+
+class SessionReader(Reader):
+
+    def __init__(self, socket, protocol, react):
+        super(SessionReader, self).__init__(socket)
+        self.protocol = protocol
+        self.send.connect(react)
+
+    def read(self):
+        return self.protocol.unmarshal(self.socket)
+
+    def close(self):
+        super(SessionReader, self).close()
+        try:
+            self.socket.shutdown(SHUT_RD)
+        except:
+            pass
+
+#===============================================================================
+
+from ADict import ADict
+
+def message_and_queue(mkfun, qfun):
+    def msg(*kargs):
+        qfun(mkfun(*kargs))
+    return msg
+
+class SessionWriter(Writer):
+
+    def __init__(self, socket, protocol):
+        super(SessionWriter, self).__init__(socket)
+        self.protocol = protocol
+        self.protocolwriter = protocol.writer(socket)
+        self.message = ADict()
+        qfun = self.recv
+        for mt in protocol.msgtypes:
+            self.message[mt.name] = message_and_queue(mt, qfun)
+        
+    def write(self, msg):
+        self.protocolwriter[msg.name](*msg.args)
+
+    def close(self):
+        super(SessionWriter, self).close()
+        try:
+            self.socket.shutdown(SHUT_WR)
+        except:
+            pass
+
+#===============================================================================
+
+class SessionStarter(ActiveObjectBase):
+
+    def __init__(self, onstart):
+        super(SessionStarter, self).__init__()
+        self._onstart = onstart
+
+    def do(self):
+        self._onstart()
+
+#===============================================================================
+# s = Session(sock, proto)
+# s.message.send(portsrc=2345,portdst=80,data="hello world")
+# s.message.ping(ttl=10)
+#===============================================================================
+
+class Session(object):
+
+    async = True
+
+    def __init__(self, protocol):
+        self._protocol = protocol
+        self._lock = Lock()
+        self._reader_done = False
+        self._writer_done = False
+        self._starter_done = False
+        self._finished = False
+        self.done = Signal()
+        if not self.async:
+            self._queue = Queue(-1)
+
+    daemon = True
+
+    def pluginto(self, socket):
+        if self.async:
+            react = self.react
+        else:
+            react = self._queue.put
+        self._reader = SessionReader(socket, self._protocol, react)
+        self._writer = SessionWriter(socket, self._protocol)
+        self._starter = SessionStarter(self._on_start)
+        self._reader.daemon = self.daemon
+        self._writer.daemon = self.daemon
+        self._starter.daemon = self.daemon
+        self.message = self._writer.message
+        self.send = self.message
+        self._writer.eof.connect(self._reader.close)
+        def closing():
+            self._writer.recv(None)
+        self._reader.eof.connect(closing)
+        self._reader.end.connect(self._set_reader_done)
+        self._writer.end.connect(self._set_writer_done)
+        self._starter.end.connect(self._set_starter_done)
+        self.done.connect(socket.close)
+        #self._reader.end.connect(self.say_reader_done)
+        #self._writer.end.connect(self.say_writer_done)
+        #self._starter.end.connect(self.say_starter_done)
+        #self.done.connect(self.say_done)
+
+    #def say_done(self):
+    #    print "DONE"
+
+    #def say_reader_done(self):
+    #    print "READER DONE"
+
+    #def say_writer_done(self):
+    #    print "WRITER DONE"
+
+    #def say_starter_done(self):
+    #    print "STARTER DONE"
+
+    def _all_done(self):
+        # should only be invoked under self._lock
+        return self._reader_done and self._writer_done and self._starter_done
+
+    def _set_reader_done(self):
+        all_done = False
+        with self._lock:
+            if not self._reader_done:
+                self._reader_done = True
+                all_done = self._all_done()
+        if all_done:
+            self.done()
+
+    def _set_writer_done(self):
+        all_done = False
+        with self._lock:
+            if not self._writer_done:
+                self._writer_done = True
+                all_done = self._all_done()
+        if all_done:
+            self.done()
+
+    def _set_starter_done(self):
+        all_done = False
+        with self._lock:
+            if not self._starter_done:
+                self._starter_done = True
+                all_done = self._all_done()
+        if all_done:
+            self.done()
+
+    def start(self):
+        self._reader.start()
+        self._writer.start()
+        self._starter.start()
+
+    def _on_start(self):
+        self.on_start()
+        if not self.async:
+            self.finish()
+
+    def on_start(self):
+        pass
+
+    def finish(self):
+        doit = False
+        with self._lock:
+            if not self._finished:
+                self._finished = True
+                doit = True
+        if doit:
+            self._writer.recv(None)
+            self._reader.close()
+
+    def close(self):
+        self._reader.close()
+        self._writer.recv(None)
+        self._writer.close()
+
+    def wait(self):
+        self._starter.join()
+        self._reader.join()
+        self._writer.join()
+
+    def react(self, msg):
+        doname = "do_%s" % msg.name
+        try:
+            dofun = getattr(self, doname)
+        except AttributeError:
+            raise NotImplementedError(doname)
+        dofun(*msg.args)
+
+    def recv(self):
+        return self._queue.get()
+
+    # you must implement all the do_FOO methods for the
+    # messages (e.g. FOO) in your protocol

=== added file 'build/lib.linux-i686-2.7/pynetez/Signal.py'
--- build/lib.linux-i686-2.7/pynetez/Signal.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/Signal.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,54 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from threading import RLock
+
+class Signal(object):
+    """a Signal can be connected to slots: whenever the signal is called, all
+    the connected slots are invoked with the same arguments as the signal.
+    """
+
+    def __init__(self):
+        self._rlock = RLock()
+        self._closed = False
+        self._slots = ()
+
+    def __call__(self, *args, **kargs):
+        for s in self._slots:
+            s(*args, **kargs)
+
+    def connect(self, slot):
+        with self._rlock:
+            if not self._closed and \
+                    slot not in self._slots:
+                # update with a new tuple so that ongoing
+                # iterations don't get messed up
+                self._slots = self._slots + (slot,)
+
+    def disconnect(self, slot):
+        with self._rlock:
+            if slot in self._slots:
+                l = list(self._slots)
+                l.remove(slot)
+                self._slots = tuple(l)
+
+    def close(self):
+        with self._rlock:
+            if not self._closed:
+                self._closed = True
+                self._slots = ()

=== added file 'build/lib.linux-i686-2.7/pynetez/Socket.py'
--- build/lib.linux-i686-2.7/pynetez/Socket.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/Socket.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,324 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+import socket, struct
+from IBuffer import IBuffer
+
+class Socket(object):
+    """socket abstraction with buffering and un/marshaling methods."""
+
+    BUFSIZE = 4096
+
+    def __init__(self, sock=None):
+        self._socket = sock
+        self._buffer = IBuffer(self._refill)
+
+    def socket(self, dom=socket.AF_INET, typ=socket.SOCK_STREAM):
+        sock = socket.socket(dom, typ)
+        self._socket = sock
+
+    def accept(self):
+        return Socket(self._socket.accept()[0])
+
+    def bind(self, addr):
+        self._socket.bind(addr)
+
+    def close(self):
+        self._socket.close()
+
+    def connect(self, addr):
+        self._socket.connect(addr)
+
+    def connect_ex(self, addr):
+        return self._socket.connect_ex(addr)
+
+    def fileno(self):
+        return self._socket.fileno()
+
+    def getpeername(self):
+        return self._socket.getpeername()
+
+    def getsockname(self):
+        return self._socket.getsockname()
+
+    def getsockopt(self, *args, **kw):
+        return self._socket.getsockopt(*args, **kw)
+
+    def ioctl(self, control, option):
+        return self._socket.ioctl(control, option)
+
+    def listen(self, backlog):
+        self._socket.listen(backlog)
+
+    def makefile(self, *args, **kw):
+        return self._socket.makefile(*args, **kw)
+
+    def recv(self, bufsize, flags=0):
+        return self._socket.recv(bufsize, flags)
+
+    def recvfrom(self, bufsize, flags=0):
+        return self._socket.recv(bufsize, flags)
+
+    def recvfrom_into(self, *args, **kw):
+        return self._socket.recvfrom_into(*args, **kw)
+
+    def recv_into(self, *args, **kw):
+        return self._socket.recv_into(*args, **kw)
+
+    def send(self, string, flags=0):
+        return self._socket.send(string, flags)
+
+    def sendall(self, string, flags=0):
+        self._socket.sendall(string, flags)
+
+    def sendto(self, *args, **kw):
+        return self._socket.sendto(*args, **kw)
+
+    def setblocking(self, flag):
+        self._socket.setblocking(flag)
+
+    def settimeout(self, value):
+        self._socket.settimeout(value)
+
+    def gettimeout(self):
+        return self._socket.gettimeout()
+
+    def setsockopt(self, level, optname, value):
+        self._socket.setsockopt(level, optname, value)
+
+    def shutdown(self, how):
+        self._socket.shutdown(how)
+
+    @property
+    def family(self):
+        return self._socket.family
+
+    @property
+    def type(self):
+        return self._socket.type
+
+    @property
+    def proto(self):
+        return self._socket.proto
+
+    def _refill(self):
+        return self.recv(self.BUFSIZE)
+
+    def read(self, n):
+        return self._buffer.read(n)
+
+    def write(self, buf):
+        self.sendall(buf)
+
+    def get_uint8(self):
+        return struct.unpack("B", self.read(1))[0]
+
+    def get_uint16(self):
+        return struct.unpack("!H", self.read(2))[0]
+
+    def get_uint32(self):
+        return struct.unpack("!I", self.read(4))[0]
+
+    get_uint = get_uint32
+
+    def get_int8(self):
+        return struct.unpack("b", self.read(1))[0]
+
+    def get_int16(self):
+        return struct.unpack("!h", self.read(2))[0]
+
+    def get_int32(self):
+        return struct.unpack("!i", self.read(4))[0]
+
+    get_int = get_int32
+
+    def put_uint8(self, i):
+        self.write(struct.pack("B", i))
+
+    def put_uint16(self, i):
+        self.write(struct.pack("!H", i))
+
+    def put_uint32(self, i):
+        self.write(struct.pack("!I", i))
+
+    put_uint = put_uint32
+
+    def put_int8(self, i):
+        self.write(struct.pack("b", i))
+
+    def put_int16(self, i):
+        self.write(struct.pack("!h", i))
+
+    def put_int32(self, i):
+        self.write(struct.pack("!i", i))
+
+    def put_bytes(self, s):
+        self.put_uint32(len(s))
+        self.write(s)
+
+    def get_bytes(self):
+        n = self.get_uint32()
+        return self.read(n)
+
+
+class SocketProxy(object):
+    """abstraction for creating objects that delegate to an existing socket."""
+
+    def __init__(self, sock=None):
+        self._socket = sock
+
+    def socket(self, dom=socket.AF_INET, typ=socket.SOCK_STREAM):
+        self._socket.socket(dom, typ)
+
+    def accept(self):
+        return self._socket.accept()
+
+    def bind(self, addr):
+        self._socket.bind(addr)
+
+    def close(self):
+        self._socket.close()
+
+    def connect(self, addr):
+        self._socket.connect(addr)
+
+    def connect_ex(self, addr):
+        return self._socket.connect_ex(addr)
+
+    def fileno(self):
+        return self._socket.fileno()
+
+    def getpeername(self):
+        return self._socket.getpeername()
+
+    def getsockname(self):
+        return self._socket.getsockname()
+
+    def getsockopt(self, *args, **kw):
+        return self._socket.getsockopt(*args, **kw)
+
+    def ioctl(self, control, option):
+        return self._socket.ioctl(control, option)
+
+    def listen(self, backlog):
+        self._socket.listen(backlog)
+
+    def makefile(self, *args, **kw):
+        return self._socket.makefile(*args, **kw)
+
+    def recv(self, bufsize, flags=0):
+        return self._socket.recv(bufsize, flags)
+
+    def recvfrom(self, bufsize, flags=0):
+        return self._socket.recv(bufsize, flags)
+
+    def recvfrom_into(self, *args, **kw):
+        return self._socket.recvfrom_into(*args, **kw)
+
+    def recv_into(self, *args, **kw):
+        return self._socket.recv_into(*args, **kw)
+
+    def send(self, string, flags=0):
+        return self._socket.send(string, flags)
+
+    def sendall(self, string, flags=0):
+        self._socket.sendall(string, flags)
+
+    def sendto(self, *args, **kw):
+        return self._socket.sendto(*args, **kw)
+
+    def setblocking(self, flag):
+        self._socket.setblocking(flag)
+
+    def settimeout(self, value):
+        self._socket.settimeout(value)
+
+    def gettimeout(self):
+        return self._socket.gettimeout()
+
+    def setsockopt(self, level, optname, value):
+        self._socket.setsockopt(level, optname, value)
+
+    def shutdown(self, how):
+        self._socket.shutdown(how)
+
+    @property
+    def family(self):
+        return self._socket.family
+
+    @property
+    def type(self):
+        return self._socket.type
+
+    @property
+    def proto(self):
+        return self._socket.proto
+
+    def read(self, n):
+        return self._socket.read(n)
+
+    def write(self, buf):
+        self._socket.write(buf)
+
+    def get_uint8(self):
+        return self._socket.get_uint8()
+
+    def get_uint16(self):
+        return self._socket.get_uint16()
+
+    def get_uint32(self):
+        return self._socket.get_uint32()
+
+    get_uint = get_uint32
+
+    def get_int8(self):
+        return self._socket.get_int8()
+
+    def get_int16(self):
+        return self._socket.get_int16()
+
+    def get_int32(self):
+        return self._socket.get_int32()
+
+    get_int = get_int32
+
+    def put_uint8(self, i):
+        self._socket.put_uint8(i)
+
+    def put_uint16(self, i):
+        self._socket.put_uint16(i)
+
+    def put_uint32(self, i):
+        self._socket.put_uint32(i)
+
+    put_uint = put_uint32
+
+    def put_int8(self, i):
+        self._socket.put_int8(i)
+
+    def put_int16(self, i):
+        self._socket.put_int16(i)
+
+    def put_int32(self, i):
+        self._socket.put_int32(i)
+
+    def put_bytes(self, s):
+        self._socket.put_bytes(s)
+
+    def get_bytes(self):
+        return self._socket.get_bytes()

=== added file 'build/lib.linux-i686-2.7/pynetez/Writer.py'
--- build/lib.linux-i686-2.7/pynetez/Writer.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/Writer.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,37 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from ActiveObject import ActiveObject
+
+class Writer(ActiveObject):
+    """an active object that serializes to a socket all the messages that it receives."""
+
+    def __init__(self, socket):
+        self.socket = socket
+        super(Writer, self).__init__()
+
+    def react(self, msg):
+        try:
+            self.write(msg)
+        except IOError:
+            self.close()
+
+    # you need to reimplement this method
+    # to serialize a message to the socket
+    def write(self, msg):
+        raise NotImplementedError()

=== added file 'build/lib.linux-i686-2.7/pynetez/__init__.py'
--- build/lib.linux-i686-2.7/pynetez/__init__.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.7/pynetez/__init__.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,17 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================

=== added file 'client.py'
Binary files client.py	1970-01-01 00:00:00 +0000 and client.py	2012-06-15 10:11:52 +0000 differ
=== renamed file 'client.py' => 'client.py.moved'
=== added directory 'examples'
=== added directory 'examples/calc'
=== added file 'examples/calc/client.py'
--- examples/calc/client.py	1970-01-01 00:00:00 +0000
+++ examples/calc/client.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,64 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Client  import Client
+
+#===============================================================================
+# session and client
+#===============================================================================
+
+class SessionOnClient(Session):
+
+    def do_err(self):
+        print "ERROR"
+
+    def do_okint(self, result):
+        print result
+
+    def do_okstr(self, result):
+        print repr(result)
+
+client = Client(proto, SessionOnClient)
+client.run_argv(wait=False)
+
+#===============================================================================
+# command shell to control the above
+#===============================================================================
+
+from cmd import Cmd
+
+class Shell(Cmd):
+
+    def do_add(self, line):
+        a1, a2 = line.strip().split()
+        a1 = int(a1)
+        a2 = int(a2)
+        client.send.add(a1, a2)
+
+    def do_sub(self, line):
+        a1, a2 = line.strip().split()
+        a1 = int(a1)
+        a2 = int(a2)
+        client.send.sub(a1, a2)
+
+    def do_mul(self, line):
+        a1, a2 = line.strip().split()
+        a1 = int(a1)
+        a2 = int(a2)
+        client.send.mul(a1, a2)
+
+    def do_substr(self, line):
+        a1, a2, a3 = line.strip().split()
+        a2 = int(a2)
+        a3 = int(a3)
+        client.send.substr(a1, a2, a3)
+
+    def do_quit(self, line):
+        client.finish()
+        return True
+
+    def do_EOF(self, line):
+        return self.do_quit()
+
+shell = Shell()
+shell.cmdloop()
+client.wait()

=== added file 'examples/calc/proto.py'
--- examples/calc/proto.py	1970-01-01 00:00:00 +0000
+++ examples/calc/proto.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,10 @@
+from pynetez.Protocol import Protocol, int32, string
+
+proto = Protocol()
+proto.define("add", int32, int32)
+proto.define("sub", int32, int32)
+proto.define("mul", int32, int32)
+proto.define("substr", string, int32, int32)
+proto.define("err")
+proto.define("okint", int32)
+proto.define("okstr", string)

=== added file 'examples/calc/server.py'
--- examples/calc/server.py	1970-01-01 00:00:00 +0000
+++ examples/calc/server.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,23 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Server  import Server
+
+class SessionOnServer(Session):
+
+    def do_add(self, x, y):
+        self.send.okint(x+y)
+
+    def do_sub(self, x, y):
+        self.send.okint(x-y)
+
+    def do_mul(self, x, y):
+        self.send.okint(x*y)
+
+    def do_substr(self, s, i, j):
+        if i>=len(s) or j>len(s):
+            self.send.err()
+        else:
+            self.send.okstr(s[i:j])
+
+server = Server(proto, SessionOnServer)
+server.run_argv()

=== added directory 'examples/date'
=== added directory 'examples/date/async'
=== added file 'examples/date/async/client.py'
--- examples/date/async/client.py	1970-01-01 00:00:00 +0000
+++ examples/date/async/client.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,15 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Client  import Client
+
+class SessionOnClient(Session):
+
+    def do_tell(self, date):
+        print date
+        self.finish()
+
+    def on_start(self):
+        self.send.ask()
+
+client = Client(proto, SessionOnClient)
+client.run_argv()

=== added file 'examples/date/async/proto.py'
--- examples/date/async/proto.py	1970-01-01 00:00:00 +0000
+++ examples/date/async/proto.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,5 @@
+from pynetez.Protocol import Protocol, string
+
+proto = Protocol()
+proto.define("ask")
+proto.define("tell", string)

=== added file 'examples/date/async/server.py'
--- examples/date/async/server.py	1970-01-01 00:00:00 +0000
+++ examples/date/async/server.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,12 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Server  import Server
+import time
+
+class SessionOnServer(Session):
+
+    def do_ask(self):
+        self.send.tell(time.asctime())
+
+server = Server(proto, SessionOnServer)
+server.run_argv()

=== added directory 'examples/date/sync'
=== added file 'examples/date/sync/client.py'
--- examples/date/sync/client.py	1970-01-01 00:00:00 +0000
+++ examples/date/sync/client.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,15 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Client  import Client
+
+class SessionOnClient(Session):
+
+    async = False
+
+    def on_start(self):
+        self.send.ask()
+        m=self.recv()
+        print m[0]
+
+client = Client(proto, SessionOnClient)
+client.run_argv()

=== added file 'examples/date/sync/proto.py'
--- examples/date/sync/proto.py	1970-01-01 00:00:00 +0000
+++ examples/date/sync/proto.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,5 @@
+from pynetez.Protocol import Protocol, string
+
+proto = Protocol()
+proto.define("ask")
+proto.define("tell", string)

=== added file 'examples/date/sync/server.py'
--- examples/date/sync/server.py	1970-01-01 00:00:00 +0000
+++ examples/date/sync/server.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,12 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Server  import Server
+import time
+
+class SessionOnServer(Session):
+
+    def do_ask(self):
+        self.send.tell(time.asctime())
+
+server = Server(proto, SessionOnServer)
+server.run_argv()

=== added directory 'examples/nim'
=== added directory 'examples/nim-agent'
=== added file 'examples/nim-agent/client.py'
--- examples/nim-agent/client.py	1970-01-01 00:00:00 +0000
+++ examples/nim-agent/client.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,39 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Client  import Client
+
+class SessionOnClient(Session):
+
+    def do_go(self):
+        n = int(raw_input("Your move: "))
+        self.send.take(n)
+
+    def do_err(self):
+        print "illegal move"
+
+    def do_left(self, n):
+        print "Left:", n
+
+    def do_won(self):
+        print "You won!"
+        self.finish()
+
+    def do_lost(self):
+        print "You lost!"
+        self.finish()
+
+    def do_abort(self):
+        print "Game aborted!"
+        self.finish()
+
+    def do_pending(self):
+        print "Waiting for an opponent"
+
+    def do_connected(self):
+        print "Connected to an opponent"
+
+    def do_wait(self):
+        print "Wait for your opponent's move"
+
+client = Client(proto, SessionOnClient)
+client.run_argv()

=== added file 'examples/nim-agent/proto.py'
--- examples/nim-agent/proto.py	1970-01-01 00:00:00 +0000
+++ examples/nim-agent/proto.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,13 @@
+from pynetez.Protocol import Protocol, int8
+
+proto = Protocol()
+proto.define("pending")          # waiting to be connected to an opponent
+proto.define("connected")        # just connected to an opponent
+proto.define("go")               # your turn to play
+proto.define("wait")             # your turn to wait
+proto.define("take", int8)       # how many tokens you take
+proto.define("err")              # illegal move
+proto.define("abort")            # game aborted
+proto.define("left", int8)       # how many tokens are left
+proto.define("won")              # you just won
+proto.define("lost")             # you just lost

=== added file 'examples/nim-agent/server.py'
--- examples/nim-agent/server.py	1970-01-01 00:00:00 +0000
+++ examples/nim-agent/server.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,91 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Server  import Server
+from threading import Lock
+from pynetez.Agent import Agent
+
+from pynetez.Protocol import Protocol
+masterproto = Protocol()
+masterproto.define("play", None, None) # agent, n
+
+class GameMaster(Agent):
+
+    def __init__(self, player1, player2):
+        super(GameMaster, self).__init__(masterproto)
+        self.player1 = player1
+        self.player2 = player2
+        self.left    = 21
+        self.begin.connect(self.connected)
+
+    def connected(self):
+        self.player1.send.connected()
+        self.player2.send.connected()
+        self.player1.send.go()
+        self.player2.send.wait()
+
+    def finish(self):
+        super(GameMaster, self).finish()
+        self.player1.finish()
+        self.player2.finish()
+
+    def do_play(self, player, n):
+        if player is not self.player1:
+            # out of turn: abort game
+            self.player1.send.abort()
+            self.player2.send.abort()
+            self.finish()
+        elif n > self.left or n > 3:
+            # trying to take too much: return error and ask for new move
+            self.player1.send.err()
+            self.player1.send.go()
+        else:
+            # take n off
+            self.left -= n
+            # inform players of what's left
+            self.player1.send.left(self.left)
+            self.player2.send.left(self.left)
+            if self.left == 0:
+                # if it's a win: end game
+                self.player1.send.won()
+                self.player2.send.lost()
+                self.finish()
+            else:
+                # else switch players
+                self.switch()
+                self.player1.send.go()
+                self.player2.send.wait()
+
+    def switch(self):
+        self.player1, self.player2 = self.player2, self.player1
+
+lock = Lock()
+waiting = None
+
+class SessionOnServer(Session):
+
+    def __init__(self, *args, **kargs):
+        super(SessionOnServer, self).__init__(*args, **kargs)
+        with lock:
+            global waiting
+            if waiting is None:
+                waiting = self
+                self.startmaster = False
+            else:
+                player1 = waiting
+                waiting = None
+                player2 = self
+                gamemaster = GameMaster(player1, player2)
+                player1.master = gamemaster
+                player2.master = gamemaster
+                self.startmaster = True
+
+    def on_start(self):
+        self.send.pending()
+        if self.startmaster:
+            self.master.start()
+
+    def do_take(self, n):
+        self.master.recv.play(self, n)
+
+server = Server(proto, SessionOnServer)
+server.run_argv()

=== added file 'examples/nim/client.py'
--- examples/nim/client.py	1970-01-01 00:00:00 +0000
+++ examples/nim/client.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,39 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Client  import Client
+
+class SessionOnClient(Session):
+
+    def do_go(self):
+        n = int(raw_input("Your move: "))
+        self.send.take(n)
+
+    def do_err(self):
+        print "illegal move"
+
+    def do_left(self, n):
+        print "Left:", n
+
+    def do_won(self):
+        print "You won!"
+        self.finish()
+
+    def do_lost(self):
+        print "You lost!"
+        self.finish()
+
+    def do_abort(self):
+        print "Game aborted!"
+        self.finish()
+
+    def do_pending(self):
+        print "Waiting for an opponent"
+
+    def do_connected(self):
+        print "Connected to an opponent"
+
+    def do_wait(self):
+        print "Wait for your opponent's move"
+
+client = Client(proto, SessionOnClient)
+client.run_argv()

=== added file 'examples/nim/proto.py'
--- examples/nim/proto.py	1970-01-01 00:00:00 +0000
+++ examples/nim/proto.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,13 @@
+from pynetez.Protocol import Protocol, int8
+
+proto = Protocol()
+proto.define("pending")          # waiting to be connected to an opponent
+proto.define("connected")        # just connected to an opponent
+proto.define("go")               # your turn to play
+proto.define("wait")             # your turn to wait
+proto.define("take", int8)       # how many tokens you take
+proto.define("err")              # illegal move
+proto.define("abort")            # game aborted
+proto.define("left", int8)       # how many tokens are left
+proto.define("won")              # you just won
+proto.define("lost")             # you just lost

=== added file 'examples/nim/server.py'
--- examples/nim/server.py	1970-01-01 00:00:00 +0000
+++ examples/nim/server.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,88 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Server  import Server
+from threading import Lock
+from pynetez.ActiveObject import ActiveObject
+
+class GameMaster(ActiveObject):
+
+    def __init__(self, player1, player2):
+        super(GameMaster, self).__init__()
+        self.player1 = player1
+        self.player2 = player2
+        self.left    = 21
+        self.begin.connect(self.connected)
+
+    def connected(self):
+        self.player1.send.connected()
+        self.player2.send.connected()
+        self.player1.send.go()
+        self.player2.send.wait()
+
+    def finish(self):
+        self.recv(None)
+        self.player1.finish()
+        self.player2.finish()
+
+    def react(self, msg):
+        player, n = msg
+        if player is not self.player1:
+            # out of turn: abort game
+            self.player1.send.abort()
+            self.player2.send.abort()
+            self.finish()
+        elif n > self.left or n > 3:
+            # trying to take too much: return error and ask for new move
+            self.player1.send.err()
+            self.player1.send.go()
+        else:
+            # take n off
+            self.left -= n
+            # inform players of what's left
+            self.player1.send.left(self.left)
+            self.player2.send.left(self.left)
+            if self.left == 0:
+                # if it's a win: end game
+                self.player1.send.won()
+                self.player2.send.lost()
+                self.finish()
+            else:
+                # else switch players
+                self.switch()
+                self.player1.send.go()
+                self.player2.send.wait()
+
+    def switch(self):
+        self.player1, self.player2 = self.player2, self.player1
+
+lock = Lock()
+waiting = None
+
+class SessionOnServer(Session):
+
+    def __init__(self, *args, **kargs):
+        super(SessionOnServer, self).__init__(*args, **kargs)
+        with lock:
+            global waiting
+            if waiting is None:
+                waiting = self
+                self.startmaster = False
+            else:
+                player1 = waiting
+                waiting = None
+                player2 = self
+                gamemaster = GameMaster(player1, player2)
+                player1.master = gamemaster
+                player2.master = gamemaster
+                self.startmaster = True
+
+    def on_start(self):
+        self.send.pending()
+        if self.startmaster:
+            self.master.start()
+
+    def do_take(self, n):
+        self.master.recv((self, n))
+
+server = Server(proto, SessionOnServer)
+server.run_argv()

=== added directory 'examples/pingpong'
=== added file 'examples/pingpong/client.py'
--- examples/pingpong/client.py	1970-01-01 00:00:00 +0000
+++ examples/pingpong/client.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,15 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Client  import Client
+
+class SessionOnClient(Session):
+
+    def do_pong(self):
+        print "PONG"
+        self.finish()
+
+    def on_start(self):
+        self.send.ping()
+
+client = Client(proto, SessionOnClient)
+client.run_argv()

=== added file 'examples/pingpong/proto.py'
--- examples/pingpong/proto.py	1970-01-01 00:00:00 +0000
+++ examples/pingpong/proto.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,5 @@
+from pynetez.Protocol import Protocol
+
+proto = Protocol()
+proto.define("ping")
+proto.define("pong")

=== added file 'examples/pingpong/server.py'
--- examples/pingpong/server.py	1970-01-01 00:00:00 +0000
+++ examples/pingpong/server.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,12 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Server  import Server
+
+class SessionOnServer(Session):
+
+    def do_ping(self):
+        print "PING"
+        self.send.pong()
+
+server = Server(proto, SessionOnServer)
+server.run_argv()

=== added file 'proto.py'
--- proto.py	1970-01-01 00:00:00 +0000
+++ proto.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,33 @@
+from pynetez.Protocol import Protocol, int8
+
+proto = Protocol()
+proto.define("pending")          # waiting to be connected to an opponent
+proto.define("connected")        # just connected to an opponent
+proto.define("go")               # your turn to play
+proto.define("wait")             # your turn to wait
+proto.define("take", int8, int8, int8)       # how many tokens you take
+proto.define("err")              # illegal move
+proto.define("abort")            # game aborted
+proto.define("left", int8)       # how many tokens are left
+proto.define("won")              # you just won
+proto.define("lost")             # you just lost
+proto.define("countStory")       # counting the beginning of the story
+proto.define("action", int8, int8)
+proto.define("entree1")
+proto.define("entree2")
+proto.define("couloir")
+proto.define("fuite")
+proto.define("salleGauche")
+proto.define("salleDroite")
+proto.define("erreur")
+proto.define("salle2Droite")
+proto.define("salle1Droite")
+proto.define("Gameover")
+proto.define("salle2gauche")
+proto.define("escalier")
+proto.define("escalierMonte")
+proto.define("erreur")
+
+
+
+

=== renamed file 'proto.py' => 'proto.py.moved'
=== added directory 'pynetez'
=== added file 'pynetez/ADict.py'
--- pynetez/ADict.py	1970-01-01 00:00:00 +0000
+++ pynetez/ADict.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,54 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+class ADict(object):
+
+    __slots__ = ('_table_',)
+
+    def __init__(self):
+        ADict._table_.__set__(self, {})
+
+    def __getattr__(self, name):
+        return self[name]
+
+    def __setattr__(self, name, value):
+        self[name] = value
+
+    def __delattr__(self, name):
+        del self[name]
+
+    def __getitem__(self, name):
+        return self._table_[name]
+
+    def __setitem__(self, name, value):
+        self._table_[name] = value
+
+    def __delitem__(self, name):
+        del self._table_[name]
+
+    def values(self):
+        return self._table_.values()
+
+    def keys(self):
+        return self._table_.keys()
+
+    def items(self):
+        return self._table_.items()
+
+    def __contains__(self, key):
+        return key in self._table_

=== added file 'pynetez/ActiveObject.py'
--- pynetez/ActiveObject.py	1970-01-01 00:00:00 +0000
+++ pynetez/ActiveObject.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,45 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from ActiveObjectBase import ActiveObjectBase
+from Queue import Queue
+
+class ActiveObject(ActiveObjectBase):
+    """reacts to messages received on its queue."""
+
+    def __init__(self, *args, **kargs):
+        self._queue = Queue(-1)
+        super(ActiveObject, self).__init__(*args, **kargs)
+
+    def recv(self, msg):
+        if not self.closed:
+            self._queue.put(msg)
+
+    def do(self):
+        while not self.closed:
+            msg = self._queue.get()
+            # None causes the active object to close
+            if msg is None:
+                return self.close()
+            self.react(msg)
+
+    def react(self, msg):
+        raise NotImplementedError()
+
+    def close(self):
+        super(ActiveObject, self).close()

=== added file 'pynetez/ActiveObjectBase.py'
--- pynetez/ActiveObjectBase.py	1970-01-01 00:00:00 +0000
+++ pynetez/ActiveObjectBase.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,46 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from Activity  import Activity
+from Signal    import Signal
+from threading import RLock
+
+class ActiveObjectBase(Activity):
+    """almost an ActiveObject, but without the queue."""
+
+    def __init__(self, *args, **kargs):
+        self.eof = Signal()
+        self._rlock = RLock()
+        self._closed = False
+        super(ActiveObjectBase, self).__init__(*args, **kargs)
+
+    @property
+    def closed(self):
+        return self._closed
+
+    def close(self):
+        sig = False
+        with self._rlock:
+            if not self._closed:
+                sig = True
+                self._closed = True
+        if sig:
+            self.eof()
+
+    def __del__(self):
+        self.close()

=== added file 'pynetez/Activity.py'
--- pynetez/Activity.py	1970-01-01 00:00:00 +0000
+++ pynetez/Activity.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,61 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from Signal import Signal
+from threading import Thread
+
+class Activity(object):
+    """abstraction for doing things on a thread."""
+
+    def __init__(self, *args, **kw):
+        self._thread = None
+        self.begin = Signal()
+        self.end = Signal()
+        self.begin.connect(self.on_begin)
+        self.end.connect(self.on_end)
+
+    def on_begin(self):
+        pass
+
+    def on_end(self):
+        pass
+
+    daemon = True
+
+    def start(self, *args, **kw):
+        """create and start a thread for doing things."""
+        self._thread = Thread(target=self._do, args=args, kwargs=kw)
+        self._thread.daemon = self.daemon
+        self._thread.start()
+
+    def _do(self, *args, **kargs):
+        self.begin()
+        try:
+            self.do(*args, **kargs)
+        finally:
+            self.end()
+
+    def do(self, *args, **kargs):
+        """method for doing things
+
+        it is invoked with whatever arguments were passed to start().
+        """
+        raise NotImplementedError()
+
+    def join(self):
+        self._thread.join()

=== added file 'pynetez/Agent.py'
--- pynetez/Agent.py	1970-01-01 00:00:00 +0000
+++ pynetez/Agent.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,51 @@
+#==============================================================================
+# Copyright (C) 2012 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+#==============================================================================
+# For the moment, an agent is an ActiveObject associated with a Protocol and
+# with methods for reacting to messages.  Methods implementing reactions for
+# messages are also called do_XXX (where XXX is the message name).
+#==============================================================================
+
+from ActiveObject import ActiveObject
+from ADict import ADict
+
+class Agent(ActiveObject):
+
+    def __init__(self, proto, *args, **kargs):
+        super(Agent, self).__init__(*args, **kargs)
+        self._proto = proto
+        self._recv = qfun = self.recv
+        self.recv = vtable = ADict()
+        def mkmsg(mt, qfun):
+            def msg(*args):
+                qfun(mt(*args))
+            return msg
+        for mt in proto.msgtypes:
+            vtable[mt.name] = mkmsg(mt, qfun)
+
+    def react(self, msg):
+        doname = "do_%s" % msg.name
+        try:
+            dofun = getattr(self, doname)
+        except AttributeError:
+            raise NotImplementedError(doname)
+        dofun(*msg.args)
+
+    def finish(self):
+        self._recv(None)

=== added file 'pynetez/Client.py'
--- pynetez/Client.py	1970-01-01 00:00:00 +0000
+++ pynetez/Client.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,45 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from Socket  import Socket
+
+class Client(object):
+
+    def __init__(self, protocol, sessiontype):
+        self.session = sessiontype(protocol)
+
+    def run(self, host, port, wait=True):
+        socket = Socket()
+        socket.socket()
+        socket.connect((host, port))
+        self.session.pluginto(socket)
+        self.send = self.session.send
+        self.recv = self.session.recv
+        self.finish = self.session.finish
+        self.wait = self.session.wait
+        self.session.start()
+        if wait:
+            self.session.wait()
+
+    def run_argv(self, wait=True):
+        from optparse import OptionParser
+        parser = OptionParser("usage: %prog [options]")
+        parser.add_option("--host","-H",dest="host",default="localhost")
+        parser.add_option("--port","-p",dest="port",type=int,default=9999)
+        options, args = parser.parse_args()
+        self.run(options.host, options.port, wait=wait)

=== added file 'pynetez/IBuffer.py'
--- pynetez/IBuffer.py	1970-01-01 00:00:00 +0000
+++ pynetez/IBuffer.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,64 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+class IBuffer(object):
+    """abstraction for buffered input."""
+
+    def __init__(self, refill):
+        self._data = ""         # buffered data
+        self._offset = 0        # how much of it we have already used
+        self._refill = refill   # how to get more data
+        self._eof = False
+
+    @property
+    def size(self):
+        """how many bytes are still available in the buffer."""
+        return len(self._data) - self._offset
+
+    def _read(self, n):
+        if self._eof:
+            raise IOError("EOF")
+        m = self.size
+        if m <= 0:
+            return None
+        elif m >= n:
+            off = self._offset
+            nxt = off + n
+            self._offset = nxt
+            return self._data[off:nxt]
+        else:
+            data = self._data[self._offset:]
+            self._data = ""
+            self._offset = 0
+            return data
+
+    def read(self, n):
+        """read and return exactly n bytes from the stream."""
+        daten = []
+        while n:
+            data = self._read(n)
+            if not data:
+                self._offset = 0
+                self._data = self._refill()
+                if not self._data:
+                    self._eof = True
+                    raise IOError("EOF")
+            else:
+                daten.append(data)
+                n -= len(data)
+        return "".join(daten)

=== added file 'pynetez/Protocol.py'
--- pynetez/Protocol.py	1970-01-01 00:00:00 +0000
+++ pynetez/Protocol.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,180 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+#===============================================================================
+# possible types of message fields.  each type knows how to un/marshal itself
+#===============================================================================
+
+class FieldType(object): pass
+
+class _uint8(FieldType):
+    def marshal(self, sock, i):
+        sock.put_uint8(i)
+    def unmarshal(self, sock):
+        return sock.get_uint8()
+uint8 = _uint8()
+
+class _uint16(FieldType):
+    def marshal(self, sock, i):
+        sock.put_int16(i)
+    def unmarshal(self, sock):
+        return sock.get_uint16()
+uint16 = _uint16()
+
+class _uint32(FieldType):
+    def marshal(self, sock, i):
+        sock.put_int32(i)
+    def unmarshal(self, sock):
+        return sock.get_uint32()
+uint32 = _uint32()
+
+class _int8(FieldType):
+    def marshal(self, sock, i):
+        sock.put_int8(i)
+    def unmarshal(self, sock):
+        return sock.get_int8()
+int8 = _int8()
+
+class _int16(FieldType):
+    def marshal(self, sock, i):
+        sock.put_int16(i)
+    def unmarshal(self, sock):
+        return sock.get_int16()
+int16 = _int16()
+
+class _int32(FieldType):
+    def marshal(self, sock, i):
+        sock.put_int32(i)
+    def unmarshal(self, sock):
+        return sock.get_int32()
+int32 = _int32()
+
+class listof(FieldType):
+    def __init__(self, typ):
+        self.elemtype = typ
+    def __cmp__(self, other):
+        return isinstance(other, listof) and \
+            self.elemtype == other.elemtype
+    def marshal(self, sock, l):
+        sock.put_uint32(len(l))
+        for x in l:
+            self.elemtype.marshal(sock, x)
+    def unmarshal(self, sock):
+        n = sock.get_uint32()
+        l = []
+        while n:
+            l.append(self.elemtype.unmarshal(sock))
+            n -= 1
+        return tuple(l)
+
+class _binary(FieldType):
+    def marshal(self, sock, b):
+        sock.put_bytes(b)
+    def unmarshal(self, sock):
+        return sock.get_bytes()
+binary = _binary()
+string = binary
+
+#===============================================================================
+# M1 = MessageType("send",0,dict(portsrc=int16,portdst=int16,data=binary))
+# m1 = M1(portsrc=2345,portdst=80,data="hello world")
+# m1.marshal(socket)
+# m2 = M1.unmarshal(socket)
+#===============================================================================
+
+class Message(object):
+
+    def __init__(self, msgtype, args):
+        self.type = msgtype
+        self.args = args
+
+    def marshal(self, sock):
+        self.type.marshal(sock, self.args)
+
+    @property
+    def name(self):
+        return self.type.name
+
+    def __getitem__(self, i):
+        return self.args[i]
+
+class MessageType(object):
+
+    def __init__(self, name, code, args):
+        self.name = name
+        self.code = code
+        if not isinstance(args, tuple):
+            args = tuple(args)
+        self.args = args
+
+    def __call__(self, *args):
+        return Message(self, args)
+
+    def marshal(self, sock, args):
+        sock.put_uint8(self.code)
+        for t,v in zip(self.args, args):
+            t.marshal(sock, v)
+
+    def unmarshal(self, sock):
+        return Message(self, tuple(t.unmarshal(sock) for t in self.args))
+
+    def writer(self, sock):
+        def msgwriter(*args):
+            self(*args).marshal(sock)
+        return msgwriter
+
+#===============================================================================
+# proto = Protocol()
+# proto.defmsgtype("send", int16, int16, binary)
+# proto.defmsgtype("ping", int32)
+# m1 = proto.message.send(2345, 80, "hello world")
+# m2 = proto.message.ping(23)
+# m1.marshal(sock)
+# m2.marshal(sock)
+# m3 = proto.unmarshal(sock)
+#===============================================================================
+
+from ADict import ADict
+
+class Protocol(object):
+
+    def __init__(self):
+        self._code = 0
+        self.message = ADict()
+
+    def defmsgtype(self, name, *args):
+        if name in self.message:
+            raise Exception("message type '%s' is already defined" % name)
+        code = self._code
+        self._code += 1
+        self.message[code] = MessageType(name, code, args)
+
+    define = defmsgtype
+
+    @property
+    def msgtypes(self):
+        return self.message.values()
+
+    def unmarshal(self, sock):
+        return self.message[sock.get_uint8()].unmarshal(sock)
+
+    def writer(self, sock):
+        protowriter = ADict()
+        for mt in self.msgtypes:
+            protowriter[mt.name] = mt.writer(sock)
+        return protowriter

=== added file 'pynetez/Reader.py'
--- pynetez/Reader.py	1970-01-01 00:00:00 +0000
+++ pynetez/Reader.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,42 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from ActiveObjectBase import ActiveObjectBase
+from Signal import Signal
+
+class Reader(ActiveObjectBase):
+    """emits a signal for every message read on a socket."""
+
+    def __init__(self, socket):
+        super(Reader, self).__init__()
+        self.socket = socket
+        self.send = Signal()
+
+    def do(self):
+        while not self.closed:
+            try:
+                msg = self.read()
+            except IOError:
+                self.close()
+                return
+            self.send(msg)
+
+    # you need to reimplement this method
+    # to deserialize a message from the socket
+    def read(self):
+        raise NotImplementedError()

=== added file 'pynetez/Server.py'
--- pynetez/Server.py	1970-01-01 00:00:00 +0000
+++ pynetez/Server.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,43 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from Socket import Socket
+
+class Server(object):
+
+    def __init__(self, protocol, sessiontype):
+        self._protocol = protocol
+        self._sessiontype = sessiontype
+
+    def run(self, port):
+        self._socket = Socket()
+        self._socket.socket()
+        self._socket.bind(("", port))
+        self._socket.listen(10)
+        while True:
+            sock = self._socket.accept()
+            session = self._sessiontype(self._protocol)
+            session.pluginto(sock)
+            session.start()
+
+    def run_argv(self):
+        from optparse import OptionParser
+        parser = OptionParser(usage="usage: %prog [options]")
+        parser.add_option("--port","-p",type=int,dest="port",default=9999)
+        options, args = parser.parse_args()
+        self.run(options.port)

=== added file 'pynetez/Session.py'
--- pynetez/Session.py	1970-01-01 00:00:00 +0000
+++ pynetez/Session.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,222 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from Reader import Reader
+from Writer import Writer
+from Signal import Signal
+from socket import SHUT_RD, SHUT_WR, SHUT_RDWR
+from threading import Lock
+from Queue  import Queue
+from ActiveObjectBase import ActiveObjectBase
+
+class SessionReader(Reader):
+
+    def __init__(self, socket, protocol, react):
+        super(SessionReader, self).__init__(socket)
+        self.protocol = protocol
+        self.send.connect(react)
+
+    def read(self):
+        return self.protocol.unmarshal(self.socket)
+
+    def close(self):
+        super(SessionReader, self).close()
+        try:
+            self.socket.shutdown(SHUT_RD)
+        except:
+            pass
+
+#===============================================================================
+
+from ADict import ADict
+
+def message_and_queue(mkfun, qfun):
+    def msg(*kargs):
+        qfun(mkfun(*kargs))
+    return msg
+
+class SessionWriter(Writer):
+
+    def __init__(self, socket, protocol):
+        super(SessionWriter, self).__init__(socket)
+        self.protocol = protocol
+        self.protocolwriter = protocol.writer(socket)
+        self.message = ADict()
+        qfun = self.recv
+        for mt in protocol.msgtypes:
+            self.message[mt.name] = message_and_queue(mt, qfun)
+        
+    def write(self, msg):
+        self.protocolwriter[msg.name](*msg.args)
+
+    def close(self):
+        super(SessionWriter, self).close()
+        try:
+            self.socket.shutdown(SHUT_WR)
+        except:
+            pass
+
+#===============================================================================
+
+class SessionStarter(ActiveObjectBase):
+
+    def __init__(self, onstart):
+        super(SessionStarter, self).__init__()
+        self._onstart = onstart
+
+    def do(self):
+        self._onstart()
+
+#===============================================================================
+# s = Session(sock, proto)
+# s.message.send(portsrc=2345,portdst=80,data="hello world")
+# s.message.ping(ttl=10)
+#===============================================================================
+
+class Session(object):
+
+    async = True
+
+    def __init__(self, protocol):
+        self._protocol = protocol
+        self._lock = Lock()
+        self._reader_done = False
+        self._writer_done = False
+        self._starter_done = False
+        self._finished = False
+        self.done = Signal()
+        if not self.async:
+            self._queue = Queue(-1)
+
+    daemon = True
+
+    def pluginto(self, socket):
+        if self.async:
+            react = self.react
+        else:
+            react = self._queue.put
+        self._reader = SessionReader(socket, self._protocol, react)
+        self._writer = SessionWriter(socket, self._protocol)
+        self._starter = SessionStarter(self._on_start)
+        self._reader.daemon = self.daemon
+        self._writer.daemon = self.daemon
+        self._starter.daemon = self.daemon
+        self.message = self._writer.message
+        self.send = self.message
+        self._writer.eof.connect(self._reader.close)
+        def closing():
+            self._writer.recv(None)
+        self._reader.eof.connect(closing)
+        self._reader.end.connect(self._set_reader_done)
+        self._writer.end.connect(self._set_writer_done)
+        self._starter.end.connect(self._set_starter_done)
+        self.done.connect(socket.close)
+        #self._reader.end.connect(self.say_reader_done)
+        #self._writer.end.connect(self.say_writer_done)
+        #self._starter.end.connect(self.say_starter_done)
+        #self.done.connect(self.say_done)
+
+    #def say_done(self):
+    #    print "DONE"
+
+    #def say_reader_done(self):
+    #    print "READER DONE"
+
+    #def say_writer_done(self):
+    #    print "WRITER DONE"
+
+    #def say_starter_done(self):
+    #    print "STARTER DONE"
+
+    def _all_done(self):
+        # should only be invoked under self._lock
+        return self._reader_done and self._writer_done and self._starter_done
+
+    def _set_reader_done(self):
+        all_done = False
+        with self._lock:
+            if not self._reader_done:
+                self._reader_done = True
+                all_done = self._all_done()
+        if all_done:
+            self.done()
+
+    def _set_writer_done(self):
+        all_done = False
+        with self._lock:
+            if not self._writer_done:
+                self._writer_done = True
+                all_done = self._all_done()
+        if all_done:
+            self.done()
+
+    def _set_starter_done(self):
+        all_done = False
+        with self._lock:
+            if not self._starter_done:
+                self._starter_done = True
+                all_done = self._all_done()
+        if all_done:
+            self.done()
+
+    def start(self):
+        self._reader.start()
+        self._writer.start()
+        self._starter.start()
+
+    def _on_start(self):
+        self.on_start()
+        if not self.async:
+            self.finish()
+
+    def on_start(self):
+        pass
+
+    def finish(self):
+        doit = False
+        with self._lock:
+            if not self._finished:
+                self._finished = True
+                doit = True
+        if doit:
+            self._writer.recv(None)
+            self._reader.close()
+
+    def close(self):
+        self._reader.close()
+        self._writer.recv(None)
+        self._writer.close()
+
+    def wait(self):
+        self._starter.join()
+        self._reader.join()
+        self._writer.join()
+
+    def react(self, msg):
+        doname = "do_%s" % msg.name
+        try:
+            dofun = getattr(self, doname)
+        except AttributeError:
+            raise NotImplementedError(doname)
+        dofun(*msg.args)
+
+    def recv(self):
+        return self._queue.get()
+
+    # you must implement all the do_FOO methods for the
+    # messages (e.g. FOO) in your protocol

=== added file 'pynetez/Signal.py'
--- pynetez/Signal.py	1970-01-01 00:00:00 +0000
+++ pynetez/Signal.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,54 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from threading import RLock
+
+class Signal(object):
+    """a Signal can be connected to slots: whenever the signal is called, all
+    the connected slots are invoked with the same arguments as the signal.
+    """
+
+    def __init__(self):
+        self._rlock = RLock()
+        self._closed = False
+        self._slots = ()
+
+    def __call__(self, *args, **kargs):
+        for s in self._slots:
+            s(*args, **kargs)
+
+    def connect(self, slot):
+        with self._rlock:
+            if not self._closed and \
+                    slot not in self._slots:
+                # update with a new tuple so that ongoing
+                # iterations don't get messed up
+                self._slots = self._slots + (slot,)
+
+    def disconnect(self, slot):
+        with self._rlock:
+            if slot in self._slots:
+                l = list(self._slots)
+                l.remove(slot)
+                self._slots = tuple(l)
+
+    def close(self):
+        with self._rlock:
+            if not self._closed:
+                self._closed = True
+                self._slots = ()

=== added file 'pynetez/Socket.py'
--- pynetez/Socket.py	1970-01-01 00:00:00 +0000
+++ pynetez/Socket.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,324 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+import socket, struct
+from IBuffer import IBuffer
+
+class Socket(object):
+    """socket abstraction with buffering and un/marshaling methods."""
+
+    BUFSIZE = 4096
+
+    def __init__(self, sock=None):
+        self._socket = sock
+        self._buffer = IBuffer(self._refill)
+
+    def socket(self, dom=socket.AF_INET, typ=socket.SOCK_STREAM):
+        sock = socket.socket(dom, typ)
+        self._socket = sock
+
+    def accept(self):
+        return Socket(self._socket.accept()[0])
+
+    def bind(self, addr):
+        self._socket.bind(addr)
+
+    def close(self):
+        self._socket.close()
+
+    def connect(self, addr):
+        self._socket.connect(addr)
+
+    def connect_ex(self, addr):
+        return self._socket.connect_ex(addr)
+
+    def fileno(self):
+        return self._socket.fileno()
+
+    def getpeername(self):
+        return self._socket.getpeername()
+
+    def getsockname(self):
+        return self._socket.getsockname()
+
+    def getsockopt(self, *args, **kw):
+        return self._socket.getsockopt(*args, **kw)
+
+    def ioctl(self, control, option):
+        return self._socket.ioctl(control, option)
+
+    def listen(self, backlog):
+        self._socket.listen(backlog)
+
+    def makefile(self, *args, **kw):
+        return self._socket.makefile(*args, **kw)
+
+    def recv(self, bufsize, flags=0):
+        return self._socket.recv(bufsize, flags)
+
+    def recvfrom(self, bufsize, flags=0):
+        return self._socket.recv(bufsize, flags)
+
+    def recvfrom_into(self, *args, **kw):
+        return self._socket.recvfrom_into(*args, **kw)
+
+    def recv_into(self, *args, **kw):
+        return self._socket.recv_into(*args, **kw)
+
+    def send(self, string, flags=0):
+        return self._socket.send(string, flags)
+
+    def sendall(self, string, flags=0):
+        self._socket.sendall(string, flags)
+
+    def sendto(self, *args, **kw):
+        return self._socket.sendto(*args, **kw)
+
+    def setblocking(self, flag):
+        self._socket.setblocking(flag)
+
+    def settimeout(self, value):
+        self._socket.settimeout(value)
+
+    def gettimeout(self):
+        return self._socket.gettimeout()
+
+    def setsockopt(self, level, optname, value):
+        self._socket.setsockopt(level, optname, value)
+
+    def shutdown(self, how):
+        self._socket.shutdown(how)
+
+    @property
+    def family(self):
+        return self._socket.family
+
+    @property
+    def type(self):
+        return self._socket.type
+
+    @property
+    def proto(self):
+        return self._socket.proto
+
+    def _refill(self):
+        return self.recv(self.BUFSIZE)
+
+    def read(self, n):
+        return self._buffer.read(n)
+
+    def write(self, buf):
+        self.sendall(buf)
+
+    def get_uint8(self):
+        return struct.unpack("B", self.read(1))[0]
+
+    def get_uint16(self):
+        return struct.unpack("!H", self.read(2))[0]
+
+    def get_uint32(self):
+        return struct.unpack("!I", self.read(4))[0]
+
+    get_uint = get_uint32
+
+    def get_int8(self):
+        return struct.unpack("b", self.read(1))[0]
+
+    def get_int16(self):
+        return struct.unpack("!h", self.read(2))[0]
+
+    def get_int32(self):
+        return struct.unpack("!i", self.read(4))[0]
+
+    get_int = get_int32
+
+    def put_uint8(self, i):
+        self.write(struct.pack("B", i))
+
+    def put_uint16(self, i):
+        self.write(struct.pack("!H", i))
+
+    def put_uint32(self, i):
+        self.write(struct.pack("!I", i))
+
+    put_uint = put_uint32
+
+    def put_int8(self, i):
+        self.write(struct.pack("b", i))
+
+    def put_int16(self, i):
+        self.write(struct.pack("!h", i))
+
+    def put_int32(self, i):
+        self.write(struct.pack("!i", i))
+
+    def put_bytes(self, s):
+        self.put_uint32(len(s))
+        self.write(s)
+
+    def get_bytes(self):
+        n = self.get_uint32()
+        return self.read(n)
+
+
+class SocketProxy(object):
+    """abstraction for creating objects that delegate to an existing socket."""
+
+    def __init__(self, sock=None):
+        self._socket = sock
+
+    def socket(self, dom=socket.AF_INET, typ=socket.SOCK_STREAM):
+        self._socket.socket(dom, typ)
+
+    def accept(self):
+        return self._socket.accept()
+
+    def bind(self, addr):
+        self._socket.bind(addr)
+
+    def close(self):
+        self._socket.close()
+
+    def connect(self, addr):
+        self._socket.connect(addr)
+
+    def connect_ex(self, addr):
+        return self._socket.connect_ex(addr)
+
+    def fileno(self):
+        return self._socket.fileno()
+
+    def getpeername(self):
+        return self._socket.getpeername()
+
+    def getsockname(self):
+        return self._socket.getsockname()
+
+    def getsockopt(self, *args, **kw):
+        return self._socket.getsockopt(*args, **kw)
+
+    def ioctl(self, control, option):
+        return self._socket.ioctl(control, option)
+
+    def listen(self, backlog):
+        self._socket.listen(backlog)
+
+    def makefile(self, *args, **kw):
+        return self._socket.makefile(*args, **kw)
+
+    def recv(self, bufsize, flags=0):
+        return self._socket.recv(bufsize, flags)
+
+    def recvfrom(self, bufsize, flags=0):
+        return self._socket.recv(bufsize, flags)
+
+    def recvfrom_into(self, *args, **kw):
+        return self._socket.recvfrom_into(*args, **kw)
+
+    def recv_into(self, *args, **kw):
+        return self._socket.recv_into(*args, **kw)
+
+    def send(self, string, flags=0):
+        return self._socket.send(string, flags)
+
+    def sendall(self, string, flags=0):
+        self._socket.sendall(string, flags)
+
+    def sendto(self, *args, **kw):
+        return self._socket.sendto(*args, **kw)
+
+    def setblocking(self, flag):
+        self._socket.setblocking(flag)
+
+    def settimeout(self, value):
+        self._socket.settimeout(value)
+
+    def gettimeout(self):
+        return self._socket.gettimeout()
+
+    def setsockopt(self, level, optname, value):
+        self._socket.setsockopt(level, optname, value)
+
+    def shutdown(self, how):
+        self._socket.shutdown(how)
+
+    @property
+    def family(self):
+        return self._socket.family
+
+    @property
+    def type(self):
+        return self._socket.type
+
+    @property
+    def proto(self):
+        return self._socket.proto
+
+    def read(self, n):
+        return self._socket.read(n)
+
+    def write(self, buf):
+        self._socket.write(buf)
+
+    def get_uint8(self):
+        return self._socket.get_uint8()
+
+    def get_uint16(self):
+        return self._socket.get_uint16()
+
+    def get_uint32(self):
+        return self._socket.get_uint32()
+
+    get_uint = get_uint32
+
+    def get_int8(self):
+        return self._socket.get_int8()
+
+    def get_int16(self):
+        return self._socket.get_int16()
+
+    def get_int32(self):
+        return self._socket.get_int32()
+
+    get_int = get_int32
+
+    def put_uint8(self, i):
+        self._socket.put_uint8(i)
+
+    def put_uint16(self, i):
+        self._socket.put_uint16(i)
+
+    def put_uint32(self, i):
+        self._socket.put_uint32(i)
+
+    put_uint = put_uint32
+
+    def put_int8(self, i):
+        self._socket.put_int8(i)
+
+    def put_int16(self, i):
+        self._socket.put_int16(i)
+
+    def put_int32(self, i):
+        self._socket.put_int32(i)
+
+    def put_bytes(self, s):
+        self._socket.put_bytes(s)
+
+    def get_bytes(self):
+        return self._socket.get_bytes()

=== added file 'pynetez/Writer.py'
--- pynetez/Writer.py	1970-01-01 00:00:00 +0000
+++ pynetez/Writer.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,37 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================
+
+from ActiveObject import ActiveObject
+
+class Writer(ActiveObject):
+    """an active object that serializes to a socket all the messages that it receives."""
+
+    def __init__(self, socket):
+        self.socket = socket
+        super(Writer, self).__init__()
+
+    def react(self, msg):
+        try:
+            self.write(msg)
+        except IOError:
+            self.close()
+
+    # you need to reimplement this method
+    # to serialize a message to the socket
+    def write(self, msg):
+        raise NotImplementedError()

=== added file 'pynetez/__init__.py'
--- pynetez/__init__.py	1970-01-01 00:00:00 +0000
+++ pynetez/__init__.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,17 @@
+#==============================================================================
+# Copyright (C) 2011 by Denys Duchier
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#==============================================================================

=== added file 'server.py'
--- server.py	1970-01-01 00:00:00 +0000
+++ server.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,227 @@
+from proto import proto
+from pynetez.Session import Session
+from pynetez.Server  import Server
+from threading import Lock
+from pynetez.Agent import Agent
+
+from pynetez.Protocol import Protocol
+masterproto = Protocol()
+masterproto.define("play", None, None) # agent, n
+
+variable = 0
+variable2 = 0
+
+class GameMaster(Agent):
+
+    def __init__(self, player1, player2):
+        super(GameMaster, self).__init__(masterproto)
+        self.player1 = player1
+        self.player2 = player2
+        self.begin.connect(self.connected)
+
+    def connected(self):
+        self.player1.send.connected()
+        self.player2.send.connected()
+        self.player1.send.countStory()
+        self.player2.send.countStory()
+        self.player1.send.action(1, 1)
+        self.player2.send.action(1, 2)
+                
+    def finish(self):
+        super(GameMaster, self).finish()
+        self.player1.finish()
+        self.player2.finish()
+
+    def do_play(self, numeroAction, player, n):
+        global variable
+        global variable2
+        if numeroAction == 1:
+            if n == 1 or n == 2:
+                if variable == 2:
+                    self.player1.send.entree2()
+                    self.player2.send.entree2()
+                    self.player1.send.couloir()
+                    self.player2.send.couloir()
+                    variable = 0
+                    self.player1.send.action(2, 1)
+                    self.player2.send.action(2, 2)
+                elif variable == 1:
+                    if n == 1:
+                        if player == 1:
+                            self.player1.send.entree1()
+                        else:
+                            self.player2.send.entree1()
+                else:
+                    if player == 1:
+                        self.player1.send.fuite()
+                        self.player1.finish()
+                    else:
+                        self.player2.send.fuite() 
+                        self.player2.finish()
+            else:
+                if player == 1:
+                    self.player1.send.erreur()
+                    self.player1.send.action(1, 1)                
+                else:
+                    self.player2.send.erreur()
+                    self.player2.send.action(1, 2)                
+        elif numeroAction == 2:
+            if n == 1 or n == 2:
+                if n == 1:
+                    if player == 1:
+                        if variable2 == 1:
+                            self.player1.send.salle2gauche()
+                            self.player1.send.escalier()
+                            self.player1.send.action(5, 1)
+                        else:
+                            self.player1.send.salleGauche()
+                            self.player1.send.action(2, 1)
+                    else:
+                        if variable2 == 1:
+                            self.player2.send.salle2gauche()
+                            self.player2.send.escalier()
+                            self.player2.send.action(5, 2)
+                        else:
+                            self.player2.send.salleGauche()
+                            self.player2.send.action(2, 2)
+                elif n == 2:
+                    if player == 1:
+                        self.player1.send.salleDroite()
+                        self.player1.send.action(3, 1)
+                    else:
+                        self.player2.send.salleDroite()
+                        self.player2.send.action(3, 2)
+            else:
+                if player == 1:
+                    self.player1.send.erreur()
+                    self.player1.send.action(2, 1)                
+                else:
+                    self.player2.send.erreur()
+                    self.player2.send.action(2, 2)
+        elif numeroAction == 3:
+            if n == 1 or n == 2 or n == 3:
+                if player == 1:
+                    if n == 1:
+                        self.player1.send.salle1Droite()
+                        self.player1.send.Gameover()
+                        self.player1.finish()
+                    elif n == 2:
+                        variable2 = 1
+                        self.player1.send.salle2Droite()
+                    elif n == 3:
+                        self.player1.send.salleGauche()
+                        self.player1.send.action(2, 1)
+                    elif player == 2:
+                        if n == 1:
+                            self.player2.send.salle1Droite()
+                            self.player2.send.Gameover()
+                            self.player2.finish()
+                        elif n == 2:
+                            variable2 = 1
+                            self.player2.send.salle2Droite()
+                        elif n == 3:
+                            self.player2.send.salleGauche()
+                            self.player2.send.action(2, 2)
+            else:
+                if player == 1:
+                    self.player1.send.erreur()
+                    self.player1.send.action(3, 1)                
+                else:
+                    self.player2.send.erreur()
+                    self.player2.send.action(3, 2)
+        elif numeroAction == 4:
+            if n == 1 and n == 2:
+                if player == 1:
+                    if n == 1:
+                        self.player1.send.salleGauche()
+                        self.player1.send.action(2, 1)
+                    else:
+                        self.player1.send.levierEnfonce()
+                else:
+                    if n == 1:
+                        self.player2.send.salleGauche()
+                        self.player2.send.action(2, 1)
+                    else:
+                        self.player2.send.levierEnfonce()
+            else:
+               if player == 1:
+                    self.player1.send.erreur()
+                    self.player1.send.action(4, 1)                
+               else:
+                    self.player2.send.erreur()
+                    self.player2.send.action(4, 2)  
+        elif numeroAction == 5:
+            if n == 1 or n == 2:
+                if player == 1:
+                    if n == 1:
+                        self.player1.send.escalierMonte()
+                        self.player1.finish()
+                        self.player2.finish()
+                    else:
+                        self.player1.finish()
+                        self.player2.finish()
+                else:
+                    if n == 1:
+                        self.player2.send.escalierMonte()
+                        self.player1.finish()
+                        self.player2.finish()
+                    else:
+                        self.player2.finish()
+                        self.player1.finish()
+            else:
+                 if player == 1:
+                    self.player1.send.erreur()
+                    self.player1.send.action(5, 1)                
+                 else:
+                    self.player2.send.erreur()
+                    self.player2.send.action(5, 2)
+
+    def switch(self):
+        self.player1, self.player2 = self.player2, self.player1
+
+lock = Lock()
+waiting = None
+
+class SessionOnServer(Session):
+
+    def __init__(self, *args, **kargs):
+        super(SessionOnServer, self).__init__(*args, **kargs)
+        with lock:
+            global waiting
+            if waiting is None:
+                waiting = self
+                self.startmaster = False
+            else:
+                player1 = waiting
+                waiting = None
+                player2 = self
+                gamemaster = GameMaster(player1, player2)
+                player1.master = gamemaster
+                player2.master = gamemaster
+                self.startmaster = True
+
+    def on_start(self):
+        self.send.pending()
+        if self.startmaster:
+            self.master.start()
+
+    def do_take(self, numeroAction, player, n):
+        global variable
+        if numeroAction == 1 and n == 2:
+            variable = 0
+        else:
+            if numeroAction == 1 and n == 1:
+                variable = variable + 1   
+        if numeroAction == 1:
+            self.master.recv.play(numeroAction, player, n)
+        elif numeroAction == 2:
+            self.master.recv.play(numeroAction, player, n)
+        elif numeroAction == 3:
+            self.master.recv.play(numeroAction, player, n)
+        elif numeroAction == 4:
+            self.master.recv.play(numeroAction, player, n)    
+        elif numeroAction == 5:
+            self.master.recv.play(numeroAction, player, n)        
+        
+server = Server(proto, SessionOnServer)
+server.run_argv()

=== renamed file 'server.py' => 'server.py.moved'
=== added file 'setup.py'
--- setup.py	1970-01-01 00:00:00 +0000
+++ setup.py	2012-06-15 10:11:52 +0000
@@ -0,0 +1,8 @@
+from distutils.core import setup
+
+setup(name="pynetez",
+      description="A Python client/server library",
+      author="Denys Duchier",
+      author_email="[e-mail]",
+      version="2.1",
+      packages=["pynetez"])