merging master

muxer/mplex/muxed_connection.py

@@ -1,4 +1,5 @@
 from .muxed_connection_interface import IMuxedConn
+from transport.stream.Stream import Stream
 
 class MuxedConn(IMuxedConn):
     """
@@ -26,12 +27,14 @@ class MuxedConn(IMuxedConn):
         """
         pass
 
-    def open_stream(self, protocol_id, stream_name):
+    def open_stream(self, protocol_id, stream_name, peer_id, multi_addr):
         """
         creates a new muxed_stream
         :return: a new stream
         """
-        pass
+
+        return Stream(peer_id, multi_addr, self)
+
 
     def accept_stream(self):
         """

network/swarm.py

@@ -1,6 +1,6 @@
 from .network_interface import INetwork
-from ..connection.muxed_connection import MuxedConnection
+from muxer.mplex.muxed_connection import MuxedConn
-from ..connection.raw_connection import RawConnection
+from transport.connection.raw_connection import RawConnection
 
 class Swarm(INetwork):
 
@@ -41,7 +41,7 @@ class Swarm(INetwork):
                 muxed_connection = MuxedConnection(conn, True)
             else:
                 raise Exception("No IP and port in addr")
-        return muxed_connection.open_stream(protocol_id, "")
+        return muxed_connection.open_stream(protocol_id, "", peer_id, addrs)
 
     def listen(self, *args):
         """

transport/connection/raw_connection.py

@@ -3,14 +3,20 @@ from .raw_connection_interface import IRawConnection
 
 class RawConnection(IRawConnection):
 
-    def __init__(self, ip, port):
+    def __init__(self, ip, port, reader, writer):
         self.conn_ip = ip
         self.conn_port = port
-        self.reader, self.writer = self.open_connection()
+        self.reader = reader
+        self.writer = writer
 
-    async def open_connection(self):
+    # def __init__(self, ip, port):
-        """
+    #     self.conn_ip = ip
-        opens a connection on self.ip and self.port
+    #     self.conn_port = port
-        :return: a raw connection
+    #     self.reader, self.writer = self.open_connection()
-        """
+
-        return await asyncio.open_connection(self.conn_ip, self.conn_port)
+    # async def open_connection(self):
+    #     """
+    #     opens a connection on self.ip and self.port
+    #     :return: a raw connection
+    #     """
+    #     return await asyncio.open_connection(self.conn_ip, self.conn_port)

transport/connection/raw_connection_interface.py

@@ -6,10 +6,10 @@ class IRawConnection(ABC):
     open_connection should return such a connection
     """
 
-    @abstractmethod
+    # @abstractmethod
-    async def open_connection(self):
+    # async def open_connection(self):
-        """
+    #     """
-        opens a connection on ip and port
+    #     opens a connection on ip and port
-        :return: a raw connection
+    #     :return: a raw connection
-        """
+    #     """
-        pass
+    #     pass

transport/stream/stream.py

@@ -4,13 +4,17 @@ from .stream_interface import IStream
 class Stream(IStream):
 
     def __init__(self, peer_id, multi_addr, connection):
-        IStream.__init__(self, peer_id, multi_addr)
+        IStream.__init__(self, peer_id, multi_addr, connection)
         self.peer_id = peer_id
 
-        stream_ip = multi_addr.get_protocol_value("ip4")
+        self.multi_addr = multi_addr
-        stream_port = multi_addr.get_protocol_value("tcp")
+
+        self.stream_ip = multi_addr.get_protocol_value("ip4")
+        self.stream_port = multi_addr.get_protocol_value("tcp")
+
         self.reader = connection.reader
         self.writer = connection.writer
+
         # TODO should construct protocol id from constructor
         self.protocol_id = None
 

transport/tcp/tcp.py

@@ -1,6 +1,7 @@
 import asyncio
-from .transport_interface import ITransport
+from transport.transport_interface import ITransport
-from .listener_interface import IListener
+from transport.listener_interface import IListener
+from transport.connection.raw_connection import RawConnection
 
 class TCP(ITransport):
 
@@ -67,9 +68,10 @@ class TCP(ITransport):
         :return: True if successful
         """
         _multiaddr_dict = multiaddr.to_dict()
-        reader, writer = await asyncio.open_connection(_multiaddr_dict.host,\
+        host = _multiaddr_dict.host
-            _multiaddr_dict.port)
+        port = _multiaddr_dict.port
-        return False
+        reader, writer = open_conn(host, port)
+        return RawConnection(host, port, reader, writer)
         # TODO dial behavior not fully understood
 
     def create_listener(self, handler_function, options=None):
@@ -81,3 +83,7 @@ class TCP(ITransport):
         :return: a listener object that implements listener_interface.py
         """
         return self.Listener(handler_function)
+
+async def open_conn(host, port):
+    reader, writer = await asyncio.open_connection(host, port)
+    return reader, writer