प्रत्येक} को एक विशाल (12 जीबी) में एक} \ n के साथ बदलें जिसमें 1 लाइन होती है?

Question

मेरे पास एक लॉग फ़ाइल है (एक ग्राहक से)। 18 गीगा फ़ाइल की सभी सामग्री 1 लाइन में हैं। मैं लॉगस्टैश में फ़ाइल को पढ़ना चाहता हूं। लेकिन मुझे मेमोरी की वजह से समस्याएं आती हैं। फ़ाइल लाइन से लाइन पढ़ी जाती है लेकिन दुर्भाग्यवश यह 1 लाइन पर है।

मैंने कोशिश की }\n साथ की जगह लाइनों में फ़ाइल विभाजित ताकि logstash यह (फ़ाइल एक सरल json प्रारूप, कोई नेस्टेड वस्तुएं हैं) को संसाधित कर सकते हैं मैं एक पंक्ति, बंटवारे में प्रत्येक json करना चाहते थे } पर:

sed -i 's/}/}\n/g' NonPROD.log.backup 

लेकिन sed मारे गए - मुझे स्मृति की वजह से भी लगता है। मैं इसे कैसे हल करूं? क्या मैं sed लाइनों की तुलना में डेटा के अन्य हिस्सों का उपयोग करके फ़ाइल में हेरफेर कर सकता हूं? मुझे डिफ़ॉल्ट रूप से पता है sed लाइन से लाइन पढ़ता है।

Answer 1

निम्नलिखित केवल खोल में निर्मित कार्यक्षमता का उपयोग करता:

#!/bin/bash 

# as long as there exists another } in the file, read up to it... 
while IFS= read -r -d '}' piece; do 
    # ...and print that content followed by '}' and a newline. 
    printf '%s}\n' "$piece" 
done 

# print any trailing content after the last } 
[[ $piece ]] && printf '%s\n' "$piece" 

आप logstash एक TCP पोर्ट (नीचे एक मनमाना उदाहरण के रूप में 14321 का प्रयोग करके) से पढ़ने के लिए कॉन्फ़िगर किया गया है, तो आप thescript <NonPROD.log.backup >"/dev/tcp/127.0.0.1/14321" या इसी तरह की है, और चला सकते हैं वहां आप हैं - डिस्क पर उपलब्ध आपकी मूल इनपुट फ़ाइल की जगह को दोगुना करने की आवश्यकता के बिना, अन्य उत्तरों को अब तक की आवश्यकता है।

Answer 2

आप किए जा सकेंगे:

1. स्प्लिट फ़ाइल 1M हिस्सा कहने के लिए split -b 1m file.log
2. प्रक्रिया का उपयोग कर सभी फाइलों को sed 's/}/}\n/g' x*
3. ... और उन्हें एक टुकड़े के लिए वापस गठबंधन करने के लिए sed के उत्पादन अनुप्रेषित

इसकी कमी दोगुनी संग्रहण स्थान है।

Answer 3

आप tr के माध्यम से इसे चलाने कर सकते हैं, तो प्रत्येक पंक्ति के अंत में पीठ पर अंत ब्रैकेट डाल:

$ cat NonPROD.log.backup | tr '}' '\n' | sed 's/$/}/' > tmp$$ 
$ wc -l NonPROD.log.backup tmp$$ 
    0 NonPROD.log.backup 
    43 tmp10528 
    43 total 

(मेरे परीक्षण फ़ाइल केवल 43 कोष्ठक था।)

Answer 4

RT के लिए जीएनयू awk साथ fold

$ fold -w 1000 long_line_file | sed 's/}/}\n\n/g' | tr -s '\n' 

Answer 5

के साथ एक और विकल्प:

$ printf 'abc}def}ghi\n' | awk -v RS='}' -v ORS='}\n' 'NR>1{print p} {p=$0} END{printf "%s",p}' 
abc} 
def} 
ghi 

मैं वर्तमान में तैनात समाधान के सभी परीक्षण करने का फैसला:

$ printf 'abc}def}ghi\n' | awk -v RS='}' '{ORS=(RT?"}\n":"")}1' 
abc} 
def} 
ghi 

अन्य awks साथ

एक इनपुट फाइल का उपयोग कर कार्यक्षमता और निष्पादन समय के लिए इस आदेश के द्वारा उत्पन्न ई:

awk 'BEGIN{for(i=1;i<=1000000;i++)printf "foo}"; print "foo"}' > file1m 

और यहाँ है कि मैं क्या मिला:

time awk -v RS='}' '{ORS=(RT?"}\n":"")}1' file1m 

उम्मीद गया उत्पादन, समय =

:

1) awk (दोनों awk स्क्रिप्ट ऊपर इसी तरह के परिणाम) था

real 0m0.608s 
user 0m0.561s 
sys  0m0.045s 

2) shell loop:

$ cat tst.sh 
#!/bin/bash 

# as long as there exists another } in the file, read up to it... 
while IFS= read -r -d '}' piece; do 
    # ...and print that content followed by '}' and a newline. 
    printf '%s}\n' "$piece" 
done 

# print any trailing content after the last } 
[[ $piece ]] && printf '%s\n' "$piece" 

$ time ./tst.sh < file1m 

उम्मीद गया उत्पादन, समय =

real 1m52.152s 
user 1m18.233s 
sys  0m32.604s 

3) tr+sed:

$ time tr '}' '\n' < file1m | sed 's/$/}/' 

उम्मीद निर्गम (जोड़ी एक अवांछनीय } फ़ाइल के अंत में) का उत्पादन नहीं किया था, समय =

real 0m0.577s 
user 0m0.468s 
sys  0m0.078s 

एक ट्वीक इसके साथ ही अंतिम अवांछनीय } दूर करने के लिए:

$ time tr '}' '\n' < file1m | sed 's/$/}/; $s/}//' 

real 0m0.718s 
user 0m0.670s 
sys  0m0.108s 

4) fold+sed+tr:

$ time fold -w 1000 file1m | sed 's/}/}\n\n/g' | tr -s '\n' 

उम्मीद गया उत्पादन, समय =

real 0m0.811s 
user 0m1.137s 
sys  0m0.076s 

5) split+sed+cat:

$ cat tst2.sh 
mkdir tmp$$ 
pwd="$(pwd)" 
cd "tmp$$" 
split -b 1m "${pwd}/${1}" 
sed -i 's/}/}\n/g' x* 
cat x* 
rm -f x* 
cd "$pwd" 
rmdir tmp$$ 

$ time ./tst2.sh file1m 

उम्मीद गया उत्पादन, समय =

real 0m0.983s 
user 0m0.685s 
sys  0m0.167s