Prorsum
0.3.3: Merge pull request #56 from GetBlast
Un système simultané Go + bibliothèques réseau/http pour Swift qui fonctionne sous Linux et Mac.
La raison pour laquelle j'ai commencé ce projet est parce que je sentais qu'il était très difficile de gérer les io asynchrones avec Swift dans le projet appelé Slimane que j'avais réalisé précédemment. Dans le paradigme asynchrone de Swift, nous devons souvent bien utiliser la liste de capture pour les fermetures et parfois conserver l'objet (Connexion etc.) pour éviter sa libération par ARC. Ensuite, j'ai pensé que le mécanisme concurrent/parallèle et synchrone de Go était un modèle approprié pour l'étape actuelle de Swift (si vous souhaitez écrire un serveur sur la machine multicœur). Parce que nous pouvons facilement effectuer des opérations asynchrones sans chaînes de rappel, nous pouvons utiliser des Full Cores avec une syntaxe simple et partager facilement la mémoire via Channel entre un thread et un thread.
(Prorsum n'est pas Goroutine. Il n'a pas de corotuines et le changement de contexte est effectué du côté du système d'exploitation. Il a juste un mécanisme de mémoire partagée thread-safe (il fonctionne sur le GCD) qui est fortement inspiré de Go.)
L'architecture du serveur HTTP de Prorsum est un maître piloté par les événements + un gestionnaire de requêtes multithreading. Dans un DispatchQueue, vous pouvez écrire des E/S asynchrones avec une syntaxe synchrone avec go() + Channel<Element> .
Des codes faciles à créer résolvent C10K sans rappels.
+-----------------+
|-- | Request Handler |
| +-----------------+
+--------+ | +-----------------+
----- TCP ---- | master |---Dispatch Queue---|-- | Request Handler |
+--------+ | +-----------------+
| +-----------------+
|-- | Request Handler |
+-----------------+
Actuellement, Prorsum ne prend en charge que SPM.
import PackageDescription
let package = Package (
name : " MyApp " ,
dependencies : [
. Package ( url : " https://github.com/noppoMan/Prorsum.git " , majorVersion : 0 , minor : 1 )
]
)Pas encore pris en charge
Pas encore pris en charge
go go est 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
}WaitGroupUn WaitGroup attend la fin d’une collection d’opérations GCD. L'opération GCD principale appelle Add pour définir le nombre d'opérations GCD à attendre. Ensuite, chacune des opérations GCD s'exécute et appelle Done une fois terminée. Dans le même temps, Wait peut être utilisé pour bloquer jusqu'à ce que toutes les opérations GCD soient terminées.
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>Les canaux sont les canaux qui relient les opérations simultanées. Vous pouvez envoyer des valeurs dans des canaux à partir d'une opération GCD et recevoir ces valeurs dans une autre opération 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 L'instruction select permet à une BlockOperation d'attendre plusieurs opérations de communication.
let magicCh = Channel < String > . make ( capacity : 1 )
go {
try ! magicCh . send ( " Obliviate " )
}
select {
when ( magicCh ) {
print ( $0 )
}
otherwise {
print ( " otherwise " )
}
}forSelect Généralement, vous devez envelopper la sélection dans une boucle while. Pour faciliter le travail avec ce modèle, vous pouvez utiliser forSelect . forSelect bouclera jusqu'à ce done() soit appelé.
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 loopimport 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 loopVoici un exemple de serveur 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 ( ) Prorsum est publié sous licence MIT. Voir LICENCE pour plus de détails.
