Haskell WebSocket सर्वर

एक बार, कुछ भी नहीं करने के लिए, मैंने एक WebSocket सर्वर लिखने का फैसला किया, और लिखने के बाद, मैंने सोचा कि किसी को यह दिलचस्प लग सकता है कि आलस्य, कार्यात्मक सफाई और अन्य लैम्ब्डा यहाँ कैसे मदद कर सकते हैं।



यह पढ़ने के बाद कि सर्वर सामान्य शब्दों में कैसे काम करता है, मैं लिखने के लिए बैठ गया। प्रोटोकॉल, वैसे, बहुत सरल है। क्लाइंट यादृच्छिक चाबियाँ भेजता है, जवाब में सर्वर कनेक्शन की पुष्टि करता है, इन चाबियों के संयोजन से md5 भेज रहा है। और फिर वे एक-दूसरे को बाइनरी या टेक्स्ट डेटा भेजते हैं, जिसके द्वारा और बड़े अलग नहीं होते हैं।

हाथ मिलाना

ड्राफ्ट खोलें और हैंडशेक फॉर्मेट का विवरण देखें:

field = 1*name-char colon [ space ] *any-char cr lf

colon = %x003A ; U+003A COLON (:)

space = %x0020 ; U+0020 SPACE

cr = %x000D ; U+000D CARRIAGE RETURN (CR)

lf = %x000A ; U+000A LINE FEED (LF)

name-char = %x0000-0009 / %x000B-000C / %x000E-0039 / %x003B-10FFFF

; a Unicode character other than U+000A LINE FEED (LF), U+000D CARRIAGE RETURN (CR), or U+003A COLON (:)

any-char = %x0000-0009 / %x000B-000C / %x000E-10FFFF

; a Unicode character other than U+000A LINE FEED (LF) or U+000D CARRIAGE RETURN (CR)









ठीक है, इसलिए हम इसे लिखते हैं:

field = ( many1 nameChar <& colon <& spaces ) <&> ( many anyChar <& cr <& lf ) where <br>

spaces = ignore ( many space ) [ () ] <br>

colon = lit ':' char<br>

space = lit ' ' char<br>

cr = lit '\r' char<br>

lf = lit '\n' char<br>

unicodeChar = optIf ( <= '\x10FFFF' ) char<br>

nameChar = optIf ( `notElem` ": \r\n" ) unicodeChar<br>

anyChar = optIf ( `notElem` "\r\n" ) unicodeChar<br>









मैं समझाऊंगा कि पहली पंक्ति के उदाहरण पर क्या हो रहा है।

field = ( many1 nameChar <& colon <& spaces ) <&> ( many anyChar <& cr <& lf ) where <br>

spaces = ignore ( many space ) [ () ] <br>









many1



एक मान का वर्णन करता है जो 1 या अधिक बार होता है, many



- 0 या अधिक। ऑपरेटर &>



और <&



क्रमिक रूप से दो नियमों को जोड़ते हैं, जबकि यह दर्शाता है कि हम केवल उनमें से एक के अर्थ में रुचि रखते हैं। इस मामले में, जो मूल्य colon



और spaces



के नियमों का पालन करते हैं, वे हमें रुचि नहीं देते हैं। ऑपरेटर <&>



आपको टुपल के रूप में दोनों मान प्राप्त करने की अनुमति देता है।

lit



फ़ंक्शन सामना करने के लिए कठिन मान सेट करता है, और optIf



एक बाधा optIf



है।



संदेश में हेडर लाइन, फ़ील्ड और फ़ील्ड के बाद एक निश्चित लंबाई का डेटा शामिल होता है।

यह अधिक जटिल नहीं लिखा है:

message = ( toMessage , fromMessage ) `wrap` ( leadingLine <&> many field ) where <br>

toMessage ( ll , fs ) = Message { <br>

messageLeadingLine = ll , <br>

messageFields = fs } <br>

fromMessage ( Message { messageLeadingLine = ll , messageFields = fs } ) = ( ll , fs ) <br>

<br>

body len = cr &> lf &> times len unicodeChar<br>

<br>

leadingLine = many anyChar <& cr <& lf<br>









leadingLine



और body



सब कुछ सरल है, लेकिन wrap



फ़ंक्शन message



परिभाषा में दिखाई देता है। तथ्य यह है कि नियम a <&> b



टपल के लिए नियम को परिभाषित करता है, और हमें किसी प्रकार की आवश्यकता है। इसलिए, हम एक ट्यूपल से परिवर्तित करने के लिए दो कार्य प्रदान करते हैं।



ठीक है, हमने सीखा कि खेतों के साथ एक सार संदेश को पार्स कैसे किया जाए, अब आप Opening



(क्लाइंट से) और Response



(सर्वर प्रतिक्रिया) की दिशा में देख सकते हैं।

उद्घाटन में कुछ फ़ील्ड्स होने चाहिए (कुछ वैकल्पिक हैं), इसलिए हम optIf



में message



नियम को optIf



; और लंबाई में 8 बाइट्स वाला शरीर भी शामिल है।

opening = ( toOpening , fromOpening ) `wrap` ( optIf hasFields message <&> body 8 ) where <br>







कार्य toOpening



, मैं नहीं दूंगा।

Response



साथ Response



यह बिल्कुल वैसा ही है।

फ्रेम्स

उदाहरण के लिए, हाथों से हिला के साथ, अब यह संदेश लेने के लायक है।

एक ही ड्राफ्ट अनुभाग में, आप फ्रेम प्रारूप का विवरण देख सकते हैं:

frames = *frame

frame = text-frame / binary-frame

text-frame = (%x00-7F) *(%x00-FE) %xFF

binary-frame = (%x80-FF) length < as many bytes as given by the length >

length = *(%x80-FF) (%x00-7F)







हम एकमात्र अपवाद के साथ फिर से लिखते हैं जो हम closing-frame



छोड़ देते हैं:

frames = ( takeWhile ( not . isClosing ) , takeWhile ( not . isClosing ) ) `wrap` many frame<br>

frame = optIf isText textFrame <|> optIf isBinary binaryFrame <|> optIf isClosing closingFrame<br>







<|>



ऑपरेटर एक विकल्प है। पहले बाएं नियम को लागू करता है, अगर यह विफल होता है, तो सही।



खुद फ्रेम:

textFrame = ( TextFrame , \ ( TextFrame s ) -> s ) `wrap` ( textFlag &> many frameChar <& frameFF ) where <br>

textFlag = ignore ( optIf ( <= 0x7F ) word8 ) 0x00 <br>

binaryFrame = ( BinaryFrame , \ ( BinaryFrame s ) -> s ) `wrap` ( binaryFlag &> byteSourceLength frameLength ) where <br>

binaryFlag = ignore ( optIf ( liftM2 ( && ) ( > 0x7F ) ( /= 0xFF ) ) word8 ) 0xF0 <br>

closingFrame = check ( 0xFF , 0x00 ) ( word8 <&> word8 ) ClosingFrame <br>







ignore



फ़ंक्शन संबंधित मान को ignore



करता है, और लिखते समय, दूसरे तर्क द्वारा निर्दिष्ट मूल्य को प्रतिस्थापित करता है। यानी textFrame



पढ़ते समय textFrame



हम टेक्स्ट को सभी फ्रेम मानते हैं textFrame



जिसका झंडा 0x7F से अधिक नहीं है, हालांकि, संदेश को textFrame



करते समय, हम हमेशा 0 सेट करते हैं।

byteSourceLength



बाइट्स के एक बादल को लोड / संग्रहीत करता है, इसे इन बाइट्स की संख्या के साथ byteSourceLength



करता है, जो कि पारित नियम ( frameLength



) का उपयोग करके लोड / सहेजा जाएगा।

WebSocket में लंबाई बाइट्स में एक चर आकार है। अंतिम बाइट का संकेत परेशान उच्च बिट है।

frameLength = ( \ ( hs , l ) -> toLength ( hs ++ [ l ] ) , ( init &&& last ) . fromLength ) `wrap` ( many highWord <&> lowWord ) where <br>







toLength



, fromLength



, highWord



और lowWord



छोड़ दूंगा।

सर्वर

अब आप सर्वर जैसा कुछ लिखने का प्रयास कर सकते हैं।

start port onAccept = do <br>

sock <- S . socket S . AF_INET S . Stream S . defaultProtocol<br>

S . bindSocket sock $ S . SockAddrInet port S . iNADDR_ANY<br>

S . listen sock S . maxListenQueue<br>

let <br>

-- . ( ), <br>

-- "" . <br>

canDie e = if fromException e == Just ThreadKilled then throwIO ThreadKilled else return () <br>

-- . <br>

th <- fork $ forever $ canDie `handle` acceptClient sock onAccept<br>

return $ Server th<br>









कनेक्शन प्रतीक्षारत समारोह:

acceptClient socket onAccept = ignore $ accept socket onReceived where <br>







accept



कनेक्शन को accept



करता है और आलसी स्ट्रिंग के रूप में onReceived



फ़ंक्शन को संपूर्ण इनपुट स्ट्रीम पास करता है।



onReceived sock income = do <br>

-- . , anything ( ), <br>

-- , opening. <br>

( o , tailData ) <- letFail $ decode ( opening <&> anything ) income<br>

-- . <br>

r <- letFail ( responseTo o >>= mapException show . encode response ) <br>

-- . <br>

send sock r<br>

let con = connection ( openingChannel o ) ( openingHost o ) ( openingOrigin o ) ( openingProtocol o ) sock<br>

let <br>

-- . callback. <br>

onConnect ClosingFrame = close con `finally` acceptOnClose handlers con<br>

-- . <br>

onConnect f = acceptOnMessage handlers con f<br>

-- callback "". <br>

fork $ acceptOnOpen handlers con<br>

<br>

-- - , . <br>

switch ( const $ return () ) ( mapM_ onConnect ) $ decode frames tailData<br>









आलसी सूचियों के साथ काम करना समझ के लिए सुविधाजनक है: संदेशों की एक सूची है, हम प्रत्येक के लिए संबंधित callback



कहते हैं; लेकिन वहाँ एक चेतावनी है।



उदाहरण के लिए, हम आलसी ByteString



रूप में सभी उपयोगकर्ता इनपुट का प्रतिनिधित्व करना चाहते हैं।

अगर हम इसे इस तरह लिखते हैं:

input <- fix $ \ loop -> unsafeInterleaveIO $ liftM2 ( : ) getLine loop<br>

let byteString = pack $ map charToByte input<br>







फिर एक आलसी ByteString



को प्रिंट करने की कोशिश करते ByteString



, हम प्रभाव की कमी पर बहुत आश्चर्यचकित हो सकते हैं। मामला pack



फ़ंक्शन के कठोरता में प्राथमिक है, इसे एक ही बार में पूरी लाइन की आवश्यकता होती है।

इस मामले में, सभी उपयोगकर्ता इनपुट की एक आलसी सूची प्राप्त करना अधिक सही होगा, और फिर fromChunks



फ़ंक्शन का उपयोग करें। फिर जैसे ही आप टाइप करते हैं, हमारा ByteString



अब एक खाली वादा नहीं ByteString



, लेकिन ईमानदारी से पूरे इनपुट का हिस्सा होगा।

निष्कर्ष

मैंने यह सब क्यों लिखा? खैर, मुझे आशा है कि किसी के पास हास्केल में अतिरिक्त रुचि है, या कार्यात्मक क्षय की निरर्थकता के बारे में कम, संदेह है।