Merge branch 'stable'

Author: tommy-th

Trevi.xcodeproj/project.pbxproj

@@ -217,10 +217,10 @@
 				23D2F3991C1DA4A000F0C784 /* views */,
 				239411E41C0C2E19001B9B07 /* AppDelegate.swift */,
 				239411E61C0C2E19001B9B07 /* ViewController.swift */,
+				239412131C0DECC2001B9B07 /* Lime.swift */,
 				239411E81C0C2E19001B9B07 /* Assets.xcassets */,
 				239411EA1C0C2E19001B9B07 /* Main.storyboard */,
 				239411ED1C0C2E19001B9B07 /* Info.plist */,
-				239412131C0DECC2001B9B07 /* Lime.swift */,
 			);
 			path = Trevi_ver_lime;
 			sourceTree = "<group>";

Trevi/Http/HttpSocket.swift

@@ -19,7 +19,6 @@ public class TreviSocket {
     func sendData ( data: NSData ) {
 
         socket.write (data, queue: dispatch_get_main_queue())
-      
         socket.close ()
     }
 }
@@ -32,7 +31,7 @@ class TreviSocketServer {
 
     func startOnPort ( p: Int ) throws {
 
-        guard let socket = ListenSocket<IPv4> ( address: IPv4 ( port: p )) else {
+        guard let socket = ListenSocket<IPv4> ( address: IPv4 (port: p)) else {
             // Should handle Listener error
             return
         }

Trevi/Socket/ConnectedSocket.swift

@@ -10,7 +10,14 @@ import Darwin
 
 let ClientBufferSize = 4096
 
-// Should add connect function
+/**
+* ConnectedSocket class
+*
+* Manage a tcp client socket, and provide read, write functions.
+*
+* Should add connect function.
+*
+*/
 public class ConnectedSocket<T: InetAddress> : Socket<T> {
 
     var bufferPtr  = UnsafeMutablePointer<CChar>.alloc(ClientBufferSize + 2)
@@ -19,7 +26,19 @@ public class ConnectedSocket<T: InetAddress> : Socket<T> {
     var isConnected : Bool = false
     var isClosing : Bool = false
 
-    // Accept client socket
+    /**
+    * init?
+    * After accept, create a client socket,
+    *
+    * @param
+    *  First : Client socket's file descriptor.
+    *  Second : Client socket's address family.
+    *  Third : A dispatch queue for this socket's read event.
+    *
+    * @return
+    *  If bind function succeeds, create a client socket.
+    *  However, if it fails, returns nil
+    */
     public init?(fd : Int32, address : T, queue : dispatch_queue_t = defaultQueue) {
 
         super.init(fd: fd, address: address)
@@ -49,25 +68,25 @@ public class ConnectedSocket<T: InetAddress> : Socket<T> {
 
         super.close()
     }
-    
-    func accept() -> (Int32, T) {
-        var clientAddr    = T()
-        var clientAddrLen = socklen_t(T.length)
-        
-        let clientFd = withUnsafeMutablePointer(&clientAddr) {
-            ptr -> Int32 in
-            let addrPtr = UnsafeMutablePointer<sockaddr>(ptr)
-            return Darwin.accept(self.fd, addrPtr, &clientAddrLen);
-        }
-        
-        return (clientFd, clientAddr)
-    }
 
     // Should add connect()
 
+    /**
+    * read
+    * Read recived data from this socket.
+    *
+    * @param
+    *
+    * @return
+    *  First : Read length.
+    *  Second : Read data buffer pointer.
+    */
     public func read() -> (length: Int, buffer: UnsafePointer<CChar>) {
         let readBufferPtr = UnsafePointer<CChar>(bufferPtr)
         let readBufferLen = Darwin.read(fd, bufferPtr, bufferLen)
+   
+//        print(length)
+//        print(blockToString(buffer, length: length))
 
         guard readBufferLen >= 0 else {
             bufferPtr[0] = 0
@@ -79,6 +98,20 @@ public class ConnectedSocket<T: InetAddress> : Socket<T> {
         return ( readBufferLen, readBufferPtr )
     }
 
+    /**
+     * write
+     * Write response data to this socket.
+     *
+     * @param
+     *  First : Data buffer pointer.
+     *  Second : Data length.
+     *  Third : A dispatch queue for write event.
+     *             If you use dispatch_get_main_queue(), all write event in this program 
+     *             will be processed by main thread.
+     *
+     * @return
+     *  Success or failure.
+     */
     public func write<M>(buffer: UnsafePointer<M>, length : Int,
         queue : dispatch_queue_t = defaultQueue) -> Bool {
 

Trevi/Socket/EventHandler.swift

@@ -8,16 +8,32 @@
 
 import Dispatch
 
-// For single thread server model
-//public let defaultQueue = dispatch_get_main_queue()
 
-// For multi thread server model (It does not mean blocking, just for parallelizing)
+/**
+* Set the 'defaultQueue' to 'dispatch_get_main_queue()' for single thread server model.
+* Then all event will dispatch to main queue in GCD, and all tasks will be processed by main thread.
+* Examples:
+*   public let defaultQueue = dispatch_get_main_queue()
+*
+* On the other hand if you want multi thread server model and more parallelizing,
+* set the defaultQueue to dispatch_get_global_queue(_ ,  0)
+*
+*/
 public let defaultQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
 
 // Below codes are prototype for injecting read event according with Socket's states.
 //  I think it's not good way, should find better way
 public typealias readCallbackType = (() -> Int)
 
+
+/**
+ * ReadEvent
+ * Socket's read event protocol
+ *
+ * Set read event type in EventHandler according with block and non-block.
+ * These classes will be injected when socket's isNonblocking sets.
+ *
+ */
 public protocol ReadEvent {
     func excute(callback : readCallbackType) -> Bool
 }
@@ -36,6 +52,15 @@ public class NonBlockingRead : ReadEvent {
     }
 }
 
+
+/**
+ * EventHandler class
+ *
+ * Manage all socket' read and write event based on GCD.
+ *
+ * Should change this module to be working in Linux.
+ *
+ */
 public class EventHandler {
 
     let fd : Int32
@@ -74,6 +99,30 @@ public class EventHandler {
         return false
     }
 
+    
+    /**
+     * dispatchReadEvent
+     * Dispatch socket's read event.
+     *
+     * Examples:
+     *  eventHandle.dispatchReadEvent(){
+     *
+     *      let (count, buffer) = clientSocket.read()
+     *
+     *      clientSocket.write(buffer, length: count, queue: dispatch_get_main_queue())
+     *
+     *      return count
+     *  }
+     *
+     * @param
+     *  First : Should be readCallbackType and return read length. If return 0 this EventHandler's
+     *           read event will stop, and parent's socket will deinit. Don't be worry about strong 
+     *           reference. All parent's properties will be destroyed.
+     *
+     *
+     * @return
+     *  Success or failure.
+     */
     public func dispatchReadEvent(callback : readCallbackType) -> Bool {
         source = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ,
             UInt(fd), 0, queue)
@@ -96,6 +145,23 @@ public class EventHandler {
         }
     }
 
+    /**
+     * dispatchWriteEvent
+     * Write response data to this socket.
+     *
+     * Examples:
+     *  eventHandle.dispatchWriteEvent(buffer, length : length) {
+     *      if self.isClosing { self.close() }
+     *  }
+     *
+     * @param
+     *  First : Data buffer pointer<data type>.
+     *  Second : Daga length.
+     *  Third : Close event to prevent socket closing before writting.
+     *
+     * @return
+     *  Success or failure.
+     */
     public func dispatchWriteEvent<M>(buffer : UnsafePointer<M>,
         length : Int, closeSocket : ()->() ) -> Bool {
 

Trevi/Socket/InetAddress.swift

@@ -31,7 +31,16 @@ extension sockaddr_in : InetAddress {
     public static let length = __uint8_t(sizeof(IPv4))
     public func port() -> in_port_t { return  in_port_t(ntohs(self.sin_port)) }
 
-    public init(address : in_addr = INADDR_ANY, port : Int = 0) {
+ 
+    public init(address : String, port : Int){
+        sin_len = __uint8_t(sizeof(sockaddr_in))
+        sin_family = sa_family_t(AF_INET)
+        sin_port = in_port_t(htons(CUnsignedShort(port)))
+        sin_addr = in_addr(s_addr: inet_addr(address))
+        sin_zero = (0,0,0,0,0,0,0,0)
+    }
+    
+    public init(address : in_addr = INADDR_ANY, port : Int) {
         sin_len = __uint8_t(sizeof(sockaddr_in))
         sin_family = sa_family_t(AF_INET)
         sin_port = in_port_t(htons(CUnsignedShort(port)))

Trevi/Socket/ListenSocket.swift

@@ -9,11 +9,28 @@
 import Darwin
 import Dispatch
 
+/**
+ * ListenSocket class
+ *
+ * Manage a tcp listen socket, and accept client socket.
+ *
+ */
 public class ListenSocket<T: InetAddress> : Socket<T> {
 
     var isListening : Bool = false
 
-    // Create socket and bind address
+    /**
+     * init?
+     * Create a listen socket, 
+     *
+     * @param
+     *  First : Listen socket's address family.
+     *  Second : A dispatch queue for this socket's read event.
+     *
+     * @return
+     *  If bind function succeeds, calls super.init().
+     *  However, if it fails, returns nil
+     */
     public init?(address : T, queue : dispatch_queue_t = defaultQueue) {
 
         let fd = socket(T.domain, SOCK_STREAM, 0)
@@ -34,6 +51,17 @@ public class ListenSocket<T: InetAddress> : Socket<T> {
         self.close()
     }
 
+    /**
+     * listen
+     * Listen client sockets
+     *
+     * @param
+     *  First : Socket's nonBlock mode. 
+     *  Second : Backlog queue setting. Handle client's concurrent connect requests.
+     *
+     * @return
+     *  Success or failure
+     */
     // Should extract nonBlock input, and move to Server Model Module
     public func listen(nonBlock : Bool, backlog : Int32 = 50) -> Bool {
         guard !isListening else { return false }
@@ -49,6 +77,16 @@ public class ListenSocket<T: InetAddress> : Socket<T> {
         return self.isListening
     }
 
+    /**
+     * accept
+     * Accept client request.
+     *
+     * @param
+     *
+     * @return
+     *  First : Client's file descriptor.
+     *  Second : Client's address family.
+     */
     public func accept() -> (Int32, T) {
         var clientAddr    = T()
         var clientAddrLen = socklen_t(T.length)
@@ -62,6 +100,34 @@ public class ListenSocket<T: InetAddress> : Socket<T> {
         return (clientFd, clientAddr)
     }
 
+    /**
+     * listenClientEvent
+     * Listen client sockets, and dispatch client event.
+     *
+     * Examples:
+     *  let server: ListenSocket? = ListenSocket(address: IPv4(port: 8080))
+     *
+     *  server!.listenClientEvent(false) {
+     *      clientSocket in
+     *
+     *      clientSocket.eventHandle.dispatchReadEvent(){
+     *
+     *          let (count, buffer) = clientSocket.read()
+     *
+     *          clientSocket.write(buffer, length: count, queue: dispatch_get_main_queue())
+     *
+     *          return count
+     *      }
+     * }
+     *
+     * @param
+     *  First : Socket's nonBlock mode.
+     *  Second : Backlog queue setting. Handle client's concurrent connect requests.
+     *  Third : Client socket's callback after it is created.
+     *
+     * @return
+     *  Success or failure
+     */
     public func listenClientEvent(nonBlock : Bool, backlog : Int32 = 50,
         clientCallback: (ConnectedSocket<T>) -> Void) -> Bool {
 
@@ -90,6 +156,33 @@ public class ListenSocket<T: InetAddress> : Socket<T> {
             return true
     }
 
+    
+    /**
+     * listenClientReadEvent
+     * Listen client sockets, and dispatch client event.
+     *
+     * Examples:
+     *  let server: ListenSocket? = ListenSocket(address: IPv4(port: 8080))
+     *
+     *  server!.listenClientReadEvent(false) {
+     *      clientSocket in
+     *
+     *      let (length, buffer) = clientSocket.read()
+     *
+     *      clientSocket.write(buffer, length: length, queue: dispatch_get_main_queue())
+     *
+     *      return count
+     * }
+     *
+     * @param
+     *  First : Socket's nonBlock mode.
+     *  Second : Backlog queue setting. Handle client's concurrent connect requests.
+     *  Third : Client socket's read callback when a client socket get a request.
+     *             In this closure, you should return read length, so if 0 value return socket will be closed.
+     *
+     * @return
+     *  Success or failure.
+     */
     public func listenClientReadEvent(nonBlock : Bool, backlog : Int32 = 50,
         clientReadCallback: (ConnectedSocket<T>) -> Int) -> Bool {