कॉमन लिस्प पार्ट वन पर एक वेब सर्वर लिखना

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

इसे लिखने के लिए, हमें emacs, sbcl, slime और quicklisp के साथ लिनक्स की आवश्यकता है। मुझे यह वर्णन नहीं करना चाहिए कि इसे कैसे स्थापित किया जाए, इसे कैसे कॉन्फ़िगर किया जाए और इसका उपयोग कैसे किया जाए - इस बारे में इंटरनेट पर कई लेख हैं। हमारा पूरा वेब सर्वर एक पैकेज में होगा जिसे myweb कहा जाता है। इस नाम से एक फ़ोल्डर बनाएँ, और इसमें दो फ़ोल्डर लॉग और वेब बनाएँ। लॉग फ़ोल्डर में वेब सर्वर लॉग फ़ाइल होगी। वेब फ़ोल्डर में html- पृष्ठ और चित्र होंगे जो वेब सर्वर ग्राहकों को देगा। पूरे वेब सर्वर में सात फाइलें होती हैं।

आइए पैकेज की घोषणा करने वाली फाइल और पैकेज विवरण के लिए asd फाइल शुरू करें।

Package.lisp फ़ाइल बनाएँ:

(in-package :cl-user) (defpackage :myweb (:use :cl :usocket :bordeaux-threads) (:export :start-http :stop-http :list-workers :list-requests)) (defpackage :myweb.util (:use :cl :local-time) (:export :parse-request :read-utf-8-string :response-write :get-param :get-header :http-response :file-response :html-template :log-info :log-warning :log-error)) (defpackage :myweb.handler (:use :cl) (:export :process-request)) 

जैसा कि आप देख सकते हैं, हमारे वेब सर्वर में तीन पैकेज हैं:

• myweb - वेब सर्वर को शुरू करने और रोकने के लिए कार्य करेगा
• myweb.util - अनुरोधों को संभालने में मदद करने के लिए कार्य शामिल होंगे
• myweb.handler - में स्वयं ही अनुरोध प्रसंस्करण कोड होगा

इन-पैकेज फ़ंक्शन आमतौर पर फ़ाइल की शुरुआत में रखा जाता है और उस पैकेज के नाम को इंगित करता है जिसमें हम चर और फ़ंक्शन घोषित करते हैं। इस मामले में, चूंकि हम पैकेजों की घोषणा कर रहे हैं, इसलिए हमें उन्हें मुख्य पैकेज: cl-user में घोषित करना चाहिए।
नोट : पैकेज घोषणाओं में उपयोग और निर्यात निर्देश। : उपयोग हमें फ़ंक्शन नाम की शुरुआत में पैकेज के नाम को निर्दिष्ट किए बिना अन्य पैकेजों से कार्यों का उपयोग करने की अनुमति देता है, जिससे टाइप किए गए पाठ की मात्रा कम हो जाती है। : निर्यात उन कार्यों के नाम सेट करता है जिनका उपयोग पैकेज के बाहर किया जा सकता है। जैसा कि आप देख सकते हैं, हमारे पास पैकेज है: myweb फ़ंक्शंस: स्टार्ट-http और: स्टॉप-http। पैकेज में होने के कारण: cl-user, हम उन्हें myweb: start-http के माध्यम से कॉल नहीं कर पाएंगे, जब तक कि हम पहली बार उन्हें: निर्यात निर्देश का उपयोग करके घोषित नहीं करते।

हमारे पास पहले से ही पैकेजों के लिए एक विज्ञापन है, अब इन पैकेजों के स्रोत कोड को लिखना बाकी है। Web.lisp, use.lisp और handler.lisp फाइलें बनाएं और उनमें से प्रत्येक में एक इन-पैकेज कॉल जोड़ें। Web.lisp के लिए - (इन-पैकेज: myweb), use.lisp (इन-पैकेज: myweb.util), आदि के लिए। हमें कॉल (इन-पैकेज: क्ल-लॉग) के साथ एक log.lisp फ़ाइल बनाने की भी आवश्यकता होगी। इस फाइल को क्लैट-लॉग लॉगिंग सिस्टम को चलाने और कॉन्फ़िगर करने के लिए आवश्यक है।

वेब सर्वर के लिए फ़ाइल संरचना बनाने के लिए अंतिम स्पर्श myweb.asd फ़ाइल का निर्माण होगा, जो बताता है कि काम करने के लिए सभी चीजों को लोड करने के लिए asdf सिस्टम की आवश्यकता होती है।

 ;; myweb.asd (asdf:defsystem #:myweb :serial t :components ((:file "package") (:file "log") (:file "util") (:file "web") (:file "handler"))) 

कुंजी: सीरियल टी इंगित करता है कि asdf फ़ाइलों को उसी क्रम में डाउनलोड करता है जिसमें वे सूचीबद्ध हैं।

अब हमें फ़ाइल load.lisp लिखना होगा, जो हमारे पैकेज को लोड करेगा और कीचड़ के लिए हंस सर्वर शुरू करेगा।

 (in-package :cl-user) (quicklisp:quickload "swank") (quicklisp:quickload "usocket") (quicklisp:quickload "bordeaux-threads") (quicklisp:quickload "trivial-utf-8") (quicklisp:quickload "cl-log") (quicklisp:quickload "local-time") (pushnew '*default-pathname-defaults* asdf:*central-registry*) (asdf:load-system 'myweb) (swank:create-server) 

विकास जारी रखने के लिए, हमें पहले से ही स्विंक को चलाने और सभी आवश्यक पुस्तकालयों को क्विकलाइज़ का उपयोग करके लोड करना होगा। ऐसा करने के लिए, मायवेब डायरेक्टरी में sbcl चलाएं और फ़ंक्शन को कॉल करें (Quicklisp: quickload "swank")। Swank को इनस्टॉल करने के बाद sbcl कमांड लाइन से swank सर्वर को कॉल करके (swank: create-server) शुरू करें।
Emacs से कीचड़-कनेक्ट का उपयोग करना, sbcl चलाने से कनेक्ट करना और load.lisp से अन्य सभी कार्यों को quickacisp के साथ कॉल करना। emacs में slime-mode और ctrl-e कुंजी संयोजन का उपयोग करना। यदि आपने सब कुछ सही ढंग से किया है, तो क्विकप्लस सभी आवश्यक पुस्तकालयों को डाउनलोड करेगा और आपके लिए asdf का उपयोग करके उन्हें लोड करेगा। सब कुछ विकास शुरू करने के लिए तैयार है।

वेब सर्वर से ही शुरू करते हैं। उसके लिए हमें कुर्सियां ​​चाहिए। मैंने व्यापक usocket लाइब्रेरी का उपयोग करके सॉकेट्स के साथ काम करने का फैसला किया। हमें थ्रेड्स की भी आवश्यकता होगी, जिसके लिए हम बोर्डो-थ्रेड्स का उपयोग करेंगे। लेकिन सबसे पहले, मैं http- अनुरोधों के प्रसंस्करण के मॉडल के बारे में बात करना चाहूंगा जो हम बनाने जा रहे हैं। प्रत्येक अनुरोध को एक अलग थ्रेड द्वारा संसाधित किया जाएगा। हमारे पास कार्यकर्ता धागे होंगे जो अनुरोधों की संख्या के आधार पर बनाए जाएंगे। उनमें से, हमारे पास अलग-अलग निष्क्रिय धाराएँ होंगी, जो अनुरोध को संसाधित करने के बाद, नए अनुरोधों के लिए, प्रतीक्षा-स्थिति में चली जाएंगी। इस प्रकार, आप नए वर्कर थ्रेड बनाने का बोझ कम कर सकते हैं। यह http अनुरोधों को संसाधित करने के लिए एक प्रकार का थ्रेड पूल तंत्र निकला है।
चलिए web.lisp फ़ाइल में म्यूटेक्स s के लिए सॉकेट और चर घोषित करके शुरू करते हैं:

 (defvar *listen-socket* nil) (defvar *listen-thread* nil) (defvar *request-mutex* (make-lock "request-mutex")) (defvar *request-threads* (list)) (defvar *worker-mutex* (make-lock "worker-mutex")) (defvar *workers* (list)) (defvar *worker-num* 0) (defvar *idle-workers* (list)) (defvar *idle-workers-num* 0) (defvar *request-queue* (list)) 

थ्रेड्स में अनुरोधों को स्वीकार करने और वितरित करने के लिए, हम एक अलग थ्रेड का उपयोग करेंगे, जो पॉइंटर को * सुनो-थ्रेड * में संग्रहीत किया जाएगा। चलिए स्टार्ट-http विधि से शुरू करते हैं:

 (defun start-http (host port &key (worker-limit 10) (idle-workers 1)) (if (not *listen-socket*) (setq *listen-thread* (make-thread (lambda () (http-acceptor host port worker-limit idle-workers)) :name "socket-acceptor")) "http server already started")) 

यह डिस्पेंसर स्ट्रीम को शुरू करने के लिए एक सरल फ़ंक्शन है, जो बदले में http-acceptor फ़ंक्शन को कॉल करेगा। हमारे पास दो चाबियाँ हैं - यह कार्यकर्ता-सीमा है - श्रमिकों की अधिकतम संख्या, और निष्क्रिय-श्रमिक - निष्क्रिय श्रमिकों की संख्या।
चलिए क्वेरी वितरण फ़ंक्शन को स्वयं लिखते हैं:

 (defun http-acceptor (host port worker-limit idle-workers) (setq *listen-socket* (socket-listen host port :reuse-address t :element-type '(unsigned-byte 8) :backlog (* worker-limit 2))) (let ((request-id 0) (worker-id 0)) (loop while *listen-thread* do (let* ((socket (socket-accept *listen-socket* :element-type '(unsigned-byte 8)))) (progn (setq request-id (1+ request-id)) (acquire-lock *worker-mutex*) (if (>= *worker-num* worker-limit) (push (cons request-id socket) *request-queue*) ;; Get worker from idle workers (if (> *idle-workers-num* 0) (progn (push (cons request-id socket) *request-queue*) (condition-notify (caar *idle-workers*))) ;; Add new Worker (progn (setq worker-id (1+ worker-id)) (setq *worker-num* (1+ *worker-num*)) (setq *workers* (cons (make-thread (lambda () (worker-thread request-id socket idle-workers)) :name (concatenate 'string "socket-worker-" (prin1-to-string worker-id))) *workers*))))) (release-lock *worker-mutex*) t))))) 

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

 (defun worker-thread (request-id socket idle-workers) (if request-id ;; Process request if it is not nil (progn (with-lock-held (*request-mutex*) (setq *request-threads* (cons (cons request-id (current-thread)) *request-threads*)) ) (http-worker socket) (with-lock-held (*request-mutex*) (setq *request-threads* (remove-if (lambda (x) (eq (car x) request-id)) *request-threads*)) ) )) (acquire-lock *worker-mutex*) (if *request-queue* (let ((request nil)) (setq request (car *request-queue*)) (setq *request-queue* (cdr *request-queue*)) (release-lock *worker-mutex*) (worker-thread (car request) (cdr request) idle-workers)) (if (< *idle-workers-num* idle-workers) (let ((condition (make-condition-variable)) (idle-lock (make-lock)) (request nil)) (push (cons condition (current-thread)) *idle-workers*) (setq *idle-workers-num* (1+ *idle-workers-num*)) (release-lock *worker-mutex*) (list-workers) (with-lock-held (idle-lock) (condition-wait condition idle-lock) ) (with-lock-held (*worker-mutex*) (setq *idle-workers* (cdr *idle-workers*)) (setq *idle-workers-num* (1- *idle-workers-num*)) (setq request (car *request-queue*)) (setq *request-queue* (cdr *request-queue*)) ) (worker-thread (car request) (cdr request) idle-workers)) (progn (setq *workers* (remove (current-thread) *workers*)) (setq *worker-num* (1- *worker-num*)) (release-lock *worker-mutex*))))) 

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

 (defun http-worker (socket) (let* ((stream (socket-stream socket)) (request (myweb.util:parse-request stream))) (myweb.handler:process-request request stream) (finish-output stream) (socket-close socket))) (defun list-workers () (with-lock-held (*worker-mutex*) (setq *workers* (remove-if (lambda (w) (not (thread-alive-p w))) *workers*)) (setq *worker-num* (length *workers*)) *workers*)) 

यहां हम सॉकेट-स्ट्रीम बनाते हैं, अनुरोध को पार्स करते हैं और इसे myweb.handler पर भेजते हैं: प्रक्रिया-अनुरोध (हम दूसरे भाग में इन कार्यों के बारे में बात करेंगे)। सूची-श्रमिकों ने हमें श्रमिकों की एक सूची दी है, पहले इसे मृत थ्रेड्स को साफ़ करना है। हम इस कार्य को स्थिति-प्रतीक्षा से पहले कार्यकर्ता-सूत्र में कहते हैं।
आखिरी चीज जो हमें करने की ज़रूरत है वह है स्टॉप-http फ़ंक्शन, जो हमारे वेब सर्वर को रोक देगा:

 (defun stop-http () (if *listen-socket* (progn (stop-thread) (socket-close *listen-socket*) (setq *listen-socket* nil) (setq *request-queue* nil) (setq *worker-num* 0) (setq *workers* nil) (mapcar (lambda (i) (destroy-thread (cdr i))) *idle-workers*) (setq *idle-workers-num* 0) (setq *idle-workers* nil) (release-lock *worker-mutex*) (setq *request-threads* nil) (release-lock *request-mutex*) (setq *request-mutex* (make-lock "request-mutex")) (setq *worker-mutex* (make-lock "worker-mutex"))))) (defun stop-thread () (if (and *listen-thread* (thread-alive-p *listen-thread*)) (destroy-thread *listen-thread*))) 

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

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

PS वर्तनी और लेआउट के साथ मदद के लिए ertaquo धन्यवाद