आप विकास कोड और उत्पादन कोड कैसे बनाए रखते हैं? [बन्द है]


136

कोड को बनाए रखते हुए पालन करने के लिए सर्वोत्तम अभ्यास और नियम क्या हैं? क्या विकास शाखा में केवल उत्पादन के लिए तैयार कोड होना अच्छा है, या अप्रयुक्त नवीनतम कोड विकास शाखा में उपलब्ध होना चाहिए?

आप लोग अपने विकास कोड और उत्पादन कोड को कैसे बनाए रखते हैं?

संपादित करें - पूरक प्रश्न - क्या आपकी विकास टीम "प्रतिबद्ध-जैसा-जल्द-जैसा-संभव है, और अक्सर-यहां तक ​​कि अगर-कोड-मामूली-कीड़े-या-अधूरा है" प्रोटोकॉल या "प्रतिबद्ध- का पालन करता है विकास शाखा के लिए कोड करते समय केवल-सही-कोड "प्रोटोकॉल?


मैंने पहले भी इसी तरह के प्रश्न (या अच्छी तरह से, उसी स्थान / दिशा में एक प्रश्न) का उत्तर दिया है, इसलिए आप इस प्रश्न की जांच कर सकते हैं: तैनात अनुप्रयोगों को प्रयोज्य बनाने की अनुमति देने के लिए कुछ अच्छी रणनीतियाँ क्या हैं?
तक

@revo: रुको ... मेरे 2008 का उत्तर पुराना है? :) मुझे लगता है कि यह वास्तव में है। 10 साल से अधिक समय हो गया है: मैंने अपना जवाब संपादित किया है।
VonC

जवाबों:


114

अपडेट 2019:

इन दिनों, यह सवाल Git का उपयोग करते हुए एक संदर्भ में देखा जाएगा, और उस वितरित विकास वर्कफ़्लो का उपयोग करने के 10 साल (मुख्य रूप से GitHub के माध्यम से सहयोग करना ) सामान्य सर्वोत्तम प्रथाओं को दर्शाता है:

  • masterक्या शाखा किसी भी समय उत्पादन में तैनात होने के लिए तैयार है: अगली रिलीज, जिसमें सुविधा शाखाओं का एक चयनित सेट शामिल है master
  • dev(या एकीकरण शाखा, या ' next') वह जगह है जहाँ अगली रिलीज़ के लिए चुनी गई सुविधा शाखा का एक साथ परीक्षण किया जाता है
  • maintenance(या hot-fix) शाखा वर्तमान रिलीज विकास / बग फिक्स के लिए एक है, संभव विलय के साथ वापस devयाmaster

कार्यप्रवाह इस तरह का (जहां विलय नहीं devकरने के लिए masterहै, लेकिन जहां के लिए एक ही सुविधा शाखा विलय devचयनित है, तो, करने के लिए masterGit में कार्यान्वित किया जाता है, ताकि आसानी से अगली फिल्म के लिए तैयार नहीं शाखाओं सुविधा ड्रॉप करने में सक्षम होना) रेपो खुद, गिटवर्कफ्लो (एक शब्द, यहां सचित्र ) के साथ।
पर अधिक देखें rocketraman/gitworkflowइस लेख को ट्रंक-आधारित-विकास करने का इतिहास एडम डाइमिट्रुक द्वारा इस लेख की टिप्पणियों और चर्चाओं में नोट किया गया है ।

https://github.com/rocketraman/gitworkflow/raw/master/docs/images/topicgraduation.png

(स्रोत: गिटवर्कफ्लो: एक टास्क-ओरिएंटेड प्राइमर )

ध्यान दें: उस वितरित वर्कफ़्लो में, जब भी आप चाहें, तो आप व्यक्तिगत शाखा में जा सकते हैं और कुछ WIP (वर्क इन प्रोग्रेस) को बिना किसी समस्या के धकेल सकते हैं: आप उन्हें फ़ीचर ब्रांच का हिस्सा बनाने से पहले अपने कमिट को पुनर्गठित (git rebase) कर पाएंगे।


मूल उत्तर (अक्टूबर 2008, 10+ साल पहले)

यह सब आपकी रिहाई के प्रबंधन की अनुक्रमिक प्रकृति पर निर्भर करता है

पहले, क्या वास्तव में अगली रिलीज के लिए आपके ट्रंक में सब कुछ है ? आपको पता चल सकता है कि वर्तमान में विकसित कार्यों में से कुछ हैं:

  • बहुत जटिल और अभी भी परिष्कृत होने की आवश्यकता है
  • समय में तैयार नहीं
  • दिलचस्प है, लेकिन इस अगली रिलीज के लिए नहीं

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

जब यह उत्पादन कोड की बात आती है, तो आपको यह भी ध्यान में रखते हुए अपनी पैच शाखाओं को प्रबंधित करने की आवश्यकता है:

  • पैच का पहला सेट वास्तव में उत्पादन शुरू होने से पहले शुरू हो सकता है (जिसका अर्थ है कि आप जानते हैं कि आप कुछ बग्स के साथ उत्पादन में जाएंगे, जो आप समय में ठीक नहीं कर सकते हैं, लेकिन आप एक अलग शाखा में उन बग्स के लिए काम शुरू कर सकते हैं)
  • अन्य पैच शाखाओं में एक अच्छी तरह से परिभाषित उत्पादन लेबल से शुरू होने वाली लक्जरी होगी

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

  • बड़े पैमाने पर refactoring
  • एक नई तकनीकी लाइब्रेरी का परीक्षण जो आपके द्वारा अन्य कक्षाओं में चीजों को कॉल करने के तरीके को बदल सकता है
  • एक नए रिलीज चक्र की शुरुआत जहां महत्वपूर्ण वास्तु परिवर्तन को शामिल करने की आवश्यकता है।

अब, यदि आपका विकास-विमोचन चक्र बहुत अनुक्रमिक है, तो आप अन्य उत्तर सुझा सकते हैं: एक ट्रंक और कई रिलीज़ शाखाएँ। यह छोटी परियोजनाओं के लिए काम करता है, जहां सभी विकास अगली रिलीज में जाना सुनिश्चित करते हैं, और बस जमे हुए हो सकते हैं और रिलीज शाखा के लिए शुरुआती बिंदु के रूप में काम कर सकते हैं, जहां पैच हो सकते हैं। यह नाममात्र की प्रक्रिया है, लेकिन जैसे ही आपके पास एक अधिक जटिल परियोजना है ... यह अब पर्याप्त नहीं है।


विले एम की टिप्पणी का जवाब देने के लिए:

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

1
@ एडम एडिट के लिए धन्यवाद, और जल्द ही उचित एट्रिब्यूशन सेट न करने के लिए क्षमा करें।
वॉन

हा! चिंता की कोई बात नहीं है। आपने यहाँ समुदाय के लिए बहुत कुछ किया है, आपको किसी भी चीज़ के लिए दोषी ठहराया जाना मुश्किल है। मुझे बस इस बात की खुशी है कि हम जैसे लोग हैं, जो दुनिया भर में सभी के लाभों के लिए इतना काम कर रहे हैं!
एडम डाइमिट्रुक

43

हम प्रयोग करते हैं:

  • विकास शाखा विशेष रूप से

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

  • रिलीज शाखा

कोई नई सुविधाएँ रिलीज़ शाखा में नहीं जाती हैं। केवल महत्वपूर्ण बग रिलीज़ शाखा में तय किए गए हैं, और इन बग को ठीक करने के लिए कोड को विकास शाखा में फिर से विभाजित किया गया है।

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

कभी-कभी हमारे पास एक नई और अप्रमाणित तकनीक पर काम करने वाले एकल डेवलपर के लिए भी शाखाएँ होती हैं, या अवधारणा का प्रमाण तैयार करती हैं। लेकिन आमतौर पर यह केवल तभी किया जाता है जब परिवर्तन कोडबेस के कई हिस्सों को प्रभावित करते हैं। यह औसतन हर 3-4 महीने में होता है और इस तरह की एक शाखा आमतौर पर एक या दो महीने के भीतर पुनर्निर्मित (या स्क्रैप) हो जाती है।

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

चेक-इन प्रारंभिक प्रश्न पर:

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

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

हर अब और फिर एक अपरिहार्य संयुक्त कोड और डेटा चेकइन प्रोग्राम को अनुपयोगी बना देगा जब तक कि नया कोड नहीं बनाया गया है। बहुत कम हम यह करते हैं कि चेक-इन टिप्पणी में और / या ई-मेल भेजने के लिए "WAIT FOR BUILD" जोड़ें।


1
मैंने इसे वोट दिया। यह वैसा ही है जैसा हम करते हैं, लेकिन हम विकास में सभी बदलाव कर रहे हैं और फिर उन बग फिक्स को रिलीज शाखा में मिलाने की कोशिश कर रहे हैं .. काम नहीं कर रहे हैं। हालांकि, मुझे लगता है कि अगर हम रिलीज में सभी बग फिक्स करने के लिए बदलते हैं और विकास में विलय कर देते हैं, तो वह इसे ठीक कर देगा।
theCodeMonk 14

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

15

इसके लायक क्या है, यह हम कैसे करते हैं।

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

इसका मतलब यह है कि पूरी तरह से काम करने के क्रम में ट्रंक रखना महत्वपूर्ण है, क्योंकि इसे पूरी तरह से तोड़ना संभव है। व्यवहार में, जो अक्सर नहीं होता है, और शायद ही कभी एक महत्वपूर्ण समस्या होती है।

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

फिर रखरखाव को आवश्यक रूप से रिलीज शाखा पर किया जा सकता है, और उन सुधारों को आसानी से ट्रंक में वापस विलय किया जा सकता है।

मैं यह दावा नहीं करता कि यह एक संपूर्ण प्रणाली है (और इसमें अभी भी कुछ छेद हैं - मुझे नहीं लगता कि हमारी रिहाई प्रबंधन अभी तक एक पर्याप्त प्रक्रिया है), लेकिन यह काफी अच्छी तरह से काम करता है।


काफी अच्छी तरह से काम करता है और कोड-केवल-गैर-वीकेएस-ड्र्यूड डेवलपर्स के लिए पर्याप्त सरल है।
माथिउ

12

अभी भी किसी ने इसका उल्लेख क्यों नहीं किया? एक सफल गिट ब्रांचिंग मॉडल

यह मेरे लिए परम शाखा मॉडल है!

यदि आप प्रोजेक्ट छोटा है, तो हर समय सभी विभिन्न शाखाओं का उपयोग न करें (शायद आप छोटी सुविधाओं के लिए फीचर शाखाओं को छोड़ सकते हैं)। लेकिन अन्यथा, यह ऐसा करने का तरीका है!

शाखायुक्त मॉडल


4
हां, सिवाय इसके कि यह अक्सर बहुत जटिल / पूर्ण हो, जैसा कि scottchacon.com/2011/08/31/github-flow.html दिखाता है।
वॉन

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

1
जिस तरह से मैं इसे देखता हूं, यह मूल रूप से सब कुछ कॉपी करता है VonC ने लगभग 1 साल पहले (उसके जवाब पर) कहा, लेकिन अधिक विस्तृत तरीके से और अच्छी तस्वीरों के साथ!
cregox

6

शाखाओं पर विकास कोड, ट्रंक पर लाइव कोड को टैग किया गया।

कोड के रिव्यू, ब्रांच टेस्टिंग, रिग्रेशन टेस्टिंग, फाइनल क्यूए टेस्टिंग: "कमिटेड परफेक्ट कोड" रूल होने की कोई जरूरत नहीं है। डेवलपर को चार जगहों पर पिकअप मिस करना चाहिए।

यहां एक और विस्तृत चरण-दर-चरण स्पष्टीकरण दिया गया है:

  1. एक शाखा पर सभी विकास करें, नियमित रूप से आप जाते हुए कमिट करें।
  2. सभी विकास पूर्ण होते ही स्वतंत्र कोड की समीक्षा।
  3. फिर परीक्षण के लिए शाखा को पास करें।
  4. एक बार शाखा परीक्षण पूरा हो जाने के बाद, कोड को रिलीज़ कैंडिडेट शाखा में विलय कर दें।
  5. रिलीज कैंडिडेट शाखा प्रत्येक व्यक्ति मर्ज के बाद प्रतिगमन परीक्षण है।
  6. सभी देव शाखाओं के विलय के बाद आरसी पर अंतिम क्यूए और यूए परीक्षण का प्रदर्शन किया गया।
  7. क्यूए और यूएटी पास होने के बाद, रिलीज शाखा को मुख्य / ट्रंक शाखा में विलय कर दें।
  8. अंत में, ट्रंक को उस बिंदु पर टैग करें, और उस टैग को लाइव में तैनात करें।


3

हम विकास कोड (जहां हर डेवलपर की अपनी शाखा है) से उत्पादन कोड (मुख्य ट्रंक) को पूरी तरह से अलग करके इस समस्या को हल करते हैं।

किसी भी कोड को उत्पादन कोड में अनुमति नहीं दी जाती है, इससे पहले कि वह अच्छी तरह से जांचा गया हो (क्यूए और कोड समीक्षकों द्वारा)।

इस तरह से कोई भ्रम नहीं है कि कौन सा कोड काम करता है, यह हमेशा मुख्य शाखा है।


2

अरे हाँ - एक और बात - हम गैर-उत्पादन कोड रखते हैं (यानी जो कभी भी जारी नहीं किया जाएगा - उदाहरण के लिए उपकरण स्क्रिप्ट, परीक्षण उपयोगिताओं) सीवीएस हेड में। आमतौर पर इसे स्पष्ट रूप से चिह्नित करने की आवश्यकता है ताकि कोई भी "गलती से" इसे जारी न करे।


2
शायद यह पिछले उत्तर को संपादित करने के रूप में बेहतर होगा।
रिचर्ड हैरिसन

6
उन्होंने कहा सी.वी.एस. :-)
तक

2

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

ट्रंक के लिए एकमात्र नियम यह है कि एक प्रतिबद्ध कुछ भी नहीं तोड़ना चाहिए। Wip-code और untested code को मैनेज करने के लिए हम उचित जोड़ते हैं यदि स्टेटमेंट्स को आसान बनाने के लिए इसे चालू और बंद करें।

मूल रूप से यह किसी भी समय ट्रंक को शाखा देने और उत्पादन में डालने के लिए संभव है।


0

मैं गिट का उपयोग करता हूं और मेरी 2 शाखाएं हैं: मास्टर और मेन्ट

  • मास्टर - विकास कोड
  • maint - उत्पादन कोड

जब मैं उत्पादन के लिए कोड जारी करता हूं, तो मैं इसे टैग करता हूं और मैं मास्टर को मेन्ट शाखा में मिला देता हूं । मैं हमेशा मेन्ट ब्रांच से तैनात हूं । विकास शाखा I से चेरी पैच उन्हें मेन्ट शाखा में ले जाते हैं और पैच तैनात करते हैं।


0

हमारे पास एक "रिलीज" शाखा है जिसमें वर्तमान में उत्पादन पर है या शीघ्र ही तैनात किया जाएगा (पहले से ही सबसे अधिक QA पारित)

प्रत्येक परियोजना, या कुछ मामलों में अन्य इकाई, की अपनी शाखा होती है जो रिलीज से शाखित होती है।

परियोजना के विकासकर्ताओं द्वारा, उनकी परियोजना की अपनी शाखा में, परिवर्तन किए जाते हैं। समय-समय पर, रिलीज को एक विकास शाखा में वापस मिला दिया जाता है।

एक बार शाखा पर कार्य पैकेज सभी QA'd (इकाई परीक्षण, सिस्टम परीक्षण, कोड समीक्षा, QA समीक्षा आदि) होते हैं, तो शाखा को रिलीज शाखा में विलय कर दिया जाता है। नया बिल्ड (s) रिलीज़ शाखा से बनाया गया है, और अंतिम सत्यापन उस संस्करण पर होता है।

प्रक्रिया मूल रूप से तब तक ठीक है जब तक कि मर्ज किए जाने के बाद किसी समस्या का पता नहीं चल जाता है। यदि विलय होने के बाद एक WP "अटक" जाता है, तो यह तय होने के बाद तक सब कुछ पकड़ लेता है (जब तक कि एक जारी नहीं किया जाता है तब तक हम एक और रिलीज नहीं कर सकते)।


यह कुछ हद तक लचीला भी है - एक बहुत ही तुच्छ परिवर्तन सीधे रिलीज शाखा पर हो सकता है यदि यह बहुत कम समय के पैमाने पर जारी किया जा रहा है (जैसे 1-2 दिन या तो)।

यदि किसी कारण से उत्पादन में सीधे परिवर्तन किया गया (एक महत्वपूर्ण ग्राहक-प्रभावित उत्पादन समस्या जिसे ठीक करने के लिए तत्काल कोड परिवर्तन की आवश्यकता है), तो उन परिवर्तनों को वापस BRANCH_RELEASE में डाल दिया जाएगा। जो शायद ही कभी होता है।


0

यह प्रोजेक्ट पर निर्भर करता है। हमारे वेब कोड की लगातार जांच की जाती है, जबकि हमारा एप्लिकेशन कोड केवल तभी जांचा जाता है जब वह संकलित होता है। मैंने देखा है कि यह बहुत ही समान है कि हम चीजों को कैसे जारी करते हैं। जब भी एप्लिकेशन हार्ड डेडलाइन मारता है तो वेब सामान ऊपर चला जाता है। मैं हालांकि विधि में गुणवत्ता का नुकसान नहीं देखा है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.