Fixed linux build.

damian-kolakowski · damian-kolakowski · commit 768dfe8ef4b7 · 2017-02-24T22:20:41.000Z
diff --git a/Sources/Linux.swift b/Sources/Linux.swift
@@ -19,7 +19,7 @@ public class LinuxIO: IO {
     
     public required init(_ port: in_port_t, forceIPv4: Bool, bindAddress: String? = nil) throws {
         
-        self.server = try LinuxAsyncServer.nonBlockingSocketForListenening(port, forceIPv4: forceIPv4, address: bindAddress)
+        self.server = try LinuxIO.nonBlockingSocketForListenening(port, forceIPv4: forceIPv4, address: bindAddress)
         
         self.descriptors.append(pollfd(fd: self.server, events: Int16(POLLIN), revents: 0))
     }
@@ -32,7 +32,7 @@ public class LinuxIO: IO {
         let result = Glibc.write(socket, data, data.count)
         if result == -1 {
             defer { self.finish(socket) }
-            throw AsyncError.writeFailed(Process.error)
+            throw SwifterError.writeFailed(Process.error)
         }
         if result == data.count {
             if done() == .terminate {
@@ -52,20 +52,20 @@ public class LinuxIO: IO {
     
     public func wait(_ callback: ((IOEvent) -> Void)) throws {
         guard poll(&descriptors, UInt(descriptors.count), -1) != -1 else {
-            throw AsyncError.async(Process.error)
+            throw SwifterError.async(Process.error)
         }
         for i in 0..<descriptors.count {
             if descriptors[i].revents == 0 {
                 continue
             }
             if descriptors[i].fd == server {
                 while case let client = accept(server, nil, nil), client > 0 {
-                    try LinuxAsyncServer.setSocketNonBlocking(client)
+                    try LinuxIO.setSocketNonBlocking(client)
                     self.backlog[Int32(client)] = []
                     descriptors.append(pollfd(fd: client, events: Int16(POLLIN), revents: 0))
                     callback(IOEvent.connect("", Int32(client)))
                 }
-                if errno != EWOULDBLOCK { throw AsyncError.acceptFailed(Process.error) }
+                if errno != EWOULDBLOCK { throw SwifterError.acceptFailed(Process.error) }
             } else {
                 if (descriptors[i].revents & Int16(POLLERR) != 0) || (descriptors[i].revents & Int16(POLLHUP) != 0) || (descriptors[i].revents & Int16(POLLNVAL) != 0) {
                     self.finish(descriptors[i].fd)
@@ -147,13 +147,13 @@ public class LinuxIO: IO {
         let server = Glibc.socket(forceIPv4 ? AF_INET : AF_INET6, Int32(SOCK_STREAM.rawValue), 0)
         
         guard server != -1 else {
-            throw AsyncError.socketCreation(Process.error)
+            throw SwifterError.socketCreation(Process.error)
         }
         
         var value: Int32 = 1
         if Glibc.setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &value, socklen_t(MemoryLayout<Int32>.size)) == -1 {
             defer { let _ = Glibc.close(server) }
-            throw AsyncError.setReuseAddrFailed(Process.error)
+            throw SwifterError.setReuseAddrFailed(Process.error)
         }
         
         do {
@@ -170,7 +170,7 @@ public class LinuxIO: IO {
         
         if Glibc.listen(server, SOMAXCONN) == -1 {
             defer { let _ = Glibc.close(server) }
-            throw AsyncError.listenFailed(Process.error)
+            throw SwifterError.listenFailed(Process.error)
         }
         
         return server
@@ -185,7 +185,7 @@ public class LinuxIO: IO {
         
         if let addressFound = address {
             guard addressFound.withCString({ inet_pton(AF_INET, $0, &addr.sin_addr) }) == 1 else {
-                throw AsyncError.inetPtonFailed(Errno.description())
+                throw SwifterError.inetPtonFailed(Errno.description())
             }
         } else {
             addr.sin_addr = in_addr(s_addr: in_addr_t(0))
@@ -198,7 +198,7 @@ public class LinuxIO: IO {
         }
         
         guard bindResult != -1 else {
-            throw AsyncError.bindFailed(Errno.description())
+            throw SwifterError.bindFailed(Errno.description())
         }
     }
     
@@ -211,7 +211,7 @@ public class LinuxIO: IO {
         
         if let addressFound = address {
             guard addressFound.withCString({ inet_pton(AF_INET6, $0, &addr.sin6_addr) }) == 1 else {
-                throw AsyncError.inetPtonFailed(Errno.description())
+                throw SwifterError.inetPtonFailed(Errno.description())
             }
         } else {
             addr.sin6_addr = in6addr_any
@@ -224,13 +224,13 @@ public class LinuxIO: IO {
         }
         
         guard bindResult != -1 else {
-            throw AsyncError.bindFailed(Errno.description())
+            throw SwifterError.bindFailed(Errno.description())
         }
     }
 
     public static func setSocketNonBlocking(_ socket: Int32) throws {
         if Glibc.fcntl(socket, F_SETFL, fcntl(socket, F_GETFL, 0) | O_NONBLOCK) == -1 {
-            throw AsyncError.setNonBlockFailed(Process.error)
+            throw SwifterError.setNonBlockFailed(Process.error)
         }
     }
 }
diff --git a/Sources/Server.swift b/Sources/Server.swift
@@ -15,7 +15,7 @@ public class Server {
     
     public init(_ port: in_port_t = 8080, forceIPv4: Bool = false) throws {
         #if os(Linux)
-            self.io = try LinuxAsyncServer(port, forceIPv4: forceIPv4)
+            self.io = try LinuxIO(port, forceIPv4: forceIPv4)
         #else
             self.io = try MacOSIO(port, forceIPv4: forceIPv4)
         #endif

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public class LinuxIO: IO {`
`19`	`19`
`20`	`20`	`public required init(_ port: in_port_t, forceIPv4: Bool, bindAddress: String? = nil) throws {`
`21`	`21`
`22`		`- self.server = try LinuxAsyncServer.nonBlockingSocketForListenening(port, forceIPv4: forceIPv4, address: bindAddress)`
	`22`	`+ self.server = try LinuxIO.nonBlockingSocketForListenening(port, forceIPv4: forceIPv4, address: bindAddress)`
`23`	`23`
`24`	`24`	`self.descriptors.append(pollfd(fd: self.server, events: Int16(POLLIN), revents: 0))`
`25`	`25`	`}`
`@@ -32,7 +32,7 @@ public class LinuxIO: IO {`
`32`	`32`	`let result = Glibc.write(socket, data, data.count)`
`33`	`33`	`if result == -1 {`
`34`	`34`	`defer { self.finish(socket) }`
`35`		`- throw AsyncError.writeFailed(Process.error)`
	`35`	`+ throw SwifterError.writeFailed(Process.error)`
`36`	`36`	`}`
`37`	`37`	`if result == data.count {`
`38`	`38`	`if done() == .terminate {`
`@@ -52,20 +52,20 @@ public class LinuxIO: IO {`
`52`	`52`
`53`	`53`	`public func wait(_ callback: ((IOEvent) -> Void)) throws {`
`54`	`54`	`guard poll(&descriptors, UInt(descriptors.count), -1) != -1 else {`
`55`		`- throw AsyncError.async(Process.error)`
	`55`	`+ throw SwifterError.async(Process.error)`
`56`	`56`	`}`
`57`	`57`	`for i in 0..<descriptors.count {`
`58`	`58`	`if descriptors[i].revents == 0 {`
`59`	`59`	`continue`
`60`	`60`	`}`
`61`	`61`	`if descriptors[i].fd == server {`
`62`	`62`	`while case let client = accept(server, nil, nil), client > 0 {`
`63`		`- try LinuxAsyncServer.setSocketNonBlocking(client)`
	`63`	`+ try LinuxIO.setSocketNonBlocking(client)`
`64`	`64`	`self.backlog[Int32(client)] = []`
`65`	`65`	`descriptors.append(pollfd(fd: client, events: Int16(POLLIN), revents: 0))`
`66`	`66`	`callback(IOEvent.connect("", Int32(client)))`
`67`	`67`	`}`
`68`		`- if errno != EWOULDBLOCK { throw AsyncError.acceptFailed(Process.error) }`
	`68`	`+ if errno != EWOULDBLOCK { throw SwifterError.acceptFailed(Process.error) }`
`69`	`69`	`} else {`
`70`	`70`	`if (descriptors[i].revents & Int16(POLLERR) != 0) \|\| (descriptors[i].revents & Int16(POLLHUP) != 0) \|\| (descriptors[i].revents & Int16(POLLNVAL) != 0) {`
`71`	`71`	`self.finish(descriptors[i].fd)`
`@@ -147,13 +147,13 @@ public class LinuxIO: IO {`
`147`	`147`	`let server = Glibc.socket(forceIPv4 ? AF_INET : AF_INET6, Int32(SOCK_STREAM.rawValue), 0)`
`148`	`148`
`149`	`149`	`guard server != -1 else {`
`150`		`- throw AsyncError.socketCreation(Process.error)`
	`150`	`+ throw SwifterError.socketCreation(Process.error)`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`var value: Int32 = 1`
`154`	`154`	`if Glibc.setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &value, socklen_t(MemoryLayout<Int32>.size)) == -1 {`
`155`	`155`	`defer { let _ = Glibc.close(server) }`
`156`		`- throw AsyncError.setReuseAddrFailed(Process.error)`
	`156`	`+ throw SwifterError.setReuseAddrFailed(Process.error)`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`do {`
`@@ -170,7 +170,7 @@ public class LinuxIO: IO {`
`170`	`170`
`171`	`171`	`if Glibc.listen(server, SOMAXCONN) == -1 {`
`172`	`172`	`defer { let _ = Glibc.close(server) }`
`173`		`- throw AsyncError.listenFailed(Process.error)`
	`173`	`+ throw SwifterError.listenFailed(Process.error)`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`return server`
`@@ -185,7 +185,7 @@ public class LinuxIO: IO {`
`185`	`185`
`186`	`186`	`if let addressFound = address {`
`187`	`187`	`guard addressFound.withCString({ inet_pton(AF_INET, $0, &addr.sin_addr) }) == 1 else {`
`188`		`- throw AsyncError.inetPtonFailed(Errno.description())`
	`188`	`+ throw SwifterError.inetPtonFailed(Errno.description())`
`189`	`189`	`}`
`190`	`190`	`} else {`
`191`	`191`	`addr.sin_addr = in_addr(s_addr: in_addr_t(0))`
`@@ -198,7 +198,7 @@ public class LinuxIO: IO {`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`guard bindResult != -1 else {`
`201`		`- throw AsyncError.bindFailed(Errno.description())`
	`201`	`+ throw SwifterError.bindFailed(Errno.description())`
`202`	`202`	`}`
`203`	`203`	`}`
`204`	`204`
`@@ -211,7 +211,7 @@ public class LinuxIO: IO {`
`211`	`211`
`212`	`212`	`if let addressFound = address {`
`213`	`213`	`guard addressFound.withCString({ inet_pton(AF_INET6, $0, &addr.sin6_addr) }) == 1 else {`
`214`		`- throw AsyncError.inetPtonFailed(Errno.description())`
	`214`	`+ throw SwifterError.inetPtonFailed(Errno.description())`
`215`	`215`	`}`
`216`	`216`	`} else {`
`217`	`217`	`addr.sin6_addr = in6addr_any`
`@@ -224,13 +224,13 @@ public class LinuxIO: IO {`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`guard bindResult != -1 else {`
`227`		`- throw AsyncError.bindFailed(Errno.description())`
	`227`	`+ throw SwifterError.bindFailed(Errno.description())`
`228`	`228`	`}`
`229`	`229`	`}`
`230`	`230`
`231`	`231`	`public static func setSocketNonBlocking(_ socket: Int32) throws {`
`232`	`232`	`if Glibc.fcntl(socket, F_SETFL, fcntl(socket, F_GETFL, 0) \| O_NONBLOCK) == -1 {`
`233`		`- throw AsyncError.setNonBlockFailed(Process.error)`
	`233`	`+ throw SwifterError.setNonBlockFailed(Process.error)`
`234`	`234`	`}`
`235`	`235`	`}`
`236`	`236`	`}`