Загрузка Prorsum - Загрузка исходного кода Prorsum

Параллельная система в стиле Go + сетевые/http-библиотеки для Swift, которая работает на Linux и Mac.

Причина, по которой я начал этот проект, заключается в том, что я чувствовал, что очень сложно обрабатывать асинхронный ввод-вывод с помощью Swift в проекте под названием Slimane, который я создал ранее. В асинхронной парадигме в Swift нам нужно часто хорошо использовать список захвата для замыканий и иногда сохранять объект (соединение и т. д.), чтобы избежать его освобождения с помощью ARC. Тогда я подумал, что параллельный/параллельный и синхронный механизм Go является подходящей моделью для нынешнего этапа Swift (если вы хотите написать сервер на многоядерной машине). Поскольку мы можем легко выполнять асинхронные операции без цепочек обратных вызовов, можем использовать полные ядра с простым синтаксисом и легко распределять память через канал между потоком и потоком.

(Prorsum не является Goroutine. Он не имеет Corotuines, а переключение контекста выполняется на стороне ОС. Он просто имеет потокобезопасный механизм общей памяти (он работает на GCD), который во многом вдохновлен Go.)

Архитектура HTTP-сервера Prorsum представляет собой управляемый событиями мастер + обработчик многопоточных запросов. В DispatchQueue вы можете написать асинхронный ввод-вывод с синхронным синтаксисом с помощью go() + Channel<Element> .
Легко создавать коды для решения C10K без обратных вызовов.

                                                 +-----------------+
                                             |-- | Request Handler |
                                             |   +-----------------+
               +--------+                    |   +-----------------+
----- TCP ---- | master |---Dispatch Queue---|-- | Request Handler |
               +--------+                    |   +-----------------+               
                                             |   +-----------------+
                                             |-- | Request Handler |
                                                 +-----------------+

import PackageDescription

let package = Package (
    name : " MyApp " ,
    dependencies : [
        . Package ( url : " https://github.com/noppoMan/Prorsum.git " , majorVersion : 0 , minor : 1 )
    ]
)

 func asyncTask ( ) {
    print ( Thread . current )
}

go ( asyncTask ( ) )

go {
    print ( Thread . current )
}

gomain {
    print ( Thread . current ) // back to the main thread
}

Группа WaitGroup ожидает завершения набора операций GCD. Основная операция НОД вызывает Add, чтобы установить количество операций НОД, которые необходимо ожидать. Затем каждая операция GCD запускается и по завершении вызывает Done. В то же время Wait можно использовать для блокировки до завершения всех операций GCD.

 let wg = WaitGroup ( )

wg . add ( 1 )
go {
    sleep ( 1 )
    print ( " wg: 1 " )
    wg . done ( )
}

wg . add ( 1 )
go {
    sleep ( 1 )
    print ( " wg: 2 " )
    wg . done ( )
}

wg . wait ( ) // block unitle twice wg.done() is called.

print ( " wg done " )

Каналы — это каналы, соединяющие одновременную работу. Вы можете отправлять значения в каналы из одной операции НОД и получать эти значения в другую операцию НОД.

 let ch = Channel < String > . make ( capacity : 1 )

func asyncSend ( ) {
    try ! ch . send ( " Expecto patronum! " )
}

go ( asyncSend ( ) ) // => Expecto patronum!

go {
    try ! ch . send ( " Accio! " )
}

try ! ch . receive ( ) // => Accio!

ch . close ( )

Оператор select позволяет BlockOperation ожидать выполнения нескольких операций связи.

 let magicCh = Channel < String > . make ( capacity : 1 )

go {
  try ! magicCh . send ( " Obliviate " )
}

select {
    when ( magicCh ) {
        print ( $0 )
    }

    otherwise {
        print ( " otherwise " )
    }
}

Обычно вам нужно обернуть выбор внутри цикла while. Чтобы упростить работу с этим шаблоном, вы можете использовать forSelect . forSelect будет выполняться в цикле до тех пор, пока не будет вызвана done() .

 let magicCh = Channel < String > . make ( capacity : 1 )
let doneCh = Channel < String > . make ( capacity : 1 )

go {
    try ! magicCh . send ( " Crucio " )
    try ! magicCh . send ( " Imperio " )
}

go {
    try ! doneCh . send ( " Avada Kedavra! " )
}

forSelect { done in
    when ( magicCh ) {
        print ( $0 )
    }

    when ( doneCh ) {
        done ( ) // break current loop
    }

    otherwise {
        print ( " otherwise " )
    }
}

import Prorsum
import Foundation

let server = try ! HTTPServer { ( request , writer ) in
    do {
        let response = Response (
            headers : [ " Server " : " Prorsum Micro HTTP Server " ] ,
            body : . buffer ( " hello " . data )
        )

        try writer . serialize ( response )

        writer . close ( )
    } catch {
        fatalError ( " ( error ) " )
    }
}

try ! server . bind ( host : " 0.0.0.0 " , port : 3000 )
print ( " Server listening at 0.0.0.0:3000 " )
try ! server . listen ( )

RunLoop . main . run ( ) //start run loop

import Prorsum

let url = URL ( string : " https://google.com " )
let client = try ! HTTPClient ( url : url! )
try ! client . open ( )
let response = try ! client . request ( )

print ( response )
// HTTP/1.1 200 OK
// Set-Cookie: NID=91=CPfJo7FsoC_HXmq7kLrs-e0DhR0lAaHcYc8GFxhazE5OXdc3uPvs22oz_UP3Bcd2mZDczDgtW80OrjC6JigVCGIhyhXSD7e1RA7rkinF3zxUNsDnAtagvs5pbZSjXuZE; expires=Sun, 04-Jun-2017 16:21:39 GMT; path=/; domain=.google.co.jp; HttpOnly
// Transfer-Encoding: chunked
// Accept-Ranges: none
// Date: Sat, 03 Dec 2016 16:21:39 GMT
// Content-Type: text/html; charset=Shift_JIS
// Expires: -1
// Alt-Svc: quic=":443"; ma=2592000; v="36,35,34"
// Cache-Control: private, max-age=0
// Server: gws
// X-XSS-Protection: 1; mode=block
// Vary: Accept-Encoding
// X-Frame-Options: SAMEORIGIN
// P3P: CP="This is not a P3P policy! See https://www.google.com/support/accounts/answer/151657?hl=en for more info."

 #if os(Linux)
    import Glibc
#else
    import Darwin . C
#endif

import Prorsum
import Foundation

let server = try ! TCPServer { clientStream in
    while !clientStream . isClosed {
        let bytes = try ! clientStream . read ( )
        try ! clientStream . write ( bytes )
        clientStream . close ( )
    }
}

// setup client
go {
    sleep ( 1 )
    let client = try ! TCPSocket ( )
    try ! client . connect ( host : " 0.0.0.0 " , port : 3000 )
    while !client . isClosed {
        try ! client . write ( Array ( " hello " . utf8 ) )
        let bytes = try ! client . recv ( )
        if !bytes . isEmpty {
            print ( String ( bytes : bytes , encoding : . utf8 ) )
        }
    }
    server . terminate ( ) // terminate server
}

try ! server . bind ( host : " 0.0.0.0 " , port : 3000 )
try ! server . listen ( ) //start run loop

RunLoop . main . run ( ) //start run loop

 #if os(Linux)
    import Glibc
#else
    import Darwin . C
#endif

import Foundation
import Prorsum

let server = try ! HTTPServer { ( request , writer ) in
    do {
        let response : Response
        if request . isWebSocket {
            response = try request . upgradeToWebSocket { request , websocket in
                websocket . onText {
                    print ( " received: ( $0 ) " )
                    try ! websocket . send ( $0 )
                }
            }
        } else {
            response = Response (
                headers : [ " Server " : " Prorsum Micro HTTP Server " ] ,
                body : . buffer ( " hello " . data )
            )
        }

        try writer . serialize ( response )

        try response . upgradeConnection ? ( request , writer . stream )

        writer . close ( )
    } catch {
        fatalError ( " ( error ) " )
    }
}

try ! server . bind ( host : " 0.0.0.0 " , port : 8080 )
print ( " Server listening at 0.0.0.0:8080 " )
try ! server . listen ( )

RunLoop . main . run ( )

Prorsum выпускается под лицензией MIT. Подробности см. в разделе ЛИЦЕНЗИЯ.