0001    import Echo
0002    import Foundation
0003    import Vaquita
0004    
0005    #if os(Linux)
0006        import Glibc
0007    #endif
0008    
0009    protocol SocketServerDelegate
Application.swift:129
extension Blackfish: SocketServerDelegate {
SocketServer.swift:29
    weak var delegate: SocketServerDelegate?: class {
0010        func socketServer
SocketServer.swift:82
                self.delegate?.socketServer(self,(socketServer: SocketServer,
0011                          didRecieveRequest request: Request,
0012                                            withResponse response: Response)
0013    }
0014    
0015    public class SocketServer
Application.swift:14
    private let server: SocketServer
Application.swift:29
        server = SocketServer()
Application.swift:130
    func socketServer(socketServer: SocketServer,
SocketServer.swift:10
    func socketServer(socketServer: SocketServer,
SocketServer.swift:108
extension SocketServer: Responder { {
0016    
0017        let socketManager
SocketServer.swift:32
        socketManager = SocketManager()
SocketServer.swift:41
        self.listenSocket = try socketManager.createListenSocket(listenPort): SocketManager
0018    
0019        private var listenSocket
SocketServer.swift:41
        self.listenSocket = try socketManager.createListenSocket(listenPort)
SocketServer.swift:45
            while let socket = try? self.listenSocket.acceptClientSocket() {
SocketServer.swift:91
        self.listenSocket.release(): Socket = Socket(rawSocket: -)
0020        
0021        private var clientSockets
SocketServer.swift:48
                    self.clientSockets.insert(socket)
SocketServer.swift:54
                        self.clientSockets.remove(socket)
SocketServer.swift:94
            for socket in self.clientSockets {
SocketServer.swift:97
            self.clientSockets.removeAll(keepCapacity: true): Set<Socket> = []
0022    
0023        private var clientSocketsLock
SocketServer.swift:47
                self.lock(self.clientSocketsLock) {
SocketServer.swift:53
                    self.lock(self.clientSocketsLock) {
SocketServer.swift:93
        self.lock(self.clientSocketsLock) { = NSLock()
0024    
0025        private var queue
SocketServer.swift:33
        queue = dispatch_queue_create("blackfish.queue.request", DISPATCH_QUEUE_CONCURRENT)
SocketServer.swift:43
        dispatch_async(self.queue) {
SocketServer.swift:51
                dispatch_async(self.queue) {: dispatch_queue_t
0026    
0027        private let socketParser
SocketServer.swift:34
        socketParser = SocketParser()
SocketServer.swift:71
        if let request = try? socketParser.readHttpRequest(socket) {: SocketParser
0028        
0029        weak var delegate
Application.swift:34
        server.delegate = self
SocketServer.swift:82
                self.delegate?.socketServer(self,: SocketServerDelegate?
0030    
0031        init
Application.swift:29
        server = SocketServer()() {
0032            socketManager = SocketManager()
0033            queue = dispatch_queue_create("blackfish.queue.request", DISPATCH_QUEUE_CONCURRENT)
0034            socketParser = SocketParser()
0035        }
0036    
0037        func start
Application.swift:158
            try server.start(port)(listenPort: Int) throws {
0038    
0039            self.stop()
0040    
0041            self.listenSocket = try socketManager.createListenSocket(listenPort)
0042    
0043            dispatch_async(self.queue) {
0044    
0045                while let socket = try? self.listenSocket.acceptClientSocket() {
0046    
0047                    self.lock(self.clientSocketsLock) {
0048                        self.clientSockets.insert(socket)
0049                    }
0050    
0051                    dispatch_async(self.queue) {
0052                        self.handleConnection(socket)
0053                        self.lock(self.clientSocketsLock) {
0054                            self.clientSockets.remove(socket)
0055                        }
0056                    }
0057                }
0058    
0059                self.stop()
0060            }
0061        }
0062    
0063        func loop
Application.swift:161
            server.loop()() {
0064            Echo.beginEventLoop()
0065        }
0066    
0067        func handleConnection
SocketServer.swift:52
                    self.handleConnection(socket)(socket: Socket) {
0068    
0069            let address = try? socket.peername()
0070    
0071            if let request = try? socketParser.readHttpRequest(socket) {
0072    
0073                dispatch_async(dispatch_get_main_queue()) {
0074    
0075                    request.address = address
0076    
0077                    request.parameters = [:]
0078                    
0079                    let response = Response(request: request, responder: self, 
0080                        socket: socket)
0081    
0082                    self.delegate?.socketServer(self,
0083                                               didRecieveRequest: request,
0084                                               withResponse: response)
0085                }
0086            }
0087        }
0088    
0089        func stop
SocketServer.swift:39
        self.stop()
SocketServer.swift:59
            self.stop()() {
0090    
0091            self.listenSocket.release()
0092    
0093            self.lock(self.clientSocketsLock) {
0094                for socket in self.clientSockets {
0095                    socket.release()
0096                }
0097                self.clientSockets.removeAll(keepCapacity: true)
0098            }
0099        }
0100    
0101        private func lock
SocketServer.swift:47
                self.lock(self.clientSocketsLock) {
SocketServer.swift:53
                    self.lock(self.clientSocketsLock) {
SocketServer.swift:93
        self.lock(self.clientSocketsLock) {(handle: NSLock, closure: () -> ()) {
0102            handle.lock()
0103            closure()
0104            handle.unlock();
0105        }
0106    }
0107    
0108    extension SocketServer: Responder {
0109        public func sendResponse(response: Response) {
0110    
0111            let socket = response.socket
0112    
0113            defer { socket
0114                socket.release()
0115            }
0116    
0117            do {
0118                try socket.writeString("HTTP/1.1 \(response.status.code) \(response.reasonPhrase)\r\n")
0119    
0120                var headers = response.headers()
0121    
0122                if response.body.count >=  {
0123                    headers["Content-Length"] = "\(response.body.count)"
0124                }
0125    
0126                if true && response.body.count != - {
0127                    headers["Connection"] = "keep-alive"
0128                }
0129    
0130                for (name, value) in headers {
0131                    try socket.writeString("\(name): \(value)\r\n")
0132                }
0133    
0134                try socket.writeString("\r\n")
0135    
0136                try socket.writeData(Data(bytes: response.body))
0137    
0138            } catch let socketError as SocketError {
0139                if let message = socketError.errorMessage {
0140                    print("Error: \(socketError) error message: \(message)")
0141                } else {
0142                    print("Error: \(socketError)")
0143                }
0144            } catch {
0145                print("Error: \(error)")
0146            }
0147        }
0148    }
0149