syndicate-lang
/
minimart-2014
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

TCP driver; simple example; chat server; chat client

This commit is contained in:
Tony Garnock-Jones 2014-06-02 14:13:12 -04:00
parent bdab665e36
commit 435ab0fbd8
4 changed files with 250 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
minimart/drivers/tcp.rkt Normal file
View File

@ -0,0 +1,139 @@
#lang racket/base
(require racket/match)
(require (prefix-in tcp: racket/tcp))
(require (only-in racket/port read-bytes-avail!-evt))
(require "../main.rkt")
(require "../demand-matcher.rkt")
(require racket/unit)
(require net/tcp-sig)
(require net/tcp-unit)
(provide (struct-out tcp-address)
(struct-out tcp-handle)
(struct-out tcp-listener)
(struct-out tcp-channel)
spawn-tcp-driver)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Protocol messages
(struct tcp-address (host port) #:prefab)
(struct tcp-handle (id) #:prefab)
(struct tcp-listener (port) #:prefab)
(struct tcp-channel (source destination subpacket) #:prefab)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Driver
(define (spawn-tcp-driver)
(list (spawn-demand-matcher (tcp-channel ? (?! (tcp-listener ?)) ?)
#:demand-level 1
#:supply-level 2
spawn-tcp-listener)
(spawn-demand-matcher (tcp-channel (?! (tcp-handle ?)) (?! (tcp-address ? ?)) ?)
#:demand-is-subscription? #f
spawn-tcp-connection)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Listener
(struct listener-state (listener server-addr) #:transparent)
(define (tcp-listener-behavior e state)
(match e
[(routing-update g)
(match-define (listener-state listener server-addr) state)
(if (gestalt-empty? (gestalt-filter g (pub (tcp-channel ? server-addr ?) #:level 2)))
(begin (when listener (tcp:tcp-close listener))
(transition (struct-copy listener-state state [listener #f]) (quit)))
#f)]
[(message (event _ (list (list cin cout))) 1 #f)
(define-values (local-hostname local-port remote-hostname remote-port) (tcp:tcp-addresses cin #t))
(transition state
(spawn-connection (listener-state-server-addr state)
(tcp-address remote-hostname remote-port)
cin
cout))]
[_ #f]))
(define (spawn-tcp-listener server-addr)
(match-define (tcp-listener port) server-addr)
(define listener (tcp:tcp-listen port 4 #t))
(spawn tcp-listener-behavior
(listener-state listener server-addr)
(gestalt-union (pub (tcp-channel ? server-addr ?) #:level 2)
(sub (event (tcp:tcp-accept-evt listener) ?) #:meta-level 1))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Outbound Connection
(define (spawn-tcp-connection local-addr remote-addr)
(match-define (tcp-address remote-hostname remote-port) remote-addr)
(define-values (cin cout) (tcp:tcp-connect remote-hostname remote-port))
(spawn-connection local-addr remote-addr cin cout))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Connection
(struct connection-state (seen-peer? local-addr remote-addr cin cout) #:transparent)
(define (shutdown-connection state)
(define cin (connection-state-cin state))
(define cout (connection-state-cout state))
(when cin (close-input-port cin))
(when cout (close-output-port cout))
(transition (struct-copy connection-state state [cin #f] [cout #f]) (quit)))
(define (read-bytes-avail-evt len input-port)
(guard-evt
(lambda ()
(let ([bstr (make-bytes len)])
(handle-evt
(read-bytes-avail!-evt bstr input-port)
(lambda (v)
(if (number? v)
(if (= v len) bstr (subbytes bstr 0 v))
v)))))))
(define (tcp-connection e state)
(with-handlers [((lambda (exn) #t)
(lambda (exn)
(shutdown-connection state)
(raise exn)))]
(match e
[(message (event _ (list (? eof-object?))) 1 #f)
(shutdown-connection state)]
[(message (event _ (list (? bytes? bs))) 1 #f)
(transition state (send (tcp-channel (connection-state-remote-addr state)
(connection-state-local-addr state)
bs)))]
[(message (tcp-channel _ _ bs) 0 #f)
(write-bytes bs (connection-state-cout state))
(flush-output (connection-state-cout state))
#f]
[(routing-update g)
(cond
[(and (connection-state-seen-peer? state) (gestalt-empty? g))
(shutdown-connection state)]
[(and (not (connection-state-seen-peer? state)) (not (gestalt-empty? g)))
(define new-state (struct-copy connection-state state [seen-peer? #t]))
(transition new-state (routing-update (connection-gestalt new-state)))]
[else
#f])]
[#f #f])))
(define (connection-gestalt state)
(match-define (connection-state seen-peer? local-addr remote-addr cin _) state)
(gestalt-union (pub (tcp-channel remote-addr local-addr ?))
(sub (tcp-channel local-addr remote-addr ?))
(pub (tcp-channel remote-addr local-addr ?) #:level 1)
(if seen-peer?
(sub (event (read-bytes-avail-evt 32768 cin) ?) #:meta-level 1)
(gestalt-empty))))
(define (spawn-connection local-addr remote-addr cin cout)
(define state (connection-state #f local-addr remote-addr cin cout))
(spawn tcp-connection state (connection-gestalt state)))

29
minimart/examples/chat-client.rkt Normal file
View File

@ -0,0 +1,29 @@
#lang minimart
(require (only-in racket/port read-bytes-line-evt))
(require "../drivers/tcp.rkt")
(define local-handle (tcp-handle 'chat))
(define remote-handle (tcp-address "localhost" 5999))
(spawn-tcp-driver)
(spawn (lambda (e seen-remote?)
(match e
[(message (event _ (list (? eof-object?))) 1 #f)
(transition seen-remote? (quit))]
[(message (event _ (list line)) 1 #f)
(transition seen-remote? (send (tcp-channel local-handle remote-handle line)))]
[(message (tcp-channel _ _ bs) 0 #f)
(write-bytes bs)
#f]
[(routing-update g)
(define remote-present? (not (gestalt-empty? g)))
(transition (or seen-remote? remote-present?)
(when (and (not remote-present?) seen-remote?) (quit)))]
[#f #f]))
#f
(gestalt-union (sub (event (read-bytes-line-evt (current-input-port) 'any) ?) #:meta-level 1)
(sub (tcp-channel remote-handle local-handle ?))
(pub (tcp-channel local-handle remote-handle ?))
(pub (tcp-channel local-handle remote-handle ?) #:level 1)))

51
minimart/examples/chat.rkt Normal file
View File

@ -0,0 +1,51 @@
#lang minimart
(require racket/set)
(require (only-in racket/string string-trim))
(require "../drivers/tcp.rkt")
(require "../demand-matcher.rkt")
(struct session (seen-remote? peers) #:transparent)
(define (spawn-session them us)
(define user (gensym 'user))
(define remote-detector (compile-gestalt-projection (?!)))
(define peer-detector (compile-gestalt-projection `(,(?!) says ,?)))
(define (send-to-remote fmt . vs)
(send #:meta-level 1 (tcp-channel us them (string->bytes/utf-8 (apply format fmt vs)))))
(define (say who fmt . vs)
(unless (equal? who user) (send-to-remote "~a ~a\n" who (apply format fmt vs))))
(list (send-to-remote "Welcome, ~a.\n" user)
(spawn (lambda (e state)
(match e
[(message (tcp-channel _ _ bs) 1 #f)
(transition state (send `(,user says ,(string-trim (bytes->string/utf-8 bs)))))]
[(message `(,who says ,what) 0 #f)
(transition state (say who "says: ~a" what))]
[(routing-update g)
(match-define (session seen-remote? old-peers) state)
(define remote-present?
(not (matcher-empty? (gestalt-project g 1 0 #f remote-detector))))
(define new-peers (matcher-key-set/single (gestalt-project g 0 0 #t peer-detector)))
(transition
(struct-copy session state
[seen-remote? (or remote-present? seen-remote?)]
[peers new-peers])
(list (when (and seen-remote? (not remote-present?)) (quit))
(for/list [(who (set-subtract new-peers old-peers))] (say who "arrived."))
(for/list [(who (set-subtract old-peers new-peers))] (say who "departed."))))]
[#f #f]))
(session #f (set))
(gestalt-union (sub `(,? says ,?))
(sub `(,? says ,?) #:level 1)
(pub `(,user says ,?))
(sub (tcp-channel them us ?) #:meta-level 1)
(pub (tcp-channel us them ?) #:meta-level 1)
(pub (tcp-channel us them ?) #:meta-level 1 #:level 1)))))
(spawn-tcp-driver)
(spawn-world
(spawn-demand-matcher (tcp-channel (?! (tcp-address ? ?)) (?! (tcp-listener 5999)) ?)
#:meta-level 1
#:demand-is-subscription? #f
spawn-session))

31
minimart/examples/tcp-hello.rkt Normal file
View File

@ -0,0 +1,31 @@
#lang minimart
(require "../drivers/tcp.rkt")
(require "../demand-matcher.rkt")
(spawn-tcp-driver)
(define server-id (tcp-listener 5999))
(define (spawn-connection-handler c)
(log-info "spawn-connection-handler ~v" c)
(define (connection-handler e n)
(when e (log-info "connection-handler ~v: ~v /// ~v" c e n))
(match e
[(routing-update (? gestalt-empty?)) (transition n (quit))]
[_
(if (< n 20)
(transition (+ n 1) (send (tcp-channel server-id c (string->bytes/utf-8 (format "msg ~v\n" n)))))
#f)]))
(spawn connection-handler
0
(gestalt-union (sub (tcp-channel c server-id ?))
(pub (tcp-channel server-id c ?))
(pub (tcp-channel server-id c ?) #:level 1))))
(spawn-demand-matcher (tcp-channel (?! (tcp-address ? ?)) server-id ?)
#:demand-is-subscription? #f
spawn-connection-handler
(lambda (c)
(log-info "Connection handler ~v decided to exit" c)
'()))