reworking listener, connectoin, etc

Author: thatstoasty

gojo/net/__init__.mojo

@@ -6,6 +6,7 @@ A good chunk of the leg work here came from the lightbug_http project! https://g
 from .fd import FileDescriptor
 from .socket import Socket
 from .tcp import TCPConnection, TCPListener, listen_tcp, dial_tcp, TCPAddr
+from .udp import UDPAddr
 from .address import NetworkType, Addr
 from .ip import get_ip_address, get_addr_info
 from .dial import Dialer

gojo/net/address.mojo

@@ -16,18 +16,36 @@ struct NetworkType:
 
 
 trait Addr(CollectionElement, Stringable):
-    fn __init__(inout self):
-        ...
-
     fn network(self) -> String:
         """Name of the network (for example, "tcp", "udp")."""
         ...
 
 
-fn resolve_internet_addr(network: String, address: String) raises -> TCPAddr:
+@value
+struct BaseAddr:
+    """Addr struct representing a TCP address.
+
+    Args:
+        ip: IP address.
+        port: Port number.
+        zone: IPv6 addressing zone.
+    """
+
+    var ip: String
+    var port: Int
+    var zone: String  # IPv6 addressing zone
+
+    fn __init__(inout self, ip: String = "", port: Int = 0, zone: String = ""):
+        self.ip = ip
+        self.port = port
+        self.zone = zone
+
+
+fn resolve_internet_addr(network: String, address: String) -> (TCPAddr, Error):
     var host: String = ""
     var port: String = ""
     var portnum: Int = 0
+    var err = Error()
     if (
         network == NetworkType.tcp.value
         or network == NetworkType.tcp4.value
@@ -37,29 +55,33 @@ fn resolve_internet_addr(network: String, address: String) raises -> TCPAddr:
         or network == NetworkType.udp6.value
     ):
         if address != "":
-            var host_port = split_host_port(address)
-            host = host_port.host
-            port = str(host_port.port)
-            portnum = atol(port.__str__())
+            var result = split_host_port(address)
+            if result[1]:
+                return TCPAddr(), result[1]
+
+            host = result[0].host
+            port = str(result[0].port)
+            portnum = result[0].port
     elif network == NetworkType.ip.value or network == NetworkType.ip4.value or network == NetworkType.ip6.value:
         if address != "":
             host = address
     elif network == NetworkType.unix.value:
-        raise Error("Unix addresses not supported yet")
+        return TCPAddr(), Error("Unix addresses not supported yet")
     else:
-        raise Error("unsupported network type: " + network)
-    return TCPAddr(host, portnum)
+        return TCPAddr(), Error("unsupported network type: " + network)
+    return TCPAddr(host, portnum), err
 
 
-alias missingPortError = Error("missing port in address")
-alias tooManyColonsError = Error("too many colons in address")
+alias MISSING_PORT_ERROR = Error("missing port in address")
+alias TOO_MANY_COLONS_ERROR = Error("too many colons in address")
 
 
+@value
 struct HostPort(Stringable):
     var host: String
     var port: Int
 
-    fn __init__(inout self, host: String, port: Int):
+    fn __init__(inout self, host: String = "", port: Int = 0):
         self.host = host
         self.port = port
 
@@ -73,43 +95,46 @@ fn join_host_port(host: String, port: String) -> String:
     return host + ":" + port
 
 
-fn split_host_port(hostport: String) raises -> HostPort:
+fn split_host_port(hostport: String) -> (HostPort, Error):
     var host: String = ""
     var port: String = ""
     var colon_index = hostport.rfind(":")
     var j: Int = 0
     var k: Int = 0
 
     if colon_index == -1:
-        raise missingPortError
+        return HostPort(), MISSING_PORT_ERROR
     if hostport[0] == "[":
         var end_bracket_index = hostport.find("]")
         if end_bracket_index == -1:
-            raise Error("missing ']' in address")
+            return HostPort(), Error("missing ']' in address")
         if end_bracket_index + 1 == len(hostport):
-            raise missingPortError
+            return HostPort(), MISSING_PORT_ERROR
         elif end_bracket_index + 1 == colon_index:
             host = hostport[1:end_bracket_index]
             j = 1
             k = end_bracket_index + 1
         else:
             if hostport[end_bracket_index + 1] == ":":
-                raise tooManyColonsError
+                return HostPort(), TOO_MANY_COLONS_ERROR
             else:
-                raise missingPortError
+                return HostPort(), MISSING_PORT_ERROR
     else:
         host = hostport[:colon_index]
         if host.find(":") != -1:
-            raise tooManyColonsError
+            return HostPort(), TOO_MANY_COLONS_ERROR
     if hostport[j:].find("[") != -1:
-        raise Error("unexpected '[' in address")
+        return HostPort(), Error("unexpected '[' in address")
     if hostport[k:].find("]") != -1:
-        raise Error("unexpected ']' in address")
+        return HostPort(), Error("unexpected ']' in address")
     port = hostport[colon_index + 1 :]
 
     if port == "":
-        raise missingPortError
+        return HostPort(), MISSING_PORT_ERROR
     if host == "":
-        raise Error("missing host")
+        return HostPort(), Error("missing host")
 
-    return HostPort(host, atol(port))
+    try:
+        return HostPort(host, atol(port)), Error()
+    except e:
+        return HostPort(), e

gojo/net/dial.mojo

@@ -1,6 +1,6 @@
 from .tcp import resolve_internet_addr
 from .socket import Socket
-from .address import split_host_port
+from .address import split_host_port, BaseAddr
 
 
 @value
@@ -9,7 +9,11 @@ struct Dialer:
 
     @always_inline
     fn dial(self, network: String, address: String) raises -> TCPConnection:
-        var tcp_addr = resolve_internet_addr(network, address)
-        var socket = Socket(local_address=self.local_address)
+        var tcp_addr: TCPAddr
+        var err: Error
+        tcp_addr, err = resolve_internet_addr(network, address)
+        if err:
+            raise err
+        var socket = Socket(local_address=BaseAddr(tcp_addr.ip, tcp_addr.port, tcp_addr.zone))
         socket.connect(tcp_addr.ip, tcp_addr.port)
         return TCPConnection(socket^)

gojo/net/listen.mojo

@@ -1,22 +1,24 @@
-# TODO: For now listener is paired with TCP until we need to support
-# more than one type of Connection or Listener
-@value
-struct ListenConfig(CollectionElement):
-    var keep_alive: Duration
+from .address import resolve_internet_addr, BaseAddr
+from ..syscall import SocketOptions
 
-    fn listen(self, network: String, address: String) raises -> TCPListener:
-        var tcp_addr = resolve_internet_addr(network, address)
-        var socket = Socket(local_address=tcp_addr)
-        socket.bind(tcp_addr.ip, tcp_addr.port)
-        socket.set_socket_option(SocketOptions.SO_REUSEADDR, 1)
-        socket.listen()
-        print(str("Listening on ") + str(socket.local_address))
-        return TCPListener(socket^, self, network, address)
+
+fn listen(network: String, address: String) raises -> TCPListener:
+    var tcp_addr: TCPAddr
+    var err: Error
+    tcp_addr, err = resolve_internet_addr(network, address)
+    if err:
+        raise err
+    var socket = Socket(local_address=BaseAddr(tcp_addr.ip, tcp_addr.port, tcp_addr.zone))
+    socket.bind(tcp_addr.ip, tcp_addr.port)
+    socket.set_socket_option(SocketOptions.SO_REUSEADDR, 1)
+    socket.listen()
+    print(str("Listening on ") + str(socket.local_address_as_tcp()))
+    return TCPListener(socket^, network, address)
 
 
 trait Listener(Movable):
     # Raising here because a Result[Optional[Connection], Error] is funky.
-    fn accept(self) raises -> Connection:
+    fn accept[T: Conn](self) raises -> T:
         ...
 
     fn close(inout self) -> Error:

gojo/net/net.mojo

@@ -55,67 +55,67 @@ trait Conn(io.Writer, io.Reader, io.Closer):
     #     ...
 
 
-struct Connection(Conn):
-    """Connection is a concrete generic stream-oriented network connection.
-    It is used as the internal connection for structs like TCPConnection.
-
-    Args:
-        fd: The file descriptor of the connection.
-    """
-
-    var fd: Socket
-
-    @always_inline
-    fn __init__(inout self, owned socket: Socket):
-        self.fd = socket^
-
-    @always_inline
-    fn __moveinit__(inout self, owned existing: Self):
-        self.fd = existing.fd^
-
-    @always_inline
-    fn read(inout self, inout dest: List[UInt8]) -> (Int, Error):
-        """Reads data from the underlying file descriptor.
-
-        Args:
-            dest: The buffer to read data into.
-
-        Returns:
-            The number of bytes read, or an error if one occurred.
-        """
-        return self.fd.read(dest)
-
-    @always_inline
-    fn write(inout self, src: List[UInt8]) -> (Int, Error):
-        """Writes data to the underlying file descriptor.
-
-        Args:
-            src: The buffer to read data into.
-
-        Returns:
-            The number of bytes written, or an error if one occurred.
-        """
-        return self.fd.write(src)
-
-    @always_inline
-    fn close(inout self) -> Error:
-        """Closes the underlying file descriptor.
-
-        Returns:
-            An error if one occurred, or None if the file descriptor was closed successfully.
-        """
-        return self.fd.close()
-
-    @always_inline
-    fn local_address[T: Addr](self) -> T:
-        """Returns the local network address.
-        The Addr returned is shared by all invocations of local_address, so do not modify it.
-        """
-        return self.fd.local_address
-
-    @always_inline
-    fn remote_address[T: Addr](self) -> T:
-        """Returns the remote network address.
-        The Addr returned is shared by all invocations of remote_address, so do not modify it.
-        """
-        return self.fd.remote_address
+# struct Connection():
+#     """Connection is a concrete generic stream-oriented network connection.
+#     It is used as the internal connection for structs like TCPConnection.
+
+#     Args:
+#         socket: The file descriptor of the connection.
+#     """
+
+#     var socket: Socket
+
+#     @always_inline
+#     fn __init__(inout self, owned socket: Socket):
+#         self.socket = socket^
+
+#     @always_inline
+#     fn __moveinit__(inout self, owned existing: Self):
+#         self.socket = existing.socket^
+
+#     @always_inline
+#     fn read(inout self, inout dest: List[UInt8]) -> (Int, Error):
+#         """Reads data from the underlying file descriptor.
+
+#         Args:
+#             dest: The buffer to read data into.
+
+#         Returns:
+#             The number of bytes read, or an error if one occurred.
+#         """
+#         return self.socket.read(dest)
+
+#     @always_inline
+#     fn write(inout self, src: List[UInt8]) -> (Int, Error):
+#         """Writes data to the underlying file descriptor.
+
+#         Args:
+#             src: The buffer to read data into.
+
+#         Returns:
+#             The number of bytes written, or an error if one occurred.
+#         """
+#         return self.socket.write(src)
+
+#     @always_inline
+#     fn close(inout self) -> Error:
+#         """Closes the underlying file descriptor.
+
+#         Returns:
+#             An error if one occurred, or None if the file descriptor was closed successfully.
+#         """
+#         return self.socket.close()
+
+#     @always_inline
+#     fn local_address[T: Addr](self) -> T:
+#         """Returns the local network address.
+#         The Addr returned is shared by all invocations of local_address, so do not modify it.
+#         """
+#         return self.socket.local_address
+
+#     @always_inline
+#     fn remote_address[T: Addr](self) -> T:
+#         """Returns the remote network address.
+#         The Addr returned is shared by all invocations of remote_address, so do not modify it.
+#         """
+#         return self.socket.remote_address