0001    #if os(Linux)
0002    import Glibc
0003    #else
0004    import Darwin.C
0005    #endif
0006    
0007    import Nest
0008    import Inquiline
0009    
0010    
0011    final class SyncronousWorker : WorkerType {
0012      let logger
SyncronousWorker.swift:39
    logger.info("Booting worker process with pid: \(getpid())")
SyncronousWorker.swift:44
      logger.info("Failed to boot \(error)"): Logger
0013      let listeners
SyncronousWorker.swift:49
    listeners.forEach { $0.blocking = false }
SyncronousWorker.swift:51
    if listeners.count == 1 {
SyncronousWorker.swift:52
      runOne(listeners.first!)
SyncronousWorker.swift:54
      runMultiple(listeners)
SyncronousWorker.swift:88
    let (read, _, _) = select(listeners + [sharedHandler!.pipe[0]], [], [], timeout: timeout): [Socket]
0014      let timeout
SyncronousWorker.swift:87
    let timeout = timeval(tv_sec: self.timeout, tv_usec: 0): Int
0015      let application: RequestType -> ResponseType
0016      var isAlive
SyncronousWorker.swift:47
    isAlive = true
SyncronousWorker.swift:59
    while isAlive {
SyncronousWorker.swift:75
    isAlive = false
SyncronousWorker.swift:79
    isAlive = false: Bool = false
0017      let temp
SyncronousWorker.swift:83
    temp.notify(): WorkerTemp
0018      var aborted: Bool = false
0019    
0020      init(logger: Logger, listeners: [Socket], timeout: Int, application: RequestType -> ResponseType) {
0021        self.logger = logger
0022        self.listeners = listeners
0023        self.timeout = timeout
0024        self.application = application
0025    
0026        temp = WorkerTemp()
0027      }
0028    
0029      func registerSignals
SyncronousWorker.swift:42
      try registerSignals()() throws {
0030        let signals = try SignalHandler()
0031        signals.register(.Interrupt, handleQuit)
0032        signals.register(.Quit, handleQuit)
0033        signals.register(.Terminate, handleTerminate)
0034        sharedHandler = signals
0035        SignalHandler.registerSignals()
0036      }
0037    
0038      func run() {
0039        logger.info("Booting worker process with pid: \(getpid())")
0040    
0041        do {
0042          try registerSignals()
0043        } catch {
0044          logger.info("Failed to boot \(error)")
0045          return
0046        }
0047        isAlive = true
0048    
0049        listeners.forEach { $0.blocking = false }
0050    
0051        if listeners.count ==  {
0052          runOne(listeners.first!)
0053        } else {
0054          runMultiple(listeners)
0055        }
0056      }
0057    
0058      func runOne
SyncronousWorker.swift:52
      runOne(listeners.first!)(listener: Socket) {
0059        while isAlive {
0060          sharedHandler?.process()
0061          notify()
0062          accept(listener)
0063          wait()
0064        }
0065      }
0066    
0067      func runMultiple
SyncronousWorker.swift:54
      runMultiple(listeners)(listeners: [Socket]) {
0068        // TODO multiple listners
0069        fatalError("Curassow Syncronous worker cannot yet handle multiple listeners")
0070      }
0071    
0072      // MARK: Signal Handling
0073    
0074      func handleQuit
SyncronousWorker.swift:31
    signals.register(.Interrupt, handleQuit)
SyncronousWorker.swift:32
    signals.register(.Quit, handleQuit)() {
0075        isAlive = false
0076      }
0077    
0078      func handleTerminate
SyncronousWorker.swift:33
    signals.register(.Terminate, handleTerminate)() {
0079        isAlive = false
0080      }
0081    
0082      func notify
SyncronousWorker.swift:61
      notify()() {
0083        temp.notify()
0084      }
0085    
0086      func wait
SyncronousWorker.swift:63
      wait()() -> [Socket] {
0087        let timeout = timeval(tv_sec: self.timeout, tv_usec: )
0088        let (read, _, _) = select(listeners + [sharedHandler!.pipe[]], [], [], timeout: timeout)
0089        return read
0090      }
0091    
0092      func accept
SyncronousWorker.swift:62
      accept(listener)(listener: Socket) {
0093        if let client = try? listener.accept() {
0094          client.blocking = true
0095          handle(client)
0096        }
0097      }
0098    
0099      func handle
SyncronousWorker.swift:95
      handle(client)(client: Socket) {
0100        let parser = HTTPParser(socket: client)
0101    
0102        let response: ResponseType
0103    
0104        do {
0105          let request = try parser.parse()
0106          response = application(request)
0107          print("[worker] \(request.method) \(request.path) - \(response.statusLine)")
0108        } catch let error as HTTPParserError {
0109          response = error.response()
0110        } catch {
0111          print("[worker] Unknown error: \(error)")
0112          response = Response(.InternalServerError, contentType: "text/plain", body: "Internal Server Error")
0113        }
0114    
0115        sendResponse(client, response: response)
0116    
0117        client.shutdown()
0118        client.close()
0119      }
0120    }
0121    
0122    
0123    func sendResponse
SyncronousWorker.swift:115
    sendResponse(client, response: response)(client: Socket, response: ResponseType) {
0124      client.send("HTTP/1.1 \(response.statusLine)\r\n")
0125    
0126      client.send("Connection: close\r\n")
0127      var hasLength = false
0128    
0129      for (key, value) in response.headers {
0130        if key != "Connection" {
0131          client.send("\(key): \(value)\r\n")
0132        }
0133    
0134        if key == "Content-Length" {
0135          hasLength = true
0136        }
0137      }
0138    
0139      if !hasLength {
0140          if let body = response.body {
0141          // TODO body shouldn't be a string
0142          client.send("Content-Length: \(body.characters.count)\r\n")
0143        } else {
0144          client.send("Content-Length: 0\r\n")
0145        }
0146      }
0147    
0148      client.send("\r\n")
0149    
0150      if let body = response.body {
0151        client.send(body)
0152      }
0153    }
0154