ग्रोवी

Question

में एक फ़ाइल दर्ज करें मुझे आश्चर्य है कि ग्रोवी में एक फाइल को पूंछ करने का एक आसान तरीका है? मुझे पता है कि फाइल को कैसे पढ़ा जाए, लेकिन मैं एक फाइल कैसे पढ़ूं और फिर और लाइनों को जोड़ने के लिए प्रतीक्षा करें, उन्हें पढ़ें, प्रतीक्षा करें, आदि ...

मेरे पास यह है कि मुझे यकीन है कि वास्तव में बेवकूफ समाधान है:

def lNum = 0 
def num= 0 
def numLines = 0 
def myFile = new File("foo.txt") 
def origNumLines = myFile.eachLine { num++ } 
def precIndex = origNumLines 

while (true) { 
num = 0 
lNum = 0 
numLines = myFile.eachLine { num++ } 

if (numLines > origNumLines) { 
    myFile.eachLine({ line -> 

    if (lNum > precIndex) { 
      println line 
     } 
    lNum++ 
    }) 
} 
precIndex = numLines 

Thread.sleep(5000) 
} 

ध्यान दें कि मैं वास्तव में यूनिक्स "पूंछ" कमांड लागू में दिलचस्पी नहीं है। जब तक यह एकमात्र समाधान न हो।

class TailReader { 

    boolean stop = false 

    public void stop() { 
    stop = true 
    } 

    public void tail (File file, Closure c) { 
    def runnable = { 
    def reader 

     try { 
     reader = file.newReader() 
     reader.skip(file.length()) 

     def line 

     while (!stop) { 
      line = reader.readLine() 
      if (line) { 
      c.call(line) 
      } 
      else { 
      Thread.currentThread().sleep(1000) 
      } 
     } 

     } 
     finally { 
     reader?.close() 
     } 
    } as Runnable 

    def t = new Thread(runnable) 
    t.start() 
    } 
} 

tail विधि taks एक फ़ाइल और पैरामीटर के रूप में बंद:

Answer 1

मैं एक ग्रूवी वर्ग जो बुनियादी पूंछ कार्यक्षमता जैसा दिखता है लिखा था। यह एक अलग धागे में चलेगा और प्रत्येक नई लाइन को पास करेगा जो फ़ाइल को दिए गए बंद करने के लिए जोड़ा जाएगा। tail विधि stop विधि TailReader उदाहरण पर कॉल होने तक विधि तब तक चली जाएगी।

def reader = new TailReader() 
reader.tail(new File("/tmp/foo.log")) { println it } 

// Do something else, e.g. 
// Thread.currentThread().sleep(30 * 1000) 

reader.stop() 

Answer 2

जवाब में क्रिस्टोफ रहे हैं: यहां तरीका देखें: TailReader वर्ग का उपयोग करने की एक छोटी सी उदाहरण है
मेरी उपयोग के मामले के लिए, मैं

साथ ब्लॉक

line = reader.readLine() 
if (line) { 
    c.call(line) 
} 
else { 
    Thread.currentThread().sleep(1000) 
} 

बदल दिया है

while ((line = reader.readLine()) != null) 
    c.call(line) 
Thread.currentThread().sleep(1000)` 

... != null => यह सुनिश्चित करने के लिए कि खाली लाइनों को भीआउटपुट किया गया है while (... = हर पंक्ति सुनिश्चित करने के लिए> संभव के रूप में तेजी से पढ़ा जाता है