Descarga Prorsum - Descarga del código fuente Prorsum

prorsum

Un sistema concurrente similar a Go + bibliotecas de red/http para Swift que funciona en Linux y Mac.

¿Por qué Prorsum?

La razón por la que comencé este proyecto es porque sentí que era muy difícil manejar io asíncrono con Swift en el proyecto llamado Slimane que había creado anteriormente. En el paradigma asincrónico en Swift, a menudo necesitamos usar bien la lista de captura para cierres y, a veces, retener el objeto (Conexión, etc.) para evitar que ARC lo libere. Entonces pensé que el mecanismo concurrente/paralelo y sincrónico de Go es un modelo adecuado para la etapa actual de Swift (si desea escribir Servidor en la máquina MultiCore). Debido a que podemos realizar operaciones asíncronas fácilmente sin cadenas de devolución de llamada, podemos usar núcleos completos con una sintaxis simple y compartir fácilmente la memoria a través del canal entre un subproceso y un subproceso.

(Prorsum no es Goroutine. No tiene Corotuines y el cambio de contexto se realiza en el lado del sistema operativo. Solo tiene un mecanismo de memoria compartida seguro para subprocesos (funciona en el GCD) que está fuertemente inspirado en Go).

Problema VS C10K

La arquitectura del servidor HTTP de Prorsum es maestro controlado por eventos + controlador de solicitudes de subprocesos múltiples. En DispatchQueue, puede escribir E/S asincrónicas con sintaxis síncrona con go() + Channel<Element> .
Los códigos fáciles de hacer resuelven C10K sin devoluciones de llamada.

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

Características

Ir como equipos

Redes/HTTP

Instalación

Actualmente, Prorsum solo admite SPM.

SPM

import PackageDescription

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

Cocoápodos

Aún no es compatible

Cartago

Aún no es compatible

Uso

`go`

go es un alias de DispatchQueue().async { }

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

go ( asyncTask ( ) )

go {
    print ( Thread . current )
}

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

`WaitGroup`

Un WaitGroup espera a que finalice una colección de operaciones de GCD. La operación principal de GCD llama a Agregar para establecer el número de operaciones de GCD a esperar. Luego, cada una de las operaciones de GCD se ejecuta y llama a Listo cuando finaliza. Al mismo tiempo, se puede utilizar Wait para bloquear hasta que hayan finalizado todas las operaciones de 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 " )

`Channel<Element>`

Los canales son las tuberías que conectan la operación concurrente. Puede enviar valores a canales desde una operación de GCD y recibir esos valores en otra operación de GCD.

 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`

La instrucción select permite que BlockOperation espere en múltiples operaciones de comunicación.

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

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

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

    otherwise {
        print ( " otherwise " )
    }
}

`forSelect`

Generalmente es necesario envolver la selección dentro de un bucle while. Para facilitar el trabajo con este patrón, puede utilizar forSelect . forSelect se repetirá hasta que se llame 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 " )
    }
}

Redes

Servidor HTTP

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

Cliente HTTP/HTTPS

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."

tcp

 #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

Websocket

Aquí hay un ejemplo de servidor Websocket Echo.

 #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 ( )