Erlang 21

disk_log




erlang

disk_log

मॉड्यूल

disk_log

मॉड्यूल सारांश

एक डिस्क-आधारित टर्म लॉगिंग सुविधा।

विवरण

disk_log एक डिस्क-आधारित शब्द लकड़हारा है जो फ़ाइलों पर कुशल लॉगिंग आइटम सक्षम करता है।

दो प्रकार के लॉग समर्थित हैं:

पड़ाव लॉग

किसी एकल फ़ाइल में आइटम जोड़ता है, जिसका आकार disk_log मॉड्यूल द्वारा सीमित किया जा सकता है।

लपेटो लॉग

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

दक्षता कारणों से, आइटम हमेशा बायनेरिज़ के रूप में फ़ाइलों को लिखे जाते हैं।

लॉग फ़ाइलों के दो प्रारूप समर्थित हैं:

आंतरिक प्रारूप

लॉग फ़ाइलों की स्वचालित मरम्मत का समर्थन करता है जो ठीक से बंद नहीं हैं और इस मॉड्यूल में परिभाषित कार्यों के एक सेट का उपयोग करके चंक्स में लॉग किए गए आइटमों के कुशल पढ़ने को सक्षम करता है। यह आंतरिक स्वरूपित लॉग को पढ़ने का एकमात्र तरीका है। आंतरिक रूप से स्वरूपित लॉग में लॉग की गई वस्तु में 4 GB से अधिक डिस्क स्थान नहीं होना चाहिए (आकार 4 बाइट्स में फिट होना चाहिए)।

बाहरी प्रारूप

लॉग किए गए डेटा को पढ़ने और व्याख्या करने के लिए उपयोगकर्ता पर छोड़ देता है। disk_log मॉड्यूल बाहरी स्वरूपित लॉग की मरम्मत नहीं कर सकता है।

प्रत्येक ओपन डिस्क लॉग के लिए, एक प्रक्रिया डिस्क लॉग में किए गए अनुरोधों को संभालती है। यह प्रक्रिया तब बनाई जाती है जब open/1 कहा जाता है, बशर्ते कि डिस्क लॉग को संभालने वाली कोई प्रक्रिया मौजूद न हो। डिस्क लॉग खोलने वाली एक प्रक्रिया एक मालिक या डिस्क लॉग का एक अनाम उपयोगकर्ता हो सकती है। प्रत्येक स्वामी डिस्क लॉग प्रक्रिया से जुड़ा होता है, और एक मालिक डिस्क लॉग को या तो स्पष्ट रूप से बंद कर सकता है ( close/1 या lclose/1,2 कॉल करके) या समाप्त करके।

स्वामी सूचनाओं के लिए सदस्यता ले सकते हैं, प्रपत्र {disk_log, Node, Log, Info} संदेश, जो डिस्क लॉग प्रक्रिया से भेजे जाते हैं जब कुछ घटनाएं {disk_log, Node, Log, Info} हैं, तो फ़ंक्शन देखें और विशेष रूप से open/1 विकल्प को notify । एक लॉग में कई मालिक हो सकते हैं, लेकिन एक प्रक्रिया एक से अधिक बार लॉग का मालिक नहीं हो सकती। हालांकि, एक ही प्रक्रिया लॉग को एक से अधिक बार उपयोगकर्ता के रूप में खोल सकती है।

डिस्क लॉग प्रक्रिया के लिए अपनी फ़ाइल को ठीक से बंद करने और समाप्त करने के लिए, इसे उसके मालिकों द्वारा बंद कर दिया जाना चाहिए और प्रत्येक बार लॉग-इन गुमनाम रूप से उपयोग किए जाने पर कुछ गैर-स्वामी प्रक्रिया के द्वारा। उपयोगकर्ताओं को गिना जाता है और डिस्क लॉग प्रक्रिया समाप्त होने पर कोई भी उपयोगकर्ता नहीं होना चाहिए।

फ़ंक्शन log/2 , blog/2 , log_terms/2 और blog_terms/2 का उपयोग करके आइटम को सिंक्रोनाइज़ किया जा सकता है। इनमें से प्रत्येक फ़ंक्शन के लिए, कॉलर को तब तक होल्ड पर रखा जाता है जब तक कि आइटम लॉग नहीं किए जाते हैं (लेकिन जरूरी नहीं कि लिखा हो, sync/1 का उपयोग करें ताकि यह सुनिश्चित हो सके)। उल्लिखित फ़ंक्शन नामों में से प्रत्येक में a जोड़कर, हमें ऐसे फ़ंक्शन मिलते हैं जो आइटम को अतुल्यकालिक रूप से लॉग करते हैं। असिंक्रोनस फ़ंक्शंस फ़ाइल में आइटम लिखने के लिए डिस्क लॉग प्रक्रिया की प्रतीक्षा नहीं करते हैं, लेकिन कॉल करने वाले को कम या ज्यादा तुरंत नियंत्रित करते हैं।

लॉग के लिए आंतरिक प्रारूप का उपयोग करते समय, फ़ंक्शन log/2 , log_terms/2 , alog/2 और alog_terms/2 । ये फ़ंक्शन एक या अधिक Erlang शब्द लॉग करते हैं। b ("बाइनरी") के साथ प्रत्येक फ़ंक्शन को उपसर्ग करने से, हमें बाहरी प्रारूप के लिए संबंधित blog() फ़ंक्शन मिलते हैं। ये फ़ंक्शन बाइट्स के एक या एक से अधिक विखंडू को लॉग करते हैं। उदाहरण के लिए, ASCII प्रारूप में स्ट्रिंग "hello" को लॉग करने के लिए, आप disk_log:blog(Log, "hello") , या disk_log:blog(Log, list_to_binary("hello")) । दो विकल्प समान रूप से कुशल हैं।

blog() फ़ंक्शंस का उपयोग आंतरिक रूप से स्वरूपित लॉग के लिए भी किया जा सकता है, लेकिन इस मामले में उन्हें बायनेरिज़ के साथ कॉल किया जाना चाहिए जिसे term_to_binary/1 कॉल किया जाता है। यह सुनिश्चित करने के लिए कोई जांच नहीं है, यह पूरी तरह से कॉलर की जिम्मेदारी है। यदि इन कार्यों को बायनेरिज़ के साथ कहा जाता है जो एरलांग शर्तों के अनुरूप नहीं हैं, तो chunk/2,3 और स्वचालित मरम्मत कार्य विफल हो जाते हैं। जब chunk/2,3 कहा जाता है तो संबंधित शब्द (बायनेरिज़ नहीं) लौटाए जाते हैं।

समान नोड्स पर चलने वाले एक ही नाम के साथ ओपन डिस्क लॉग्स का एक संग्रह एक वितरित डिस्क लॉग कहा जाता है यदि किसी भी लॉग में किए गए अनुरोध स्वचालित रूप से अन्य लॉग्स के लिए भी किए जाते हैं। इस तरह के संग्रह के सदस्यों को अलग-अलग वितरित डिस्क लॉग्स कहा जाता है, या केवल डिस्क लॉग वितरित किए जाने पर भ्रम की स्थिति नहीं होती है। इस तरह के संग्रह के सदस्यों के बीच कोई आदेश नहीं है। उदाहरण के लिए, लॉग किए गए शब्दों को आवश्यक रूप से उस नोड पर नहीं लिखा जाता है जहां अन्य नोड्स को लिखे जाने से पहले अनुरोध किया गया था। हालाँकि, कुछ फ़ंक्शंस वितरित डिस्क लॉग के सभी सदस्यों के लिए अनुरोध नहीं करते हैं, अर्थात् info/1 , chunk/2,3 , bchunk/2,3 , chunk_step/3 और lclose/1,2

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

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

ध्यान दें

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

त्रुटियों को अतुल्यकालिक लॉग प्रयासों और disk_log मॉड्यूल के अन्य उपयोगों के लिए अलग-अलग रिपोर्ट किया जाता है। जब सिंक्रोनस का उपयोग किया जाता है, तो यह मॉड्यूल एक त्रुटि संदेश के साथ उत्तर देता है, लेकिन जब एसिंक्रोनसली कहा जाता है, तो यह मॉड्यूल नहीं जानता कि त्रुटि संदेश कहां भेजा जाए। इसके बजाय, सूचनाओं की सदस्यता लेने वाले मालिकों को एक error_status संदेश प्राप्त होता है।

disk_log मॉड्यूल disk_log मॉड्यूल में त्रुटियों की रिपोर्ट नहीं करता है। यह कॉल करने वाले पर निर्भर करता है कि वह त्रुटि लकड़हारे को नियोजित करे या नहीं। फंक्शन format_error/1 का उपयोग त्रुटि उत्तरों से पठनीय संदेशों का उत्पादन करने के लिए किया जा सकता है। हालाँकि, जानकारी ईवेंट दो लॉगर में त्रुटि लॉगर को भेजी जाती हैं, अर्थात् जब लॉग की मरम्मत की जाती है, या जब किसी फाइल को पढ़ने के दौरान कोई फाइल गायब होती है।

त्रुटि संदेश no_such_log अर्थ है कि निर्दिष्ट डिस्क लॉग खुला नहीं है। डिस्क लॉग फाइल मौजूद है या नहीं, इसके बारे में कुछ नहीं कहा गया है।

ध्यान दें

यदि लॉग लॉग को फिर से खोलने या छोटा करने का प्रयास विफल रहता है ( reopen/2,3 और truncate/1,2 ) डिस्क लॉग प्रक्रिया तुरंत समाप्त हो जाती है। प्रक्रिया समाप्त होने से पहले, मालिकों और अवरुद्ध प्रक्रियाओं के लिंक ( block/1,2 देखें) हटा दिए जाते हैं। इसका प्रभाव यह है कि लिंक केवल एक दिशा में काम करते हैं। डिस्क लॉग का उपयोग करने वाली किसी भी प्रक्रिया को त्रुटि संदेश no_such_log लिए no_such_log यदि कोई अन्य प्रक्रिया लॉग को एक साथ no_such_log या फिर से no_such_log

जानकारी का प्रकार

log() = term()
dlog_size() =
infinity |
integer() >= 1 |
{MaxNoBytes :: integer() >= 1, MaxNoFiles :: integer() >= 1}

dlog_format() = external | internal
dlog_head_opt() = none | term() | iodata()
dlog_mode() = read_only | read_write
dlog_type() = halt | wrap
continuation()

Chunk chunk/2,3 , bchunk/2,3 , या chunk_step/3 द्वारा चंक जारी है।

invalid_header() = term()
file_error() = term()

निर्यात

सुलभ_लॉग्स () -> {[लोकललॉग], [वितरितलोग]}

प्रकार

वर्तमान नोड पर सुलभ डिस्क लॉग के नाम लौटाता है। पहली सूची में स्थानीय डिस्क लॉग होते हैं और दूसरी सूची में वितरित डिस्क लॉग होते हैं।

alog (लॉग, शब्द) -> सूचना_पत्र ()
बोग (लॉग, बाइट्स) -> सूचना_रेट ()

प्रकार

असिंक्रोनस रूप से डिस्क लॉग में एक आइटम जोड़ें। alog/2 का उपयोग आंतरिक रूप से स्वरूपित लॉग और बाहरी रूप से स्वरूपित लॉग के लिए balog/2 लिए किया जाता है। balog/2 उपयोग आंतरिक रूप से स्वरूपित लॉग के लिए भी किया जा सकता है यदि बाइनरी का निर्माण term_to_binary/1 कॉल के साथ किया जाता है term_to_binary/1

यदि format_external लॉग में नहीं लिखी जा सकती हैं, और संभवत: एक आइटम लॉग में लिखे जाने पर, संदेश में सब्सक्राइब करने वाले मालिकों को संदेश read_only , blocked_log , या format_external प्राप्त होता है, और संभवत: संदेश wrap , full , या error_status एक। संदेश error_status को भेजा जाता है यदि हेडर फ़ंक्शन के साथ कुछ गलत है या यदि फ़ाइल त्रुटि होती है।

alog_terms (लॉग, टर्मलिस्ट) -> सूचना_रेट ()
balog_terms (लॉग, बाइटलिस्ट) -> सूचना_रेट ()

प्रकार

असिंक्रोनस रूप से डिस्क लॉग में आइटमों की एक सूची संलग्न करें। alog_terms/2 का उपयोग आंतरिक रूप से स्वरूपित लॉग के लिए और बाहरी रूप से स्वरूपित लॉग के लिए balog_terms/2 लिए किया जाता है। यदि बायनेरिज़ को term_to_binary/1 कॉल के साथ निर्मित किया जाता है, तो balog_terms/2 उपयोग आंतरिक रूप से स्वरूपित लॉग के लिए भी किया जा सकता है।

यदि format_external लॉग में नहीं लिखी जा सकती हैं, और संभवत: आइटम लॉग में लिखे गए हैं, तो सूचनाओं की सदस्यता लेने वाले स्वामी, read_only , blocked_log , या format_external संदेश प्राप्त करते हैं और संभवत: एक या अधिक संदेश wrap , full , और error_status । संदेश error_status को भेजा जाता है यदि हेडर फ़ंक्शन के साथ कुछ गलत है या यदि फ़ाइल त्रुटि होती है।

ब्लॉक (लॉग) -> ठीक | {त्रुटि, block_error_rsn ()}
ब्लॉक (लॉग, QueueLogRecords) -> ठीक | {त्रुटि, block_error_rsn ()}

प्रकार

एक कॉल को block/1,2 करने से एक लॉग को ब्लॉक किया जा सकता है। यदि ब्लॉकिंग प्रक्रिया लॉग का स्वामी नहीं है, तो डिस्क लॉग प्रक्रिया और ब्लॉकिंग प्रक्रिया के बीच एक अस्थायी लिंक बनाया जाता है। लिंक यह सुनिश्चित करता है कि अगर डिस्क को पहले बंद या लॉग को अनब्लॉक किए बिना ब्लॉक करने की प्रक्रिया समाप्त हो जाए तो डिस्क लॉग अनब्लॉक हो जाता है।

कोई भी प्रक्रिया अवरुद्ध लॉग की info/1 साथ जांच कर सकती है या इसे close/1 साथ close/1 । ब्लॉकिंग प्रक्रिया प्रभावित किए बिना भी फ़ंक्शन chunk/2,3 , bchunk/2,3 , chunk_step/3 और unblock/1 उपयोग कर सकती है। ब्लॉक किए गए लॉग को अपडेट करने या पढ़ने के लिए अब तक उल्लिखित उन लोगों के अलावा कोई अन्य प्रयास कॉलिंग प्रक्रिया को निलंबित करता है जब तक कि लॉग अनब्लॉक न हो या त्रुटि संदेश {blocked_log, Log} वापस कर देता है, यह इस बात पर निर्भर करता है कि QueueLogRecords का मूल्य true या false QueueLogRecords true को डिफॉल्ट करता true , जिसका उपयोग block/1 द्वारा किया जाता है।

change_header (लॉग, हैडर) -> ठीक | {त्रुटि, कारण}

प्रकार

डिस्क लॉग के स्वामी के लिए विकल्प head या head_func का मान बदलता है।

change_notify (लॉग, मालिक, सूचित करें) -> ठीक है | {त्रुटि, कारण}

प्रकार

डिस्क लॉग के स्वामी के लिए विकल्प के मूल्य को notify

change_size (लॉग, आकार) -> ठीक | {त्रुटि, कारण}

प्रकार

एक खुले लॉग का आकार बदलता है। पड़ाव लॉग के लिए, आकार हमेशा बढ़ाया जा सकता है, लेकिन इसे वर्तमान फ़ाइल आकार से कुछ कम नहीं किया जा सकता है।

एक रैप लॉग के लिए, फ़ाइलों के आकार और संख्या दोनों को हमेशा बढ़ाया जा सकता है, जब तक कि फ़ाइलों की संख्या 65000 से अधिक न हो। यदि फ़ाइलों की अधिकतम संख्या कम हो जाती है, तो परिवर्तन तब तक मान्य नहीं होता है जब तक कि वर्तमान फ़ाइल पूर्ण न हो। और लॉग अगली फाइल में जाता है। बेमानी फ़ाइलों को हटा दिया जाता है अगली बार जब लॉग चारों ओर घूमता है, अर्थात, फ़ाइल नंबर 1 में प्रवेश करना शुरू होता है।

एक उदाहरण के रूप में, मान लें कि फ़ाइलों की पुरानी अधिकतम संख्या 10 है और यह कि नई अधिकतम फ़ाइलों की संख्या 6 है। यदि वर्तमान फ़ाइल संख्या नई अधिकतम फ़ाइलों की संख्या से अधिक नहीं है, तो फ़ाइल 6 के समय 7-10 फाइलें हटा दी जाती हैं। भरा हुआ है और लॉग फिर से फाइल नंबर 1 पर लिखना शुरू करता है। अन्यथा, वर्तमान फ़ाइल पूर्ण होने पर वर्तमान फ़ाइल से अधिक फ़ाइलें हटा दी जाती हैं (उदाहरण के लिए, यदि वर्तमान फ़ाइल 8 है, तो फ़ाइलें 9 और 10 हटा दी जाती हैं)। अगली बार फ़ाइल 6 भरी जाने पर नई फ़ाइलों की संख्या और वर्तमान फ़ाइल (यानी, फ़ाइलें 7 और 8) के बीच की फाइलें निकाल दी जाती हैं।

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

यदि लॉग आकार घटाया जाता है, उदाहरण के लिए, अंतरिक्ष को बचाने के लिए, inc_wrap_file/1 फ़ंक्शन को लपेटने के लिए लॉग को मजबूर करने के लिए उपयोग किया जा सकता है।

chunk (लॉग, कंटीन्यूअस) -> chunk_ret ​​()
chunk (लॉग, कंटीन्यूशन, N) -> chunk_ret ​​()
bchunk (लॉग, कंटीन्यूअस) -> bchunk_ret ​​()
bchunk (लॉग, कंटीन्यूशन, N) -> bchunk_ret ​​()

प्रकार

कुशलता से उन शब्दों को पढ़ता है जो आंतरिक रूप से स्वरूपित लॉग में जोड़े जाते हैं। यह फ़ाइल से 64 किलोबाइट विखंडू पढ़कर डिस्क I / O को कम करता है। कार्य bchunk/2,3 फ़ाइल से पढ़े गए बायनेरिज़ को वापस करते हैं, वे binary_to_term() नहीं कहते हैं। इसके अलावा, वे chunk/2,3 तरह ही काम करते हैं।

पहली बार chunk() (या bchunk() ) कहा जाता है, एक प्रारंभिक निरंतरता, परमाणु start , प्रदान किया जाना चाहिए। यदि डिस्क नोड प्रक्रिया वर्तमान नोड पर चल रही है, तो उस लॉग से शर्तें पढ़ी जाती हैं। अन्यथा, कुछ अन्य नोड पर एक व्यक्तिगत वितरित लॉग चुना जाता है, अगर ऐसा लॉग मौजूद है।

जब chunk/3 कहा जाता है, तो N प्रत्येक चंक में लॉग से पढ़े जाने वाले शब्दों की अधिकतम संख्या को नियंत्रित करता है। infinity लिए चूक, जिसका अर्थ है कि 64 किलोबाइट चंक में निहित सभी शब्द पढ़े जाते हैं। यदि N से कम शर्तें वापस की जाती हैं, तो इसका मतलब यह नहीं है कि फ़ाइल का अंत तक पहुंच गया है।

chunk() एक tuple {Continuation2, Terms} , जहाँ Terms लॉग में पाए गए शब्दों की एक सूची है। Continuation2 अभी तक एक और निरंतरता है, जिसे किसी भी बाद की कॉल को chunk() करने के लिए पारित किया जाना चाहिए chunk() । कॉल को chunk() की एक श्रृंखला के साथ, एक लॉग से सभी शर्तों को निकाला जा सकता है।

chunk() एक टपल लौटाता है {Continuation2, Terms, Badbytes} यदि लॉग को केवल-पठन मोड में खोला गया है और रीड चंक दूषित है। Badbytes फ़ाइल में बाइट्स की संख्या है जो Badbytes में Erlang शब्द नहीं है। ध्यान दें कि लॉग की मरम्मत नहीं की गई है। जब पठन-लेखन मोड में खोले गए लॉग से विखंडू को पढ़ने की कोशिश की {corrupt_log_file, FileName} को वापस लौटा दिया जाता है।

लॉग के अंत तक पहुँचने पर chunk() eof लौटाता है, या यदि कोई त्रुटि होती है {error, Reason} तो {error, Reason} । यदि कोई रैप लॉग फ़ाइल अनुपलब्ध है, तो त्रुटि लॉग पर एक संदेश आउटपुट है।

जब chunk/2,3 लॉग्स के साथ chunk/2,3 का उपयोग किया जाता है, तो अगली कॉल chunk() में मान्य नहीं हो सकती है। ऐसा इसलिए है क्योंकि लॉग उस फ़ाइल को लपेट और हटा सकता है जिसमें निरंतरता इंगित करती है। इसे रोकने के लिए, खोज के दौरान लॉग को अवरुद्ध किया जा सकता है।

chunk_info (निरंतरता) -> InfoList | {त्रुटि, कारण}

प्रकार

chunk/2,3 , bchunk/2,3 , या chunk_step/3 द्वारा लौटी हुई निरंतरता का वर्णन करते हुए {node, Node} जोड़ी {node, Node} chunk_step/3

Node पर चल रहे डिस्क लॉग से शर्तें पढ़ी जाती हैं।

chunk_step (लॉग, कंटीन्यूअस, स्टेप) ->
{ठीक है, किसी भी ()} | {त्रुटि, कारण}

प्रकार

आंतरिक रूप से स्वरूपित रैप लॉग के माध्यम से खोजने के लिए chunk/2,3 और bchunk/2,3 साथ उपयोग किया जा सकता है। यह तर्क के रूप में एक निरंतरता लेता है जैसा कि chunk/2,3 , bchunk/2,3 , या chunk_step/3 द्वारा लौटाया जाता है, और रैप लॉग में Step (या पिछड़े) Step फ़ाइलों को आगे बढ़ाया जाता है। निरंतरता वापस लौटी, नई वर्तमान फ़ाइल में पहले लॉग आइटम की ओर इशारा करती है।

यदि परमाणु start को निरंतरता के रूप में निर्दिष्ट किया जाता है, तो शर्तों को पढ़ने के लिए एक डिस्क लॉग चुना जाता है। वर्तमान नोड पर एक स्थानीय या वितरित डिस्क लॉग किसी अन्य नोड पर एक व्यक्ति वितरित लॉग के लिए पसंद किया जाता है।

यदि रैप लॉग भरा नहीं है, क्योंकि सभी फाइलें अभी तक उपयोग नहीं की गई हैं, तो लॉग के बाहर कदम रखने की कोशिश करने पर {error, end_of_log} को लौटा दिया जाता है।

बंद (लॉग) -> ठीक है | {त्रुटि, करीब_रोर_र्सन ()}

प्रकार

एक स्थानीय या वितरित डिस्क लॉग को ठीक से बंद करता है। Erlang सिस्टम बंद करने से पहले एक आंतरिक स्वरूपित लॉग बंद होना चाहिए। अन्यथा, लॉग को अप्राप्त के रूप में माना जाता है और लॉग को खोलने के बाद स्वचालित मरम्मत प्रक्रिया सक्रिय हो जाती है।

डिस्क लॉग प्रक्रिया तब तक समाप्त नहीं होती है जब तक कि लॉग के मालिक या उपयोगकर्ता हैं। सभी मालिकों को संभवतः बंद करके लॉग बंद करना होगा। इसके अलावा, किसी भी अन्य प्रक्रिया, न केवल उन प्रक्रियाओं को, जिन्होंने लॉग को गुमनाम रूप से खोला है, लॉग को बंद करके users काउंटर को घटा सकते हैं। उपयोगकर्ता नहीं होने पर एक प्रक्रिया द्वारा लॉग को बंद करने के प्रयासों को अनदेखा किया जाता है।

यदि लॉग को समापन प्रक्रिया द्वारा अवरुद्ध किया जाता है, तो लॉग भी अनब्लॉक हो जाता है।

format_error (त्रुटि) -> io_lib:chars()

प्रकार

इस मॉड्यूल में किसी फ़ंक्शन द्वारा दी गई त्रुटि को देखते हुए, यह फ़ंक्शन अंग्रेजी में त्रुटि का एक वर्णनात्मक स्ट्रिंग लौटाता है। फ़ाइल त्रुटियों के लिए, मॉड्यूल file में फ़ंक्शन format_error/1 कहा जाता है।

inc_wrap_file (लॉग) -> ठीक | {त्रुटि, inc_wrap_error_rsn ()}

प्रकार

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

सूचनाओं की सदस्यता लेने वाले मालिक सामान्य रूप से एक wrap संदेश प्राप्त करते हैं, लेकिन यदि कोई त्रुटि error_status या file_error कारण टैग के साथ होती है, तो एक error_status संदेश भेजा जाता है।

जानकारी (लॉग) -> सूचना सूची | {त्रुटि, no_such_log}

प्रकार

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

सभी जोड़े के लिए निम्न जोड़े लौटाए गए हैं:

{name, Log}

Log open/1 नाम है जैसा कि open/1 विकल्प name निर्दिष्ट है।

{file, File}

पड़ाव लॉग के लिए File नाम है, और रैप लॉग्स के लिए File का आधार नाम है।

{type, Type}

Type open/1 विकल्प type द्वारा निर्दिष्ट लॉग type

{format, Format}

Format open/1 विकल्प format द्वारा निर्दिष्ट के रूप में लॉग format

{size, Size}

Size लॉग आकार है जैसा कि open/1 विकल्प size द्वारा निर्दिष्ट किया गया है, या change_size/2 द्वारा निर्धारित आकार। change_size/2 द्वारा निर्धारित मान तुरंत परिलक्षित होता है।

{mode, Mode}

Mode open/1 विकल्प mode द्वारा निर्दिष्ट के रूप में लॉग मोड mode

{owners, [{pid(), Notify}]}

Notify लॉग के मालिकों के लिए open/1 विकल्प notify या change_notify/3 द्वारा निर्धारित मूल्य है।

{users, Users}

Users लॉग के अनाम उपयोगकर्ताओं की संख्या है, open/1 विकल्प linkto

{status, Status}

Status ok या {blocked, QueueLogRecords} रूप से {blocked, QueueLogRecords} फ़ंक्शन block/1,2 द्वारा सेट और unblock/1

{node, Node}

फ़ंक्शन info/1 के वर्तमान आह्वान से लौटी info/1 को Node पर चल रही डिस्क लॉग प्रक्रिया से इकट्ठा किया जाता है।

{distributed, Dist}

यदि वर्तमान नोड पर लॉग स्थानीय है, तो Dist का मान local , अन्यथा सभी नोड्स जहां लॉग वितरित किया गया है एक सूची के रूप में वापस कर दिया जाता है।

निम्नलिखित जोड़े read_write मोड में खोले गए सभी लॉग्स के लिए दिए गए हैं:

{head, Head}

open/1 विकल्प head और head_func के मान के आधार पर, या फ़ंक्शन change_header/2 द्वारा सेट, Head का मूल्य none (डिफ़ॉल्ट), {head, H} ( head विकल्प), या {M,F,A} ( head_func विकल्प)।

{no_written_items, NoWrittenItems}

NoWrittenItems डिस्क लॉग प्रक्रिया NoWrittenItems बाद से लॉग में लिखे गए आइटमों की संख्या है।

निम्नलिखित जोड़ी read_write मोड में खोले गए हॉल्ट लॉग के लिए दी गई है:

{full, Full}

Full true या false इस पर निर्भर करता है कि पड़ाव लॉग भरा हुआ है या नहीं।

निम्नलिखित जोड़े read_write मोड में खोले गए लॉग के लिए लौटे हैं:

{no_current_bytes, integer() >= 0}

वर्तमान रैप लॉग फ़ाइल में लिखे गए बाइट्स की संख्या।

{no_current_items, integer() >= 0}

वर्तमान रैप लॉग फ़ाइल में लिखे गए मदों की संख्या, हैडर समावेशी।

{no_items, integer() >= 0}

सभी रैप लॉग फ़ाइलों में आइटम की कुल संख्या।

{current_file, integer()}

सीमा में वर्तमान रैप लॉग फ़ाइल के लिए क्रमिक 1..MaxNoFiles , जहां MaxNoFiles को open/1 विकल्प size द्वारा निर्दिष्ट किया जाता है या change_size/2 द्वारा सेट किया change_size/2

{no_overflows, {SinceLogWasOpened, SinceLastInfo}}

SinceLogWasOpened ( SinceLastInfo ) कई बार एक रैप लॉग फ़ाइल को भरने और एक नया खोलने या inc_wrap_file/1 को कॉल किया गया है क्योंकि डिस्क लॉग को अंतिम बार खोला गया था ( info/1 को आखिरी बार कहा गया था)। पहली बार info/2 को एक लॉग (फिर से खोला या छंटनी) के बाद कहा जाता है, दोनों मान समान हैं।

ध्यान दें कि chunk/2,3 , bchunk/2,3 , और chunk_step/3 info/1 द्वारा दिए गए किसी भी मूल्य को प्रभावित नहीं करते हैं।

lclose (लॉग) -> ठीक | {त्रुटि, lclose_error_rsn ()}
lclose (लॉग, नोड) -> ठीक | {त्रुटि, lclose_error_rsn ()}

प्रकार

lclose/1 एक स्थानीय लॉग या वर्तमान नोड पर एक व्यक्तिगत वितरित लॉग को बंद करता है।

lclose/2 निर्दिष्ट नोड पर एक व्यक्तिगत वितरित लॉग को बंद कर देता है यदि नोड वर्तमान नहीं है।

lclose(Log) lclose(Log, node()) बराबर है। close/1 भी देखें।

यदि निर्दिष्ट नाम के साथ कोई लॉग निर्दिष्ट नोड पर मौजूद नहीं है, तो no_such_log लौटाया जाता है।

log (लॉग, टर्म) -> ठीक है | {त्रुटि, कारण :: log_error_rsn ()}
ब्लॉग (लॉग, बाइट्स) -> ठीक | {त्रुटि, कारण :: log_error_rsn ()}

प्रकार

किसी शब्द को डिस्क लॉग में समकालिक रूप से जोड़ देता है। डिस्क पर शब्द लिखे जाने पर ok या {error, Reason} है। यदि लॉग वितरित किया जाता है, तो ok लौटाया जाता है, जब तक कि सभी नोड्स डाउन न हों। ऑपरेटिंग सिस्टम के साधारण write() फ़ंक्शन द्वारा शब्द लिखे गए हैं। इसलिए, यह गारंटी नहीं है कि यह शब्द डिस्क पर लिखा गया है, यह ऑपरेटिंग सिस्टम कर्नेल में थोड़ी देर के लिए टिका रह सकता है। यह सुनिश्चित करने के लिए कि आइटम डिस्क पर लिखा गया है, फ़ंक्शन sync/1 को बुलाया जाना चाहिए।

log/2 का उपयोग आंतरिक रूप से स्वरूपित लॉग के लिए किया जाता है, और blog/2 बाहरी स्वरूपित लॉग के लिए। blog/2 उपयोग आंतरिक रूप से स्वरूपित लॉग के लिए भी किया जा सकता है यदि बाइनरी का निर्माण term_to_binary/1

यदि त्रुटि कारण टैग error_status या file_error है, तो सूचनाओं के लिए सदस्यता लेने वाले स्वामी को एक error_status संदेश के साथ त्रुटि की सूचना दी जाती है।

log_terms (लॉग, टर्मलिस्ट) ->
ठीक है | {त्रुटि, Resaon :: log_error_rsn ()}
blog_terms (लॉग, बाइट्सलिस्ट) ->
ठीक है | {त्रुटि, कारण :: log_error_rsn ()}

प्रकार

सिंक्रोनस लॉग में आइटमों की एक सूची को जोड़ देता है। कार्य log/2 और blog/2 बजाय इन फ़ंक्शन का उपयोग करना अधिक कुशल है। निर्दिष्ट सूची को संभव के रूप में बड़े सब्लिस्ट में विभाजित किया गया है (रैप लॉग फ़ाइलों के आकार द्वारा सीमित), और प्रत्येक सबलिस्ट को एक एकल आइटम के रूप में लॉग किया जाता है, जो ओवरहेड को कम करता है।

log_terms/2 का उपयोग आंतरिक रूप से स्वरूपित लॉग के लिए किया जाता है, और बाह्य स्वरूपित लॉग के लिए blog_terms/2 blog_terms/2 उपयोग आंतरिक रूप से स्वरूपित लॉग के लिए भी किया जा सकता है यदि बायनेरिज़ term_to_binary/1 कॉल के साथ बनाए जाते हैं।

यदि त्रुटि कारण टैग error_status या file_error है, तो सूचनाओं के लिए सदस्यता लेने वाले स्वामी को एक error_status संदेश के साथ त्रुटि की सूचना दी जाती है।

open (ArgL) -> open_ret () | dist_open_ret ()

प्रकार

पैरामीटर ArgL निम्नलिखित विकल्पों की एक सूची है:

{name, Log}

लॉग नाम निर्दिष्ट करता है। इस नाम को बाद के सभी लॉगिंग ऑपरेशनों में एक पैरामीटर के रूप में पारित किया जाना चाहिए। एक नाम हमेशा दिया जाना चाहिए।

{file, FileName}

लॉग किए गए शब्दों के लिए उपयोग की जाने वाली फ़ाइल का नाम निर्दिष्ट करता है। यदि यह मान छोड़ दिया गया है और लॉग नाम एक एटम या स्ट्रिंग है, तो फ़ाइल नाम डिफॉल्ट को lists:concat([Log, ".LOG"]) हॉल्ट लॉग्स के लिए lists:concat([Log, ".LOG"])

रैप लॉग्स के लिए, यह फ़ाइलों का आधार नाम है। रैप लॉग में प्रत्येक फ़ाइल को <base_name>.N कहा जाता है, जहाँ N एक पूर्णांक है। प्रत्येक रैप लॉग में दो फाइलें भी होती हैं जिन्हें <base_name>.idx और <base_name>.siz कहा जाता है।

{linkto, LinkTo}

यदि LinkTo एक पिड है, तो यह लॉग का मालिक बन जाता है। यदि LinkTo none , तो लॉग इन रिकॉर्ड करता है कि यह users काउंटर को LinkTo कुछ प्रक्रिया द्वारा गुमनाम रूप से उपयोग किया जाता है। डिफ़ॉल्ट रूप से, open/1 कॉल करने वाली प्रक्रिया लॉग का मालिक है।

{repair, Repair}

यदि Repair true , तो वर्तमान लॉग फ़ाइल की मरम्मत की जाती है, यदि आवश्यक हो। जैसे ही बहाली शुरू की जाती है, त्रुटि लॉग पर एक संदेश आउटपुट होता है। यदि false निर्दिष्ट किया गया है, तो कोई भी स्वचालित मरम्मत का प्रयास नहीं किया जाता है। इसके बजाय, दूषित लॉग फ़ाइल को खोलने का प्रयास किए जाने पर टपल {error, {need_repair, Log}} लौटा दी जाती है। यदि truncate निर्दिष्ट किया गया है, तो लॉग फ़ाइल छोटा हो जाता है, एक खाली लॉग बनाता है। डिफॉल्ट्स टू true , जिसका रीड-ओनली मोड में खोले गए लॉग पर कोई प्रभाव नहीं पड़ता है।

{type, Type}

लॉग प्रकार। halt लिए चूक।

{format, Format}

डिस्क लॉग प्रारूप। internal चूक।

{size, Size}

लॉग आकार।

जब एक हॉल्ट लॉग अपने अधिकतम आकार तक पहुंच गया है, तो अधिक आइटम लॉग करने के सभी प्रयास अस्वीकार कर दिए जाते हैं। infinity , जो रुकने का अर्थ है कि अधिकतम आकार नहीं है।

रैप लॉग के लिए, पैरामीटर Size एक जोड़ी {MaxNoBytes, MaxNoFiles} या infinity । उत्तरार्द्ध मामले में, यदि मौजूदा रैप लॉग की फाइलें उसी नाम से पाई जा सकती हैं, तो आकार को मौजूदा रैप लॉग से पढ़ा जाता है, अन्यथा एक त्रुटि वापस आ जाती है।

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

मौजूदा रैप लॉग खोलते समय, विकल्प Size लिए एक मूल्य की आपूर्ति करना आवश्यक नहीं है, लेकिन किसी भी आपूर्ति किए गए मूल्य को वर्तमान लॉग आकार के बराबर होना चाहिए, अन्यथा टपल {error, {size_mismatch, CurrentSize, NewSize}} वापस आ गया है।

{distributed, Nodes}

इस विकल्प का उपयोग किसी वितरित डिस्क लॉग में सदस्यों को जोड़ने के लिए किया जा सकता है। डिफॉल्ट्स [] , जिसका अर्थ है कि वर्तमान नोड पर लॉग स्थानीय है।

{notify, boolean()}

यदि true , तो कुछ निश्चित ईवेंट होने पर लॉग स्वामियों को सूचित किया जाता है। false अवहेलना। किसी घटना के होने पर मालिकों को निम्नलिखित संदेशों में से एक भेजा जाता है:

{disk_log, Node, Log, {wrap, NoLostItems}}

भेजा गया है जब एक रैप लॉग ने अपनी एक फाइल भर दी है और एक नई फाइल खोली है। NoLostItems पहले से लॉग की गई वस्तुओं की संख्या है जो मौजूदा फ़ाइलों को NoLostItems समय खो गई थीं।

{disk_log, Node, Log, {truncated, NoLostItems}}

जब एक लॉग को छोटा या फिर से खोल दिया जाता है तो भेजा जाता है। हॉल्ट लॉग के लिए NoLostItems लॉग लॉग पर लिखी गई वस्तुओं की संख्या है क्योंकि डिस्क लॉग प्रक्रिया बनाई गई थी। रैप लॉग्स के लिए NoLostItems सभी रैप लॉग फाइलों पर मदों की संख्या है।

{disk_log, Node, Log, {read_only, Items}}

जब एक अतुल्यकालिक लॉग प्रयास केवल-केवल मोड में खोली गई लॉग फ़ाइल के लिए भेजा जाता है। Items लॉग प्रयास से Items है।

{disk_log, Node, Log, {blocked_log, Items}}

भेजा जब एक अतुल्यकालिक लॉग प्रयास एक अवरुद्ध लॉग के लिए किया जाता है जो लॉग प्रयासों को कतार में नहीं रखता है। Items लॉग प्रयास से Items है।

{disk_log, Node, Log, {format_external, Items}}

भेजा जब फ़ंक्शन alog/2 या alog_terms/2 आंतरिक रूप से स्वरूपित लॉग के लिए उपयोग किया जाता है। Items लॉग प्रयास से Items है।

{disk_log, Node, Log, full}

भेजा जब एक लपेटो लॉग करने के लिए आइटम लॉग करने का प्रयास विकल्प size द्वारा निर्धारित सीमा से अधिक बाइट्स लिखेंगे।

{disk_log, Node, Log, {error_status, Status}}

भेजे जाने पर त्रुटि स्थिति बदल जाती है। त्रुटि स्थिति को लॉग में आइटम लॉग करने के लिए अंतिम प्रयास के परिणाम या लॉग को छोटा करने के लिए या फ़ंक्शन sync/1 , inc_wrap_file/1 , या change_size/2 के अंतिम उपयोग द्वारा परिभाषित किया गया है। Status या तो ok या {error, Error} , पूर्व प्रारंभिक मूल्य है।

{head, Head}

किसी शीर्ष लेख को पहले लॉग फ़ाइल पर लिखे जाने के लिए निर्दिष्ट करता है। यदि लॉग एक रैप लॉग है, तो आइटम Head प्रत्येक नई फ़ाइल में पहले लिखा जाता है। यदि प्रारूप internal है तो Head एक शब्द होना चाहिए, अन्यथा बाइट्स का एक क्रम। डिफॉल्ट्स टू नो, जिसका अर्थ है कि कोई भी हेडर पहले फ़ाइल पर नहीं लिखा जाता है।

{head_func, {M,F,A}}

हर बार एक नई लॉग फ़ाइल खोले जाने के लिए किसी फ़ंक्शन को निर्दिष्ट करता है। कॉल M:F(A) मान लिया गया है {ok, Head} । आइटम Head प्रत्येक फ़ाइल में पहले लिखा जाता है। यदि प्रारूप internal है तो Head एक शब्द होना चाहिए, अन्यथा बाइट्स का एक क्रम।

{mode, Mode}

निर्दिष्ट करता है कि लॉग को रीड-ओनली या रीड-राइट मोड में खोला जाना है। read_write करने के लिए डिफ़ॉल्ट।

{quiet, Boolean}

निर्दिष्ट करता है कि लॉग फ़ाइलों के साथ पुनर्प्राप्त करने योग्य त्रुटियों पर संदेश error_logger को भेजा जाएगा या नहीं। false अवहेलना।

यदि लॉग फ़ाइल को सफलतापूर्वक खोला जाता है तो open/1 रिटर्न {ok, Log} । यदि फ़ाइल को सफलतापूर्वक ठीक किया जाता है, तो टपल {repaired, Log, {recovered, Rec}, {badbytes, Bad}} को वापस कर दिया जाता है, जहां Rec फ़ाइल में पाए गए पूरे एर्लांग शब्दों की संख्या है और Bad बाइट्स की संख्या है। वह फ़ाइल जो गैर-एर्लैंग शब्द है। यदि distributed गया पैरामीटर निर्दिष्ट है, तो open/1 सफल उत्तरों की एक सूची और गलत उत्तरों की एक सूची देता है। प्रत्येक उत्तर नोड नाम के साथ टैग किया गया है।

जब डिस्क लॉग को रीड-राइट मोड में खोला जाता है, तो किसी भी मौजूदा लॉग फ़ाइल की जाँच की जाती है। यदि कोई नहीं है, तो एक नया खाली लॉग बनाया जाता है, अन्यथा मौजूदा फ़ाइल को अंतिम लॉग आइटम के बाद की स्थिति में खोला जाता है, और आइटम का लॉगिंग वहीं से शुरू होता है। यदि स्वरूप internal और मौजूदा फ़ाइल को आंतरिक रूप से स्वरूपित लॉग के रूप में नहीं पहचाना जाता है, तो एक टपल {error, {not_a_log_file, FileName}} वापस आ जाती है।

open/1 लॉग के विकल्पों के मूल्यों को बदलने के लिए open/1 उपयोग नहीं किया जा सकता है। जब कोई लॉग के पूर्व मालिक या उपयोगकर्ता होते हैं, तो name , linkto और linkto को छोड़कर सभी विकल्प मान केवल जाँच किए गए मानों के खिलाफ जाँच किए जाते हैं जैसे कि विकल्प मान open/1 , change_header/2 , change_notify/3 , या change_size/2 । इस प्रकार, name को छोड़कर कोई भी विकल्प अनिवार्य नहीं है। यदि कुछ निर्दिष्ट मान वर्तमान मान से भिन्न होता है, तो एक {error, {arg_mismatch, OptionName, CurrentValue, Value}} वापस आ जाता है।

ध्यान दें

यदि कोई स्वामी एक बार फिर से स्वामी के रूप में लॉग खोलने का प्रयास करता है, तो उसे रिटर्न मान {ok, Log} साथ स्वीकार किया जाता है, लेकिन डिस्क लॉग की स्थिति प्रभावित नहीं होती है।

यदि किसी निर्दिष्ट नाम के साथ एक लॉग कुछ नोड पर स्थानीय है, और कोई उसी नोड पर वितरित लॉग को खोलने का प्रयास करता है, तो टपल {error, {node_already_open, Log}} वापस आ जाता है। यदि कुछ नोड पर लॉग वितरित किया जाता है, तो वही टपल लौटाया जाता है, और एक ही नोड पर स्थानीय रूप से लॉग को खोलने का प्रयास करता है। पहली बार व्यक्तिगत रूप से वितरित डिस्क लॉग को खोलना उन लॉग को (संभवतः खाली) वितरित डिस्क लॉग में जोड़ता है। distributed विकल्प मानों का उपयोग distributed किए गए विकल्प द्वारा उल्लिखित सभी नोड्स पर किया जाता है। व्यक्तिगत वितरित लॉग एक दूसरे के विकल्प मूल्यों के बारे में कुछ भी नहीं जानते हैं, इसलिए प्रत्येक नोड को open/1 को open/1 लिए कई कॉल के साथ वितरित लॉग बनाकर अद्वितीय विकल्प मान दिए जा सकते हैं।

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

यदि पहली बार लॉग फ़ाइल खोलने का प्रयास विफल हो जाता है, तो डिस्क लॉग प्रक्रिया EXIT संदेश {{failed,Reason},[{disk_log,open,1}]} साथ समाप्त हो जाती है। फ़ंक्शन अन्य सभी त्रुटियों के लिए {error, Reason} देता है।

pid2name (Pid) -> {ठीक है, लॉग} | अपरिभाषित

प्रकार

निर्दिष्ट नोड पर डिस्क लॉग प्रक्रिया नहीं होने पर लॉग नाम की डिस्क को मौजूदा नोड पर undefined करता है, या undefined करता है।

यह फ़ंक्शन केवल डीबगिंग के लिए उपयोग करने के लिए है।

reopen (लॉग, फ़ाइल) -> ठीक है | {त्रुटि, reopen_error_rsn ()}
reopen (लॉग, फ़ाइल, हेड) -> ठीक | {त्रुटि, reopen_error_rsn ()}
breopen (लॉग, फ़ाइल, BHead) -> ठीक | {त्रुटि, reopen_error_rsn ()}

प्रकार

फ़ाइल के लिए लॉग फ़ाइल का नाम बदलता है और फिर एक नई लॉग फ़ाइल को फिर से बनाता है। यदि कोई रैप लॉग मौजूद है, तो File का उपयोग नामांकित फ़ाइलों के आधार नाम के रूप में किया जाता है। डिफ़ॉल्ट रूप से open/1 लिए दिए गए हेडर को पहले नई खुली लॉग फ़ाइल में लिखा जाता है, लेकिन यदि तर्क Head या BHead निर्दिष्ट किया जाता है, तो इस आइटम का उपयोग इसके बजाय किया जाता है। शीर्ष लेख तर्क केवल एक बार उपयोग किया जाता है। अगली बार जब एक रैप लॉग फ़ाइल खोली जाती है, तो open/1 को दिए गए हेडर का उपयोग किया जाता है।

reopen/2,3 आंतरिक स्वरूपित लॉग के लिए उपयोग किया जाता है, और बाहरी रूप से स्वरूपित लॉग के लिए breopen/3

सूचनाओं की सदस्यता लेने वाले मालिकों को एक truncate संदेश मिलता है।

लॉग को फिर से खोलने में विफल होने पर, डिस्क लॉग प्रक्रिया EXIT संदेश {{failed,Error},[{disk_log,Fun,Arity}]} साथ समाप्त हो जाती है। कतारबद्ध अनुरोध वाली अन्य प्रक्रियाओं से संदेश {disk_log, Node, {error, disk_log_stopped}}

सिंक (लॉग) -> ठीक | {त्रुटि, Sync_error_rsn ()}

प्रकार

यह सुनिश्चित करता है कि लॉग की सामग्री डिस्क पर लिखी गई है। यह आमतौर पर एक महंगा ऑपरेशन है।

truncate (लॉग) -> ठीक | {त्रुटि, trunc_error_rsn ()}
truncate (लॉग, हेड) -> ठीक है | {त्रुटि, trunc_error_rsn ()}
btruncate (लॉग, BHead) -> ठीक | {त्रुटि, trunc_error_rsn ()}

प्रकार

डिस्क लॉग से सभी आइटम निकालता है। यदि तर्क Head या BHead निर्दिष्ट किया जाता है, तो यह आइटम पहले नए काटे गए लॉग में लिखा जाता है, अन्यथा open/1 में दिए गए हेडर का उपयोग किया जाता है। शीर्ष लेख तर्क केवल एक बार उपयोग किया जाता है। अगली बार जब एक रैप लॉग फ़ाइल खोली जाती है, तो open/1 को दिए गए हेडर का उपयोग किया जाता है।

truncate/1,2 का उपयोग आंतरिक रूप से स्वरूपित लॉग के लिए किया जाता है, और btruncate/2 लिए बाह्य स्वरूपित लॉग का उपयोग किया जाता है।

सूचनाओं की सदस्यता लेने वाले मालिकों को एक truncate संदेश मिलता है।

यदि लॉग को विफल करने का प्रयास विफल रहता है, तो डिस्क लॉग प्रक्रिया EXIT संदेश {{failed,Reason},[{disk_log,Fun,Arity}]} साथ समाप्त हो जाती है। कतारबद्ध अनुरोध वाली अन्य प्रक्रियाओं से संदेश {disk_log, Node, {error, disk_log_stopped}}

अनब्लॉक (लॉग) -> ओके | {त्रुटि, अनब्लॉक_रोर_र्सन ()}

प्रकार

लॉग को अनब्लॉक करता है। एक लॉग को केवल अवरुद्ध प्रक्रिया द्वारा अनब्लॉक किया जा सकता है।

यह भी देखें

file(3) , wrap_log_reader(3) pg2(3) , wrap_log_reader(3)

Original text