Django do-it-yourself भाग 3: रूट, डिबगिंग, मिडलवेयर, बोतल, बीकर

भाग 1
भाग २

परिचय।

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

डिबगिंग

माइक्रोफ्रेम की मुख्य समस्याओं में से एक यह है कि जब एप्लिकेशन में त्रुटियां होती हैं, तो अधिकांश त्रुटियां जो wsgi हमें देती हैं, उन्हें लॉग में पकड़ा जाना चाहिए। और हम ब्राउज़र में पृष्ठ पर यह सब देखना चाहेंगे, या इसके कंसोल में कुछ पोस्ट अनुरोध एक त्रुटि लौटाएंगे।

ऐसा करने के लिए, हम बस प्रसंस्करण श्रृंखला में एकीकृत होते हैं और उन सभी अपवादों को पकड़ लेंगे जो एप्लिकेशन स्वयं नहीं पकड़ते थे, और इसे एक सुंदर रूप से डिज़ाइन किए गए पृष्ठ के रूप में फेंक देते हैं।

try: #  bottle        ,    . @bottle.hook('before_request') def pre_init(): #       , ini_environment() #       #  options_session #   bottle app = bottle.app() app.catchall = False #       . debugger = DebuggerM(app) #     . session = SessionMiddleware(debugger, options_session) #   application    wsgi' application = session except Exception as e: #            #     . exc = sys.exc_info() def error_apps(environ, start_response): start_response('500 INTERNAL SERVER ERROR', [('Content-Type', 'text/html; charset=utf-8')]) return view_error(exc, environ, e) application = error_apps 

वह वर्ग जो सीधे हमारे मिडलवेयर की सेवा करता है।

 class DebuggerM(object): """       """ __app = None def __init__ (self, app): #      bottle # app-    ,  application     middleware self.__app = app def __call__(self, environ, start_response): try: #      (   ) app_iter = self.__app(environ, start_response) for item in app_iter: #      #          yield item except Exception as e: #         . start_response('500 INTERNAL SERVER ERROR', [('Content-Type', 'text/html; charset=utf-8')]) yield view_error(sys.exc_info(), environ, e) 

समारोह ही है कि हमारी त्रुटि खींचता है:

 def view_error(exc, environ, e): import cgi, traceback ee = dict(environ) text= '' text='<h1>ERROR "%s"</h1>' % str(e) text+='<style>pre{border:red solid 1px; max-height:240px; overflow:auto;}</style>' text+='<h2>Stack trace</h2><pre>%s</pre>' % ''.join(reversed(traceback.format_exception(*exc))) text+='<h2>Env</h2><pre">%s </pre>' % ' '.join(['%s=%s' %(k, ee[k])for k in ee]) text+='</pre>' return text 

मार्गों के साथ काम करें

डिफ़ॉल्ट रूप से, हमारे पास पहले से ही एक सजावटकर्ता के रूप में बूट में मार्ग हैं जो किसी भी फ़ंक्शन के लिए झुका जा सकते हैं:

 @route('/hello/:name') def index(name='World'): return '<b>Hello %s</b>' % name 

लेकिन यह अपेक्षाकृत छोटी परियोजनाओं के लिए सुविधाजनक है। और हम इस क्षण का विस्तार करना चाहते हैं ताकि किसी भी घटक में इस प्रकार की फ़ाइल बनाना संभव हो।

 from app1 import * routes = { 'function': ('/hello/', hello, 'GET'), 'function2':('/hello/<_id>', hello_post, 'POST') } 

तदनुसार, उसके बाद, आप पहले से ही इस घटक में कहीं भी हैलो फ़ंक्शन को कॉल कर सकते हैं। ऐसा करने के लिए, उस फ़ाइल में लिखें जिसमें कर्नेल की मुख्य कार्यक्षमता का विवरण है।

 all_routes = {} def union_routes(dir): routes = {} #               . if __builtin__.__import__('routes', globals=globals()): #    module = sys.modules['routes'] #     routes routes.update(module.routes) #     for name in os.listdir(dir): path = os.path.join(dir, name) #       routes.py if os.path.isdir(path) and os.path.isfile(path+'/routes.py'): #           name = 'app.'+path[len(dir)+1:]+'.routes' if __builtin__.__import__(name, globals=globals()): module = sys.modules[name] routes.update(module.routes) return routes def setup_routes(routes): #           bottle        . all_routes.clear() all_routes.update(routes) for name in routes: path, func, method = routes[name] route(path, method=method, name=name)(func) 

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

 routes = {} #      routes.update(union_routes(lib_path)) #      routes.update(union_routes(app_path)) setup_routes(routes) 

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

 from app1 import * routes = { 'function2': ('/hello/<_id>', hello_post, 'POST'), 'function3': ('/base/1', lambda: test(True, u''), 'GET') } 

अब इस मामले में, हमारे फ़ंक्शन मार्गों की कुंजी का उपयोग करते हुए, 'function2', हम रूट के नाम से लिंक बना सकते हैं बिना यह जाने कि पैरामीटर को लिंक से ही कैसे पारित किया जाएगा, उदाहरण के लिए, यदि हम '/ hello / <_id' लेते हैं, तो <_id> को गतिशील रूप से सेट किया जाएगा।

 def make_link(name, params, full=False): """     <>     """ #     templ_link = all_routes[name][0][1:] #      <> r = re.compile(r'<([^:>]+)(:[^>]+)?>') #       ,       . while True: rs = r.search(templ_link) if not rs: break sub = rs.group(0) name = rs.group(1) templ_link = re.sub(sub, params[name], teml_link) link = os.path.sep+ templ_link #        ,     . if full: link = 'http://'+get_name_host()+link return link 

अब हम टेम्पलेट में या कोड में कहीं भी लिखते हैं

 link = make_link('test', {'id':id, 'doc_id':doc_id}, True) 

स्वीकार करें कि अक्सर केवल एक लिंक लिखना आसान होता है, लेकिन कभी-कभी आप इस फ़ंक्शन के बिना नहीं कर सकते।

सत्र के साथ काम करें

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

 from beaker.middleware import SessionMiddleware 

इसके बाद, हम मार्गों के आरंभ होने के तुरंत बाद आरंभीकरण टिप्पणी को प्रतिस्थापित करते हैं।

  options_session = { 'session.cookie_expires': 30000, 'session.timeout': 30000, 'session.type': 'file', #     'session.data_dir': './s_data' #      } 

और प्री_इनिट () फ़ंक्शन में, हम डायनेमिक के लिए एक पंक्ति जोड़ते हैं यदि ऐसा है तो परिभाषा के लिए जिस डोमेन के लिए हमें सत्र संग्रहीत करने की आवश्यकता है।

 session.options['session.cookie_domain'] = get_name_host() 

get_name_host () - हमारी साइट का नाम प्राप्त करने में लगा हुआ है।
उसके बाद, हम सभी की जरूरत है एक सरल कार्य है जिसके साथ हम सत्र का उपयोग कर सकते हैं।

 def session(): #    s = request.environ.get('beaker.session') return s 

अब कहीं भी:

 s = session() s['test'] = '123' s.save() 

स्थिति-विज्ञान

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

 #  bottle          ,           . @route('/static/<component>/<fname:re:.*>') def st_file(component, fname): #              ,     bottle path = os.path.join( settings.lib_path, component, 'static') + os.path.sep if not os.path.exists(path + fname): path = os.path.join( settings.lib_path, 'app', component,'static')+ os.path.sep if not os.path.exists( path + fname): path = os.path.join( os.getcwd(), 'app', component, 'static')+ os.path.sep if not os.path.exists(path + fname) and component == 'static': path = os.path.join( os.getcwd(), 'static')+ os.path.sep return static_file(fname, root=path) 

अब यह सीखना बाकी है कि अगर मॉड्यूल ऐसा हो तो स्टैटिक्स को कैसे कनेक्ट करना है, अगर ऐसा कोई मॉड्यूल मौजूद है, और मुख्य टेम्पलेट में सभी अंधाधुंध नहीं हैं।

 def add_resourse(name, append=True): env = get_environment(); t = '' if name.endswith('.css'): t = 'css' if name.endswith('.js'): t = 'js' if not t: return if not name in env['res_list'][t]: if append: env['res_list'][t].append(name) else: env['res_list'][t].prepend(name) 

हम इस फ़ंक्शन को किसी भी मॉड्यूल में कॉल करते हैं और इस प्रकार की स्थिर फ़ाइल का सही रास्ता पास करते हैं '/ स्थिर / <घटक> / <नाम: पुनः। *>> पहले तर्क के रूप में:

 add_resourse(/static/base/base.js, True) 

और मुख्य टेम्पलेट में, हम बस कॉल करते हैं:

 {% for res in env.res_list['js'] %} <script type="text/javascript" src="{{res}}"></script> {% endfor %} {% for res in env.res_list['css'] %} <link rel="stylesheet" type="text/css" href="{{res}}" /> {% endfor %} 

नमस्ते दुनिया

अब एक साधारण नमस्ते दुनिया कुछ इस तरह दिखाई देगी।
हम फ़ाइल को प्रोजेक्ट के रूट / २०१६ के रूट मार्गों के साथ रखेंगे।

 from app.app_one.view import * routes = { 'hello': ('/', hello, 'GET') } 

हम नज़दीकी फ़ाइल को पास में रखते हैं, हालाँकि यहाँ नाम तर्क की दृष्टि से महत्वपूर्ण नहीं है:

 def hello(): text = 'It works' return templ('hello', text=text) 

और उसी निर्देशिका में / templ फ़ोल्डर में हमने hello.tpl नामक एक टेम्पलेट रखा है।

 {{text}} 

हम सभी साइट की जड़ में जाते हैं और एक ग्रीटिंग देखते हैं।

सारांश

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

प्रयुक्त और उपयोगी सामग्री

बोतल
बीकर और कैशिंग
बीकर
अजगर के लिए वेब का परिचय
पायथन वेब सर्वर गेटवे इंटरफ़ेस