👩‍🏫 🔵 🈲 खुद का HTTP सर्वर 40 से कम लाइनों में काम करने वाला और C ++ 11 में कोड है 🏔️ ✍️ 🔅

समय-समय पर हैबर के माध्यम से देखते हुए, मैं समय-समय पर C ++ या किसी अन्य भाषा में अपना स्वयं का वेब सर्वर बनाने के विषय पर पोस्टों पर आता हूं। चूंकि प्रोग्रामिंग भाषाओं से C ++ मेरे लिए अधिक रुचि रखता है, इसलिए मैंने इस ब्लॉग को सबसे अधिक पढ़ा। यदि आप इसके माध्यम से देखते हैं, तो आप आसानी से अपने वेब सर्वर को "सॉकेट्स" पर लिखने के लिए पा सकते हैं। कुछ समय पहले, मैंने एक परीक्षण कार्य को हल करने के उदाहरण के रूप में इस तरह के http-server के निर्माण पर अपनी पोस्ट भी प्रकाशित की। लेकिन प्राप्त एक के लिए सीमित नहीं है और हित के लिए, मैंने libevent और boost.asio विकास के साथ तुलना की। और इस तरह, उन्होंने परीक्षण कार्य करने से इनकार कर दिया।

खुद के लिए, काम पर, मैंने कामवासना और कामवासना पर विचार किया। प्रत्येक के अपने फायदे हैं। यदि एक छोटे http-सर्वर के तेजी से विकास की इच्छा या आवश्यकता है, तो libevent मेरे लिए बहुत रुचि है, और कुछ C ++ 11 नवाचारों के साथ, कोड बहुत अधिक कॉम्पैक्ट हो जाता है और आपको 40 लाइनों से कम में एक मूल http-सर्वर बनाने की अनुमति देता है।

पोस्ट की सामग्री संभवतः उन लोगों के लिए उपयोगी होगी जो अभी तक परिवाद से परिचित नहीं हैं और जल्द ही अपना स्वयं का http-server बनाने की आवश्यकता है, साथ ही सामग्री उन लोगों के लिए भी रुचि की हो सकती है जिनके पास अभी तक ऐसी कोई आवश्यकता नहीं है, और यहां तक कि उनके पास पहले से ही एक बनाने का अनुभव था, यह जानना दिलचस्प है उनकी राय और अनुभव। और चूंकि पोस्ट में मौलिक रूप से नया कुछ भी नहीं है, इसलिए इसका उपयोग इस दिशा में काम शुरू करने के लिए सामग्री के रूप में किया जा सकता है, और इसलिए मैं "प्रशिक्षण सामग्री" पर ध्यान देने की कोशिश करूंगा।

उदाहरण के लिए, libev और boost.asio के विपरीत, libevent के बारे में क्या अच्छा है, यह है कि इसका अपना अंतर्निहित http-server है, और बफ़र्स के साथ काम करने के लिए कुछ अमूर्तता है। इसमें सहायक कार्यों का काफी समूह भी है। आप एक साधारण राज्य मशीन या किसी अन्य विधि को लिखकर स्वयं HTTP प्रोटोकॉल को पार्स कर सकते हैं। जब libevent के साथ काम करते हैं, तो यह सब कुछ है। यह इतनी अच्छी छोटी बात है, या आप कम स्तर पर जा सकते हैं और HTTP के लिए अपना खुद का पार्सर लिख सकते हैं, जबकि libevent पर सॉकेट्स के साथ काम कर रहे हैं। मुझे लाइब्रेरी में विस्तार का स्तर पसंद आया क्योंकि यदि आप जल्दी से कुछ करना चाहते हैं, तो आप इसमें उच्च-स्तरीय इंटरफ़ेस पा सकते हैं, जो आमतौर पर कम लचीला होता है। बड़ी जरूरतों के उद्भव के साथ, आप धीरे-धीरे निचले स्तर और निचले स्तर के बाद नीचे जा सकते हैं। पुस्तकालय आपको कई चीजें करने की अनुमति देता है: अतुल्यकालिक इनपुट-आउटपुट, नेटवर्क के साथ काम करना, टाइमर के साथ काम करना, आरपीसी, आदि। आप इसका उपयोग सर्वर और क्लाइंट सॉफ्टवेयर दोनों बनाने के लिए कर सकते हैं।

क्यों?

अपना खुद का छोटा http-सर्वर बनाना अपनी जरूरतों, इच्छा या अनिच्छा से प्रत्येक के लिए एक कारण या किसी अन्य के लिए पूरी तरह कार्यात्मक तैयार किए गए सर्वर का उपयोग करने के कारण हो सकता है। मान लें कि आपके पास कुछ सर्वर सॉफ़्टवेयर है जो अपने प्रोटोकॉल के अनुसार काम करता है और कुछ समस्याओं को हल करता है, और आपको HTTP प्रोटोकॉल के माध्यम से इस सॉफ़्टवेयर के लिए कुछ एपीआई जारी करने की आवश्यकता है। सर्वर को कॉन्फ़िगर करने और HTTP के माध्यम से इसकी वर्तमान स्थिति प्राप्त करने के लिए केवल कुछ छोटे कार्य संभव हैं। उदाहरण के लिए, मापदंडों के साथ GET अनुरोधों के प्रसंस्करण को व्यवस्थित करने और प्रतिक्रिया या किसी अन्य प्रारूप में एक छोटे से xml दिया जाता है। इस मामले में, आप थोड़े प्रयास से अपना खुद का http-server बना सकते हैं, जो आपके मुख्य सर्वर सॉफ़्टवेयर के लिए इंटरफ़ेस होगा। इसके अलावा, यदि आपको फ़ाइलों के एक निश्चित सेट को वितरित करने के लिए अपनी खुद की छोटी विशिष्ट सेवा बनाने की आवश्यकता है या यहां तक कि अपना स्वयं का वेब एप्लिकेशन भी बनाना है, तो आप ऐसे स्व-निर्मित छोटे सर्वर का भी उपयोग कर सकते हैं। सामान्य तौर पर, आप इसका उपयोग स्व-निहित सर्वर सॉफ़्टवेयर के निर्माण के लिए कर सकते हैं, साथ ही साथ बड़ी प्रणालियों के भीतर समर्थन सेवाएं बनाने के लिए भी कर सकते हैं।

40 से कम लाइनों में सरल http सर्वर

Libevent का उपयोग करके एक साधारण एकल-थ्रेडेड http सर्वर बनाने के लिए, आपको इन कुछ सरल चरणों का पालन करने की आवश्यकता है:

Event_init फ़ंक्शन का उपयोग करके वैश्विक लाइब्रेरी ऑब्जेक्ट को प्रारंभ करें। यह फ़ंक्शन केवल एकल-थ्रेडेड प्रसंस्करण के लिए उपयोग किया जा सकता है। बहु-थ्रेडेड कार्य के लिए, प्रत्येक थ्रेड के लिए एक ऑब्जेक्ट बनाया जाना चाहिए (नीचे इस पर अधिक)।
एक वैश्विक इवेंट प्रोसेसिंग ऑब्जेक्ट वाले एकल-थ्रेडेड सर्वर के मामले में http सर्वर का निर्माण स्वयं evhttp_start फ़ंक्शन द्वारा किया जाता है। अंत में evhttp_start के साथ बनाई गई एक वस्तु को evhttp_free के साथ हटा दिया जाना चाहिए।
आने वाले अनुरोधों का जवाब देने के लिए, आपको evhttp_set_gencb का उपयोग करके कॉलबैक फ़ंक्शन सेट करना होगा।
तब आप Event_dispatch फ़ंक्शन के साथ ईवेंट लूप प्रारंभ कर सकते हैं। यह फ़ंक्शन एक वैश्विक ऑब्जेक्ट के साथ एकल थ्रेड में काम करने के लिए भी डिज़ाइन किया गया है।
अनुरोध संसाधित करते समय, आप evhttp_request_get_output_buffer फ़ंक्शन के साथ प्रतिक्रिया के लिए एक बफर प्राप्त कर सकते हैं। इस बफ़र में कुछ सामग्री जोड़ें। उदाहरण के लिए, आप एक स्ट्रिंग भेजने के लिए evbuffer_add_printf फ़ंक्शन का उपयोग कर सकते हैं और एक फ़ाइल भेजने के लिए evbuffer_add_file। उसके बाद, अनुरोध की प्रतिक्रिया भेजी जानी चाहिए, और यह evhttp_send_reply का उपयोग करके किया जा सकता है।

40 से कम लाइनों में एकल-थ्रेडेड सर्वर कोड:

#include <memory> #include <cstdint> #include <iostream> #include <evhttp.h> int main() { if (!event_init()) { std::cerr << "Failed to init libevent." << std::endl; return -1; } char const SrvAddress[] = "127.0.0.1"; std::uint16_t SrvPort = 5555; std::unique_ptr<evhttp, decltype(&evhttp_free)> Server(evhttp_start(SrvAddress, SrvPort), &evhttp_free); if (!Server) { std::cerr << "Failed to init http server." << std::endl; return -1; } void (*OnReq)(evhttp_request *req, void *) = [] (evhttp_request *req, void *) { auto *OutBuf = evhttp_request_get_output_buffer(req); if (!OutBuf) return; evbuffer_add_printf(OutBuf, "<html><body><center><h1>Hello Wotld!</h1></center></body></html>"); evhttp_send_reply(req, HTTP_OK, "", OutBuf); }; evhttp_set_gencb(Server.get(), OnReq, nullptr); if (event_dispatch() == -1) { std::cerr << "Failed to run messahe loop." << std::endl; return -1; } return 0; }

यह 40 पंक्तियों से कम निकला, जो http अनुरोधों को संसाधित करने में सक्षम हैं, स्ट्रिंग "हैलो वर्ल्ड" लौटाते हैं, और यदि आप evbuffer_add_printf फ़ंक्शन को evbuffer_add_file से प्रतिस्थापित करते हैं, तो आप फ़ाइलें भेज सकते हैं। आप इस सर्वर को मूल विन्यास कह सकते हैं। अधिकांश भाग के लिए, किसी भी ऑटो डीलर या रियाल्टार का सपना है कि उनकी कार और अपार्टमेंट कभी भी, किसी भी परिस्थिति में, मानक के रूप में बंद न हों, लेकिन केवल अतिरिक्त विकल्पों के साथ। लेकिन क्या इस तरह के विकल्पों की जरूरत उपभोक्ता को है और किस हद तक ...

इस तरह के एक बुनियादी प्रदर्शन पैकेज प्रदान कर सकते हैं मापदंडों में मामूली बदलाव के साथ * nix सिस्टम के लिए ab उपयोगिता का उपयोग करके जाँच की जा सकती है।

ab -c 1000 -k -r -t 10 http: //127.0.0.15 555 /

सर्वर सॉफ्टवेयर:
सर्वर होस्टनाम: 127.0.0.1
सर्वर पोर्ट: 5555

दस्तावेज़ पथ: /
दस्तावेज़ की लंबाई: 64 बाइट्स

सम्‍मिलितता स्तर: 1000
परीक्षणों के लिए लिया गया समय: 2.289 सेकंड
पूर्ण अनुरोध: 50,000
विफल अनुरोध: 0
त्रुटियों को लिखें: 0
रख-रखाव अनुरोध: 50,000
कुल हस्तांतरित: 8500000 बाइट्स
HTML स्थानांतरित: 3200000 बाइट्स
प्रति सेकंड अनुरोध: 21843.76 [# / सेकंड] (मतलब)
अनुरोध के अनुसार समय: 45.780 [एमएस] (मतलब)
अनुरोध के अनुसार समय: 0.046 [एमएस] (मतलब, सभी समवर्ती अनुरोधों के पार)
स्थानांतरण दर: 3626.41 [Kbytes / sec] प्राप्त किया

कनेक्शन टाइम्स (एमएस)
मिन का मतलब है [] sd] माध्यिका अधिकतम
कनेक्ट: 0 3 48.6 0 1001
प्रसंस्करण: 17 42 9.0 43 93
प्रतीक्षा: 17 42 9.0 43 93
कुल: 19 45 49.7 43 1053

ab -c 1000 -r -t 10 http: //127.0.0.15555/

सर्वर सॉफ्टवेयर:
सर्वर होस्टनाम: 127.0.0.1
सर्वर पोर्ट: 5555

दस्तावेज़ पथ: /
दस्तावेज़ की लंबाई: 64 बाइट्स

सम्‍मिलितता स्तर: 1000
परीक्षणों के लिए समय लिया गया: 5.004 सेकंड
पूर्ण अनुरोध: 50,000
विफल अनुरोध: 0
त्रुटियों को लिखें: 0
कुल हस्तांतरित: 6,300,000 बाइट्स
HTML स्थानांतरित: 3200000 बाइट्स
प्रति सेकंड अनुरोध: 9992.34 [# / सेकंड] (माध्य)
अनुरोध के अनुसार समय: 100.077 [एमएस] (मतलब)
अनुरोध के अनुसार समय: 0.100 [एमएस] (मतलब, सभी समवर्ती अनुरोधों के पार)
स्थानांतरण दर: 1229.53 [Kbytes / sec] प्राप्त किया

कनेक्शन टाइम्स (एमएस)
मिन का मतलब है [] sd] माध्यिका अधिकतम
कनेक्ट: 0 61 214.1 20 3028
प्रसंस्करण: 7 34 17.6 31 277
प्रतीक्षा: 6 28 16.9 25 267
कुल: 17 95 219.5 50 3055

परीक्षण 32-बिट Ubuntu 12.10 ऑपरेटिंग सिस्टम पर चलने वाले एक नए लैपटॉप (2 कोर, 4 जीबी रैम) पर आयोजित किया गया था।

मल्टीथ्रेडेड http सर्वर

क्या मल्टीथ्रेडिंग आवश्यक है? सवाल बयानबाजी का है ... आप सभी आईओ को एक सूत्र में व्यवस्थित कर सकते हैं, और अनुरोधों को एक कतार में रख सकते हैं और इसे कई धागों में पिरो सकते हैं। इस मामले में, उपरोक्त सर्वर को केवल एक कतार और प्रसंस्करण के लिए थ्रेड्स के पूल के साथ पूरक किया जा सकता है और कुछ भी नहीं किया जाना चाहिए। यदि एक बहु-थ्रेडेड सर्वर बनाने की इच्छा या आवश्यकता है, तो यह पिछले एक की तुलना में थोड़ा लंबा होगा, लेकिन बहुत अधिक नहीं। अपने स्मार्ट पॉइंटर्स के साथ सी ++ 11 आपको आरएआई को अच्छी तरह से लागू करने की अनुमति देता है, जैसा कि ऊपर दिए गए उदाहरण में std :: unique_ptr के साथ दिखाया गया था, और लैम्ब्डा कार्यों की उपस्थिति कोड को थोड़ा कम करती है।

एक मल्टीथ्रेड सर्वर का एक उदाहरण इसकी विचारधारा में एकल-थ्रेडेड के समान है, और मल्टीथ्रेडिंग से जुड़ी कुछ विशेषताएं इसे कोड की मात्रा से लगभग 2 गुना बढ़ाती हैं। C ++ में एक बहु-थ्रेडेड http सर्वर के लिए कोड की कुछ पंक्तियों के साथ अस्सी इतना नहीं है।

एक समाधान जो बनाया जा सकता है:

कई धागे बनाएँ, उदाहरण के लिए, प्रोसेसर कोर की दोगुनी संख्या के बराबर। C ++ 11 में थ्रेड्स के साथ काम करने के लिए समर्थन है और अब आपको अपने स्वयं के रैपर लिखने की आवश्यकता नहीं है।
प्रत्येक थ्रेड के लिए, event_base_new फ़ंक्शन का उपयोग करके अपना स्वयं का ईवेंट हैंडलिंग ऑब्जेक्ट बनाएं। अंत में बनाई गई वस्तु को event_base_free फ़ंक्शन द्वारा हटा दिया जाना चाहिए, और std :: unique_ptr और RAII इसे और अधिक कॉम्पैक्ट रूप से करने की अनुमति देते हैं।
प्रत्येक स्ट्रीम के लिए, उपरोक्त ऑब्जेक्ट को ध्यान में रखते हुए, evhttp_new फ़ंक्शन का उपयोग करके अपना स्वयं का http-server ऑब्जेक्ट बनाएं। इस ऑब्जेक्ट को भी अंत में हटा दिया जाना चाहिए, और यह evhttp_free का उपयोग करके किया जा सकता है।
पिछले उदाहरण के रूप में, evhttp_set_gencb का उपयोग करके अनुरोध हैंडलर स्थापित करें।
यह कदम सबसे अजीब हो सकता है। कई हैंडलर के लिए नेटवर्क इंटरफ़ेस में सॉकेट को बनाना और बांधना आवश्यक है, जिनमें से प्रत्येक अपने स्वयं के धागे में स्थित है। यहां आप सॉकेट्स के साथ काम करने के लिए एपीआई का उपयोग कर सकते हैं (एक सॉकेट बनाएं, इसे कॉन्फ़िगर करें, इसे एक विशिष्ट इंटरफ़ेस से बांधें), और फिर evhttp_accept_socket फ़ंक्शन के साथ सर्वर के संचालन के लिए सॉकेट पास करें। यह एक लंबा समय है। Libevent इस समस्या को हल करने के लिए कई कार्य प्रदान करता है। जैसा कि पहले ही ऊपर उल्लेख किया गया है, libevent यह संभव बनाता है, यदि आवश्यक हो, तो आवश्यकता के आधार पर एक स्तर नीचे और नीचे जाने के लिए और अपने लिए इष्टतम एक चुनें। इस स्थिति में, पहले थ्रेड के लिए, एक सॉकेट बनाने का सारा कार्य, उसका कॉन्फ़िगरेशन और बाइंडिंग evhttp_bind_socket_with_handle फ़ंक्शन द्वारा किया जाता है, और अन्य फ्लो के लिए सॉकेट को evhttp_bound_socket_get_fd का उपयोग करके कॉन्फ़िगर ऑब्जेक्ट से निकाला जाता है। अन्य सभी धागे पहले से ही प्राप्त सॉकेट का उपयोग करते हैं, इसे evhttp_accept_socket फ़ंक्शन द्वारा प्रसंस्करण के लिए सेट करते हैं। सॉकेट्स के साथ काम करने के लिए एपीआई का उपयोग करने की तुलना में थोड़ा अजीब, लेकिन बहुत आसान है और क्रॉस-प्लेटफॉर्म पर विचार करने पर भी आसान है। ऐसा लगता है कि बर्कले सॉकेट्स के लिए एपीआई समान है, लेकिन अगर आपने इसका उपयोग करके क्रॉस-प्लेटफ़ॉर्म सॉफ़्टवेयर लिखा है, उदाहरण के लिए, विंडोज और लिनक्स के लिए, तो एक ऑपरेटिंग सिस्टम के लिए लिखा कोड निश्चित रूप से दूसरे के लिए कोड के बराबर नहीं है।
इवेंट लूप प्रारंभ करें। एकल-थ्रेडेड सर्वर के विपरीत, यह एक अलग तरीके से किया जाना चाहिए, क्योंकि सभी के पास अलग-अलग ऑब्जेक्ट हैं। Libevent (event_base_dispatch) में इसके लिए एक विशेष कार्य है। अपने लिए, मुझे इसमें एक माइनस दिखाई देता है - इसे सही तरीके से सही करना मुश्किल है (उदाहरण के लिए, आपको एक ऐसी स्थिति की आवश्यकता है जिसमें आप event_base_loopexit कह सकते हैं)। ऐसा करने के लिए, आपको थोड़ा चकमा देने की आवश्यकता है। और इसलिए आप function event_base_loop का उपयोग कर सकते हैं। यह फ़ंक्शन अवरुद्ध नहीं है भले ही कोई प्रक्रिया करने के लिए इवेंट न हों, यह नियंत्रण लौटाता है, जो इवेंट प्रोसेसिंग चक्र और कॉल के बीच कुछ करने की क्षमता को पूरा करने का एक सरलीकृत अवसर देता है। एक शून्य भी है - व्यर्थ में प्रोसेसर निष्क्रिय का उपयोग नहीं करने के लिए, आपको कम से कम थोड़ी देरी (सी ++ 11 में - यह कुछ इस तरह से करना आसान है: std :: this_thread :: sleep_for (std :: chrono :: milliseconds (10)) सेट करने की आवश्यकता है )।
अनुरोध प्रसंस्करण पहले उदाहरण के समान है।
अगले धागे के निर्माण और विन्यास के दौरान, इसके कार्य में कुछ गड़बड़ हो सकती है: उदाहरण के लिए, कुछ परिवाद फ़ंक्शन ने एक त्रुटि की सूचना दी। इस स्थिति में, आप एक अपवाद को फेंक सकते हैं और इसे पकड़ सकते हैं, और फिर इसे उसी C ++ 11 टूल (std :: अपवाद_ptr, std :: current_exception और std :: rethrow_exception) का उपयोग करके स्ट्रीम के बाहर भेज सकते हैं

सरल मल्टीथ्रेडेड सर्वर कोड:

 #include <stdexcept> #include <iostream> #include <memory> #include <chrono> #include <thread> #include <cstdint> #include <vector> #include <evhttp.h> int main() { char const SrvAddress[] = "127.0.0.1"; std::uint16_t const SrvPort = 5555; int const SrvThreadCount = 4; try { void (*OnRequest)(evhttp_request *, void *) = [] (evhttp_request *req, void *) { auto *OutBuf = evhttp_request_get_output_buffer(req); if (!OutBuf) return; evbuffer_add_printf(OutBuf, "<html><body><center><h1>Hello Wotld!</h1></center></body></html>"); evhttp_send_reply(req, HTTP_OK, "", OutBuf); }; std::exception_ptr InitExcept; bool volatile IsRun = true; evutil_socket_t Socket = -1; auto ThreadFunc = [&] () { try { std::unique_ptr<event_base, decltype(&event_base_free)> EventBase(event_base_new(), &event_base_free); if (!EventBase) throw std::runtime_error("Failed to create new base_event."); std::unique_ptr<evhttp, decltype(&evhttp_free)> EvHttp(evhttp_new(EventBase.get()), &evhttp_free); if (!EvHttp) throw std::runtime_error("Failed to create new evhttp."); evhttp_set_gencb(EvHttp.get(), OnRequest, nullptr); if (Socket == -1) { auto *BoundSock = evhttp_bind_socket_with_handle(EvHttp.get(), SrvAddress, SrvPort); if (!BoundSock) throw std::runtime_error("Failed to bind server socket."); if ((Socket = evhttp_bound_socket_get_fd(BoundSock)) == -1) throw std::runtime_error("Failed to get server socket for next instance."); } else { if (evhttp_accept_socket(EvHttp.get(), Socket) == -1) throw std::runtime_error("Failed to bind server socket for new instance."); } for ( ; IsRun ; ) { event_base_loop(EventBase.get(), EVLOOP_NONBLOCK); std::this_thread::sleep_for(std::chrono::milliseconds(10)); } } catch (...) { InitExcept = std::current_exception(); } }; auto ThreadDeleter = [&] (std::thread *t) { IsRun = false; t->join(); delete t; }; typedef std::unique_ptr<std::thread, decltype(ThreadDeleter)> ThreadPtr; typedef std::vector<ThreadPtr> ThreadPool; ThreadPool Threads; for (int i = 0 ; i < SrvThreadCount ; ++i) { ThreadPtr Thread(new std::thread(ThreadFunc), ThreadDeleter); std::this_thread::sleep_for(std::chrono::milliseconds(500)); if (InitExcept != std::exception_ptr()) { IsRun = false; std::rethrow_exception(InitExcept); } Threads.push_back(std::move(Thread)); } std::cout << "Press Enter fot quit." << std::endl; std::cin.get(); IsRun = false; } catch (std::exception const &e) { std::cerr << "Error: " << e.what() << std::endl; } return 0; }

कोड में, आप देख सकते हैं कि प्रत्येक थ्रेड कुछ प्रतीक्षा के बाद बनाया गया है। यह एक छोटी सी हैक है जो पहले से ही सर्वर के अंतिम संस्करण में तय हो जाएगी। अभी के लिए, हम केवल यह कह सकते हैं कि यदि ऐसा नहीं किया जाता है, तो थ्रेड्स को किसी तरह से सिंक्रनाइज़ करने की आवश्यकता होगी ताकि वे सॉकेट बनाने और बांधने के लिए "अजीब कदम" का काम करें। सरलता के लिए, इस हैक को अभी रहने दें। इसके अलावा उपरोक्त कोड में, लैम्ब्डा फ़ंक्शन एक विवादास्पद समाधान लग सकता है। जब इस्तेमाल किया जाता है, तो लैम्ब्डा एक अच्छा समाधान हो सकता है, उदाहरण के लिए, मानक एल्गोरिदम के साथ काम करते समय किसी प्रकार का विधेय। उसी समय, आप कोड के बड़े टुकड़े लिखते समय उनके उपयोग के बारे में सोच सकते हैं। ऊपर दिए गए उदाहरण में, आप एक नियमित फ़ंक्शन में सब कुछ डाल सकते हैं, सभी आवश्यक पैरामीटर पास कर सकते हैं और कोड को C ++ 03 शैली में प्राप्त कर सकते हैं। इसी समय, लैम्ब्डा के उपयोग से कोड की मात्रा कम हो गई है। मेरी राय में, जब कोड छोटा होता है, तो लैम्ब्डा अपनी छोटी से छोटी सामग्री के साथ भी काफी अच्छी तरह से इसमें फिट हो सकते हैं और कोड की गुणवत्ता पर प्रतिकूल प्रभाव नहीं डालते हैं, बेशक आपको चरम सीमा पर नहीं जाना चाहिए और केवल 700 लाइनों में लेखन कार्य के साथ छात्र की रोजमर्रा की जिंदगी को याद करना चाहिए। मुख्य कार्य।

बहुस्तरीय सर्वर का परीक्षण पिछले उदाहरण के समान मापदंडों के साथ किया गया था।

ab -c 1000 -k -r -t 10 http: //127.0.0.15 555 /

सर्वर सॉफ्टवेयर:
सर्वर होस्टनाम: 127.0.0.1
सर्वर पोर्ट: 5555

दस्तावेज़ पथ: /
दस्तावेज़ की लंबाई: 64 बाइट्स

सम्‍मिलितता स्तर: 1000
परीक्षणों के लिए लिया गया समय: 1.576 सेकंड
पूर्ण अनुरोध: 50,000
विफल अनुरोध: 0
त्रुटियों को लिखें: 0
रख-रखाव अनुरोध: 50,000
कुल हस्तांतरित: 8500000 बाइट्स
HTML स्थानांतरित: 3200000 बाइट्स
प्रति सेकंड अनुरोध: 31717.96 [# / सेकंड] (मतलब)
अनुरोध के अनुसार समय: 31.528 [एमएस] (मतलब)
अनुरोध के अनुसार समय: 0.032 [एमएस] (मतलब, सभी समवर्ती अनुरोधों के पार)
स्थानांतरण दर: 5265.68 [Kbytes / sec] प्राप्त किया

ab -c 1000 -r -t 10 http: //127.0.0.15555/

सर्वर सॉफ्टवेयर:
सर्वर होस्टनाम: 127.0.0.1
सर्वर पोर्ट: 5555

दस्तावेज़ पथ: /
दस्तावेज़ की लंबाई: 64 बाइट्स

सम्‍मिलितता स्तर: 1000
परीक्षणों के लिए लिया गया समय: 3.685 सेकंड
पूर्ण अनुरोध: 50,000
विफल अनुरोध: 0
त्रुटियों को लिखें: 0
कुल हस्तांतरित: 6,300,000 बाइट्स
HTML स्थानांतरित: 3200000 बाइट्स
प्रति सेकंड अनुरोध: 13568.41 [# / सेकंड] (मतलब)
अनुरोध के अनुसार समय: 73.701 [एमएस] (मतलब)
अनुरोध के अनुसार समय: 0.074 [एमएस] (मतलब, सभी समवर्ती अनुरोधों के पार)
स्थानांतरण दर: 1669.55 [Kbytes / sec] प्राप्त किया

कनेक्शन टाइम्स (एमएस)
मिन का मतलब है [] sd] माध्यिका अधिकतम
कनेक्ट: 0 36 117.2 23 1033
प्रसंस्करण: 3 37 10.0 37 247
प्रतीक्षा: 3 30 8.7 30 242
कुल: ९ .8३ ११ 9. :६ 61 १०। ९

सर्वर का अंतिम संस्करण

बुनियादी उपकरण प्रदान किए जाते हैं, विकल्पों के एक छोटे सेट के साथ उपकरण भी होते हैं। अब बारी आई और कुछ अधिक उपयोगी और कार्यात्मक बनाने के लिए, साथ ही साथ थोड़ी ट्यूनिंग के साथ।

न्यूनतम http सर्वर:

 #include "http_server.h" #include "http_headers.h" #include "http_content_type.h" #include <iostream> int main() { try { using namespace Network; HttpServer Srv("127.0.0.1", 5555, 4, [&] (IHttpRequestPtr req) { req->SetResponseAttr(Http::Response::Header::Server::Value, "MyTestServer"); req->SetResponseAttr(Http::Response::Header::ContentType::Value, Http::Content::Type::html::Value); req->SetResponseString("<html><body><center><h1>Hello Wotld!</h1></center></body></html>"); }); std::cout << "Press Enter for quit." << std::endl; std::cin.get(); } catch (std::exception const &e) { std::cout << e.what() << std::endl; } return 0; }

C ++ http सर्वर के लिए बहुत कम मात्रा में कोड। हर चीज के लिए एक शुल्क है। और इस मामले में, सर्वर बनाने के लिए क्लाइंट कोड की इस तरह की सादगी का भुगतान लिबर्टीवेंट पर प्रस्तावित आवरण में लंबे समय तक कार्यान्वयन द्वारा किया जाता है। वास्तव में, बिक्री में थोड़ी वृद्धि हुई है। नीचे, इसके अंशों का वर्णन किया जाएगा।

सर्वर क्रिएशन:

आपको एक प्रकार का ऑब्जेक्ट बनाना होगा HttpServer। मापदंडों के रूप में, कम से कम उस पते और पोर्ट को पास करें जिस पर सर्वर काम करेगा, प्रसंस्करण अनुरोधों के लिए थ्रेड्स और फ़ंक्शन की संख्या (इस मामले में, क्योंकि अनुरोध प्रसंस्करण न्यूनतम है, आप एक अलग फ़ंक्शन या एक संपूर्ण हैंडलर वर्ग बनाए बिना थोड़ा सा लंबोदा कर सकते हैं) । ऑब्जेक्ट बनाने के बाद, सर्वर तब तक काम करेगा जब तक उसका ऑब्जेक्ट मौजूद है।
हैंडलर IHttpRequest इंटरफ़ेस के लिए एक स्मार्ट पॉइंटर को स्वीकार करता है, जिसके कार्यान्वयन से सभी काम लिबरवेंट बफर के साथ छिप जाते हैं और एक प्रतिक्रिया भेजते हैं, और इसके तरीकों से आने वाले अनुरोध से डेटा प्राप्त करना और प्रतिक्रिया तैयार करना संभव हो जाता है।

IHttpRequest इंटरफ़ेस

 namespace Network { DECLARE_RUNTIME_EXCEPTION(HttpRequest) struct IHttpRequest { enum class Type { HEAD, GET, PUT, POST }; typedef std::unordered_map<std::string, std::string> RequestParams; virtual ~IHttpRequest() {} virtual Type GetRequestType() const = 0; virtual std::string const GetHeaderAttr(char const *attrName) const = 0; virtual std::size_t GetContentSize() const = 0; virtual void GetContent(void *buf, std::size_t len, bool remove) const = 0; virtual std::string const GetPath() const = 0; virtual RequestParams const GetParams() const = 0; virtual void SetResponseAttr(std::string const &name, std::string const &val) = 0; virtual void SetResponseCode(int code) = 0; virtual void SetResponseString(std::string const &str) = 0; virtual void SetResponseBuf(void const *data, std::size_t bytes) = 0; virtual void SetResponseFile(std::string const &fileName) = 0; }; typedef std::shared_ptr<IHttpRequest> IHttpRequestPtr; }

यह इंटरफ़ेस आपको आने वाले अनुरोध से अपने प्रकार, कुछ विशेषताएँ (हेडर), अनुरोध निकाय का आकार और अनुरोध निकाय को स्वयं प्राप्त करने की अनुमति देता है, यदि उपलब्ध हो, साथ ही विशेषता (हेडर) सेट करने की क्षमता, अनुरोध पूरा होने वाले कोड और प्रतिक्रिया निकाय (इसमें) कार्यान्वयन, एक स्ट्रिंग पास करने के तरीके हैं, कुछ बफर या प्रतिक्रिया में फ़ाइल)। इसके कार्यान्वयन में प्रत्येक विधि HttpRequestException प्रकार का अपवाद फेंक सकती है।

यदि आप सर्वर कोड को एक बार फिर से देखते हैं, तो आप अनुरोध प्रसंस्करण कोड में निम्न पंक्तियाँ देख सकते हैं:

 req->SetResponseAttr(Http::Response::Header::Server::Value, "MyTestServer"); req->SetResponseAttr(Http::Response::Header::ContentType::Value, Http::Content::Type::html::Value);

यह प्रतिक्रिया हेडर का गठन है, और इस उदाहरण में, हेडर फ़ील्ड जैसे "सामग्री-प्रकार" और "सर्वर" सेट हैं। इस तथ्य के बावजूद कि libevent में काफी व्यापक कार्यक्षमता है जो HTTP की जरूरतों से बहुत आगे जाती है, इसमें हेडर फील्ड स्थिरांक की कोई सूची नहीं है; केवल रिटर्न कोड की अधूरी सूची है (सबसे अधिक इस्तेमाल किया जाता है)। हेडर फ़ील्ड्स (उदाहरण के लिए, उपयोगकर्ता कोड में टाइपो से बचने के लिए) को परिभाषित करने वाले तारों के साथ गड़बड़ नहीं करने के लिए, सभी स्थिरांक पहले से ही libevent पर प्रस्तावित आवरण में परिभाषित किए गए हैं।

स्ट्रिंग स्थिरांक को परिभाषित करने का उदाहरण

 namespace Network { namespace Http { namespace Request { namespace Header { DECLARE_STRING_CONSTANT(Accept, Accept) DECLARE_STRING_CONSTANT(AcceptCharset, Accept-Charset) // ... } } namespace Response { namespace Header { DECLARE_STRING_CONSTANT(AccessControlAllowOrigin, Access-Control-Allow-Origin) DECLARE_STRING_CONSTANT(AcceptRanges, Accept-Ranges) // ... } } } }

स्ट्रिंग फ़ाइलों में हेडर की पुरानी शैली में शुद्ध सी की पुरानी शैली में स्ट्रिंग स्थिरांक को सरल मैक्रो के रूप में परिभाषित किया जा सकता है, और सीएच शैली में पहले से ही टाइप किए जाने के दौरान .h और .cpp फ़ाइलों के बीच अपनी घोषणाओं और परिभाषाओं को फैलाने के लिए। हालाँकि, आप फ़ाइल रिक्ति के बिना कर सकते हैं, और C ++ शैली में सभी टाइप की गई परिभाषाएँ केवल हेडर फ़ाइल में बना सकते हैं। ऐसा करने के लिए, आप टेम्प्लेट के साथ कुछ दृष्टिकोण का उपयोग कर सकते हैं और इस तरह के मैक्रो (मैक्रोस, निश्चित रूप से, C ++ द्वारा मान्यता प्राप्त एक बुराई, और साथ ही छोटी खुराक में बाम को लिख सकते हैं; विषम समाधानों में अधिक व्यवहार्यता है)।

DECLARE_STRING_CONSTANT

 #define DECLARE_STRING_CONSTANT(name_, value_) \ namespace Private \ { \ template <typename T> \ struct name_ \ { \ static char const Name[]; \ static char const Value[]; \ }; \ template <typename T> \ char const name_ <T>::Name[] = #name_; \ template <typename T> \ char const name_ <T>::Value[] = #value_; \ } \ typedef Private:: name_ <void> name_;

लगभग उसी तरह से, सामग्री के प्रकार की स्थापना के लिए स्थिरांक को परिभाषित किया जाता है; थोड़ा सा संशोधन करें। अनुरोध के जवाब में फ़ाइलें भेजते समय सुविधा के लिए फ़ाइल एक्सटेंशन द्वारा सामग्री प्रकार की खोज को लागू करने की इच्छा थी।

यदि आप किसी आवक अनुरोध से कुछ प्राप्त करना चाहते हैं, उदाहरण के लिए, किस होस्ट से और किस पृष्ठ से अनुरोधित संसाधन में संक्रमण हुआ था और उदाहरण के लिए, क्या उपयोगकर्ता के पास कुकीज़ हैं, तो आप इस तरह से आने वाले अनुरोध के शीर्ष लेख से यह सब प्राप्त कर सकते हैं:

 std::string Host = req->GetHeaderAttr(Http::Request::Header::Host::Value); std::string Referer = req->GetHeaderAttr(Http::Request::Header::Referer::Value); std::string Cookie = req->GetHeaderAttr(Http::Request::Header::Cookie::Value);

इसी तरह, प्रतिक्रिया में, आप उदाहरण के लिए, उपयोगकर्ता को कुछ कुकीज़ सेट कर सकते हैं, जो बाद में उसके सत्र और ट्रैक के साथ काम करते हैं यदि वह आपके संसाधन के आसपास घूमना चाहता है (प्रतिक्रिया हेडर के साथ काम करने का एक उदाहरण सर्वर कोड में दिया गया है)।

यदि आप अपने कुछ एपीआई को HTTP के माध्यम से व्यवस्थित करना चाहते हैं, तो यह करना उतना ही आसान है। मान लें कि आपको तरीके बनाने की जरूरत है: एक सत्र खोलना, सर्वर के बारे में सांख्यिकीय जानकारी प्राप्त करना और सत्र बंद करना। अपने सर्वर को इस क्वेरी स्ट्रिंग को कुछ इस तरह से देखने दें:

  http://myserver.com/service/login/OpenSession?user=nym&pwd=kakoyto
 http://myserver.com/service/login/CliseSession?sessionId=nym1234567890
 http://myserver.com/service/stat/GetInfo?sessionId=nym1234567890

इन क्वेरी स्ट्रिंग का जवाब देकर, उपयोगकर्ता सर्वर कुछ प्रकार की प्रतिक्रिया उत्पन्न कर सकता है, उदाहरण के लिए, xml प्रारूप में। यह सर्वर डेवलपर का व्यवसाय है। लेकिन इस तरह के अनुरोधों के साथ कैसे काम करें, उनसे पैरामीटर प्राप्त करें, नीचे दिए गए हैं:

 auto Path = req->GetPath(); auto Params = req->GetParams();

ऊपर दिए गए उदाहरणों में से एक तरीका / सेवा / लॉगिन / OpenSession होगा, और पैरामीटर पारित कुंजी / मूल्य जोड़े का एक नक्शा है। पैरामीटर कार्ड का प्रकार:

 typedef std::unordered_map<std::string, std::string> RequestParams;

सब कुछ का विश्लेषण करने के बाद, जो कि आवरण के प्रस्तावित अंतिम संस्करण का उपयोग करने के लिए परिवाद पर लागू किया जा सकता है, आप इस आवरण के हुड के नीचे देख सकते हैं।

कक्षा HttpServer

 namespace Network { DECLARE_RUNTIME_EXCEPTION(HttpServer) class HttpServer final : private Common::NonCopyable { public: typedef std::vector<IHttpRequest::Type> MethodPool; typedef std::function<void (IHttpRequestPtr)> OnRequestFunc; enum { MaxHeaderSize = static_cast<std::size_t>(-1), MaxBodySize = MaxHeaderSize }; HttpServer(std::string const &address, std::uint16_t port, std::uint16_t threadCount, OnRequestFunc const &onRequest, MethodPool const &allowedMethods = {IHttpRequest::Type::GET }, std::size_t maxHeadersSize = MaxHeaderSize, std::size_t maxBodySize = MaxBodySize); private: volatile bool IsRun = true; void (*ThreadDeleter)(std::thread *t) = [] (std::thread *t) { t->join(); delete t; };; typedef std::unique_ptr<std::thread, decltype(ThreadDeleter)> ThreadPtr; typedef std::vector<ThreadPtr> ThreadPool; ThreadPool Threads; Common::BoolFlagInvertor RunFlag; }; } </source</spoiler> <spoiler title="  HttpServer"><source lang="cpp"> namespace Network { HttpServer::HttpServer(std::string const &address, std::uint16_t port, std::uint16_t threadCount, OnRequestFunc const &onRequest, MethodPool const &allowedMethods, std::size_t maxHeadersSize, std::size_t maxBodySize) : RunFlag(&IsRun) { int AllowedMethods = -1; for (auto const i : allowedMethods) AllowedMethods |= HttpRequestTypeToAllowedMethod(i); bool volatile DoneInitThread = false; std::exception_ptr Except; evutil_socket_t Socket = -1; auto ThreadFunc = [&] () { try { bool volatile ProcessRequest = false; RequestParams ReqPrm; ReqPrm.Func = onRequest; ReqPrm.Process = &ProcessRequest; typedef std::unique_ptr<event_base, decltype(&event_base_free)> EventBasePtr; EventBasePtr EventBase(event_base_new(), &event_base_free); if (!EventBase) throw HttpServerException("Failed to create new base_event."); typedef std::unique_ptr<evhttp, decltype(&evhttp_free)> EvHttpPtr; EvHttpPtr EvHttp(evhttp_new(EventBase.get()), &evhttp_free); if (!EvHttp) throw HttpServerException("Failed to create new evhttp."); evhttp_set_allowed_methods(EvHttp.get(), AllowedMethods); if (maxHeadersSize != MaxHeaderSize) evhttp_set_max_headers_size(EvHttp.get(), maxHeadersSize); if (maxBodySize != MaxBodySize) evhttp_set_max_body_size(EvHttp.get(), maxBodySize); evhttp_set_gencb(EvHttp.get(), &OnRawRequest, &ReqPrm); if (Socket == -1) { auto *BoundSock = evhttp_bind_socket_with_handle(EvHttp.get(), address.c_str(), port); if (!BoundSock) throw HttpServerException("Failed to bind server socket."); if ((Socket = evhttp_bound_socket_get_fd(BoundSock)) == -1) throw HttpServerException("Failed to get server socket for next instance."); } else { if (evhttp_accept_socket(EvHttp.get(), Socket) == -1) throw HttpServerException("Failed to bind server socket for new instance."); } DoneInitThread = true; for ( ; IsRun ; ) { ProcessRequest = false; event_base_loop(EventBase.get(), EVLOOP_NONBLOCK); if (!ProcessRequest) std::this_thread::sleep_for(std::chrono::milliseconds(100)); } } catch (...) { Except = std::current_exception(); } }; ThreadPool NewThreads; for (int i = 0 ; i < threadCount ; ++i) { DoneInitThread = false; ThreadPtr Thread(new std::thread(ThreadFunc), ThreadDeleter); NewThreads.push_back(std::move(Thread)); for ( ; ; ) { if (Except != std::exception_ptr()) { IsRun = false; std::rethrow_exception(Except); } if (DoneInitThread) break; std::this_thread::sleep_for(std::chrono::milliseconds(100)); } } Threads = std::move(NewThreads); } }

अनुरोध प्रसंस्करण फ़ंक्शन को उदाहरणों की स्रोत फ़ाइलों को डाउनलोड करके पूर्ण संस्करण में देखा जा सकता है, यह पिछले उदाहरणों की तुलना में थोड़ा अधिक हो गया है, और कोड की पठनीयता के नुकसान के बिना लैम्ब्डा का दावा करना बंद कर दिया है। मैंने IHttpRequest इंटरफ़ेस के कार्यान्वयन का भी हवाला नहीं दिया, क्योंकि यह libevent बफ़र के साथ अपने नियमित काम में थोड़ी रुचि रखता है। बाकी के लिए, यदि आप अंतिम संस्करण के कोड को देखते हैं, तो यह बहुत अधिक नहीं बदला है। थोड़ा संशोधन और थोड़ा "ट्यूनिंग" जोड़ा गया था।

उपयोगकर्ता सर्वर को सभी प्रकार के http अनुरोधों को संसाधित करने की आवश्यकता नहीं है।आप अनुरोध प्रकारों की एक सूची निर्दिष्ट कर सकते हैं जो सर्वर को संसाधित करना चाहिए, और इसके लिए, libevent में evhttp_set_allowed_methods फ़ंक्शन है (डिफ़ॉल्ट रूप से, आवरण केवल GET अनुरोधों के प्रकार को परिभाषित करता है)। जब बाकी सभी के लिए संसाधित अनुरोधों की एक सूची निर्दिष्ट करते हैं, तो libevent खुद ऐसे अनुरोध को निष्पादित करने की असंभवता को रिपोर्ट करेगा, जिससे उपयोगकर्ता को अतिरिक्त चेक से बचाया जा सके।

मन की जिज्ञासा, यह अलग है: निर्माण और विनाश के उद्देश्य से। सर्वर को "भरने" की इच्छा के साथ मन की विनाशकारी जिज्ञासा से, इसे कुछ प्रकार के निषेधात्मक रूप से बड़े http-पैकेट शीर्षक भेजना या एक बड़े अनुरोध वाले निकाय को भी evhttp_set_max_headers_size और evhttp_set_max_body_size कार्यों द्वारा सुरक्षित रूप से संरक्षित किया जा सकता है। बेशक, बड़े अनुरोध भेजना न केवल बुरे विचारों के कारण हो सकता है, बल्कि अन्य कारणों से भी हो सकता है। उपरोक्त विधियां आपके सर्वर की अवांछित दुर्घटनाओं को थोड़ा कम करेंगी। कुछ और के लिए प्रदान करना संभव है, लेकिन अन्यथा आप पहले से ही प्रतिक्रियात्मक रूप से प्रतिक्रिया कर सकते हैं, जो आमतौर पर होता है ...

अंत में, मैं अंतिम संस्करण दूंगा, जो जीईटी अनुरोधों (निर्दिष्ट निर्देशिका से फाइलें देता है) को संसाधित करता है और प्रदर्शित करता है कि किस मेजबान से अनुरोध किया गया था और किस पृष्ठ से सर्वर द्वारा संसाधित संसाधन में संक्रमण हुआ था।

एक साधारण http सर्वर का अंतिम संस्करण

 #include "http_server.h" #include "http_headers.h" #include "http_content_type.h" #include <iostream> #include <sstream> #include <mutex> int main() { char const SrvAddress[] = "127.0.0.1"; std::uint16_t SrvPort = 5555; std::uint16_t SrvThreadCount = 4; std::string const RootDir = "../test_content"; std::string const DefaultPage = "index.html"; std::mutex Mtx; try { using namespace Network; HttpServer Srv(SrvAddress, SrvPort, SrvThreadCount, [&] (IHttpRequestPtr req) { std::string Path = req->GetPath(); Path = RootDir + Path + (Path == "/" ? DefaultPage : std::string()); { std::stringstream Io; Io << "Path: " << Path << std::endl << Http::Request::Header::Host::Name << ": " << req->GetHeaderAttr(Http::Request::Header::Host::Value) << std::endl << Http::Request::Header::Referer::Name << ": " << req->GetHeaderAttr(Http::Request::Header::Referer::Value) << std::endl; std::lock_guard<std::mutex> Lock(Mtx); std::cout << Io.str() << std::endl; } req->SetResponseAttr(Http::Response::Header::Server::Value, "MyTestServer"); req->SetResponseAttr(Http::Response::Header::ContentType::Value, Http::Content::TypeFromFileName(Path)); req->SetResponseFile(Path); }); std::cin.get(); } catch (std::exception const &e) { std::cout << e.what() << std::endl; } return 0; }

निष्कर्ष

चर्चा की गई कार्यक्षमता के अलावा, लिबवेंट में अभी भी कई उपयोगी विशेषताएं हैं। सामान्य तौर पर: इस पुस्तकालय का उपयोग करके लिखने के लिए अभी भी कुछ करना है और इसके बारे में क्या लिखना है। इस पोस्ट ने केवल अपना छोटा सा हिस्सा दिखाया, जिसे http-server के विकास के लिए बनाया गया है। सभी उदाहरणों के लिए सभी स्रोत फाइलें गीथूब पर उपलब्ध हैं । उपरोक्त उदाहरणों के आधार पर, http सर्वर को मेरे अन्य होम प्रोजेक्ट्स से बनाया गया था ।
परीक्षा परिणाम:

ab -c 1000 -k -r -t 10 http: // localhost: 8888 / libevent_test_http_srv.zip

Server Software: test
Server Hostname: test
Server Port: 8888

Document Path: /libevent_test_http_srv.zip
Document Length: 23756 bytes

Concurrency Level: 1000
Time taken for tests: 10.012 seconds
Complete requests: 2293
विफल अनुरोध: 0
त्रुटियों को लिखें: 0
Keep-Alive requests: 2293
Total transferred: 60628847 bytes
HTML transferred: 60328370 bytes
Requests per second: 229.02 [#/sec] (mean)
Time per request: 4366.365 [ms] (mean)
Time per request: 4.366 [ms] (mean, across all concurrent requests)
Transfer rate: 5913.65 [Kbytes/sec] received

लोहे के पहले से ही बहुत मामूली विन्यास पर दस सेकंड में एक पोस्ट के उदाहरणों की स्रोत फ़ाइलों के साथ एक संग्रह के लिए ढाई हजार संसाधित अनुरोध ...

आपका ध्यान देने के लिए आप सभी का धन्यवाद!

खुद का HTTP सर्वर 40 से कम लाइनों में काम करने वाला और C ++ 11 में कोड है

क्यों?

40 से कम लाइनों में सरल http सर्वर

मल्टीथ्रेडेड http सर्वर

सर्वर का अंतिम संस्करण

निष्कर्ष

सामग्री

More articles: